Previous

199869 Revisions

Next

r31058 Saturday 21st June, 2014 at 13:39:30 UTC by Couriersud
Align naming convention to be the same for nld_signal and nld_truthtable

[src/emu/netlist]	nl_time.h
[src/emu/netlist/devices]	nld_7400.c nld_7400.h nld_7402.c nld_7408.c nld_7410.c nld_7411.c nld_7420.c nld_7425.c nld_7427.c nld_7430.c nld_7432.c nld_7437.c nld_signal.h nld_truthtable.h

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

r31057	r31058
39	39	{
40	40	const char *sIN[8] = { "A", "B", "C", "D", "E", "F", "G", "H" };
41	41
42		register_output("Q", m_Q);
	42	register_output("Q", m_Q[0]);
43	43	for (int i=0; i < _numdev; i++)
44	44	{
45	45	register_input(sIN[i], m_i[i]);
r31057	r31058
49	49
50	50	ATTR_COLD void reset()
51	51	{
52		m_Q.initial(1);
	52	m_Q[0].initial(1);
53	53	m_active = 1;
54	54	}
55	55
r31057	r31058
90	90	for (int j = i + 1; j < _numdev; j++)
91	91	this->m_i[j].inactivate();
92	92
93		OUTLOGIC(this->m_Q, _check ^ (1 ^ _invert), times[_check ^ (1 ^ _invert)]);// ? 15000 : 22000);
	93	OUTLOGIC(this->m_Q[0], _check ^ (1 ^ _invert), times[_check ^ (1 ^ _invert)]);// ? 15000 : 22000);
94	94	return;
95	95	}
96	96	}
97		OUTLOGIC(this->m_Q,_check ^ (_invert), times[_check ^ (_invert)]);// ? 22000 : 15000);
	97	OUTLOGIC(this->m_Q[0],_check ^ (_invert), times[_check ^ (_invert)]);// ? 22000 : 15000);
98	98	}
99	99
100	100	public:
101	101	netlist_ttl_input_t m_i[_numdev];
102		netlist_ttl_output_t m_Q;
	102	netlist_ttl_output_t m_Q[1];
103	103	INT32 m_active;
104	104	};
105	105
r31057	r31058
114	114
115	115	ATTR_COLD void start()
116	116	{
117		register_output("Q", m_Q);
	117	register_output("Q", m_Q[0]);
118	118	register_input("A", m_i[0]);
119	119	register_input("B", m_i[1]);
120	120
r31057	r31058
123	123
124	124	ATTR_COLD void reset()
125	125	{
126		m_Q.initial(1);
	126	m_Q[0].initial(1);
127	127	m_active = 1;
128	128	}
129	129
r31057	r31058
171	171	res = _invert ^ _check;
172	172	break;
173	173	}
174		OUTLOGIC(m_Q, res, times[res]);// ? 22000 : 15000);
	174	OUTLOGIC(m_Q[0], res, times[res]);// ? 22000 : 15000);
175	175	}
176	176
177	177	public:
178	178	netlist_ttl_input_t m_i[2];
179		netlist_ttl_output_t m_Q;
	179	netlist_ttl_output_t m_Q[1];
180	180	INT32 m_active;
181	181
182	182	};

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

r31057	r31058
6	6	#include "nld_7400.h"
7	7
8	8	#if 0
9		UINT32 nld_7400::m_outs[m_size];
	9	nld_7400::truthtable_t nld_7400::m_ttbl;
	10
	11	const char *nld_7400::m_desc[] = {
	12	"A,B,PQ,PA,PB|Q",
	13	"0,X,X,X,X|1|22",
	14	"X,0,X,X,X|1|22",
	15	"1,1,X,X,X|0|15",
	16	""
	17	};
	18
10	19	#endif
11	20
12	21	NETLIB_START(7400_dip)
r31057	r31058
18	27
19	28	register_subalias("1", m_1.m_i[0]);
20	29	register_subalias("2", m_1.m_i[1]);
21		register_subalias("3", m_1.m_Q);
	30	register_subalias("3", m_1.m_Q[0]);
22	31
23	32	register_subalias("4", m_2.m_i[0]);
24	33	register_subalias("5", m_2.m_i[1]);
25		register_subalias("6", m_2.m_Q);
	34	register_subalias("6", m_2.m_Q[0]);
