Previous

199869 Revisions

Next

r34479 Sunday 18th January, 2015 at 18:26:45 UTC by Cesare Falco
*nix: Bump version and date in man pages.

[src/emu]	clifront.c clifront.h distate.c distate.h emu.mak emuopts.h image.c image.h ioport.c luaengine.c luaengine.h machine.c machine.h mame.c mame.h render.h rendfont.c rendfont.h rendutil.h save.c save.h video.c webengine.c
[src/emu/cpu/tms0980]	tms0980.c tms0980.h
[src/emu/machine]	netlist.c
[src/emu/netlist]	netlist.mak nl_base.c nl_base.h nl_config.h nl_dice_compat.h nl_factory.c nl_factory.h nl_lists.h nl_parser.c nl_parser.h nl_setup.c nl_setup.h plists.h pstate.c pstate.h pstring.c pstring.h
[src/emu/netlist/analog]	nld_bjt.c nld_bjt.h nld_fourterm.c nld_fourterm.h nld_ms_direct.h nld_ms_direct1.h nld_ms_direct2.h nld_ms_gauss_seidel.h nld_solver.c nld_solver.h nld_twoterm.c nld_twoterm.h
[src/emu/netlist/devices]	net_lib.c net_lib.h nld_4020.c nld_4066.c nld_74107.c nld_74123.c nld_74153.c nld_7448.c nld_7474.c nld_7483.c nld_7490.c nld_7493.c nld_74ls629.c nld_9316.c nld_cmos.h nld_ne555.c nld_ne555.h nld_r2r_dac.c nld_signal.h nld_system.c nld_system.h nld_truthtable.h
[src/emu/sound]	rf5c400.c rf5c400.h
[src/emu/ui]	filemngr.c filemngr.h imgcntrl.c imgcntrl.h imginfo.c* imginfo.h* info.c info.h mainmenu.c miscmenu.c miscmenu.h selgame.c slotopt.c ui.c
[src/lib]	lib.mak
[src/lib/util]	corefile.h options.h
[src/mame]	mame.lst
[src/mame/audio]	mario.c
[src/mame/drivers]	20pacgal.c aleck64.c chihiro.c itech32.c naomi.c nl_pongd.c peplus.c snowbros.c twinkle.c
[src/mame/includes]	mario.h snowbros.h
[src/mame/machine]	315-5881_crypt.c naomicrypt.c
[src/mess]	mess.lst mess.mak
[src/mess/drivers]	comp4.c splitsec.c
[src/mess/includes]	msx.h
[src/mess/layout]	splitsec.lay
[src/osd]	osdcore.c osdepend.h
[src/osd/modules/lib]	osdobj_common.c osdobj_common.h
[src/osd/osdmini]	minimain.c osdmini.h osdmini.mak
[src/osd/sdl]	draw13.c osdsdl.h sdlmain.c
[src/osd/sdl/man]	castool.1 chdman.1 floptool.1 imgtool.1 jedutil.1 ldresample.1 ldverify.1 mame.6 mess.6 romcmp.1 testkeys.1
[src/osd/windows]	winmain.c winmain.h
[src/tools]	nltool.c

trunk/src/emu/clifront.c

r242990	r242991
24	24
25	25	#include "drivenum.h"
26	26
27		#include "osdepend.h"
28
29	27	#include <new>
30	28	#include <ctype.h>
31	29

trunk/src/emu/clifront.h

r242990	r242991
15	15
16	16	#include "emu.h"
17	17	#include "cliopts.h"
	18	#include "osdepend.h"
18	19
19		// don't include osd_interface in header files
20		class osd_interface;
21	20
22	21	//**************************************************************************
23	22	//  TYPE DEFINITIONS

trunk/src/emu/cpu/tms0980/tms0980.c

r242990	r242991
429	429	m_sr = 0;
430	430	m_pa = 0;
431	431	m_pb = 0;
432		m_ps = 0;
433	432	m_a = 0;
434	433	m_x = 0;
435	434	m_y = 0;
r242990	r242991
467	466	save_item(NAME(m_sr));
468	467	save_item(NAME(m_pa));
469	468	save_item(NAME(m_pb));
470		save_item(NAME(m_ps));
471	469	save_item(NAME(m_a));
472	470	save_item(NAME(m_x));
473	471	save_item(NAME(m_y));
r242990	r242991
638	636	tms1100_cpu_device::device_reset();
639	637
640	638	// small differences in 00-3f area
641		m_fixed_decode[0x09] = F_COMX;
	639	m_fixed_decode[0x09] = F_COMX; // !
642	640	m_fixed_decode[0x0b] = F_TPC;
643	641	}
644	642
r242990	r242991
960	958	//-------------------------------------------------
961	959
962	960	// handle branches:
963
964		// TMS1000/common
965	961	// note: add(latch) and bl(branch latch) are specific to 0980 series,
966	962	// c(chapter) bits are specific to 1100(and 1400) series
967	963
	964	// TMS1000/common:
	965
968	966	void tms1xxx_cpu_device::op_br()
969	967	{
970	968	// BR/BL: conditional branch
971		if (m_status)
972		{
973		if (m_clatch == 0)
974		m_pa = m_pb;
975		m_ca = m_cb;
976		m_pc = m_opcode & m_pc_mask;
977		}
	969	if (!m_status)
	970	return;
	971
	972	if (!m_clatch)
	973	m_pa = m_pb;
	974	m_ca = m_cb;
	975	m_pc = m_opcode & m_pc_mask;
978	976	}
979	977
980	978	void tms1xxx_cpu_device::op_call()
981	979	{
982	980	// CALL/CALLL: conditional call
983		if (m_status)
984		{
985		UINT8 prev_pa = m_pa;
	981	if (!m_status)
	982	return;
986	983
987		if (m_clatch == 0)
988		{
989		m_clatch = 1;
990		m_sr = m_pc;
991		m_pa = m_pb;
992		m_cs = m_ca;
993		}
994		m_ca = m_cb;
995		m_pb = prev_pa;
996		m_pc = m_opcode & m_pc_mask;
	984	UINT8 prev_pa = m_pa;
	985	if (!m_clatch)
	986	{
	987	m_sr = m_pc;
	988	m_clatch = 1;
	989	m_pa = m_pb;
	990	m_cs = m_ca;
997	991	}
	992	m_ca = m_cb;
	993	m_pb = prev_pa;
	994	m_pc = m_opcode & m_pc_mask;
998	995	}
999	996
1000	997	void tms1xxx_cpu_device::op_retn()
1001	998	{
1002	999	// RETN: return from subroutine
1003		if (m_clatch == 1)
	1000	if (m_clatch)
1004	1001	{
1005		m_clatch = 0;
1006	1002	m_pc = m_sr;
	1003	m_clatch = 0;
1007	1004	m_ca = m_cs;
1008	1005	}
1009	1006	m_add = 0;
r242990	r242991
1017	1014	void tms1400_cpu_device::op_br()
1018	1015	{
1019	1016	// BR/BL: conditional branch
1020		if (m_status)
1021		{
1022		m_pa = m_pb; // don't care about clatch
1023		m_ca = m_cb;
1024		m_pc = m_opcode & m_pc_mask;
1025		}
	1017	if (!m_status)
	1018	return;
	1019
	1020	//..
1026	1021	}
1027	1022
1028	1023	void tms1400_cpu_device::op_call()
1029	1024	{
1030	1025	// CALL/CALLL: conditional call
1031		if (m_status)
1032		{
1033		// 3-level stack, mask clatch 3 bits (no need to mask others)
1034		m_clatch = (m_clatch << 1 | 1) & 7;
	1026	if (!m_status)
	1027	return;
1035	1028
1036		m_sr = m_sr << m_pc_bits | m_pc;
1037		m_pc = m_opcode & m_pc_mask;
1038
1039		m_ps = m_ps << 4 | m_pa;
1040		m_pa = m_pb;
1041
1042		m_cs = m_cs << 2 | m_ca;
1043		m_ca = m_cb;
1044		}
1045		else
1046		{
1047		m_pb = m_pa;
1048		m_cb = m_ca;
1049		}
	1029	//..
1050	1030	}
1051	1031
1052	1032	void tms1400_cpu_device::op_retn()
1053	1033	{
1054	1034	// RETN: return from subroutine
1055		if (m_clatch & 1)
1056		{
1057		m_clatch >>= 1;
1058
1059		m_pc = m_sr & m_pc_mask;
1060		m_sr >>= m_pc_bits;
1061
1062		m_pa = m_pb = m_ps & 0xf;
1063		m_ps >>= 4;
1064
1065		m_ca = m_cb = m_cs & 3;
1066		m_cs >>= 2;
1067		}
	1035	//..
1068	1036	}
1069	1037
1070	1038
1071	1039	// handle other:
1072	1040
1073		// TMS1000/common
	1041	// TMS1000/common:
1074	1042
1075	1043	void tms1xxx_cpu_device::op_sbit()
1076	1044	{
r242990	r242991
1190	1158
1191	1159
1192	1160	// TMS0980-specific (and possibly child classes)
1193
1194	1161	void tms0980_cpu_device::op_comx()
1195	1162	{
1196	1163	// COMX: complement X register, but not the MSB
r242990	r242991
1236	1203
1237	1204
1238	1205	// TMS0270-specific
1239
1240	1206	void tms0270_cpu_device::op_setr()
1241	1207	{
1242	1208	// same as default, but handle write to output in dynamic_output

trunk/src/emu/cpu/tms0980/tms0980.h

r242990	r242991
139	139	optional_device<pla_device> m_spla;
140	140
141	141	UINT8   m_pc;        // 6 or 7-bit program counter
142		UINT32  m_sr;        // 6 or 7-bit subroutine return register(s)
	142	UINT8  m_sr;        // 6 or 7-bit subroutine return register
143	143	UINT8   m_pa;        // 4-bit page address register
144	144	UINT8   m_pb;        // 4-bit page buffer register
145		UINT16  m_ps;        // 4-bit page subroutine register(s)
146	145	UINT8   m_a;         // 4-bit accumulator
147	146	UINT8   m_x;         // 2,3,or 4-bit RAM X register
148	147	UINT8   m_y;         // 4-bit RAM Y register
149		UINT8   m_ca;        // chapter address register
150		UINT8   m_cb;        // chapter buffer register
151		UINT16  m_cs;        // chapter subroutine register(s)
	148	UINT8   m_ca;        // chapter address bit
	149	UINT8   m_cb;        // chapter buffer bit
	150	UINT8   m_cs;        // chapter subroutine bit
152	151	UINT16  m_r;
153	152	UINT16  m_o;
154	153	UINT8   m_cki_bus;
r242990	r242991
161	160	UINT8   m_status;
162	161	UINT8   m_status_latch;
163	162	UINT8   m_eac;       // end around carry bit
164		UINT8   m_clatch;    // call latch bit(s)
	163	UINT8   m_clatch;    // call latch bit
165	164	UINT8   m_add;       // add latch bit
166	165	UINT8   m_bl;        // branch latch bit
167	166

trunk/src/emu/distate.c

r242990	r242991
49	49	//  device_state_entry - constructor
50	50	//-------------------------------------------------
51	51
52		device_state_entry::device_state_entry(int index, const char *symbol, void *dataptr, UINT8 size, device_state_interface *dev)
53		: m_device_state(dev),
54		m_next(NULL),
	52	device_state_entry::device_state_entry(int index, const char *symbol, void *dataptr, UINT8 size)
	53	: m_next(NULL),
55	54	m_index(index),
56	55	m_dataptr(dataptr),
57	56	m_datamask(0),
r242990	r242991
87	86	m_symbol.cpy("CURFLAGS");
88	87	}
89	88
90		device_state_entry::device_state_entry(int index, device_state_interface *dev)
91		: m_device_state(dev),
92		m_next(NULL),
	89	device_state_entry::device_state_entry(int index)
	90	: m_next(NULL),
93	91	m_index(index),
94	92	m_dataptr(NULL),
95	93	m_datamask(0),
r242990	r242991
525	523	assert(symbol != NULL);
526	524
527	525	// allocate new entry
528		device_state_entry *entry = global_alloc(device_state_entry(index, symbol, data, size, this));
	526	device_state_entry *entry = global_alloc(device_state_entry(index, symbol, data, size));
529	527
530	528	// append to the end of the list
531	529	m_state_list.append(*entry);
r242990	r242991
545	543	device_state_entry &device_state_interface::state_add_divider(int index)
546	544	{
547	545	// allocate new entry
548		device_state_entry *entry = global_alloc(device_state_entry(index, this));
	546	device_state_entry *entry = global_alloc(device_state_entry(index));
549	547
550	548	// append to the end of the list
551	549	m_state_list.append(*entry);

trunk/src/emu/distate.h

r242990	r242991
45	45	{
46	46	friend class device_state_interface;
47	47	friend class simple_list<device_state_entry>;
	48	friend class lua_engine;
48	49
49	50	private:
50	51	// construction/destruction
51		device_state_entry(int index, const char *symbol, void *dataptr, UINT8 size, device_state_interface *dev);
52		device_state_entry(int index, device_state_interface *dev);
	52	device_state_entry(int index, const char *symbol, void *dataptr, UINT8 size);
	53	device_state_entry(int index);
53	54
54	55	public:
55	56	// post-construction modifiers
r242990	r242991
69	70	const char *symbol() const { return m_symbol; }
70	71	bool visible() const { return ((m_flags & DSF_NOSHOW) == 0); }
71	72	bool divider() const { return m_flags & DSF_DIVIDER; }
72		device_state_interface *parent_state() const {return m_device_state;}
73	73
74	74	protected:
75	75	// device state flags
r242990	r242991
98	98	static const UINT64 k_decimal_divisor[20];      // divisors for outputting decimal values
99	99
100	100	// public state description
101		device_state_interface *m_device_state;         // link to parent device state
102	101	device_state_entry *    m_next;                 // link to next item
103	102	UINT32                  m_index;                // index by which this item is referred
104	103	generic_ptr             m_dataptr;              // pointer to where the data lives

trunk/src/emu/emu.mak

r242990	r242991
124	124	$(EMUOBJ)/ui/filemngr.o \
125	125	$(EMUOBJ)/ui/filesel.o \
126	126	$(EMUOBJ)/ui/imgcntrl.o \
127		$(EMUOBJ)/ui/info.o \
	127	$(EMUOBJ)/ui/imginfo.o \
128	128	$(EMUOBJ)/ui/inputmap.o \
129	129	$(EMUOBJ)/ui/selgame.o \
130	130	$(EMUOBJ)/ui/slotopt.o \
r242990	r242991
148	148	$(EMUOBJ)/debug/textbuf.o \
149	149	$(EMUOBJ)/profiler.o \
150	150	$(EMUOBJ)/webengine.o \
	151	$(OSDOBJ)/osdcore.o \
151	152	$(OSDOBJ)/osdnet.o \
152	153	$(OSDOBJ)/modules/sound/none.o \
153	154	$(OSDOBJ)/modules/debugger/none.o \

trunk/src/emu/emuopts.h

r242990	r242991
354	354
355	355	const char *main_value(astring &buffer, const char *option) const;
356	356	const char *sub_value(astring &buffer, const char *name, const char *subname) const;
357		bool add_slot_options(bool isfirst);
358
359	357	private:
360	358	// device-specific option handling
361	359	void add_device_options(bool isfirst);
	360	bool add_slot_options(bool isfirst);
362	361	void update_slot_options();
363	362
364	363	// INI parsing helper

trunk/src/emu/image.c

r242990	r242991
237	237	}
238	238	}
239	239	}
240		}
241	240
242		/*-------------------------------------------------
243		image_mandatory_scan - search for devices which
244		need an image to be loaded
245		-------------------------------------------------*/
246
247		astring &image_mandatory_scan(running_machine &machine, astring &mandatory)
248		{
249		mandatory.reset();
250		// make sure that any required image has a mounted file
251		image_interface_iterator iter(machine.root_device());
252	241	for (device_image_interface *image = iter.first(); image != NULL; image = iter.next())
253	242	{
254		if (image->filename() == NULL && image->must_be_loaded())
255		mandatory.cat("\"").cat(image->instance_name()).cat("\", ");
	243	/* is an image specified for this image */
	244	image_name = image->filename();
	245
	246	if (!((image_name != NULL) && (image_name[0] != '\0')))
	247	{
	248	/* no image... must this device be loaded? */
	249	if (image->must_be_loaded())
	250	{
	251	fatalerror_exitcode(machine, MAMERR_DEVICE, "Driver requires that device \"%s\" must have an image to load", image->instance_name());
	252	}
	253	}
256	254	}
257		return mandatory;
258	255	}
259	256
260	257	/*-------------------------------------------------

trunk/src/emu/image.h

r242990	r242991
20	20
21	21	void image_init(running_machine &machine);
22	22	void image_postdevice_init(running_machine &machine);
23		astring &image_mandatory_scan(running_machine &machine, astring &mandatory);
24	23
25	24	extern struct io_procs image_ioprocs;
26	25

trunk/src/emu/ioport.c

r242990	r242991
99	99	#include "uiinput.h"
100	100	#include "debug/debugcon.h"
101	101
102		#include "osdepend.h"
103
104	102	#include <ctype.h>
105	103	#include <time.h>
106	104

trunk/src/emu/luaengine.c

r242990	r242991
1	1	// license:BSD-3-Clause
2		// copyright-holders:Miodrag Milanovic,Luca Bruno
	2	// copyright-holders:Miodrag Milanovic
3	3	/***************************************************************************
4	4
5	5	luaengine.c
r242990	r242991
456	456	}
457	457
458	458	//-------------------------------------------------
459		//  state_get_value - return value of a device state entry
	459	//  state_get_value - return value of a devices state
460	460	//  -> manager:machine().devices[":maincpu"].state["PC"].value
461	461	//-------------------------------------------------
462	462
463	463	UINT64 lua_engine::l_state_get_value(const device_state_entry *d)
464	464	{
465		device_state_interface *state = d->parent_state();
466		if(state) {
467		luaThis->machine().save().dispatch_presave();
468		return state->state_int(d->index());
469		} else {
470		return 0;
471		}
	465	return d->value();
472	466	}
473	467
474	468	//-------------------------------------------------
475		//  state_set_value - set value of a device state entry
	469	//  state_set_value - set value of a devices state
476	470	//  -> manager:machine().devices[":maincpu"].state["D0"].value = 0x0c00
477	471	//-------------------------------------------------
478	472
479	473	void lua_engine::l_state_set_value(device_state_entry *d, UINT64 val)
480	474	{
481		device_state_interface *state = d->parent_state();
482		if(state) {
483		state->set_state_int(d->index(), val);
484		luaThis->machine().save().dispatch_presave();
485		}
	475	d->set_value(val);
486	476	}
487	477
488	478	//-------------------------------------------------
r242990	r242991
537	527	}
538	528
539	529	//-------------------------------------------------
540		//  mem_write - templated memory writer for <sign>,<size>
541		//  -> manager:machine().devices[":maincpu"].spaces["program"]:write_u16(0xC000, 0xF00D)
542		//-------------------------------------------------
543
544		template <typename T>
545		int lua_engine::lua_addr_space::l_mem_write(lua_State *L)
546		{
547		address_space &sp = luabridge::Stack<address_space &>::get(L, 1);
548		luaL_argcheck(L, lua_isnumber(L, 2), 2, "address (integer) expected");
549		luaL_argcheck(L, lua_isnumber(L, 3), 3, "value (integer) expected");
550		offs_t address = lua_tounsigned(L, 2);
551		T val = lua_tounsigned(L, 3);
552
553		switch(sizeof(val) * 8) {
554		case 8:
555		sp.write_byte(address, val);
556		break;
557		case 16:
558		if ((address & 1) == 0) {
559		sp.write_word(address, val);
560		} else {
561		sp.read_word_unaligned(address, val);
562		}
563		break;
564		case 32:
565		if ((address & 3) == 0) {
566		sp.write_dword(address, val);
567		} else {
568		sp.write_dword_unaligned(address, val);
569		}
570		break;
571		case 64:
572		if ((address & 7) == 0) {
573		sp.write_qword(address, val);
574		} else {
575		sp.write_qword_unaligned(address, val);
576		}
577		break;
578		default:
579		break;
580		}
581
582		return 0;
583		}
584
585		//-------------------------------------------------
586		//  screen_height - return screen visible height
587		//  -> manager:machine().screens[":screen"]:height()
588		//-------------------------------------------------
589
590		int lua_engine::lua_screen::l_height(lua_State *L)
591		{
592		screen_device *sc = luabridge::Stack<screen_device *>::get(L, 1);
593		if(!sc) {
594		return 0;
595		}
596
597		lua_pushunsigned(L, sc->visible_area().height());
598		return 1;
599		}
600
601		//-------------------------------------------------
602		//  screen_width - return screen visible width
603		//  -> manager:machine().screens[":screen"]:width()
604		//-------------------------------------------------
605
606		int lua_engine::lua_screen::l_width(lua_State *L)
607		{
608		screen_device *sc = luabridge::Stack<screen_device *>::get(L, 1);
609		if(!sc) {
610		return 0;
611		}
612
613		lua_pushunsigned(L, sc->visible_area().width());
614		return 1;
615		}
616
617		//-------------------------------------------------
618	530	//  draw_box - draw a box on a screen container
619	531	//  -> manager:machine().screens[":screen"]:draw_box(x1, y1, x2, y2, bgcolor, linecolor)
620	532	//-------------------------------------------------
r242990	r242991
636	548
637	549	// retrieve all parameters
638	550	float x1, y1, x2, y2;
639		x1 = MIN(lua_tounsigned(L, 2) / static_cast<float>(sc->visible_area().width()) , 1.0f);
640		y1 = MIN(lua_tounsigned(L, 3) / static_cast<float>(sc->visible_area().height()), 1.0f);
641		x2 = MIN(lua_tounsigned(L, 4) / static_cast<float>(sc->visible_area().width()) , 1.0f);
642		y2 = MIN(lua_tounsigned(L, 5) / static_cast<float>(sc->visible_area().height()), 1.0f);
	551	x1 = MIN(lua_tounsigned(L, 2) / static_cast<float>(sc->width()) , 1.0f);
	552	y1 = MIN(lua_tounsigned(L, 3) / static_cast<float>(sc->height()), 1.0f);
	553	x2 = MIN(lua_tounsigned(L, 4) / static_cast<float>(sc->width()) , 1.0f);
	554	y2 = MIN(lua_tounsigned(L, 5) / static_cast<float>(sc->height()), 1.0f);
643	555	UINT32 bgcolor = lua_tounsigned(L, 6);
644	556	UINT32 fgcolor = lua_tounsigned(L, 7);
645	557
r242990	r242991
672	584
673	585	// retrieve all parameters
674	586	float x1, y1, x2, y2;
675		x1 = MIN(lua_tounsigned(L, 2) / static_cast<float>(sc->visible_area().width()) , 1.0f);
676		y1 = MIN(lua_tounsigned(L, 3) / static_cast<float>(sc->visible_area().height()), 1.0f);
677		x2 = MIN(lua_tounsigned(L, 4) / static_cast<float>(sc->visible_area().width()) , 1.0f);
678		y2 = MIN(lua_tounsigned(L, 5) / static_cast<float>(sc->visible_area().height()), 1.0f);
	587	x1 = MIN(lua_tounsigned(L, 2) / static_cast<float>(sc->width()) , 1.0f);
	588	y1 = MIN(lua_tounsigned(L, 3) / static_cast<float>(sc->height()), 1.0f);
	589	x2 = MIN(lua_tounsigned(L, 4) / static_cast<float>(sc->width()) , 1.0f);
	590	y2 = MIN(lua_tounsigned(L, 5) / static_cast<float>(sc->height()), 1.0f);
679	591	UINT32 color = lua_tounsigned(L, 6);
680	592
681	593	// draw the line
r242990	r242991
701	613	luaL_argcheck(L, lua_isstring(L, 4), 4, "message (string) expected");
702	614
703	615	// retrieve all parameters
704		float x = MIN(lua_tounsigned(L, 2) / static_cast<float>(sc->visible_area().width()) , 1.0f);
705		float y = MIN(lua_tounsigned(L, 3) / static_cast<float>(sc->visible_area().height()), 1.0f);
	616	float x = MIN(lua_tounsigned(L, 2) / static_cast<float>(sc->width()) , 1.0f);
	617	float y = MIN(lua_tounsigned(L, 3) / static_cast<float>(sc->height()), 1.0f);
706	618	const char *msg = luaL_checkstring(L,4);
707	619	// TODO: add optional parameters (colors, etc.)
708	620
r242990	r242991
970	882	.addCFunction ("read_u32", &lua_addr_space::l_mem_read<UINT32>)
971	883	.addCFunction ("read_i64", &lua_addr_space::l_mem_read<INT64>)
972	884	.addCFunction ("read_u64", &lua_addr_space::l_mem_read<UINT64>)
973		.addCFunction ("write_i8", &lua_addr_space::l_mem_write<INT8>)
974		.addCFunction ("write_u8", &lua_addr_space::l_mem_write<UINT8>)
975		.addCFunction ("write_i16", &lua_addr_space::l_mem_write<INT16>)
976		.addCFunction ("write_u16", &lua_addr_space::l_mem_write<UINT16>)
977		.addCFunction ("write_i32", &lua_addr_space::l_mem_write<INT32>)
978		.addCFunction ("write_u32", &lua_addr_space::l_mem_write<UINT32>)
979		.addCFunction ("write_i64", &lua_addr_space::l_mem_write<INT64>)
980		.addCFunction ("write_u64", &lua_addr_space::l_mem_write<UINT64>)
981	885	.endClass()
982	886	.deriveClass <address_space, lua_addr_space> ("addr_space")
983	887	.addFunction("name", &address_space::name)
r242990	r242991
986	890	.addCFunction ("draw_box",  &lua_screen::l_draw_box)
987	891	.addCFunction ("draw_line", &lua_screen::l_draw_line)
988	892	.addCFunction ("draw_text", &lua_screen::l_draw_text)
989		.addCFunction ("height", &lua_screen::l_height)
990		.addCFunction ("width", &lua_screen::l_width)
991	893	.endClass()
992	894	.deriveClass <screen_device, lua_screen> ("screen_dev")
993		.addFunction ("frame_number", &screen_device::frame_number)
994	895	.addFunction ("name", &screen_device::name)
995	896	.addFunction ("shortname", &screen_device::shortname)
996	897	.addFunction ("tag", &screen_device::tag)
	898	.addFunction ("height", &screen_device::height)
	899	.addFunction ("width", &screen_device::width)
997	900	.endClass()
998	901	.beginClass <device_state_entry> ("dev_space")
999	902	.addFunction ("name", &device_state_entry::symbol)

trunk/src/emu/luaengine.h

r242990	r242991
112	112	static luabridge::LuaRef l_dev_get_memspaces(const device_t *d);
113	113	struct lua_addr_space {
114	114	template<typename T> int l_mem_read(lua_State *L);
115		template<typename T> int l_mem_write(lua_State *L);
116	115	};
117	116	static luabridge::LuaRef l_machine_get_screens(const running_machine *r);
118	117	struct lua_screen {
119		int l_height(lua_State *L);
120		int l_width(lua_State *L);
121	118	int l_draw_box(lua_State *L);
122	119	int l_draw_line(lua_State *L);
123	120	int l_draw_text(lua_State *L);

trunk/src/emu/machine.c

r242990	r242991
106	106	//  RUNNING MACHINE
107	107	//**************************************************************************
108	108
109		osd_interface &running_machine::osd() const
110		{
111		return m_manager.osd();
112		}
113
114	109	//-------------------------------------------------
115	110	//  running_machine - constructor
116	111	//-------------------------------------------------

trunk/src/emu/machine.h

r242990	r242991
19	19
20	20	#include <time.h>
21	21
22		// forward declaration instead of osdepend.h
23		class osd_interface;
24	22
	23
25	24	//**************************************************************************
26	25	//  CONSTANTS
27	26	//**************************************************************************
r242990	r242991
158	157	const machine_config &config() const { return m_config; }
159	158	device_t &root_device() const { return m_config.root_device(); }
160	159	const game_driver &system() const { return m_system; }
161		osd_interface &osd() const;
	160	osd_interface &osd() const { return m_manager.osd(); }
162	161	machine_manager &manager() const { return m_manager; }
163	162	resource_pool &respool() { return m_respool; }
164	163	device_scheduler &scheduler() { return m_scheduler; }

trunk/src/emu/machine/netlist.c

r242990	r242991
48	48	#include "netlist.h"
49	49	#include "netlist/nl_base.h"
50	50	#include "netlist/nl_setup.h"
51		#include "netlist/nl_factory.h"
52	51	#include "netlist/devices/net_lib.h"
53	52	#include "debugger.h"
54	53
r242990	r242991
135	134	pstring dname = "OUT_" + m_in;
136	135	m_delegate.bind_relative_to(owner()->machine().root_device());
137	136	NETLIB_NAME(analog_callback) *dev = downcast<NETLIB_NAME(analog_callback) *>(
138		setup.register_dev("nld_analog_callback", dname));
	137	setup.factory().new_device_by_classname("nld_analog_callback", setup));
139	138
	139	setup.register_dev(dev, dname);
140	140	dev->register_callback(m_delegate);
141	141	setup.register_link(dname + ".IN", m_in);
142	142	}
r242990	r242991
208	208	{
209	209	NETLIB_NAME(sound_in) *snd_in = setup.netlist().get_first_device<NETLIB_NAME(sound_in)>();
210	210	if (snd_in == NULL)
211		snd_in = dynamic_cast<NETLIB_NAME(sound_in) *>(setup.register_dev("nld_sound_in", "STREAM_INPUT"));
	211	{
	212	snd_in = dynamic_cast<NETLIB_NAME(sound_in) *>(setup.factory().new_device_by_classname("nld_sound_in", setup));
	213	setup.register_dev(snd_in, "STREAM_INPUT");
	214	}
212	215
213	216	pstring sparam = pstring::sprintf("STREAM_INPUT.CHAN%d", m_channel);
214	217	setup.register_param(sparam, m_param_name);
r242990	r242991
244	247
245	248	void netlist_mame_stream_output_t::custom_netlist_additions(netlist_setup_t &setup)
246	249	{
247		//NETLIB_NAME(sound_out) *snd_out;
	250	NETLIB_NAME(sound_out) *snd_out;
248	251	pstring sname = pstring::sprintf("STREAM_OUT_%d", m_channel);
249	252
250		//snd_out = dynamic_cast<NETLIB_NAME(sound_out) *>(setup.register_dev("nld_sound_out", sname));
251		setup.register_dev("nld_sound_out", sname);
	253	snd_out = dynamic_cast<NETLIB_NAME(sound_out) *>(setup.factory().new_device_by_classname("nld_sound_out", setup));
	254	setup.register_dev(snd_out, sname);
252	255
253	256	setup.register_param(sname + ".CHAN" , m_channel);
254	257	setup.register_param(sname + ".MULT",  m_mult);
r242990	r242991
440	443	if (td != NULL) save_pointer(td, s->m_name, s->m_count);
441	444	}
442	445	break;
443		case DT_FLOAT:
444		{
445		float *td = s->resolved<float>();
446		if (td != NULL) save_pointer(td, s->m_name, s->m_count);
447		}
448		break;
449	446	case DT_INT64:
450	447	save_pointer((INT64 *) s->m_ptr, s->m_name, s->m_count);
451	448	break;

trunk/src/emu/mame.c

r242990	r242991
92	92
93	93	machine_manager* machine_manager::m_manager = NULL;
94	94
95		osd_interface &machine_manager::osd() const
96		{
97		return m_osd;
98		}
99
100
101	95	machine_manager* machine_manager::instance(emu_options &options,osd_interface &osd)
102	96	{
103	97	if(!m_manager)

trunk/src/emu/mame.h

r242990	r242991
22	22
23	23	#include "webengine.h"
24	24
25		class osd_interface;
26	25
27	26	//**************************************************************************
28	27	//    CONSTANTS
r242990	r242991
89	88	static machine_manager *instance();
90	89	~machine_manager();
91	90
92		osd_interface &osd() const;
	91	osd_interface &osd() const { return m_osd; }
93	92	emu_options &options() const { return m_options; }
94	93	web_engine *web() { return &m_web; }
95	94	lua_engine *lua() { return &m_lua; }

trunk/src/emu/netlist/analog/nld_bjt.c

r242990	r242991
11	11	{
12	12	public:
13	13	diode() : m_Is(1e-15), m_VT(0.0258), m_VT_inv(1.0 / m_VT) {}
14		diode(const nl_double Is, const nl_double n)
	14	diode(const double Is, const double n)
15	15	{
16	16	m_Is = Is;
17	17	m_VT = 0.0258 * n;
18	18	m_VT_inv = 1.0 / m_VT;
19	19	}
20		void set(const nl_double Is, const nl_double n)
	20	void set(const double Is, const double n)
21	21	{
22	22	m_Is = Is;
23	23	m_VT = 0.0258 * n;
24	24	m_VT_inv = 1.0 / m_VT;
25	25	}
26		nl_double I(const nl_double V) const { return m_Is * exp(V * m_VT_inv) - m_Is; }
27		nl_double g(const nl_double V) const { return m_Is * m_VT_inv * exp(V * m_VT_inv); }
28		nl_double V(const nl_double I) const { return log(1.0 + I / m_Is) * m_VT; }
29		nl_double gI(const nl_double I) const { return m_VT_inv * (I + m_Is); }
	26	double I(const double V) const { return m_Is * exp(V * m_VT_inv) - m_Is; }
	27	double g(const double V) const { return m_Is * m_VT_inv * exp(V * m_VT_inv); }
	28	double V(const double I) const { return log(1.0 + I / m_Is) * m_VT; }
	29	double gI(const double I) const { return m_VT_inv * (I + m_Is); }
30	30
31	31	private:
32		nl_double m_Is;
33		nl_double m_VT;
34		nl_double m_VT_inv;
	32	double m_Is;
	33	double m_VT;
	34	double m_VT_inv;
35	35	};
36	36
37	37
r242990	r242991
75	75	connect(m_RB.m_P, m_BC_dummy.m_P);
76	76	connect(m_RC.m_P, m_BC_dummy.m_N);
77	77
78		save(NLNAME(m_state_on));
	78	save(NAME(m_state_on));
79	79
80	80	m_RB.set(netlist().gmin(), 0.0, 0.0);
81	81	m_RC.set(netlist().gmin(), 0.0, 0.0);
r242990	r242991
85	85	m_state_on = 0;
86	86
87	87	{
88		nl_double IS = m_model.model_value("IS", 1e-15);
89		nl_double BF = m_model.model_value("BF", 100);
90		nl_double NF = m_model.model_value("NF", 1);
91		//nl_double VJE = m_model.dValue("VJE", 0.75);
	88	double IS = m_model.model_value("IS", 1e-15);
	89	double BF = m_model.model_value("BF", 100);
	90	double NF = m_model.model_value("NF", 1);
	91	//double VJE = m_model.dValue("VJE", 0.75);
92	92
93	93	set_qtype((m_model.model_type() == "NPN") ? BJT_NPN : BJT_PNP);
94	94
95		nl_double alpha = BF / (1.0 + BF);
	95	double alpha = BF / (1.0 + BF);
96	96
97	97	diode d(IS, NF);
98	98
r242990	r242991
155	155	m_gD_BC.save("m_D_BC", *this);
156	156
157	157	{
158		nl_double IS = m_model.model_value("IS", 1e-15);
159		nl_double BF = m_model.model_value("BF", 100);
160		nl_double NF = m_model.model_value("NF", 1);
161		nl_double BR = m_model.model_value("BR", 1);
162		nl_double NR = m_model.model_value("NR", 1);
163		//nl_double VJE = m_model.dValue("VJE", 0.75);
	158	double IS = m_model.model_value("IS", 1e-15);
	159	double BF = m_model.model_value("BF", 100);
	160	double NF = m_model.model_value("NF", 1);
	161	double BR = m_model.model_value("BR", 1);
	162	double NR = m_model.model_value("NR", 1);
	163	//double VJE = m_model.dValue("VJE", 0.75);
164	164
165	165	set_qtype((m_model.model_type() == "NPN") ? BJT_NPN : BJT_PNP);
166	166	//printf("type %s\n", m_model.model_type().cstr());

trunk/src/emu/netlist/analog/nld_bjt.h

r242990	r242991
98	98
99	99	NETLIB_UPDATE_TERMINALS()
100	100	{
101		const nl_double m = (is_qtype( BJT_NPN) ? 1 : -1);
	101	const double m = (is_qtype( BJT_NPN) ? 1 : -1);
102	102
103	103	const int new_state = (m_RB.deltaV() * m > m_V ) ? 1 : 0;
104	104	if (m_state_on ^ new_state)
105	105	{
106	106	#if 0
107		nl_double gb = m_gB;
108		nl_double gc = m_gC;
109		nl_double v  = m_V * m;
	107	double gb = m_gB;
	108	double gc = m_gC;
	109	double v  = m_V * m;
110	110	if (!new_state )
111	111	{
112	112	// not conducting
r242990	r242991
115	115	gc = netlist().gmin();
116	116	}
117	117	#else
118		const nl_double gb = new_state ? m_gB : netlist().gmin();
119		const nl_double gc = new_state ? m_gC : netlist().gmin();
120		const nl_double v  = new_state ? m_V * m : 0;
	118	const double gb = new_state ? m_gB : netlist().gmin();
	119	const double gc = new_state ? m_gC : netlist().gmin();
	120	const double v  = new_state ? m_V * m : 0;
121	121	#endif
122	122	m_RB.set(gb, v,   0.0);
123	123	m_RC.set(gc, 0.0, 0.0);
r242990	r242991
142	142	ATTR_COLD virtual void start();
143	143	ATTR_HOT void update_param();
144	144
145		nl_double m_gB; // base conductance / switch on
146		nl_double m_gC; // collector conductance / switch on
147		nl_double m_V; // internal voltage source
	145	double m_gB; // base conductance / switch on
	146	double m_gC; // collector conductance / switch on
	147	double m_V; // internal voltage source
148	148	UINT8 m_state_on;
149	149
150	150	private:
r242990	r242991
169	169
170	170	NETLIB_UPDATE_TERMINALS()
171	171	{
172		const nl_double polarity = (qtype() == BJT_NPN ? 1.0 : -1.0);
	172	const double polarity = (qtype() == BJT_NPN ? 1.0 : -1.0);
173	173
174	174	m_gD_BE.update_diode(-m_D_EB.deltaV() * polarity);
175	175	m_gD_BC.update_diode(-m_D_CB.deltaV() * polarity);
176	176
177		const nl_double gee = m_gD_BE.G();
178		const nl_double gcc = m_gD_BC.G();
179		const nl_double gec =  m_alpha_r * gcc;
180		const nl_double gce =  m_alpha_f * gee;
181		const nl_double sIe = -m_gD_BE.I() + m_alpha_r * m_gD_BC.I();
182		const nl_double sIc = m_alpha_f * m_gD_BE.I() - m_gD_BC.I();
183		const nl_double Ie = (sIe + gee * m_gD_BE.Vd() - gec * m_gD_BC.Vd()) * polarity;
184		const nl_double Ic = (sIc - gce * m_gD_BE.Vd() + gcc * m_gD_BC.Vd()) * polarity;
	177	const double gee = m_gD_BE.G();
	178	const double gcc = m_gD_BC.G();
	179	const double gec =  m_alpha_r * gcc;
	180	const double gce =  m_alpha_f * gee;
	181	const double sIe = -m_gD_BE.I() + m_alpha_r * m_gD_BC.I();
	182	const double sIc = m_alpha_f * m_gD_BE.I() - m_gD_BC.I();
	183	const double Ie = (sIe + gee * m_gD_BE.Vd() - gec * m_gD_BC.Vd()) * polarity;
	184	const double Ic = (sIc - gce * m_gD_BE.Vd() + gcc * m_gD_BC.Vd()) * polarity;
185	185
186	186	m_D_EB.set_mat(gee, gec - gee, gce - gee, gee - gec, Ie, -Ie);
187	187	m_D_CB.set_mat(gcc, gce - gcc, gec - gcc, gcc - gce, Ic, -Ic);
r242990	r242991
202	202	nld_twoterm m_D_EB;  // gee, gec - gee, gce - gee, gee - gec | Ie
203	203	nld_twoterm m_D_EC;  // 0, -gec, -gcc, 0 | 0
204	204
205		nl_double m_alpha_f;
206		nl_double m_alpha_r;
	205	double m_alpha_f;
	206	double m_alpha_r;
207	207
208	208	private:
209	209	};

trunk/src/emu/netlist/analog/nld_fourterm.c

r242990	r242991
17	17	m_gfac = 1.0;
18	18	}
19	19
20		void NETLIB_NAME(VCCS)::start_internal(const nl_double def_RI)
	20	void NETLIB_NAME(VCCS)::start_internal(const double def_RI)
21	21	{
22	22	register_param("G", m_G, 1.0);
23	23	register_param("RI", m_RI, def_RI);
r242990	r242991
45	45
46	46	NETLIB_RESET(VCCS)
47	47	{
48		const nl_double m_mult = m_G.Value() * m_gfac; // 1.0 ==> 1V ==> 1A
49		const nl_double GI = 1.0 / m_RI.Value();
	48	const double m_mult = m_G.Value() * m_gfac; // 1.0 ==> 1V ==> 1A
	49	const double GI = 1.0 / m_RI.Value();
50	50
51	51	m_IP.set(GI);
52	52	m_IN.set(GI);

trunk/src/emu/netlist/analog/nld_fourterm.h

r242990	r242991
59	59	ATTR_COLD virtual void update_param();
60	60	ATTR_HOT ATTR_ALIGN void update();
61	61
62		ATTR_COLD void start_internal(const nl_double def_RI);
	62	ATTR_COLD void start_internal(const double def_RI);
63	63
64	64	netlist_terminal_t m_OP;
65	65	netlist_terminal_t m_ON;
r242990	r242991
73	73	netlist_param_double_t m_G;
74	74	netlist_param_double_t m_RI;
75	75
76		nl_double m_gfac;
	76	double m_gfac;
77	77	};
78	78
79	79	// ----------------------------------------------------------------------------------------
r242990	r242991
115	115	ATTR_COLD virtual void update_param();
116	116	ATTR_HOT ATTR_ALIGN void update();
117	117
118		nl_double m_gfac;
	118	double m_gfac;
119	119	};
120	120
121	121

trunk/src/emu/netlist/analog/nld_ms_direct.h

r242990	r242991
28	28	protected:
29	29	ATTR_COLD virtual void add_term(int net_idx, netlist_terminal_t *term);
30	30
31		ATTR_HOT virtual nl_double vsolve();
	31	ATTR_HOT virtual double vsolve();
32	32
33	33	ATTR_HOT int solve_non_dynamic();
34	34	ATTR_HOT void build_LE();
35		ATTR_HOT void gauss_LE(nl_double (* RESTRICT x));
36		ATTR_HOT nl_double delta(const nl_double (* RESTRICT V));
37		ATTR_HOT void store(const nl_double (* RESTRICT V), const bool store_RHS);
	35	ATTR_HOT void gauss_LE(double (* RESTRICT x));
	36	ATTR_HOT double delta(const double (* RESTRICT V));
	37	ATTR_HOT void store(const double (* RESTRICT V), const bool store_RHS);
38	38
39	39	/* bring the whole system to the current time
40	40	* Don't schedule a new calculation time. The recalculation has to be
41	41	* triggered by the caller after the netlist element was changed.
42	42	*/
43		ATTR_HOT nl_double compute_next_timestep();
	43	ATTR_HOT double compute_next_timestep();
44	44
45		nl_double m_A[_storage_N][((_storage_N + 7) / 8) * 8];
46		nl_double m_RHS[_storage_N];
47		nl_double m_last_RHS[_storage_N]; // right hand side - contains currents
48		nl_double m_Vdelta[_storage_N];
49		nl_double m_last_V[_storage_N];
	45	double m_A[_storage_N][((_storage_N + 7) / 8) * 8];
	46	double m_RHS[_storage_N];
	47	double m_last_RHS[_storage_N]; // right hand side - contains currents
	48	double m_Vdelta[_storage_N];
	49	double m_last_V[_storage_N];
50	50
51	51	terms_t **m_terms;
52	52	terms_t *m_rails_temp;
r242990	r242991
55	55	vector_ops_t *m_row_ops[_storage_N + 1];
56	56
57	57	int m_dim;
58		nl_double m_lp_fact;
	58	double m_lp_fact;
59	59	};
60	60
61	61	// ----------------------------------------------------------------------------------------
r242990	r242991
69	69	{
70	70	//delete[] m_A[k];
71	71	}
72		for (int k = 0; k < N(); k++)
73		{
74		nl_free(m_terms[k]);
75		nl_free(m_row_ops[k]);
76		}
77		nl_free(m_row_ops[N()]);
78		//delete[] m_last_RHS;
	72	//delete[] m_last_RHS;
79	73	//delete[] m_RHS;
80		nl_free_array(m_terms);
81		nl_free_array(m_rails_temp);
	74	delete[] m_terms;
	75	delete[] m_rails_temp;
82	76	//delete[] m_row_ops;
83	77
84	78	}
85	79
86	80	template <int m_N, int _storage_N>
87		ATTR_HOT nl_double netlist_matrix_solver_direct_t<m_N, _storage_N>::compute_next_timestep()
	81	ATTR_HOT double netlist_matrix_solver_direct_t<m_N, _storage_N>::compute_next_timestep()
