gem5  v20.1.0.0
sc_bit_proxies.hh
Go to the documentation of this file.
1 /*****************************************************************************
2 
3  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
4  more contributor license agreements. See the NOTICE file distributed
5  with this work for additional information regarding copyright ownership.
6  Accellera licenses this file to you under the Apache License, Version 2.0
7  (the "License"); you may not use this file except in compliance with the
8  License. You may obtain a copy of the License at
9 
10  http://www.apache.org/licenses/LICENSE-2.0
11 
12  Unless required by applicable law or agreed to in writing, software
13  distributed under the License is distributed on an "AS IS" BASIS,
14  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
15  implied. See the License for the specific language governing
16  permissions and limitations under the License.
17 
18  *****************************************************************************/
19 
20 /*****************************************************************************
21 
22  sc_bit_proxies.h -- Proxy classes for vector data types.
23 
24  Original Author: Gene Bushuyev, Synopsys, Inc.
25 
26  CHANGE LOG AT THE END OF THE FILE
27  *****************************************************************************/
28 
29 #ifndef __SYSTEMC_EXT_DT_BIT_SC_BIT_PROXIES_HH__
30 #define __SYSTEMC_EXT_DT_BIT_SC_BIT_PROXIES_HH__
31 
32 #include <iostream>
33 
34 #include "../../utils/messages.hh"
35 #include "sc_proxy.hh"
36 
37 namespace sc_dt
38 {
39 
40 // classes defined in this module
41 template <class X, class Traits>
42 class sc_bitref_conv_r;
43 template <class X>
44 class sc_bitref_r;
45 template <class X>
46 class sc_bitref;
47 template <class X>
48 class sc_subref_r;
49 template <class X>
50 class sc_subref;
51 template <class X, class Y>
52 class sc_concref_r;
53 template <class X, class Y>
54 class sc_concref;
55 
56 // ----------------------------------------------------------------------------
57 // CLASS TEMPLATE : sc_bitref_conv_r<T>
58 //
59 // Proxy class for sc_proxy bit selection (r-value only, boolean conversion).
60 // ----------------------------------------------------------------------------
61 template <class T, class Traits=typename T::traits_type>
62 class sc_bitref_conv_r { /* empty by default */ };
63 
64 // specialization for bit-vector based sc_proxy classes
65 template<typename T>
66 class sc_bitref_conv_r<T, sc_proxy_traits<sc_bv_base> >
67 {
68  public:
69 #if __cplusplus >= 201103L // explicit operator needs C++11
70  // explicit conversion to bool
71  explicit operator bool() const
72  {
73  return static_cast<const sc_bitref_r<T> &>(*this).to_bool();
74  }
75 #endif
76 
77  // explicit (negating) conversion to bool
78  bool
79  operator ! () const
80  {
81  return !static_cast<const sc_bitref_r<T> &>(*this).to_bool();
82  }
83 };
84 
85 // ----------------------------------------------------------------------------
86 // CLASS TEMPLATE : sc_bitref_r<T>
87 //
88 // Proxy class for sc_proxy bit selection (r-value only).
89 // ----------------------------------------------------------------------------
90 
91 template <class T>
92 class sc_bitref_r : public sc_bitref_conv_r<T>
93 {
94  friend class sc_bv_base;
95  friend class sc_lv_base;
96 
97  public:
98  // typedefs
99  typedef typename T::traits_type traits_type;
100  typedef typename traits_type::bit_type bit_type;
101  typedef typename traits_type::value_type value_type;
102 
103  // constructor
104  sc_bitref_r(const T &obj_, int index_) :
105  m_obj(const_cast<T &>(obj_)), m_index(index_)
106  {}
107 
108  // copy constructor
109  sc_bitref_r(const sc_bitref_r<T> &a) : m_obj(a.m_obj), m_index(a.m_index)
110  {}
111 
112  // cloning
113  sc_bitref_r<T> *clone() const { return new sc_bitref_r<T>(*this); }
114 
115  // bitwise operators and functions
116 
117  // bitwise complement
118  bit_type
119  operator ~ () const
120  {
121  return bit_type(sc_logic::not_table[value()]);
122  }
123 
124  // implicit conversion to bit_type
125  operator bit_type() const { return bit_type(m_obj.get_bit(m_index)); }
126 
127  // explicit conversions
128  value_type value() const { return m_obj.get_bit(m_index); }
129  bool is_01() const { return sc_logic(value()).is_01(); }
130  bool to_bool() const { return sc_logic(value()).to_bool(); }
131  char to_char() const { return sc_logic(value()).to_char(); }
132 
133  // common methods
134  int length() const { return 1; }
135  int size() const { return ((length() - 1) / SC_DIGIT_SIZE + 1); }
136 
137  value_type get_bit(int n) const;
138 
139  sc_digit get_word(int i) const;
140  sc_digit get_cword(int i) const;
141 
142  // other methods
143  void print(::std::ostream &os=::std::cout) const { os << to_char(); }
144 
145  protected:
146  T &m_obj;
147  int m_index;
148 
149  private:
150  // Disabled
151  sc_bitref_r();
152  sc_bitref_r<T> &operator = (const sc_bitref_r<T> &);
153 };
154 
155 // bitwise operators and functions
156 
157 // bitwise and
158 template <class T1, class T2>
159 inline sc_logic operator & (
160  const sc_bitref_r<T1> &a, const sc_bitref_r<T2> &b);
161 
162 
163 // bitwise or
164 template <class T1, class T2>
165 inline sc_logic operator | (
166  const sc_bitref_r<T1> &a, const sc_bitref_r<T2> &b);
167 
168 // bitwise xor
169 template <class T1, class T2>
170 inline sc_logic operator ^ (
171  const sc_bitref_r<T1> &a, const sc_bitref_r<T2> &b);
172 
173 // relational operators and functions
174 template <class T1, class T2>
175 inline bool operator == (const sc_bitref_r<T1> &a, const sc_bitref_r<T2> &b);
176 
177 template <class T1, class T2>
178 inline bool operator != (const sc_bitref_r<T1> &a, const sc_bitref_r<T2> &b);
179 
180 // r-value concatenation operators and functions
181 template <class T1, class T2>
182 inline sc_concref_r<sc_bitref_r<T1>, sc_bitref_r<T2> > operator , (
183  sc_bitref_r<T1>, sc_bitref_r<T2>);
184 
185 template <class T1, class T2>
186 inline sc_concref_r<sc_bitref_r<T1>, sc_subref_r<T2> > operator , (
187  sc_bitref_r<T1>, sc_subref_r<T2>);
188 
189 template <class T1, class T2, class T3>
190 inline sc_concref_r<sc_bitref_r<T1>, sc_concref_r<T2,T3> > operator , (
191  sc_bitref_r<T1>, sc_concref_r<T2,T3>);
192 
193 template <class T1, class T2>
194 inline sc_concref_r<sc_bitref_r<T1>, T2> operator , (
195  sc_bitref_r<T1>, const sc_proxy<T2> &);
196 
197 template <class T>
198 inline sc_concref_r<sc_bitref_r<T>, sc_lv_base> operator , (
199  sc_bitref_r<T>, const char *);
200 
201 template <class T>
202 inline sc_concref_r<sc_lv_base, sc_bitref_r<T> > operator , (
203  const char *, sc_bitref_r<T>);
204 
205 template <class T>
206 inline sc_concref_r<sc_bitref_r<T>, sc_lv_base> operator , (
207  sc_bitref_r<T>, const sc_logic &);
208 
209 template <class T>
210 inline sc_concref_r<sc_lv_base, sc_bitref_r<T> > operator , (
211  const sc_logic &, sc_bitref_r<T>);
212 
213 template <class T>
214 inline sc_concref_r<sc_bitref_r<T>, sc_lv_base> operator , (
215  sc_bitref_r<T>, bool);
216 
217 template <class T>
218 inline sc_concref_r<sc_lv_base, sc_bitref_r<T> > operator , (
219  bool, sc_bitref_r<T>);
220 
221 
222 template <class T1, class T2>
223 inline sc_concref_r<sc_bitref_r<T1>, sc_bitref_r<T2> > concat(
224  sc_bitref_r<T1>, sc_bitref_r<T2>);
225 
226 template <class T1, class T2>
227 inline sc_concref_r<sc_bitref_r<T1>, sc_subref_r<T2> > concat(
228  sc_bitref_r<T1>, sc_subref_r<T2>);
229 
230 template <class T1, class T2, class T3>
231 inline sc_concref_r<sc_bitref_r<T1>, sc_concref_r<T2,T3> > concat(
232  sc_bitref_r<T1>, sc_concref_r<T2, T3>);
233 
234 template <class T1, class T2>
235 inline sc_concref_r<sc_bitref_r<T1>, T2> concat(
236  sc_bitref_r<T1>, const sc_proxy<T2> &);
237 
238 template <class T>
239 inline sc_concref_r<sc_bitref_r<T>, sc_lv_base> concat(
240  sc_bitref_r<T>, const char *);
241 
242 template <class T>
243 inline sc_concref_r<sc_lv_base, sc_bitref_r<T> > concat(
244  const char *, sc_bitref_r<T>);
245 
246 template <class T>
247 inline sc_concref_r<sc_bitref_r<T>, sc_lv_base> concat(
248  sc_bitref_r<T>, const sc_logic &);
249 
250 template <class T>
251 inline sc_concref_r<sc_lv_base, sc_bitref_r<T> > concat(
252  const sc_logic &, sc_bitref_r<T>);
253 
254 template <class T>
255 inline sc_concref_r<sc_bitref_r<T>, sc_lv_base> concat(
256  sc_bitref_r<T>, bool);
257 
258 template <class T>
259 inline sc_concref_r<sc_lv_base, sc_bitref_r<T> > concat(
260  bool, sc_bitref_r<T>);
261 
262 
263 template <class T1, class T2>
264 inline sc_concref_r<sc_bitref_r<T1>, sc_bitref_r<T2> > operator , (
265  sc_bitref_r<T1>, sc_bitref<T2>);
266 
267 template <class T1, class T2>
268 inline sc_concref_r<sc_bitref_r<T1>, sc_bitref_r<T2> > operator , (
269  sc_bitref<T1>, sc_bitref_r<T2>);
270 
271 template <class T1, class T2>
272 inline sc_concref_r<sc_bitref_r<T1>, sc_subref_r<T2> > operator , (
273  sc_bitref_r<T1>, sc_subref<T2>);
274 
275 template <class T1, class T2>
276 inline sc_concref_r<sc_bitref_r<T1>, sc_subref_r<T2> > operator , (
277  sc_bitref<T1>, sc_subref_r<T2>);
278 
279 template <class T1, class T2, class T3>
280 inline sc_concref_r<sc_bitref_r<T1>, sc_concref_r<T2, T3> > operator , (
281  sc_bitref_r<T1>, sc_concref<T2, T3>);
282 
283 template <class T1, class T2, class T3>
284 inline sc_concref_r<sc_bitref_r<T1>, sc_concref_r<T2,T3> > operator , (
285  sc_bitref<T1>, sc_concref_r<T2, T3>);
286 
287 template <class T1, class T2>
288 inline sc_concref_r<sc_bitref_r<T1>, T2> operator , (
289  sc_bitref<T1>, const sc_proxy<T2> &);
290 
291 template <class T1, class T2>
292 inline sc_concref_r<sc_bitref_r<T1>, T2> operator , (
293  sc_bitref_r<T1>, sc_proxy<T2> &);
294 
295 template <class T>
296 inline sc_concref_r<sc_bitref_r<T>, sc_lv_base> operator , (
297  sc_bitref<T>, const char *);
298 
299 template <class T>
300 inline sc_concref_r<sc_lv_base, sc_bitref_r<T> > operator , (
301  const char *, sc_bitref<T>);
302 
303 template <class T>
304 inline sc_concref_r<sc_bitref_r<T>, sc_lv_base> operator , (
305  sc_bitref<T>, const sc_logic &);
306 
307 template <class T>
308 inline sc_concref_r<sc_lv_base, sc_bitref_r<T> > operator , (
309  const sc_logic &, sc_bitref<T>);
310 
311 template <class T>
312 inline sc_concref_r<sc_bitref_r<T>, sc_lv_base> operator , (
313  sc_bitref<T>, bool);
314 
315 template <class T>
316 inline sc_concref_r<sc_lv_base, sc_bitref_r<T> > operator , (
317  bool, sc_bitref<T>);
318 
319 
320 template <class T1, class T2>
321 inline sc_concref_r<sc_bitref_r<T1>, sc_bitref_r<T2> > concat(
322  sc_bitref_r<T1>, sc_bitref<T2>);
323 
324 template <class T1, class T2>
325 inline sc_concref_r<sc_bitref_r<T1>, sc_bitref_r<T2> > concat(
326  sc_bitref<T1>, sc_bitref_r<T2>);
327 
328 template <class T1, class T2>
329 inline sc_concref_r<sc_bitref_r<T1>, sc_subref_r<T2> > concat(
330  sc_bitref_r<T1>, sc_subref<T2>);
331 
332 template <class T1, class T2>
333 inline sc_concref_r<sc_bitref_r<T1>, sc_subref_r<T2> > concat(
334  sc_bitref<T1>, sc_subref_r<T2>);
335 
336 template <class T1, class T2, class T3>
337 inline sc_concref_r<sc_bitref_r<T1>, sc_concref_r<T2, T3> > concat(
338  sc_bitref_r<T1>, sc_concref<T2, T3>);
339 
340 template <class T1, class T2, class T3>
341 inline sc_concref_r<sc_bitref_r<T1>, sc_concref_r<T2, T3> > concat(
342  sc_bitref<T1>, sc_concref_r<T2, T3>);
343 
344 template <class T1, class T2>
345 inline sc_concref_r<sc_bitref_r<T1>, T2> concat(
346  sc_bitref<T1>, const sc_proxy<T2> &);
347 
348 template <class T1, class T2>
349 inline sc_concref_r<sc_bitref_r<T1>, T2> concat(
350  sc_bitref_r<T1>, sc_proxy<T2> &);
351 
352 template <class T>
353 inline sc_concref_r<sc_bitref_r<T>, sc_lv_base> concat(
354  sc_bitref<T>, const char *);
355 
356 template <class T>
357 inline sc_concref_r<sc_lv_base, sc_bitref_r<T> > concat(
358  const char *, sc_bitref<T>);
359 
360 template <class T>
361 inline sc_concref_r<sc_bitref_r<T>, sc_lv_base> concat(
362  sc_bitref<T>, const sc_logic &);
363 
364 template <class T>
365 inline sc_concref_r<sc_lv_base, sc_bitref_r<T> > concat(
366  const sc_logic &, sc_bitref<T>);
367 
368 template <class T>
369 inline sc_concref_r<sc_bitref_r<T>, sc_lv_base> concat(sc_bitref<T>, bool);
370 
371 template <class T>
372 inline sc_concref_r<sc_lv_base, sc_bitref_r<T> > concat(bool, sc_bitref<T>);
373 
374 
375 // ----------------------------------------------------------------------------
376 // CLASS TEMPLATE : sc_bitref<X>
377 //
378 // Proxy class for sc_proxy bit selection (r-value and l-value).
379 // ----------------------------------------------------------------------------
380 
381 template <class X>
382 class sc_bitref : public sc_bitref_r<X>
383 {
384  friend class sc_bv_base;
385  friend class sc_lv_base;
386 
387  public:
388  typedef typename sc_bitref_r<X>::value_type value_type;
389 
390  // constructor
391  sc_bitref(X &obj_, int index_) : sc_bitref_r<X>(obj_, index_) {}
392 
393  // copy constructor
394  sc_bitref(const sc_bitref<X> &a) : sc_bitref_r<X>(a) {}
395 
396  // cloning
397  sc_bitref<X> *clone() const { return new sc_bitref<X>(*this); }
398 
399  // assignment operators
400  sc_bitref<X> &operator = (const sc_bitref_r<X> &a);
401  sc_bitref<X> &operator = (const sc_bitref<X> &a);
402 
403  sc_bitref<X> &
404  operator = (const sc_logic &a)
405  {
406  this->m_obj.set_bit(this->m_index, a.value());
407  return *this;
408  }
409 
410  sc_bitref<X> &
411  operator = (sc_logic_value_t v)
412  {
413  *this = sc_logic(v);
414  return *this;
415  }
416 
417  sc_bitref<X> &
418  operator = (bool a)
419  {
420  *this = sc_logic(a);
421  return *this;
422  }
423 
424  sc_bitref<X> &
425  operator = (char a)
426  {
427  *this = sc_logic(a);
428  return *this;
429  }
430 
431  sc_bitref<X> &
432  operator = (int a)
433  {
434  *this = sc_logic(a);
435  return *this;
436  }
437 
438  sc_bitref<X> &
439  operator = (const sc_bit &a)
440  {
441  *this = sc_logic(a);
442  return *this;
443  }
444 
445  // bitwise assignment operators
446  sc_bitref<X> &operator &= (const sc_bitref_r<X> &a);
447  sc_bitref<X> &operator &= (const sc_logic &a);
448 
449  sc_bitref<X> &
450  operator &= (sc_logic_value_t v)
451  {
452  *this &= sc_logic(v);
453  return *this;
454  }
455 
456  sc_bitref<X> &
457  operator &= (bool a)
458  {
459  *this &= sc_logic(a);
460  return *this;
461  }
462 
463  sc_bitref<X> &
464  operator &= (char a)
465  {
466  *this &= sc_logic(a);
467  return *this;
468  }
469 
470  sc_bitref<X> &
471  operator &= (int a)
472  {
473  *this &= sc_logic(a);
474  return *this;
475  }
476 
477  sc_bitref<X> &operator |= (const sc_bitref_r<X> &a);
478  sc_bitref<X> &operator |= (const sc_logic &a);
479 
480  sc_bitref<X> &
481  operator |= (sc_logic_value_t v)
482  {
483  *this |= sc_logic(v);
484  return *this;
485  }
486 
487  sc_bitref<X> &
488  operator |= (bool a)
489  {
490  *this |= sc_logic(a);
491  return *this;
492  }
493 
494  sc_bitref<X> &
495  operator |= (char a)
496  {
497  *this |= sc_logic(a);
498  return *this;
499  }
500 
501  sc_bitref<X> &
502  operator |= (int a)
503  {
504  *this |= sc_logic(a);
505  return *this;
506  }
507 
508  sc_bitref<X> &operator ^= (const sc_bitref_r<X> &a);
509  sc_bitref<X> &operator ^= (const sc_logic &a);
510 
511  sc_bitref<X> &
512  operator ^= (sc_logic_value_t v)
513  {
514  *this ^= sc_logic(v);
515  return *this;
516  }
517 
518  sc_bitref<X> &
519  operator ^= (bool a)
520  {
521  *this ^= sc_logic(a);
522  return *this;
523  }
524 
525  sc_bitref<X> &
526  operator ^= (char a)
527  {
528  *this ^= sc_logic(a);
529  return *this;
530  }
531 
532  sc_bitref<X> &
533  operator ^= (int a)
534  {
535  *this ^= sc_logic(a);
536  return *this;
537  }
538 
539  // bitwise operators and functions
540 
541  // bitwise complement
542  sc_bitref<X> &b_not();
543 
544  // common methods
545  void set_bit(int n, value_type value);
546 
547  void set_word(int i, sc_digit w);
548  void set_cword(int i, sc_digit w);
549 
550  void clean_tail() { this->m_obj.clean_tail(); }
551 
552  // other methods
553  void scan(::std::istream &is=::std::cin);
554 
555  private:
556  // Disabled
557  sc_bitref();
558 };
559 
560 
561 // l-value concatenation operators and functions
562 
563 template <class T1, class T2>
564 inline sc_concref<sc_bitref<T1>, sc_bitref<T2> > operator , (
565  sc_bitref<T1>, sc_bitref<T2>);
566 
567 template <class T1, class T2>
568 inline sc_concref<sc_bitref<T1>, sc_subref<T2> > operator , (
569  sc_bitref<T1>, sc_subref<T2>);
570 
571 template <class T1, class T2, class T3>
572 inline sc_concref<sc_bitref<T1>, sc_concref<T2, T3> > operator , (
573  sc_bitref<T1>, sc_concref<T2, T3>);
574 
575 template <class T1, class T2>
576 inline sc_concref<sc_bitref<T1>, T2> operator , (
577  sc_bitref<T1>, sc_proxy<T2> &);
578 
579 
580 template <class T1, class T2>
581 inline sc_concref<sc_bitref<T1>, sc_bitref<T2> > concat(
582  sc_bitref<T1>, sc_bitref<T2>);
583 
584 template <class T1, class T2>
585 inline sc_concref<sc_bitref<T1>, sc_subref<T2> > concat(
586  sc_bitref<T1>, sc_subref<T2>);
587 
588 template <class T1, class T2, class T3>
589 inline sc_concref<sc_bitref<T1>, sc_concref<T2,T3> > concat(
590  sc_bitref<T1>, sc_concref<T2, T3>);
591 
592 template <class T1, class T2>
593 inline sc_concref<sc_bitref<T1>, T2> concat(sc_bitref<T1>, sc_proxy<T2> &);
594 
595 
596 template <class T>
597 ::std::istream &operator >> (::std::istream &, sc_bitref<T>);
598 
599 
600 // ----------------------------------------------------------------------------
601 // CLASS TEMPLATE : sc_subref_r<X>
602 //
603 // Proxy class for sc_proxy part selection (r-value only).
604 // ----------------------------------------------------------------------------
605 
606 template <class X>
607 class sc_subref_r : public sc_proxy<sc_subref_r<X> >
608 {
609  void check_bounds();
610 
611  public:
612  typedef typename sc_proxy<sc_subref_r<X> >::value_type value_type;
613 
614  // constructor
615  sc_subref_r(const X &obj_, int hi_, int lo_) :
616  m_obj(const_cast<X &>(obj_)), m_hi(hi_), m_lo(lo_), m_len(0)
617  { check_bounds(); }
618 
619  // copy constructor
620  sc_subref_r(const sc_subref_r<X> &a) :
621  m_obj(a.m_obj), m_hi(a.m_hi), m_lo(a.m_lo), m_len(a.m_len)
622  {}
623 
624  // cloning
625  sc_subref_r<X> *clone() const { return new sc_subref_r<X>(*this); }
626 
627  // common methods
628  int length() const { return m_len; }
629 
630  int size() const { return ((length() - 1) / SC_DIGIT_SIZE + 1); }
631 
632  value_type get_bit(int n) const;
633  void set_bit(int n, value_type value);
634 
635  sc_digit get_word(int i) const;
636  void set_word(int i, sc_digit w);
637 
638  sc_digit get_cword(int i) const;
639  void set_cword(int i, sc_digit w);
640 
641  void clean_tail() { m_obj.clean_tail(); }
642 
643  // other methods
644  bool is_01() const;
645  bool reversed() const { return m_lo > m_hi; }
646 
647  protected:
648  X &m_obj;
649  int m_hi;
650  int m_lo;
651  int m_len;
652 
653  private:
654  // Disabled
655  sc_subref_r();
656  sc_subref_r<X> &operator = (const sc_subref_r<X> &);
657 };
658 
659 
660 // r-value concatenation operators and functions
661 
662 template <class T1, class T2>
663 inline sc_concref_r<sc_subref_r<T1>, sc_bitref_r<T2> > operator , (
664  sc_subref_r<T1>, sc_bitref_r<T2>);
665 
666 template <class T1, class T2>
667 inline sc_concref_r<sc_subref_r<T1>, sc_subref_r<T2> > operator , (
668  sc_subref_r<T1>, sc_subref_r<T2>);
669 
670 template <class T1, class T2, class T3>
671 inline sc_concref_r<sc_subref_r<T1>, sc_concref_r<T2,T3> > operator , (
672  sc_subref_r<T1>, sc_concref_r<T2, T3>);
673 
674 template <class T1, class T2>
675 inline sc_concref_r<sc_subref_r<T1>, T2> operator , (
676  sc_subref_r<T1>, const sc_proxy<T2> &);
677 
678 template <class T>
679 inline sc_concref_r<sc_subref_r<T>,sc_lv_base> operator , (
680  sc_subref_r<T>, const char *);
681 
682 template <class T>
683 inline sc_concref_r<sc_lv_base, sc_subref_r<T> > operator , (
684  const char *, sc_subref_r<T>);
685 
686 template <class T>
687 inline sc_concref_r<sc_subref_r<T>, sc_lv_base> operator , (
688  sc_subref_r<T>, const sc_logic &);
689 
690 template <class T>
691 inline sc_concref_r<sc_lv_base, sc_subref_r<T> > operator , (
692  const sc_logic &, sc_subref_r<T>);
693 
694 template <class T>
695 inline sc_concref_r<sc_subref_r<T>, sc_bv_base> operator , (
696  sc_subref_r<T>, bool);
697 
698 template <class T>
699 inline sc_concref_r<sc_bv_base, sc_subref_r<T> > operator , (
700  bool, sc_subref_r<T>);
701 
702 
703 template <class T1, class T2>
704 inline sc_concref_r<sc_subref_r<T1>, sc_bitref_r<T2> > concat(
705  sc_subref_r<T1>, sc_bitref_r<T2>);
706 
707 template <class T1, class T2>
708 inline sc_concref_r<sc_subref_r<T1>, sc_subref_r<T2> > concat(
709  sc_subref_r<T1>, sc_subref_r<T2>);
710 
711 template <class T1, class T2, class T3>
712 inline sc_concref_r<sc_subref_r<T1>, sc_concref_r<T2, T3> > concat(
713  sc_subref_r<T1>, sc_concref_r<T2, T3>);
714 
715 template <class T1, class T2>
716 inline sc_concref_r<sc_subref_r<T1>, T2> concat(
717  sc_subref_r<T1>, const sc_proxy<T2> &);
718 
719 template <class T>
720 inline sc_concref_r<sc_subref_r<T>, sc_lv_base> concat(
721  sc_subref_r<T>, const char *);
722 
723 template <class T>
724 inline sc_concref_r<sc_lv_base,sc_subref_r<T> > concat(
725  const char *, sc_subref_r<T>);
726 
727 template <class T>
728 inline sc_concref_r<sc_subref_r<T>, sc_lv_base> concat(
729  sc_subref_r<T>, const sc_logic &);
730 
731 template <class T>
732 inline sc_concref_r<sc_lv_base, sc_subref_r<T> > concat(
733  const sc_logic &, sc_subref_r<T>);
734 
735 template <class T>
736 inline sc_concref_r<sc_subref_r<T>, sc_bv_base> concat(sc_subref_r<T>, bool);
737 
738 template <class T>
739 inline sc_concref_r<sc_bv_base, sc_subref_r<T> > concat(bool, sc_subref_r<T>);
740 
741 
742 template <class T1, class T2>
743 inline sc_concref_r<sc_subref_r<T1>, sc_bitref_r<T2> > operator , (
744  sc_subref_r<T1>, sc_bitref<T2>);
745 
746 template <class T1, class T2>
747 inline sc_concref_r<sc_subref_r<T1>, sc_bitref_r<T2> > operator , (
748  sc_subref<T1>, sc_bitref_r<T2>);
749 
750 template <class T1, class T2>
751 inline sc_concref_r<sc_subref_r<T1>, sc_subref_r<T2> > operator , (
752  sc_subref_r<T1>, sc_subref<T2>);
753 
754 template <class T1, class T2>
755 inline sc_concref_r<sc_subref_r<T1>, sc_subref_r<T2> > operator , (
756  sc_subref<T1>, sc_subref_r<T2>);
757 
758 template <class T1, class T2, class T3>
759 inline sc_concref_r<sc_subref_r<T1>, sc_concref_r<T2, T3> > operator , (
760  sc_subref_r<T1>, sc_concref<T2, T3>);
761 
762 template <class T1, class T2, class T3>
763 inline sc_concref_r<sc_subref_r<T1>, sc_concref_r<T2, T3> > operator , (
764  sc_subref<T1>, sc_concref_r<T2, T3>);
765 
766 template <class T1, class T2>
767 inline sc_concref_r<sc_subref_r<T1>, T2> operator , (
768  sc_subref<T1>, const sc_proxy<T2> &);
769 
770 template <class T1, class T2>
771 inline sc_concref_r<sc_subref_r<T1>, T2> operator , (
772  sc_subref_r<T1>, sc_proxy<T2> &);
773 
774 template <class T>
775 inline sc_concref_r<sc_subref_r<T>, sc_lv_base> operator , (
776  sc_subref<T>, const char *);
777 
778 template <class T>
779 inline sc_concref_r<sc_lv_base, sc_subref_r<T> > operator , (
780  const char *, sc_subref<T>);
781 
782 template <class T>
783 inline sc_concref_r<sc_subref_r<T>, sc_lv_base> operator , (
784  sc_subref<T>, const sc_logic &);
785 
786 template <class T>
787 inline sc_concref_r<sc_lv_base, sc_subref_r<T> > operator , (
788  const sc_logic &, sc_subref<T>);
789 
790 template <class T>
791 inline sc_concref_r<sc_subref_r<T>, sc_bv_base> operator , (
792  sc_subref<T>, bool);
793 
794 template <class T>
795 inline sc_concref_r<sc_bv_base, sc_subref_r<T> > operator , (
796  bool, sc_subref<T>);
797 
798 
799 template <class T1, class T2>
800 inline sc_concref_r<sc_subref_r<T1>, sc_bitref_r<T2> > concat(
801  sc_subref_r<T1>, sc_bitref<T2>);
802 
803 template <class T1, class T2>
804 inline sc_concref_r<sc_subref_r<T1>, sc_bitref_r<T2> > concat(
805  sc_subref<T1>, sc_bitref_r<T2>);
806 
807 template <class T1, class T2>
808 inline sc_concref_r<sc_subref_r<T1>, sc_subref_r<T2> > concat(
809  sc_subref_r<T1>, sc_subref<T2>);
810 
811 template <class T1, class T2>
812 inline sc_concref_r<sc_subref_r<T1>, sc_subref_r<T2> > concat(
813  sc_subref<T1>, sc_subref_r<T2>);
814 
815 template <class T1, class T2, class T3>
816 inline sc_concref_r<sc_subref_r<T1>, sc_concref_r<T2, T3> > concat(
817  sc_subref_r<T1>, sc_concref<T2, T3>);
818 
819 template <class T1, class T2, class T3>
820 inline sc_concref_r<sc_subref_r<T1>, sc_concref_r<T2, T3> > concat(
821  sc_subref<T1>, sc_concref_r<T2, T3>);
822 
823 template <class T1, class T2>
824 inline sc_concref_r<sc_subref_r<T1>, T2> concat(
825  sc_subref<T1>, const sc_proxy<T2> &);
826 
827 template <class T1, class T2>
828 inline sc_concref_r<sc_subref_r<T1>, T2> concat(
829  sc_subref_r<T1>, sc_proxy<T2> &);
830 
831 template <class T>
832 inline sc_concref_r<sc_subref_r<T>, sc_lv_base> concat(
833  sc_subref<T>, const char *);
834 
835 template <class T>
836 inline sc_concref_r<sc_lv_base, sc_subref_r<T> > concat(
837  const char *, sc_subref<T>);
838 
839 template <class T>
840 inline sc_concref_r<sc_subref_r<T>, sc_lv_base> concat(
841  sc_subref<T>, const sc_logic &);
842 
843 template <class T>
844 inline sc_concref_r<sc_lv_base, sc_subref_r<T> > concat(
845  const sc_logic &, sc_subref<T>);
846 
847 template <class T>
848 inline sc_concref_r<sc_subref_r<T>, sc_bv_base> concat(sc_subref<T>, bool);
849 
850 template <class T>
851 inline sc_concref_r<sc_bv_base, sc_subref_r<T> > concat(bool, sc_subref<T>);
852 
853 
854 // ----------------------------------------------------------------------------
855 // CLASS TEMPLATE : sc_subref<X>
856 //
857 // Proxy class for sc_proxy part selection (r-value and l-value).
858 // ----------------------------------------------------------------------------
859 
860 template <class X>
861 class sc_subref : public sc_subref_r<X>
862 {
863  public:
864  // typedefs
865  typedef sc_subref_r<X> base_type;
866 
867  // constructor
868  sc_subref(X &obj_, int hi_, int lo_) : sc_subref_r<X>(obj_, hi_, lo_) {}
869 
870  // copy constructor
871  sc_subref(const sc_subref<X> &a) : sc_subref_r<X>(a) {}
872 
873  // cloning
874  sc_subref<X> *clone() const { return new sc_subref<X>(*this); }
875 
876  // assignment operators
877  template <class Y>
878  sc_subref<X> &
879  operator = (const sc_proxy<Y> &a)
880  {
881  base_type::assign_(a);
882  return *this;
883  }
884 
885  sc_subref<X> &operator = (const sc_subref_r<X> &a);
886  sc_subref<X> &operator = (const sc_subref<X> &a);
887 
888  sc_subref<X> &
889  operator = (const char *a)
890  {
891  base_type::assign_(a);
892  return *this;
893  }
894 
895  sc_subref<X> &
896  operator = (const bool *a)
897  {
898  base_type::assign_(a);
899  return *this;
900  }
901 
902  sc_subref<X> &
903  operator = (const sc_logic *a)
904  {
905  base_type::assign_(a);
906  return *this;
907  }
908 
909  sc_subref<X> &
910  operator = (const sc_unsigned &a)
911  {
912  base_type::assign_(a);
913  return *this;
914  }
915 
916  sc_subref<X> &
917  operator = (const sc_signed &a)
918  {
919  base_type::assign_(a);
920  return *this;
921  }
922 
923  sc_subref<X> &
924  operator = (const sc_uint_base &a)
925  {
926  base_type::assign_(a);
927  return *this;
928  }
929 
930  sc_subref<X> &
931  operator = (const sc_int_base &a)
932  {
933  base_type::assign_(a);
934  return *this;
935  }
936 
937  sc_subref<X> &
938  operator = (unsigned long a)
939  {
940  base_type::assign_(a);
941  return *this;
942  }
943 
944  sc_subref<X> &
945  operator = (long a)
946  {
947  base_type::assign_(a);
948  return *this;
949  }
950 
951  sc_subref<X> &
952  operator = (unsigned int a)
953  {
954  base_type::assign_(a);
955  return *this;
956  }
957 
958  sc_subref<X> &
959  operator = (int a)
960  {
961  base_type::assign_(a);
962  return *this;
963  }
964 
965  sc_subref<X> &
966  operator = (uint64 a)
967  {
968  base_type::assign_(a);
969  return *this;
970  }
971 
972  sc_subref<X> &
973  operator = (int64 a)
974  {
975  base_type::assign_(a);
976  return *this;
977  }
978 
979  // other methods
980  void scan(::std::istream & =::std::cin);
981 
982  private:
983  // Disabled
984  sc_subref();
985 };
986 
987 
988 // l-value concatenation operators and functions
989 
990 template <class T1, class T2>
991 inline sc_concref<sc_subref<T1>, sc_bitref<T2> > operator , (
992  sc_subref<T1>, sc_bitref<T2>);
993 
994 template <class T1, class T2>
995 inline sc_concref<sc_subref<T1>, sc_subref<T2> > operator , (
996  sc_subref<T1>, sc_subref<T2>);
997 
998 template <class T1, class T2, class T3>
999 inline sc_concref<sc_subref<T1>, sc_concref<T2, T3> > operator , (
1000  sc_subref<T1>, sc_concref<T2, T3>);
1001 
1002 template <class T1, class T2>
1003 inline sc_concref<sc_subref<T1>, T2> operator , (
1004  sc_subref<T1>, sc_proxy<T2> &);
1005 
1006 
1007 template <class T1, class T2>
1008 inline sc_concref<sc_subref<T1>, sc_bitref<T2> > concat(
1009  sc_subref<T1>, sc_bitref<T2>);
1010 
1011 template <class T1, class T2>
1012 inline sc_concref<sc_subref<T1>, sc_subref<T2> > concat(
1013  sc_subref<T1>, sc_subref<T2>);
1014 
1015 template <class T1, class T2, class T3>
1016 inline sc_concref<sc_subref<T1>, sc_concref<T2, T3> > concat(
1017  sc_subref<T1>, sc_concref<T2, T3>);
1018 
1019 template <class T1, class T2>
1020 inline sc_concref<sc_subref<T1>, T2> concat(sc_subref<T1>, sc_proxy<T2> &);
1021 
1022 
1023 template <class T>
1024 inline ::std::istream &operator >> (::std::istream &, sc_subref<T>);
1025 
1026 
1027 // ----------------------------------------------------------------------------
1028 // CLASS TEMPLATE : sc_concref_r<X,Y>
1029 //
1030 // Proxy class for sc_proxy concatenation (r-value only).
1031 // ----------------------------------------------------------------------------
1032 
1033 template <class X, class Y>
1034 class sc_concref_r : public sc_proxy<sc_concref_r<X, Y> >
1035 {
1036  public:
1037  typedef typename sc_proxy<sc_concref_r<X, Y> >::value_type value_type;
1038 
1039  // constructor
1040  sc_concref_r(const X &left_, const Y &right_, int delete_=0) :
1041  m_left(const_cast<X &>(left_)), m_right(const_cast<Y &>(right_)),
1042  m_delete(delete_), m_refs(*new int(1))
1043  {}
1044 
1045  // copy constructor
1046  sc_concref_r(const sc_concref_r<X, Y> &a) :
1047  m_left(a.m_left), m_right(a.m_right),
1048  m_delete(a.m_delete), m_refs(a.m_refs)
1049  { ++ m_refs; }
1050 
1051  // destructor
1052  virtual ~sc_concref_r();
1053 
1054  // cloning
1055  sc_concref_r<X, Y> *clone() const { return new sc_concref_r<X, Y>(*this); }
1056 
1057  // common methods
1058  int length() const { return (m_left.length() + m_right.length()); }
1059 
1060  int size() const { return ((length() - 1) / SC_DIGIT_SIZE + 1); }
1061 
1062  value_type get_bit(int n) const;
1063  void set_bit(int n, value_type value);
1064 
1065  sc_digit get_word(int i) const;
1066  void set_word(int i, sc_digit w);
1067 
1068  sc_digit get_cword(int i) const;
1069  void set_cword(int i, sc_digit w);
1070 
1071  void clean_tail() { m_left.clean_tail(); m_right.clean_tail(); }
1072 
1073  // other methods
1074  bool is_01() const { return (m_left.is_01() && m_right.is_01()); }
1075 
1076  protected:
1077  X &m_left;
1078  Y &m_right;
1079  mutable int m_delete;
1080  int &m_refs;
1081 
1082  private:
1083  // Disabled
1084  sc_concref_r();
1085  sc_concref_r<X, Y> &operator = (const sc_concref_r<X, Y> &);
1086 };
1087 
1088 
1089 // r-value concatenation operators and functions
1090 
1091 template <class T1, class T2, class T3>
1092 inline sc_concref_r<sc_concref_r<T1, T2>,sc_bitref_r<T3> > operator , (
1093  sc_concref_r<T1, T2>, sc_bitref_r<T3>);
1094 
1095 template <class T1, class T2, class T3>
1096 inline sc_concref_r<sc_concref_r<T1, T2>, sc_subref_r<T3> > operator , (
1097  sc_concref_r<T1, T2>, sc_subref_r<T3>);
1098 
1099 template <class T1, class T2, class T3, class T4>
1100 inline sc_concref_r<sc_concref_r<T1, T2>, sc_concref_r<T3, T4> > operator , (
1101  sc_concref_r<T1, T2>, sc_concref_r<T3, T4>);
1102 
1103 template <class T1, class T2, class T3>
1104 inline sc_concref_r<sc_concref_r<T1, T2>, T3> operator , (
1105  sc_concref_r<T1, T2>, const sc_proxy<T3> &);
1106 
1107 template <class T1, class T2>
1108 inline sc_concref_r<sc_concref_r<T1, T2>, sc_lv_base> operator , (
1109  sc_concref_r<T1, T2>, const char *);
1110 
1111 template <class T1, class T2>
1112 inline sc_concref_r<sc_lv_base, sc_concref_r<T1, T2> > operator , (
1113  const char *, sc_concref_r<T1, T2>);
1114 
1115 template <class T1, class T2>
1116 inline sc_concref_r<sc_concref_r<T1, T2>, sc_lv_base> operator , (
1117  sc_concref_r<T1, T2>, const sc_logic &);
1118 
1119 template <class T1, class T2>
1120 inline sc_concref_r<sc_lv_base, sc_concref_r<T1, T2> > operator , (
1121  const sc_logic &, sc_concref_r<T1, T2>);
1122 
1123 template <class T1, class T2>
1124 inline sc_concref_r<sc_concref_r<T1, T2>, sc_bv_base> operator , (
1125  sc_concref_r<T1, T2>, bool);
1126 
1127 template <class T1, class T2>
1128 inline sc_concref_r<sc_bv_base, sc_concref_r<T1, T2> > operator , (
1129  bool, sc_concref_r<T1, T2>);
1130 
1131 
1132 template <class T1, class T2, class T3>
1133 inline sc_concref_r<sc_concref_r<T1, T2>, sc_bitref_r<T3> > concat(
1134  sc_concref_r<T1, T2>, sc_bitref_r<T3>);
1135 
1136 template <class T1, class T2, class T3>
1137 inline sc_concref_r<sc_concref_r<T1, T2>, sc_subref_r<T3> > concat(
1138  sc_concref_r<T1, T2>, sc_subref_r<T3>);
1139 
1140 template <class T1, class T2, class T3, class T4>
1141 inline sc_concref_r<sc_concref_r<T1, T2>, sc_concref_r<T3, T4> > concat(
1142  sc_concref_r<T1, T2>, sc_concref_r<T3, T4>);
1143 
1144 template <class T1, class T2, class T3>
1145 inline sc_concref_r<sc_concref_r<T1, T2>, T3> concat(
1146  sc_concref_r<T1, T2>, const sc_proxy<T3> &);
1147 
1148 template <class T1, class T2>
1149 inline sc_concref_r<sc_concref_r<T1, T2>, sc_lv_base> concat(
1150  sc_concref_r<T1, T2>, const char *);
1151 
1152 template <class T1, class T2>
1153 inline sc_concref_r<sc_lv_base, sc_concref_r<T1, T2> > concat(
1154  const char *, sc_concref_r<T1, T2>);
1155 
1156 template <class T1, class T2>
1157 inline sc_concref_r<sc_concref_r<T1, T2>, sc_lv_base> concat(
1158  sc_concref_r<T1, T2>, const sc_logic &);
1159 
1160 template <class T1, class T2>
1161 inline sc_concref_r<sc_lv_base, sc_concref_r<T1, T2> > concat(
1162  const sc_logic &, sc_concref_r<T1, T2>);
1163 
1164 template <class T1, class T2>
1165 inline sc_concref_r<sc_concref_r<T1, T2>, sc_bv_base> concat(
1166  sc_concref_r<T1, T2>, bool);
1167 
1168 template <class T1, class T2>
1169 inline sc_concref_r<sc_bv_base, sc_concref_r<T1, T2> > concat(
1170  bool, sc_concref_r<T1, T2>);
1171 
1172 
1173 template <class T1, class T2, class T3>
1174 inline sc_concref_r<sc_concref_r<T1, T2>, sc_bitref_r<T3> > operator , (
1175  sc_concref_r<T1, T2>, sc_bitref<T3>);
1176 
1177 template <class T1, class T2, class T3>
1178 inline sc_concref_r<sc_concref_r<T1, T2>, sc_bitref_r<T3> > operator , (
1179  sc_concref<T1, T2>, sc_bitref_r<T3>);
1180 
1181 template <class T1, class T2, class T3>
1182 inline sc_concref_r<sc_concref_r<T1, T2>, sc_subref_r<T3> > operator , (
1183  sc_concref_r<T1, T2>, sc_subref<T3>);
1184 
1185 template <class T1, class T2, class T3>
1186 inline sc_concref_r<sc_concref_r<T1, T2>, sc_subref_r<T3> > operator , (
1187  sc_concref<T1, T2>, sc_subref_r<T3>);
1188 
1189 template <class T1, class T2, class T3, class T4>
1190 inline sc_concref_r<sc_concref_r<T1, T2>, sc_concref_r<T3, T4> > operator , (
1191  sc_concref_r<T1, T2>, sc_concref<T3, T4>);
1192 
1193 template <class T1, class T2, class T3, class T4>
1194 inline sc_concref_r<sc_concref_r<T1, T2>, sc_concref_r<T3, T4> > operator , (
1195  sc_concref<T1, T2>, sc_concref_r<T3, T4>);
1196 
1197 template <class T1, class T2, class T3>
1198 inline sc_concref_r<sc_concref_r<T1, T2>, T3> operator , (
1199  sc_concref<T1, T2>, const sc_proxy<T3> &);
1200 
1201 template <class T1, class T2, class T3>
1202 inline sc_concref_r<sc_concref_r<T1, T2>, T3> operator , (
1203  sc_concref_r<T1, T2>, sc_proxy<T3> &);
1204 
1205 template <class T1, class T2>
1206 inline sc_concref_r<sc_concref_r<T1, T2>, sc_lv_base> operator , (
1207  sc_concref<T1, T2>, const char *);
1208 
1209 template <class T1, class T2>
1210 inline sc_concref_r<sc_lv_base, sc_concref_r<T1, T2> > operator , (
1211  const char *, sc_concref<T1, T2>);
1212 
1213 template <class T1, class T2>
1214 inline sc_concref_r<sc_concref_r<T1, T2>, sc_lv_base> operator , (
1215  sc_concref<T1, T2>, const sc_logic &);
1216 
1217 template <class T1, class T2>
1218 inline sc_concref_r<sc_lv_base, sc_concref_r<T1, T2> > operator , (
1219  const sc_logic &, sc_concref<T1, T2>);
1220 
1221 template <class T1, class T2>
1222 inline sc_concref_r<sc_concref_r<T1, T2>, sc_bv_base> operator , (
1223  sc_concref<T1, T2>, bool);
1224 
1225 template <class T1, class T2>
1226 inline sc_concref_r<sc_bv_base, sc_concref_r<T1, T2> > operator , (
1227  bool, sc_concref<T1, T2>);
1228 
1229 
1230 template <class T1, class T2, class T3>
1231 inline sc_concref_r<sc_concref_r<T1, T2>, sc_bitref_r<T3> > concat(
1232  sc_concref_r<T1, T2>, sc_bitref<T3>);
1233 
1234 template <class T1, class T2, class T3>
1235 inline sc_concref_r<sc_concref_r<T1, T2>, sc_bitref_r<T3> > concat(
1236  sc_concref<T1, T2>, sc_bitref_r<T3>);
1237 
1238 template <class T1, class T2, class T3>
1239 inline sc_concref_r<sc_concref_r<T1, T2>, sc_subref_r<T3> > concat(
1240  sc_concref_r<T1, T2>, sc_subref<T3>);
1241 
1242 template <class T1, class T2, class T3>
1243 inline sc_concref_r<sc_concref_r<T1, T2>, sc_subref_r<T3> > concat(
1244  sc_concref<T1, T2>, sc_subref_r<T3>);
1245 
1246 template <class T1, class T2, class T3, class T4>
1247 inline sc_concref_r<sc_concref_r<T1, T2>, sc_concref_r<T3, T4> > concat(
1248  sc_concref_r<T1, T2>, sc_concref<T3, T4>);
1249 
1250 template <class T1, class T2, class T3, class T4>
1251 inline sc_concref_r<sc_concref_r<T1, T2>, sc_concref_r<T3, T4> > concat(
1252  sc_concref<T1, T2>, sc_concref_r<T3, T4> );
1253 
1254 template <class T1, class T2, class T3>
1255 inline sc_concref_r<sc_concref_r<T1, T2>, T3> concat(
1256  sc_concref<T1, T2>, const sc_proxy<T3> &);
1257 
1258 template <class T1, class T2, class T3>
1259 inline sc_concref_r<sc_concref_r<T1, T2>, T3> concat(
1260  sc_concref_r<T1, T2>, sc_proxy<T3> &);
1261 
1262 template <class T1, class T2>
1263 inline sc_concref_r<sc_concref_r<T1, T2>, sc_lv_base> concat(
1264  sc_concref<T1, T2>, const char *);
1265 
1266 template <class T1, class T2>
1267 inline sc_concref_r<sc_lv_base, sc_concref_r<T1, T2> > concat(
1268  const char *, sc_concref<T1, T2>);
1269 
1270 template <class T1, class T2>
1271 inline sc_concref_r<sc_concref_r<T1, T2>, sc_lv_base> concat(
1272  sc_concref<T1, T2>, const sc_logic &);
1273 
1274 template <class T1, class T2>
1275 inline sc_concref_r<sc_lv_base, sc_concref_r<T1, T2> > concat(
1276  const sc_logic &, sc_concref<T1, T2>);
1277 
1278 template <class T1, class T2>
1279 inline sc_concref_r<sc_concref_r<T1, T2>, sc_bv_base> concat(
1280  sc_concref<T1, T2>, bool);
1281 
1282 template <class T1, class T2>
1283 inline sc_concref_r<sc_bv_base, sc_concref_r<T1, T2> > concat(
1284  bool, sc_concref<T1, T2>);
1285 
1286 
1287 // ----------------------------------------------------------------------------
1288 // CLASS TEMPLATE : sc_concref<X,Y>
1289 //
1290 // Proxy class for sc_proxy concatenation (r-value and l-value).
1291 // ----------------------------------------------------------------------------
1292 
1293 template <class X, class Y>
1294 class sc_concref : public sc_concref_r<X, Y>
1295 {
1296  public:
1297  // typedefs
1298  typedef sc_concref_r<X, Y> base_type;
1299 
1300  // constructor
1301  sc_concref(X &left_, Y &right_, int delete_=0) :
1302  sc_concref_r<X, Y>(left_, right_, delete_)
1303  {}
1304 
1305  // copy constructor
1306  sc_concref(const sc_concref<X, Y> &a) : sc_concref_r<X, Y>(a) {}
1307 
1308  // cloning
1309  sc_concref<X, Y> *clone() const { return new sc_concref<X, Y>(*this); }
1310 
1311  // assignment operators
1312  template <class Z>
1313  sc_concref<X, Y> &
1314  operator = (const sc_proxy<Z> &a)
1315  {
1316  base_type::assign_(a);
1317  return *this;
1318  }
1319 
1320  sc_concref<X, Y> &
1321  operator = (const sc_concref<X, Y> &a)
1322  {
1323  base_type::assign_(a);
1324  return *this;
1325  }
1326 
1327  sc_concref<X, Y> &
1328  operator = (const char *a)
1329  {
1330  base_type::assign_(a);
1331  return *this;
1332  }
1333 
1334  sc_concref<X, Y> &
1335  operator = (const bool *a)
1336  {
1337  base_type::assign_(a);
1338  return *this;
1339  }
1340 
1341  sc_concref<X, Y> &
1342  operator = (const sc_logic *a)
1343  {
1344  base_type::assign_(a);
1345  return *this;
1346  }
1347 
1348  sc_concref<X, Y> &
1349  operator = (const sc_unsigned &a)
1350  {
1351  base_type::assign_(a);
1352  return *this;
1353  }
1354 
1355  sc_concref<X, Y> &
1356  operator = (const sc_signed &a)
1357  {
1358  base_type::assign_(a);
1359  return *this;
1360  }
1361 
1362  sc_concref<X, Y> &
1363  operator = (const sc_uint_base &a)
1364  {
1365  base_type::assign_(a);
1366  return *this;
1367  }
1368 
1369  sc_concref<X, Y> &
1370  operator = (const sc_int_base &a)
1371  {
1372  base_type::assign_(a);
1373  return *this;
1374  }
1375 
1376  sc_concref<X, Y> &
1377  operator = (unsigned long a)
1378  {
1379  base_type::assign_(a);
1380  return *this;
1381  }
1382 
1383  sc_concref<X, Y> &
1384  operator = (long a)
1385  {
1386  base_type::assign_(a);
1387  return *this;
1388  }
1389 
1390  sc_concref<X, Y> &
1391  operator = (unsigned int a)
1392  {
1393  base_type::assign_(a);
1394  return *this;
1395  }
1396 
1397  sc_concref<X, Y> &
1398  operator = (int a)
1399  {
1400  base_type::assign_(a);
1401  return *this;
1402  }
1403 
1404  sc_concref<X, Y> &
1405  operator = (uint64 a)
1406  {
1407  base_type::assign_(a);
1408  return *this;
1409  }
1410 
1411  sc_concref<X, Y> &
1412  operator = (int64 a)
1413  {
1414  base_type::assign_(a);
1415  return *this;
1416  }
1417 
1418  // other methods
1419  void scan(::std::istream & =::std::cin);
1420 
1421  private:
1422  // Disabled
1423  sc_concref();
1424 };
1425 
1426 
1427 // l-value concatenation operators and functions
1428 
1429 template <class T1, class T2, class T3>
1430 inline sc_concref<sc_concref<T1, T2>, sc_bitref<T3> > operator , (
1431  sc_concref<T1, T2>, sc_bitref<T3>);
1432 
1433 template <class T1, class T2, class T3>
1434 inline sc_concref<sc_concref<T1, T2>, sc_subref<T3> > operator , (
1435  sc_concref<T1, T2>, sc_subref<T3>);
1436 
1437 template <class T1, class T2, class T3, class T4>
1438 inline sc_concref<sc_concref<T1, T2>, sc_concref<T3, T4> > operator , (
1439  sc_concref<T1, T2>, sc_concref<T3, T4>);
1440 
1441 template <class T1, class T2, class T3>
1442 inline sc_concref<sc_concref<T1, T2>, T3> operator , (
1443  sc_concref<T1, T2>, sc_proxy<T3> &);
1444 
1445 
1446 template <class T1, class T2, class T3>
1447 inline sc_concref<sc_concref<T1, T2>, sc_bitref<T3> > concat(
1448  sc_concref<T1, T2>, sc_bitref<T3>);
1449 
1450 template <class T1, class T2, class T3>
1451 inline sc_concref<sc_concref<T1, T2>, sc_subref<T3> > concat(
1452  sc_concref<T1, T2>, sc_subref<T3>);
1453 
1454 template <class T1, class T2, class T3, class T4>
1455 inline sc_concref<sc_concref<T1, T2>, sc_concref<T3, T4> > concat(
1456  sc_concref<T1, T2>, sc_concref<T3, T4>);
1457 
1458 template <class T1, class T2, class T3>
1459 inline sc_concref<sc_concref<T1, T2>, T3> concat(
1460  sc_concref<T1, T2>, sc_proxy<T3> &);
1461 
1462 
1463 template <class T1, class T2>
1464 inline ::std::istream &operator >> (::std::istream &, sc_concref<T1, T2>);
1465 
1466 
1467 // ----------------------------------------------------------------------------
1468 // CLASS TEMPLATE : sc_proxy<T>
1469 //
1470 // Base class template for bit/logic vector classes.
1471 // (Barton/Nackmann implementation)
1472 // ----------------------------------------------------------------------------
1473 
1474 // r-value concatenation operators and functions
1475 
1476 template <class T1, class T2>
1477 inline sc_concref_r<T1, sc_bitref_r<T2> > operator , (
1478  const sc_proxy<T1> &, sc_bitref_r<T2>);
1479 
1480 template <class T1, class T2>
1481 inline sc_concref_r<T1, sc_subref_r<T2> > operator , (
1482  const sc_proxy<T1> &, sc_subref_r<T2>);
1483 
1484 template <class T1, class T2, class T3>
1485 inline sc_concref_r<T1, sc_concref_r<T2, T3> > operator , (
1486  const sc_proxy<T1> &, sc_concref_r<T2, T3>);
1487 
1488 template <class T1, class T2>
1489 inline sc_concref_r<T1, T2> operator , (
1490  const sc_proxy<T1> &, const sc_proxy<T2> &);
1491 
1492 template <class T>
1493 inline sc_concref_r<T, sc_lv_base> operator , (
1494  const sc_proxy<T> &, const char *);
1495 
1496 template <class T>
1497 inline sc_concref_r<sc_lv_base,T> operator , (
1498  const char *, const sc_proxy<T> &);
1499 
1500 template <class T>
1501 inline sc_concref_r<T, sc_lv_base> operator , (
1502  const sc_proxy<T> &, const sc_logic &);
1503 
1504 template <class T>
1505 inline sc_concref_r<sc_lv_base, T> operator , (
1506  const sc_logic &, const sc_proxy<T> &);
1507 
1508 template <class T>
1509 inline sc_concref_r<T, sc_bv_base> operator , (const sc_proxy<T> &, bool);
1510 
1511 template <class T>
1512 inline sc_concref_r<sc_bv_base, T> operator , (bool, const sc_proxy<T> &);
1513 
1514 
1515 template <class T1, class T2>
1516 inline sc_concref_r<T1, sc_bitref_r<T2> > concat(
1517  const sc_proxy<T1> &, sc_bitref_r<T2>);
1518 
1519 template <class T1, class T2>
1520 inline sc_concref_r<T1, sc_subref_r<T2> > concat(
1521  const sc_proxy<T1> &, sc_subref_r<T2>);
1522 
1523 template <class T1, class T2, class T3>
1524 inline sc_concref_r<T1, sc_concref_r<T2, T3> > concat(
1525  const sc_proxy<T1> &, sc_concref_r<T2, T3>);
1526 
1527 template <class T1, class T2>
1528 inline sc_concref_r<T1, T2> concat(const sc_proxy<T1> &, const sc_proxy<T2> &);
1529 
1530 template <class T>
1531 inline sc_concref_r<T, sc_lv_base> concat(const sc_proxy<T> &, const char *);
1532 
1533 template <class T>
1534 inline sc_concref_r<sc_lv_base, T> concat(const char *, const sc_proxy<T> &);
1535 
1536 template <class T>
1537 inline sc_concref_r<T, sc_lv_base> concat(
1538  const sc_proxy<T> &, const sc_logic &);
1539 
1540 template <class T>
1541 inline sc_concref_r<sc_lv_base, T> concat(
1542  const sc_logic &, const sc_proxy<T> &);
1543 
1544 template <class T>
1545 inline sc_concref_r<T, sc_bv_base> concat(const sc_proxy<T> &, bool);
1546 
1547 template <class T>
1548 inline sc_concref_r<sc_bv_base, T> concat(bool, const sc_proxy<T> &);
1549 
1550 
1551 template <class T1, class T2>
1552 inline sc_concref_r<T1, sc_bitref_r<T2> > operator , (
1553  const sc_proxy<T1> &, sc_bitref<T2>);
1554 
1555 template <class T1, class T2>
1556 inline sc_concref_r<T1, sc_bitref_r<T2> > operator , (
1557  sc_proxy<T1> &, sc_bitref_r<T2>);
1558 
1559 template <class T1, class T2>
1560 inline sc_concref_r<T1, sc_subref_r<T2> > operator , (
1561  const sc_proxy<T1> &, sc_subref<T2>);
1562 
1563 template <class T1, class T2>
1564 inline sc_concref_r<T1, sc_subref_r<T2> > operator , (
1565  sc_proxy<T1> &, sc_subref_r<T2>);
1566 
1567 template <class T1, class T2, class T3>
1568 inline sc_concref_r<T1, sc_concref_r<T2, T3> > operator , (
1569  const sc_proxy<T1> &, sc_concref<T2, T3>);
1570 
1571 template <class T1, class T2, class T3>
1572 inline sc_concref_r<T1, sc_concref_r<T2, T3> > operator , (
1573  sc_proxy<T1> &, sc_concref_r<T2, T3>);
1574 
1575 template <class T1, class T2>
1576 inline sc_concref_r<T1, T2> operator , (const sc_proxy<T1> &, sc_proxy<T2> &);
1577 
1578 template <class T1, class T2>
1579 inline sc_concref_r<T1, T2> operator , (sc_proxy<T1> &, const sc_proxy<T2> &);
1580 
1581 template <class T>
1582 inline sc_concref_r<T, sc_lv_base> operator , (sc_proxy<T> &, const char *);
1583 
1584 template <class T>
1585 inline sc_concref_r<sc_lv_base, T> operator , (const char *, sc_proxy<T> &);
1586 
1587 template <class T>
1588 inline sc_concref_r<T, sc_lv_base> operator , (
1589  sc_proxy<T> &, const sc_logic &);
1590 
1591 template <class T>
1592 inline sc_concref_r<sc_lv_base, T> operator , (
1593  const sc_logic &, sc_proxy<T> &);
1594 
1595 template <class T>
1596 inline sc_concref_r<T, sc_bv_base> operator , (sc_proxy<T> &, bool);
1597 
1598 template <class T>
1599 inline sc_concref_r<sc_bv_base, T> operator , (bool, sc_proxy<T> &);
1600 
1601 
1602 template <class T1, class T2>
1603 inline sc_concref_r<T1, sc_bitref_r<T2> > concat(
1604  const sc_proxy<T1> &, sc_bitref<T2>);
1605 
1606 template <class T1, class T2>
1607 inline sc_concref_r<T1, sc_bitref_r<T2> > concat(
1608  sc_proxy<T1> &, sc_bitref_r<T2>);
1609 
1610 template <class T1, class T2>
1611 inline sc_concref_r<T1, sc_subref_r<T2> > concat(
1612  const sc_proxy<T1> &, sc_subref<T2>);
1613 
1614 template <class T1, class T2>
1615 inline sc_concref_r<T1, sc_subref_r<T2> > concat(
1616  sc_proxy<T1> &, sc_subref_r<T2>);
1617 
1618 template <class T1, class T2, class T3>
1619 inline sc_concref_r<T1, sc_concref_r<T2, T3> > concat(
1620  const sc_proxy<T1> &, sc_concref<T2, T3>);
1621 
1622 template <class T1, class T2, class T3>
1623 inline sc_concref_r<T1, sc_concref_r<T2, T3> > concat(
1624  sc_proxy<T1> &, sc_concref_r<T2, T3>);
1625 
1626 template <class T1, class T2>
1627 inline sc_concref_r<T1, T2> concat(const sc_proxy<T1> &, sc_proxy<T2> &);
1628 
1629 template <class T1, class T2>
1630 inline sc_concref_r<T1, T2> concat(sc_proxy<T1> &, const sc_proxy<T2> &);
1631 
1632 template <class T>
1633 inline sc_concref_r<T, sc_lv_base> concat(sc_proxy<T> &, const char *);
1634 
1635 template <class T>
1636 inline sc_concref_r<sc_lv_base, T> concat(const char *, sc_proxy<T> &);
1637 
1638 template <class T>
1639 inline sc_concref_r<T, sc_lv_base> concat(sc_proxy<T> &, const sc_logic &);
1640 
1641 template <class T>
1642 inline sc_concref_r<sc_lv_base, T> concat(const sc_logic &, sc_proxy<T> &);
1643 
1644 template <class T>
1645 inline sc_concref_r<T, sc_bv_base> concat(sc_proxy<T> &, bool);
1646 
1647 template <class T>
1648 inline sc_concref_r<sc_bv_base, T> concat(bool, sc_proxy<T> &);
1649 
1650 
1651 // l-value concatenation operators and functions
1652 template <class T1, class T2>
1653 inline sc_concref<T1,sc_bitref<T2> > operator , (
1654  sc_proxy<T1> &, sc_bitref<T2>);
1655 
1656 template <class T1, class T2>
1657 inline sc_concref<T1, sc_subref<T2> > operator , (
1658  sc_proxy<T1> &, sc_subref<T2>);
1659 
1660 template <class T1, class T2, class T3>
1661 inline sc_concref<T1, sc_concref<T2, T3> > operator , (
1662  sc_proxy<T1> &, sc_concref<T2, T3>);
1663 
1664 template <class T1, class T2>
1665 inline sc_concref<T1, T2> operator , (sc_proxy<T1> &, sc_proxy<T2> &);
1666 
1667 
1668 template <class T1, class T2>
1669 inline sc_concref<T1, sc_bitref<T2> > concat(sc_proxy<T1> &, sc_bitref<T2>);
1670 
1671 template <class T1, class T2>
1672 inline sc_concref<T1, sc_subref<T2> > concat(sc_proxy<T1> &, sc_subref<T2>);
1673 
1674 template <class T1, class T2, class T3>
1675 inline sc_concref<T1, sc_concref<T2, T3> > concat(
1676  sc_proxy<T1> &, sc_concref<T2, T3>);
1677 
1678 template <class T1, class T2>
1679 inline sc_concref<T1, T2> concat(sc_proxy<T1> &, sc_proxy<T2> &);
1680 
1681 
1682 // IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
1683 
1684 // ----------------------------------------------------------------------------
1685 // CLASS TEMPLATE : sc_bitref_r<T>
1686 //
1687 // Proxy class for sc_proxy bit selection (r-value only).
1688 // ----------------------------------------------------------------------------
1689 
1690 // bitwise operators and functions
1691 
1692 // bitwise and
1693 template <class T1, class T2>
1694 inline sc_logic
1695 operator & (const sc_bitref_r<T1> &a, const sc_bitref_r<T2> &b)
1696 {
1697  return sc_logic(sc_logic::and_table[a.value()][b.value()]);
1698 }
1699 
1700 // bitwise or
1701 template <class T1, class T2>
1702 inline sc_logic
1703 operator | (const sc_bitref_r<T1> &a, const sc_bitref_r<T2> &b)
1704 {
1705  return sc_logic(sc_logic::or_table[a.value()][b.value()]);
1706 }
1707 
1708 // bitwise xor
1709 template <class T1, class T2>
1710 inline sc_logic
1711 operator ^ (const sc_bitref_r<T1> &a, const sc_bitref_r<T2> &b)
1712 {
1713  return sc_logic(sc_logic::xor_table[a.value()][b.value()]);
1714 }
1715 
1716 // relational operators and functions
1717 template <class T1, class T2>
1718 inline bool
1719 operator == (const sc_bitref_r<T1> &a, const sc_bitref_r<T2> &b)
1720 {
1721  return ((int)a.value() == b.value());
1722 }
1723 
1724 template <class T1, class T2>
1725 inline bool
1726 operator != (const sc_bitref_r<T1> &a, const sc_bitref_r<T2> &b)
1727 {
1728  return ((int)a.value() != b.value());
1729 }
1730 
1731 // common methods
1732 template <class T>
1733 inline typename sc_bitref_r<T>::value_type
1734 sc_bitref_r<T>::get_bit(int n) const
1735 {
1736  if (n == 0) {
1737  return m_obj.get_bit(m_index);
1738  } else {
1739  SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, 0);
1740  return Log_0;
1741  }
1742 }
1743 
1744 template <class T>
1745 inline sc_digit
1746 sc_bitref_r<T>::get_word(int n) const
1747 {
1748  if (n == 0) {
1749  return (get_bit(n) & SC_DIGIT_ONE);
1750  } else {
1751  SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, 0);
1752  return 0;
1753  }
1754 }
1755 
1756 template <class T>
1757 inline sc_digit
1758 sc_bitref_r<T>::get_cword(int n) const
1759 {
1760  if (n == 0) {
1761  return ((get_bit(n) & SC_DIGIT_TWO) >> 1);
1762  } else {
1763  SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, 0);
1764  return 0;
1765  }
1766 }
1767 
1768 // r-value concatenation operators and functions
1769 template <class T1, class T2>
1770 inline sc_concref_r<sc_bitref_r<T1>, sc_bitref_r<T2> >
1771 operator , (sc_bitref_r<T1> a, sc_bitref_r<T2> b)
1772 {
1773  return sc_concref_r<sc_bitref_r<T1>, sc_bitref_r<T2> >(
1774  *a.clone(), *b.clone(), 3);
1775 }
1776 
1777 template <class T1, class T2>
1778 inline sc_concref_r<sc_bitref_r<T1>, sc_subref_r<T2> >
1779 operator , (sc_bitref_r<T1> a, sc_subref_r<T2> b)
1780 {
1781  return sc_concref_r<sc_bitref_r<T1>, sc_subref_r<T2> >(
1782  *a.clone(), *b.clone(), 3);
1783 }
1784 
1785 template <class T1, class T2, class T3>
1786 inline sc_concref_r<sc_bitref_r<T1>, sc_concref_r<T2, T3> >
1787 operator , (sc_bitref_r<T1> a, sc_concref_r<T2, T3> b)
1788 {
1789  return sc_concref_r<sc_bitref_r<T1>, sc_concref_r<T2, T3> >(
1790  *a.clone(), *b.clone(), 3);
1791 }
1792 
1793 template <class T1, class T2>
1794 inline sc_concref_r<sc_bitref_r<T1>, T2>
1795 operator , (sc_bitref_r<T1> a, const sc_proxy<T2> &b)
1796 {
1797  return sc_concref_r<sc_bitref_r<T1>, T2>(
1798  *a.clone(), b.back_cast(), 1);
1799 }
1800 
1801 
1802 template <class T1, class T2>
1803 inline
1804 sc_concref_r<sc_bitref_r<T1>, sc_bitref_r<T2> >
1805 concat(sc_bitref_r<T1> a, sc_bitref_r<T2> b)
1806 {
1807  return sc_concref_r<sc_bitref_r<T1>, sc_bitref_r<T2> >(
1808  *a.clone(), *b.clone(), 3);
1809 }
1810 
1811 template <class T1, class T2>
1812 inline sc_concref_r<sc_bitref_r<T1>, sc_subref_r<T2> >
1813 concat(sc_bitref_r<T1> a, sc_subref_r<T2> b)
1814 {
1815  return sc_concref_r<sc_bitref_r<T1>, sc_subref_r<T2> >(
1816  *a.clone(), *b.clone(), 3);
1817 }
1818 
1819 template <class T1, class T2, class T3>
1820 inline sc_concref_r<sc_bitref_r<T1>, sc_concref_r<T2, T3> >
1821 concat(sc_bitref_r<T1> a, sc_concref_r<T2, T3> b)
1822 {
1823  return sc_concref_r<sc_bitref_r<T1>, sc_concref_r<T2, T3> >(
1824  *a.clone(), *b.clone(), 3);
1825 }
1826 
1827 template <class T1, class T2>
1828 inline sc_concref_r<sc_bitref_r<T1>, T2>
1829 concat(sc_bitref_r<T1> a, const sc_proxy<T2> &b)
1830 {
1831  return sc_concref_r<sc_bitref_r<T1>, T2>(
1832  *a.clone(), b.back_cast(), 1);
1833 }
1834 
1835 
1836 template <class T1, class T2>
1837 inline sc_concref_r<sc_bitref_r<T1>, sc_bitref_r<T2> >
1838 operator , (sc_bitref_r<T1> a, sc_bitref<T2> b)
1839 {
1840  return sc_concref_r<sc_bitref_r<T1>, sc_bitref_r<T2> >(
1841  *a.clone(), *b.clone(), 3);
1842 }
1843 
1844 template <class T1, class T2>
1845 inline sc_concref_r<sc_bitref_r<T1>, sc_bitref_r<T2> >
1846 operator , (sc_bitref<T1> a, sc_bitref_r<T2> b)
1847 {
1848  return sc_concref_r<sc_bitref_r<T1>, sc_bitref_r<T2> >(
1849  *a.clone(), *b.clone(), 3);
1850 }
1851 
1852 template <class T1, class T2>
1853 inline sc_concref_r<sc_bitref_r<T1>, sc_subref_r<T2> >
1854 operator , (sc_bitref_r<T1> a, sc_subref<T2> b)
1855 {
1856  return sc_concref_r<sc_bitref_r<T1>, sc_subref_r<T2> >(
1857  *a.clone(), *b.clone(), 3);
1858 }
1859 
1860 template <class T1, class T2>
1861 inline sc_concref_r<sc_bitref_r<T1>, sc_subref_r<T2> >
1862 operator , (sc_bitref<T1> a, sc_subref_r<T2> b)
1863 {
1864  return sc_concref_r<sc_bitref_r<T1>, sc_subref_r<T2> >(
1865  *a.clone(), *b.clone(), 3);
1866 }
1867 
1868 template <class T1, class T2, class T3>
1869 inline sc_concref_r<sc_bitref_r<T1>, sc_concref_r<T2, T3> >
1870 operator , (sc_bitref_r<T1> a, sc_concref<T2, T3> b)
1871 {
1872  return sc_concref_r<sc_bitref_r<T1>, sc_concref_r<T2, T3> >(
1873  *a.clone(), *b.clone(), 3);
1874 }
1875 
1876 template <class T1, class T2, class T3>
1877 inline sc_concref_r<sc_bitref_r<T1>, sc_concref_r<T2, T3> >
1878 operator , (sc_bitref<T1> a, sc_concref_r<T2, T3> b)
1879 {
1880  return sc_concref_r<sc_bitref_r<T1>, sc_concref_r<T2, T3> >(
1881  *a.clone(), *b.clone(), 3);
1882 }
1883 
1884 template <class T1, class T2>
1885 inline sc_concref_r<sc_bitref_r<T1>, T2>
1886 operator , (sc_bitref<T1> a, const sc_proxy<T2> &b)
1887 {
1888  return sc_concref_r<sc_bitref_r<T1>, T2>(
1889  *a.clone(), b.back_cast(), 1);
1890 }
1891 
1892 template <class T1, class T2>
1893 inline sc_concref_r<sc_bitref_r<T1>, T2>
1894 operator , (sc_bitref_r<T1> a, sc_proxy<T2> &b)
1895 {
1896  return sc_concref_r<sc_bitref_r<T1>, T2>(
1897  *a.clone(), b.back_cast(), 1);
1898 }
1899 
1900 
1901 template <class T1, class T2>
1902 inline sc_concref_r<sc_bitref_r<T1>, sc_bitref_r<T2> >
1903 concat(sc_bitref_r<T1> a, sc_bitref<T2> b)
1904 {
1905  return sc_concref_r<sc_bitref_r<T1>, sc_bitref_r<T2> >(
1906  *a.clone(), *b.clone(), 3);
1907 }
1908 
1909 template <class T1, class T2>
1910 inline sc_concref_r<sc_bitref_r<T1>, sc_bitref_r<T2> >
1911 concat(sc_bitref<T1> a, sc_bitref_r<T2> b)
1912 {
1913  return sc_concref_r<sc_bitref_r<T1>, sc_bitref_r<T2> >(
1914  *a.clone(), *b.clone(), 3);
1915 }
1916 
1917 template <class T1, class T2>
1918 inline sc_concref_r<sc_bitref_r<T1>, sc_subref_r<T2> >
1919 concat(sc_bitref_r<T1> a, sc_subref<T2> b)
1920 {
1921  return sc_concref_r<sc_bitref_r<T1>, sc_subref_r<T2> >(
1922  *a.clone(), *b.clone(), 3);
1923 }
1924 
1925 template <class T1, class T2>
1926 inline sc_concref_r<sc_bitref_r<T1>, sc_subref_r<T2> >
1927 concat(sc_bitref<T1> a, sc_subref_r<T2> b)
1928 {
1929  return sc_concref_r<sc_bitref_r<T1>, sc_subref_r<T2> >(
1930  *a.clone(), *b.clone(), 3);
1931 }
1932 
1933 template <class T1, class T2, class T3>
1934 inline sc_concref_r<sc_bitref_r<T1>, sc_concref_r<T2, T3> >
1935 concat(sc_bitref_r<T1> a, sc_concref<T2, T3> b)
1936 {
1937  return sc_concref_r<sc_bitref_r<T1>, sc_concref_r<T2,T3> >(
1938  *a.clone(), *b.clone(), 3);
1939 }
1940 
1941 template <class T1, class T2, class T3>
1942 inline sc_concref_r<sc_bitref_r<T1>, sc_concref_r<T2, T3> >
1943 concat(sc_bitref<T1> a, sc_concref_r<T2, T3> b)
1944 {
1945  return sc_concref_r<sc_bitref_r<T1>, sc_concref_r<T2,T3> >(
1946  *a.clone(), *b.clone(), 3);
1947 }
1948 
1949 template <class T1, class T2>
1950 inline sc_concref_r<sc_bitref_r<T1>, T2>
1951 concat(sc_bitref<T1> a, const sc_proxy<T2> &b)
1952 {
1953  return sc_concref_r<sc_bitref_r<T1>, T2>(*a.clone(), b.back_cast(), 1);
1954 }
1955 
1956 template <class T1, class T2>
1957 inline sc_concref_r<sc_bitref_r<T1>, T2>
1958 concat(sc_bitref_r<T1> a, sc_proxy<T2> &b)
1959 {
1960  return sc_concref_r<sc_bitref_r<T1>, T2>(*a.clone(), b.back_cast(), 1);
1961 }
1962 
1963 
1964 // ----------------------------------------------------------------------------
1965 // CLASS TEMPLATE : sc_bitref<X>
1966 //
1967 // Proxy class for sc_proxy bit selection (r-value and l-value).
1968 // ----------------------------------------------------------------------------
1969 
1970 // assignment operators
1971 template <class X>
1972 inline sc_bitref<X> &
1973 sc_bitref<X>::operator = (const sc_bitref_r<X> &a)
1974 {
1975  this->m_obj.set_bit(this->m_index, a.value());
1976  return *this;
1977 }
1978 
1979 template <class X>
1980 inline sc_bitref<X> &
1981 sc_bitref<X>::operator = (const sc_bitref<X> &a)
1982 {
1983  if (&a != this) {
1984  this->m_obj.set_bit(this->m_index, a.value());
1985  }
1986  return *this;
1987 }
1988 
1989 
1990 // bitwise assignment operators
1991 template <class X>
1992 inline sc_bitref<X> &
1993 sc_bitref<X>::operator &= (const sc_bitref_r<X> &a)
1994 {
1995  if (&a != this) {
1996  this->m_obj.set_bit(
1997  this->m_index, sc_logic::and_table[this->value()][a.value()]);
1998  }
1999  return *this;
2000 }
2001 
2002 template <class X>
2003 inline sc_bitref<X> &
2004 sc_bitref<X>::operator &= (const sc_logic &a)
2005 {
2006  this->m_obj.set_bit(
2007  this->m_index, sc_logic::and_table[this->value()][a.value()]);
2008  return *this;
2009 }
2010 
2011 
2012 template <class X>
2013 inline sc_bitref<X> &
2014 sc_bitref<X>::operator |= (const sc_bitref_r<X> &a)
2015 {
2016  if (&a != this) {
2017  this->m_obj.set_bit(
2018  this->m_index, sc_logic::or_table[this->value()][a.value()]);
2019  }
2020  return *this;
2021 }
2022 
2023 template <class X>
2024 inline sc_bitref<X> &
2025 sc_bitref<X>::operator |= (const sc_logic &a)
2026 {
2027  this->m_obj.set_bit(
2028  this->m_index, sc_logic::or_table[this->value()][a.value()]);
2029  return *this;
2030 }
2031 
2032 
2033 template <class X>
2034 inline sc_bitref<X> &
2035 sc_bitref<X>::operator ^= (const sc_bitref_r<X> &a)
2036 {
2037  if (&a != this) {
2038  this->m_obj.set_bit(
2039  this->m_index, sc_logic::xor_table[this->value()][a.value()]);
2040  }
2041  return *this;
2042 }
2043 
2044 template <class X>
2045 inline sc_bitref<X> &
2046 sc_bitref<X>::operator ^= (const sc_logic &a)
2047 {
2048  this->m_obj.set_bit(
2049  this->m_index, sc_logic::xor_table[this->value()][a.value()]);
2050  return *this;
2051 }
2052 
2053 // bitwise operators and functions
2054 
2055 // bitwise complement
2056 template <class X>
2057 inline sc_bitref<X> &
2058 sc_bitref<X>::b_not()
2059 {
2060  this->m_obj.set_bit(this->m_index, sc_logic::not_table[this->value()]);
2061  return *this;
2062 }
2063 
2064 // common methods
2065 template <class X>
2066 inline void
2067 sc_bitref<X>::set_bit(int n, value_type value)
2068 {
2069  if (n == 0) {
2070  this->m_obj.set_bit(this->m_index, value);
2071  } else {
2072  SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, 0);
2073  }
2074 }
2075 
2076 template <class X>
2077 inline void
2078 sc_bitref<X>::set_word(int n, sc_digit w)
2079 {
2080  unsigned int bi = this->m_index % (8 * sizeof(sc_digit));
2081  sc_digit temp;
2082  unsigned int wi = this->m_index / (8 * sizeof(sc_digit));
2083  if (n == 0) {
2084  temp = this->m_obj.get_word(wi);
2085  temp = (temp & ~(1 << bi)) | ((w & 1) << bi);
2086  this->m_obj.set_word(wi, temp);
2087  } else {
2088  SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, 0);
2089  }
2090 }
2091 
2092 template <class X>
2093 inline void
2094 sc_bitref<X>::set_cword(int n, sc_digit w)
2095 {
2096  unsigned int bi = this->m_index % (8 * sizeof(sc_digit));
2097  sc_digit temp;
2098  unsigned int wi = this->m_index / (8 * sizeof(sc_digit));
2099  if (n == 0) {
2100  temp = this->m_obj.get_cword(wi);
2101  temp = (temp & ~(1 << bi)) | ((w & 1) << bi);
2102  this->m_obj.set_cword(wi, temp);
2103  } else {
2104  SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, 0);
2105  }
2106 }
2107 
2108 // other methods
2109 template <class X>
2110 inline void
2111 sc_bitref<X>::scan(::std::istream &is)
2112 {
2113  char c;
2114  is >> c;
2115  *this = c;
2116 }
2117 
2118 // l-value concatenation operators and functions
2119 template <class T1, class T2>
2120 inline sc_concref<sc_bitref<T1>, sc_bitref<T2> >
2121 operator , (sc_bitref<T1> a, sc_bitref<T2> b)
2122 {
2123  return sc_concref<sc_bitref<T1>, sc_bitref<T2> >(
2124  *a.clone(), *b.clone(), 3);
2125 }
2126 
2127 template <class T1, class T2>
2128 inline sc_concref<sc_bitref<T1>, sc_subref<T2> >
2129 operator , (sc_bitref<T1> a, sc_subref<T2> b)
2130 {
2131  return sc_concref<sc_bitref<T1>, sc_subref<T2> >(
2132  *a.clone(), *b.clone(), 3);
2133 }
2134 
2135 template <class T1, class T2, class T3>
2136 inline sc_concref<sc_bitref<T1>, sc_concref<T2, T3> >
2137 operator , (sc_bitref<T1> a, sc_concref<T2, T3> b)
2138 {
2139  return sc_concref<sc_bitref<T1>, sc_concref<T2, T3> >(
2140  *a.clone(), *b.clone(), 3);
2141 }
2142 
2143 template <class T1, class T2>
2144 inline sc_concref<sc_bitref<T1>, T2>
2145 operator , (sc_bitref<T1> a, sc_proxy<T2> &b)
2146 {
2147  return sc_concref<sc_bitref<T1>, T2>(*a.clone(), b.back_cast(), 1);
2148 }
2149 
2150 
2151 template <class T1, class T2>
2152 inline sc_concref<sc_bitref<T1>, sc_bitref<T2> >
2153 concat(sc_bitref<T1> a, sc_bitref<T2> b)
2154 {
2155  return sc_concref<sc_bitref<T1>, sc_bitref<T2> >(
2156  *a.clone(), *b.clone(), 3);
2157 }
2158 
2159 template <class T1, class T2>
2160 inline sc_concref<sc_bitref<T1>, sc_subref<T2> >
2161 concat(sc_bitref<T1> a, sc_subref<T2> b)
2162 {
2163  return sc_concref<sc_bitref<T1>, sc_subref<T2> >(
2164  *a.clone(), *b.clone(), 3);
2165 }
2166 
2167 template <class T1, class T2, class T3>
2168 inline sc_concref<sc_bitref<T1>, sc_concref<T2, T3> >
2169 concat(sc_bitref<T1> a, sc_concref<T2, T3> b)
2170 {
2171  return sc_concref<sc_bitref<T1>, sc_concref<T2,T3> >(
2172  *a.clone(), *b.clone(), 3);
2173 }
2174 
2175 template <class T1, class T2>
2176 inline sc_concref<sc_bitref<T1>, T2>
2177 concat(sc_bitref<T1> a, sc_proxy<T2> &b)
2178 {
2179  return sc_concref<sc_bitref<T1>, T2>(*a.clone(), b.back_cast(), 1);
2180 }
2181 
2182 template <class X>
2183 inline ::std::istream &
2184 operator >> (::std::istream &is, sc_bitref<X> a)
2185 {
2186  a.scan(is);
2187  return is;
2188 }
2189 
2190 
2191 // ----------------------------------------------------------------------------
2192 // CLASS TEMPLATE : sc_subref_r<X>
2193 //
2194 // Proxy class for sc_proxy part selection (r-value only).
2195 // ----------------------------------------------------------------------------
2196 
2197 template <class X>
2198 inline void
2199 sc_subref_r<X>::check_bounds()
2200 {
2201  int len = m_obj.length();
2202  if (m_hi < 0 || m_hi >= len || m_lo < 0 || m_lo >= len) {
2203  SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, 0);
2204  sc_core::sc_abort(); // can't recover from here
2205  }
2206  if (reversed()) {
2207  m_len = m_lo - m_hi + 1;
2208  } else {
2209  m_len = m_hi - m_lo + 1;
2210  }
2211 }
2212 
2213 // common methods
2214 template <class X>
2215 inline typename sc_subref_r<X>::value_type
2216 sc_subref_r<X>::get_bit(int n) const
2217 {
2218  if (reversed()) {
2219  return m_obj.get_bit(m_lo - n);
2220  } else {
2221  return m_obj.get_bit(m_lo + n);
2222  }
2223 }
2224 
2225 template <class X>
2226 inline void
2227 sc_subref_r<X>::set_bit(int n, value_type value)
2228 {
2229  if (reversed()) {
2230  m_obj.set_bit(m_lo - n, value);
2231  } else {
2232  m_obj.set_bit(m_lo + n, value);
2233  }
2234 }
2235 
2236 template <class X>
2237 inline sc_digit
2238 sc_subref_r<X>::get_word(int i) const
2239 {
2240  int n1 = 0;
2241  int n2 = 0;
2242  sc_digit result = 0;
2243  int k = 0;
2244  if (reversed()) {
2245  n1 = m_lo - i * SC_DIGIT_SIZE;
2246  n2 = sc_max(n1 - SC_DIGIT_SIZE, m_hi - 1);
2247  for (int n = n1; n > n2; n--) {
2248  result |= (m_obj[n].value() & SC_DIGIT_ONE) << k++;
2249  }
2250  } else {
2251  n1 = m_lo + i * SC_DIGIT_SIZE;
2252  n2 = sc_min(n1 + SC_DIGIT_SIZE, m_hi + 1);
2253  for (int n = n1; n < n2; n++) {
2254  result |= (m_obj[n].value() & SC_DIGIT_ONE) << k++;
2255  }
2256  }
2257  return result;
2258 }
2259 
2260 template <class X>
2261 inline void
2262 sc_subref_r<X>::set_word(int i, sc_digit w)
2263 {
2264  int n1 = 0;
2265  int n2 = 0;
2266  int k = 0;
2267  if (reversed()) {
2268  n1 = m_lo - i * SC_DIGIT_SIZE;
2269  n2 = sc_max(n1 - SC_DIGIT_SIZE, m_hi - 1);
2270  for (int n = n1; n > n2; n--) {
2271  m_obj.set_bit(n, value_type(
2272  ((w >> k++) & SC_DIGIT_ONE) |
2273  (m_obj[n].value() & SC_DIGIT_TWO)));
2274  }
2275  } else {
2276  n1 = m_lo + i * SC_DIGIT_SIZE;
2277  n2 = sc_min(n1 + SC_DIGIT_SIZE, m_hi + 1);
2278  for (int n = n1; n < n2; n++) {
2279  m_obj.set_bit(n, value_type(
2280  ((w >> k++) & SC_DIGIT_ONE) |
2281  (m_obj[n].value() & SC_DIGIT_TWO)));
2282  }
2283  }
2284 }
2285 
2286 
2287 template <class X>
2288 inline sc_digit
2289 sc_subref_r<X>::get_cword(int i) const
2290 {
2291  int n1 = 0;
2292  int n2 = 0;
2293  sc_digit result = 0;
2294  int k = 0;
2295  if (reversed()) {
2296  n1 = m_lo - i * SC_DIGIT_SIZE;
2297  n2 = sc_max(n1 - SC_DIGIT_SIZE, m_hi - 1);
2298  for (int n = n1; n > n2; n--) {
2299  result |= ((m_obj[n].value() & SC_DIGIT_TWO) >> 1) << k++;
2300  }
2301  } else {
2302  n1 = m_lo + i * SC_DIGIT_SIZE;
2303  n2 = sc_min(n1 + SC_DIGIT_SIZE, m_hi + 1);
2304  for (int n = n1; n < n2; n++) {
2305  result |= ((m_obj[n].value() & SC_DIGIT_TWO) >> 1) << k++;
2306  }
2307  }
2308  return result;
2309 }
2310 
2311 template <class X>
2312 inline void
2313 sc_subref_r<X>::set_cword(int i, sc_digit w)
2314 {
2315  int n1 = 0;
2316  int n2 = 0;
2317  int k = 0;
2318  if (reversed()) {
2319  n1 = m_lo - i * SC_DIGIT_SIZE;
2320  n2 = sc_max(n1 - SC_DIGIT_SIZE, m_hi - 1);
2321  for (int n = n1; n > n2; n--) {
2322  m_obj.set_bit(n, value_type(
2323  (((w >> k++) & SC_DIGIT_ONE) << 1) |
2324  (m_obj[n].value() & SC_DIGIT_ONE)));
2325  }
2326  } else {
2327  n1 = m_lo + i * SC_DIGIT_SIZE;
2328  n2 = sc_min(n1 + SC_DIGIT_SIZE, m_hi + 1);
2329  for (int n = n1; n < n2; n++) {
2330  m_obj.set_bit(n, value_type(
2331  (((w >> k++) & SC_DIGIT_ONE) << 1) |
2332  (m_obj[n].value() & SC_DIGIT_ONE)));
2333  }
2334  }
2335 }
2336 
2337 // other methods
2338 template <class X>
2339 inline bool
2340 sc_subref_r<X>::is_01() const
2341 {
2342  int sz = size();
2343  for (int i = 0; i < sz; ++i) {
2344  if (get_cword(i) != SC_DIGIT_ZERO) {
2345  return false;
2346  }
2347  }
2348  return true;
2349 }
2350 
2351 // r-value concatenation operators and functions
2352 template <class T1, class T2>
2353 inline sc_concref_r<sc_subref_r<T1>, sc_bitref_r<T2> >
2354 operator , (sc_subref_r<T1> a, sc_bitref_r<T2> b)
2355 {
2356  return sc_concref_r<sc_subref_r<T1>, sc_bitref_r<T2> >(
2357  *a.clone(), *b.clone(), 3);
2358 }
2359 
2360 template <class T1, class T2>
2361 inline sc_concref_r<sc_subref_r<T1>, sc_subref_r<T2> >
2362 operator , (sc_subref_r<T1> a, sc_subref_r<T2> b)
2363 {
2364  return sc_concref_r<sc_subref_r<T1>, sc_subref_r<T2> >(
2365  *a.clone(), *b.clone(), 3);
2366 }
2367 
2368 template <class T1, class T2, class T3>
2369 inline sc_concref_r<sc_subref_r<T1>, sc_concref_r<T2, T3> >
2370 operator , (sc_subref_r<T1> a, sc_concref_r<T2, T3> b)
2371 {
2372  return sc_concref_r<sc_subref_r<T1>, sc_concref_r<T2, T3> >(
2373  *a.clone(), *b.clone(), 3);
2374 }
2375 
2376 template <class T1, class T2>
2377 inline sc_concref_r<sc_subref_r<T1>, T2>
2378 operator , (sc_subref_r<T1> a, const sc_proxy<T2> &b)
2379 {
2380  return sc_concref_r<sc_subref_r<T1>, T2>(
2381  *a.clone(), b.back_cast(), 1);
2382 }
2383 
2384 
2385 template <class T1, class T2>
2386 inline sc_concref_r<sc_subref_r<T1>, sc_bitref_r<T2> >
2387 concat(sc_subref_r<T1> a, sc_bitref_r<T2> b)
2388 {
2389  return sc_concref_r<sc_subref_r<T1>, sc_bitref_r<T2> >(
2390  *a.clone(), *b.clone(), 3);
2391 }
2392 
2393 template <class T1, class T2>
2394 inline sc_concref_r<sc_subref_r<T1>, sc_subref_r<T2> >
2395 concat(sc_subref_r<T1> a, sc_subref_r<T2> b)
2396 {
2397  return sc_concref_r<sc_subref_r<T1>, sc_subref_r<T2> >(
2398  *a.clone(), *b.clone(), 3);
2399 }
2400 
2401 template <class T1, class T2, class T3>
2402 inline sc_concref_r<sc_subref_r<T1>, sc_concref_r<T2, T3> >
2403 concat(sc_subref_r<T1> a, sc_concref_r<T2, T3> b)
2404 {
2405  return sc_concref_r<sc_subref_r<T1>, sc_concref_r<T2, T3> >(
2406  *a.clone(), *b.clone(), 3);
2407 }
2408 
2409 template <class T1, class T2>
2410 inline sc_concref_r<sc_subref_r<T1>, T2>
2411 concat(sc_subref_r<T1> a, const sc_proxy<T2> &b)
2412 {
2413  return sc_concref_r<sc_subref_r<T1>, T2>(*a.clone(), b.back_cast(), 1);
2414 }
2415 
2416 
2417 template <class T1, class T2>
2418 inline sc_concref_r<sc_subref_r<T1>, sc_bitref_r<T2> >
2419 operator , (sc_subref_r<T1> a, sc_bitref<T2> b)
2420 {
2421  return sc_concref_r<sc_subref_r<T1>, sc_bitref_r<T2> >(
2422  *a.clone(), *b.clone(), 3);
2423 }
2424 
2425 template <class T1, class T2>
2426 inline sc_concref_r<sc_subref_r<T1>, sc_bitref_r<T2> >
2427 operator , (sc_subref<T1> a, sc_bitref_r<T2> b)
2428 {
2429  return sc_concref_r<sc_subref_r<T1>, sc_bitref_r<T2> >(
2430  *a.clone(), *b.clone(), 3);
2431 }
2432 
2433 template <class T1, class T2>
2434 inline sc_concref_r<sc_subref_r<T1>, sc_subref_r<T2> >
2435 operator , (sc_subref_r<T1> a, sc_subref<T2> b)
2436 {
2437  return sc_concref_r<sc_subref_r<T1>, sc_subref_r<T2> >(
2438  *a.clone(), *b.clone(), 3);
2439 }
2440 
2441 template <class T1, class T2>
2442 inline sc_concref_r<sc_subref_r<T1>, sc_subref_r<T2> >
2443 operator , (sc_subref<T1> a, sc_subref_r<T2> b)
2444 {
2445  return sc_concref_r<sc_subref_r<T1>, sc_subref_r<T2> >(
2446  *a.clone(), *b.clone(), 3);
2447 }
2448 
2449 template <class T1, class T2, class T3>
2450 inline
2451 sc_concref_r<sc_subref_r<T1>, sc_concref_r<T2, T3> >
2452 operator , (sc_subref_r<T1> a, sc_concref<T2, T3> b)
2453 {
2454  return sc_concref_r<sc_subref_r<T1>, sc_concref_r<T2, T3> >(
2455  *a.clone(), *b.clone(), 3);
2456 }
2457 
2458 template <class T1, class T2, class T3>
2459 inline sc_concref_r<sc_subref_r<T1>, sc_concref_r<T2, T3> >
2460 operator , (sc_subref<T1> a, sc_concref_r<T2, T3> b)
2461 {
2462  return sc_concref_r<sc_subref_r<T1>, sc_concref_r<T2, T3> >(
2463  *a.clone(), *b.clone(), 3);
2464 }
2465 
2466 template <class T1, class T2>
2467 inline sc_concref_r<sc_subref_r<T1>, T2>
2468 operator , (sc_subref<T1> a, const sc_proxy<T2> &b)
2469 {
2470  return sc_concref_r<sc_subref_r<T1>, T2>(*a.clone(), b.back_cast(), 1);
2471 }
2472 
2473 template <class T1, class T2>
2474 inline sc_concref_r<sc_subref_r<T1>, T2>
2475 operator , (sc_subref_r<T1> a, sc_proxy<T2> &b)
2476 {
2477  return sc_concref_r<sc_subref_r<T1>, T2>(*a.clone(), b.back_cast(), 1);
2478 }
2479 
2480 
2481 template <class T1, class T2>
2482 inline sc_concref_r<sc_subref_r<T1>, sc_bitref_r<T2> >
2483 concat(sc_subref_r<T1> a, sc_bitref<T2> b)
2484 {
2485  return sc_concref_r<sc_subref_r<T1>, sc_bitref_r<T2> >(
2486  *a.clone(), *b.clone(), 3);
2487 }
2488 
2489 template <class T1, class T2>
2490 inline sc_concref_r<sc_subref_r<T1>, sc_bitref_r<T2> >
2491 concat(sc_subref<T1> a, sc_bitref_r<T2> b)
2492 {
2493  return sc_concref_r<sc_subref_r<T1>, sc_bitref_r<T2> >(
2494  *a.clone(), *b.clone(), 3);
2495 }
2496 
2497 template <class T1, class T2>
2498 inline sc_concref_r<sc_subref_r<T1>, sc_subref_r<T2> >
2499 concat(sc_subref_r<T1> a, sc_subref<T2> b)
2500 {
2501  return sc_concref_r<sc_subref_r<T1>, sc_subref_r<T2> >(
2502  *a.clone(), *b.clone(), 3);
2503 }
2504 
2505 template <class T1, class T2>
2506 inline sc_concref_r<sc_subref_r<T1>, sc_subref_r<T2> >
2507 concat(sc_subref<T1> a, sc_subref_r<T2> b)
2508 {
2509  return sc_concref_r<sc_subref_r<T1>, sc_subref_r<T2> >(
2510  *a.clone(), *b.clone(), 3);
2511 }
2512 
2513 template <class T1, class T2, class T3>
2514 inline sc_concref_r<sc_subref_r<T1>, sc_concref_r<T2, T3> >
2515 concat(sc_subref_r<T1> a, sc_concref<T2, T3> b)
2516 {
2517  return sc_concref_r<sc_subref_r<T1>, sc_concref_r<T2, T3> >(
2518  *a.clone(), *b.clone(), 3);
2519 }
2520 
2521 template <class T1, class T2, class T3>
2522 inline sc_concref_r<sc_subref_r<T1>, sc_concref_r<T2, T3> >
2523 concat(sc_subref<T1> a, sc_concref_r<T2, T3> b)
2524 {
2525  return sc_concref_r<sc_subref_r<T1>, sc_concref_r<T2, T3> >(
2526  *a.clone(), *b.clone(), 3);
2527 }
2528 
2529 template <class T1, class T2>
2530 inline sc_concref_r<sc_subref_r<T1>, T2>
2531 concat(sc_subref<T1> a, const sc_proxy<T2> &b)
2532 {
2533  return sc_concref_r<sc_subref_r<T1>, T2>(*a.clone(), b.back_cast(), 1);
2534 }
2535 
2536 template <class T1, class T2>
2537 inline sc_concref_r<sc_subref_r<T1>, T2>
2538 concat(sc_subref_r<T1> a, sc_proxy<T2> &b)
2539 {
2540  return sc_concref_r<sc_subref_r<T1>, T2>(*a.clone(), b.back_cast(), 1);
2541 }
2542 
2543 
2544 // ----------------------------------------------------------------------------
2545 // CLASS TEMPLATE : sc_subref<X>
2546 //
2547 // Proxy class for sc_proxy part selection (r-value and l-value).
2548 // ----------------------------------------------------------------------------
2549 
2550 // assignment operators
2551 // sc_subref<X>::operator = ( const sc_subref_r<X>& ) in sc_lv_base.h
2552 // sc_subref<X>::operator = ( const sc_subref<X>& ) in sc_lv_base.h
2553 
2554 // other methods
2555 template <class T>
2556 inline void
2557 sc_subref<T>::scan(::std::istream &is)
2558 {
2559  std::string s;
2560  is >> s;
2561  *this = s.c_str();
2562 }
2563 
2564 // l-value concatenation operators and functions
2565 template <class T1, class T2>
2566 inline
2567 sc_concref<sc_subref<T1>, sc_bitref<T2> >
2568 operator , (sc_subref<T1> a, sc_bitref<T2> b)
2569 {
2570  return sc_concref<sc_subref<T1>, sc_bitref<T2> >(
2571  *a.clone(), *b.clone(), 3);
2572 }
2573 
2574 template <class T1, class T2>
2575 inline sc_concref<sc_subref<T1>, sc_subref<T2> >
2576 operator , (sc_subref<T1> a, sc_subref<T2> b)
2577 {
2578  return sc_concref<sc_subref<T1>, sc_subref<T2> >(
2579  *a.clone(), *b.clone(), 3);
2580 }
2581 
2582 template <class T1, class T2, class T3>
2583 inline sc_concref<sc_subref<T1>, sc_concref<T2,T3> >
2584 operator , (sc_subref<T1> a, sc_concref<T2, T3> b)
2585 {
2586  return sc_concref<sc_subref<T1>, sc_concref<T2, T3> >(
2587  *a.clone(), *b.clone(), 3);
2588 }
2589 
2590 template <class T1, class T2>
2591 inline sc_concref<sc_subref<T1>, T2>
2592 operator , (sc_subref<T1> a, sc_proxy<T2> &b)
2593 {
2594  return sc_concref<sc_subref<T1>, T2>(*a.clone(), b.back_cast(), 1);
2595 }
2596 
2597 
2598 template <class T1, class T2>
2599 inline sc_concref<sc_subref<T1>, sc_bitref<T2> >
2600 concat(sc_subref<T1> a, sc_bitref<T2> b)
2601 {
2602  return sc_concref<sc_subref<T1>, sc_bitref<T2> >(
2603  *a.clone(), *b.clone(), 3);
2604 }
2605 
2606 template <class T1, class T2>
2607 inline sc_concref<sc_subref<T1>, sc_subref<T2> >
2608 concat(sc_subref<T1> a, sc_subref<T2> b)
2609 {
2610  return sc_concref<sc_subref<T1>, sc_subref<T2> >(
2611  *a.clone(), *b.clone(), 3);
2612 }
2613 
2614 template <class T1, class T2, class T3>
2615 inline sc_concref<sc_subref<T1>, sc_concref<T2, T3> >
2616 concat(sc_subref<T1> a, sc_concref<T2, T3> b)
2617 {
2618  return sc_concref<sc_subref<T1>, sc_concref<T2, T3> >(
2619  *a.clone(), *b.clone(), 3);
2620 }
2621 
2622 template <class T1, class T2>
2623 inline sc_concref<sc_subref<T1>, T2>
2624 concat(sc_subref<T1> a, sc_proxy<T2> &b)
2625 {
2626  return sc_concref<sc_subref<T1>, T2>(*a.clone(), b.back_cast(), 1);
2627 }
2628 
2629 template <class X>
2630 inline ::std::istream &
2631 operator >> (::std::istream &is, sc_subref<X> a)
2632 {
2633  a.scan(is);
2634  return is;
2635 }
2636 
2637 // ----------------------------------------------------------------------------
2638 // CLASS TEMPLATE : sc_concref_r<X,Y>
2639 //
2640 // Proxy class for sc_proxy concatenation (r-value only).
2641 // ----------------------------------------------------------------------------
2642 
2643 // destructor
2644 template <class X, class Y>
2645 inline sc_concref_r<X, Y>::~sc_concref_r()
2646 {
2647  if (--m_refs == 0) {
2648  delete &m_refs;
2649  if (m_delete == 0) {
2650  return;
2651  }
2652  if (m_delete & 1) {
2653  delete &m_left;
2654  }
2655  if (m_delete & 2) {
2656  delete &m_right;
2657  }
2658  }
2659 }
2660 
2661 // common methods
2662 template <class X, class Y>
2663 inline typename sc_concref_r<X, Y>::value_type
2664 sc_concref_r<X, Y>::get_bit(int n) const
2665 {
2666  int r_len = m_right.length();
2667  if (n < r_len) {
2668  return value_type(m_right.get_bit(n));
2669  } else if (n < r_len + m_left.length()) {
2670  return value_type(m_left.get_bit(n - r_len));
2671  } else {
2672  SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, 0);
2673  return Log_0;
2674  }
2675 }
2676 
2677 template <class X, class Y>
2678 inline void
2679 sc_concref_r<X, Y>::set_bit(int n, value_type v)
2680 {
2681  int r_len = m_right.length();
2682  if (n < r_len) {
2683  m_right.set_bit(n, typename Y::value_type(v));
2684  } else if (n < r_len + m_left.length()) {
2685  m_left.set_bit(n - r_len, typename X::value_type(v));
2686  } else {
2687  SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, 0);
2688  }
2689 }
2690 
2691 template <class X, class Y>
2692 inline sc_digit
2693 sc_concref_r<X, Y>::get_word(int i) const
2694 {
2695  if (i < 0 || i >= size()) {
2696  SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, 0);
2697  }
2698  // 0 <= i < size()
2699  Y &r = m_right;
2700  int r_len = r.length();
2701  int border = r_len / SC_DIGIT_SIZE;
2702  if (i < border) {
2703  return r.get_word(i);
2704  }
2705  // border <= i < size()
2706  X& l = m_left;
2707  int shift = r_len % SC_DIGIT_SIZE;
2708  int j = i - border;
2709  if (shift == 0) {
2710  return l.get_word(j);
2711  }
2712  // border <= i < size() && shift != 0
2713  int nshift = SC_DIGIT_SIZE - shift;
2714  if (i == border) {
2715  sc_digit rl_mask = ~SC_DIGIT_ZERO >> nshift;
2716  return ((r.get_word(i) & rl_mask) | (l.get_word(0) << shift));
2717  }
2718  // border < i < size() && shift != 0
2719  if (j < l.size())
2720  return ((l.get_word(j - 1) >> nshift) | (l.get_word(j) << shift));
2721  else
2722  return (l.get_word(j - 1) >> nshift);
2723 }
2724 
2725 template <class X, class Y>
2726 inline void
2727 sc_concref_r<X, Y>::set_word(int i, sc_digit w)
2728 {
2729  if (i < 0 || i >= size()) {
2730  SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, 0);
2731  }
2732  // 0 <= i < size()
2733  Y &r = m_right;
2734  int r_len = r.length();
2735  int border = r_len / SC_DIGIT_SIZE;
2736  if (i < border) {
2737  r.set_word(i, w);
2738  return;
2739  }
2740  // border <= i < size()
2741  X &l = m_left;
2742  int shift = r_len % SC_DIGIT_SIZE;
2743  int j = i - border;
2744  if (shift == 0) {
2745  l.set_word(j, w);
2746  return;
2747  }
2748  // border <= i < size() && shift != 0
2749  int nshift = SC_DIGIT_SIZE - shift;
2750  sc_digit lh_mask = ~SC_DIGIT_ZERO << nshift;
2751  if (i == border) {
2752  sc_digit rl_mask = ~SC_DIGIT_ZERO >> nshift;
2753  r.set_word(i, w & rl_mask);
2754  l.set_word(0, (l.get_word(0) & lh_mask) | (w >> shift));
2755  return;
2756  }
2757  // border < i < size() && shift != 0
2758  sc_digit ll_mask = ~SC_DIGIT_ZERO >> shift;
2759  l.set_word(j - 1, (l.get_word(j - 1) & ll_mask) | (w << nshift));
2760  if (j < l.size())
2761  l.set_word(j, (l.get_word(j) & lh_mask) | (w >> shift));
2762 }
2763 
2764 template <class X, class Y>
2765 inline sc_digit
2766 sc_concref_r<X, Y>::get_cword(int i) const
2767 {
2768  if (i < 0 || i >= size()) {
2769  SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, 0);
2770  }
2771  // 0 <= i < size()
2772  Y &r = m_right;
2773  int r_len = r.length();
2774  int border = r_len / SC_DIGIT_SIZE;
2775  if (i < border) {
2776  return r.get_cword(i);
2777  }
2778  // border <= i < size()
2779  X &l = m_left;
2780  int shift = r_len % SC_DIGIT_SIZE;
2781  int j = i - border;
2782  if (shift == 0) {
2783  return l.get_cword(j);
2784  }
2785  // border <= i < size() && shift != 0
2786  int nshift = SC_DIGIT_SIZE - shift;
2787  if (i == border) {
2788  sc_digit rl_mask = ~SC_DIGIT_ZERO >> nshift;
2789  return ((r.get_cword(i) & rl_mask) | (l.get_cword(0) << shift));
2790  }
2791  // border < i < size() && shift != 0
2792  if (j < l.size())
2793  return ((l.get_cword(j - 1) >> nshift) | (l.get_cword(j) << shift));
2794  else
2795  return (l.get_cword( j - 1 ) >> nshift);
2796 }
2797 
2798 template <class X, class Y>
2799 inline void
2800 sc_concref_r<X, Y>::set_cword(int i, sc_digit w)
2801 {
2802  if (i < 0 || i >= size()) {
2803  SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, 0);
2804  }
2805  // 0 <= i < size()
2806  Y &r = m_right;
2807  int r_len = r.length();
2808  int border = r_len / SC_DIGIT_SIZE;
2809  if (i < border) {
2810  r.set_cword(i, w);
2811  return;
2812  }
2813  // border <= i < size()
2814  X &l = m_left;
2815  int shift = r_len % SC_DIGIT_SIZE;
2816  int j = i - border;
2817  if (shift == 0) {
2818  l.set_cword(j, w);
2819  return;
2820  }
2821  // border <= i < size() && shift != 0
2822  int nshift = SC_DIGIT_SIZE - shift;
2823  sc_digit lh_mask = ~SC_DIGIT_ZERO << nshift;
2824  if (i == border) {
2825  sc_digit rl_mask = ~SC_DIGIT_ZERO >> nshift;
2826  r.set_cword(i, w & rl_mask);
2827  l.set_cword(0, (l.get_cword(0) & lh_mask) | (w >> shift));
2828  return;
2829  }
2830  // border < i < size() && shift != 0
2831  sc_digit ll_mask = ~SC_DIGIT_ZERO >> shift;
2832  l.set_cword(j - 1, (l.get_cword(j - 1) & ll_mask) | (w << nshift));
2833  if (j < l.size())
2834  l.set_cword(j, (l.get_cword(j) & lh_mask) | (w >> shift));
2835 }
2836 
2837 // r-value concatenation operators and functions
2838 template <class T1, class T2, class T3>
2839 inline sc_concref_r<sc_concref_r<T1, T2>,sc_bitref_r<T3> >
2840 operator , (sc_concref_r<T1, T2> a, sc_bitref_r<T3> b)
2841 {
2842  return sc_concref_r<sc_concref_r<T1, T2>,sc_bitref_r<T3> >(
2843  *a.clone(), *b.clone(), 3);
2844 }
2845 
2846 template <class T1, class T2, class T3>
2847 inline sc_concref_r<sc_concref_r<T1, T2>, sc_subref_r<T3> >
2848 operator , (sc_concref_r<T1, T2> a, sc_subref_r<T3> b)
2849 {
2850  return sc_concref_r<sc_concref_r<T1, T2>, sc_subref_r<T3> >(
2851  *a.clone(), *b.clone(), 3);
2852 }
2853 
2854 template <class T1, class T2, class T3, class T4>
2855 inline sc_concref_r<sc_concref_r<T1, T2>, sc_concref_r<T3, T4> >
2856 operator , (sc_concref_r<T1, T2> a, sc_concref_r<T3, T4> b)
2857 {
2858  return sc_concref_r<sc_concref_r<T1, T2>,sc_concref_r<T3, T4> >(
2859  *a.clone(), *b.clone(), 3);
2860 }
2861 
2862 template <class T1, class T2, class T3>
2863 inline sc_concref_r<sc_concref_r<T1, T2>, T3>
2864 operator , (sc_concref_r<T1, T2> a, const sc_proxy<T3> &b)
2865 {
2866  return sc_concref_r<sc_concref_r<T1, T2>, T3>(
2867  *a.clone(), b.back_cast(), 1);
2868 }
2869 
2870 
2871 template <class T1, class T2, class T3>
2872 inline sc_concref_r<sc_concref_r<T1, T2>, sc_bitref_r<T3> >
2873 concat(sc_concref_r<T1, T2> a, sc_bitref_r<T3> b)
2874 {
2875  return sc_concref_r<sc_concref_r<T1, T2>, sc_bitref_r<T3> >(
2876  *a.clone(), *b.clone(), 3);
2877 }
2878 
2879 template <class T1, class T2, class T3>
2880 inline sc_concref_r<sc_concref_r<T1, T2>, sc_subref_r<T3> >
2881 concat(sc_concref_r<T1, T2> a, sc_subref_r<T3> b)
2882 {
2883  return sc_concref_r<sc_concref_r<T1, T2>, sc_subref_r<T3> >(
2884  *a.clone(), *b.clone(), 3);
2885 }
2886 
2887 template <class T1, class T2, class T3, class T4>
2888 inline sc_concref_r<sc_concref_r<T1, T2>, sc_concref_r<T3, T4> >
2889 concat(sc_concref_r<T1, T2> a, sc_concref_r<T3, T4> b)
2890 {
2891  return sc_concref_r<sc_concref_r<T1, T2>, sc_concref_r<T3, T4> >(
2892  *a.clone(), *b.clone(), 3);
2893 }
2894 
2895 template <class T1, class T2, class T3>
2896 inline sc_concref_r<sc_concref_r<T1, T2>, T3>
2897 concat(sc_concref_r<T1, T2> a, const sc_proxy<T3> &b)
2898 {
2899  return sc_concref_r<sc_concref_r<T1, T2>, T3>(
2900  *a.clone(), b.back_cast(), 1);
2901 }
2902 
2903 
2904 template <class T1, class T2, class T3>
2905 inline sc_concref_r<sc_concref_r<T1, T2>, sc_bitref_r<T3> >
2906 operator , (sc_concref_r<T1, T2> a, sc_bitref<T3> b)
2907 {
2908  return sc_concref_r<sc_concref_r<T1, T2>, sc_bitref_r<T3> >(
2909  *a.clone(), *b.clone(), 3);
2910 }
2911 
2912 template <class T1, class T2, class T3>
2913 inline sc_concref_r<sc_concref_r<T1, T2>, sc_bitref_r<T3> >
2914 operator , (sc_concref<T1, T2> a, sc_bitref_r<T3> b)
2915 {
2916  return sc_concref_r<sc_concref_r<T1, T2>, sc_bitref_r<T3> >(
2917  *a.clone(), *b.clone(), 3);
2918 }
2919 
2920 template <class T1, class T2, class T3>
2921 inline
2922 sc_concref_r<sc_concref_r<T1, T2>, sc_subref_r<T3> >
2923 operator , (sc_concref_r<T1, T2> a, sc_subref<T3> b)
2924 {
2925  return sc_concref_r<sc_concref_r<T1, T2>, sc_subref_r<T3> >(
2926  *a.clone(), *b.clone(), 3);
2927 }
2928 
2929 template <class T1, class T2, class T3>
2930 inline sc_concref_r<sc_concref_r<T1, T2>, sc_subref_r<T3> >
2931 operator , (sc_concref<T1, T2> a, sc_subref_r<T3> b)
2932 {
2933  return sc_concref_r<sc_concref_r<T1, T2>, sc_subref_r<T3> >(
2934  *a.clone(), *b.clone(), 3);
2935 }
2936 
2937 template <class T1, class T2, class T3, class T4>
2938 inline sc_concref_r<sc_concref_r<T1, T2>, sc_concref_r<T3, T4> >
2939 operator , (sc_concref_r<T1, T2> a, sc_concref<T3, T4> b)
2940 {
2941  return sc_concref_r<sc_concref_r<T1, T2>, sc_concref_r<T3, T4> >(
2942  *a.clone(), *b.clone(), 3);
2943 }
2944 
2945 template <class T1, class T2, class T3, class T4>
2946 inline sc_concref_r<sc_concref_r<T1, T2>, sc_concref_r<T3, T4> >
2947 operator , (sc_concref<T1, T2> a, sc_concref_r<T3, T4> b)
2948 {
2949  return sc_concref_r<sc_concref_r<T1, T2>, sc_concref_r<T3, T4> >(
2950  *a.clone(), *b.clone(), 3);
2951 }
2952 
2953 template <class T1, class T2, class T3>
2954 inline sc_concref_r<sc_concref_r<T1, T2>, T3>
2955 operator , (sc_concref<T1, T2> a, const sc_proxy<T3> &b)
2956 {
2957  return sc_concref_r<sc_concref_r<T1, T2>, T3>(
2958  *a.clone(), b.back_cast(), 1);
2959 }
2960 
2961 template <class T1, class T2, class T3>
2962 inline sc_concref_r<sc_concref_r<T1, T2>, T3>
2963 operator , (sc_concref_r<T1, T2> a, sc_proxy<T3> &b)
2964 {
2965  return sc_concref_r<sc_concref_r<T1, T2>, T3>(
2966  *a.clone(), b.back_cast(), 1);
2967 }
2968 
2969 
2970 template <class T1, class T2, class T3>
2971 inline sc_concref_r<sc_concref_r<T1, T2>, sc_bitref_r<T3> >
2972 concat(sc_concref_r<T1, T2> a, sc_bitref<T3> b)
2973 {
2974  return sc_concref_r<sc_concref_r<T1, T2>, sc_bitref_r<T3> >(
2975  *a.clone(), *b.clone(), 3);
2976 }
2977 
2978 template <class T1, class T2, class T3>
2979 inline sc_concref_r<sc_concref_r<T1, T2>, sc_bitref_r<T3> >
2980 concat(sc_concref<T1, T2> a, sc_bitref_r<T3> b)
2981 {
2982  return sc_concref_r<sc_concref_r<T1, T2>, sc_bitref_r<T3> >(
2983  *a.clone(), *b.clone(), 3);
2984 }
2985 
2986 template <class T1, class T2, class T3>
2987 inline sc_concref_r<sc_concref_r<T1, T2>, sc_subref_r<T3> >
2988 concat(sc_concref_r<T1, T2> a, sc_subref<T3> b)
2989 {
2990  return sc_concref_r<sc_concref_r<T1, T2>, sc_subref_r<T3> >(
2991  *a.clone(), *b.clone(), 3);
2992 }
2993 
2994 template <class T1, class T2, class T3>
2995 inline sc_concref_r<sc_concref_r<T1, T2>, sc_subref_r<T3> >
2996 concat(sc_concref<T1, T2> a, sc_subref_r<T3> b)
2997 {
2998  return sc_concref_r<sc_concref_r<T1, T2>, sc_subref_r<T3> >(
2999  *a.clone(), *b.clone(), 3);
3000 }
3001 
3002 template <class T1, class T2, class T3, class T4>
3003 inline sc_concref_r<sc_concref_r<T1, T2>, sc_concref_r<T3, T4> >
3004 concat(sc_concref_r<T1, T2> a, sc_concref<T3, T4> b)
3005 {
3006  return sc_concref_r<sc_concref_r<T1, T2>, sc_concref_r<T3, T4> >(
3007  *a.clone(), *b.clone(), 3);
3008 }
3009 
3010 template <class T1, class T2, class T3, class T4>
3011 inline sc_concref_r<sc_concref_r<T1, T2>, sc_concref_r<T3, T4> >
3012 concat(sc_concref<T1, T2> a, sc_concref_r<T3, T4> b)
3013 {
3014  return sc_concref_r<sc_concref_r<T1, T2>, sc_concref_r<T3, T4> >(
3015  *a.clone(), *b.clone(), 3);
3016 }
3017 
3018 template <class T1, class T2, class T3>
3019 inline sc_concref_r<sc_concref_r<T1, T2>, T3>
3020 concat(sc_concref<T1, T2> a, const sc_proxy<T3> &b)
3021 {
3022  return sc_concref_r<sc_concref_r<T1, T2>, T3>(
3023  *a.clone(), b.back_cast(), 1);
3024 }
3025 
3026 template <class T1, class T2, class T3>
3027 inline sc_concref_r<sc_concref_r<T1, T2>, T3>
3028 concat(sc_concref_r<T1, T2> a, sc_proxy<T3> &b)
3029 {
3030  return sc_concref_r<sc_concref_r<T1, T2>, T3>(
3031  *a.clone(), b.back_cast(), 1);
3032 }
3033 
3034 
3035 // ----------------------------------------------------------------------------
3036 // CLASS TEMPLATE : sc_concref<X,Y>
3037 //
3038 // Proxy class for sc_proxy concatenation (r-value and l-value).
3039 // ----------------------------------------------------------------------------
3040 
3041 // other methods
3042 template <class T1, class T2>
3043 inline void
3044 sc_concref<T1, T2>::scan(::std::istream &is)
3045 {
3046  std::string s;
3047  is >> s;
3048  *this = s.c_str();
3049 }
3050 
3051 // l-value concatenation operators and functions
3052 template <class T1, class T2, class T3>
3053 inline sc_concref<sc_concref<T1, T2>, sc_bitref<T3> >
3054 operator , (sc_concref<T1, T2> a, sc_bitref<T3> b)
3055 {
3056  return sc_concref<sc_concref<T1, T2>, sc_bitref<T3> >(
3057  *a.clone(), *b.clone(), 3);
3058 }
3059 
3060 template <class T1, class T2, class T3>
3061 inline sc_concref<sc_concref<T1, T2>, sc_subref<T3> >
3062 operator , (sc_concref<T1, T2> a, sc_subref<T3>b)
3063 {
3064  return sc_concref<sc_concref<T1, T2>, sc_subref<T3> >(
3065  *a.clone(), *b.clone(), 3);
3066 }
3067 
3068 template <class T1, class T2, class T3, class T4>
3069 inline sc_concref<sc_concref<T1, T2>, sc_concref<T3, T4> >
3070 operator , (sc_concref<T1, T2> a, sc_concref<T3, T4> b)
3071 {
3072  return sc_concref<sc_concref<T1, T2>, sc_concref<T3, T4> >(
3073  *a.clone(), *b.clone(), 3);
3074 }
3075 
3076 template <class T1, class T2, class T3>
3077 inline sc_concref<sc_concref<T1, T2>, T3>
3078 operator , (sc_concref<T1, T2> a, sc_proxy<T3> &b)
3079 {
3080  return sc_concref<sc_concref<T1, T2>, T3>(
3081  *a.clone(), b.back_cast(), 1);
3082 }
3083 
3084 
3085 template <class T1, class T2, class T3>
3086 inline sc_concref<sc_concref<T1, T2>, sc_bitref<T3> >
3087 concat(sc_concref<T1, T2> a, sc_bitref<T3> b)
3088 {
3089  return sc_concref<sc_concref<T1, T2>, sc_bitref<T3> >(
3090  *a.clone(), *b.clone(), 3);
3091 }
3092 
3093 template <class T1, class T2, class T3>
3094 inline sc_concref<sc_concref<T1, T2>, sc_subref<T3> >
3095 concat(sc_concref<T1, T2> a, sc_subref<T3> b)
3096 {
3097  return sc_concref<sc_concref<T1, T2>, sc_subref<T3> >(
3098  *a.clone(), *b.clone(), 3);
3099 }
3100 
3101 template <class T1, class T2, class T3, class T4>
3102 inline sc_concref<sc_concref<T1, T2>, sc_concref<T3, T4> >
3103 concat(sc_concref<T1, T2> a, sc_concref<T3, T4> b)
3104 {
3105  return sc_concref<sc_concref<T1, T2>, sc_concref<T3, T4> >(
3106  *a.clone(), *b.clone(), 3);
3107 }
3108 
3109 template <class T1, class T2, class T3>
3110 inline sc_concref<sc_concref<T1, T2>, T3>
3111 concat(sc_concref<T1, T2> a, sc_proxy<T3> &b)
3112 {
3113  return sc_concref<sc_concref<T1, T2>, T3>(
3114  *a.clone(), b.back_cast(), 1);
3115 }
3116 
3117 template <class X, class Y>
3118 inline ::std::istream &
3119 operator >> (::std::istream &is, sc_concref<X, Y> a)
3120 {
3121  a.scan(is);
3122  return is;
3123 }
3124 
3125 
3126 // ----------------------------------------------------------------------------
3127 // CLASS TEMPLATE : sc_proxy<T>
3128 //
3129 // Base class template for bit/logic vector classes.
3130 // (Barton/Nackmann implementation)
3131 // ----------------------------------------------------------------------------
3132 
3133 // r-value concatenation operators and functions
3134 
3135 template <class T1, class T2>
3136 inline sc_concref_r<T1, sc_bitref_r<T2> >
3137 operator , (const sc_proxy<T1> &a, sc_bitref_r<T2> b)
3138 {
3139  return sc_concref_r<T1, sc_bitref_r<T2> >(
3140  a.back_cast(), *b.clone(), 2);
3141 }
3142 
3143 template <class T1, class T2>
3144 inline sc_concref_r<T1, sc_subref_r<T2> >
3145 operator , (const sc_proxy<T1> &a, sc_subref_r<T2> b)
3146 {
3147  return sc_concref_r<T1, sc_subref_r<T2> >(
3148  a.back_cast(), *b.clone(), 2);
3149 }
3150 
3151 template <class T1, class T2, class T3>
3152 inline sc_concref_r<T1, sc_concref_r<T2, T3> >
3153 operator , (const sc_proxy<T1> &a, sc_concref_r<T2, T3> b)
3154 {
3155  return sc_concref_r<T1, sc_concref_r<T2, T3> >(
3156  a.back_cast(), *b.clone(), 2);
3157 }
3158 
3159 template <class T1, class T2>
3160 inline sc_concref_r<T1, T2>
3161 operator , (const sc_proxy<T1> &a, const sc_proxy<T2> &b)
3162 {
3163  return sc_concref_r<T1, T2>(a.back_cast(), b.back_cast());
3164 }
3165 
3166 
3167 template <class T1, class T2>
3168 inline sc_concref_r<T1, sc_bitref_r<T2> >
3169 concat(const sc_proxy<T1> &a, sc_bitref_r<T2> b)
3170 {
3171  return sc_concref_r<T1, sc_bitref_r<T2> >(a.back_cast(), *b.clone(), 2);
3172 }
3173 
3174 template <class T1, class T2>
3175 inline sc_concref_r<T1, sc_subref_r<T2> >
3176 concat(const sc_proxy<T1> &a, sc_subref_r<T2> b)
3177 {
3178  return sc_concref_r<T1, sc_subref_r<T2> >(a.back_cast(), *b.clone(), 2);
3179 }
3180 
3181 template <class T1, class T2, class T3>
3182 inline sc_concref_r<T1, sc_concref_r<T2, T3> >
3183 concat(const sc_proxy<T1> &a, sc_concref_r<T2, T3> b )
3184 {
3185  return sc_concref_r<T1, sc_concref_r<T2, T3> >(
3186  a.back_cast(), *b.clone(), 2);
3187 }
3188 
3189 template <class T1, class T2>
3190 inline sc_concref_r<T1, T2>
3191 concat(const sc_proxy<T1> &a, const sc_proxy<T2> &b)
3192 {
3193  return sc_concref_r<T1, T2>(a.back_cast(), b.back_cast());
3194 }
3195 
3196 
3197 template <class T1, class T2>
3198 inline sc_concref_r<T1, sc_bitref_r<T2> >
3199 operator , (const sc_proxy<T1> &a, sc_bitref<T2> b)
3200 {
3201  return sc_concref_r<T1, sc_bitref_r<T2> >(a.back_cast(), *b.clone(), 2);
3202 }
3203 
3204 template <class T1, class T2>
3205 inline sc_concref_r<T1, sc_bitref_r<T2> >
3206 operator , (sc_proxy<T1> &a, sc_bitref_r<T2> b)
3207 {
3208  return sc_concref_r<T1, sc_bitref_r<T2> >(a.back_cast(), *b.clone(), 2);
3209 }
3210 
3211 template <class T1, class T2>
3212 inline sc_concref_r<T1, sc_subref_r<T2> >
3213 operator , (const sc_proxy<T1> &a, sc_subref<T2> b)
3214 {
3215  return sc_concref_r<T1, sc_subref_r<T2> >(a.back_cast(), *b.clone(), 2);
3216 }
3217 
3218 template <class T1, class T2>
3219 inline sc_concref_r<T1, sc_subref_r<T2> >
3220 operator , (sc_proxy<T1> &a, sc_subref_r<T2> b)
3221 {
3222  return sc_concref_r<T1, sc_subref_r<T2> >(a.back_cast(), *b.clone(), 2);
3223 }
3224 
3225 template <class T1, class T2, class T3>
3226 inline sc_concref_r<T1, sc_concref_r<T2, T3> >
3227 operator , (const sc_proxy<T1> &a, sc_concref<T2, T3> b)
3228 {
3229  return sc_concref_r<T1, sc_concref_r<T2, T3> >(
3230  a.back_cast(), *b.clone(), 2);
3231 }
3232 
3233 template <class T1, class T2, class T3>
3234 inline sc_concref_r<T1, sc_concref_r<T2, T3> >
3235 operator , (sc_proxy<T1> &a, sc_concref_r<T2, T3> b)
3236 {
3237  return sc_concref_r<T1, sc_concref_r<T2, T3> >(
3238  a.back_cast(), *b.clone(), 2);
3239 }
3240 
3241 template <class T1, class T2>
3242 inline sc_concref_r<T1, T2>
3243 operator , (const sc_proxy<T1> &a, sc_proxy<T2> &b)
3244 {
3245  return sc_concref_r<T1, T2>(a.back_cast(), b.back_cast());
3246 }
3247 
3248 template <class T1, class T2>
3249 inline sc_concref_r<T1, T2>
3250 operator , (sc_proxy<T1> &a, const sc_proxy<T2> &b)
3251 {
3252  return sc_concref_r<T1, T2>(a.back_cast(), b.back_cast());
3253 }
3254 
3255 
3256 template <class T1, class T2>
3257 inline sc_concref_r<T1, sc_bitref_r<T2> >
3258 concat(const sc_proxy<T1> &a, sc_bitref<T2> b)
3259 {
3260  return sc_concref_r<T1, sc_bitref_r<T2> >(a.back_cast(), *b.clone(), 2);
3261 }
3262 
3263 template <class T1, class T2>
3264 inline sc_concref_r<T1, sc_bitref_r<T2> >
3265 concat(sc_proxy<T1> &a, sc_bitref_r<T2> b)
3266 {
3267  return sc_concref_r<T1, sc_bitref_r<T2> >(a.back_cast(), *b.clone(), 2);
3268 }
3269 
3270 template <class T1, class T2>
3271 inline sc_concref_r<T1, sc_subref_r<T2> >
3272 concat(const sc_proxy<T1> &a, sc_subref<T2> b)
3273 {
3274  return sc_concref_r<T1, sc_subref_r<T2> >(a.back_cast(), *b.clone(), 2);
3275 }
3276 
3277 template <class T1, class T2>
3278 inline sc_concref_r<T1, sc_subref_r<T2> >
3279 concat(sc_proxy<T1> &a, sc_subref_r<T2> b)
3280 {
3281  return sc_concref_r<T1, sc_subref_r<T2> >(a.back_cast(), *b.clone(), 2);
3282 }
3283 
3284 template <class T1, class T2, class T3>
3285 inline sc_concref_r<T1, sc_concref_r<T2, T3> >
3286 concat(const sc_proxy<T1> &a, sc_concref<T2, T3> b)
3287 {
3288  return sc_concref_r<T1, sc_concref_r<T2, T3> >(
3289  a.back_cast(), *b.clone(), 2);
3290 }
3291 
3292 template <class T1, class T2, class T3>
3293 inline sc_concref_r<T1, sc_concref_r<T2, T3> >
3294 concat(sc_proxy<T1> &a, sc_concref_r<T2, T3> b)
3295 {
3296  return sc_concref_r<T1, sc_concref_r<T2, T3> >(
3297  a.back_cast(), *b.clone(), 2);
3298 }
3299 
3300 template <class T1, class T2>
3301 inline sc_concref_r<T1, T2>
3302 concat(const sc_proxy<T1> &a, sc_proxy<T2> &b)
3303 {
3304  return sc_concref_r<T1, T2>(a.back_cast(), b.back_cast());
3305 }
3306 
3307 template <class T1, class T2>
3308 inline sc_concref_r<T1, T2>
3309 concat(sc_proxy<T1> &a, const sc_proxy<T2> &b)
3310 {
3311  return sc_concref_r<T1, T2>(a.back_cast(), b.back_cast());
3312 }
3313 
3314 
3315 // l-value concatenation operators and functions
3316 
3317 template <class T1, class T2>
3318 inline sc_concref<T1, sc_bitref<T2> >
3319 operator , (sc_proxy<T1> &a, sc_bitref<T2> b)
3320 {
3321  return sc_concref<T1, sc_bitref<T2> >(a.back_cast(), *b.clone(), 2);
3322 }
3323 
3324 template <class T1, class T2>
3325 inline sc_concref<T1, sc_subref<T2> >
3326 operator , (sc_proxy<T1> &a, sc_subref<T2> b)
3327 {
3328  return sc_concref<T1, sc_subref<T2> >(a.back_cast(), *b.clone(), 2);
3329 }
3330 
3331 template <class T1, class T2, class T3>
3332 inline sc_concref<T1, sc_concref<T2, T3> >
3333 operator , (sc_proxy<T1> &a, sc_concref<T2, T3> b)
3334 {
3335  return sc_concref<T1, sc_concref<T2, T3> >(a.back_cast(), *b.clone(), 2);
3336 }
3337 
3338 template <class T1, class T2>
3339 inline sc_concref<T1, T2>
3340 operator , (sc_proxy<T1> &a, sc_proxy<T2> &b)
3341 {
3342  return sc_concref<T1, T2>(a.back_cast(), b.back_cast());
3343 }
3344 
3345 
3346 template <class T1, class T2>
3347 inline sc_concref<T1, sc_bitref<T2> >
3348 concat(sc_proxy<T1> &a, sc_bitref<T2> b)
3349 {
3350  return sc_concref<T1, sc_bitref<T2> >(a.back_cast(), *b.clone(), 2);
3351 }
3352 
3353 template <class T1, class T2>
3354 inline sc_concref<T1, sc_subref<T2> >
3355 concat(sc_proxy<T1> &a, sc_subref<T2> b)
3356 {
3357  return sc_concref<T1, sc_subref<T2> >(a.back_cast(), *b.clone(), 2);
3358 }
3359 
3360 template <class T1, class T2, class T3>
3361 inline sc_concref<T1, sc_concref<T2, T3> >
3362 concat(sc_proxy<T1> &a, sc_concref<T2, T3> b)
3363 {
3364  return sc_concref<T1, sc_concref<T2, T3> >(a.back_cast(), *b.clone(), 2);
3365 }
3366 
3367 template <class T1, class T2>
3368 inline sc_concref<T1, T2>
3369 concat(sc_proxy<T1> &a, sc_proxy<T2> &b)
3370 {
3371  return sc_concref<T1, T2>(a.back_cast(), b.back_cast());
3372 }
3373 
3374 } // namespace sc_dt
3375 
3376 // $Log: sc_bit_proxies.h,v $
3377 // Revision 1.10 2011/09/05 21:19:53 acg
3378 // Philipp A. Hartmann: added parentheses to expressions to eliminate
3379 // compiler warnings.
3380 //
3381 // Revision 1.9 2011/09/01 15:03:42 acg
3382 // Philipp A. Hartmann: add parentheses to eliminate compiler warnings.
3383 //
3384 // Revision 1.8 2011/08/29 18:04:32 acg
3385 // Philipp A. Hartmann: miscellaneous clean ups.
3386 //
3387 // Revision 1.7 2011/08/24 22:05:40 acg
3388 // Torsten Maehne: initialization changes to remove warnings.
3389 //
3390 // Revision 1.6 2010/02/22 14:25:43 acg
3391 // Andy Goodrich: removed 'mutable' directive from references, since it
3392 // is not a legal C++ construct.
3393 //
3394 // Revision 1.5 2009/02/28 00:26:14 acg
3395 // Andy Goodrich: bug fixes.
3396 //
3397 // Revision 1.4 2007/03/14 17:48:37 acg
3398 // Andy Goodrich: fixed bug.
3399 //
3400 // Revision 1.3 2007/01/18 19:29:18 acg
3401 // Andy Goodrich: fixed bug in concatenations of bit selects on sc_lv and
3402 // sc_bv types. The offending code was in sc_bitref<X>::set_word and
3403 // sc_bitref<X>::get_word. These methods were not writing the bit they
3404 // represented, but rather writing an entire word whose index was the
3405 // index of the bit they represented. This not only did not write the
3406 // correct bit, but clobbered a word that might not even be in the
3407 // variable the reference was for.
3408 //
3409 // Revision 1.2 2007/01/17 22:45:08 acg
3410 // Andy Goodrich: fixed sc_bitref<X>::set_bit().
3411 //
3412 // Revision 1.1.1.1 2006/12/15 20:31:36 acg
3413 // SystemC 2.2
3414 //
3415 // Revision 1.3 2006/01/13 18:53:53 acg
3416 // Andy Goodrich: added $Log command so that CVS comments are reproduced in
3417 // the source.
3418 //
3419 
3420 #endif // __SYSTEMC_EXT_DT_BIT_SC_BIT_PROXIES_HH__
sc_dt::sc_bitref::set_word
void set_word(int i, sc_digit w)
Definition: sc_bit_proxies.hh:2102
sc_dt::sc_concref_r::get_word
sc_digit get_word(int i) const
Definition: sc_bit_proxies.hh:2717
sc_dt::sc_bitref::set_bit
void set_bit(int n, value_type value)
Definition: sc_bit_proxies.hh:2091
sc_dt::sc_concref_r::m_refs
int & m_refs
Definition: sc_bit_proxies.hh:1104
sc_dt::sc_subref_r::is_01
bool is_01() const
Definition: sc_bit_proxies.hh:2364
X86ISA::os
Bitfield< 17 > os
Definition: misc.hh:803
sc_dt::operator|
sc_signed operator|(const sc_unsigned &u, const sc_int_base &v)
Definition: sc_signed.cc:791
sc_dt::sc_bitref_r::operator=
sc_bitref_r< T > & operator=(const sc_bitref_r< T > &)
sc_dt::sc_bitref_r::length
int length() const
Definition: sc_bit_proxies.hh:158
sc_dt::SC_DIGIT_ZERO
const sc_digit SC_DIGIT_ZERO
Definition: sc_proxy.hh:139
sc_dt::sc_bitref::operator|=
sc_bitref< X > & operator|=(const sc_bitref_r< X > &a)
Definition: sc_bit_proxies.hh:2038
sc_dt::sc_bitref::clone
sc_bitref< X > * clone() const
Definition: sc_bit_proxies.hh:421
sc_dt::sc_concref::operator=
sc_concref< X, Y > & operator=(const sc_proxy< Z > &a)
Definition: sc_bit_proxies.hh:1338
sc_dt::sc_bitref_r
Definition: sc_bit_proxies.hh:68
sc_dt::sc_subref_r::m_hi
int m_hi
Definition: sc_bit_proxies.hh:673
sc_dt::sc_subref_r::set_bit
void set_bit(int n, value_type value)
Definition: sc_bit_proxies.hh:2251
sc_dt::sc_concref_r::m_right
Y & m_right
Definition: sc_bit_proxies.hh:1102
sc_dt::sc_subref_r::get_cword
sc_digit get_cword(int i) const
Definition: sc_bit_proxies.hh:2313
sc_dt
Definition: sc_bit.cc:67
sc_dt::sc_concref_r::is_01
bool is_01() const
Definition: sc_bit_proxies.hh:1098
ArmISA::i
Bitfield< 7 > i
Definition: miscregs_types.hh:63
sc_dt::sc_logic::and_table
static const sc_logic_value_t and_table[4][4]
Definition: sc_logic.hh:180
sc_dt::sc_bitref::operator=
sc_bitref< X > & operator=(const sc_bitref_r< X > &a)
Definition: sc_bit_proxies.hh:1997
sc_dt::sc_digit
unsigned int sc_digit
Definition: sc_nbdefs.hh:197
sc_dt::sc_concref_r::set_bit
void set_bit(int n, value_type value)
Definition: sc_bit_proxies.hh:2703
sc_dt::sc_subref_r::clean_tail
void clean_tail()
Definition: sc_bit_proxies.hh:665
sc_dt::sc_bv_base
Definition: sc_bv_base.hh:105
sc_dt::sc_int_base
Definition: sc_int_base.hh:494
sc_dt::sc_concref_r::m_delete
int m_delete
Definition: sc_bit_proxies.hh:1103
sc_dt::sc_bitref::set_cword
void set_cword(int i, sc_digit w)
Definition: sc_bit_proxies.hh:2118
sc_dt::sc_concref_r::get_bit
value_type get_bit(int n) const
Definition: sc_bit_proxies.hh:2688
sc_dt::sc_bitref_r::is_01
bool is_01() const
Definition: sc_bit_proxies.hh:153
sc_dt::sc_subref::base_type
sc_subref_r< X > base_type
Definition: sc_bit_proxies.hh:889
X86ISA::X
Bitfield< 15, 0 > X
Definition: int.hh:53
sc_dt::sc_bitref_r::sc_bitref_r
sc_bitref_r()
sc_dt::sc_concref_r
Definition: sc_bit_proxies.hh:76
sc_dt::sc_concref_r::get_cword
sc_digit get_cword(int i) const
Definition: sc_bit_proxies.hh:2790
sc_dt::sc_concref_r::set_cword
void set_cword(int i, sc_digit w)
Definition: sc_bit_proxies.hh:2824
sc_dt::sc_subref_r::size
int size() const
Definition: sc_bit_proxies.hh:654
sc_dt::sc_signed
Definition: sc_signed.hh:984
sc_dt::sc_logic
Definition: sc_logic.hh:130
sc_dt::operator^
sc_signed operator^(const sc_unsigned &u, const sc_int_base &v)
Definition: sc_signed.cc:822
sc_dt::sc_subref_r::m_obj
X & m_obj
Definition: sc_bit_proxies.hh:672
MipsISA::is
Bitfield< 24, 22 > is
Definition: pra_constants.hh:232
sc_dt::sc_bitref_r::clone
sc_bitref_r< T > * clone() const
Definition: sc_bit_proxies.hh:137
sc_dt::sc_subref_r::set_word
void set_word(int i, sc_digit w)
Definition: sc_bit_proxies.hh:2286
sc_dt::sc_logic_value_t
sc_logic_value_t
Definition: sc_logic.hh:116
sc_dt::operator==
bool operator==(const sc_signed &u, const sc_int_base &v)
Definition: sc_signed.cc:879
sc_dt::sc_subref_r::length
int length() const
Definition: sc_bit_proxies.hh:652
sc_dt::sc_subref_r::clone
sc_subref_r< X > * clone() const
Definition: sc_bit_proxies.hh:649
sc_dt::sc_concref_r::clean_tail
void clean_tail()
Definition: sc_bit_proxies.hh:1095
sc_dt::sc_subref_r::get_word
sc_digit get_word(int i) const
Definition: sc_bit_proxies.hh:2262
sc_dt::sc_logic::is_01
bool is_01() const
Definition: sc_logic.hh:270
ArmISA::n
Bitfield< 31 > n
Definition: miscregs_types.hh:450
sc_dt::sc_concref_r::operator=
sc_concref_r< X, Y > & operator=(const sc_concref_r< X, Y > &)
sc_dt::sc_bitref_r::to_char
char to_char() const
Definition: sc_bit_proxies.hh:155
PowerISA::bi
Bitfield< 20, 16 > bi
Definition: types.hh:63
ArmISA::j
Bitfield< 24 > j
Definition: miscregs_types.hh:54
sc_dt::sc_concref::clone
sc_concref< X, Y > * clone() const
Definition: sc_bit_proxies.hh:1333
ArmISA::a
Bitfield< 8 > a
Definition: miscregs_types.hh:62
MipsISA::k
Bitfield< 23 > k
Definition: dt_constants.hh:78
SC_REPORT_ERROR
#define SC_REPORT_ERROR(msg_type, msg)
Definition: sc_report_handler.hh:127
sc_dt::sc_bitref_conv_r
Definition: sc_bit_proxies.hh:66
sc_dt::uint64
uint64_t uint64
Definition: sc_nbdefs.hh:206
MipsISA::w
Bitfield< 0 > w
Definition: pra_constants.hh:278
sc_dt::SC_DIGIT_ONE
const sc_digit SC_DIGIT_ONE
Definition: sc_proxy.hh:140
ArmISA::shift
Bitfield< 6, 5 > shift
Definition: types.hh:126
sc_dt::sc_logic::or_table
static const sc_logic_value_t or_table[4][4]
Definition: sc_logic.hh:181
sc_dt::sc_bitref::operator^=
sc_bitref< X > & operator^=(const sc_bitref_r< X > &a)
Definition: sc_bit_proxies.hh:2059
sc_dt::sc_subref_r::check_bounds
void check_bounds()
Definition: sc_bit_proxies.hh:2223
sc_dt::sc_proxy
Definition: sc_proxy.hh:119
sc_dt::sc_subref_r
Definition: sc_bit_proxies.hh:72
sc_dt::sc_subref::clone
sc_subref< X > * clone() const
Definition: sc_bit_proxies.hh:898
MipsISA::r
r
Definition: pra_constants.hh:95
sc_dt::sc_concref_r::length
int length() const
Definition: sc_bit_proxies.hh:1082
sc_dt::sc_bitref::clean_tail
void clean_tail()
Definition: sc_bit_proxies.hh:574
sc_dt::sc_bitref_r::bit_type
traits_type::bit_type bit_type
Definition: sc_bit_proxies.hh:124
sc_dt::sc_concref_r::clone
sc_concref_r< X, Y > * clone() const
Definition: sc_bit_proxies.hh:1079
sc_dt::sc_concref_r::sc_concref_r
sc_concref_r()
sc_dt::operator!=
bool operator!=(const sc_signed &u, const sc_int_base &v)
Definition: sc_signed.cc:892
sc_dt::sc_bitref_r::m_obj
T & m_obj
Definition: sc_bit_proxies.hh:170
sc_dt::sc_bit
Definition: sc_bit.hh:118
sc_dt::sc_concref_r::size
int size() const
Definition: sc_bit_proxies.hh:1084
sc_dt::sc_subref_r::set_cword
void set_cword(int i, sc_digit w)
Definition: sc_bit_proxies.hh:2337
sc_dt::sc_subref_r::m_len
int m_len
Definition: sc_bit_proxies.hh:675
sc_dt::sc_proxy_traits
Definition: sc_proxy.hh:171
sc_dt::sc_bitref
Definition: sc_bit_proxies.hh:70
sc_dt::sc_bitref_r::m_index
int m_index
Definition: sc_bit_proxies.hh:171
sc_dt::sc_concref_r::~sc_concref_r
virtual ~sc_concref_r()
Definition: sc_bit_proxies.hh:2669
sc_dt::sc_concref::sc_concref
sc_concref()
sc_dt::sc_bitref_r::get_word
sc_digit get_word(int i) const
Definition: sc_bit_proxies.hh:1770
sc_dt::int64
int64_t int64
Definition: sc_nbdefs.hh:205
sc_dt::sc_subref_r::sc_subref_r
sc_subref_r()
sc_dt::sc_min
const T sc_min(const T &a, const T &b)
Definition: functions.hh:59
sc_dt::sc_uint_base
Definition: sc_uint_base.hh:465
sc_dt::sc_concref_r::value_type
sc_proxy< sc_concref_r< X, Y > >::value_type value_type
Definition: sc_bit_proxies.hh:1061
sc_dt::sc_bitref_r::print
void print(::std::ostream &os=::std::cout) const
Definition: sc_bit_proxies.hh:167
sc_dt::sc_subref::scan
void scan(::std::istream &=::std::cin)
Definition: sc_bit_proxies.hh:2581
sc_dt::operator,
sc_concref_r< sc_bitref_r< T1 >, sc_bitref_r< T2 > > operator,(sc_bitref_r< T1 >, sc_bitref_r< T2 >)
Definition: sc_bit_proxies.hh:1862
sc_dt::sc_bitref_r::value_type
traits_type::value_type value_type
Definition: sc_bit_proxies.hh:125
sc_dt::sc_lv_base
Definition: sc_lv_base.hh:118
sc_dt::sc_bitref_r::value
value_type value() const
Definition: sc_bit_proxies.hh:152
sc_dt::sc_subref_r::get_bit
value_type get_bit(int n) const
Definition: sc_bit_proxies.hh:2240
sc_dt::sc_subref_r::m_lo
int m_lo
Definition: sc_bit_proxies.hh:674
sc_dt::sc_concref
Definition: sc_bit_proxies.hh:78
sc_dt::sc_subref
Definition: sc_bit_proxies.hh:74
sc_dt::operator>>
sc_signed operator>>(const sc_signed &u, const sc_int_base &v)
Definition: sc_signed.cc:866
sc_dt::concat
sc_concref_r< sc_bitref_r< T1 >, sc_bitref_r< T2 > > concat(sc_bitref_r< T1 >, sc_bitref_r< T2 >)
Definition: sc_bit_proxies.hh:1927
sc_dt::sc_bitref_r::operator~
bit_type operator~() const
Definition: sc_bit_proxies.hh:143
sc_dt::sc_subref_r::value_type
sc_proxy< sc_subref_r< X > >::value_type value_type
Definition: sc_bit_proxies.hh:636
sc_dt::sc_max
const T sc_max(const T &a, const T &b)
Definition: functions.hh:56
sc_dt::sc_subref::operator=
sc_subref< X > & operator=(const sc_proxy< Y > &a)
Definition: sc_bit_proxies.hh:903
ArmISA::b
Bitfield< 7 > b
Definition: miscregs_types.hh:376
sc_dt::sc_bitref::b_not
sc_bitref< X > & b_not()
Definition: sc_bit_proxies.hh:2082
sc_dt::sc_subref_r::operator=
sc_subref_r< X > & operator=(const sc_subref_r< X > &)
sc_dt::sc_logic::xor_table
static const sc_logic_value_t xor_table[4][4]
Definition: sc_logic.hh:182
sc_dt::sc_bitref::operator&=
sc_bitref< X > & operator&=(const sc_bitref_r< X > &a)
Definition: sc_bit_proxies.hh:2017
sc_dt::sc_bitref_r::get_cword
sc_digit get_cword(int i) const
Definition: sc_bit_proxies.hh:1782
ArmISA::len
Bitfield< 18, 16 > len
Definition: miscregs_types.hh:439
sc_dt::sc_unsigned
Definition: sc_unsigned.hh:890
sc_dt::sc_concref_r::set_word
void set_word(int i, sc_digit w)
Definition: sc_bit_proxies.hh:2751
sc_dt::sc_bitref_r::to_bool
bool to_bool() const
Definition: sc_bit_proxies.hh:154
sc_dt::sc_subref_r::reversed
bool reversed() const
Definition: sc_bit_proxies.hh:669
sc_core::sc_abort
void sc_abort()
Definition: sc_report.cc:178
sc_dt::SC_DIGIT_SIZE
const int SC_DIGIT_SIZE
Definition: sc_proxy.hh:137
sc_dt::sc_subref::sc_subref
sc_subref()
ArmISA::c
Bitfield< 29 > c
Definition: miscregs_types.hh:50
sc_core::SC_ID_OUT_OF_BOUNDS_
const char SC_ID_OUT_OF_BOUNDS_[]
Definition: messages.cc:40
sc_proxy.hh
sc_dt::sc_bitref::scan
void scan(::std::istream &is=::std::cin)
Definition: sc_bit_proxies.hh:2135
sc_dt::sc_concref_r::m_left
X & m_left
Definition: sc_bit_proxies.hh:1101
ArmISA::s
Bitfield< 4 > s
Definition: miscregs_types.hh:556
MipsISA::l
Bitfield< 5 > l
Definition: pra_constants.hh:320
sc_dt::Log_0
@ Log_0
Definition: sc_logic.hh:118
sc_dt::sc_concref::scan
void scan(::std::istream &=::std::cin)
Definition: sc_bit_proxies.hh:3068
sc_dt::sc_logic::not_table
static const sc_logic_value_t not_table[4]
Definition: sc_logic.hh:183
sc_dt::sc_concref::base_type
sc_concref_r< X, Y > base_type
Definition: sc_bit_proxies.hh:1322
ArmISA::v
Bitfield< 28 > v
Definition: miscregs_types.hh:51
sc_dt::sc_bitref_r::traits_type
T::traits_type traits_type
Definition: sc_bit_proxies.hh:123
sc_dt::SC_DIGIT_TWO
const sc_digit SC_DIGIT_TWO
Definition: sc_proxy.hh:141
sc_dt::sc_bitref::sc_bitref
sc_bitref()
sc_dt::operator&
sc_signed operator&(const sc_unsigned &u, const sc_int_base &v)
Definition: sc_signed.cc:760
sc_dt::sc_bitref_r::get_bit
value_type get_bit(int n) const
Definition: sc_bit_proxies.hh:1758
sc_dt::sc_bitref_r::size
int size() const
Definition: sc_bit_proxies.hh:159
sc_dt::sc_bitref::value_type
sc_bitref_r< X >::value_type value_type
Definition: sc_bit_proxies.hh:412
Generated on Wed Sep 30 2020 14:02:15 for gem5 by doxygen 1.8.17