26	35
27	36	register_subalias("9", m_3.m_i[0]);
28	37	register_subalias("10", m_3.m_i[1]);
29		register_subalias("8", m_3.m_Q);
	38	register_subalias("8", m_3.m_Q[0]);
30	39
31	40	register_subalias("12", m_4.m_i[0]);
32	41	register_subalias("13", m_4.m_i[1]);
33		register_subalias("11", m_4.m_Q);
	42	register_subalias("11", m_4.m_Q[0]);
34	43	}
35	44
36	45	NETLIB_UPDATE(7400_dip)

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

r31057	r31058
15	15
16	16	register_subalias("4", m_1.m_i[2]);
17	17	register_subalias("5", m_1.m_i[3]);
18		register_subalias("6", m_1.m_Q);
	18	register_subalias("6", m_1.m_Q[0]);
19	19
20		register_subalias("8", m_2.m_Q);
	20	register_subalias("8", m_2.m_Q[0]);
21	21	register_subalias("9", m_2.m_i[0]);
22	22	register_subalias("10", m_2.m_i[1]);
23	23

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

r31057	r31058
12	12	register_sub(m_3, "3");
13	13	register_sub(m_4, "4");
14	14
15		register_subalias("1", m_1.m_Q);
	15	register_subalias("1", m_1.m_Q[0]);
16	16	register_subalias("2", m_1.m_i[0]);
17	17	register_subalias("3", m_1.m_i[1]);
18	18
19		register_subalias("4", m_2.m_Q);
	19	register_subalias("4", m_2.m_Q[0]);
20	20	register_subalias("5", m_2.m_i[0]);
21	21	register_subalias("6", m_2.m_i[1]);
22	22
23	23	register_subalias("8", m_3.m_i[0]);
24	24	register_subalias("9", m_3.m_i[1]);
25		register_subalias("10", m_3.m_Q);
	25	register_subalias("10", m_3.m_Q[0]);
26	26
27	27	register_subalias("11", m_4.m_i[0]);
28	28	register_subalias("12", m_4.m_i[1]);
29		register_subalias("13", m_4.m_Q);
	29	register_subalias("13", m_4.m_Q[0]);
30	30	}
31	31
32	32	NETLIB_UPDATE(7402_dip)

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

r31057	r31058
43	43	NETLIB_SIGNAL(7400, 2, 0, 0);
44	44	#else
45	45	#include "nld_truthtable.h"
46		class nld_7400 : public nld_truthtable_t<2,1>
47		{
48		public:
49		nld_7400 ()
50		: nld_truthtable_t<2,1>()
51		{
52		}
53		void start()
54		{
55		static const char *tt[] = {
56		"A,B,PQ,PA,PB|Q",
57		"0,X,X,X,X|1",
58		"X,0,X,X,X|1",
59		"1,1,X,X,X|0",
60		""
61		};
62		setup_tt(tt, m_outs);
63		}
64		private:
65		static UINT32 m_outs[m_size];
66		};
	46	NETLIB_TRUTHTABLE(7400, 2, 1, 0);
67	47	#endif
68	48
69	49

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

r31057	r31058
17	17
18	18	register_subalias("4", m_1.m_i[2]);
19	19	register_subalias("5", m_1.m_i[3]);
20		register_subalias("6", m_1.m_Q);
	20	register_subalias("6", m_1.m_Q[0]);
21	21
22		register_subalias("8", m_2.m_Q);
	22	register_subalias("8", m_2.m_Q[0]);
23	23	register_subalias("9", m_2.m_i[0]);
24	24	register_subalias("10", m_2.m_i[1]);
25	25

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

r31057	r31058
14	14
15	15	register_subalias("1", m_1.m_i[0]);
16	16	register_subalias("2", m_1.m_i[1]);
17		register_subalias("3", m_1.m_Q);
	17	register_subalias("3", m_1.m_Q[0]);
18	18
19	19	register_subalias("4", m_2.m_i[0]);
20	20	register_subalias("5", m_2.m_i[1]);
21		register_subalias("6", m_2.m_Q);
	21	register_subalias("6", m_2.m_Q[0]);
