sc_signal.hh (12912:8a06e701c31a) sc_signal.hh (12933:9fb537a605f6)
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>
34#include <string>
35#include <vector>
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;
36
37#include "../core/sc_module.hh" // for sc_gen_unique_name
38#include "../core/sc_prim.hh"
39#include "sc_signal_inout_if.hh"
40#include "warn_unimpl.hh" // for warn_unimpl
41
42namespace sc_core
43{
44
45class sc_port_base;
46class sc_trace_file;
44
47
48// Nonstandard
49// Despite having a warning "FOR INTERNAL USE ONLY!" in all caps above this
50// class definition in the Accellera implementation, it appears in their
51// examples and test programs, and so we need to have it here as well.
52struct sc_trace_params
53{
54 sc_trace_file *tf;
55 std::string name;
56
57 sc_trace_params(sc_trace_file *tf, const std::string &name) :
58 tf(tf), name(name)
59 {}
60};
61typedef std::vector<sc_trace_params *> sc_trace_params_vec;
62
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__