sc_inout.hh revision 12841:22aa7ba47bf9 
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