22	22
23	23	register_subalias("9", m_3.m_i[0]);
24	24	register_subalias("10", m_3.m_i[1]);
25		register_subalias("8", m_3.m_Q);
	25	register_subalias("8", m_3.m_Q[0]);
26	26
27	27	register_subalias("12", m_4.m_i[0]);
28	28	register_subalias("13", m_4.m_i[1]);
29		register_subalias("11", m_4.m_Q);
	29	register_subalias("11", m_4.m_Q[0]);
30	30	}
31	31
32	32	NETLIB_UPDATE(7408_dip)

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

r31057	r31058
16	16	register_subalias("3", m_2.m_i[0]);
17	17	register_subalias("4", m_2.m_i[1]);
18	18	register_subalias("5", m_2.m_i[2]);
19		register_subalias("6", m_2.m_Q);
	19	register_subalias("6", m_2.m_Q[0]);
20	20
21		register_subalias("8", m_3.m_Q);
	21	register_subalias("8", m_3.m_Q[0]);
22	22	register_subalias("9", m_3.m_i[0]);
23	23	register_subalias("10", m_3.m_i[1]);
24	24	register_subalias("11", m_3.m_i[2]);
25	25
26		register_subalias("12", m_1.m_Q);
	26	register_subalias("12", m_1.m_Q[0]);
27	27	register_subalias("13", m_1.m_i[2]);
28	28	}
29	29

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

r31057	r31058
10	10
11	11	#include "../nl_base.h"
12	12
13		template<int m_NI, int m_NO>
	13	#define NETLIB_TRUTHTABLE(_name, _nIN, _nOUT, _state)                               \
	14	class NETLIB_NAME(_name) : public nld_truthtable_t<_nIN, _nOUT, _state>         \
	15	{                                                                               \
	16	public:                                                                         \
	17	NETLIB_NAME(_name)()                                                        \
	18	: nld_truthtable_t<_nIN, _nOUT, _state>(&m_ttbl, m_desc) { }                \
	19	private:                                                                        \
	20	static truthtable_t m_ttbl;                                                 \
	21	static const char *m_desc[];                                                \
	22	}
	23
	24
	25	template<int m_NI, int m_NO, int has_state>
14	26	class nld_truthtable_t : public netlist_device_t
15	27	{
16	28	public:
17	29
18		static const int m_size = (1 << (2 * m_NI + m_NO));
	30	static const int m_num_bits = m_NI + has_state * (m_NI + m_NO);
	31	static const int m_size = (1 << (m_num_bits));
19	32
20		nld_truthtable_t()
21		: netlist_device_t(), m_active(1)
	33	struct truthtable_t
22	34	{
	35	truthtable_t() : m_initialized(false) {}
	36	UINT32 m_outs[m_size];
	37	UINT8  m_timing[m_size][m_NO];
	38	netlist_time m_timing_nt[16];
	39	bool m_initialized;
	40	};
	41
	42	nld_truthtable_t(truthtable_t *ttbl, const char *desc[])
	43	: netlist_device_t(), m_last_state(0), m_active(1), m_ttp(ttbl), m_desc(desc)
	44	{
23	45	}
24	46
25	47	ATTR_COLD virtual void start()
26	48	{
	49	pstring ttline = pstring(m_desc[0]);
	50	{
	51	nl_util::pstring_list io = nl_util::split(ttline,"|");
	52	// checks
	53	assert(io.count() == 2);
	54	nl_util::pstring_list inout = nl_util::split(io[0], ",");
	55	assert(inout.count() == m_num_bits);
	56	nl_util::pstring_list out = nl_util::split(io[1], ",");
	57	assert(out.count() == m_NO);
	58
	59	for (int i=0; i < m_NI; i++)
	60	{
	61	register_input(inout[i], m_i[i]);
	62	}
	63	for (int i=0; i < m_NO; i++)
	64	{
	65	register_output(out[i], m_Q[i]);
	66	}
	67	}
	68	setup_tt();
	69	// FIXME: save state
27	70	}
28	71
29		ATTR_COLD void help(UINT32 outs[], int cur, nl_util::pstring_list list, UINT64 state, UINT64 ignore, UINT16 val)
	72	ATTR_COLD void help(int cur, nl_util::pstring_list list,
	73	UINT64 state, UINT64 ignore, UINT16 val, UINT8 timing_index[m_NO])
30	74	{
31	75	pstring elem = list[cur];
32	76	int start = 0;
r31057	r31058
54	98	const UINT64 nstate = state | (i << cur);
55	99	const UINT64 nignore = ignore | (ign << cur);
56	100
57		if (cur < list.count() - 1)
	101	if (cur < m_num_bits - 1)
58	102	{
59		help(outs, cur + 1, list, nstate, nignore, val);
	103	help(cur + 1, list, nstate, nignore, val, timing_index);
60	104	}
61	105	else
62	106	{
63	107	// cutoff previous inputs and outputs for ignore
64		outs[nstate] = val | ((nignore & ((1 << m_NI)-1)) << m_NO);
	108	m_ttp->m_outs[nstate] = val | ((nignore & ((1 << m_NI)-1)) << m_NO);
	109	for (int j=0; j<m_NO; j++)
	110	m_ttp->m_timing[nstate][j] = timing_index[j];
65	111	}
66	112	}
67	113	}
68	114
69		ATTR_COLD void setup_tt(const char **truthtable, UINT32 outs[])
	115	ATTR_COLD void setup_tt()
