sc_signal.hh revision 12912
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 9 * notice, this list of conditions and the following disclaimer in the 10 * documentation and/or other materials provided with the distribution; 11 * neither the name of the copyright holders nor the names of its 12 * contributors may be used to endorse or promote products derived from 13 * this software without specific prior written permission. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 16 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 17 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 18 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 19 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 21 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 25 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 * 27 * Authors: Gabe Black 28 */ 29 30#ifndef __SYSTEMC_EXT_CHANNEL_SC_SIGNAL_HH__ 31#define __SYSTEMC_EXT_CHANNEL_SC_SIGNAL_HH__ 32 33#include <iostream> 34 35#include "../core/sc_module.hh" // for sc_gen_unique_name 36#include "../core/sc_prim.hh" 37#include "sc_signal_inout_if.hh" 38#include "warn_unimpl.hh" // for warn_unimpl 39 40namespace sc_core 41{ 42 43class sc_port_base; 44 45template <class T, sc_writer_policy WRITER_POLICY=SC_ONE_WRITER> 46class sc_signal : public sc_signal_inout_if<T>, 47 public sc_prim_channel 48{ 49 public: 50 sc_signal() : sc_signal_inout_if<T>(), 51 sc_prim_channel(sc_gen_unique_name("signal")) 52 {} 53 explicit sc_signal(const char *name) : sc_signal_inout_if<T>(), 54 sc_prim_channel(name) 55 {} 56 explicit sc_signal(const char *name, const T &initial_value) : 57 sc_signal_inout_if<T>(), sc_prim_channel(name) 58 { 59 // Need to consume initial_value. 60 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 61 } 62 virtual ~sc_signal() {} 63 64 virtual void 65 register_port(sc_port_base &, const char *) 66 { 67 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 68 } 69 70 virtual const T& 71 read() const 72 { 73 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 74 return *(const T *)nullptr; 75 } 76 operator const T&() const 77 { 78 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 79 return *(const T *)nullptr; 80 } 81 82 virtual sc_writer_policy 83 get_writer_policy() const 84 { 85 return WRITER_POLICY; 86 } 87 virtual void 88 write(const T&) 89 { 90 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 91 } 92 sc_signal<T, WRITER_POLICY> & 93 operator = (const T&) 94 { 95 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 96 return *this; 97 } 98 sc_signal<T, WRITER_POLICY> & 99 operator = (const sc_signal<T, WRITER_POLICY> &) 100 { 101 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 102 return *this; 103 } 104 105 virtual const sc_event & 106 default_event() const 107 { 108 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 109 return *(sc_event *)nullptr; 110 } 111 virtual const sc_event & 112 value_changed_event() const 113 { 114 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 115 return *(sc_event *)nullptr; 116 } 117 virtual bool 118 event() const 119 { 120 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 121 return false; 122 } 123 124 virtual void 125 print(std::ostream & =std::cout) const 126 { 127 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 128 } 129 virtual void 130 dump(std::ostream & =std::cout) const 131 { 132 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 133 } 134 virtual const char *kind() const { return "sc_signal"; } 135 136 protected: 137 virtual void 138 update() 139 { 140 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 141 } 142 143 private: 144 // Disabled 145 sc_signal(const sc_signal<T, WRITER_POLICY> &) : 146 sc_signal_inout_if<T>(), sc_prim_channel("") 147 {} 148}; 149 150template <class T, sc_writer_policy WRITER_POLICY> 151inline std::ostream & 152operator << (std::ostream &os, const sc_signal<T, WRITER_POLICY> &) 153{ 154 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 155 return os; 156} 157 158template <sc_writer_policy WRITER_POLICY> 159class sc_signal<bool, WRITER_POLICY> : 160 public sc_signal_inout_if<bool>, public sc_prim_channel 161{ 162 public: 163 sc_signal() 164 { 165 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 166 } 167 explicit sc_signal(const char *) 168 { 169 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 170 } 171 explicit sc_signal(const char *name, const bool &initial_value) : 172 sc_signal_inout_if<bool>(), sc_prim_channel(name) 173 { 174 // Need to consume initial_value. 175 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 176 } 177 virtual ~sc_signal() 178 { 179 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 180 } 181 182 virtual void 183 register_port(sc_port_base &, const char *) 184 { 185 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 186 } 187 188 virtual const bool & 189 read() const 190 { 191 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 192 return *(const bool *)nullptr; 193 } 194 operator const bool &() const 195 { 196 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 197 return *(const bool *)nullptr; 198 } 199 200 virtual sc_writer_policy 201 get_writer_policy() const 202 { 203 return WRITER_POLICY; 204 } 205 virtual void 206 write(const bool &) 207 { 208 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 209 } 210 sc_signal<bool, WRITER_POLICY> & 211 operator = (const bool &) 212 { 213 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 214 return *this; 215 } 216 sc_signal<bool, WRITER_POLICY> & 217 operator = (const sc_signal<bool, WRITER_POLICY> &) 218 { 219 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 220 return *this; 221 } 222 223 virtual const sc_event & 224 default_event() const 225 { 226 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 227 return *(sc_event *)nullptr; 228 } 229 230 virtual const sc_event & 231 value_changed_event() const 232 { 233 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 234 return *(sc_event *)nullptr; 235 } 236 virtual const sc_event & 237 posedge_event() const 238 { 239 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 240 return *(sc_event *)nullptr; 241 } 242 virtual const sc_event & 243 negedge_event() const 244 { 245 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 246 return *(sc_event *)nullptr; 247 } 248 249 virtual bool 250 event() const 251 { 252 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 253 return false; 254 } 255 virtual bool 256 posedge() const 257 { 258 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 259 return false; 260 } 261 virtual bool 262 negedge() const 263 { 264 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 265 return false; 266 } 267 268 virtual void 269 print(std::ostream & =std::cout) const 270 { 271 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 272 } 273 virtual void 274 dump(std::ostream & =std::cout) const 275 { 276 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 277 } 278 virtual const char *kind() const { return "sc_signal"; } 279 280 protected: 281 virtual void 282 update() 283 { 284 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 285 } 286 287 private: 288 // Disabled 289 sc_signal(const sc_signal<bool, WRITER_POLICY> &) : 290 sc_signal_inout_if<bool>(), sc_prim_channel("") 291 {} 292}; 293 294template <sc_writer_policy WRITER_POLICY> 295class sc_signal<sc_dt::sc_logic, WRITER_POLICY> : 296 public sc_signal_inout_if<sc_dt::sc_logic>, public sc_prim_channel 297{ 298 public: 299 sc_signal() 300 { 301 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 302 } 303 explicit sc_signal(const char *) 304 { 305 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 306 } 307 explicit sc_signal(const char *name, 308 const sc_dt::sc_logic &initial_value) : 309 sc_signal_inout_if<sc_dt::sc_logic>(), sc_prim_channel(name) 310 { 311 // Need to consume initial_value. 312 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 313 } 314 virtual ~sc_signal() 315 { 316 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 317 } 318 319 virtual void 320 register_port(sc_port_base &, const char *) 321 { 322 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 323 } 324 325 virtual const sc_dt::sc_logic & 326 read() const 327 { 328 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 329 return *(const sc_dt::sc_logic *)nullptr; 330 } 331 operator const sc_dt::sc_logic &() const 332 { 333 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 334 return *(const sc_dt::sc_logic *)nullptr; 335 } 336 337 virtual sc_writer_policy 338 get_writer_policy() const 339 { 340 return WRITER_POLICY; 341 } 342 virtual void 343 write(const sc_dt::sc_logic &) 344 { 345 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 346 } 347 sc_signal<sc_dt::sc_logic, WRITER_POLICY> & 348 operator = (const sc_dt::sc_logic &) 349 { 350 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 351 return *this; 352 } 353 sc_signal<sc_dt::sc_logic, WRITER_POLICY> & 354 operator = (const sc_signal<sc_dt::sc_logic, WRITER_POLICY> &) 355 { 356 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 357 return *this; 358 } 359 360 virtual const sc_event & 361 default_event() const 362 { 363 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 364 return *(sc_event *)nullptr; 365 } 366 367 virtual const sc_event & 368 value_changed_event() const 369 { 370 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 371 return *(sc_event *)nullptr; 372 } 373 virtual const sc_event & 374 posedge_event() const 375 { 376 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 377 return *(sc_event *)nullptr; 378 } 379 virtual const sc_event & 380 negedge_event() const 381 { 382 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 383 return *(sc_event *)nullptr; 384 } 385 386 virtual bool 387 event() const 388 { 389 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 390 return false; 391 } 392 virtual bool 393 posedge() const 394 { 395 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 396 return false; 397 } 398 virtual bool 399 negedge() const 400 { 401 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 402 return false; 403 } 404 405 virtual void 406 print(std::ostream & =std::cout) const 407 { 408 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 409 } 410 virtual void 411 dump(std::ostream & =std::cout) const 412 { 413 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 414 } 415 virtual const char *kind() const { return "sc_signal"; } 416 417 protected: 418 virtual void 419 update() 420 { 421 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 422 } 423 424 private: 425 // Disabled 426 sc_signal(const sc_signal<sc_dt::sc_logic, WRITER_POLICY> &) : 427 sc_signal_inout_if<sc_dt::sc_logic>(), sc_prim_channel("") 428 {} 429}; 430 431} // namespace sc_core 432 433#endif //__SYSTEMC_EXT_CHANNEL_SC_SIGNAL_HH__ 434