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

--- 20 unchanged lines hidden (view full) ---

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>
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;

--- 14 unchanged lines hidden (view full) ---

61typedef std::vector<sc_trace_params *> sc_trace_params_vec;
62
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(), 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 &)
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 // These members which store the current and future value of the signal
162 // are not specified in the standard but are referred to directly by one
163 // of the tests.
164 T m_cur_val;
165 T m_new_val;
166
167 private:
168 // Disabled
169 sc_signal(const sc_signal<T, WRITER_POLICY> &) :
170 sc_signal_inout_if<T>(), sc_prim_channel("")
171 {}
172};
173
174template <class T, sc_writer_policy WRITER_POLICY>
175inline std::ostream &
176operator << (std::ostream &os, const sc_signal<T, WRITER_POLICY> &)
177{
178 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
179 return os;
180}
181
182template <sc_writer_policy WRITER_POLICY>
183class sc_signal<bool, WRITER_POLICY> :
184 public sc_signal_inout_if<bool>, public sc_prim_channel
185{
186 public:
187 sc_signal()
188 {
189 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
190 }
191 explicit sc_signal(const char *)
192 {
193 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
194 }
195 explicit sc_signal(const char *name, const bool &initial_value) :
196 sc_signal_inout_if(), sc_prim_channel(name)
197 {
198 // Need to consume initial_value.
199 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
200 }
201 virtual ~sc_signal()
202 {
203 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
204 }
205
206 virtual void
207 register_port(sc_port_base &, const char *)
208 {
209 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
210 }
211
212 virtual const bool &
213 read() const
214 {
215 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
216 return *(const bool *)nullptr;
217 }
218 operator const bool &() const
219 {
220 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
221 return *(const bool *)nullptr;
222 }
223
224 virtual sc_writer_policy
225 get_writer_policy() const
226 {
227 return WRITER_POLICY;
228 }
229 virtual void
230 write(const bool &)
231 {
232 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
233 }
234 sc_signal<bool, WRITER_POLICY> &
235 operator = (const bool &)
236 {
237 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
238 return *this;
239 }
240 sc_signal<bool, WRITER_POLICY> &
241 operator = (const sc_signal &)
242 {
243 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
244 return *this;
245 }
246
247 virtual const sc_event &
248 default_event() const
249 {
250 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
251 return *(sc_event *)nullptr;
252 }
253
254 virtual const sc_event &
255 value_changed_event() const
256 {
257 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
258 return *(sc_event *)nullptr;
259 }
260 virtual const sc_event &
261 posedge_event() const
262 {
263 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
264 return *(sc_event *)nullptr;
265 }
266 virtual const sc_event &
267 negedge_event() const
268 {
269 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
270 return *(sc_event *)nullptr;
271 }
272
273 virtual bool
274 event() const
275 {
276 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
277 return false;
278 }

--- 5 unchanged lines hidden (view full) ---

284 }
285 virtual bool
286 negedge() const
287 {
288 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
289 return false;
290 }
291
292 virtual void
293 print(std::ostream & =std::cout) const
294 {
295 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
296 }
297 virtual void
298 dump(std::ostream & =std::cout) const
299 {
300 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
301 }
302 virtual const char *kind() const { return "sc_signal"; }
303
304 protected:
305 virtual void
306 update()
307 {
308 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
309 }
310
311 private:
312 // Disabled
313 sc_signal(const sc_signal<bool, WRITER_POLICY> &) :
314 sc_signal_inout_if<bool>(), sc_prim_channel("")
315 {}
316};
317
318template <sc_writer_policy WRITER_POLICY>
319class sc_signal<sc_dt::sc_logic, WRITER_POLICY> :
320 public sc_signal_inout_if<sc_dt::sc_logic>, public sc_prim_channel
321{
322 public:
323 sc_signal()
324 {
325 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
326 }
327 explicit sc_signal(const char *)
328 {
329 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
330 }
331 explicit sc_signal(const char *name,
332 const sc_dt::sc_logic &initial_value) :
333 sc_signal_inout_if(), sc_prim_channel(name)
334 {
335 // Need to consume initial_value.
336 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
337 }
338 virtual ~sc_signal()
339 {
340 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
341 }
342
343 virtual void
344 register_port(sc_port_base &, const char *)
345 {
346 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
347 }
348
349 virtual const sc_dt::sc_logic &
350 read() const
351 {
352 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
353 return *(const sc_dt::sc_logic *)nullptr;
354 }
355 operator const sc_dt::sc_logic &() const
356 {
357 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
358 return *(const sc_dt::sc_logic *)nullptr;
359 }
360
361 virtual sc_writer_policy
362 get_writer_policy() const
363 {
364 return WRITER_POLICY;
365 }
366 virtual void
367 write(const sc_dt::sc_logic &)
368 {
369 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
370 }
371 sc_signal<sc_dt::sc_logic, WRITER_POLICY> &
372 operator = (const sc_dt::sc_logic &)
373 {
374 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
375 return *this;
376 }
377 sc_signal<sc_dt::sc_logic, WRITER_POLICY> &
378 operator = (const sc_signal &)
379 {
380 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
381 return *this;
382 }
383
384 virtual const sc_event &
385 default_event() const
386 {
387 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
388 return *(sc_event *)nullptr;
389 }
390
391 virtual const sc_event &
392 value_changed_event() const
393 {
394 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
395 return *(sc_event *)nullptr;
396 }
397 virtual const sc_event &
398 posedge_event() const
399 {
400 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
401 return *(sc_event *)nullptr;
402 }
403 virtual const sc_event &
404 negedge_event() const
405 {
406 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
407 return *(sc_event *)nullptr;
408 }
409
410 virtual bool
411 event() const
412 {
413 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
414 return false;
415 }

--- 5 unchanged lines hidden (view full) ---

421 }
422 virtual bool
423 negedge() const
424 {
425 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
426 return false;
427 }
428
429 virtual void
430 print(std::ostream & =std::cout) const
431 {
432 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
433 }
434 virtual void
435 dump(std::ostream & =std::cout) const
436 {
437 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
438 }
439 virtual const char *kind() const { return "sc_signal"; }
440
441 protected:
442 virtual void
443 update()
444 {
445 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
446 }
447
448 private:
449 // Disabled
450 sc_signal(const sc_signal<sc_dt::sc_logic, WRITER_POLICY> &) :
451 sc_signal_inout_if<sc_dt::sc_logic>(), sc_prim_channel("")
452 {}
453};
454
455} // namespace sc_core
456
457#endif //__SYSTEMC_EXT_CHANNEL_SC_SIGNAL_HH__