void newstate(netlist_sig_t stateQ, netlist_sig_t stateQQ)
{
// 0: High-to-low 40 ns, 1: Low-to-high 25 ns
std.array <netlist_time, u64_const_2> delay = new std.array <netlist_time, u64_const_2>(NLTIME_FROM_NS(40), NLTIME_FROM_NS(25));
m_Q.push(stateQ, delay[stateQ]);
m_QQ.push(stateQQ, delay[stateQQ]);
}
public static void sha1_process(std.array <uint32_t, u64_const_5> st, PointerU32 data) //inline void sha1_process(std::array<uint32_t, 5> &st, uint32_t *data)
{
std.array <uint32_t, u64_const_5> d = st;
unsigned i = 0U;
while (i < 16U)
{
sha1_r0(data, d, i++);
}
while (i < 20U)
{
sha1_r1(data, d, i++);
}
while (i < 40U)
{
sha1_r2(data, d, i++);
}
while (i < 60U)
{
sha1_r3(data, d, i++);
}
while (i < 80U)
{
sha1_r4(data, d, i++);
}
for (i = 0U; i < 5U; i++)
{
st[i] += d[i];
}
}
public void terminal_t_after_ctor(terminal_t otherterm, std.array <terminal_t, u64_const_2> splitterterms = null)
{
if (splitterterms == null)
{
splitterterms = new std.array <terminal_t, u64_const_2>(null, null);
}
state().setup().register_term(this, otherterm, splitterterms);
}
//template<typename T, std::size_t NT>
public void push <size_t_NT>(UInt64 v, std.array <netlist_time, size_t_NT> t) //void push(const T &v, const std::array<netlist_time, NT> &t)
where size_t_NT : u64_const, new()
{
//throw new emu_unimplemented();
#if false
static_assert(NT >= N, "Not enough timing entries provided");
#endif
push(v, t.data());
}
//NETLIB_HANDLERI(sub)
void sub()
{
std.array <netlist_time, u64_const_2> delay = new std.array <netlist_time, u64_const_2>(NLTIME_FROM_NS(23), NLTIME_FROM_NS(18));
if (m_G.op() == 0)
{
var t = m_C.op(m_chan.op).op();
m_Y.push(t, delay[t]);
}
else
{
m_Y.push(0, delay[0]);
}
}
/// \brief Evaluate the expression
///
/// \param values for input variables, e.g. {1.1, 2.2}
/// \return value of expression
///
//template <typename NT>
public NT evaluate(std.vector <NT> values = null) //value_type evaluate(const values_container &values = values_container()) noexcept;
{
std.array <NT, size_t_const_MAX_STACK> stack = new std.array <NT, size_t_const_MAX_STACK>(); // NOLINT //std::array<value_type, MAX_STACK> stack; // NOLINT
Pointer <NT> ptr = stack.data(); //value_type *ptr = stack.data();
var zero = plib.constants <NT, NT_OPS> .zero(); //var zero = plib.constants<value_type>.zero();
var one = plib.constants <NT, NT_OPS> .one(); //var one = plib.constants<value_type>.one();
foreach (var rc in m_precompiled)
{
switch (rc.cmd())
{
case rpn_cmd.ADD: evaluate_OP(ref ptr, rpn_cmd.ADD, 1, ops.add(evaluate_ST2(ptr), evaluate_ST1(ptr))); break; //OP(ADD, 1, ST2 + ST1)
case rpn_cmd.MULT: evaluate_OP(ref ptr, rpn_cmd.MULT, 1, ops.multiply(evaluate_ST2(ptr), evaluate_ST1(ptr))); break; //OP(MULT, 1, ST2 * ST1)
case rpn_cmd.SUB: evaluate_OP(ref ptr, rpn_cmd.SUB, 1, ops.subtract(evaluate_ST2(ptr), evaluate_ST1(ptr))); break; //OP(SUB, 1, ST2 - ST1)
case rpn_cmd.DIV: evaluate_OP(ref ptr, rpn_cmd.DIV, 1, ops.divide(evaluate_ST2(ptr), evaluate_ST1(ptr))); break; //OP(DIV, 1, ST2 / ST1)
case rpn_cmd.EQ: evaluate_OP(ref ptr, rpn_cmd.EQ, 1, ops.equals(evaluate_ST2(ptr), evaluate_ST1(ptr)) ? one : zero); break; //OP(EQ, 1, ST2 == ST1 ? one : zero)
case rpn_cmd.NE: evaluate_OP(ref ptr, rpn_cmd.NE, 1, ops.not_equals(evaluate_ST2(ptr), evaluate_ST1(ptr)) ? one : zero); break; //OP(NE, 1, ST2 != ST1 ? one : zero)
case rpn_cmd.GT: evaluate_OP(ref ptr, rpn_cmd.GT, 1, ops.greater_than(evaluate_ST2(ptr), evaluate_ST1(ptr)) ? one : zero); break; //OP(GT, 1, ST2 > ST1 ? one : zero)
case rpn_cmd.LT: evaluate_OP(ref ptr, rpn_cmd.LT, 1, ops.less_than(evaluate_ST2(ptr), evaluate_ST1(ptr)) ? one : zero); break; //OP(LT, 1, ST2 < ST1 ? one : zero)
case rpn_cmd.LE: evaluate_OP(ref ptr, rpn_cmd.LE, 1, ops.less_than_or_equal(evaluate_ST2(ptr), evaluate_ST1(ptr)) ? one : zero); break; //OP(LE, 1, ST2 <= ST1 ? one : zero)
case rpn_cmd.GE: evaluate_OP(ref ptr, rpn_cmd.GE, 1, ops.greater_than_or_equal(evaluate_ST2(ptr), evaluate_ST1(ptr)) ? one : zero); break; //OP(GE, 1, ST2 >= ST1 ? one : zero)
case rpn_cmd.IF: evaluate_OP(ref ptr, rpn_cmd.IF, 2, ops.not_equals(evaluate_ST2(ptr), zero) ? evaluate_ST1(ptr) : evaluate_ST0(ptr)); break; //OP(IF, 2, (ST2 != zero) ? ST1 : ST0)
case rpn_cmd.NEG: evaluate_OP(ref ptr, rpn_cmd.NEG, 0, ops.neg(evaluate_ST2(ptr))); break; //OP(NEG, 0, -ST2)
case rpn_cmd.POW: evaluate_OP(ref ptr, rpn_cmd.POW, 1, ops.pow(evaluate_ST2(ptr), evaluate_ST1(ptr))); break; //OP(POW, 1, plib::pow(ST2, ST1))
case rpn_cmd.LOG: evaluate_OP(ref ptr, rpn_cmd.LOG, 0, ops.log(evaluate_ST2(ptr))); break; //OP(LOG, 0, plib::log(ST2))
case rpn_cmd.SIN: evaluate_OP(ref ptr, rpn_cmd.SIN, 0, ops.sin(evaluate_ST2(ptr))); break; //OP(SIN, 0, plib::sin(ST2))
case rpn_cmd.COS: evaluate_OP(ref ptr, rpn_cmd.COS, 0, ops.cos(evaluate_ST2(ptr))); break; //OP(COS, 0, plib::cos(ST2))
case rpn_cmd.MAX: evaluate_OP(ref ptr, rpn_cmd.MAX, 1, ops.max(evaluate_ST2(ptr), evaluate_ST1(ptr))); break; //OP(MAX, 1, std::max(ST2, ST1))
case rpn_cmd.MIN: evaluate_OP(ref ptr, rpn_cmd.MIN, 1, ops.min(evaluate_ST2(ptr), evaluate_ST1(ptr))); break; //OP(MIN, 1, std::min(ST2, ST1))
case rpn_cmd.TRUNC: evaluate_OP(ref ptr, rpn_cmd.TRUNC, 0, ops.trunc(evaluate_ST2(ptr))); break; //OP(TRUNC, 0, plib::trunc(ST2))
case rpn_cmd.RAND: evaluate_OP0(ref ptr, rpn_cmd.RAND, lfsr_random(ref m_lfsr)); break; //OP0(RAND, lfsr_random<value_type>(m_lfsr))
case rpn_cmd.PUSH_INPUT: evaluate_OP0(ref ptr, rpn_cmd.PUSH_INPUT, values[rc.index()]); break; //OP0(PUSH_INPUT, values[rc.index()])
case rpn_cmd.PUSH_CONST: evaluate_OP0(ref ptr, rpn_cmd.PUSH_CONST, rc.value()); break; //OP0(PUSH_CONST, rc.value())
// please compiler
case rpn_cmd.LP:
case rpn_cmd.RP:
break;
}
}
return((ptr - 1)[0]); //return *(ptr-1);
}
static void sha1_r4(PointerU32 data, std.array <uint32_t, u64_const_5> d, unsigned i) //inline void sha1_r4(uint32_t *data, std::array<uint32_t, 5> &d, unsigned i)
{
d[i % 5] = d[i % 5] + (d[(i + 3) % 5] ^ d[(i + 2) % 5] ^ d[(i + 1) % 5]) + sha1_b(data, i) + 0xca62c1d6U + sha1_rol(d[(i + 4) % 5], 5);
d[(i + 3) % 5] = sha1_rol(d[(i + 3) % 5], 30);
}
static void sha1_r3(PointerU32 data, std.array <uint32_t, u64_const_5> d, unsigned i) //inline void sha1_r3(uint32_t *data, std::array<uint32_t, 5> &d, unsigned i)
{
d[i % 5] = d[i % 5] + (((d[(i + 3) % 5] | d[(i + 2) % 5]) & d[(i + 1) % 5]) | (d[(i + 3) % 5] & d[(i + 2) % 5])) + sha1_b(data, i) + 0x8f1bbcdcU + sha1_rol(d[(i + 4) % 5], 5);
d[(i + 3) % 5] = sha1_rol(d[(i + 3) % 5], 30);
}
static void sha1_r0(PointerU32 data, std.array <uint32_t, u64_const_5> d, unsigned i) //inline void sha1_r0(const uint32_t *data, std::array<uint32_t, 5> &d, unsigned i)
{
d[i % 5] = d[i % 5] + ((d[(i + 3) % 5] & (d[(i + 2) % 5] ^ d[(i + 1) % 5])) ^ d[(i + 1) % 5]) + data[i] + 0x5a827999U + sha1_rol(d[(i + 4) % 5], 5);
d[(i + 3) % 5] = sha1_rol(d[(i + 3) % 5], 30);
}
// debugging
//void dump(std::ostream &str) const;
//std::string dump();
// internal helpers
//-------------------------------------------------
// build_codes - given an input port table, create
// an input code table useful for mapping unicode
// chars
//-------------------------------------------------
void build_codes()
{
ioport_manager manager = machine().ioport();
// find all the devices with keyboard or keypad inputs
foreach (var port in manager.ports())
{
var devinfo =
std.find_if(
m_keyboards,
(kbd_dev_info info) =>
{
return(port.second().device() == info.device);
});
foreach (ioport_field field in port.second().fields())
{
bool is_keyboard = field.type() == ioport_type.IPT_KEYBOARD;
if (is_keyboard || (field.type() == ioport_type.IPT_KEYPAD))
{
if (default == devinfo)
{
//devinfo = m_keyboards.emplace(devinfo, port.second->device());
devinfo = new kbd_dev_info(port.second().device());
m_keyboards.push_back(devinfo);
}
devinfo.keyfields.emplace_back(field);
if (is_keyboard)
{
devinfo.keyboard = true;
}
else
{
devinfo.keypad = true;
}
}
}
}
std.sort(
m_keyboards,
(kbd_dev_info l, kbd_dev_info r) =>
{
return(std.strcmp(l.device.tag(), r.device.tag()));
});
// set up key mappings for each keyboard
std.array <ioport_field, size_t_const_SHIFT_COUNT> shift = new std.array <ioport_field, size_t_const_SHIFT_COUNT>();
unsigned mask;
bool have_keyboard = false;
foreach (kbd_dev_info devinfo in m_keyboards)
{
if (LOG_NATURAL_KEYBOARD)
{
machine().logerror("natural_keyboard: building codes for {0}... ({1} fields)\n", devinfo.device.tag(), devinfo.keyfields.size());
}
// enable all pure keypads and the first keyboard
if (!devinfo.keyboard || !have_keyboard)
{
devinfo.enabled = true;
}
have_keyboard = have_keyboard || devinfo.keyboard;
// find all shift keys
std.fill(shift, (ioport_field)null); //std::fill(std::begin(shift), std::end(shift), nullptr);
mask = 0;
foreach (ioport_field field in devinfo.keyfields)
{
if (field.type() == ioport_type.IPT_KEYBOARD)
{
std.vector <char32_t> codes = field.keyboard_codes(0);
foreach (char32_t code in codes)
{
if ((code >= UCHAR_SHIFT_BEGIN) && (code <= UCHAR_SHIFT_END))
{
mask |= 1U << (int)(code - UCHAR_SHIFT_BEGIN);
shift[code - UCHAR_SHIFT_BEGIN] = field;
if (LOG_NATURAL_KEYBOARD)
{
machine().logerror("natural_keyboard: UCHAR_SHIFT_{0} found\n", code - UCHAR_SHIFT_BEGIN + 1);
}
}
}
}
}
// iterate over keyboard/keypad fields
foreach (ioport_field field in devinfo.keyfields)
{
field.live().lockout = !devinfo.enabled;
if (field.type() == ioport_type.IPT_KEYBOARD)
{
// iterate over all shift states
for (unsigned curshift = 0; curshift < SHIFT_STATES; ++curshift)
{
if ((curshift & ~mask) == 0)
{
// fetch the code, ignoring 0 and shifters
std.vector <char32_t> codes = field.keyboard_codes((int)curshift);
foreach (char32_t code in codes)
{
if (((code < UCHAR_SHIFT_BEGIN) || (code > UCHAR_SHIFT_END)) && (code != 0))
{
m_have_charkeys = true;
var found = devinfo.codemap.find(code); //keycode_map::iterator const found(devinfo.codemap.find(code));
keycode_map_entry newcode = new keycode_map_entry();
std.fill(newcode.field, (ioport_field)null); //std::fill(std::begin(newcode.field), std::end(newcode.field), nullptr);
newcode.shift = curshift;
newcode.condition = field.condition();
unsigned fieldnum = 0;
for (unsigned i = 0, bits = curshift; (i < SHIFT_COUNT) && (bits != 0); ++i, bits >>= 1)
{
if (BIT(bits, 0) != 0)
{
newcode.field[fieldnum++] = shift[i];
}
}
newcode.field[fieldnum] = field;
if (default == found)
{
natural_keyboard_keycode_map_entries entries = new natural_keyboard_keycode_map_entries();
entries.emplace_back(newcode);
devinfo.codemap.emplace(code, entries);
}
else
{
found.emplace_back(newcode);
}
if (LOG_NATURAL_KEYBOARD)
{
machine().logerror("natural_keyboard: code={0} ({1}) port={2} field.name='{3}'\n",
code, unicode_to_string(code), field.port(), field.name());
}
}
}
}
}
}
}
// sort mapping entries by shift state
foreach (var mapping in devinfo.codemap)
{
std.sort(
mapping.second(),
(keycode_map_entry x, keycode_map_entry y) => { return(x.shift.CompareTo(y.shift)); }); //[] (keycode_map_entry const &x, keycode_map_entry const &y) { return x.shift < y.shift; });
}
}
public std.array <netlist_time, u64_const_16> m_timing_nt = new std.array <netlist_time, u64_const_16>(); //std::array<netlist_time, 16> m_timing_nt;
public truthtable_t()
{
m_timing_index = new std.array <uint_least8_t, u64_const_m_size_multiply_m_NO>();
m_out_state.fill(new FlexPrim(type_t, 0U));
}