sc_signal.hh revision 12912:8a06e701c31a 
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    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__
434