diff options
Diffstat (limited to 'src/lib')
88 files changed, 1533 insertions, 1536 deletions
diff --git a/src/lib/netlist/analog/nld_bjt.h b/src/lib/netlist/analog/nld_bjt.h index c7811d590d5..b829e8a22b2 100644 --- a/src/lib/netlist/analog/nld_bjt.h +++ b/src/lib/netlist/analog/nld_bjt.h @@ -15,13 +15,13 @@ // Macros // ----------------------------------------------------------------------------- -#define QBJT_SW(_name, _model) \ - NET_REGISTER_DEV(QBJT_SW, _name) \ - NETDEV_PARAMI(_name, MODEL, _model) +#define QBJT_SW(name, model) \ + NET_REGISTER_DEV(QBJT_SW, name) \ + NETDEV_PARAMI(name, MODEL, model) -#define QBJT_EB(_name, _model) \ - NET_REGISTER_DEV(QBJT_EB, _name) \ - NETDEV_PARAMI(_name, MODEL, _model) +#define QBJT_EB(name, model) \ + NET_REGISTER_DEV(QBJT_EB, name) \ + NETDEV_PARAMI(name, MODEL, model) NETLIB_NAMESPACE_DEVICES_START() diff --git a/src/lib/netlist/analog/nld_fourterm.h b/src/lib/netlist/analog/nld_fourterm.h index 801f4c0fd49..7b577fc1bde 100644 --- a/src/lib/netlist/analog/nld_fourterm.h +++ b/src/lib/netlist/analog/nld_fourterm.h @@ -16,17 +16,17 @@ // Macros // ---------------------------------------------------------------------------------------- -#define VCCS(_name) \ - NET_REGISTER_DEV(VCCS, _name) +#define VCCS(name) \ + NET_REGISTER_DEV(VCCS, name) -#define CCCS(_name) \ - NET_REGISTER_DEV(CCCS, _name) +#define CCCS(name) \ + NET_REGISTER_DEV(CCCS, name) -#define VCVS(_name) \ - NET_REGISTER_DEV(VCVS, _name) +#define VCVS(name) \ + NET_REGISTER_DEV(VCVS, name) -#define LVCCS(_name) \ - NET_REGISTER_DEV(LVCCS, _name) +#define LVCCS(name) \ + NET_REGISTER_DEV(LVCCS, name) NETLIB_NAMESPACE_DEVICES_START() diff --git a/src/lib/netlist/analog/nld_opamps.h b/src/lib/netlist/analog/nld_opamps.h index a4ff22bbb90..0e7868de8af 100644 --- a/src/lib/netlist/analog/nld_opamps.h +++ b/src/lib/netlist/analog/nld_opamps.h @@ -19,12 +19,12 @@ // Macros // ---------------------------------------------------------------------------------------- -#define OPAMP(_name, _model) \ - NET_REGISTER_DEV(OPAMP, _name) \ - NETDEV_PARAMI(_name, MODEL, _model) +#define OPAMP(name, model) \ + NET_REGISTER_DEV(OPAMP, name) \ + NETDEV_PARAMI(name, MODEL, model) -#define LM3900(_name) \ - SUBMODEL(opamp_lm3900, _name) +#define LM3900(name) \ + SUBMODEL(opamp_lm3900, name) // ---------------------------------------------------------------------------------------- // Devices ... diff --git a/src/lib/netlist/analog/nld_switches.h b/src/lib/netlist/analog/nld_switches.h index b6a49cbd951..4f908b8564d 100644 --- a/src/lib/netlist/analog/nld_switches.h +++ b/src/lib/netlist/analog/nld_switches.h @@ -17,11 +17,11 @@ // Macros // ---------------------------------------------------------------------------------------- -#define SWITCH(_name) \ - NET_REGISTER_DEV(SWITCH, _name) +#define SWITCH(name) \ + NET_REGISTER_DEV(SWITCH, name) -#define SWITCH2(_name) \ - NET_REGISTER_DEV(SWITCH2, _name) +#define SWITCH2(name) \ + NET_REGISTER_DEV(SWITCH2, name) // ---------------------------------------------------------------------------------------- // Devices ... diff --git a/src/lib/netlist/analog/nld_twoterm.h b/src/lib/netlist/analog/nld_twoterm.h index 7879baa6cde..029cc9e2bde 100644 --- a/src/lib/netlist/analog/nld_twoterm.h +++ b/src/lib/netlist/analog/nld_twoterm.h @@ -39,36 +39,36 @@ // Macros // ----------------------------------------------------------------------------- -#define RES(_name, _R) \ - NET_REGISTER_DEV(RES, _name) \ - NETDEV_PARAMI(_name, R, _R) +#define RES(name, p_R) \ + NET_REGISTER_DEV(RES, name) \ + NETDEV_PARAMI(name, R, p_R) -#define POT(_name, _R) \ - NET_REGISTER_DEV(POT, _name) \ - NETDEV_PARAMI(_name, R, _R) +#define POT(name, p_R) \ + NET_REGISTER_DEV(POT, name) \ + NETDEV_PARAMI(name, R, p_R) /* Does not have pin 3 connected */ -#define POT2(_name, _R) \ - NET_REGISTER_DEV(POT2, _name) \ - NETDEV_PARAMI(_name, R, _R) +#define POT2(name, p_R) \ + NET_REGISTER_DEV(POT2, name) \ + NETDEV_PARAMI(name, R, p_R) -#define CAP(_name, _C) \ - NET_REGISTER_DEV(CAP, _name) \ - NETDEV_PARAMI(_name, C, _C) +#define CAP(name, p_C) \ + NET_REGISTER_DEV(CAP, name) \ + NETDEV_PARAMI(name, C, p_C) /* Generic Diode */ -#define DIODE(_name, _model) \ - NET_REGISTER_DEV(DIODE, _name) \ - NETDEV_PARAMI(_name, MODEL, _model) +#define DIODE(name, model) \ + NET_REGISTER_DEV(DIODE, name) \ + NETDEV_PARAMI(name, MODEL, model) -#define VS(_name, _V) \ - NET_REGISTER_DEV(VS, _name) \ - NETDEV_PARAMI(_name, V, _V) +#define VS(name, pV) \ + NET_REGISTER_DEV(VS, name) \ + NETDEV_PARAMI(name, V, pV) -#define CS(_name, _I) \ - NET_REGISTER_DEV(CS, _name) \ - NETDEV_PARAMI(_name, I, _I) +#define CS(name, pI) \ + NET_REGISTER_DEV(CS, name) \ + NETDEV_PARAMI(name, I, pI) // ----------------------------------------------------------------------------- // Generic macros diff --git a/src/lib/netlist/devices/net_lib.cpp b/src/lib/netlist/devices/net_lib.cpp index 4dc0c74b233..fe0a2d087ca 100644 --- a/src/lib/netlist/devices/net_lib.cpp +++ b/src/lib/netlist/devices/net_lib.cpp @@ -58,8 +58,8 @@ NETLIST_END() #define xstr(s) # s -#define ENTRY1(_nic, _name, _defparam) factory.register_device<_nic>( # _name, xstr(_nic), _defparam ); -#define ENTRY(_nic, _name, _defparam) ENTRY1(NETLIB_NAME(_nic), _name, _defparam) +#define ENTRY1(nic, name, defparam) factory.register_device<nic>( # name, xstr(nic), defparam ); +#define ENTRY(nic, name, defparam) ENTRY1(NETLIB_NAME(nic), name, defparam) NETLIB_NAMESPACE_DEVICES_START() @@ -119,7 +119,7 @@ void initialize_factory(factory_list_t &factory) ENTRY(9316, TTL_9316, "+CLK,ENP,ENT,CLRQ,LOADQ,A,B,C,D") ENTRY(CD4020, CD4020, "") ENTRY(CD4066_GATE, CD4066_GATE, "") - /* entries with suffix _WI are legacy only */ + /* entries with suffix WI are legacy only */ ENTRY(CD4020, CD4020_WI, "+IP,RESET,VDD,VSS") //ENTRY(4066, CD_4066, "+A,B") ENTRY(NE555, NE555, "-") diff --git a/src/lib/netlist/devices/nld_4020.h b/src/lib/netlist/devices/nld_4020.h index 491bef29c21..0ca252222b9 100644 --- a/src/lib/netlist/devices/nld_4020.h +++ b/src/lib/netlist/devices/nld_4020.h @@ -31,15 +31,15 @@ #include "nld_cmos.h" /* FIXME: only used in mario.c */ -#define CD4020_WI(_name, _IP, _RESET, _VDD, _VSS) \ - NET_REGISTER_DEV(CD4020_WI, _name) \ - NET_CONNECT(_name, IP, _IP) \ - NET_CONNECT(_name, RESET, _RESET) \ - NET_CONNECT(_name, VDD, _VDD) \ - NET_CONNECT(_name, VSS, _VSS) - -#define CD4020(_name) \ - NET_REGISTER_DEV(CD4020, _name) +#define CD4020_WI(name, cIP, cRESET, cVDD, cVSS) \ + NET_REGISTER_DEV(CD4020_WI, name) \ + NET_CONNECT(name, IP, cIP) \ + NET_CONNECT(name, RESET, cRESET) \ + NET_CONNECT(name, VDD, cVDD) \ + NET_CONNECT(name, VSS, cVSS) + +#define CD4020(name) \ + NET_REGISTER_DEV(CD4020, name) NETLIB_NAMESPACE_DEVICES_START() diff --git a/src/lib/netlist/devices/nld_4066.h b/src/lib/netlist/devices/nld_4066.h index ca1f1bd66cc..87772264136 100644 --- a/src/lib/netlist/devices/nld_4066.h +++ b/src/lib/netlist/devices/nld_4066.h @@ -27,8 +27,8 @@ #include "nl_base.h" #include "nld_cmos.h" -#define CD4066_GATE(_name) \ - NET_REGISTER_DEV(CD4066_GATE, _name) +#define CD4066_GATE(name) \ + NET_REGISTER_DEV(CD4066_GATE, name) NETLIB_NAMESPACE_DEVICES_START() diff --git a/src/lib/netlist/devices/nld_74107.h b/src/lib/netlist/devices/nld_74107.h index 8023f1103fd..90c632314af 100644 --- a/src/lib/netlist/devices/nld_74107.h +++ b/src/lib/netlist/devices/nld_74107.h @@ -61,18 +61,18 @@ #include "nl_base.h" -#define TTL_74107A(_name, _CLK, _J, _K, _CLRQ) \ - NET_REGISTER_DEV(TTL_74107A, _name) \ - NET_CONNECT(_name, CLK, _CLK) \ - NET_CONNECT(_name, J, _J) \ - NET_CONNECT(_name, K, _K) \ - NET_CONNECT(_name, CLRQ, _CLRQ) - -#define TTL_74107(_name, _CLK, _J, _K, _CLRQ) \ - TTL_74107A(_name, _CLK, _J, _K, _CLRQ) - -#define TTL_74107_DIP(_name) \ - NET_REGISTER_DEV(TTL_74107_DIP, _name) +#define TTL_74107A(name, cCLK, cJ, cK, cCLRQ) \ + NET_REGISTER_DEV(TTL_74107A, name) \ + NET_CONNECT(name, CLK, cCLK) \ + NET_CONNECT(name, J, cJ) \ + NET_CONNECT(name, K, cK) \ + NET_CONNECT(name, CLRQ, cCLRQ) + +#define TTL_74107(name, cCLK, cJ, cK, cCLRQ) \ + TTL_74107A(name, cCLK, cJ, cK, cCLRQ) + +#define TTL_74107_DIP(name) \ + NET_REGISTER_DEV(TTL_74107_DIP, name) NETLIB_NAMESPACE_DEVICES_START() diff --git a/src/lib/netlist/devices/nld_74123.h b/src/lib/netlist/devices/nld_74123.h index 70f0bf05a67..696e917abd5 100644 --- a/src/lib/netlist/devices/nld_74123.h +++ b/src/lib/netlist/devices/nld_74123.h @@ -53,8 +53,8 @@ #include "nld_system.h" #include "analog/nld_twoterm.h" -#define TTL_74123(_name) \ - NET_REGISTER_DEV(TTL_74123, _name) +#define TTL_74123(name) \ + NET_REGISTER_DEV(TTL_74123, name) NETLIB_NAMESPACE_DEVICES_START() @@ -126,8 +126,8 @@ public: param_double_t m_RI; }; -#define TTL_74123_DIP(_name) \ - NET_REGISTER_DEV(TTL_74123_DIP, _name) +#define TTL_74123_DIP(name) \ + NET_REGISTER_DEV(TTL_74123_DIP, name) NETLIB_OBJECT(74123_dip) { @@ -166,8 +166,8 @@ private: * THe 9602 uses an OR gate instead of an AND gate. */ -#define TTL_9602_DIP(_name) \ - NET_REGISTER_DEV(TTL_9602_DIP, _name) +#define TTL_9602_DIP(name) \ + NET_REGISTER_DEV(TTL_9602_DIP, name) NETLIB_OBJECT(9602_dip) { @@ -206,8 +206,8 @@ private: * The CD4538 is pretty similar to the 9602 */ -#define CD4538_DIP(_name) \ - NET_REGISTER_DEV(CD4538_DIP, _name) +#define CD4538_DIP(name) \ + NET_REGISTER_DEV(CD4538_DIP, name) NETLIB_OBJECT(4538_dip) { diff --git a/src/lib/netlist/devices/nld_74153.h b/src/lib/netlist/devices/nld_74153.h index dc7753c28c6..d4059bbb384 100644 --- a/src/lib/netlist/devices/nld_74153.h +++ b/src/lib/netlist/devices/nld_74153.h @@ -47,18 +47,18 @@ #include "nl_base.h" -#define TTL_74153(_name, _C0, _C1, _C2, _C3, _A, _B, _G) \ - NET_REGISTER_DEV(TTL_74153, _name) \ - NET_CONNECT(_name, C0, _C0) \ - NET_CONNECT(_name, C1, _C1) \ - NET_CONNECT(_name, C2, _C2) \ - NET_CONNECT(_name, C3, _C3) \ - NET_CONNECT(_name, A, _A) \ - NET_CONNECT(_name, B, _B) \ - NET_CONNECT(_name, G, _G) - -#define TTL_74153_DIP(_name) \ - NET_REGISTER_DEV(TTL_74153_DIP, _name) +#define TTL_74153(name, cC0, cC1, cC2, cC3, cA, cB, cG) \ + NET_REGISTER_DEV(TTL_74153, name) \ + NET_CONNECT(name, C0, cC0) \ + NET_CONNECT(name, C1, cC1) \ + NET_CONNECT(name, C2, cC2) \ + NET_CONNECT(name, C3, cC3) \ + NET_CONNECT(name, A, cA) \ + NET_CONNECT(name, B, cB) \ + NET_CONNECT(name, G, cG) + +#define TTL_74153_DIP(name) \ + NET_REGISTER_DEV(TTL_74153_DIP, name) NETLIB_NAMESPACE_DEVICES_START() diff --git a/src/lib/netlist/devices/nld_74175.h b/src/lib/netlist/devices/nld_74175.h index 4ab919aee2d..ca796f65d83 100644 --- a/src/lib/netlist/devices/nld_74175.h +++ b/src/lib/netlist/devices/nld_74175.h @@ -38,10 +38,10 @@ #include "nl_base.h" -#define TTL_74175(_name) \ - NET_REGISTER_DEV(TTL_74175, _name) -#define TTL_74175_DIP(_name) \ - NET_REGISTER_DEV(TTL_74175_DIP, _name) +#define TTL_74175(name) \ + NET_REGISTER_DEV(TTL_74175, name) +#define TTL_74175_DIP(name) \ + NET_REGISTER_DEV(TTL_74175_DIP, name) NETLIB_NAMESPACE_DEVICES_START() diff --git a/src/lib/netlist/devices/nld_74192.h b/src/lib/netlist/devices/nld_74192.h index c92cce9482b..34f02845b05 100644 --- a/src/lib/netlist/devices/nld_74192.h +++ b/src/lib/netlist/devices/nld_74192.h @@ -32,11 +32,11 @@ #include "nl_base.h" #include "nld_9316.h" -#define TTL_74192(_name) \ - NET_REGISTER_DEV(TTL_74192, _name) +#define TTL_74192(name) \ + NET_REGISTER_DEV(TTL_74192, name) -#define TTL_74192_DIP(_name) \ - NET_REGISTER_DEV(TTL_74192_DIP, _name) +#define TTL_74192_DIP(name) \ + NET_REGISTER_DEV(TTL_74192_DIP, name) NETLIB_NAMESPACE_DEVICES_START() diff --git a/src/lib/netlist/devices/nld_74193.h b/src/lib/netlist/devices/nld_74193.h index 184acf3ee8d..729d3c91290 100644 --- a/src/lib/netlist/devices/nld_74193.h +++ b/src/lib/netlist/devices/nld_74193.h @@ -28,11 +28,11 @@ #include "nl_base.h" -#define TTL_74193(_name) \ - NET_REGISTER_DEV(TTL_74193, _name) +#define TTL_74193(name) \ + NET_REGISTER_DEV(TTL_74193, name) -#define TTL_74193_DIP(_name) \ - NET_REGISTER_DEV(TTL_74193_DIP, _name) +#define TTL_74193_DIP(name) \ + NET_REGISTER_DEV(TTL_74193_DIP, name) NETLIB_NAMESPACE_DEVICES_START() diff --git a/src/lib/netlist/devices/nld_74279.h b/src/lib/netlist/devices/nld_74279.h index 5f47cfbb4a0..2e298d62dc6 100644 --- a/src/lib/netlist/devices/nld_74279.h +++ b/src/lib/netlist/devices/nld_74279.h @@ -38,8 +38,8 @@ #include "nld_truthtable.h" -#define TTL_74279_DIP(_name) \ - NET_REGISTER_DEV(TTL_74279_DIP, _name) +#define TTL_74279_DIP(name) \ + NET_REGISTER_DEV(TTL_74279_DIP, name) NETLIB_NAMESPACE_DEVICES_START() diff --git a/src/lib/netlist/devices/nld_7448.h b/src/lib/netlist/devices/nld_7448.h index c9de0af5cc6..f5280daf550 100644 --- a/src/lib/netlist/devices/nld_7448.h +++ b/src/lib/netlist/devices/nld_7448.h @@ -27,18 +27,18 @@ #include "nl_base.h" #include "nld_truthtable.h" -#define TTL_7448(_name, _A0, _A1, _A2, _A3, _LTQ, _BIQ, _RBIQ) \ - NET_REGISTER_DEV(TTL_7448, _name) \ - NET_CONNECT(_name, A, _A0) \ - NET_CONNECT(_name, B, _A1) \ - NET_CONNECT(_name, C, _A2) \ - NET_CONNECT(_name, D, _A3) \ - NET_CONNECT(_name, LTQ, _LTQ) \ - NET_CONNECT(_name, BIQ, _BIQ) \ - NET_CONNECT(_name, RBIQ, _RBIQ) - -#define TTL_7448_DIP(_name) \ - NET_REGISTER_DEV(TTL_7448_DIP, _name) +#define TTL_7448(name, cA0, cA1, cA2, cA3, cLTQ, cBIQ, cRBIQ) \ + NET_REGISTER_DEV(TTL_7448, name) \ + NET_CONNECT(name, A, cA0) \ + NET_CONNECT(name, B, cA1) \ + NET_CONNECT(name, C, cA2) \ + NET_CONNECT(name, D, cA3) \ + NET_CONNECT(name, LTQ, cLTQ) \ + NET_CONNECT(name, BIQ, cBIQ) \ + NET_CONNECT(name, RBIQ, cRBIQ) + +#define TTL_7448_DIP(name) \ + NET_REGISTER_DEV(TTL_7448_DIP, name) NETLIB_NAMESPACE_DEVICES_START() diff --git a/src/lib/netlist/devices/nld_7450.h b/src/lib/netlist/devices/nld_7450.h index 0b10b35e1ed..ded207bc070 100644 --- a/src/lib/netlist/devices/nld_7450.h +++ b/src/lib/netlist/devices/nld_7450.h @@ -26,15 +26,15 @@ #include "nl_base.h" -#define TTL_7450_ANDORINVERT(_name, _I1, _I2, _I3, _I4) \ - NET_REGISTER_DEV(TTL_7450_ANDORINVERT, _name) \ - NET_CONNECT(_name, A, _I1) \ - NET_CONNECT(_name, B, _I2) \ - NET_CONNECT(_name, C, _I3) \ - NET_CONNECT(_name, D, _I4) +#define TTL_7450_ANDORINVERT(name, cI1, cI2, cI3, cI4) \ + NET_REGISTER_DEV(TTL_7450_ANDORINVERT, name) \ + NET_CONNECT(name, A, cI1) \ + NET_CONNECT(name, B, cI2) \ + NET_CONNECT(name, C, cI3) \ + NET_CONNECT(name, D, cI4) -#define TTL_7450_DIP(_name) \ - NET_REGISTER_DEV(TTL_7450_DIP, _name) +#define TTL_7450_DIP(name) \ + NET_REGISTER_DEV(TTL_7450_DIP, name) NETLIB_NAMESPACE_DEVICES_START() diff --git a/src/lib/netlist/devices/nld_7474.h b/src/lib/netlist/devices/nld_7474.h index 1de0838b9c9..918280f9966 100644 --- a/src/lib/netlist/devices/nld_7474.h +++ b/src/lib/netlist/devices/nld_7474.h @@ -44,15 +44,15 @@ #include "nl_base.h" -#define TTL_7474(_name, _CLK, _D, _CLRQ, _PREQ) \ - NET_REGISTER_DEV(TTL_7474, _name) \ - NET_CONNECT(_name, CLK, _CLK) \ - NET_CONNECT(_name, D, _D) \ - NET_CONNECT(_name, CLRQ, _CLRQ) \ - NET_CONNECT(_name, PREQ, _PREQ) - -#define TTL_7474_DIP(_name) \ - NET_REGISTER_DEV(TTL_7474_DIP, _name) +#define TTL_7474(name, cCLK, cD, cCLRQ, cPREQ) \ + NET_REGISTER_DEV(TTL_7474, name) \ + NET_CONNECT(name, CLK, cCLK) \ + NET_CONNECT(name, D, cD) \ + NET_CONNECT(name, CLRQ, cCLRQ) \ + NET_CONNECT(name, PREQ, cPREQ) + +#define TTL_7474_DIP(name) \ + NET_REGISTER_DEV(TTL_7474_DIP, name) NETLIB_NAMESPACE_DEVICES_START() diff --git a/src/lib/netlist/devices/nld_7483.h b/src/lib/netlist/devices/nld_7483.h index 34ddc8f2c70..a66876844e6 100644 --- a/src/lib/netlist/devices/nld_7483.h +++ b/src/lib/netlist/devices/nld_7483.h @@ -29,20 +29,20 @@ #include "nl_base.h" -#define TTL_7483(_name, _A1, _A2, _A3, _A4, _B1, _B2, _B3, _B4, _CI) \ - NET_REGISTER_DEV(TTL_7483, _name) \ - NET_CONNECT(_name, A1, _A1) \ - NET_CONNECT(_name, A2, _A2) \ - NET_CONNECT(_name, A3, _A3) \ - NET_CONNECT(_name, A4, _A4) \ - NET_CONNECT(_name, B1, _B1) \ - NET_CONNECT(_name, B2, _B2) \ - NET_CONNECT(_name, B3, _B3) \ - NET_CONNECT(_name, B4, _B4) \ - NET_CONNECT(_name, C0, _CI) - -#define TTL_7483_DIP(_name) \ - NET_REGISTER_DEV(TTL_7483_DIP, _name) +#define TTL_7483(name, cA1, cA2, cA3, cA4, cB1, cB2, cB3, cB4, cCI) \ + NET_REGISTER_DEV(TTL_7483, name) \ + NET_CONNECT(name, A1, cA1) \ + NET_CONNECT(name, A2, cA2) \ + NET_CONNECT(name, A3, cA3) \ + NET_CONNECT(name, A4, cA4) \ + NET_CONNECT(name, B1, cB1) \ + NET_CONNECT(name, B2, cB2) \ + NET_CONNECT(name, B3, cB3) \ + NET_CONNECT(name, B4, cB4) \ + NET_CONNECT(name, C0, cCI) + +#define TTL_7483_DIP(name) \ + NET_REGISTER_DEV(TTL_7483_DIP, name) NETLIB_NAMESPACE_DEVICES_START() diff --git a/src/lib/netlist/devices/nld_7490.h b/src/lib/netlist/devices/nld_7490.h index e85b06aa1a5..c4a92f1b364 100644 --- a/src/lib/netlist/devices/nld_7490.h +++ b/src/lib/netlist/devices/nld_7490.h @@ -57,17 +57,17 @@ #include "nl_base.h" -#define TTL_7490(_name, _A, _B, _R1, _R2, _R91, _R92) \ - NET_REGISTER_DEV(TTL_7490, _name) \ - NET_CONNECT(_name, A, _A) \ - NET_CONNECT(_name, B, _B) \ - NET_CONNECT(_name, R1, _R1) \ - NET_CONNECT(_name, R2, _R2) \ - NET_CONNECT(_name, R91, _R91) \ - NET_CONNECT(_name, R92, _R92) - -#define TTL_7490_DIP(_name) \ - NET_REGISTER_DEV(TTL_7490_DIP, _name) +#define TTL_7490(name, cA, cB, cR1, cR2, cR91, cR92) \ + NET_REGISTER_DEV(TTL_7490, name) \ + NET_CONNECT(name, A, cA) \ + NET_CONNECT(name, B, cB) \ + NET_CONNECT(name, R1, cR1) \ + NET_CONNECT(name, R2, cR2) \ + NET_CONNECT(name, R91, cR91) \ + NET_CONNECT(name, R92, cR92) + +#define TTL_7490_DIP(name) \ + NET_REGISTER_DEV(TTL_7490_DIP, name) NETLIB_NAMESPACE_DEVICES_START() diff --git a/src/lib/netlist/devices/nld_7493.h b/src/lib/netlist/devices/nld_7493.h index 2fa8127e547..778e2358b2d 100644 --- a/src/lib/netlist/devices/nld_7493.h +++ b/src/lib/netlist/devices/nld_7493.h @@ -59,15 +59,15 @@ #include "nl_base.h" -#define TTL_7493(_name, _CLKA, _CLKB, _R1, _R2) \ - NET_REGISTER_DEV(TTL_7493, _name) \ - NET_CONNECT(_name, CLKA, _CLKA) \ - NET_CONNECT(_name, CLKB, _CLKB) \ - NET_CONNECT(_name, R1, _R1) \ - NET_CONNECT(_name, R2, _R2) - -#define TTL_7493_DIP(_name) \ - NET_REGISTER_DEV(TTL_7493_DIP, _name) +#define TTL_7493(name, cCLKA, cCLKB, cR1, cR2) \ + NET_REGISTER_DEV(TTL_7493, name) \ + NET_CONNECT(name, CLKA, cCLKA) \ + NET_CONNECT(name, CLKB, cCLKB) \ + NET_CONNECT(name, R1, cR1) \ + NET_CONNECT(name, R2, cR2) + +#define TTL_7493_DIP(name) \ + NET_REGISTER_DEV(TTL_7493_DIP, name) NETLIB_NAMESPACE_DEVICES_START() diff --git a/src/lib/netlist/devices/nld_74ls629.h b/src/lib/netlist/devices/nld_74ls629.h index f2aa6e8a6d8..f0805f03681 100644 --- a/src/lib/netlist/devices/nld_74ls629.h +++ b/src/lib/netlist/devices/nld_74ls629.h @@ -31,14 +31,14 @@ #include "nl_base.h" #include "analog/nld_twoterm.h" -#define SN74LS629(_name, _cap) \ - NET_REGISTER_DEV(SN74LS629, _name) \ - NETDEV_PARAMI(_name, CAP, _cap) - -#define SN74LS629_DIP(_name, _cap1, _cap2) \ - NET_REGISTER_DEV(SN74LS629_DIP, _name) \ - NETDEV_PARAMI(_name, 1.CAP, _cap1) \ - NETDEV_PARAMI(_name, 2.CAP, _cap2) +#define SN74LS629(name, p_cap) \ + NET_REGISTER_DEV(SN74LS629, name) \ + NETDEV_PARAMI(name, CAP, p_cap) + +#define SN74LS629_DIP(name, p_cap1, p_cap2) \ + NET_REGISTER_DEV(SN74LS629_DIP, name) \ + NETDEV_PARAMI(name, 1.CAP, p_cap1) \ + NETDEV_PARAMI(name, 2.CAP, p_cap2) NETLIB_NAMESPACE_DEVICES_START() diff --git a/src/lib/netlist/devices/nld_82S16.h b/src/lib/netlist/devices/nld_82S16.h index 33bc87fa650..769e2324964 100644 --- a/src/lib/netlist/devices/nld_82S16.h +++ b/src/lib/netlist/devices/nld_82S16.h @@ -26,10 +26,10 @@ #include "nl_base.h" -#define TTL_82S16(_name) \ - NET_REGISTER_DEV(TTL_82S16, _name) -#define TTL_82S16_DIP(_name) \ - NET_REGISTER_DEV(TTL_82S16_DIP, _name) +#define TTL_82S16(name) \ + NET_REGISTER_DEV(TTL_82S16, name) +#define TTL_82S16_DIP(name) \ + NET_REGISTER_DEV(TTL_82S16_DIP, name) NETLIB_NAMESPACE_DEVICES_START() diff --git a/src/lib/netlist/devices/nld_9310.h b/src/lib/netlist/devices/nld_9310.h index 935044c8180..3c4fbb22847 100644 --- a/src/lib/netlist/devices/nld_9310.h +++ b/src/lib/netlist/devices/nld_9310.h @@ -47,20 +47,20 @@ #include "nl_base.h" -#define TTL_9310(_name, _CLK, _ENP, _ENT, _CLRQ, _LOADQ, _A, _B, _C, _D) \ - NET_REGISTER_DEV(TTL_9310, _name) \ - NET_CONNECT(_name, CLK, _CLK) \ - NET_CONNECT(_name, ENP, _ENP) \ - NET_CONNECT(_name, ENT, _ENT) \ - NET_CONNECT(_name, CLRQ, _CLRQ) \ - NET_CONNECT(_name, LOADQ,_LOADQ) \ - NET_CONNECT(_name, A, _A) \ - NET_CONNECT(_name, B, _B) \ - NET_CONNECT(_name, C, _C) \ - NET_CONNECT(_name, D, _D) - -#define TTL_9310_DIP(_name) \ - NET_REGISTER_DEV(TTL_9310_DIP, _name) +#define TTL_9310(name, cCLK, cENP, cENT, cCLRQ, cLOADQ, cA, cB, cC, cD) \ + NET_REGISTER_DEV(TTL_9310, name) \ + NET_CONNECT(name, CLK, cCLK) \ + NET_CONNECT(name, ENP, cENP) \ + NET_CONNECT(name, ENT, cENT) \ + NET_CONNECT(name, CLRQ, cCLRQ) \ + NET_CONNECT(name, LOADQ,_LOADQ) \ + NET_CONNECT(name, A, cA) \ + NET_CONNECT(name, B, cB) \ + NET_CONNECT(name, C, cC) \ + NET_CONNECT(name, D, cD) + +#define TTL_9310_DIP(name) \ + NET_REGISTER_DEV(TTL_9310_DIP, name) NETLIB_NAMESPACE_DEVICES_START() diff --git a/src/lib/netlist/devices/nld_9312.h b/src/lib/netlist/devices/nld_9312.h index a48f13900d2..37a2e3afcb8 100644 --- a/src/lib/netlist/devices/nld_9312.h +++ b/src/lib/netlist/devices/nld_9312.h @@ -39,11 +39,11 @@ #include "nld_truthtable.h" -#define TTL_9312(_name) \ - NET_REGISTER_DEV(TTL_9312, _name) +#define TTL_9312(name) \ + NET_REGISTER_DEV(TTL_9312, name) -#define TTL_9312_DIP(_name) \ - NET_REGISTER_DEV(TTL_9312_DIP, _name) +#define TTL_9312_DIP(name) \ + NET_REGISTER_DEV(TTL_9312_DIP, name) NETLIB_NAMESPACE_DEVICES_START() diff --git a/src/lib/netlist/devices/nld_9316.h b/src/lib/netlist/devices/nld_9316.h index b913095e3eb..82bd008b64c 100644 --- a/src/lib/netlist/devices/nld_9316.h +++ b/src/lib/netlist/devices/nld_9316.h @@ -51,20 +51,20 @@ #include "nl_base.h" -#define TTL_9316(_name, _CLK, _ENP, _ENT, _CLRQ, _LOADQ, _A, _B, _C, _D) \ - NET_REGISTER_DEV(TTL_9316, _name) \ - NET_CONNECT(_name, CLK, _CLK) \ - NET_CONNECT(_name, ENP, _ENP) \ - NET_CONNECT(_name, ENT, _ENT) \ - NET_CONNECT(_name, CLRQ, _CLRQ) \ - NET_CONNECT(_name, LOADQ,_LOADQ) \ - NET_CONNECT(_name, A, _A) \ - NET_CONNECT(_name, B, _B) \ - NET_CONNECT(_name, C, _C) \ - NET_CONNECT(_name, D, _D) - -#define TTL_9316_DIP(_name) \ - NET_REGISTER_DEV(TTL_9316_DIP, _name) +#define TTL_9316(name, cCLK, cENP, cENT, cCLRQ, cLOADQ, cA, cB, cC, cD) \ + NET_REGISTER_DEV(TTL_9316, name) \ + NET_CONNECT(name, CLK, cCLK) \ + NET_CONNECT(name, ENP, cENP) \ + NET_CONNECT(name, ENT, cENT) \ + NET_CONNECT(name, CLRQ, cCLRQ) \ + NET_CONNECT(name, LOADQ,_LOADQ) \ + NET_CONNECT(name, A, cA) \ + NET_CONNECT(name, B, cB) \ + NET_CONNECT(name, C, cC) \ + NET_CONNECT(name, D, cD) + +#define TTL_9316_DIP(name) \ + NET_REGISTER_DEV(TTL_9316_DIP, name) NETLIB_NAMESPACE_DEVICES_START() diff --git a/src/lib/netlist/devices/nld_legacy.h b/src/lib/netlist/devices/nld_legacy.h index 5e7410254e3..f4fdd84ca61 100644 --- a/src/lib/netlist/devices/nld_legacy.h +++ b/src/lib/netlist/devices/nld_legacy.h @@ -21,11 +21,11 @@ NETLIB_NAMESPACE_DEVICES_START() // Macros // ---------------------------------------------------------------------------------------- -#define NETDEV_RSFF(_name) \ - NET_REGISTER_DEV(NETDEV_RSFF, _name) +#define NETDEV_RSFF(name) \ + NET_REGISTER_DEV(NETDEV_RSFF, name) -#define NETDEV_DELAY(_name) \ - NET_REGISTER_DEV(NETDEV_DELAY, _name) +#define NETDEV_DELAY(name) \ + NET_REGISTER_DEV(NETDEV_DELAY, name) // ---------------------------------------------------------------------------------------- // Devices ... diff --git a/src/lib/netlist/devices/nld_log.cpp b/src/lib/netlist/devices/nld_log.cpp index 8e57f1313cb..501b6e862e5 100644 --- a/src/lib/netlist/devices/nld_log.cpp +++ b/src/lib/netlist/devices/nld_log.cpp @@ -15,7 +15,7 @@ NETLIB_NAMESPACE_DEVICES_START() NETLIB_UPDATE(log) { /* use pstring::sprintf, it is a LOT faster */ - m_strm->writeline(pfmt("{1} {2}").e(netlist().time().as_double(),".9").e((nl_double) INPANALOG(m_I))); + m_strm->writeline(plib::pfmt("{1} {2}").e(netlist().time().as_double(),".9").e((nl_double) INPANALOG(m_I))); } NETLIB_NAME(log)::~NETLIB_NAME(log)() @@ -25,7 +25,7 @@ NETLIB_NAME(log)::~NETLIB_NAME(log)() NETLIB_UPDATE(logD) { - m_strm->writeline(pfmt("{1} {2}").e(netlist().time().as_double(),".9").e((nl_double) (INPANALOG(m_I) - INPANALOG(m_I2)))); + m_strm->writeline(plib::pfmt("{1} {2}").e(netlist().time().as_double(),".9").e((nl_double) (INPANALOG(m_I) - INPANALOG(m_I2)))); } // FIXME: Implement wav later, this must be clock triggered device where the input to be written diff --git a/src/lib/netlist/devices/nld_log.h b/src/lib/netlist/devices/nld_log.h index c2e05784913..79ef4e53ae6 100644 --- a/src/lib/netlist/devices/nld_log.h +++ b/src/lib/netlist/devices/nld_log.h @@ -23,14 +23,14 @@ #include "plib/pstream.h" #include "plib/pfmtlog.h" -#define LOG(_name, _I) \ - NET_REGISTER_DEV(??PG, _name) \ - NET_CONNECT(_name, I, _I) +#define LOG(name, cI) \ + NET_REGISTER_DEV(??PG, name) \ + NET_CONNECT(name, I, cI) -#define LOGD(_name, _I, _I2) \ - NET_REGISTER_DEV(LOGD, _name) \ - NET_CONNECT(_name, I, _I) \ - NET_CONNECT(_name, I2, _I2) +#define LOGD(name, cI, cI2) \ + NET_REGISTER_DEV(LOGD, name) \ + NET_CONNECT(name, I, cI) \ + NET_CONNECT(name, I2, cI2) NETLIB_NAMESPACE_DEVICES_START() @@ -41,15 +41,15 @@ NETLIB_OBJECT(log) { enregister("I", m_I); - pstring filename = pfmt("{1}.log")(this->name()); - m_strm = pmake_unique<pofilestream>(filename); + pstring filename = plib::pfmt("{1}.log")(this->name()); + m_strm = plib::pmake_unique<plib::pofilestream>(filename); } NETLIB_DESTRUCTOR(log); NETLIB_UPDATEI(); NETLIB_RESETI() { } protected: analog_input_t m_I; - std::unique_ptr<pofilestream> m_strm; + std::unique_ptr<plib::pofilestream> m_strm; }; NETLIB_OBJECT_DERIVED(logD, log) diff --git a/src/lib/netlist/devices/nld_mm5837.h b/src/lib/netlist/devices/nld_mm5837.h index b4ee4cc231e..d433b057d57 100644 --- a/src/lib/netlist/devices/nld_mm5837.h +++ b/src/lib/netlist/devices/nld_mm5837.h @@ -22,8 +22,8 @@ #include "nl_base.h" #include "analog/nld_twoterm.h" -#define MM5837_DIP(_name) \ - NET_REGISTER_DEV(MM5837_DIP, _name) +#define MM5837_DIP(name) \ + NET_REGISTER_DEV(MM5837_DIP, name) NETLIB_NAMESPACE_DEVICES_START() diff --git a/src/lib/netlist/devices/nld_ne555.h b/src/lib/netlist/devices/nld_ne555.h index 9963b83546e..cead3ba8cd5 100644 --- a/src/lib/netlist/devices/nld_ne555.h +++ b/src/lib/netlist/devices/nld_ne555.h @@ -22,8 +22,8 @@ #include "nl_base.h" #include "analog/nld_twoterm.h" -#define NE555(_name) \ - NET_REGISTER_DEV(NE555, _name) +#define NE555(name) \ + NET_REGISTER_DEV(NE555, name) NETLIB_NAMESPACE_DEVICES_START() @@ -77,8 +77,8 @@ private: }; -#define NE555_DIP(_name) \ - NET_REGISTER_DEV(NE555_DIP, _name) +#define NE555_DIP(name) \ + NET_REGISTER_DEV(NE555_DIP, name) NETLIB_OBJECT_DERIVED(NE555_dip, NE555) { diff --git a/src/lib/netlist/devices/nld_r2r_dac.h b/src/lib/netlist/devices/nld_r2r_dac.h index 6e7ec44d604..89ee4c5cbf4 100644 --- a/src/lib/netlist/devices/nld_r2r_dac.h +++ b/src/lib/netlist/devices/nld_r2r_dac.h @@ -49,11 +49,11 @@ #include "nl_base.h" #include "analog/nld_twoterm.h" -#define R2R_DAC(_name, _VIN, _R, _N) \ - NET_REGISTER_DEV(R2R_DAC, _name) \ - NETDEV_PARAMI(_name, VIN, _VIN) \ - NETDEV_PARAMI(_name, R, _R) \ - NETDEV_PARAMI(_name, N, _N) +#define R2R_DAC(name, p_VIN, p_R, p_N) \ + NET_REGISTER_DEV(R2R_DAC, name) \ + NETDEV_PARAMI(name, VIN, p_VIN) \ + NETDEV_PARAMI(name, R, p_R) \ + NETDEV_PARAMI(name, N, p_N) NETLIB_NAMESPACE_DEVICES_START() diff --git a/src/lib/netlist/devices/nld_system.h b/src/lib/netlist/devices/nld_system.h index 4ca2a8cf84e..d7e340c421e 100644 --- a/src/lib/netlist/devices/nld_system.h +++ b/src/lib/netlist/devices/nld_system.h @@ -18,62 +18,62 @@ // Macros // ----------------------------------------------------------------------------- -#define TTL_INPUT(_name, _v) \ - NET_REGISTER_DEV(TTL_INPUT, _name) \ - PARAM(_name.IN, _v) +#define TTL_INPUT(name, v) \ + NET_REGISTER_DEV(TTL_INPUT, name) \ + PARAM(name.IN, v) -#define LOGIC_INPUT(_name, _v, _family) \ - NET_REGISTER_DEV(LOGIC_INPUT, _name) \ - PARAM(_name.IN, _v) \ - PARAM(_name.FAMILY, _family) +#define LOGIC_INPUT(name, v, family) \ + NET_REGISTER_DEV(LOGIC_INPUT, name) \ + PARAM(name.IN, v) \ + PARAM(name.FAMILY, family) -#define ANALOG_INPUT(_name, _v) \ - NET_REGISTER_DEV(ANALOG_INPUT, _name) \ - PARAM(_name.IN, _v) +#define ANALOG_INPUT(name, v) \ + NET_REGISTER_DEV(ANALOG_INPUT, name) \ + PARAM(name.IN, v) -#define MAINCLOCK(_name, _freq) \ - NET_REGISTER_DEV(MAINCLOCK, _name) \ - PARAM(_name.FREQ, _freq) +#define MAINCLOCK(name, freq) \ + NET_REGISTER_DEV(MAINCLOCK, name) \ + PARAM(name.FREQ, freq) -#define CLOCK(_name, _freq) \ - NET_REGISTER_DEV(CLOCK, _name) \ - PARAM(_name.FREQ, _freq) +#define CLOCK(name, freq) \ + NET_REGISTER_DEV(CLOCK, name) \ + PARAM(name.FREQ, freq) -#define EXTCLOCK(_name, _freq, _pattern) \ - NET_REGISTER_DEV(EXTCLOCK, _name) \ - PARAM(_name.FREQ, _freq) \ - PARAM(_name.PATTERN, _pattern) +#define EXTCLOCK(name, freq, pattern) \ + NET_REGISTER_DEV(EXTCLOCK, name) \ + PARAM(name.FREQ, freq) \ + PARAM(name.PATTERN, pattern) #define GNDA() \ NET_REGISTER_DEV(GNDA, GND) -#define DUMMY_INPUT(_name) \ - NET_REGISTER_DEV(DUMMY_INPUT, _name) +#define DUMMY_INPUT(name) \ + NET_REGISTER_DEV(DUMMY_INPUT, name) //FIXME: Usage discouraged, use OPTIMIZE_FRONTIER instead -#define FRONTIER_DEV(_name, _IN, _G, _OUT) \ - NET_REGISTER_DEV(FRONTIER_DEV, _name) \ - NET_C(_IN, _name.I) \ - NET_C(_G, _name.G) \ - NET_C(_OUT, _name.Q) +#define FRONTIER_DEV(name, cIN, cG, cOUT) \ + NET_REGISTER_DEV(FRONTIER_DEV, name) \ + NET_C(cIN, name.I) \ + NET_C(cG, name.G) \ + NET_C(cOUT, name.Q) -#define OPTIMIZE_FRONTIER(_attach, _r_in, _r_out) \ - setup.register_frontier(# _attach, _r_in, _r_out); +#define OPTIMIZE_FRONTIER(attach, r_in, r_out) \ + setup.register_frontier(# attach, r_in, r_out); -#define RES_SWITCH(_name, _IN, _P1, _P2) \ - NET_REGISTER_DEV(RES_SWITCH, _name) \ - NET_C(_IN, _name.I) \ - NET_C(_P1, _name.1) \ - NET_C(_P2, _name.2) +#define RES_SWITCH(name, cIN, cP1, cP2) \ + NET_REGISTER_DEV(RES_SWITCH, name) \ + NET_C(cIN, name.I) \ + NET_C(cP1, name.1) \ + NET_C(cP2, name.2) /* Default device to hold netlist parameters */ -#define PARAMETERS(_name) \ - NET_REGISTER_DEV(PARAMETERS, _name) +#define PARAMETERS(name) \ + NET_REGISTER_DEV(PARAMETERS, name) -#define AFUNC(_name, _N, _F) \ - NET_REGISTER_DEV(AFUNC, _name) \ - PARAM(_name.N, _N) \ - PARAM(_name.FUNC, _F) +#define AFUNC(name, p_N, p_F) \ + NET_REGISTER_DEV(AFUNC, name) \ + PARAM(name.N, p_N) \ + PARAM(name.FUNC, p_F) NETLIB_NAMESPACE_DEVICES_START() @@ -183,7 +183,7 @@ NETLIB_OBJECT(extclock) connect_late(m_feedback, m_Q); { netlist_time base = netlist_time::from_hz(m_freq.Value()*2); - pstring_vector_t pat(m_pattern.Value(),","); + plib::pstring_vector_t pat(m_pattern.Value(),","); m_off = netlist_time::from_double(m_offset.Value()); int pati[256]; @@ -369,9 +369,9 @@ NETLIB_OBJECT(function) enregister("Q", m_Q); for (int i=0; i < m_N; i++) - enregister(pfmt("A{1}")(i), m_I[i]); + enregister(plib::pfmt("A{1}")(i), m_I[i]); - pstring_vector_t cmds(m_func.Value(), " "); + plib::pstring_vector_t cmds(m_func.Value(), " "); m_precompiled.clear(); for (std::size_t i=0; i < cmds.size(); i++) @@ -434,7 +434,7 @@ private: analog_output_t m_Q; analog_input_t m_I[10]; - pvector_t<rpn_inst> m_precompiled; + plib::pvector_t<rpn_inst> m_precompiled; }; // ----------------------------------------------------------------------------- @@ -617,23 +617,23 @@ public: class wrapper : public device_t { public: - wrapper(const pstring &dev_name, netlist_t &anetlist, const pstring &name) - : device_t(anetlist, name), m_dev_name(dev_name) + wrapper(const pstring &devname, netlist_t &anetlist, const pstring &name) + : device_t(anetlist, name), m_devname(devname) { anetlist.setup().namespace_push(name); - anetlist.setup().include(m_dev_name); + anetlist.setup().include(m_devname); anetlist.setup().namespace_pop(); } protected: NETLIB_RESETI() { } NETLIB_UPDATEI() { } - pstring m_dev_name; + pstring m_devname; }; - powned_ptr<device_t> Create(netlist_t &anetlist, const pstring &name) override + plib::powned_ptr<device_t> Create(netlist_t &anetlist, const pstring &name) override { - return powned_ptr<device_t>::Create<wrapper>(this->name(), anetlist, name); + return plib::powned_ptr<device_t>::Create<wrapper>(this->name(), anetlist, name); } private: diff --git a/src/lib/netlist/devices/nld_truthtable.cpp b/src/lib/netlist/devices/nld_truthtable.cpp index 6440ad0a2db..bd37a80d4f4 100644 --- a/src/lib/netlist/devices/nld_truthtable.cpp +++ b/src/lib/netlist/devices/nld_truthtable.cpp @@ -64,7 +64,7 @@ UINT32 truthtable_desc_t::get_ignored_extended(UINT32 i) * may change the output */ UINT32 bits = (1<<count_bits(nign)); - parray_t<int> t(bits); + plib::array_t<int> t(bits); for (UINT32 j=1; j<bits; j++) { @@ -99,8 +99,8 @@ UINT32 truthtable_desc_t::get_ignored_extended(UINT32 i) // desc // ---------------------------------------------------------------------------------------- -void truthtable_desc_t::help(unsigned cur, pstring_vector_t list, - UINT64 state,UINT16 val, parray_t<UINT8> &timing_index) +void truthtable_desc_t::help(unsigned cur, plib::pstring_vector_t list, + UINT64 state,UINT16 val, plib::array_t<UINT8> &timing_index) { pstring elem = list[cur].trim(); int start = 0; @@ -135,7 +135,7 @@ void truthtable_desc_t::help(unsigned cur, pstring_vector_t list, { // cutoff previous inputs and outputs for ignore if (m_outs[nstate] != ~0U && m_outs[nstate] != val) - fatalerror_e(pfmt("Error in truthtable: State {1} already set, {2} != {3}\n") + fatalerror_e(plib::pfmt("Error in truthtable: State {1} already set, {2} != {3}\n") .x(nstate,"04")(m_outs[nstate])(val) ); m_outs[nstate] = val; for (unsigned j=0; j<m_NO; j++) @@ -144,7 +144,7 @@ void truthtable_desc_t::help(unsigned cur, pstring_vector_t list, } } -void truthtable_desc_t::setup(const pstring_vector_t &truthtable, UINT32 disabled_ignore) +void truthtable_desc_t::setup(const plib::pstring_vector_t &truthtable, UINT32 disabled_ignore) { unsigned line = 0; @@ -164,18 +164,18 @@ void truthtable_desc_t::setup(const pstring_vector_t &truthtable, UINT32 disable while (!ttline.equals("")) { - pstring_vector_t io(ttline,"|"); + plib::pstring_vector_t io(ttline,"|"); // checks nl_assert_always(io.size() == 3, "io.count mismatch"); - pstring_vector_t inout(io[0], ","); + plib::pstring_vector_t inout(io[0], ","); nl_assert_always(inout.size() == m_num_bits, "number of bits not matching"); - pstring_vector_t out(io[1], ","); + plib::pstring_vector_t out(io[1], ","); nl_assert_always(out.size() == m_NO, "output count not matching"); - pstring_vector_t times(io[2], ","); + plib::pstring_vector_t times(io[2], ","); nl_assert_always(times.size() == m_NO, "timing count not matching"); UINT16 val = 0; - parray_t<UINT8> tindex(m_NO); + plib::array_t<UINT8> tindex(m_NO); for (unsigned j=0; j<m_NO; j++) { @@ -201,7 +201,7 @@ void truthtable_desc_t::setup(const pstring_vector_t &truthtable, UINT32 disable } // determine ignore - parray_t<UINT32> ign(m_size); + plib::array_t<UINT32> ign(m_size); for (UINT32 j=0; j < m_size; j++) ign[j] = ~0U; @@ -234,22 +234,22 @@ void truthtable_desc_t::setup(const pstring_vector_t &truthtable, UINT32 disable for (UINT32 i=0; i<m_size; i++) { if (m_outs[i] == ~0U) - throw fatalerror_e(pfmt("truthtable: found element not set {1}\n").x(i) ); + throw fatalerror_e(plib::pfmt("truthtable: found element not set {1}\n").x(i) ); m_outs[i] |= ((ign[i] & ~disabled_ignore) << m_NO); } *m_initialized = true; } -#define ENTRYX(_n,_m,_h) case (_n * 1000 + _m * 10 + _h): \ - { using xtype = netlist_factory_truthtable_t<_n,_m,_h>; \ - return powned_ptr<netlist_base_factory_truthtable_t>::Create<xtype>(name,classname,def_param); } break +#define ENTRYX(n, m, h) case (n * 1000 + m * 10 + h): \ + { using xtype = netlist_factory_truthtable_t<n, m, h>; \ + return plib::powned_ptr<netlist_base_factory_truthtable_t>::Create<xtype>(name,classname,def_param); } break -#define ENTRYY(_n,_m) ENTRYX(_n,_m,0); ENTRYX(_n,_m,1) +#define ENTRYY(n, m) ENTRYX(n, m, 0); ENTRYX(n, m, 1) -#define ENTRY(_n) ENTRYY(_n, 1); ENTRYY(_n, 2); ENTRYY(_n, 3); ENTRYY(_n, 4); ENTRYY(_n, 5); ENTRYY(_n, 6) +#define ENTRY(n) ENTRYY(n, 1); ENTRYY(n, 2); ENTRYY(n, 3); ENTRYY(n, 4); ENTRYY(n, 5); ENTRYY(n, 6) -powned_ptr<netlist_base_factory_truthtable_t> nl_tt_factory_create(const unsigned ni, const unsigned no, +plib::powned_ptr<netlist_base_factory_truthtable_t> nl_tt_factory_create(const unsigned ni, const unsigned no, const unsigned has_state, const pstring &name, const pstring &classname, const pstring &def_param) @@ -267,7 +267,7 @@ powned_ptr<netlist_base_factory_truthtable_t> nl_tt_factory_create(const unsigne ENTRY(9); ENTRY(10); default: - pstring msg = pfmt("unable to create truthtable<{1},{2},{3}>")(ni)(no)(has_state); + pstring msg = plib::pfmt("unable to create truthtable<{1},{2},{3}>")(ni)(no)(has_state); nl_assert_always(false, msg); } //return nullptr; diff --git a/src/lib/netlist/devices/nld_truthtable.h b/src/lib/netlist/devices/nld_truthtable.h index e9270db2faa..8f447420490 100644 --- a/src/lib/netlist/devices/nld_truthtable.h +++ b/src/lib/netlist/devices/nld_truthtable.h @@ -13,31 +13,31 @@ #include "nl_base.h" #include "nl_factory.h" -#define NETLIB_TRUTHTABLE(_name, _nIN, _nOUT, _state) \ - class NETLIB_NAME(_name) : public nld_truthtable_t<_nIN, _nOUT, _state> \ - { \ - public: \ - template <class C> \ - NETLIB_NAME(_name)(C &owner, const pstring &name) \ - : nld_truthtable_t<_nIN, _nOUT, _state>(owner, name, nullptr, &m_ttbl, m_desc) { } \ - private: \ - static truthtable_t m_ttbl; \ - static const char *m_desc[]; \ +#define NETLIB_TRUTHTABLE(cname, nIN, nOUT, state) \ + class NETLIB_NAME(cname) : public nld_truthtable_t<nIN, nOUT, state> \ + { \ + public: \ + template <class C> \ + NETLIB_NAME(cname)(C &owner, const pstring &name) \ + : nld_truthtable_t<nIN, nOUT, state>(owner, name, nullptr, &m_ttbl, m_desc) { } \ + private: \ + static truthtable_t m_ttbl; \ + static const char *m_desc[]; \ } -#define TRUTHTABLE_START(_name, _in, _out, _has_state, _def_params) \ +#define TRUTHTABLE_START(cname, in, out, has_state, def_params) \ { \ - auto ttd = netlist::devices::nl_tt_factory_create(_in, _out, _has_state, \ - # _name, # _name, "+" _def_params); + auto ttd = netlist::devices::nl_tt_factory_create(in, out, has_state, \ + # cname, # cname, "+" def_params); -#define TT_HEAD(_x) \ - ttd->m_desc.push_back(_x); +#define TT_HEAD(x) \ + ttd->m_desc.push_back(x); -#define TT_LINE(_x) \ - ttd->m_desc.push_back(_x); +#define TT_LINE(x) \ + ttd->m_desc.push_back(x); -#define TT_FAMILY(_x) \ - ttd->m_family = setup.family_from_model(_x); +#define TT_FAMILY(x) \ + ttd->m_family = setup.family_from_model(x); #define TRUTHTABLE_END() \ setup.factory().register_device(std::move(ttd)); \ @@ -66,11 +66,11 @@ struct truthtable_desc_t { } - void setup(const pstring_vector_t &desc, UINT32 disabled_ignore); + void setup(const plib::pstring_vector_t &desc, UINT32 disabled_ignore); private: - void help(unsigned cur, pstring_vector_t list, - UINT64 state,UINT16 val, parray_t<UINT8> &timing_index); + void help(unsigned cur, plib::pstring_vector_t list, + UINT64 state,UINT16 val, plib::array_t<UINT8> &timing_index); static unsigned count_bits(UINT32 v); static UINT32 set_bits(UINT32 v, UINT32 b); UINT32 get_ignored_simple(UINT32 i); @@ -133,7 +133,7 @@ public: template <class C> nld_truthtable_t(C &owner, const pstring &name, const logic_family_desc_t *fam, - truthtable_t *ttbl, const pstring_vector_t &desc) + truthtable_t *ttbl, const plib::pstring_vector_t &desc) : device_t(owner, name) , m_fam(*this, fam) , m_last_state(0) @@ -149,12 +149,12 @@ public: { pstring header = m_desc[0]; - pstring_vector_t io(header,"|"); + plib::pstring_vector_t io(header,"|"); // checks nl_assert_always(io.size() == 2, "too many '|'"); - pstring_vector_t inout(io[0], ","); + plib::pstring_vector_t inout(io[0], ","); nl_assert_always(inout.size() == m_num_bits, "bitcount wrong"); - pstring_vector_t out(io[1], ","); + plib::pstring_vector_t out(io[1], ","); nl_assert_always(out.size() == m_NO, "output count wrong"); for (unsigned i=0; i < m_NI; i++) @@ -311,7 +311,7 @@ private: INT32 m_active; truthtable_t *m_ttp; - pstring_vector_t m_desc; + plib::pstring_vector_t m_desc; }; class netlist_base_factory_truthtable_t : public base_factory_t @@ -327,7 +327,7 @@ public: { } - pstring_vector_t m_desc; + plib::pstring_vector_t m_desc; const logic_family_desc_t *m_family; }; @@ -341,16 +341,16 @@ public: const pstring &def_param) : netlist_base_factory_truthtable_t(name, classname, def_param) { } - powned_ptr<device_t> Create(netlist_t &anetlist, const pstring &name) override + plib::powned_ptr<device_t> Create(netlist_t &anetlist, const pstring &name) override { typedef nld_truthtable_t<m_NI, m_NO, has_state> tt_type; - return powned_ptr<device_t>::Create<tt_type>(anetlist, name, m_family, &m_ttbl, m_desc); + return plib::powned_ptr<device_t>::Create<tt_type>(anetlist, name, m_family, &m_ttbl, m_desc); } private: typename nld_truthtable_t<m_NI, m_NO, has_state>::truthtable_t m_ttbl; }; -powned_ptr<netlist_base_factory_truthtable_t> nl_tt_factory_create(const unsigned ni, const unsigned no, +plib::powned_ptr<netlist_base_factory_truthtable_t> nl_tt_factory_create(const unsigned ni, const unsigned no, const unsigned has_state, const pstring &name, const pstring &classname, const pstring &def_param); diff --git a/src/lib/netlist/macro/nlm_cd4xxx.h b/src/lib/netlist/macro/nlm_cd4xxx.h index ebfb58740b2..acc47f45d21 100644 --- a/src/lib/netlist/macro/nlm_cd4xxx.h +++ b/src/lib/netlist/macro/nlm_cd4xxx.h @@ -22,24 +22,24 @@ * Netlist Macros * ---------------------------------------------------------------------------*/ -#define CD4001_NOR(_name) \ - NET_REGISTER_DEV(CD4001_NOR, _name) +#define CD4001_NOR(name) \ + NET_REGISTER_DEV(CD4001_NOR, name) -#define CD4001_DIP(_name) \ - NET_REGISTER_DEV(CD4001_DIP, _name) +#define CD4001_DIP(name) \ + NET_REGISTER_DEV(CD4001_DIP, name) /* ---------------------------------------------------------------------------- * DIP only macros * ---------------------------------------------------------------------------*/ -#define CD4020_DIP(_name) \ - NET_REGISTER_DEV(CD4020_DIP, _name) +#define CD4020_DIP(name) \ + NET_REGISTER_DEV(CD4020_DIP, name) -#define CD4066_DIP(_name) \ - NET_REGISTER_DEV(CD4066_DIP, _name) +#define CD4066_DIP(name) \ + NET_REGISTER_DEV(CD4066_DIP, name) -#define CD4016_DIP(_name) \ - NET_REGISTER_DEV(CD4016_DIP, _name) +#define CD4016_DIP(name) \ + NET_REGISTER_DEV(CD4016_DIP, name) /* ---------------------------------------------------------------------------- * External declarations diff --git a/src/lib/netlist/macro/nlm_opamp.h b/src/lib/netlist/macro/nlm_opamp.h index c0d6a0b158f..f349f11911c 100644 --- a/src/lib/netlist/macro/nlm_opamp.h +++ b/src/lib/netlist/macro/nlm_opamp.h @@ -11,14 +11,14 @@ * Netlist Macros * ---------------------------------------------------------------------------*/ -#define MB3614_DIP(_name) \ - NET_REGISTER_DEV(MB3614_DIP, _name) +#define MB3614_DIP(name) \ + NET_REGISTER_DEV(MB3614_DIP, name) -#define LM324_DIP(_name) \ - NET_REGISTER_DEV(LM324_DIP, _name) +#define LM324_DIP(name) \ + NET_REGISTER_DEV(LM324_DIP, name) -#define LM358_DIP(_name) \ - NET_REGISTER_DEV(LM358_DIP, _name) +#define LM358_DIP(name) \ + NET_REGISTER_DEV(LM358_DIP, name) /* ---------------------------------------------------------------------------- * External declarations diff --git a/src/lib/netlist/macro/nlm_other.h b/src/lib/netlist/macro/nlm_other.h index 76f8dd781d5..bb73d0105d2 100644 --- a/src/lib/netlist/macro/nlm_other.h +++ b/src/lib/netlist/macro/nlm_other.h @@ -11,11 +11,11 @@ * Netlist Macros * ---------------------------------------------------------------------------*/ -#define MC14584B_GATE(_name) \ - NET_REGISTER_DEV(MC14584B_GATE, _name) +#define MC14584B_GATE(name) \ + NET_REGISTER_DEV(MC14584B_GATE, name) -#define MC14584B_DIP(_name) \ - NET_REGISTER_DEV(MC14584B_DIP, _name) +#define MC14584B_DIP(name) \ + NET_REGISTER_DEV(MC14584B_DIP, name) /* ---------------------------------------------------------------------------- diff --git a/src/lib/netlist/macro/nlm_ttl74xx.cpp b/src/lib/netlist/macro/nlm_ttl74xx.cpp index fc589231b19..25bf7573c03 100644 --- a/src/lib/netlist/macro/nlm_ttl74xx.cpp +++ b/src/lib/netlist/macro/nlm_ttl74xx.cpp @@ -9,7 +9,7 @@ /* * DM7400: Quad 2-Input NAND Gates * - * __ + * _ * Y = AB * +---+---++---+ * | A | B || Y | @@ -85,7 +85,7 @@ NETLIST_END() /* * DM7404: Hex Inverting Gates - * _ + * * Y = A * +---++---+ * | A || Y | @@ -162,7 +162,7 @@ NETLIST_END() /* * DM7410: Triple 3-Input NAND Gates - * ___ + * __ * Y = ABC * +---+---+---++---+ * | A | B | C || Y | @@ -266,7 +266,7 @@ NETLIST_END() /* * DM7420: Dual 4-Input NAND Gates * - * ____ + * ___ * Y = ABCD * +---+---+---+---++---+ * | A | B | C | D || Y | @@ -304,7 +304,7 @@ NETLIST_END() /* * DM7425: Dual 4-Input NOR Gates * - * _______ + * ______ * Y = A+B+C+D * +---+---+---+---+---++---+ * | A | B | C | D | X || Y | @@ -346,7 +346,7 @@ NETLIST_END() /* * DM7427: Triple 3-Input NOR Gates * - * _____ + * ____ * Y = A+B+C * +---+---+---++---+ * | A | B | C || Y | @@ -384,7 +384,7 @@ NETLIST_END() /* * DM7430: 8-Input NAND Gate * - * ________ + * _______ * Y = ABCDEFGH * +---+---+---+---+---+---+---+---++---+ * | A | B | C | D | E | F | G | H || Y | @@ -424,7 +424,7 @@ NETLIST_END() /* * DM7432: Quad 2-Input OR Gates * - * ___ + * __ * Y = A+B * +---+---++---+ * | A | B || Y | @@ -464,7 +464,7 @@ NETLIST_END() /* * DM7437: Quad 2-Input NAND Gates * - * __ + * _ * Y = AB * +---+---++---+ * | A | B || Y | diff --git a/src/lib/netlist/macro/nlm_ttl74xx.h b/src/lib/netlist/macro/nlm_ttl74xx.h index 541a9932fb5..2a29334487e 100644 --- a/src/lib/netlist/macro/nlm_ttl74xx.h +++ b/src/lib/netlist/macro/nlm_ttl74xx.h @@ -11,179 +11,179 @@ * Netlist Macros * ---------------------------------------------------------------------------*/ -#define TTL_7400_GATE(_name) \ - NET_REGISTER_DEV(TTL_7400_GATE, _name) +#define TTL_7400_GATE(name) \ + NET_REGISTER_DEV(TTL_7400_GATE, name) -#define TTL_7400_NAND(_name, _A, _B) \ - NET_REGISTER_DEV(TTL_7400_NAND, _name) \ - NET_CONNECT(_name, A, _A) \ - NET_CONNECT(_name, B, _B) +#define TTL_7400_NAND(name, cA, cB) \ + NET_REGISTER_DEV(TTL_7400_NAND, name) \ + NET_CONNECT(name, A, cA) \ + NET_CONNECT(name, B, cB) -#define TTL_7400_DIP(_name) \ - NET_REGISTER_DEV(TTL_7400_DIP, _name) +#define TTL_7400_DIP(name) \ + NET_REGISTER_DEV(TTL_7400_DIP, name) -#define TTL_7402_GATE(_name) \ - NET_REGISTER_DEV(TTL_7402_GATE, _name) +#define TTL_7402_GATE(name) \ + NET_REGISTER_DEV(TTL_7402_GATE, name) -#define TTL_7402_NOR(_name, _I1, _I2) \ - NET_REGISTER_DEV(TTL_7402_NOR, _name) \ - NET_CONNECT(_name, A, _I1) \ - NET_CONNECT(_name, B, _I2) +#define TTL_7402_NOR(name, cI1, cI2) \ + NET_REGISTER_DEV(TTL_7402_NOR, name) \ + NET_CONNECT(name, A, cI1) \ + NET_CONNECT(name, B, cI2) -#define TTL_7402_DIP(_name) \ - NET_REGISTER_DEV(TTL_7402_DIP, _name) +#define TTL_7402_DIP(name) \ + NET_REGISTER_DEV(TTL_7402_DIP, name) -#define TTL_7404_GATE(_name) \ - NET_REGISTER_DEV(TTL_7404_GATE, _name) +#define TTL_7404_GATE(name) \ + NET_REGISTER_DEV(TTL_7404_GATE, name) -#define TTL_7404_INVERT(_name, _A) \ - NET_REGISTER_DEV(TTL_7404_INVERT, _name) \ - NET_CONNECT(_name, A, _A) +#define TTL_7404_INVERT(name, cA) \ + NET_REGISTER_DEV(TTL_7404_INVERT, name) \ + NET_CONNECT(name, A, cA) -#define TTL_7404_DIP(_name) \ - NET_REGISTER_DEV(TTL_7404_DIP, _name) +#define TTL_7404_DIP(name) \ + NET_REGISTER_DEV(TTL_7404_DIP, name) -#define TTL_7408_GATE(_name) \ - NET_REGISTER_DEV(TTL_7408_GATE, _name) +#define TTL_7408_GATE(name) \ + NET_REGISTER_DEV(TTL_7408_GATE, name) -#define TTL_7408_AND(_name, _A, _B) \ - NET_REGISTER_DEV(TTL_7408_AND, _name) \ - NET_CONNECT(_name, A, _A) \ - NET_CONNECT(_name, B, _B) +#define TTL_7408_AND(name, cA, cB) \ + NET_REGISTER_DEV(TTL_7408_AND, name) \ + NET_CONNECT(name, A, cA) \ + NET_CONNECT(name, B, cB) -#define TTL_7408_DIP(_name) \ - NET_REGISTER_DEV(TTL_7408_DIP, _name) +#define TTL_7408_DIP(name) \ + NET_REGISTER_DEV(TTL_7408_DIP, name) -#define TTL_7410_GATE(_name) \ - NET_REGISTER_DEV(TTL_7410_GATE, _name) +#define TTL_7410_GATE(name) \ + NET_REGISTER_DEV(TTL_7410_GATE, name) -#define TTL_7410_NAND(_name, _I1, _I2, _I3) \ - NET_REGISTER_DEV(TTL_7410_NAND, _name) \ - NET_CONNECT(_name, A, _I1) \ - NET_CONNECT(_name, B, _I2) \ - NET_CONNECT(_name, C, _I3) +#define TTL_7410_NAND(name, cI1, cI2, cI3) \ + NET_REGISTER_DEV(TTL_7410_NAND, name) \ + NET_CONNECT(name, A, cI1) \ + NET_CONNECT(name, B, cI2) \ + NET_CONNECT(name, C, cI3) -#define TTL_7410_DIP(_name) \ - NET_REGISTER_DEV(TTL_7410_DIP, _name) +#define TTL_7410_DIP(name) \ + NET_REGISTER_DEV(TTL_7410_DIP, name) -#define TTL_7411_GATE(_name) \ - NET_REGISTER_DEV(TTL_7411_GATE, _name) +#define TTL_7411_GATE(name) \ + NET_REGISTER_DEV(TTL_7411_GATE, name) -#define TTL_7411_AND(_name, _I1, _I2, _I3) \ - NET_REGISTER_DEV(TTL_7411_AND, _name) \ - NET_CONNECT(_name, A, _I1) \ - NET_CONNECT(_name, B, _I2) \ - NET_CONNECT(_name, C, _I3) +#define TTL_7411_AND(name, cI1, cI2, cI3) \ + NET_REGISTER_DEV(TTL_7411_AND, name) \ + NET_CONNECT(name, A, cI1) \ + NET_CONNECT(name, B, cI2) \ + NET_CONNECT(name, C, cI3) -#define TTL_7411_DIP(_name) \ - NET_REGISTER_DEV(TTL_7411_DIP, _name) +#define TTL_7411_DIP(name) \ + NET_REGISTER_DEV(TTL_7411_DIP, name) -#define TTL_7416_GATE(_name) \ - NET_REGISTER_DEV(TTL_7416_GATE, _name) +#define TTL_7416_GATE(name) \ + NET_REGISTER_DEV(TTL_7416_GATE, name) -#define TTL_7416_DIP(_name) \ - NET_REGISTER_DEV(TTL7416_DIP, _name) +#define TTL_7416_DIP(name) \ + NET_REGISTER_DEV(TTL7416_DIP, name) -#define TTL_7420_GATE(_name) \ - NET_REGISTER_DEV(TTL_7420_GATE, _name) +#define TTL_7420_GATE(name) \ + NET_REGISTER_DEV(TTL_7420_GATE, name) -#define TTL_7420_NAND(_name, _I1, _I2, _I3, _I4) \ - NET_REGISTER_DEV(TTL_7420_NAND, _name) \ - NET_CONNECT(_name, A, _I1) \ - NET_CONNECT(_name, B, _I2) \ - NET_CONNECT(_name, C, _I3) \ - NET_CONNECT(_name, D, _I4) +#define TTL_7420_NAND(name, cI1, cI2, cI3, cI4) \ + NET_REGISTER_DEV(TTL_7420_NAND, name) \ + NET_CONNECT(name, A, cI1) \ + NET_CONNECT(name, B, cI2) \ + NET_CONNECT(name, C, cI3) \ + NET_CONNECT(name, D, cI4) -#define TTL_7420_DIP(_name) \ - NET_REGISTER_DEV(TTL_7420_DIP, _name) +#define TTL_7420_DIP(name) \ + NET_REGISTER_DEV(TTL_7420_DIP, name) -#define TTL_7425_GATE(_name) \ - NET_REGISTER_DEV(TTL_7425_GATE, _name) +#define TTL_7425_GATE(name) \ + NET_REGISTER_DEV(TTL_7425_GATE, name) -#define TTL_7425_NOR(_name, _I1, _I2, _I3, _I4) \ - NET_REGISTER_DEV(TTL_7425_NOR, _name) \ - NET_CONNECT(_name, A, _I1) \ - NET_CONNECT(_name, B, _I2) \ - NET_CONNECT(_name, C, _I3) \ - NET_CONNECT(_name, D, _I4) +#define TTL_7425_NOR(name, cI1, cI2, cI3, cI4) \ + NET_REGISTER_DEV(TTL_7425_NOR, name) \ + NET_CONNECT(name, A, cI1) \ + NET_CONNECT(name, B, cI2) \ + NET_CONNECT(name, C, cI3) \ + NET_CONNECT(name, D, cI4) -#define TTL_7425_DIP(_name) \ - NET_REGISTER_DEV(TTL_7425_DIP, _name) +#define TTL_7425_DIP(name) \ + NET_REGISTER_DEV(TTL_7425_DIP, name) -#define TTL_7427_GATE(_name) \ - NET_REGISTER_DEV(TTL_7427_GATE, _name) +#define TTL_7427_GATE(name) \ + NET_REGISTER_DEV(TTL_7427_GATE, name) -#define TTL_7427_NOR(_name, _I1, _I2, _I3) \ - NET_REGISTER_DEV(TTL_7427_NOR, _name) \ - NET_CONNECT(_name, A, _I1) \ - NET_CONNECT(_name, B, _I2) \ - NET_CONNECT(_name, C, _I3) +#define TTL_7427_NOR(name, cI1, cI2, cI3) \ + NET_REGISTER_DEV(TTL_7427_NOR, name) \ + NET_CONNECT(name, A, cI1) \ + NET_CONNECT(name, B, cI2) \ + NET_CONNECT(name, C, cI3) -#define TTL_7427_DIP(_name) \ - NET_REGISTER_DEV(TTL_7427_DIP, _name) +#define TTL_7427_DIP(name) \ + NET_REGISTER_DEV(TTL_7427_DIP, name) -#define TTL_7430_GATE(_name) \ - NET_REGISTER_DEV(TTL_7430_GATE, _name) +#define TTL_7430_GATE(name) \ + NET_REGISTER_DEV(TTL_7430_GATE, name) -#define TTL_7430_NAND(_name, _I1, _I2, _I3, _I4, _I5, _I6, _I7, _I8) \ - NET_REGISTER_DEV(TTL_7430_NAND, _name) \ - NET_CONNECT(_name, A, _I1) \ - NET_CONNECT(_name, B, _I2) \ - NET_CONNECT(_name, C, _I3) \ - NET_CONNECT(_name, D, _I4) \ - NET_CONNECT(_name, E, _I5) \ - NET_CONNECT(_name, F, _I6) \ - NET_CONNECT(_name, G, _I7) \ - NET_CONNECT(_name, H, _I8) +#define TTL_7430_NAND(name, cI1, cI2, cI3, cI4, cI5, cI6, cI7, cI8) \ + NET_REGISTER_DEV(TTL_7430_NAND, name) \ + NET_CONNECT(name, A, cI1) \ + NET_CONNECT(name, B, cI2) \ + NET_CONNECT(name, C, cI3) \ + NET_CONNECT(name, D, cI4) \ + NET_CONNECT(name, E, cI5) \ + NET_CONNECT(name, F, cI6) \ + NET_CONNECT(name, G, cI7) \ + NET_CONNECT(name, H, cI8) -#define TTL_7430_DIP(_name) \ - NET_REGISTER_DEV(TTL_7430_DIP, _name) +#define TTL_7430_DIP(name) \ + NET_REGISTER_DEV(TTL_7430_DIP, name) -#define TTL_7432_GATE(_name) \ - NET_REGISTER_DEV(TTL_7432_OR, _name) +#define TTL_7432_GATE(name) \ + NET_REGISTER_DEV(TTL_7432_OR, name) -#define TTL_7432_OR(_name, _I1, _I2) \ - NET_REGISTER_DEV(TTL_7432_OR, _name) \ - NET_CONNECT(_name, A, _I1) \ - NET_CONNECT(_name, B, _I2) +#define TTL_7432_OR(name, cI1, cI2) \ + NET_REGISTER_DEV(TTL_7432_OR, name) \ + NET_CONNECT(name, A, cI1) \ + NET_CONNECT(name, B, cI2) -#define TTL_7432_DIP(_name) \ - NET_REGISTER_DEV(TTL_7432_DIP, _name) +#define TTL_7432_DIP(name) \ + NET_REGISTER_DEV(TTL_7432_DIP, name) -#define TTL_7437_GATE(_name) \ - NET_REGISTER_DEV(TTL_7437_GATE, _name) +#define TTL_7437_GATE(name) \ + NET_REGISTER_DEV(TTL_7437_GATE, name) -#define TTL_7437_NAND(_name, _A, _B) \ - NET_REGISTER_DEV(TTL_7437_NAND, _name) \ - NET_CONNECT(_name, A, _A) \ - NET_CONNECT(_name, B, _B) +#define TTL_7437_NAND(name, cA, cB) \ + NET_REGISTER_DEV(TTL_7437_NAND, name) \ + NET_CONNECT(name, A, cA) \ + NET_CONNECT(name, B, cB) -#define TTL_7437_DIP(_name) \ - NET_REGISTER_DEV(TTL_7437_DIP, _name) +#define TTL_7437_DIP(name) \ + NET_REGISTER_DEV(TTL_7437_DIP, name) -#define TTL_7486_GATE(_name) \ - NET_REGISTER_DEV(TTL_7486_GATE, _name) +#define TTL_7486_GATE(name) \ + NET_REGISTER_DEV(TTL_7486_GATE, name) -#define TTL_7486_XOR(_name, _A, _B) \ - NET_REGISTER_DEV(TTL_7486_XOR, _name) \ - NET_CONNECT(_name, A, _A) \ - NET_CONNECT(_name, B, _B) +#define TTL_7486_XOR(name, cA, cB) \ + NET_REGISTER_DEV(TTL_7486_XOR, name) \ + NET_CONNECT(name, A, cA) \ + NET_CONNECT(name, B, cB) -#define TTL_7486_DIP(_name) \ - NET_REGISTER_DEV(TTL_7486_DIP, _name) +#define TTL_7486_DIP(name) \ + NET_REGISTER_DEV(TTL_7486_DIP, name) /* ---------------------------------------------------------------------------- * External declarations diff --git a/src/lib/netlist/nl_base.cpp b/src/lib/netlist/nl_base.cpp index 556e346cfa0..f7629065ff4 100644 --- a/src/lib/netlist/nl_base.cpp +++ b/src/lib/netlist/nl_base.cpp @@ -64,9 +64,9 @@ public: m_R_low = 1.0; m_R_high = 130.0; } - virtual powned_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_t &anetlist, const pstring &name, logic_output_t *proxied) const override + virtual plib::powned_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_t &anetlist, const pstring &name, logic_output_t *proxied) const override { - return powned_ptr<devices::nld_base_d_to_a_proxy>::Create<devices::nld_d_to_a_proxy>(anetlist, name, proxied); + return plib::powned_ptr<devices::nld_base_d_to_a_proxy>::Create<devices::nld_d_to_a_proxy>(anetlist, name, proxied); } }; @@ -84,9 +84,9 @@ public: m_R_low = 10.0; m_R_high = 10.0; } - virtual powned_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_t &anetlist, const pstring &name, logic_output_t *proxied) const override + virtual plib::powned_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_t &anetlist, const pstring &name, logic_output_t *proxied) const override { - return powned_ptr<devices::nld_base_d_to_a_proxy>::Create<devices::nld_d_to_a_proxy>(anetlist, name, proxied); + return plib::powned_ptr<devices::nld_base_d_to_a_proxy>::Create<devices::nld_d_to_a_proxy>(anetlist, name, proxied); } }; @@ -108,14 +108,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) - , pstate_callback_t() + , plib::pstate_callback_t() , m_qsize(0) , m_times(512) , m_names(512) { } -void queue_t::register_state(pstate_manager_t &manager, const pstring &module) +void queue_t::register_state(plib::pstate_manager_t &manager, const pstring &module) { netlist().log().debug("register_state\n"); manager.save_item(m_qsize, this, module + "." + "qsize"); @@ -228,7 +228,7 @@ netlist_t::netlist_t(const pstring &aname) m_log(this), m_lib(nullptr) { - save_item(static_cast<pstate_callback_t &>(m_queue), this, "m_queue"); + save_item(static_cast<plib::pstate_callback_t &>(m_queue), this, "m_queue"); save_item(m_time, this, "m_time"); } @@ -253,7 +253,7 @@ ATTR_COLD void netlist_t::start() pstring libpath = nl_util::environment("NL_BOOSTLIB", nl_util::buildpath({".", "nlboost.so"})); - m_lib = palloc(pdynlib(libpath)); + m_lib = plib::palloc<plib::dynlib>(libpath); /* make sure the solver and parameters are started first! */ @@ -264,7 +264,7 @@ ATTR_COLD void netlist_t::start() || setup().factory().is_class<devices::NETLIB_NAME(gnd)>(e.second) || setup().factory().is_class<devices::NETLIB_NAME(netlistparams)>(e.second)) { - auto dev = powned_ptr<device_t>(e.second->Create(*this, e.first)); + auto dev = plib::powned_ptr<device_t>(e.second->Create(*this, e.first)); setup().register_dev_s(std::move(dev)); } } @@ -287,7 +287,7 @@ ATTR_COLD void netlist_t::start() && !setup().factory().is_class<devices::NETLIB_NAME(gnd)>(e.second) && !setup().factory().is_class<devices::NETLIB_NAME(netlistparams)>(e.second)) { - auto dev = powned_ptr<device_t>(e.second->Create(*this, e.first)); + auto dev = plib::powned_ptr<device_t>(e.second->Create(*this, e.first)); setup().register_dev_s(std::move(dev)); } } @@ -495,7 +495,7 @@ ATTR_COLD core_device_t::core_device_t(core_device_t &owner, const pstring &name if (logic_family() == nullptr) set_logic_family(family_TTL()); init_object(owner.netlist(), owner.name() + "." + name); - owner.netlist().m_devices.push_back(powned_ptr<core_device_t>(this, false)); + owner.netlist().m_devices.push_back(plib::powned_ptr<core_device_t>(this, false)); } ATTR_COLD core_device_t::~core_device_t() @@ -514,7 +514,7 @@ ATTR_COLD void core_device_t::set_delegate_pointer() void (core_device_t::* pFunc)() = &core_device_t::update; m_static_update = reinterpret_cast<net_update_delegate>((this->*pFunc)); #elif (NL_PMF_TYPE == NL_PMF_TYPE_INTERNAL) - m_static_update = pmfp::get_mfp<net_update_delegate>(&core_device_t::update, this); + m_static_update = plib::mfp::get_mfp<net_update_delegate>(&core_device_t::update, this); #endif } @@ -866,7 +866,7 @@ ATTR_COLD void analog_net_t::save_register() net_t::save_register(); } -ATTR_COLD bool analog_net_t::already_processed(pvector_t<list_t> &groups) +ATTR_COLD bool analog_net_t::already_processed(plib::pvector_t<list_t> &groups) { if (isRailNet()) return true; @@ -878,7 +878,7 @@ ATTR_COLD bool analog_net_t::already_processed(pvector_t<list_t> &groups) return false; } -ATTR_COLD void analog_net_t::process_net(pvector_t<list_t> &groups) +ATTR_COLD void analog_net_t::process_net(plib::pvector_t<list_t> &groups) { if (num_cons() == 0) return; diff --git a/src/lib/netlist/nl_base.h b/src/lib/netlist/nl_base.h index 135d6ed1ab1..63650c25700 100644 --- a/src/lib/netlist/nl_base.h +++ b/src/lib/netlist/nl_base.h @@ -161,9 +161,9 @@ #include "nl_lists.h" #include "nl_time.h" #include "nl_util.h" +#include "plib/pdynlib.h" #include "plib/pstate.h" #include "plib/pfmtlog.h" -#include "plib/pdynlib.h" // ---------------------------------------------------------------------------------------- // Type definitions @@ -183,29 +183,29 @@ using netlist_sig_t = std::uint32_t; #define NETLIB_NAMESPACE_DEVICES_START() namespace netlist { namespace devices { #define NETLIB_NAMESPACE_DEVICES_END() }} -#define NETLIB_NAME(_chip) nld_ ## _chip +#define NETLIB_NAME(chip) nld_ ## chip -#define NETLIB_OBJECT_DERIVED(_name, _pclass) \ -class NETLIB_NAME(_name) : public NETLIB_NAME(_pclass) +#define NETLIB_OBJECT_DERIVED(name, pclass) \ +class NETLIB_NAME(name) : public NETLIB_NAME(pclass) -#define NETLIB_OBJECT(_name) \ -class NETLIB_NAME(_name) : public device_t +#define NETLIB_OBJECT(name) \ +class NETLIB_NAME(name) : public device_t -#define NETLIB_CONSTRUCTOR_DERIVED(_name, _pclass) \ +#define NETLIB_CONSTRUCTOR_DERIVED(cname, pclass) \ private: family_setter_t m_famsetter; \ - public: template <class _CLASS> ATTR_COLD NETLIB_NAME(_name)(_CLASS &owner, const pstring name) \ - : NETLIB_NAME(_pclass)(owner, name) + public: template <class CLASS> ATTR_COLD NETLIB_NAME(cname)(CLASS &owner, const pstring name) \ + : NETLIB_NAME(pclass)(owner, name) -#define NETLIB_CONSTRUCTOR(_name) \ +#define NETLIB_CONSTRUCTOR(cname) \ private: family_setter_t m_famsetter; \ - public: template <class _CLASS> ATTR_COLD NETLIB_NAME(_name)(_CLASS &owner, const pstring name) \ + public: template <class CLASS> ATTR_COLD NETLIB_NAME(cname)(CLASS &owner, const pstring name) \ : device_t(owner, name) -#define NETLIB_DESTRUCTOR(_name) public: ATTR_HOT virtual ~NETLIB_NAME(_name)() +#define NETLIB_DESTRUCTOR(name) public: ATTR_HOT virtual ~NETLIB_NAME(name)() -#define NETLIB_CONSTRUCTOR_EX(_name, ...) \ +#define NETLIB_CONSTRUCTOR_EX(cname, ...) \ private: family_setter_t m_famsetter; \ - public: template <class _CLASS> ATTR_COLD NETLIB_NAME(_name)(_CLASS &owner, const pstring name, __VA_ARGS__) \ + public: template <class CLASS> ATTR_COLD NETLIB_NAME(cname)(CLASS &owner, const pstring name, __VA_ARGS__) \ : device_t(owner, name) #define NETLIB_DYNAMIC() \ @@ -218,26 +218,26 @@ class NETLIB_NAME(_name) : public device_t #define NETLIB_UPDATE_AFTER_PARAM_CHANGE() \ public: ATTR_HOT virtual bool needs_update_after_param_change() const override { return true; } -#define NETLIB_FAMILY(_family) , m_famsetter(*this, _family) +#define NETLIB_FAMILY(family) , m_famsetter(*this, family) #define NETLIB_UPDATE_TERMINALSI() public: ATTR_HOT virtual void update_terminals() override #define NETLIB_UPDATEI() protected: ATTR_HOT virtual void update() NOEXCEPT override #define NETLIB_UPDATE_PARAMI() public: ATTR_HOT virtual void update_param() override #define NETLIB_RESETI() protected: ATTR_HOT virtual void reset() override -#define NETLIB_SUB(_chip) nld_ ## _chip -#define NETLIB_SUBXX(_chip) std::unique_ptr< nld_ ## _chip > +#define NETLIB_SUB(chip) nld_ ## chip +#define NETLIB_SUBXX(chip) std::unique_ptr< nld_ ## chip > -#define NETLIB_UPDATE(_chip) ATTR_HOT void NETLIB_NAME(_chip) :: update(void) NOEXCEPT +#define NETLIB_UPDATE(chip) ATTR_HOT void NETLIB_NAME(chip) :: update(void) NOEXCEPT -#define NETLIB_RESET(_chip) ATTR_COLD void NETLIB_NAME(_chip) :: reset(void) +#define NETLIB_RESET(chip) ATTR_COLD void NETLIB_NAME(chip) :: reset(void) -#define NETLIB_STOP(_chip) ATTR_COLD void NETLIB_NAME(_chip) :: stop(void) +#define NETLIB_STOP(chip) ATTR_COLD void NETLIB_NAME(chip) :: stop(void) -#define NETLIB_UPDATE_PARAM(_chip) ATTR_HOT void NETLIB_NAME(_chip) :: update_param(void) -#define NETLIB_FUNC_VOID(_chip, _name, _params) ATTR_HOT void NETLIB_NAME(_chip) :: _name _params +#define NETLIB_UPDATE_PARAM(chip) ATTR_HOT void NETLIB_NAME(chip) :: update_param(void) +#define NETLIB_FUNC_VOID(chip, name, params) ATTR_HOT void NETLIB_NAME(chip) :: name params -#define NETLIB_UPDATE_TERMINALS(_chip) ATTR_HOT void NETLIB_NAME(_chip) :: update_terminals(void) +#define NETLIB_UPDATE_TERMINALS(chip) ATTR_HOT void NETLIB_NAME(chip) :: update_terminals(void) //============================================================ @@ -250,11 +250,11 @@ class NETLIB_NAME(_name) : public device_t //============================================================ #if defined(MAME_DEBUG) -#define nl_assert(x) do { if (1) if (!(x)) throw fatalerror_e(pfmt("assert: {1}:{2}: {3}")(__FILE__)(__LINE__)(#x) ); } while (0) +#define nl_assert(x) do { if (1) if (!(x)) throw fatalerror_e(plib::pfmt("assert: {1}:{2}: {3}")(__FILE__)(__LINE__)(#x) ); } while (0) #else -#define nl_assert(x) do { if (0) if (!(x)) throw fatalerror_e(pfmt("assert: {1}:{2}: {3}")(__FILE__)(__LINE__)(#x) ); } while (0) +#define nl_assert(x) do { if (0) if (!(x)) throw fatalerror_e(plib::pfmt("assert: {1}:{2}: {3}")(__FILE__)(__LINE__)(#x) ); } while (0) #endif -#define nl_assert_always(x, msg) do { if (!(x)) throw fatalerror_e(pfmt("Fatal error: {1}\nCaused by assert: {2}:{3}: {4}")(msg)(__FILE__)(__LINE__)(#x)); } while (0) +#define nl_assert_always(x, msg) do { if (!(x)) throw fatalerror_e(plib::pfmt("Fatal error: {1}\nCaused by assert: {2}:{3}: {4}")(msg)(__FILE__)(__LINE__)(#x)); } while (0) // ----------------------------------------------------------------------------- @@ -282,10 +282,10 @@ namespace netlist // Exceptions //============================================================ - class fatalerror_e : public pexception + class fatalerror_e : public plib::pexception { public: - fatalerror_e(const pstring &text) : pexception(text) { } + fatalerror_e(const pstring &text) : plib::pexception(text) { } virtual ~fatalerror_e() throw() {} }; @@ -302,7 +302,7 @@ namespace netlist // model_map_t // ----------------------------------------------------------------------------- - using model_map_t = phashmap_t<pstring, pstring>; + using model_map_t = plib::hashmap_t<pstring, pstring>; // ----------------------------------------------------------------------------- // logic_family_t @@ -313,7 +313,7 @@ namespace netlist public: logic_family_desc_t() {} virtual ~logic_family_desc_t() {} - virtual powned_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_t &anetlist, const pstring &name, + virtual plib::powned_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_t &anetlist, const pstring &name, logic_output_t *proxied) const = 0; nl_double m_low_thresh_V; @@ -354,7 +354,7 @@ namespace netlist // object_t // ----------------------------------------------------------------------------- - class object_t : public pstate_interface_t<object_t> + class object_t : public plib::pstate_interface_t<object_t> { P_PREVENT_COPYING(object_t) public: @@ -379,7 +379,7 @@ namespace netlist ATTR_COLD const pstring &name() const; - ATTR_COLD inline pstate_manager_t *state_manager(); + ATTR_COLD inline plib::pstate_manager_t *state_manager(); ATTR_HOT type_t type() const { return m_objtype; } @@ -433,12 +433,12 @@ namespace netlist // core_terminal_t // ----------------------------------------------------------------------------- - class core_terminal_t : public device_object_t, public plinkedlist_element_t<core_terminal_t> + class core_terminal_t : public device_object_t, public plib::plinkedlist_element_t<core_terminal_t> { P_PREVENT_COPYING(core_terminal_t) public: - using list_t = pvector_t<core_terminal_t *>; + using list_t = plib::pvector_t<core_terminal_t *>; /* needed here ... */ @@ -519,7 +519,7 @@ namespace netlist P_PREVENT_COPYING(terminal_t) public: - using list_t = pvector_t<terminal_t *>; + using list_t = plib::pvector_t<terminal_t *>; ATTR_COLD terminal_t(); @@ -668,7 +668,7 @@ namespace netlist public: using ptr_t = net_t *; - using list_t = pvector_t<std::shared_ptr<net_t>>; + using list_t = plib::pvector_t<std::shared_ptr<net_t>>; ATTR_COLD net_t(); virtual ~net_t(); @@ -708,7 +708,7 @@ namespace netlist ATTR_COLD void move_connections(net_t *new_net); - pvector_t<core_terminal_t *> m_core_terms; // save post-start m_list ... + plib::pvector_t<core_terminal_t *> m_core_terms; // save post-start m_list ... ATTR_HOT void set_Q_time(const netlist_sig_t &newQ, const netlist_time &at) { @@ -731,7 +731,7 @@ namespace netlist private: core_terminal_t * m_railterminal; - plinkedlist_t<core_terminal_t> m_list_active; + plib::linkedlist_t<core_terminal_t> m_list_active; netlist_time m_time; INT32 m_active; @@ -750,7 +750,7 @@ namespace netlist P_PREVENT_COPYING(logic_net_t) public: - using list_t = pvector_t<logic_net_t *>; + using list_t = plib::pvector_t<logic_net_t *>; ATTR_COLD logic_net_t(); virtual ~logic_net_t() { }; @@ -810,7 +810,7 @@ namespace netlist P_PREVENT_COPYING(analog_net_t) public: - using list_t = pvector_t<analog_net_t *>; + using list_t = plib::pvector_t<analog_net_t *>; ATTR_COLD analog_net_t(); ATTR_COLD analog_net_t(netlist_t &nl, const pstring &aname); @@ -829,8 +829,8 @@ namespace netlist ATTR_HOT devices::matrix_solver_t *solver() { return m_solver; } - ATTR_COLD bool already_processed(pvector_t<list_t> &groups); - ATTR_COLD void process_net(pvector_t<list_t> &groups); + ATTR_COLD bool already_processed(plib::pvector_t<list_t> &groups); + ATTR_COLD void process_net(plib::pvector_t<list_t> &groups); protected: @@ -982,7 +982,7 @@ namespace netlist P_PREVENT_COPYING(core_device_t) public: - using list_t = pvector_t<core_device_t *>; + using list_t = plib::pvector_t<core_device_t *>; ATTR_COLD core_device_t(netlist_t &owner, const pstring &name); ATTR_COLD core_device_t(core_device_t &owner, const pstring &name); @@ -1039,7 +1039,7 @@ namespace netlist #if (NL_KEEP_STATISTICS) /* stats */ - osd_ticks_t stat_total_time; + plib::ticks_t stat_total_time; INT32 stat_update_count; INT32 stat_call_count; #endif @@ -1124,7 +1124,7 @@ namespace netlist ATTR_COLD void connect_late(core_terminal_t &t1, core_terminal_t &t2); ATTR_COLD void connect_post_start(core_terminal_t &t1, core_terminal_t &t2); - pvector_t<pstring> m_terminals; + plib::pvector_t<pstring> m_terminals; protected: @@ -1166,7 +1166,7 @@ namespace netlist class queue_t : public timed_queue<net_t *, netlist_time>, public object_t, - public pstate_callback_t + public plib::pstate_callback_t { public: queue_t(netlist_t &nl); @@ -1175,15 +1175,15 @@ namespace netlist void reset() override {} - void register_state(pstate_manager_t &manager, const pstring &module) override; + void register_state(plib::pstate_manager_t &manager, const pstring &module) override; void on_pre_save() override; void on_post_load() override; private: struct names_t { char m_buf[64]; }; int m_qsize; - parray_t<netlist_time::INTERNALTYPE> m_times; - parray_t<names_t> m_names; + plib::array_t<netlist_time::INTERNALTYPE> m_times; + plib::array_t<names_t> m_names; }; // ----------------------------------------------------------------------------- @@ -1191,7 +1191,7 @@ namespace netlist // ----------------------------------------------------------------------------- - class netlist_t : public pstate_manager_t, public plog_dispatch_intf //, public device_owner_t + class netlist_t : public plib::pstate_manager_t, public plib::plog_dispatch_intf //, public device_owner_t { P_PREVENT_COPYING(netlist_t) public: @@ -1226,26 +1226,26 @@ namespace netlist ATTR_COLD net_t *find_net(const pstring &name); - template<class _device_class> - ATTR_COLD pvector_t<_device_class *> get_device_list() + template<class device_class> + ATTR_COLD plib::pvector_t<device_class *> get_device_list() { - pvector_t<_device_class *> tmp; + plib::pvector_t<device_class *> tmp; for (auto &d : m_devices) { - _device_class *dev = dynamic_cast<_device_class *>(d.get()); + device_class *dev = dynamic_cast<device_class *>(d.get()); if (dev != nullptr) tmp.push_back(dev); } return tmp; } - template<class _device_class> - ATTR_COLD _device_class *get_single_device(const char *classname) + template<class device_class> + ATTR_COLD device_class *get_single_device(const char *classname) { - _device_class *ret = nullptr; + device_class *ret = nullptr; for (auto &d : m_devices) { - _device_class *dev = dynamic_cast<_device_class *>(d.get()); + device_class *dev = dynamic_cast<device_class *>(d.get()); if (dev != nullptr) { if (ret != nullptr) @@ -1261,16 +1261,16 @@ namespace netlist pvector_t<core_device_t *> m_started_devices; #endif - ATTR_COLD plog_base<NL_DEBUG> &log() { return m_log; } - ATTR_COLD const plog_base<NL_DEBUG> &log() const { return m_log; } + ATTR_COLD plib::plog_base<NL_DEBUG> &log() { return m_log; } + ATTR_COLD const plib::plog_base<NL_DEBUG> &log() const { return m_log; } virtual void reset(); - ATTR_COLD pdynlib &lib() { return *m_lib; } + ATTR_COLD plib::dynlib &lib() { return *m_lib; } void print_stats() const; - pvector_t<powned_ptr<core_device_t>> m_devices; + plib::pvector_t<plib::powned_ptr<core_device_t>> m_devices; /* sole use is to manage lifetime of net objects */ net_t::list_t m_nets; @@ -1302,15 +1302,15 @@ protected: pstring m_name; setup_t *m_setup; - plog_base<NL_DEBUG> m_log; - pdynlib *m_lib; // external lib needs to be loaded as long as netlist exists + plib::plog_base<NL_DEBUG> m_log; + plib::dynlib *m_lib; // external lib needs to be loaded as long as netlist exists }; // ----------------------------------------------------------------------------- // inline implementations // ----------------------------------------------------------------------------- - ATTR_COLD inline pstate_manager_t *object_t::state_manager() + ATTR_COLD inline plib::pstate_manager_t *object_t::state_manager() { return m_netlist; } @@ -1478,7 +1478,7 @@ protected: } -NETLIST_SAVE_TYPE(netlist::core_terminal_t::state_e, DT_INT); +NETLIST_SAVE_TYPE(netlist::core_terminal_t::state_e, pstate_data_type_e::DT_INT); #endif /* NLBASE_H_ */ diff --git a/src/lib/netlist/nl_config.h b/src/lib/netlist/nl_config.h index 285bbd9e8c4..dd96bbd5ecc 100644 --- a/src/lib/netlist/nl_config.h +++ b/src/lib/netlist/nl_config.h @@ -118,8 +118,8 @@ // General Macros //============================================================ -#if defined(_OPENMP) -#define HAS_OPENMP ( _OPENMP >= 200805 ) +#if defined(OPENMP) +#define HAS_OPENMP ( OPENMP >= 200805 ) #else #define HAS_OPENMP (0) #endif @@ -129,11 +129,10 @@ //============================================================ #if NL_KEEP_STATISTICS -#include "eminline.h" #define add_to_stat(v,x) do { v += (x); } while (0) #define inc_stat(v) add_to_stat(v, 1) -#define begin_timing(v) do { v -= get_profile_ticks(); } while (0) -#define end_timing(v) do { v += get_profile_ticks(); } while (0) +#define begin_timing(v) do { v -= plib::profile_ticks(); } while (0) +#define end_timing(v) do { v += plib::profile_ticks(); } while (0) #else #define add_to_stat(v,x) do { } while (0) #define inc_stat(v) add_to_stat(v, 1) diff --git a/src/lib/netlist/nl_dice_compat.h b/src/lib/netlist/nl_dice_compat.h index 5a600ad117a..d70b8d8494d 100644 --- a/src/lib/netlist/nl_dice_compat.h +++ b/src/lib/netlist/nl_dice_compat.h @@ -39,24 +39,24 @@ sed -e 's/#define \(.*\)"\(.*\)"[ \t]*,[ \t]*\(.*\)/NET_ALIAS(\1,\2.\3)/' src/ma * a temporary support and not be used in commits. */ -#define NETLIB_NAME_STR_S(_s) # _s -#define NETLIB_NAME_STR(_chip) NETLIB_NAME_STR_S(nld_ ## _chip) +#define NETLIB_NAME_STR_S(s) # s +#define NETLIB_NAME_STR(chip) NETLIB_NAME_STR_S(nld_ ## chip) #ifndef NL_CONVERT_CPP #ifndef NETLIST_DEVELOPMENT #define NETLIST_DEVELOPMENT 0 #endif #if (NETLIST_DEVELOPMENT) -#define CHIP(_n, _t) setup.register_dev( palloc(netlist::devices::nld_ ## _t ## _dip), _n); +#define CHIP(n, t) setup.register_dev( palloc(netlist::devices::nld_ ## t ## dip), n); #else -#define CHIP(_n, _t) setup.register_dev(NETLIB_NAME_STR_S(TTL_ ## _t ## _DIP), _n); -//#define CHIP(_n, _t) TTL_ ## _t ## _DIP(_n) +#define CHIP(n, t) setup.register_dev(NETLIB_NAME_STR_S(TTL_ ## t ## _DIP), n); +//#define CHIP(n, t) TTL_ ## t ## _DIP(n) #endif #define CONNECTION( ... ) CONNECTIONY( CONNECTIONX( __VA_ARGS__ ) ) -#define CONNECTIONY(_a) _a -#define CONNECTIONX(_a, _b, _c, _d) setup.register_link(_a "." # _b, _c "." # _d); -#define NET_CSTR(_a, _b) setup.register_link( _a, _b); +#define CONNECTIONY(a) a +#define CONNECTIONX(a, b, c, d) setup.register_link(a "." # b, c "." # d); +#define NET_CSTR(a, b) setup.register_link( a, b); #define OHM(x) (x) #define K_OHM(x) ((x) * 1000.0) @@ -105,7 +105,7 @@ public: }; #else -#define CHIP(_n, _t) TTL_ ## _t ## _DIP(_n) +#define CHIP(n, t) TTL_ ## t ## DIP(n) #define OHM(x) x #define K_OHM(x) RES_K(X) @@ -120,75 +120,75 @@ public: #define CIRCUIT_LAYOUT(x) NETLIST_START(x) #define CIRCUIT_LAYOUT_END NETLIST_END() -#define CHIP_555_Mono(_name, _pdesc) \ - NE555_DIP(_name) \ - NET_C(_name.6, _name.7) \ - RES(_name ## _R, (_pdesc)->r) \ - CAP(_name ## _C, (_pdesc)->c) \ - NET_C(_name.6, _name ## _R.1) \ - NET_C(_name.6, _name ## _C.1) \ - NET_C(_name ## _R.2, V5) \ - NET_CSTR(# _name "_C.2", "GND") \ - NET_C(_name.8, V5) \ - NET_CSTR(# _name ".1", "GND") - -#define CHIP_555_Astable(_name, _pdesc) \ - NE555_DIP(_name) \ - RES(_name ## _R1, (_pdesc)->r1) \ - RES(_name ## _R2, (_pdesc)->r2) \ - CAP(_name ## _C, (_pdesc)->c) \ - NET_C(_name.7, _name ## _R1.1) \ - NET_C(_name.7, _name ## _R2.1) \ - NET_C(_name.6, _name ## _R2.2) \ - NET_C(_name.6, _name ## _C.1) \ - NET_C(_name.2, _name ## _C.1) \ - NET_C(_name ## _R1.2, V5) \ - NET_CSTR(# _name "_C.2", "GND") \ - NET_C(_name.8, V5) \ - NET_CSTR(# _name ".1", "GND") - -#define CHIP_9602_Mono(_name, _pdesc) \ - CHIP(# _name, 9602) \ - NET_C(VCC, _name.16) \ - NET_C(GND, _name.8) \ - RES(_name ## _R1, (_pdesc)->r1) \ - CAP(_name ## _C1, (_pdesc)->c1) \ - RES(_name ## _R2, (_pdesc)->r2) \ - NET_C(_name.1, _name ## _C1.1) \ - NET_C(_name.2, _name ## _C1.2) \ - NET_C(_name.2, _name ## _R1.2) \ - NET_C(VCC, _name ## _R1.1) \ - if (((_pdesc)->c2)>1e-15) { \ - CAP(_name ## _C2, (_pdesc)->c2) \ - NET_C(_name.15, _name ## _C2.1) \ - NET_C(_name.14, _name ## _C2.2) }\ - NET_C(_name.14, _name ## _R2.2) \ - NET_C(VCC, _name ## _R2.1) -#define CHIP_SERIES_RC(_name, _pdesc) \ - RES(_name ## _R, (_pdesc)->r) \ - CAP(_name ## _C, (_pdesc)->c) \ - NET_C(_name ## _R.1, _name ## _C.2) \ - ALIAS(_name.3, _name ## _R.1) \ - ALIAS(_name.2, _name ## _R.2) \ - ALIAS(_name.1, _name ## _C.1) - -#define CHIP_INPUT_ACTIVE_LOW(_name) \ - SWITCH2(_name ## _SW) \ - NET_C(_name ## _SW.1, V5) \ - NET_CSTR(# _name "_SW.2", "GND") \ - ALIAS(_name.1, _name ## _SW.Q) - -#define CHIP_INPUT_ACTIVE_HIGH(_name) \ - SWITCH2(_name ## _SW) \ - NET_C(_name ## _SW.2, V5) \ - NET_CSTR(# _name "_SW.1", "GND") \ - ALIAS(_name.1, _name ## _SW.Q) - -#define CHIP_LATCH(_name) \ - NETDEV_RSFF(_name) \ - ALIAS(_name.1, _name.R) \ - ALIAS(_name.2, _name.S) \ - ALIAS(_name.3, _name.QQ) +#define CHIP_555_Mono(name, pdesc) \ + NE555_DIP(name) \ + NET_C(name.6, name.7) \ + RES(name ## _R, (pdesc)->r) \ + CAP(name ## _C, (pdesc)->c) \ + NET_C(name.6, name ## _R.1) \ + NET_C(name.6, name ## _C.1) \ + NET_C(name ## _R.2, V5) \ + NET_CSTR(# name "_C.2", "GND") \ + NET_C(name.8, V5) \ + NET_CSTR(# name ".1", "GND") + +#define CHIP_555_Astable(name, pdesc) \ + NE555_DIP(name) \ + RES(name ## _R1, (pdesc)->r1) \ + RES(name ## _R2, (pdesc)->r2) \ + CAP(name ## _C, (pdesc)->c) \ + NET_C(name.7, name ## _R1.1) \ + NET_C(name.7, name ## _R2.1) \ + NET_C(name.6, name ## _R2.2) \ + NET_C(name.6, name ## _C.1) \ + NET_C(name.2, name ## _C.1) \ + NET_C(name ## _R1.2, V5) \ + NET_CSTR(# name "_C.2", "GND") \ + NET_C(name.8, V5) \ + NET_CSTR(# name ".1", "GND") + +#define CHIP_9602_Mono(name, pdesc) \ + CHIP(# name, 9602) \ + NET_C(VCC, name.16) \ + NET_C(GND, name.8) \ + RES(name ## _R1, (pdesc)->r1) \ + CAP(name ## _C1, (pdesc)->c1) \ + RES(name ## _R2, (pdesc)->r2) \ + NET_C(name.1, name ## _C1.1) \ + NET_C(name.2, name ## _C1.2) \ + NET_C(name.2, name ## _R1.2) \ + NET_C(VCC, name ## _R1.1) \ + if (((pdesc)->c2)>1e-15) { \ + CAP(name ## _C2, (pdesc)->c2) \ + NET_C(name.15, name ## _C2.1) \ + NET_C(name.14, name ## _C2.2) }\ + NET_C(name.14, name ## _R2.2) \ + NET_C(VCC, name ## _R2.1) +#define CHIP_SERIES_RC(name, pdesc) \ + RES(name ## _R, (pdesc)->r) \ + CAP(name ## _C, (pdesc)->c) \ + NET_C(name ## _R.1, name ## _C.2) \ + ALIAS(name.3, name ## _R.1) \ + ALIAS(name.2, name ## _R.2) \ + ALIAS(name.1, name ## _C.1) + +#define CHIP_INPUT_ACTIVE_LOW(name) \ + SWITCH2(name ## _SW) \ + NET_C(name ## _SW.1, V5) \ + NET_CSTR(# name "_SW.2", "GND") \ + ALIAS(name.1, name ## _SW.Q) + +#define CHIP_INPUT_ACTIVE_HIGH(name) \ + SWITCH2(name ## _SW) \ + NET_C(name ## _SW.2, V5) \ + NET_CSTR(# name "_SW.1", "GND") \ + ALIAS(name.1, name ## _SW.Q) + +#define CHIP_LATCH(name) \ + NETDEV_RSFF(name) \ + ALIAS(name.1, name.R) \ + ALIAS(name.2, name.S) \ + ALIAS(name.3, name.QQ) /* FIXME: Alternative implementation using capacitor. * This is a transitional implementation @@ -216,9 +216,9 @@ inline int CAPACITOR_tc_lh(const double c, const double r) return ret; } -#define CHIP_CAPACITOR(_name, _pdesc) \ - NETDEV_DELAY(_name) \ - NETDEV_PARAMI(_name, L_TO_H, CAPACITOR_tc_lh((_pdesc)->c, (_pdesc)->r)) \ - NETDEV_PARAMI(_name, H_TO_L, CAPACITOR_tc_hl((_pdesc)->c, (_pdesc)->r)) +#define CHIP_CAPACITOR(name, pdesc) \ + NETDEV_DELAY(name) \ + NETDEV_PARAMI(name, L_TO_H, CAPACITOR_tc_lh((pdesc)->c, (pdesc)->r)) \ + NETDEV_PARAMI(name, H_TO_L, CAPACITOR_tc_hl((pdesc)->c, (pdesc)->r)) #endif /* NL_DICE_COMPAT_H_ */ diff --git a/src/lib/netlist/nl_factory.cpp b/src/lib/netlist/nl_factory.cpp index 8a101f91e68..0b59d0afef4 100644 --- a/src/lib/netlist/nl_factory.cpp +++ b/src/lib/netlist/nl_factory.cpp @@ -18,20 +18,20 @@ namespace netlist // net_device_t_base_factory // ---------------------------------------------------------------------------------------- -ATTR_COLD const pstring_vector_t base_factory_t::term_param_list() +ATTR_COLD const plib::pstring_vector_t base_factory_t::term_param_list() { if (m_def_param.startsWith("+")) - return pstring_vector_t(m_def_param.substr(1), ","); + return plib::pstring_vector_t(m_def_param.substr(1), ","); else - return pstring_vector_t(); + return plib::pstring_vector_t(); } -ATTR_COLD const pstring_vector_t base_factory_t::def_params() +ATTR_COLD const plib::pstring_vector_t base_factory_t::def_params() { if (m_def_param.startsWith("+") || m_def_param.equals("-")) - return pstring_vector_t(); + return plib::pstring_vector_t(); else - return pstring_vector_t(m_def_param, ","); + return plib::pstring_vector_t(m_def_param, ","); } @@ -67,7 +67,7 @@ void factory_list_t::error(const pstring &s) m_setup.log().fatal("{1}", s); } -powned_ptr<device_t> factory_list_t::new_device_by_name(const pstring &devname, netlist_t &anetlist, const pstring &name) +plib::powned_ptr<device_t> factory_list_t::new_device_by_name(const pstring &devname, netlist_t &anetlist, const pstring &name) { base_factory_t *f = factory_by_name(devname); return f->Create(anetlist, name); diff --git a/src/lib/netlist/nl_factory.h b/src/lib/netlist/nl_factory.h index a0a4dcdf214..97374d29c1a 100644 --- a/src/lib/netlist/nl_factory.h +++ b/src/lib/netlist/nl_factory.h @@ -32,13 +32,13 @@ namespace netlist virtual ~base_factory_t() {} - virtual powned_ptr<device_t> Create(netlist_t &anetlist, const pstring &name) = 0; + virtual plib::powned_ptr<device_t> Create(netlist_t &anetlist, const pstring &name) = 0; const pstring &name() const { return m_name; } const pstring &classname() const { return m_classname; } const pstring ¶m_desc() const { return m_def_param; } - const pstring_vector_t term_param_list(); - const pstring_vector_t def_params(); + const plib::pstring_vector_t term_param_list(); + const plib::pstring_vector_t def_params(); protected: pstring m_name; /* device name */ @@ -46,7 +46,7 @@ namespace netlist pstring m_def_param; /* default parameter */ }; - template <class _device_class> + template <class device_class> class factory_t : public base_factory_t { P_PREVENT_COPYING(factory_t) @@ -55,27 +55,27 @@ namespace netlist const pstring &def_param) : base_factory_t(name, classname, def_param) { } - powned_ptr<device_t> Create(netlist_t &anetlist, const pstring &name) override + plib::powned_ptr<device_t> Create(netlist_t &anetlist, const pstring &name) override { - return powned_ptr<device_t>::Create<_device_class>(anetlist, name); + return plib::powned_ptr<device_t>::Create<device_class>(anetlist, name); } }; - class factory_list_t : public pvector_t<powned_ptr<base_factory_t>> + class factory_list_t : public plib::pvector_t<plib::powned_ptr<base_factory_t>> { public: factory_list_t(setup_t &m_setup); ~factory_list_t(); - template<class _device_class> + template<class device_class> void register_device(const pstring &name, const pstring &classname, const pstring &def_param) { - register_device(powned_ptr<base_factory_t>::Create<factory_t<_device_class>>(name, classname, def_param)); + register_device(plib::powned_ptr<base_factory_t>::Create<factory_t<device_class>>(name, classname, def_param)); } - void register_device(powned_ptr<base_factory_t> factory) + void register_device(plib::powned_ptr<base_factory_t> factory) { for (auto & e : *this) if (e->name() == factory->name()) @@ -85,13 +85,13 @@ namespace netlist //ATTR_COLD device_t *new_device_by_classname(const pstring &classname) const; // FIXME: legacy, should use factory_by_name - powned_ptr<device_t> new_device_by_name(const pstring &devname, netlist_t &anetlist, const pstring &name); + plib::powned_ptr<device_t> new_device_by_name(const pstring &devname, netlist_t &anetlist, const pstring &name); base_factory_t * factory_by_name(const pstring &devname); - template <class _class> + template <class C> bool is_class(base_factory_t *f) { - return dynamic_cast<factory_t<_class> *>(f) != nullptr; + return dynamic_cast<factory_t<C> *>(f) != nullptr; } private: diff --git a/src/lib/netlist/nl_lists.h b/src/lib/netlist/nl_lists.h index 6eaca97906f..bedfc002588 100644 --- a/src/lib/netlist/nl_lists.h +++ b/src/lib/netlist/nl_lists.h @@ -22,7 +22,7 @@ namespace netlist { - template <class _Element, class _Time> + template <class Element, class Time> class timed_queue { P_PREVENT_COPYING(timed_queue) @@ -39,10 +39,10 @@ namespace netlist ATTR_HOT entry_t(const entry_t &right) NOEXCEPT : m_exec_time(right.m_exec_time), m_object(right.m_object) {} #endif - ATTR_HOT entry_t(const _Time &atime, const _Element &elem) NOEXCEPT + ATTR_HOT entry_t(const Time &atime, const Element &elem) NOEXCEPT : m_exec_time(atime), m_object(elem) {} - ATTR_HOT const _Time &exec_time() const { return m_exec_time; } - ATTR_HOT const _Element &object() const { return m_object; } + ATTR_HOT const Time &exec_time() const { return m_exec_time; } + ATTR_HOT const Element &object() const { return m_object; } #if 0 ATTR_HOT entry_t &operator=(const entry_t &right) NOEXCEPT { m_exec_time = right.m_exec_time; @@ -51,8 +51,8 @@ namespace netlist } #endif private: - _Time m_exec_time; - _Element m_object; + Time m_exec_time; + Element m_object; }; timed_queue(unsigned list_size) @@ -75,7 +75,7 @@ namespace netlist while (m_lock.exchange(1)) { } #endif #if 1 - const _Time t = e.exec_time(); + const Time t = e.exec_time(); entry_t * i = m_end++; for (; t > (i - 1)->exec_time(); i--) { @@ -98,7 +98,7 @@ namespace netlist #if HAS_OPENMP && USE_OPENMP m_lock = 0; #endif - //nl_assert(m_end - m_list < _Size); + //nl_assert(m_end - m_list < Size); } ATTR_HOT const entry_t & pop() NOEXCEPT @@ -111,7 +111,7 @@ namespace netlist return *(m_end-1); } - ATTR_HOT void remove(const _Element &elem) NOEXCEPT + ATTR_HOT void remove(const Element &elem) NOEXCEPT { /* Lock */ #if HAS_OPENMP && USE_OPENMP @@ -145,7 +145,7 @@ namespace netlist * the insert algo above will run into this element and doesn't * need a comparison with queue start. */ - m_list[0] = entry_t(_Time::from_raw(~0), _Element(0)); + m_list[0] = entry_t(Time::from_raw(~0), Element(0)); m_end++; } @@ -167,7 +167,7 @@ namespace netlist volatile std::atomic<int> m_lock; #endif entry_t * m_end; - parray_t<entry_t> m_list; + plib::array_t<entry_t> m_list; }; } diff --git a/src/lib/netlist/nl_parser.cpp b/src/lib/netlist/nl_parser.cpp index 41060df73e6..2aa4366b0ba 100644 --- a/src/lib/netlist/nl_parser.cpp +++ b/src/lib/netlist/nl_parser.cpp @@ -158,7 +158,7 @@ void parser_t::net_truthtable_start() pstring def_param = get_string(); require_token(m_tok_param_right); - powned_ptr<netlist::devices::netlist_base_factory_truthtable_t> ttd = netlist::devices::nl_tt_factory_create(ni, no, hs, + plib::powned_ptr<netlist::devices::netlist_base_factory_truthtable_t> ttd = netlist::devices::nl_tt_factory_create(ni, no, hs, name, name, "+" + def_param); while (true) @@ -287,14 +287,14 @@ void parser_t::net_c() if (n.is(m_tok_param_right)) break; if (!n.is(m_tok_comma)) - error(pfmt("expected a comma, found <{1}>")(n.str()) ); + error(plib::pfmt("expected a comma, found <{1}>")(n.str()) ); } } void parser_t::dippins() { - pstring_vector_t pins; + plib::pstring_vector_t pins; pins.push_back(get_identifier()); require_token(m_tok_comma); @@ -307,15 +307,15 @@ void parser_t::dippins() if (n.is(m_tok_param_right)) break; if (!n.is(m_tok_comma)) - error(pfmt("expected a comma, found <{1}>")(n.str()) ); + error(plib::pfmt("expected a comma, found <{1}>")(n.str()) ); } if ((pins.size() % 2) == 1) error("You must pass an equal number of pins to DIPPINS"); unsigned n = pins.size(); for (unsigned i = 0; i < n / 2; i++) { - m_setup.register_alias(pfmt("{1}")(i+1), pins[i*2]); - m_setup.register_alias(pfmt("{1}")(n-i), pins[i*2 + 1]); + m_setup.register_alias(plib::pfmt("{1}")(i+1), pins[i*2]); + m_setup.register_alias(plib::pfmt("{1}")(n-i), pins[i*2 + 1]); } } @@ -352,8 +352,8 @@ void parser_t::device(const pstring &dev_type) else { base_factory_t *f = m_setup.factory().factory_by_name(dev_type); - pstring_vector_t termlist = f->term_param_list(); - pstring_vector_t def_params = f->def_params(); + plib::pstring_vector_t termlist = f->term_param_list(); + plib::pstring_vector_t def_params = f->def_params(); std::size_t cnt; diff --git a/src/lib/netlist/nl_parser.h b/src/lib/netlist/nl_parser.h index 2a6cc79ad2b..dc30ff056a0 100644 --- a/src/lib/netlist/nl_parser.h +++ b/src/lib/netlist/nl_parser.h @@ -14,12 +14,12 @@ namespace netlist { - class parser_t : public ptokenizer + class parser_t : public plib::ptokenizer { P_PREVENT_COPYING(parser_t) public: - parser_t(pistream &strm, setup_t &setup) - : ptokenizer(strm), m_setup(setup), m_buf(nullptr) {} + parser_t(plib::pistream &strm, setup_t &setup) + : plib::ptokenizer(strm), m_setup(setup), m_buf(nullptr) {} bool parse(const pstring nlname = ""); diff --git a/src/lib/netlist/nl_setup.cpp b/src/lib/netlist/nl_setup.cpp index 53cb1f45a85..8e0b9a11ff2 100644 --- a/src/lib/netlist/nl_setup.cpp +++ b/src/lib/netlist/nl_setup.cpp @@ -100,7 +100,7 @@ void setup_t::namespace_pop() } -void setup_t::register_dev(powned_ptr<device_t> dev) +void setup_t::register_dev(plib::powned_ptr<device_t> dev) { for (auto & d : netlist().m_devices) if (d->name() == dev->name()) @@ -171,14 +171,14 @@ void setup_t::register_alias(const pstring &alias, const pstring &out) void setup_t::register_dippins_arr(const pstring &terms) { - pstring_vector_t list(terms,", "); + plib::pstring_vector_t list(terms,", "); if (list.size() == 0 || (list.size() % 2) == 1) log().fatal("You must pass an equal number of pins to DIPPINS"); unsigned n = list.size(); for (unsigned i = 0; i < n / 2; i++) { - register_alias(pfmt("{1}")(i+1), list[i * 2]); - register_alias(pfmt("{1}")(n-i), list[i * 2 + 1]); + register_alias(plib::pfmt("{1}")(i+1), list[i * 2]); + register_alias(plib::pfmt("{1}")(n-i), list[i * 2 + 1]); } } @@ -307,7 +307,7 @@ void setup_t::register_object(device_t &dev, const pstring &name, object_t &obj) void setup_t::register_link_arr(const pstring &terms) { - pstring_vector_t list(terms,", "); + plib::pstring_vector_t list(terms,", "); if (list.size() < 2) log().fatal("You must pass at least 2 terminals to NET_C"); for (std::size_t i = 1; i < list.size(); i++) @@ -351,7 +351,7 @@ void setup_t::remove_connections(const pstring pin) void setup_t::register_frontier(const pstring attach, const double r_IN, const double r_OUT) { - pstring frontier_name = pfmt("frontier_{1}")(m_frontier_cnt); + pstring frontier_name = plib::pfmt("frontier_{1}")(m_frontier_cnt); m_frontier_cnt++; register_dev("FRONTIER_DEV", frontier_name); register_param(frontier_name + ".RIN", r_IN); @@ -382,7 +382,7 @@ void setup_t::register_frontier(const pstring attach, const double r_IN, const d void setup_t::register_param(const pstring ¶m, const double value) { // FIXME: there should be a better way - register_param(param, pfmt("{1}").e(value,".9")); + register_param(param, plib::pfmt("{1}").e(value,".9")); } void setup_t::register_param(const pstring ¶m, const pstring &value) @@ -496,7 +496,7 @@ devices::nld_base_proxy *setup_t::get_d_a_proxy(core_terminal_t &out) if (proxy == nullptr) { // create a new one ... - pstring x = pfmt("proxy_da_{1}_{2}")(out.name())(m_proxy_cnt); + pstring x = plib::pfmt("proxy_da_{1}_{2}")(out.name())(m_proxy_cnt); auto new_proxy = out_cast.logic_family()->create_d_a_proxy(netlist(), x, &out_cast); m_proxy_cnt++; @@ -528,8 +528,8 @@ void setup_t::connect_input_output(core_terminal_t &in, core_terminal_t &out) if (out.is_analog() && in.is_logic()) { logic_input_t &incast = dynamic_cast<logic_input_t &>(in); - pstring x = pfmt("proxy_ad_{1}_{2}")(in.name())( m_proxy_cnt); - auto proxy = powned_ptr<devices::nld_a_to_d_proxy>::Create(netlist(), x, &incast); + pstring x = plib::pfmt("proxy_ad_{1}_{2}")(in.name())( m_proxy_cnt); + auto proxy = plib::powned_ptr<devices::nld_a_to_d_proxy>::Create(netlist(), x, &incast); incast.set_proxy(proxy.get()); m_proxy_cnt++; @@ -566,8 +566,8 @@ void setup_t::connect_terminal_input(terminal_t &term, core_terminal_t &inp) { logic_input_t &incast = dynamic_cast<logic_input_t &>(inp); log().debug("connect_terminal_input: connecting proxy\n"); - pstring x = pfmt("proxy_ad_{1}_{2}")(inp.name())(m_proxy_cnt); - auto proxy = powned_ptr<devices::nld_a_to_d_proxy>::Create(netlist(), x, &incast); + pstring x = plib::pfmt("proxy_ad_{1}_{2}")(inp.name())(m_proxy_cnt); + auto proxy = plib::powned_ptr<devices::nld_a_to_d_proxy>::Create(netlist(), x, &incast); incast.set_proxy(proxy.get()); m_proxy_cnt++; @@ -632,7 +632,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 = palloc(analog_net_t(netlist(),"net." + t1.name())); + analog_net_t::ptr_t anet = plib::palloc<analog_net_t>(netlist(),"net." + t1.name()); t1.set_net(anet); anet->register_con(t2); anet->register_con(t1); @@ -802,7 +802,7 @@ void setup_t::resolve_inputs() 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()) - errstr += pfmt("Found terminal {1} without a net\n")(term->name()); + errstr += plib::pfmt("Found terminal {1} without a net\n")(term->name()); else if (term->net().num_cons() == 0) log().warning("Found terminal {1} without connections", term->name()); } @@ -849,7 +849,7 @@ void setup_t::start_devices() if (env != "") { log().debug("Creating dynamic logs ...\n"); - pstring_vector_t loglist(env, ":"); + plib::pstring_vector_t loglist(env, ":"); for (pstring ll : loglist) { pstring name = "log_" + ll; @@ -872,10 +872,10 @@ class logic_family_std_proxy_t : public logic_family_desc_t { public: logic_family_std_proxy_t() { } - virtual powned_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_t &anetlist, + virtual plib::powned_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_t &anetlist, const pstring &name, logic_output_t *proxied) const override { - return powned_ptr<devices::nld_base_d_to_a_proxy>::Create<devices::nld_d_to_a_proxy>(anetlist, name, proxied); + return plib::powned_ptr<devices::nld_base_d_to_a_proxy>::Create<devices::nld_d_to_a_proxy>(anetlist, name, proxied); } }; @@ -893,7 +893,7 @@ const logic_family_desc_t *setup_t::family_from_model(const pstring &model) if (e.first == model) return e.second.get(); - auto ret = make_unique_base<logic_family_desc_t, logic_family_std_proxy_t>(); + auto ret = plib::make_unique_base<logic_family_desc_t, logic_family_std_proxy_t>(); ret->m_low_thresh_V = setup_t::model_value(map, "IVL"); ret->m_high_thresh_V = setup_t::model_value(map, "IVH"); @@ -944,7 +944,7 @@ void setup_t::model_parse(const pstring &model_in, model_map_t &map) if (m_models.contains(xmodel)) model_parse(xmodel, map); else - log().fatal("Model doesn't exist {1}\n", xmodel); + log().fatal("Model doesn't exist: <{1}>\n", model_in); } pstring remainder=model.substr(pos+1).trim(); @@ -952,7 +952,7 @@ void setup_t::model_parse(const pstring &model_in, model_map_t &map) log().fatal("Model error {1}\n", model); remainder = remainder.left(remainder.len() - 1); - pstring_vector_t pairs(remainder," ", true); + plib::pstring_vector_t pairs(remainder," ", true); for (pstring &pe : pairs) { int pose = pe.find("="); @@ -994,7 +994,7 @@ nl_double setup_t::model_value(model_map_t &map, const pstring &entity) case 'a': factor = 1e-18; break; default: if (numfac < "0" || numfac > "9") - fatalerror_e(pfmt("Unknown number factor <{1}> in: {2}")(numfac)(entity)); + fatalerror_e(plib::pfmt("Unknown number factor <{1}> in: {2}")(numfac)(entity)); } if (factor != NL_FCONST(1.0)) tmp = tmp.left(tmp.len() - 1); @@ -1021,28 +1021,28 @@ void setup_t::include(const pstring &netlist_name) bool source_string_t::parse(setup_t &setup, const pstring &name) { - pimemstream istrm(m_str.cstr(), m_str.len()); - pomemstream ostrm; + plib::pimemstream istrm(m_str.cstr(), m_str.len()); + plib::pomemstream ostrm; - pimemstream istrm2(ppreprocessor().process(istrm, ostrm)); + plib::pimemstream istrm2(plib::ppreprocessor().process(istrm, ostrm)); return parser_t(istrm2, setup).parse(name); } bool source_mem_t::parse(setup_t &setup, const pstring &name) { - pimemstream istrm(m_str.cstr(), m_str.len()); - pomemstream ostrm; + plib::pimemstream istrm(m_str.cstr(), m_str.len()); + plib::pomemstream ostrm; - pimemstream istrm2(ppreprocessor().process(istrm, ostrm)); + plib::pimemstream istrm2(plib::ppreprocessor().process(istrm, ostrm)); return parser_t(istrm2, setup).parse(name); } bool source_file_t::parse(setup_t &setup, const pstring &name) { - pifilestream istrm(m_filename); - pomemstream ostrm; + plib::pifilestream istrm(m_filename); + plib::pomemstream ostrm; - pimemstream istrm2(ppreprocessor().process(istrm, ostrm)); + plib::pimemstream istrm2(plib::ppreprocessor().process(istrm, ostrm)); return parser_t(istrm2, setup).parse(name); } diff --git a/src/lib/netlist/nl_setup.h b/src/lib/netlist/nl_setup.h index c795cba818b..bb0a6f2d01a 100644 --- a/src/lib/netlist/nl_setup.h +++ b/src/lib/netlist/nl_setup.h @@ -16,56 +16,56 @@ // MACROS / inline netlist definitions //============================================================ -#define NET_STR(_x) # _x +#define NET_STR(x) # x -#define NET_MODEL(_model) \ - setup.register_model(_model); +#define NET_MODEL(model) \ + setup.register_model(model); -#define ALIAS(_alias, _name) \ - setup.register_alias(# _alias, # _name); +#define ALIAS(alias, name) \ + setup.register_alias(# alias, # name); -#define DIPPINS(_pin1, ...) \ - setup.register_dippins_arr( #_pin1 ", " # __VA_ARGS__); +#define DIPPINS(pin1, ...) \ + setup.register_dippins_arr( # pin1 ", " # __VA_ARGS__); /* to be used to reference new library truthtable devices */ -#define NET_REGISTER_DEV(_type, _name) \ - setup.register_dev(# _type, # _name); +#define NET_REGISTER_DEV(type, name) \ + setup.register_dev(# type, # name); -#define NET_CONNECT(_name, _input, _output) \ - setup.register_link(# _name "." # _input, # _output); +#define NET_CONNECT(name, input, output) \ + setup.register_link(# name "." # input, # output); -#define NET_C(_term1, ...) \ - setup.register_link_arr( #_term1 ", " # __VA_ARGS__); +#define NET_C(term1, ...) \ + setup.register_link_arr( # term1 ", " # __VA_ARGS__); -#define PARAM(_name, _val) \ - setup.register_param(# _name, _val); +#define PARAM(name, val) \ + setup.register_param(# name, val); -#define NETDEV_PARAMI(_name, _param, _val) \ - setup.register_param(# _name "." # _param, _val); +#define NETDEV_PARAMI(name, param, val) \ + setup.register_param(# name "." # param, val); -#define NETLIST_NAME(_name) netlist ## _ ## _name +#define NETLIST_NAME(name) netlist ## _ ## name -#define NETLIST_EXTERNAL(_name) \ - ATTR_COLD void NETLIST_NAME(_name)(netlist::setup_t &setup); +#define NETLIST_EXTERNAL(name) \ + ATTR_COLD void NETLIST_NAME(name)(netlist::setup_t &setup); -#define NETLIST_START(_name) \ -ATTR_COLD void NETLIST_NAME(_name)(netlist::setup_t &setup) \ +#define NETLIST_START(name) \ +ATTR_COLD void NETLIST_NAME(name)(netlist::setup_t &setup) \ { #define NETLIST_END() } -#define LOCAL_SOURCE(_name) \ - setup.register_source(std::make_shared<netlist::source_proc_t>(# _name, &NETLIST_NAME(_name))); +#define LOCAL_SOURCE(name) \ + setup.register_source(std::make_shared<netlist::source_proc_t>(# name, &NETLIST_NAME(name))); -#define LOCAL_LIB_ENTRY(_name) \ - LOCAL_SOURCE(_name) \ - setup.register_lib_entry(# _name); +#define LOCAL_LIB_ENTRY(name) \ + LOCAL_SOURCE(name) \ + setup.register_lib_entry(# name); -#define INCLUDE(_name) \ - setup.include(# _name); +#define INCLUDE(name) \ + setup.include(# name); -#define SUBMODEL(_model, _name) \ - setup.namespace_push(# _name); \ - NETLIST_NAME(_model)(setup); \ +#define SUBMODEL(model, name) \ + setup.namespace_push(# name); \ + NETLIST_NAME(model)(setup); \ setup.namespace_pop(); // ---------------------------------------------------------------------------------------- @@ -90,7 +90,7 @@ namespace netlist class source_t { public: - using list_t = pvector_t<std::shared_ptr<source_t>>; + using list_t = plib::pvector_t<std::shared_ptr<source_t>>; source_t() {} @@ -116,13 +116,13 @@ namespace netlist void register_object(device_t &dev, const pstring &name, object_t &obj); template<class NETLIST_X> - void register_dev_s(powned_ptr<NETLIST_X> dev) + void register_dev_s(plib::powned_ptr<NETLIST_X> dev) { register_dev(std::move(dev)); } - void register_dev(powned_ptr<device_t> dev); + void register_dev(plib::powned_ptr<device_t> dev); void register_dev(const pstring &classname, const pstring &name); void register_lib_entry(const pstring &name); @@ -183,10 +183,10 @@ namespace netlist void model_parse(const pstring &model, model_map_t &map); - plog_base<NL_DEBUG> &log() { return netlist().log(); } - const plog_base<NL_DEBUG> &log() const { return netlist().log(); } + plib::plog_base<NL_DEBUG> &log() { return netlist().log(); } + const plib::plog_base<NL_DEBUG> &log() const { return netlist().log(); } - pvector_t<std::pair<pstring, base_factory_t *>> m_device_factory; + plib::pvector_t<std::pair<pstring, base_factory_t *>> m_device_factory; protected: @@ -209,23 +209,23 @@ namespace netlist netlist_t &m_netlist; - phashmap_t<pstring, pstring> m_alias; - phashmap_t<pstring, param_ref_t> m_params; - phashmap_t<pstring, pstring> m_param_values; - phashmap_t<pstring, core_terminal_t *> m_terminals; + 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; - pvector_t<link_t> m_links; + plib::pvector_t<link_t> m_links; factory_list_t m_factory; - phashmap_t<pstring, pstring> m_models; + plib::hashmap_t<pstring, pstring> m_models; int m_proxy_cnt; int m_frontier_cnt; std::stack<pstring> m_namespace_stack; source_t::list_t m_sources; - pvector_t<pstring> m_lib; + plib::pvector_t<pstring> m_lib; }; diff --git a/src/lib/netlist/nl_time.h b/src/lib/netlist/nl_time.h index fed3bc48cb1..a97a02bc34a 100644 --- a/src/lib/netlist/nl_time.h +++ b/src/lib/netlist/nl_time.h @@ -14,9 +14,9 @@ // MACROS //============================================================ -#define NLTIME_FROM_NS(_t) netlist_time::from_nsec(_t) -#define NLTIME_FROM_US(_t) netlist_time::from_usec(_t) -#define NLTIME_FROM_MS(_t) netlist_time::from_msec(_t) +#define NLTIME_FROM_NS(t) netlist_time::from_nsec(t) +#define NLTIME_FROM_US(t) netlist_time::from_usec(t) +#define NLTIME_FROM_MS(t) netlist_time::from_msec(t) #define NLTIME_IMMEDIATE netlist_time::from_nsec(1) // ---------------------------------------------------------------------------------------- @@ -37,7 +37,7 @@ namespace netlist static const pstate_data_type_e STATETYPE = DT_INT128; #else using INTERNALTYPE = UINT64; - static const pstate_data_type_e STATETYPE = DT_INT64; + static const pstate_data_type_e STATETYPE = pstate_data_type_e::DT_INT64; #endif static const INTERNALTYPE RESOLUTION = NETLIST_INTERNAL_RES; @@ -137,10 +137,11 @@ namespace netlist } +PLIB_NAMESPACE_START() template<> ATTR_COLD inline void pstate_manager_t::save_item(netlist::netlist_time &nlt, const void *owner, const pstring &stname) { save_state_ptr(stname, netlist::netlist_time::STATETYPE, owner, sizeof(netlist::netlist_time::INTERNALTYPE), 1, nlt.get_internaltype_ptr(), false); } - +PLIB_NAMESPACE_END() #endif /* NLTIME_H_ */ diff --git a/src/lib/netlist/nl_util.h b/src/lib/netlist/nl_util.h index f25a0d13320..54e0090119d 100644 --- a/src/lib/netlist/nl_util.h +++ b/src/lib/netlist/nl_util.h @@ -33,7 +33,7 @@ public: if (ret == "") ret = elem; else -#ifdef _WIN32 +#ifdef WIN32 ret = ret + '\\' + elem; #else ret = ret + '/' + elem; @@ -70,7 +70,7 @@ public: template <typename T> static T log(const T &x) { return std::log(x); } - #if defined(_MSC_VER) && _MSC_VER < 1800 + #if defined(MSC_VER) && MSC_VER < 1800 ATTR_HOT inline static double e_log1p(const double &x) { return nl_math::log(1.0 + x); } ATTR_HOT inline static float e_log1p(const float &x) { return nl_math::log(1.0 + x); } #else @@ -123,89 +123,6 @@ public: }; -template <typename _SC> -class powned_ptr -{ -private: - powned_ptr() - : m_ptr(nullptr), m_is_owned(true) { } -public: - powned_ptr(_SC *p, bool owned) - : m_ptr(p), m_is_owned(owned) - { } - powned_ptr(const powned_ptr &r) = delete; - powned_ptr & operator =(const powned_ptr &r) = delete; - - powned_ptr(powned_ptr &&r) - { - m_is_owned = r.m_is_owned; - m_ptr = r.m_ptr; - r.m_is_owned = false; - r.m_ptr = nullptr; - } - - template<typename _DC> - powned_ptr(powned_ptr<_DC> &&r) - { - _SC *dest_ptr = &dynamic_cast<_SC &>(*r.get()); - bool o = r.is_owned(); - r.release(); - m_is_owned = o; - m_ptr = dest_ptr; - } - - ~powned_ptr() - { - if (m_is_owned) - delete m_ptr; - } - template<typename _DC, typename... _Args> - static powned_ptr Create(_Args&&... __args) - { - powned_ptr a; - _DC *x = new _DC(std::forward<_Args>(__args)...); - a.m_ptr = static_cast<_SC *>(x); - return a; - } - - template<typename... _Args> - static powned_ptr Create(_Args&&... __args) - { - powned_ptr a; - a.m_ptr = new _SC(std::forward<_Args>(__args)...); - return a; - } - void release() - { - m_is_owned = false; - m_ptr = nullptr; - } - - bool is_owned() const { return m_is_owned; } - - template<typename _DC> - powned_ptr<_DC> & operator =(powned_ptr<_DC> &r) - { - m_is_owned = r.m_is_owned; - m_ptr = r.m_ptr; - r.m_is_owned = false; - r.m_ptr = nullptr; - return *this; - } - _SC * operator ->() { return m_ptr; } - _SC & operator *() { return *m_ptr; } - _SC * get() const { return m_ptr; } -private: - _SC *m_ptr; - bool m_is_owned; -}; - -template<typename _BC, typename _DC, typename... _Args> -static std::unique_ptr<_BC> make_unique_base(_Args&&... __args) -{ - std::unique_ptr<_BC> ret(new _DC(std::forward<_Args>(__args)...)); - return ret; -} #endif /* NL_UTIL_H_ */ diff --git a/src/lib/netlist/plib/palloc.cpp b/src/lib/netlist/plib/palloc.cpp index efa42964434..c3d674f7519 100644 --- a/src/lib/netlist/plib/palloc.cpp +++ b/src/lib/netlist/plib/palloc.cpp @@ -9,6 +9,9 @@ #include "pconfig.h" #include "palloc.h" + +PLIB_NAMESPACE_START() + //============================================================ // Exceptions //============================================================ @@ -19,42 +22,6 @@ pexception::pexception(const pstring &text) fprintf(stderr, "%s\n", m_text.cstr()); } -#if (PSTANDALONE) -#include <stdlib.h> -#include <xmmintrin.h> - -class pmemory_pool -{ -public: - pmemory_pool() {} -}; - -static pmemory_pool sppool; - -pmemory_pool *ppool = &sppool; - -void* operator new(std::size_t size, pmemory_pool *pool) throw (std::bad_alloc) -{ - return palloc_raw(size);; -} - -void operator delete(void *ptr, pmemory_pool *pool) -{ - if (ptr != nullptr) - pfree_raw(ptr); -} - -void *palloc_raw(const size_t size) -{ - return _mm_malloc(size, 64); -} - -void pfree_raw(void *p) -{ - _mm_free(p); -} -#endif - pmempool::pmempool(int min_alloc, int min_align) : m_min_alloc(min_alloc), m_min_align(min_align) { @@ -127,3 +94,5 @@ void pmempool::free(void *ptr) } b->m_num_alloc--; } + +PLIB_NAMESPACE_END() diff --git a/src/lib/netlist/plib/palloc.h b/src/lib/netlist/plib/palloc.h index bc0b18a2ff8..bd994466226 100644 --- a/src/lib/netlist/plib/palloc.h +++ b/src/lib/netlist/plib/palloc.h @@ -16,6 +16,28 @@ #include "pconfig.h" #include "pstring.h" +#if (PSTANDALONE) +#include <cstddef> +#include <new> + +#if defined(__GNUC__) && (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) +#if !defined(__ppc__) && !defined (__PPC__) && !defined(__ppc64__) && !defined(__PPC64__) +#define ATTR_ALIGN __attribute__ ((aligned(64))) +#else +#define ATTR_ALIGN +#endif +#else +#define ATTR_ALIGN +#endif + +#else + +#define ATTR_ALIGN + +#endif + +PLIB_NAMESPACE_START() + //============================================================ // exception base //============================================================ @@ -36,97 +58,112 @@ private: // Memory allocation //============================================================ -#if (PSTANDALONE) -#include <cstddef> -#include <new> - -#if defined(__GNUC__) && (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) -#if !defined(__ppc__) && !defined (__PPC__) && !defined(__ppc64__) && !defined(__PPC64__) -#define ATTR_ALIGN __attribute__ ((aligned(64))) -#else -#define ATTR_ALIGN -#endif -#else -#define ATTR_ALIGN -#endif - -class pmemory_pool; - -extern pmemory_pool *ppool; - -void *palloc_raw(const size_t size); -void pfree_raw(void *p); - -void* operator new(std::size_t size, pmemory_pool *pool) throw (std::bad_alloc); +template<typename T, typename... Args> +T *palloc(Args&&... args) +{ + return new T(std::forward<Args>(args)...); +} -void operator delete(void *ptr, pmemory_pool *pool); +template<typename T> +void pfree(T *ptr) { delete ptr; } template<typename T> -inline void pfree_t(T *p) +inline T* palloc_array(std::size_t num) { - p->~T(); - pfree_raw(p); + return new T[num](); } -template <typename T> -inline T *palloc_array_t(size_t N) -{ - char *buf = reinterpret_cast<char *>(palloc_raw(N * sizeof(T) + 64*2)); - size_t *s = reinterpret_cast<size_t *>(buf); - *s = N; - buf += 64; - T *p = reinterpret_cast<T *>(buf); - for (size_t i = 0; i < N; i++) - new(reinterpret_cast<void *>(&p[i])) T(); - return p; +template<typename T> +void pfree_array(T *ptr) { delete [] ptr; } + +template<typename T, typename... Args> +std::unique_ptr<T> pmake_unique(Args&&... args) { + return std::unique_ptr<T>(new T(std::forward<Args>(args)...)); } -template <typename T> -inline void pfree_array_t(T *p) +template<typename BC, typename DC, typename... Args> +static std::unique_ptr<BC> make_unique_base(Args&&... args) { - char *buf = reinterpret_cast<char *>(p); - buf -= 64; - size_t *s = reinterpret_cast<size_t *>(buf); - size_t N = *s; - while (N > 0) - { - p->~T(); - p++; - N--; - } - pfree_raw(s); + std::unique_ptr<BC> ret(new DC(std::forward<Args>(args)...)); + return ret; } -#if 0 -#define palloc(T) new(ppool) T -#define pfree(_ptr) pfree_t(_ptr) - -#define palloc_array(T, N) palloc_array_t<T>(N) -#define pfree_array(_ptr) pfree_array_t(_ptr) -#else -#define palloc(T) new T -#define pfree(_ptr) delete _ptr +template <typename SC> +class powned_ptr +{ +private: + powned_ptr() + : m_ptr(nullptr), m_is_owned(true) { } +public: + powned_ptr(SC *p, bool owned) + : m_ptr(p), m_is_owned(owned) + { } + powned_ptr(const powned_ptr &r) = delete; + powned_ptr & operator =(const powned_ptr &r) = delete; -#define palloc_array(T, N) new T[N] -#define pfree_array(_ptr) delete[] _ptr -#endif -#else -#include "corealloc.h" + powned_ptr(powned_ptr &&r) + { + m_is_owned = r.m_is_owned; + m_ptr = r.m_ptr; + r.m_is_owned = false; + r.m_ptr = nullptr; + } -#define ATTR_ALIGN + template<typename DC> + powned_ptr(powned_ptr<DC> &&r) + { + SC *dest_ptr = &dynamic_cast<SC &>(*r.get()); + bool o = r.is_owned(); + r.release(); + m_is_owned = o; + m_ptr = dest_ptr; + } -#define palloc(T) global_alloc(T) -#define pfree(_ptr) global_free(_ptr) + ~powned_ptr() + { + if (m_is_owned) + delete m_ptr; + } + template<typename DC, typename... Args> + static powned_ptr Create(Args&&... args) + { + powned_ptr a; + DC *x = new DC(std::forward<Args>(args)...); + a.m_ptr = static_cast<SC *>(x); + return a; + } -#define palloc_array(T, N) global_alloc_array(T, N) -#define pfree_array(_ptr) global_free_array(_ptr) + template<typename... Args> + static powned_ptr Create(Args&&... args) + { + powned_ptr a; + a.m_ptr = new SC(std::forward<Args>(args)...); + return a; + } + void release() + { + m_is_owned = false; + m_ptr = nullptr; + } -#endif + bool is_owned() const { return m_is_owned; } -template<typename T, typename... Args> -std::unique_ptr<T> pmake_unique(Args&&... args) { - return std::unique_ptr<T>(new T(std::forward<Args>(args)...)); -} + template<typename DC> + powned_ptr<DC> & operator =(powned_ptr<DC> &r) + { + m_is_owned = r.m_is_owned; + m_ptr = r.m_ptr; + r.m_is_owned = false; + r.m_ptr = nullptr; + return *this; + } + SC * operator ->() { return m_ptr; } + SC & operator *() { return *m_ptr; } + SC * get() const { return m_ptr; } +private: + SC *m_ptr; + bool m_is_owned; +}; class pmempool { @@ -161,5 +198,6 @@ public: std::vector<block> m_blocks; }; +PLIB_NAMESPACE_END() -#endif /* NLCONFIG_H_ */ +#endif /* PALLOC_H_ */ diff --git a/src/lib/netlist/plib/pconfig.h b/src/lib/netlist/plib/pconfig.h index 82c71c2f2a8..652d5f807a0 100644 --- a/src/lib/netlist/plib/pconfig.h +++ b/src/lib/netlist/plib/pconfig.h @@ -9,6 +9,8 @@ #define PCONFIG_H_ #include <cstdint> +#include <thread> +#include <chrono> #ifndef PSTANDALONE #define PSTANDALONE (0) @@ -21,10 +23,12 @@ #endif #if (PHAS_INT128) -typedef __uint128_t UINT128; -typedef __int128_t INT128; +typedef _uint128_t UINT128; +typedef _int128_t INT128; #endif +#define PLIB_NAMESPACE_START() namespace plib { +#define PLIB_NAMESPACE_END() } #if !(PSTANDALONE) #include "osdcomm.h" @@ -47,10 +51,10 @@ typedef __int128_t INT128; //============================================================ // prevent implicit copying -#define P_PREVENT_COPYING(_name) \ - private: \ - _name(const _name &); \ - _name &operator=(const _name &); +#define P_PREVENT_COPYING(name) \ + private: \ + name(const name &); \ + name &operator=(const name &); //============================================================ // Compiling standalone @@ -73,7 +77,7 @@ typedef __int128_t INT128; /* does not work in versions over 4.7.x of 32bit MINGW */ #if defined(__MINGW32__) && !defined(__x86_64) && defined(__i386__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7))) #define PHAS_PMF_INTERNAL 1 - #define MEMBER_ABI __thiscall + #define MEMBER_ABI _thiscall #elif defined(EMSCRIPTEN) #define PHAS_PMF_INTERNAL 0 #elif defined(__arm__) || defined(__ARMEL__) @@ -108,16 +112,16 @@ typedef unsigned short UINT16; typedef signed short INT16; /* 32-bit values */ -#ifndef _WINDOWS_H +#ifndef WINDOWS_H typedef unsigned int UINT32; typedef signed int INT32; #endif /* 64-bit values */ -#ifndef _WINDOWS_H +#ifndef WINDOWS_H #ifdef _MSC_VER -typedef signed __int64 INT64; -typedef unsigned __int64 UINT64; +typedef signed _int64 INT64; +typedef unsigned _int64 UINT64; #else typedef uint64_t UINT64; typedef int64_t INT64; @@ -135,38 +139,64 @@ typedef int64_t INT64; #endif +PLIB_NAMESPACE_START() + +using ticks_t = INT64; + +static inline ticks_t ticks() +{ + return std::chrono::high_resolution_clock::now().time_since_epoch().count(); +} +static inline ticks_t ticks_per_second() +{ + return std::chrono::high_resolution_clock::period::den / std::chrono::high_resolution_clock::period::num; +} + +#if defined(__x86_64__) && !defined(_clang__) && !defined(_MSC_VER) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 6)) + +static inline ticks_t profile_ticks() +{ + unsigned hi, lo; + __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi)); + return ( (unsigned long long)lo)|( ((unsigned long long)hi)<<32 ); +} + +#else +static inline ticks_t profile_ticks() { return ticks(); } +#endif + /* * The following class was derived from the MAME delegate.h code. * It derives a pointer to a member function. */ #if (PHAS_PMF_INTERNAL) -class pmfp +class mfp { public: // construct from any member function pointer class generic_class; using generic_function = void (*)(); - template<typename _MemberFunctionType> - pmfp(_MemberFunctionType mfp) + template<typename MemberFunctionType> + mfp(MemberFunctionType mftp) : m_function(0), m_this_delta(0) { - *reinterpret_cast<_MemberFunctionType *>(this) = mfp; + *reinterpret_cast<MemberFunctionType *>(this) = mftp; } // binding helper - template<typename _FunctionType, typename _ObjectType> - _FunctionType update_after_bind(_ObjectType *object) + template<typename FunctionType, typename ObjectType> + FunctionType update_after_bind(ObjectType *object) { - return reinterpret_cast<_FunctionType>( + return reinterpret_cast<FunctionType>( convert_to_generic(reinterpret_cast<generic_class *>(object))); } - template<typename _FunctionType, typename _MemberFunctionType, typename _ObjectType> - static _FunctionType get_mfp(_MemberFunctionType mfp, _ObjectType *object) + template<typename FunctionType, typename MemberFunctionType, typename ObjectType> + static FunctionType get_mfp(MemberFunctionType mftp, ObjectType *object) { - pmfp mfpo(mfp); - return mfpo.update_after_bind<_FunctionType>(object); + mfp mfpo(mftp); + return mfpo.update_after_bind<FunctionType>(object); } private: @@ -191,6 +221,9 @@ private: // if odd, it's the byte offset into the vtable int m_this_delta; // delta to apply to the 'this' pointer }; + +PLIB_NAMESPACE_END() + #endif #endif /* PCONFIG_H_ */ diff --git a/src/lib/netlist/plib/pdynlib.cpp b/src/lib/netlist/plib/pdynlib.cpp index d08f194a137..f1901e4dda3 100644 --- a/src/lib/netlist/plib/pdynlib.cpp +++ b/src/lib/netlist/plib/pdynlib.cpp @@ -1,21 +1,23 @@ // license:GPL-2.0+ // copyright-holders:Couriersud /* - * pdynlib.c + * dynlib.c * */ -#include "pdynlib.h" -#ifdef _WIN32 +#include <plib/pdynlib.h> +#ifdef WIN32 #include "windows.h" #else #include <dlfcn.h> #endif -pdynlib::pdynlib(const pstring libname) +PLIB_NAMESPACE_START() + +dynlib::dynlib(const pstring libname) : m_isLoaded(false), m_lib(nullptr) { -#ifdef _WIN32 +#ifdef WIN32 //fprintf(stderr, "win: loading <%s>\n", libname.cstr()); if (libname != "") m_lib = LoadLibrary(libname.cstr()); @@ -38,11 +40,11 @@ pdynlib::pdynlib(const pstring libname) #endif } -pdynlib::pdynlib(const pstring path, const pstring libname) +dynlib::dynlib(const pstring path, const pstring libname) : m_isLoaded(false), m_lib(nullptr) { // printf("win: loading <%s>\n", libname.cstr()); -#ifdef _WIN32 +#ifdef WIN32 if (libname != "") m_lib = LoadLibrary(libname.cstr()); else @@ -68,11 +70,11 @@ pdynlib::pdynlib(const pstring path, const pstring libname) #endif } -pdynlib::~pdynlib() +dynlib::~dynlib() { if (m_lib != nullptr) { -#ifdef _WIN32 +#ifdef WIN32 #else dlclose(m_lib); //printf("Closed %s\n", dlerror()); @@ -80,16 +82,18 @@ pdynlib::~pdynlib() } } -bool pdynlib::isLoaded() const +bool dynlib::isLoaded() const { return m_isLoaded; } -void *pdynlib::getsym_p(const pstring name) +void *dynlib::getsym_p(const pstring name) { -#ifdef _WIN32 +#ifdef WIN32 return (void *) GetProcAddress((HMODULE) m_lib, name.cstr()); #else return dlsym(m_lib, name.cstr()); #endif } + +PLIB_NAMESPACE_END() diff --git a/src/lib/netlist/plib/pdynlib.h b/src/lib/netlist/plib/pdynlib.h index 66a2d63b302..71b885d2b8f 100644 --- a/src/lib/netlist/plib/pdynlib.h +++ b/src/lib/netlist/plib/pdynlib.h @@ -4,8 +4,8 @@ * pstring.h */ -#ifndef _PDYNLIB_H_ -#define _PDYNLIB_H_ +#ifndef PDYNLIB_H_ +#define PDYNLIB_H_ #include <cstdarg> #include <cstddef> @@ -13,16 +13,18 @@ #include "pconfig.h" #include "pstring.h" +PLIB_NAMESPACE_START() + // ---------------------------------------------------------------------------------------- // pdynlib: dynamic loading of libraries ... // ---------------------------------------------------------------------------------------- -class pdynlib +class dynlib { public: - pdynlib(const pstring libname); - pdynlib(const pstring path, const pstring libname); - ~pdynlib(); + dynlib(const pstring libname); + dynlib(const pstring path, const pstring libname); + ~dynlib(); bool isLoaded() const; @@ -38,4 +40,6 @@ private: void *m_lib; }; -#endif /* _PSTRING_H_ */ +PLIB_NAMESPACE_END() + +#endif /* PSTRING_H_ */ diff --git a/src/lib/netlist/plib/pfmtlog.cpp b/src/lib/netlist/plib/pfmtlog.cpp index 25ed4c4d391..90e743b8125 100644 --- a/src/lib/netlist/plib/pfmtlog.cpp +++ b/src/lib/netlist/plib/pfmtlog.cpp @@ -16,6 +16,8 @@ #include "pfmtlog.h" #include "palloc.h" +PLIB_NAMESPACE_START() + pfmt::pfmt(const pstring &fmt) : m_str(m_str_buf), m_allocated(0), m_arg(0) { @@ -23,7 +25,7 @@ pfmt::pfmt(const pstring &fmt) if (l>sizeof(m_str_buf)) { m_allocated = 2 * l; - m_str = palloc_array(char, 2 * l); + m_str = palloc_array<char>(2 * l); } memcpy(m_str, fmt.cstr(), l); } @@ -35,7 +37,7 @@ pfmt::pfmt(const char *fmt) if (l>sizeof(m_str_buf)) { m_allocated = 2 * l; - m_str = palloc_array(char, 2 * l); + m_str = palloc_array<char>(2 * l); } memcpy(m_str, fmt, l); } @@ -148,7 +150,7 @@ void pfmt::format_element(const char *f, const char *l, const char *fmt_spec, . m_allocated = old_alloc; while (new_size > m_allocated) m_allocated *= 2; - char *np = palloc_array(char, m_allocated); + char *np = palloc_array<char>(m_allocated); memcpy(np, m_str, old_alloc); p = np + (p - m_str); if (m_str != m_str_buf) @@ -161,4 +163,7 @@ void pfmt::format_element(const char *f, const char *l, const char *fmt_spec, . } va_end(ap); } + +PLIB_NAMESPACE_END() + #endif diff --git a/src/lib/netlist/plib/pfmtlog.h b/src/lib/netlist/plib/pfmtlog.h index d72bdc6ce6b..1aff9473311 100644 --- a/src/lib/netlist/plib/pfmtlog.h +++ b/src/lib/netlist/plib/pfmtlog.h @@ -4,8 +4,8 @@ * pfmtlog.h */ -#ifndef _PFMT_H_ -#define _PFMT_H_ +#ifndef PFMT_H_ +#define PFMT_H_ //#include <cstdarg> //#include <cstddef> @@ -14,6 +14,8 @@ #include "pstring.h" #include "ptypes.h" +PLIB_NAMESPACE_START() + template <typename T> struct ptype_treats { @@ -293,4 +295,7 @@ void plog_channel<L, build_enabled>::vdowrite(const pstring &ls) const m_base->vlog(L, ls); } -#endif /* _PSTRING_H_ */ +PLIB_NAMESPACE_END() + + +#endif /* PSTRING_H_ */ diff --git a/src/lib/netlist/plib/plists.h b/src/lib/netlist/plib/plists.h index b77d034a9c2..c2a4f44565a 100644 --- a/src/lib/netlist/plib/plists.h +++ b/src/lib/netlist/plib/plists.h @@ -19,22 +19,24 @@ #include "palloc.h" #include "pstring.h" +PLIB_NAMESPACE_START() + // ---------------------------------------------------------------------------------------- // parray_t: dynamic array // ---------------------------------------------------------------------------------------- -template <class _ListClass> -class parray_t +template <class LC> +class array_t { public: - ATTR_COLD parray_t(std::size_t numElements) + ATTR_COLD array_t(std::size_t numElements) : m_list(0), m_capacity(0) { set_capacity(numElements); } - ATTR_COLD parray_t(const parray_t &rhs) + ATTR_COLD array_t(const array_t &rhs) : m_list(0), m_capacity(0) { set_capacity(rhs.size()); @@ -42,7 +44,7 @@ public: m_list[i] = rhs[i]; } - ATTR_COLD parray_t &operator=(const parray_t &rhs) + ATTR_COLD array_t &operator=(const array_t &rhs) { set_capacity(rhs.size()); for (std::size_t i=0; i<m_capacity; i++) @@ -50,15 +52,15 @@ public: return *this; } - ~parray_t() + ~array_t() { if (m_list != nullptr) pfree_array(m_list); m_list = nullptr; } - ATTR_HOT _ListClass& operator[](const std::size_t index) { return m_list[index]; } - ATTR_HOT const _ListClass& operator[](const std::size_t index) const { return m_list[index]; } + ATTR_HOT LC& operator[](const std::size_t index) { return m_list[index]; } + ATTR_HOT const LC& operator[](const std::size_t index) const { return m_list[index]; } ATTR_HOT std::size_t size() const { return m_capacity; } @@ -73,7 +75,7 @@ protected: if (m_list != nullptr) pfree_array(m_list); if (new_capacity > 0) - m_list = palloc_array(_ListClass, new_capacity); + m_list = palloc_array<LC>(new_capacity); else m_list = nullptr; m_capacity = new_capacity; @@ -81,7 +83,7 @@ protected: private: - _ListClass * m_list; + LC * m_list; int m_capacity; }; @@ -89,32 +91,32 @@ private: // plist_t: a simple list // ---------------------------------------------------------------------------------------- -template <typename _ListClass> -class pvector_t : public std::vector<_ListClass> +template <typename LC> +class pvector_t : public std::vector<LC> { public: - pvector_t() : std::vector<_ListClass>() {} + pvector_t() : std::vector<LC>() {} void clear_and_free() { - for (_ListClass i : *this) + for (LC i : *this) { pfree(i); } this->clear(); } - bool contains(const _ListClass &elem) const + bool contains(const LC &elem) const { return (std::find(this->begin(), this->end(), elem) != this->end()); } - void remove(const _ListClass &elem) + void remove(const LC &elem) { this->erase(std::remove(this->begin(), this->end(), elem), this->end()); } - ATTR_HOT void insert_at(const std::size_t index, const _ListClass &elem) + ATTR_HOT void insert_at(const std::size_t index, const LC &elem) { this->insert(this->begin() + index, elem); } @@ -124,7 +126,7 @@ public: this->erase(this->begin() + pos); } - int indexof(const _ListClass &elem) const + int indexof(const LC &elem) const { for (unsigned i = 0; i < this->size(); i++) { @@ -141,33 +143,33 @@ public: // the list allows insertions / deletions if used properly // ---------------------------------------------------------------------------------------- -template <class _ListClass> -class plinkedlist_t; +template <class LC> +class linkedlist_t; #if 1 -template <class _ListClass> +template <class LC> struct plinkedlist_element_t { public: - friend class plinkedlist_t<_ListClass>; + friend class linkedlist_t<LC>; plinkedlist_element_t() : m_next(nullptr) {} - _ListClass *next() const { return m_next; } + LC *next() const { return m_next; } //private: - _ListClass * m_next; + LC * m_next; }; -template <class _ListClass> -class plinkedlist_t +template <class LC> +class linkedlist_t { public: - plinkedlist_t() : m_head(nullptr) {} + linkedlist_t() : m_head(nullptr) {} #if 0 - ATTR_HOT void insert(const _ListClass &before, _ListClass &elem) + ATTR_HOT void insert(const LC &before, LC &elem) { if (m_head == &before) { @@ -176,7 +178,7 @@ public: } else { - _ListClass *p = m_head; + LC *p = m_head; while (p != nullptr) { if (p->m_next == &before) @@ -191,15 +193,15 @@ public: } } #endif - ATTR_HOT void insert(_ListClass &elem) + ATTR_HOT void insert(LC &elem) { elem.m_next = m_head; m_head = &elem; } - ATTR_HOT void add(_ListClass &elem) + ATTR_HOT void add(LC &elem) { - _ListClass **p = &m_head; + LC **p = &m_head; while (*p != nullptr) { p = &((*p)->m_next); @@ -208,9 +210,9 @@ public: elem.m_next = nullptr; } - ATTR_HOT void remove(const _ListClass &elem) + ATTR_HOT void remove(const LC &elem) { - _ListClass **p; + LC **p; for (p = &m_head; *p != &elem; p = &((*p)->m_next)) { //nl_assert(*p != nullptr); @@ -218,38 +220,38 @@ public: (*p) = elem.m_next; } - ATTR_HOT _ListClass *first() const { return m_head; } + ATTR_HOT LC *first() const { return m_head; } ATTR_HOT void clear() { m_head = nullptr; } ATTR_HOT bool is_empty() const { return (m_head == nullptr); } //private: - _ListClass *m_head; + LC *m_head; }; #else -template <class _ListClass> +template <class LC> struct plinkedlist_element_t { public: - friend class plinkedlist_t<_ListClass>; + friend class linkedlist_t<LC>; plinkedlist_element_t() : m_next(nullptr), m_prev(nullptr) {} - _ListClass *next() const { return m_next; } + LC *next() const { return m_next; } private: - _ListClass * m_next; - _ListClass * m_prev; + LC * m_next; + LC * m_prev; }; -template <class _ListClass> -class plinkedlist_t +template <class LC> +class linkedlist_t { public: - plinkedlist_t() : m_head(nullptr), m_tail(nullptr) {} + linkedlist_t() : m_head(nullptr), m_tail(nullptr) {} - ATTR_HOT void insert(_ListClass &elem) + ATTR_HOT void insert(LC &elem) { if (m_head != nullptr) m_head->m_prev = &elem; @@ -260,7 +262,7 @@ public: m_tail = &elem; } - ATTR_HOT void add(_ListClass &elem) + ATTR_HOT void add(LC &elem) { if (m_tail != nullptr) m_tail->m_next = &elem; @@ -271,7 +273,7 @@ public: m_head = &elem; } - ATTR_HOT void remove(const _ListClass &elem) + ATTR_HOT void remove(const LC &elem) { if (prev(elem) == nullptr) { @@ -293,17 +295,17 @@ public: } - ATTR_HOT static _ListClass *next(const _ListClass &elem) { return static_cast<_ListClass *>(elem.m_next); } - ATTR_HOT static _ListClass *next(const _ListClass *elem) { return static_cast<_ListClass *>(elem->m_next); } - ATTR_HOT static _ListClass *prev(const _ListClass &elem) { return static_cast<_ListClass *>(elem.m_prev); } - ATTR_HOT static _ListClass *prev(const _ListClass *elem) { return static_cast<_ListClass *>(elem->m_prev); } - ATTR_HOT _ListClass *first() const { return m_head; } + ATTR_HOT static LC *next(const LC &elem) { return static_cast<LC *>(elem.m_next); } + ATTR_HOT static LC *next(const LC *elem) { return static_cast<LC *>(elem->m_next); } + ATTR_HOT static LC *prev(const LC &elem) { return static_cast<LC *>(elem.m_prev); } + ATTR_HOT static LC *prev(const LC *elem) { return static_cast<LC *>(elem->m_prev); } + ATTR_HOT LC *first() const { return m_head; } ATTR_HOT void clear() { m_head = m_tail = nullptr; } ATTR_HOT bool is_empty() const { return (m_head == nullptr); } private: - _ListClass *m_head; - _ListClass *m_tail; + LC *m_head; + LC *m_tail; }; #endif @@ -383,26 +385,28 @@ public: template <class C> -struct phash_functor +struct hash_functor { - phash_functor() + hash_functor() + : m_hash(0) {} - phash_functor(const C &v) + hash_functor(const C &v) + : m_hash(v) { - m_hash = v; } - friend unsigned operator%(const phash_functor &lhs, const unsigned &rhs) { return lhs.m_hash % rhs; } - bool operator==(const phash_functor &lhs) const { return (m_hash == lhs.m_hash); } + 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 phash_functor<pstring> +struct hash_functor<pstring> { - phash_functor() + hash_functor() + : m_hash(0) {} - phash_functor(const pstring &v) + hash_functor(const pstring &v) { /* modified djb2 */ const pstring::mem_t *string = v.cstr(); @@ -412,9 +416,9 @@ struct phash_functor<pstring> //result = (result*33) ^ c; m_hash = result; } - friend unsigned operator%(const phash_functor<pstring> &lhs, const unsigned &rhs) { return lhs.m_hash % rhs; } + friend unsigned operator%(const hash_functor<pstring> &lhs, const unsigned &rhs) { return lhs.m_hash % rhs; } unsigned operator()() { return m_hash; } - bool operator==(const phash_functor<pstring> &lhs) const { return (m_hash == lhs.m_hash); } + bool operator==(const hash_functor<pstring> &lhs) const { return (m_hash == lhs.m_hash); } private: unsigned m_hash; }; @@ -452,17 +456,17 @@ private: #endif #endif -template <class K, class V, class H = phash_functor<K> > -class phashmap_t +template <class K, class V, class H = hash_functor<K> > +class hashmap_t { public: - phashmap_t() : m_hash(37) + hashmap_t() : m_hash(37) { for (unsigned i=0; i<m_hash.size(); i++) m_hash[i] = -1; } - ~phashmap_t() + ~hashmap_t() { } @@ -593,7 +597,7 @@ private: } pvector_t<element_t> m_values; - parray_t<int> m_hash; + array_t<int> m_hash; }; // ---------------------------------------------------------------------------------------- @@ -601,8 +605,8 @@ private: // elements must support ">" operator. // ---------------------------------------------------------------------------------------- -template<typename Class> -static inline void psort_list(Class &sl) +template<typename T> +static inline void sort_list(T &sl) { for(unsigned i = 0; i < sl.size(); i++) { @@ -613,4 +617,6 @@ static inline void psort_list(Class &sl) } } +PLIB_NAMESPACE_END() + #endif /* PLISTS_H_ */ diff --git a/src/lib/netlist/plib/poptions.h b/src/lib/netlist/plib/poptions.h index 984db395e2f..1665738ebe4 100644 --- a/src/lib/netlist/plib/poptions.h +++ b/src/lib/netlist/plib/poptions.h @@ -15,22 +15,24 @@ #include "pstring.h" #include "plists.h" +PLIB_NAMESPACE_START() + /*************************************************************************** Options ***************************************************************************/ -class poptions; +class options; -class poption +class option { public: - poption() + option() : m_short(""), m_long(""), m_help(""), m_has_argument(false) {} - poption(pstring ashort, pstring along, pstring help, bool has_argument, poptions *parent = nullptr); + option(pstring ashort, pstring along, pstring help, bool has_argument, options *parent = nullptr); - virtual ~poption() + virtual ~option() { } @@ -45,11 +47,11 @@ public: private: }; -class poption_str : public poption +class option_str : public option { public: - poption_str(pstring ashort, pstring along, pstring defval, pstring help, poptions *parent = nullptr) - : poption(ashort, along, help, true, parent), m_val(defval) + option_str(pstring ashort, pstring along, pstring defval, pstring help, options *parent = nullptr) + : option(ashort, along, help, true, parent), m_val(defval) {} virtual int parse(pstring argument) override { m_val = argument; return 0; } @@ -59,11 +61,11 @@ private: pstring m_val; }; -class poption_str_limit : public poption +class option_str_limit : public option { public: - poption_str_limit(pstring ashort, pstring along, pstring defval, pstring limit, pstring help, poptions *parent = nullptr) - : poption(ashort, along, help, true, parent), m_val(defval), m_limit(limit, ":") + option_str_limit(pstring ashort, pstring along, pstring defval, pstring limit, pstring help, options *parent = nullptr) + : option(ashort, along, help, true, parent), m_val(defval), m_limit(limit, ":") {} virtual int parse(pstring argument) override @@ -83,11 +85,11 @@ private: pstring_vector_t m_limit; }; -class poption_bool : public poption +class option_bool : public option { public: - poption_bool(pstring ashort, pstring along, pstring help, poptions *parent = nullptr) - : poption(ashort, along, help, false, parent), m_val(false) + option_bool(pstring ashort, pstring along, pstring help, options *parent = nullptr) + : option(ashort, along, help, false, parent), m_val(false) {} virtual int parse(ATTR_UNUSED pstring argument) override { m_val = true; return 0; } @@ -97,11 +99,11 @@ private: bool m_val; }; -class poption_double : public poption +class option_double : public option { public: - poption_double(pstring ashort, pstring along, double defval, pstring help, poptions *parent = nullptr) - : poption(ashort, along, help, true, parent), m_val(defval) + option_double(pstring ashort, pstring along, double defval, pstring help, options *parent = nullptr) + : option(ashort, along, help, true, parent), m_val(defval) {} virtual int parse(pstring argument) override @@ -116,13 +118,13 @@ private: double m_val; }; -class poptions +class options { public: - poptions() {} + options() {} - poptions(poption *o[]) + options(option *o[]) { int i=0; while (o[i] != nullptr) @@ -132,12 +134,12 @@ public: } } - ~poptions() + ~options() { m_opts.clear(); } - void register_option(poption *opt) + void register_option(option *opt) { m_opts.push_back(opt); } @@ -149,7 +151,7 @@ public: for (int i=1; i<argc; ) { pstring arg(argv[i]); - poption *opt = nullptr; + option *opt = nullptr; if (arg.startsWith("--")) { @@ -182,7 +184,7 @@ public: for (std::size_t i=0; i<m_opts.size(); i++ ) { - poption *opt = m_opts[i]; + option *opt = m_opts[i]; pstring line = ""; if (opt->m_short != "") line += " -" + opt->m_short; @@ -203,7 +205,7 @@ public: private: - poption *getopt_short(pstring arg) + option *getopt_short(pstring arg) { for (std::size_t i=0; i < m_opts.size(); i++) { @@ -212,7 +214,7 @@ private: } return nullptr; } - poption *getopt_long(pstring arg) + option *getopt_long(pstring arg) { for (std::size_t i=0; i < m_opts.size(); i++) { @@ -222,16 +224,17 @@ private: return nullptr; } - pvector_t<poption *> m_opts; + pvector_t<option *> m_opts; pstring m_app; }; -poption::poption(pstring ashort, pstring along, pstring help, bool has_argument, poptions *parent) +option::option(pstring ashort, pstring along, pstring help, bool has_argument, options *parent) : m_short(ashort), m_long(along), m_help(help), m_has_argument(has_argument) { if (parent != nullptr) parent->register_option(this); } +PLIB_NAMESPACE_END() #endif /* POPTIONS_H_ */ diff --git a/src/lib/netlist/plib/pparser.cpp b/src/lib/netlist/plib/pparser.cpp index 70e48ba5c23..dc0c99e8560 100644 --- a/src/lib/netlist/plib/pparser.cpp +++ b/src/lib/netlist/plib/pparser.cpp @@ -9,6 +9,7 @@ #include "pparser.h" +PLIB_NAMESPACE_START() // ---------------------------------------------------------------------------------------- // A simple tokenizer // ---------------------------------------------------------------------------------------- @@ -21,22 +22,22 @@ pstring ptokenizer::currentline_str() void ptokenizer::skipeol() { - pstring::code_t c = _getc(); + pstring::code_t c = getc(); while (c) { if (c == 10) { - c = _getc(); + c = getc(); if (c != 13) - _ungetc(); + ungetc(); return; } - c = _getc(); + c = getc(); } } -pstring::code_t ptokenizer::_getc() +pstring::code_t ptokenizer::getc() { if (m_px >= m_cur_line.len()) { @@ -51,7 +52,7 @@ pstring::code_t ptokenizer::_getc() return m_cur_line.code_at(m_px++); } -void ptokenizer::_ungetc() +void ptokenizer::ungetc() { m_px--; } @@ -159,10 +160,10 @@ ptokenizer::token_t ptokenizer::get_token() ptokenizer::token_t ptokenizer::get_token_internal() { /* skip ws */ - pstring::code_t c = _getc(); + pstring::code_t c = getc(); while (m_whitespace.find(c)>=0) { - c = _getc(); + c = getc(); if (eof()) { return token_t(ENDOFFILE); @@ -182,9 +183,9 @@ ptokenizer::token_t ptokenizer::get_token_internal() else if (m_number_chars.find(c)<0) break; tokstr += c; - c = _getc(); + c = getc(); } - _ungetc(); + ungetc(); return token_t(ret, tokstr); } else if (m_identifier_chars.find(c)>=0) @@ -193,9 +194,9 @@ ptokenizer::token_t ptokenizer::get_token_internal() pstring tokstr = ""; while (m_identifier_chars.find(c)>=0) { tokstr += c; - c = _getc(); + c = getc(); } - _ungetc(); + ungetc(); token_id_t id = token_id_t(m_tokens.indexof(tokstr)); if (id.id() >= 0) return token_t(id, tokstr); @@ -207,11 +208,11 @@ ptokenizer::token_t ptokenizer::get_token_internal() else if (c == m_string) { pstring tokstr = ""; - c = _getc(); + c = getc(); while (c != m_string) { tokstr += c; - c = _getc(); + c = getc(); } return token_t(STRING, tokstr); } @@ -228,9 +229,9 @@ ptokenizer::token_t ptokenizer::get_token_internal() if (id.id() >= 0) return token_t(id, tokstr); } - c = _getc(); + c = getc(); } - _ungetc(); + ungetc(); token_id_t id = token_id_t(m_tokens.indexof(tokstr)); if (id.id() >= 0) return token_t(id, tokstr); @@ -468,3 +469,5 @@ postream & ppreprocessor::process_i(pistream &istrm, postream &ostrm) } return ostrm; } + +PLIB_NAMESPACE_END() diff --git a/src/lib/netlist/plib/pparser.h b/src/lib/netlist/plib/pparser.h index cf122fec7f8..e5bd3617cda 100644 --- a/src/lib/netlist/plib/pparser.h +++ b/src/lib/netlist/plib/pparser.h @@ -13,6 +13,8 @@ #include "plists.h" #include "pstream.h" +PLIB_NAMESPACE_START() + class ptokenizer { P_PREVENT_COPYING(ptokenizer) @@ -120,8 +122,8 @@ protected: private: void skipeol(); - pstring::code_t _getc(); - void _ungetc(); + pstring::code_t getc(); + void ungetc(); bool eof() { return m_strm.eof(); } @@ -186,7 +188,7 @@ private: pstring process_line(const pstring &line); - phashmap_t<pstring, define_t> m_defines; + hashmap_t<pstring, define_t> m_defines; pstring_vector_t m_expr_sep; //pstringbuffer m_ret; @@ -195,4 +197,6 @@ private: int m_lineno; }; +PLIB_NAMESPACE_END() + #endif /* PPARSER_H_ */ diff --git a/src/lib/netlist/plib/pstate.cpp b/src/lib/netlist/plib/pstate.cpp index 095c8c812be..f0763d5eab4 100644 --- a/src/lib/netlist/plib/pstate.cpp +++ b/src/lib/netlist/plib/pstate.cpp @@ -7,6 +7,8 @@ #include "pstate.h" +PLIB_NAMESPACE_START() + pstate_manager_t::pstate_manager_t() { } @@ -74,3 +76,5 @@ template<> ATTR_COLD void pstate_manager_t::save_item(pstate_callback_t &state, m_save.push_back(std::move(p)); state.register_state(*this, stname); } + +PLIB_NAMESPACE_END() diff --git a/src/lib/netlist/plib/pstate.h b/src/lib/netlist/plib/pstate.h index 9b88f8f562b..5432c37f327 100644 --- a/src/lib/netlist/plib/pstate.h +++ b/src/lib/netlist/plib/pstate.h @@ -32,19 +32,19 @@ enum pstate_data_type_e { DT_FLOAT }; -template<typename _ItemType> struct pstate_datatype +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 *> +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; }; +//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;}; \ @@ -68,6 +68,8 @@ NETLIST_SAVE_TYPE(UINT16, DT_INT16); NETLIST_SAVE_TYPE(INT16, DT_INT16); //NETLIST_SAVE_TYPE(std::size_t, DT_INT64); +PLIB_NAMESPACE_START() + class pstate_manager_t; class pstate_callback_t @@ -185,5 +187,6 @@ public: } }; +PLIB_NAMESPACE_END() #endif /* PSTATE_H_ */ diff --git a/src/lib/netlist/plib/pstream.cpp b/src/lib/netlist/plib/pstream.cpp index 988a403236d..dd3713499d5 100644 --- a/src/lib/netlist/plib/pstream.cpp +++ b/src/lib/netlist/plib/pstream.cpp @@ -13,6 +13,8 @@ #include "pstream.h" #include "palloc.h" +PLIB_NAMESPACE_START() + // ----------------------------------------------------------------------------- // pistream: input stream // ----------------------------------------------------------------------------- @@ -306,7 +308,7 @@ pimemstream::pos_type pimemstream::vtell() pomemstream::pomemstream() : postream(FLAG_SEEKABLE), m_pos(0), m_capacity(1024), m_size(0) { - m_mem = palloc_array(char, m_capacity); + m_mem = palloc_array<char>(m_capacity); } pomemstream::~pomemstream() @@ -321,7 +323,7 @@ void pomemstream::vwrite(const void *buf, const unsigned n) while (m_pos + n >= m_capacity) m_capacity *= 2; char *o = m_mem; - m_mem = palloc_array(char, m_capacity); + m_mem = palloc_array<char>(m_capacity); if (m_mem == nullptr) { set_flag(FLAG_ERROR); @@ -345,7 +347,7 @@ void pomemstream::vseek(const pos_type n) while (m_size >= m_capacity) m_capacity *= 2; char *o = m_mem; - m_mem = palloc_array(char, m_capacity); + m_mem = palloc_array<char>(m_capacity); if (m_mem == nullptr) { set_flag(FLAG_ERROR); @@ -360,3 +362,5 @@ pstream::pos_type pomemstream::vtell() { return m_pos; } + +PLIB_NAMESPACE_END() diff --git a/src/lib/netlist/plib/pstream.h b/src/lib/netlist/plib/pstream.h index fd749a09cce..b0a5c0379da 100644 --- a/src/lib/netlist/plib/pstream.h +++ b/src/lib/netlist/plib/pstream.h @@ -4,8 +4,8 @@ * pstream.h */ -#ifndef _PSTREAM_H_ -#define _PSTREAM_H_ +#ifndef PSTREAM_H_ +#define PSTREAM_H_ #include <cstdarg> #include <cstddef> @@ -16,6 +16,8 @@ #include "palloc.h" #include "pfmtlog.h" +PLIB_NAMESPACE_START() + // ----------------------------------------------------------------------------- // pstream: things common to all streams // ----------------------------------------------------------------------------- @@ -357,7 +359,7 @@ private: // pstream_fmt_writer_t: writer on top of ostream // ----------------------------------------------------------------------------- -class pstream_fmt_writer_t : public pfmt_writer_t<> +class pstream_fmt_writer_t : public plib::pfmt_writer_t<> { P_PREVENT_COPYING(pstream_fmt_writer_t) public: @@ -375,4 +377,6 @@ private: postream &m_strm; }; -#endif /* _PSTREAM_H_ */ +PLIB_NAMESPACE_END() + +#endif /* PSTREAM_H_ */ diff --git a/src/lib/netlist/plib/pstring.cpp b/src/lib/netlist/plib/pstring.cpp index 172d543c06e..7dadb9e6240 100644 --- a/src/lib/netlist/plib/pstring.cpp +++ b/src/lib/netlist/plib/pstring.cpp @@ -364,7 +364,7 @@ void pstring_t<F>::sfree(pstr_t *s) stk[sn].push(s); } else - pfree_array(((char *)s)); + plib::pfree_array(((char *)s)); //_mm_free(((char *)s)); } } @@ -373,19 +373,19 @@ template<typename F> pstr_t *pstring_t<F>::salloc(int n) { if (stk == nullptr) - stk = palloc_array(std::stack<pstr_t *>, 17); + stk = plib::palloc_array<std::stack<pstr_t *>>(17); pstr_t *p; unsigned sn= ((32 - countleadbits(n)) + 1) / 2; unsigned size = sizeof(pstr_t) + ((UINT64) 1<<(sn * 2)) + 1; if (stk[sn].empty()) - p = (pstr_t *) palloc_array(char, size); + p = (pstr_t *) plib::palloc_array<char>(size); else { p = stk[sn].top(); stk[sn].pop(); } - // str_t *p = (str_t *) _mm_malloc(size, 8); + // str_t *p = (str_t *) mm_malloc(size, 8); p->init(n); return p; } @@ -398,11 +398,11 @@ void pstring_t<F>::resetmem() { for (; stk[i].size() > 0; ) { - pfree_array(stk[i].top()); + plib::pfree_array(stk[i].top()); stk[i].pop(); } } - pfree_array(stk); + plib::pfree_array(stk); stk = nullptr; } } @@ -425,7 +425,7 @@ pstr_t *pstring_t<F>::salloc(int n) { int size = sizeof(pstr_t) + n + 1; pstr_t *p = (pstr_t *) palloc_array(char, size); - // str_t *p = (str_t *) _mm_malloc(size, 8); + // str_t *p = (str_t *) mm_malloc(size, 8); p->init(n); return p; } @@ -533,7 +533,7 @@ int pstring_t<F>::pcmp(const mem_t *right) const pstringbuffer::~pstringbuffer() { if (m_ptr != nullptr) - pfree_array(m_ptr); + plib::pfree_array(m_ptr); } void pstringbuffer::resize(const std::size_t size) @@ -543,7 +543,7 @@ void pstringbuffer::resize(const std::size_t size) m_size = DEFAULT_SIZE; while (m_size <= size) m_size *= 2; - m_ptr = palloc_array(char, m_size); + m_ptr = plib::palloc_array<char>(m_size); *m_ptr = 0; m_len = 0; } @@ -551,9 +551,9 @@ void pstringbuffer::resize(const std::size_t size) { while (m_size < size) m_size *= 2; - char *new_buf = palloc_array(char, m_size); + char *new_buf = plib::palloc_array<char>(m_size); std::memcpy(new_buf, m_ptr, m_len + 1); - pfree_array(m_ptr); + plib::pfree_array(m_ptr); m_ptr = new_buf; } } diff --git a/src/lib/netlist/plib/pstring.h b/src/lib/netlist/plib/pstring.h index 18cabd6fce5..5cfe5945fcf 100644 --- a/src/lib/netlist/plib/pstring.h +++ b/src/lib/netlist/plib/pstring.h @@ -4,8 +4,8 @@ * pstring.h */ -#ifndef _PSTRING_H_ -#define _PSTRING_H_ +#ifndef PSTRING_H_ +#define PSTRING_H_ #include <cstdarg> #include <cstddef> @@ -378,4 +378,4 @@ private: }; -#endif /* _PSTRING_H_ */ +#endif /* PSTRING_H_ */ diff --git a/src/lib/netlist/plib/ptypes.h b/src/lib/netlist/plib/ptypes.h index 5ccfe171ed4..a747dc9e8d7 100644 --- a/src/lib/netlist/plib/ptypes.h +++ b/src/lib/netlist/plib/ptypes.h @@ -11,11 +11,13 @@ #include "pconfig.h" #include "pstring.h" +PLIB_NAMESPACE_START() + //============================================================ // penum - strongly typed enumeration //============================================================ -struct penum_base +struct enum_base { protected: static int from_string_int(const char *str, const char *x) @@ -74,10 +76,12 @@ protected: } }; -#define P_ENUM(_name, ...) \ - struct _name : public penum_base { \ +PLIB_NAMESPACE_END() + +#define P_ENUM(ename, ...) \ + struct ename : public plib::enum_base { \ enum e { __VA_ARGS__ }; \ - _name (e v) : m_v(v) { } \ + ename (e v) : m_v(v) { } \ bool set_from_string (const pstring &s) { \ static const char *strings = # __VA_ARGS__; \ int f = from_string_int(strings, s.cstr()); \ @@ -85,7 +89,7 @@ protected: } \ operator e() const {return m_v;} \ int as_int() const {return (int) m_v;} \ - bool operator==(const _name &rhs) const {return m_v == rhs.m_v;} \ + bool operator==(const ename &rhs) const {return m_v == rhs.m_v;} \ bool operator==(const e &rhs) const {return m_v == (int) rhs;} \ const pstring name() const { \ static const char *strings = # __VA_ARGS__; \ diff --git a/src/lib/netlist/prg/nltool.cpp b/src/lib/netlist/prg/nltool.cpp index 362e072b244..ed96b517192 100644 --- a/src/lib/netlist/prg/nltool.cpp +++ b/src/lib/netlist/prg/nltool.cpp @@ -16,7 +16,7 @@ #endif #endif -#include "plib/poptions.h" +#include <plib/poptions.h> #include "plib/pstring.h" #include "plib/plists.h" #include "plib/ptypes.h" @@ -26,24 +26,11 @@ #include "devices/net_lib.h" #include "tools/nl_convert.h" - -#ifdef PSTANDALONE_PROVIDED - -#include <ctime> - -#define osd_ticks_t clock_t - -inline osd_ticks_t osd_ticks_per_second() { return CLOCKS_PER_SEC; } - -osd_ticks_t osd_ticks(void) { return clock(); } -#endif - - -class tool_options_t : public poptions +class tool_options_t : public plib::options { public: tool_options_t() : - poptions(), + plib::options(), opt_ttr ("t", "time_to_run", 1.0, "time to run the emulation (seconds)", this), opt_name("n", "name", "", "netlist in file to run; default is first one", this), opt_logs("l", "logs", "", "colon separated list of terminals to log", this), @@ -56,23 +43,23 @@ public: opt_help("h", "help", "display help", this) {} - poption_double opt_ttr; - poption_str opt_name; - poption_str opt_logs; - poption_str opt_file; - poption_str_limit opt_type; - poption_str opt_cmd; - poption_str opt_inp; - poption_bool opt_verb; - poption_bool opt_quiet; - poption_bool opt_help; + plib::option_double opt_ttr; + plib::option_str opt_name; + plib::option_str opt_logs; + plib::option_str opt_file; + plib::option_str_limit opt_type; + plib::option_str opt_cmd; + plib::option_str opt_inp; + plib::option_bool opt_verb; + plib::option_bool opt_quiet; + plib::option_bool opt_help; }; -pstdout pout_strm; -pstderr perr_strm; +plib::pstdout pout_strm; +plib::pstderr perr_strm; -pstream_fmt_writer_t pout(pout_strm); -pstream_fmt_writer_t perr(perr_strm); +plib::pstream_fmt_writer_t pout(pout_strm); +plib::pstream_fmt_writer_t perr(perr_strm); NETLIST_START(dummy) /* Standard stuff */ @@ -98,12 +85,12 @@ public: ~netlist_tool_t() { if (m_setup != nullptr) - pfree(m_setup); + plib::pfree(m_setup); }; void init() { - m_setup = palloc(netlist::setup_t(*this)); + m_setup = plib::palloc<netlist::setup_t>(*this); } void read_netlist(const pstring &filename, const pstring &name) @@ -124,7 +111,7 @@ public: void log_setup() { log().debug("Creating dynamic logs ...\n"); - pstring_vector_t ll(m_opts ? m_opts->opt_logs() : "" , ":"); + plib::pstring_vector_t ll(m_opts ? m_opts->opt_logs() : "" , ":"); for (unsigned i=0; i < ll.size(); i++) { pstring name = "log_" + ll[i]; @@ -137,10 +124,10 @@ public: protected: - void vlog(const plog_level &l, const pstring &ls) const override + void vlog(const plib::plog_level &l, const pstring &ls) const override { pout("{}: {}\n", l.name().cstr(), ls.cstr()); - if (l == plog_level::FATAL) + if (l == plib::plog_level::FATAL) throw; } @@ -173,7 +160,7 @@ struct input_t double t; int e = sscanf(line.cstr(), "%lf,%[^,],%lf", &t, buf, &m_value); if ( e!= 3) - throw netlist::fatalerror_e(pfmt("error {1} scanning line {2}\n")(e)(line)); + throw netlist::fatalerror_e(plib::pfmt("error {1} scanning line {2}\n")(e)(line)); m_time = netlist::netlist_time::from_double(t); m_param = netlist->setup().find_param(buf, true); } @@ -184,7 +171,7 @@ struct input_t { case netlist::param_t::MODEL: case netlist::param_t::STRING: - throw netlist::fatalerror_e(pfmt("param {1} is not numeric\n")(m_param->name())); + throw netlist::fatalerror_e(plib::pfmt("param {1} is not numeric\n")(m_param->name())); case netlist::param_t::DOUBLE: static_cast<netlist::param_double_t*>(m_param)->setTo(m_value); break; @@ -203,12 +190,12 @@ struct input_t }; -pvector_t<input_t> *read_input(netlist::netlist_t *netlist, pstring fname) +plib::pvector_t<input_t> *read_input(netlist::netlist_t *netlist, pstring fname) { - pvector_t<input_t> *ret = palloc(pvector_t<input_t>()); + plib::pvector_t<input_t> *ret = plib::palloc<plib::pvector_t<input_t>>(); if (fname != "") { - pifilestream f(fname); + plib::pifilestream f(fname); pstring l; while (f.readline(l)) { @@ -225,7 +212,7 @@ pvector_t<input_t> *read_input(netlist::netlist_t *netlist, pstring fname) static void run(tool_options_t &opts) { netlist_tool_t nt("netlist"); - osd_ticks_t t = osd_ticks(); + plib::ticks_t t = plib::ticks(); nt.m_opts = &opts; nt.init(); @@ -237,13 +224,13 @@ static void run(tool_options_t &opts) nt.read_netlist(opts.opt_file(), opts.opt_name()); - pvector_t<input_t> *inps = read_input(&nt, opts.opt_inp()); + plib::pvector_t<input_t> *inps = read_input(&nt, opts.opt_inp()); double ttr = opts.opt_ttr(); - pout("startup time ==> {1:5.3f}\n", (double) (osd_ticks() - t) / (double) osd_ticks_per_second() ); + pout("startup time ==> {1:5.3f}\n", (double) (plib::ticks() - t) / (double) plib::ticks_per_second() ); pout("runnning ...\n"); - t = osd_ticks(); + t = plib::ticks(); unsigned pos = 0; netlist::netlist_time nlt = netlist::netlist_time::zero; @@ -259,7 +246,7 @@ static void run(tool_options_t &opts) nt.stop(); pfree(inps); - double emutime = (double) (osd_ticks() - t) / (double) osd_ticks_per_second(); + 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); } @@ -300,10 +287,10 @@ static void listdevices() for (unsigned i=0; i < list.size(); i++) { auto &f = list[i]; - pstring out = pfmt("{1} {2}(<id>")(f->classname(),"-20")(f->name()); + pstring out = plib::pfmt("{1} {2}(<id>")(f->classname(),"-20")(f->name()); pstring terms(""); - auto d = f->Create(nt.setup().netlist(), pfmt("dummy{1}")(i)); + auto d = f->Create(nt.setup().netlist(), plib::pfmt("dummy{1}")(i)); // get the list of terminals ... for (unsigned j=0; j < d->m_terminals.size(); j++) @@ -384,15 +371,15 @@ int main(int argc, char *argv[]) else if (cmd == "convert") { pstring contents; - postringstream ostrm; + plib::postringstream ostrm; if (opts.opt_file() == "-") { - pstdin f; + plib::pstdin f; ostrm.write(f); } else { - pifilestream f(opts.opt_file()); + plib::pifilestream f(opts.opt_file()); ostrm.write(f); } contents = ostrm.str(); diff --git a/src/lib/netlist/prg/nlwav.cpp b/src/lib/netlist/prg/nlwav.cpp index ebd128af08d..8b53ea8f428 100644 --- a/src/lib/netlist/prg/nlwav.cpp +++ b/src/lib/netlist/prg/nlwav.cpp @@ -1,18 +1,18 @@ // license:GPL-2.0+ // copyright-holders:Couriersud +#include <plib/poptions.h> #include <cstdio> #include <cstring> -#include "plib/poptions.h" #include "plib/pstring.h" #include "plib/plists.h" #include "plib/pstream.h" #include "nl_setup.h" -class nlwav_options_t : public poptions +class nlwav_options_t : public plib::options { public: nlwav_options_t() : - poptions(), + plib::options(), #if 0 opt_ttr ("t", "time_to_run", 1.0, "time to run the emulation (seconds)", this), opt_name("n", "name", "", "netlist in file to run; default is first one", this), @@ -30,26 +30,26 @@ public: opt_help("h", "help", "display help", this) {} #if 0 - poption_double opt_ttr; - poption_str opt_name; - poption_str opt_logs; - poption_str opt_file; + option_double opt_ttr; + option_str opt_name; + option_str opt_logs; + option_str opt_file; poption_str_limit opt_type; - poption_str opt_cmd; + option_str opt_cmd; #endif - poption_str opt_inp; - poption_str opt_out; - poption_double opt_amp; - poption_bool opt_verb; - poption_bool opt_quiet; - poption_bool opt_help; + plib::option_str opt_inp; + plib::option_str opt_out; + plib::option_double opt_amp; + plib::option_bool opt_verb; + plib::option_bool opt_quiet; + plib::option_bool opt_help; }; /* http://de.wikipedia.org/wiki/RIFF_WAVE */ class wav_t { public: - wav_t(postream &strm, unsigned sr) : m_f(strm) + wav_t(plib::postream &strm, unsigned sr) : m_f(strm) { initialize(sr); m_f.write(&m_fh, sizeof(m_fh)); @@ -131,20 +131,20 @@ private: riff_format_t m_fmt; riff_data_t m_data; - postream &m_f; + plib::postream &m_f; }; void convert(nlwav_options_t &opts) { - pofilestream fo(opts.opt_out()); + plib::pofilestream fo(opts.opt_out()); if (fo.bad()) { throw netlist::fatalerror_e("Error opening output file: " + opts.opt_out()); } wav_t wo(fo, 48000); - pifilestream fin(opts.opt_inp()); + plib::pifilestream fin(opts.opt_inp()); if (fin.bad()) throw netlist::fatalerror_e("Error opening input file: " + opts.opt_inp()); diff --git a/src/lib/netlist/solver/mat_cr.h b/src/lib/netlist/solver/mat_cr.h index 6e7c22f4f82..340c662752f 100644 --- a/src/lib/netlist/solver/mat_cr.h +++ b/src/lib/netlist/solver/mat_cr.h @@ -13,13 +13,13 @@ #include <algorithm> #include "plib/pconfig.h" -template<int _storage_N> +template<int storage_N> struct mat_cr_t { unsigned nz_num; - unsigned ia[_storage_N + 1]; - unsigned ja[_storage_N * _storage_N]; - unsigned diag[_storage_N]; /* n */ + unsigned ia[storage_N + 1]; + unsigned ja[storage_N * storage_N]; + unsigned diag[storage_N]; /* n */ template<typename T> void mult_vec(const T * RESTRICT A, const T * RESTRICT x, T * RESTRICT res) diff --git a/src/lib/netlist/solver/nld_matrix_solver.h b/src/lib/netlist/solver/nld_matrix_solver.h index ab6364cb2d3..b4e8da156c8 100644 --- a/src/lib/netlist/solver/nld_matrix_solver.h +++ b/src/lib/netlist/solver/nld_matrix_solver.h @@ -52,9 +52,9 @@ public: unsigned m_railstart; - pvector_t<unsigned> m_nz; /* all non zero for multiplication */ - pvector_t<unsigned> m_nzrd; /* non zero right of the diagonal for elimination, may include RHS element */ - pvector_t<unsigned> m_nzbd; /* non zero below of the diagonal for elimination */ + 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 */ /* state */ nl_double m_last_V; @@ -62,19 +62,19 @@ public: nl_double m_h_n_m_1; private: - pvector_t<int> m_net_other; - pvector_t<nl_double> m_go; - pvector_t<nl_double> m_gt; - pvector_t<nl_double> m_Idr; - pvector_t<nl_double *> m_other_curanalog; - pvector_t<terminal_t *> m_term; + 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; }; class matrix_solver_t : public device_t { public: - using list_t = pvector_t<matrix_solver_t *>; + using list_t = plib::pvector_t<matrix_solver_t *>; using dev_list_t = core_device_t::list_t; enum eSortType @@ -133,13 +133,13 @@ public: public: ATTR_COLD int get_net_idx(net_t *net); - plog_base<NL_DEBUG> &log() { return netlist().log(); } + plib::plog_base<NL_DEBUG> &log() { return netlist().log(); } virtual void log_stats(); - virtual void create_solver_code(postream &strm) + virtual void create_solver_code(plib::postream &strm) { - strm.writeline(pfmt("/* {1} doesn't support static compile */")); + strm.writeline(plib::pfmt("/* {1} doesn't support static compile */")); } protected: @@ -163,11 +163,11 @@ protected: template <typename T> void build_LE_RHS(); - pvector_t<terms_t *> m_terms; - pvector_t<analog_net_t *> m_nets; - pvector_t<analog_output_t *> m_inps; + plib::pvector_t<terms_t *> m_terms; + plib::pvector_t<analog_net_t *> m_nets; + plib::pvector_t<analog_output_t *> m_inps; - pvector_t<terms_t *> m_rails_temp; + plib::pvector_t<terms_t *> m_rails_temp; int m_stat_calculations; int m_stat_newton_raphson; diff --git a/src/lib/netlist/solver/nld_ms_direct.h b/src/lib/netlist/solver/nld_ms_direct.h index bfbd0a66c7a..47a2d62027b 100644 --- a/src/lib/netlist/solver/nld_ms_direct.h +++ b/src/lib/netlist/solver/nld_ms_direct.h @@ -28,7 +28,7 @@ NETLIB_NAMESPACE_DEVICES_START() -//#define nl_ext_double __float128 // slow, very slow +//#define nl_ext_double _float128 // slow, very slow //#define nl_ext_double long double // slightly slower #define nl_ext_double nl_double @@ -46,7 +46,7 @@ struct ti_t volatile std::atomic<int> lo; thr_intf *intf; void *params; -// int _block[29]; /* make it 256 bytes */ +// int block[29]; /* make it 256 bytes */ }; static ti_t ti[MAXTHR]; @@ -111,7 +111,7 @@ static void thr_dispose() } #endif -template <unsigned m_N, unsigned _storage_N> +template <unsigned m_N, unsigned storage_N> #if TEST_PARALLEL class matrix_solver_direct_t: public matrix_solver_t, public thr_intf #else @@ -158,18 +158,18 @@ protected: template <typename T1> inline nl_ext_double &RHS(const T1 &r) { return m_A[r][N()]; } #endif - ATTR_ALIGN nl_double m_last_RHS[_storage_N]; // right hand side - contains currents + ATTR_ALIGN nl_double m_last_RHS[storage_N]; // right hand side - contains currents private: - static const std::size_t m_pitch = (((_storage_N + 1) + 7) / 8) * 8; - //static const std::size_t m_pitch = (((_storage_N + 1) + 15) / 16) * 16; - //static const std::size_t m_pitch = (((_storage_N + 1) + 31) / 32) * 32; + static const std::size_t m_pitch = (((storage_N + 1) + 7) / 8) * 8; + //static const std::size_t m_pitch = (((storage_N + 1) + 15) / 16) * 16; + //static const std::size_t m_pitch = (((storage_N + 1) + 31) / 32) * 32; #if (NL_USE_DYNAMIC_ALLOCATION) ATTR_ALIGN nl_ext_double * RESTRICT m_A; #else - ATTR_ALIGN nl_ext_double m_A[_storage_N][m_pitch]; + ATTR_ALIGN nl_ext_double m_A[storage_N][m_pitch]; #endif - //ATTR_ALIGN nl_ext_double m_RHSx[_storage_N]; + //ATTR_ALIGN nl_ext_double m_RHSx[storage_N]; const unsigned m_dim; @@ -179,8 +179,8 @@ private: // matrix_solver_direct // ---------------------------------------------------------------------------------------- -template <unsigned m_N, unsigned _storage_N> -matrix_solver_direct_t<m_N, _storage_N>::~matrix_solver_direct_t() +template <unsigned m_N, unsigned storage_N> +matrix_solver_direct_t<m_N, storage_N>::~matrix_solver_direct_t() { #if (NL_USE_DYNAMIC_ALLOCATION) pfree_array(m_A); @@ -190,8 +190,8 @@ matrix_solver_direct_t<m_N, _storage_N>::~matrix_solver_direct_t() #endif } -template <unsigned m_N, unsigned _storage_N> -ATTR_COLD void matrix_solver_direct_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets) +template <unsigned m_N, unsigned storage_N> +ATTR_COLD void matrix_solver_direct_t<m_N, storage_N>::vsetup(analog_net_t::list_t &nets) { if (m_dim < nets.size()) log().fatal("Dimension {1} less than {2}", m_dim, nets.size()); @@ -211,7 +211,7 @@ ATTR_COLD void matrix_solver_direct_t<m_N, _storage_N>::vsetup(analog_net_t::lis for (unsigned k = 0; k < N(); k++) { - pstring num = pfmt("{1}")(k); + pstring num = plib::pfmt("{1}")(k); save(RHS(k), "RHS." + num); } @@ -220,8 +220,8 @@ ATTR_COLD void matrix_solver_direct_t<m_N, _storage_N>::vsetup(analog_net_t::lis #if TEST_PARALLEL -template <unsigned m_N, unsigned _storage_N> -void matrix_solver_direct_t<m_N, _storage_N>::do_work(const int id, void *param) +template <unsigned m_N, unsigned storage_N> +void matrix_solver_direct_t<m_N, storage_N>::do_work(const int id, void *param) { const int i = x_i[id]; /* FIXME: Singular matrix? */ @@ -244,8 +244,8 @@ void matrix_solver_direct_t<m_N, _storage_N>::do_work(const int id, void *param) } #endif -template <unsigned m_N, unsigned _storage_N> -void matrix_solver_direct_t<m_N, _storage_N>::LE_solve() +template <unsigned m_N, unsigned storage_N> +void matrix_solver_direct_t<m_N, storage_N>::LE_solve() { const unsigned kN = N(); @@ -340,9 +340,9 @@ void matrix_solver_direct_t<m_N, _storage_N>::LE_solve() } } -template <unsigned m_N, unsigned _storage_N> +template <unsigned m_N, unsigned storage_N> template <typename T> -void matrix_solver_direct_t<m_N, _storage_N>::LE_back_subst( +void matrix_solver_direct_t<m_N, storage_N>::LE_back_subst( T * RESTRICT x) { const unsigned kN = N(); @@ -378,10 +378,10 @@ void matrix_solver_direct_t<m_N, _storage_N>::LE_back_subst( } -template <unsigned m_N, unsigned _storage_N> -int matrix_solver_direct_t<m_N, _storage_N>::solve_non_dynamic(ATTR_UNUSED const bool newton_raphson) +template <unsigned m_N, unsigned storage_N> +int matrix_solver_direct_t<m_N, storage_N>::solve_non_dynamic(ATTR_UNUSED const bool newton_raphson) { - nl_double new_V[_storage_N]; // = { 0.0 }; + nl_double new_V[storage_N]; // = { 0.0 }; this->LE_solve(); this->LE_back_subst(new_V); @@ -401,8 +401,8 @@ int matrix_solver_direct_t<m_N, _storage_N>::solve_non_dynamic(ATTR_UNUSED const } } -template <unsigned m_N, unsigned _storage_N> -inline int matrix_solver_direct_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton_raphson) +template <unsigned m_N, unsigned storage_N> +inline int matrix_solver_direct_t<m_N, storage_N>::vsolve_non_dynamic(const bool newton_raphson) { build_LE_A<matrix_solver_direct_t>(); build_LE_RHS<matrix_solver_direct_t>(); @@ -414,8 +414,8 @@ inline int matrix_solver_direct_t<m_N, _storage_N>::vsolve_non_dynamic(const boo return this->solve_non_dynamic(newton_raphson); } -template <unsigned m_N, unsigned _storage_N> -matrix_solver_direct_t<m_N, _storage_N>::matrix_solver_direct_t(netlist_t &anetlist, const pstring &name, +template <unsigned m_N, unsigned storage_N> +matrix_solver_direct_t<m_N, storage_N>::matrix_solver_direct_t(netlist_t &anetlist, const pstring &name, const solver_parameters_t *params, const int size) : matrix_solver_t(anetlist, name, ASCENDING, params) , m_dim(size) @@ -432,8 +432,8 @@ matrix_solver_direct_t<m_N, _storage_N>::matrix_solver_direct_t(netlist_t &anetl #endif } -template <unsigned m_N, unsigned _storage_N> -matrix_solver_direct_t<m_N, _storage_N>::matrix_solver_direct_t(netlist_t &anetlist, const pstring &name, +template <unsigned m_N, unsigned storage_N> +matrix_solver_direct_t<m_N, storage_N>::matrix_solver_direct_t(netlist_t &anetlist, const pstring &name, const eSortType sort, const solver_parameters_t *params, const int size) : matrix_solver_t(anetlist, name, sort, params) , m_dim(size) diff --git a/src/lib/netlist/solver/nld_ms_direct_lu.h b/src/lib/netlist/solver/nld_ms_direct_lu.h index e6ccf819653..6f6288f9c48 100644 --- a/src/lib/netlist/solver/nld_ms_direct_lu.h +++ b/src/lib/netlist/solver/nld_ms_direct_lu.h @@ -13,15 +13,15 @@ #include "solver/nld_solver.h" #include "solver/nld_matrix_solver.h" -//#define A(_r, _c) m_A[_r][_c] +//#define A(r, c) m_A[_r][_c] NETLIB_NAMESPACE_DEVICES_START() -//#define nl_ext_double __float128 // slow, very slow +//#define nl_ext_double _float128 // slow, very slow //#define nl_ext_double long double // slightly slower #define nl_ext_double double -template <unsigned m_N, unsigned _storage_N> +template <unsigned m_N, unsigned storage_N> class matrix_solver_direct_t: public matrix_solver_t { public: @@ -54,7 +54,7 @@ protected: const unsigned * const p = m_terms[k]->m_nzrd.data(); const unsigned e = m_terms[k]->m_nzrd.size(); - for (int i = k+1; i < _storage_N;i++) + for (int i = k+1; i < storage_N;i++) { const double alpha = A(i,k) * akki; A(i,k) = alpha; @@ -72,7 +72,7 @@ protected: const unsigned kN = N(); unsigned sk = 1; - if (1 && kN == _storage_N) + if (1 && kN == storage_N) { if (kN> 0 ) LEk<0>(); if (kN> 1 ) LEk<1>(); @@ -139,15 +139,15 @@ protected: template <typename T1, typename T2> inline nl_ext_double &A(const T1 r, const T2 c) { return m_A[r][c]; } - //ATTR_ALIGN nl_double m_A[_storage_N][((_storage_N + 7) / 8) * 8]; - ATTR_ALIGN nl_double m_RHS[_storage_N]; - ATTR_ALIGN nl_double m_last_RHS[_storage_N]; // right hand side - contains currents - ATTR_ALIGN nl_double m_last_V[_storage_N]; + //ATTR_ALIGN nl_double m_A[storage_N][((storage_N + 7) / 8) * 8]; + ATTR_ALIGN nl_double m_RHS[storage_N]; + ATTR_ALIGN nl_double m_last_RHS[storage_N]; // right hand side - contains currents + ATTR_ALIGN nl_double m_last_V[storage_N]; terms_t *m_rails_temp; private: - ATTR_ALIGN nl_ext_double m_A[_storage_N][((_storage_N + 7) / 8) * 8]; + ATTR_ALIGN nl_ext_double m_A[storage_N][((storage_N + 7) / 8) * 8]; const unsigned m_dim; nl_double m_lp_fact; @@ -157,14 +157,14 @@ private: // matrix_solver_direct // ---------------------------------------------------------------------------------------- -template <unsigned m_N, unsigned _storage_N> -matrix_solver_direct_t<m_N, _storage_N>::~matrix_solver_direct_t() +template <unsigned m_N, unsigned storage_N> +matrix_solver_direct_t<m_N, storage_N>::~matrix_solver_direct_t() { pfree_array(m_rails_temp); } -template <unsigned m_N, unsigned _storage_N> -nl_double matrix_solver_direct_t<m_N, _storage_N>::compute_next_timestep() +template <unsigned m_N, unsigned storage_N> +nl_double matrix_solver_direct_t<m_N, storage_N>::compute_next_timestep() { nl_double new_solver_timestep = m_params.m_max_timestep; @@ -202,8 +202,8 @@ nl_double matrix_solver_direct_t<m_N, _storage_N>::compute_next_timestep() return new_solver_timestep; } -template <unsigned m_N, unsigned _storage_N> -ATTR_COLD void matrix_solver_direct_t<m_N, _storage_N>::add_term(int k, terminal_t *term) +template <unsigned m_N, unsigned storage_N> +ATTR_COLD void matrix_solver_direct_t<m_N, storage_N>::add_term(int k, terminal_t *term) { if (term->m_otherterm->net().isRailNet()) { @@ -226,8 +226,8 @@ ATTR_COLD void matrix_solver_direct_t<m_N, _storage_N>::add_term(int k, terminal } -template <unsigned m_N, unsigned _storage_N> -ATTR_COLD void matrix_solver_direct_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets) +template <unsigned m_N, unsigned storage_N> +ATTR_COLD void matrix_solver_direct_t<m_N, storage_N>::vsetup(analog_net_t::list_t &nets) { if (m_dim < nets.size()) netlist().error("Dimension {1} less than {2}", m_dim,nets.size()); @@ -355,7 +355,7 @@ ATTR_COLD void matrix_solver_direct_t<m_N, _storage_N>::vsetup(analog_net_t::lis for (unsigned k = 0; k < N(); k++) { - pstring num = pfmt("{1}")(k); + pstring num = plib::pfmt("{1}")(k); save(m_terms[k]->go(),"GO" + num, m_terms[k]->count()); save(m_terms[k]->gt(),"GT" + num, m_terms[k]->count()); @@ -365,8 +365,8 @@ ATTR_COLD void matrix_solver_direct_t<m_N, _storage_N>::vsetup(analog_net_t::lis } -template <unsigned m_N, unsigned _storage_N> -void matrix_solver_direct_t<m_N, _storage_N>::build_LE_A() +template <unsigned m_N, unsigned storage_N> +void matrix_solver_direct_t<m_N, storage_N>::build_LE_A() { const unsigned iN = N(); for (unsigned k = 0; k < iN; k++) @@ -391,8 +391,8 @@ void matrix_solver_direct_t<m_N, _storage_N>::build_LE_A() } } -template <unsigned m_N, unsigned _storage_N> -void matrix_solver_direct_t<m_N, _storage_N>::build_LE_RHS(nl_double * RESTRICT rhs) +template <unsigned m_N, unsigned storage_N> +void matrix_solver_direct_t<m_N, storage_N>::build_LE_RHS(nl_double * RESTRICT rhs) { const unsigned iN = N(); for (unsigned k = 0; k < iN; k++) @@ -419,8 +419,8 @@ void matrix_solver_direct_t<m_N, _storage_N>::build_LE_RHS(nl_double * RESTRICT #if 1 #else // Crout algo -template <unsigned m_N, unsigned _storage_N> -void matrix_solver_direct_t<m_N, _storage_N>::LE_solve() +template <unsigned m_N, unsigned storage_N> +void matrix_solver_direct_t<m_N, storage_N>::LE_solve() { const unsigned kN = N(); @@ -428,7 +428,7 @@ void matrix_solver_direct_t<m_N, _storage_N>::LE_solve() ATTR_UNUSED double big,temp; #if 0 - double vv[_storage_N]; + double vv[storage_N]; for (i=0;i<kN;i++) { @@ -501,8 +501,8 @@ void matrix_solver_direct_t<m_N, _storage_N>::LE_solve() } #endif -template <unsigned m_N, unsigned _storage_N> -void matrix_solver_direct_t<m_N, _storage_N>::LE_back_subst( +template <unsigned m_N, unsigned storage_N> +void matrix_solver_direct_t<m_N, storage_N>::LE_back_subst( nl_double * RESTRICT x) { const unsigned kN = N(); @@ -535,8 +535,8 @@ void matrix_solver_direct_t<m_N, _storage_N>::LE_back_subst( } -template <unsigned m_N, unsigned _storage_N> -nl_double matrix_solver_direct_t<m_N, _storage_N>::delta( +template <unsigned m_N, unsigned storage_N> +nl_double matrix_solver_direct_t<m_N, storage_N>::delta( const nl_double * RESTRICT V) { /* FIXME: Ideally we should also include currents (RHS) here. This would @@ -551,8 +551,8 @@ nl_double matrix_solver_direct_t<m_N, _storage_N>::delta( return cerr; } -template <unsigned m_N, unsigned _storage_N> -void matrix_solver_direct_t<m_N, _storage_N>::store( +template <unsigned m_N, unsigned storage_N> +void matrix_solver_direct_t<m_N, storage_N>::store( const nl_double * RESTRICT V) { for (unsigned i = 0, iN=N(); i < iN; i++) @@ -562,10 +562,10 @@ void matrix_solver_direct_t<m_N, _storage_N>::store( } -template <unsigned m_N, unsigned _storage_N> -int matrix_solver_direct_t<m_N, _storage_N>::solve_non_dynamic(ATTR_UNUSED const bool newton_raphson) +template <unsigned m_N, unsigned storage_N> +int matrix_solver_direct_t<m_N, storage_N>::solve_non_dynamic(ATTR_UNUSED const bool newton_raphson) { - nl_double new_V[_storage_N]; // = { 0.0 }; + nl_double new_V[storage_N]; // = { 0.0 }; this->LE_back_subst(new_V); @@ -584,8 +584,8 @@ int matrix_solver_direct_t<m_N, _storage_N>::solve_non_dynamic(ATTR_UNUSED const } } -template <unsigned m_N, unsigned _storage_N> -inline int matrix_solver_direct_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton_raphson) +template <unsigned m_N, unsigned storage_N> +inline int matrix_solver_direct_t<m_N, storage_N>::vsolve_non_dynamic(const bool newton_raphson) { this->build_LE_A(); this->build_LE_RHS(m_last_RHS); @@ -596,8 +596,8 @@ inline int matrix_solver_direct_t<m_N, _storage_N>::vsolve_non_dynamic(const boo return this->solve_non_dynamic(newton_raphson); } -template <unsigned m_N, unsigned _storage_N> -matrix_solver_direct_t<m_N, _storage_N>::matrix_solver_direct_t(const solver_parameters_t *params, const int size) +template <unsigned m_N, unsigned storage_N> +matrix_solver_direct_t<m_N, storage_N>::matrix_solver_direct_t(const solver_parameters_t *params, const int size) : matrix_solver_t(GAUSSIAN_ELIMINATION, params) , m_dim(size) , m_lp_fact(0) @@ -610,8 +610,8 @@ matrix_solver_direct_t<m_N, _storage_N>::matrix_solver_direct_t(const solver_par } } -template <unsigned m_N, unsigned _storage_N> -matrix_solver_direct_t<m_N, _storage_N>::matrix_solver_direct_t(const eSolverType type, const solver_parameters_t *params, const int size) +template <unsigned m_N, unsigned storage_N> +matrix_solver_direct_t<m_N, storage_N>::matrix_solver_direct_t(const eSolverType type, const solver_parameters_t *params, const int size) : matrix_solver_t(type, params) , m_dim(size) , m_lp_fact(0) diff --git a/src/lib/netlist/solver/nld_ms_gcr.h b/src/lib/netlist/solver/nld_ms_gcr.h index be9346deb59..7ffe4594d3a 100644 --- a/src/lib/netlist/solver/nld_ms_gcr.h +++ b/src/lib/netlist/solver/nld_ms_gcr.h @@ -14,18 +14,18 @@ #include <algorithm> +#include "plib/pdynlib.h" #include "solver/mat_cr.h" #include "solver/nld_ms_direct.h" #include "solver/nld_solver.h" #include "solver/vector_base.h" -#include "plib/pdynlib.h" #include "plib/pstream.h" #define NL_USE_SSE 0 NETLIB_NAMESPACE_DEVICES_START() -template <unsigned m_N, unsigned _storage_N> +template <unsigned m_N, unsigned storage_N> class matrix_solver_GCR_t: public matrix_solver_t { public: @@ -47,27 +47,27 @@ public: virtual void vsetup(analog_net_t::list_t &nets) override; virtual int vsolve_non_dynamic(const bool newton_raphson) override; - virtual void create_solver_code(postream &strm) override; + virtual void create_solver_code(plib::postream &strm) override; private: - void csc_private(postream &strm); + void csc_private(plib::postream &strm); using extsolver = void (*)(double * RESTRICT m_A, double * RESTRICT RHS); pstring static_compile_name() { - postringstream t; + plib::postringstream t; csc_private(t); - phash_functor<pstring> h(t.str()); + plib::hash_functor<pstring> h(t.str()); - return pfmt("nl_gcr_{1:x}_{2}")(h())(mat.nz_num); + return plib::pfmt("nl_gcr_{1:x}_{2}")(h())(mat.nz_num); } unsigned m_dim; - pvector_t<int> m_term_cr[_storage_N]; - mat_cr_t<_storage_N> mat; - nl_double m_A[_storage_N * _storage_N]; + plib::pvector_t<int> m_term_cr[storage_N]; + mat_cr_t<storage_N> mat; + nl_double m_A[storage_N * storage_N]; extsolver m_proc; @@ -77,8 +77,8 @@ private: // matrix_solver - GMRES // ---------------------------------------------------------------------------------------- -template <unsigned m_N, unsigned _storage_N> -void matrix_solver_GCR_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets) +template <unsigned m_N, unsigned storage_N> +void matrix_solver_GCR_t<m_N, storage_N>::vsetup(analog_net_t::list_t &nets) { setup_base(nets); @@ -87,7 +87,7 @@ void matrix_solver_GCR_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets) /* build the final matrix */ - bool touched[_storage_N][_storage_N] = { { false } }; + bool touched[storage_N][storage_N] = { { false } }; for (unsigned k = 0; k < iN; k++) { for (auto & j : this->m_terms[k]->m_nz) @@ -178,8 +178,8 @@ void matrix_solver_GCR_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets) } -template <unsigned m_N, unsigned _storage_N> -void matrix_solver_GCR_t<m_N, _storage_N>::csc_private(postream &strm) +template <unsigned m_N, unsigned storage_N> +void matrix_solver_GCR_t<m_N, storage_N>::csc_private(plib::postream &strm) { const unsigned iN = N(); for (unsigned i = 0; i < iN - 1; i++) @@ -191,7 +191,7 @@ void matrix_solver_GCR_t<m_N, _storage_N>::csc_private(postream &strm) unsigned pi = mat.diag[i]; //const nl_double f = 1.0 / m_A[pi++]; - strm.writeline(pfmt("const double f{1} = 1.0 / m_A[{2}];")(i)(pi)); + strm.writeline(plib::pfmt("const double f{1} = 1.0 / m_A[{2}];")(i)(pi)); pi++; const unsigned piie = mat.ia[i+1]; @@ -204,7 +204,7 @@ void matrix_solver_GCR_t<m_N, _storage_N>::csc_private(postream &strm) pj++; //const nl_double f1 = - m_A[pj++] * f; - strm.writeline(pfmt("\tconst double f{1}_{2} = -f{3} * m_A[{4}];")(i)(j)(i)(pj)); + strm.writeline(plib::pfmt("\tconst double f{1}_{2} = -f{3} * m_A[{4}];")(i)(j)(i)(pj)); pj++; // subtract row i from j */ @@ -213,35 +213,35 @@ void matrix_solver_GCR_t<m_N, _storage_N>::csc_private(postream &strm) while (mat.ja[pj] < mat.ja[pii]) pj++; //m_A[pj++] += m_A[pii++] * f1; - strm.writeline(pfmt("\tm_A[{1}] += m_A[{2}] * f{3}_{4};")(pj)(pii)(i)(j)); + strm.writeline(plib::pfmt("\tm_A[{1}] += m_A[{2}] * f{3}_{4};")(pj)(pii)(i)(j)); pj++; pii++; } //RHS[j] += f1 * RHS[i]; - strm.writeline(pfmt("\tRHS[{1}] += f{2}_{3} * RHS[{4}];")(j)(i)(j)(i)); + strm.writeline(plib::pfmt("\tRHS[{1}] += f{2}_{3} * RHS[{4}];")(j)(i)(j)(i)); } } } } -template <unsigned m_N, unsigned _storage_N> -void matrix_solver_GCR_t<m_N, _storage_N>::create_solver_code(postream &strm) +template <unsigned m_N, unsigned storage_N> +void matrix_solver_GCR_t<m_N, storage_N>::create_solver_code(plib::postream &strm) { //const unsigned iN = N(); - strm.writeline(pfmt("extern \"C\" void {1}(double * __restrict m_A, double * __restrict RHS)")(static_compile_name())); + strm.writeline(plib::pfmt("extern \"C\" void {1}(double * _restrict m_A, double * _restrict RHS)")(static_compile_name())); strm.writeline("{"); csc_private(strm); strm.writeline("}"); } -template <unsigned m_N, unsigned _storage_N> -int matrix_solver_GCR_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton_raphson) +template <unsigned m_N, unsigned storage_N> +int matrix_solver_GCR_t<m_N, storage_N>::vsolve_non_dynamic(const bool newton_raphson) { const unsigned iN = this->N(); - ATTR_ALIGN nl_double RHS[_storage_N]; - ATTR_ALIGN nl_double new_V[_storage_N]; + ATTR_ALIGN nl_double RHS[storage_N]; + ATTR_ALIGN nl_double new_V[storage_N]; for (unsigned i=0, e=mat.nz_num; i<e; i++) m_A[i] = 0.0; @@ -260,16 +260,16 @@ int matrix_solver_GCR_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton_r const nl_double * const * RESTRICT other_cur_analog = t->other_curanalog(); #if (0 ||NL_USE_SSE) - __m128d mg = _mm_set_pd(0.0, 0.0); - __m128d mr = _mm_set_pd(0.0, 0.0); + __m128d mg = mm_set_pd(0.0, 0.0); + __m128d mr = mm_set_pd(0.0, 0.0); unsigned i = 0; for (; i < term_count - 1; i+=2) { - mg = _mm_add_pd(mg, _mm_loadu_pd(>[i])); - mr = _mm_add_pd(mr, _mm_loadu_pd(&Idr[i])); + mg = mm_add_pd(mg, mm_loadu_pd(>[i])); + mr = mm_add_pd(mr, mm_loadu_pd(&Idr[i])); } - gtot_t = _mm_cvtsd_f64(mg) + _mm_cvtsd_f64(_mm_unpackhi_pd(mg,mg)); - RHS_t = _mm_cvtsd_f64(mr) + _mm_cvtsd_f64(_mm_unpackhi_pd(mr,mr)); + gtot_t = mm_cvtsd_f64(mg) + mm_cvtsd_f64(mm_unpackhi_pd(mg,mg)); + RHS_t = mm_cvtsd_f64(mr) + mm_cvtsd_f64(mm_unpackhi_pd(mr,mr)); for (; i < term_count; i++) { gtot_t += gt[i]; @@ -353,16 +353,16 @@ int matrix_solver_GCR_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton_r //__builtin_prefetch(&new_V[j-1], 1); //if (j>0)__builtin_prefetch(&m_A[mat.diag[j-1]], 0); #if (NL_USE_SSE) - __m128d tmp = _mm_set_pd1(0.0); + __m128d tmp = mm_set_pd1(0.0); const unsigned e = mat.ia[j+1]; unsigned pk = mat.diag[j] + 1; for (; pk < e - 1; pk+=2) { //tmp += m_A[pk] * new_V[mat.ja[pk]]; - tmp = _mm_add_pd(tmp, _mm_mul_pd(_mm_set_pd(m_A[pk], m_A[pk+1]), + tmp = mm_add_pd(tmp, mm_mul_pd(mm_set_pd(m_A[pk], m_A[pk+1]), _mm_set_pd(new_V[mat.ja[pk]], new_V[mat.ja[pk+1]]))); } - double tmpx = _mm_cvtsd_f64(tmp) + _mm_cvtsd_f64(_mm_unpackhi_pd(tmp,tmp)); + double tmpx = mm_cvtsd_f64(tmp) + mm_cvtsd_f64(mm_unpackhi_pd(tmp,tmp)); for (; pk < e; pk++) { tmpx += m_A[pk] * new_V[mat.ja[pk]]; diff --git a/src/lib/netlist/solver/nld_ms_gmres.h b/src/lib/netlist/solver/nld_ms_gmres.h index 9e5542f2a42..6d0bb404fd3 100644 --- a/src/lib/netlist/solver/nld_ms_gmres.h +++ b/src/lib/netlist/solver/nld_ms_gmres.h @@ -21,13 +21,13 @@ NETLIB_NAMESPACE_DEVICES_START() -template <unsigned m_N, unsigned _storage_N> -class matrix_solver_GMRES_t: public matrix_solver_direct_t<m_N, _storage_N> +template <unsigned m_N, unsigned storage_N> +class matrix_solver_GMRES_t: public matrix_solver_direct_t<m_N, storage_N> { public: matrix_solver_GMRES_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) + : matrix_solver_direct_t<m_N, storage_N>(anetlist, name, matrix_solver_t::ASCENDING, params, size) , m_use_iLU_preconditioning(true) , m_use_more_precise_stop_condition(false) , m_accuracy_mult(1.0) @@ -45,23 +45,23 @@ private: int solve_ilu_gmres(nl_double * RESTRICT x, const nl_double * RESTRICT rhs, const unsigned restart_max, const unsigned mr, nl_double accuracy); - pvector_t<int> m_term_cr[_storage_N]; + plib::pvector_t<int> m_term_cr[storage_N]; bool m_use_iLU_preconditioning; bool m_use_more_precise_stop_condition; nl_double m_accuracy_mult; // FXIME: Save state - mat_cr_t<_storage_N> mat; + mat_cr_t<storage_N> mat; - nl_double m_A[_storage_N * _storage_N]; - nl_double m_LU[_storage_N * _storage_N]; + nl_double m_A[storage_N * storage_N]; + nl_double m_LU[storage_N * storage_N]; - nl_double m_c[_storage_N + 1]; /* mr + 1 */ - nl_double m_g[_storage_N + 1]; /* mr + 1 */ - nl_double m_ht[_storage_N + 1][_storage_N]; /* (mr + 1), mr */ - nl_double m_s[_storage_N + 1]; /* mr + 1 */ - nl_double m_v[_storage_N + 1][_storage_N]; /*(mr + 1), n */ - nl_double m_y[_storage_N + 1]; /* mr + 1 */ + nl_double m_c[storage_N + 1]; /* mr + 1 */ + nl_double m_g[storage_N + 1]; /* mr + 1 */ + nl_double m_ht[storage_N + 1][storage_N]; /* (mr + 1), mr */ + nl_double m_s[storage_N + 1]; /* mr + 1 */ + nl_double m_v[storage_N + 1][storage_N]; /*(mr + 1), n */ + nl_double m_y[storage_N + 1]; /* mr + 1 */ }; @@ -69,10 +69,10 @@ private: // matrix_solver - GMRES // ---------------------------------------------------------------------------------------- -template <unsigned m_N, unsigned _storage_N> -void matrix_solver_GMRES_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets) +template <unsigned m_N, unsigned storage_N> +void matrix_solver_GMRES_t<m_N, storage_N>::vsetup(analog_net_t::list_t &nets) { - matrix_solver_direct_t<m_N, _storage_N>::vsetup(nets); + matrix_solver_direct_t<m_N, storage_N>::vsetup(nets); unsigned nz = 0; const unsigned iN = this->N(); @@ -108,8 +108,8 @@ void matrix_solver_GMRES_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets) mat.nz_num = nz; } -template <unsigned m_N, unsigned _storage_N> -int matrix_solver_GMRES_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton_raphson) +template <unsigned m_N, unsigned storage_N> +int matrix_solver_GMRES_t<m_N, storage_N>::vsolve_non_dynamic(const bool newton_raphson) { const unsigned iN = this->N(); @@ -122,8 +122,8 @@ int matrix_solver_GMRES_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton */ //nz_num = 0; - ATTR_ALIGN nl_double RHS[_storage_N]; - ATTR_ALIGN nl_double new_V[_storage_N]; + ATTR_ALIGN nl_double RHS[storage_N]; + ATTR_ALIGN nl_double new_V[storage_N]; for (unsigned i=0, e=mat.nz_num; i<e; i++) m_A[i] = 0.0; @@ -179,7 +179,7 @@ int matrix_solver_GMRES_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton if (gsl>=failed) { this->m_iterative_fail++; - return matrix_solver_direct_t<m_N, _storage_N>::vsolve_non_dynamic(newton_raphson); + return matrix_solver_direct_t<m_N, storage_N>::vsolve_non_dynamic(newton_raphson); } if (newton_raphson) @@ -207,8 +207,8 @@ inline void givens_mult( const T & c, const T & s, T & g0, T & g1 ) g1 = tg1; } -template <unsigned m_N, unsigned _storage_N> -int matrix_solver_GMRES_t<m_N, _storage_N>::solve_ilu_gmres (nl_double * RESTRICT x, const nl_double * RESTRICT rhs, const unsigned restart_max, const unsigned mr, nl_double accuracy) +template <unsigned m_N, unsigned storage_N> +int matrix_solver_GMRES_t<m_N, storage_N>::solve_ilu_gmres (nl_double * RESTRICT x, const nl_double * RESTRICT rhs, const unsigned restart_max, const unsigned mr, nl_double accuracy) { /*------------------------------------------------------------------------- * The code below was inspired by code published by John Burkardt under @@ -253,8 +253,8 @@ int matrix_solver_GMRES_t<m_N, _storage_N>::solve_ilu_gmres (nl_double * RESTRIC * differently: The invest doesn't pay off. * Therefore we use the approach in the else part. */ - nl_double t[_storage_N]; - nl_double Ax[_storage_N]; + nl_double t[storage_N]; + nl_double Ax[storage_N]; vec_set(n, accuracy, t); mat.mult_vec(m_A, t, Ax); mat.solveLUx(m_LU, Ax); @@ -272,8 +272,8 @@ int matrix_solver_GMRES_t<m_N, _storage_N>::solve_ilu_gmres (nl_double * RESTRIC nl_double mu; nl_double rho; - nl_double Ax[_storage_N]; - nl_double residual[_storage_N]; + nl_double Ax[storage_N]; + nl_double residual[storage_N]; mat.mult_vec(m_A, x, Ax); diff --git a/src/lib/netlist/solver/nld_ms_sm.h b/src/lib/netlist/solver/nld_ms_sm.h index 1a3c50b4a27..c11e4fd0500 100644 --- a/src/lib/netlist/solver/nld_ms_sm.h +++ b/src/lib/netlist/solver/nld_ms_sm.h @@ -41,11 +41,11 @@ NETLIB_NAMESPACE_DEVICES_START() -//#define nl_ext_double __float128 // slow, very slow +//#define nl_ext_double _float128 // slow, very slow //#define nl_ext_double long double // slightly slower #define nl_ext_double nl_double -template <unsigned m_N, unsigned _storage_N> +template <unsigned m_N, unsigned storage_N> class matrix_solver_sm_t: public matrix_solver_t { friend class matrix_solver_t; @@ -87,19 +87,19 @@ protected: template <typename T1, typename T2> inline nl_ext_double &lAinv(const T1 &r, const T2 &c) { return m_lAinv[r][c]; } - ATTR_ALIGN nl_double m_last_RHS[_storage_N]; // right hand side - contains currents + ATTR_ALIGN nl_double m_last_RHS[storage_N]; // right hand side - contains currents private: - static const std::size_t m_pitch = ((( _storage_N) + 7) / 8) * 8; - ATTR_ALIGN nl_ext_double m_A[_storage_N][m_pitch]; - ATTR_ALIGN nl_ext_double m_Ainv[_storage_N][m_pitch]; - ATTR_ALIGN nl_ext_double m_W[_storage_N][m_pitch]; - ATTR_ALIGN nl_ext_double m_RHS[_storage_N]; // right hand side - contains currents + static const std::size_t m_pitch = ((( storage_N) + 7) / 8) * 8; + ATTR_ALIGN nl_ext_double m_A[storage_N][m_pitch]; + ATTR_ALIGN nl_ext_double m_Ainv[storage_N][m_pitch]; + ATTR_ALIGN nl_ext_double m_W[storage_N][m_pitch]; + ATTR_ALIGN nl_ext_double m_RHS[storage_N]; // right hand side - contains currents - ATTR_ALIGN nl_ext_double m_lA[_storage_N][m_pitch]; - ATTR_ALIGN nl_ext_double m_lAinv[_storage_N][m_pitch]; + ATTR_ALIGN nl_ext_double m_lA[storage_N][m_pitch]; + ATTR_ALIGN nl_ext_double m_lAinv[storage_N][m_pitch]; - //ATTR_ALIGN nl_ext_double m_RHSx[_storage_N]; + //ATTR_ALIGN nl_ext_double m_RHSx[storage_N]; const unsigned m_dim; @@ -109,16 +109,16 @@ private: // matrix_solver_direct // ---------------------------------------------------------------------------------------- -template <unsigned m_N, unsigned _storage_N> -matrix_solver_sm_t<m_N, _storage_N>::~matrix_solver_sm_t() +template <unsigned m_N, unsigned storage_N> +matrix_solver_sm_t<m_N, storage_N>::~matrix_solver_sm_t() { #if (NL_USE_DYNAMIC_ALLOCATION) pfree_array(m_A); #endif } -template <unsigned m_N, unsigned _storage_N> -ATTR_COLD void matrix_solver_sm_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets) +template <unsigned m_N, unsigned storage_N> +ATTR_COLD void matrix_solver_sm_t<m_N, storage_N>::vsetup(analog_net_t::list_t &nets) { if (m_dim < nets.size()) log().fatal("Dimension {1} less than {2}", m_dim, nets.size()); @@ -130,7 +130,7 @@ ATTR_COLD void matrix_solver_sm_t<m_N, _storage_N>::vsetup(analog_net_t::list_t for (unsigned k = 0; k < N(); k++) { - pstring num = pfmt("{1}")(k); + pstring num = plib::pfmt("{1}")(k); save(RHS(k), "RHS." + num); } @@ -138,8 +138,8 @@ ATTR_COLD void matrix_solver_sm_t<m_N, _storage_N>::vsetup(analog_net_t::list_t -template <unsigned m_N, unsigned _storage_N> -void matrix_solver_sm_t<m_N, _storage_N>::LE_invert() +template <unsigned m_N, unsigned storage_N> +void matrix_solver_sm_t<m_N, storage_N>::LE_invert() { const unsigned kN = N(); @@ -201,9 +201,9 @@ void matrix_solver_sm_t<m_N, _storage_N>::LE_invert() } } -template <unsigned m_N, unsigned _storage_N> +template <unsigned m_N, unsigned storage_N> template <typename T> -void matrix_solver_sm_t<m_N, _storage_N>::LE_compute_x( +void matrix_solver_sm_t<m_N, storage_N>::LE_compute_x( T * RESTRICT x) { const unsigned kN = N(); @@ -221,14 +221,14 @@ void matrix_solver_sm_t<m_N, _storage_N>::LE_compute_x( } -template <unsigned m_N, unsigned _storage_N> -int matrix_solver_sm_t<m_N, _storage_N>::solve_non_dynamic(ATTR_UNUSED const bool newton_raphson) +template <unsigned m_N, unsigned storage_N> +int matrix_solver_sm_t<m_N, storage_N>::solve_non_dynamic(ATTR_UNUSED const bool newton_raphson) { static const bool incremental = true; static unsigned cnt = 0; const auto iN = N(); - nl_double new_V[_storage_N]; // = { 0.0 }; + nl_double new_V[storage_N]; // = { 0.0 }; if (0 || ((cnt % 200) == 0)) { @@ -311,8 +311,8 @@ int matrix_solver_sm_t<m_N, _storage_N>::solve_non_dynamic(ATTR_UNUSED const boo } } -template <unsigned m_N, unsigned _storage_N> -inline int matrix_solver_sm_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton_raphson) +template <unsigned m_N, unsigned storage_N> +inline int matrix_solver_sm_t<m_N, storage_N>::vsolve_non_dynamic(const bool newton_raphson) { build_LE_A<matrix_solver_sm_t>(); build_LE_RHS<matrix_solver_sm_t>(); @@ -324,8 +324,8 @@ inline int matrix_solver_sm_t<m_N, _storage_N>::vsolve_non_dynamic(const bool ne return this->solve_non_dynamic(newton_raphson); } -template <unsigned m_N, unsigned _storage_N> -matrix_solver_sm_t<m_N, _storage_N>::matrix_solver_sm_t(netlist_t &anetlist, const pstring &name, +template <unsigned m_N, unsigned storage_N> +matrix_solver_sm_t<m_N, storage_N>::matrix_solver_sm_t(netlist_t &anetlist, const pstring &name, const solver_parameters_t *params, const int size) : matrix_solver_t(anetlist, name, NOSORT, params) , m_dim(size) diff --git a/src/lib/netlist/solver/nld_ms_sor.h b/src/lib/netlist/solver/nld_ms_sor.h index 8d210cd79f7..355a7ce138d 100644 --- a/src/lib/netlist/solver/nld_ms_sor.h +++ b/src/lib/netlist/solver/nld_ms_sor.h @@ -19,13 +19,13 @@ NETLIB_NAMESPACE_DEVICES_START() -template <unsigned m_N, unsigned _storage_N> -class matrix_solver_SOR_t: public matrix_solver_direct_t<m_N, _storage_N> +template <unsigned m_N, unsigned storage_N> +class matrix_solver_SOR_t: public matrix_solver_direct_t<m_N, storage_N> { 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) + : matrix_solver_direct_t<m_N, storage_N>(anetlist, name, matrix_solver_t::ASCENDING, params, size) , m_lp_fact(0) { } @@ -44,15 +44,15 @@ private: // ---------------------------------------------------------------------------------------- -template <unsigned m_N, unsigned _storage_N> -void matrix_solver_SOR_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets) +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); + matrix_solver_direct_t<m_N, storage_N>::vsetup(nets); this->save(NLNAME(m_lp_fact)); } -template <unsigned m_N, unsigned _storage_N> -int matrix_solver_SOR_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton_raphson) +template <unsigned m_N, unsigned storage_N> +int matrix_solver_SOR_t<m_N, storage_N>::vsolve_non_dynamic(const bool newton_raphson) { const unsigned iN = this->N(); bool resched = false; @@ -68,10 +68,10 @@ int matrix_solver_SOR_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton_r const nl_double ws = this->m_params.m_sor; - ATTR_ALIGN nl_double w[_storage_N]; - ATTR_ALIGN nl_double one_m_w[_storage_N]; - ATTR_ALIGN nl_double RHS[_storage_N]; - ATTR_ALIGN nl_double new_V[_storage_N]; + ATTR_ALIGN nl_double w[storage_N]; + ATTR_ALIGN nl_double one_m_w[storage_N]; + ATTR_ALIGN nl_double RHS[storage_N]; + ATTR_ALIGN nl_double new_V[storage_N]; for (unsigned k = 0; k < iN; k++) { @@ -163,7 +163,7 @@ int matrix_solver_SOR_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton_r { // Fallback to direct solver ... this->m_iterative_fail++; - return matrix_solver_direct_t<m_N, _storage_N>::vsolve_non_dynamic(newton_raphson); + return matrix_solver_direct_t<m_N, storage_N>::vsolve_non_dynamic(newton_raphson); } this->m_stat_calculations++; diff --git a/src/lib/netlist/solver/nld_ms_sor_mat.h b/src/lib/netlist/solver/nld_ms_sor_mat.h index 99a66afd221..099db11ab0f 100644 --- a/src/lib/netlist/solver/nld_ms_sor_mat.h +++ b/src/lib/netlist/solver/nld_ms_sor_mat.h @@ -20,15 +20,15 @@ NETLIB_NAMESPACE_DEVICES_START() -template <unsigned m_N, unsigned _storage_N> -class matrix_solver_SOR_mat_t: public matrix_solver_direct_t<m_N, _storage_N> +template <unsigned m_N, unsigned storage_N> +class matrix_solver_SOR_mat_t: public matrix_solver_direct_t<m_N, storage_N> { friend class matrix_solver_t; 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) + : 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) @@ -43,7 +43,7 @@ public: virtual int vsolve_non_dynamic(const bool newton_raphson) override; private: - nl_double m_Vdelta[_storage_N]; + nl_double m_Vdelta[storage_N]; nl_double m_omega; nl_double m_lp_fact; @@ -55,10 +55,10 @@ private: // matrix_solver - Gauss - Seidel // ---------------------------------------------------------------------------------------- -template <unsigned m_N, unsigned _storage_N> -void matrix_solver_SOR_mat_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets) +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); + 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)); @@ -68,8 +68,8 @@ void matrix_solver_SOR_mat_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets #if 0 //FIXME: move to solve_base -template <unsigned m_N, unsigned _storage_N> -nl_double matrix_solver_SOR_mat_t<m_N, _storage_N>::vsolve() +template <unsigned m_N, unsigned storage_N> +nl_double matrix_solver_SOR_mat_t<m_N, storage_N>::vsolve() { /* * enable linear prediction on first newton pass @@ -115,8 +115,8 @@ nl_double matrix_solver_SOR_mat_t<m_N, _storage_N>::vsolve() } #endif -template <unsigned m_N, unsigned _storage_N> -int matrix_solver_SOR_mat_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton_raphson) +template <unsigned m_N, unsigned storage_N> +int matrix_solver_SOR_mat_t<m_N, storage_N>::vsolve_non_dynamic(const bool newton_raphson) { /* The matrix based code looks a lot nicer but actually is 30% slower than * the optimized code which works directly on the data structures. @@ -124,7 +124,7 @@ int matrix_solver_SOR_mat_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newt */ - ATTR_ALIGN nl_double new_v[_storage_N] = { 0.0 }; + ATTR_ALIGN nl_double new_v[storage_N] = { 0.0 }; const unsigned iN = this->N(); matrix_solver_t::build_LE_A<matrix_solver_SOR_mat_t>(); @@ -208,7 +208,7 @@ int matrix_solver_SOR_mat_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newt //this->netlist().warning("Falling back to direct solver .. Consider increasing RESCHED_LOOPS"); this->m_gs_fail++; - return matrix_solver_direct_t<m_N, _storage_N>::solve_non_dynamic(newton_raphson); + return matrix_solver_direct_t<m_N, storage_N>::solve_non_dynamic(newton_raphson); } else { this->store(new_v); diff --git a/src/lib/netlist/solver/nld_ms_w.h b/src/lib/netlist/solver/nld_ms_w.h index f61c2b1b616..2fd64b2f990 100644 --- a/src/lib/netlist/solver/nld_ms_w.h +++ b/src/lib/netlist/solver/nld_ms_w.h @@ -48,11 +48,11 @@ NETLIB_NAMESPACE_DEVICES_START() -//#define nl_ext_double __float128 // slow, very slow +//#define nl_ext_double _float128 // slow, very slow //#define nl_ext_double long double // slightly slower #define nl_ext_double nl_double -template <unsigned m_N, unsigned _storage_N> +template <unsigned m_N, unsigned storage_N> class matrix_solver_w_t: public matrix_solver_t { friend class matrix_solver_t; @@ -92,26 +92,26 @@ protected: template <typename T1, typename T2> inline nl_ext_double &lA(const T1 &r, const T2 &c) { return m_lA[r][c]; } - ATTR_ALIGN nl_double m_last_RHS[_storage_N]; // right hand side - contains currents + ATTR_ALIGN nl_double m_last_RHS[storage_N]; // right hand side - contains currents private: - static const std::size_t m_pitch = ((( _storage_N) + 7) / 8) * 8; - ATTR_ALIGN nl_ext_double m_A[_storage_N][m_pitch]; - ATTR_ALIGN nl_ext_double m_Ainv[_storage_N][m_pitch]; - ATTR_ALIGN nl_ext_double m_W[_storage_N][m_pitch]; - ATTR_ALIGN nl_ext_double m_RHS[_storage_N]; // right hand side - contains currents + static const std::size_t m_pitch = ((( storage_N) + 7) / 8) * 8; + ATTR_ALIGN nl_ext_double m_A[storage_N][m_pitch]; + ATTR_ALIGN nl_ext_double m_Ainv[storage_N][m_pitch]; + ATTR_ALIGN nl_ext_double m_W[storage_N][m_pitch]; + ATTR_ALIGN nl_ext_double m_RHS[storage_N]; // right hand side - contains currents - ATTR_ALIGN nl_ext_double m_lA[_storage_N][m_pitch]; + ATTR_ALIGN nl_ext_double m_lA[storage_N][m_pitch]; /* temporary */ - ATTR_ALIGN nl_double H[_storage_N][m_pitch] ; - unsigned rows[_storage_N]; - unsigned cols[_storage_N][m_pitch]; - unsigned colcount[_storage_N]; + ATTR_ALIGN nl_double H[storage_N][m_pitch] ; + unsigned rows[storage_N]; + unsigned cols[storage_N][m_pitch]; + unsigned colcount[storage_N]; unsigned m_cnt; - //ATTR_ALIGN nl_ext_double m_RHSx[_storage_N]; + //ATTR_ALIGN nl_ext_double m_RHSx[storage_N]; const unsigned m_dim; @@ -121,13 +121,13 @@ private: // matrix_solver_direct // ---------------------------------------------------------------------------------------- -template <unsigned m_N, unsigned _storage_N> -matrix_solver_w_t<m_N, _storage_N>::~matrix_solver_w_t() +template <unsigned m_N, unsigned storage_N> +matrix_solver_w_t<m_N, storage_N>::~matrix_solver_w_t() { } -template <unsigned m_N, unsigned _storage_N> -ATTR_COLD void matrix_solver_w_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets) +template <unsigned m_N, unsigned storage_N> +ATTR_COLD void matrix_solver_w_t<m_N, storage_N>::vsetup(analog_net_t::list_t &nets) { if (m_dim < nets.size()) log().fatal("Dimension {1} less than {2}", m_dim, nets.size()); @@ -139,7 +139,7 @@ ATTR_COLD void matrix_solver_w_t<m_N, _storage_N>::vsetup(analog_net_t::list_t & for (unsigned k = 0; k < N(); k++) { - pstring num = pfmt("{1}")(k); + pstring num = plib::pfmt("{1}")(k); save(RHS(k), "RHS." + num); } @@ -147,8 +147,8 @@ ATTR_COLD void matrix_solver_w_t<m_N, _storage_N>::vsetup(analog_net_t::list_t & -template <unsigned m_N, unsigned _storage_N> -void matrix_solver_w_t<m_N, _storage_N>::LE_invert() +template <unsigned m_N, unsigned storage_N> +void matrix_solver_w_t<m_N, storage_N>::LE_invert() { const unsigned kN = N(); @@ -209,9 +209,9 @@ void matrix_solver_w_t<m_N, _storage_N>::LE_invert() } } -template <unsigned m_N, unsigned _storage_N> +template <unsigned m_N, unsigned storage_N> template <typename T> -void matrix_solver_w_t<m_N, _storage_N>::LE_compute_x( +void matrix_solver_w_t<m_N, storage_N>::LE_compute_x( T * RESTRICT x) { const unsigned kN = N(); @@ -229,12 +229,12 @@ void matrix_solver_w_t<m_N, _storage_N>::LE_compute_x( } -template <unsigned m_N, unsigned _storage_N> -int matrix_solver_w_t<m_N, _storage_N>::solve_non_dynamic(ATTR_UNUSED const bool newton_raphson) +template <unsigned m_N, unsigned storage_N> +int matrix_solver_w_t<m_N, storage_N>::solve_non_dynamic(ATTR_UNUSED const bool newton_raphson) { const auto iN = N(); - nl_double new_V[_storage_N]; // = { 0.0 }; + nl_double new_V[storage_N]; // = { 0.0 }; if ((m_cnt % 100) == 0) { @@ -272,7 +272,7 @@ int matrix_solver_w_t<m_N, _storage_N>::solve_non_dynamic(ATTR_UNUSED const bool /* construct w = transform(V) * y * dim: rowcount x iN * */ - nl_double w[_storage_N]; + nl_double w[storage_N]; for (unsigned i = 0; i < rowcount; i++) { const unsigned r = rows[i]; @@ -322,7 +322,7 @@ int matrix_solver_w_t<m_N, _storage_N>::solve_non_dynamic(ATTR_UNUSED const bool } /* Back substitution */ //inv(H) w = t w = H t - nl_double t[_storage_N]; // FIXME: convert to member + nl_double t[storage_N]; // FIXME: convert to member for (int j = rowcount - 1; j >= 0; j--) { nl_double tmp = 0; @@ -375,8 +375,8 @@ int matrix_solver_w_t<m_N, _storage_N>::solve_non_dynamic(ATTR_UNUSED const bool } } -template <unsigned m_N, unsigned _storage_N> -inline int matrix_solver_w_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton_raphson) +template <unsigned m_N, unsigned storage_N> +inline int matrix_solver_w_t<m_N, storage_N>::vsolve_non_dynamic(const bool newton_raphson) { build_LE_A<matrix_solver_w_t>(); build_LE_RHS<matrix_solver_w_t>(); @@ -388,8 +388,8 @@ inline int matrix_solver_w_t<m_N, _storage_N>::vsolve_non_dynamic(const bool new return this->solve_non_dynamic(newton_raphson); } -template <unsigned m_N, unsigned _storage_N> -matrix_solver_w_t<m_N, _storage_N>::matrix_solver_w_t(netlist_t &anetlist, const pstring &name, +template <unsigned m_N, unsigned storage_N> +matrix_solver_w_t<m_N, storage_N>::matrix_solver_w_t(netlist_t &anetlist, const pstring &name, const solver_parameters_t *params, const int size) : matrix_solver_t(anetlist, name, NOSORT, params) ,m_cnt(0) diff --git a/src/lib/netlist/solver/nld_solver.cpp b/src/lib/netlist/solver/nld_solver.cpp index 33b1bb9bb5d..92cadc1859c 100644 --- a/src/lib/netlist/solver/nld_solver.cpp +++ b/src/lib/netlist/solver/nld_solver.cpp @@ -99,7 +99,7 @@ ATTR_COLD matrix_solver_t::~matrix_solver_t() m_inps.clear_and_free(); for (unsigned k = 0; k < m_terms.size(); k++) { - pfree(m_terms[k]); + plib::pfree(m_terms[k]); } } @@ -114,8 +114,8 @@ ATTR_COLD void matrix_solver_t::setup_base(analog_net_t::list_t &nets) for (auto & net : nets) { m_nets.push_back(net); - m_terms.push_back(palloc(terms_t)); - m_rails_temp.push_back(palloc(terms_t)); + m_terms.push_back(plib::palloc<terms_t>()); + m_rails_temp.push_back(plib::palloc<terms_t>()); } for (std::size_t k = 0; k < nets.size(); k++) @@ -157,9 +157,9 @@ ATTR_COLD void matrix_solver_t::setup_base(analog_net_t::list_t &nets) if (net_proxy_output == nullptr) { //net_proxy_output = palloc(analog_output_t(*this, - // this->name() + "." + pfmt("m{1}")(m_inps.size()))); + // this->name() + "." + plib::pfmt("m{1}")(m_inps.size()))); - net_proxy_output = palloc(analog_output_t(*this, this->name() + "." + pfmt("m{1}")(m_inps.size()))); + net_proxy_output = plib::palloc<analog_output_t>(*this, this->name() + "." + plib::pfmt("m{1}")(m_inps.size())); m_inps.push_back(net_proxy_output); net_proxy_output->m_proxied_net = &p->net().as_analog(); } @@ -196,7 +196,7 @@ ATTR_COLD void matrix_solver_t::setup_matrix() } for (unsigned k = 0; k < iN; k++) - pfree(m_rails_temp[k]); // no longer needed + plib::pfree(m_rails_temp[k]); // no longer needed m_rails_temp.clear(); @@ -259,7 +259,7 @@ ATTR_COLD void matrix_solver_t::setup_matrix() t->m_nz.push_back(k); // add diagonal /* and sort */ - psort_list(t->m_nz); + plib::sort_list(t->m_nz); } /* create a list of non zero elements right of the diagonal @@ -292,7 +292,7 @@ ATTR_COLD void matrix_solver_t::setup_matrix() t->m_nzrd.push_back(other[i]); /* and sort */ - psort_list(t->m_nzrd); + plib::sort_list(t->m_nzrd); } /* create a list of non zero elements below diagonal k @@ -336,9 +336,9 @@ ATTR_COLD void matrix_solver_t::setup_matrix() if (0) for (unsigned k = 0; k < iN; k++) { - pstring line = pfmt("{1}")(k, "3"); + pstring line = plib::pfmt("{1}")(k, "3"); for (unsigned j = 0; j < m_terms[k]->m_nzrd.size(); j++) - line += pfmt(" {1}")(m_terms[k]->m_nzrd[j], "3"); + line += plib::pfmt(" {1}")(m_terms[k]->m_nzrd[j], "3"); log().verbose("{1}", line); } @@ -347,7 +347,7 @@ ATTR_COLD void matrix_solver_t::setup_matrix() */ for (unsigned k = 0; k < iN; k++) { - pstring num = pfmt("{1}")(k); + 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); @@ -622,54 +622,54 @@ NETLIB_UPDATE(solver) } } -template <int m_N, int _storage_N> +template <int m_N, int storage_N> matrix_solver_t * NETLIB_NAME(solver)::create_solver(int size, const bool use_specific) { - pstring solvername = pfmt("Solver_{1}")(m_mat_solvers.size()); + pstring solvername = plib::pfmt("Solver_{1}")(m_mat_solvers.size()); if (use_specific && m_N == 1) - return palloc(matrix_solver_direct1_t(netlist(), solvername, &m_params)); + return plib::palloc<matrix_solver_direct1_t>(netlist(), solvername, &m_params); else if (use_specific && m_N == 2) - return palloc(matrix_solver_direct2_t(netlist(), solvername, &m_params)); + return plib::palloc<matrix_solver_direct2_t>(netlist(), solvername, &m_params); else { if (size >= m_gs_threshold) { if (pstring("SOR_MAT").equals(m_iterative_solver)) { - typedef matrix_solver_SOR_mat_t<m_N,_storage_N> solver_sor_mat; - return palloc(solver_sor_mat(netlist(), solvername, &m_params, size)); + typedef matrix_solver_SOR_mat_t<m_N,storage_N> solver_sor_mat; + return plib::palloc<solver_sor_mat>(netlist(), solvername, &m_params, size); } else if (pstring("MAT_CR").equals(m_iterative_solver)) { - typedef matrix_solver_GCR_t<m_N,_storage_N> solver_mat; - return palloc(solver_mat(netlist(), solvername, &m_params, size)); + typedef matrix_solver_GCR_t<m_N,storage_N> solver_mat; + return plib::palloc<solver_mat>(netlist(), solvername, &m_params, size); } else if (pstring("MAT").equals(m_iterative_solver)) { - typedef matrix_solver_direct_t<m_N,_storage_N> solver_mat; - return palloc(solver_mat(netlist(), solvername, &m_params, size)); + typedef matrix_solver_direct_t<m_N,storage_N> solver_mat; + return plib::palloc<solver_mat>(netlist(), solvername, &m_params, size); } else if (pstring("SM").equals(m_iterative_solver)) { /* Sherman-Morrison Formula */ - typedef matrix_solver_sm_t<m_N,_storage_N> solver_mat; - return palloc(solver_mat(netlist(), solvername, &m_params, size)); + typedef matrix_solver_sm_t<m_N,storage_N> solver_mat; + return plib::palloc<solver_mat>(netlist(), solvername, &m_params, size); } else if (pstring("W").equals(m_iterative_solver)) { /* Woodbury Formula */ - typedef matrix_solver_w_t<m_N,_storage_N> solver_mat; - return palloc(solver_mat(netlist(), solvername, &m_params, size)); + typedef matrix_solver_w_t<m_N,storage_N> solver_mat; + return plib::palloc<solver_mat>(netlist(), solvername, &m_params, size); } else if (pstring("SOR").equals(m_iterative_solver)) { - typedef matrix_solver_SOR_t<m_N,_storage_N> solver_GS; - return palloc(solver_GS(netlist(), solvername, &m_params, size)); + typedef matrix_solver_SOR_t<m_N,storage_N> solver_GS; + return plib::palloc<solver_GS>(netlist(), solvername, &m_params, size); } else if (pstring("GMRES").equals(m_iterative_solver)) { - typedef matrix_solver_GMRES_t<m_N,_storage_N> solver_GMRES; - return palloc(solver_GMRES(netlist(), solvername, &m_params, size)); + typedef matrix_solver_GMRES_t<m_N,storage_N> solver_GMRES; + return plib::palloc<solver_GMRES>(netlist(), solvername, &m_params, size); } else { @@ -679,15 +679,15 @@ matrix_solver_t * NETLIB_NAME(solver)::create_solver(int size, const bool use_sp } else { - typedef matrix_solver_direct_t<m_N,_storage_N> solver_D; - return palloc(solver_D(netlist(), solvername, &m_params, size)); + typedef matrix_solver_direct_t<m_N,storage_N> solver_D; + return plib::palloc<solver_D>(netlist(), solvername, &m_params, size); } } } ATTR_COLD void NETLIB_NAME(solver)::post_start() { - pvector_t<analog_net_t::list_t> groups; + plib::pvector_t<analog_net_t::list_t> groups; const bool use_specific = true; m_params.m_pivot = m_pivot.Value(); @@ -840,7 +840,7 @@ ATTR_COLD void NETLIB_NAME(solver)::post_start() } } -void NETLIB_NAME(solver)::create_solver_code(postream &strm) +void NETLIB_NAME(solver)::create_solver_code(plib::postream &strm) { for (auto & s : m_mat_solvers) s->create_solver_code(strm); diff --git a/src/lib/netlist/solver/nld_solver.h b/src/lib/netlist/solver/nld_solver.h index 8b1e674cbdd..86a0d6c3218 100644 --- a/src/lib/netlist/solver/nld_solver.h +++ b/src/lib/netlist/solver/nld_solver.h @@ -19,9 +19,9 @@ // Macros // ---------------------------------------------------------------------------------------- -#define SOLVER(_name, _freq) \ - NET_REGISTER_DEV(SOLVER, _name) \ - PARAM(_name.FREQ, _freq) +#define SOLVER(name, freq) \ + NET_REGISTER_DEV(SOLVER, name) \ + PARAM(name.FREQ, freq) // ---------------------------------------------------------------------------------------- // solver @@ -92,7 +92,7 @@ NETLIB_OBJECT(solver) inline nl_double gmin() { return m_gmin.Value(); } - void create_solver_code(postream &strm); + void create_solver_code(plib::postream &strm); NETLIB_UPDATEI(); NETLIB_RESETI(); @@ -120,12 +120,12 @@ protected: param_logic_t m_log_stats; - pvector_t<matrix_solver_t *> m_mat_solvers; + plib::pvector_t<matrix_solver_t *> m_mat_solvers; private: solver_parameters_t m_params; - template <int m_N, int _storage_N> + template <int m_N, int storage_N> matrix_solver_t *create_solver(int size, bool use_specific); }; diff --git a/src/lib/netlist/solver/vector_base.h b/src/lib/netlist/solver/vector_base.h index 1e8e33388ad..b721596e44d 100644 --- a/src/lib/netlist/solver/vector_base.h +++ b/src/lib/netlist/solver/vector_base.h @@ -14,17 +14,17 @@ #include "plib/pconfig.h" #if 0 -template <unsigned _storage_N> +template <unsigned storage_N> struct pvector { pvector(unsigned size) : m_N(size) { } unsigned size() { - if (_storage_N) + if (storage_N) } - double m_V[_storage_N]; + double m_V[storage_N]; private: unsigned m_N; }; diff --git a/src/lib/netlist/tools/nl_convert.cpp b/src/lib/netlist/tools/nl_convert.cpp index 052bd246e5e..fde6c663005 100644 --- a/src/lib/netlist/tools/nl_convert.cpp +++ b/src/lib/netlist/tools/nl_convert.cpp @@ -12,9 +12,9 @@ template<typename Class> -static pvector_t<int> bubble(const pvector_t<Class> &sl) +static plib::pvector_t<int> bubble(const plib::pvector_t<Class> &sl) { - pvector_t<int> ret; + plib::pvector_t<int> ret; for (unsigned i=0; i<sl.size(); i++) ret.push_back(i); @@ -38,7 +38,7 @@ static pvector_t<int> bubble(const 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, pmake_unique<pin_alias_t>(pname, devname + "." + alias)); + m_pins.add(pname, plib::pmake_unique<pin_alias_t>(pname, devname + "." + alias)); } void nl_convert_base_t::add_ext_alias(const pstring &alias) @@ -102,7 +102,7 @@ void nl_convert_base_t::dump_nl() if (net->terminals().size() == 1) net->set_no_export(); } - pvector_t<int> sorted = bubble(m_devs); + plib::pvector_t<int> sorted = bubble(m_devs); for (std::size_t i=0; i<m_devs.size(); i++) { std::size_t j = sorted[i]; @@ -148,7 +148,7 @@ const pstring nl_convert_base_t::get_nl_val(const double val) break; i++; } - return pfmt(m_units[i].m_func.cstr())(val / m_units[i].m_mult); + return plib::pfmt(m_units[i].m_func.cstr())(val / m_units[i].m_mult); } } double nl_convert_base_t::get_sp_unit(const pstring &unit) @@ -199,7 +199,7 @@ nl_convert_base_t::unit_t nl_convert_base_t::m_units[] = { void nl_convert_spice_t::convert(const pstring &contents) { - pstring_vector_t spnl(contents, "\n"); + plib::pstring_vector_t spnl(contents, "\n"); // Add gnd net @@ -231,7 +231,7 @@ void nl_convert_spice_t::process_line(const pstring &line) { if (line != "") { - pstring_vector_t tt(line, " ", true); + plib::pstring_vector_t tt(line, " ", true); double val = 0.0; switch (tt[0].code_at(0)) { @@ -270,7 +270,7 @@ void nl_convert_spice_t::process_line(const pstring &line) model = tt[5]; else model = tt[4]; - pstring_vector_t m(model,"{"); + plib::pstring_vector_t m(model,"{"); if (m.size() == 2) { if (m[1].len() != 4) @@ -343,7 +343,7 @@ void nl_convert_spice_t::process_line(const pstring &line) add_device(tname, xname); for (std::size_t i=1; i < tt.size() - 1; i++) { - pstring term = pfmt("{1}.{2}")(xname)(i); + pstring term = plib::pfmt("{1}.{2}")(xname)(i); add_term(tt[i], term); } break; @@ -357,7 +357,7 @@ void nl_convert_spice_t::process_line(const pstring &line) //FIXME: should accept a stream as well void nl_convert_eagle_t::convert(const pstring &contents) { - pistringstream istrm(contents); + plib::pistringstream istrm(contents); eagle_tokenizer tok(*this, istrm); out("NETLIST_START(dummy)\n"); diff --git a/src/lib/netlist/tools/nl_convert.h b/src/lib/netlist/tools/nl_convert.h index 65b951d8daf..40d339e0934 100644 --- a/src/lib/netlist/tools/nl_convert.h +++ b/src/lib/netlist/tools/nl_convert.h @@ -54,7 +54,7 @@ protected: double get_sp_val(const pstring &sin); - pstream_fmt_writer_t out; + plib::pstream_fmt_writer_t out; private: struct net_t @@ -64,14 +64,14 @@ private: : m_name(aname), m_no_export(false) {} const pstring &name() { return m_name;} - pstring_vector_t &terminals() { return m_terminals; } + plib::pstring_vector_t &terminals() { return m_terminals; } void set_no_export() { m_no_export = true; } bool is_no_export() { return m_no_export; } private: pstring m_name; bool m_no_export; - pstring_vector_t m_terminals; + plib::pstring_vector_t m_terminals; }; struct dev_t @@ -128,12 +128,12 @@ private: void add_device(std::shared_ptr<dev_t> dev); - postringstream m_buf; + plib::postringstream m_buf; - pvector_t<std::shared_ptr<dev_t>> m_devs; - phashmap_t<pstring, std::shared_ptr<net_t> > m_nets; - pvector_t<pstring> m_ext_alias; - phashmap_t<pstring, std::shared_ptr<pin_alias_t>> m_pins; + 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; static unit_t m_units[]; @@ -167,11 +167,11 @@ public: { } - class eagle_tokenizer : public ptokenizer + class eagle_tokenizer : public plib::ptokenizer { public: - eagle_tokenizer(nl_convert_eagle_t &convert, pistream &strm) - : ptokenizer(strm), m_convert(convert) + eagle_tokenizer(nl_convert_eagle_t &convert, plib::pistream &strm) + : plib::ptokenizer(strm), m_convert(convert) { set_identifier_chars("abcdefghijklmnopqrstuvwvxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890_.-"); set_number_chars(".0123456789", "0123456789eE-."); //FIXME: processing of numbers |