88	82	{
89		nl_double new_solver_timestep = m_params.m_max_timestep;
	83	double new_solver_timestep = m_params.m_max_timestep;
90	84
91	85	if (m_params.m_dynamic)
92	86	{
r242990	r242991
103	97	{
104	98	netlist_analog_net_t *n = m_nets[k];
105	99	#endif
106		const nl_double DD_n = (n->m_cur_Analog - m_last_V[k]);
107		const nl_double hn = current_timestep();
	100	const double DD_n = (n->m_cur_Analog - m_last_V[k]);
	101	const double hn = current_timestep();
108	102
109		nl_double DD2 = (DD_n / hn - n->m_DD_n_m_1 / n->m_h_n_m_1) / (hn + n->m_h_n_m_1);
110		nl_double new_net_timestep;
	103	double DD2 = (DD_n / hn - n->m_DD_n_m_1 / n->m_h_n_m_1) / (hn + n->m_h_n_m_1);
	104	double new_net_timestep;
111	105
112	106	n->m_h_n_m_1 = hn;
113	107	n->m_DD_n_m_1 = DD_n;
r242990	r242991
236	230	for (int i=0; i < N(); i++)
237	231	m_A[k][i] = 0.0;
238	232
239		nl_double rhsk = 0.0;
240		nl_double akk  = 0.0;
	233	double rhsk = 0.0;
	234	double akk  = 0.0;
241	235	{
242	236	const int terms_count = m_terms[k]->count();
243		const nl_double * RESTRICT gt = m_terms[k]->gt();
244		const nl_double * RESTRICT go = m_terms[k]->go();
245		const nl_double * RESTRICT Idr = m_terms[k]->Idr();
	237	const double * RESTRICT gt = m_terms[k]->gt();
	238	const double * RESTRICT go = m_terms[k]->go();
	239	const double * RESTRICT Idr = m_terms[k]->Idr();
246	240	#if VECTALT
247	241
248	242	for (int i = 0; i < terms_count; i++)
r242990	r242991
253	247	#else
254	248	m_terms[k]->ops()->sum2(Idr, gt, rhsk, akk);
255	249	#endif
256		nl_double * const * RESTRICT other_cur_analog = m_terms[k]->other_curanalog();
	250	double * const * RESTRICT other_cur_analog = m_terms[k]->other_curanalog();
257	251	for (int i = m_terms[k]->m_railstart; i < terms_count; i++)
258	252	{
259	253	//rhsk = rhsk + go[i] * terms[i]->m_otherterm->net().as_analog().Q_Analog();
r242990	r242991
272	266	m_A[k][k] += 1.0;
273	267	{
274	268	const int *net_other = m_terms[k]->net_other();
275		const nl_double *go = m_terms[k]->go();
	269	const double *go = m_terms[k]->go();
276	270	const int railstart =  m_terms[k]->m_railstart;
277	271
278	272	for (int i = 0; i < railstart; i++)
r242990	r242991
285	279	m_A[k][k] += akk;
286	280	{
287	281	const int * RESTRICT net_other = m_terms[k]->net_other();
288		const nl_double * RESTRICT go = m_terms[k]->go();
	282	const double * RESTRICT go = m_terms[k]->go();
289	283	const int railstart =  m_terms[k]->m_railstart;
290	284
291	285	for (int i = 0; i < railstart; i++)
r242990	r242991
299	293
300	294	template <int m_N, int _storage_N>
301	295	ATTR_HOT void netlist_matrix_solver_direct_t<m_N, _storage_N>::gauss_LE(
302		nl_double (* RESTRICT x))
	296	double (* RESTRICT x))
303	297	{
304	298	#if 0
305	299	for (int i = 0; i < N(); i++)
r242990	r242991
336	330	}
337	331
338	332	/* FIXME: Singular matrix? */
339		const nl_double f = 1.0 / m_A[i][i];
	333	const double f = 1.0 / m_A[i][i];
340	334
341	335	/* Eliminate column i from row j */
342	336
343	337	for (int j = i + 1; j < kN; j++)
344	338	{
345		const nl_double f1 = - m_A[j][i] * f;
	339	const double f1 = - m_A[j][i] * f;
346	340	if (f1 != 0.0)
347	341	{
348	342	#if 0 && VECTALT
r242990	r242991
359	353	/* back substitution */
360	354	for (int j = kN - 1; j >= 0; j--)
361	355	{
362		nl_double tmp = 0;
	356	double tmp = 0;
363	357
364	358	for (int k = j + 1; k < kN; k++)
365	359	tmp += m_A[j][k] * x[k];
r242990	r242991
380	374	}
381	375
382	376	template <int m_N, int _storage_N>
383		ATTR_HOT nl_double netlist_matrix_solver_direct_t<m_N, _storage_N>::delta(
384		const nl_double (* RESTRICT V))
	377	ATTR_HOT double netlist_matrix_solver_direct_t<m_N, _storage_N>::delta(
	378	const double (* RESTRICT V))
385	379	{
386		nl_double cerr = 0;
387		nl_double cerr2 = 0;
	380	double cerr = 0;
	381	double cerr2 = 0;
388	382	for (int i = 0; i < this->N(); i++)
389	383	{
390		const nl_double e = (V[i] - this->m_nets[i]->m_cur_Analog);
391		const nl_double e2 = (m_RHS[i] - this->m_last_RHS[i]);
	384	const double e = (V[i] - this->m_nets[i]->m_cur_Analog);
	385	const double e2 = (m_RHS[i] - this->m_last_RHS[i]);
392	386	cerr = (fabs(e) > cerr ? fabs(e) : cerr);
393	387	cerr2 = (fabs(e2) > cerr2 ? fabs(e2) : cerr2);
394	388	}
r242990	r242991
398	392
399	393	template <int m_N, int _storage_N>
400	394	ATTR_HOT void netlist_matrix_solver_direct_t<m_N, _storage_N>::store(
401		const nl_double (* RESTRICT V), const bool store_RHS)
	395	const double (* RESTRICT V), const bool store_RHS)
402	396	{
403	397	for (int i = 0; i < this->N(); i++)
404	398	{
r242990	r242991
414	408	}
415	409
416	410	template <int m_N, int _storage_N>
417		ATTR_HOT nl_double netlist_matrix_solver_direct_t<m_N, _storage_N>::vsolve()
	411	ATTR_HOT double netlist_matrix_solver_direct_t<m_N, _storage_N>::vsolve()
418	412	{
419	413	solve_base<netlist_matrix_solver_direct_t>(this);
420	414	return this->compute_next_timestep();
r242990	r242991
424	418	template <int m_N, int _storage_N>
425	419	ATTR_HOT int netlist_matrix_solver_direct_t<m_N, _storage_N>::solve_non_dynamic()
426	420	{
427		nl_double new_v[_storage_N] = { 0.0 };
	421	double new_v[_storage_N] = { 0.0 };
428	422
429	423	this->gauss_LE(new_v);
430	424
431	425	if (this->is_dynamic())
432	426	{
433		nl_double err = delta(new_v);
	427	double err = delta(new_v);
434	428
435	429	store(new_v, true);
436	430
r242990	r242991
458	452	, m_dim(size)
459	453	, m_lp_fact(0)
460	454	{
461		m_terms = nl_alloc_array(terms_t *, N());
462		m_rails_temp = nl_alloc_array(terms_t, N());
	455	m_terms = new terms_t *[N()];
	456	m_rails_temp = new terms_t[N()];
463	457
464	458	for (int k = 0; k < N(); k++)
465	459	{
466		m_terms[k] = nl_alloc(terms_t);
	460	m_terms[k] = new terms_t;
467	461	m_row_ops[k] = vector_ops_t::create_ops(k);
468	462	}
469	463	m_row_ops[N()] = vector_ops_t::create_ops(N());
r242990	r242991
475	469	, m_dim(size)
476	470	, m_lp_fact(0)
477	471	{
478		m_terms = nl_alloc_array(terms_t *, N());
479		m_rails_temp = nl_alloc_array(terms_t, N());
	472	m_terms = new terms_t *[N()];
	473	m_rails_temp = new terms_t[N()];
480	474
481	475	for (int k = 0; k < N(); k++)
482	476	{
483		m_terms[k] = nl_alloc(terms_t);
	477	m_terms[k] = new terms_t;
484	478	m_row_ops[k] = vector_ops_t::create_ops(k);
485	479	}
486	480	m_row_ops[N()] = vector_ops_t::create_ops(N());

trunk/src/emu/netlist/analog/nld_ms_direct1.h

r242990	r242991
18	18	{}
19	19	ATTR_HOT inline int vsolve_non_dynamic();
20	20	protected:
21		ATTR_HOT virtual nl_double vsolve();
	21	ATTR_HOT virtual double vsolve();
22	22	private:
23	23	};
24	24
r242990	r242991
26	26	// netlist_matrix_solver - Direct1
27	27	// ----------------------------------------------------------------------------------------
28	28
29		ATTR_HOT nl_double netlist_matrix_solver_direct1_t::vsolve()
	29	ATTR_HOT double netlist_matrix_solver_direct1_t::vsolve()
30	30	{
31	31	solve_base<netlist_matrix_solver_direct1_t>(this);
32	32	return this->compute_next_timestep();
r242990	r242991
38	38	this->build_LE();
39	39	//NL_VERBOSE_OUT(("%f %f\n", new_val, m_RHS[0] / m_A[0][0]);
40	40
41		nl_double new_val =  m_RHS[0] / m_A[0][0];
	41	double new_val =  m_RHS[0] / m_A[0][0];
42	42
43		nl_double e = (new_val - net->m_cur_Analog);
44		nl_double cerr = fabs(e);
	43	double e = (new_val - net->m_cur_Analog);
	44	double cerr = fabs(e);
45	45
46	46	net->m_cur_Analog = new_val;
47	47

trunk/src/emu/netlist/analog/nld_ms_direct2.h

r242990	r242991
20	20	{}
21	21	ATTR_HOT inline int vsolve_non_dynamic();
22	22	protected:
23		ATTR_HOT virtual nl_double vsolve();
	23	ATTR_HOT virtual double vsolve();
24	24	private:
25	25	};
26	26
r242990	r242991
28	28	// netlist_matrix_solver - Direct2
29	29	// ----------------------------------------------------------------------------------------
30	30
31		ATTR_HOT nl_double netlist_matrix_solver_direct2_t::vsolve()
	31	ATTR_HOT double netlist_matrix_solver_direct2_t::vsolve()
32	32	{
33	33	solve_base<netlist_matrix_solver_direct2_t>(this);
34	34	return this->compute_next_timestep();
r242990	r242991
38	38	{
39	39	build_LE();
40	40
41		const nl_double a = m_A[0][0];
42		const nl_double b = m_A[0][1];
43		const nl_double c = m_A[1][0];
44		const nl_double d = m_A[1][1];
	41	const double a = m_A[0][0];
	42	const double b = m_A[0][1];
	43	const double c = m_A[1][0];
	44	const double d = m_A[1][1];
45	45
46		nl_double new_val[2];
	46	double new_val[2];
47	47	new_val[1] = (a * m_RHS[1] - c * m_RHS[0]) / (a * d - b * c);
48	48	new_val[0] = (m_RHS[0] - b * new_val[1]) / a;
49	49
50	50	if (is_dynamic())
51	51	{
52		nl_double err = this->delta(new_val);
	52	double err = this->delta(new_val);
53	53	store(new_val, true);
54	54	if (err > m_params.m_accuracy )
55	55	return 2;

trunk/src/emu/netlist/analog/nld_ms_gauss_seidel.h

r242990	r242991
29	29
30	30	ATTR_HOT inline int vsolve_non_dynamic();
31	31	protected:
32		ATTR_HOT virtual nl_double vsolve();
	32	ATTR_HOT virtual double vsolve();
33	33
34	34	private:
35		nl_double m_lp_fact;
	35	double m_lp_fact;
36	36	int m_gs_fail;
37	37	int m_gs_total;
38	38
r242990	r242991
64	64	}
65	65
66	66	template <int m_N, int _storage_N>
67		ATTR_HOT nl_double netlist_matrix_solver_gauss_seidel_t<m_N, _storage_N>::vsolve()
	67	ATTR_HOT double netlist_matrix_solver_gauss_seidel_t<m_N, _storage_N>::vsolve()
68	68	{
69	69	/*
70	70	* enable linear prediction on first newton pass
r242990	r242991
86	86
87	87	if (USE_LINEAR_PREDICTION)
88	88	{
89		nl_double sq = 0;
90		nl_double sqo = 0;
91		const nl_double rez_cts = 1.0 / this->current_timestep();
	89	double sq = 0;
	90	double sqo = 0;
	91	const double rez_cts = 1.0 / this->current_timestep();
92	92	for (int k = 0; k < this->N(); k++)
93	93	{
94	94	const netlist_analog_net_t *n = this->m_nets[k];
95		const nl_double nv = (n->m_cur_Analog - this->m_last_V[k]) * rez_cts ;
	95	const double nv = (n->m_cur_Analog - this->m_last_V[k]) * rez_cts ;
96	96	sq += nv * nv;
97	97	sqo += this->m_Vdelta[k] * this->m_Vdelta[k];
98	98	this->m_Vdelta[k] = nv;
r242990	r242991
116	116	*/
117	117
118	118	#if 0 || USE_MATRIX_GS
119		static nl_double ws = 1.0;
120		ATTR_ALIGN nl_double new_v[_storage_N] = { 0.0 };
	119	static double ws = 1.0;
	120	ATTR_ALIGN double new_v[_storage_N] = { 0.0 };
121	121	const int iN = this->N();
122	122
123	123	bool resched = false;
r242990	r242991
127	127	this->build_LE();
128	128
129	129	{
130		nl_double frob;
	130	double frob;
131	131	frob = 0;
132		nl_double rmin = 1e99, rmax = -1e99;
	132	double rmin = 1e99, rmax = -1e99;
133	133	for (int k = 0; k < iN; k++)
134	134	{
135	135	new_v[k] = this->m_nets[k]->m_cur_Analog;
136		nl_double s=0.0;
	136	double s=0.0;
137	137	for (int i = 0; i < iN; i++)
138	138	{
139	139	frob += this->m_A[k][i] * this->m_A[k][i];
r242990	r242991
146	146	rmax = s;
147	147	}
148	148	#if 0
149		nl_double frobA = sqrt(frob /(iN));
	149	double frobA = sqrt(frob /(iN));
150	150	if (1 &&frobA < 1.0)
151	151	//ws = 2.0 / (1.0 + sqrt(1.0-frobA));
152	152	ws = 2.0 / (2.0 - frobA);
r242990	r242991
161	161	// overhead is bigger than the gain. Consequently the fast GS below
162	162	// uses a fixed GS. One can however use this here to determine a
163	163	// suitable parameter.
164		nl_double rm = (rmax + rmin) * 0.5;
	164	double rm = (rmax + rmin) * 0.5;
165	165	if (rm < 1.0)
166	166	ws = 2.0 / (1.0 + sqrt(1.0-rm));
167	167	else
r242990	r242991
172	172	}
173	173
174	174	// Frobenius norm for (D-L)^(-1)U
175		//nl_double frobU;
176		//nl_double frobL;
177		//nl_double norm;
	175	//double frobU;
	176	//double frobL;
	177	//double norm;
178	178	do {
179	179	resched = false;
180		nl_double cerr = 0.0;
	180	double cerr = 0.0;
181	181	//frobU = 0;
182	182	//frobL = 0;
183	183	//norm = 0;
184	184
185	185	for (int k = 0; k < iN; k++)
186	186	{
187		nl_double Idrive = 0;
188		//nl_double norm_t = 0;
	187	double Idrive = 0;
	188	//double norm_t = 0;
189	189	// Reduction loops need -ffast-math
190	190	for (int i = 0; i < iN; i++)
191	191	Idrive += this->m_A[k][i] * new_v[i];
r242990	r242991
198	198	}
199	199
200	200	//if (norm_t > norm) norm = norm_t;
201		const nl_double new_val = (1.0-ws) * new_v[k] + ws * (this->m_RHS[k] - Idrive + this->m_A[k][k] * new_v[k]) / this->m_A[k][k];
	201	const double new_val = (1.0-ws) * new_v[k] + ws * (this->m_RHS[k] - Idrive + this->m_A[k][k] * new_v[k]) / this->m_A[k][k];
202	202
203		const nl_double e = fabs(new_val - new_v[k]);
	203	const double e = fabs(new_val - new_v[k]);
204	204	cerr = (e > cerr ? e : cerr);
205	205	new_v[k] = new_val;
206	206	}
r242990	r242991
210	210	resched = true;
211	211	}
212	212	resched_cnt++;
213		//ATTR_UNUSED nl_double frobUL = sqrt((frobU + frobL) / (double) (iN) / (double) (iN));
	213	//ATTR_UNUSED double frobUL = sqrt((frobU + frobL) / (double) (iN) / (double) (iN));
214	214	} while (resched && (resched_cnt < this->m_params.m_gs_loops));
215	215	//printf("Frobenius %f %f %f %f %f\n", sqrt(frobU), sqrt(frobL), frobUL, frobA, norm);
216	216	//printf("Omega Estimate1 %f %f\n", 2.0 / (1.0 + sqrt(1-frobUL)), 2.0 / (1.0 + sqrt(1-frobA)) ); //        printf("Frobenius %f\n", sqrt(frob / (double) (iN * iN) ));
r242990	r242991
247	247	* omega = 2.0 / (1.0 + sqrt(1-rho))
248	248	*/
249	249
250		const nl_double ws = this->m_params.m_sor; //1.045; //2.0 / (1.0 + /*sin*/(3.14159 * 5.5 / (double) (m_nets.count()+1)));
251		//const nl_double ws = 2.0 / (1.0 + sin(3.14159 * 4 / (double) (this->N())));
	250	const double ws = this->m_params.m_sor; //1.045; //2.0 / (1.0 + /*sin*/(3.14159 * 5.5 / (double) (m_nets.count()+1)));
	251	//const double ws = 2.0 / (1.0 + sin(3.14159 * 4 / (double) (this->N())));
252	252
253		ATTR_ALIGN nl_double w[_storage_N];
254		ATTR_ALIGN nl_double one_m_w[_storage_N];
255		ATTR_ALIGN nl_double RHS[_storage_N];
256		ATTR_ALIGN nl_double new_V[_storage_N];
	253	ATTR_ALIGN double w[_storage_N];
	254	ATTR_ALIGN double one_m_w[_storage_N];
	255	ATTR_ALIGN double RHS[_storage_N];
	256	ATTR_ALIGN double new_V[_storage_N];
257	257
258	258	for (int k = 0; k < iN; k++)
259	259	{
260		nl_double gtot_t = 0.0;
261		nl_double gabs_t = 0.0;
262		nl_double RHS_t = 0.0;
	260	double gtot_t = 0.0;
	261	double gabs_t = 0.0;
	262	double RHS_t = 0.0;
263	263
264	264	new_V[k] = this->m_nets[k]->m_cur_Analog;
265	265
266	266	{
267	267	const int term_count = this->m_terms[k]->count();
268		const nl_double * const RESTRICT gt = this->m_terms[k]->gt();
269		const nl_double * const RESTRICT go = this->m_terms[k]->go();
270		const nl_double * const RESTRICT Idr = this->m_terms[k]->Idr();
271		const nl_double * const *other_cur_analog = this->m_terms[k]->other_curanalog();
	268	const double * const RESTRICT gt = this->m_terms[k]->gt();
	269	const double * const RESTRICT go = this->m_terms[k]->go();
	270	const double * const RESTRICT Idr = this->m_terms[k]->Idr();
	271	const double * const *other_cur_analog = this->m_terms[k]->other_curanalog();
272	272	#if VECTALT
273	273	for (int i = 0; i < term_count; i++)
274	274	{
r242990	r242991
308	308
309	309	}
310	310
311		const nl_double accuracy = this->m_params.m_accuracy;
	311	const double accuracy = this->m_params.m_accuracy;
312	312
313	313	do {
314	314	resched = false;
r242990	r242991
317	317	{
318	318	const int * RESTRICT net_other = this->m_terms[k]->net_other();
319	319	const int railstart = this->m_terms[k]->m_railstart;
320		const nl_double * RESTRICT go = this->m_terms[k]->go();
	320	const double * RESTRICT go = this->m_terms[k]->go();
321	321
322		nl_double Idrive = 0.0;
	322	double Idrive = 0.0;
323	323	for (int i = 0; i < railstart; i++)
324	324	Idrive = Idrive + go[i] * new_V[net_other[i]];
325	325
326		//nl_double new_val = (net->m_cur_Analog * gabs[k] + iIdr) / (gtot[k]);
327		const nl_double new_val = new_V[k] * one_m_w[k] + (Idrive + RHS[k]) * w[k];
	326	//double new_val = (net->m_cur_Analog * gabs[k] + iIdr) / (gtot[k]);
	327	const double new_val = new_V[k] * one_m_w[k] + (Idrive + RHS[k]) * w[k];
328	328
329	329	resched = resched || (std::abs(new_val - new_V[k]) > accuracy);
330	330	new_V[k] = new_val;

trunk/src/emu/netlist/analog/nld_solver.c

r242990	r242991
44	44	switch (size)
45	45	{
46	46	case 1:
47		return nl_alloc(vector_ops_impl_t<1>);
	47	return new vector_ops_impl_t<1>();
48	48	case 2:
49		return nl_alloc(vector_ops_impl_t<2>);
	49	return new vector_ops_impl_t<2>();
50	50	case 3:
51		return nl_alloc(vector_ops_impl_t<3>);
	51	return new vector_ops_impl_t<3>();
52	52	case 4:
53		return nl_alloc(vector_ops_impl_t<4>);
	53	return new vector_ops_impl_t<4>();
54	54	case 5:
55		return nl_alloc(vector_ops_impl_t<5>);
	55	return new vector_ops_impl_t<5>();
56	56	case 6:
57		return nl_alloc(vector_ops_impl_t<6>);
	57	return new vector_ops_impl_t<6>();
58	58	case 7:
59		return nl_alloc(vector_ops_impl_t<7>);
	59	return new vector_ops_impl_t<7>();
60	60	case 8:
61		return nl_alloc(vector_ops_impl_t<8>);
	61	return new vector_ops_impl_t<8>();
62	62	case 9:
63		return nl_alloc(vector_ops_impl_t<9>);
	63	return new vector_ops_impl_t<9>();
64	64	case 10:
65		return nl_alloc(vector_ops_impl_t<10>);
	65	return new vector_ops_impl_t<10>();
66	66	case 11:
67		return nl_alloc(vector_ops_impl_t<11>);
	67	return new vector_ops_impl_t<11>();
68	68	case 12:
69		return nl_alloc(vector_ops_impl_t<12>);
	69	return new vector_ops_impl_t<12>();
70	70	default:
71		return nl_alloc(vector_ops_impl_t<0>, size);
	71	return new vector_ops_impl_t<0>(size);
72	72	}
73	73	}
74	74
r242990	r242991
91	91	m_term[i]->m_Idr1 = &m_Idr[i];
92	92	m_other_curanalog[i] = &m_term[i]->m_otherterm->net().as_analog().m_cur_Analog;
93	93	}
	94
	95	m_ops = vector_ops_t::create_ops(m_gt.count());
94	96	}
95	97
96	98	// ----------------------------------------------------------------------------------------
r242990	r242991
110	112	ATTR_COLD netlist_matrix_solver_t::~netlist_matrix_solver_t()
111	113	{
112	114	for (int i = 0; i < m_inps.count(); i++)
113		global_free(m_inps[i]);
	115	delete m_inps[i];
114	116	}
115	117
116	118	ATTR_COLD void netlist_matrix_solver_t::setup(netlist_analog_net_t::list_t &nets)
r242990	r242991
174	176
175	177	if (net_proxy_output == NULL)
176	178	{
177		net_proxy_output = nl_alloc(netlist_analog_output_t);
	179	net_proxy_output = new netlist_analog_output_t();
178	180	net_proxy_output->init_object(*this, this->name() + "." + pstring::sprintf("m%d", m_inps.count()));
179	181	m_inps.add(net_proxy_output);
180	182	net_proxy_output->m_proxied_net = &p->net().as_analog();
r242990	r242991
233	235
234	236	ATTR_COLD void netlist_matrix_solver_t::update()
235	237	{
236		const nl_double new_timestep = solve();
	238	const double new_timestep = solve();
237	239
238	240	if (m_params.m_dynamic && is_timestep() && new_timestep > 0)
239	241	m_Q_sync.net().reschedule_in_queue(netlist_time::from_double(new_timestep));
r242990	r242991
241	243
242	244	ATTR_COLD void netlist_matrix_solver_t::update_forced()
243	245	{
244		ATTR_UNUSED const nl_double new_timestep = solve();
	246	ATTR_UNUSED const double new_timestep = solve();
245	247
246	248	if (m_params.m_dynamic && is_timestep())
247	249	m_Q_sync.net().reschedule_in_queue(netlist_time::from_double(m_params.m_min_timestep));
r242990	r242991
249	251
250	252	ATTR_HOT void netlist_matrix_solver_t::step(const netlist_time delta)
251	253	{
252		const nl_double dd = delta.as_double();
	254	const double dd = delta.as_double();
253	255	for (int k=0; k < m_step_devices.count(); k++)
254	256	m_step_devices[k]->step_time(dd);
255	257	}
r242990	r242991
284	286	}
285	287	}
286	288
287		ATTR_HOT nl_double netlist_matrix_solver_t::solve()
	289	ATTR_HOT double netlist_matrix_solver_t::solve()
288	290	{
289	291	netlist_time now = netlist().time();
290	292	netlist_time delta = now - m_last_step;
r242990	r242991
300	302
301	303	step(delta);
302	304
303		const nl_double next_time_step = vsolve();
	305	const double next_time_step = vsolve();
304	306
305	307	update_inputs();
306	308	return next_time_step;
r242990	r242991
348	350	register_param("GMIN", m_gmin, NETLIST_GMIN_DEFAULT);
349	351	register_param("DYNAMIC_TS", m_dynamic, 0);
350	352	register_param("LTE", m_lte, 5e-5);                     // diff/timestep
351		register_param("MIN_TIMESTEP", m_min_timestep, 1e-6);   // nl_double timestep resolution
	353	register_param("MIN_TIMESTEP", m_min_timestep, 1e-6);   // double timestep resolution
352	354
353	355	// internal staff
354	356
r242990	r242991
378	380	while (e != NULL)
379	381	{
380	382	netlist_matrix_solver_t * const *en = m_mat_solvers.next(e);
381		global_free(*e);
	383	delete *e;
382	384	e = en;
383	385	}
384	386
r242990	r242991
417	419	if (m_mat_solvers[i]->is_timestep())
418	420	{
419	421	// Ignore return value
420		ATTR_UNUSED const nl_double ts = m_mat_solvers[i]->solve();
	422	ATTR_UNUSED const double ts = m_mat_solvers[i]->solve();
421	423	}
422	424	}
423	425	#endif
r242990	r242991
433	435	netlist_matrix_solver_t * NETLIB_NAME(solver)::create_solver(int size, const int gs_threshold, const bool use_specific)
434	436	{
435	437	if (use_specific && m_N == 1)
436		return nl_alloc(netlist_matrix_solver_direct1_t, m_params);
	438	return new netlist_matrix_solver_direct1_t(m_params);
437	439	else if (use_specific && m_N == 2)
438		return nl_alloc(netlist_matrix_solver_direct2_t, m_params);
	440	return new netlist_matrix_solver_direct2_t(m_params);
439	441	else
440	442	{
441		typedef netlist_matrix_solver_gauss_seidel_t<m_N,_storage_N> solver_N;
442	443	if (size >= gs_threshold)
443		return nl_alloc(solver_N, m_params, size);
	444	return new netlist_matrix_solver_gauss_seidel_t<m_N,_storage_N>(m_params, size);
444	445	else
445		return nl_alloc(solver_N, m_params, size);
	446	return new netlist_matrix_solver_direct_t<m_N, _storage_N>(m_params, size);
446	447	}
447	448	}
448	449

trunk/src/emu/netlist/analog/nld_solver.h

r242990	r242991
37	37
38	38	struct netlist_solver_parameters_t
39	39	{
40		nl_double m_accuracy;
41		nl_double m_lte;
42		nl_double m_min_timestep;
43		nl_double m_max_timestep;
44		nl_double m_sor;
	40	double m_accuracy;
	41	double m_lte;
	42	double m_min_timestep;
	43	double m_max_timestep;
	44	double m_sor;
45	45	bool m_dynamic;
46	46	int m_gs_loops;
47	47	int m_nr_loops;
r242990	r242991
59	59
60	60	virtual ~vector_ops_t() {}
61	61
62		virtual const nl_double sum(const nl_double * v) = 0;
63		virtual void sum2(const nl_double * RESTRICT v1, const nl_double * RESTRICT v2, nl_double & RESTRICT  s1, nl_double & RESTRICT s2) = 0;
64		virtual void addmult(nl_double * RESTRICT v1, const nl_double * RESTRICT v2, const nl_double &mult) = 0;
65		virtual void sum2a(const nl_double * RESTRICT v1, const nl_double * RESTRICT v2, const nl_double * RESTRICT v3abs, nl_double & RESTRICT s1, nl_double & RESTRICT s2, nl_double & RESTRICT s3abs) = 0;
	62	virtual const double sum(const double * v) = 0;
	63	virtual void sum2(const double * RESTRICT v1, const double * RESTRICT v2, double & RESTRICT  s1, double & RESTRICT s2) = 0;
	64	virtual void addmult(double * RESTRICT v1, const double * RESTRICT v2, const double &mult) = 0;
	65	virtual void sum2a(const double * RESTRICT v1, const double * RESTRICT v2, const double * RESTRICT v3abs, double & RESTRICT s1, double & RESTRICT s2, double & RESTRICT s3abs) = 0;
66	66
67		virtual const nl_double sumabs(const nl_double * v) = 0;
	67	virtual const double sumabs(const double * v) = 0;
68	68
69	69	static vector_ops_t *create_ops(const int size);
70	70
r242990	r242991
88	88	vector_ops_impl_t(int size)
89	89	: vector_ops_t(size)
90	90	{
91		nl_assert(m_N == 0);
	91	assert(m_N == 0);
92	92	}
93	93
94	94	virtual ~vector_ops_impl_t() {}
95	95
96	96	ATTR_HOT inline const int N() const { if (m_N == 0) return m_dim; else return m_N; }
97	97
98		const nl_double sum(const nl_double * v)
	98	const double sum(const double * v)
99	99	{
100		const nl_double *  RESTRICT vl = v;
101		nl_double tmp = 0.0;
	100	const double *  RESTRICT vl = v;
	101	double tmp = 0.0;
102	102	for (int i=0; i < N(); i++)
103	103	tmp += vl[i];
104	104	return tmp;
105	105	}
106	106
107		void sum2(const nl_double * RESTRICT v1, const nl_double * RESTRICT v2, nl_double & RESTRICT s1, nl_double & RESTRICT s2)
	107	void sum2(const double * RESTRICT v1, const double * RESTRICT v2, double & RESTRICT s1, double & RESTRICT s2)
108	108	{
109		const nl_double * RESTRICT v1l = v1;
110		const nl_double * RESTRICT v2l = v2;
	109	const double * RESTRICT v1l = v1;
	110	const double * RESTRICT v2l = v2;
111	111	for (int i=0; i < N(); i++)
112	112	{
113	113	s1 += v1l[i];
r242990	r242991
115	115	}
116	116	}
117	117
118		void addmult(nl_double * RESTRICT v1, const nl_double * RESTRICT v2, const nl_double &mult)
	118	void addmult(double * RESTRICT v1, const double * RESTRICT v2, const double &mult)
119	119	{
120		nl_double * RESTRICT v1l = v1;
121		const nl_double * RESTRICT v2l = v2;
	120	double * RESTRICT v1l = v1;
	121	const double * RESTRICT v2l = v2;
122	122	for (int i=0; i < N(); i++)
123	123	{
124	124	v1l[i] += v2l[i] * mult;
125	125	}
126	126	}
127	127
128		void sum2a(const nl_double * RESTRICT v1, const nl_double * RESTRICT v2, const nl_double * RESTRICT v3abs, nl_double & RESTRICT s1, nl_double & RESTRICT s2, nl_double & RESTRICT s3abs)
	128	void sum2a(const double * RESTRICT v1, const double * RESTRICT v2, const double * RESTRICT v3abs, double & RESTRICT s1, double & RESTRICT s2, double & RESTRICT s3abs)
129	129	{
130		const nl_double * RESTRICT v1l = v1;
131		const nl_double * RESTRICT v2l = v2;
132		const nl_double * RESTRICT v3l = v3abs;
	130	const double * RESTRICT v1l = v1;
	131	const double * RESTRICT v2l = v2;
	132	const double * RESTRICT v3l = v3abs;
133	133	for (int i=0; i < N(); i++)
134	134	{
135	135	s1 += v1l[i];
r242990	r242991
138	138	}
139	139	}
140	140
141		const nl_double sumabs(const nl_double * v)
	141	const double sumabs(const double * v)
142	142	{
143		const nl_double * RESTRICT vl = v;
144		nl_double tmp = 0.0;
	143	const double * RESTRICT vl = v;
	144	double tmp = 0.0;
145	145	for (int i=0; i < N(); i++)
146	146	tmp += fabs(vl[i]);
147	147	return tmp;
r242990	r242991
155	155	NETLIST_PREVENT_COPYING(terms_t)
156	156
157	157	public:
158		ATTR_COLD terms_t() : m_railstart(0)
	158	ATTR_COLD terms_t() : m_railstart(0), m_ops(NULL)
159	159	{}
160	160
161	161	ATTR_COLD void clear()
r242990	r242991
171	171
172	172	ATTR_HOT inline netlist_terminal_t **terms() { return m_term; }
173	173	ATTR_HOT inline int *net_other() { return m_net_other; }
174		ATTR_HOT inline nl_double *gt() { return m_gt; }
175		ATTR_HOT inline nl_double *go() { return m_go; }
176		ATTR_HOT inline nl_double *Idr() { return m_Idr; }
177		ATTR_HOT inline nl_double **other_curanalog() { return m_other_curanalog; }
	174	ATTR_HOT inline double *gt() { return m_gt; }
	175	ATTR_HOT inline double *go() { return m_go; }
	176	ATTR_HOT inline double *Idr() { return m_Idr; }
	177	ATTR_HOT inline double **other_curanalog() { return m_other_curanalog; }
	178	ATTR_HOT vector_ops_t *ops() { return m_ops; }
178	179
179	180	ATTR_COLD void set_pointers();
180	181
r242990	r242991
183	184	private:
184	185	plinearlist_t<netlist_terminal_t *> m_term;
185	186	plinearlist_t<int> m_net_other;
186		plinearlist_t<nl_double> m_go;
187		plinearlist_t<nl_double> m_gt;
188		plinearlist_t<nl_double> m_Idr;
189		plinearlist_t<nl_double *> m_other_curanalog;
	187	plinearlist_t<double> m_go;
	188	plinearlist_t<double> m_gt;
	189	plinearlist_t<double> m_Idr;
	190	plinearlist_t<double *> m_other_curanalog;
	191	vector_ops_t * m_ops;
190	192	};
191	193
192	194	class netlist_matrix_solver_t : public netlist_device_t
r242990	r242991
209	211	template<class C>
210	212	void solve_base(C *p);
211	213
212		ATTR_HOT nl_double solve();
	214	ATTR_HOT double solve();
213	215
214	216	ATTR_HOT inline bool is_dynamic() { return m_dynamic_devices.count() > 0; }
215	217	ATTR_HOT inline bool is_timestep() { return m_step_devices.count() > 0; }
r242990	r242991
236	238	ATTR_HOT void update_dynamic();
237	239
238	240	// should return next time step
239		ATTR_HOT virtual nl_double vsolve() = 0;
	241	ATTR_HOT virtual double vsolve() = 0;
240	242
241	243	ATTR_COLD virtual void  add_term(int net_idx, netlist_terminal_t *term) = 0;
242	244
r242990	r242991
249	251
250	252	const netlist_solver_parameters_t &m_params;
251	253
252		ATTR_HOT inline const nl_double current_timestep() { return m_cur_ts; }
	254	ATTR_HOT inline const double current_timestep() { return m_cur_ts; }
253	255	private:
254	256
255	257	netlist_time m_last_step;
256		nl_double m_cur_ts;
	258	double m_cur_ts;
257	259	dev_list_t m_step_devices;
258	260	dev_list_t m_dynamic_devices;
259	261
r242990	r242991
279	281
280	282	ATTR_COLD void post_start();
281	283
282		ATTR_HOT inline nl_double gmin() { return m_gmin.Value(); }
	284	ATTR_HOT inline double gmin() { return m_gmin.Value(); }
283	285
284	286	protected:
285	287	ATTR_HOT void update();

trunk/src/emu/netlist/analog/nld_twoterm.c

r242990	r242991
16	16	set_param(1e-15, 1, 1e-15);
17	17	}
18	18
19		ATTR_COLD void netlist_generic_diode::set_param(const nl_double Is, const nl_double n, nl_double gmin)
	19	ATTR_COLD void netlist_generic_diode::set_param(const double Is, const double n, double gmin)
20	20	{
21	21	m_Is = Is;
22	22	m_n = n;
r242990	r242991
157	157
158	158	NETLIB_UPDATE_PARAM(POT)
159	159	{
160		nl_double v = m_Dial.Value();
	160	double v = m_Dial.Value();
161	161	if (m_DialIsLog.Value())
162	162	v = (exp(v) - 1.0) / (exp(1.0) - 1.0);
163	163
r242990	r242991
221	221
222	222	NETLIB_UPDATE_PARAM(D)
223	223	{
224		nl_double Is = m_model.model_value("Is", 1e-15);
225		nl_double n = m_model.model_value("N", 1);
	224	double Is = m_model.model_value("Is", 1e-15);
	225	double n = m_model.model_value("N", 1);
226	226
227	227	m_D.set_param(Is, n, netlist().gmin());
228	228	}

trunk/src/emu/netlist/analog/nld_twoterm.h

r242990	r242991
97	97	{
98	98	}
99	99
100		ATTR_HOT inline void set(const nl_double G, const nl_double V, const nl_double I)
	100	ATTR_HOT inline void set(const double G, const double V, const double I)
101	101	{
102	102	/*      GO, GT, I                */
103	103	m_P.set( G,  G, (  V) * G - I);
104	104	m_N.set( G,  G, ( -V) * G + I);
105	105	}
106	106
107		ATTR_HOT inline nl_double deltaV() const
	107	ATTR_HOT inline double deltaV() const
108	108	{
109	109	return m_P.net().as_analog().Q_Analog() - m_N.net().as_analog().Q_Analog();
110	110	}
111	111
112		ATTR_HOT void set_mat(nl_double a11, nl_double a12, nl_double a21, nl_double a22, nl_double r1, nl_double r2)
	112	ATTR_HOT void set_mat(double a11, double a12, double a21, double a22, double r1, double r2)
113	113	{
114	114	/*      GO, GT, I                */
115	115	m_P.set(-a12, a11, -r1);
r242990	r242991
133	133	public:
134	134	ATTR_COLD NETLIB_NAME(R_base)() : NETLIB_NAME(twoterm)(RESISTOR) { }
135	135
136		inline void set_R(const nl_double R)
	136	inline void set_R(const double R)
137	137	{
138	138	set(1.0 / R, 0.0, 0.0);
139	139	}
r242990	r242991
171	171	public:
172	172	ATTR_COLD NETLIB_NAME(C)() : NETLIB_NAME(twoterm)(CAPACITOR) { }
173	173
174		ATTR_HOT void step_time(const nl_double st)
	174	ATTR_HOT void step_time(const double st)
175	175	{
176		const nl_double G = m_C.Value() / st;
177		const nl_double I = -G * deltaV();
	176	const double G = m_C.Value() / st;
	177	const double I = -G * deltaV();
178	178	set(G, 0.0, I);
179	179	}
180	180
r242990	r242991
198	198	public:
199	199	ATTR_COLD netlist_generic_diode();
200	200
201		ATTR_HOT inline void update_diode(const nl_double nVd)
	201	ATTR_HOT inline void update_diode(const double nVd)
202	202	{
203	203	//FIXME: Optimize cutoff case
204	204
r242990	r242991
212	212	{
213	213	m_Vd = nVd;
214	214
215		const nl_double eVDVt = exp(m_Vd * m_VtInv);
	215	const double eVDVt = exp(m_Vd * m_VtInv);
216	216	m_Id = m_Is * (eVDVt - 1.0);
217	217	m_G = m_Is * m_VtInv * eVDVt + m_gmin;
218	218	}
r242990	r242991
221	221	#if defined(_MSC_VER) && _MSC_VER < 1800
222	222	m_Vd = m_Vd + log((nVd - m_Vd) * m_VtInv + 1.0) * m_Vt;
223	223	#else
224		nl_double a = (nVd - m_Vd) * m_VtInv;
	224	double a = (nVd - m_Vd) * m_VtInv;
225	225	if (a<1e-12 - 1.0) a = 1e-12 - 1.0;
226	226	m_Vd = m_Vd + log1p(a) * m_Vt;
227	227	#endif
228		const nl_double eVDVt = exp(m_Vd * m_VtInv);
	228	const double eVDVt = exp(m_Vd * m_VtInv);
229	229	m_Id = m_Is * (eVDVt - 1.0);
230	230
231	231	m_G = m_Is * m_VtInv * eVDVt + m_gmin;
r242990	r242991
234	234	//printf("nVd %f m_Vd %f Vcrit %f\n", nVd, m_Vd, m_Vcrit);
235	235	}
236	236
237		ATTR_COLD void set_param(const nl_double Is, const nl_double n, nl_double gmin);
	237	ATTR_COLD void set_param(const double Is, const double n, double gmin);
238	238
239		ATTR_HOT inline nl_double I() const { return m_Id; }
240		ATTR_HOT inline nl_double G() const { return m_G; }
241		ATTR_HOT inline nl_double Ieq() const { return (m_Id - m_Vd * m_G); }
242		ATTR_HOT inline nl_double Vd() const { return m_Vd; }
	239	ATTR_HOT inline double I() const { return m_Id; }
	240	ATTR_HOT inline double G() const { return m_G; }
	241	ATTR_HOT inline double Ieq() const { return (m_Id - m_Vd * m_G); }
	242	ATTR_HOT inline double Vd() const { return m_Vd; }
243	243
244	244	/* owning object must save those ... */
245	245
246	246	ATTR_COLD void save(pstring name, netlist_object_t &parent);
247	247
248	248	private:
249		nl_double m_Vd;
250		nl_double m_Id;
251		nl_double m_G;
	249	double m_Vd;
	250	double m_Id;
	251	double m_G;
252	252
253		nl_double m_Vt;
254		nl_double m_Is;
255		nl_double m_n;
256		nl_double m_gmin;
	253	double m_Vt;
	254	double m_Is;
	255	double m_n;
	256	double m_gmin;
257	257
258		nl_double m_VtInv;
259		nl_double m_Vcrit;
	258	double m_VtInv;
	259	double m_Vcrit;
260	260	};
261	261
262	262	// ----------------------------------------------------------------------------------------
r242990	r242991
268	268	// add c3 and it'll be better than 1%
269	269
270	270	#if 0
271		inline nl_double fastexp_h(const nl_double x)
	271	inline double fastexp_h(const double x)
272	272	{
273		static const nl_double ln2r = 1.442695040888963387;
274		static const nl_double ln2  = 0.693147180559945286;
275		//static const nl_double c3   = 0.166666666666666667;
	273	static const double ln2r = 1.442695040888963387;
	274	static const double ln2  = 0.693147180559945286;
	275	//static const double c3   = 0.166666666666666667;
276	276
277		const nl_double y = x * ln2r;
	277	const double y = x * ln2r;
278	278	const unsigned int t = y;
279		const nl_double z = (x - ln2 * (double) t);
280		const nl_double zz = z * z;
281		//const nl_double zzz = zz * z;
	279	const double z = (x - ln2 * (double) t);
	280	const double zz = z * z;
	281	//const double zzz = zz * z;
282	282
283	283	return (double)(1 << t)*(1.0 + z + 0.5 * zz); // + c3*zzz;
284	284	}
285	285
286		inline nl_double fastexp(const nl_double x)
	286	inline double fastexp(const double x)
287	287	{
288	288	if (x<0)
289	289	return 1.0 / fastexp_h(-x);

trunk/src/emu/netlist/devices/net_lib.c

r242990	r242991
49	49
50	50	#include "net_lib.h"
51	51	#include "nld_system.h"
52		#include "../nl_factory.h"
53	52
54	53	NETLIST_START(diode_models)
55	54	NET_MODEL(".model 1N914 D(Is=2.52n Rs=.568 N=1.752 Cjo=4p M=.4 tt=20n Iave=200m Vpk=75 mfg=OnSemi type=silicon)")
r242990	r242991
65	64
66	65
67	66	#define xstr(s) # s
68		#define ENTRY1(_nic, _name, _defparam) factory.register_device<_nic>( # _name, xstr(_nic), _defparam );
	67	#define ENTRY1(_nic, _name, _defparam) register_device<_nic>( # _name, xstr(_nic), _defparam );
69	68	#define ENTRY(_nic, _name, _defparam) ENTRY1(NETLIB_NAME(_nic), _name, _defparam)
70	69
71		void nl_initialize_factory(netlist_factory_t &factory)
	70	netlist_factory_t::netlist_factory_t()
72	71	{
	72	}
	73
	74	netlist_factory_t::~netlist_factory_t()
	75	{
	76	for (net_device_t_base_factory * const *e = m_list.first(); e != NULL; e = m_list.next(e))
	77	{
	78	net_device_t_base_factory *p = *e;
	79	delete p;
	80	}
	81	m_list.clear();
	82	}
	83
	84	void netlist_factory_t::initialize()
	85	{
73	86	ENTRY(R,                    RES,                    "R")
74	87	ENTRY(POT,                  POT,                    "R")
75	88	ENTRY(C,                    CAP,                    "C")
r242990	r242991
149	162	ENTRY(NE555_dip,            NE555_DIP,              "-")
150	163	}
151	164
	165	netlist_device_t *netlist_factory_t::new_device_by_classname(const pstring &classname, netlist_setup_t &setup) const
	166	{
	167	for (net_device_t_base_factory * const *e = m_list.first(); e != NULL; e = m_list.next(e))
	168	{
	169	net_device_t_base_factory *p = *e;
	170	if (strcmp(p->classname(), classname) == 0)
	171	{
	172	netlist_device_t *ret = p->Create();
	173	return ret;
	174	}
	175	p++;
	176	}
	177	setup.netlist().error("Class %s not found!\n", classname.cstr());
	178	return NULL; // appease code analysis
	179	}
	180
	181	netlist_device_t *netlist_factory_t::new_device_by_name(const pstring &name, netlist_setup_t &setup) const
	182	{
	183	net_device_t_base_factory *f = factory_by_name(name, setup);
	184	return f->Create();
	185	}
	186
	187	net_device_t_base_factory * netlist_factory_t::factory_by_name(const pstring &name, netlist_setup_t &setup) const
	188	{
	189	for (net_device_t_base_factory * const *e = m_list.first(); e != NULL; e = m_list.next(e))
	190	{
	191	net_device_t_base_factory *p = *e;
	192	if (strcmp(p->name(), name) == 0)
	193	{
	194	return p;
	195	}
	196	p++;
	197	}
	198	setup.netlist().error("Class %s not found!\n", name.cstr());
	199	return NULL; // appease code analysis
	200	}

trunk/src/emu/netlist/devices/net_lib.h

r242990	r242991
99	99	NETLIST_EXTERNAL(diode_models);
100	100	NETLIST_EXTERNAL(bjt_models);
101	101
102		void nl_initialize_factory(netlist_factory_t &factory);
103
104	102	#endif

trunk/src/emu/netlist/devices/nld_4020.c

r242990	r242991
51	51	register_output("Q13", m_Q[12]);
52	52	register_output("Q14", m_Q[13]);
53	53
54		save(NLNAME(m_cnt));
	54	save(NAME(m_cnt));
55	55	}
56	56
57	57	NETLIB_RESET(4020_sub)
r242990	r242991
125	125	register_subalias("7", sub.m_Q[3]);
126	126	register_subalias("8", m_supply.m_vss);
127	127
128		register_subalias("9", sub.m_Q[0]);
	128	register_subalias("9", sub.m_Q[1]);
129	129	register_subalias("10", sub.m_IP);
130	130	register_subalias("11", m_RESET);
131	131	register_subalias("12", sub.m_Q[8]);

trunk/src/emu/netlist/devices/nld_4066.c

r242990	r242991
19	19
20	20	NETLIB_UPDATE(4066)
21	21	{
22		nl_double sup = (m_supply.get()->vdd() - m_supply.get()->vss());
23		nl_double low = 0.45 * sup;
24		nl_double high = 0.55 * sup;
25		nl_double in = INPANALOG(m_control) - m_supply.get()->vss();
26		nl_double rON = 270.0 * 5.0 / sup;
	22	double sup = (m_supply.get()->vdd() - m_supply.get()->vss());
	23	double low = 0.45 * sup;
	24	double high = 0.55 * sup;
	25	double in = INPANALOG(m_control) - m_supply.get()->vss();
	26	double rON = 270.0 * 5.0 / sup;
27	27
28	28	if (in < low)
29	29	{
r242990	r242991
53	53	register_subalias("4", m_B.m_R.m_N);
54	54	register_subalias("5", m_B.m_control);
55	55	register_subalias("6", m_C.m_control);
56		register_subalias("7", m_supply.m_vss);
	56	register_input("7", m_supply.m_vss);
57	57
58	58	register_subalias("8", m_C.m_R.m_P);
59	59	register_subalias("9", m_C.m_R.m_N);
r242990	r242991
61	61	register_subalias("11", m_D.m_R.m_N);
62	62	register_subalias("12", m_D.m_control);
63	63	register_subalias("13", m_A.m_control);
64		register_subalias("14", m_supply.m_vdd);
	64	register_input("14", m_supply.m_vdd);
65	65
66	66	}
67	67

trunk/src/emu/netlist/devices/nld_74107.c

r242990	r242991
11	11	register_output("Q", m_Q);
12	12	register_output("QQ", m_QQ);
13	13
14		save(NLNAME(m_Q1));
15		save(NLNAME(m_Q2));
16		save(NLNAME(m_F));
	14	save(NAME(m_Q1));
	15	save(NAME(m_Q2));
	16	save(NAME(m_F));
17	17	}
18	18
19	19	NETLIB_RESET(74107Asub)

trunk/src/emu/netlist/devices/nld_74123.c

r242990	r242991
32	32	connect(m_RN.m_P, m_RP.m_N);
33	33	connect(m_CV, m_RN.m_P);
34	34
35		save(NLNAME(m_last_trig));
36		save(NLNAME(m_state));
37		save(NLNAME(m_KP));
	35	save(NAME(m_last_trig));
	36	save(NAME(m_state));
	37	save(NAME(m_KP));
38	38
39	39	m_KP = 1.0 / (1.0 + exp(m_K.Value()));
40	40	}
r242990	r242991
69	69
70	70	if (m_state == 1)
71	71	{
72		const nl_double vLow = m_KP * TERMANALOG(m_RP.m_P);
	72	const double vLow = m_KP * TERMANALOG(m_RP.m_P);
73	73	if (INPANALOG(m_CV) < vLow)
74	74	{
75	75	m_RN.set_R(R_OFF);
r242990	r242991
78	78	}
79	79	else if (m_state == 2)
80	80	{
81		const nl_double vHigh = TERMANALOG(m_RP.m_P) * (1.0 - m_KP);
	81	const double vHigh = TERMANALOG(m_RP.m_P) * (1.0 - m_KP);
82	82	if (INPANALOG(m_CV) > vHigh)
83	83	{
84	84	m_RP.set_R(R_OFF);

trunk/src/emu/netlist/devices/nld_74153.c

r242990	r242991
22	22
23	23	m_chan = 0;
24	24
25		save(NLNAME(m_chan));
	25	save(NAME(m_chan));
26	26	}
27	27
28	28	NETLIB_RESET(74153sub)

trunk/src/emu/netlist/devices/nld_7448.c

r242990	r242991
78	78	register_output("f", m_f);
79	79	register_output("g", m_g);
80	80
81		save(NLNAME(m_state));
	81	save(NAME(m_state));
82	82	}
83	83
84	84	NETLIB_RESET(7448_sub)
r242990	r242991
98	98
99	99	NETLIB_FUNC_VOID(7448_sub, update_outputs, (UINT8 v))
100	100	{
101		nl_assert(v<16);
	101	assert(v<16);
102	102	if (v != m_state)
103	103	{
104	104	// max transfer time is 100 NS */

trunk/src/emu/netlist/devices/nld_7474.c

r242990	r242991
76	76	register_output("Q",   m_Q);
77	77	register_output("QQ",  m_QQ);
78	78
79		save(NLNAME(m_nextD));
	79	save(NAME(m_nextD));
80	80	}
81	81
82	82	NETLIB_RESET(7474sub)

trunk/src/emu/netlist/devices/nld_7483.c

r242990	r242991
23	23	register_output("S4", m_S4);
24	24	register_output("C4", m_C4);
25	25
26		save(NLNAME(m_lastr));
	26	save(NAME(m_lastr));
27	27	}
28	28
29	29	NETLIB_RESET(7483)

trunk/src/emu/netlist/devices/nld_7490.c

r242990	r242991
19	19	register_output("QC", m_Q[2]);
20	20	register_output("QD", m_Q[3]);
21	21
22		save(NLNAME(m_cnt));
23		save(NLNAME(m_last_A));
24		save(NLNAME(m_last_B));
	22	save(NAME(m_cnt));
	23	save(NAME(m_last_A));
	24	save(NAME(m_last_B));
25	25
26	26	}
27	27

trunk/src/emu/netlist/devices/nld_7493.c

r242990	r242991
40	40	register_input("CLK", m_I);
41	41	register_output("Q", m_Q);
42	42
43		save(NLNAME(m_reset));
	43	save(NAME(m_reset));
44	44	}
45	45
46	46	NETLIB_RESET(7493ff)

trunk/src/emu/netlist/devices/nld_74ls629.c

r242990	r242991
49	49
50	50	reset();
51	51
52		save(NLNAME(m_enableq));
53		save(NLNAME(m_inc));
54		save(NLNAME(m_out));
	52	save(NAME(m_enableq));
	53	save(NAME(m_inc));
	54	save(NAME(m_out));
55	55	}
56	56
57	57	NETLIB_RESET(SN74LS629clk)
r242990	r242991
104	104	{
105	105	{
106	106	// recompute
107		nl_double  freq;
108		nl_double  v_freq_2, v_freq_3, v_freq_4;
109		nl_double  v_freq = INPANALOG(m_FC);
110		nl_double  v_rng = INPANALOG(m_RNG);
	107	double  freq;
	108	double  v_freq_2, v_freq_3, v_freq_4;
	109	double  v_freq = INPANALOG(m_FC);
	110	double  v_rng = INPANALOG(m_RNG);
111	111
112	112	/* coefficients */
113		const nl_double k1 = 1.9904769024796283E+03;
114		const nl_double k2 = 1.2070059213983407E+03;
115		const nl_double k3 = 1.3266985579561108E+03;
116		const nl_double k4 = -1.5500979825922698E+02;
117		const nl_double k5 = 2.8184536266938172E+00;
118		const nl_double k6 = -2.3503421582744556E+02;
119		const nl_double k7 = -3.3836786704527788E+02;
120		const nl_double k8 = -1.3569136703258670E+02;
121		const nl_double k9 = 2.9914575453819188E+00;
122		const nl_double k10 = 1.6855569086173170E+00;
	113	const double k1 = 1.9904769024796283E+03;
	114	const double k2 = 1.2070059213983407E+03;
	115	const double k3 = 1.3266985579561108E+03;
	116	const double k4 = -1.5500979825922698E+02;
	117	const double k5 = 2.8184536266938172E+00;
	118	const double k6 = -2.3503421582744556E+02;
	119	const double k7 = -3.3836786704527788E+02;
	120	const double k8 = -1.3569136703258670E+02;
	121	const double k9 = 2.9914575453819188E+00;
	122	const double k10 = 1.6855569086173170E+00;
123	123
124	124	/* scale due to input resistance */
125	125

trunk/src/emu/netlist/devices/nld_9316.c

r242990	r242991
73	73	register_output("QD", m_QD);
74	74	register_output("RC", m_RC);
75	75
76		save(NLNAME(m_cnt.ref()));
77		save(NLNAME(m_loadq.ref()));
78		save(NLNAME(m_ent.ref()));
	76	save(NAME(m_cnt.ref()));
	77	save(NAME(m_loadq.ref()));
	78	save(NAME(m_ent.ref()));
79	79	}
80	80
81	81	NETLIB_RESET(9316_sub)

trunk/src/emu/netlist/devices/nld_cmos.h

r242990	r242991
29	29	ATTR_HOT void reset()  {};
30	30
31	31	public:
32		ATTR_HOT inline nl_double vdd() { return INPANALOG(m_vdd); }
33		ATTR_HOT inline nl_double vss() { return INPANALOG(m_vss); }
	32	ATTR_HOT inline double vdd() { return INPANALOG(m_vdd); }
	33	ATTR_HOT inline double vss() { return INPANALOG(m_vss); }
34	34	};
35	35
36	36	#endif /* NLD_CMOS_H_ */

trunk/src/emu/netlist/devices/nld_ne555.c

r242990	r242991
10	10	#define R_OFF (1E20)
11	11	#define R_ON (25)   // Datasheet states a maximum discharge of 200mA, R = 5V / 0.2
12	12
13		inline nl_double NETLIB_NAME(NE555)::clamp(const nl_double v, const nl_double a, const nl_double b)
	13	inline double NETLIB_NAME(NE555)::clamp(const double v, const double a, const double b)
14	14	{
15		nl_double ret = v;
16		nl_double vcc = TERMANALOG(m_R1.m_P);
	15	double ret = v;
	16	double vcc = TERMANALOG(m_R1.m_P);
17	17
18	18	if (ret >  vcc - a)
19	19	ret = vcc - a;
r242990	r242991
42	42	connect(m_R2.m_N, m_R3.m_P);
43	43	connect(m_RDIS.m_N, m_R3.m_N);
44	44
45		save(NLNAME(m_last_out));
	45	save(NAME(m_last_out));
46	46	}
47	47
48	48	NETLIB_RESET(NE555)
r242990	r242991
64	64	{
65	65	// FIXME: assumes GND is connected to 0V.
66	66
67		nl_double vt = clamp(TERMANALOG(m_R2.m_P), 0.7, 1.4);
	67	double vt = clamp(TERMANALOG(m_R2.m_P), 0.7, 1.4);
68	68	bool bthresh = (INPANALOG(m_THRES) > vt);
69	69	bool btrig = (INPANALOG(m_TRIG) > clamp(TERMANALOG(m_R2.m_N), 0.7, 1.4));
70	70	bool out = m_last_out;

trunk/src/emu/netlist/devices/nld_ne555.h

r242990	r242991
39	39
40	40	netlist_state_t<bool> m_last_out;
41	41
42		inline nl_double clamp(const nl_double v, const nl_double a, const nl_double b);
	42	inline double clamp(const double v, const double a, const double b);
43	43
44	44	);
45	45

trunk/src/emu/netlist/devices/nld_r2r_dac.c

r242990	r242991
32	32
33	33	update_dev();
34	34
35		nl_double V = m_VIN.Value() / (double) (1 << m_num.Value()) * (double) m_val.Value();
	35	double V = m_VIN.Value() / (double) (1 << m_num.Value()) * (double) m_val.Value();
36	36
37	37	this->set(1.0 / m_R.Value(), V, 0.0);
38	38	}

trunk/src/emu/netlist/devices/nld_signal.h

r242990	r242991
44	44	{
45	45	register_input(sIN[i], m_i[i]);
46	46	}
47		save(NLNAME(m_active));
	47	save(NAME(m_active));
48	48	}
49	49
50	50	ATTR_COLD void reset()
r242990	r242991
118	118	register_input("A", m_i[0]);
119	119	register_input("B", m_i[1]);
120	120
121		save(NLNAME(m_active));
	121	save(NAME(m_active));
122	122	}
123	123
124	124	ATTR_COLD void reset()

trunk/src/emu/netlist/devices/nld_system.c

r242990	r242991
118	118	if (state != m_last_state)
119	119	{
120	120	m_last_state = state;
121		const nl_double R = state ? m_logic_family->m_R_high : m_logic_family->m_R_low;
122		const nl_double V = state ? m_logic_family->m_high_V : m_logic_family->m_low_V;
	121	const double R = state ? m_logic_family->m_R_high : m_logic_family->m_R_low;
	122	const double V = state ? m_logic_family->m_high_V : m_logic_family->m_low_V;
123	123
124	124	// We only need to update the net first if this is a time stepping net
125	125	if (m_RV.m_P.net().as_analog().solver()->is_timestep())

trunk/src/emu/netlist/devices/nld_system.h

r242990	r242991
198	198	ATTR_COLD nld_a_to_d_proxy(netlist_input_t &in_proxied)
199	199	: netlist_device_t()
200	200	{
201		nl_assert(in_proxied.family() == LOGIC);
	201	assert(in_proxied.family() == LOGIC);
202	202	m_I.m_logic_family = in_proxied.m_logic_family;
203	203	}
204	204
r242990	r242991
240	240	ATTR_COLD nld_base_d_to_a_proxy(netlist_output_t &out_proxied)
241	241	: netlist_device_t()
242	242	{
243		nl_assert(out_proxied.family() == LOGIC);
	243	assert(out_proxied.family() == LOGIC);
244	244	m_logic_family = out_proxied.m_logic_family;
245	245	}
246	246

trunk/src/emu/netlist/devices/nld_truthtable.h

r242990	r242991
50	50	{
51	51	nl_util::pstring_list io = nl_util::split(ttline,"|");
52	52	// checks
53		nl_assert(io.count() == 2);
	53	assert(io.count() == 2);
54	54	nl_util::pstring_list inout = nl_util::split(io[0], ",");
55		nl_assert(inout.count() == m_num_bits);
	55	assert(inout.count() == m_num_bits);
56	56	nl_util::pstring_list out = nl_util::split(io[1], ",");
57		nl_assert(out.count() == m_NO);
	57	assert(out.count() == m_NO);
58	58
59	59	for (int i=0; i < m_NI; i++)
60	60	{
r242990	r242991
133	133	{
134	134	nl_util::pstring_list io = nl_util::split(ttline,"|");
135	135	// checks
136		nl_assert(io.count() == 3);
	136	assert(io.count() == 3);
137	137	nl_util::pstring_list inout = nl_util::split(io[0], ",");
138		nl_assert(inout.count() == m_num_bits);
	138	assert(inout.count() == m_num_bits);
139	139	nl_util::pstring_list out = nl_util::split(io[1], ",");
140		nl_assert(out.count() == m_NO);
	140	assert(out.count() == m_NO);
141	141	nl_util::pstring_list times = nl_util::split(io[2], ",");
142		nl_assert(times.count() == m_NO);
	142	assert(times.count() == m_NO);
143	143
144	144	UINT16 val = 0;
145	145	UINT8 tindex[m_NO];

trunk/src/emu/netlist/netlist.mak

r242990	r242991
26	26	$(NETLISTOBJ)/nl_base.o \
27	27	$(NETLISTOBJ)/nl_parser.o \
28	28	$(NETLISTOBJ)/nl_setup.o \
29		$(NETLISTOBJ)/nl_factory.o \
30	29	$(NETLISTOBJ)/pstring.o \
31	30	$(NETLISTOBJ)/pstate.o \
32	31	$(NETLISTOBJ)/analog/nld_bjt.o \

trunk/src/emu/netlist/nl_base.c

r242990	r242991
9	9	#include "pstring.h"
10	10	#include "nl_util.h"
11	11
12		#include <stdlib.h> // FIXME: only included for atof
13
14	12	const netlist_time netlist_time::zero = netlist_time::from_raw(0);
15	13
16	14	netlist_logic_family_desc_t netlist_family_TTL =
r242990	r242991
152	150	{
153	151	if (!m_nets[i]->isRailNet())
154	152	{
155		global_free(m_nets[i]);
	153	delete m_nets[i];
156	154	}
157	155	}
158	156
r242990	r242991
166	164	ATTR_COLD void netlist_base_t::save_register()
167	165	{
168	166	save(static_cast<pstate_callback_t &>(m_queue), "m_queue");
169		save(NLNAME(m_time));
	167	save(NAME(m_time));
170	168	netlist_object_t::save_register();
171	169	}
172	170
173		ATTR_HOT const nl_double netlist_base_t::gmin() const
	171	ATTR_HOT const double netlist_base_t::gmin() const
174	172	{
175	173	return solver()->gmin();
176	174	}
r242990	r242991
452	450	}
453	451
454	452	template ATTR_COLD void netlist_device_t::register_param(const pstring &sname, netlist_param_double_t &param, const double initialVal);
455		template ATTR_COLD void netlist_device_t::register_param(const pstring &sname, netlist_param_double_t &param, const float initialVal);
456	453	template ATTR_COLD void netlist_device_t::register_param(const pstring &sname, netlist_param_int_t &param, const int initialVal);
457	454	template ATTR_COLD void netlist_device_t::register_param(const pstring &sname, netlist_param_logic_t &param, const int initialVal);
458	455	template ATTR_COLD void netlist_device_t::register_param(const pstring &sname, netlist_param_str_t &param, const char * const initialVal);
r242990	r242991
532	529
533	530	ATTR_COLD void netlist_net_t::register_railterminal(netlist_output_t &mr)
534	531	{
535		nl_assert(m_railterminal == NULL);
	532	assert(m_railterminal == NULL);
536	533	m_railterminal = &mr;
537	534	}
538	535
r242990	r242991
548	545
549	546	ATTR_COLD void netlist_net_t::save_register()
550	547	{
551		save(NLNAME(m_time));
552		save(NLNAME(m_active));
553		save(NLNAME(m_in_queue));
554		save(NLNAME(m_cur_Analog));
555		save(NLNAME(m_cur_Q));
556		save(NLNAME(m_new_Q));
	548	save(NAME(m_time));
	549	save(NAME(m_active));
	550	save(NAME(m_in_queue));
	551	save(NAME(m_cur_Analog));
	552	save(NAME(m_cur_Q));
	553	save(NAME(m_new_Q));
557	554	netlist_object_t::save_register();
558	555	}
559	556
r242990	r242991
572	569	ATTR_HOT ATTR_ALIGN inline void netlist_net_t::update_devs()
573	570	{
574	571	//assert(m_num_cons != 0);
575		nl_assert(this->isRailNet());
	572	assert(this->isRailNet());
576	573
577	574	const UINT32 masks[4] = { 1, 5, 3, 1 };
578	575	const UINT32 mask = masks[ (m_cur_Q  << 1) | m_new_Q ];
r242990	r242991
710	707
711	708	ATTR_COLD void netlist_analog_net_t::save_register()
712	709	{
713		save(NLNAME(m_DD_n_m_1));
714		save(NLNAME(m_h_n_m_1));
	710	save(NAME(m_DD_n_m_1));
	711	save(NAME(m_h_n_m_1));
715	712	netlist_net_t::save_register();
716	713	}
717	714
r242990	r242991
806	803
807	804	ATTR_COLD void netlist_terminal_t::save_register()
808	805	{
809		save(NLNAME(m_Idr1));
810		save(NLNAME(m_go1));
811		save(NLNAME(m_gt1));
	806	save(NAME(m_Idr1));
	807	save(NAME(m_go1));
	808	save(NAME(m_gt1));
812	809	netlist_core_terminal_t::save_register();
813	810	}
814	811
r242990	r242991
875	872	net().as_analog().m_cur_Analog = 0.98;
876	873	}
877	874
878		ATTR_COLD void netlist_analog_output_t::initial(const nl_double val)
	875	ATTR_COLD void netlist_analog_output_t::initial(const double val)
879	876	{
880	877	net().as_analog().m_cur_Analog = val * 0.99;
881	878	}
r242990	r242991
932	929	}
933	930
934	931
935		ATTR_COLD nl_double netlist_param_model_t::model_value(const pstring &entity, const nl_double defval) const
	932	ATTR_COLD double netlist_param_model_t::model_value(const pstring &entity, const double defval) const
936	933	{
937	934	pstring tmp = this->Value();
938	935	// .model 1N914 D(Is=2.52n Rs=.568 N=1.752 Cjo=4p M=.4 tt=20n Iave=200m Vpk=75 mfg=OnSemi type=silicon)
r242990	r242991
946	943	if (pequal < 0)
947	944	netlist().error("parameter %s misformat in model %s temp %s\n", entity.cstr(), Value().cstr(), tmp.cstr());
948	945	tmp = tmp.substr(pequal+1);
949		nl_double factor = 1.0;
	946	double factor = 1.0;
950	947	switch (*(tmp.right(1).cstr()))
951	948	{
952	949	case 'm': factor = 1e-3; break;
r242990	r242991
1002	999	net.set_time(netlist().time() + m_inc);
1003	1000	}
1004	1001
	1002	// ----------------------------------------------------------------------------------------
	1003	// net_device_t_base_factory
	1004	// ----------------------------------------------------------------------------------------
	1005
	1006	ATTR_COLD const nl_util::pstring_list net_device_t_base_factory::term_param_list()
	1007	{
	1008	if (m_def_param.startsWith("+"))
	1009	return nl_util::split(m_def_param.substr(1), ",");
	1010	else
	1011	return nl_util::pstring_list();
	1012	}
	1013
	1014	ATTR_COLD const nl_util::pstring_list net_device_t_base_factory::def_params()
	1015	{
	1016	if (m_def_param.startsWith("+") || m_def_param.equals("-"))
	1017	return nl_util::pstring_list();
	1018	else
	1019	return nl_util::split(m_def_param, ",");
	1020	}

trunk/src/emu/netlist/nl_base.h

r242990	r242991
272	272
273	273	struct netlist_logic_family_desc_t
274	274	{
275		nl_double m_low_thresh_V;
276		nl_double m_high_thresh_V;
277		nl_double m_low_V;
278		nl_double m_high_V;
279		nl_double m_R_low;
280		nl_double m_R_high;
	275	double m_low_thresh_V;
	276	double m_high_thresh_V;
	277	double m_low_V;
	278	double m_high_V;
	279	double m_R_low;
	280	double m_R_high;
281	281	};
282	282
283	283	/* Terminals inherit the family description from the netlist_device
r242990	r242991
444	444	ATTR_HOT inline const state_e state() const { return m_state; }
445	445	ATTR_HOT inline void set_state(const state_e astate)
446	446	{
447		nl_assert(astate != STATE_NONEX);
	447	assert(astate != STATE_NONEX);
448	448	m_state = astate;
449	449	}
450	450
r242990	r242991
453	453	protected:
454	454	ATTR_COLD virtual void save_register()
455	455	{
456		save(NLNAME(m_state));
	456	save(NAME(m_state));
457	457	netlist_owned_object_t::save_register();
458	458	}
459	459
r242990	r242991
474	474
475	475	ATTR_COLD netlist_terminal_t();
476	476
477		nl_double *m_Idr1; // drive current
478		nl_double *m_go1;  // conductance for Voltage from other term
479		nl_double *m_gt1;  // conductance for total conductance
	477	double *m_Idr1; // drive current
	478	double *m_go1;  // conductance for Voltage from other term
	479	double *m_gt1;  // conductance for total conductance
480	480
481		ATTR_HOT inline void set(const nl_double G)
	481	ATTR_HOT inline void set(const double G)
482	482	{
483	483	set_ptr(m_Idr1, 0);
484	484	set_ptr(m_go1, G);
485	485	set_ptr(m_gt1, G);
486	486	}
487	487
488		ATTR_HOT inline void set(const nl_double GO, const nl_double GT)
	488	ATTR_HOT inline void set(const double GO, const double GT)
489	489	{
490	490	set_ptr(m_Idr1, 0);
491	491	set_ptr(m_go1, GO);
492	492	set_ptr(m_gt1, GT);
493	493	}
494	494
495		ATTR_HOT inline void set(const nl_double GO, const nl_double GT, const nl_double I)
	495	ATTR_HOT inline void set(const double GO, const double GT, const double I)
496	496	{
497	497	set_ptr(m_Idr1, I);
498	498	set_ptr(m_go1, GO);
r242990	r242991
509	509
510	510	ATTR_COLD virtual void reset();
511	511	private:
512		inline void set_ptr(nl_double *ptr, const nl_double val)
	512	inline void set_ptr(double *ptr, const double val)
513	513	{
514	514	if (ptr != NULL)
515	515	*ptr = val;
r242990	r242991
586	586	ATTR_COLD netlist_analog_input_t()
587	587	: netlist_input_t(INPUT, ANALOG) { }
588	588
589		ATTR_HOT inline const nl_double Q_Analog() const;
	589	ATTR_HOT inline const double Q_Analog() const;
590	590	};
591	591
592	592	//#define INPVAL(_x) (_x).Q()
r242990	r242991
661	661	// We have to have those on one object. Dividing those does lead
662	662	// to a significant performance hit
663	663	// FIXME: Have to fix the public at some time
664		nl_double m_cur_Analog;
	664	double m_cur_Analog;
665	665
666	666	};
667	667
r242990	r242991
710	710	*/
711	711	ATTR_COLD inline netlist_sig_t &Q_state_ptr()
712	712	{
713		nl_assert(family() == LOGIC);
	713	assert(family() == LOGIC);
714	714	return m_cur_Q;
715	715	}
716	716
r242990	r242991
736	736	ATTR_COLD netlist_analog_net_t();
737	737	ATTR_COLD virtual ~netlist_analog_net_t() { };
738	738
739		ATTR_HOT inline const nl_double Q_Analog() const
	739	ATTR_HOT inline const double Q_Analog() const
740	740	{
741		//nl_assert(object_type(SIGNAL_MASK) == SIGNAL_ANALOG);
742		nl_assert(family() == ANALOG);
	741	//assert(object_type(SIGNAL_MASK) == SIGNAL_ANALOG);
	742	assert(family() == ANALOG);
743	743	return m_cur_Analog;
744	744	}
745	745
746		ATTR_COLD inline nl_double &Q_Analog_state_ptr()
	746	ATTR_COLD inline double &Q_Analog_state_ptr()
747	747	{
748		//nl_assert(object_type(SIGNAL_MASK) == SIGNAL_ANALOG);
749		nl_assert(family() == ANALOG);
	748	//assert(object_type(SIGNAL_MASK) == SIGNAL_ANALOG);
	749	assert(family() == ANALOG);
750	750	return m_cur_Analog;
751	751	}
752	752
r242990	r242991
764	764	private:
765	765
766	766	public:
767		nl_double m_DD_n_m_1;
768		nl_double m_h_n_m_1;
	767	double m_DD_n_m_1;
	768	double m_h_n_m_1;
769	769
770	770	//FIXME: needed by current solver code
771	771	netlist_matrix_solver_t *m_solver;
r242990	r242991
831	831
832	832	ATTR_COLD netlist_analog_output_t();
833	833
834		ATTR_COLD void initial(const nl_double val);
	834	ATTR_COLD void initial(const double val);
835	835
836		ATTR_HOT inline void set_Q(const nl_double newQ);
	836	ATTR_HOT inline void set_Q(const double newQ);
837	837
838	838	netlist_analog_net_t *m_proxied_net; // only for proxy nets in analog input logic
839	839
r242990	r242991
876	876	public:
877	877	ATTR_COLD netlist_param_double_t();
878	878
879		ATTR_HOT inline void setTo(const nl_double param);
880		ATTR_COLD inline void initial(const nl_double val) { m_param = val; }
881		ATTR_HOT inline const nl_double Value() const        { return m_param;   }
	879	ATTR_HOT inline void setTo(const double param);
	880	ATTR_COLD inline void initial(const double val) { m_param = val; }
	881	ATTR_HOT inline const double Value() const        { return m_param;   }
882	882
883	883	protected:
884	884	ATTR_COLD virtual void save_register()
885	885	{
886		save(NLNAME(m_param));
	886	save(NAME(m_param));
887	887	netlist_param_t::save_register();
888	888	}
889	889
890	890	private:
891		nl_double m_param;
	891	double m_param;
892	892	};
893	893
894	894	class netlist_param_int_t : public netlist_param_t
r242990	r242991
905	905	protected:
906	906	ATTR_COLD virtual void save_register()
907	907	{
908		save(NLNAME(m_param));
	908	save(NAME(m_param));
909	909	netlist_param_t::save_register();
910	910	}
911	911
r242990	r242991
946	946	ATTR_HOT inline const pstring &Value() const     { return m_param;     }
947	947
948	948	/* these should be cached! */
949		ATTR_COLD nl_double model_value(const pstring &entity, const nl_double defval = 0.0) const;
	949	ATTR_COLD double model_value(const pstring &entity, const double defval = 0.0) const;
950	950	ATTR_COLD const pstring model_type() const;
951	951
952	952	private:
r242990	r242991
988	988
989	989	ATTR_HOT inline const netlist_sig_t INPLOGIC(const netlist_logic_input_t &inp) const
990	990	{
991		nl_assert(inp.state() != netlist_input_t::STATE_INP_PASSIVE);
	991	assert(inp.state() != netlist_input_t::STATE_INP_PASSIVE);
992	992	return inp.Q();
993	993	}
994	994
r242990	r242991
997	997	out.set_Q(val, delay);
998	998	}
999	999
1000		ATTR_HOT inline const nl_double INPANALOG(const netlist_analog_input_t &inp) const { return inp.Q_Analog(); }
	1000	ATTR_HOT inline const double INPANALOG(const netlist_analog_input_t &inp) const { return inp.Q_Analog(); }
1001	1001
1002		ATTR_HOT inline const nl_double TERMANALOG(const netlist_terminal_t &term) const { return term.net().as_analog().Q_Analog(); }
	1002	ATTR_HOT inline const double TERMANALOG(const netlist_terminal_t &term) const { return term.net().as_analog().Q_Analog(); }
1003	1003
1004		ATTR_HOT inline void OUTANALOG(netlist_analog_output_t &out, const nl_double val)
	1004	ATTR_HOT inline void OUTANALOG(netlist_analog_output_t &out, const double val)
1005	1005	{
1006	1006	out.set_Q(val);
1007	1007	}
r242990	r242991
1010	1010
1011	1011	ATTR_HOT virtual void dec_active() {  }
1012	1012
1013		ATTR_HOT virtual void step_time(const nl_double st) { }
	1013	ATTR_HOT virtual void step_time(const double st) { }
1014	1014	ATTR_HOT virtual void update_terminals() { }
1015	1015
1016	1016
r242990	r242991
1120	1120	ATTR_HOT inline const netlist_time time() const { return m_time; }
1121	1121	ATTR_HOT inline NETLIB_NAME(solver) *solver() const { return m_solver; }
1122	1122	ATTR_HOT inline NETLIB_NAME(gnd) *gnd() const { return m_gnd; }
1123		ATTR_HOT const nl_double gmin() const;
	1123	ATTR_HOT const double gmin() const;
1124	1124
1125	1125	ATTR_HOT inline void push_to_queue(netlist_net_t *out, const netlist_time attime)
1126	1126	{
r242990	r242991
1251	1251	}
1252	1252	}
1253	1253
1254		ATTR_HOT inline void netlist_param_double_t::setTo(const nl_double param)
	1254	ATTR_HOT inline void netlist_param_double_t::setTo(const double param)
1255	1255	{
1256	1256	if (m_param != param)
1257	1257	{
r242990	r242991
1262	1262
1263	1263	ATTR_HOT inline netlist_logic_net_t & RESTRICT netlist_net_t::as_logic()
1264	1264	{
1265		nl_assert(family() == LOGIC);
	1265	assert(family() == LOGIC);
1266	1266	return static_cast<netlist_logic_net_t &>(*this);
1267	1267	}
1268	1268
1269	1269	ATTR_HOT inline const netlist_logic_net_t & RESTRICT netlist_net_t::as_logic() const
1270	1270	{
1271		nl_assert(family() == LOGIC);
	1271	assert(family() == LOGIC);
1272	1272	return static_cast<const netlist_logic_net_t &>(*this);
1273	1273	}
1274	1274
1275	1275	ATTR_HOT inline netlist_analog_net_t & RESTRICT netlist_net_t::as_analog()
1276	1276	{
1277		nl_assert(family() == ANALOG);
	1277	assert(family() == ANALOG);
1278	1278	return static_cast<netlist_analog_net_t &>(*this);
1279	1279	}
1280	1280
1281	1281	ATTR_HOT inline const netlist_analog_net_t & RESTRICT netlist_net_t::as_analog() const
1282	1282	{
1283		nl_assert(family() == ANALOG);
	1283	assert(family() == ANALOG);
1284	1284	return static_cast<const netlist_analog_net_t &>(*this);
1285	1285	}
1286	1286
r242990	r242991
1356	1356	return net().as_logic().Q();
1357	1357	}
1358	1358
1359		ATTR_HOT inline const nl_double netlist_analog_input_t::Q_Analog() const
	1359	ATTR_HOT inline const double netlist_analog_input_t::Q_Analog() const
1360	1360	{
1361	1361	return net().as_analog().Q_Analog();
1362	1362	}
1363	1363
1364		ATTR_HOT inline void netlist_analog_output_t::set_Q(const nl_double newQ)
	1364	ATTR_HOT inline void netlist_analog_output_t::set_Q(const double newQ)
1365	1365	{
1366	1366	if (newQ != net().as_analog().m_cur_Analog)
1367	1367	{
r242990	r242991
1370	1370	}
1371	1371	}
1372	1372
	1373
	1374	// -----------------------------------------------------------------------------
	1375	// net_dev class factory
	1376	// -----------------------------------------------------------------------------
	1377
	1378	class net_device_t_base_factory
	1379	{
	1380	NETLIST_PREVENT_COPYING(net_device_t_base_factory)
	1381	public:
	1382	ATTR_COLD net_device_t_base_factory(const pstring &name, const pstring &classname,
	1383	const pstring &def_param)
	1384	: m_name(name), m_classname(classname), m_def_param(def_param)
	1385	{}
	1386
	1387	ATTR_COLD virtual ~net_device_t_base_factory() {}
	1388
	1389	ATTR_COLD virtual netlist_device_t *Create() const = 0;
	1390
	1391	ATTR_COLD const pstring &name() const { return m_name; }
	1392	ATTR_COLD const pstring &classname() const { return m_classname; }
	1393	ATTR_COLD const pstring &param_desc() const { return m_def_param; }
	1394	ATTR_COLD const nl_util::pstring_list term_param_list();
	1395	ATTR_COLD const nl_util::pstring_list def_params();
	1396
	1397	protected:
	1398	pstring m_name;                             /* device name */
	1399	pstring m_classname;                        /* device class name */
	1400	pstring m_def_param;                        /* default parameter */
	1401	};
	1402
	1403	template <class C>
	1404	class net_device_t_factory : public net_device_t_base_factory
	1405	{
	1406	NETLIST_PREVENT_COPYING(net_device_t_factory)
	1407	public:
	1408	ATTR_COLD net_device_t_factory(const pstring &name, const pstring &classname,
	1409	const pstring &def_param)
	1410	: net_device_t_base_factory(name, classname, def_param) { }
	1411
	1412	ATTR_COLD netlist_device_t *Create() const
	1413	{
	1414	netlist_device_t *r = new C();
	1415	//r->init(setup, name);
	1416	return r;
	1417	}
	1418	};
	1419
	1420	class netlist_factory_t
	1421	{
	1422	public:
	1423	typedef plinearlist_t<net_device_t_base_factory *> list_t;
	1424
	1425	ATTR_COLD netlist_factory_t();
	1426	ATTR_COLD ~netlist_factory_t();
	1427
	1428	ATTR_COLD void initialize();
	1429
	1430	template<class _C>
	1431	ATTR_COLD void register_device(const pstring &name, const pstring &classname,
	1432	const pstring &def_param)
	1433	{
	1434	m_list.add(new net_device_t_factory< _C >(name, classname, def_param) );
	1435	}
	1436
	1437	ATTR_COLD netlist_device_t *new_device_by_classname(const pstring &classname, netlist_setup_t &setup) const;
	1438	ATTR_COLD netlist_device_t *new_device_by_name(const pstring &name, netlist_setup_t &setup) const;
	1439	ATTR_COLD net_device_t_base_factory * factory_by_name(const pstring &name, netlist_setup_t &setup) const;
	1440
	1441	const list_t &list() { return m_list; }
	1442
	1443	private:
	1444	list_t m_list;
	1445
	1446	};
	1447
	1448
1373	1449	#endif /* NLBASE_H_ */

trunk/src/emu/netlist/nl_config.h

r242990	r242991
10	10
11	11	/* FIXME: at some time, make it compile on it's own */
12	12
13		#include "osdcore.h"
14		#include "corealloc.h"
15		#include <math.h>
16		#include <exception>
17		#include <typeinfo>
	13	#include "emu.h"
18	14
19	15	//============================================================
20	16	//  SETUP
r242990	r242991
49	45
50	46	#define NETLIST_GMIN_DEFAULT    (1e-9)
51	47
52		//typedef double   nl_double;
53
54		#define nl_double double
55
56	48	//============================================================
57	49	//  DEBUGGING
58	50	//============================================================
r242990	r242991
110	102	#define end_timing(v)           do { } while (0)
111	103	#endif
112	104
113		// this macro passes an item followed by a string version of itself as two consecutive parameters
114		#define NLNAME(x) x, #x
115	105
116	106	//============================================================
117		//  Exceptions
118		//============================================================
119
120		// emu_fatalerror is a generic fatal exception that provides an error string
121		class nl_fatalerror : public std::exception
122		{
123		public:
124		nl_fatalerror(const char *format, ...) ATTR_PRINTF(2,3)
125		{
126		char text[1024];
127		va_list ap;
128		va_start(ap, format);
129		vsprintf(text, format, ap);
130		va_end(ap);
131		osd_printf_error("%s\n", text);
132		}
133		nl_fatalerror(const char *format, va_list ap)
134		{
135		char text[1024];
136		vsprintf(text, format, ap);
137		osd_printf_error("%s\n", text);
138		}
139		};
140
141		//============================================================
142		//  Memory allocation
143		//============================================================
144
145		#define nl_alloc(T, ...)        global_alloc(T(__VA_ARGS__))
146		#define nl_alloc_array(T, N)    global_alloc_array(T, N)
147
148		#define nl_free(_ptr)           global_free(_ptr)
149		#define nl_free_array(_ptr)     global_free_array(_ptr)
150
151
152		//============================================================
153		//  Asserts
154		//============================================================
155
156		#ifdef MAME_DEBUG
157		#define nl_assert(x)               do { if (!(x)) throw nl_fatalerror("assert: %s:%d: %s", __FILE__, __LINE__, #x); } while (0)
158		#define nl_assert_always(x, msg)   do { if (!(x)) throw nl_fatalerror("Fatal error: %s\nCaused by assert: %s:%d: %s", msg, __FILE__, __LINE__, #x); } while (0)
159		#else
160		#define nl_assert(x)               do { } while (0)
161		//#define assert_always(x, msg)   do { if (!(x)) throw emu_fatalerror("Fatal error: %s (%s:%d)", msg, __FILE__, __LINE__); } while (0)
162		#define nl_assert_always(x, msg)    do { if (!(x)) throw nl_fatalerror("Fatal error: %s\nCaused by assert: %s:%d: %s", msg, __FILE__, __LINE__, #x); } while (0)
163		#endif
164
165		//============================================================
166	107	//  Compiling standalone
167	108	//============================================================
168	109
169	110	// Compiling without mame ?
170	111
171	112	#ifndef ATTR_HOT
172		#warning ATTR_HOT not defined
	113	//#warning ATTR_HOT not defined
173	114
174	115	// standard C includes
175	116	#include <math.h>
r242990	r242991
191	132	#define UNEXPECTED
192	133	#define ATTR_UNUSED             __attribute__((__unused__))
193	134
	135	// this macro passes an item followed by a string version of itself as two consecutive parameters
	136	#define NAME(x) x, #x
	137
194	138	/* 8-bit values */
195	139	typedef unsigned char                       UINT8;
196	140	typedef signed char                         INT8;
r242990	r242991
216	160	#endif
217	161	#endif
218	162
	163	#ifdef MAME_DEBUG
	164	#define assert(x)               do { if (!(x)) throw emu_fatalerror("assert: %s:%d: %s", __FILE__, __LINE__, #x); } while (0)
	165	#define assert_always(x, msg)   do { if (!(x)) throw emu_fatalerror("Fatal error: %s\nCaused by assert: %s:%d: %s", msg, __FILE__, __LINE__, #x); } while (0)
	166	#else
	167	#define assert(x)               do { } while (0)
	168	//#define assert_always(x, msg)   do { if (!(x)) throw emu_fatalerror("Fatal error: %s (%s:%d)", msg, __FILE__, __LINE__); } while (0)
	169	#define assert_always(x, msg)   do { } while (0)
	170	#endif
	171
219	172	/* U64 and S64 are used to wrap long integer constants. */
220	173	#if defined(__GNUC__) || defined(_MSC_VER)
221	174	#define U64(val) val##ULL

trunk/src/emu/netlist/nl_dice_compat.h

r242990	r242991
8	8	#ifndef NL_DICE_COMPAT_H_
9	9	#define NL_DICE_COMPAT_H_
10	10
11		#include "netlist/devices/net_lib.h"
12
13	11	/* --------------------------------------------------------------------
14	12	* Compatibility macros for DICE netlists ...
15	13	* -------------------------------------------------------------------- */
16	14
17		/*
18		* define NETLIST_DEVELOPMENT in IDEs before including this header file
19		* to get compile time errors on unknown devices. This should only be
20		* a temporary support and not be used in commits.
21		*/
	15	//#define CHIP(_n, _t) netlist.register_dev(NET_NEW(_t ## _dip), _n);
	16	#define CHIP(_n, _t) setup.register_dev( new nld_ ## _t ## _dip(), _n);
22	17
23		#ifdef NETLIST_DEVELOPMENT
24		#define CHIP(_n, _t) setup.register_dev( nl_alloc(nld_ ## _t ## _dip), _n);
25		#else
26		#define CHIP(_n, _t) setup.register_dev(NETLIB_NAME_STR(_t ## _dip), _n);
27		#endif
28
29	18	#define CONNECTION( ... ) CONNECTIONY( CONNECTIONX( __VA_ARGS__ ) )
30	19	#define CONNECTIONY(_a) _a
31	20	#define CONNECTIONX(_a, _b, _c, _d) setup.register_link(_a "." # _b, _c "." # _d);
r242990	r242991
41	30	struct Mono555Desc
42	31	{
43	32	public:
44		nl_double r, c;
	33	double r, c;
45	34
46		Mono555Desc(nl_double res, nl_double cap) : r(res), c(cap) { }
	35	Mono555Desc(double res, double cap) : r(res), c(cap) { }
47	36	};
48	37
49	38	struct SeriesRCDesc
50	39	{
51	40	public:
52		nl_double r, c;
	41	double r, c;
53	42
54		SeriesRCDesc(nl_double res, nl_double cap) : r(res), c(cap) { }
	43	SeriesRCDesc(double res, double cap) : r(res), c(cap) { }
55	44	};
56	45
57	46	#define CHIP_555_Mono(_name,  _pdesc)   \

trunk/src/emu/netlist/nl_factory.c

r242990	r242991
1		// license:GPL-2.0+
2		// copyright-holders:Couriersud
3		/***************************************************************************
4
5		nl_factory.c
6
7		Discrete netlist implementation.
8
9		****************************************************************************
10
11		Couriersud reserves the right to license the code under a less restrictive
12		license going forward.
13
14		Copyright Nicola Salmoria and the MAME team
15		All rights reserved.
16
17		Redistribution and use of this code or any derivative works are permitted
18		provided that the following conditions are met:
19
20		* Redistributions may not be sold, nor may they be used in a commercial
21		product or activity.
22
23		* Redistributions that are modified from the original source must include the
24		complete source code, including the source code for all components used by a
25		binary built from the modified sources. However, as a special exception, the
26		source code distributed need not include anything that is normally distributed
27		(in either source or binary form) with the major components (compiler, kernel,
28		and so on) of the operating system on which the executable runs, unless that
29		component itself accompanies the executable.
30
31		* Redistributions must reproduce the above copyright notice, this list of
32		conditions and the following disclaimer in the documentation and/or other
33		materials provided with the distribution.
34
35		THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
36		AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
37		IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
38		ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
39		LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
40		CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
41		SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
42		INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
43		CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
44		ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
45		POSSIBILITY OF SUCH DAMAGE.
46
47
48		****************************************************************************/
49
50		#include "nl_factory.h"
51		#include "nl_setup.h"
52
53		// ----------------------------------------------------------------------------------------
54		// net_device_t_base_factory
55		// ----------------------------------------------------------------------------------------
56
57		ATTR_COLD const nl_util::pstring_list net_device_t_base_factory::term_param_list()
58		{
59		if (m_def_param.startsWith("+"))
60		return nl_util::split(m_def_param.substr(1), ",");
61		else
62		return nl_util::pstring_list();
63		}
64
65		ATTR_COLD const nl_util::pstring_list net_device_t_base_factory::def_params()
66		{
67		if (m_def_param.startsWith("+") || m_def_param.equals("-"))
68		return nl_util::pstring_list();
69		else
70		return nl_util::split(m_def_param, ",");
71		}
72
73
74		netlist_factory_t::netlist_factory_t()
75		{
76		}
77
78		netlist_factory_t::~netlist_factory_t()
79		{
80		for (net_device_t_base_factory * const *e = m_list.first(); e != NULL; e = m_list.next(e))
81		{
82		net_device_t_base_factory *p = *e;
83		global_free(p);
84		}
85		m_list.clear();
86		}
87
88		netlist_device_t *netlist_factory_t::new_device_by_classname(const pstring &classname) const
89		{
90		for (net_device_t_base_factory * const *e = m_list.first(); e != NULL; e = m_list.next(e))
91		{
92		net_device_t_base_factory *p = *e;
93		if (strcmp(p->classname(), classname) == 0)
94		{
95		netlist_device_t *ret = p->Create();
96		return ret;
97		}
98		p++;
99		}
100		return NULL; // appease code analysis
101		}
102
103		netlist_device_t *netlist_factory_t::new_device_by_name(const pstring &name, netlist_setup_t &setup) const
104		{
105		net_device_t_base_factory *f = factory_by_name(name, setup);
106		return f->Create();
107		}
108
109		net_device_t_base_factory * netlist_factory_t::factory_by_name(const pstring &name, netlist_setup_t &setup) const
110		{
111		for (net_device_t_base_factory * const *e = m_list.first(); e != NULL; e = m_list.next(e))
112		{
113		net_device_t_base_factory *p = *e;
114		if (strcmp(p->name(), name) == 0)
115		{
116		return p;
117		}
118		p++;
119		}
120		setup.netlist().error("Class %s not found!\n", name.cstr());
121		return NULL; // appease code analysis
122		}

trunk/src/emu/netlist/nl_factory.h

r242990	r242991
1		// license:GPL-2.0+
2		// copyright-holders:Couriersud
3		/*
4		* nl_factory.h
5		*
6		*
7		*/
8
9		#ifndef NLFACTORY_H_
10		#define NLFACTORY_H_
11
12		#include "nl_config.h"
13		#include "plists.h"
14		#include "nl_base.h"
15		#if 0
16		#include "nl_time.h"
17		#include "nl_util.h"
18		#include "pstate.h"
19		#endif
20		#include "pstring.h"
21
22		// -----------------------------------------------------------------------------
23		// net_dev class factory
24		// -----------------------------------------------------------------------------
25
26		class net_device_t_base_factory
27		{
28		NETLIST_PREVENT_COPYING(net_device_t_base_factory)
29		public:
30		ATTR_COLD net_device_t_base_factory(const pstring &name, const pstring &classname,
31		const pstring &def_param)
32		: m_name(name), m_classname(classname), m_def_param(def_param)
33		{}
34
35		ATTR_COLD virtual ~net_device_t_base_factory() {}
36
37		ATTR_COLD virtual netlist_device_t *Create() const = 0;
38
39		ATTR_COLD const pstring &name() const { return m_name; }
40		ATTR_COLD const pstring &classname() const { return m_classname; }
41		ATTR_COLD const pstring &param_desc() const { return m_def_param; }
42		ATTR_COLD const nl_util::pstring_list term_param_list();
43		ATTR_COLD const nl_util::pstring_list def_params();
44
45		protected:
46		pstring m_name;                             /* device name */
47		pstring m_classname;                        /* device class name */
48		pstring m_def_param;                        /* default parameter */
49		};
50
51		template <class C>
52		class net_device_t_factory : public net_device_t_base_factory
53		{
54		NETLIST_PREVENT_COPYING(net_device_t_factory)
55		public:
56		ATTR_COLD net_device_t_factory(const pstring &name, const pstring &classname,
57		const pstring &def_param)
58		: net_device_t_base_factory(name, classname, def_param) { }
59
60		ATTR_COLD netlist_device_t *Create() const
61		{
62		netlist_device_t *r = nl_alloc(C);
63		//r->init(setup, name);
64		return r;
65		}
66		};
67
68		class netlist_factory_t
69		{
70		public:
71		typedef plinearlist_t<net_device_t_base_factory *> list_t;
72
73		ATTR_COLD netlist_factory_t();
74		ATTR_COLD ~netlist_factory_t();
75
76		template<class _C>
77		ATTR_COLD void register_device(const pstring &name, const pstring &classname,
78		const pstring &def_param)
79		{
80		m_list.add(nl_alloc(net_device_t_factory< _C >, name, classname, def_param));
81		}
82
83		ATTR_COLD netlist_device_t *new_device_by_classname(const pstring &classname) const;
84		ATTR_COLD netlist_device_t *new_device_by_name(const pstring &name, netlist_setup_t &setup) const;
85		ATTR_COLD net_device_t_base_factory * factory_by_name(const pstring &name, netlist_setup_t &setup) const;
86
87		const list_t &list() { return m_list; }
88
89		private:
90		list_t m_list;
91
92		};
93
94
95		#endif /* NLFACTORY_H_ */

trunk/src/emu/netlist/nl_lists.h

r242990	r242991
59	59	}
60	60	*i = e;
61	61	inc_stat(m_prof_sort);
62		nl_assert(m_end - m_list < _Size);
	62	assert(m_end - m_list < _Size);
63	63	}
64	64
65	65	ATTR_HOT inline const entry_t *pop()

trunk/src/emu/netlist/nl_parser.c

r242990	r242991
6	6	*/
7	7
8	8	#include "nl_parser.h"
9		#include "nl_factory.h"
10	9
11	10	//#undef NL_VERBOSE_OUT
12	11	//#define NL_VERBOSE_OUT(x) printf x
r242990	r242991
400	399	void netlist_parser::netdev_param()
401	400	{
402	401	pstring param;
403		nl_double val;
	402	double val;
404	403	param = get_identifier();
405	404	require_token(m_tok_comma);
406	405	val = eval_param(get_token());
r242990	r242991
440	439	}
441	440	else
442	441	{
443		nl_double val = eval_param(tok);
	442	double val = eval_param(tok);
444	443	m_setup.register_param(paramfq, val);
445	444	}
446	445	cnt++;
r242990	r242991
468	467	// ----------------------------------------------------------------------------------------
469	468
470	469
471		nl_double netlist_parser::eval_param(const token_t tok)
	470	double netlist_parser::eval_param(const token_t tok)
472	471	{
473	472	static const char *macs[6] = {"", "RES_K", "RES_M", "CAP_U", "CAP_N", "CAP_P"};
474		static nl_double facs[6] = {1, 1e3, 1e6, 1e-6, 1e-9, 1e-12};
	473	static double facs[6] = {1, 1e3, 1e6, 1e-6, 1e-9, 1e-12};
475	474	int i;
476	475	int f=0;
477	476	bool e;
478		nl_double ret;
	477	double ret;
479	478	pstring val;
480	479
481	480	//printf("param %s\n", tok.m_token.cstr());

trunk/src/emu/netlist/nl_parser.h

r242990	r242991
160	160	virtual void verror(pstring msg, int line_num, pstring line);
161	161	private:
162	162
163		nl_double eval_param(const token_t tok);
	163	double eval_param(const token_t tok);
164	164
165	165	token_id_t m_tok_param_left;
166	166	token_id_t m_tok_param_right;

trunk/src/emu/netlist/nl_setup.c

r242990	r242991
9	9	#include "nl_setup.h"
10	10	#include "nl_parser.h"
11	11	#include "nl_util.h"
12		#include "nl_factory.h"
13	12	#include "devices/net_lib.h"
14	13	#include "devices/nld_system.h"
15	14	#include "analog/nld_solver.h"
16	15	#include "analog/nld_twoterm.h"
17	16
18		//FIXME: we need a nl_getenv
19		#include <stdlib.h>
20
21	17	static NETLIST_START(base)
22	18	TTL_INPUT(ttlhigh, 1)
23	19	TTL_INPUT(ttllow, 0)
r242990	r242991
38	34	, m_proxy_cnt(0)
39	35	{
40	36	netlist.set_setup(this);
41		m_factory = nl_alloc(netlist_factory_t);
42	37	}
43	38
44	39	void netlist_setup_t::init()
45	40	{
46		nl_initialize_factory(factory());
	41	m_factory.initialize();
47	42	NETLIST_NAME(base)(*this);
48	43	}
49	44
r242990	r242991
57	52	m_params_temp.clear();
58	53
59	54	netlist().set_setup(NULL);
60		nl_free(m_factory);
61	55
62	56	pstring::resetmem();
63	57	}
r242990	r242991
95	89	return dev;
96	90	}
97	91
98		netlist_device_t *netlist_setup_t::register_dev(const pstring &classname, const pstring &name)
99		{
100		netlist_device_t *dev = factory().new_device_by_classname(classname);
101		if (dev == NULL)
102		netlist().error("Class %s not found!\n", classname.cstr());
103		return register_dev(dev, name);
104		}
105
106	92	template <class T>
107	93	static void remove_start_with(T &hm, pstring &sw)
108	94	{
r242990	r242991
392	378
393	379	nld_base_d_to_a_proxy *netlist_setup_t::get_d_a_proxy(netlist_output_t &out)
394	380	{
395		nl_assert(out.isFamily(netlist_terminal_t::LOGIC));
	381	assert(out.isFamily(netlist_terminal_t::LOGIC));
396	382
397	383	//printf("proxy for %s\n", out.name().cstr());;
398	384	netlist_logic_output_t &out_cast = dynamic_cast<netlist_logic_output_t &>(out);
r242990	r242991
401	387	if (proxy == NULL)
402	388	{
403	389	// create a new one ...
404		proxy = nl_alloc(nld_d_to_a_proxy ,out);
	390	proxy = new nld_d_to_a_proxy(out);
405	391	pstring x = pstring::sprintf("proxy_da_%s_%d", out.name().cstr(), m_proxy_cnt);
406	392	m_proxy_cnt++;
407	393
r242990	r242991
430	416	{
431	417	if (out.isFamily(netlist_terminal_t::ANALOG) && in.isFamily(netlist_terminal_t::LOGIC))
432	418	{
433		nld_a_to_d_proxy *proxy = nl_alloc(nld_a_to_d_proxy, in);
	419	nld_a_to_d_proxy *proxy = new nld_a_to_d_proxy(in);
434	420	pstring x = pstring::sprintf("proxy_ad_%s_%d", in.name().cstr(), m_proxy_cnt);
435	421	m_proxy_cnt++;
436	422
r242990	r242991
466	452	else if (inp.isFamily(netlist_terminal_t::LOGIC))
467	453	{
468	454	NL_VERBOSE_OUT(("connect_terminal_input: connecting proxy\n"));
469		nld_a_to_d_proxy *proxy = nl_alloc(nld_a_to_d_proxy, inp);
	455	nld_a_to_d_proxy *proxy = new nld_a_to_d_proxy(inp);
470	456	pstring x = pstring::sprintf("proxy_ad_%s_%d", inp.name().cstr(), m_proxy_cnt);
471	457	m_proxy_cnt++;
472	458
r242990	r242991
513	499
514	500	void netlist_setup_t::connect_terminals(netlist_core_terminal_t &t1, netlist_core_terminal_t &t2)
515	501	{
516		//nl_assert(in.isType(netlist_terminal_t::TERMINAL));
517		//nl_assert(out.isType(netlist_terminal_t::TERMINAL));
	502	//assert(in.isType(netlist_terminal_t::TERMINAL));
	503	//assert(out.isType(netlist_terminal_t::TERMINAL));
518	504
519	505	if (t1.has_net() && t2.has_net())
520	506	{
r242990	r242991
534	520	else
535	521	{
536	522	NL_VERBOSE_OUT(("adding net ...\n"));
537		netlist_analog_net_t *anet =  nl_alloc(netlist_analog_net_t);
	523	netlist_analog_net_t *anet =  new netlist_analog_net_t();
538	524	t1.set_net(*anet);
539	525	//m_netlist.solver()->m_nets.add(anet);
540	526	// FIXME: Nets should have a unique name
r242990	r242991
697	683
698	684	void netlist_setup_t::start_devices()
699	685	{
700		//FIXME: we need a nl_getenv
701	686	if (getenv("NL_LOGS"))
702	687	{
703	688	NL_VERBOSE_OUT(("Creating dynamic logs ...\n"));
r242990	r242991
706	691	{
707	692	NL_VERBOSE_OUT(("%d: <%s>\n",i, ll[i].cstr()));
708	693	NL_VERBOSE_OUT(("%d: <%s>\n",i, ll[i].cstr()));
709		netlist_device_t *nc = factory().new_device_by_classname("nld_log");
	694	netlist_device_t *nc = factory().new_device_by_classname("nld_log", *this);
710	695	pstring name = "log_" + ll[i];
711	696	register_dev(nc, name);
712	697	register_link(name + ".I", ll[i]);

trunk/src/emu/netlist/nl_setup.h

r242990	r242991
3	3	/*
4	4	* nlsetup.h
5	5	*
	6	*  Created on: 3 Nov 2013
	7	*      Author: andre
6	8	*/
7	9
8	10	#ifndef NLSETUP_H_
9	11	#define NLSETUP_H_
10	12
11	13	#include "nl_base.h"
12		//#include "nl_factory.h"
13	14
14	15	//============================================================
15	16	//  MACROS / inline netlist definitions
r242990	r242991
23	24	#define ALIAS(_alias, _name)                                                        \
24	25	setup.register_alias(# _alias, # _name);
25	26
26		//#define NET_NEW(_type)  setup.factory().new_device_by_classname(NETLIB_NAME_STR(_type), setup)
	27	#define NET_NEW(_type)  setup.factory().new_device_by_classname(NETLIB_NAME_STR(_type), setup)
27	28
28	29	#define NET_REGISTER_DEV(_type, _name)                                              \
29		setup.register_dev(NETLIB_NAME_STR(_type), # _name);
	30	setup.register_dev(NET_NEW(_type), # _name);
30	31
31	32	#define NET_REMOVE_DEV(_name)                                                       \
32	33	setup.remove_dev(# _name);
r242990	r242991
65	66	setup.namespace_pop();
66	67
67	68	// ----------------------------------------------------------------------------------------
	69	// FIXME: Clean this up
	70	// ----------------------------------------------------------------------------------------
	71
	72	//class NETLIB_NAME(analog_callback);
	73
	74	// ----------------------------------------------------------------------------------------
68	75	// netlist_setup_t
69	76	// ----------------------------------------------------------------------------------------
70	77
71		// Forward definition so we keep nl_factory.h out of the public
72		class netlist_factory_t;
73
74	78	class netlist_setup_t
75	79	{
76	80	NETLIST_PREVENT_COPYING(netlist_setup_t)
r242990	r242991
113	117
114	118	netlist_base_t &netlist() { return m_netlist; }
115	119	const netlist_base_t &netlist() const { return m_netlist; }
	120	netlist_factory_t &factory() { return m_factory; }
	121	const netlist_factory_t &factory() const { return m_factory; }
116	122
117	123	pstring build_fqn(const pstring &obj_name) const;
118	124
119	125	netlist_device_t *register_dev(netlist_device_t *dev, const pstring &name);
120		netlist_device_t *register_dev(const pstring &classname, const pstring &name);
121	126	void remove_dev(const pstring &name);
122	127
123	128	void register_model(const pstring &model);
r242990	r242991
146	151	void namespace_push(const pstring &aname);
147	152	void namespace_pop();
148	153
149		netlist_factory_t &factory() { return *m_factory; }
150		const netlist_factory_t &factory() const { return *m_factory; }
	154	/* not ideal, but needed for save_state */
	155	tagmap_terminal_t  m_terminals;
151	156
152		/* not ideal, but needed for save_state */
153		tagmap_terminal_t  m_terminals;
	157	void print_stats() const;
154	158
155		void print_stats() const;
156
157	159	protected:
158	160
159	161	private:
r242990	r242991
165	167	tagmap_link_t   m_links;
166	168	tagmap_nstring_t m_params_temp;
167	169
168		netlist_factory_t *m_factory;
	170	netlist_factory_t m_factory;
169	171
170	172	plinearlist_t<pstring> m_models;
171	173

trunk/src/emu/netlist/plists.h

r242990	r242991
28	28	if (m_num_elements == 0)
29	29	m_list = NULL;
30	30	else
31		m_list = nl_alloc_array(_ListClass, m_num_elements);
	31	m_list = new _ListClass[m_num_elements];
32	32	m_count = 0;
33	33	}
34	34
r242990	r242991
38	38	if (m_num_elements == 0)
39	39	m_list = NULL;
40	40	else
41		m_list = nl_alloc_array(_ListClass, m_num_elements);
	41	m_list = new _ListClass[m_num_elements];
42	42	m_count = 0;
43	43	for (int i=0; i<rhs.count(); i++)
44	44	{
r242990	r242991
60	60	ATTR_COLD ~plinearlist_t()
61	61	{
62	62	if (m_list != NULL)
63		nl_free_array(m_list);
	63	delete[] m_list;
64	64	m_list = NULL;
65	65	}
66	66
r242990	r242991
108	108
109	109	ATTR_HOT inline void remove_at(const int pos)
110	110	{
111		nl_assert((pos>=0) && (pos<m_count));
	111	assert((pos>=0) && (pos<m_count));
112	112	m_count--;
113	113	for (int i = pos; i < m_count; i++)
114	114	{
r242990	r242991
118	118
119	119	ATTR_HOT inline void swap(const int pos1, const int pos2)
120	120	{
121		nl_assert((pos1>=0) && (pos1<m_count));
122		nl_assert((pos2>=0) && (pos2<m_count));
	121	assert((pos1>=0) && (pos1<m_count));
	122	assert((pos2>=0) && (pos2<m_count));
123	123	_ListClass tmp = m_list[pos1];
124	124	m_list[pos1] = m_list[pos2];
125	125	m_list[pos2] =tmp;
r242990	r242991
157	157	{
158	158	for (_ListClass *i = m_list; i < m_list + m_count; i++)
159	159	{
160		nl_free(*i);
	160	delete *i;
161	161	}
162	162	clear();
163	163	}
164	164
165	165	private:
166		ATTR_COLD void resize(const int new_size)
	166	ATTR_HOT inline void resize(const int new_size)
167	167	{
168	168	int cnt = count();
169	169	if (new_size > 0)
170	170	{
171		_ListClass *m_new = nl_alloc_array(_ListClass, new_size);
	171	_ListClass *m_new = new _ListClass[new_size];
172	172	_ListClass *pd = m_new;
173	173
174	174	if (cnt > new_size)
r242990	r242991
176	176	for (_ListClass *ps = m_list; ps < m_list + cnt; ps++, pd++)
177	177	*pd = *ps;
178	178	if (m_list != NULL)
179		nl_free_array(m_list);
	179	delete[] m_list;
180	180	m_list = m_new;
181	181	m_count = cnt;
182	182	}
183	183	else
184	184	{
185	185	if (m_list != NULL)
186		nl_free_array(m_list);
	186	delete[] m_list;
187	187	m_list = NULL;
188	188	m_count = 0;
189	189	}
r242990	r242991
331	331	}
332	332	p = p->m_next;
333	333	}
334		nl_assert_always(false, "element not found");
	334	assert_always(false, "element not found");
335	335	}
336	336	}
337	337
r242990	r242991
357	357	_ListClass **p = &m_head;
358	358	while (*p != &elem)
359	359	{
360		nl_assert(*p != NULL);
	360	assert(*p != NULL);
361	361	p = &((*p)->m_next);
362	362	}
363	363	(*p) = elem.m_next;

trunk/src/emu/netlist/pstate.c

r242990	r242991
23	23	"DT_INT16",
24	24	"DT_INT8",
25	25	"DT_INT",
26		"DT_BOOLEAN",
27		"DT_FLOAT"
	26	"DT_BOOLEAN"
28	27	};
29	28
30	29	NL_VERBOSE_OUT(("SAVE: <%s> %s(%d) %p\n", fullname.cstr(), ts[dt].cstr(), size, ptr));
31		pstate_entry_t *p = nl_alloc(pstate_entry_t, stname, dt, owner, size, count, ptr, is_ptr);
	30	pstate_entry_t *p = new pstate_entry_t(stname, dt, owner, size, count, ptr, is_ptr);
32	31	m_save.add(p);
33	32	}
34	33
r242990	r242991
61	60	if (m_save[i]->m_dt == DT_CUSTOM)
62	61	m_save[i]->m_callback->on_post_load();
63	62	}
64
65		template<> ATTR_COLD void pstate_manager_t::save_item(pstate_callback_t &state, const void *owner, const pstring &stname)
66		{
67		//save_state_ptr(stname, DT_CUSTOM, 0, 1, &state);
68		pstate_entry_t *p = nl_alloc(pstate_entry_t, stname, owner, &state);
69		m_save.add(p);
70		state.register_state(*this, stname);
71		}

trunk/src/emu/netlist/pstate.h

r242990	r242991
32	32	DT_INT16,
33	33	DT_INT8,
34	34	DT_INT,
35		DT_BOOLEAN,
36		DT_FLOAT
	35	DT_BOOLEAN
37	36	};
38	37
39	38	template<typename _ItemType> struct nl_datatype
r242990	r242991
56	55
57	56	NETLIST_SAVE_TYPE(char, DT_INT8);
58	57	NETLIST_SAVE_TYPE(double, DT_DOUBLE);
59		NETLIST_SAVE_TYPE(float, DT_FLOAT);
60	58	NETLIST_SAVE_TYPE(INT8, DT_INT8);
61	59	NETLIST_SAVE_TYPE(UINT8, DT_INT8);
62	60	NETLIST_SAVE_TYPE(INT64, DT_INT64);
r242990	r242991
147	145	pstate_entry_t::list_t m_save;
148	146	};
149	147
150		template<> ATTR_COLD void pstate_manager_t::save_item(pstate_callback_t &state, const void *owner, const pstring &stname);
	148	template<> ATTR_COLD inline void pstate_manager_t::save_item(pstate_callback_t &state, const void *owner, const pstring &stname)
	149	{
	150	//save_state_ptr(stname, DT_CUSTOM, 0, 1, &state);
	151	pstate_entry_t *p = new pstate_entry_t(stname, owner, &state);
	152	m_save.add(p);
	153	state.register_state(*this, stname);
	154	}
151	155
152	156	template<> ATTR_COLD inline void pstate_manager_t::save_item(netlist_time &nlt, const void *owner, const pstring &stname)
153	157	{

trunk/src/emu/netlist/pstring.c

r242990	r242991
5	5
6	6	#include "pstring.h"
7	7	#include <cstdio>
8		#include <stdlib.h>
9	8
10	9
11	10	// The following will work on linux, however not on Windows ....
r242990	r242991
14	13	//pstring::str_t *pstring::m_zero = new(pstring::m_pool, 0) pstring::str_t(0);
15	14
16	15	pblockpool pstring::m_pool;
	16
17	17	pstring::str_t pstring::m_zero;
18	18
19	19	/*
r242990	r242991
108	108	return 1;
109	109	}
110	110
111		nl_double pstring::as_double(bool *error) const
	111	double pstring::as_double(bool *error) const
112	112	{
113		nl_double ret;
	113	double ret;
114	114	char *e = NULL;
115	115
116	116	if (error != NULL)
r242990	r242991
124	124
125	125	long pstring::as_long(bool *error) const
126	126	{
127		nl_double ret;
	127	double ret;
128	128	char *e = NULL;
129	129
130	130	if (error != NULL)

trunk/src/emu/netlist/pstring.h

r242990	r242991
159	159
160	160	// conversions
161	161
162		nl_double as_double(bool *error = NULL) const;
	162	double as_double(bool *error = NULL) const;
163	163
164	164	long as_long(bool *error = NULL) const;
165	165

trunk/src/emu/render.h

r242990	r242991
46	46	#ifndef __RENDER_H__
47	47	#define __RENDER_H__
48	48
49		//#include "osdepend.h"
	49	#include "osdepend.h"
50	50
51	51	#include <math.h>
52	52

trunk/src/emu/rendfont.c

r242990	r242991
14	14	#include "emuopts.h"
15	15	#include <zlib.h>
16	16
17		#include "osdepend.h"
18	17	#include "uismall.fh"
19	18
20	19

trunk/src/emu/rendfont.h

r242990	r242991
13	13
14	14	#include "render.h"
15	15
16		// forward instead of include
17		class osd_font;
18	16
19	17	//**************************************************************************
20	18	//  TYPE DEFINITIONS
r242990	r242991
93	91	dynamic_array<glyph> m_glyphs[256];     // array of glyph subtables
94	92	dynamic_array<char> m_rawdata;          // pointer to the raw data for the font
95	93	UINT64              m_rawsize;          // size of the raw font data
96		osd_font            *m_osdfont;          // handle to the OSD font
	94	osd_font            m_osdfont;          // handle to the OSD font
97	95
98	96	// constants
99	97	static const int CACHED_CHAR_SIZE       = 12;

trunk/src/emu/rendutil.h

r242990	r242991
12	12	#ifndef __RENDUTIL_H__
13	13	#define __RENDUTIL_H__
14	14
	15	#include "osdepend.h"
15	16	#include "render.h"
16	17
17	18	#include <math.h>

trunk/src/emu/save.c

r242990	r242991
213	213	return validate_header(header, gamename, sig, errormsg, "");
214	214	}
215	215
216		//-------------------------------------------------
217		//  dispatch_postload - invoke all registered
218		//  postload callbacks for updates
219		//-------------------------------------------------
220	216
221
222		void save_manager::dispatch_postload()
223		{
224		for (state_callback *func = m_postload_list.first(); func != NULL; func = func->next())
225		func->m_func();
226		}
227
228	217	//-------------------------------------------------
229	218	//  read_file - read the data from a file
230	219	//-------------------------------------------------
r242990	r242991
264	253	}
265	254
266	255	// call the post-load functions
267		dispatch_postload();
	256	for (state_callback *func = m_postload_list.first(); func != NULL; func = func->next())
	257	func->m_func();
268	258
269	259	return STATERR_NONE;
270	260	}
271	261
272		//-------------------------------------------------
273		//  dispatch_presave - invoke all registered
274		//  presave callbacks for updates
275		//-------------------------------------------------
276	262
277
278		void save_manager::dispatch_presave()
279		{
280		for (state_callback *func = m_presave_list.first(); func != NULL; func = func->next())
281		func->m_func();
282		}
283
284	263	//-------------------------------------------------
285	264	//  write_file - writes the data to a file
286	265	//-------------------------------------------------
r242990	r242991
308	287	file.compress(FCOMPRESS_MEDIUM);
309	288
310	289	// call the pre-save functions
311		dispatch_presave();
	290	for (state_callback *func = m_presave_list.first(); func != NULL; func = func->next())
	291	func->m_func();
312	292
313	293	// then write all the data
314	294	for (state_entry *entry = m_entry_list.first(); entry != NULL; entry = entry->next())

trunk/src/emu/save.h

r242990	r242991
99	99	void register_presave(save_prepost_delegate func);
100	100	void register_postload(save_prepost_delegate func);
101	101
102		// callback dispatching
103		void dispatch_presave();
104		void dispatch_postload();
105
106	102	// generic memory registration
107	103	void save_memory(const char *module, const char *tag, UINT32 index, const char *name, void *val, UINT32 valsize, UINT32 valcount = 1);
108	104

trunk/src/emu/sound/rf5c400.c

r242990	r242991
129	129
130	130	if (env_phase == PHASE_NONE) break;
131	131
132		tmp = rom[(pos>>16) & m_rommask];
	132	tmp = rom[pos>>16];
133	133	switch ( type )
134	134	{
135	135	case TYPE_16:
r242990	r242991
331	331	}
332	332
333	333	m_stream = stream_alloc(0, 2, clock()/384);
334
335		m_rommask = m_rom.length() - 1;
336	334	}
337	335
338	336

trunk/src/emu/sound/rf5c400.h

r242990	r242991
98	98	private:
99	99	required_region_ptr<INT16> m_rom;
100	100
101		UINT32 m_rommask;
102
103	101	sound_stream *m_stream;
104	102
105	103	double m_env_ar_table[0x9f];

trunk/src/emu/ui/filemngr.c

r242990	r242991
20	20	#include "ui/swlist.h"
21	21	#include "ui/filemngr.h"
22	22	#include "ui/filesel.h"
23		#include "ui/miscmenu.h"
24	23
25	24
26	25	/***************************************************************************
r242990	r242991
31	30	//  ctor
32	31	//-------------------------------------------------
33	32
34		ui_menu_file_manager::ui_menu_file_manager(running_machine &machine, render_container *container, const char *warnings) : ui_menu(machine, container)
	33	ui_menu_file_manager::ui_menu_file_manager(running_machine &machine, render_container *container) : ui_menu(machine, container)
35	34	{
36		// This warning string is used when accessing from the force_file_manager call, i.e.
37		// when the file manager is loaded top front in the case of mandatory image devices
38		if (warnings)
39		m_warnings.cpy(warnings);
40		else
41		m_warnings.reset();
42	35	}
43	36
44	37
r242990	r242991
108	101	bool first_entry = true;
109	102	astring prev_owner;
110	103
111		if (m_warnings)
112		{
113		item_append(m_warnings, NULL, MENU_FLAG_DISABLE, NULL);
114		item_append("", NULL, MENU_FLAG_DISABLE, NULL);
115		}
116
117	104	// cycle through all devices for this system
118	105	device_iterator iter(machine().root_device());
119	106	tagmap_t<UINT8> devtags;
r242990	r242991
185	172	}
186	173	}
187	174	}
188
189		// force file manager menu
190		void ui_menu_file_manager::force_file_manager(running_machine &machine, render_container *container, const char *warnings)
191		{
192		// reset the menu stack
193		ui_menu::stack_reset(machine);
194
195		// add the quit entry followed by the game select entry
196		ui_menu *quit = auto_alloc_clear(machine, ui_menu_quit_game(machine, container));
197		quit->set_special_main_menu(true);
198		ui_menu::stack_push(quit);
199		ui_menu::stack_push(auto_alloc_clear(machine, ui_menu_file_manager(machine, container, warnings)));
200
201		// force the menus on
202		machine.ui().show_menu();
203
204		// make sure MAME is paused
205		machine.pause();
206		}

trunk/src/emu/ui/filemngr.h

r242990	r242991
20	20	astring current_file;
21	21	device_image_interface *selected_device;
22	22
23		static void force_file_manager(running_machine &machine, render_container *container, const char *warnings);
24
25		ui_menu_file_manager(running_machine &machine, render_container *container, const char *warnings);
	23	ui_menu_file_manager(running_machine &machine, render_container *container);
26	24	virtual ~ui_menu_file_manager();
27	25	virtual void populate();
28	26	virtual void handle();
29	27	virtual void custom_render(void *selectedref, float top, float bottom, float x, float y, float x2, float y2);
30	28
31	29	void fill_image_line(device_image_interface *img, astring &instance, astring &filename);
32
33		private:
34		astring m_warnings;
35	30	};
36	31
37	32	#endif  /* __UI_FILEMNGR_H__ */

trunk/src/emu/ui/imgcntrl.c

r242990	r242991
16	16	#include "ui/filesel.h"
17	17	#include "ui/swlist.h"
18	18	#include "zippath.h"
19		#include "audit.h"
20	19
21	20
22	21	/***************************************************************************
r242990	r242991
133	132	void ui_menu_control_device_image::load_software_part()
134	133	{
135	134	astring temp_name(sld->list_name(), ":", swi->shortname(), ":", swp->name());
136
137		driver_enumerator drivlist(machine().options(), machine().options().system_name());
138		media_auditor auditor(drivlist);
139		media_auditor::summary summary = auditor.audit_software(sld->list_name(), (software_info *)swi, AUDIT_VALIDATE_FAST);
140		// if everything looks good, load software
141		if (summary == media_auditor::CORRECT || summary == media_auditor::BEST_AVAILABLE || summary == media_auditor::NONE_NEEDED)
142		hook_load(temp_name, true);
143		else
144		{
145		popmessage("The selected game is missing one or more required ROM or CHD images. Please select a different game.");
146		state = SELECT_SOFTLIST;
147		}
	135	hook_load(temp_name, true);
148	136	}
149	137
150	138
r242990	r242991
229	217	{
230	218	swp = swi->first_part();
231	219	load_software_part();
	220	ui_menu::stack_pop(machine());
232	221	}
233	222	break;
234	223
r242990	r242991
236	225	switch(submenu_result) {
237	226	case ui_menu_software_parts::T_ENTRY: {
238	227	load_software_part();
	228	ui_menu::stack_pop(machine());
239	229	break;
240	230	}
241	231

trunk/src/emu/ui/imgcntrl.h

r242990	r242991
14	14	#ifndef __UI_IMGCNTRL_H__
15	15	#define __UI_IMGCNTRL_H__
16	16
17		#include "drivenum.h"
18
19	17	// ======================> ui_menu_control_device_image
20	18
21	19	class ui_menu_control_device_image : public ui_menu {

trunk/src/emu/ui/imginfo.c

r0	r242991
	1	/***************************************************************************
	2
	3	ui/imginfo.c
	4
	5	Image info screen
	6
	7	Copyright Nicola Salmoria and the MAME Team.
	8	Visit http://mamedev.org for licensing and usage restrictions.
	9
	10	***************************************************************************/
	11
	12	#include "emu.h"
	13	#include "ui/menu.h"
	14	#include "ui/imginfo.h"
	15
	16
	17	/***************************************************************************
	18	IMPLEMENTATION
	19	***************************************************************************/
	20
	21	//-------------------------------------------------
	22	//  ctor
	23	//-------------------------------------------------
	24
	25	ui_menu_image_info::ui_menu_image_info(running_machine &machine, render_container *container) : ui_menu(machine, container)
	26	{
	27	}
	28
	29
	30	//-------------------------------------------------
	31	//  dtor
	32	//-------------------------------------------------
	33
	34	ui_menu_image_info::~ui_menu_image_info()
	35	{
	36	}
	37
	38
	39	//-------------------------------------------------
	40	//  populate
	41	//-------------------------------------------------
	42
	43	void ui_menu_image_info::populate()
	44	{
	45	item_append(machine().system().description, NULL, MENU_FLAG_DISABLE, NULL);
	46	item_append("", NULL, MENU_FLAG_DISABLE, NULL);
	47
	48	image_interface_iterator iter(machine().root_device());
	49	for (device_image_interface *image = iter.first(); image != NULL; image = iter.next())
	50	image_info(image);
	51	}
	52
	53
	54	//-------------------------------------------------
	55	//  handle
	56	//-------------------------------------------------
	57
	58	void ui_menu_image_info::handle()
	59	{
	60	// process the menu
	61	process(0);
	62	}
	63
	64
	65	//-------------------------------------------------
	66	//  image_info - display image info for a specific
	67	//  image interface device
	68	//-------------------------------------------------
	69
	70	void ui_menu_image_info::image_info(device_image_interface *image)
	71	{
	72	if (image->exists())
	73	{
	74	// display device type and filename
	75	item_append(image->brief_instance_name(), image->basename(), 0, NULL);
	76
	77	// if image has been loaded through softlist, let's add some more info
	78	if (image->software_entry())
	79	{
	80	astring string;
	81
	82	// display long filename
	83	item_append(image->longname(), "", MENU_FLAG_DISABLE, NULL);
	84
	85	// display manufacturer and year
	86	string.catprintf("%s, %s", image->manufacturer(), image->year());
	87	item_append(string, "", MENU_FLAG_DISABLE, NULL);
	88
	89	// display supported information, if available
	90	switch (image->supported())
	91	{
	92	case SOFTWARE_SUPPORTED_NO:
	93	item_append("Not supported", "", MENU_FLAG_DISABLE, NULL);
	94	break;
	95	case SOFTWARE_SUPPORTED_PARTIAL:
	96	item_append("Partially supported", "", MENU_FLAG_DISABLE, NULL);
	97	break;
	98	default:
	99	break;
	100	}
	101	}
	102	}
	103	else
	104	item_append(image->brief_instance_name(), "[empty]", 0, NULL);
	105	item_append("", NULL, MENU_FLAG_DISABLE, NULL);
	106	}

trunk/src/emu/ui/imginfo.h

r0	r242991
	1	/***************************************************************************
	2
	3	ui/imginfo.h
	4
	5	Image info screen
	6
	7	Copyright Nicola Salmoria and the MAME Team.
	8	Visit http://mamedev.org for licensing and usage restrictions.
	9
	10	***************************************************************************/
	11
	12	#pragma once
	13
	14	#ifndef __UI_IMGINFO_H__
	15	#define __UI_IMGINFO_H__
	16
	17	class ui_menu_image_info : public ui_menu
	18	{
	19	public:
	20	ui_menu_image_info(running_machine &machine, render_container *container);
	21	virtual ~ui_menu_image_info();
	22	virtual void populate();
	23	virtual void handle();
	24
	25	private:
	26	void image_info(device_image_interface *image);
	27	};
	28
	29	#endif // __UI_IMGINFO_H__

trunk/src/emu/ui/info.c

r242990	r242991
1		/***************************************************************************
2
3		ui/info.c
4
5		System and image info screens
6
7		Copyright Nicola Salmoria and the MAME Team.
8		Visit http://mamedev.org for licensing and usage restrictions.
9
10		***************************************************************************/
11
12		#include "emu.h"
13		#include "ui/menu.h"
14		#include "ui/info.h"
15		#include "ui/ui.h"
16
17		/*-------------------------------------------------
18		menu_game_info - handle the game information
19		menu
20		-------------------------------------------------*/
21
22		ui_menu_game_info::ui_menu_game_info(running_machine &machine, render_container *container) : ui_menu(machine, container)
23		{
24		}
25
26		ui_menu_game_info::~ui_menu_game_info()
27		{
28		}
29
30		void ui_menu_game_info::populate()
31		{
32		astring tempstring;
33		item_append(machine().ui().game_info_astring(tempstring), NULL, MENU_FLAG_MULTILINE, NULL);
34		}
35
36		void ui_menu_game_info::handle()
37		{
38		// process the menu
39		process(0);
40		}
41
42
43		/*-------------------------------------------------
44		ui_menu_image_info - handle the image information
45		menu
46		-------------------------------------------------*/
47
48		ui_menu_image_info::ui_menu_image_info(running_machine &machine, render_container *container) : ui_menu(machine, container)
49		{
50		}
51
52		ui_menu_image_info::~ui_menu_image_info()
53		{
54		}
55
56		void ui_menu_image_info::populate()
57		{
58		item_append(machine().system().description, NULL, MENU_FLAG_DISABLE, NULL);
59		item_append("", NULL, MENU_FLAG_DISABLE, NULL);
60
61		image_interface_iterator iter(machine().root_device());
62		for (device_image_interface *image = iter.first(); image != NULL; image = iter.next())
63		image_info(image);
64		}
65
66		void ui_menu_image_info::handle()
67		{
68		// process the menu
69		process(0);
70		}
71
72
73		/*-------------------------------------------------
74		image_info - display image info for a specific
75		image interface device
76		-------------------------------------------------*/
77
78		void ui_menu_image_info::image_info(device_image_interface *image)
79		{
80		if (image->exists())
81		{
82		// display device type and filename
83		item_append(image->brief_instance_name(), image->basename(), 0, NULL);
84
85		// if image has been loaded through softlist, let's add some more info
86		if (image->software_entry())
87		{
88		astring string;
89
90		// display long filename
91		item_append(image->longname(), "", MENU_FLAG_DISABLE, NULL);
92
93		// display manufacturer and year
94		string.catprintf("%s, %s", image->manufacturer(), image->year());
95		item_append(string, "", MENU_FLAG_DISABLE, NULL);
96
97		// display supported information, if available
98		switch (image->supported())
99		{
100		case SOFTWARE_SUPPORTED_NO:
101		item_append("Not supported", "", MENU_FLAG_DISABLE, NULL);
102		break;
103		case SOFTWARE_SUPPORTED_PARTIAL:
104		item_append("Partially supported", "", MENU_FLAG_DISABLE, NULL);
105		break;
106		default:
107		break;
108		}
109		}
110		}
111		else
112		item_append(image->brief_instance_name(), "[empty]", 0, NULL);
113		item_append("", NULL, MENU_FLAG_DISABLE, NULL);
114		}

trunk/src/emu/ui/info.h

r242990	r242991
1		/***************************************************************************
2
3		ui/info.h
4
5		System and image info screens
6
7		Copyright Nicola Salmoria and the MAME Team.
8		Visit http://mamedev.org for licensing and usage restrictions.
9
10		***************************************************************************/
11
12		#pragma once
13
14		#ifndef __UI_INFO_H__
15		#define __UI_INFO_H__
16
17		class ui_menu_game_info : public ui_menu {
18		public:
19		ui_menu_game_info(running_machine &machine, render_container *container);
20		virtual ~ui_menu_game_info();
21		virtual void populate();
22		virtual void handle();
23		};
24
25
26		class ui_menu_image_info : public ui_menu
27		{
28		public:
29		ui_menu_image_info(running_machine &machine, render_container *container);
30		virtual ~ui_menu_image_info();
31		virtual void populate();
32		virtual void handle();
33
34		private:
35		void image_info(device_image_interface *image);
36		};
37
38		#endif // __UI_INFO_H__

trunk/src/emu/ui/mainmenu.c

r242990	r242991
19	19	#include "ui/filemngr.h"
20	20	#include "ui/filesel.h"
21	21	#include "ui/barcode.h"
22		#include "ui/info.h"
	22	#include "ui/imginfo.h"
23	23	#include "ui/inputmap.h"
24	24	#include "ui/mainmenu.h"
25	25	#include "ui/miscmenu.h"
r242990	r242991
183	183	break;
184	184
185	185	case IMAGE_MENU_FILE_MANAGER:
186		ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_file_manager(machine(), container, NULL)));
	186	ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_file_manager(machine(), container)));
187	187	break;
188	188
189	189	case TAPE_CONTROL:

trunk/src/emu/ui/miscmenu.c

r242990	r242991
19	19	#include "rendutil.h"
20	20
21	21	#include "uiinput.h"
	22	#include "ui/ui.h"
22	23	#include "ui/miscmenu.h"
23	24	#include "ui/filemngr.h"
24	25
25		#include "osdepend.h"
26	26
27	27	/*-------------------------------------------------
28	28	ui_slider_ui_handler - pushes the slider
r242990	r242991
304	304
305	305
306	306	/*-------------------------------------------------
	307	menu_game_info - handle the game information
	308	menu
	309	-------------------------------------------------*/
	310
	311	ui_menu_game_info::ui_menu_game_info(running_machine &machine, render_container *container) : ui_menu(machine, container)
	312	{
	313	}
	314
	315	void ui_menu_game_info::populate()
	316	{
	317	astring tempstring;
	318	item_append(machine().ui().game_info_astring(tempstring), NULL, MENU_FLAG_MULTILINE, NULL);
	319	}
	320
	321	void ui_menu_game_info::handle()
	322	{
	323	/* process the menu */
	324	process(0);
	325	}
	326
	327	ui_menu_game_info::~ui_menu_game_info()
	328	{
	329	}
	330
	331	/*-------------------------------------------------
307	332	menu_cheat - handle the cheat menu
308	333	-------------------------------------------------*/
309	334

trunk/src/emu/ui/miscmenu.h

r242990	r242991
44	44	attotime prevtime;
45	45	};
46	46
	47	class ui_menu_game_info : public ui_menu {
	48	public:
	49	ui_menu_game_info(running_machine &machine, render_container *container);
	50	virtual ~ui_menu_game_info();
	51	virtual void populate();
	52	virtual void handle();
	53	};
	54
47	55	class ui_menu_cheat : public ui_menu {
48	56	public:
49	57	ui_menu_cheat(running_machine &machine, render_container *container);

trunk/src/emu/ui/selgame.c

r242990	r242991
157	157	media_auditor::summary summary = auditor.audit_media(AUDIT_VALIDATE_FAST);
158	158
159	159	// if everything looks good, schedule the new driver
160		if (summary == media_auditor::CORRECT || summary == media_auditor::BEST_AVAILABLE || summary == media_auditor::NONE_NEEDED)
	160	if (summary == media_auditor::CORRECT || summary == media_auditor::BEST_AVAILABLE)
161	161	{
162	162	machine().manager().schedule_new_driver(*driver);
163	163	machine().schedule_hard_reset();

trunk/src/emu/ui/slotopt.c

r242990	r242991
188	188	if (menu_event != NULL && menu_event->itemref != NULL)
189	189	{
190	190	if ((FPTR)menu_event->itemref == 1 && menu_event->iptkey == IPT_UI_SELECT)
191		{
192		machine().options().add_slot_options(false);
193	191	machine().schedule_hard_reset();
194		}
195	192	else if (menu_event->iptkey == IPT_UI_LEFT || menu_event->iptkey == IPT_UI_RIGHT)
196	193	{
197	194	device_slot_interface *slot = (device_slot_interface *)menu_event->itemref;

trunk/src/emu/ui/ui.c

r242990	r242991
20	20	#include "uiinput.h"
21	21	#include "ui/mainmenu.h"
22	22	#include "ui/miscmenu.h"
23		#include "ui/filemngr.h"
24	23	#include "ui/viewgfx.h"
25	24	#include "imagedev/cassette.h"
26	25	#include <ctype.h>
r242990	r242991
307	306
308	307	void ui_manager::display_startup_screens(bool first_time, bool show_disclaimer)
309	308	{
310		const int maxstate = 4;
	309	const int maxstate = 3;
311	310	int str = machine().options().seconds_to_run();
312	311	bool show_gameinfo = !machine().options().skip_gameinfo();
313	312	bool show_warnings = true;
r242990	r242991
353	352	if (show_gameinfo && game_info_astring(messagebox_text).len() > 0)
354	353	set_handler(handler_messagebox_anykey, 0);
355	354	break;
356
357		case 3:
358		if (image_mandatory_scan(machine(), messagebox_text).len() > 0)
359		{
360		astring warning;
361		warning.cpy("This driver requires images to be loaded in the following device(s): ").cat(messagebox_text.substr(0, messagebox_text.len() - 2));
362		ui_menu_file_manager::force_file_manager(machine(), &machine().render().ui_container(), warning.cstr());
363		}
364		break;
365	355	}
366	356
367	357	// clear the input memory

trunk/src/emu/video.c

r242990	r242991
20	20
21	21	#include "snap.lh"
22	22
23		#include "osdepend.h"
24	23
	24
25	25	//**************************************************************************
26	26	//  DEBUGGING
27	27	//**************************************************************************

trunk/src/emu/webengine.c

r242990	r242991
16	16	#include "webengine.h"
17	17	#include "lua.hpp"
18	18
19		#include "osdepend.h"
20	19
	20
21	21	//**************************************************************************
22	22	//  WEB ENGINE
23	23	//**************************************************************************

trunk/src/lib/lib.mak

r242990	r242991
39	39	#-------------------------------------------------
40	40
41	41	UTILOBJS = \
42		$(OSDOBJ)/osdcore.o \
43	42	$(LIBOBJ)/util/astring.o \
44	43	$(LIBOBJ)/util/avhuff.o \
45	44	$(LIBOBJ)/util/aviio.o \

trunk/src/lib/util/corefile.h

r242990	r242991
14	14	#define __COREFILE_H__
15	15
16	16	#include <stdarg.h>
	17	#include "osdcore.h"
17	18	#include "astring.h"
18	19	#include "coretmpl.h"
19	20

trunk/src/lib/util/options.h

r242990	r242991
11	11	#ifndef __OPTIONS_H__
12	12	#define __OPTIONS_H__
13	13
	14	#include "osdcore.h"
14	15	#include "corefile.h"
15	16	#include "tagmap.h"
16	17

trunk/src/mame/audio/mario.c

r242990	r242991
2	2	#include "cpu/z80/z80.h"
3	3	#include "cpu/mcs48/mcs48.h"
4	4	#include "sound/ay8910.h"
	5	#include "sound/discrete.h"
5	6
6	7	#include "includes/mario.h"
7	8
r242990	r242991
38	39	#define I8035_P1_W_AH(M,B,D) I8035_P1_W(M,ACTIVEHIGH_PORT_BIT(I8035_P1_R(M),B,(D)))
39	40	#define I8035_P2_W_AH(M,B,D) I8035_P2_W(M,ACTIVEHIGH_PORT_BIT(I8035_P2_R(M),B,(D)))
40	41
41
42		#if !OLD_SOUND
43
44		/* ---------------------------------------------------------------------- */
45		/* mario sound                                                            */
46		/* ---------------------------------------------------------------------- */
47		static NETLIST_START(nl_mario_snd0)
48
49		RES(R17, RES_K(27))               /* 20 according to parts list           */
50		/* 27 verified, 30K in schematics       */
51		CAP(C14, CAP_U(4.7))              /* verified                             */
52
53		TTL_74123(2H_A)
54		NET_C(2H_A.VCC, V5)
55		NET_C(2H_A.GND, GND)
56		NET_C(SOUND0.Q, 2H_A.B)
57		NET_C(GND, 2H_A.A)
58		NET_C(2H_A.CLRQ, ttlhigh)         /* NOT IN SCHEMATICS                    */
59		DIODE(D1, "1N4148")               /* FIXME: try to identify */
60		TTL_7404_INVERT(1H_A, 2H_A.QQ)
61		NET_C(R17.1, V5)
62		NET_C(R17.2, D1.A, C14.1)
63		NET_C(D1.K, 2H_A.RC)
64		NET_C(C14.2, 2H_A.C)
65
66		RES(R6, RES_K(4.7))               /* verified                             */
67		CAP(C3, CAP_U(10))                /* verified                             */
68
69		NET_C(1H_A.Q, R6.1)
70		NET_C(R6.2, C3.1, 1J_A.FC)
71		NET_C(R6.2, 2J_A.FC)
72		NET_C(C3.2, GND)
73
74		//#define MR_C6       CAP_N(3.9)        /* verified                           */
75
76		SN74LS629(1J_A, CAP_N(3.9))
77		NET_C(1J_A.RNG, V5)
78		NET_C(1J_A.ENQ, ttllow)
79		NET_C(GND, 1J_A.GND)
80
81		//#define MR_C17      CAP_N(22)        /* verified                            */
82
83		SN74LS629(2J_A, CAP_N(22))
84		NET_C(2J_A.RNG, V5)
85		NET_C(2J_A.ENQ, ttllow)
86		NET_C(GND, 2J_A.GND)
87
88		TTL_7486_XOR(1K_A, 1J_A.Y, 2J_A.Y)
89		TTL_7408_AND(2K_A, 2H_A.Q, 1K_A)
90		NETLIST_END()
91
92		/* ---------------------------------------------------------------------- */
93		/* skid sound                                                            */
94		/* ---------------------------------------------------------------------- */
95
96		// FIXME: Diodes are 1S953
97		static NETLIST_START(nl_mario_snd7)
98
99		RES(R61, RES_K(47))
100		CAP(C41, CAP_U(4.7))              /* verified                             */
101
102		TTL_74123(4L_A)
103		NET_C(4L_A.VCC, V5)
104		NET_C(4L_A.GND, GND)
105		NET_C(SOUND7.Q, 4L_A.B)
106		NET_C(GND, 4L_A.A)
107		NET_C(4L_A.CLRQ, ttlhigh)         /* NOT IN SCHEMATICS                    */
108		DIODE(D10, "1N4148")               /* FIXME: try to identify */
109		TTL_7404_INVERT(4J_A, 4L_A.Q)
110		NET_C(R61.1, V5)
111		NET_C(R61.2, D10.A, C41.1)
112		NET_C(D10.K, 4L_A.RC)
113		NET_C(C41.2, 4L_A.C)
114
115		RES(R65, RES_K(10))
116		CAP(C44, CAP_U(3.3))              /* verified                             */
117
118		SN74LS629(4K_A, CAP_U(0.022))
119		NET_C(4K_A.RNG, V5)
120		NET_C(4K_A.ENQ, ttllow)
121		NET_C(GND, 4K_A.GND)
122		NET_C(R65.1, 4J_A.Q)
123		NET_C(R65.2, 4K_A.FC, C44.1)
124		NET_C(C44.2, GND)
125
126		CD_4020(3H, 4K_B.Y, ttllow, V5, GND)
127		TTL_7404_INVERT(4J_B, 3H.Q12)
128
129		RES(R64, RES_K(20))
130		CAP(C43, CAP_U(3.3))              /* verified                             */
131
132		SN74LS629(4K_B, CAP_U(0.0047))
133		NET_C(4K_B.RNG, V5)
134		NET_C(4K_B.ENQ, ttllow)
135		NET_C(GND, 4K_B.GND)
136		NET_C(R64.1, 4J_B.Q)
137		NET_C(R64.2, 4K_B.FC, C43.1)
138		NET_C(C43.2, GND)
139
140		TTL_7486_XOR(1K_C, 3H.Q4, 4K_A.Y)
141		TTL_7408_AND(2K_C, 4L_A.Q, 1K_C)
142
143		NETLIST_END()
144
145		/* ---------------------------------------------------------------------- */
146		/* DAC sound                                                            */
147		/* ---------------------------------------------------------------------- */
148		static NETLIST_START(nl_mario_dac)
149		RES(R34, RES_M(2))
150		RES(R35, RES_M(1))
151		RES(R36, RES_M(1.8))
152		LM3900(3M_1)
153		NET_C(3M_1.VM, GND)
154		NET_C(3M_1.VP, V5)
155
156		NET_C(DAC.VOUT, R34.1)
157		NET_C(3M_1.MINUS, R34.2, R35.2)
158		NET_C(3M_1.OUT, R35.1)
159		NET_C(3M_1.PLUS, R36.1)
160		NET_C(R36.2, GND)
161
162		RES(R21, RES_M(1.8))
163		RES(R23, RES_K(10))
164		RES(R25, RES_K(10))
165		RES(R37, RES_K(750))
166		RES(R38, RES_K(360))
167		RES(R39, RES_K(750))
168
169		CAP(C18, CAP_P(100))
170		CAP(C19, CAP_U(10))
171		CAP(C20, CAP_U(1))
172		CAP(C30, CAP_P(100))
173
174		LM3900(3M_2)
175		NET_C(3M_2.VM, GND)
176		NET_C(3M_2.VP, V5)
177
178		NET_C(R35.1, C20.1)
179		NET_C(C20.2, R37.1)
180		NET_C(R37.2, R38.2, C18.1, R39.2)
181
182		NET_C(C18.2, GND)
183		NET_C(R38.1, C30.2, 3M_2.MINUS)
184		NET_C(3M_2.OUT, R39.1, C30.1)
185
186		NET_C(R21.1, 3M_2.PLUS)
187		NET_C(R21.2, C19.1, R25.2, R23.1)
188		NET_C(C19.2, R23.2, GND)
189		NET_C(R25.1, V5)
190		NETLIST_END()
191
192		static NETLIST_START(nl_mario)
193
194		/* Standard stuff */
195
196		SOLVER(Solver, 48000)
197		PARAM(Solver.ACCURACY, 1e-8)
198		PARAM(Solver.SOR_FACTOR, 1.0)
199		PARAM(Solver.GS_THRESHOLD, 5)
200		PARAM(Solver.GS_LOOPS, 4)
201		//PARAM(Solver.LTE,     5e-2) // Default is not enough for paddle control
202		PARAM(Solver.DYNAMIC_TS,  0)
203		ANALOG_INPUT(V5, 5)
204
205		TTL_INPUT(SOUND0, 1)
206		INCLUDE(nl_mario_snd0)
207
208		TTL_INPUT(SOUND7, 1)
209		INCLUDE(nl_mario_snd7)
210
211		R2R_DAC(DAC, 3.4, 10000.0, 8)
212		NET_C(DAC.VGND, GND)
213
214		INCLUDE(nl_mario_dac)
215
216		/* ---------------------------------------------------------------------- */
217		/* mixing                                                                 */
218		/* ---------------------------------------------------------------------- */
219
220		RES(R20, RES_K(22))               /* verified                             */
221		RES(R19, RES_K(22))               /* verified                             */
222		RES(R40, RES_K(22))               /* verified                             */
223		RES(R41, RES_K(100))              /* verified                             */
224		CAP(C31, CAP_U(0.022))            /*                             */
225
226		NET_C(2K_A.Q, R20.1)
227		NET_C(GND, R19.1) //FIXME
228		NET_C(2K_C.Q, R41.1)
229
230		#if 1
231		RES(DUM, RES_K(22))
232		NET_C(R39.1, DUM.1)
233		NET_C(DUM.2, GND)
234		FRONTIER(front1, R39.1, R40.1)
235		#else
236		NET_C(R39.1, R40.1)
237		#endif
238
239		NET_C(R20.2, R19.2, R40.2, R41.2, C31.1)
240		NET_C(C31.2, GND)
241
242		CAP(C32, CAP_U(1))                /* verified                             */
243		RES(R42, RES_K(43))               /* verified                             */
244		RES(R43, RES_K(100))              /* verified                             */
245
246		NET_C(C31.1, C32.1)
247		NET_C(C32.2, R42.1, R43.2, Q10.B)
248		//NET_C(C32.2, R42.1, R43.2)
249		NET_C(R43.1, V5)
250		NET_C(R42.2, GND)
251		#if 1
252		RES(R63, RES_K(1))                /*                                      */
253		RES(R62, 150)                     /*                                      */
254
255		QBJT_EB(Q10, "2SC1815")
256
257		NET_C(R62.2, GND)
258		NET_C(R62.1, Q10.E)
259
260		NET_C(R63.1, V5)
261		NET_C(R63.2, Q10.C)
262
263		CAP(C42, CAP_U(0.1))
264		CAP(C47, CAP_U(4.7))
265		RES(VR1, RES_K(10))
266
267		NET_C(C42.1, C47.1, R62.1)
268		NET_C(C42.2, GND)
269		NET_C(C47.2, VR1.1)
270		NET_C(VR1.2, GND)
271		#endif
272		/* ---------------------------------------------------------------------- */
273		/* Output                                                                 */
274		/* ---------------------------------------------------------------------- */
275
276		RES(ROUT, 1000000)
277
278		//NET_C(Q10.C, ROUT.1)
279		//NET_C(R43.2, ROUT.1)
280		NET_C(VR1.1, ROUT.1)
281
282		NET_C(GND, ROUT.2)
283
284		NETLIST_END()
285
286		#else
287	42	/****************************************************************
288	43	*
289	44	* Discrete Sound defines
r242990	r242991
635	390	DISCRETE_TASK_END()
636	391
637	392	DISCRETE_SOUND_END
638		#endif
	393
639	394	/****************************************************************
640	395	*
641	396	* EA / Banking
r242990	r242991
743	498
744	499	WRITE8_MEMBER(mario_state::mario_sh_sound_w)
745	500	{
746		#if OLD_SOUND
747	501	m_discrete->write(space, DS_DAC, data);
748		#else
749		m_audio_dac->write(data);
750		#endif
751	502	}
752	503
753	504	WRITE8_MEMBER(mario_state::mario_sh_p1_w)
r242990	r242991
787	538	/* Mario running sample */
788	539	WRITE8_MEMBER(mario_state::mario_sh1_w)
789	540	{
790		#if OLD_SOUND
791	541	m_discrete->write(space, DS_SOUND0_INP, 0);
792		#else
793		m_audio_snd0->write(data);
794		#endif
795	542	}
796	543
797	544	/* Luigi running sample */
798	545	WRITE8_MEMBER(mario_state::mario_sh2_w)
799	546	{
800		#if OLD_SOUND
801	547	m_discrete->write(space, DS_SOUND1_INP, 0);
802		#endif
803	548	}
804	549
805	550	/* Misc samples */
r242990	r242991
832	577	I8035_P1_W_AH(space, 3, data & 1);
833	578	break;
834	579	case 7: /* skid */
835		#if OLD_SOUND
836	580	machine().device<discrete_device>("discrete")->write(space, DS_SOUND7_INP, data & 1);
837		#else
838		m_audio_snd7->write((data & 1) ^ 1);
839		#endif
840	581	break;
841	582	}
842	583	}
r242990	r242991
885	626	MCFG_CPU_IO_MAP(mario_sound_io_map)
886	627
887	628	MCFG_SPEAKER_STANDARD_MONO("mono")
888
889		#if OLD_SOUND
890	629	MCFG_SOUND_ADD("discrete", DISCRETE, 0)
891	630	MCFG_DISCRETE_INTF(mario)
892	631	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1)
893		#else
894		MCFG_SOUND_ADD("snd_nl", NETLIST_SOUND, 48000)
895		MCFG_NETLIST_SETUP(nl_mario)
896		MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
897	632
898		MCFG_NETLIST_LOGIC_INPUT("snd_nl", "snd0", "SOUND0.IN", 0, 1)
899		MCFG_NETLIST_LOGIC_INPUT("snd_nl", "snd7", "SOUND7.IN", 0, 1)
900		MCFG_NETLIST_LOGIC_INPUT("snd_nl", "dac", "DAC.VAL", 0, 255)
901
902		MCFG_NETLIST_STREAM_OUTPUT("snd_nl", 0, "ROUT.1")
903		MCFG_NETLIST_ANALOG_MULT_OFFSET(150000.0, 0.0)
904		#endif
905
906	633	MACHINE_CONFIG_END
907	634
908	635	MACHINE_CONFIG_FRAGMENT( masao_audio )

trunk/src/mame/drivers/20pacgal.c

r242990	r242991
341	341	PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNKNOWN )
342	342	INPUT_PORTS_END
343	343
344		static INPUT_PORTS_START( 25pacmano )
345		PORT_INCLUDE(20pacgal)
346	344
347		PORT_MODIFY("SERVICE")
348		PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_UNKNOWN )
349		PORT_BIT( 0x04, IP_ACTIVE_HIGH, IPT_UNKNOWN )
350		PORT_BIT( 0x08, IP_ACTIVE_HIGH, IPT_UNKNOWN )
351		PORT_BIT( 0x10, IP_ACTIVE_HIGH, IPT_UNKNOWN )
352		PORT_BIT( 0x20, IP_ACTIVE_HIGH, IPT_UNKNOWN )
353		PORT_BIT( 0x40, IP_ACTIVE_HIGH, IPT_UNKNOWN )
354		INPUT_PORTS_END
355	345
356	346	/*************************************
357	347	*
r242990	r242991
534	524	*************************************/
535	525
536	526	GAME( 2006, 25pacman,          0, 25pacman, 25pacman, _20pacgal_state, 25pacman, ROT90, "Namco / Cosmodog", "Pac-Man - 25th Anniversary Edition (Rev 3.00)", GAME_IMPERFECT_GRAPHICS | GAME_SUPPORTS_SAVE | GAME_NOT_WORKING )
537		GAME( 2005, 25pacmano,  25pacman, 20pacgal, 25pacmano,_20pacgal_state, 25pacman, ROT90, "Namco / Cosmodog", "Pac-Man - 25th Anniversary Edition (Rev 2.00)", GAME_IMPERFECT_GRAPHICS | GAME_SUPPORTS_SAVE)
	527	GAME( 2005, 25pacmano,  25pacman, 20pacgal, 25pacman, _20pacgal_state, 25pacman, ROT90, "Namco / Cosmodog", "Pac-Man - 25th Anniversary Edition (Rev 2.00)", GAME_IMPERFECT_GRAPHICS | GAME_SUPPORTS_SAVE)
538	528
539	529	GAME( 2000, 20pacgal,          0, 20pacgal, 20pacgal, _20pacgal_state, 20pacgal, ROT90, "Namco / Cosmodog", "Ms. Pac-Man/Galaga - 20th Anniversary Class of 1981 Reunion (V1.08)", GAME_IMPERFECT_GRAPHICS | GAME_SUPPORTS_SAVE)
540	530	GAME( 2000, 20pacgalr4, 20pacgal, 20pacgal, 20pacgal, _20pacgal_state, 20pacgal, ROT90, "Namco / Cosmodog", "Ms. Pac-Man/Galaga - 20th Anniversary Class of 1981 Reunion (V1.04)", GAME_IMPERFECT_GRAPHICS | GAME_SUPPORTS_SAVE)

trunk/src/mame/drivers/aleck64.c

r242990	r242991
336	336
337	337	if(data & 1) // 0 -> 1 transition
338	338	{
339		//for(int i=0;i<0x1000;i+=4)
340		//   space.write_dword(0x007502f4+i,space.read_dword(0xd0000000+i));
	339	for(int i=0;i<0x1000;i+=4)
	340	space.write_dword(0x007502f4+i,space.read_dword(0xd0000000+i));
341	341	}
342	342	break;
343	343	//0x1e bit 0 probably enables the chip
r242990	r242991
349	349
350	350	static ADDRESS_MAP_START( e90_map, AS_PROGRAM, 32, aleck64_state )
351	351	AM_IMPORT_FROM( n64_map )
352		AM_RANGE(0xd0000000, 0xd0000fff) AM_RAM // x/y offsets
353		AM_RANGE(0xd0010000, 0xd0010fff) AM_RAM // RGB555 palette
	352	AM_RANGE(0xd0000000, 0xd0000fff) AM_RAM
	353	AM_RANGE(0xd0010000, 0xd0010fff) AM_RAM
354	354	AM_RANGE(0xd0030000, 0xd003001f) AM_READWRITE16(e90_prot_r, e90_prot_w,0xffffffff)
355	355	ADDRESS_MAP_END
356	356

trunk/src/mame/drivers/chihiro.c

r242990	r242991
369	369	#include "debug/debugcon.h"
370	370	#include "debug/debugcmd.h"
371	371	#include "debug/debugcpu.h"
	372	#include "osdcore.h"
372	373	#include "includes/chihiro.h"
373	374
374	375	#define LOG_PCI

trunk/src/mame/drivers/itech32.c

r242990	r242991
76	76	Starting with GT Fore!, I.T. moved to a redesigned hardware platform known as the Eagle platform.
77	77	It has a main board with a 3Dfx video card and is hard drive based. This series started with
78	78	GT Fore! in 2000 and continued through 2006 ending with Golden Tee Complete. This final
79		version included all the courses from all the previous years in the Fore! series.
	79	version incuded all the courses from all the previous years in the Fore! series.
80	80	The Eagle platform also supports I.T.'s hunting series "Big Buck Hunter", the light game gun
81	81	called Carnival King as well as the limited release game Virtual Pool.
82	82
r242990	r242991
1615	1615
1616	1616	PORT_MODIFY("DIPS")
1617	1617	PORT_DIPNAME( 0x00100000, 0x00000000, "Trackball Orientation" ) PORT_DIPLOCATION("SW1:4")   /* Determined by actual use / trial & error */
1618		PORT_DIPSETTING(          0x00000000, "Normal Mount" )                      /* The manual says "Always on (default)" and "Off -- UNUSED --" */
	1618	PORT_DIPSETTING(          0x00000000, "Normal Mount" )                      /* The manual says "Always on (defualt)" and "Off -- UNUSED --" */
1619	1619	PORT_DIPSETTING(          0x00100000, "45 Degree Angle" )
1620	1620	PORT_DIPNAME( 0x00200000, 0x00000000, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW1:3")    /* Single controller version -  has no effect */
1621	1621	PORT_DIPSETTING(          0x00000000, DEF_STR( Off ) )
r242990	r242991
1631	1631
1632	1632	PORT_MODIFY("DIPS")
1633	1633	PORT_DIPNAME( 0x00100000, 0x00000000, "Trackball Orientation" ) PORT_DIPLOCATION("SW1:4")   /* Determined by actual use / trial & error */
1634		PORT_DIPSETTING(          0x00000000, "Normal Mount" )                      /* The manual says "Always on (default)" and "Off -- UNUSED --" */
	1634	PORT_DIPSETTING(          0x00000000, "Normal Mount" )                      /* The manual says "Always on (defualt)" and "Off -- UNUSED --" */
1635	1635	PORT_DIPSETTING(          0x00100000, "45 Degree Angle" )
1636	1636	PORT_DIPNAME( 0x00200000, 0x00000000, DEF_STR( Cabinet ) ) PORT_DIPLOCATION("SW1:3")
1637	1637	PORT_DIPSETTING(          0x00000000, DEF_STR( Upright ) )
r242990	r242991
2450	2450	ROM_CONTINUE(                 0x08000, 0x08000 )
2451	2451
2452	2452	ROM_REGION( 0x880000, "gfx1", 0 )
2453		/* No known set specifically checks for this, however the GROM data may be in the form of four 8 Meg roms:
	2453	/* No known set specificly checks for this, however the GROM data may be in the form of four 8 Meg roms:
2454	2454	ROM_LOAD32_BYTE( "wcb_grom0_0_+.grm0_0", 0x000000, 0x100000, CRC(40837737) SHA1(f073943ec6f84285a8559553fb292ec1f8a629d0) ) Labeled as "WCB GROM0_0 *" ect
2455	2455	ROM_LOAD32_BYTE( "wcb_grom0_1_+.grm0_1", 0x000001, 0x100000, CRC(1615aee8) SHA1(6184919371a894b1d6f2e06a2b328cb55abed4a9) )
2456	2456	ROM_LOAD32_BYTE( "wcb_grom0_2_+.grm0_2", 0x000002, 0x100000, CRC(d8e0b06e) SHA1(4981c0cf16df68a1b4da7ebf65ca587c21292478) )
r242990	r242991
2485	2485	ROM_CONTINUE(                 0x08000, 0x08000 )
2486	2486
2487	2487	ROM_REGION( 0x880000, "gfx1", 0 )
2488		/* No known set specifically checks for this, however the GROM data may be in the form of four 8 Meg roms:
	2488	/* No known set specificly checks for this, however the GROM data may be in the form of four 8 Meg roms:
2489	2489	ROM_LOAD32_BYTE( "wcb_grom0_0_+.grm0_0", 0x000000, 0x100000, CRC(40837737) SHA1(f073943ec6f84285a8559553fb292ec1f8a629d0) ) Labeled as "WCB GROM0_0 *" ect
2490	2490	ROM_LOAD32_BYTE( "wcb_grom0_1_+.grm0_1", 0x000001, 0x100000, CRC(1615aee8) SHA1(6184919371a894b1d6f2e06a2b328cb55abed4a9) )
2491	2491	ROM_LOAD32_BYTE( "wcb_grom0_2_+.grm0_2", 0x000002, 0x100000, CRC(d8e0b06e) SHA1(4981c0cf16df68a1b4da7ebf65ca587c21292478) )
r242990	r242991
2520	2520	ROM_CONTINUE(                 0x08000, 0x08000 )
2521	2521
2522	2522	ROM_REGION( 0x880000, "gfx1", 0 )
2523		/* No known set specifically checks for this, however the GROM data may be in the form of four 8 Meg roms:
	2523	/* No known set specificly checks for this, however the GROM data may be in the form of four 8 Meg roms:
2524	2524	ROM_LOAD32_BYTE( "wcb_grom0_0_+.grm0_0", 0x000000, 0x100000, CRC(40837737) SHA1(f073943ec6f84285a8559553fb292ec1f8a629d0) ) Labeled as "WCB GROM0_0 *" ect
2525	2525	ROM_LOAD32_BYTE( "wcb_grom0_1_+.grm0_1", 0x000001, 0x100000, CRC(1615aee8) SHA1(6184919371a894b1d6f2e06a2b328cb55abed4a9) )
2526	2526	ROM_LOAD32_BYTE( "wcb_grom0_2_+.grm0_2", 0x000002, 0x100000, CRC(d8e0b06e) SHA1(4981c0cf16df68a1b4da7ebf65ca587c21292478) )
r242990	r242991
2555	2555	ROM_CONTINUE(                 0x08000, 0x08000 )
2556	2556
2557	2557	ROM_REGION( 0x880000, "gfx1", 0 )
2558		/* No known set specifically checks for this, however the GROM data may be in the form of four 8 Meg roms:
	2558	/* No known set specificly checks for this, however the GROM data may be in the form of four 8 Meg roms:
2559	2559	ROM_LOAD32_BYTE( "wcb_grom0_0_+.grm0_0", 0x000000, 0x100000, CRC(40837737) SHA1(f073943ec6f84285a8559553fb292ec1f8a629d0) ) Labeled as "WCB GROM0_0 *" ect
2560	2560	ROM_LOAD32_BYTE( "wcb_grom0_1_+.grm0_1", 0x000001, 0x100000, CRC(1615aee8) SHA1(6184919371a894b1d6f2e06a2b328cb55abed4a9) )
2561	2561	ROM_LOAD32_BYTE( "wcb_grom0_2_+.grm0_2", 0x000002, 0x100000, CRC(d8e0b06e) SHA1(4981c0cf16df68a1b4da7ebf65ca587c21292478) )
r242990	r242991
2590	2590	ROM_CONTINUE(                 0x08000, 0x08000 )
2591	2591
2592	2592	ROM_REGION( 0x880000, "gfx1", 0 )
2593		/* No known set specifically checks for this, however the GROM data may be in the form of four 8 Meg roms:
	2593	/* No known set specificly checks for this, however the GROM data may be in the form of four 8 Meg roms:
2594	2594	ROM_LOAD32_BYTE( "wcb_grom0_0_+.grm0_0", 0x000000, 0x100000, CRC(40837737) SHA1(f073943ec6f84285a8559553fb292ec1f8a629d0) ) Labeled as "WCB GROM0_0 *" ect
2595	2595	ROM_LOAD32_BYTE( "wcb_grom0_1_+.grm0_1", 0x000001, 0x100000, CRC(1615aee8) SHA1(6184919371a894b1d6f2e06a2b328cb55abed4a9) )
2596	2596	ROM_LOAD32_BYTE( "wcb_grom0_2_+.grm0_2", 0x000002, 0x100000, CRC(d8e0b06e) SHA1(4981c0cf16df68a1b4da7ebf65ca587c21292478) )
r242990	r242991
2625	2625	ROM_CONTINUE(                 0x08000, 0x08000 )
2626	2626
2627	2627	ROM_REGION( 0x880000, "gfx1", 0 )
2628		/* No known set specifically checks for this, however the GROM data may be in the form of four 8 Meg roms:
	2628	/* No known set specificly checks for this, however the GROM data may be in the form of four 8 Meg roms:
2629	2629	ROM_LOAD32_BYTE( "wcb_grom0_0_+.grm0_0", 0x000000, 0x100000, CRC(40837737) SHA1(f073943ec6f84285a8559553fb292ec1f8a629d0) ) Labeled as "WCB GROM0_0 *" ect
2630	2630	ROM_LOAD32_BYTE( "wcb_grom0_1_+.grm0_1", 0x000001, 0x100000, CRC(1615aee8) SHA1(6184919371a894b1d6f2e06a2b328cb55abed4a9) )
2631	2631	ROM_LOAD32_BYTE( "wcb_grom0_2_+.grm0_2", 0x000002, 0x100000, CRC(d8e0b06e) SHA1(4981c0cf16df68a1b4da7ebf65ca587c21292478) )
r242990	r242991
3354	3354	ROM_LOAD32_BYTE( "gtg3_grom0_3++.grm0_3", 0x000003, 0x100000, CRC(1173a710) SHA1(1f612c1efbf38796707f5b5fecf9d4044691f031) )
3355	3355	/*
3356	3356	The above 4 roms have the same exact data as the other sets, but in 8 meg roms instead of 4 meg roms.
3357		This is the only set that specifically checks for these roms in this format
	3357	This is the only set that specificaly checks for these roms in this format
3358	3358	*/
3359	3359	ROM_LOAD32_BYTE( "gtg3_grom1_0+.grm1_0", 0x400000, 0x080000, CRC(80ae7148) SHA1(e19d3390a2a0dad260d770fdbbb64d1f8e43d53f) ) /* actually labeled "GTG3 GROM1_0*" ect */
3360	3360	ROM_LOAD32_BYTE( "gtg3_grom1_1+.grm1_1", 0x400001, 0x080000, CRC(0f85a618) SHA1(d9ced21c20f9ed6b7f19e7645d75b239ea709b79) )
r242990	r242991
4036	4036	ROM_LOAD32_BYTE( "gt2k_grom1_3.grm1_3", 0x200003, 0x80000, CRC(59f48688) SHA1(37b2c84e487f4f3a9145bef34c573a3716b4a6a7) )
4037	4037
4038	4038	/* GT99, GT2K & GT Classic all share the above listed 8 graphics roms and may be labeled GT99, GT2K or GTClassic */
4039		/* The Euro version has different GROM2_x compared to the standard US versions.  GT Supreme PCBs have been seen  */
	4039	/* The Euro version has different GROM2_x compared to the standard US versions.  GT Superme PCBs have been seen  */
4040	4040	/* with GT 2K mask roms as well as all GROMs labeled "GT SUPREME" */
4041	4041
4042	4042	ROM_LOAD32_BYTE( "gt_supreme_grom2_0.grm2_0", 0x400000, 0x80000, CRC(33998a3e) SHA1(53832e37c42155eb9c774eb33b8b36fe387fa162) )
r242990	r242991
4505	4505	NOTE: Due to various different upgrade packages from IT, the 3 tier boards can end up with any combination
4506	4506	of rom boards and sound boards.  For historical reasons, GTG3 3 tier S versions will use the oldest
4507	4507	sound file set up. Version L will use the newer Ensoniq sample rom and v2.X sound code, while gt97
4508		through gtclassic will use the latest "NR" versions.
	4508	through gtclassic will use the lastest "NR" versions.
4509	4509
4510	4510	GT Diamond Edition Tournament is a Euro GT98 with different GROM2_0 through GROM2_3
4511	4511	GT Royal Edition Tournament is a Euro GT99
4512	4512	GT Supreme Edition Tournament is a Euro GT2K with different GROM2_0 through GROM2_3
4513	4513	GT Supreme (on a real PCB with actual tournament data) comes up with a different title screen and is (c) 2002
4514		showing the title as GT Supreme Plus! and the Hole-In-One board shows an additional course, Coconut Cove from GT99
	4514	showing the title as GT Supreme Plus! and the Hole-In-One board shows an aditional course, Coconut Cove from GT99
4515	4515	Current emulation does not reproduce this extra title screen due to missing tournament data.
4516	4516	There doesn't seem to be a Euro version of GT Classic (at least none have been found).
4517	4517
4518	4518	NOTE: There is an "8 Meg board" version of the P/N 1083 Rev 2 PCB, so GROM0_0 through GROM0_3 are 8 meg roms and labeled "GTxx GROM0_0 **" ect
4519	4519	while GROM1_0 through GROM1_3 are 4 meg roms matching "4 Meg board" GROM2_0 through GROM2_3 and are labeled "GTxx GROM1_0 *" ect
4520		It is possible to find these rom combinations on any given GT board set.  There is only 1 known GT set which specifically checks for 8 meg
	4520	It is possible to find these rom combinations on any given GT board set.  There is only 1 known GT set which specificly checks for 8 meg
4521	4521	roms under the GROM Checksum test.
4522	4522
4523	4523	Parent set will always be gt(year) with the most recent version.  IE: gt97 is Golden Tee '97 v1.30

trunk/src/mame/drivers/naomi.c

r242990	r242991
521	521	Star Horse (satellite)                          840-0056C  23627    6 (128Mb)* 315-6319   315-6213  not present   * +1 (64Mb), requires 837-13785 ARCNET&IO BD
522	522	Star Horse Progress (satellite) (Rev A)         840-0123C  24122A   7 (128Mb)  315-6319A  315-6213  not present   requires 837-13785 ARCNET&IO BD
523	523	The King of Route 66 (Rev A)                    840-0087C  23819A  10 (128Mb)  315-6319A  315-6213  not present
524		Virtua Striker 3                                840-0061C  23663   11 (128Mb)  315-6319A  315-6213  317-0310-COM
525	524	Virtua Striker 3 (Rev B)                        840-0061C  23663B  11 (128Mb)  315-6319A  315-6213  317-0310-COM
	525	Virtua Striker 3 (Rev C)                        840-0061C  23663C  11 (128Mb)  315-6319A  315-6213  317-0310-COM
526	526	Wave Runner GP                                  840-0064C  24059    6 (128Mb)  315-6319A  315-6213  not present
527	527	Wild Riders                                     840-0046C  23622   10 (128Mb)  315-6319A  315-6213  317-0301-COM
528	528	WWF Royal Rumble                                840-0040C  22261    8 (128Mb)  315-6319   315-6213  317-0285-COM
r242990	r242991
6014	6014	ROM_LOAD( "wk1ma10.4c",  0xa000000, 0x1000000, CRC(e96f312c) SHA1(0a92640277111aef5c6e9dab4218a8ae2196ce61) )
6015	6015
6016	6016	ROM_REGION( 4, "rom_key", 0 )
6017		ROM_LOAD( "wldkicks-key.bin", 0, 4, CRC(1708ebb9) SHA1(c1115e4dd675f10d5fb41f57c1eea8e6a4f09fed) )
	6017	ROM_LOAD( "wldkicks-key.bin", 0, 4, CRC(c1e3000b) SHA1(36c2546833effe9452e2b3f7d31335fc5e349f49) )
6018	6018	ROM_END
6019	6019
6020	6020	ROM_START( wldkicksa )
r242990	r242991
6036	6036	ROM_LOAD( "wk1ma10.4c",  0xa000000, 0x1000000, CRC(e96f312c) SHA1(0a92640277111aef5c6e9dab4218a8ae2196ce61) )
6037	6037
6038	6038	ROM_REGION( 4, "rom_key", 0 )
6039		ROM_LOAD( "wldkicks-key.bin", 0, 4, CRC(1708ebb9) SHA1(c1115e4dd675f10d5fb41f57c1eea8e6a4f09fed) )
	6039	ROM_LOAD( "wldkicks-key.bin", 0, 4, CRC(c1e3000b) SHA1(36c2546833effe9452e2b3f7d31335fc5e349f49) )
6040	6040	ROM_END
6041	6041
6042	6042	ROM_START( wldkicksb )
r242990	r242991
6058	6058	ROM_LOAD( "wk1ma10.4c",  0xa000000, 0x1000000, CRC(e96f312c) SHA1(0a92640277111aef5c6e9dab4218a8ae2196ce61) )
6059	6059
6060	6060	ROM_REGION( 4, "rom_key", 0 )
6061		ROM_LOAD( "wldkicks-key.bin", 0, 4, CRC(1708ebb9) SHA1(c1115e4dd675f10d5fb41f57c1eea8e6a4f09fed) )
	6061	ROM_LOAD( "wldkicks-key.bin", 0, 4, CRC(c1e3000b) SHA1(36c2546833effe9452e2b3f7d31335fc5e349f49) )
6062	6062	ROM_END
6063	6063
6064	6064	ROM_START( toukon4 )
r242990	r242991
6085	6085	ROM_LOAD( "trf1ma15.6l", 0xf000000, 0x1000000, CRC(42d318c5) SHA1(f9fe82ffbfc51fcb52333f94c55a7092e7124fb4) )
6086	6086
6087	6087	ROM_REGION( 4, "rom_key", 0 )
6088		ROM_LOAD( "tr4ae-key.bin", 0x000000, 0x000004, CRC(1708ebb9) SHA1(c1115e4dd675f10d5fb41f57c1eea8e6a4f09fed) )
	6088	ROM_LOAD( "tr4ae-key.bin", 0x000000, 0x000004, CRC(986a7cee) SHA1(70c3ff80f86de6a0655251658c66a156fb644995) )
6089	6089	ROM_END
6090	6090
6091	6091	ROM_START( ninjaslt )
r242990	r242991
7790	7790	NAOMI_DEFAULT_EEPROM
7791	7791
7792	7792	ROM_REGION( 0xb000000, "rom_board", ROMREGION_ERASEFF)
7793		// rom was handmade from 2 damaged dumps, needs to be verified
7794		ROM_LOAD( "epr-23663.ic22", 0x0000000, 0x0400000, BAD_DUMP CRC(6910a008) SHA1(865affff1cf31321725ef727a17be384555e3aae) )
	7793	ROM_LOAD( "epr-23663c.ic22",0x0000000, 0x0400000, CRC(7007fec7) SHA1(523168f0b218d0bd5c815d65bf0caba2c8468c9d) )
7795	7794	ROM_LOAD( "mpr-23652.ic1",  0x0800000, 0x1000000, CRC(992758a2) SHA1(5e2a25c520c1795128e5026fc00d355c24852ded) )
7796	7795	ROM_LOAD( "mpr-23653.ic2",  0x1800000, 0x1000000, CRC(e210e932) SHA1(2f6f0a31c3e98b21f1ff3af1680e50b3535b130f) )
7797	7796	ROM_LOAD( "mpr-23654.ic3",  0x2800000, 0x1000000, CRC(91335971) SHA1(fc7599b836fb7995dd7da940e64b08b3c09cb180) )
r242990	r242991
7805	7804	ROM_LOAD( "mpr-23662.ic11", 0xa800000, 0x0800000, CRC(d6ef7d68) SHA1(4ee396af6c5caf4c5af6e9ad0e03a7ac2c5039f4) )
7806	7805
7807	7806	ROM_REGION( 4, "rom_key", 0 )
7808		ROM_LOAD( "vstrik3c-key.bin", 0, 4, CRC(8c9012fe) SHA1(d81e00d6377a3f0eeed01dc523707e36ca1b434d) )
	7807	ROM_LOAD( "vstrik3c-key.bin", 0, 4, CRC(049f41b0) SHA1(4ea444878c8e9288ec95b1763d48bc92c634acdd) )
7809	7808	ROM_END
7810	7809
7811	7810	ROM_START( vstrik3cb )
r242990	r242991
7827	7826	ROM_LOAD( "mpr-23662.ic11", 0xa800000, 0x0800000, CRC(d6ef7d68) SHA1(4ee396af6c5caf4c5af6e9ad0e03a7ac2c5039f4) )
7828	7827
7829	7828	ROM_REGION( 4, "rom_key", 0 )
7830		ROM_LOAD( "vstrik3c-key.bin", 0, 4, CRC(8c9012fe) SHA1(d81e00d6377a3f0eeed01dc523707e36ca1b434d) )
	7829	ROM_LOAD( "vstrik3c-key.bin", 0, 4, CRC(049f41b0) SHA1(4ea444878c8e9288ec95b1763d48bc92c634acdd) )
7831	7830	ROM_END
7832	7831
7833	7832	ROM_START( wldrider )
r242990	r242991
7848	7847	ROM_LOAD( "mpr-23620.ic10", 0x9800000, 0x1000000, CRC(67aa15a9) SHA1(42c24cbf7069c27430a71509a872cd1c4224aaeb) )
7849	7848
7850	7849	ROM_REGION( 4, "rom_key", 0 )
7851		ROM_LOAD( "wldrider-key.bin", 0, 4, CRC(7ac4f5fa) SHA1(5d08ecfbdc5f4bf26a9ea521a647c93141e7f635) )
	7850	ROM_LOAD( "wldrider-key.bin", 0, 4, CRC(f5a662ad) SHA1(a75b1e490d1f7d57cd8976115572266d1ca05202) )
7852	7851	ROM_END
7853	7852
7854	7853	ROM_START( vf4cart )
r242990	r242991
7870	7869	ROM_LOAD( "mpr-23784.ic11", 0xa800000, 0x1000000, CRC(f74f2fee) SHA1(84b07baa6d116727e66ef27e24ba6484c3393891) )
7871	7870
7872	7871	ROM_REGION( 4, "rom_key", 0 )
7873		ROM_LOAD( "vf4cart-key.bin", 0, 4, CRC(aa8cdd58) SHA1(e282b7d215044a005b50c8553b8056f3d599135c) )
	7872	ROM_LOAD( "vf4cart-key.bin", 0, 4, CRC(22838e16) SHA1(afee674dce3cfdd20360c30da2da5ba69f8d4682) )
7874	7873	ROM_END
7875	7874
7876	7875	// There is also a development cart (171-7885A) with 20x 64Mb FlashROMs instead of 10x 128Mb MaskROMs. Content is the same.
r242990	r242991
7993	7992	ROM_LOAD( "mpr-23703.ic11", 0xa800000, 0x1000000, CRC(702b8b4a) SHA1(3a8dfde458f341e7db20664382b9fce2b6e5d462) )
7994	7993
7995	7994	ROM_REGION( 4, "rom_key", 0 )
7996		ROM_LOAD( "clubkrte-key.bin", 0, 4, CRC(5420fd0a) SHA1(06cb480c12f0ddc10e7601d34c5f42dda6ac6145) )
	7995	ROM_LOAD( "clubkrte-key.bin", 0, 4, CRC(db426a5d) SHA1(6a6a0b80ec0416605541159efea379dc19fe796d) )
7997	7996	ROM_END
7998	7997
7999	7998	ROM_START( clubkrtd )
r242990	r242991
9035	9034
9036	9035	/* 840-xxxxx (Sega Naomi 2 cart games) */
9037	9036	/* 0046 */ GAME( 2001, wldrider, naomi2,  naomi2m2, naomi, naomi_state, naomi2,   ROT0, "Sega", "Wild Riders (JPN, USA, EXP, KOR, AUS)", GAME_FLAGS )
9038		/* 0061 */ GAME( 2001, vstrik3c, naomi2,  naomi2m2, naomi, naomi_state, naomi2,   ROT0, "Sega", "Virtua Striker 3 (USA, EXP, KOR, AUS) (Cart)", GAME_FLAGS )
	9037	/* 0061 */ GAME( 2001, vstrik3c, naomi2,  naomi2m2, naomi, naomi_state, naomi2,   ROT0, "Sega", "Virtua Striker 3 (USA, EXP, KOR, AUS) (Cart, Rev C)", GAME_FLAGS )
9039	9038	/* 0061 */ GAME( 2001, vstrik3cb,vstrik3c,naomi2m2, naomi, naomi_state, naomi2,   ROT0, "Sega", "Virtua Striker 3 (USA, EXP, KOR, AUS) (Cart, Rev B)", GAME_FLAGS )
9040	9039	/* 0062 */ GAME( 2001, clubkrte, naomi2,  naomi2m2, naomi, naomi_state, naomi2,   ROT0, "Sega", "Club Kart: European Session", GAME_FLAGS )
9041	9040	/* 0062 */ GAME( 2001, clubkrtd, clubkrte,naomi2m2, naomi, naomi_state, naomi2,   ROT0, "Sega", "Club Kart: European Session (Rev D)", GAME_FLAGS )

trunk/src/mame/drivers/nl_pongd.c

r242990	r242991
65	65	*
66	66	*/
67	67
68		// identify unknown devices in IDE
69	68
70		//#define NETLIST_DEVELOPMENT 1
71
72	69	#include "netlist/nl_dice_compat.h"
73	70	#include "netlist/devices/net_lib.h"
74	71	#include "netlist/analog/nld_twoterm.h"

trunk/src/mame/drivers/peplus.c

r242990	r242991
3687	3687	ROM_REGION( 0x020000, "gfx1", 0 )
3688	3688	ROM_LOAD( "mro-cg2153.u72",   0x00000, 0x8000, CRC(004c9c8e) SHA1(ec3fa9d2c658de59e722d9979513d6b0c71d5742) ) /*  05/01/95   @ IGT  L95-1123  */
3689	3689	ROM_LOAD( "mgo-cg2153.u73",   0x08000, 0x8000, CRC(e6843b35) SHA1(2d5219a3cb054ce8b470797c0496c7e24e94ed81) )
3690		ROM_LOAD( "mbo-cg2153.u74",   0x10000, 0x8000, CRC(e3e28611) SHA1(d040f1df6203dc0bd6a79a391fb90fb930f8dd1a) ) /* Custom Arizona Charlie's Casino card backs */
	3690	ROM_LOAD( "mbo-cg2153.u74",   0x10000, 0x8000, CRC(e3e28611) SHA1(d040f1df6203dc0bd6a79a391fb90fb930f8dd1a) ) /* Custom Arizona Charlie's Casino graphics */
3691	3691	ROM_LOAD( "mxo-cg2153.u75",   0x18000, 0x8000, CRC(3ae44f7e) SHA1(00d625b60bffef6ce622cb50a3aa93b92131f578) )
3692	3692
3693	3693	ROM_REGION( 0x100, "proms", 0 )
r242990	r242991
4772	4772	Four of a Kind Bonus Poker
4773	4773	Deuces Wild Poker
4774	4774
4775		Also uses a Dallas (Maxim) DS1216 SmartWatch RAM for RTC (Real Time Clock) functions
4776
4777	4775	Came out of an IGT machine with belly glass calling it Montana Choice
4778	4776	*/
4779	4777	ROM_REGION( 0x10000, "maincpu", 0 )
r242990	r242991
5393	5391	ROM_LOAD( "x000055p.u66",   0x00000, 0x10000, CRC(e06819df) SHA1(36590c4588b8036908e63714fbb3e77d23e60eae) ) /* Deuces Wild Poker */
5394	5392
5395	5393	ROM_REGION( 0x020000, "gfx1", 0 )
5396		ROM_LOAD( "mro-cg2291.u77",  0x00000, 0x8000, CRC(db4e491c) SHA1(e371e7b236962a0f30640c683d3a0a302c51aee9) ) /* Custom The Orleans card backs */
	5394	ROM_LOAD( "mro-cg2291.u77",  0x00000, 0x8000, CRC(db4e491c) SHA1(e371e7b236962a0f30640c683d3a0a302c51aee9) ) /* Custom The Orleans graphics */
5397	5395	ROM_LOAD( "mgo-cg2291.u78",  0x08000, 0x8000, CRC(17bb35f8) SHA1(ba9e8aa3ff42b17c7be6ee46c70db22d8e60e52c) ) /* Compatible with most "standard" game sets */
5398	5396	ROM_LOAD( "mbo-cg2291.u79",  0x10000, 0x8000, CRC(de1036e4) SHA1(774bbcda301754dc4a606974248847a2264c3827) )
5399	5397	ROM_LOAD( "mxo-cg2291.u80",  0x18000, 0x8000, CRC(7049403c) SHA1(3a29a00fb8dfdb30dba757c1536151827ea09068) )
r242990	r242991
5418	5416	ROM_LOAD( "x000055p.u66",   0x00000, 0x10000, CRC(e06819df) SHA1(36590c4588b8036908e63714fbb3e77d23e60eae) ) /* Deuces Wild Poker */
5419	5417
5420	5418	ROM_REGION( 0x020000, "gfx1", 0 )
5421		ROM_LOAD( "mro-cg2399.u72",  0x00000, 0x8000, CRC(0424f4ba) SHA1(c8b192a6f63c8c9937cb3923d27b9ba2c39823cd) ) /* Custom The Fun Ships card backs */
	5419	ROM_LOAD( "mro-cg2399.u72",  0x00000, 0x8000, CRC(0424f4ba) SHA1(c8b192a6f63c8c9937cb3923d27b9ba2c39823cd) ) /* Custom The Fun Ships graphics */
5422	5420	ROM_LOAD( "mgo-cg2399.u73",  0x08000, 0x8000, CRC(5848a2fa) SHA1(4173a473016b7a776d2b59bf3ded0be35bd43721) )
5423	5421	ROM_LOAD( "mbo-cg2399.u74",  0x10000, 0x8000, CRC(5c3e16f6) SHA1(a4aa457f239527bffa6472e0d6f9d836f796b326) )
5424	5422	ROM_LOAD( "mxo-cg2399.u75",  0x18000, 0x8000, CRC(bd7669d5) SHA1(4343a9764fd563e2e1cdd8558f2f53f77006b159) )
r242990	r242991
5443	5441	ROM_LOAD( "x000055p.u66",   0x00000, 0x10000, CRC(e06819df) SHA1(36590c4588b8036908e63714fbb3e77d23e60eae) ) /* Deuces Wild Poker */
5444	5442
5445	5443	ROM_REGION( 0x020000, "gfx1", 0 )
5446		ROM_LOAD( "mro-cg2374.u72",  0x00000, 0x8000, CRC(ceeb714d) SHA1(6de908d04bcaa243195943affa9ad0d725de5c81) ) /* Custom Horseshoe Casino card backs */
5447		ROM_LOAD( "mgo-cg2374.u73",  0x08000, 0x8000, CRC(d0fabad5) SHA1(438ebe074fa3eaa3073ef042f481449f416d0665) )
5448		ROM_LOAD( "mbo-cg2374.u74",  0x10000, 0x8000, CRC(9a0fbc8d) SHA1(aa39f47cbeaf8218fd2d753c9a350e9eab5df5d3) )
5449		ROM_LOAD( "mxo-cg2374.u75",  0x18000, 0x8000, CRC(99814562) SHA1(2d8e132f4cc4edd06332c0327927219513b22832) )
	5444	ROM_LOAD( "mro-cg2185.u77",  0x00000, 0x8000, CRC(7e64bd1a) SHA1(e988a380ee58078bf5bdc7747e83aed1393cfad8) ) /*  07/10/95   @ IGT  L95-1506  */
	5445	ROM_LOAD( "mgo-cg2185.u78",  0x08000, 0x8000, CRC(d4127893) SHA1(75039c45ba6fd171a66876c91abc3191c7feddfc) )
	5446	ROM_LOAD( "mbo-cg2185.u79",  0x10000, 0x8000, CRC(17dba955) SHA1(5f77379c88839b3a04e235e4fb0120c77e17b60e) )
	5447	ROM_LOAD( "mxo-cg2185.u80",  0x18000, 0x8000, CRC(583eb3b1) SHA1(4a2952424969917fb1594698a779fe5a1e99bff5) )
5450	5448
5451	5449	ROM_REGION( 0x200, "proms", 0 )
5452		ROM_LOAD( "capx2374.u43", 0x0000, 0x0200, CRC(f922e1b8) SHA1(4aa5291c59431c022dc0561a6e3b38209f60286a) )
	5450	ROM_LOAD( "capx1321.u43", 0x0000, 0x0200, CRC(4b57569f) SHA1(fa29c0f627e7ce79951ec6dadec114864144f37d) )
5453	5451	ROM_END
5454	5452
5455	5453	ROM_START( pex0055pd ) /* Superboard : Deuces Wild Poker (X000055P+XP000035) */
r242990	r242991
7940	7938	ROM_LOAD( "x002374p.u66",   0x00000, 0x10000, CRC(fc4b6c8d) SHA1(b101f9042bd54dbfdeed4c7a3acf3798096f6857) ) /* Super Aces Poker */
7941	7939
7942	7940	ROM_REGION( 0x020000, "gfx1", 0 )
7943		ROM_LOAD( "mro-cg2324.u77",  0x00000, 0x8000, CRC(6eceef42) SHA1(a2ddd2a3290c41e510f483c6b633fe0002694d0b) )
7944		ROM_LOAD( "mgo-cg2324.u78",  0x08000, 0x8000, CRC(26d0acbe) SHA1(09a9127deb88185cd5b748bac657461eadb2f48f) )
7945		ROM_LOAD( "mbo-cg2324.u79",  0x10000, 0x8000, CRC(47baee32) SHA1(d8af09022ccb5fc06aa3aa4c200a734b66cbee00) )
7946		ROM_LOAD( "mxo-cg2324.u80",  0x18000, 0x8000, CRC(60449fc0) SHA1(251d1e04786b70c1d2bc7b02f3b69cd58ac76398) )
	7941	ROM_LOAD( "mro-cg2374.u72",  0x00000, 0x8000, CRC(ceeb714d) SHA1(6de908d04bcaa243195943affa9ad0d725de5c81) ) /* Custom Horseshoe Casino card backs */
	7942	ROM_LOAD( "mgo-cg2374.u73",  0x08000, 0x8000, CRC(d0fabad5) SHA1(438ebe074fa3eaa3073ef042f481449f416d0665) )
	7943	ROM_LOAD( "mbo-cg2374.u74",  0x10000, 0x8000, CRC(9a0fbc8d) SHA1(aa39f47cbeaf8218fd2d753c9a350e9eab5df5d3) )
	7944	ROM_LOAD( "mxo-cg2374.u75",  0x18000, 0x8000, CRC(99814562) SHA1(2d8e132f4cc4edd06332c0327927219513b22832) )
7947	7945
7948	7946	ROM_REGION( 0x200, "proms", 0 )
7949		ROM_LOAD( "capx1321.u43", 0x0000, 0x0200, CRC(4b57569f) SHA1(fa29c0f627e7ce79951ec6dadec114864144f37d) )
	7947	ROM_LOAD( "cap2374.u43", 0x0000, 0x0200, CRC(f922e1b8) SHA1(4aa5291c59431c022dc0561a6e3b38209f60286a) )
7950	7948	ROM_END
7951	7949
7952	7950	ROM_START( pex2377p ) /* Superboard : Super Double Bonus Poker (X002377P+XP000112) */
r242990	r242991
9265	9263	GAMEL(1995, pex0055p,  0,         peplus,  peplus_poker, peplus_state, peplussb, ROT0,  "IGT - International Game Technology", "Player's Edge Plus (X000055P+XP000019) Deuces Wild Poker",   0, layout_pe_poker )
9266	9264	GAMEL(1995, pex0055pa, pex0055p,  peplus,  peplus_poker, peplus_state, peplussb, ROT0,  "IGT - International Game Technology", "Player's Edge Plus (X000055P+XP000022) Deuces Wild Poker (The Orleans)", 0, layout_pe_poker )
9267	9265	GAMEL(1995, pex0055pb, pex0055p,  peplus,  peplus_poker, peplus_state, peplussb, ROT0,  "IGT - International Game Technology", "Player's Edge Plus (X000055P+XP000023) Deuces Wild Poker (The Fun Ships)", 0, layout_pe_poker )
9268		GAMEL(1995, pex0055pc, pex0055p,  peplus,  peplus_poker, peplus_state, peplussb, ROT0,  "IGT - International Game Technology", "Player's Edge Plus (X000055P+XP000028) Deuces Wild Poker (Horseshoe)", 0, layout_pe_poker )
	9266	GAMEL(1995, pex0055pc, pex0055p,  peplus,  peplus_poker, peplus_state, peplussb, ROT0,  "IGT - International Game Technology", "Player's Edge Plus (X000055P+XP000028) Deuces Wild Poker",  0, layout_pe_poker )
9269	9267	GAMEL(1995, pex0055pd, pex0055p,  peplus,  peplus_poker, peplus_state, peplussb, ROT0,  "IGT - International Game Technology", "Player's Edge Plus (X000055P+XP000035) Deuces Wild Poker",   0, layout_pe_poker )
9270	9268	GAMEL(1995, pex0055pe, pex0055p,  peplus,  peplus_poker, peplus_state, peplussb, ROT0,  "IGT - International Game Technology", "Player's Edge Plus (X000055P+XP000038) Deuces Wild Poker",   0, layout_pe_poker )
9271	9269	GAMEL(1995, pex0055pf, pex0055p,  peplus,  peplus_poker, peplus_state, peplussb, ROT0,  "IGT - International Game Technology", "Player's Edge Plus (X000055P+XP000040) Deuces Wild Poker",   0, layout_pe_poker )
r242990	r242991
9363	9361	GAMEL(1995, pex2308p,  0,         peplus,  peplus_poker, peplus_state, peplussb, ROT0,  "IGT - International Game Technology", "Player's Edge Plus (X002308P+XP000112) Triple Double Bonus Poker", 0, layout_pe_poker )
9364	9362	GAMEL(1995, pex2310p,  0,         peplus,  peplus_poker, peplus_state, peplussb, ROT0,  "IGT - International Game Technology", "Player's Edge Plus (X002310P+XP000112) Triple Double Bonus Poker", 0, layout_pe_poker )
9365	9363	GAMEL(1995, pex2314p,  0,         peplus,  peplus_poker, peplus_state, peplussb, ROT0,  "IGT - International Game Technology", "Player's Edge Plus (X002314P+XP000112) Triple Bonus Poker Plus", 0, layout_pe_poker )
9366		GAMEL(1995, pex2374p,  0,         peplus,  peplus_poker, peplus_state, peplussb, ROT0,  "IGT - International Game Technology", "Player's Edge Plus (X002374P+XP000112) Super Aces Poker",    0, layout_pe_poker )
	9364	GAMEL(1995, pex2374p,  0,         peplus,  peplus_poker, peplus_state, peplussb, ROT0,  "IGT - International Game Technology", "Player's Edge Plus (X002374P+XP000112) Super Aces Poker (Horseshoe)", 0, layout_pe_poker )
9367	9365	GAMEL(1995, pex2377p,  0,         peplus,  peplus_poker, peplus_state, peplussb, ROT0,  "IGT - International Game Technology", "Player's Edge Plus (X002377P+XP000112) Super Double Bonus Poker", 0, layout_pe_poker )
9368	9366	GAMEL(1995, pex2419p,  0,         peplus,  peplus_poker, peplus_state, peplussb, ROT0,  "IGT - International Game Technology", "Player's Edge Plus (X002419P+XP000064) Deuces Wild Bonus Poker - French", 0, layout_pe_poker )
9369	9367	GAMEL(1995, pex2420p,  0,         peplus,  peplus_poker, peplus_state, peplussb, ROT0,  "IGT - International Game Technology", "Player's Edge Plus (X002420P+XP000064) Deuces Wild Bonus Poker - French", 0, layout_pe_poker )

trunk/src/mame/drivers/snowbros.c

r242990	r242991
185	185	if (ACCESSING_BITS_0_7) soundlatch_byte_w(space,0,data & 0xff);
186	186	}
187	187
188		READ16_MEMBER(snowbros_state::toto_read)
189		{
190		int pc = space.device().safe_pc();
191		if ((pc!= 0x3f010) && (pc!= 0x38008)) printf("toto prot %08x %04x\n", pc, mem_mask);
192		return 0x0700;
193		}
194
195	188	/* Snow Bros Memory Map */
196	189
197	190	static ADDRESS_MAP_START( snowbros_map, AS_PROGRAM, 16, snowbros_state )
r242990	r242991
1962	1955	ROM_LOAD16_BYTE( "wb09.bin",     0x60001, 0x10000, CRC(9be718ca) SHA1(5c195e4f13efbdb229201d2408d018861bf389cc) )
1963	1956	ROM_END
1964	1957
1965		ROM_START( toto )
1966		ROM_REGION( 0x40000, "maincpu", 0 )
1967		ROM_LOAD16_BYTE( "u60.5j",  0x00000, 0x20000, CRC(39203792) SHA1(4c8d560be02a514cbf91774c7a0b4a95cf573356) )
1968		ROM_LOAD16_BYTE( "u51.4j",  0x00001, 0x20000, CRC(7b846cd4) SHA1(04aa0bbaab4303fb08dff52d5515f7e764f1be6d))
1969
1970		ROM_REGION( 0x10000, "soundcpu", 0 )    /* 64k for z80 sound code */
1971		ROM_LOAD( "u46.4c",   0x0000, 0x8000, CRC(77b1ef42) SHA1(75e3c8c2b687669cc56f972dd7375dab5185859c) )
1972
1973		ROM_REGION( 0x80000, "gfx1", 0 )
1974		ROM_LOAD( "u107.8k",          0x00000, 0x20000, CRC(4486153b) SHA1(a6dc0c17bf2328ab725bce4aaa0a413a42129fb0) )
1975		ROM_LOAD( "u108.8l",          0x20000, 0x20000, CRC(3286cf5f) SHA1(133366b0e10ab86111247cbedf329e8e3a7f2148) )
1976		ROM_LOAD( "u109.8m",          0x40000, 0x20000, CRC(464d7251) SHA1(f03ee54e9301ea87de4171cecdbad4a5e17929c4) )
1977		ROM_LOAD( "u110.8n",          0x60000, 0x20000, CRC(7dea56df) SHA1(7e7b9238837c6f4221cff416a2de21723d2c9272) )
1978		ROM_END
1979
1980	1958	/* Barko */
1981	1959
1982	1960	ROM_START( honeydol )
r242990	r242991
2888	2866
2889	2867
2890	2868
2891		DRIVER_INIT_MEMBER(snowbros_state,toto)
2892		{
2893		// every single rom has bits 0x10 and 0x08 swapped
2894		UINT8 *src = memregion("maincpu")->base();
2895		int len = memregion("maincpu")->bytes();
2896
2897		for (int i = 0; i < len; i++)
2898		{
2899		src[i] = BITSWAP8(src[i], 7, 6, 5, 3, 4, 2, 1, 0);
2900		}
2901
2902		src = memregion("gfx1")->base();
2903		len = memregion("gfx1")->bytes();
2904
2905		for (int i = 0; i < len; i++)
2906		{
2907		src[i] = BITSWAP8(src[i], 7, 6, 5, 3, 4, 2, 1, 0);
2908		}
2909
2910		src = memregion("soundcpu")->base();
2911		len = memregion("soundcpu")->bytes();
2912
2913		for (int i = 0; i < len; i++)
2914		{
2915		src[i] = BITSWAP8(src[i], 7, 6, 5, 3, 4, 2, 1, 0);
2916		}
2917
2918		// protection? (just return 0x07)
2919		m_maincpu->space(AS_PROGRAM).install_read_handler(0x500006, 0x500007, read16_delegate(FUNC(snowbros_state::toto_read),this));
2920		}
2921
2922
2923
2924	2869	GAME( 1990, snowbros,  0,        snowbros, snowbros, driver_device, 0, ROT0, "Toaplan",                        "Snow Bros. - Nick & Tom (set 1)", 0 )
2925	2870	GAME( 1990, snowbrosa, snowbros, snowbros, snowbros, driver_device, 0, ROT0, "Toaplan",                        "Snow Bros. - Nick & Tom (set 2)", 0 )
2926	2871	GAME( 1990, snowbrosb, snowbros, snowbros, snowbros, driver_device, 0, ROT0, "Toaplan",                        "Snow Bros. - Nick & Tom (set 3)", 0 )
r242990	r242991
2930	2875	GAME( 1990, wintbob,   snowbros, wintbob,  snowbros, driver_device, 0, ROT0, "bootleg (Sakowa Project Korea)", "The Winter Bobble (bootleg of Snow Bros.)", 0 )
2931	2876	GAME( 1990, snowbroswb,snowbros, wintbob,  snowbros, driver_device, 0, ROT0, "bootleg",                        "Snow Bros. - Nick & Tom (The Winter Bobble hardware bootleg)", 0 ) // this was probably unhacked back from the more common Winter Bobble to make it look more original
2932	2877
2933		GAME( 1996, toto,      0,        snowbros, snowbros, snowbros_state, toto, ROT0, "SoftClub",                    "Come Back Toto", 0 ) // modified from 'snowbros' code
2934
2935	2878	// none of the games below are on genuine SnowBros hardware, but they clone the functionality of it.
2936	2879
2937	2880	// SemiCom / Jeil titles are protected, a dumb MCU copies code into RAM at startup, some also check for a specific return value from an address on startup.

trunk/src/mame/drivers/twinkle.c

r242990	r242991
254	254	m_maincpu(*this, "maincpu"),
255	255	m_audiocpu(*this, "audiocpu")
256	256	{
	257	m_spu_hle[0x200] = 0;
	258	m_spu_hle[0x202] = 0;
257	259	}
258	260
259	261	required_device<am53cf96_device> m_am53cf96;
r242990	r242991
262	264
263	265	UINT16 m_spu_ctrl;      // SPU board control register
264	266	UINT8 m_spu_shared[0x400];  // SPU/PSX shared dual-ported RAM
	267	UINT8 m_spu_hle[0x400];
265	268	UINT32 m_spu_ata_dma;
266	269	int m_spu_ata_dmarq;
267	270
r242990	r242991
282	285	DECLARE_WRITE16_MEMBER(twinkle_waveram_w);
283	286	DECLARE_READ16_MEMBER(shared_68k_r);
284	287	DECLARE_WRITE16_MEMBER(shared_68k_w);
285		DECLARE_READ16_MEMBER(unk_68k_r);
286	288	DECLARE_WRITE_LINE_MEMBER(spu_ata_irq);
287	289	DECLARE_WRITE_LINE_MEMBER(spu_ata_dmarq);
288	290	required_device<cpu_device> m_maincpu;
r242990	r242991
669	671
670	672	WRITE8_MEMBER(twinkle_state::shared_psx_w)
671	673	{
672		//   printf("shared_psx_w: %04x, %04x, %04x\n", offset, data, mem_mask);
	674	//printf("shared_psx_w: %04x, %04x, %04x\n", offset, data, mem_mask);
673	675
674	676	m_spu_shared[offset] = data;
675	677
	678	// HLE sound board
	679	m_spu_hle[offset] = data;
	680
676	681	if (offset == 0x03fe && data == 0xff)
677	682	{
678		//      printf("spu command %02x %02x\n", m_spu_shared[1], m_spu_shared[3]);
	683	//printf("spu command %02x %02x\n", m_spu_hle[1], m_spu_hle[3]);
679	684
680		m_audiocpu->set_input_line(M68K_IRQ_4, HOLD_LINE);
	685	for (int i = 0x200; i < 0x300; i++) m_spu_hle[i] = 0xea;
	686
	687	switch (m_spu_hle[1])
	688	{
	689	case 0x91: // hdd sum 1
	690	m_spu_hle[0x200] = 0; // ?
	691	m_spu_hle[0x202] = 0; // ?
	692	break;
	693
	694	case 0x9a: // hdd sum 2
	695	m_spu_hle[0x200] = 0; // ?
	696	m_spu_hle[0x202] = 0; // ?
	697	m_spu_hle[0x203] = 1; // Must be 1 to pass test
	698	break;
	699
	700	case 0xa1: // version
	701	m_spu_hle[0x200] = 0; // ?
	702	m_spu_hle[0x202] = 0; // ?
	703
	704	if (strcmp(machine().system().name, "bmiidx") == 0 ||
	705	strcmp(machine().system().name, "bmiidxa") == 0 ||
	706	strcmp(machine().system().name, "bmiidxc") == 0 ||
	707	strcmp(machine().system().name, "bmiidxca") == 0)
	708	{
	709	strcpy((char *)&m_spu_hle[0x204], "GQ863JA_A");
	710	}
	711	else if (strcmp(machine().system().name, "bmiidxs") == 0 ||
	712	strcmp(machine().system().name, "bmiidxc2") == 0)
	713	{
	714	strcpy((char *)&m_spu_hle[0x204], "GC983JA_R");
	715	}
	716	else if (strcmp(machine().system().name, "bmiidx2") == 0)
	717	{
	718	strcpy((char *)&m_spu_hle[0x204], "GC985JA_A");
	719	}
	720	else if (strcmp(machine().system().name, "bmiidx3") == 0 ||
	721	strcmp(machine().system().name, "bmiidx3a") == 0)
	722	{
	723	strcpy((char *)&m_spu_hle[0x204], "GC992JA_A");
	724	}
	725	else if (strcmp(machine().system().name, "bmiidx4") == 0)
	726	{
	727	strcpy((char *)&m_spu_hle[0x204], "GCA03JA_A");
	728	}
	729	else if (strcmp(machine().system().name, "bmiidx5") == 0)
	730	{
	731	strcpy((char *)&m_spu_hle[0x204], "GCA17JA_A");
	732	}
	733	else if (strcmp(machine().system().name, "bmiidx6") == 0 ||
	734	strcmp(machine().system().name, "bmiidx6a") == 0)
	735	{
	736	strcpy((char *)&m_spu_hle[0x204], "GCB4UJA_A");
	737	}
	738	else if (strcmp(machine().system().name, "bmiidx7") == 0)
	739	{
	740	strcpy((char *)&m_spu_hle[0x204], "GCB44JA_A");
	741	}
	742	else if (strcmp(machine().system().name, "bmiidx8") == 0)
	743	{
	744	strcpy((char *)&m_spu_hle[0x204], "GCC44JA_A");
	745	}
	746	break;
	747
	748	case 0x30: // play sound [3]=sound code
	749	case 0x51: // sound off
	750	case 0x25: // spu rom error ([3]==0x0f)
	751	case 0x26: // spu rom error ([3]==0x0f)
	752	case 0x08: // spu rom error
	753	case 0x40: // spu rom error ([3]==0x01 coin sound?)
	754	case 0x2f: // spu rom error
	755	case 0x52: // spu rom error
	756	case 0x04: // spu rom error ([3]==?)
	757	m_spu_hle[0x200] = 0;
	758	m_spu_hle[0x202] = 0;
	759	break;
	760	}
681	761	}
682	762	}
683	763
684	764	READ8_MEMBER(twinkle_state::shared_psx_r)
685	765	{
686		UINT32 result = m_spu_shared[offset];
	766	//UINT32 result = m_spu_shared[offset];
	767	UINT32 result = m_spu_hle[offset];
687	768
688	769	//printf("shared_psx_r: %04x, %04x, %04x\n", offset, result, mem_mask);
689	770
r242990	r242991
722	803	/*
723	804	System control register (Konami always has one)
724	805
725		bit 7  = write 0 to ack IRQ 1, write 1 to enable (IRQ 1 appears to be an RF5C400-related timer, or some free-running timing source)
	806	bit 7  = write 0 to ack IRQ 1, write 1 to enable (IRQ 1 appears to be vblank)
726	807	bit 8  = write 0 to ack IRQ 2, write 1 to enable (IRQ 2 appears to be DMA completion)
727		bit 9  = write 0 to ack IRQ 4, write 1 to enable (IRQ 4 is "command available")
728		bit 10 = write 0 to ack IRQ 6, write 1 to enable (IRQ 6 is the ATA IRQ)
729		bit 11 = watchdog toggle
	808	bit 9  = write 0 to ack IRQ 4, write 1 to enable (IRQ 4 appears to be "command sent", unsure how the MIPS causes it yet however)
	809	bit 10 = write 0 to ack IRQ 6, write 1 to enable (IRQ 6 is IDE)
	810	bit 11 = watchdog toggle?
730	811
731	812	Other bits unknown.
732	813	*/
r242990	r242991
755	836	WRITE16_MEMBER(twinkle_state::spu_ata_dma_low_w)
756	837	{
757	838	m_spu_ata_dma = (m_spu_ata_dma & ~0xffff) | data;
	839
	840	//printf("dma_low %08x\n", m_spu_ata_dma * 2);
758	841	}
759	842
760	843	WRITE16_MEMBER(twinkle_state::spu_ata_dma_high_w)
761	844	{
762	845	m_spu_ata_dma = (m_spu_ata_dma & 0xffff) | (data << 16);
	846
	847	//printf("dma_high %08x\n", m_spu_ata_dma * 2);
763	848	}
764	849
765	850	WRITE_LINE_MEMBER(twinkle_state::spu_ata_dmarq)
r242990	r242991
779	864	//waveram[m_spu_ata_dma++] = (data >> 8) | (data << 8);
780	865	// bp 4a0e ;bmiidx4 checksum
781	866	// bp 4d62 ;bmiidx4 dma
782
783		// $$$HACK - game DMAs nothing useful to 0x400000 but all sound plays are 0x400000 or above
784		//           so limit sound RAM to 4MB (there's 6 MB on the board) and let the 5c400's address masking
785		//           work for us until we figure out what's actually going on.
786		if (m_spu_ata_dma < 0x200000)
787		{
788		m_waveram[m_spu_ata_dma++] = data;
789		}
	867	m_waveram[m_spu_ata_dma++] = data;
790	868	}
791	869
792	870	m_ata->write_dmack(CLEAR_LINE);
r242990	r242991
808	886	{
809	887	UINT16 result = m_spu_shared[offset];
810	888
811		//   printf("shared_68k_r: %04x, %04x, %04x\n", offset, result, mem_mask);
	889	//printf("shared_68k_r: %04x, %04x, %04x\n", offset, result, mem_mask);
812	890
813	891	return result;
814	892	}
815	893
816	894	WRITE16_MEMBER(twinkle_state::shared_68k_w)
817	895	{
818		//   printf("shared_68k_w: %04x, %04x, %04x\n", offset, data, mem_mask);
	896	//printf("shared_68k_w: %04x, %04x, %04x\n", offset, data, mem_mask);
819	897
820	898	m_spu_shared[offset] = data & 0xff;
821	899	}
822	900
823		READ16_MEMBER(twinkle_state::unk_68k_r)
824		{
825		return 0xffff;   // must return 0xff for 68000 POST to complete properly
826		}
827
828	901	static ADDRESS_MAP_START( sound_map, AS_PROGRAM, 16, twinkle_state )
829	902	AM_RANGE(0x000000, 0x07ffff) AM_ROM
830	903	AM_RANGE(0x100000, 0x13ffff) AM_RAM
831		AM_RANGE(0x200000, 0x200001) AM_READ(unk_68k_r)
832	904	// 220000 = LEDs?
833	905	AM_RANGE(0x230000, 0x230003) AM_WRITE(twinkle_spu_ctrl_w)
834	906	AM_RANGE(0x240000, 0x240003) AM_WRITE(spu_ata_dma_low_w)
r242990	r242991
837	909	AM_RANGE(0x280000, 0x280fff) AM_READWRITE(shared_68k_r, shared_68k_w)
838	910	AM_RANGE(0x300000, 0x30000f) AM_DEVREADWRITE("ata", ata_interface_device, read_cs0, write_cs0)
839	911	// 34000E = ???
840		AM_RANGE(0x34000e, 0x34000f) AM_WRITENOP
841	912	AM_RANGE(0x400000, 0x400fff) AM_DEVREADWRITE("rfsnd", rf5c400_device, rf5c400_r, rf5c400_w)
842		AM_RANGE(0x800000, 0xbfffff) AM_READWRITE(twinkle_waveram_r, twinkle_waveram_w )
843		AM_RANGE(0xfe0000, 0xffffff) AM_RAM   // ...and the RAM test checks this last 128k (mirror of the work RAM at 0x100000?)
	913	AM_RANGE(0x800000, 0xffffff) AM_READWRITE(twinkle_waveram_r, twinkle_waveram_w )    // 8 MB window wave RAM
844	914	ADDRESS_MAP_END
845	915
846	916	/* SCSI */
r242990	r242991
941	1011
942	1012	MCFG_CPU_ADD("audiocpu", M68000, 32000000/2)    /* 16.000 MHz */
943	1013	MCFG_CPU_PROGRAM_MAP( sound_map )
944		MCFG_CPU_PERIODIC_INT_DRIVER(twinkle_state, irq1_line_assert, 60)
945		MCFG_CPU_PERIODIC_INT_DRIVER(twinkle_state, irq2_line_assert, 60)
946	1014
947	1015	MCFG_WATCHDOG_TIME_INIT(attotime::from_msec(1200)) /* check TD pin on LTC1232 */
948	1016
r242990	r242991
1081	1149	ROM_REGION32_LE( 0x080000, "audiocpu", 0 )\
1082	1150	ROM_LOAD16_WORD_SWAP( "863a05.2x",    0x000000, 0x080000, CRC(6f42a09e) SHA1(cab5209f90f47b9ee6e721479913ad74e3ba84b1) )\
1083	1151	\
1084		ROM_REGION16_LE(0x400000, "rfsnd", ROMREGION_ERASE00)
	1152	ROM_REGION16_LE(0x1800000, "rfsnd", ROMREGION_ERASE00)
1085	1153
1086	1154	ROM_START( gq863 )
1087	1155	TWINKLE_BIOS

trunk/src/mame/includes/mario.h

r242990	r242991
1	1	#ifndef MARIO_H_
2	2	#define MARIO_H_
3	3
	4	#include "sound/discrete.h"
4	5	#include "machine/z80dma.h"
5	6
6		#define OLD_SOUND   (1)
7
8		#if !OLD_SOUND
9		#include "machine/netlist.h"
10		#include "netlist/devices/net_lib.h"
11		#else
12		#include "sound/discrete.h"
13		#endif
14
15	7	/*
16	8	* From the schematics:
17	9	*
r242990	r242991
50	42	m_gfxdecode(*this, "gfxdecode"),
51	43	m_palette(*this, "palette"),
52	44	m_z80dma(*this, "z80dma"),
53		#if OLD_SOUND
54	45	m_discrete(*this, "discrete"),
55		#else
56		m_audio_snd0(*this, "snd_nl:snd0"),
57		m_audio_snd7(*this, "snd_nl:snd7"),
58		m_audio_dac(*this, "snd_nl:dac"),
59		#endif
60	46	m_spriteram(*this, "spriteram"),
61	47	m_videoram(*this, "videoram"),
62	48	m_monitor(0) { }
r242990	r242991
67	53	required_device<gfxdecode_device> m_gfxdecode;
68	54	required_device<palette_device> m_palette;
69	55	optional_device<z80dma_device> m_z80dma;
70		#if OLD_SOUND
71	56	optional_device<discrete_device> m_discrete;
72		#else
73		optional_device<netlist_mame_logic_input_t> m_audio_snd0;
74		optional_device<netlist_mame_logic_input_t> m_audio_snd7;
75		optional_device<netlist_mame_logic_input_t> m_audio_dac;
76		#endif
77	57
78	58	/* memory pointers */
79	59	required_shared_ptr<UINT8> m_spriteram;

trunk/src/mame/includes/snowbros.h

r242990	r242991
55	55	DECLARE_DRIVER_INIT(4in1boot);
56	56	DECLARE_DRIVER_INIT(3in1semi);
57	57	DECLARE_DRIVER_INIT(cookbib2);
58		DECLARE_DRIVER_INIT(toto);
59		DECLARE_READ16_MEMBER(toto_read);
60	58	DECLARE_MACHINE_RESET(semiprot);
61	59	DECLARE_MACHINE_RESET(finalttr);
62	60	UINT32 screen_update_snowbros(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);

trunk/src/mame/machine/315-5881_crypt.c

r242990	r242991
121	121	The encryption is done by a stream cipher operating in counter mode, which use a 16-bits internal block cipher.
122	122
123	123	There are 2 "control bits" at the start of the decrypted stream which control the mode of operation: bit #1 set to 1 means
124		that the stream needs to be decompressed after being decrypted. More on this later.
	124	that the decrypted stream needs to be decompressed after being decrypted. More on this later.
125	125
126	126	The next 16-bits are part of the header (they don't belong to the plaintext), but his meaning is unclear. It has been
127	127	conjectured that it could stablish when to "reset" the process and start processing a new stream (based on some tests
r242990	r242991
134	134	given plaintext word, and the remaining 2 to the next plaintext word.
135	135
136	136	The underlying block cipher consists of two 4-round Feistel Networks (FN): the first one takes the counter (16 bits),
137		the game-key (>=27 bits) and the sequence-key (16 bits) and output a middle result (16 bits) which will act as another key
	137	the game-key (>=26 bits) and the sequence-key (16 bits) and output a middle result (16 bits) which will act as another key
138	138	for the second one. The second FN will take the encrypted word (16 bits), the game-key, the sequence-key and the result
139	139	from the first FN and will output the decrypted word (16 bits).
140	140
141		Each round of the Feistel Networks use four substitution sboxes, each having 6 inputs and 2 outputs. The input is the
142		XOR of at most one bit from the previous round and at most one bit from the different keys.
	141	Each round of the Feistel Networks use four substitution sboxes, each having 6 inputs and 2 outputs. The input can be the
	142	XOR of at most two "sources bits", being source bits the bits from the previous round and the bits from the different keys.
143	143
144	144	The underlying block cipher has the same structure than the one used by the CPS-2 (Capcom Play System 2) and,
145	145	indeed, some of the used sboxes are exactly the same and appear in the same FN/round in both systems (this is not evident,
r242990	r242991
151	151	some (encrypted word-decrypted word) pairs suffice. However, due to the weak key scheduling, it should be noted that some
152	152	related keys can produce the same output bytes for some (short) input sequences.
153	153
	154	The only difference in the decryption process between M2 and M3 is the initialization of the counter. In M3, the counter is
	155	always set to 0 at the beginning of the decryption while, in M2, the bits #1-#16 of the ciphertext's address are used
	156	to initialize the counter.
	157
154	158	Note that this implementation considers that the counter initialization for ram decryption is 0 simply because the ram is
155	159	mapped to multiples of 128K.
156	160
r242990	r242991
160	164	chosen so as to make the key for CAPSNK equal to 0.
161	165
162	166	It can be observed that a couple of sboxes have incomplete tables (a 255 value indicate an unknown value). The recovered keys
163		as of january/2015 show small randomness and big correlations, making possible that some unseen bits could make the
	167	as of december/2010 show small randomness and big correlations, making possible that some unseen bits could make the
164	168	decryption need those incomplete parts.
165	169
166	170	****************************************************************************************/
r242990	r242991
474	478	{1,29},  {1,71},  {2,4},   {2,54},  {3,8},   {4,56},  {4,73},  {5,11},
475	479	{6,51},  {7,92},  {8,89},  {9,9},   {9,10},  {9,39},  {9,41},  {9,58},
476	480	{9,59},  {9,86},  {10,90}, {11,6},  {12,64}, {13,49}, {14,44}, {15,40},
477		{16,69}, {17,15}, {18,23}, {18,43}, {19,82}, {20,81}, {21,32}, {22,5},
478		{23,66}, {24,13}, {24,45}, {25,12}, {25,35}, {26,61},
	481	{16,69}, {17,15}, {18,23}, {18,43}, {19,82}, {20,81}, {21,32}, {21,61},
	482	{22,5},  {23,66}, {24,13}, {24,45}, {25,12}, {25,35}
479	483	};
480	484
481	485	const int sega_315_5881_crypt_device::fn2_game_key_scheduling[34][2] = {
482	486	{0,0},   {1,3},   {2,11},  {3,20},  {4,22},  {5,23},  {6,29},  {7,38},
483	487	{8,39},  {9,47},  {9,55},  {9,86},  {9,87},  {9,90},  {10,50}, {10,53},
484	488	{11,57}, {12,59}, {13,61}, {13,64}, {14,63}, {15,67}, {16,72}, {17,83},
485		{18,88}, {19,94}, {20,35}, {21,17}, {22,6},  {22,11}, {23,85}, {24,16},
486		{25,25}, {26,92}
	489	{18,88}, {19,94}, {20,35}, {21,17}, {21,92}, {22,6},  {22,11}, {23,85},
	490	{24,16}, {25,25}
487	491	};
488	492
489	493	const int sega_315_5881_crypt_device::fn1_sequence_key_scheduling[20][2] = {

trunk/src/mame/machine/naomicrypt.c

r242990	r242991
28	28	{
29	29	// name             key              gameid #         year
30	30	// M2
31		{ "wldkicks",        0x052e2901 }, // 25209801    2000
32		{ "toukon4",         0x052e2901 }, // 25349801    2000
	31	{ "wldkicks",        0x00ae2901 }, // 25209801    2000
	32	{ "toukon4",         0x012e2901 }, // 25349801    2000
33	33	{ "ninjaslt",        0x000ca510 }, // 25469801    2000
34	34	{ "ninjaslt4",       0x000ca510 }, // 25469801    2000
35	35	{ "gunsur2e",        0x000680d0 }, // 25709801    2001
r242990	r242991
68	68	{ "alienfnt",        0x00174343 }, // 840-0048    2001
69	69	{ "alienfnta",       0x00174343 }, // 840-0048    2001
70	70	{ "crackdj2",        0x00428247 }, // 840-0068    2001
71		{ "vf4cart",         0x06ef2f92 }, // 840-0080    2002
	71	{ "vf4cart",         0x02ef2f96 }, // 840-0080    2002
72	72	{ "pstone",          0x000e69c1 }, // 841-0001    1999
73	73	{ "suchie3",         0x000368e1 }, // 841-0002    1999
74	74	{ "doa2",            0x0008ad01 }, // 841-0003    1999

trunk/src/mame/mame.lst

r242990	r242991
2678	2678	snowbrosd       // MIN16-02 (c) 1990 Toaplan + Dooyong license
2679	2679	wintbob         // bootleg
2680	2680	snowbroswb      //
2681		toto         //
2682	2681	// modified snowbros 'clone' hardware
2683	2682	honeydol        // (c) 1995 Barko Corp
2684	2683	twinadv         // (c) 1995 Barko Corp
r242990	r242991
5447	5446	starhrsp        // 2003.12.01 Star Horse Progress (satellite) (Rev A)
5448	5447	puyofevp        // 2003.?? Puyo Puyo Fever (prototype)
5449	5448	// 2003.?? Dragon Treasure
	5449	// 2003.?? Rabbit 2
5450	5450	cfield          // 2004.06 Chaos Field
5451	5451	tetkiwam        // 2004.06 Tetris Kiwamemichi (Arcade TV Game List - P.88, Right, 11 from bottom)
5452	5452	trizeal         // 2004.09 Trizeal
r242990	r242991
5513	5513
5514	5514	// NAOMI 2
5515	5515	naomi2          // 2001.?? Naomi 2 BIOS
5516		vstrik3c        // 2001.04 Virtua Striker 3 (cartridge)
	5516	vstrik3        // 2001.04.06 Virtua Striker 3 Ver. 2002
5517	5517	vstrik3cb       // 2001.04 Virtua Striker 3 (Rev B) (cartridge)
5518		vstrik3        // 2001.04.06 Virtua Striker 3 Ver. 2002
	5518	vstrik3c        // 2001.04 Virtua Striker 3 (Rev C) (cartridge)
5519	5519	wldrider        // 2001.05 Wild Riders
5520	5520	clubkrte        // 2001.06 Club Kart: European Session
	5521	clubkrtd        // 2001.06 Club Kart: European Session (Rev D)
5521	5522	clubkrtc        // 2001.?? Club Kart: European Session (Rev C)
5522		clubkrtd        // 2001.06 Club Kart: European Session (Rev D)
5523	5523	beachspi        // 2001.07 Beach Spikers
5524	5524	vf4cart         // 2001.08.02 Virtua Fighter 4 (cartridge)
5525	5525	vf4             // 2001.08.02 Virtua Fighter 4 (GD-ROM)

trunk/src/mess/drivers/comp4.c

r242990	r242991
141	141	static INPUT_PORTS_START( comp4 )
142	142	PORT_START("IN.0") // O1
143	143	PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_R) PORT_CODE(KEYCODE_DEL) PORT_CODE(KEYCODE_DEL_PAD) PORT_NAME("R")
144		PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_1) PORT_CODE(KEYCODE_1_PAD) PORT_NAME("1")
145		PORT_BIT( 0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_4) PORT_CODE(KEYCODE_4_PAD) PORT_NAME("4")
	144	PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_4) PORT_CODE(KEYCODE_1_PAD) PORT_NAME("1")
	145	PORT_BIT( 0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_1) PORT_CODE(KEYCODE_4_PAD) PORT_NAME("4")
146	146	PORT_BIT( 0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_7) PORT_CODE(KEYCODE_7_PAD) PORT_NAME("7")
147	147
148	148	PORT_START("IN.1") // O2
149	149	PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_0) PORT_CODE(KEYCODE_0_PAD) PORT_NAME("0")
150		PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_2) PORT_CODE(KEYCODE_2_PAD) PORT_NAME("2")
151		PORT_BIT( 0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_5) PORT_CODE(KEYCODE_5_PAD) PORT_NAME("5")
	150	PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_5) PORT_CODE(KEYCODE_2_PAD) PORT_NAME("2")
	151	PORT_BIT( 0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_2) PORT_CODE(KEYCODE_5_PAD) PORT_NAME("5")
152	152	PORT_BIT( 0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_8) PORT_CODE(KEYCODE_8_PAD) PORT_NAME("8")
153	153
154	154	PORT_START("IN.2") // O3
155	155	PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_E) PORT_CODE(KEYCODE_ENTER) PORT_CODE(KEYCODE_ENTER_PAD) PORT_NAME("E")
156		PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_3) PORT_CODE(KEYCODE_3_PAD) PORT_NAME("3")
157		PORT_BIT( 0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_6) PORT_CODE(KEYCODE_6_PAD) PORT_NAME("6")
	156	PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_6) PORT_CODE(KEYCODE_3_PAD) PORT_NAME("3")
	157	PORT_BIT( 0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_3) PORT_CODE(KEYCODE_6_PAD) PORT_NAME("6")
158	158	PORT_BIT( 0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_9) PORT_CODE(KEYCODE_9_PAD) PORT_NAME("9")
159	159	INPUT_PORTS_END
160	160

trunk/src/mess/drivers/splitsec.c

r242990	r242991
1		// license:BSD-3-Clause
2		// copyright-holders:hap
3		/***************************************************************************
4
5		Parker Brothers Split Second
6		* TMS1400NLL MP7314-N2 (die labeled MP7314)
7
8
9		***************************************************************************/
10
11		#include "emu.h"
12		#include "cpu/tms0980/tms0980.h"
13		#include "sound/speaker.h"
14
15		#include "splitsec.lh"
16
17		// master clock is a single stage RC oscillator: R=24K, C=100pf,
18		// according to the TMS 1000 series data manual this is around 375kHz
19		#define MASTER_CLOCK (375000)
20
21
22		class splitsec_state : public driver_device
23		{
24		public:
25		splitsec_state(const machine_config &mconfig, device_type type, const char *tag)
26		: driver_device(mconfig, type, tag),
27		m_maincpu(*this, "maincpu"),
28		m_button_matrix(*this, "IN"),
29		m_speaker(*this, "speaker")
30		{ }
31
32		required_device<cpu_device> m_maincpu;
33		required_ioport_array<2> m_button_matrix;
34		required_device<speaker_sound_device> m_speaker;
35
36		UINT16 m_r;
37		UINT16 m_o;
38
39		UINT16 m_leds_state[0x10];
40		UINT16 m_leds_cache[0x10];
41		UINT8 m_leds_decay[0x100];
42
43		DECLARE_READ8_MEMBER(read_k);
44		DECLARE_WRITE16_MEMBER(write_o);
45		DECLARE_WRITE16_MEMBER(write_r);
46
47		TIMER_DEVICE_CALLBACK_MEMBER(leds_decay_tick);
48		void leds_update();
49
50		virtual void machine_start();
51		};
52
53
54
55		/***************************************************************************
56
57		LEDs
58
59		***************************************************************************/
60
61		// The device strobes the outputs very fast, it is unnoticeable to the user.
62		// To prevent flickering here, we need to simulate a decay.
63
64		// decay time, in steps of 10ms
65		#define LEDS_DECAY_TIME 4
66
67		void splitsec_state::leds_update()
68		{
69		UINT16 active_state[0x10];
70
71		for (int i = 0; i < 0x10; i++)
72		{
73		// update current state
74		if (m_r >> i & 1)
75		m_leds_state[i] = m_o;
76
77		active_state[i] = 0;
78
79		for (int j = 0; j < 0x10; j++)
80		{
81		int di = j << 4 | i;
82
83		// turn on powered leds
84		if (m_leds_state[i] >> j & 1)
85		m_leds_decay[di] = LEDS_DECAY_TIME;
86
87		// determine active state
88		int ds = (m_leds_decay[di] != 0) ? 1 : 0;
89		active_state[i] |= (ds << j);
90		}
91		}
92
93		// on difference, send to output
94		for (int i = 0; i < 0x10; i++)
95		if (m_leds_cache[i] != active_state[i])
96		{
97		for (int j = 0; j < 8; j++)
98		output_set_lamp_value(i*10 + j, active_state[i] >> j & 1);
99		}
100
101		memcpy(m_leds_cache, active_state, sizeof(m_leds_cache));
102		}
103
104		TIMER_DEVICE_CALLBACK_MEMBER(splitsec_state::leds_decay_tick)
105		{
106		// slowly turn off unpowered leds
107		for (int i = 0; i < 0x100; i++)
108		if (!(m_leds_state[i & 0xf] >> (i>>4) & 1) && m_leds_decay[i])
109		m_leds_decay[i]--;
110
111		leds_update();
112		}
113
114
115
116		/***************************************************************************
117
118		I/O
119
120		***************************************************************************/
121
122		READ8_MEMBER(splitsec_state::read_k)
123		{
124		UINT8 k = 0;
125
126		// read selected button rows
127		for (int i = 0; i < 2; i++)
128		if (m_r >> (i+9) & 1)
129		k |= m_button_matrix[i]->read();
130
131		return k;
132		}
133
134		WRITE16_MEMBER(splitsec_state::write_r)
135		{
136		// R8: speaker out
137		m_speaker->level_w(data >> 8 & 1);
138
139		// R9,R10: input mux
140		// R0-R7: led columns
141		m_r = data;
142		leds_update();
143		}
144
145		WRITE16_MEMBER(splitsec_state::write_o)
146		{
147		// O0-O6: led rows
148		// O7: N/C
149		m_o = data;
150		leds_update();
151		}
152
153
154
155		/***************************************************************************
156
157		Inputs
158
159		***************************************************************************/
160
161		static INPUT_PORTS_START( splitsec )
162		PORT_START("IN.0") // R9
163		PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_JOYSTICK_RIGHT )
164		PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_JOYSTICK_UP )
165		PORT_BIT( 0x04, IP_ACTIVE_HIGH, IPT_JOYSTICK_LEFT )
166		PORT_BIT( 0x08, IP_ACTIVE_HIGH, IPT_UNUSED )
167
168		PORT_START("IN.1") // R10
169		PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_JOYSTICK_DOWN )
170		PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_BUTTON1 ) PORT_NAME("Select")
171		PORT_BIT( 0x04, IP_ACTIVE_HIGH, IPT_BUTTON2 ) PORT_NAME("Start")
172		PORT_BIT( 0x08, IP_ACTIVE_HIGH, IPT_UNUSED )
173		INPUT_PORTS_END
174
175
176
177		/***************************************************************************
178
179		Machine Config
180
181		***************************************************************************/
182
183		void splitsec_state::machine_start()
184		{
185		// zerofill
186		memset(m_leds_state, 0, sizeof(m_leds_state));
187		memset(m_leds_cache, 0, sizeof(m_leds_cache));
188		memset(m_leds_decay, 0, sizeof(m_leds_decay));
189
190		m_r = 0;
191		m_o = 0;
192
193		// register for savestates
194		save_item(NAME(m_leds_state));
195		save_item(NAME(m_leds_cache));
196		save_item(NAME(m_leds_decay));
197
198		save_item(NAME(m_r));
199		save_item(NAME(m_o));
200		}
201
202
203		static MACHINE_CONFIG_START( splitsec, splitsec_state )
204
205		/* basic machine hardware */
206		MCFG_CPU_ADD("maincpu", TMS1400, MASTER_CLOCK)
207		MCFG_TMS1XXX_READ_K_CB(READ8(splitsec_state, read_k))
208		MCFG_TMS1XXX_WRITE_O_CB(WRITE16(splitsec_state, write_o))
209		MCFG_TMS1XXX_WRITE_R_CB(WRITE16(splitsec_state, write_r))
210
211		MCFG_TIMER_DRIVER_ADD_PERIODIC("leds_decay", splitsec_state, leds_decay_tick, attotime::from_msec(10))
212
213		MCFG_DEFAULT_LAYOUT(layout_splitsec)
214
215		/* no video! */
216
217		/* sound hardware */
218		MCFG_SPEAKER_STANDARD_MONO("mono")
219		MCFG_SOUND_ADD("speaker", SPEAKER_SOUND, 0)
220		MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25)
221		MACHINE_CONFIG_END
222
223
224
225		/***************************************************************************
226
227		Game driver(s)
228
229		***************************************************************************/
230
231		ROM_START( splitsec )
232		ROM_REGION( 0x1000, "maincpu", 0 )
233		ROM_LOAD( "tms1400nll_mp7314", 0x0000, 0x1000, CRC(0cccdf59) SHA1(06a533134a433aaf856b80f0ca239d0498b98d5f) )
234
235		ROM_REGION( 867, "maincpu:mpla", 0 )
236		ROM_LOAD( "tms1100_default_mpla.pla", 0, 867, CRC(62445fc9) SHA1(d6297f2a4bc7a870b76cc498d19dbb0ce7d69fec) )
237		ROM_REGION( 557, "maincpu:opla", 0 )
238		ROM_LOAD( "tms1400_splitsec_opla.pla", 0, 557, CRC(7539283b) SHA1(f791fa98259fc10c393ff1961d4c93040f1a2932) )
239		ROM_END
240
241
242		CONS( 1980, splitsec, 0, 0, splitsec, splitsec, driver_device, 0, "Parker Brothers", "Split Second", GAME_SUPPORTS_SAVE | GAME_NOT_WORKING )

trunk/src/mess/includes/msx.h

r242990	r242991
24	24	#include "formats/basicdsk.h"
25	25	#include "formats/fmsx_cas.h"
26	26	#include "formats/msx_dsk.h"
	27	//#include "osdepend.h"
27	28	#include "hashfile.h"
28	29	#include "machine/wd_fdc.h"
29	30	#include "imagedev/floppy.h"

trunk/src/mess/layout/splitsec.lay

r242990	r242991
1		<?xml version="1.0"?>
2		<mamelayout version="2">
3
4		<!-- define elements -->
5
6		<element name="static_black"><rect><color red="0.0" green="0.0" blue="0.0" /></rect></element>
7
8		<element name="lamp_disk" defstate="0">
9		<disk state="1"><color red="1.0" green="0.24" blue="0.26" /></disk>
10		<disk state="0"><color red="0.15" green="0.043" blue="0.047" /></disk>
11		</element>
12		<element name="lamp_rect" defstate="0">
13		<rect state="1"><color red="1.0" green="0.24" blue="0.26" /></rect>
14		<rect state="0"><color red="0.15" green="0.043" blue="0.047" /></rect>
15		</element>
16
17
18		<!-- build screen -->
19
20		<view name="Internal Layout">
21		<bounds left="0" right="18" top="0" bottom="28" />
22		<bezel element="static_black">
23		<bounds left="0" right="18" top="0" bottom="28" />
24		</bezel>
25
26		<!-- maze of lamps -->
27
28		<bezel name="lamp6" element="lamp_rect"><bounds x="2" y="1" width="4" height="1" /></bezel>
29		<bezel name="lamp4" element="lamp_rect"><bounds x="7" y="1" width="4" height="1" /></bezel>
30		<bezel name="lamp2" element="lamp_rect"><bounds x="12" y="1" width="4" height="1" /></bezel>
31
32		<bezel name="lamp16" element="lamp_rect"><bounds x="1" y="2" width="1" height="4" /></bezel>
33		<bezel name="lamp5" element="lamp_disk"><bounds x="3" y="3" width="2" height="2" /></bezel>
34		<bezel name="lamp14" element="lamp_rect"><bounds x="6" y="2" width="1" height="4" /></bezel>
35		<bezel name="lamp3" element="lamp_disk"><bounds x="8" y="3" width="2" height="2" /></bezel>
36		<bezel name="lamp12" element="lamp_rect"><bounds x="11" y="2" width="1" height="4" /></bezel>
37		<bezel name="lamp1" element="lamp_disk"><bounds x="13" y="3" width="2" height="2" /></bezel>
38		<bezel name="lamp10" element="lamp_rect"><bounds x="16" y="2" width="1" height="4" /></bezel>
39
40		<bezel name="lamp15" element="lamp_rect"><bounds x="2" y="6" width="4" height="1" /></bezel>
41		<bezel name="lamp13" element="lamp_rect"><bounds x="7" y="6" width="4" height="1" /></bezel>
42		<bezel name="lamp11" element="lamp_rect"><bounds x="12" y="6" width="4" height="1" /></bezel>
43
44		<bezel name="lamp26" element="lamp_rect"><bounds x="1" y="7" width="1" height="4" /></bezel>
45		<bezel name="lamp25" element="lamp_disk"><bounds x="3" y="8" width="2" height="2" /></bezel>
46		<bezel name="lamp24" element="lamp_rect"><bounds x="6" y="7" width="1" height="4" /></bezel>
47		<bezel name="lamp23" element="lamp_disk"><bounds x="8" y="8" width="2" height="2" /></bezel>
48		<bezel name="lamp22" element="lamp_rect"><bounds x="11" y="7" width="1" height="4" /></bezel>
49		<bezel name="lamp21" element="lamp_disk"><bounds x="13" y="8" width="2" height="2" /></bezel>
50		<bezel name="lamp20" element="lamp_rect"><bounds x="16" y="7" width="1" height="4" /></bezel>
51
52		<bezel name="lamp35" element="lamp_rect"><bounds x="2" y="11" width="4" height="1" /></bezel>
53		<bezel name="lamp33" element="lamp_rect"><bounds x="7" y="11" width="4" height="1" /></bezel>
54		<bezel name="lamp31" element="lamp_rect"><bounds x="12" y="11" width="4" height="1" /></bezel>
55
56		<bezel name="lamp36" element="lamp_rect"><bounds x="1" y="12" width="1" height="4" /></bezel>
57		<bezel name="lamp45" element="lamp_disk"><bounds x="3" y="13" width="2" height="2" /></bezel>
58		<bezel name="lamp34" element="lamp_rect"><bounds x="6" y="12" width="1" height="4" /></bezel>
59		<bezel name="lamp43" element="lamp_disk"><bounds x="8" y="13" width="2" height="2" /></bezel>
60		<bezel name="lamp32" element="lamp_rect"><bounds x="11" y="12" width="1" height="4" /></bezel>
61		<bezel name="lamp41" element="lamp_disk"><bounds x="13" y="13" width="2" height="2" /></bezel>
62		<bezel name="lamp30" element="lamp_rect"><bounds x="16" y="12" width="1" height="4" /></bezel>
63
64		<bezel name="lamp55" element="lamp_rect"><bounds x="2" y="16" width="4" height="1" /></bezel>
65		<bezel name="lamp53" element="lamp_rect"><bounds x="7" y="16" width="4" height="1" /></bezel>
66		<bezel name="lamp51" element="lamp_rect"><bounds x="12" y="16" width="4" height="1" /></bezel>
67
68		<bezel name="lamp46" element="lamp_rect"><bounds x="1" y="17" width="1" height="4" /></bezel>
69		<bezel name="lamp65" element="lamp_disk"><bounds x="3" y="18" width="2" height="2" /></bezel>
70		<bezel name="lamp44" element="lamp_rect"><bounds x="6" y="17" width="1" height="4" /></bezel>
71		<bezel name="lamp63" element="lamp_disk"><bounds x="8" y="18" width="2" height="2" /></bezel>
72		<bezel name="lamp42" element="lamp_rect"><bounds x="11" y="17" width="1" height="4" /></bezel>
73		<bezel name="lamp61" element="lamp_disk"><bounds x="13" y="18" width="2" height="2" /></bezel>
74		<bezel name="lamp40" element="lamp_rect"><bounds x="16" y="17" width="1" height="4" /></bezel>
75
76		<bezel name="lamp75" element="lamp_rect"><bounds x="2" y="21" width="4" height="1" /></bezel>
77		<bezel name="lamp73" element="lamp_rect"><bounds x="7" y="21" width="4" height="1" /></bezel>
78		<bezel name="lamp71" element="lamp_rect"><bounds x="12" y="21" width="4" height="1" /></bezel>
79
80		<bezel name="lamp56" element="lamp_rect"><bounds x="1" y="22" width="1" height="4" /></bezel>
81		<bezel name="lamp66" element="lamp_disk"><bounds x="3" y="23" width="2" height="2" /></bezel>
82		<bezel name="lamp54" element="lamp_rect"><bounds x="6" y="22" width="1" height="4" /></bezel>
83		<bezel name="lamp64" element="lamp_disk"><bounds x="8" y="23" width="2" height="2" /></bezel>
84		<bezel name="lamp52" element="lamp_rect"><bounds x="11" y="22" width="1" height="4" /></bezel>
85		<bezel name="lamp62" element="lamp_disk"><bounds x="13" y="23" width="2" height="2" /></bezel>
86		<bezel name="lamp50" element="lamp_rect"><bounds x="16" y="22" width="1" height="4" /></bezel>
87
88		<bezel name="lamp76" element="lamp_rect"><bounds x="2" y="26" width="4" height="1" /></bezel>
89		<bezel name="lamp74" element="lamp_rect"><bounds x="7" y="26" width="4" height="1" /></bezel>
90		<bezel name="lamp72" element="lamp_rect"><bounds x="12" y="26" width="4" height="1" /></bezel>
91
92		</view>
93		</mamelayout>

trunk/src/mess/mess.lst

r242990	r242991
2269	2269	starwbcp
2270	2270	stopthie
2271	2271	stopthiep
2272		splitsec
2273	2272	amico2k
2274	2273	jtc
2275	2274	jtces88

trunk/src/mess/mess.mak

r242990	r242991
1490	1490	$(MESSOBJ)/parker.a:            \
1491	1491	$(MESS_DRIVERS)/cnsector.o  \
1492	1492	$(MESS_DRIVERS)/merlin.o    \
1493		$(MESS_DRIVERS)/splitsec.o  \
1494	1493	$(MESS_DRIVERS)/stopthie.o  \
1495	1494
1496	1495	$(MESSOBJ)/pitronic.a:          \
r242990	r242991
2172	2171	$(MESS_DRIVERS)/sitcom.o:   $(MESS_LAYOUT)/sitcom.lh
2173	2172	$(MESS_DRIVERS)/slc1.o:     $(MESS_LAYOUT)/slc1.lh
2174	2173	$(MESS_DRIVERS)/sms.o:      $(MESS_LAYOUT)/sms1.lh
2175		$(MESS_DRIVERS)/splitsec.o: $(MESS_LAYOUT)/splitsec.lh
2176	2174	$(MESS_DRIVERS)/starwbc.o:  $(MESS_LAYOUT)/starwbc.lh
2177	2175	$(MESS_DRIVERS)/stopthie.o: $(MESS_LAYOUT)/stopthie.lh
2178	2176	$(MESS_DRIVERS)/super80.o:  $(MESS_LAYOUT)/super80.lh

trunk/src/osd/modules/lib/osdobj_common.c

r242990	r242991
346	346	//  font with the given name
347	347	//-------------------------------------------------
348	348
349		osd_font *osd_common_t::font_open(const char *name, int &height)
	349	osd_font osd_common_t::font_open(const char *name, int &height)
350	350	{
351	351	return NULL;
352	352	}
r242990	r242991
357	357	//  a given OSD font
358	358	//-------------------------------------------------
359	359
360		void osd_common_t::font_close(osd_font *font)
	360	void osd_common_t::font_close(osd_font font)
361	361	{
362	362	}
363	363
r242990	r242991
370	370	//  pixel of a black & white font
371	371	//-------------------------------------------------
372	372
373		bool osd_common_t::font_get_bitmap(osd_font *font, unicode_char chnum, bitmap_argb32 &bitmap, INT32 &width, INT32 &xoffs, INT32 &yoffs)
	373	bool osd_common_t::font_get_bitmap(osd_font font, unicode_char chnum, bitmap_argb32 &bitmap, INT32 &width, INT32 &xoffs, INT32 &yoffs)
374	374	{
375	375	return false;
376	376	}

trunk/src/osd/modules/lib/osdobj_common.h

r242990	r242991
153	153	virtual void customize_input_type_list(simple_list<input_type_entry> &typelist);
154	154
155	155	// font overridables
156		virtual osd_font *font_open(const char *name, int &height);
157		virtual void font_close(osd_font *font);
158		virtual bool font_get_bitmap(osd_font *font, unicode_char chnum, bitmap_argb32 &bitmap, INT32 &width, INT32 &xoffs, INT32 &yoffs);
	156	virtual osd_font font_open(const char *name, int &height);
	157	virtual void font_close(osd_font font);
	158	virtual bool font_get_bitmap(osd_font font, unicode_char chnum, bitmap_argb32 &bitmap, INT32 &width, INT32 &xoffs, INT32 &yoffs);
159	159
160	160	// video overridables
161	161	virtual void *get_slider_list();

trunk/src/osd/osdcore.c

r242990	r242991
53	53
54	54	output_delegate osd_set_output_channel(output_channel channel, output_delegate callback)
55	55	{
56		if (!(channel < OSD_OUTPUT_CHANNEL_COUNT) || callback.isnull())
57		{
58		throw std::exception();
59		}
	56	assert(channel < OSD_OUTPUT_CHANNEL_COUNT);
	57	assert(!callback.isnull());
60	58
61	59	/* return the originals if requested */
62	60	output_delegate prevcb = output_cb[channel];

trunk/src/osd/osdepend.h

r242990	r242991
27	27	//============================================================
28	28
29	29	// FIXME: We can do better than this
30		class osd_font;
	30	typedef void *osd_font;
31	31
32	32	// ======================> osd_interface
33	33
r242990	r242991
53	53	virtual void customize_input_type_list(simple_list<input_type_entry> &typelist) = 0;
54	54
55	55	// font overridables
56		virtual osd_font *font_open(const char *name, int &height) = 0;
57		virtual void font_close(osd_font *font) = 0;
58		virtual bool font_get_bitmap(osd_font *font, unicode_char chnum, bitmap_argb32 &bitmap, INT32 &width, INT32 &xoffs, INT32 &yoffs) = 0;
	56	virtual osd_font font_open(const char *name, int &height) = 0;
	57	virtual void font_close(osd_font font) = 0;
	58	virtual bool font_get_bitmap(osd_font font, unicode_char chnum, bitmap_argb32 &bitmap, INT32 &width, INT32 &xoffs, INT32 &yoffs) = 0;
59	59
60	60	// video overridables
61	61	virtual void *get_slider_list() = 0; // FIXME: returns slider_state *

trunk/src/osd/osdmini/minimain.c

r242990	r242991
55	55
56	56
57	57	//============================================================
58		//  mini_osd_options
59		//============================================================
60
61		mini_osd_options::mini_osd_options()
62		: osd_options()
63		{
64		//add_entries(s_option_entries);
65		}
66
67		//============================================================
68	58	//  main
69	59	//============================================================
70	60
r242990	r242991
72	62	{
73	63	// cli_frontend does the heavy lifting; if we have osd-specific options, we
74	64	// create a derivative of cli_options and add our own
75		mini_osd_options options;
76		mini_osd_interface osd(options);
77		osd.register_options();
	65	cli_options options;
	66	mini_osd_interface osd;
	67	osd.register_options(options);
78	68	cli_frontend frontend(options, osd);
79	69	return frontend.execute(argc, argv);
80	70	}
r242990	r242991
84	74	//  constructor
85	75	//============================================================
86	76
87		mini_osd_interface::mini_osd_interface(mini_osd_options &options)
88		: osd_common_t(options)
	77	mini_osd_interface::mini_osd_interface()
89	78	{
90	79	}
91	80
r242990	r242991
106	95	void mini_osd_interface::init(running_machine &machine)
107	96	{
108	97	// call our parent
109		osd_common_t::init(machine);
	98	osd_interface::init(machine);
110	99
111	100	// initialize the video system by allocating a rendering target
112	101	our_target = machine.render().target_alloc();

trunk/src/osd/osdmini/osdmini.h

r242990	r242991
8	8
9	9	#include "options.h"
10	10	#include "osdepend.h"
11		#include "modules/lib/osdobj_common.h"
12	11
13	12
14		class mini_osd_options : public osd_options
15		{
16		public:
17		// construction/destruction
18		mini_osd_options();
19
20		};
21
22	13	//============================================================
23	14	//  TYPE DEFINITIONS
24	15	//============================================================
25	16
26		class mini_osd_interface : public osd_common_t
	17	class mini_osd_interface : public osd_interface
27	18	{
28	19	public:
29	20	// construction/destruction
30		mini_osd_interface(mini_osd_options &options);
	21	mini_osd_interface();
31	22	virtual ~mini_osd_interface();
32	23
33	24	// general overridables

trunk/src/osd/osdmini/osdmini.mak

r242990	r242991
50	50	OSDSRC = $(SRC)/osd
51	51	OSDOBJ = $(OBJ)/osd
52	52
53		OBJDIRS += $(MINIOBJ) \
54		$(OSDOBJ)/modules/sync \
55		$(OSDOBJ)/modules/lib \
56		$(OSDOBJ)/modules/midi
	53	OBJDIRS += $(MINIOBJ) $(OSDOBJ)/modules/sync
57	54
	55
	56
58	57	#-------------------------------------------------
59	58	# OSD core library
60	59	#-------------------------------------------------
r242990	r242991
65	64	$(MINIOBJ)/minimisc.o \
66	65	$(MINIOBJ)/minisync.o \
67	66	$(MINIOBJ)/minitime.o \
	67	$(OSDOBJ)/modules/sync/work_mini.o \
68	68
69	69	#-------------------------------------------------
70	70	# OSD mini library
71	71	#-------------------------------------------------
72	72
73	73	OSDOBJS = \
74		$(MINIOBJ)/minimain.o \
75		$(OSDOBJ)/modules/sync/work_mini.o \
76		$(OSDOBJ)/modules/lib/osdobj_common.o  \
77		$(OSDOBJ)/modules/midi/none.o \
	74	$(MINIOBJ)/minimain.o
78	75
79	76	ifeq ($(OS),Windows_NT)
80	77	LIBS += -lwinmm -lwsock32

trunk/src/osd/sdl/draw13.c

r242990	r242991
134	134	const HashT hash() const { return m_hash; }
135	135	const UINT32 flags() const { return m_flags; }
136	136	const bool is_pixels_owned() const { // do we own / allocated it ?
137		return false && ((m_sdl_access == SDL_TEXTUREACCESS_STATIC)
138		&& (m_copyinfo->func != NULL)) ;
	137	return m_sdl_access == SDL_TEXTUREACCESS_STATIC
	138	&& m_copyinfo->func != NULL ;
139	139	}
140	140
141	141	private:
142		Uint32              m_sdl_access;
143	142	SDL_Renderer *      m_renderer;
144	143	render_texinfo      m_texinfo;            // copy of the texture info
145	144	HashT               m_hash;               // hash value for the texture (must be >= pointer size)
r242990	r242991
150	149
151	150	int                 m_format;             // texture format
152	151	SDL_BlendMode       m_sdl_blendmode;
	152	Uint32              m_sdl_access;
153	153
154	154	texture_info *      m_next;               // next texture in the list
155	155	};
r242990	r242991
490	490	}
491	491	}
492	492
493		// FIXME: machine only used to access options.
494	493	int drawsdl2_init(running_machine &machine, sdl_draw_info *callbacks)
495	494	{
496	495	const char *stemp;
r242990	r242991
1008	1007
1009	1008	texture_info::~texture_info()
1010	1009	{
1011		if ( is_pixels_owned() && (m_pixels != NULL) )
1012		free(m_pixels);
1013	1010	SDL_DestroyTexture(m_texture_id);
	1011	if ( is_pixels_owned() && m_pixels != NULL )
	1012	free(m_pixels);
1014	1013	}
1015	1014
1016	1015	//============================================================

trunk/src/osd/sdl/man/castool.1

r242990	r242991
6	6	.\" Cesare Falco <c.falco@ubuntu.com>, February 2011
7	7	.\"
8	8	.\"
9		.TH CASTOOL 1 2014-12-15 0.157 "MESS Generic cassette manipulation tool"
	9	.TH CASTOOL 1 2015-01-18 0.158 "MESS Generic cassette manipulation tool"
10	10	.\"
11	11	.\"
12	12	.\" NAME chapter

trunk/src/osd/sdl/man/chdman.1

r242990	r242991
6	6	.\" Ashley T. Howes <debiandev@ashleyhowes.com>, February 2005
7	7	.\" updated by Cesare Falco <c.falco@ubuntu.com>, February 2007
8	8	.\"
9		.TH CHDMAN 1 2014-12-15 0.157 "MAME Compressed Hunks of Data (CHD) manager"
	9	.TH CHDMAN 1 2015-01-18 0.158 "MAME Compressed Hunks of Data (CHD) manager"
10	10	.\"
11	11	.\" NAME chapter
12	12	.SH NAME

trunk/src/osd/sdl/man/floptool.1

r242990	r242991
6	6	.\" Cesare Falco <c.falco@ubuntu.com>, April 2014
7	7	.\"
8	8	.\"
9		.TH FLOPTOOL 1 2014-12-15 0.157 "MESS Generic floppy manipulation tool"
	9	.TH FLOPTOOL 1 2015-01-18 0.158 "MESS Generic floppy manipulation tool"
10	10	.\"
11	11	.\"
12	12	.\" NAME chapter

trunk/src/osd/sdl/man/imgtool.1

r242990	r242991
6	6	.\" Cesare Falco <c.falco@ubuntu.com>, February 2011
7	7	.\"
8	8	.\"
9		.TH IMGTOOL 1 2014-12-15 0.157 "MESS media image manipulation tool"
	9	.TH IMGTOOL 1 2015-01-18 0.158 "MESS media image manipulation tool"
10	10	.\"
11	11	.\"
12	12	.\" NAME chapter

trunk/src/osd/sdl/man/jedutil.1

r242990	r242991
8	8	.\" References
9	9	.\" http://aarongiles.com/?p=159
10	10	.\"
11		.TH JEDUTIL 1 2014-12-15 0.157 "MAME JEDEC file utilities"
	11	.TH JEDUTIL 1 2015-01-18 0.158 "MAME JEDEC file utilities"
12	12	.\"
13	13	.\" NAME chapter
14	14	.SH NAME

trunk/src/osd/sdl/man/ldresample.1

r242990	r242991
3	3	.\" Second parameter, SECTION, should be 1-8, maybe w/ subsection
4	4	.\" other parameters are allowed: see man(7), man(1)
5	5	.\"
6		.TH LDRESAMPLE 1 2014-12-15 0.157 "MAME laserdisc audio manipulation tool"
	6	.TH LDRESAMPLE 1 2015-01-18 0.158 "MAME laserdisc audio manipulation tool"
7	7	.\"
8	8	.\" Please adjust this date whenever revising the manpage.
9	9	.\"

trunk/src/osd/sdl/man/ldverify.1

r242990	r242991
5	5	.\" Man page created from source and usage information by
6	6	.\" Cesare Falco <c.falco@ubuntu.com>, August 2008
7	7	.\"
8		.TH LDVERIFY 1 2014-12-15 0.157 "MAME laserdisc data checker"
	8	.TH LDVERIFY 1 2015-01-18 0.158 "MAME laserdisc data checker"
9	9	.\"
10	10	.\" NAME chapter
11	11	.SH NAME

trunk/src/osd/sdl/man/mame.6

r242990	r242991
13	13	.\" and updated by Andrew Burton <burtona@gol.com>, July 2003
14	14	.\"
15	15	.\"
16		.TH MAME 6 2014-12-15 0.157 "MAME \- The Multiple Arcade Machine Emulator"
	16	.TH MAME 6 2015-01-18 0.158 "MAME \- The Multiple Arcade Machine Emulator"
17	17	.\"
18	18	.\"
19	19	.\" NAME chapter

trunk/src/osd/sdl/man/mess.6

r242990	r242991
16	16	.\" http://www.mess.org/
17	17	.\"
18	18	.\"
19		.TH MESS 6 2014-12-15 0.157 "The Multiple Emulator Super System (MESS)"
	19	.TH MESS 6 2015-01-18 0.158 "The Multiple Emulator Super System (MESS)"
20	20	.\"
21	21	.\"
22	22	.\" NAME chapter

trunk/src/osd/sdl/man/romcmp.1

r242990	r242991
9	9	.\" References
10	10	.\" http://www.mame.net/mamefaq.html
11	11	.\"
12		.TH ROMCMP 1 2014-12-15 0.157 "MAME romset checking tool"
	12	.TH ROMCMP 1 2015-01-18 0.158 "MAME romset checking tool"
13	13	.\"
14	14	.\" NAME chapter
15	15	.SH NAME

trunk/src/osd/sdl/man/testkeys.1

r242990	r242991
5	5	.\" Man page created from source and usage information
6	6	.\" Cesare Falco <c.falco@ubuntu.com>, February 2007
7	7	.\"
8		.TH TESTKEYS 1 2014-12-15 0.157 "MAME SDL keycode scanner"
	8	.TH TESTKEYS 1 2015-01-18 0.158 "MAME SDL keycode scanner"
9	9	.\"
10	10	.\" NAME chapter
11	11	.SH NAME

trunk/src/osd/sdl/osdsdl.h

r242990	r242991
115	115	//  TYPE DEFINITIONS
116	116	//============================================================
117	117
	118	typedef void *osd_font;
	119
	120	//============================================================
	121	//  TYPE DEFINITIONS
	122	//============================================================
	123
118	124	class sdl_options : public osd_options
119	125	{
120	126	public:
r242990	r242991
187	193	virtual void customize_input_type_list(simple_list<input_type_entry> &typelist);
188	194
189	195	// font overridables
190		virtual osd_font *font_open(const char *name, int &height);
191		virtual void font_close(osd_font *font);
192		virtual bool font_get_bitmap(osd_font *font, unicode_char chnum, bitmap_argb32 &bitmap, INT32 &width, INT32 &xoffs, INT32 &yoffs);
	196	virtual osd_font font_open(const char *name, int &height);
	197	virtual void font_close(osd_font font);
	198	virtual bool font_get_bitmap(osd_font font, unicode_char chnum, bitmap_argb32 &bitmap, INT32 &width, INT32 &xoffs, INT32 &yoffs);
193	199
194	200	virtual void video_register();
195	201	virtual void sound_register();

trunk/src/osd/sdl/sdlmain.c

r242990	r242991
717	717	//  font with the given name
718	718	//-------------------------------------------------
719	719
720		class osd_font
	720	osd_font sdl_osd_interface::font_open(const char *_name, int &height)
721	721	{
722		public:
723		CTFontRef m_font;
724		};
725
726		osd_font *sdl_osd_interface::font_open(const char *_name, int &height)
727		{
728	722	CFStringRef font_name = NULL;
729	723	CTFontRef ct_font = NULL;
730	724	CTFontDescriptorRef font_descriptor;
r242990	r242991
776	770	line_height += CTFontGetLeading(ct_font);
777	771	height = ceilf(line_height * EXTRA_HEIGHT);
778	772
779		osd_font *ret = global_alloc(osd_font);
780		ret->m_font = ct_font;
781		return ret;
	773	return (osd_font)ct_font;
782	774	}
783	775
784	776	//-------------------------------------------------
r242990	r242991
786	778	//  a given OSD font
787	779	//-------------------------------------------------
788	780
789		void sdl_osd_interface::font_close(osd_font *font)
	781	void sdl_osd_interface::font_close(osd_font font)
790	782	{
791		CTFontRef ct_font = font->m_font;
	783	CTFontRef ct_font = (CTFontRef)font;
792	784
793	785	if( ct_font != NULL )
794	786	{
795	787	CFRelease( ct_font );
796	788	}
797		global_free(font);
798	789	}
799	790
800	791	//-------------------------------------------------
r242990	r242991
805	796	//  pixel of a black & white font
806	797	//-------------------------------------------------
807	798
808		bool sdl_osd_interface::font_get_bitmap(osd_font *font, unicode_char chnum, bitmap_argb32 &bitmap, INT32 &width, INT32 &xoffs, INT32 &yoffs)
	799	bool sdl_osd_interface::font_get_bitmap(osd_font font, unicode_char chnum, bitmap_argb32 &bitmap, INT32 &width, INT32 &xoffs, INT32 &yoffs)
809	800	{
810	801	UniChar uni_char;
811	802	CGGlyph glyph;
812		CTFontRef ct_font = font->m_font;
	803	CTFontRef ct_font = (CTFontRef)font;
813	804	const CFIndex count = 1;
814	805	CGRect bounding_rect, success_rect;
815	806	CGContextRef context_ref;
r242990	r242991
1018	1009	//  font with the given name
1019	1010	//-------------------------------------------------
1020	1011
1021		class osd_font
	1012	osd_font sdl_osd_interface::font_open(const char *_name, int &height)
1022	1013	{
1023		public:
1024		TTF_Font *m_font;
1025		};
1026
1027		osd_font *sdl_osd_interface::font_open(const char *_name, int &height)
1028		{
1029	1014	TTF_Font *font = (TTF_Font *)NULL;
1030	1015	bool bakedstyles = false;
1031	1016	int style = 0;
r242990	r242991
1096	1081
1097	1082	height = TTF_FontLineSkip(font);
1098	1083
1099		osd_font *ret = global_alloc(osd_font);
1100		ret->m_font = font;
1101		return ret;
	1084	return (osd_font)font;
1102	1085	}
1103	1086
1104	1087	//-------------------------------------------------
r242990	r242991
1106	1089	//  a given OSD font
1107	1090	//-------------------------------------------------
1108	1091
1109		void sdl_osd_interface::font_close(osd_font *font)
	1092	void sdl_osd_interface::font_close(osd_font font)
1110	1093	{
1111		TTF_CloseFont(font->m_font);
1112		global_free(font);
	1094	TTF_Font *ttffont;
	1095
	1096	ttffont = (TTF_Font *)font;
	1097
	1098	TTF_CloseFont(ttffont);
1113	1099	}
1114	1100
1115	1101	//-------------------------------------------------
r242990	r242991
1120	1106	//  pixel of a black & white font
1121	1107	//-------------------------------------------------
1122	1108
1123		bool sdl_osd_interface::font_get_bitmap(osd_font *font, unicode_char chnum, bitmap_argb32 &bitmap, INT32 &width, INT32 &xoffs, INT32 &yoffs)
	1109	bool sdl_osd_interface::font_get_bitmap(osd_font font, unicode_char chnum, bitmap_argb32 &bitmap, INT32 &width, INT32 &xoffs, INT32 &yoffs)
1124	1110	{
1125	1111	TTF_Font *ttffont;
1126	1112	SDL_Surface *drawsurf;
1127	1113	SDL_Color fcol = { 0xff, 0xff, 0xff };
1128	1114	UINT16 ustr[16];
1129	1115
1130		ttffont = font->m_font;
	1116	ttffont = (TTF_Font *)font;
1131	1117
1132	1118	memset(ustr,0,sizeof(ustr));
1133	1119	ustr[0] = (UINT16)chnum;

trunk/src/osd/windows/winmain.c

r242990	r242991
719	719	//  font with the given name
720	720	//-------------------------------------------------
721	721
722		osd_font *windows_osd_interface::font_open(const char *_name, int &height)
	722	osd_font windows_osd_interface::font_open(const char *_name, int &height)
723	723	{
724	724	// accept qualifiers from the name
725	725	astring name(_name);
r242990	r242991
751	751
752	752	// create the font
753	753	height = logfont.lfHeight;
754		osd_font *font = reinterpret_cast<osd_font *>(CreateFontIndirect(&logfont));
	754	osd_font font = reinterpret_cast<osd_font>(CreateFontIndirect(&logfont));
755	755	if (font == NULL)
756	756	return NULL;
757	757
r242990	r242991
783	783	//  a given OSD font
784	784	//-------------------------------------------------
785	785
786		void windows_osd_interface::font_close(osd_font *font)
	786	void windows_osd_interface::font_close(osd_font font)
787	787	{
788	788	// delete the font ojbect
789	789	if (font != NULL)
r242990	r242991
799	799	//  pixel of a black & white font
800	800	//-------------------------------------------------
801	801
802		bool windows_osd_interface::font_get_bitmap(osd_font *font, unicode_char chnum, bitmap_argb32 &bitmap, INT32 &width, INT32 &xoffs, INT32 &yoffs)
	802	bool windows_osd_interface::font_get_bitmap(osd_font font, unicode_char chnum, bitmap_argb32 &bitmap, INT32 &width, INT32 &xoffs, INT32 &yoffs)
803	803	{
804	804	// create a dummy DC to work with
805	805	HDC dummyDC = CreateCompatibleDC(NULL);

trunk/src/osd/windows/winmain.h

r242990	r242991
253	253	virtual void customize_input_type_list(simple_list<input_type_entry> &typelist);
254	254
255	255	// font overridables
256		virtual osd_font *font_open(const char *name, int &height);
257		virtual void font_close(osd_font *font);
258		virtual bool font_get_bitmap(osd_font *font, unicode_char chnum, bitmap_argb32 &bitmap, INT32 &width, INT32 &xoffs, INT32 &yoffs);
	256	virtual osd_font font_open(const char *name, int &height);
	257	virtual void font_close(osd_font font);
	258	virtual bool font_get_bitmap(osd_font font, unicode_char chnum, bitmap_argb32 &bitmap, INT32 &width, INT32 &xoffs, INT32 &yoffs);
259	259
260	260	virtual void video_register();
261	261	virtual void sound_register();

trunk/src/tools/nltool.c

r242990	r242991
18	18	#include "netlist/nl_base.h"
19	19	#include "netlist/nl_setup.h"
20	20	#include "netlist/nl_parser.h"
21		#include "netlist/nl_factory.h"
22	21	#include "netlist/nl_util.h"
23		#include "netlist/devices/net_lib.h"
24	22	#include "options.h"
25	23
26	24	/***************************************************************************
27		* MAME COMPATIBILITY ...
28		*
29		* These are needed if we link without libutil
30		***************************************************************************/
	25	MAME COMPATIBILITY ...
	26	***************************************************************************/
31	27
32	28	#if 0
33	29	void ATTR_PRINTF(1,2) osd_printf_warning(const char *format, ...)
r242990	r242991
39	35	vprintf(format, argptr);
40	36	va_end(argptr);
41	37	}
	38	#endif
42	39
43	40	void *malloc_file_line(size_t size, const char *file, int line)
44	41	{
r242990	r242991
75	72	src_type.name(), dst_type.name());
76	73	throw;
77	74	}
78		#endif
79	75
80	76	struct options_entry oplist[] =
81	77	{
r242990	r242991
87	83	{ NULL }
88	84	};
89	85
90		NETLIST_START(dummy)
91		/* Standard stuff */
92
93		CLOCK(clk, 1000) // 1000 Hz
94		SOLVER(Solver, 48000)
95
96		NETLIST_END()
97
98	86	/***************************************************************************
99	87	CORE IMPLEMENTATION
100	88	***************************************************************************/
r242990	r242991
172	160	nl_util::pstring_list ll = nl_util::split(m_logs, ":");
173	161	for (int i=0; i < ll.count(); i++)
174	162	{
175		pstring name = "log_" + ll[i];
176		netlist_device_t *nc = m_setup->register_dev("nld_log", name);
	163	netlist_device_t *nc = m_setup->factory().new_device_by_classname("nld_log", *m_setup);
	164	pstring name = "log_" + ll[i];
	165	m_setup->register_dev(nc, name);
177	166	m_setup->register_link(name + ".I", ll[i]);
178	167	}
179	168	}
r242990	r242991
241	230	nt.init();
242	231	const netlist_factory_t::list_t &list = nt.setup().factory().list();
243	232
244		netlist_sources_t sources;
245
246		sources.add(netlist_source_t("dummy", &netlist_dummy));
247		sources.parse(nt.setup(),"dummy");
248
249	233	nt.setup().start_devices();
250	234	nt.setup().resolve_inputs();
251	235

https://github.com/mamedev/mame/commit/4488e12e3fc720fe9eebd951dd01c4224dbbd02b

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team