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