sc_signal.hh revision 12841
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 virtual ~sc_signal() {} 57 58 virtual void 59 register_port(sc_port_base &, const char *) 60 { 61 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 62 } 63 64 virtual const T& 65 read() const 66 { 67 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 68 return *(const T *)nullptr; 69 } 70 operator const T&() const 71 { 72 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 73 return *(const T *)nullptr; 74 } 75 76 virtual sc_writer_policy 77 get_writer_policy() const 78 { 79 return WRITER_POLICY; 80 } 81 virtual void 82 write(const T&) 83 { 84 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 85 } 86 sc_signal<T, WRITER_POLICY> & 87 operator = (const T&) 88 { 89 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 90 return *this; 91 } 92 sc_signal<T, WRITER_POLICY> & 93 operator = (const sc_signal<T, WRITER_POLICY> &) 94 { 95 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 96 return *this; 97 } 98 99 virtual const sc_event & 100 default_event() const 101 { 102 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 103 return *(sc_event *)nullptr; 104 } 105 virtual const sc_event & 106 value_changed_event() const 107 { 108 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 109 return *(sc_event *)nullptr; 110 } 111 virtual bool 112 event() const 113 { 114 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 115 return false; 116 } 117 118 virtual void 119 print(std::ostream & =std::cout) const 120 { 121 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 122 } 123 virtual void 124 dump(std::ostream & =std::cout) const 125 { 126 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 127 } 128 virtual const char *kind() const { return "sc_signal"; } 129 130 protected: 131 virtual void 132 update() 133 { 134 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 135 } 136 137 private: 138 // Disabled 139 sc_signal(const sc_signal<T, WRITER_POLICY> &) : 140 sc_signal_inout_if<T>(), sc_prim_channel("") 141 {} 142}; 143 144template <class T, sc_writer_policy WRITER_POLICY> 145inline std::ostream & 146operator << (std::ostream &os, const sc_signal<T, WRITER_POLICY> &) 147{ 148 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 149 return os; 150} 151 152template <sc_writer_policy WRITER_POLICY> 153class sc_signal<bool, WRITER_POLICY> : 154 public sc_signal_inout_if<bool>, public sc_prim_channel 155{ 156 public: 157 sc_signal() 158 { 159 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 160 } 161 explicit sc_signal(const char *) 162 { 163 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 164 } 165 virtual ~sc_signal() 166 { 167 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 168 } 169 170 virtual void 171 register_port(sc_port_base &, const char *) 172 { 173 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 174 } 175 176 virtual const bool & 177 read() const 178 { 179 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 180 return *(const bool *)nullptr; 181 } 182 operator const bool &() const 183 { 184 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 185 return *(const bool *)nullptr; 186 } 187 188 virtual sc_writer_policy 189 get_writer_policy() const 190 { 191 return WRITER_POLICY; 192 } 193 virtual void 194 write(const bool &) 195 { 196 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 197 } 198 sc_signal<bool, WRITER_POLICY> & 199 operator = (const bool &) 200 { 201 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 202 return *this; 203 } 204 sc_signal<bool, WRITER_POLICY> & 205 operator = (const sc_signal<bool, WRITER_POLICY> &) 206 { 207 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 208 return *this; 209 } 210 211 virtual const sc_event & 212 default_event() const 213 { 214 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 215 return *(sc_event *)nullptr; 216 } 217 218 virtual const sc_event & 219 value_changed_event() const 220 { 221 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 222 return *(sc_event *)nullptr; 223 } 224 virtual const sc_event & 225 posedge_event() const 226 { 227 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 228 return *(sc_event *)nullptr; 229 } 230 virtual const sc_event & 231 negedge_event() const 232 { 233 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 234 return *(sc_event *)nullptr; 235 } 236 237 virtual bool 238 event() const 239 { 240 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 241 return false; 242 } 243 virtual bool 244 posedge() const 245 { 246 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 247 return false; 248 } 249 virtual bool 250 negedge() const 251 { 252 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 253 return false; 254 } 255 256 virtual void 257 print(std::ostream & =std::cout) const 258 { 259 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 260 } 261 virtual void 262 dump(std::ostream & =std::cout) const 263 { 264 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 265 } 266 virtual const char *kind() const { return "sc_signal"; } 267 268 protected: 269 virtual void 270 update() 271 { 272 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 273 } 274 275 private: 276 // Disabled 277 sc_signal(const sc_signal<bool, WRITER_POLICY> &) : 278 sc_signal_inout_if<bool>(), sc_prim_channel("") 279 {} 280}; 281 282template <sc_writer_policy WRITER_POLICY> 283class sc_signal<sc_dt::sc_logic, WRITER_POLICY> : 284 public sc_signal_inout_if<sc_dt::sc_logic>, public sc_prim_channel 285{ 286 public: 287 sc_signal() 288 { 289 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 290 } 291 explicit sc_signal(const char *) 292 { 293 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 294 } 295 virtual ~sc_signal() 296 { 297 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 298 } 299 300 virtual void 301 register_port(sc_port_base &, const char *) 302 { 303 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 304 } 305 306 virtual const sc_dt::sc_logic & 307 read() const 308 { 309 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 310 return *(const sc_dt::sc_logic *)nullptr; 311 } 312 operator const sc_dt::sc_logic &() const 313 { 314 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 315 return *(const sc_dt::sc_logic *)nullptr; 316 } 317 318 virtual sc_writer_policy 319 get_writer_policy() const 320 { 321 return WRITER_POLICY; 322 } 323 virtual void 324 write(const sc_dt::sc_logic &) 325 { 326 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 327 } 328 sc_signal<sc_dt::sc_logic, WRITER_POLICY> & 329 operator = (const sc_dt::sc_logic &) 330 { 331 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 332 return *this; 333 } 334 sc_signal<sc_dt::sc_logic, WRITER_POLICY> & 335 operator = (const sc_signal<sc_dt::sc_logic, WRITER_POLICY> &) 336 { 337 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 338 return *this; 339 } 340 341 virtual const sc_event & 342 default_event() const 343 { 344 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 345 return *(sc_event *)nullptr; 346 } 347 348 virtual const sc_event & 349 value_changed_event() const 350 { 351 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 352 return *(sc_event *)nullptr; 353 } 354 virtual const sc_event & 355 posedge_event() const 356 { 357 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 358 return *(sc_event *)nullptr; 359 } 360 virtual const sc_event & 361 negedge_event() const 362 { 363 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 364 return *(sc_event *)nullptr; 365 } 366 367 virtual bool 368 event() const 369 { 370 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 371 return false; 372 } 373 virtual bool 374 posedge() const 375 { 376 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 377 return false; 378 } 379 virtual bool 380 negedge() const 381 { 382 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 383 return false; 384 } 385 386 virtual void 387 print(std::ostream & =std::cout) const 388 { 389 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 390 } 391 virtual void 392 dump(std::ostream & =std::cout) const 393 { 394 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 395 } 396 virtual const char *kind() const { return "sc_signal"; } 397 398 protected: 399 virtual void 400 update() 401 { 402 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 403 } 404 405 private: 406 // Disabled 407 sc_signal(const sc_signal<sc_dt::sc_logic, WRITER_POLICY> &) : 408 sc_signal_inout_if<sc_dt::sc_logic>(), sc_prim_channel("") 409 {} 410}; 411 412} // namespace sc_core 413 414#endif //__SYSTEMC_EXT_CHANNEL_SC_SIGNAL_HH__ 415