sc_signal.hh (12945:365bae01b46d) | sc_signal.hh (13044:df7783886021) |
---|---|
1/* 2 * Copyright 2018 Google, Inc. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions are 6 * met: redistributions of source code must retain the above copyright 7 * notice, this list of conditions and the following disclaimer; 8 * redistributions in binary form must reproduce the above copyright --- 20 unchanged lines hidden (view full) --- 29 30#ifndef __SYSTEMC_EXT_CHANNEL_SC_SIGNAL_HH__ 31#define __SYSTEMC_EXT_CHANNEL_SC_SIGNAL_HH__ 32 33#include <iostream> 34#include <string> 35#include <vector> 36 | 1/* 2 * Copyright 2018 Google, Inc. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions are 6 * met: redistributions of source code must retain the above copyright 7 * notice, this list of conditions and the following disclaimer; 8 * redistributions in binary form must reproduce the above copyright --- 20 unchanged lines hidden (view full) --- 29 30#ifndef __SYSTEMC_EXT_CHANNEL_SC_SIGNAL_HH__ 31#define __SYSTEMC_EXT_CHANNEL_SC_SIGNAL_HH__ 32 33#include <iostream> 34#include <string> 35#include <vector> 36 |
37#include "../core/sc_event.hh" |
|
37#include "../core/sc_module.hh" // for sc_gen_unique_name 38#include "../core/sc_prim.hh" | 38#include "../core/sc_module.hh" // for sc_gen_unique_name 39#include "../core/sc_prim.hh" |
40#include "../dt/bit/sc_logic.hh" |
|
39#include "sc_signal_inout_if.hh" 40#include "warn_unimpl.hh" // for warn_unimpl 41 42namespace sc_core 43{ 44 45class sc_port_base; 46class sc_trace_file; --- 14 unchanged lines hidden (view full) --- 61typedef std::vector<sc_trace_params *> sc_trace_params_vec; 62 63template <class T, sc_writer_policy WRITER_POLICY=SC_ONE_WRITER> 64class sc_signal : public sc_signal_inout_if<T>, 65 public sc_prim_channel 66{ 67 public: 68 sc_signal() : sc_signal_inout_if<T>(), | 41#include "sc_signal_inout_if.hh" 42#include "warn_unimpl.hh" // for warn_unimpl 43 44namespace sc_core 45{ 46 47class sc_port_base; 48class sc_trace_file; --- 14 unchanged lines hidden (view full) --- 63typedef std::vector<sc_trace_params *> sc_trace_params_vec; 64 65template <class T, sc_writer_policy WRITER_POLICY=SC_ONE_WRITER> 66class sc_signal : public sc_signal_inout_if<T>, 67 public sc_prim_channel 68{ 69 public: 70 sc_signal() : sc_signal_inout_if<T>(), |
69 sc_prim_channel(sc_gen_unique_name("signal")) | 71 sc_prim_channel(sc_gen_unique_name("signal")), 72 m_cur_val(T()), m_new_val(T()) |
70 {} | 73 {} |
71 explicit sc_signal(const char *name) : sc_signal_inout_if<T>(), 72 sc_prim_channel(name) | 74 explicit sc_signal(const char *name) : 75 sc_signal_inout_if<T>(), sc_prim_channel(name), 76 m_cur_val(T()), m_new_val(T()) |
73 {} 74 explicit sc_signal(const char *name, const T &initial_value) : | 77 {} 78 explicit sc_signal(const char *name, const T &initial_value) : |
75 sc_signal_inout_if 76 { 77 // Need to consume initial_value. 78 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 79 } | 79 sc_signal_inout_if<T>(), sc_prim_channel(name), 80 m_cur_val(initial_value), m_new_val(initial_value) 81 {} |
80 virtual ~sc_signal() {} 81 82 virtual void 83 register_port(sc_port_base &, const char *) 84 { 85 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 86 } 87 | 82 virtual ~sc_signal() {} 83 84 virtual void 85 register_port(sc_port_base &, const char *) 86 { 87 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 88 } 89 |
88 virtual const T& 89 read() const 90 { 91 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 92 return *(const T *)nullptr; 93 } 94 operator const T&() const 95 { 96 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 97 return *(const T *)nullptr; 98 } | 90 virtual const T &read() const { return m_cur_val; } 91 operator const T&() const { return read(); } |
99 100 virtual sc_writer_policy 101 get_writer_policy() const 102 { 103 return WRITER_POLICY; 104 } 105 virtual void | 92 93 virtual sc_writer_policy 94 get_writer_policy() const 95 { 96 return WRITER_POLICY; 97 } 98 virtual void |
106 write(const T&) | 99 write(const T &t) |
107 { | 100 { |
108 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); | 101 m_new_val = t; 102 bool changed = !(m_cur_val == m_new_val); 103 //TODO check whether this write follows the write policy. 104 if (changed) 105 request_update(); |
109 } 110 sc_signal<T, WRITER_POLICY> & | 106 } 107 sc_signal<T, WRITER_POLICY> & |
111 operator = (const T&) | 108 operator = (const T &t) |
112 { | 109 { |
113 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); | 110 write(t); |
114 return *this; 115 } 116 sc_signal<T, WRITER_POLICY> & | 111 return *this; 112 } 113 sc_signal<T, WRITER_POLICY> & |
117 operator = (const sc_signal | 114 operator = (const sc_signal<T, WRITER_POLICY> &s) |
118 { | 115 { |
119 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); | 116 write(s.read()); |
120 return *this; 121 } 122 123 virtual const sc_event & 124 default_event() const 125 { | 117 return *this; 118 } 119 120 virtual const sc_event & 121 default_event() const 122 { |
126 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 127 return *(sc_event *)nullptr; | 123 return value_changed_event(); |
128 } 129 virtual const sc_event & 130 value_changed_event() const 131 { | 124 } 125 virtual const sc_event & 126 value_changed_event() const 127 { |
132 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 133 return *(sc_event *)nullptr; | 128 return _valueChangedEvent; |
134 } 135 virtual bool 136 event() const 137 { 138 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 139 return false; 140 } 141 | 129 } 130 virtual bool 131 event() const 132 { 133 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 134 return false; 135 } 136 |
137 virtual void print(std::ostream &os=std::cout) const { os << m_cur_val; } |
|
142 virtual void | 138 virtual void |
143 print(std::ostream & =std::cout) const | 139 dump(std::ostream &os=std::cout) const |
144 { | 140 { |
145 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); | 141 os << " name = " << name() << ::std::endl; 142 os << " value = " << m_cur_val << ::std::endl; 143 os << "new value = " << m_new_val << ::std::endl; |
146 } | 144 } |
147 virtual void 148 dump(std::ostream & =std::cout) const 149 { 150 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 151 } | |
152 virtual const char *kind() const { return "sc_signal"; } 153 154 protected: 155 virtual void 156 update() 157 { | 145 virtual const char *kind() const { return "sc_signal"; } 146 147 protected: 148 virtual void 149 update() 150 { |
158 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); | 151 if (m_new_val == m_cur_val) 152 return; 153 154 m_cur_val = m_new_val; 155 _valueChangedEvent.notify(SC_ZERO_TIME); |
159 } 160 161 // These members which store the current and future value of the signal 162 // are not specified in the standard but are referred to directly by one 163 // of the tests. 164 T m_cur_val; 165 T m_new_val; 166 167 private: | 156 } 157 158 // These members which store the current and future value of the signal 159 // are not specified in the standard but are referred to directly by one 160 // of the tests. 161 T m_cur_val; 162 T m_new_val; 163 164 private: |
165 sc_event _valueChangedEvent; 166 |
|
168 // Disabled 169 sc_signal(const sc_signal<T, WRITER_POLICY> &) : 170 sc_signal_inout_if<T>(), sc_prim_channel("") 171 {} 172}; 173 174template <class T, sc_writer_policy WRITER_POLICY> 175inline std::ostream & 176operator << (std::ostream &os, const sc_signal<T, WRITER_POLICY> &) 177{ 178 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 179 return os; 180} 181 182template <sc_writer_policy WRITER_POLICY> 183class sc_signal<bool, WRITER_POLICY> : 184 public sc_signal_inout_if<bool>, public sc_prim_channel 185{ 186 public: | 167 // Disabled 168 sc_signal(const sc_signal<T, WRITER_POLICY> &) : 169 sc_signal_inout_if<T>(), sc_prim_channel("") 170 {} 171}; 172 173template <class T, sc_writer_policy WRITER_POLICY> 174inline std::ostream & 175operator << (std::ostream &os, const sc_signal<T, WRITER_POLICY> &) 176{ 177 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 178 return os; 179} 180 181template <sc_writer_policy WRITER_POLICY> 182class sc_signal<bool, WRITER_POLICY> : 183 public sc_signal_inout_if<bool>, public sc_prim_channel 184{ 185 public: |
187 sc_signal() 188 { 189 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 190 } 191 explicit sc_signal(const char *) 192 { 193 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 194 } | 186 sc_signal() : sc_signal_inout_if<bool>(), 187 sc_prim_channel(sc_gen_unique_name("signal")), 188 m_cur_val(bool()), m_new_val(bool()) 189 {} 190 explicit sc_signal(const char *name) : 191 sc_signal_inout_if<bool>(), sc_prim_channel(name), 192 m_cur_val(bool()), m_new_val(bool()) 193 {} |
195 explicit sc_signal(const char *name, const bool &initial_value) : | 194 explicit sc_signal(const char *name, const bool &initial_value) : |
196 sc_signal_inout_if 197 { 198 // Need to consume initial_value. 199 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 200 } 201 virtual ~sc_signal() 202 { 203 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 204 } | 195 sc_signal_inout_if<bool>(), sc_prim_channel(name), 196 m_cur_val(initial_value), m_new_val(initial_value) 197 {} 198 virtual ~sc_signal() {} |
205 206 virtual void 207 register_port(sc_port_base &, const char *) 208 { 209 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 210 } 211 | 199 200 virtual void 201 register_port(sc_port_base &, const char *) 202 { 203 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 204 } 205 |
212 virtual const bool & 213 read() const 214 { 215 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 216 return *(const bool *)nullptr; 217 } 218 operator const bool &() const 219 { 220 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 221 return *(const bool *)nullptr; 222 } | 206 virtual const bool &read() const { return m_cur_val; } 207 operator const bool &() const { return read(); } |
223 224 virtual sc_writer_policy 225 get_writer_policy() const 226 { 227 return WRITER_POLICY; 228 } 229 virtual void | 208 209 virtual sc_writer_policy 210 get_writer_policy() const 211 { 212 return WRITER_POLICY; 213 } 214 virtual void |
230 write(const bool &) | 215 write(const bool &b) |
231 { | 216 { |
232 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); | 217 m_new_val = b; 218 bool changed = !(m_cur_val == m_new_val); 219 //TODO check whether this write follows the write policy. 220 if (changed) 221 request_update(); |
233 } 234 sc_signal<bool, WRITER_POLICY> & | 222 } 223 sc_signal<bool, WRITER_POLICY> & |
235 operator = (const bool &) | 224 operator = (const bool &b) |
236 { | 225 { |
237 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); | 226 write(b); |
238 return *this; 239 } 240 sc_signal<bool, WRITER_POLICY> & | 227 return *this; 228 } 229 sc_signal<bool, WRITER_POLICY> & |
241 operator = (const sc_signal | 230 operator = (const sc_signal<bool, WRITER_POLICY> &s) |
242 { | 231 { |
243 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); | 232 write(s.read()); |
244 return *this; 245 } 246 247 virtual const sc_event & 248 default_event() const 249 { | 233 return *this; 234 } 235 236 virtual const sc_event & 237 default_event() const 238 { |
250 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 251 return *(sc_event *)nullptr; | 239 return value_changed_event(); |
252 } 253 254 virtual const sc_event & 255 value_changed_event() const 256 { | 240 } 241 242 virtual const sc_event & 243 value_changed_event() const 244 { |
257 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 258 return *(sc_event *)nullptr; | 245 return _valueChangedEvent; |
259 } 260 virtual const sc_event & 261 posedge_event() const 262 { | 246 } 247 virtual const sc_event & 248 posedge_event() const 249 { |
263 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 264 return *(sc_event *)nullptr; | 250 return _posedgeEvent; |
265 } 266 virtual const sc_event & 267 negedge_event() const 268 { | 251 } 252 virtual const sc_event & 253 negedge_event() const 254 { |
269 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 270 return *(sc_event *)nullptr; | 255 return _negedgeEvent; |
271 } 272 273 virtual bool 274 event() const 275 { 276 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 277 return false; 278 } --- 5 unchanged lines hidden (view full) --- 284 } 285 virtual bool 286 negedge() const 287 { 288 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 289 return false; 290 } 291 | 256 } 257 258 virtual bool 259 event() const 260 { 261 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 262 return false; 263 } --- 5 unchanged lines hidden (view full) --- 269 } 270 virtual bool 271 negedge() const 272 { 273 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 274 return false; 275 } 276 |
277 virtual void print(std::ostream &os=std::cout) const { os << m_cur_val; } |
|
292 virtual void | 278 virtual void |
293 print(std::ostream & =std::cout) const | 279 dump(std::ostream &os=std::cout) const |
294 { | 280 { |
295 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); | 281 os << " name = " << name() << ::std::endl; 282 os << " value = " << m_cur_val << ::std::endl; 283 os << "new value = " << m_new_val << ::std::endl; |
296 } | 284 } |
297 virtual void 298 dump(std::ostream & =std::cout) const 299 { 300 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 301 } | |
302 virtual const char *kind() const { return "sc_signal"; } 303 304 protected: 305 virtual void 306 update() 307 { | 285 virtual const char *kind() const { return "sc_signal"; } 286 287 protected: 288 virtual void 289 update() 290 { |
308 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); | 291 if (m_new_val == m_cur_val) 292 return; 293 294 m_cur_val = m_new_val; 295 _valueChangedEvent.notify(SC_ZERO_TIME); 296 if (m_cur_val) 297 _posedgeEvent.notify(SC_ZERO_TIME); 298 else 299 _negedgeEvent.notify(SC_ZERO_TIME); |
309 } 310 | 300 } 301 |
302 bool m_cur_val; 303 bool m_new_val; 304 |
|
311 private: | 305 private: |
306 sc_event _valueChangedEvent; 307 sc_event _posedgeEvent; 308 sc_event _negedgeEvent; 309 |
|
312 // Disabled 313 sc_signal(const sc_signal<bool, WRITER_POLICY> &) : 314 sc_signal_inout_if<bool>(), sc_prim_channel("") 315 {} 316}; 317 318template <sc_writer_policy WRITER_POLICY> 319class sc_signal<sc_dt::sc_logic, WRITER_POLICY> : 320 public sc_signal_inout_if<sc_dt::sc_logic>, public sc_prim_channel 321{ 322 public: | 310 // Disabled 311 sc_signal(const sc_signal<bool, WRITER_POLICY> &) : 312 sc_signal_inout_if<bool>(), sc_prim_channel("") 313 {} 314}; 315 316template <sc_writer_policy WRITER_POLICY> 317class sc_signal<sc_dt::sc_logic, WRITER_POLICY> : 318 public sc_signal_inout_if<sc_dt::sc_logic>, public sc_prim_channel 319{ 320 public: |
323 sc_signal() 324 { 325 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 326 } 327 explicit sc_signal(const char *) 328 { 329 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 330 } | 321 sc_signal() : sc_signal_inout_if<sc_dt::sc_logic>(), 322 sc_prim_channel(sc_gen_unique_name("signal")), 323 m_cur_val(sc_dt::sc_logic()), m_new_val(sc_dt::sc_logic()) 324 {} 325 explicit sc_signal(const char *name) : 326 sc_signal_inout_if<sc_dt::sc_logic>(), sc_prim_channel(name), 327 m_cur_val(sc_dt::sc_logic()), m_new_val(sc_dt::sc_logic()) 328 {} |
331 explicit sc_signal(const char *name, 332 const sc_dt::sc_logic &initial_value) : | 329 explicit sc_signal(const char *name, 330 const sc_dt::sc_logic &initial_value) : |
333 sc_signal_inout_if 334 { 335 // Need to consume initial_value. 336 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 337 } 338 virtual ~sc_signal() 339 { 340 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 341 } | 331 sc_signal_inout_if<sc_dt::sc_logic>(), sc_prim_channel(name), 332 m_cur_val(initial_value), m_new_val(initial_value) 333 {} 334 virtual ~sc_signal() {} |
342 343 virtual void 344 register_port(sc_port_base &, const char *) 345 { 346 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 347 } 348 | 335 336 virtual void 337 register_port(sc_port_base &, const char *) 338 { 339 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 340 } 341 |
349 virtual const sc_dt::sc_logic & 350 read() const 351 { 352 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 353 return *(const sc_dt::sc_logic *)nullptr; 354 } 355 operator const sc_dt::sc_logic &() const 356 { 357 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 358 return *(const sc_dt::sc_logic *)nullptr; 359 } | 342 virtual const sc_dt::sc_logic &read() const { return m_cur_val; } 343 operator const sc_dt::sc_logic &() const { return read(); } |
360 361 virtual sc_writer_policy 362 get_writer_policy() const 363 { 364 return WRITER_POLICY; 365 } 366 virtual void | 344 345 virtual sc_writer_policy 346 get_writer_policy() const 347 { 348 return WRITER_POLICY; 349 } 350 virtual void |
367 write(const sc_dt::sc_logic &) | 351 write(const sc_dt::sc_logic &l) |
368 { | 352 { |
369 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); | 353 m_new_val = l; 354 bool changed = !(m_cur_val == m_new_val); 355 //TODO check whether this write follows the write policy. 356 if (changed) 357 request_update(); |
370 } 371 sc_signal<sc_dt::sc_logic, WRITER_POLICY> & | 358 } 359 sc_signal<sc_dt::sc_logic, WRITER_POLICY> & |
372 operator = (const sc_dt::sc_logic &) | 360 operator = (const sc_dt::sc_logic &l) |
373 { | 361 { |
374 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); | 362 write(l); |
375 return *this; 376 } 377 sc_signal<sc_dt::sc_logic, WRITER_POLICY> & | 363 return *this; 364 } 365 sc_signal<sc_dt::sc_logic, WRITER_POLICY> & |
378 operator = (const sc_signal | 366 operator = (const sc_signal<sc_dt::sc_logic, WRITER_POLICY> &s) |
379 { | 367 { |
380 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); | 368 write(s.read()); |
381 return *this; 382 } 383 384 virtual const sc_event & 385 default_event() const 386 { | 369 return *this; 370 } 371 372 virtual const sc_event & 373 default_event() const 374 { |
387 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 388 return *(sc_event *)nullptr; | 375 return value_changed_event(); |
389 } 390 391 virtual const sc_event & 392 value_changed_event() const 393 { | 376 } 377 378 virtual const sc_event & 379 value_changed_event() const 380 { |
394 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 395 return *(sc_event *)nullptr; | 381 return _valueChangedEvent; |
396 } 397 virtual const sc_event & 398 posedge_event() const 399 { | 382 } 383 virtual const sc_event & 384 posedge_event() const 385 { |
400 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 401 return *(sc_event *)nullptr; | 386 return _posedgeEvent; |
402 } 403 virtual const sc_event & 404 negedge_event() const 405 { | 387 } 388 virtual const sc_event & 389 negedge_event() const 390 { |
406 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 407 return *(sc_event *)nullptr; | 391 return _negedgeEvent; |
408 } 409 410 virtual bool 411 event() const 412 { 413 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 414 return false; 415 } --- 5 unchanged lines hidden (view full) --- 421 } 422 virtual bool 423 negedge() const 424 { 425 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 426 return false; 427 } 428 | 392 } 393 394 virtual bool 395 event() const 396 { 397 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 398 return false; 399 } --- 5 unchanged lines hidden (view full) --- 405 } 406 virtual bool 407 negedge() const 408 { 409 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 410 return false; 411 } 412 |
413 virtual void print(std::ostream &os=std::cout) const { os << m_cur_val; } |
|
429 virtual void | 414 virtual void |
430 print(std::ostream & =std::cout) const | 415 dump(std::ostream &os=std::cout) const |
431 { | 416 { |
432 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); | 417 os << " name = " << name() << ::std::endl; 418 os << " value = " << m_cur_val << ::std::endl; 419 os << "new value = " << m_new_val << ::std::endl; |
433 } | 420 } |
434 virtual void 435 dump(std::ostream & =std::cout) const 436 { 437 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 438 } | |
439 virtual const char *kind() const { return "sc_signal"; } 440 441 protected: 442 virtual void 443 update() 444 { | 421 virtual const char *kind() const { return "sc_signal"; } 422 423 protected: 424 virtual void 425 update() 426 { |
445 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); | 427 if (m_new_val == m_cur_val) 428 return; 429 430 m_cur_val = m_new_val; 431 _valueChangedEvent.notify(SC_ZERO_TIME); 432 if (m_cur_val == sc_dt::SC_LOGIC_1) 433 _posedgeEvent.notify(SC_ZERO_TIME); 434 else if (m_cur_val == sc_dt::SC_LOGIC_0) 435 _negedgeEvent.notify(SC_ZERO_TIME); |
446 } 447 | 436 } 437 |
438 sc_dt::sc_logic m_cur_val; 439 sc_dt::sc_logic m_new_val; 440 |
|
448 private: | 441 private: |
442 sc_event _valueChangedEvent; 443 sc_event _posedgeEvent; 444 sc_event _negedgeEvent; 445 |
|
449 // Disabled 450 sc_signal(const sc_signal<sc_dt::sc_logic, WRITER_POLICY> &) : 451 sc_signal_inout_if<sc_dt::sc_logic>(), sc_prim_channel("") 452 {} 453}; 454 455} // namespace sc_core 456 457#endif //__SYSTEMC_EXT_CHANNEL_SC_SIGNAL_HH__ | 446 // Disabled 447 sc_signal(const sc_signal<sc_dt::sc_logic, WRITER_POLICY> &) : 448 sc_signal_inout_if<sc_dt::sc_logic>(), sc_prim_channel("") 449 {} 450}; 451 452} // namespace sc_core 453 454#endif //__SYSTEMC_EXT_CHANNEL_SC_SIGNAL_HH__ |