70	116	{
	117	if (m_ttp->m_initialized)
	118	return;
	119
	120	const char **truthtable = m_desc;
71	121	pstring ttline = pstring(truthtable[0]);
72	122	truthtable++;
73		{
74		nl_util::pstring_list io = nl_util::split(ttline,"|");
75		// checks
76		assert(io.count() == 2);
77		nl_util::pstring_list inout = nl_util::split(io[0], ",");
78		assert(inout.count() == 2 * m_NI + m_NO);
79		nl_util::pstring_list out = nl_util::split(io[1], ",");
80		assert(out.count() == m_NO);
	123	ttline = pstring(truthtable[0]);
	124	truthtable++;
81	125
82		for (int i=0; i < m_NI; i++)
83		{
84		register_input(inout[i], m_i[i]);
85		}
86		for (int i=0; i < m_NO; i++)
87		{
88		register_output(out[i], m_Q[i]);
89		}
90		//save(NAME(m_active));
91		ttline = pstring(truthtable[0]);
92		truthtable++;
93		}
94
95	126	for (int j=0; j < m_size; j++)
96		outs[j] = -1;
	127	m_ttp->m_outs[j] = -1;
97	128
	129	for (int j=0; j < 16; j++)
	130	m_ttp->m_timing_nt[j] = netlist_time::zero;
	131
98	132	while (!ttline.equals(""))
99	133	{
100	134	nl_util::pstring_list io = nl_util::split(ttline,"|");
101	135	// checks
102		assert(io.count() == 2);
	136	assert(io.count() == 3);
103	137	nl_util::pstring_list inout = nl_util::split(io[0], ",");
104		assert(inout.count() == 2 * m_NI + m_NO);
	138	assert(inout.count() == m_num_bits);
105	139	nl_util::pstring_list out = nl_util::split(io[1], ",");
106	140	assert(out.count() == m_NO);
	141	nl_util::pstring_list times = nl_util::split(io[2], ",");
	142	assert(times.count() == m_NO);
107	143
108	144	UINT16 val = 0;
	145	UINT8 tindex[m_NO];
109	146	for (int j=0; j<m_NO; j++)
	147	{
110	148	if (out[j].equals("1"))
111	149	val = val | (1 << j);
	150	netlist_time t = netlist_time::from_nsec(times[j].as_long());
	151	int k=0;
	152	while (m_ttp->m_timing_nt[k] != netlist_time::zero && m_ttp->m_timing_nt[k] != t)
	153	k++;
	154	m_ttp->m_timing_nt[k] = t;
	155	tindex[j] = k;
	156	}
112	157
113		help(outs, 0, inout, 0 , 0 , val);
	158	help(0, inout, 0 , 0 , val, tindex);
114	159	ttline = pstring(truthtable[0]);
115	160	truthtable++;
116	161	}
117	162	for (int j=0; j < m_size; j++)
118		printf("%05x %04x %04x\n", j, outs[j] & ((1 << m_NO)-1), outs[j] >> m_NO);
119		m_ttp = outs;
	163	printf("%05x %04x %04x %04x\n", j, m_ttp->m_outs[j] & ((1 << m_NO)-1),
	164	m_ttp->m_outs[j] >> m_NO, m_ttp->m_timing[j][0]);
	165	for (int k=0; m_ttp->m_timing_nt[k] != netlist_time::zero; k++)
	166	printf("%d %f\n", k, m_ttp->m_timing_nt[k].as_double() * 1000000.0);
	167
	168	m_ttp->m_initialized = true;
	169
120	170	}
121	171
122	172	ATTR_COLD void reset()
r31057	r31058
128	178
129	179	ATTR_HOT ATTR_ALIGN void update()
130	180	{
131		const netlist_time times[2] = { NLTIME_FROM_NS(15), NLTIME_FROM_NS(22)};
	181	//const netlist_time times[2] = { NLTIME_FROM_NS(15), NLTIME_FROM_NS(22)};
132	182
133	183	// FIXME: this check is needed because update is called during startup as well
134	184	if (UNEXPECTED(USE_DEACTIVE_DEVICE && m_active == 0))
r31057	r31058
141	191	state = state | (INPLOGIC(m_i[i]) << i);
142	192	}
143	193
144		const UINT32 nstate = state | (m_last_state << m_NI);
145		const UINT32 out = m_ttp[nstate] & ((1 << m_NO) - 1);
146		const UINT32 ign = m_ttp[nstate] >> m_NO;
	194	const UINT32 nstate = (has_state ? state | (m_last_state << m_NI) : state);
	195	const UINT32 out = m_ttp->m_outs[nstate] & ((1 << m_NO) - 1);
	196	const UINT32 ign = m_ttp->m_outs[nstate] >> m_NO;
	197	if (has_state) m_last_state = (state << m_NO) | out;
