sc_inout.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_INOUT_HH__ 31#define __SYSTEMC_EXT_CHANNEL_SC_INOUT_HH__ 32 33#include <string> 34 35#include "../core/sc_port.hh" 36#include "sc_signal_inout_if.hh" 37#include "warn_unimpl.hh" 38 39namespace sc_dt 40{ 41 42class sc_logic; 43 44} // namespace sc_dt 45 46namespace sc_core 47{ 48 49class sc_event; 50class sc_event_finder; 51class sc_trace_file; 52 53template <class T> 54class sc_inout : public sc_port<sc_signal_inout_if<T>, 1> 55{ 56 public: 57 sc_inout() : sc_port<sc_signal_inout_if<T>, 1>() {} 58 explicit sc_inout(const char *name) : 59 sc_port<sc_signal_inout_if<T>, 1>(name) 60 {} 61 virtual ~sc_inout() {} 62 63 void 64 initialize(const T &) 65 { 66 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 67 } 68 void 69 initialize(const sc_signal_in_if<T> &) 70 { 71 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 72 } 73 74 virtual void end_of_elaboration() {} 75 76 const T & 77 read() const 78 { 79 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 80 return *(const T *)nullptr; 81 } 82 operator const T& () const 83 { 84 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 85 return *(const T *)nullptr; 86 } 87 88 void 89 write(const T &) 90 { 91 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 92 } 93 sc_inout<T> & 94 operator = (const T &) 95 { 96 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 97 return *(sc_inout<T> *)nullptr; 98 } 99 sc_inout<T> & 100 operator = (const sc_signal_in_if<T> &) 101 { 102 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 103 return *(sc_inout<T> *)nullptr; 104 } 105 sc_inout<T> & 106 operator = (const sc_port<sc_signal_in_if<T>, 1> &) 107 { 108 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 109 return *(sc_inout<T> *)nullptr; 110 } 111 sc_inout<T> & 112 operator = (const sc_port<sc_signal_inout_if<T>, 1> &) 113 { 114 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 115 return *(sc_inout<T> *)nullptr; 116 } 117 sc_inout<T> & 118 operator = (const sc_inout<T> &) 119 { 120 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 121 return *(sc_inout<T> *)nullptr; 122 } 123 124 const sc_event & 125 default_event() const 126 { 127 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 128 return *(sc_event *)nullptr; 129 } 130 const sc_event & 131 value_changed_event() const 132 { 133 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 134 return *(sc_event *)nullptr; 135 } 136 bool 137 event() const 138 { 139 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 140 return false; 141 } 142 sc_event_finder & 143 value_changed() const 144 { 145 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 146 return *(sc_event_finder *)nullptr; 147 } 148 149 virtual const char *kind() const { return "sc_inout"; } 150 151 private: 152 // Disabled 153 sc_inout(const sc_inout<T> &) : sc_port<sc_signal_inout_if<T>, 1>() {} 154}; 155 156template <class T> 157inline void 158sc_trace(sc_trace_file *, const sc_inout<T> &, const std::string &) 159{ 160 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 161} 162 163template <> 164class sc_inout<bool> : public sc_port<sc_signal_inout_if<bool>, 1> 165{ 166 public: 167 sc_inout() : sc_port<sc_signal_inout_if<bool>, 1>() {} 168 explicit sc_inout(const char *name) : 169 sc_port<sc_signal_inout_if<bool>, 1>(name) 170 {} 171 virtual ~sc_inout() {} 172 173 void 174 initialize(const bool &) 175 { 176 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 177 } 178 void 179 initialize(const sc_signal_in_if<bool> &) 180 { 181 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 182 } 183 184 virtual void end_of_elaboration() {} 185 186 const bool & 187 read() const 188 { 189 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 190 return *(bool *)nullptr; 191 } 192 operator const bool& () const 193 { 194 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 195 return *(bool *)nullptr; 196 } 197 198 void 199 write(const bool &) 200 { 201 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 202 } 203 sc_inout<bool> & 204 operator = (const bool &) 205 { 206 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 207 return *(sc_inout<bool> *)nullptr; 208 } 209 sc_inout<bool> & 210 operator = (const sc_signal_in_if<bool> &) 211 { 212 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 213 return *(sc_inout<bool> *)nullptr; 214 } 215 sc_inout<bool> & 216 operator = (const sc_port<sc_signal_in_if<bool>, 1> &) 217 { 218 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 219 return *(sc_inout<bool> *)nullptr; 220 } 221 sc_inout<bool> & 222 operator = (const sc_port<sc_signal_inout_if<bool>, 1> &) 223 { 224 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 225 return *(sc_inout<bool> *)nullptr; 226 } 227 sc_inout<bool> & 228 operator = (const sc_inout<bool> &) 229 { 230 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 231 return *(sc_inout<bool> *)nullptr; 232 } 233 234 const sc_event & 235 default_event() const 236 { 237 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 238 return *(sc_event *)nullptr; 239 } 240 const sc_event & 241 value_changed_event() const 242 { 243 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 244 return *(sc_event *)nullptr; 245 } 246 const sc_event & 247 posedge_event() const 248 { 249 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 250 return *(sc_event *)nullptr; 251 } 252 const sc_event & 253 negedge_event() const 254 { 255 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 256 return *(sc_event *)nullptr; 257 } 258 259 bool 260 event() const 261 { 262 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 263 return false; 264 } 265 bool 266 posedge() const 267 { 268 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 269 return false; 270 } 271 bool 272 negedge() const 273 { 274 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 275 return false; 276 } 277 278 sc_event_finder & 279 value_changed() const 280 { 281 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 282 return *(sc_event_finder *)nullptr; 283 } 284 sc_event_finder & 285 pos() const 286 { 287 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 288 return *(sc_event_finder *)nullptr; 289 } 290 sc_event_finder & 291 neg() const 292 { 293 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 294 return *(sc_event_finder *)nullptr; 295 } 296 297 virtual const char *kind() const { return "sc_inout"; } 298 299 private: 300 // Disabled 301 sc_inout(const sc_inout<bool> &) : 302 sc_port<sc_signal_inout_if<bool>, 1>() {} 303}; 304 305template <> 306inline void sc_trace<bool>( 307 sc_trace_file *, const sc_inout<bool> &, const std::string &) 308{ 309 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 310} 311 312template <> 313class sc_inout<sc_dt::sc_logic> : 314 public sc_port<sc_signal_inout_if<sc_dt::sc_logic>, 1> 315{ 316 public: 317 sc_inout() : sc_port<sc_signal_inout_if<sc_dt::sc_logic>, 1>() {} 318 explicit sc_inout(const char *name) : 319 sc_port<sc_signal_inout_if<sc_dt::sc_logic>, 1>(name) 320 {} 321 virtual ~sc_inout() {} 322 323 void 324 initialize(const sc_dt::sc_logic &) 325 { 326 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 327 } 328 void 329 initialize(const sc_signal_in_if<sc_dt::sc_logic> &) 330 { 331 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 332 } 333 334 virtual void end_of_elaboration() {} 335 336 const sc_dt::sc_logic & 337 read() const 338 { 339 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 340 return *(const sc_dt::sc_logic *)nullptr; 341 } 342 operator const sc_dt::sc_logic& () const 343 { 344 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 345 return *(const sc_dt::sc_logic *)nullptr; 346 } 347 348 void 349 write(const sc_dt::sc_logic &) 350 { 351 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 352 } 353 sc_inout<sc_dt::sc_logic> & 354 operator = (const sc_dt::sc_logic &) 355 { 356 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 357 return *(sc_inout<sc_dt::sc_logic> *)nullptr; 358 } 359 sc_inout<sc_dt::sc_logic> & 360 operator = (const sc_signal_in_if<sc_dt::sc_logic> &) 361 { 362 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 363 return *(sc_inout<sc_dt::sc_logic> *)nullptr; 364 } 365 sc_inout<sc_dt::sc_logic> & 366 operator = (const sc_port<sc_signal_in_if<sc_dt::sc_logic>, 1> &) 367 { 368 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 369 return *(sc_inout<sc_dt::sc_logic> *)nullptr; 370 } 371 sc_inout<sc_dt::sc_logic> & 372 operator = (const sc_port<sc_signal_inout_if<sc_dt::sc_logic>, 1> &) 373 { 374 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 375 return *(sc_inout<sc_dt::sc_logic> *)nullptr; 376 } 377 sc_inout<sc_dt::sc_logic> & 378 operator = (const sc_inout<sc_dt::sc_logic> &) 379 { 380 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 381 return *(sc_inout<sc_dt::sc_logic> *)nullptr; 382 } 383 384 const sc_event & 385 default_event() const 386 { 387 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 388 return *(sc_event *)nullptr; 389 } 390 const sc_event & 391 value_changed_event() const 392 { 393 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 394 return *(sc_event *)nullptr; 395 } 396 const sc_event & 397 posedge_event() const 398 { 399 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 400 return *(sc_event *)nullptr; 401 } 402 const sc_event & 403 negedge_event() const 404 { 405 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 406 return *(sc_event *)nullptr; 407 } 408 409 bool 410 event() const 411 { 412 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 413 return false; 414 } 415 bool 416 posedge() const 417 { 418 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 419 return false; 420 } 421 bool 422 negedge() const 423 { 424 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 425 return false; 426 } 427 428 sc_event_finder & 429 value_changed() const 430 { 431 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 432 return *(sc_event_finder *)nullptr; 433 } 434 sc_event_finder & 435 pos() const 436 { 437 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 438 return *(sc_event_finder *)nullptr; 439 } 440 sc_event_finder & 441 neg() const 442 { 443 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 444 return *(sc_event_finder *)nullptr; 445 } 446 447 virtual const char *kind() const { return "sc_inout"; } 448 449 private: 450 // Disabled 451 sc_inout(const sc_inout<sc_dt::sc_logic> &) : 452 sc_port<sc_signal_inout_if<sc_dt::sc_logic>, 1>() 453 {} 454}; 455 456template <> 457inline void 458sc_trace<sc_dt::sc_logic>(sc_trace_file *, const sc_inout<sc_dt::sc_logic> &, 459 const std::string &) 460{ 461 sc_channel_warn_unimpl(__PRETTY_FUNCTION__); 462} 463 464} // namespace sc_core 465 466#endif //__SYSTEMC_EXT_CHANNEL_SC_INOUT_HH__ 467