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