147	198
148	199	for (int i=0; i< m_NI; i++)
149	200	if (ign & (1 << i))
150	201	m_i[i].inactivate();
151	202
152	203	for (int i=0; i<m_NO; i++)
153		OUTLOGIC(m_Q[i], (out >> i) & 1, times[(out >> i) & 1]);// ? 22000 : 15000);
154		m_last_state = (state << m_NO) | out;
	204	//            OUTLOGIC(m_Q[i], (out >> i) & 1, times[(out >> i) & 1]);// ? 22000 : 15000);
	205	OUTLOGIC(m_Q[i], (out >> i) & 1, m_ttp->m_timing_nt[m_ttp->m_timing[nstate][i]]);// ? 22000 : 15000);
155	206
156	207	}
157	208
r31057	r31058
175	226	}
176	227	#endif
177	228
178		public:
179	229	netlist_ttl_input_t m_i[m_NI];
180	230	netlist_ttl_output_t m_Q[m_NO];
181	231
182		UINT32 *m_ttp;
	232	private:
	233
	234	UINT32 m_last_state;
183	235	INT32 m_active;
184		UINT32 m_last_state;
	236
	237	truthtable_t *m_ttp;
	238	const char **m_desc;
185	239	};
186	240
187	241	#endif /* NLD_TRUTHTABLE_H_ */

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

r31057	r31058
16	16	register_subalias("3", m_2.m_i[0]);
17	17	register_subalias("4", m_2.m_i[1]);
18	18	register_subalias("5", m_2.m_i[2]);
19		register_subalias("6", m_2.m_Q);
	19	register_subalias("6", m_2.m_Q[0]);
20	20
21		register_subalias("8", m_3.m_Q);
	21	register_subalias("8", m_3.m_Q[0]);
22	22	register_subalias("9", m_3.m_i[0]);
23	23	register_subalias("10", m_3.m_i[1]);
24	24	register_subalias("11", m_3.m_i[2]);
25	25
26		register_subalias("12", m_1.m_Q);
	26	register_subalias("12", m_1.m_Q[0]);
27	27	register_subalias("13", m_1.m_i[2]);
28	28	}
29	29

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

r31057	r31058
16	16	register_subalias("3", m_2.m_i[0]);
17	17	register_subalias("4", m_2.m_i[1]);
18	18	register_subalias("5", m_2.m_i[2]);
19		register_subalias("6", m_2.m_Q);
	19	register_subalias("6", m_2.m_Q[0]);
