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