gem5  v22.0.0.2
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>
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
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
119  operator ~ () const
120  {
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();
153 };
154 
155 // bitwise operators and functions
156 
157 // bitwise and
158 template <class T1, class T2>
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>
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>
184 
185 template <class T1, class T2>
188 
189 template <class T1, class T2, class T3>
192 
193 template <class T1, class T2>
195  sc_bitref_r<T1>, const sc_proxy<T2> &);
196 
197 template <class T>
199  sc_bitref_r<T>, const char *);
200 
201 template <class T>
203  const char *, sc_bitref_r<T>);
204 
205 template <class T>
207  sc_bitref_r<T>, const sc_logic &);
208 
209 template <class T>
211  const sc_logic &, sc_bitref_r<T>);
212 
213 template <class T>
215  sc_bitref_r<T>, bool);
216 
217 template <class T>
219  bool, sc_bitref_r<T>);
220 
221 
222 template <class T1, class T2>
225 
226 template <class T1, class T2>
229 
230 template <class T1, class T2, class T3>
233 
234 template <class T1, class T2>
236  sc_bitref_r<T1>, const sc_proxy<T2> &);
237 
238 template <class T>
240  sc_bitref_r<T>, const char *);
241 
242 template <class T>
244  const char *, sc_bitref_r<T>);
245 
246 template <class T>
248  sc_bitref_r<T>, const sc_logic &);
249 
250 template <class T>
252  const sc_logic &, sc_bitref_r<T>);
253 
254 template <class T>
256  sc_bitref_r<T>, bool);
257 
258 template <class T>
260  bool, sc_bitref_r<T>);
261 
262 
263 template <class T1, class T2>
266 
267 template <class T1, class T2>
270 
271 template <class T1, class T2>
274 
275 template <class T1, class T2>
278 
279 template <class T1, class T2, class T3>
282 
283 template <class T1, class T2, class T3>
286 
287 template <class T1, class T2>
289  sc_bitref<T1>, const sc_proxy<T2> &);
290 
291 template <class T1, class T2>
294 
295 template <class T>
297  sc_bitref<T>, const char *);
298 
299 template <class T>
301  const char *, sc_bitref<T>);
302 
303 template <class T>
305  sc_bitref<T>, const sc_logic &);
306 
307 template <class T>
309  const sc_logic &, sc_bitref<T>);
310 
311 template <class T>
313  sc_bitref<T>, bool);
314 
315 template <class T>
317  bool, sc_bitref<T>);
318 
319 
320 template <class T1, class T2>
323 
324 template <class T1, class T2>
327 
328 template <class T1, class T2>
331 
332 template <class T1, class T2>
335 
336 template <class T1, class T2, class T3>
339 
340 template <class T1, class T2, class T3>
343 
344 template <class T1, class T2>
346  sc_bitref<T1>, const sc_proxy<T2> &);
347 
348 template <class T1, class T2>
351 
352 template <class T>
354  sc_bitref<T>, const char *);
355 
356 template <class T>
358  const char *, sc_bitref<T>);
359 
360 template <class T>
362  sc_bitref<T>, const sc_logic &);
363 
364 template <class T>
366  const sc_logic &, sc_bitref<T>);
367 
368 template <class T>
370 
371 template <class 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> &
412  {
413  *this = sc_logic(v);
414  return *this;
415  }
416 
417  sc_bitref<X> &
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
448 
451  {
452  *this &= sc_logic(v);
453  return *this;
454  }
455 
457  operator &= (bool a)
458  {
459  *this &= sc_logic(a);
460  return *this;
461  }
462 
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 
479 
480  sc_bitref<X> &
482  {
483  *this |= sc_logic(v);
484  return *this;
485  }
486 
487  sc_bitref<X> &
489  {
490  *this |= sc_logic(a);
491  return *this;
492  }
493 
494  sc_bitref<X> &
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 
510 
511  sc_bitref<X> &
513  {
514  *this ^= sc_logic(v);
515  return *this;
516  }
517 
518  sc_bitref<X> &
520  {
521  *this ^= sc_logic(a);
522  return *this;
523  }
524 
525  sc_bitref<X> &
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
558 };
559 
560 
561 // l-value concatenation operators and functions
562 
563 template <class T1, class T2>
566 
567 template <class T1, class T2>
570 
571 template <class T1, class T2, class T3>
574 
575 template <class T1, class T2>
578 
579 
580 template <class T1, class T2>
583 
584 template <class T1, class T2>
587 
588 template <class T1, class T2, class T3>
591 
592 template <class T1, class 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:
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) :
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();
657 };
658 
659 
660 // r-value concatenation operators and functions
661 
662 template <class T1, class T2>
665 
666 template <class T1, class T2>
669 
670 template <class T1, class T2, class T3>
673 
674 template <class T1, class T2>
676  sc_subref_r<T1>, const sc_proxy<T2> &);
677 
678 template <class T>
680  sc_subref_r<T>, const char *);
681 
682 template <class T>
684  const char *, sc_subref_r<T>);
685 
686 template <class T>
688  sc_subref_r<T>, const sc_logic &);
689 
690 template <class T>
692  const sc_logic &, sc_subref_r<T>);
693 
694 template <class T>
696  sc_subref_r<T>, bool);
697 
698 template <class T>
700  bool, sc_subref_r<T>);
701 
702 
703 template <class T1, class T2>
706 
707 template <class T1, class T2>
710 
711 template <class T1, class T2, class T3>
714 
715 template <class T1, class T2>
717  sc_subref_r<T1>, const sc_proxy<T2> &);
718 
719 template <class T>
721  sc_subref_r<T>, const char *);
722 
723 template <class T>
725  const char *, sc_subref_r<T>);
726 
727 template <class T>
729  sc_subref_r<T>, const sc_logic &);
730 
731 template <class T>
733  const sc_logic &, sc_subref_r<T>);
734 
735 template <class T>
737 
738 template <class T>
740 
741 
742 template <class T1, class T2>
745 
746 template <class T1, class T2>
749 
750 template <class T1, class T2>
753 
754 template <class T1, class T2>
757 
758 template <class T1, class T2, class T3>
761 
762 template <class T1, class T2, class T3>
765 
766 template <class T1, class T2>
768  sc_subref<T1>, const sc_proxy<T2> &);
769 
770 template <class T1, class T2>
773 
774 template <class T>
776  sc_subref<T>, const char *);
777 
778 template <class T>
780  const char *, sc_subref<T>);
781 
782 template <class T>
784  sc_subref<T>, const sc_logic &);
785 
786 template <class T>
788  const sc_logic &, sc_subref<T>);
789 
790 template <class T>
792  sc_subref<T>, bool);
793 
794 template <class T>
796  bool, sc_subref<T>);
797 
798 
799 template <class T1, class T2>
802 
803 template <class T1, class T2>
806 
807 template <class T1, class T2>
810 
811 template <class T1, class T2>
814 
815 template <class T1, class T2, class T3>
818 
819 template <class T1, class T2, class T3>
822 
823 template <class T1, class T2>
825  sc_subref<T1>, const sc_proxy<T2> &);
826 
827 template <class T1, class T2>
830 
831 template <class T>
833  sc_subref<T>, const char *);
834 
835 template <class T>
837  const char *, sc_subref<T>);
838 
839 template <class T>
841  sc_subref<T>, const sc_logic &);
842 
843 template <class T>
845  const sc_logic &, sc_subref<T>);
846 
847 template <class T>
849 
850 template <class 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 
896  operator = (const bool *a)
897  {
898  base_type::assign_(a);
899  return *this;
900  }
901 
902  sc_subref<X> &
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> &
967  {
968  base_type::assign_(a);
969  return *this;
970  }
971 
972  sc_subref<X> &
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>
993 
994 template <class T1, class T2>
997 
998 template <class T1, class T2, class T3>
1001 
1002 template <class T1, class T2>
1005 
1006 
1007 template <class T1, class T2>
1010 
1011 template <class T1, class T2>
1014 
1015 template <class T1, class T2, class T3>
1018 
1019 template <class T1, class 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:
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
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); }
1062  value_type get_bit(int n) const;
1063  void set_bit(int n, value_type value);
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);
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
1086 };
1087 
1088 
1089 // r-value concatenation operators and functions
1090 
1091 template <class T1, class T2, class T3>
1094 
1095 template <class T1, class T2, class T3>
1099 template <class T1, class T2, class T3, class T4>
1103 template <class T1, class T2, class T3>
1106 
1107 template <class T1, class T2>
1109  sc_concref_r<T1, T2>, const char *);
1110 
1111 template <class T1, class T2>
1113  const char *, sc_concref_r<T1, T2>);
1114 
1115 template <class T1, class T2>
1117  sc_concref_r<T1, T2>, const sc_logic &);
1118 
1119 template <class T1, class T2>
1121  const sc_logic &, sc_concref_r<T1, T2>);
1122 
1123 template <class T1, class T2>
1125  sc_concref_r<T1, T2>, bool);
1126 
1127 template <class T1, class T2>
1129  bool, sc_concref_r<T1, T2>);
1130 
1131 
1132 template <class T1, class T2, class T3>
1135 
1136 template <class T1, class T2, class T3>
1139 
1140 template <class T1, class T2, class T3, class T4>
1143 
1144 template <class T1, class T2, class T3>
1147 
1148 template <class T1, class T2>
1150  sc_concref_r<T1, T2>, const char *);
1151 
1152 template <class T1, class T2>
1154  const char *, sc_concref_r<T1, T2>);
1155 
1156 template <class T1, class T2>
1158  sc_concref_r<T1, T2>, const sc_logic &);
1159 
1160 template <class T1, class T2>
1162  const sc_logic &, sc_concref_r<T1, T2>);
1163 
1164 template <class T1, class T2>
1166  sc_concref_r<T1, T2>, bool);
1167 
1168 template <class T1, class T2>
1170  bool, sc_concref_r<T1, T2>);
1171 
1172 
1173 template <class T1, class T2, class T3>
1176 
1177 template <class T1, class T2, class T3>
1180 
1181 template <class T1, class T2, class T3>
1184 
1185 template <class T1, class T2, class T3>
1188 
1189 template <class T1, class T2, class T3, class T4>
1192 
1193 template <class T1, class T2, class T3, class T4>
1196 
1197 template <class T1, class T2, class T3>
1199  sc_concref<T1, T2>, const sc_proxy<T3> &);
1200 
1201 template <class T1, class T2, class T3>
1204 
1205 template <class T1, class T2>
1207  sc_concref<T1, T2>, const char *);
1208 
1209 template <class T1, class T2>
1211  const char *, sc_concref<T1, T2>);
1212 
1213 template <class T1, class T2>
1215  sc_concref<T1, T2>, const sc_logic &);
1216 
1217 template <class T1, class T2>
1219  const sc_logic &, sc_concref<T1, T2>);
1220 
1221 template <class T1, class T2>
1223  sc_concref<T1, T2>, bool);
1224 
1225 template <class T1, class T2>
1227  bool, sc_concref<T1, T2>);
1228 
1229 
1230 template <class T1, class T2, class T3>
1233 
1234 template <class T1, class T2, class T3>
1237 
1238 template <class T1, class T2, class T3>
1241 
1242 template <class T1, class T2, class T3>
1245 
1246 template <class T1, class T2, class T3, class T4>
1249 
1250 template <class T1, class T2, class T3, class T4>
1253 
1254 template <class T1, class T2, class T3>
1256  sc_concref<T1, T2>, const sc_proxy<T3> &);
1257 
1258 template <class T1, class T2, class T3>
1261 
1262 template <class T1, class T2>
1264  sc_concref<T1, T2>, const char *);
1265 
1266 template <class T1, class T2>
1268  const char *, sc_concref<T1, T2>);
1269 
1270 template <class T1, class T2>
1272  sc_concref<T1, T2>, const sc_logic &);
1273 
1274 template <class T1, class T2>
1276  const sc_logic &, sc_concref<T1, T2>);
1277 
1278 template <class T1, class T2>
1280  sc_concref<T1, T2>, bool);
1281 
1282 template <class T1, class T2>
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 
1328  operator = (const char *a)
1329  {
1330  base_type::assign_(a);
1331  return *this;
1332  }
1335  operator = (const bool *a)
1336  {
1337  base_type::assign_(a);
1338  return *this;
1339  }
1340 
1342  operator = (const sc_logic *a)
1343  {
1344  base_type::assign_(a);
1345  return *this;
1346  }
1347 
1349  operator = (const sc_unsigned &a)
1350  {
1351  base_type::assign_(a);
1352  return *this;
1353  }
1354 
1356  operator = (const sc_signed &a)
1357  {
1358  base_type::assign_(a);
1359  return *this;
1360  }
1361 
1363  operator = (const sc_uint_base &a)
1364  {
1365  base_type::assign_(a);
1366  return *this;
1367  }
1368 
1370  operator = (const sc_int_base &a)
1371  {
1372  base_type::assign_(a);
1373  return *this;
1374  }
1375 
1377  operator = (unsigned long a)
1378  {
1379  base_type::assign_(a);
1380  return *this;
1381  }
1382 
1384  operator = (long a)
1385  {
1386  base_type::assign_(a);
1387  return *this;
1388  }
1389 
1391  operator = (unsigned int a)
1392  {
1393  base_type::assign_(a);
1394  return *this;
1395  }
1396 
1398  operator = (int a)
1399  {
1400  base_type::assign_(a);
1401  return *this;
1402  }
1403 
1406  {
1407  base_type::assign_(a);
1408  return *this;
1409  }
1410 
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>
1432 
1433 template <class T1, class T2, class T3>
1437 template <class T1, class T2, class T3, class T4>
1440 
1441 template <class T1, class T2, class T3>
1444 
1445 
1446 template <class T1, class T2, class T3>
1449 
1450 template <class T1, class T2, class T3>
1453 
1454 template <class T1, class T2, class T3, class T4>
1457 
1458 template <class T1, class T2, class 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>
1478  const sc_proxy<T1> &, sc_bitref_r<T2>);
1479 
1480 template <class T1, class T2>
1482  const sc_proxy<T1> &, sc_subref_r<T2>);
1483 
1484 template <class T1, class T2, class T3>
1487 
1488 template <class T1, class T2>
1490  const sc_proxy<T1> &, const sc_proxy<T2> &);
1491 
1492 template <class T>
1494  const sc_proxy<T> &, const char *);
1495 
1496 template <class T>
1498  const char *, const sc_proxy<T> &);
1499 
1500 template <class T>
1502  const sc_proxy<T> &, const sc_logic &);
1503 
1504 template <class T>
1506  const sc_logic &, const sc_proxy<T> &);
1507 
1508 template <class T>
1510 
1511 template <class T>
1513 
1514 
1515 template <class T1, class T2>
1517  const sc_proxy<T1> &, sc_bitref_r<T2>);
1518 
1519 template <class T1, class T2>
1521  const sc_proxy<T1> &, sc_subref_r<T2>);
1522 
1523 template <class T1, class T2, class 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>
1538  const sc_proxy<T> &, const sc_logic &);
1539 
1540 template <class T>
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>
1553  const sc_proxy<T1> &, sc_bitref<T2>);
1554 
1555 template <class T1, class T2>
1558 
1559 template <class T1, class T2>
1561  const sc_proxy<T1> &, sc_subref<T2>);
1562 
1563 template <class T1, class T2>
1566 
1567 template <class T1, class T2, class T3>
1569  const sc_proxy<T1> &, sc_concref<T2, T3>);
1570 
1571 template <class T1, class T2, class T3>
1574 
1575 template <class T1, class T2>
1577 
1578 template <class T1, class 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>
1589  sc_proxy<T> &, const sc_logic &);
1590 
1591 template <class T>
1593  const sc_logic &, sc_proxy<T> &);
1594 
1595 template <class T>
1597 
1598 template <class T>
1600 
1601 
1602 template <class T1, class T2>
1604  const sc_proxy<T1> &, sc_bitref<T2>);
1605 
1606 template <class T1, class T2>
1609 
1610 template <class T1, class T2>
1612  const sc_proxy<T1> &, sc_subref<T2>);
1613 
1614 template <class T1, class T2>
1617 
1618 template <class T1, class T2, class T3>
1620  const sc_proxy<T1> &, sc_concref<T2, T3>);
1621 
1622 template <class T1, class T2, class T3>
1625 
1626 template <class T1, class T2>
1628 
1629 template <class T1, class 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>
1640 
1641 template <class T>
1643 
1644 template <class T>
1646 
1647 template <class T>
1649 
1650 
1651 // l-value concatenation operators and functions
1652 template <class T1, class T2>
1655 
1656 template <class T1, class T2>
1659 
1660 template <class T1, class T2, class T3>
1663 
1664 template <class T1, class T2>
1666 
1667 
1668 template <class T1, class T2>
1670 
1671 template <class T1, class T2>
1673 
1674 template <class T1, class T2, class T3>
1677 
1678 template <class T1, class 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
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
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
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)
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
1736  if (n == 0) {
1737  return m_obj.get_bit(m_index);
1738  } else {
1740  return Log_0;
1741  }
1742 }
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 {
1752  return 0;
1753  }
1754 }
1755 
1756 template <class T>
1757 inline sc_digit
1759 {
1760  if (n == 0) {
1761  return ((get_bit(n) & SC_DIGIT_TWO) >> 1);
1762  } else {
1764  return 0;
1765  }
1766 }
1767 
1768 // r-value concatenation operators and functions
1769 template <class T1, class T2>
1772 {
1774  *a.clone(), *b.clone(), 3);
1775 }
1776 
1777 template <class T1, class T2>
1780 {
1782  *a.clone(), *b.clone(), 3);
1783 }
1784 
1785 template <class T1, class T2, class T3>
1788 {
1790  *a.clone(), *b.clone(), 3);
1791 }
1792 
1793 template <class T1, class T2>
1794 inline sc_concref_r<sc_bitref_r<T1>, T2>
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
1806 {
1808  *a.clone(), *b.clone(), 3);
1809 }
1810 
1811 template <class T1, class T2>
1814 {
1816  *a.clone(), *b.clone(), 3);
1817 }
1818 
1819 template <class T1, class T2, class T3>
1822 {
1824  *a.clone(), *b.clone(), 3);
1825 }
1826 
1827 template <class T1, class T2>
1828 inline sc_concref_r<sc_bitref_r<T1>, T2>
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>
1839 {
1841  *a.clone(), *b.clone(), 3);
1842 }
1843 
1844 template <class T1, class T2>
1847 {
1849  *a.clone(), *b.clone(), 3);
1850 }
1851 
1852 template <class T1, class T2>
1855 {
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> >
1863 {
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> >
1871 {
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> >
1879 {
1881  *a.clone(), *b.clone(), 3);
1882 }
1883 
1884 template <class T1, class T2>
1885 inline sc_concref_r<sc_bitref_r<T1>, T2>
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>
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>
1904 {
1906  *a.clone(), *b.clone(), 3);
1907 }
1908 
1909 template <class T1, class T2>
1912 {
1914  *a.clone(), *b.clone(), 3);
1915 }
1916 
1917 template <class T1, class T2>
1920 {
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> >
1928 {
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> >
1936 {
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> >
1944 {
1946  *a.clone(), *b.clone(), 3);
1947 }
1948 
1949 template <class T1, class T2>
1950 inline sc_concref_r<sc_bitref_r<T1>, T2>
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)
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> &
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)
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)
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> &
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> &
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> &
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 {
2073  }
2074 }
2075 
2076 template <class X>
2077 inline void
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 {
2089  }
2090 }
2092 template <class X>
2093 inline void
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 {
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>
2122 {
2124  *a.clone(), *b.clone(), 3);
2125 }
2126 
2127 template <class T1, class T2>
2130 {
2132  *a.clone(), *b.clone(), 3);
2133 }
2134 
2135 template <class T1, class T2, class T3>
2138 {
2140  *a.clone(), *b.clone(), 3);
2141 }
2142 
2143 template <class T1, class T2>
2144 inline sc_concref<sc_bitref<T1>, T2>
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> >
2154 {
2156  *a.clone(), *b.clone(), 3);
2157 }
2158 
2159 template <class T1, class T2>
2160 inline sc_concref<sc_bitref<T1>, sc_subref<T2> >
2162 {
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> >
2170 {
2172  *a.clone(), *b.clone(), 3);
2173 }
2174 
2175 template <class T1, class T2>
2176 inline sc_concref<sc_bitref<T1>, T2>
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)
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
2200 {
2201  int len = m_obj.length();
2202  if (m_hi < 0 || m_hi >= len || m_lo < 0 || m_lo >= len) {
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  }
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
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 
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
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>
2355 {
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 {
2365  *a.clone(), *b.clone(), 3);
2366 }
2367 
2368 template <class T1, class T2, class T3>
2371 {
2373  *a.clone(), *b.clone(), 3);
2374 }
2375 
2376 template <class T1, class T2>
2377 inline sc_concref_r<sc_subref_r<T1>, T2>
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>
2388 {
2390  *a.clone(), *b.clone(), 3);
2391 }
2392 
2393 template <class T1, class T2>
2396 {
2398  *a.clone(), *b.clone(), 3);
2399 }
2400 
2401 template <class T1, class T2, class T3>
2404 {
2406  *a.clone(), *b.clone(), 3);
2407 }
2408 
2409 template <class T1, class T2>
2410 inline sc_concref_r<sc_subref_r<T1>, T2>
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> >
2420 {
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> >
2428 {
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> >
2436 {
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> >
2444 {
2446  *a.clone(), *b.clone(), 3);
2447 }
2448 
2449 template <class T1, class T2, class T3>
2450 inline
2453 {
2455  *a.clone(), *b.clone(), 3);
2456 }
2457 
2458 template <class T1, class T2, class T3>
2461 {
2463  *a.clone(), *b.clone(), 3);
2464 }
2465 
2466 template <class T1, class T2>
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)
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)
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)
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> >
2500 {
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> >
2508 {
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> >
2516 {
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> >
2524 {
2526  *a.clone(), *b.clone(), 3);
2527 }
2528 
2529 template <class T1, class T2>
2530 inline sc_concref_r<sc_subref_r<T1>, T2>
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)
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();
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 }
2582 template <class T1, class T2, class T3>
2585 {
2587  *a.clone(), *b.clone(), 3);
2588 }
2589 
2590 template <class T1, class T2>
2591 inline sc_concref<sc_subref<T1>, T2>
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> >
2601 {
2603  *a.clone(), *b.clone(), 3);
2604 }
2605 
2606 template <class T1, class T2>
2607 inline sc_concref<sc_subref<T1>, sc_subref<T2> >
2609 {
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> >
2617 {
2619  *a.clone(), *b.clone(), 3);
2620 }
2621 
2622 template <class T1, class T2>
2623 inline sc_concref<sc_subref<T1>, T2>
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)
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>
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 {
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 {
2688  }
2689 }
2690 
2691 template <class X, class Y>
2692 inline sc_digit
2694 {
2695  if (i < 0 || i >= size()) {
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
2728 {
2729  if (i < 0 || i >= size()) {
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
2767 {
2768  if (i < 0 || i >= size()) {
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
2801 {
2802  if (i < 0 || i >= size()) {
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>
2865 {
2867  *a.clone(), b.back_cast(), 1);
2868 }
2869 
2870 
2871 template <class T1, class T2, class T3>
2874 {
2876  *a.clone(), *b.clone(), 3);
2877 }
2878 
2879 template <class T1, class T2, class T3>
2882 {
2884  *a.clone(), *b.clone(), 3);
2885 }
2886 
2887 template <class T1, class T2, class T3, class T4>
2890 {
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>
2898 {
2900  *a.clone(), b.back_cast(), 1);
2901 }
2902 
2903 
2904 template <class T1, class T2, class T3>
2907 {
2909  *a.clone(), *b.clone(), 3);
2910 }
2911 
2912 template <class T1, class T2, class T3>
2915 {
2917  *a.clone(), *b.clone(), 3);
2918 }
2919 
2920 template <class T1, class T2, class T3>
2921 inline
2924 {
2926  *a.clone(), *b.clone(), 3);
2927 }
2928 
2929 template <class T1, class T2, class T3>
2932 {
2934  *a.clone(), *b.clone(), 3);
2935 }
2936 
2937 template <class T1, class T2, class T3, class T4>
2940 {
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> >
2948 {
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>
2956 {
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>
2964 {
2966  *a.clone(), b.back_cast(), 1);
2967 }
2968 
2969 
2970 template <class T1, class T2, class T3>
2973 {
2975  *a.clone(), *b.clone(), 3);
2976 }
2977 
2978 template <class T1, class T2, class T3>
2981 {
2983  *a.clone(), *b.clone(), 3);
2984 }
2985 
2986 template <class T1, class T2, class T3>
2989 {
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> >
2997 {
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> >
3005 {
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> >
3013 {
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>
3021 {
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>
3029 {
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
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>
3055 {
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>
3071 {
3073  *a.clone(), *b.clone(), 3);
3074 }
3075 
3076 template <class T1, class T2, class T3>
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>
3088 {
3090  *a.clone(), *b.clone(), 3);
3091 }
3092 
3093 template <class T1, class T2, class T3>
3096 {
3098  *a.clone(), *b.clone(), 3);
3099 }
3100 
3101 template <class T1, class T2, class T3, class T4>
3104 {
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>
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 &
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>
3138 {
3140  a.back_cast(), *b.clone(), 2);
3141 }
3142 
3143 template <class T1, class T2>
3146 {
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>
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> >
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)
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 {
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)
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)
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);
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 {
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)
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)
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)
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);
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 {
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)
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)
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>
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> >
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> >
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());
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());
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__
gem5::VegaISA::s
Bitfield< 1 > s
Definition: pagetable.hh:64
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
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
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
gem5::ArmISA::a
Bitfield< 8 > a
Definition: misc_types.hh:66
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
gem5::VegaISA::w
Bitfield< 6 > w
Definition: pagetable.hh:59
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
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
gem5::VegaISA::r
Bitfield< 5 > r
Definition: pagetable.hh:60
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
gem5::ArmISA::i
Bitfield< 7 > i
Definition: misc_types.hh:67
gem5::PowerISA::bi
Bitfield< 20, 16 > bi
Definition: types.hh:80
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
gem5::MipsISA::is
Bitfield< 24, 22 > is
Definition: pra_constants.hh:235
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
gem5::ArmISA::shift
Bitfield< 6, 5 > shift
Definition: types.hh:117
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
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
gem5::VegaISA::c
Bitfield< 2 > c
Definition: pagetable.hh:63
gem5::ArmISA::j
Bitfield< 24 > j
Definition: misc_types.hh:57
sc_dt::sc_concref::clone
sc_concref< X, Y > * clone() const
Definition: sc_bit_proxies.hh:1333
gem5::ArmISA::b
Bitfield< 7 > b
Definition: misc_types.hh:382
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
sc_dt::SC_DIGIT_ONE
const sc_digit SC_DIGIT_ONE
Definition: sc_proxy.hh:140
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
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
len
uint16_t len
Definition: helpers.cc:62
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
gem5::VegaISA::v
Bitfield< 0 > v
Definition: pagetable.hh:65
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
gem5::ArmISA::n
Bitfield< 31 > n
Definition: misc_types.hh:456
gem5::X86ISA::os
Bitfield< 17 > os
Definition: misc.hh:803
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
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()
gem5::VegaISA::l
Bitfield< 55 > l
Definition: pagetable.hh:54
gem5::MipsISA::k
Bitfield< 23 > k
Definition: dt_constants.hh:81
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
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
gem5::X86ISA::X
Bitfield< 15, 0 > X
Definition: int.hh:57
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 Thu Jul 28 2022 13:32:38 for gem5 by doxygen 1.8.17