20	20
21		register_subalias("8", m_3.m_Q);
	21	register_subalias("8", m_3.m_Q[0]);
22	22	register_subalias("9", m_3.m_i[0]);
23	23	register_subalias("10", m_3.m_i[1]);
24	24	register_subalias("11", m_3.m_i[2]);
25	25
26		register_subalias("12", m_1.m_Q);
	26	register_subalias("12", m_1.m_Q[0]);
27	27	register_subalias("13", m_1.m_i[2]);
28	28	}
29	29

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

r31057	r31058
16	16	register_subalias("5", m_1.m_i[4]);
17	17	register_subalias("6", m_1.m_i[5]);
18	18
19		register_subalias("8", m_1.m_Q);
	19	register_subalias("8", m_1.m_Q[0]);
20	20
21	21	register_subalias("11", m_1.m_i[6]);
22	22	register_subalias("12", m_1.m_i[7]);

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

r31057	r31058
12	12	register_sub(m_3, "3");
13	13	register_sub(m_4, "4");
14	14
15		register_subalias("1", m_1.m_Q);
	15	register_subalias("1", m_1.m_Q[0]);
16	16	register_subalias("2", m_1.m_i[0]);
17	17	register_subalias("3", m_1.m_i[1]);
18	18
19		register_subalias("4", m_2.m_Q);
	19	register_subalias("4", m_2.m_Q[0]);
20	20	register_subalias("5", m_2.m_i[0]);
21	21	register_subalias("6", m_2.m_i[1]);
22	22
23	23	register_subalias("8", m_3.m_i[0]);
24	24	register_subalias("9", m_3.m_i[1]);
25		register_subalias("10", m_3.m_Q);
	25	register_subalias("10", m_3.m_Q[0]);
26	26
27	27	register_subalias("11", m_4.m_i[0]);
28	28	register_subalias("12", m_4.m_i[1]);
29		register_subalias("13", m_4.m_Q);
	29	register_subalias("13", m_4.m_Q[0]);
30	30	}
31	31
32	32	NETLIB_UPDATE(7432_dip)

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

r31057	r31058
14	14
15	15	register_subalias("1", m_1.m_i[0]);
16	16	register_subalias("2", m_1.m_i[1]);
17		register_subalias("3", m_1.m_Q);
	17	register_subalias("3", m_1.m_Q[0]);
18	18
19	19	register_subalias("4", m_2.m_i[0]);
20	20	register_subalias("5", m_2.m_i[1]);
21		register_subalias("6", m_2.m_Q);
	21	register_subalias("6", m_2.m_Q[0]);
22	22
23	23	register_subalias("9", m_3.m_i[0]);
24	24	register_subalias("10", m_3.m_i[1]);
25		register_subalias("8", m_3.m_Q);
	25	register_subalias("8", m_3.m_Q[0]);
26	26
27	27	register_subalias("12", m_4.m_i[0]);
28	28	register_subalias("13", m_4.m_i[1]);
29		register_subalias("11", m_4.m_Q);
	29	register_subalias("11", m_4.m_Q[0]);
30	30	}
31	31
32	32	NETLIB_UPDATE(7437_dip)

trunk/src/emu/netlist/nl_time.h

r31057	r31058
40	40	ATTR_HOT friend inline bool operator<(const netlist_time &left, const netlist_time &right);
41	41	ATTR_HOT friend inline bool operator>=(const netlist_time &left, const netlist_time &right);
42	42	ATTR_HOT friend inline bool operator<=(const netlist_time &left, const netlist_time &right);
	43	ATTR_HOT friend inline bool operator!=(const netlist_time &left, const netlist_time &right);
43	44
44	45	ATTR_HOT inline const netlist_time &operator=(const netlist_time &right) { m_time = right.m_time; return *this; }
45	46	ATTR_HOT inline const netlist_time &operator=(const double &right) { m_time = (INTERNALTYPE) ( right * (double) RESOLUTION); return *this; }
r31057	r31058
111	112	return (left.m_time >= right.m_time);
112	113	}
113	114
	115	ATTR_HOT inline bool operator!=(const netlist_time &left, const netlist_time &right)
	116	{
	117	return (left.m_time != right.m_time);
	118	}
114	119
115	120	#endif /* NLTIME_H_ */

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team