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