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