mirror of
https://github.com/holub/mame
synced 2025-07-04 09:28:51 +03:00
- More c++.
- Simplify main processing loop. As a nice side-effect that squeezed out some cycles. - More cycle squeezing. - Removed pvector_t. - Use std::sort. - Refactored netlist state manager. - Introduction of state_var object template to be used on device state members. - Changed remaining save occurrences to state_var. - Rewrote nltool's listdevices command. This allowed removal of one member from devices which served solely for listdevices. - Remove hashmap_t. Fix kidniki regression. (nw)
This commit is contained in:
Ivan Vangelista
couriersud
parent
dfe4681161
commit
04c69f9aef
@ -1176,6 +1176,18 @@ if (MACHINES["LDV1000"]~=null) then
|
||||
}
|
||||
end
|
||||
|
||||
---------------------------------------------------
|
||||
--
|
||||
--@src/devices/machine/ldp1000.h,MACHINES["LDP1000"] = true
|
||||
---------------------------------------------------
|
||||
|
||||
if (MACHINES["LDP1000"]~=null) then
|
||||
files {
|
||||
MAME_DIR .. "src/devices/machine/ldp1000.cpp",
|
||||
MAME_DIR .. "src/devices/machine/ldp1000.h",
|
||||
}
|
||||
end
|
||||
|
||||
---------------------------------------------------
|
||||
--
|
||||
--@src/devices/machine/ldvp931.h,MACHINES["LDVP931"] = true
|
||||
|
||||
@ -429,6 +429,7 @@ MACHINES["LC89510"] = true
|
||||
MACHINES["LDPR8210"] = true
|
||||
MACHINES["LDSTUB"] = true
|
||||
MACHINES["LDV1000"] = true
|
||||
MACHINES["LDP1000"] = true
|
||||
MACHINES["LDVP931"] = true
|
||||
--MACHINES["LH5810"] = true
|
||||
MACHINES["LINFLASH"] = true
|
||||
|
||||
120
src/devices/machine/ldp1000.cpp
Normal file
120
src/devices/machine/ldp1000.cpp
Normal file
@ -0,0 +1,120 @@
|
||||
// license:BSD-3-Clause
|
||||
// copyright-holders:Angelo Salese
|
||||
/***************************************************************************
|
||||
|
||||
Sony LDP-1000 laserdisc emulation.
|
||||
|
||||
TODO:
|
||||
- Dump BIOSes (seven of them according to docs)
|
||||
- Hookup with Sony SMC-70 / SMC-777
|
||||
|
||||
***************************************************************************/
|
||||
|
||||
#include "emu.h"
|
||||
#include "machine/ldp1000.h"
|
||||
|
||||
|
||||
ROM_START( ldp1000 )
|
||||
ROM_REGION( 0x2000, "ldp1000", 0 )
|
||||
ROM_LOAD( "ldp1000_bios.bin", 0x0000, 0x2000, NO_DUMP )
|
||||
ROM_END
|
||||
|
||||
//**************************************************************************
|
||||
// GLOBAL VARIABLES
|
||||
//**************************************************************************
|
||||
|
||||
// device type definition
|
||||
const device_type SONY_LDP1000 = &device_creator<sony_ldp1000_device>;
|
||||
|
||||
|
||||
//**************************************************************************
|
||||
// LIVE DEVICE
|
||||
//**************************************************************************
|
||||
|
||||
//-------------------------------------------------
|
||||
// ldp1000_device - constructor
|
||||
//-------------------------------------------------
|
||||
|
||||
sony_ldp1000_device::sony_ldp1000_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
|
||||
: laserdisc_device(mconfig, SONY_LDP1000, "Sony LDP-1000", tag, owner, clock, "ldp1000", __FILE__)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// device_validity_check - perform validity checks
|
||||
// on this device
|
||||
//-------------------------------------------------
|
||||
|
||||
void sony_ldp1000_device::device_validity_check(validity_checker &valid) const
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// device_start - device-specific startup
|
||||
//-------------------------------------------------
|
||||
|
||||
void sony_ldp1000_device::device_start()
|
||||
{
|
||||
laserdisc_device::device_start();
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// device_reset - device-specific reset
|
||||
//-------------------------------------------------
|
||||
|
||||
void sony_ldp1000_device::device_reset()
|
||||
{
|
||||
laserdisc_device::device_reset();
|
||||
|
||||
}
|
||||
|
||||
//-------------------------------------------------
|
||||
// device_rom_region - return a pointer to our
|
||||
// ROM region definitions
|
||||
//-------------------------------------------------
|
||||
|
||||
const rom_entry *sony_ldp1000_device::device_rom_region() const
|
||||
{
|
||||
return ROM_NAME(ldp1000);
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// player_vsync - VSYNC callback, called at the
|
||||
// start of the blanking period
|
||||
//-------------------------------------------------
|
||||
|
||||
void sony_ldp1000_device::player_vsync(const vbi_metadata &vbi, int fieldnum, const attotime &curtime)
|
||||
{
|
||||
//printf("%d vsync\n",fieldnum);
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// player_update - update callback, called on
|
||||
// the first visible line of the frame
|
||||
//-------------------------------------------------
|
||||
|
||||
INT32 sony_ldp1000_device::player_update(const vbi_metadata &vbi, int fieldnum, const attotime &curtime)
|
||||
{
|
||||
//printf("%d update\n",fieldnum);
|
||||
|
||||
return fieldnum;
|
||||
}
|
||||
|
||||
|
||||
//**************************************************************************
|
||||
// READ/WRITE HANDLERS
|
||||
//**************************************************************************
|
||||
|
||||
READ8_MEMBER( sony_ldp1000_device::read )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
WRITE8_MEMBER( sony_ldp1000_device::write )
|
||||
{
|
||||
}
|
||||
67
src/devices/machine/ldp1000.h
Normal file
67
src/devices/machine/ldp1000.h
Normal file
@ -0,0 +1,67 @@
|
||||
// license:BSD-3-Clause
|
||||
// copyright-holders:Angelo Salese
|
||||
/***************************************************************************
|
||||
|
||||
Sony LDP-1000 laserdisc emulation.
|
||||
|
||||
***************************************************************************/
|
||||
|
||||
#pragma once
|
||||
|
||||
#ifndef __LDP1000DEV_H__
|
||||
#define __LDP1000DEV_H__
|
||||
|
||||
#include "laserdsc.h"
|
||||
|
||||
|
||||
//**************************************************************************
|
||||
// INTERFACE CONFIGURATION MACROS
|
||||
//**************************************************************************
|
||||
|
||||
#define MCFG_LASERDISC_LDP1000_ADD(_tag) \
|
||||
MCFG_DEVICE_ADD(_tag, SONY_LDP1000, 0)
|
||||
|
||||
//**************************************************************************
|
||||
// TYPE DEFINITIONS
|
||||
//**************************************************************************
|
||||
|
||||
// device type definition
|
||||
extern const device_type SONY_LDP1000;
|
||||
|
||||
// ======================> sony_ldp1000_device
|
||||
|
||||
class sony_ldp1000_device : public laserdisc_device
|
||||
{
|
||||
public:
|
||||
// construction/destruction
|
||||
sony_ldp1000_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
|
||||
|
||||
// I/O operations
|
||||
DECLARE_WRITE8_MEMBER( write );
|
||||
DECLARE_READ8_MEMBER( read );
|
||||
|
||||
protected:
|
||||
// device-level overrides
|
||||
virtual void device_validity_check(validity_checker &valid) const override;
|
||||
virtual void device_start() override;
|
||||
virtual void device_reset() override;
|
||||
virtual const rom_entry *device_rom_region() const override;
|
||||
|
||||
virtual void player_vsync(const vbi_metadata &vbi, int fieldnum, const attotime &curtime) override;
|
||||
virtual INT32 player_update(const vbi_metadata &vbi, int fieldnum, const attotime &curtime) override;
|
||||
virtual void player_overlay(bitmap_yuy16 &bitmap) override { }
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
//**************************************************************************
|
||||
// GLOBAL VARIABLES
|
||||
//**************************************************************************
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
@ -322,9 +322,9 @@ void netlist_mame_device_t::device_start()
|
||||
m_setup->start_devices();
|
||||
m_setup->resolve_inputs();
|
||||
|
||||
netlist().save_item(this, m_rem, "m_rem");
|
||||
netlist().save_item(this, m_div, "m_div");
|
||||
netlist().save_item(this, m_old, "m_old");
|
||||
netlist().save(*this, m_rem, "m_rem");
|
||||
netlist().save(*this, m_div, "m_div");
|
||||
netlist().save(*this, m_old, "m_old");
|
||||
|
||||
save_state();
|
||||
|
||||
@ -366,7 +366,7 @@ ATTR_COLD void netlist_mame_device_t::device_post_load()
|
||||
{
|
||||
LOG_DEV_CALLS(("device_post_load\n"));
|
||||
|
||||
netlist().post_load();
|
||||
netlist().state().post_load();
|
||||
netlist().rebuild_lists();
|
||||
}
|
||||
|
||||
@ -374,7 +374,7 @@ ATTR_COLD void netlist_mame_device_t::device_pre_save()
|
||||
{
|
||||
LOG_DEV_CALLS(("device_pre_save\n"));
|
||||
|
||||
netlist().pre_save();
|
||||
netlist().state().pre_save();
|
||||
}
|
||||
|
||||
void netlist_mame_device_t::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
|
||||
@ -399,53 +399,44 @@ ATTR_HOT ATTR_ALIGN void netlist_mame_device_t::check_mame_abort_slice()
|
||||
|
||||
ATTR_COLD void netlist_mame_device_t::save_state()
|
||||
{
|
||||
for (auto const & s : netlist().save_list())
|
||||
for (auto const & s : netlist().state().save_list())
|
||||
{
|
||||
netlist().log().debug("saving state for {1}\n", s->m_name.cstr());
|
||||
switch (s->m_dt)
|
||||
if (s->m_dt.is_float)
|
||||
{
|
||||
case pstate_data_type_e::DT_DOUBLE:
|
||||
{
|
||||
double *td = s->resolved<double>();
|
||||
if (td != nullptr) save_pointer(td, s->m_name.cstr(), s->m_count);
|
||||
}
|
||||
break;
|
||||
case pstate_data_type_e::DT_FLOAT:
|
||||
{
|
||||
float *td = s->resolved<float>();
|
||||
if (td != nullptr) save_pointer(td, s->m_name.cstr(), s->m_count);
|
||||
}
|
||||
break;
|
||||
#if (PHAS_INT128)
|
||||
case pstate_data_type_e::DT_INT128:
|
||||
// FIXME: we are cheating here
|
||||
save_pointer((char *) s->m_ptr, s->m_name.cstr(), s->m_count * sizeof(INT128));
|
||||
break;
|
||||
#endif
|
||||
case pstate_data_type_e::DT_INT64:
|
||||
save_pointer((INT64 *) s->m_ptr, s->m_name.cstr(), s->m_count);
|
||||
break;
|
||||
case pstate_data_type_e::DT_INT16:
|
||||
save_pointer((INT16 *) s->m_ptr, s->m_name.cstr(), s->m_count);
|
||||
break;
|
||||
case pstate_data_type_e::DT_INT8:
|
||||
save_pointer((INT8 *) s->m_ptr, s->m_name.cstr(), s->m_count);
|
||||
break;
|
||||
case pstate_data_type_e::DT_INT:
|
||||
save_pointer((int *) s->m_ptr, s->m_name.cstr(), s->m_count);
|
||||
break;
|
||||
case pstate_data_type_e::DT_BOOLEAN:
|
||||
save_pointer((bool *) s->m_ptr, s->m_name.cstr(), s->m_count);
|
||||
break;
|
||||
case pstate_data_type_e::DT_CUSTOM:
|
||||
break;
|
||||
case pstate_data_type_e::NOT_SUPPORTED:
|
||||
default:
|
||||
netlist().log().fatal("found unsupported save element %s\n", s->m_name);
|
||||
break;
|
||||
if (s->m_dt.size == sizeof(double))
|
||||
{
|
||||
double *td = s->resolved<double>();
|
||||
if (td != nullptr) save_pointer(td, s->m_name.cstr(), s->m_count);
|
||||
}
|
||||
else if (s->m_dt.size == sizeof(float))
|
||||
{
|
||||
float *td = s->resolved<float>();
|
||||
if (td != nullptr) save_pointer(td, s->m_name.cstr(), s->m_count);
|
||||
}
|
||||
else
|
||||
netlist().log().fatal("Unknown floating type for {1}\n", s->m_name.cstr());
|
||||
}
|
||||
else if (s->m_dt.is_integral)
|
||||
{
|
||||
if (s->m_dt.size == sizeof(INT64))
|
||||
save_pointer((INT64 *) s->m_ptr, s->m_name.cstr(), s->m_count);
|
||||
else if (s->m_dt.size == sizeof(INT32))
|
||||
save_pointer((INT32 *) s->m_ptr, s->m_name.cstr(), s->m_count);
|
||||
else if (s->m_dt.size == sizeof(INT16))
|
||||
save_pointer((INT16 *) s->m_ptr, s->m_name.cstr(), s->m_count);
|
||||
else if (s->m_dt.size == sizeof(INT8))
|
||||
save_pointer((INT8 *) s->m_ptr, s->m_name.cstr(), s->m_count);
|
||||
else
|
||||
netlist().log().fatal("Unknown integral type size {1} for {2}\n", s->m_dt.size, s->m_name.cstr());
|
||||
}
|
||||
else if (s->m_dt.is_custom)
|
||||
{
|
||||
/* do nothing */
|
||||
}
|
||||
else
|
||||
netlist().log().fatal("found unsupported save element {1}\n", s->m_name);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
@ -566,7 +557,7 @@ void netlist_mame_sound_device_t::device_start()
|
||||
|
||||
// Configure outputs
|
||||
|
||||
plib::pvector_t<nld_sound_out *> outdevs = netlist().get_device_list<nld_sound_out>();
|
||||
std::vector<nld_sound_out *> outdevs = netlist().get_device_list<nld_sound_out>();
|
||||
if (outdevs.size() == 0)
|
||||
fatalerror("No output devices");
|
||||
|
||||
@ -592,7 +583,7 @@ void netlist_mame_sound_device_t::device_start()
|
||||
m_num_inputs = 0;
|
||||
m_in = nullptr;
|
||||
|
||||
plib::pvector_t<nld_sound_in *> indevs = netlist().get_device_list<nld_sound_in>();
|
||||
std::vector<nld_sound_in *> indevs = netlist().get_device_list<nld_sound_in>();
|
||||
if (indevs.size() > 1)
|
||||
fatalerror("A maximum of one input device is allowed!");
|
||||
if (indevs.size() == 1)
|
||||
|
||||
@ -507,10 +507,9 @@ public:
|
||||
: device_t(anetlist, name)
|
||||
, m_in(*this, "IN")
|
||||
, m_cpu_device(nullptr)
|
||||
, m_last(0)
|
||||
, m_last(*this, "m_last", 0)
|
||||
{
|
||||
m_cpu_device = downcast<netlist_mame_cpu_device_t *>(&downcast<netlist_mame_t &>(netlist()).parent());
|
||||
save(NLNAME(m_last));
|
||||
}
|
||||
|
||||
ATTR_COLD void reset() override
|
||||
@ -542,7 +541,7 @@ private:
|
||||
netlist::analog_input_t m_in;
|
||||
netlist_analog_output_delegate m_callback;
|
||||
netlist_mame_cpu_device_t *m_cpu_device;
|
||||
nl_double m_last;
|
||||
netlist::state_var<nl_double> m_last;
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
@ -557,10 +556,10 @@ public:
|
||||
, m_channel(*this, "CHAN", 0)
|
||||
, m_mult(*this, "MULT", 1000.0)
|
||||
, m_offset(*this, "OFFSET", 0.0)
|
||||
, m_sample(netlist::netlist_time::from_hz(1)) //sufficiently big enough
|
||||
, m_in(*this, "IN")
|
||||
, m_last_buffer(*this, "m_last_buffer", netlist::netlist_time::zero())
|
||||
{
|
||||
m_sample = netlist::netlist_time::from_hz(1); //sufficiently big enough
|
||||
save(NAME(m_last_buffer));
|
||||
}
|
||||
|
||||
static const int BUFSIZE = 2048;
|
||||
@ -615,7 +614,7 @@ private:
|
||||
netlist::analog_input_t m_in;
|
||||
double m_cur;
|
||||
int m_last_pos;
|
||||
netlist::netlist_time m_last_buffer;
|
||||
netlist::state_var<netlist::netlist_time> m_last_buffer;
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
@ -105,7 +105,7 @@ NETLIB_OBJECT_DERIVED(QBJT_switch, QBJT)
|
||||
, m_gB(NETLIST_GMIN_DEFAULT)
|
||||
, m_gC(NETLIST_GMIN_DEFAULT)
|
||||
, m_V(0.0)
|
||||
, m_state_on(0)
|
||||
, m_state_on(*this, "m_state_on", 0)
|
||||
{
|
||||
register_subalias("B", m_RB.m_P);
|
||||
register_subalias("E", m_RB.m_N);
|
||||
@ -119,8 +119,6 @@ NETLIB_OBJECT_DERIVED(QBJT_switch, QBJT)
|
||||
|
||||
connect_late(m_RB.m_P, m_BC_dummy.m_P);
|
||||
connect_late(m_RC.m_P, m_BC_dummy.m_N);
|
||||
|
||||
save(NLNAME(m_state_on));
|
||||
}
|
||||
|
||||
NETLIB_RESETI();
|
||||
@ -141,7 +139,7 @@ protected:
|
||||
nl_double m_gB; // base conductance / switch on
|
||||
nl_double m_gC; // collector conductance / switch on
|
||||
nl_double m_V; // internal voltage source
|
||||
UINT8 m_state_on;
|
||||
state_var<unsigned> m_state_on;
|
||||
|
||||
private:
|
||||
};
|
||||
@ -155,11 +153,13 @@ NETLIB_OBJECT_DERIVED(QBJT_EB, QBJT)
|
||||
{
|
||||
public:
|
||||
NETLIB_CONSTRUCTOR_DERIVED(QBJT_EB, QBJT)
|
||||
, m_D_CB(*this, "m_D_CB", true)
|
||||
, m_D_EB(*this, "m_D_EB", true)
|
||||
, m_D_EC(*this, "m_D_EC", true)
|
||||
, m_alpha_f(0)
|
||||
, m_alpha_r(0)
|
||||
, m_gD_BC(*this, "m_D_BC")
|
||||
, m_gD_BE(*this, "m_D_BE")
|
||||
, m_D_CB(*this, "m_D_CB", true)
|
||||
, m_D_EB(*this, "m_D_EB", true)
|
||||
, m_D_EC(*this, "m_D_EC", true)
|
||||
, m_alpha_f(0)
|
||||
, m_alpha_r(0)
|
||||
{
|
||||
register_subalias("E", m_D_EB.m_P); // Cathode
|
||||
register_subalias("B", m_D_EB.m_N); // Anode
|
||||
@ -173,9 +173,6 @@ public:
|
||||
connect_late(m_D_EB.m_P, m_D_EC.m_P);
|
||||
connect_late(m_D_EB.m_N, m_D_CB.m_N);
|
||||
connect_late(m_D_CB.m_P, m_D_EC.m_N);
|
||||
|
||||
m_gD_BE.save("m_D_BE", *this);
|
||||
m_gD_BC.save("m_D_BC", *this);
|
||||
}
|
||||
|
||||
protected:
|
||||
|
||||
@ -44,7 +44,7 @@ NETLIB_OBJECT(OPAMP)
|
||||
, m_G1(*this, "G1")
|
||||
, m_VCC(*this, "VCC")
|
||||
, m_GND(*this, "GND")
|
||||
, m_model(*this, "MODEL", "")
|
||||
, m_model(*this, "MODEL", "LM324")
|
||||
, m_VH(*this, "VH")
|
||||
, m_VL(*this, "VL")
|
||||
, m_VREF(*this, "VREF")
|
||||
|
||||
@ -19,12 +19,18 @@ namespace netlist
|
||||
// generic_diode
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
generic_diode::generic_diode()
|
||||
generic_diode::generic_diode(device_t &dev, pstring name)
|
||||
: m_Vd(dev, name + ".m_Vd", 0.7)
|
||||
, m_Id(dev, name + ".m_Id", 0.0)
|
||||
, m_G(dev, name + ".m_G", 1e-15)
|
||||
, m_Vt(0.0)
|
||||
, m_Is(0.0)
|
||||
, m_n(0.0)
|
||||
, m_gmin(1e-15)
|
||||
, m_VtInv(0.0)
|
||||
, m_Vcrit(0.0)
|
||||
{
|
||||
m_Vd = 0.7;
|
||||
set_param(1e-15, 1, 1e-15);
|
||||
m_G = m_gmin;
|
||||
m_Id = 0.0;
|
||||
}
|
||||
|
||||
void generic_diode::set_param(const nl_double Is, const nl_double n, nl_double gmin)
|
||||
@ -40,13 +46,6 @@ void generic_diode::set_param(const nl_double Is, const nl_double n, nl_double g
|
||||
m_VtInv = 1.0 / m_Vt;
|
||||
}
|
||||
|
||||
void generic_diode::save(pstring name, object_t &parent)
|
||||
{
|
||||
parent.save(m_Vd, name + ".m_Vd");
|
||||
parent.save(m_Id, name + ".m_Id");
|
||||
parent.save(m_G, name + ".m_G");
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// nld_twoterm
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
@ -311,7 +311,7 @@ private:
|
||||
class generic_diode
|
||||
{
|
||||
public:
|
||||
generic_diode();
|
||||
generic_diode(device_t &dev, pstring name);
|
||||
|
||||
inline void update_diode(const nl_double nVd)
|
||||
{
|
||||
@ -360,12 +360,10 @@ public:
|
||||
|
||||
/* owning object must save those ... */
|
||||
|
||||
void save(pstring name, object_t &parent);
|
||||
|
||||
private:
|
||||
nl_double m_Vd;
|
||||
nl_double m_Id;
|
||||
nl_double m_G;
|
||||
state_var<nl_double> m_Vd;
|
||||
state_var<nl_double> m_Id;
|
||||
state_var<nl_double> m_G;
|
||||
|
||||
nl_double m_Vt;
|
||||
nl_double m_Is;
|
||||
@ -385,11 +383,10 @@ NETLIB_OBJECT_DERIVED(D, twoterm)
|
||||
public:
|
||||
NETLIB_CONSTRUCTOR_DERIVED(D, twoterm)
|
||||
, m_model(*this, "MODEL", "")
|
||||
, m_D(*this, "m_D")
|
||||
{
|
||||
register_subalias("A", m_P);
|
||||
register_subalias("K", m_N);
|
||||
|
||||
m_D.save("m_D", *this);
|
||||
}
|
||||
|
||||
NETLIB_DYNAMIC()
|
||||
|
||||
@ -22,9 +22,8 @@ namespace netlist
|
||||
, m_IP(*this, "IP")
|
||||
, m_Q(*this, {{"Q1", "_Q2", "_Q3", "Q4", "Q5", "Q6", "Q7", "Q8", "Q9",
|
||||
"Q10", "Q11", "Q12", "Q13", "Q14"}})
|
||||
, m_cnt(0)
|
||||
, m_cnt(*this, "m_cnt", 0)
|
||||
{
|
||||
save(NLNAME(m_cnt));
|
||||
}
|
||||
|
||||
NETLIB_RESETI()
|
||||
@ -41,7 +40,7 @@ namespace netlist
|
||||
logic_input_t m_IP;
|
||||
object_array_t<logic_output_t, 14> m_Q;
|
||||
|
||||
UINT16 m_cnt;
|
||||
state_var<unsigned> m_cnt;
|
||||
};
|
||||
|
||||
NETLIB_OBJECT(CD4020)
|
||||
|
||||
@ -18,14 +18,10 @@ namespace netlist
|
||||
, m_clk(*this, "CLK")
|
||||
, m_Q(*this, "Q")
|
||||
, m_QQ(*this, "QQ")
|
||||
, m_Q1(0)
|
||||
, m_Q2(0)
|
||||
, m_F(0)
|
||||
|
||||
, m_Q1(*this, "m_Q1", 0)
|
||||
, m_Q2(*this, "m_Q2", 0)
|
||||
, m_F(*this, "m_F", 0)
|
||||
{
|
||||
save(NLNAME(m_Q1));
|
||||
save(NLNAME(m_Q2));
|
||||
save(NLNAME(m_F));
|
||||
}
|
||||
|
||||
NETLIB_RESETI();
|
||||
@ -37,9 +33,9 @@ namespace netlist
|
||||
logic_output_t m_Q;
|
||||
logic_output_t m_QQ;
|
||||
|
||||
netlist_sig_t m_Q1;
|
||||
netlist_sig_t m_Q2;
|
||||
netlist_sig_t m_F;
|
||||
state_var<netlist_sig_t> m_Q1;
|
||||
state_var<netlist_sig_t> m_Q2;
|
||||
state_var<netlist_sig_t> m_F;
|
||||
|
||||
void newstate(const netlist_sig_t state);
|
||||
|
||||
|
||||
@ -32,6 +32,9 @@ namespace netlist
|
||||
, m_Q(*this, "Q")
|
||||
, m_QQ(*this, "QQ")
|
||||
, m_CV(*this, "_CV") // internal
|
||||
, m_last_trig(*this, "m_last_trig", 0)
|
||||
, m_state(*this, "m_state", 0)
|
||||
, m_KP(*this, "m_KP", 0)
|
||||
, m_K(*this, "K", (m_dev_type == 4538) ? 0.4 : 0.4)
|
||||
, m_RI(*this, "RI", 400.0) // around 250 for HC series, 400 on LS/TTL, estimated from datasheets
|
||||
{
|
||||
@ -49,10 +52,6 @@ namespace netlist
|
||||
|
||||
connect_late(m_RN.m_R.m_P, m_RP.m_R.m_N);
|
||||
connect_late(m_CV, m_RN.m_R.m_P);
|
||||
|
||||
save(NLNAME(m_last_trig));
|
||||
save(NLNAME(m_state));
|
||||
save(NLNAME(m_KP));
|
||||
}
|
||||
|
||||
NETLIB_RESETI();
|
||||
@ -75,9 +74,9 @@ namespace netlist
|
||||
|
||||
analog_input_t m_CV;
|
||||
|
||||
netlist_sig_t m_last_trig;
|
||||
UINT8 m_state;
|
||||
double m_KP;
|
||||
state_var<netlist_sig_t> m_last_trig;
|
||||
state_var<unsigned> m_state;
|
||||
state_var<double> m_KP;
|
||||
|
||||
param_double_t m_K;
|
||||
param_double_t m_RI;
|
||||
|
||||
@ -23,9 +23,8 @@ namespace netlist
|
||||
, m_C(*this, {{"C0", "C1", "C2", "C3"}})
|
||||
, m_G(*this, "G")
|
||||
, m_Y(*this, "AY") //FIXME: Change netlists
|
||||
, m_chan(0)
|
||||
, m_chan(*this, "m_chan", 0)
|
||||
{
|
||||
save(NLNAME(m_chan));
|
||||
}
|
||||
|
||||
NETLIB_RESETI();
|
||||
@ -37,7 +36,7 @@ namespace netlist
|
||||
|
||||
logic_output_t m_Y;
|
||||
|
||||
int m_chan;
|
||||
state_var<unsigned> m_chan;
|
||||
};
|
||||
|
||||
NETLIB_OBJECT(74153)
|
||||
|
||||
@ -18,10 +18,9 @@ namespace netlist
|
||||
, m_CLK(*this, "CLK")
|
||||
, m_Q(*this, {{"Q1", "Q2", "Q3", "Q4"}})
|
||||
, m_QQ(*this, {{"Q1Q", "Q2Q", "Q3Q", "Q4Q"}})
|
||||
, m_data(0)
|
||||
, m_clrq(*this, "m_clr", 0)
|
||||
, m_data(*this, "m_data", 0)
|
||||
{
|
||||
save(NLNAME(m_clrq));
|
||||
save(NLNAME(m_data));
|
||||
}
|
||||
|
||||
NETLIB_RESETI();
|
||||
@ -32,8 +31,8 @@ namespace netlist
|
||||
object_array_t<logic_output_t, 4> m_Q;
|
||||
object_array_t<logic_output_t, 4> m_QQ;
|
||||
|
||||
netlist_sig_t m_clrq;
|
||||
UINT8 m_data;
|
||||
state_var<netlist_sig_t> m_clrq;
|
||||
state_var<unsigned> m_data;
|
||||
};
|
||||
|
||||
NETLIB_OBJECT(74175)
|
||||
|
||||
@ -48,6 +48,9 @@ namespace netlist
|
||||
, m_LOADQ(*this, "LOADQ")
|
||||
, m_CU(*this, "CU")
|
||||
, m_CD(*this, "CD")
|
||||
, m_cnt(*this, "m_cnt", 0)
|
||||
, m_last_CU(*this, "m_last_CU", 0)
|
||||
, m_last_CD(*this, "m_last_CD", 0)
|
||||
, m_Q(*this, {{"QA", "QB", "QC", "QD"}})
|
||||
, m_BORROWQ(*this, "BORROWQ")
|
||||
, m_CARRYQ(*this, "CARRYQ")
|
||||
@ -56,10 +59,6 @@ namespace netlist
|
||||
register_subalias("B", m_ABCD.m_B);
|
||||
register_subalias("C", m_ABCD.m_C);
|
||||
register_subalias("D", m_ABCD.m_D);
|
||||
|
||||
save(NLNAME(m_cnt));
|
||||
save(NLNAME(m_last_CU));
|
||||
save(NLNAME(m_last_CD));
|
||||
}
|
||||
|
||||
NETLIB_RESETI();
|
||||
@ -72,9 +71,9 @@ namespace netlist
|
||||
logic_input_t m_CU;
|
||||
logic_input_t m_CD;
|
||||
|
||||
INT8 m_cnt;
|
||||
UINT8 m_last_CU;
|
||||
UINT8 m_last_CD;
|
||||
state_var<int> m_cnt;
|
||||
state_var<unsigned> m_last_CU;
|
||||
state_var<unsigned> m_last_CD;
|
||||
|
||||
object_array_t<logic_output_t, 4> m_Q;
|
||||
logic_output_t m_BORROWQ;
|
||||
|
||||
@ -25,17 +25,13 @@ namespace netlist
|
||||
, m_LOADQ(*this, "LOADQ")
|
||||
, m_CU(*this, "CU")
|
||||
, m_CD(*this, "CD")
|
||||
, m_cnt(0)
|
||||
, m_last_CU(0)
|
||||
, m_last_CD(0)
|
||||
, m_cnt(*this, "m_cnt", 0)
|
||||
, m_last_CU(*this, "m_last_CU", 0)
|
||||
, m_last_CD(*this, "m_last_CD", 0)
|
||||
, m_Q(*this, {{"QA", "QB", "QC", "QD"}})
|
||||
, m_BORROWQ(*this, "BORROWQ")
|
||||
, m_CARRYQ(*this, "CARRYQ")
|
||||
{
|
||||
|
||||
save(NLNAME(m_cnt));
|
||||
save(NLNAME(m_last_CU));
|
||||
save(NLNAME(m_last_CD));
|
||||
}
|
||||
|
||||
NETLIB_RESETI();
|
||||
@ -51,9 +47,9 @@ namespace netlist
|
||||
logic_input_t m_CU;
|
||||
logic_input_t m_CD;
|
||||
|
||||
INT8 m_cnt;
|
||||
UINT8 m_last_CU;
|
||||
UINT8 m_last_CD;
|
||||
state_var<int> m_cnt;
|
||||
state_var<unsigned> m_last_CU;
|
||||
state_var<unsigned> m_last_CD;
|
||||
|
||||
object_array_t<logic_output_t, 4> m_Q;
|
||||
logic_output_t m_BORROWQ;
|
||||
|
||||
@ -37,10 +37,9 @@ namespace netlist
|
||||
, m_LTQ(*this, "LTQ")
|
||||
, m_BIQ(*this, "BIQ")
|
||||
, m_RBIQ(*this, "RBIQ")
|
||||
, m_state(0)
|
||||
, m_state(*this, "m_state", 0)
|
||||
, m_Q(*this, {{"a", "b", "c", "d", "e", "f", "g"}})
|
||||
{
|
||||
save(NLNAME(m_state));
|
||||
}
|
||||
|
||||
NETLIB_RESETI();
|
||||
@ -58,7 +57,7 @@ namespace netlist
|
||||
logic_input_t m_BIQ;
|
||||
logic_input_t m_RBIQ;
|
||||
|
||||
UINT8 m_state;
|
||||
state_var<unsigned> m_state;
|
||||
|
||||
object_array_t<logic_output_t, 7> m_Q; /* a .. g */
|
||||
|
||||
|
||||
@ -18,10 +18,8 @@ namespace netlist
|
||||
, m_CLK(*this, "CLK")
|
||||
, m_Q(*this, "Q")
|
||||
, m_QQ(*this, "QQ")
|
||||
, m_nextD(0)
|
||||
, m_nextD(*this, "m_nextD", 0)
|
||||
{
|
||||
|
||||
save(NLNAME(m_nextD));
|
||||
}
|
||||
|
||||
NETLIB_RESETI();
|
||||
@ -31,7 +29,7 @@ namespace netlist
|
||||
logic_input_t m_CLK;
|
||||
logic_output_t m_Q;
|
||||
logic_output_t m_QQ;
|
||||
INT8 m_nextD;
|
||||
state_var<unsigned> m_nextD;
|
||||
|
||||
inline void newstate(const UINT8 stateQ, const UINT8 stateQQ);
|
||||
|
||||
|
||||
@ -24,14 +24,13 @@ namespace netlist
|
||||
, m_B2(*this, "B2")
|
||||
, m_B3(*this, "B3")
|
||||
, m_B4(*this, "B4")
|
||||
, m_lastr(0)
|
||||
, m_lastr(*this, "m_lastr", 0)
|
||||
, m_S1(*this, "S1")
|
||||
, m_S2(*this, "S2")
|
||||
, m_S3(*this, "S3")
|
||||
, m_S4(*this, "S4")
|
||||
, m_C4(*this, "C4")
|
||||
{
|
||||
save(NLNAME(m_lastr));
|
||||
}
|
||||
NETLIB_RESETI();
|
||||
NETLIB_UPDATEI();
|
||||
@ -47,7 +46,7 @@ namespace netlist
|
||||
logic_input_t m_B3;
|
||||
logic_input_t m_B4;
|
||||
|
||||
UINT8 m_lastr;
|
||||
state_var<unsigned> m_lastr;
|
||||
|
||||
logic_output_t m_S1;
|
||||
logic_output_t m_S2;
|
||||
|
||||
@ -21,14 +21,11 @@ namespace netlist
|
||||
, m_R2(*this, "R2")
|
||||
, m_R91(*this, "R91")
|
||||
, m_R92(*this, "R92")
|
||||
, m_cnt(0)
|
||||
, m_last_A(0)
|
||||
, m_last_B(0)
|
||||
, m_cnt(*this, "m_cnt", 0)
|
||||
, m_last_A(*this, "m_last_A", 0)
|
||||
, m_last_B(*this, "m_last_B", 0)
|
||||
, m_Q(*this, {{"QA", "QB", "QC", "QD"}})
|
||||
{
|
||||
save(NLNAME(m_cnt));
|
||||
save(NLNAME(m_last_A));
|
||||
save(NLNAME(m_last_B));
|
||||
}
|
||||
|
||||
NETLIB_UPDATEI();
|
||||
@ -44,9 +41,9 @@ namespace netlist
|
||||
logic_input_t m_R91;
|
||||
logic_input_t m_R92;
|
||||
|
||||
UINT8 m_cnt;
|
||||
UINT8 m_last_A;
|
||||
UINT8 m_last_B;
|
||||
state_var<UINT8> m_cnt;
|
||||
state_var<UINT8> m_last_A;
|
||||
state_var<UINT8> m_last_B;
|
||||
|
||||
object_array_t<logic_output_t, 4> m_Q;
|
||||
};
|
||||
|
||||
@ -19,10 +19,9 @@ namespace netlist
|
||||
NETLIB_CONSTRUCTOR(7493ff)
|
||||
, m_I(*this, "CLK")
|
||||
, m_Q(*this, "Q")
|
||||
, m_reset(*this, "m_reset", 0)
|
||||
, m_state(*this, "m_state", 0)
|
||||
{
|
||||
|
||||
save(NLNAME(m_reset));
|
||||
save(NLNAME(m_state));
|
||||
}
|
||||
|
||||
NETLIB_RESETI();
|
||||
@ -32,8 +31,8 @@ namespace netlist
|
||||
logic_input_t m_I;
|
||||
logic_output_t m_Q;
|
||||
|
||||
UINT8 m_reset;
|
||||
UINT8 m_state;
|
||||
state_var<UINT8> m_reset;
|
||||
state_var<UINT8> m_state;
|
||||
};
|
||||
|
||||
NETLIB_OBJECT(7493)
|
||||
|
||||
@ -52,15 +52,11 @@ namespace netlist
|
||||
NETLIB_CONSTRUCTOR(SN74LS629clk)
|
||||
, m_FB(*this, "FB")
|
||||
, m_Y(*this, "Y")
|
||||
, m_enableq(1)
|
||||
, m_out(0)
|
||||
, m_inc(netlist_time::zero())
|
||||
, m_enableq(*this, "m_enableq", 1)
|
||||
, m_out(*this, "m_out", 0)
|
||||
, m_inc(*this, "m_inc", netlist_time::zero())
|
||||
{
|
||||
connect_late(m_FB, m_Y);
|
||||
|
||||
save(NLNAME(m_enableq));
|
||||
save(NLNAME(m_inc));
|
||||
save(NLNAME(m_out));
|
||||
}
|
||||
|
||||
NETLIB_RESETI()
|
||||
@ -76,9 +72,9 @@ namespace netlist
|
||||
logic_input_t m_FB;
|
||||
logic_output_t m_Y;
|
||||
|
||||
netlist_sig_t m_enableq;
|
||||
netlist_sig_t m_out;
|
||||
netlist_time m_inc;
|
||||
state_var<netlist_sig_t> m_enableq;
|
||||
state_var<netlist_sig_t> m_out;
|
||||
state_var<netlist_time> m_inc;
|
||||
};
|
||||
|
||||
NETLIB_OBJECT(SN74LS629)
|
||||
|
||||
@ -22,8 +22,8 @@ namespace netlist
|
||||
, m_WEQ(*this, "WEQ")
|
||||
, m_DIN(*this, "DIN")
|
||||
, m_DOUTQ(*this, "DOUTQ")
|
||||
, m_ram(*this, "m_ram", 0)
|
||||
{
|
||||
save(NLNAME(m_ram));
|
||||
}
|
||||
|
||||
NETLIB_RESETI();
|
||||
@ -39,7 +39,7 @@ namespace netlist
|
||||
logic_output_t m_DOUTQ;
|
||||
|
||||
//netlist_state_t<UINT8[256]> m_ram;
|
||||
UINT64 m_ram[4]; // 256 bits
|
||||
state_var<UINT64[4]> m_ram; // 256 bits
|
||||
};
|
||||
|
||||
NETLIB_OBJECT_DERIVED(82S16_dip, 82S16)
|
||||
|
||||
@ -50,13 +50,10 @@ namespace netlist
|
||||
, m_QC(*this, "QC")
|
||||
, m_QD(*this, "QD")
|
||||
, m_RC(*this, "RC")
|
||||
, m_cnt(0)
|
||||
, m_loadq(0)
|
||||
, m_ent(0)
|
||||
, m_cnt(*this, "m_cnt", 0)
|
||||
, m_loadq(*this, "m_loadq", 0)
|
||||
, m_ent(*this, "m_ent", 0)
|
||||
{
|
||||
save(NLNAME(m_cnt));
|
||||
save(NLNAME(m_loadq));
|
||||
save(NLNAME(m_ent));
|
||||
}
|
||||
NETLIB_RESETI();
|
||||
NETLIB_UPDATEI();
|
||||
@ -73,9 +70,9 @@ namespace netlist
|
||||
logic_output_t m_QC;
|
||||
logic_output_t m_QD;
|
||||
logic_output_t m_RC;
|
||||
UINT8 m_cnt;
|
||||
netlist_sig_t m_loadq;
|
||||
netlist_sig_t m_ent;
|
||||
state_var<UINT8> m_cnt;
|
||||
state_var<netlist_sig_t> m_loadq;
|
||||
state_var<netlist_sig_t> m_ent;
|
||||
};
|
||||
|
||||
NETLIB_OBJECT(9310)
|
||||
|
||||
@ -49,15 +49,11 @@ namespace netlist
|
||||
, m_QC(*this, "QC")
|
||||
, m_QD(*this, "QD")
|
||||
, m_RC(*this, "RC")
|
||||
, m_cnt(0)
|
||||
, m_ABCD(nullptr)
|
||||
, m_loadq(0)
|
||||
, m_ent(0)
|
||||
, m_cnt(*this, "m_cnt", 0)
|
||||
, m_loadq(*this, "m_loadq", 0)
|
||||
, m_ent(*this, "m_ent", 0)
|
||||
{
|
||||
|
||||
save(NLNAME(m_cnt));
|
||||
save(NLNAME(m_loadq));
|
||||
save(NLNAME(m_ent));
|
||||
}
|
||||
|
||||
NETLIB_RESETI();
|
||||
@ -75,10 +71,10 @@ namespace netlist
|
||||
logic_output_t m_QD;
|
||||
logic_output_t m_RC;
|
||||
|
||||
UINT8 m_cnt;
|
||||
NETLIB_NAME(9316_subABCD) *m_ABCD;
|
||||
netlist_sig_t m_loadq;
|
||||
netlist_sig_t m_ent;
|
||||
state_var<UINT8> m_cnt;
|
||||
state_var<netlist_sig_t> m_loadq;
|
||||
state_var<netlist_sig_t> m_ent;
|
||||
};
|
||||
|
||||
NETLIB_OBJECT(9316)
|
||||
|
||||
@ -42,9 +42,8 @@ namespace netlist
|
||||
, m_Q(*this, "2")
|
||||
, m_L_to_H(*this, "L_TO_H", 10)
|
||||
, m_H_to_L(*this, "H_TO_L", 10)
|
||||
, m_last(0)
|
||||
, m_last(*this, "m_last", 0)
|
||||
{
|
||||
save(NLNAME(m_last));
|
||||
}
|
||||
|
||||
//NETLIB_UPDATE_PARAMI();
|
||||
@ -58,7 +57,7 @@ namespace netlist
|
||||
param_int_t m_L_to_H;
|
||||
param_int_t m_H_to_L;
|
||||
|
||||
UINT8 m_last;
|
||||
state_var<UINT8> m_last;
|
||||
};
|
||||
|
||||
NETLIB_RESET(nicRSFF)
|
||||
|
||||
@ -28,10 +28,10 @@ namespace netlist
|
||||
/* clock */
|
||||
, m_feedback(*this, "FB")
|
||||
, m_Q(*this, "Q")
|
||||
, m_inc(0, 1)
|
||||
, m_inc(netlist_time::from_hz(56000))
|
||||
, m_shift(*this, "m_shift", 0)
|
||||
, m_is_timestep(false)
|
||||
{
|
||||
m_inc = netlist_time::from_hz(56000);
|
||||
connect_late(m_feedback, m_Q);
|
||||
|
||||
/* output */
|
||||
@ -41,9 +41,6 @@ namespace netlist
|
||||
|
||||
/* device */
|
||||
register_subalias("3", m_RV.m_P);
|
||||
|
||||
save(NLNAME(m_shift));
|
||||
|
||||
}
|
||||
|
||||
NETLIB_RESETI();
|
||||
@ -61,10 +58,10 @@ namespace netlist
|
||||
/* clock stage */
|
||||
logic_input_t m_feedback;
|
||||
logic_output_t m_Q;
|
||||
netlist_time m_inc;
|
||||
const netlist_time m_inc;
|
||||
|
||||
/* state */
|
||||
UINT32 m_shift;
|
||||
state_var<UINT32> m_shift;
|
||||
|
||||
/* cache */
|
||||
bool m_is_timestep;
|
||||
|
||||
@ -28,8 +28,8 @@ namespace netlist
|
||||
, m_THRES(*this, "THRESH") // Pin 6
|
||||
, m_TRIG(*this, "TRIG") // Pin 2
|
||||
, m_OUT(*this, "OUT") // Pin 3
|
||||
, m_last_out(false)
|
||||
, m_ff(false)
|
||||
, m_last_out(*this, "m_last_out", false)
|
||||
, m_ff(*this, "m_ff", false)
|
||||
{
|
||||
|
||||
register_subalias("GND", m_R3.m_N); // Pin 1
|
||||
@ -40,9 +40,6 @@ namespace netlist
|
||||
connect_late(m_R1.m_N, m_R2.m_P);
|
||||
connect_late(m_R2.m_N, m_R3.m_P);
|
||||
connect_late(m_RDIS.m_N, m_R3.m_N);
|
||||
|
||||
save(NLNAME(m_last_out));
|
||||
save(NLNAME(m_ff));
|
||||
}
|
||||
|
||||
NETLIB_UPDATEI();
|
||||
@ -60,8 +57,8 @@ namespace netlist
|
||||
analog_output_t m_OUT;
|
||||
|
||||
private:
|
||||
bool m_last_out;
|
||||
bool m_ff;
|
||||
state_var<bool> m_last_out;
|
||||
state_var<bool> m_ff;
|
||||
|
||||
inline nl_double clamp(const nl_double v, const nl_double a, const nl_double b);
|
||||
|
||||
|
||||
@ -30,7 +30,7 @@ namespace netlist
|
||||
|
||||
NETLIB_UPDATE(clock)
|
||||
{
|
||||
OUTLOGIC(m_Q, !m_Q.net().new_Q(), m_inc );
|
||||
OUTLOGIC(m_Q, !INPLOGIC(m_feedback), m_inc );
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
@ -187,7 +187,7 @@ namespace netlist
|
||||
stack[ptr-1] = stack[ptr-1] / stack[ptr];
|
||||
break;
|
||||
case PUSH_INPUT:
|
||||
stack[ptr++] = INPANALOG(m_I[(int) rc.m_param]);
|
||||
stack[ptr++] = INPANALOG((*m_I[(int) rc.m_param]));
|
||||
break;
|
||||
case PUSH_CONST:
|
||||
stack[ptr++] = rc.m_param;
|
||||
|
||||
@ -180,9 +180,9 @@ namespace netlist
|
||||
truthtable_t *ttp, const char *desc[])
|
||||
: device_t(owner, name)
|
||||
, m_fam(*this, fam)
|
||||
, m_last_state(0)
|
||||
, m_ign(0)
|
||||
, m_active(1)
|
||||
, m_last_state(*this, "m_last_state", 0)
|
||||
, m_ign(*this, "m_ign", 0)
|
||||
, m_active(*this, "m_active", 1)
|
||||
, m_ttp(ttp)
|
||||
{
|
||||
while (*desc != nullptr && **desc != 0 )
|
||||
@ -198,9 +198,9 @@ namespace netlist
|
||||
truthtable_t *ttp, const plib::pstring_vector_t &desc)
|
||||
: device_t(owner, name)
|
||||
, m_fam(*this, fam)
|
||||
, m_last_state(0)
|
||||
, m_ign(0)
|
||||
, m_active(1)
|
||||
, m_last_state(*this, "m_last_state", 0)
|
||||
, m_ign(*this, "m_ign", 0)
|
||||
, m_active(*this, "m_active", 1)
|
||||
, m_ttp(ttp)
|
||||
{
|
||||
m_desc = desc;
|
||||
@ -235,7 +235,7 @@ namespace netlist
|
||||
for (std::size_t i=0; i < m_NO; i++)
|
||||
{
|
||||
pstring tmp = "_" + out[i];
|
||||
const int idx = inout.indexof(tmp);
|
||||
const int idx = plib::container::indexof(inout, tmp);
|
||||
if (idx>=0)
|
||||
{
|
||||
connect_late(m_Q[i], m_I[idx]);
|
||||
@ -260,9 +260,6 @@ namespace netlist
|
||||
for (int k=0; m_ttp.m_timing_nt[k] != netlist_time::zero(); k++)
|
||||
printf("%d %f\n", k, m_ttp.m_timing_nt[k].as_double() * 1000000.0);
|
||||
#endif
|
||||
save(NLNAME(m_last_state));
|
||||
save(NLNAME(m_ign));
|
||||
save(NLNAME(m_active));
|
||||
}
|
||||
|
||||
NETLIB_RESETI()
|
||||
@ -389,9 +386,9 @@ namespace netlist
|
||||
}
|
||||
}
|
||||
|
||||
UINT32 m_last_state;
|
||||
UINT32 m_ign;
|
||||
INT32 m_active;
|
||||
state_var<UINT32> m_last_state;
|
||||
state_var<UINT32> m_ign;
|
||||
state_var<INT32> m_active;
|
||||
|
||||
truthtable_t *m_ttp;
|
||||
plib::pstring_vector_t m_desc;
|
||||
|
||||
@ -11,6 +11,8 @@
|
||||
#ifndef NLID_SYSTEM_H_
|
||||
#define NLID_SYSTEM_H_
|
||||
|
||||
#include <vector>
|
||||
|
||||
#include "nl_setup.h"
|
||||
#include "nl_base.h"
|
||||
#include "nl_factory.h"
|
||||
@ -119,6 +121,8 @@ namespace netlist
|
||||
, m_offset(*this, "OFFSET", 0.0)
|
||||
, m_feedback(*this, "FB")
|
||||
, m_Q(*this, "Q")
|
||||
, m_cnt(*this, "m_cnt", 0)
|
||||
, m_off(*this, "m_off", netlist_time::zero())
|
||||
{
|
||||
m_inc[0] = netlist_time::from_hz(m_freq.Value()*2);
|
||||
|
||||
@ -144,8 +148,6 @@ namespace netlist
|
||||
}
|
||||
m_inc[m_size - 1] = base * total - ttotal;
|
||||
}
|
||||
save(NLNAME(m_cnt));
|
||||
save(NLNAME(m_off));
|
||||
}
|
||||
NETLIB_UPDATEI();
|
||||
NETLIB_RESETI();
|
||||
@ -158,10 +160,10 @@ namespace netlist
|
||||
|
||||
logic_input_t m_feedback;
|
||||
logic_output_t m_Q;
|
||||
unsigned m_cnt;
|
||||
unsigned m_size;
|
||||
netlist_time m_inc[32];
|
||||
netlist_time m_off;
|
||||
state_var<unsigned> m_cnt;
|
||||
state_var<netlist_time> m_off;
|
||||
unsigned m_size;
|
||||
};
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
@ -258,7 +260,7 @@ namespace netlist
|
||||
{
|
||||
public:
|
||||
NETLIB_CONSTRUCTOR_DERIVED(frontier, base_dummy)
|
||||
, m_RIN(*this, "m_RIN")
|
||||
, m_RIN(*this, "m_RIN", true)
|
||||
, m_ROUT(*this, "m_ROUT", true)
|
||||
, m_I(*this, "_I")
|
||||
, m_Q(*this, "_Q")
|
||||
@ -312,7 +314,7 @@ namespace netlist
|
||||
{
|
||||
|
||||
for (std::size_t i=0; i < m_N; i++)
|
||||
m_I.emplace(i, *this, plib::pfmt("A{1}")(i));
|
||||
m_I.push_back(plib::make_unique<analog_input_t>(*this, plib::pfmt("A{1}")(i)));
|
||||
|
||||
plib::pstring_vector_t cmds(m_func.Value(), " ");
|
||||
m_precompiled.clear();
|
||||
@ -375,9 +377,9 @@ namespace netlist
|
||||
param_int_t m_N;
|
||||
param_str_t m_func;
|
||||
analog_output_t m_Q;
|
||||
plib::uninitialised_array_t<analog_input_t, 10> m_I;
|
||||
std::vector<std::unique_ptr<analog_input_t>> m_I;
|
||||
|
||||
plib::pvector_t<rpn_inst> m_precompiled;
|
||||
std::vector<rpn_inst> m_precompiled;
|
||||
};
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
@ -392,12 +394,10 @@ namespace netlist
|
||||
, m_I(*this, "I")
|
||||
, m_RON(*this, "RON", 1.0)
|
||||
, m_ROFF(*this, "ROFF", 1.0E20)
|
||||
, m_last_state(0)
|
||||
, m_last_state(*this, "m_last_state", 0)
|
||||
{
|
||||
register_subalias("1", m_R.m_P);
|
||||
register_subalias("2", m_R.m_N);
|
||||
|
||||
save(NLNAME(m_last_state));
|
||||
}
|
||||
|
||||
NETLIB_SUB(R) m_R;
|
||||
@ -415,7 +415,7 @@ namespace netlist
|
||||
|
||||
private:
|
||||
|
||||
UINT8 m_last_state;
|
||||
state_var<UINT8> m_last_state;
|
||||
};
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
@ -518,7 +518,7 @@ namespace netlist
|
||||
: nld_base_d_to_a_proxy(anetlist, name, out_proxied, m_RV.m_P)
|
||||
, m_GNDHack(*this, "_Q")
|
||||
, m_RV(*this, "RV")
|
||||
, m_last_state(-1)
|
||||
, m_last_state(*this, "m_last_var", -1)
|
||||
, m_is_timestep(false)
|
||||
{
|
||||
//register_sub(m_RV);
|
||||
@ -528,8 +528,6 @@ namespace netlist
|
||||
register_subalias("Q", m_RV.m_P);
|
||||
|
||||
connect_late(m_RV.m_N, m_GNDHack);
|
||||
|
||||
save(NLNAME(m_last_state));
|
||||
}
|
||||
|
||||
virtual ~nld_d_to_a_proxy() {}
|
||||
@ -542,7 +540,7 @@ namespace netlist
|
||||
private:
|
||||
analog_output_t m_GNDHack; // FIXME: Long term, we need to connect proxy gnd to device gnd
|
||||
NETLIB_SUB(twoterm) m_RV;
|
||||
int m_last_state;
|
||||
state_var<int> m_last_state;
|
||||
bool m_is_timestep;
|
||||
};
|
||||
|
||||
|
||||
@ -105,14 +105,14 @@ const logic_family_desc_t *family_CD4XXX()
|
||||
queue_t::queue_t(netlist_t &nl)
|
||||
: timed_queue<net_t *, netlist_time>(512)
|
||||
, object_t(nl, "QUEUE", QUEUE)
|
||||
, plib::pstate_callback_t()
|
||||
, plib::state_manager_t::callback_t()
|
||||
, m_qsize(0)
|
||||
, m_times(512)
|
||||
, m_names(512)
|
||||
{
|
||||
}
|
||||
|
||||
void queue_t::register_state(plib::pstate_manager_t &manager, const pstring &module)
|
||||
void queue_t::register_state(plib::state_manager_t &manager, const pstring &module)
|
||||
{
|
||||
netlist().log().debug("register_state\n");
|
||||
manager.save_item(this, m_qsize, module + "." + "qsize");
|
||||
@ -186,22 +186,21 @@ device_object_t::device_object_t(core_device_t &dev, const pstring &aname, const
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
netlist_t::netlist_t(const pstring &aname)
|
||||
: pstate_manager_t(),
|
||||
m_stop(netlist_time::zero()),
|
||||
m_time(netlist_time::zero()),
|
||||
m_use_deactivate(0),
|
||||
m_queue(*this),
|
||||
m_mainclock(nullptr),
|
||||
m_solver(nullptr),
|
||||
m_gnd(nullptr),
|
||||
m_params(nullptr),
|
||||
m_name(aname),
|
||||
m_setup(nullptr),
|
||||
m_log(this),
|
||||
m_lib(nullptr)
|
||||
: m_state()
|
||||
, m_time(netlist_time::zero())
|
||||
, m_queue(*this)
|
||||
, m_use_deactivate(0)
|
||||
, m_mainclock(nullptr)
|
||||
, m_solver(nullptr)
|
||||
, m_gnd(nullptr)
|
||||
, m_params(nullptr)
|
||||
, m_name(aname)
|
||||
, m_setup(nullptr)
|
||||
, m_log(this)
|
||||
, m_lib(nullptr)
|
||||
{
|
||||
save_item(this, static_cast<plib::pstate_callback_t &>(m_queue), "m_queue");
|
||||
save_item(this, m_time, "m_time");
|
||||
state().save_item(this, static_cast<plib::state_manager_t::callback_t &>(m_queue), "m_queue");
|
||||
state().save_item(this, m_time, "m_time");
|
||||
}
|
||||
|
||||
netlist_t::~netlist_t()
|
||||
@ -331,51 +330,43 @@ void netlist_t::reset()
|
||||
|
||||
void netlist_t::process_queue(const netlist_time &delta)
|
||||
{
|
||||
m_stop = m_time + delta;
|
||||
netlist_time stop(m_time + delta);
|
||||
|
||||
m_queue.push(stop, nullptr);
|
||||
|
||||
if (m_mainclock == nullptr)
|
||||
{
|
||||
while ( (m_time < m_stop) & (!m_queue.empty()))
|
||||
queue_t::entry_t e(m_queue.pop());
|
||||
m_time = e.m_exec_time;
|
||||
while (e.m_object != nullptr)
|
||||
{
|
||||
const queue_t::entry_t e(m_queue.pop());
|
||||
m_time = e.m_exec_time;
|
||||
e.m_object->update_devs();
|
||||
|
||||
add_to_stat(m_perf_out_processed, 1);
|
||||
e = m_queue.pop();
|
||||
m_time = e.m_exec_time;
|
||||
}
|
||||
if (m_queue.empty())
|
||||
m_time = m_stop;
|
||||
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
logic_net_t &mc_net = m_mainclock->m_Q.net();
|
||||
const netlist_time inc = m_mainclock->m_inc;
|
||||
netlist_time mc_time(mc_net.time());
|
||||
|
||||
while (m_time < m_stop)
|
||||
while (1)
|
||||
{
|
||||
if (!m_queue.empty())
|
||||
while (m_queue.top().m_exec_time > mc_time)
|
||||
{
|
||||
while (m_queue.top().m_exec_time > mc_time)
|
||||
{
|
||||
m_time = mc_time;
|
||||
mc_time += inc;
|
||||
mc_net.toggle_new_Q();
|
||||
mc_net.update_devs();
|
||||
//devices::NETLIB_NAME(mainclock)::mc_update(mc_net);
|
||||
}
|
||||
|
||||
const queue_t::entry_t &e = m_queue.pop();
|
||||
m_time = e.m_exec_time;
|
||||
e.m_object->update_devs();
|
||||
|
||||
} else {
|
||||
m_time = mc_time;
|
||||
mc_time += inc;
|
||||
mc_net.toggle_new_Q();
|
||||
mc_net.update_devs();
|
||||
//devices::NETLIB_NAME(mainclock)::mc_update(mc_net);
|
||||
}
|
||||
|
||||
const queue_t::entry_t e(m_queue.pop());
|
||||
m_time = e.m_exec_time;
|
||||
if (e.m_object == nullptr)
|
||||
break;
|
||||
e.m_object->update_devs();
|
||||
add_to_stat(m_perf_out_processed, 1);
|
||||
}
|
||||
mc_net.set_time(mc_time);
|
||||
@ -410,7 +401,7 @@ param_template_t<C, T>::param_template_t(device_t &device, const pstring name, c
|
||||
{
|
||||
/* pstrings not yet supported, these need special logic */
|
||||
if (T != param_t::STRING && T != param_t::MODEL)
|
||||
save(NLNAME(m_param));
|
||||
netlist().save(*this, m_param, "m_param");
|
||||
device.setup().register_and_set_param(device.name() + "." + name, *this);
|
||||
}
|
||||
|
||||
@ -509,9 +500,6 @@ void device_t::register_subalias(const pstring &name, core_terminal_t &term)
|
||||
|
||||
// everything already fully qualified
|
||||
setup().register_alias_nofqn(alias, term.name());
|
||||
|
||||
if (term.is_type(terminal_t::INPUT) || term.is_type(terminal_t::TERMINAL))
|
||||
m_terminals.push_back(alias);
|
||||
}
|
||||
|
||||
void device_t::register_subalias(const pstring &name, const pstring &aliased)
|
||||
@ -521,10 +509,6 @@ void device_t::register_subalias(const pstring &name, const pstring &aliased)
|
||||
|
||||
// everything already fully qualified
|
||||
setup().register_alias_nofqn(alias, aliased_fqn);
|
||||
|
||||
// FIXME: make this working again
|
||||
//if (term.isType(terminal_t::INPUT) || term.isType(terminal_t::TERMINAL))
|
||||
// m_terminals.add(name);
|
||||
}
|
||||
|
||||
void device_t::connect_late(core_terminal_t &t1, core_terminal_t &t2)
|
||||
@ -588,17 +572,17 @@ net_t::net_t(netlist_t &nl, const pstring &aname, core_terminal_t *mr)
|
||||
else
|
||||
nl.m_nets.push_back(std::shared_ptr<net_t>(this));
|
||||
|
||||
save(NLNAME(m_time));
|
||||
save(NLNAME(m_active));
|
||||
save(NLNAME(m_in_queue));
|
||||
save(NLNAME(m_cur_Analog));
|
||||
save(NLNAME(m_cur_Q));
|
||||
save(NLNAME(m_new_Q));
|
||||
netlist().save(*this, m_time, "m_time");
|
||||
netlist().save(*this, m_active, "m_active");
|
||||
netlist().save(*this, m_in_queue, "m_in_queue");
|
||||
netlist().save(*this, m_cur_Analog, "m_cur_Analog");
|
||||
netlist().save(*this, m_cur_Q, "m_cur_Q");
|
||||
netlist().save(*this, m_new_Q, "m_new_Q");
|
||||
}
|
||||
|
||||
net_t::~net_t()
|
||||
{
|
||||
netlist().remove_save_items(this);
|
||||
netlist().state().remove_save_items(this);
|
||||
}
|
||||
|
||||
void net_t::inc_active(core_terminal_t &term)
|
||||
@ -770,19 +754,19 @@ analog_net_t::analog_net_t(netlist_t &nl, const pstring &aname, core_terminal_t
|
||||
{
|
||||
}
|
||||
|
||||
bool analog_net_t::already_processed(plib::pvector_t<list_t> &groups)
|
||||
bool analog_net_t::already_processed(std::vector<list_t> &groups)
|
||||
{
|
||||
if (isRailNet())
|
||||
return true;
|
||||
for (auto & grp : groups)
|
||||
{
|
||||
if (grp.contains(this))
|
||||
if (plib::container::contains(grp, this))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void analog_net_t::process_net(plib::pvector_t<list_t> &groups)
|
||||
void analog_net_t::process_net(std::vector<list_t> &groups)
|
||||
{
|
||||
if (num_cons() == 0)
|
||||
return;
|
||||
@ -811,7 +795,7 @@ core_terminal_t::core_terminal_t(core_device_t &dev, const pstring &aname, const
|
||||
, m_net(nullptr)
|
||||
, m_state(STATE_NONEX)
|
||||
{
|
||||
save(NLNAME(m_state));
|
||||
netlist().save(*this, m_state, "m_state");
|
||||
}
|
||||
|
||||
void core_terminal_t::reset()
|
||||
@ -822,7 +806,7 @@ void core_terminal_t::reset()
|
||||
set_state(STATE_INP_ACTIVE);
|
||||
}
|
||||
|
||||
void core_terminal_t::set_net(net_t::ptr_t anet)
|
||||
void core_terminal_t::set_net(net_t *anet)
|
||||
{
|
||||
m_net = anet;
|
||||
}
|
||||
@ -845,9 +829,9 @@ terminal_t::terminal_t(core_device_t &dev, const pstring &aname)
|
||||
, m_gt1(nullptr)
|
||||
{
|
||||
netlist().setup().register_term(*this);
|
||||
save(NLNAME(m_Idr1));
|
||||
save(NLNAME(m_go1));
|
||||
save(NLNAME(m_gt1));
|
||||
netlist().save(*this, m_Idr1, "m_Idr1");
|
||||
netlist().save(*this, m_go1, "m_go1");
|
||||
netlist().save(*this, m_gt1, "m_gt1");
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -156,8 +156,10 @@
|
||||
#define NLBASE_H_
|
||||
|
||||
#include <vector>
|
||||
#include <unordered_map>
|
||||
#include <memory>
|
||||
#include <cmath>
|
||||
#include <cstdint>
|
||||
|
||||
#include "nl_lists.h"
|
||||
#include "nl_time.h"
|
||||
@ -169,11 +171,6 @@
|
||||
// Type definitions
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
/*
|
||||
* unsigned int would be a 20% speed increase over UINT8 for pong.
|
||||
* For breakout it causes a slight decrease.
|
||||
*
|
||||
*/
|
||||
using netlist_sig_t = std::uint32_t;
|
||||
|
||||
//============================================================
|
||||
@ -293,7 +290,7 @@ namespace netlist
|
||||
// model_map_t
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
using model_map_t = plib::hashmap_t<pstring, pstring>;
|
||||
using model_map_t = std::unordered_map<pstring, pstring>;
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// logic_family_t
|
||||
@ -345,7 +342,7 @@ namespace netlist
|
||||
// object_t
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
class object_t : public plib::pstate_interface_t<object_t>
|
||||
class object_t
|
||||
{
|
||||
P_PREVENT_COPYING(object_t)
|
||||
public:
|
||||
@ -364,8 +361,6 @@ namespace netlist
|
||||
|
||||
const pstring &name() const;
|
||||
|
||||
plib::pstate_manager_t &state_manager();
|
||||
|
||||
type_t type() const { return m_objtype; }
|
||||
bool is_type(const type_t atype) const { return (m_objtype == atype); }
|
||||
|
||||
@ -408,7 +403,7 @@ namespace netlist
|
||||
P_PREVENT_COPYING(core_terminal_t)
|
||||
public:
|
||||
|
||||
using list_t = plib::pvector_t<core_terminal_t *>;
|
||||
using list_t = std::vector<core_terminal_t *>;
|
||||
|
||||
/* needed here ... */
|
||||
|
||||
@ -475,8 +470,6 @@ namespace netlist
|
||||
P_PREVENT_COPYING(terminal_t)
|
||||
public:
|
||||
|
||||
using list_t = plib::pvector_t<terminal_t *>;
|
||||
|
||||
terminal_t(core_device_t &dev, const pstring &aname);
|
||||
|
||||
terminal_t *m_otherterm;
|
||||
@ -594,9 +587,6 @@ namespace netlist
|
||||
P_PREVENT_COPYING(net_t)
|
||||
public:
|
||||
|
||||
using ptr_t = net_t *;
|
||||
using list_t = plib::pvector_t<std::shared_ptr<net_t>>;
|
||||
|
||||
net_t(netlist_t &nl, const pstring &aname, core_terminal_t *mr = nullptr);
|
||||
virtual ~net_t();
|
||||
|
||||
@ -622,7 +612,7 @@ namespace netlist
|
||||
bool isRailNet() const { return !(m_railterminal == nullptr); }
|
||||
core_terminal_t & railterminal() const { return *m_railterminal; }
|
||||
|
||||
int num_cons() const { return m_core_terms.size(); }
|
||||
std::size_t num_cons() const { return m_core_terms.size(); }
|
||||
|
||||
void inc_active(core_terminal_t &term);
|
||||
void dec_active(core_terminal_t &term);
|
||||
@ -631,15 +621,15 @@ namespace netlist
|
||||
|
||||
void move_connections(net_t *new_net);
|
||||
|
||||
plib::pvector_t<core_terminal_t *> m_core_terms; // save post-start m_list ...
|
||||
std::vector<core_terminal_t *> m_core_terms; // save post-start m_list ...
|
||||
|
||||
protected:
|
||||
netlist_sig_t m_new_Q;
|
||||
netlist_sig_t m_cur_Q;
|
||||
|
||||
netlist_time m_time;
|
||||
INT32 m_active;
|
||||
UINT8 m_in_queue; /* 0: not in queue, 1: in queue, 2: last was taken */
|
||||
netlist_time m_time;
|
||||
INT32 m_active;
|
||||
UINT8 m_in_queue; /* 0: not in queue, 1: in queue, 2: last was taken */
|
||||
|
||||
private:
|
||||
plib::linkedlist_t<core_terminal_t> m_list_active;
|
||||
@ -656,8 +646,6 @@ namespace netlist
|
||||
P_PREVENT_COPYING(logic_net_t)
|
||||
public:
|
||||
|
||||
using list_t = plib::pvector_t<logic_net_t *>;
|
||||
|
||||
logic_net_t(netlist_t &nl, const pstring &aname, core_terminal_t *mr = nullptr);
|
||||
virtual ~logic_net_t() { };
|
||||
|
||||
@ -699,7 +687,7 @@ namespace netlist
|
||||
P_PREVENT_COPYING(analog_net_t)
|
||||
public:
|
||||
|
||||
using list_t = plib::pvector_t<analog_net_t *>;
|
||||
using list_t = std::vector<analog_net_t *>;
|
||||
|
||||
analog_net_t(netlist_t &nl, const pstring &aname, core_terminal_t *mr = nullptr);
|
||||
|
||||
@ -712,8 +700,8 @@ namespace netlist
|
||||
devices::matrix_solver_t *solver() { return m_solver; }
|
||||
void set_solver(devices::matrix_solver_t *solver) { m_solver = solver; }
|
||||
|
||||
bool already_processed(plib::pvector_t<list_t> &groups);
|
||||
void process_net(plib::pvector_t<list_t> &groups);
|
||||
bool already_processed(std::vector<list_t> &groups);
|
||||
void process_net(std::vector<list_t> &groups);
|
||||
|
||||
private:
|
||||
devices::matrix_solver_t *m_solver;
|
||||
@ -835,9 +823,6 @@ namespace netlist
|
||||
{
|
||||
P_PREVENT_COPYING(core_device_t)
|
||||
public:
|
||||
|
||||
using list_t = plib::pvector_t<core_device_t *>;
|
||||
|
||||
core_device_t(netlist_t &owner, const pstring &name);
|
||||
core_device_t(core_device_t &owner, const pstring &name);
|
||||
|
||||
@ -965,9 +950,6 @@ namespace netlist
|
||||
void connect_late(const pstring &t1, const pstring &t2);
|
||||
void connect_late(core_terminal_t &t1, core_terminal_t &t2);
|
||||
void connect_post_start(core_terminal_t &t1, core_terminal_t &t2);
|
||||
|
||||
plib::pvector_t<pstring> m_terminals;
|
||||
|
||||
protected:
|
||||
|
||||
NETLIB_UPDATEI() { }
|
||||
@ -1005,14 +987,14 @@ namespace netlist
|
||||
|
||||
class queue_t : public timed_queue<net_t *, netlist_time>,
|
||||
public object_t,
|
||||
public plib::pstate_callback_t
|
||||
public plib::state_manager_t::callback_t
|
||||
{
|
||||
public:
|
||||
queue_t(netlist_t &nl);
|
||||
|
||||
protected:
|
||||
|
||||
void register_state(plib::pstate_manager_t &manager, const pstring &module) override;
|
||||
void register_state(plib::state_manager_t &manager, const pstring &module) override;
|
||||
void on_pre_save() override;
|
||||
void on_post_load() override;
|
||||
|
||||
@ -1028,7 +1010,7 @@ namespace netlist
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
|
||||
class netlist_t : public plib::pstate_manager_t, public plib::plog_dispatch_intf //, public device_owner_t
|
||||
class netlist_t : public plib::plog_dispatch_intf //, public device_owner_t
|
||||
{
|
||||
P_PREVENT_COPYING(netlist_t)
|
||||
public:
|
||||
@ -1041,18 +1023,18 @@ namespace netlist
|
||||
void start();
|
||||
void stop();
|
||||
|
||||
const queue_t &queue() const { return m_queue; }
|
||||
queue_t &queue() { return m_queue; }
|
||||
const netlist_time time() const { return m_time; }
|
||||
devices::NETLIB_NAME(solver) *solver() const { return m_solver; }
|
||||
devices::NETLIB_NAME(gnd) *gnd() const { return m_gnd; }
|
||||
const queue_t &queue() const { return m_queue; }
|
||||
queue_t &queue() { return m_queue; }
|
||||
const netlist_time time() const { return m_time; }
|
||||
devices::NETLIB_NAME(solver) *solver() const { return m_solver; }
|
||||
devices::NETLIB_NAME(gnd) *gnd() const { return m_gnd; }
|
||||
nl_double gmin() const;
|
||||
|
||||
void push_to_queue(net_t &out, const netlist_time attime) NOEXCEPT;
|
||||
void remove_from_queue(net_t &out);
|
||||
|
||||
void process_queue(const netlist_time &delta);
|
||||
void abort_current_queue_slice() { m_stop = netlist_time::zero(); }
|
||||
void abort_current_queue_slice() { m_queue.retime(m_time, nullptr); }
|
||||
|
||||
bool use_deactivate() const { return m_use_deactivate; }
|
||||
|
||||
@ -1064,9 +1046,9 @@ namespace netlist
|
||||
net_t *find_net(const pstring &name);
|
||||
|
||||
template<class device_class>
|
||||
plib::pvector_t<device_class *> get_device_list()
|
||||
std::vector<device_class *> get_device_list()
|
||||
{
|
||||
plib::pvector_t<device_class *> tmp;
|
||||
std::vector<device_class *> tmp;
|
||||
for (auto &d : m_devices)
|
||||
{
|
||||
device_class *dev = dynamic_cast<device_class *>(d.get());
|
||||
@ -1097,16 +1079,27 @@ namespace netlist
|
||||
plib::plog_base<NL_DEBUG> &log() { return m_log; }
|
||||
const plib::plog_base<NL_DEBUG> &log() const { return m_log; }
|
||||
|
||||
plib::state_manager_t &state() { return m_state; }
|
||||
|
||||
template<typename O, typename C> void save(O &owner, C &state, const pstring &stname)
|
||||
{
|
||||
this->state().save_item((void *)&owner, state, pstring(owner.name()) + "." + stname);
|
||||
}
|
||||
template<typename O, typename C> void save(O &owner, C *state, const pstring &stname, const int count)
|
||||
{
|
||||
this->state().save_state_ptr((void *)&owner, pstring(owner.name()) + "." + stname, plib::state_manager_t::datatype_f<C>::f(), count, state);
|
||||
}
|
||||
|
||||
virtual void reset();
|
||||
|
||||
plib::dynlib &lib() { return *m_lib; }
|
||||
|
||||
void print_stats() const;
|
||||
|
||||
plib::pvector_t<plib::owned_ptr<core_device_t>> m_devices;
|
||||
std::vector<plib::owned_ptr<core_device_t>> m_devices;
|
||||
|
||||
/* sole use is to manage lifetime of net objects */
|
||||
net_t::list_t m_nets;
|
||||
std::vector<std::shared_ptr<net_t>> m_nets;
|
||||
|
||||
/* sole use is to manage lifetime of family objects */
|
||||
std::vector<std::pair<pstring, std::unique_ptr<logic_family_desc_t>>> m_family_cache;
|
||||
@ -1121,16 +1114,16 @@ protected:
|
||||
#endif
|
||||
|
||||
private:
|
||||
netlist_time m_stop; // target time for current queue processing
|
||||
|
||||
plib::state_manager_t m_state;
|
||||
/* mostly rw */
|
||||
netlist_time m_time;
|
||||
bool m_use_deactivate;
|
||||
queue_t m_queue;
|
||||
/* mostly rw */
|
||||
bool m_use_deactivate;
|
||||
|
||||
devices::NETLIB_NAME(mainclock) * m_mainclock;
|
||||
devices::NETLIB_NAME(solver) * m_solver;
|
||||
devices::NETLIB_NAME(gnd) * m_gnd;
|
||||
|
||||
devices::NETLIB_NAME(netlistparams) *m_params;
|
||||
|
||||
pstring m_name;
|
||||
@ -1139,6 +1132,50 @@ protected:
|
||||
plib::dynlib *m_lib; // external lib needs to be loaded as long as netlist exists
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct state_var
|
||||
{
|
||||
public:
|
||||
state_var(device_t &dev, const pstring name, const T &value)
|
||||
: m_value(value)
|
||||
{
|
||||
dev.netlist().save(dev, m_value, name);
|
||||
}
|
||||
|
||||
state_var(const state_var &rhs) NOEXCEPT = default;
|
||||
state_var(state_var &&rhs) NOEXCEPT = default;
|
||||
state_var &operator=(const state_var rhs) { m_value = rhs.m_value; return *this; }
|
||||
state_var &operator=(const T rhs) { m_value = rhs; return *this; }
|
||||
operator T & () { return m_value; }
|
||||
T & operator()() { return m_value; }
|
||||
operator const T & () const { return m_value; }
|
||||
const T & operator()() const { return m_value; }
|
||||
private:
|
||||
T m_value;
|
||||
};
|
||||
|
||||
template <typename T, std::size_t N>
|
||||
struct state_var<T[N]>
|
||||
{
|
||||
public:
|
||||
state_var(device_t &dev, const pstring name, const T & value)
|
||||
{
|
||||
dev.netlist().save(dev, m_value, name);
|
||||
for (int i=0; i<N; i++)
|
||||
m_value[i] = value;
|
||||
}
|
||||
|
||||
state_var(const state_var &rhs) NOEXCEPT = default;
|
||||
state_var(state_var &&rhs) NOEXCEPT = default;
|
||||
state_var &operator=(const state_var rhs) { m_value = rhs.m_value; return *this; }
|
||||
state_var &operator=(const T rhs) { m_value = rhs; return *this; }
|
||||
T & operator[](const std::size_t i) { return m_value[i]; }
|
||||
const T & operator[](const std::size_t i) const { return m_value[i]; }
|
||||
private:
|
||||
T m_value[N];
|
||||
};
|
||||
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Support classes for devices
|
||||
// -----------------------------------------------------------------------------
|
||||
@ -1162,11 +1199,6 @@ protected:
|
||||
// inline implementations
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
inline plib::pstate_manager_t &object_t::state_manager()
|
||||
{
|
||||
return m_netlist;
|
||||
}
|
||||
|
||||
template <class C, param_t::param_type_t T>
|
||||
inline void param_template_t<C, T>::setTo(const C ¶m)
|
||||
{
|
||||
@ -1238,7 +1270,7 @@ protected:
|
||||
|
||||
inline void net_t::push_to_queue(const netlist_time delay) NOEXCEPT
|
||||
{
|
||||
if (!is_queued() && (num_cons() > 0))
|
||||
if (!is_queued() && (num_cons() != 0))
|
||||
{
|
||||
m_time = netlist().time() + delay;
|
||||
m_in_queue = (m_active > 0); /* queued ? */
|
||||
@ -1320,7 +1352,5 @@ protected:
|
||||
|
||||
}
|
||||
|
||||
NETLIST_SAVE_TYPE(netlist::core_terminal_t::state_e, pstate_data_type_e::DT_INT);
|
||||
|
||||
|
||||
#endif /* NLBASE_H_ */
|
||||
|
||||
@ -65,7 +65,7 @@ namespace netlist
|
||||
}
|
||||
};
|
||||
|
||||
class factory_list_t : public plib::pvector_t<plib::owned_ptr<base_factory_t>>
|
||||
class factory_list_t : public std::vector<plib::owned_ptr<base_factory_t>>
|
||||
{
|
||||
public:
|
||||
factory_list_t(setup_t &m_setup);
|
||||
|
||||
@ -68,13 +68,12 @@ namespace netlist
|
||||
#if HAS_OPENMP && USE_OPENMP
|
||||
m_lock = 0;
|
||||
#endif
|
||||
//nl_assert(m_end - m_list < Size);
|
||||
}
|
||||
|
||||
entry_t pop() NOEXCEPT { return *(--m_end); }
|
||||
entry_t top() const NOEXCEPT { return *(m_end-1); }
|
||||
entry_t pop() NOEXCEPT { return *(--m_end); }
|
||||
const entry_t &top() const NOEXCEPT { return *(m_end-1); }
|
||||
|
||||
void remove(const Element &elem) NOEXCEPT
|
||||
void remove(const Element &elem) NOEXCEPT
|
||||
{
|
||||
/* Lock */
|
||||
#if HAS_OPENMP && USE_OPENMP
|
||||
@ -101,6 +100,12 @@ namespace netlist
|
||||
#endif
|
||||
}
|
||||
|
||||
void retime(const Time t, const Element &elem) NOEXCEPT
|
||||
{
|
||||
remove(elem);
|
||||
push(t, elem);
|
||||
}
|
||||
|
||||
void clear()
|
||||
{
|
||||
m_end = &m_list[0];
|
||||
|
||||
@ -110,7 +110,7 @@ void setup_t::register_dev(plib::owned_ptr<device_t> dev)
|
||||
|
||||
void setup_t::register_lib_entry(const pstring &name)
|
||||
{
|
||||
if (m_lib.contains(name))
|
||||
if (plib::container::contains(m_lib, name))
|
||||
log().warning("Lib entry collection already contains {1}. IGNORED", name);
|
||||
else
|
||||
m_lib.push_back(name);
|
||||
@ -118,7 +118,7 @@ void setup_t::register_lib_entry(const pstring &name)
|
||||
|
||||
void setup_t::register_dev(const pstring &classname, const pstring &name)
|
||||
{
|
||||
if (m_lib.contains(classname))
|
||||
if (plib::container::contains(m_lib, classname))
|
||||
{
|
||||
namespace_push(name);
|
||||
include(classname);
|
||||
@ -151,13 +151,13 @@ void setup_t::register_model(const pstring &model_in)
|
||||
log().fatal("Unable to parse model: {1}", model_in);
|
||||
pstring model = model_in.left(pos).trim().ucase();
|
||||
pstring def = model_in.substr(pos + 1).trim();
|
||||
if (!m_models.add(model, def))
|
||||
if (!m_models.insert({model, def}).second)
|
||||
log().fatal("Model already exists: {1}", model_in);
|
||||
}
|
||||
|
||||
void setup_t::register_alias_nofqn(const pstring &alias, const pstring &out)
|
||||
{
|
||||
if (!m_alias.add(alias, out))
|
||||
if (!m_alias.insert({alias, out}).second)
|
||||
log().fatal("Error adding alias {1} to alias list\n", alias);
|
||||
}
|
||||
|
||||
@ -207,9 +207,10 @@ pstring setup_t::objtype_as_str(object_t &in) const
|
||||
|
||||
void setup_t::register_and_set_param(pstring name, param_t ¶m)
|
||||
{
|
||||
if (m_param_values.contains(name))
|
||||
auto i = m_param_values.find(name);
|
||||
if (i != m_param_values.end())
|
||||
{
|
||||
const pstring val = m_param_values[name];
|
||||
const pstring val = i->second;
|
||||
log().debug("Found parameter ... {1} : {1}\n", name, val);
|
||||
switch (param.param_type())
|
||||
{
|
||||
@ -240,24 +241,13 @@ void setup_t::register_and_set_param(pstring name, param_t ¶m)
|
||||
log().fatal("Parameter is not supported {1} : {2}\n", name, val);
|
||||
}
|
||||
}
|
||||
if (!m_params.add(param.name(), param_ref_t(param.name(), param.device(), param)))
|
||||
if (!m_params.insert({param.name(), param_ref_t(param.name(), param.device(), param)}).second)
|
||||
log().fatal("Error adding parameter {1} to parameter list\n", name);
|
||||
}
|
||||
|
||||
void setup_t::register_term(core_terminal_t &term)
|
||||
{
|
||||
if (term.is_type(terminal_t::OUTPUT))
|
||||
{
|
||||
}
|
||||
else if (term.is_type(terminal_t::INPUT))
|
||||
{
|
||||
static_cast<device_t &>(term.device()).m_terminals.push_back(term.name());
|
||||
}
|
||||
else
|
||||
{
|
||||
static_cast<device_t &>(term.device()).m_terminals.push_back(term.name());
|
||||
}
|
||||
if (!m_terminals.add(term.name(), &term))
|
||||
if (!m_terminals.insert({term.name(), &term}).second)
|
||||
log().fatal("Error adding {1} {2} to terminal list\n", objtype_as_str(term), term.name());
|
||||
log().debug("{1} {2}\n", objtype_as_str(term), term.name());
|
||||
}
|
||||
@ -291,15 +281,16 @@ void setup_t::remove_connections(const pstring pin)
|
||||
pstring pinfn = build_fqn(pin);
|
||||
bool found = false;
|
||||
|
||||
for (int i = m_links.size() - 1; i >= 0; i--)
|
||||
for (auto link = m_links.begin(); link != m_links.end(); )
|
||||
{
|
||||
auto &link = m_links[i];
|
||||
if ((link.first == pinfn) || (link.second == pinfn))
|
||||
if ((link->first == pinfn) || (link->second == pinfn))
|
||||
{
|
||||
log().verbose("removing connection: {1} <==> {2}\n", link.first, link.second);
|
||||
m_links.remove_at(i);
|
||||
log().verbose("removing connection: {1} <==> {2}\n", link->first, link->second);
|
||||
link = m_links.erase(link);
|
||||
found = true;
|
||||
}
|
||||
else
|
||||
link++;
|
||||
}
|
||||
if (!found)
|
||||
log().fatal("remove_connections: found no occurrence of {1}\n", pin);
|
||||
@ -345,15 +336,15 @@ void setup_t::register_param(const pstring ¶m, const pstring &value)
|
||||
{
|
||||
pstring fqn = build_fqn(param);
|
||||
|
||||
int idx = m_param_values.index_of(fqn);
|
||||
if (idx < 0)
|
||||
auto idx = m_param_values.find(fqn);
|
||||
if (idx == m_param_values.end())
|
||||
{
|
||||
if (!m_param_values.add(fqn, value))
|
||||
if (!m_param_values.insert({fqn, value}).second)
|
||||
log().fatal("Unexpected error adding parameter {1} to parameter list\n", param);
|
||||
}
|
||||
else
|
||||
{
|
||||
log().warning("Overwriting {1} old <{2}> new <{3}>\n", fqn, m_param_values.value_at(idx), value);
|
||||
log().warning("Overwriting {1} old <{2}> new <{3}>\n", fqn, idx->second, value);
|
||||
m_param_values[fqn] = value;
|
||||
}
|
||||
}
|
||||
@ -366,8 +357,8 @@ const pstring setup_t::resolve_alias(const pstring &name) const
|
||||
/* FIXME: Detect endless loop */
|
||||
do {
|
||||
ret = temp;
|
||||
int p = m_alias.index_of(ret);
|
||||
temp = (p>=0 ? m_alias.value_at(p) : "");
|
||||
auto p = m_alias.find(ret);
|
||||
temp = (p != m_alias.end() ? p->second : "");
|
||||
} while (temp != "");
|
||||
|
||||
log().debug("{1}==>{2}\n", name, ret);
|
||||
@ -377,17 +368,15 @@ const pstring setup_t::resolve_alias(const pstring &name) const
|
||||
core_terminal_t *setup_t::find_terminal(const pstring &terminal_in, bool required)
|
||||
{
|
||||
const pstring &tname = resolve_alias(terminal_in);
|
||||
int ret;
|
||||
|
||||
ret = m_terminals.index_of(tname);
|
||||
auto ret = m_terminals.find(tname);
|
||||
/* look for default */
|
||||
if (ret < 0)
|
||||
if (ret == m_terminals.end())
|
||||
{
|
||||
/* look for ".Q" std output */
|
||||
ret = m_terminals.index_of(tname + ".Q");
|
||||
ret = m_terminals.find(tname + ".Q");
|
||||
}
|
||||
|
||||
core_terminal_t *term = (ret < 0 ? nullptr : m_terminals.value_at(ret));
|
||||
core_terminal_t *term = (ret == m_terminals.end() ? nullptr : ret->second);
|
||||
|
||||
if (term == nullptr && required)
|
||||
log().fatal("terminal {1}({2}) not found!\n", terminal_in, tname);
|
||||
@ -399,19 +388,17 @@ core_terminal_t *setup_t::find_terminal(const pstring &terminal_in, bool require
|
||||
core_terminal_t *setup_t::find_terminal(const pstring &terminal_in, object_t::type_t atype, bool required)
|
||||
{
|
||||
const pstring &tname = resolve_alias(terminal_in);
|
||||
int ret;
|
||||
|
||||
ret = m_terminals.index_of(tname);
|
||||
auto ret = m_terminals.find(tname);
|
||||
/* look for default */
|
||||
if (ret < 0 && atype == object_t::OUTPUT)
|
||||
if (ret == m_terminals.end() && atype == object_t::OUTPUT)
|
||||
{
|
||||
/* look for ".Q" std output */
|
||||
ret = m_terminals.index_of(tname + ".Q");
|
||||
ret = m_terminals.find(tname + ".Q");
|
||||
}
|
||||
if (ret < 0 && required)
|
||||
if (ret == m_terminals.end() && required)
|
||||
log().fatal("terminal {1}({2}) not found!\n", terminal_in, tname);
|
||||
|
||||
core_terminal_t *term = (ret < 0 ? nullptr : m_terminals.value_at(ret));
|
||||
core_terminal_t *term = (ret == m_terminals.end() ? nullptr : ret->second);
|
||||
|
||||
if (term != nullptr && term->type() != atype)
|
||||
{
|
||||
@ -431,14 +418,12 @@ param_t *setup_t::find_param(const pstring ¶m_in, bool required)
|
||||
const pstring param_in_fqn = build_fqn(param_in);
|
||||
|
||||
const pstring &outname = resolve_alias(param_in_fqn);
|
||||
int ret;
|
||||
|
||||
ret = m_params.index_of(outname);
|
||||
if (ret < 0 && required)
|
||||
auto ret = m_params.find(outname);
|
||||
if (ret == m_params.end() && required)
|
||||
log().fatal("parameter {1}({2}) not found!\n", param_in_fqn, outname);
|
||||
if (ret != -1)
|
||||
if (ret != m_params.end())
|
||||
log().debug("Found parameter {1}\n", outname);
|
||||
return (ret == -1 ? nullptr : &m_params.value_at(ret).m_param);
|
||||
return (ret == m_params.end() ? nullptr : &ret->second.m_param);
|
||||
}
|
||||
|
||||
// FIXME avoid dynamic cast here
|
||||
@ -588,7 +573,7 @@ void setup_t::connect_terminals(core_terminal_t &t1, core_terminal_t &t2)
|
||||
{
|
||||
log().debug("adding analog net ...\n");
|
||||
// FIXME: Nets should have a unique name
|
||||
analog_net_t::ptr_t anet = plib::palloc<analog_net_t>(netlist(),"net." + t1.name());
|
||||
auto anet = plib::palloc<analog_net_t>(netlist(),"net." + t1.name());
|
||||
t1.set_net(anet);
|
||||
anet->register_con(t2);
|
||||
anet->register_con(t1);
|
||||
@ -706,16 +691,16 @@ void setup_t::resolve_inputs()
|
||||
int tries = 100;
|
||||
while (m_links.size() > 0 && tries > 0) // FIXME: convert into constant
|
||||
{
|
||||
unsigned li = 0;
|
||||
while (li < m_links.size())
|
||||
auto li = m_links.begin();
|
||||
while (li != m_links.end())
|
||||
{
|
||||
const pstring t1s = m_links[li].first;
|
||||
const pstring t2s = m_links[li].second;
|
||||
const pstring t1s = li->first;
|
||||
const pstring t2s = li->second;
|
||||
core_terminal_t *t1 = find_terminal(t1s);
|
||||
core_terminal_t *t2 = find_terminal(t2s);
|
||||
|
||||
if (connect(*t1, *t2))
|
||||
m_links.remove_at(li);
|
||||
li = m_links.erase(li);
|
||||
else
|
||||
li++;
|
||||
}
|
||||
@ -733,28 +718,23 @@ void setup_t::resolve_inputs()
|
||||
|
||||
// delete empty nets ... and save m_list ...
|
||||
|
||||
net_t::list_t todelete;
|
||||
|
||||
for (auto & net : netlist().m_nets)
|
||||
for (auto net = netlist().m_nets.begin(); net != netlist().m_nets.end();)
|
||||
{
|
||||
if (net->num_cons() == 0)
|
||||
todelete.push_back(net);
|
||||
if (net->get()->num_cons() == 0)
|
||||
{
|
||||
log().verbose("Deleting net {1} ...", net->get()->name());
|
||||
net = netlist().m_nets.erase(net);
|
||||
}
|
||||
else
|
||||
net->rebuild_list();
|
||||
}
|
||||
|
||||
for (auto & net : todelete)
|
||||
{
|
||||
log().verbose("Deleting net {1} ...", net->name());
|
||||
netlist().m_nets.remove(net);
|
||||
++net;
|
||||
}
|
||||
|
||||
pstring errstr("");
|
||||
|
||||
log().verbose("looking for terminals not connected ...");
|
||||
for (std::size_t i = 0; i < m_terminals.size(); i++)
|
||||
for (auto & i : m_terminals)
|
||||
{
|
||||
core_terminal_t *term = m_terminals.value_at(i);
|
||||
core_terminal_t *term = i.second;
|
||||
if (!term->has_net() && dynamic_cast< devices::NETLIB_NAME(dummy_input) *>(&term->device()) != nullptr)
|
||||
log().warning("Found dummy terminal {1} without connections", term->name());
|
||||
else if (!term->has_net())
|
||||
@ -862,13 +842,12 @@ const logic_family_desc_t *setup_t::family_from_model(const pstring &model)
|
||||
static pstring model_string(model_map_t &map)
|
||||
{
|
||||
pstring ret = map["COREMODEL"] + "(";
|
||||
for (unsigned i=0; i<map.size(); i++)
|
||||
ret = ret + map.key_at(i) + "=" + map.value_at(i) + " ";
|
||||
for (auto & i : map)
|
||||
ret = ret + i.first + "=" + i.second + " ";
|
||||
|
||||
return ret + ")";
|
||||
}
|
||||
|
||||
|
||||
void setup_t::model_parse(const pstring &model_in, model_map_t &map)
|
||||
{
|
||||
pstring model = model_in;
|
||||
@ -881,9 +860,10 @@ void setup_t::model_parse(const pstring &model_in, model_map_t &map)
|
||||
if (pos >= 0) break;
|
||||
|
||||
key = model.ucase();
|
||||
if (!m_models.contains(key))
|
||||
auto i = m_models.find(key);
|
||||
if (i == m_models.end())
|
||||
log().fatal("Model {1} not found\n", model);
|
||||
model = m_models[key];
|
||||
model = i->second;
|
||||
}
|
||||
pstring xmodel = model.left(pos);
|
||||
|
||||
@ -891,7 +871,8 @@ void setup_t::model_parse(const pstring &model_in, model_map_t &map)
|
||||
map["COREMODEL"] = key;
|
||||
else
|
||||
{
|
||||
if (m_models.contains(xmodel))
|
||||
auto i = m_models.find(xmodel);
|
||||
if (i != m_models.end())
|
||||
model_parse(xmodel, map);
|
||||
else
|
||||
log().fatal("Model doesn't exist: <{1}>\n", model_in);
|
||||
@ -918,7 +899,7 @@ const pstring setup_t::model_value_str(model_map_t &map, const pstring &entity)
|
||||
|
||||
if (entity != entity.ucase())
|
||||
log().fatal("model parameters should be uppercase:{1} {2}\n", entity, model_string(map));
|
||||
if (!map.contains(entity))
|
||||
if (map.find(entity) == map.end())
|
||||
log().fatal("Entity {1} not found in model {2}\n", entity, model_string(map));
|
||||
else
|
||||
ret = map[entity];
|
||||
|
||||
@ -10,6 +10,8 @@
|
||||
|
||||
#include <memory>
|
||||
#include <stack>
|
||||
#include <unordered_map>
|
||||
|
||||
#include "nl_base.h"
|
||||
#include "nl_factory.h"
|
||||
|
||||
@ -91,7 +93,7 @@ namespace netlist
|
||||
class source_t
|
||||
{
|
||||
public:
|
||||
using list_t = plib::pvector_t<std::shared_ptr<source_t>>;
|
||||
using list_t = std::vector<std::shared_ptr<source_t>>;
|
||||
|
||||
source_t()
|
||||
{}
|
||||
@ -167,7 +169,7 @@ namespace netlist
|
||||
factory_list_t &factory() { return m_factory; }
|
||||
const factory_list_t &factory() const { return m_factory; }
|
||||
|
||||
bool is_library_item(const pstring &name) const { return m_lib.contains(name); }
|
||||
bool is_library_item(const pstring &name) const { return plib::container::contains(m_lib, name); }
|
||||
|
||||
/* model / family related */
|
||||
|
||||
@ -180,7 +182,7 @@ namespace netlist
|
||||
plib::plog_base<NL_DEBUG> &log() { return netlist().log(); }
|
||||
const plib::plog_base<NL_DEBUG> &log() const { return netlist().log(); }
|
||||
|
||||
plib::pvector_t<std::pair<pstring, base_factory_t *>> m_device_factory;
|
||||
std::vector<std::pair<pstring, base_factory_t *>> m_device_factory;
|
||||
|
||||
protected:
|
||||
|
||||
@ -203,23 +205,25 @@ namespace netlist
|
||||
|
||||
netlist_t &m_netlist;
|
||||
|
||||
plib::hashmap_t<pstring, pstring> m_alias;
|
||||
plib::hashmap_t<pstring, param_ref_t> m_params;
|
||||
plib::hashmap_t<pstring, pstring> m_param_values;
|
||||
plib::hashmap_t<pstring, core_terminal_t *> m_terminals;
|
||||
public:
|
||||
std::unordered_map<pstring, pstring> m_alias;
|
||||
std::unordered_map<pstring, param_ref_t> m_params;
|
||||
std::unordered_map<pstring, pstring> m_param_values;
|
||||
std::unordered_map<pstring, core_terminal_t *> m_terminals;
|
||||
private:
|
||||
|
||||
plib::pvector_t<link_t> m_links;
|
||||
std::vector<link_t> m_links;
|
||||
|
||||
factory_list_t m_factory;
|
||||
|
||||
plib::hashmap_t<pstring, pstring> m_models;
|
||||
std::unordered_map<pstring, pstring> m_models;
|
||||
|
||||
int m_proxy_cnt;
|
||||
int m_frontier_cnt;
|
||||
|
||||
std::stack<pstring> m_namespace_stack;
|
||||
source_t::list_t m_sources;
|
||||
plib::pvector_t<pstring> m_lib;
|
||||
std::vector<pstring> m_lib;
|
||||
|
||||
};
|
||||
|
||||
|
||||
@ -31,10 +31,8 @@ namespace netlist
|
||||
|
||||
#if (PHAS_INT128)
|
||||
using INTERNALTYPE = UINT128;
|
||||
static const pstate_data_type_e STATETYPE = DT_INT128;
|
||||
#else
|
||||
using INTERNALTYPE = UINT64;
|
||||
static constexpr pstate_data_type_e STATETYPE = pstate_data_type_e::DT_INT64;
|
||||
#endif
|
||||
static constexpr INTERNALTYPE RESOLUTION = NETLIST_INTERNAL_RES;
|
||||
|
||||
@ -47,7 +45,6 @@ namespace netlist
|
||||
constexpr explicit netlist_time(const INTERNALTYPE nom, const INTERNALTYPE den)
|
||||
: m_time(nom * (RESOLUTION / den)) { }
|
||||
|
||||
|
||||
netlist_time &operator=(const netlist_time rhs) { m_time = rhs.m_time; return *this; }
|
||||
|
||||
netlist_time &operator+=(const netlist_time &rhs) { m_time += rhs.m_time; return *this; }
|
||||
@ -125,14 +122,12 @@ namespace netlist
|
||||
INTERNALTYPE m_time;
|
||||
};
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
namespace plib {
|
||||
template<> inline void pstate_manager_t::save_item(const void *owner, netlist::netlist_time &nlt, const pstring &stname)
|
||||
template<> inline void state_manager_t::save_item(const void *owner, netlist::netlist_time &nlt, const pstring &stname)
|
||||
{
|
||||
save_state_ptr(owner, stname, netlist::netlist_time::STATETYPE, sizeof(netlist::netlist_time::INTERNALTYPE), 1, nlt.get_internaltype_ptr(), false);
|
||||
save_state_ptr(owner, stname, datatype_t(sizeof(netlist::netlist_time::INTERNALTYPE), false, true, false), 1, nlt.get_internaltype_ptr());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -14,8 +14,6 @@
|
||||
#include <vector>
|
||||
#include <type_traits>
|
||||
#include <cmath>
|
||||
//#include <cstring>
|
||||
//#include <array>
|
||||
|
||||
#include "palloc.h"
|
||||
#include "pstring.h"
|
||||
@ -71,48 +69,6 @@ private:
|
||||
typename std::aligned_storage<sizeof(C), alignof(C)>::type m_buf[N];
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// plist_t: a simple list
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <typename LC>
|
||||
class pvector_t : public std::vector<LC>
|
||||
{
|
||||
public:
|
||||
pvector_t() : std::vector<LC>() {}
|
||||
|
||||
bool contains(const LC &elem) const
|
||||
{
|
||||
return (std::find(this->begin(), this->end(), elem) != this->end());
|
||||
}
|
||||
|
||||
void remove(const LC &elem)
|
||||
{
|
||||
this->erase(std::remove(this->begin(), this->end(), elem), this->end());
|
||||
}
|
||||
|
||||
void insert_at(const std::size_t index, const LC &elem)
|
||||
{
|
||||
this->insert(this->begin() + index, elem);
|
||||
}
|
||||
|
||||
void remove_at(const std::size_t pos)
|
||||
{
|
||||
this->erase(this->begin() + pos);
|
||||
}
|
||||
|
||||
int indexof(const LC &elem) const
|
||||
{
|
||||
for (std::size_t i = 0; i < this->size(); i++)
|
||||
{
|
||||
if (this->at(i) == elem)
|
||||
return i;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// plinkedlist_t: a simple linked list
|
||||
// the list allows insertions / deletions if used properly
|
||||
@ -187,249 +143,10 @@ public:
|
||||
void clear() { m_head = nullptr; }
|
||||
bool empty() const { return (m_head == nullptr); }
|
||||
|
||||
//private:
|
||||
private:
|
||||
LC *m_head;
|
||||
};
|
||||
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// hashmap list
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
|
||||
template <class C>
|
||||
struct hash_functor
|
||||
{
|
||||
hash_functor()
|
||||
: m_hash(0)
|
||||
{}
|
||||
hash_functor(const C &v)
|
||||
: m_hash(v)
|
||||
{
|
||||
}
|
||||
friend unsigned operator%(const hash_functor &lhs, const unsigned &rhs) { return lhs.m_hash % rhs; }
|
||||
bool operator==(const hash_functor &lhs) const { return (m_hash == lhs.m_hash); }
|
||||
private:
|
||||
unsigned m_hash;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash_functor<pstring>
|
||||
{
|
||||
hash_functor()
|
||||
: m_hash(0)
|
||||
{}
|
||||
hash_functor(const pstring &v)
|
||||
{
|
||||
/* modified djb2 */
|
||||
const pstring::mem_t *string = v.cstr();
|
||||
unsigned result = 5381;
|
||||
for (pstring::mem_t c = *string; c != 0; c = *string++)
|
||||
result = ((result << 5) + result ) ^ (result >> (32 - 5)) ^ c;
|
||||
//result = (result*33) ^ c;
|
||||
m_hash = result;
|
||||
}
|
||||
friend unsigned operator%(const hash_functor<pstring> &lhs, const unsigned &rhs) { return lhs.m_hash % rhs; }
|
||||
unsigned operator()() { return m_hash; }
|
||||
bool operator==(const hash_functor<pstring> &lhs) const { return (m_hash == lhs.m_hash); }
|
||||
private:
|
||||
unsigned m_hash;
|
||||
};
|
||||
|
||||
#if 0
|
||||
#if 0
|
||||
unsigned hash(const pstring &v) const
|
||||
{
|
||||
/* Fowler???Noll???Vo hash - FNV-1 */
|
||||
const char *string = v.cstr();
|
||||
unsigned result = 2166136261;
|
||||
for (UINT8 c = *string++; c != 0; c = *string++)
|
||||
result = (result * 16777619) ^ c;
|
||||
// result = (result ^ c) * 16777619; FNV 1a
|
||||
return result;
|
||||
}
|
||||
#else
|
||||
unsigned hash(const pstring &v) const
|
||||
{
|
||||
/* jenkins one at a time algo */
|
||||
unsigned result = 0;
|
||||
const char *string = v.cstr();
|
||||
while (*string)
|
||||
{
|
||||
result += *string;
|
||||
string++;
|
||||
result += (result << 10);
|
||||
result ^= (result >> 6);
|
||||
}
|
||||
result += (result << 3);
|
||||
result ^= (result >> 11);
|
||||
result += (result << 15);
|
||||
return result;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
template <class K, class V, class H = hash_functor<K> >
|
||||
class hashmap_t
|
||||
{
|
||||
public:
|
||||
hashmap_t() : m_hash(37)
|
||||
{
|
||||
for (unsigned i=0; i<m_hash.size(); i++)
|
||||
m_hash[i] = -1;
|
||||
}
|
||||
|
||||
~hashmap_t()
|
||||
{
|
||||
}
|
||||
|
||||
struct element_t
|
||||
{
|
||||
element_t(const K &key, const H &hash, const V &value)
|
||||
: m_key(key), m_hash(hash), m_value(value), m_next(-1)
|
||||
{}
|
||||
K m_key;
|
||||
H m_hash;
|
||||
V m_value;
|
||||
int m_next;
|
||||
};
|
||||
|
||||
void clear()
|
||||
{
|
||||
#if 0
|
||||
if (0)
|
||||
{
|
||||
unsigned cnt = 0;
|
||||
for (unsigned i=0; i<m_hash.size(); i++)
|
||||
if (m_hash[i] >= 0)
|
||||
cnt++;
|
||||
const unsigned s = m_values.size();
|
||||
if (s>0)
|
||||
printf("phashmap: %d elements %d hashsize, percent in overflow: %d\n", s, (unsigned) m_hash.size(), (s - cnt) * 100 / s);
|
||||
else
|
||||
printf("phashmap: No elements .. \n");
|
||||
}
|
||||
#endif
|
||||
m_values.clear();
|
||||
for (unsigned i=0; i<m_hash.size(); i++)
|
||||
m_hash[i] = -1;
|
||||
}
|
||||
|
||||
bool contains(const K &key) const
|
||||
{
|
||||
return (get_idx(key) >= 0);
|
||||
}
|
||||
|
||||
int index_of(const K &key) const
|
||||
{
|
||||
return get_idx(key);
|
||||
}
|
||||
|
||||
unsigned size() const { return m_values.size(); }
|
||||
|
||||
bool add(const K &key, const V &value)
|
||||
{
|
||||
/*
|
||||
* we are using the Euler prime function here
|
||||
*
|
||||
* n * n + n + 41 | 40 >= n >=0
|
||||
*
|
||||
* and accept that outside we will not have a prime
|
||||
*
|
||||
*/
|
||||
if (m_values.size() * 3 / 2 > m_hash.size())
|
||||
{
|
||||
unsigned n = std::sqrt( 2 * m_hash.size());
|
||||
n = n * n + n + 41;
|
||||
m_hash.resize(n);
|
||||
rebuild();
|
||||
}
|
||||
const H hash(key);
|
||||
const unsigned pos = hash % m_hash.size();
|
||||
if (m_hash[pos] == -1)
|
||||
{
|
||||
unsigned vpos = m_values.size();
|
||||
m_values.push_back(element_t(key, hash, value));
|
||||
m_hash[pos] = vpos;
|
||||
}
|
||||
else
|
||||
{
|
||||
int ep = m_hash[pos];
|
||||
|
||||
for (; ep != -1; ep = m_values[ep].m_next)
|
||||
{
|
||||
if (m_values[ep].m_hash == hash && m_values[ep].m_key == key )
|
||||
return false; /* duplicate */
|
||||
}
|
||||
unsigned vpos = m_values.size();
|
||||
m_values.push_back(element_t(key, hash, value));
|
||||
m_values[vpos].m_next = m_hash[pos];
|
||||
m_hash[pos] = vpos;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
V& operator[](const K &key)
|
||||
{
|
||||
int p = get_idx(key);
|
||||
if (p == -1)
|
||||
{
|
||||
p = m_values.size();
|
||||
add(key, V());
|
||||
}
|
||||
return m_values[p].m_value;
|
||||
}
|
||||
|
||||
V& value_at(const unsigned pos) { return m_values[pos].m_value; }
|
||||
const V& value_at(const unsigned pos) const { return m_values[pos].m_value; }
|
||||
|
||||
V& key_at(const unsigned pos) { return m_values[pos].m_key; }
|
||||
private:
|
||||
|
||||
int get_idx(const K &key) const
|
||||
{
|
||||
H hash(key);
|
||||
const unsigned pos = hash % m_hash.size();
|
||||
|
||||
for (int ep = m_hash[pos]; ep != -1; ep = m_values[ep].m_next)
|
||||
if (m_values[ep].m_hash == hash && m_values[ep].m_key == key )
|
||||
return ep;
|
||||
return -1;
|
||||
}
|
||||
|
||||
void rebuild()
|
||||
{
|
||||
for (unsigned i=0; i<m_hash.size(); i++)
|
||||
m_hash[i] = -1;
|
||||
for (unsigned i=0; i<m_values.size(); i++)
|
||||
{
|
||||
unsigned pos = m_values[i].m_hash % m_hash.size();
|
||||
m_values[i].m_next = m_hash[pos];
|
||||
m_hash[pos] = i;
|
||||
}
|
||||
|
||||
}
|
||||
pvector_t<element_t> m_values;
|
||||
std::vector<int> m_hash;
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// sort a list ... slow, I am lazy
|
||||
// elements must support ">" operator.
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template<typename T>
|
||||
static inline void sort_list(T &sl)
|
||||
{
|
||||
for(unsigned i = 0; i < sl.size(); i++)
|
||||
{
|
||||
for(unsigned j = i + 1; j < sl.size(); j++)
|
||||
if(sl[i] > sl[j])
|
||||
std::swap(sl[i], sl[j]);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#endif /* PLISTS_H_ */
|
||||
|
||||
@ -71,7 +71,7 @@ public:
|
||||
|
||||
virtual int parse(pstring argument) override
|
||||
{
|
||||
if (m_limit.contains(argument))
|
||||
if (plib::container::contains(m_limit, argument))
|
||||
{
|
||||
m_val = argument;
|
||||
return 0;
|
||||
@ -224,7 +224,7 @@ private:
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
pvector_t<option *> m_opts;
|
||||
std::vector<option *> m_opts;
|
||||
pstring m_app;
|
||||
};
|
||||
|
||||
|
||||
@ -197,7 +197,7 @@ ptokenizer::token_t ptokenizer::get_token_internal()
|
||||
c = getc();
|
||||
}
|
||||
ungetc();
|
||||
token_id_t id = token_id_t(m_tokens.indexof(tokstr));
|
||||
token_id_t id(plib::container::indexof(m_tokens, tokstr));
|
||||
if (id.id() >= 0)
|
||||
return token_t(id, tokstr);
|
||||
else
|
||||
@ -225,14 +225,14 @@ ptokenizer::token_t ptokenizer::get_token_internal()
|
||||
/* expensive, check for single char tokens */
|
||||
if (tokstr.len() == 1)
|
||||
{
|
||||
token_id_t id = token_id_t(m_tokens.indexof(tokstr));
|
||||
token_id_t id(plib::container::indexof(m_tokens, tokstr));
|
||||
if (id.id() >= 0)
|
||||
return token_t(id, tokstr);
|
||||
}
|
||||
c = getc();
|
||||
}
|
||||
ungetc();
|
||||
token_id_t id = token_id_t(m_tokens.indexof(tokstr));
|
||||
token_id_t id(plib::container::indexof(m_tokens, tokstr));
|
||||
if (id.id() >= 0)
|
||||
return token_t(id, tokstr);
|
||||
else
|
||||
@ -267,7 +267,7 @@ ppreprocessor::ppreprocessor()
|
||||
m_expr_sep.push_back(" ");
|
||||
m_expr_sep.push_back("\t");
|
||||
|
||||
m_defines.add("__PLIB_PREPROCESSOR__", define_t("__PLIB_PREPROCESSOR__", "1"));
|
||||
m_defines.insert({"__PLIB_PREPROCESSOR__", define_t("__PLIB_PREPROCESSOR__", "1")});
|
||||
}
|
||||
|
||||
void ppreprocessor::error(const pstring &err)
|
||||
@ -349,9 +349,9 @@ double ppreprocessor::expr(const pstring_vector_t &sexpr, std::size_t &start, in
|
||||
|
||||
ppreprocessor::define_t *ppreprocessor::get_define(const pstring &name)
|
||||
{
|
||||
int idx = m_defines.index_of(name);
|
||||
if (idx >= 0)
|
||||
return &m_defines.value_at(idx);
|
||||
auto idx = m_defines.find(name);
|
||||
if (idx != m_defines.end())
|
||||
return &idx->second;
|
||||
else
|
||||
return nullptr;
|
||||
}
|
||||
@ -440,7 +440,7 @@ pstring ppreprocessor::process_line(const pstring &line)
|
||||
{
|
||||
if (lti.size() != 3)
|
||||
error("PREPRO: only simple defines allowed: " + line);
|
||||
m_defines.add(lti[1], define_t(lti[1], lti[2]));
|
||||
m_defines.insert({lti[1], define_t(lti[1], lti[2])});
|
||||
}
|
||||
}
|
||||
else
|
||||
|
||||
@ -8,6 +8,8 @@
|
||||
#ifndef PPARSER_H_
|
||||
#define PPARSER_H_
|
||||
|
||||
#include <unordered_map>
|
||||
|
||||
#include "pconfig.h"
|
||||
#include "pstring.h"
|
||||
#include "plists.h"
|
||||
@ -139,7 +141,7 @@ private:
|
||||
pstring m_identifier_chars;
|
||||
pstring m_number_chars;
|
||||
pstring m_number_chars_start;
|
||||
pvector_t<pstring> m_tokens;
|
||||
std::vector<pstring> m_tokens;
|
||||
pstring m_whitespace;
|
||||
pstring::code_t m_string;
|
||||
|
||||
@ -189,7 +191,7 @@ private:
|
||||
|
||||
pstring process_line(const pstring &line);
|
||||
|
||||
hashmap_t<pstring, define_t> m_defines;
|
||||
std::unordered_map<pstring, define_t> m_defines;
|
||||
plib::pstring_vector_t m_expr_sep;
|
||||
|
||||
//pstringbuffer m_ret;
|
||||
|
||||
@ -9,70 +9,53 @@
|
||||
|
||||
namespace plib {
|
||||
|
||||
pstate_manager_t::pstate_manager_t()
|
||||
state_manager_t::state_manager_t()
|
||||
{
|
||||
}
|
||||
|
||||
pstate_manager_t::~pstate_manager_t()
|
||||
state_manager_t::~state_manager_t()
|
||||
{
|
||||
m_save.clear();
|
||||
}
|
||||
|
||||
|
||||
|
||||
void pstate_manager_t::save_state_ptr(const void *owner, const pstring &stname, const pstate_data_type_e dt, const int size, const int count, void *ptr, bool is_ptr)
|
||||
void state_manager_t::save_state_ptr(const void *owner, const pstring &stname, const datatype_t dt, const int count, void *ptr)
|
||||
{
|
||||
pstring fullname = stname;
|
||||
ATTR_UNUSED pstring ts[] = {
|
||||
"NOT_SUPPORTED",
|
||||
"DT_CUSTOM",
|
||||
"DT_DOUBLE",
|
||||
#if (PHAS_INT128)
|
||||
"DT_INT128",
|
||||
#endif
|
||||
"DT_INT64",
|
||||
"DT_INT16",
|
||||
"DT_INT8",
|
||||
"DT_INT",
|
||||
"DT_BOOLEAN",
|
||||
"DT_FLOAT"
|
||||
};
|
||||
|
||||
auto p = plib::make_unique<pstate_entry_t>(stname, dt, owner, size, count, ptr, is_ptr);
|
||||
auto p = plib::make_unique<entry_t>(stname, dt, owner, count, ptr);
|
||||
m_save.push_back(std::move(p));
|
||||
}
|
||||
|
||||
void pstate_manager_t::remove_save_items(const void *owner)
|
||||
void state_manager_t::remove_save_items(const void *owner)
|
||||
{
|
||||
unsigned i = 0;
|
||||
while (i < m_save.size())
|
||||
for (auto i = m_save.begin(); i != m_save.end(); )
|
||||
{
|
||||
if (m_save[i]->m_owner == owner)
|
||||
m_save.remove_at(i);
|
||||
if (i->get()->m_owner == owner)
|
||||
i = m_save.erase(i);
|
||||
else
|
||||
i++;
|
||||
}
|
||||
}
|
||||
|
||||
void pstate_manager_t::pre_save()
|
||||
void state_manager_t::pre_save()
|
||||
{
|
||||
for (auto & s : m_save)
|
||||
if (s->m_dt == DT_CUSTOM)
|
||||
if (s->m_dt.is_custom)
|
||||
s->m_callback->on_pre_save();
|
||||
}
|
||||
|
||||
void pstate_manager_t::post_load()
|
||||
void state_manager_t::post_load()
|
||||
{
|
||||
for (auto & s : m_save)
|
||||
if (s->m_dt == DT_CUSTOM)
|
||||
if (s->m_dt.is_custom)
|
||||
s->m_callback->on_post_load();
|
||||
}
|
||||
|
||||
template<> void pstate_manager_t::save_item(const void *owner, pstate_callback_t &state, const pstring &stname)
|
||||
template<> void state_manager_t::save_item(const void *owner, callback_t &state, const pstring &stname)
|
||||
{
|
||||
//save_state_ptr(stname, DT_CUSTOM, 0, 1, &state);
|
||||
pstate_callback_t *state_p = &state;
|
||||
auto p = plib::make_unique<pstate_entry_t>(stname, owner, state_p);
|
||||
callback_t *state_p = &state;
|
||||
auto p = plib::make_unique<entry_t>(stname, owner, state_p);
|
||||
m_save.push_back(std::move(p));
|
||||
state.register_state(*this, stname);
|
||||
}
|
||||
|
||||
@ -9,6 +9,7 @@
|
||||
#define PSTATE_H_
|
||||
|
||||
#include <memory>
|
||||
#include <type_traits>
|
||||
|
||||
#include "plists.h"
|
||||
#include "pstring.h"
|
||||
@ -17,126 +18,104 @@
|
||||
// state saving ...
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
enum pstate_data_type_e {
|
||||
NOT_SUPPORTED,
|
||||
DT_CUSTOM,
|
||||
DT_DOUBLE,
|
||||
#if (PHAS_INT128)
|
||||
DT_INT128,
|
||||
#endif
|
||||
DT_INT64,
|
||||
DT_INT16,
|
||||
DT_INT8,
|
||||
DT_INT,
|
||||
DT_BOOLEAN,
|
||||
DT_FLOAT
|
||||
};
|
||||
|
||||
template<typename ItemType> struct pstate_datatype
|
||||
{
|
||||
static const pstate_data_type_e type = pstate_data_type_e(NOT_SUPPORTED);
|
||||
static const bool is_ptr = false;
|
||||
};
|
||||
|
||||
template<typename ItemType> struct pstate_datatype<ItemType *>
|
||||
{
|
||||
static const pstate_data_type_e type = pstate_data_type_e(NOT_SUPPORTED);
|
||||
static const bool is_ptr = true;
|
||||
};
|
||||
|
||||
//template<typename ItemType> struct type_checker<ItemType*> { static const bool is_atom = false; static const bool is_pointer = true; };
|
||||
|
||||
#define NETLIST_SAVE_TYPE(TYPE, TYPEDESC) \
|
||||
template<> struct pstate_datatype<TYPE>{ static const pstate_data_type_e type = pstate_data_type_e(TYPEDESC); static const bool is_ptr = false;}; \
|
||||
template<> struct pstate_datatype<TYPE *>{ static const pstate_data_type_e type = pstate_data_type_e(TYPEDESC); static const bool is_ptr = true;}
|
||||
|
||||
NETLIST_SAVE_TYPE(char, DT_INT8);
|
||||
NETLIST_SAVE_TYPE(double, DT_DOUBLE);
|
||||
NETLIST_SAVE_TYPE(float, DT_FLOAT);
|
||||
NETLIST_SAVE_TYPE(INT8, DT_INT8);
|
||||
NETLIST_SAVE_TYPE(UINT8, DT_INT8);
|
||||
#if (PHAS_INT128)
|
||||
NETLIST_SAVE_TYPE(INT128, DT_INT128);
|
||||
NETLIST_SAVE_TYPE(UINT128, DT_INT128);
|
||||
#endif
|
||||
NETLIST_SAVE_TYPE(INT64, DT_INT64);
|
||||
NETLIST_SAVE_TYPE(UINT64, DT_INT64);
|
||||
NETLIST_SAVE_TYPE(bool, DT_BOOLEAN);
|
||||
NETLIST_SAVE_TYPE(UINT32, DT_INT);
|
||||
NETLIST_SAVE_TYPE(INT32, DT_INT);
|
||||
NETLIST_SAVE_TYPE(UINT16, DT_INT16);
|
||||
NETLIST_SAVE_TYPE(INT16, DT_INT16);
|
||||
//NETLIST_SAVE_TYPE(std::size_t, DT_INT64);
|
||||
|
||||
namespace plib {
|
||||
|
||||
class pstate_manager_t;
|
||||
|
||||
class pstate_callback_t
|
||||
class state_manager_t
|
||||
{
|
||||
public:
|
||||
using list_t = pvector_t<pstate_callback_t *>;
|
||||
|
||||
virtual ~pstate_callback_t() { };
|
||||
|
||||
virtual void register_state(pstate_manager_t &manager, const pstring &module) = 0;
|
||||
virtual void on_pre_save() = 0;
|
||||
virtual void on_post_load() = 0;
|
||||
protected:
|
||||
};
|
||||
|
||||
struct pstate_entry_t
|
||||
{
|
||||
using list_t = pvector_t<std::unique_ptr<pstate_entry_t>>;
|
||||
|
||||
pstate_entry_t(const pstring &stname, const pstate_data_type_e dt, const void *owner,
|
||||
const int size, const int count, void *ptr, bool is_ptr)
|
||||
: m_name(stname), m_dt(dt), m_owner(owner), m_callback(nullptr), m_size(size), m_count(count), m_ptr(ptr), m_is_ptr(is_ptr) { }
|
||||
|
||||
pstate_entry_t(const pstring &stname, const void *owner, pstate_callback_t *callback)
|
||||
: m_name(stname), m_dt(DT_CUSTOM), m_owner(owner), m_callback(callback), m_size(0), m_count(0), m_ptr(nullptr), m_is_ptr(false) { }
|
||||
|
||||
~pstate_entry_t() { }
|
||||
|
||||
pstring m_name;
|
||||
const pstate_data_type_e m_dt;
|
||||
const void *m_owner;
|
||||
pstate_callback_t *m_callback;
|
||||
const int m_size;
|
||||
const int m_count;
|
||||
void *m_ptr;
|
||||
bool m_is_ptr;
|
||||
|
||||
template<typename T>
|
||||
T *resolved()
|
||||
struct datatype_t
|
||||
{
|
||||
if (m_is_ptr)
|
||||
return *static_cast<T **>(m_ptr);
|
||||
else
|
||||
return static_cast<T *>(m_ptr);
|
||||
}
|
||||
};
|
||||
datatype_t(std::size_t bsize, bool bptr, bool bintegral, bool bfloat)
|
||||
: size(bsize), is_ptr(bptr), is_integral(bintegral), is_float(bfloat), is_custom(false)
|
||||
{}
|
||||
datatype_t(bool bcustom)
|
||||
: size(0), is_ptr(false), is_integral(false), is_float(false), is_custom(bcustom)
|
||||
{}
|
||||
|
||||
class pstate_manager_t
|
||||
{
|
||||
public:
|
||||
const std::size_t size;
|
||||
const bool is_ptr;
|
||||
const bool is_integral;
|
||||
const bool is_float;
|
||||
const bool is_custom;
|
||||
};
|
||||
|
||||
pstate_manager_t();
|
||||
~pstate_manager_t();
|
||||
template<typename T> struct datatype_f
|
||||
{
|
||||
static inline const datatype_t f()
|
||||
{
|
||||
return datatype_t(sizeof(T), false, std::is_integral<T>::value || std::is_enum<T>::value,
|
||||
std::is_floating_point<T>::value); }
|
||||
};
|
||||
|
||||
template<typename T> struct datatype_f<T *>
|
||||
{
|
||||
static inline const datatype_t f()
|
||||
{
|
||||
return datatype_t(sizeof(T), true, std::is_integral<T>::value || std::is_enum<T>::value,
|
||||
std::is_floating_point<T>::value);
|
||||
}
|
||||
};
|
||||
|
||||
class callback_t
|
||||
{
|
||||
public:
|
||||
using list_t = std::vector<callback_t *>;
|
||||
|
||||
virtual ~callback_t() { };
|
||||
|
||||
virtual void register_state(state_manager_t &manager, const pstring &module) = 0;
|
||||
virtual void on_pre_save() = 0;
|
||||
virtual void on_post_load() = 0;
|
||||
protected:
|
||||
};
|
||||
|
||||
struct entry_t
|
||||
{
|
||||
using list_t = std::vector<std::unique_ptr<entry_t>>;
|
||||
|
||||
entry_t(const pstring &stname, const datatype_t dt, const void *owner,
|
||||
const std::size_t count, void *ptr)
|
||||
: m_name(stname), m_dt(dt), m_owner(owner), m_callback(nullptr), m_count(count), m_ptr(ptr) { }
|
||||
|
||||
entry_t(const pstring &stname, const void *owner, callback_t *callback)
|
||||
: m_name(stname), m_dt(datatype_t(true)), m_owner(owner), m_callback(callback), m_count(0), m_ptr(nullptr) { }
|
||||
|
||||
~entry_t() { }
|
||||
|
||||
pstring m_name;
|
||||
const datatype_t m_dt;
|
||||
const void * m_owner;
|
||||
callback_t * m_callback;
|
||||
const std::size_t m_count;
|
||||
void * m_ptr;
|
||||
|
||||
template<typename T>
|
||||
T *resolved()
|
||||
{
|
||||
if (m_dt.is_ptr)
|
||||
return *static_cast<T **>(m_ptr);
|
||||
else
|
||||
return static_cast<T *>(m_ptr);
|
||||
}
|
||||
};
|
||||
|
||||
state_manager_t();
|
||||
~state_manager_t();
|
||||
|
||||
template<typename C> void save_item(const void *owner, C &state, const pstring &stname)
|
||||
{
|
||||
save_state_ptr( owner, stname, pstate_datatype<C>::type, sizeof(C), 1, &state, pstate_datatype<C>::is_ptr);
|
||||
save_state_ptr( owner, stname, datatype_f<C>::f(), 1, &state);
|
||||
}
|
||||
|
||||
template<typename C, std::size_t N> void save_item(const void *owner, C (&state)[N], const pstring &stname)
|
||||
{
|
||||
save_state_ptr(owner, stname, pstate_datatype<C>::type, sizeof(state[0]), N, &(state[0]), false);
|
||||
save_state_ptr(owner, stname, datatype_f<C>::f(), N, &(state[0]));
|
||||
}
|
||||
|
||||
template<typename C> void save_item(const void *owner, C *state, const pstring &stname, const int count)
|
||||
{
|
||||
save_state_ptr(owner, stname, pstate_datatype<C>::type, sizeof(C), count, state, false);
|
||||
save_state_ptr(owner, stname, datatype_f<C>::f(), count, state);
|
||||
}
|
||||
|
||||
template<typename C>
|
||||
@ -149,18 +128,19 @@ public:
|
||||
void post_load();
|
||||
void remove_save_items(const void *owner);
|
||||
|
||||
const pstate_entry_t::list_t &save_list() const { return m_save; }
|
||||
const entry_t::list_t &save_list() const { return m_save; }
|
||||
|
||||
void save_state_ptr(const void *owner, const pstring &stname, const pstate_data_type_e, const int size, const int count, void *ptr, bool is_ptr);
|
||||
void save_state_ptr(const void *owner, const pstring &stname, const datatype_t dt, const int count, void *ptr);
|
||||
|
||||
protected:
|
||||
|
||||
private:
|
||||
pstate_entry_t::list_t m_save;
|
||||
entry_t::list_t m_save;
|
||||
};
|
||||
|
||||
template<> void pstate_manager_t::save_item(const void *owner, pstate_callback_t &state, const pstring &stname);
|
||||
template<> void state_manager_t::save_item(const void *owner, callback_t &state, const pstring &stname);
|
||||
|
||||
#if 0
|
||||
template <typename T>
|
||||
class pstate_interface_t
|
||||
{
|
||||
@ -169,24 +149,24 @@ public:
|
||||
|
||||
template<typename C> void save(C &state, const pstring &stname)
|
||||
{
|
||||
pstate_manager_t &manager = static_cast<T*>(this)->state_manager();
|
||||
state_manager_t &manager = static_cast<T*>(this)->state_manager();
|
||||
pstring module = static_cast<T*>(this)->name();
|
||||
manager.save_item(this, state, module + "." + stname);
|
||||
}
|
||||
template<typename C, std::size_t N> void save(C (&state)[N], const pstring &stname)
|
||||
{
|
||||
pstate_manager_t &manager = static_cast<T*>(this)->state_manager();
|
||||
state_manager_t &manager = static_cast<T*>(this)->state_manager();
|
||||
pstring module = static_cast<T*>(this)->name();
|
||||
manager.save_state_ptr(this, module + "." + stname, pstate_datatype<C>::type, sizeof(state[0]), N, &(state[0]), false);
|
||||
manager.save_state_ptr(this, module + "." + stname, state_manager_t::datatype_f<C>::f(), N, &(state[0]));
|
||||
}
|
||||
template<typename C> void save(C *state, const pstring &stname, const int count)
|
||||
{
|
||||
pstate_manager_t &manager = static_cast<T*>(this)->state_manager();
|
||||
state_manager_t &manager = static_cast<T*>(this)->state_manager();
|
||||
pstring module = static_cast<T*>(this)->name();
|
||||
manager.save_state_ptr(this, module + "." + stname, pstate_datatype<C>::type, sizeof(C), count, state, false);
|
||||
manager.save_state_ptr(this, module + "." + stname, state_manager_t::datatype_f<C>::f(), count, state);
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif /* PSTATE_H_ */
|
||||
|
||||
@ -306,7 +306,6 @@ public:
|
||||
// construction with copy
|
||||
pstring(const mem_t *string) : type_t(string) { }
|
||||
pstring(const type_t &string) : type_t(string) { }
|
||||
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
@ -378,4 +377,22 @@ private:
|
||||
|
||||
};
|
||||
|
||||
// custom specialization of std::hash can be injected in namespace std
|
||||
namespace std
|
||||
{
|
||||
template<> struct hash<pstring>
|
||||
{
|
||||
typedef pstring argument_type;
|
||||
typedef std::size_t result_type;
|
||||
result_type operator()(argument_type const& s) const
|
||||
{
|
||||
const pstring::mem_t *string = s.cstr();
|
||||
result_type result = 5381;
|
||||
for (pstring::mem_t c = *string; c != 0; c = *string++)
|
||||
result = ((result << 5) + result ) ^ (result >> (32 - 5)) ^ c;
|
||||
return result;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
#endif /* PSTRING_H_ */
|
||||
|
||||
@ -41,7 +41,7 @@ namespace plib
|
||||
}
|
||||
|
||||
pstring_vector_t::pstring_vector_t(const pstring &str, const pstring &onstr, bool ignore_empty)
|
||||
: pvector_t<pstring>()
|
||||
: std::vector<pstring>()
|
||||
{
|
||||
int p = 0;
|
||||
int pn;
|
||||
@ -64,7 +64,7 @@ namespace plib
|
||||
}
|
||||
|
||||
pstring_vector_t::pstring_vector_t(const pstring &str, const pstring_vector_t &onstrl)
|
||||
: pvector_t<pstring>()
|
||||
: std::vector<pstring>()
|
||||
{
|
||||
pstring col = "";
|
||||
|
||||
|
||||
@ -21,14 +21,49 @@ namespace plib
|
||||
const pstring environment(const pstring &var, const pstring &default_val = "");
|
||||
}
|
||||
|
||||
namespace container
|
||||
{
|
||||
template <class C>
|
||||
const bool contains(C &con, const typename C::value_type &elem)
|
||||
{
|
||||
return std::find(con.begin(), con.end(), elem) != con.end();
|
||||
}
|
||||
|
||||
template <class C>
|
||||
int indexof(C &con, const typename C::value_type &elem)
|
||||
{
|
||||
auto it = std::find(con.begin(), con.end(), elem);
|
||||
if (it != con.end())
|
||||
return it - con.begin();
|
||||
return -1;
|
||||
}
|
||||
|
||||
template <class C>
|
||||
void insert_at(C &con, const std::size_t index, const typename C::value_type &elem)
|
||||
{
|
||||
con.insert(con.begin() + index, elem);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
template <class C>
|
||||
struct indexed_compare
|
||||
{
|
||||
indexed_compare(const C& target): m_target(target) {}
|
||||
|
||||
bool operator()(int a, int b) const { return m_target[a] < m_target[b]; }
|
||||
|
||||
const C& m_target;
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// string list
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
class pstring_vector_t : public pvector_t<pstring>
|
||||
class pstring_vector_t : public std::vector<pstring>
|
||||
{
|
||||
public:
|
||||
pstring_vector_t() : pvector_t<pstring>() { }
|
||||
pstring_vector_t() : std::vector<pstring>() { }
|
||||
pstring_vector_t(const pstring &str, const pstring &onstr, bool ignore_empty = false);
|
||||
pstring_vector_t(const pstring &str, const pstring_vector_t &onstrl);
|
||||
};
|
||||
|
||||
@ -129,7 +129,7 @@ protected:
|
||||
{
|
||||
pout("{}: {}\n", l.name().cstr(), ls.cstr());
|
||||
if (l == plib::plog_level::FATAL)
|
||||
throw;
|
||||
throw std::exception();
|
||||
}
|
||||
|
||||
private:
|
||||
@ -191,9 +191,9 @@ struct input_t
|
||||
|
||||
};
|
||||
|
||||
plib::pvector_t<input_t> *read_input(netlist::netlist_t *netlist, pstring fname)
|
||||
std::vector<input_t> *read_input(netlist::netlist_t *netlist, pstring fname)
|
||||
{
|
||||
plib::pvector_t<input_t> *ret = plib::palloc<plib::pvector_t<input_t>>();
|
||||
std::vector<input_t> *ret = plib::palloc<std::vector<input_t>>();
|
||||
if (fname != "")
|
||||
{
|
||||
plib::pifilestream f(fname);
|
||||
@ -225,7 +225,7 @@ static void run(tool_options_t &opts)
|
||||
|
||||
nt.read_netlist(opts.opt_file(), opts.opt_name());
|
||||
|
||||
plib::pvector_t<input_t> *inps = read_input(&nt, opts.opt_inp());
|
||||
std::vector<input_t> *inps = read_input(&nt, opts.opt_inp());
|
||||
|
||||
double ttr = opts.opt_ttr();
|
||||
|
||||
@ -245,7 +245,7 @@ static void run(tool_options_t &opts)
|
||||
}
|
||||
nt.process_queue(netlist::netlist_time(ttr) - nlt);
|
||||
nt.stop();
|
||||
pfree(inps);
|
||||
plib::pfree(inps);
|
||||
|
||||
double emutime = (double) (plib::ticks() - t) / (double) plib::ticks_per_second();
|
||||
pout("{1:f} seconds emulation took {2:f} real time ==> {3:5.2f}%\n", ttr, emutime, ttr/emutime*100.0);
|
||||
@ -285,19 +285,34 @@ static void listdevices()
|
||||
nt.setup().start_devices();
|
||||
nt.setup().resolve_inputs();
|
||||
|
||||
std::vector<plib::owned_ptr<netlist::core_device_t>> devs;
|
||||
|
||||
for (auto & f : list)
|
||||
{
|
||||
pstring out = plib::pfmt("{1} {2}(<id>")(f->classname(),"-20")(f->name());
|
||||
pstring terms("");
|
||||
|
||||
auto d = f->Create(nt.setup().netlist(), "dummy");
|
||||
|
||||
auto d = f->Create(nt.setup().netlist(), f->name() + "_lc");
|
||||
// get the list of terminals ...
|
||||
for (auto & inp : d->m_terminals)
|
||||
|
||||
for (auto & t : nt.setup().m_terminals)
|
||||
{
|
||||
if (inp.startsWith(d->name() + "."))
|
||||
inp = inp.substr(d->name().len() + 1);
|
||||
terms += "," + inp;
|
||||
if (t.second->name().startsWith(d->name()))
|
||||
{
|
||||
pstring tn(t.second->name().substr(d->name().len()+1));
|
||||
if (tn.find(".")<0)
|
||||
terms += ", " + tn;
|
||||
}
|
||||
}
|
||||
|
||||
for (auto & t : nt.setup().m_alias)
|
||||
{
|
||||
if (t.first.startsWith(d->name()))
|
||||
{
|
||||
pstring tn(t.first.substr(d->name().len()+1));
|
||||
if (tn.find(".")<0)
|
||||
terms += ", " + tn;
|
||||
}
|
||||
}
|
||||
|
||||
if (f->param_desc().startsWith("+"))
|
||||
@ -317,6 +332,7 @@ static void listdevices()
|
||||
printf("%s\n", out.cstr());
|
||||
if (terms != "")
|
||||
printf("Terminals: %s\n", terms.substr(1).cstr());
|
||||
devs.push_back(std::move(d));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -74,9 +74,9 @@ public:
|
||||
|
||||
unsigned m_railstart;
|
||||
|
||||
plib::pvector_t<unsigned> m_nz; /* all non zero for multiplication */
|
||||
plib::pvector_t<unsigned> m_nzrd; /* non zero right of the diagonal for elimination, may include RHS element */
|
||||
plib::pvector_t<unsigned> m_nzbd; /* non zero below of the diagonal for elimination */
|
||||
std::vector<unsigned> m_nz; /* all non zero for multiplication */
|
||||
std::vector<unsigned> m_nzrd; /* non zero right of the diagonal for elimination, may include RHS element */
|
||||
std::vector<unsigned> m_nzbd; /* non zero below of the diagonal for elimination */
|
||||
|
||||
/* state */
|
||||
nl_double m_last_V;
|
||||
@ -84,12 +84,12 @@ public:
|
||||
nl_double m_h_n_m_1;
|
||||
|
||||
private:
|
||||
plib::pvector_t<int> m_net_other;
|
||||
plib::pvector_t<nl_double> m_go;
|
||||
plib::pvector_t<nl_double> m_gt;
|
||||
plib::pvector_t<nl_double> m_Idr;
|
||||
plib::pvector_t<nl_double *> m_other_curanalog;
|
||||
plib::pvector_t<terminal_t *> m_term;
|
||||
std::vector<int> m_net_other;
|
||||
std::vector<nl_double> m_go;
|
||||
std::vector<nl_double> m_gt;
|
||||
std::vector<nl_double> m_Idr;
|
||||
std::vector<nl_double *> m_other_curanalog;
|
||||
std::vector<terminal_t *> m_term;
|
||||
|
||||
};
|
||||
|
||||
@ -109,8 +109,7 @@ public:
|
||||
class matrix_solver_t : public device_t
|
||||
{
|
||||
public:
|
||||
using list_t = plib::pvector_t<matrix_solver_t *>;
|
||||
using dev_list_t = core_device_t::list_t;
|
||||
using list_t = std::vector<matrix_solver_t *>;
|
||||
|
||||
enum eSortType
|
||||
{
|
||||
@ -121,28 +120,20 @@ public:
|
||||
|
||||
matrix_solver_t(netlist_t &anetlist, const pstring &name,
|
||||
const eSortType sort, const solver_parameters_t *params)
|
||||
: device_t(anetlist, name),
|
||||
m_stat_calculations(0),
|
||||
m_stat_newton_raphson(0),
|
||||
m_stat_vsolver_calls(0),
|
||||
m_iterative_fail(0),
|
||||
m_iterative_total(0),
|
||||
m_params(*params),
|
||||
m_last_step(0, 1),
|
||||
m_cur_ts(0),
|
||||
m_fb_sync(*this, "FB_sync"),
|
||||
m_Q_sync(*this, "Q_sync"),
|
||||
m_sort(sort)
|
||||
: device_t(anetlist, name)
|
||||
, m_params(*params)
|
||||
, m_stat_calculations(*this, "m_stat_calculations", 0)
|
||||
, m_stat_newton_raphson(*this, "m_stat_newton_raphson", 0)
|
||||
, m_stat_vsolver_calls(*this, "m_stat_vsolver_calls", 0)
|
||||
, m_iterative_fail(*this, "m_iterative_fail", 0)
|
||||
, m_iterative_total(*this, "m_iterative_total", 0)
|
||||
, m_last_step(*this, "m_last_step", netlist_time::quantum())
|
||||
, m_cur_ts(*this, "m_cur_ts", 0)
|
||||
, m_fb_sync(*this, "FB_sync")
|
||||
, m_Q_sync(*this, "Q_sync")
|
||||
, m_sort(sort)
|
||||
{
|
||||
connect_post_start(m_fb_sync, m_Q_sync);
|
||||
|
||||
save(NLNAME(m_last_step));
|
||||
save(NLNAME(m_cur_ts));
|
||||
save(NLNAME(m_stat_calculations));
|
||||
save(NLNAME(m_stat_newton_raphson));
|
||||
save(NLNAME(m_stat_vsolver_calls));
|
||||
save(NLNAME(m_iterative_fail));
|
||||
save(NLNAME(m_iterative_total));
|
||||
}
|
||||
|
||||
virtual ~matrix_solver_t();
|
||||
@ -200,27 +191,27 @@ protected:
|
||||
template <typename T>
|
||||
void build_LE_RHS();
|
||||
|
||||
plib::pvector_t<terms_t *> m_terms;
|
||||
plib::pvector_t<analog_net_t *> m_nets;
|
||||
std::vector<terms_t *> m_terms;
|
||||
std::vector<analog_net_t *> m_nets;
|
||||
std::vector<std::unique_ptr<proxied_analog_output_t>> m_inps;
|
||||
|
||||
plib::pvector_t<terms_t *> m_rails_temp;
|
||||
|
||||
int m_stat_calculations;
|
||||
int m_stat_newton_raphson;
|
||||
int m_stat_vsolver_calls;
|
||||
int m_iterative_fail;
|
||||
int m_iterative_total;
|
||||
std::vector<terms_t *> m_rails_temp;
|
||||
|
||||
const solver_parameters_t &m_params;
|
||||
|
||||
state_var<int> m_stat_calculations;
|
||||
state_var<int> m_stat_newton_raphson;
|
||||
state_var<int> m_stat_vsolver_calls;
|
||||
state_var<int> m_iterative_fail;
|
||||
state_var<int> m_iterative_total;
|
||||
|
||||
inline nl_double current_timestep() { return m_cur_ts; }
|
||||
private:
|
||||
|
||||
netlist_time m_last_step;
|
||||
nl_double m_cur_ts;
|
||||
dev_list_t m_step_devices;
|
||||
dev_list_t m_dynamic_devices;
|
||||
state_var<netlist_time> m_last_step;
|
||||
state_var<nl_double> m_cur_ts;
|
||||
std::vector<core_device_t *> m_step_devices;
|
||||
std::vector<core_device_t *> m_dynamic_devices;
|
||||
|
||||
logic_input_t m_fb_sync;
|
||||
logic_output_t m_Q_sync;
|
||||
|
||||
@ -206,18 +206,14 @@ void matrix_solver_direct_t<m_N, storage_N>::vsetup(analog_net_t::list_t &nets)
|
||||
{
|
||||
terms_t * t = m_terms[k];
|
||||
|
||||
if (!t->m_nzrd.contains(N()))
|
||||
if (!plib::container::contains(t->m_nzrd, N()))
|
||||
t->m_nzrd.push_back(N());
|
||||
}
|
||||
|
||||
save(NLNAME(m_last_RHS));
|
||||
netlist().save(*this, m_last_RHS, "m_last_RHS");
|
||||
|
||||
for (unsigned k = 0; k < N(); k++)
|
||||
{
|
||||
pstring num = plib::pfmt("{1}")(k);
|
||||
|
||||
save(RHS(k), "RHS." + num);
|
||||
}
|
||||
netlist().save(*this, RHS(k), plib::pfmt("RHS.{1}")(k));
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -334,10 +334,11 @@ void matrix_solver_direct_t<m_N, storage_N>::vsetup(analog_net_t::list_t &nets)
|
||||
t->m_nz.add(other[i]);
|
||||
}
|
||||
}
|
||||
psort_list(t->m_nzrd);
|
||||
std::sort(t->m_nzrd.begin(), t->m_nzrd.end());
|
||||
|
||||
t->m_nz.add(k); // add diagonal
|
||||
psort_list(t->m_nz);
|
||||
|
||||
std::sort(t->m_nz.begin(), t->m_nz.end());
|
||||
}
|
||||
|
||||
if(0)
|
||||
|
||||
@ -62,13 +62,13 @@ private:
|
||||
{
|
||||
plib::postringstream t;
|
||||
csc_private(t);
|
||||
plib::hash_functor<pstring> h(t.str());
|
||||
std::hash<pstring> h;
|
||||
|
||||
return plib::pfmt("nl_gcr_{1:x}_{2}")(h())(mat.nz_num);
|
||||
return plib::pfmt("nl_gcr_{1:x}_{2}")(h( t.str() ))(mat.nz_num);
|
||||
}
|
||||
|
||||
unsigned m_dim;
|
||||
plib::pvector_t<int> m_term_cr[storage_N];
|
||||
std::vector<int> m_term_cr[storage_N];
|
||||
mat_cr_t<storage_N> mat;
|
||||
nl_double m_A[storage_N * storage_N];
|
||||
|
||||
|
||||
@ -48,7 +48,7 @@ private:
|
||||
|
||||
int solve_ilu_gmres(nl_double * RESTRICT x, const nl_double * RESTRICT rhs, const unsigned restart_max, const unsigned mr, nl_double accuracy);
|
||||
|
||||
plib::pvector_t<int> m_term_cr[storage_N];
|
||||
std::vector<int> m_term_cr[storage_N];
|
||||
|
||||
bool m_use_iLU_preconditioning;
|
||||
bool m_use_more_precise_stop_condition;
|
||||
|
||||
@ -128,15 +128,10 @@ void matrix_solver_sm_t<m_N, storage_N>::vsetup(analog_net_t::list_t &nets)
|
||||
|
||||
matrix_solver_t::setup_base(nets);
|
||||
|
||||
|
||||
save(NLNAME(m_last_RHS));
|
||||
netlist().save(*this, m_last_RHS, "m_last_RHS");
|
||||
|
||||
for (unsigned k = 0; k < N(); k++)
|
||||
{
|
||||
pstring num = plib::pfmt("{1}")(k);
|
||||
|
||||
save(RHS(k), "RHS." + num);
|
||||
}
|
||||
netlist().save(*this, RHS(k), plib::pfmt("RHS.{1}")(k));
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -29,7 +29,7 @@ public:
|
||||
|
||||
matrix_solver_SOR_t(netlist_t &anetlist, const pstring &name, const solver_parameters_t *params, int size)
|
||||
: matrix_solver_direct_t<m_N, storage_N>(anetlist, name, matrix_solver_t::ASCENDING, params, size)
|
||||
, m_lp_fact(0)
|
||||
, m_lp_fact(*this, "m_lp_fact", 0)
|
||||
{
|
||||
}
|
||||
|
||||
@ -39,7 +39,7 @@ public:
|
||||
virtual int vsolve_non_dynamic(const bool newton_raphson) override;
|
||||
|
||||
private:
|
||||
nl_double m_lp_fact;
|
||||
state_var<nl_double> m_lp_fact;
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
@ -51,7 +51,6 @@ template <unsigned m_N, unsigned storage_N>
|
||||
void matrix_solver_SOR_t<m_N, storage_N>::vsetup(analog_net_t::list_t &nets)
|
||||
{
|
||||
matrix_solver_direct_t<m_N, storage_N>::vsetup(nets);
|
||||
this->save(NLNAME(m_lp_fact));
|
||||
}
|
||||
|
||||
template <unsigned m_N, unsigned storage_N>
|
||||
|
||||
@ -32,10 +32,11 @@ public:
|
||||
|
||||
matrix_solver_SOR_mat_t(netlist_t &anetlist, const pstring &name, const solver_parameters_t *params, int size)
|
||||
: matrix_solver_direct_t<m_N, storage_N>(anetlist, name, matrix_solver_t::DESCENDING, params, size)
|
||||
, m_omega(params->m_sor)
|
||||
, m_lp_fact(0)
|
||||
, m_gs_fail(0)
|
||||
, m_gs_total(0)
|
||||
, m_Vdelta(*this, "m_Vdelta", 0.0)
|
||||
, m_omega(*this, "m_omega", params->m_sor)
|
||||
, m_lp_fact(*this, "m_lp_fact", 0)
|
||||
, m_gs_fail(*this, "m_gs_fail", 0)
|
||||
, m_gs_total(*this, "m_gs_total", 0)
|
||||
{
|
||||
}
|
||||
|
||||
@ -46,12 +47,12 @@ public:
|
||||
virtual int vsolve_non_dynamic(const bool newton_raphson) override;
|
||||
|
||||
private:
|
||||
nl_double m_Vdelta[storage_N];
|
||||
state_var<nl_double[storage_N]> m_Vdelta;
|
||||
|
||||
nl_double m_omega;
|
||||
nl_double m_lp_fact;
|
||||
int m_gs_fail;
|
||||
int m_gs_total;
|
||||
state_var<nl_double> m_omega;
|
||||
state_var<nl_double> m_lp_fact;
|
||||
state_var<int> m_gs_fail;
|
||||
state_var<int> m_gs_total;
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
@ -62,11 +63,6 @@ template <unsigned m_N, unsigned storage_N>
|
||||
void matrix_solver_SOR_mat_t<m_N, storage_N>::vsetup(analog_net_t::list_t &nets)
|
||||
{
|
||||
matrix_solver_direct_t<m_N, storage_N>::vsetup(nets);
|
||||
this->save(NLNAME(m_omega));
|
||||
this->save(NLNAME(m_lp_fact));
|
||||
this->save(NLNAME(m_gs_fail));
|
||||
this->save(NLNAME(m_gs_total));
|
||||
this->save(NLNAME(m_Vdelta));
|
||||
}
|
||||
|
||||
#if 0
|
||||
|
||||
@ -137,15 +137,10 @@ void matrix_solver_w_t<m_N, storage_N>::vsetup(analog_net_t::list_t &nets)
|
||||
|
||||
matrix_solver_t::setup_base(nets);
|
||||
|
||||
|
||||
save(NLNAME(m_last_RHS));
|
||||
netlist().save(*this, m_last_RHS, "m_last_RHS");
|
||||
|
||||
for (unsigned k = 0; k < N(); k++)
|
||||
{
|
||||
pstring num = plib::pfmt("{1}")(k);
|
||||
|
||||
save(RHS(k), "RHS." + num);
|
||||
}
|
||||
netlist().save(*this, RHS(k), plib::pfmt("RHS.{1}")(k));
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -67,12 +67,12 @@ void terms_t::add(terminal_t *term, int net_other, bool sorted)
|
||||
{
|
||||
if (m_net_other[i] > net_other)
|
||||
{
|
||||
m_term.insert_at(i, term);
|
||||
m_net_other.insert_at(i, net_other);
|
||||
m_gt.insert_at(i, 0.0);
|
||||
m_go.insert_at(i, 0.0);
|
||||
m_Idr.insert_at(i, 0.0);
|
||||
m_other_curanalog.insert_at(i, nullptr);
|
||||
plib::container::insert_at(m_term, i, term);
|
||||
plib::container::insert_at(m_net_other, i, net_other);
|
||||
plib::container::insert_at(m_gt, i, 0.0);
|
||||
plib::container::insert_at(m_go, i, 0.0);
|
||||
plib::container::insert_at(m_Idr, i, 0.0);
|
||||
plib::container::insert_at(m_other_curanalog, i, nullptr);
|
||||
return;
|
||||
}
|
||||
}
|
||||
@ -135,10 +135,10 @@ void matrix_solver_t::setup_base(analog_net_t::list_t &nets)
|
||||
{
|
||||
case terminal_t::TERMINAL:
|
||||
if (p->device().is_timestep())
|
||||
if (!m_step_devices.contains(&p->device()))
|
||||
if (!plib::container::contains(m_step_devices, &p->device()))
|
||||
m_step_devices.push_back(&p->device());
|
||||
if (p->device().is_dynamic())
|
||||
if (!m_dynamic_devices.contains(&p->device()))
|
||||
if (!plib::container::contains(m_dynamic_devices, &p->device()))
|
||||
m_dynamic_devices.push_back(&p->device());
|
||||
{
|
||||
terminal_t *pterm = dynamic_cast<terminal_t *>(p);
|
||||
@ -257,13 +257,13 @@ void matrix_solver_t::setup_matrix()
|
||||
t->m_nz.clear();
|
||||
|
||||
for (unsigned i = 0; i < t->m_railstart; i++)
|
||||
if (!t->m_nz.contains(other[i]))
|
||||
if (!plib::container::contains(t->m_nz, other[i]))
|
||||
t->m_nz.push_back(other[i]);
|
||||
|
||||
t->m_nz.push_back(k); // add diagonal
|
||||
|
||||
/* and sort */
|
||||
plib::sort_list(t->m_nz);
|
||||
std::sort(t->m_nz.begin(), t->m_nz.end());
|
||||
}
|
||||
|
||||
/* create a list of non zero elements right of the diagonal
|
||||
@ -281,22 +281,21 @@ void matrix_solver_t::setup_matrix()
|
||||
else
|
||||
{
|
||||
t->m_nzrd = m_terms[k-1]->m_nzrd;
|
||||
unsigned j=0;
|
||||
while(j < t->m_nzrd.size())
|
||||
for (auto j = t->m_nzrd.begin(); j != t->m_nzrd.end(); )
|
||||
{
|
||||
if (t->m_nzrd[j] < k + 1)
|
||||
t->m_nzrd.remove_at(j);
|
||||
if (*j < k + 1)
|
||||
j = t->m_nzrd.erase(j);
|
||||
else
|
||||
j++;
|
||||
++j;
|
||||
}
|
||||
}
|
||||
|
||||
for (unsigned i = 0; i < t->m_railstart; i++)
|
||||
if (!t->m_nzrd.contains(other[i]) && other[i] >= (int) (k + 1))
|
||||
if (!plib::container::contains(t->m_nzrd, other[i]) && other[i] >= (int) (k + 1))
|
||||
t->m_nzrd.push_back(other[i]);
|
||||
|
||||
/* and sort */
|
||||
plib::sort_list(t->m_nzrd);
|
||||
std::sort(t->m_nzrd.begin(), t->m_nzrd.end());
|
||||
}
|
||||
|
||||
/* create a list of non zero elements below diagonal k
|
||||
@ -324,7 +323,7 @@ void matrix_solver_t::setup_matrix()
|
||||
if (touched[row][k])
|
||||
{
|
||||
ops++;
|
||||
if (!m_terms[k]->m_nzbd.contains(row))
|
||||
if (!plib::container::contains(m_terms[k]->m_nzbd, row))
|
||||
m_terms[k]->m_nzbd.push_back(row);
|
||||
for (unsigned col = k + 1; col < iN; col++)
|
||||
if (touched[k][col])
|
||||
@ -353,13 +352,13 @@ void matrix_solver_t::setup_matrix()
|
||||
{
|
||||
pstring num = plib::pfmt("{1}")(k);
|
||||
|
||||
save(m_terms[k]->m_last_V, "lastV." + num);
|
||||
save(m_terms[k]->m_DD_n_m_1, "m_DD_n_m_1." + num);
|
||||
save(m_terms[k]->m_h_n_m_1, "m_h_n_m_1." + num);
|
||||
netlist().save(*this, m_terms[k]->m_last_V, "lastV." + num);
|
||||
netlist().save(*this, m_terms[k]->m_DD_n_m_1, "m_DD_n_m_1." + num);
|
||||
netlist().save(*this, m_terms[k]->m_h_n_m_1, "m_h_n_m_1." + num);
|
||||
|
||||
save(m_terms[k]->go(),"GO" + num, m_terms[k]->count());
|
||||
save(m_terms[k]->gt(),"GT" + num, m_terms[k]->count());
|
||||
save(m_terms[k]->Idr(),"IDR" + num , m_terms[k]->count());
|
||||
netlist().save(*this, m_terms[k]->go(),"GO" + num, m_terms[k]->count());
|
||||
netlist().save(*this, m_terms[k]->gt(),"GT" + num, m_terms[k]->count());
|
||||
netlist().save(*this, m_terms[k]->Idr(),"IDR" + num , m_terms[k]->count());
|
||||
}
|
||||
|
||||
for (unsigned k=0; k<iN; k++)
|
||||
@ -552,11 +551,11 @@ void matrix_solver_t::log_stats()
|
||||
log().verbose(" has {1} elements", this->has_timestep_devices() ? "timestep" : "no timestep");
|
||||
log().verbose(" {1:6.3} average newton raphson loops", (double) this->m_stat_newton_raphson / (double) this->m_stat_vsolver_calls);
|
||||
log().verbose(" {1:10} invocations ({2:6} Hz) {3:10} gs fails ({4:6.2} %) {5:6.3} average",
|
||||
this->m_stat_calculations,
|
||||
this->m_stat_calculations * 10 / (int) (this->netlist().time().as_double() * 10.0),
|
||||
this->m_iterative_fail,
|
||||
100.0 * (double) this->m_iterative_fail / (double) this->m_stat_calculations,
|
||||
(double) this->m_iterative_total / (double) this->m_stat_calculations);
|
||||
this->m_stat_calculations(),
|
||||
this->m_stat_calculations() * 10 / (int) (this->netlist().time().as_double() * 10.0),
|
||||
this->m_iterative_fail(),
|
||||
100.0 * (double) this->m_iterative_fail() / (double) this->m_stat_calculations(),
|
||||
(double) this->m_iterative_total() / (double) this->m_stat_calculations());
|
||||
}
|
||||
}
|
||||
|
||||
@ -698,7 +697,7 @@ std::unique_ptr<matrix_solver_t> NETLIB_NAME(solver)::create_solver(int size, co
|
||||
|
||||
void NETLIB_NAME(solver)::post_start()
|
||||
{
|
||||
plib::pvector_t<analog_net_t::list_t> groups;
|
||||
std::vector<analog_net_t::list_t> groups;
|
||||
const bool use_specific = true;
|
||||
|
||||
m_params.m_pivot = m_pivot.Value();
|
||||
|
||||
@ -11,26 +11,6 @@
|
||||
#include "nl_convert.h"
|
||||
|
||||
|
||||
template<typename Class>
|
||||
static plib::pvector_t<int> bubble(const plib::pvector_t<Class> &sl)
|
||||
{
|
||||
plib::pvector_t<int> ret;
|
||||
for (unsigned i=0; i<sl.size(); i++)
|
||||
ret.push_back(i);
|
||||
|
||||
for(unsigned i=0; i < sl.size(); i++)
|
||||
{
|
||||
for(unsigned j=i+1; j < sl.size(); j++)
|
||||
{
|
||||
if(sl[ret[i]]->name() > sl[ret[j]]->name())
|
||||
{
|
||||
std::swap(ret[i], ret[j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------
|
||||
convert - convert a spice netlist
|
||||
-------------------------------------------------*/
|
||||
@ -38,7 +18,7 @@ static plib::pvector_t<int> bubble(const plib::pvector_t<Class> &sl)
|
||||
void nl_convert_base_t::add_pin_alias(const pstring &devname, const pstring &name, const pstring &alias)
|
||||
{
|
||||
pstring pname = devname + "." + name;
|
||||
m_pins.add(pname, plib::make_unique<pin_alias_t>(pname, devname + "." + alias));
|
||||
m_pins.insert({pname, plib::make_unique<pin_alias_t>(pname, devname + "." + alias)});
|
||||
}
|
||||
|
||||
void nl_convert_base_t::add_ext_alias(const pstring &alias)
|
||||
@ -73,13 +53,14 @@ void nl_convert_base_t::add_device(const pstring &atype, const pstring &aname)
|
||||
void nl_convert_base_t::add_term(pstring netname, pstring termname)
|
||||
{
|
||||
net_t * net = nullptr;
|
||||
if (m_nets.contains(netname))
|
||||
auto idx = m_nets.find(netname);
|
||||
if (idx != m_nets.end())
|
||||
net = m_nets[netname].get();
|
||||
else
|
||||
{
|
||||
auto nets = std::make_shared<net_t>(netname);
|
||||
net = nets.get();
|
||||
m_nets.add(netname, nets);
|
||||
m_nets.insert({netname, nets});
|
||||
}
|
||||
|
||||
/* if there is a pin alias, translate ... */
|
||||
@ -102,7 +83,12 @@ void nl_convert_base_t::dump_nl()
|
||||
if (net->terminals().size() == 1)
|
||||
net->set_no_export();
|
||||
}
|
||||
plib::pvector_t<int> sorted = bubble(m_devs);
|
||||
|
||||
std::vector<int> sorted;
|
||||
for (unsigned i=0; i < m_devs.size(); i++)
|
||||
sorted.push_back(i);
|
||||
std::sort(sorted.begin(), sorted.end(), plib::indexed_compare<std::vector<std::shared_ptr<dev_t>>>(m_devs));
|
||||
|
||||
for (std::size_t i=0; i<m_devs.size(); i++)
|
||||
{
|
||||
std::size_t j = sorted[i];
|
||||
@ -118,9 +104,9 @@ void nl_convert_base_t::dump_nl()
|
||||
m_devs[j]->name().cstr());
|
||||
}
|
||||
// print nets
|
||||
for (std::size_t i=0; i<m_nets.size(); i++)
|
||||
for (auto & i : m_nets)
|
||||
{
|
||||
net_t * net = m_nets.value_at(i).get();
|
||||
net_t * net = i.second.get();
|
||||
if (!net->is_no_export())
|
||||
{
|
||||
//printf("Net {}\n", net->name().cstr());
|
||||
|
||||
@ -130,10 +130,10 @@ private:
|
||||
|
||||
plib::postringstream m_buf;
|
||||
|
||||
plib::pvector_t<std::shared_ptr<dev_t>> m_devs;
|
||||
plib::hashmap_t<pstring, std::shared_ptr<net_t> > m_nets;
|
||||
plib::pvector_t<pstring> m_ext_alias;
|
||||
plib::hashmap_t<pstring, std::shared_ptr<pin_alias_t>> m_pins;
|
||||
std::vector<std::shared_ptr<dev_t>> m_devs;
|
||||
std::unordered_map<pstring, std::shared_ptr<net_t> > m_nets;
|
||||
std::vector<pstring> m_ext_alias;
|
||||
std::unordered_map<pstring, std::shared_ptr<pin_alias_t>> m_pins;
|
||||
|
||||
static unit_t m_units[];
|
||||
|
||||
|
||||
@ -111,8 +111,9 @@ Sound processor - 6502
|
||||
#include "emu.h"
|
||||
#include "cpu/m6502/m6502.h"
|
||||
#include "sound/ay8910.h"
|
||||
#include "machine/ldv1000.h"
|
||||
#include "machine/ldp1000.h"
|
||||
#include "machine/gen_latch.h"
|
||||
#include "machine/6850acia.h"
|
||||
|
||||
|
||||
class deco_ld_state : public driver_device
|
||||
@ -123,6 +124,7 @@ public:
|
||||
m_maincpu(*this, "maincpu"),
|
||||
m_audiocpu(*this, "audiocpu"),
|
||||
m_laserdisc(*this, "laserdisc"),
|
||||
//m_acia(*this, "acia"),
|
||||
m_gfxdecode(*this, "gfxdecode"),
|
||||
m_screen(*this, "screen"),
|
||||
m_palette(*this, "palette"),
|
||||
@ -137,7 +139,8 @@ public:
|
||||
|
||||
required_device<cpu_device> m_maincpu;
|
||||
optional_device<cpu_device> m_audiocpu;
|
||||
required_device<pioneer_ldv1000_device> m_laserdisc;
|
||||
required_device<sony_ldp1000_device> m_laserdisc;
|
||||
//required_device<acia6850_device> m_acia;
|
||||
required_device<gfxdecode_device> m_gfxdecode;
|
||||
required_device<screen_device> m_screen;
|
||||
required_device<palette_device> m_palette;
|
||||
@ -150,20 +153,17 @@ public:
|
||||
|
||||
UINT8 m_laserdisc_data;
|
||||
int m_nmimask;
|
||||
DECLARE_READ8_MEMBER(laserdisc_r);
|
||||
DECLARE_WRITE8_MEMBER(laserdisc_w);
|
||||
DECLARE_READ8_MEMBER(sound_status_r);
|
||||
DECLARE_WRITE8_MEMBER(decold_sound_cmd_w);
|
||||
DECLARE_WRITE8_MEMBER(decold_palette_w);
|
||||
DECLARE_CUSTOM_INPUT_MEMBER(begas_vblank_r);
|
||||
DECLARE_INPUT_CHANGED_MEMBER(coin_inserted);
|
||||
virtual void machine_start() override;
|
||||
UINT32 screen_update_rblaster(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
|
||||
UINT32 screen_update_rblaster(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
|
||||
INTERRUPT_GEN_MEMBER(sound_interrupt);
|
||||
void draw_sprites(bitmap_rgb32 &bitmap, const rectangle &cliprect, UINT8 *spriteram, UINT16 tile_bank );
|
||||
void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 *spriteram, UINT16 tile_bank );
|
||||
};
|
||||
|
||||
void deco_ld_state::draw_sprites(bitmap_rgb32 &bitmap, const rectangle &cliprect, UINT8 *spriteram, UINT16 tile_bank )
|
||||
void deco_ld_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 *spriteram, UINT16 tile_bank )
|
||||
{
|
||||
gfx_element *gfx = m_gfxdecode->gfx(1);
|
||||
int i,spr_offs,x,y,col,fx,fy;
|
||||
@ -208,7 +208,7 @@ void deco_ld_state::draw_sprites(bitmap_rgb32 &bitmap, const rectangle &cliprect
|
||||
}
|
||||
}
|
||||
|
||||
UINT32 deco_ld_state::screen_update_rblaster(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
|
||||
UINT32 deco_ld_state::screen_update_rblaster(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
|
||||
{
|
||||
gfx_element *gfx = m_gfxdecode->gfx(0);
|
||||
int y,x;
|
||||
@ -246,33 +246,12 @@ UINT32 deco_ld_state::screen_update_rblaster(screen_device &screen, bitmap_rgb32
|
||||
}
|
||||
|
||||
|
||||
|
||||
READ8_MEMBER(deco_ld_state::laserdisc_r)
|
||||
{
|
||||
UINT8 result = m_laserdisc->status_r();
|
||||
// osd_printf_debug("laserdisc_r = %02X\n", result);
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
WRITE8_MEMBER(deco_ld_state::laserdisc_w)
|
||||
{
|
||||
m_laserdisc_data = data;
|
||||
}
|
||||
|
||||
|
||||
WRITE8_MEMBER(deco_ld_state::decold_sound_cmd_w)
|
||||
{
|
||||
m_soundlatch->write(space, 0, data);
|
||||
m_audiocpu->set_input_line(0, HOLD_LINE);
|
||||
}
|
||||
|
||||
/* same as Burger Time HW */
|
||||
WRITE8_MEMBER(deco_ld_state::decold_palette_w)
|
||||
{
|
||||
m_palette->write(space, offset, UINT8(~data));
|
||||
}
|
||||
|
||||
/* unknown, but certainly related to audiocpu somehow */
|
||||
READ8_MEMBER(deco_ld_state::sound_status_r)
|
||||
{
|
||||
@ -287,9 +266,10 @@ static ADDRESS_MAP_START( rblaster_map, AS_PROGRAM, 8, deco_ld_state )
|
||||
AM_RANGE(0x1003, 0x1003) AM_READ_PORT("IN1")
|
||||
AM_RANGE(0x1004, 0x1004) AM_DEVREAD("soundlatch2", generic_latch_8_device, read) AM_WRITE(decold_sound_cmd_w)
|
||||
AM_RANGE(0x1005, 0x1005) AM_READ(sound_status_r)
|
||||
AM_RANGE(0x1006, 0x1006) AM_NOP // 6850 status
|
||||
AM_RANGE(0x1007, 0x1007) AM_READWRITE(laserdisc_r,laserdisc_w) // 6850 data
|
||||
AM_RANGE(0x1800, 0x1fff) AM_RAM_WRITE(decold_palette_w) AM_SHARE("palette")
|
||||
//AM_RANGE(0x1006, 0x1006) AM_READ(acia_status_hack_r)
|
||||
//AM_RANGE(0x1006, 0x1006) AM_DEVREADWRITE("acia", acia6850_device, status_r, control_w)
|
||||
//AM_RANGE(0x1007, 0x1007) AM_DEVREADWRITE("acia", acia6850_device, data_r, data_w)
|
||||
AM_RANGE(0x1800, 0x1fff) AM_RAM_DEVWRITE("palette", palette_device, write) AM_SHARE("palette")
|
||||
AM_RANGE(0x2000, 0x27ff) AM_RAM
|
||||
AM_RANGE(0x2800, 0x2bff) AM_RAM AM_SHARE("vram0")
|
||||
AM_RANGE(0x2c00, 0x2fff) AM_RAM AM_SHARE("attr0")
|
||||
@ -480,16 +460,20 @@ static MACHINE_CONFIG_START( rblaster, deco_ld_state )
|
||||
|
||||
// MCFG_QUANTUM_TIME(attotime::from_hz(6000))
|
||||
|
||||
MCFG_LASERDISC_LDV1000_ADD("laserdisc") //Sony LDP-1000A, is it truly compatible with the Pioneer?
|
||||
MCFG_LASERDISC_LDP1000_ADD("laserdisc")
|
||||
MCFG_LASERDISC_OVERLAY_DRIVER(256, 256, deco_ld_state, screen_update_rblaster)
|
||||
MCFG_LASERDISC_OVERLAY_CLIP(0, 256-1, 8, 240-1)
|
||||
//MCFG_LASERDISC_OVERLAY_CLIP(0, 256-1, 8, 240-1)
|
||||
MCFG_LASERDISC_OVERLAY_PALETTE("palette")
|
||||
|
||||
/* video hardware */
|
||||
MCFG_LASERDISC_SCREEN_ADD_NTSC("screen", "laserdisc")
|
||||
MCFG_GFXDECODE_ADD("gfxdecode", "palette", rblaster)
|
||||
MCFG_PALETTE_ADD("palette", 512)
|
||||
MCFG_PALETTE_FORMAT(BBGGGRRR)
|
||||
MCFG_PALETTE_ADD("palette", 0x800)
|
||||
MCFG_PALETTE_FORMAT(BBGGGRRR_inverted)
|
||||
|
||||
//MCFG_DEVICE_ADD("acia", ACIA6850, 0)
|
||||
//MCFG_ACIA6850_TXD_HANDLER(DEVWRITELINE("laserdisc", sony_ldp1000_device, write))
|
||||
//MCFG_ACIA6850_RXD_HANDLER(DEVREADLINE("laserdisc", sony_ldp1000_device, read))
|
||||
|
||||
/* sound hardware */
|
||||
/* TODO: mixing */
|
||||
@ -608,7 +592,7 @@ ROM_START( rblaster )
|
||||
ROM_LOAD( "08.bin", 0xa000, 0x2000, CRC(4608b516) SHA1(44af4be84a0b807ea0813ce86376a4b6fd927e5a) )
|
||||
|
||||
DISK_REGION( "laserdisc" )
|
||||
DISK_IMAGE_READONLY( "rblaster", 0, NO_DUMP )
|
||||
DISK_IMAGE_READONLY( "rblaster", 0, SHA1(1563ea907d461592e17646848fdf2dce904bba32) )
|
||||
ROM_END
|
||||
|
||||
ROM_START( cobra )
|
||||
|
||||
@ -53,7 +53,7 @@
|
||||
Passing Shot (2 sets)
|
||||
Wonderboy 3
|
||||
|
||||
System 18 (more commplex tilemaps)
|
||||
System 18 (more complex tilemaps)
|
||||
----------------------------------
|
||||
|
||||
Alien Storm
|
||||
@ -100,12 +100,6 @@
|
||||
#define SHADOW_COLORS_MULTIPLIER 3
|
||||
|
||||
|
||||
INTERRUPT_GEN_MEMBER(segas1x_bootleg_state::sys16_interrupt)
|
||||
{
|
||||
device.execute().set_input_line(4, HOLD_LINE); /* Interrupt vector 4, used by VBlank */
|
||||
}
|
||||
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
WRITE16_MEMBER(segas1x_bootleg_state::sound_command_nmi_w)
|
||||
@ -551,7 +545,7 @@ WRITE16_MEMBER(segas1x_bootleg_state::s16bl_fgscrollx_bank_w)
|
||||
scroll += 0x200;
|
||||
set_tile_bank(bank);
|
||||
|
||||
scroll += 3; // so that the character portraits in attract mode are properly aligned (alighnment on character select no longer matches original tho?)
|
||||
scroll += 3; // so that the character portraits in attract mode are properly aligned (alignment on character select no longer matches original tho?)
|
||||
m_fg_scrollx = -scroll;
|
||||
}
|
||||
|
||||
@ -1963,35 +1957,11 @@ GFXDECODE_END
|
||||
|
||||
/*************************************
|
||||
*
|
||||
* Machine driver
|
||||
* Sound fragments
|
||||
*
|
||||
*************************************/
|
||||
|
||||
/* System 16A/B Bootlegs */
|
||||
static MACHINE_CONFIG_START( system16_base, segas1x_bootleg_state )
|
||||
|
||||
/* basic machine hardware */
|
||||
MCFG_CPU_ADD("maincpu", M68000, 10000000)
|
||||
MCFG_CPU_VBLANK_INT_DRIVER("screen", segas1x_bootleg_state, sys16_interrupt)
|
||||
|
||||
/* video hardware */
|
||||
MCFG_SCREEN_ADD("screen", RASTER)
|
||||
MCFG_SCREEN_REFRESH_RATE(60)
|
||||
MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(0))
|
||||
MCFG_SCREEN_SIZE(40*8, 36*8)
|
||||
MCFG_SCREEN_VISIBLE_AREA(0*8, 40*8-1, 0*8, 28*8-1)
|
||||
MCFG_SCREEN_UPDATE_DRIVER(segas1x_bootleg_state, screen_update_system16)
|
||||
MCFG_SCREEN_PALETTE("palette")
|
||||
|
||||
MCFG_GFXDECODE_ADD("gfxdecode", "palette", sys16)
|
||||
MCFG_PALETTE_ADD("palette", 2048*SHADOW_COLORS_MULTIPLIER)
|
||||
|
||||
MCFG_VIDEO_START_OVERRIDE(segas1x_bootleg_state,system16)
|
||||
|
||||
MCFG_GENERIC_LATCH_8_ADD("soundlatch")
|
||||
MACHINE_CONFIG_END
|
||||
|
||||
static MACHINE_CONFIG_DERIVED( system16, system16_base )
|
||||
static MACHINE_CONFIG_FRAGMENT( z80_ym2151 )
|
||||
|
||||
MCFG_CPU_ADD("soundcpu", Z80, 4000000)
|
||||
MCFG_CPU_PROGRAM_MAP(sound_map)
|
||||
@ -2011,23 +1981,26 @@ WRITE_LINE_MEMBER(segas1x_bootleg_state::sound_cause_nmi)
|
||||
m_soundcpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
|
||||
}
|
||||
|
||||
static MACHINE_CONFIG_DERIVED( system16_7759, system16 )
|
||||
static MACHINE_CONFIG_FRAGMENT( z80_ym2151_upd7759 )
|
||||
|
||||
/* basic machine hardware */
|
||||
|
||||
MCFG_CPU_MODIFY("soundcpu")
|
||||
MCFG_CPU_ADD("soundcpu", Z80, 4000000)
|
||||
MCFG_CPU_PROGRAM_MAP(sound_7759_map)
|
||||
MCFG_CPU_IO_MAP(sound_7759_io_map)
|
||||
|
||||
/* sound hardware */
|
||||
MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
|
||||
|
||||
MCFG_YM2151_ADD("ymsnd", 4000000)
|
||||
MCFG_SOUND_ROUTE(0, "lspeaker", 0.32)
|
||||
MCFG_SOUND_ROUTE(1, "rspeaker", 0.32)
|
||||
|
||||
MCFG_SOUND_ADD("7759", UPD7759, UPD7759_STANDARD_CLOCK)
|
||||
MCFG_UPD7759_DRQ_CALLBACK(WRITELINE(segas1x_bootleg_state,sound_cause_nmi))
|
||||
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 0.48)
|
||||
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 0.48)
|
||||
MACHINE_CONFIG_END
|
||||
|
||||
|
||||
static MACHINE_CONFIG_FRAGMENT( system16_datsu_sound )
|
||||
static MACHINE_CONFIG_FRAGMENT( datsu_ym2151_msm5205 )
|
||||
/* TODO:
|
||||
- other games might use this sound configuration
|
||||
- speaker is likely to be mono for the bootlegs, not stereo.
|
||||
@ -2039,8 +2012,6 @@ static MACHINE_CONFIG_FRAGMENT( system16_datsu_sound )
|
||||
|
||||
MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
|
||||
|
||||
MCFG_GENERIC_LATCH_8_ADD("soundlatch")
|
||||
|
||||
MCFG_YM2151_ADD("ymsnd", 4000000)
|
||||
MCFG_SOUND_ROUTE(0, "lspeaker", 0.32)
|
||||
MCFG_SOUND_ROUTE(1, "rspeaker", 0.32)
|
||||
@ -2052,19 +2023,7 @@ static MACHINE_CONFIG_FRAGMENT( system16_datsu_sound )
|
||||
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 0.80)
|
||||
MACHINE_CONFIG_END
|
||||
|
||||
static MACHINE_CONFIG_DERIVED( shinobi_datsu, system16_base )
|
||||
|
||||
/* basic machine hardware */
|
||||
MCFG_CPU_MODIFY("maincpu")
|
||||
MCFG_CPU_PROGRAM_MAP(shinobib_map)
|
||||
|
||||
MCFG_BOOTLEG_SYS16A_SPRITES_ADD("sprites")
|
||||
MCFG_BOOTLEG_SYS16A_SPRITES_XORIGIN(189-117)
|
||||
|
||||
MCFG_VIDEO_START_OVERRIDE(segas1x_bootleg_state, s16a_bootleg_shinobi )
|
||||
MCFG_SCREEN_MODIFY("screen")
|
||||
MCFG_SCREEN_UPDATE_DRIVER(segas1x_bootleg_state, screen_update_s16a_bootleg)
|
||||
|
||||
static MACHINE_CONFIG_FRAGMENT( datsu_2x_ym2203 )
|
||||
MCFG_CPU_ADD("soundcpu", Z80, 4000000)
|
||||
MCFG_CPU_PERIODIC_INT_DRIVER(segas1x_bootleg_state, nmi_line_pulse, 3000) // or from the YM2203?
|
||||
MCFG_CPU_PROGRAM_MAP(shinobi_datsu_sound_map)
|
||||
@ -2087,11 +2046,56 @@ static MACHINE_CONFIG_DERIVED( shinobi_datsu, system16_base )
|
||||
MCFG_SOUND_ROUTE(1, "mono", 0.50)
|
||||
MCFG_SOUND_ROUTE(2, "mono", 0.50)
|
||||
MCFG_SOUND_ROUTE(3, "mono", 0.80)
|
||||
MACHINE_CONFIG_END
|
||||
|
||||
/*************************************
|
||||
*
|
||||
* Machine driver
|
||||
*
|
||||
*************************************/
|
||||
|
||||
/* System 16A/B Bootlegs */
|
||||
static MACHINE_CONFIG_START( system16_base, segas1x_bootleg_state )
|
||||
|
||||
/* basic machine hardware */
|
||||
MCFG_CPU_ADD("maincpu", M68000, 10000000)
|
||||
MCFG_CPU_VBLANK_INT_DRIVER("screen", segas1x_bootleg_state, irq4_line_hold)
|
||||
|
||||
/* video hardware */
|
||||
MCFG_SCREEN_ADD("screen", RASTER)
|
||||
MCFG_SCREEN_REFRESH_RATE(60)
|
||||
MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(0))
|
||||
MCFG_SCREEN_SIZE(40*8, 36*8)
|
||||
MCFG_SCREEN_VISIBLE_AREA(0*8, 40*8-1, 0*8, 28*8-1)
|
||||
MCFG_SCREEN_UPDATE_DRIVER(segas1x_bootleg_state, screen_update_system16)
|
||||
MCFG_SCREEN_PALETTE("palette")
|
||||
|
||||
MCFG_GFXDECODE_ADD("gfxdecode", "palette", sys16)
|
||||
MCFG_PALETTE_ADD("palette", 2048*SHADOW_COLORS_MULTIPLIER)
|
||||
|
||||
MCFG_VIDEO_START_OVERRIDE(segas1x_bootleg_state,system16)
|
||||
|
||||
MCFG_GENERIC_LATCH_8_ADD("soundlatch")
|
||||
MACHINE_CONFIG_END
|
||||
|
||||
static MACHINE_CONFIG_DERIVED( shinobi_datsu, system16_base )
|
||||
|
||||
/* basic machine hardware */
|
||||
MCFG_CPU_MODIFY("maincpu")
|
||||
MCFG_CPU_PROGRAM_MAP(shinobib_map)
|
||||
|
||||
MCFG_BOOTLEG_SYS16A_SPRITES_ADD("sprites")
|
||||
MCFG_BOOTLEG_SYS16A_SPRITES_XORIGIN(189-117)
|
||||
|
||||
MCFG_VIDEO_START_OVERRIDE(segas1x_bootleg_state, s16a_bootleg_shinobi )
|
||||
MCFG_SCREEN_MODIFY("screen")
|
||||
MCFG_SCREEN_UPDATE_DRIVER(segas1x_bootleg_state, screen_update_s16a_bootleg)
|
||||
|
||||
MCFG_FRAGMENT_ADD(datsu_2x_ym2203)
|
||||
MACHINE_CONFIG_END
|
||||
|
||||
|
||||
static MACHINE_CONFIG_DERIVED( passshtb, system16_7759 )
|
||||
static MACHINE_CONFIG_DERIVED( passshtb, system16_base )
|
||||
|
||||
/* basic machine hardware */
|
||||
MCFG_CPU_MODIFY("maincpu")
|
||||
@ -2104,10 +2108,12 @@ static MACHINE_CONFIG_DERIVED( passshtb, system16_7759 )
|
||||
MCFG_VIDEO_START_OVERRIDE(segas1x_bootleg_state, s16a_bootleg_passsht )
|
||||
MCFG_SCREEN_MODIFY("screen")
|
||||
MCFG_SCREEN_UPDATE_DRIVER(segas1x_bootleg_state, screen_update_s16a_bootleg)
|
||||
|
||||
MCFG_FRAGMENT_ADD(z80_ym2151_upd7759)
|
||||
MACHINE_CONFIG_END
|
||||
|
||||
|
||||
static MACHINE_CONFIG_DERIVED( passsht4b, system16_7759 )
|
||||
static MACHINE_CONFIG_DERIVED( passsht4b, system16_base )
|
||||
|
||||
/* basic machine hardware */
|
||||
MCFG_CPU_MODIFY("maincpu")
|
||||
@ -2121,9 +2127,11 @@ static MACHINE_CONFIG_DERIVED( passsht4b, system16_7759 )
|
||||
MCFG_VIDEO_START_OVERRIDE(segas1x_bootleg_state, s16a_bootleg_passsht )
|
||||
MCFG_SCREEN_MODIFY("screen")
|
||||
MCFG_SCREEN_UPDATE_DRIVER(segas1x_bootleg_state, screen_update_s16a_bootleg_passht4b)
|
||||
|
||||
MCFG_FRAGMENT_ADD(datsu_2x_ym2203)
|
||||
MACHINE_CONFIG_END
|
||||
|
||||
static MACHINE_CONFIG_DERIVED( wb3bb, system16 )
|
||||
static MACHINE_CONFIG_DERIVED( wb3bb, system16_base )
|
||||
|
||||
/* basic machine hardware */
|
||||
MCFG_CPU_MODIFY("maincpu")
|
||||
@ -2137,6 +2145,8 @@ static MACHINE_CONFIG_DERIVED( wb3bb, system16 )
|
||||
MCFG_VIDEO_START_OVERRIDE(segas1x_bootleg_state, s16a_bootleg_wb3bl )
|
||||
MCFG_SCREEN_MODIFY("screen")
|
||||
MCFG_SCREEN_UPDATE_DRIVER(segas1x_bootleg_state, screen_update_s16a_bootleg)
|
||||
|
||||
MCFG_FRAGMENT_ADD(z80_ym2151)
|
||||
MACHINE_CONFIG_END
|
||||
|
||||
|
||||
@ -2146,7 +2156,7 @@ static MACHINE_CONFIG_START( goldnaxeb1, segas1x_bootleg_state )
|
||||
MCFG_CPU_ADD("maincpu", M68000, 10000000)
|
||||
MCFG_CPU_PROGRAM_MAP(goldnaxeb1_map)
|
||||
MCFG_CPU_DECRYPTED_OPCODES_MAP(decrypted_opcodes_map)
|
||||
MCFG_CPU_VBLANK_INT_DRIVER("screen", segas1x_bootleg_state, sys16_interrupt)
|
||||
MCFG_CPU_VBLANK_INT_DRIVER("screen", segas1x_bootleg_state, irq4_line_hold)
|
||||
|
||||
|
||||
/* video hardware */
|
||||
@ -2192,35 +2202,28 @@ static MACHINE_CONFIG_DERIVED( bayrouteb2, goldnaxeb1 )
|
||||
MCFG_CPU_PROGRAM_MAP(bayrouteb2_map)
|
||||
MCFG_DEVICE_REMOVE_ADDRESS_MAP(AS_DECRYPTED_OPCODES)
|
||||
|
||||
MCFG_FRAGMENT_ADD(system16_datsu_sound)
|
||||
MCFG_GENERIC_LATCH_8_ADD("soundlatch")
|
||||
|
||||
MCFG_FRAGMENT_ADD(datsu_ym2151_msm5205)
|
||||
|
||||
MCFG_DEVICE_MODIFY("sprites")
|
||||
MCFG_BOOTLEG_SYS16B_SPRITES_XORIGIN(189-107)
|
||||
|
||||
MACHINE_CONFIG_END
|
||||
|
||||
static MACHINE_CONFIG_DERIVED( tturfbl, system16_7759 )
|
||||
static MACHINE_CONFIG_DERIVED( tturfbl, system16_base )
|
||||
|
||||
/* basic machine hardware */
|
||||
MCFG_CPU_MODIFY("maincpu")
|
||||
MCFG_CPU_PROGRAM_MAP(tturfbl_map)
|
||||
|
||||
MCFG_CPU_MODIFY("soundcpu")
|
||||
MCFG_CPU_PROGRAM_MAP(tturfbl_sound_map)
|
||||
MCFG_CPU_IO_MAP(tturfbl_sound_io_map)
|
||||
|
||||
MCFG_DEVICE_REMOVE("7759")
|
||||
MCFG_SOUND_ADD("5205", MSM5205, 220000)
|
||||
MCFG_MSM5205_VCLK_CB(WRITELINE(segas1x_bootleg_state, tturfbl_msm5205_callback))
|
||||
MCFG_MSM5205_PRESCALER_SELECTOR(MSM5205_S48_4B)
|
||||
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 0.80)
|
||||
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 0.80)
|
||||
MCFG_FRAGMENT_ADD(datsu_ym2151_msm5205)
|
||||
|
||||
MCFG_BOOTLEG_SYS16B_SPRITES_ADD("sprites")
|
||||
MCFG_BOOTLEG_SYS16B_SPRITES_XORIGIN(189-107)
|
||||
MACHINE_CONFIG_END
|
||||
|
||||
static MACHINE_CONFIG_DERIVED( dduxbl, system16 )
|
||||
static MACHINE_CONFIG_DERIVED( dduxbl, system16_base )
|
||||
|
||||
/* basic machine hardware */
|
||||
MCFG_CPU_MODIFY("maincpu")
|
||||
@ -2228,9 +2231,11 @@ static MACHINE_CONFIG_DERIVED( dduxbl, system16 )
|
||||
|
||||
MCFG_BOOTLEG_SYS16B_SPRITES_ADD("sprites")
|
||||
MCFG_BOOTLEG_SYS16B_SPRITES_XORIGIN(189-112)
|
||||
|
||||
MCFG_FRAGMENT_ADD(z80_ym2151)
|
||||
MACHINE_CONFIG_END
|
||||
|
||||
static MACHINE_CONFIG_DERIVED( eswatbl, system16_7759 )
|
||||
static MACHINE_CONFIG_DERIVED( eswatbl, system16_base )
|
||||
|
||||
/* basic machine hardware */
|
||||
MCFG_CPU_MODIFY("maincpu")
|
||||
@ -2238,11 +2243,13 @@ static MACHINE_CONFIG_DERIVED( eswatbl, system16_7759 )
|
||||
|
||||
MCFG_BOOTLEG_SYS16B_SPRITES_ADD("sprites")
|
||||
MCFG_BOOTLEG_SYS16B_SPRITES_XORIGIN(189-124)
|
||||
|
||||
MCFG_FRAGMENT_ADD(z80_ym2151_upd7759)
|
||||
MACHINE_CONFIG_END
|
||||
|
||||
|
||||
|
||||
static MACHINE_CONFIG_DERIVED( tetrisbl, system16 )
|
||||
static MACHINE_CONFIG_DERIVED( tetrisbl, system16_base )
|
||||
|
||||
/* basic machine hardware */
|
||||
MCFG_CPU_MODIFY("maincpu")
|
||||
@ -2250,10 +2257,22 @@ static MACHINE_CONFIG_DERIVED( tetrisbl, system16 )
|
||||
|
||||
MCFG_BOOTLEG_SYS16B_SPRITES_ADD("sprites")
|
||||
MCFG_BOOTLEG_SYS16B_SPRITES_XORIGIN(189-112)
|
||||
|
||||
MCFG_FRAGMENT_ADD(z80_ym2151)
|
||||
MACHINE_CONFIG_END
|
||||
|
||||
static MACHINE_CONFIG_DERIVED( altbeastbl, system16_base )
|
||||
/* basic machine hardware */
|
||||
MCFG_CPU_MODIFY("maincpu")
|
||||
MCFG_CPU_PROGRAM_MAP(tetrisbl_map)
|
||||
|
||||
static MACHINE_CONFIG_DERIVED( beautyb, system16 )
|
||||
MCFG_BOOTLEG_SYS16B_SPRITES_ADD("sprites")
|
||||
MCFG_BOOTLEG_SYS16B_SPRITES_XORIGIN(189-112)
|
||||
|
||||
MCFG_FRAGMENT_ADD(datsu_2x_ym2203)
|
||||
MACHINE_CONFIG_END
|
||||
|
||||
static MACHINE_CONFIG_DERIVED( beautyb, system16_base )
|
||||
|
||||
/* basic machine hardware */
|
||||
MCFG_CPU_MODIFY("maincpu")
|
||||
@ -2261,6 +2280,8 @@ static MACHINE_CONFIG_DERIVED( beautyb, system16 )
|
||||
|
||||
MCFG_BOOTLEG_SYS16B_SPRITES_ADD("sprites")
|
||||
MCFG_BOOTLEG_SYS16B_SPRITES_XORIGIN(189-112)
|
||||
|
||||
MCFG_FRAGMENT_ADD(z80_ym2151)
|
||||
MACHINE_CONFIG_END
|
||||
|
||||
|
||||
@ -3254,7 +3275,7 @@ ROM_END
|
||||
|
||||
Michael Jackson's Mooonwalker bootleg - Complete Dump
|
||||
|
||||
This romset comes from a bootleg pcb.This is the complement of which lacks in the existing set (mwalkbl)
|
||||
This romset comes from a bootleg pcb. This is the complement of which lacks in the existing set (mwalkbl)
|
||||
Hardware info:
|
||||
Main cpu 68000P10
|
||||
Sound cpu Z80A
|
||||
@ -3265,7 +3286,7 @@ mwb5snd - sound program
|
||||
mwb10snd to mwb15snd - adpcm samples
|
||||
mwb16obj to mwb31obj - sprites/objects
|
||||
Rest of eproms (main program and tiles/bg) are identical of existing set and original set respectively.
|
||||
Note - sound section was been heavily modified: sound program to use only samples and some musics are cut (not present).Sprite eproms are splitted from original set.
|
||||
Note - sound section was been heavily modified: sound program to use only samples and some musics are cut (not present). Sprite eproms are split from original set.
|
||||
Eproms are 27512, 27010
|
||||
|
||||
*/
|
||||
@ -3779,7 +3800,7 @@ DRIVER_INIT_MEMBER(segas1x_bootleg_state,astormbl)
|
||||
GAME( 1987, shinobld, shinobi, shinobi_datsu, shinobi, segas1x_bootleg_state, shinobl, ROT0, "bootleg (Datsu)", "Shinobi (Datsu bootleg, set 1)", MACHINE_NOT_WORKING | MACHINE_IMPERFECT_GRAPHICS | MACHINE_IMPERFECT_SOUND )
|
||||
GAME( 1987, shinoblda, shinobi, shinobi_datsu, shinobi, segas1x_bootleg_state, shinobl, ROT0, "bootleg (Datsu)", "Shinobi (Datsu bootleg, set 2)", MACHINE_NOT_WORKING | MACHINE_IMPERFECT_GRAPHICS | MACHINE_IMPERFECT_SOUND )
|
||||
GAME( 1988, passshtb, passsht, passshtb, passsht, segas1x_bootleg_state, passsht, ROT270, "bootleg", "Passing Shot (2 Players) (bootleg)", MACHINE_NOT_WORKING | MACHINE_IMPERFECT_GRAPHICS | MACHINE_IMPERFECT_SOUND )
|
||||
GAME( 1988, passht4b, passsht, passsht4b, passht4b, segas1x_bootleg_state, shinobl, ROT270, "bootleg", "Passing Shot (4 Players) (bootleg)", MACHINE_NOT_WORKING | MACHINE_IMPERFECT_GRAPHICS | MACHINE_NO_SOUND )
|
||||
GAME( 1988, passht4b, passsht, passsht4b, passht4b, segas1x_bootleg_state, shinobl, ROT270, "bootleg", "Passing Shot (4 Players) (bootleg)", MACHINE_NOT_WORKING | MACHINE_IMPERFECT_GRAPHICS | MACHINE_IMPERFECT_SOUND )
|
||||
GAME( 1988, wb3bbl, wb3, wb3bb, wb3b, segas1x_bootleg_state, wb3bbl, ROT0, "bootleg", "Wonder Boy III - Monster Lair (bootleg)", MACHINE_NOT_WORKING | MACHINE_IMPERFECT_GRAPHICS)
|
||||
GAME( 1988, wb3bble, wb3, wb3bb, wb3b, segas1x_bootleg_state, wb3bbl, ROT0, "bootleg", "Wonder Boy III - Monster Lair (encrypted bootleg)", MACHINE_NOT_WORKING )
|
||||
|
||||
@ -3790,8 +3811,8 @@ GAME( 1989, goldnaxeb1, goldnaxe, goldnaxeb1, goldnaxe, segas1x_bootleg_state
|
||||
GAME( 1989, goldnaxeb2, goldnaxe, goldnaxeb2, goldnaxe, segas1x_bootleg_state, goldnaxeb2, ROT0, "bootleg", "Golden Axe (bootleg)", MACHINE_NOT_WORKING | MACHINE_NO_SOUND )
|
||||
GAME( 1989, tturfbl, tturf, tturfbl, tturf, segas1x_bootleg_state, tturfbl, ROT0, "bootleg (Datsu)", "Tough Turf (Datsu bootleg)", MACHINE_NOT_WORKING | MACHINE_IMPERFECT_GRAPHICS | MACHINE_IMPERFECT_SOUND )
|
||||
GAME( 1989, dduxbl, ddux, dduxbl, ddux, segas1x_bootleg_state, dduxbl, ROT0, "bootleg (Datsu)", "Dynamite Dux (Datsu bootleg)", MACHINE_NOT_WORKING )
|
||||
GAME( 1988, altbeastbl, altbeast, tetrisbl, tetris, segas1x_bootleg_state, altbeastbl, ROT0, "bootleg (Datsu)", "Altered Beast (Datsu bootleg)", MACHINE_NOT_WORKING | MACHINE_IMPERFECT_GRAPHICS | MACHINE_NO_SOUND )
|
||||
GAME( 1988, mutantwarr, altbeast, tetrisbl, tetris, segas1x_bootleg_state, altbeastbl, ROT0, "bootleg (Datsu)", "Mutant Warrior (Altered Beast - Datsu bootleg)", MACHINE_NOT_WORKING | MACHINE_IMPERFECT_GRAPHICS | MACHINE_NO_SOUND )
|
||||
GAME( 1988, altbeastbl, altbeast, altbeastbl, tetris, segas1x_bootleg_state, altbeastbl, ROT0, "bootleg (Datsu)", "Altered Beast (Datsu bootleg)", MACHINE_NOT_WORKING | MACHINE_IMPERFECT_GRAPHICS | MACHINE_IMPERFECT_SOUND )
|
||||
GAME( 1988, mutantwarr, altbeast, altbeastbl, tetris, segas1x_bootleg_state, altbeastbl, ROT0, "bootleg (Datsu)", "Mutant Warrior (Altered Beast - Datsu bootleg)", MACHINE_NOT_WORKING | MACHINE_IMPERFECT_GRAPHICS | MACHINE_IMPERFECT_SOUND )
|
||||
GAME( 1989, eswatbl, eswat, eswatbl, eswat, segas1x_bootleg_state, eswatbl, ROT0, "bootleg", "E-Swat - Cyber Police (bootleg)", MACHINE_NOT_WORKING | MACHINE_IMPERFECT_GRAPHICS | MACHINE_IMPERFECT_SOUND )
|
||||
GAME( 1988, tetrisbl, tetris, tetrisbl, tetris, segas1x_bootleg_state, dduxbl, ROT0, "bootleg", "Tetris (bootleg)", 0 )
|
||||
|
||||
|
||||
@ -212,7 +212,6 @@ public:
|
||||
UINT32 screen_update_system18old(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
|
||||
UINT32 screen_update_s16a_bootleg(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
|
||||
UINT32 screen_update_s16a_bootleg_passht4b(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
|
||||
INTERRUPT_GEN_MEMBER(sys16_interrupt);
|
||||
void setup_system16_bootleg_spritebanking( );
|
||||
void update_page( );
|
||||
void set_tile_bank( int data );
|
||||
|
||||
Loading…
Reference in New Issue
Block a user