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