diff options
Diffstat (limited to 'ext/systemc/src/sysc/datatypes/bit/sc_bit_proxies.h')
| -rw-r--r-- | ext/systemc/src/sysc/datatypes/bit/sc_bit_proxies.h | 3884 |
1 files changed, 3884 insertions, 0 deletions
diff --git a/ext/systemc/src/sysc/datatypes/bit/sc_bit_proxies.h b/ext/systemc/src/sysc/datatypes/bit/sc_bit_proxies.h new file mode 100644 index 000000000..59d997181 --- /dev/null +++ b/ext/systemc/src/sysc/datatypes/bit/sc_bit_proxies.h @@ -0,0 +1,3884 @@ +/***************************************************************************** + + Licensed to Accellera Systems Initiative Inc. (Accellera) under one or + more contributor license agreements. See the NOTICE file distributed + with this work for additional information regarding copyright ownership. + Accellera licenses this file to you under the Apache License, Version 2.0 + (the "License"); you may not use this file except in compliance with the + License. You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied. See the License for the specific language governing + permissions and limitations under the License. + + *****************************************************************************/ + +/***************************************************************************** + + sc_bit_proxies.h -- Proxy classes for vector data types. + + Original Author: Gene Bushuyev, Synopsys, Inc. + + CHANGE LOG AT THE END OF THE FILE + *****************************************************************************/ + +#ifndef SC_BIT_PROXIES_H +#define SC_BIT_PROXIES_H + + +#include "sysc/datatypes/bit/sc_bit_ids.h" +#include "sysc/datatypes/bit/sc_proxy.h" + + +namespace sc_dt +{ + +// classes defined in this module +template <class X> class sc_bitref_r; +template <class X> class sc_bitref; +template <class X> class sc_subref_r; +template <class X> class sc_subref; +template <class X, class Y> class sc_concref_r; +template <class X, class Y> class sc_concref; + + +// ---------------------------------------------------------------------------- +// CLASS TEMPLATE : sc_bitref_r<T> +// +// Proxy class for sc_proxy bit selection (r-value only). +// ---------------------------------------------------------------------------- + +template <class T> +class sc_bitref_r +{ + friend class sc_bv_base; + friend class sc_lv_base; + +public: + + // typedefs + + typedef typename T::traits_type traits_type; + typedef typename traits_type::bit_type bit_type; + + // constructor + + sc_bitref_r( const T& obj_, int index_ ) + : m_obj( CCAST<T&>( obj_ ) ), m_index( index_ ) + {} + + + // copy constructor + + sc_bitref_r( const sc_bitref_r<T>& a ) + : m_obj( a.m_obj ), m_index( a.m_index ) + {} + + // cloning + + sc_bitref_r<T>* clone() const + { return new sc_bitref_r<T>( *this ); } + + + // bitwise operators and functions + + // bitwise complement + + const bit_type operator ~ () const + { return bit_type( sc_logic::not_table[value()] ); } + + + // implicit conversion to bit_type + + operator const bit_type() const + { return bit_type( m_obj.get_bit( m_index ) ); } + + + // explicit conversions + + sc_logic_value_t value() const + { return m_obj.get_bit( m_index ); } + + + bool is_01() const + { return sc_logic( value() ).is_01(); } + + bool to_bool() const + { return sc_logic( value() ).to_bool(); } + + char to_char() const + { return sc_logic( value() ).to_char(); } + + + // common methods + + int length() const + { return 1; } + + int size() const + { return ( (length() - 1) / SC_DIGIT_SIZE + 1 ); } + + sc_logic_value_t get_bit( int n ) const; + + sc_digit get_word( int i ) const; + sc_digit get_cword( int i ) const; + + + // other methods + + void print( ::std::ostream& os = ::std::cout ) const + { os << to_char(); } + +protected: + + T& m_obj; + int m_index; + +private: + + // disabled + sc_bitref_r(); + sc_bitref_r<T>& operator = ( const sc_bitref_r<T>& ); +}; + + +// bitwise operators and functions + +// bitwise and + +template <class T1, class T2> +inline +const sc_logic +operator & ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b ); + + +// bitwise or + +template <class T1, class T2> +inline +const sc_logic +operator | ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b ); + + +// bitwise xor + +template <class T1, class T2> +inline +const sc_logic +operator ^ ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b ); + + +// relational operators and functions + +template <class T1, class T2> +inline +bool +operator == ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b ); + +template <class T1, class T2> +inline +bool +operator != ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b ); + + +// r-value concatenation operators and functions + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> > +operator , ( sc_bitref_r<T1>, sc_bitref_r<T2> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> > +operator , ( sc_bitref_r<T1>, sc_subref_r<T2> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> > +operator , ( sc_bitref_r<T1>, sc_concref_r<T2,T3> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,T2> +operator , ( sc_bitref_r<T1>, const sc_proxy<T2>& ); + +template <class T> +inline +sc_concref_r<sc_bitref_r<T>,sc_lv_base> +operator , ( sc_bitref_r<T>, const char* ); + +template <class T> +inline +sc_concref_r<sc_lv_base,sc_bitref_r<T> > +operator , ( const char*, sc_bitref_r<T> ); + +template <class T> +inline +sc_concref_r<sc_bitref_r<T>,sc_lv_base> +operator , ( sc_bitref_r<T>, const sc_logic& ); + +template <class T> +inline +sc_concref_r<sc_lv_base,sc_bitref_r<T> > +operator , ( const sc_logic&, sc_bitref_r<T> ); + +template <class T> +inline +sc_concref_r<sc_bitref_r<T>,sc_lv_base> +operator , ( sc_bitref_r<T>, bool ); + +template <class T> +inline +sc_concref_r<sc_lv_base,sc_bitref_r<T> > +operator , ( bool, sc_bitref_r<T> ); + + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> > +concat( sc_bitref_r<T1>, sc_bitref_r<T2> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> > +concat( sc_bitref_r<T1>, sc_subref_r<T2> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> > +concat( sc_bitref_r<T1>, sc_concref_r<T2,T3> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,T2> +concat( sc_bitref_r<T1>, const sc_proxy<T2>& ); + +template <class T> +inline +sc_concref_r<sc_bitref_r<T>,sc_lv_base> +concat( sc_bitref_r<T>, const char* ); + +template <class T> +inline +sc_concref_r<sc_lv_base,sc_bitref_r<T> > +concat( const char*, sc_bitref_r<T> ); + +template <class T> +inline +sc_concref_r<sc_bitref_r<T>,sc_lv_base> +concat( sc_bitref_r<T>, const sc_logic& ); + +template <class T> +inline +sc_concref_r<sc_lv_base,sc_bitref_r<T> > +concat( const sc_logic&, sc_bitref_r<T> ); + +template <class T> +inline +sc_concref_r<sc_bitref_r<T>,sc_lv_base> +concat( sc_bitref_r<T>, bool ); + +template <class T> +inline +sc_concref_r<sc_lv_base,sc_bitref_r<T> > +concat( bool, sc_bitref_r<T> ); + + +#ifdef SC_DT_MIXED_COMMA_OPERATORS + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> > +operator , ( sc_bitref_r<T1>, sc_bitref<T2> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> > +operator , ( sc_bitref<T1>, sc_bitref_r<T2> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> > +operator , ( sc_bitref_r<T1>, sc_subref<T2> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> > +operator , ( sc_bitref<T1>, sc_subref_r<T2> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> > +operator , ( sc_bitref_r<T1>, sc_concref<T2,T3> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> > +operator , ( sc_bitref<T1>, sc_concref_r<T2,T3> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,T2> +operator , ( sc_bitref<T1>, const sc_proxy<T2>& ); + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,T2> +operator , ( sc_bitref_r<T1>, sc_proxy<T2>& ); + +template <class T> +inline +sc_concref_r<sc_bitref_r<T>,sc_lv_base> +operator , ( sc_bitref<T>, const char* ); + +template <class T> +inline +sc_concref_r<sc_lv_base,sc_bitref_r<T> > +operator , ( const char*, sc_bitref<T> ); + +template <class T> +inline +sc_concref_r<sc_bitref_r<T>,sc_lv_base> +operator , ( sc_bitref<T>, const sc_logic& ); + +template <class T> +inline +sc_concref_r<sc_lv_base,sc_bitref_r<T> > +operator , ( const sc_logic&, sc_bitref<T> ); + +template <class T> +inline +sc_concref_r<sc_bitref_r<T>,sc_lv_base> +operator , ( sc_bitref<T>, bool ); + +template <class T> +inline +sc_concref_r<sc_lv_base,sc_bitref_r<T> > +operator , ( bool, sc_bitref<T> ); + + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> > +concat( sc_bitref_r<T1>, sc_bitref<T2> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> > +concat( sc_bitref<T1>, sc_bitref_r<T2> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> > +concat( sc_bitref_r<T1>, sc_subref<T2> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> > +concat( sc_bitref<T1>, sc_subref_r<T2> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> > +concat( sc_bitref_r<T1>, sc_concref<T2,T3> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> > +concat( sc_bitref<T1>, sc_concref_r<T2,T3> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,T2> +concat( sc_bitref<T1>, const sc_proxy<T2>& ); + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,T2> +concat( sc_bitref_r<T1>, sc_proxy<T2>& ); + +template <class T> +inline +sc_concref_r<sc_bitref_r<T>,sc_lv_base> +concat( sc_bitref<T>, const char* ); + +template <class T> +inline +sc_concref_r<sc_lv_base,sc_bitref_r<T> > +concat( const char*, sc_bitref<T> ); + +template <class T> +inline +sc_concref_r<sc_bitref_r<T>,sc_lv_base> +concat( sc_bitref<T>, const sc_logic& ); + +template <class T> +inline +sc_concref_r<sc_lv_base,sc_bitref_r<T> > +concat( const sc_logic&, sc_bitref<T> ); + +template <class T> +inline +sc_concref_r<sc_bitref_r<T>,sc_lv_base> +concat( sc_bitref<T>, bool ); + +template <class T> +inline +sc_concref_r<sc_lv_base,sc_bitref_r<T> > +concat( bool, sc_bitref<T> ); + +#endif + + +// ---------------------------------------------------------------------------- +// CLASS TEMPLATE : sc_bitref<X> +// +// Proxy class for sc_proxy bit selection (r-value and l-value). +// ---------------------------------------------------------------------------- + +template <class X> +class sc_bitref + : public sc_bitref_r<X> +{ + friend class sc_bv_base; + friend class sc_lv_base; + +public: + + // constructor + + sc_bitref( X& obj_, int index_ ) + : sc_bitref_r<X>( obj_, index_ ) + {} + + + // copy constructor + + sc_bitref( const sc_bitref<X>& a ) + : sc_bitref_r<X>( a ) + {} + + + // cloning + + sc_bitref<X>* clone() const + { return new sc_bitref<X>( *this ); } + + + // assignment operators + + sc_bitref<X>& operator = ( const sc_bitref_r<X>& a ); + sc_bitref<X>& operator = ( const sc_bitref<X>& a ); + + sc_bitref<X>& operator = ( const sc_logic& a ) + { this->m_obj.set_bit( this->m_index, a.value() ); return *this; } + + sc_bitref<X>& operator = ( sc_logic_value_t v ) + { *this = sc_logic( v ); return *this; } + + sc_bitref<X>& operator = ( bool a ) + { *this = sc_logic( a ); return *this; } + + sc_bitref<X>& operator = ( char a ) + { *this = sc_logic( a ); return *this; } + + sc_bitref<X>& operator = ( int a ) + { *this = sc_logic( a ); return *this; } + + sc_bitref<X>& operator = ( const sc_bit& a ) + { *this = sc_logic( a ); return *this; } + + + // bitwise assignment operators + + sc_bitref<X>& operator &= ( const sc_bitref_r<X>& a ); + sc_bitref<X>& operator &= ( const sc_logic& a ); + + sc_bitref<X>& operator &= ( sc_logic_value_t v ) + { *this &= sc_logic( v ); return *this; } + + sc_bitref<X>& operator &= ( bool a ) + { *this &= sc_logic( a ); return *this; } + + sc_bitref<X>& operator &= ( char a ) + { *this &= sc_logic( a ); return *this; } + + sc_bitref<X>& operator &= ( int a ) + { *this &= sc_logic( a ); return *this; } + + + sc_bitref<X>& operator |= ( const sc_bitref_r<X>& a ); + sc_bitref<X>& operator |= ( const sc_logic& a ); + + sc_bitref<X>& operator |= ( sc_logic_value_t v ) + { *this |= sc_logic( v ); return *this; } + + sc_bitref<X>& operator |= ( bool a ) + { *this |= sc_logic( a ); return *this; } + + sc_bitref<X>& operator |= ( char a ) + { *this |= sc_logic( a ); return *this; } + + sc_bitref<X>& operator |= ( int a ) + { *this |= sc_logic( a ); return *this; } + + + sc_bitref<X>& operator ^= ( const sc_bitref_r<X>& a ); + sc_bitref<X>& operator ^= ( const sc_logic& a ); + + sc_bitref<X>& operator ^= ( sc_logic_value_t v ) + { *this ^= sc_logic( v ); return *this; } + + sc_bitref<X>& operator ^= ( bool a ) + { *this ^= sc_logic( a ); return *this; } + + sc_bitref<X>& operator ^= ( char a ) + { *this ^= sc_logic( a ); return *this; } + + sc_bitref<X>& operator ^= ( int a ) + { *this ^= sc_logic( a ); return *this; } + + + // bitwise operators and functions + + // bitwise complement + + sc_bitref<X>& b_not(); + + + // common methods + + void set_bit( int n, sc_logic_value_t value ); + + void set_word( int i, sc_digit w ); + void set_cword( int i, sc_digit w ); + + void clean_tail() + { this->m_obj.clean_tail(); } + + + // other methods + + void scan( ::std::istream& is = ::std::cin ); + +private: + + // disabled + sc_bitref(); +}; + + +// l-value concatenation operators and functions + +template <class T1, class T2> +inline +sc_concref<sc_bitref<T1>,sc_bitref<T2> > +operator , ( sc_bitref<T1>, sc_bitref<T2> ); + +template <class T1, class T2> +inline +sc_concref<sc_bitref<T1>,sc_subref<T2> > +operator , ( sc_bitref<T1>, sc_subref<T2> ); + +template <class T1, class T2, class T3> +inline +sc_concref<sc_bitref<T1>,sc_concref<T2,T3> > +operator , ( sc_bitref<T1>, sc_concref<T2,T3> ); + +template <class T1, class T2> +inline +sc_concref<sc_bitref<T1>,T2> +operator , ( sc_bitref<T1>, sc_proxy<T2>& ); + + +template <class T1, class T2> +inline +sc_concref<sc_bitref<T1>,sc_bitref<T2> > +concat( sc_bitref<T1>, sc_bitref<T2> ); + +template <class T1, class T2> +inline +sc_concref<sc_bitref<T1>,sc_subref<T2> > +concat( sc_bitref<T1>, sc_subref<T2> ); + +template <class T1, class T2, class T3> +inline +sc_concref<sc_bitref<T1>,sc_concref<T2,T3> > +concat( sc_bitref<T1>, sc_concref<T2,T3> ); + +template <class T1, class T2> +inline +sc_concref<sc_bitref<T1>,T2> +concat( sc_bitref<T1>, sc_proxy<T2>& ); + + +template <class T> +::std::istream& +operator >> ( ::std::istream&, sc_bitref<T> ); + + +// ---------------------------------------------------------------------------- +// CLASS TEMPLATE : sc_subref_r<X> +// +// Proxy class for sc_proxy part selection (r-value only). +// ---------------------------------------------------------------------------- + +template <class X> +class sc_subref_r + : public sc_proxy<sc_subref_r<X> > +{ + void check_bounds(); + +public: + + // constructor + + sc_subref_r( const X& obj_, int hi_, int lo_ ) + : m_obj( CCAST<X&>( obj_ ) ), m_hi( hi_ ), m_lo( lo_ ), m_len( 0 ) + { check_bounds(); } + + + // copy constructor + + sc_subref_r( const sc_subref_r<X>& a ) + : m_obj( a.m_obj ), m_hi( a.m_hi ), m_lo( a.m_lo ), m_len( a.m_len ) + {} + + + // cloning + + sc_subref_r<X>* clone() const + { return new sc_subref_r<X>( *this ); } + + + // common methods + + int length() const + { return m_len; } + + int size() const + { return ( (length() - 1) / SC_DIGIT_SIZE + 1 ); } + + sc_logic_value_t get_bit( int n ) const; + void set_bit( int n, sc_logic_value_t value ); + + sc_digit get_word( int i )const; + void set_word( int i, sc_digit w ); + + sc_digit get_cword( int i ) const; + void set_cword( int i, sc_digit w ); + + void clean_tail() + { m_obj.clean_tail(); } + + + // other methods + + bool is_01() const; + + bool reversed() const + { return m_lo > m_hi; } + +protected: + + X& m_obj; + int m_hi; + int m_lo; + int m_len; + +private: + + // disabled + sc_subref_r(); + sc_subref_r<X>& operator = ( const sc_subref_r<X>& ); +}; + + +// r-value concatenation operators and functions + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> > +operator , ( sc_subref_r<T1>, sc_bitref_r<T2> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> > +operator , ( sc_subref_r<T1>, sc_subref_r<T2> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> > +operator , ( sc_subref_r<T1>, sc_concref_r<T2,T3> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,T2> +operator , ( sc_subref_r<T1>, const sc_proxy<T2>& ); + +template <class T> +inline +sc_concref_r<sc_subref_r<T>,sc_lv_base> +operator , ( sc_subref_r<T>, const char* ); + +template <class T> +inline +sc_concref_r<sc_lv_base,sc_subref_r<T> > +operator , ( const char*, sc_subref_r<T> ); + +template <class T> +inline +sc_concref_r<sc_subref_r<T>,sc_lv_base> +operator , ( sc_subref_r<T>, const sc_logic& ); + +template <class T> +inline +sc_concref_r<sc_lv_base,sc_subref_r<T> > +operator , ( const sc_logic&, sc_subref_r<T> ); + +template <class T> +inline +sc_concref_r<sc_subref_r<T>,sc_bv_base> +operator , ( sc_subref_r<T>, bool ); + +template <class T> +inline +sc_concref_r<sc_bv_base,sc_subref_r<T> > +operator , ( bool, sc_subref_r<T> ); + + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> > +concat( sc_subref_r<T1>, sc_bitref_r<T2> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> > +concat( sc_subref_r<T1>, sc_subref_r<T2> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> > +concat( sc_subref_r<T1>, sc_concref_r<T2,T3> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,T2> +concat( sc_subref_r<T1>, const sc_proxy<T2>& ); + +template <class T> +inline +sc_concref_r<sc_subref_r<T>,sc_lv_base> +concat( sc_subref_r<T>, const char* ); + +template <class T> +inline +sc_concref_r<sc_lv_base,sc_subref_r<T> > +concat( const char*, sc_subref_r<T> ); + +template <class T> +inline +sc_concref_r<sc_subref_r<T>,sc_lv_base> +concat( sc_subref_r<T>, const sc_logic& ); + +template <class T> +inline +sc_concref_r<sc_lv_base,sc_subref_r<T> > +concat( const sc_logic&, sc_subref_r<T> ); + +template <class T> +inline +sc_concref_r<sc_subref_r<T>,sc_bv_base> +concat( sc_subref_r<T>, bool ); + +template <class T> +inline +sc_concref_r<sc_bv_base,sc_subref_r<T> > +concat( bool, sc_subref_r<T> ); + + +#ifdef SC_DT_MIXED_COMMA_OPERATORS + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> > +operator , ( sc_subref_r<T1>, sc_bitref<T2> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> > +operator , ( sc_subref<T1>, sc_bitref_r<T2> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> > +operator , ( sc_subref_r<T1>, sc_subref<T2> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> > +operator , ( sc_subref<T1>, sc_subref_r<T2> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> > +operator , ( sc_subref_r<T1>, sc_concref<T2,T3> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> > +operator , ( sc_subref<T1>, sc_concref_r<T2,T3> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,T2> +operator , ( sc_subref<T1>, const sc_proxy<T2>& ); + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,T2> +operator , ( sc_subref_r<T1>, sc_proxy<T2>& ); + +template <class T> +inline +sc_concref_r<sc_subref_r<T>,sc_lv_base> +operator , ( sc_subref<T>, const char* ); + +template <class T> +inline +sc_concref_r<sc_lv_base,sc_subref_r<T> > +operator , ( const char*, sc_subref<T> ); + +template <class T> +inline +sc_concref_r<sc_subref_r<T>,sc_lv_base> +operator , ( sc_subref<T>, const sc_logic& ); + +template <class T> +inline +sc_concref_r<sc_lv_base,sc_subref_r<T> > +operator , ( const sc_logic&, sc_subref<T> ); + +template <class T> +inline +sc_concref_r<sc_subref_r<T>,sc_bv_base> +operator , ( sc_subref<T>, bool ); + +template <class T> +inline +sc_concref_r<sc_bv_base,sc_subref_r<T> > +operator , ( bool, sc_subref<T> ); + + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> > +concat( sc_subref_r<T1>, sc_bitref<T2> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> > +concat( sc_subref<T1>, sc_bitref_r<T2> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> > +concat( sc_subref_r<T1>, sc_subref<T2> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> > +concat( sc_subref<T1>, sc_subref_r<T2> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> > +concat( sc_subref_r<T1>, sc_concref<T2,T3> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> > +concat( sc_subref<T1>, sc_concref_r<T2,T3> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,T2> +concat( sc_subref<T1>, const sc_proxy<T2>& ); + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,T2> +concat( sc_subref_r<T1>, sc_proxy<T2>& ); + +template <class T> +inline +sc_concref_r<sc_subref_r<T>,sc_lv_base> +concat( sc_subref<T>, const char* ); + +template <class T> +inline +sc_concref_r<sc_lv_base,sc_subref_r<T> > +concat( const char*, sc_subref<T> ); + +template <class T> +inline +sc_concref_r<sc_subref_r<T>,sc_lv_base> +concat( sc_subref<T>, const sc_logic& ); + +template <class T> +inline +sc_concref_r<sc_lv_base,sc_subref_r<T> > +concat( const sc_logic&, sc_subref<T> ); + +template <class T> +inline +sc_concref_r<sc_subref_r<T>,sc_bv_base> +concat( sc_subref<T>, bool ); + +template <class T> +inline +sc_concref_r<sc_bv_base,sc_subref_r<T> > +concat( bool, sc_subref<T> ); + +#endif + + +// ---------------------------------------------------------------------------- +// CLASS TEMPLATE : sc_subref<X> +// +// Proxy class for sc_proxy part selection (r-value and l-value). +// ---------------------------------------------------------------------------- + +template <class X> +class sc_subref + : public sc_subref_r<X> +{ +public: + + // typedefs + + typedef sc_subref_r<X> base_type; + + + // constructor + + sc_subref( X& obj_, int hi_, int lo_ ) + : sc_subref_r<X>( obj_, hi_, lo_ ) + {} + + + // copy constructor + + sc_subref( const sc_subref<X>& a ) + : sc_subref_r<X>( a ) + {} + + + // cloning + + sc_subref<X>* clone() const + { return new sc_subref<X>( *this ); } + + + // assignment operators + + template <class Y> + sc_subref<X>& operator = ( const sc_proxy<Y>& a ) + { base_type::assign_( a ); return *this; } + + sc_subref<X>& operator = ( const sc_subref_r<X>& a ); + sc_subref<X>& operator = ( const sc_subref<X>& a ); + + sc_subref<X>& operator = ( const char* a ) + { base_type::assign_( a ); return *this; } + + sc_subref<X>& operator = ( const bool* a ) + { base_type::assign_( a ); return *this; } + + sc_subref<X>& operator = ( const sc_logic* a ) + { base_type::assign_( a ); return *this; } + + sc_subref<X>& operator = ( const sc_unsigned& a ) + { base_type::assign_( a ); return *this; } + + sc_subref<X>& operator = ( const sc_signed& a ) + { base_type::assign_( a ); return *this; } + + sc_subref<X>& operator = ( const sc_uint_base& a ) + { base_type::assign_( a ); return *this; } + + sc_subref<X>& operator = ( const sc_int_base& a ) + { base_type::assign_( a ); return *this; } + + sc_subref<X>& operator = ( unsigned long a ) + { base_type::assign_( a ); return *this; } + + sc_subref<X>& operator = ( long a ) + { base_type::assign_( a ); return *this; } + + sc_subref<X>& operator = ( unsigned int a ) + { base_type::assign_( a ); return *this; } + + sc_subref<X>& operator = ( int a ) + { base_type::assign_( a ); return *this; } + + sc_subref<X>& operator = ( uint64 a ) + { base_type::assign_( a ); return *this; } + + sc_subref<X>& operator = ( int64 a ) + { base_type::assign_( a ); return *this; } + + + // other methods + + void scan( ::std::istream& = ::std::cin ); + +private: + + // disabled + sc_subref(); +}; + + +// l-value concatenation operators and functions + +template <class T1, class T2> +inline +sc_concref<sc_subref<T1>,sc_bitref<T2> > +operator , ( sc_subref<T1>, sc_bitref<T2> ); + +template <class T1, class T2> +inline +sc_concref<sc_subref<T1>,sc_subref<T2> > +operator , ( sc_subref<T1>, sc_subref<T2> ); + +template <class T1, class T2, class T3> +inline +sc_concref<sc_subref<T1>,sc_concref<T2,T3> > +operator , ( sc_subref<T1>, sc_concref<T2,T3> ); + +template <class T1, class T2> +inline +sc_concref<sc_subref<T1>,T2> +operator , ( sc_subref<T1>, sc_proxy<T2>& ); + + +template <class T1, class T2> +inline +sc_concref<sc_subref<T1>,sc_bitref<T2> > +concat( sc_subref<T1>, sc_bitref<T2> ); + +template <class T1, class T2> +inline +sc_concref<sc_subref<T1>,sc_subref<T2> > +concat( sc_subref<T1>, sc_subref<T2> ); + +template <class T1, class T2, class T3> +inline +sc_concref<sc_subref<T1>,sc_concref<T2,T3> > +concat( sc_subref<T1>, sc_concref<T2,T3> ); + +template <class T1, class T2> +inline +sc_concref<sc_subref<T1>,T2> +concat( sc_subref<T1>, sc_proxy<T2>& ); + + +template <class T> +inline +::std::istream& +operator >> ( ::std::istream&, sc_subref<T> ); + + +// ---------------------------------------------------------------------------- +// CLASS TEMPLATE : sc_concref_r<X,Y> +// +// Proxy class for sc_proxy concatenation (r-value only). +// ---------------------------------------------------------------------------- + +template <class X, class Y> +class sc_concref_r + : public sc_proxy<sc_concref_r<X,Y> > +{ +public: + + // constructor + + sc_concref_r( const X& left_, const Y& right_, int delete_ = 0 ) + : m_left( CCAST<X&>( left_ ) ), m_right( CCAST<Y&>( right_ ) ), + m_delete( delete_ ), m_refs( *new int( 1 ) ) + {} + + + // copy constructor + + sc_concref_r( const sc_concref_r<X,Y>& a ) + : m_left( a.m_left ), m_right( a.m_right ), + m_delete( a.m_delete ), m_refs( a.m_refs ) + { ++ m_refs; } + + + // destructor + + virtual ~sc_concref_r(); + + + // cloning + + sc_concref_r<X,Y>* clone() const + { return new sc_concref_r<X,Y>( *this ); } + + + // common methods + + int length() const + { return ( m_left.length() + m_right.length() ); } + + int size() const + { return ( (length() - 1) / SC_DIGIT_SIZE + 1 ); } + + sc_logic_value_t get_bit( int n ) const; + void set_bit( int n, sc_logic_value_t value ); + + sc_digit get_word( int i ) const; + void set_word( int i, sc_digit w ); + + sc_digit get_cword( int i ) const; + void set_cword( int i, sc_digit w ); + + void clean_tail() + { m_left.clean_tail(); m_right.clean_tail(); } + + + // other methods + + bool is_01() const + { return ( m_left.is_01() && m_right.is_01() ); } + +protected: + + X& m_left; + Y& m_right; + mutable int m_delete; + int& m_refs; + +private: + + // disabled + sc_concref_r(); + sc_concref_r<X,Y>& operator = ( const sc_concref_r<X,Y>& ); +}; + + +// r-value concatenation operators and functions + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> > +operator , ( sc_concref_r<T1,T2>, sc_bitref_r<T3> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> > +operator , ( sc_concref_r<T1,T2>, sc_subref_r<T3> ); + +template <class T1, class T2, class T3, class T4> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> > +operator , ( sc_concref_r<T1,T2>, sc_concref_r<T3,T4> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,T3> +operator , ( sc_concref_r<T1,T2>, const sc_proxy<T3>& ); + +template <class T1, class T2> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base> +operator , ( sc_concref_r<T1,T2>, const char* ); + +template <class T1, class T2> +inline +sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> > +operator , ( const char*, sc_concref_r<T1,T2> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base> +operator , ( sc_concref_r<T1,T2>, const sc_logic& ); + +template <class T1, class T2> +inline +sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> > +operator , ( const sc_logic&, sc_concref_r<T1,T2> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_bv_base> +operator , ( sc_concref_r<T1,T2>, bool ); + +template <class T1, class T2> +inline +sc_concref_r<sc_bv_base,sc_concref_r<T1,T2> > +operator , ( bool, sc_concref_r<T1,T2> ); + + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> > +concat( sc_concref_r<T1,T2>, sc_bitref_r<T3> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> > +concat( sc_concref_r<T1,T2>, sc_subref_r<T3> ); + +template <class T1, class T2, class T3, class T4> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> > +concat( sc_concref_r<T1,T2>, sc_concref_r<T3,T4> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,T3> +concat( sc_concref_r<T1,T2>, const sc_proxy<T3>& ); + +template <class T1, class T2> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base> +concat( sc_concref_r<T1,T2>, const char* ); + +template <class T1, class T2> +inline +sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> > +concat( const char*, sc_concref_r<T1,T2> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base> +concat( sc_concref_r<T1,T2>, const sc_logic& ); + +template <class T1, class T2> +inline +sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> > +concat( const sc_logic&, sc_concref_r<T1,T2> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_bv_base> +concat( sc_concref_r<T1,T2>, bool ); + +template <class T1, class T2> +inline +sc_concref_r<sc_bv_base,sc_concref_r<T1,T2> > +concat( bool, sc_concref_r<T1,T2> ); + + +#ifdef SC_DT_MIXED_COMMA_OPERATORS + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> > +operator , ( sc_concref_r<T1,T2>, sc_bitref<T3> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> > +operator , ( sc_concref<T1,T2>, sc_bitref_r<T3> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> > +operator , ( sc_concref_r<T1,T2>, sc_subref<T3> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> > +operator , ( sc_concref<T1,T2>, sc_subref_r<T3> ); + +template <class T1, class T2, class T3, class T4> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> > +operator , ( sc_concref_r<T1,T2>, sc_concref<T3,T4> ); + +template <class T1, class T2, class T3, class T4> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> > +operator , ( sc_concref<T1,T2>, sc_concref_r<T3,T4> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,T3> +operator , ( sc_concref<T1,T2>, const sc_proxy<T3>& ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,T3> +operator , ( sc_concref_r<T1,T2>, sc_proxy<T3>& ); + +template <class T1, class T2> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base> +operator , ( sc_concref<T1,T2>, const char* ); + +template <class T1, class T2> +inline +sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> > +operator , ( const char*, sc_concref<T1,T2> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base> +operator , ( sc_concref<T1,T2>, const sc_logic& ); + +template <class T1, class T2> +inline +sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> > +operator , ( const sc_logic&, sc_concref<T1,T2> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_bv_base> +operator , ( sc_concref<T1,T2>, bool ); + +template <class T1, class T2> +inline +sc_concref_r<sc_bv_base,sc_concref_r<T1,T2> > +operator , ( bool, sc_concref<T1,T2> ); + + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> > +concat( sc_concref_r<T1,T2>, sc_bitref<T3> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> > +concat( sc_concref<T1,T2>, sc_bitref_r<T3> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> > +concat( sc_concref_r<T1,T2>, sc_subref<T3> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> > +concat( sc_concref<T1,T2>, sc_subref_r<T3> ); + +template <class T1, class T2, class T3, class T4> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> > +concat( sc_concref_r<T1,T2>, sc_concref<T3,T4> ); + +template <class T1, class T2, class T3, class T4> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> > +concat( sc_concref<T1,T2>, sc_concref_r<T3,T4> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,T3> +concat( sc_concref<T1,T2>, const sc_proxy<T3>& ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,T3> +concat( sc_concref_r<T1,T2>, sc_proxy<T3>& ); + +template <class T1, class T2> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base> +concat( sc_concref<T1,T2>, const char* ); + +template <class T1, class T2> +inline +sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> > +concat( const char*, sc_concref<T1,T2> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base> +concat( sc_concref<T1,T2>, const sc_logic& ); + +template <class T1, class T2> +inline +sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> > +concat( const sc_logic&, sc_concref<T1,T2> ); + +template <class T1, class T2> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_bv_base> +concat( sc_concref<T1,T2>, bool ); + +template <class T1, class T2> +inline +sc_concref_r<sc_bv_base,sc_concref_r<T1,T2> > +concat( bool, sc_concref<T1,T2> ); + +#endif + + +// ---------------------------------------------------------------------------- +// CLASS TEMPLATE : sc_concref<X,Y> +// +// Proxy class for sc_proxy concatenation (r-value and l-value). +// ---------------------------------------------------------------------------- + +template <class X, class Y> +class sc_concref + : public sc_concref_r<X,Y> +{ +public: + + // typedefs + + typedef sc_concref_r<X,Y> base_type; + + + // constructor + + sc_concref( X& left_, Y& right_, int delete_ = 0 ) + : sc_concref_r<X,Y>( left_, right_, delete_ ) + {} + + + // copy constructor + + sc_concref( const sc_concref<X,Y>& a ) + : sc_concref_r<X,Y>( a ) + {} + + + // cloning + + sc_concref<X,Y>* clone() const + { return new sc_concref<X,Y>( *this ); } + + + // assignment operators + + template <class Z> + sc_concref<X,Y>& operator = ( const sc_proxy<Z>& a ) + { base_type::assign_( a ); return *this; } + + sc_concref<X,Y>& operator = ( const sc_concref<X,Y>& a ) + { base_type::assign_( a ); return *this; } + + sc_concref<X,Y>& operator = ( const char* a ) + { base_type::assign_( a ); return *this; } + + sc_concref<X,Y>& operator = ( const bool* a ) + { base_type::assign_( a ); return *this; } + + sc_concref<X,Y>& operator = ( const sc_logic* a ) + { base_type::assign_( a ); return *this; } + + sc_concref<X,Y>& operator = ( const sc_unsigned& a ) + { base_type::assign_( a ); return *this; } + + sc_concref<X,Y>& operator = ( const sc_signed& a ) + { base_type::assign_( a ); return *this; } + + sc_concref<X,Y>& operator = ( const sc_uint_base& a ) + { base_type::assign_( a ); return *this; } + + sc_concref<X,Y>& operator = ( const sc_int_base& a ) + { base_type::assign_( a ); return *this; } + + sc_concref<X,Y>& operator = ( unsigned long a ) + { base_type::assign_( a ); return *this; } + + sc_concref<X,Y>& operator = ( long a ) + { base_type::assign_( a ); return *this; } + + sc_concref<X,Y>& operator = ( unsigned int a ) + { base_type::assign_( a ); return *this; } + + sc_concref<X,Y>& operator = ( int a ) + { base_type::assign_( a ); return *this; } + + sc_concref<X,Y>& operator = ( uint64 a ) + { base_type::assign_( a ); return *this; } + + sc_concref<X,Y>& operator = ( int64 a ) + { base_type::assign_( a ); return *this; } + + + // other methods + + void scan( ::std::istream& = ::std::cin ); + +private: + + // disabled + sc_concref(); +}; + + +// l-value concatenation operators and functions + +template <class T1, class T2, class T3> +inline +sc_concref<sc_concref<T1,T2>,sc_bitref<T3> > +operator , ( sc_concref<T1,T2>, sc_bitref<T3> ); + +template <class T1, class T2, class T3> +inline +sc_concref<sc_concref<T1,T2>,sc_subref<T3> > +operator , ( sc_concref<T1,T2>, sc_subref<T3> ); + +template <class T1, class T2, class T3, class T4> +inline +sc_concref<sc_concref<T1,T2>,sc_concref<T3,T4> > +operator , ( sc_concref<T1,T2>, sc_concref<T3,T4> ); + +template <class T1, class T2, class T3> +inline +sc_concref<sc_concref<T1,T2>,T3> +operator , ( sc_concref<T1,T2>, sc_proxy<T3>& ); + + +template <class T1, class T2, class T3> +inline +sc_concref<sc_concref<T1,T2>,sc_bitref<T3> > +concat( sc_concref<T1,T2>, sc_bitref<T3> ); + +template <class T1, class T2, class T3> +inline +sc_concref<sc_concref<T1,T2>,sc_subref<T3> > +concat( sc_concref<T1,T2>, sc_subref<T3> ); + +template <class T1, class T2, class T3, class T4> +inline +sc_concref<sc_concref<T1,T2>,sc_concref<T3,T4> > +concat( sc_concref<T1,T2>, sc_concref<T3,T4> ); + +template <class T1, class T2, class T3> +inline +sc_concref<sc_concref<T1,T2>,T3> +concat( sc_concref<T1,T2>, sc_proxy<T3>& ); + + +template <class T1, class T2> +inline +::std::istream& +operator >> ( ::std::istream&, sc_concref<T1,T2> ); + + +// ---------------------------------------------------------------------------- +// CLASS TEMPLATE : sc_proxy<T> +// +// Base class template for bit/logic vector classes. +// (Barton/Nackmann implementation) +// ---------------------------------------------------------------------------- + +// r-value concatenation operators and functions + +template <class T1, class T2> +inline +sc_concref_r<T1,sc_bitref_r<T2> > +operator , ( const sc_proxy<T1>&, sc_bitref_r<T2> ); + +template <class T1, class T2> +inline +sc_concref_r<T1,sc_subref_r<T2> > +operator , ( const sc_proxy<T1>&, sc_subref_r<T2> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<T1,sc_concref_r<T2,T3> > +operator , ( const sc_proxy<T1>&, sc_concref_r<T2,T3> ); + +template <class T1, class T2> +inline +sc_concref_r<T1,T2> +operator , ( const sc_proxy<T1>&, const sc_proxy<T2>& ); + +template <class T> +inline +sc_concref_r<T,sc_lv_base> +operator , ( const sc_proxy<T>&, const char* ); + +template <class T> +inline +sc_concref_r<sc_lv_base,T> +operator , ( const char*, const sc_proxy<T>& ); + +template <class T> +inline +sc_concref_r<T,sc_lv_base> +operator , ( const sc_proxy<T>&, const sc_logic& ); + +template <class T> +inline +sc_concref_r<sc_lv_base,T> +operator , ( const sc_logic&, const sc_proxy<T>& ); + +template <class T> +inline +sc_concref_r<T,sc_bv_base> +operator , ( const sc_proxy<T>&, bool ); + +template <class T> +inline +sc_concref_r<sc_bv_base,T> +operator , ( bool, const sc_proxy<T>& ); + + +template <class T1, class T2> +inline +sc_concref_r<T1,sc_bitref_r<T2> > +concat( const sc_proxy<T1>&, sc_bitref_r<T2> ); + +template <class T1, class T2> +inline +sc_concref_r<T1,sc_subref_r<T2> > +concat( const sc_proxy<T1>&, sc_subref_r<T2> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<T1,sc_concref_r<T2,T3> > +concat( const sc_proxy<T1>&, sc_concref_r<T2,T3> ); + +template <class T1, class T2> +inline +sc_concref_r<T1,T2> +concat( const sc_proxy<T1>&, const sc_proxy<T2>& ); + +template <class T> +inline +sc_concref_r<T,sc_lv_base> +concat( const sc_proxy<T>&, const char* ); + +template <class T> +inline +sc_concref_r<sc_lv_base,T> +concat( const char*, const sc_proxy<T>& ); + +template <class T> +inline +sc_concref_r<T,sc_lv_base> +concat( const sc_proxy<T>&, const sc_logic& ); + +template <class T> +inline +sc_concref_r<sc_lv_base,T> +concat( const sc_logic&, const sc_proxy<T>& ); + +template <class T> +inline +sc_concref_r<T,sc_bv_base> +concat( const sc_proxy<T>&, bool ); + +template <class T> +inline +sc_concref_r<sc_bv_base,T> +concat( bool, const sc_proxy<T>& ); + + +#ifdef SC_DT_MIXED_COMMA_OPERATORS + +template <class T1, class T2> +inline +sc_concref_r<T1,sc_bitref_r<T2> > +operator , ( const sc_proxy<T1>&, sc_bitref<T2> ); + +template <class T1, class T2> +inline +sc_concref_r<T1,sc_bitref_r<T2> > +operator , ( sc_proxy<T1>&, sc_bitref_r<T2> ); + +template <class T1, class T2> +inline +sc_concref_r<T1,sc_subref_r<T2> > +operator , ( const sc_proxy<T1>&, sc_subref<T2> ); + +template <class T1, class T2> +inline +sc_concref_r<T1,sc_subref_r<T2> > +operator , ( sc_proxy<T1>&, sc_subref_r<T2> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<T1,sc_concref_r<T2,T3> > +operator , ( const sc_proxy<T1>&, sc_concref<T2,T3> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<T1,sc_concref_r<T2,T3> > +operator , ( sc_proxy<T1>&, sc_concref_r<T2,T3> ); + +template <class T1, class T2> +inline +sc_concref_r<T1,T2> +operator , ( const sc_proxy<T1>&, sc_proxy<T2>& ); + +template <class T1, class T2> +inline +sc_concref_r<T1,T2> +operator , ( sc_proxy<T1>&, const sc_proxy<T2>& ); + +template <class T> +inline +sc_concref_r<T,sc_lv_base> +operator , ( sc_proxy<T>&, const char* ); + +template <class T> +inline +sc_concref_r<sc_lv_base,T> +operator , ( const char*, sc_proxy<T>& ); + +template <class T> +inline +sc_concref_r<T,sc_lv_base> +operator , ( sc_proxy<T>&, const sc_logic& ); + +template <class T> +inline +sc_concref_r<sc_lv_base,T> +operator , ( const sc_logic&, sc_proxy<T>& ); + +template <class T> +inline +sc_concref_r<T,sc_bv_base> +operator , ( sc_proxy<T>&, bool ); + +template <class T> +inline +sc_concref_r<sc_bv_base,T> +operator , ( bool, sc_proxy<T>& ); + + +template <class T1, class T2> +inline +sc_concref_r<T1,sc_bitref_r<T2> > +concat( const sc_proxy<T1>&, sc_bitref<T2> ); + +template <class T1, class T2> +inline +sc_concref_r<T1,sc_bitref_r<T2> > +concat( sc_proxy<T1>&, sc_bitref_r<T2> ); + +template <class T1, class T2> +inline +sc_concref_r<T1,sc_subref_r<T2> > +concat( const sc_proxy<T1>&, sc_subref<T2> ); + +template <class T1, class T2> +inline +sc_concref_r<T1,sc_subref_r<T2> > +concat( sc_proxy<T1>&, sc_subref_r<T2> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<T1,sc_concref_r<T2,T3> > +concat( const sc_proxy<T1>&, sc_concref<T2,T3> ); + +template <class T1, class T2, class T3> +inline +sc_concref_r<T1,sc_concref_r<T2,T3> > +concat( sc_proxy<T1>&, sc_concref_r<T2,T3> ); + +template <class T1, class T2> +inline +sc_concref_r<T1,T2> +concat( const sc_proxy<T1>&, sc_proxy<T2>& ); + +template <class T1, class T2> +inline +sc_concref_r<T1,T2> +concat( sc_proxy<T1>&, const sc_proxy<T2>& ); + +template <class T> +inline +sc_concref_r<T,sc_lv_base> +concat( sc_proxy<T>&, const char* ); + +template <class T> +inline +sc_concref_r<sc_lv_base,T> +concat( const char*, sc_proxy<T>& ); + +template <class T> +inline +sc_concref_r<T,sc_lv_base> +concat( sc_proxy<T>&, const sc_logic& ); + +template <class T> +inline +sc_concref_r<sc_lv_base,T> +concat( const sc_logic&, sc_proxy<T>& ); + +template <class T> +inline +sc_concref_r<T,sc_bv_base> +concat( sc_proxy<T>&, bool ); + +template <class T> +inline +sc_concref_r<sc_bv_base,T> +concat( bool, sc_proxy<T>& ); + +#endif + + +// l-value concatenation operators and functions + +template <class T1, class T2> +inline +sc_concref<T1,sc_bitref<T2> > +operator , ( sc_proxy<T1>&, sc_bitref<T2> ); + +template <class T1, class T2> +inline +sc_concref<T1,sc_subref<T2> > +operator , ( sc_proxy<T1>&, sc_subref<T2> ); + +template <class T1, class T2, class T3> +inline +sc_concref<T1,sc_concref<T2,T3> > +operator , ( sc_proxy<T1>&, sc_concref<T2,T3> ); + +template <class T1, class T2> +inline +sc_concref<T1,T2> +operator , ( sc_proxy<T1>&, sc_proxy<T2>& ); + + +template <class T1, class T2> +inline +sc_concref<T1,sc_bitref<T2> > +concat( sc_proxy<T1>&, sc_bitref<T2> ); + +template <class T1, class T2> +inline +sc_concref<T1,sc_subref<T2> > +concat( sc_proxy<T1>&, sc_subref<T2> ); + +template <class T1, class T2, class T3> +inline +sc_concref<T1,sc_concref<T2,T3> > +concat( sc_proxy<T1>&, sc_concref<T2,T3> ); + +template <class T1, class T2> +inline +sc_concref<T1,T2> +concat( sc_proxy<T1>&, sc_proxy<T2>& ); + + +// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII + +// ---------------------------------------------------------------------------- +// CLASS TEMPLATE : sc_bitref_r<T> +// +// Proxy class for sc_proxy bit selection (r-value only). +// ---------------------------------------------------------------------------- + +// bitwise operators and functions + +// bitwise and + +template <class T1, class T2> +inline +const sc_logic +operator & ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b ) +{ + return sc_logic( sc_logic::and_table[a.value()][b.value()] ); +} + + +// bitwise or + +template <class T1, class T2> +inline +const sc_logic +operator | ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b ) +{ + return sc_logic( sc_logic::or_table[a.value()][b.value()] ); +} + + +// bitwise xor + +template <class T1, class T2> +inline +const sc_logic +operator ^ ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b ) +{ + return sc_logic( sc_logic::xor_table[a.value()][b.value()] ); +} + + +// relational operators and functions + +template <class T1, class T2> +inline +bool +operator == ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b ) +{ + return ( (int) a.value() == b.value() ); +} + +template <class T1, class T2> +inline +bool +operator != ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b ) +{ + return ( (int) a.value() != b.value() ); +} + + +// common methods + +template <class T> +inline +sc_logic_value_t +sc_bitref_r<T>::get_bit( int n ) const +{ + if( n == 0 ) { + return m_obj.get_bit( m_index ); + } else { + SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_ , 0 ); + // never reached + return Log_0; + } +} + + +template <class T> +inline +sc_digit +sc_bitref_r<T>::get_word( int n ) const +{ + if( n == 0 ) { + return ( get_bit( n ) & SC_DIGIT_ONE ); + } else { + SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 ); + // never reached + return 0; + } +} + +template <class T> +inline +sc_digit +sc_bitref_r<T>::get_cword( int n ) const +{ + if( n == 0 ) { + return ( (get_bit( n ) & SC_DIGIT_TWO) >> 1 ); + } else { + SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 ); + // never reached + return 0; + } +} + + +// r-value concatenation operators and functions + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> > +operator , ( sc_bitref_r<T1> a, sc_bitref_r<T2> b ) +{ + return sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> > +operator , ( sc_bitref_r<T1> a, sc_subref_r<T2> b ) +{ + return sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> > +operator , ( sc_bitref_r<T1> a, sc_concref_r<T2,T3> b ) +{ + return sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,T2> +operator , ( sc_bitref_r<T1> a, const sc_proxy<T2>& b ) +{ + return sc_concref_r<sc_bitref_r<T1>,T2>( + *a.clone(), b.back_cast(), 1 ); +} + + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> > +concat( sc_bitref_r<T1> a, sc_bitref_r<T2> b ) +{ + return sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> > +concat( sc_bitref_r<T1> a, sc_subref_r<T2> b ) +{ + return sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> > +concat( sc_bitref_r<T1> a, sc_concref_r<T2,T3> b ) +{ + return sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,T2> +concat( sc_bitref_r<T1> a, const sc_proxy<T2>& b ) +{ + return sc_concref_r<sc_bitref_r<T1>,T2>( + *a.clone(), b.back_cast(), 1 ); +} + + +#ifdef SC_DT_MIXED_COMMA_OPERATORS + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> > +operator , ( sc_bitref_r<T1> a, sc_bitref<T2> b ) +{ + return sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> > +operator , ( sc_bitref<T1> a, sc_bitref_r<T2> b ) +{ + return sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> > +operator , ( sc_bitref_r<T1> a, sc_subref<T2> b ) +{ + return sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> > +operator , ( sc_bitref<T1> a, sc_subref_r<T2> b ) +{ + return sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> > +operator , ( sc_bitref_r<T1> a, sc_concref<T2,T3> b ) +{ + return sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> > +operator , ( sc_bitref<T1> a, sc_concref_r<T2,T3> b ) +{ + return sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,T2> +operator , ( sc_bitref<T1> a, const sc_proxy<T2>& b ) +{ + return sc_concref_r<sc_bitref_r<T1>,T2>( + *a.clone(), b.back_cast(), 1 ); +} + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,T2> +operator , ( sc_bitref_r<T1> a, sc_proxy<T2>& b ) +{ + return sc_concref_r<sc_bitref_r<T1>,T2>( + *a.clone(), b.back_cast(), 1 ); +} + + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> > +concat( sc_bitref_r<T1> a, sc_bitref<T2> b ) +{ + return sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> > +concat( sc_bitref<T1> a, sc_bitref_r<T2> b ) +{ + return sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> > +concat( sc_bitref_r<T1> a, sc_subref<T2> b ) +{ + return sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> > +concat( sc_bitref<T1> a, sc_subref_r<T2> b ) +{ + return sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> > +concat( sc_bitref_r<T1> a, sc_concref<T2,T3> b ) +{ + return sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> > +concat( sc_bitref<T1> a, sc_concref_r<T2,T3> b ) +{ + return sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,T2> +concat( sc_bitref<T1> a, const sc_proxy<T2>& b ) +{ + return sc_concref_r<sc_bitref_r<T1>,T2>( + *a.clone(), b.back_cast(), 1 ); +} + +template <class T1, class T2> +inline +sc_concref_r<sc_bitref_r<T1>,T2> +concat( sc_bitref_r<T1> a, sc_proxy<T2>& b ) +{ + return sc_concref_r<sc_bitref_r<T1>,T2>( + *a.clone(), b.back_cast(), 1 ); +} + +#endif + + +// ---------------------------------------------------------------------------- +// CLASS TEMPLATE : sc_bitref<X> +// +// Proxy class for sc_proxy bit selection (r-value and l-value). +// ---------------------------------------------------------------------------- + +// assignment operators + +template <class X> +inline +sc_bitref<X>& +sc_bitref<X>::operator = ( const sc_bitref_r<X>& a ) +{ + this->m_obj.set_bit( this->m_index, a.value() ); + return *this; +} + +template <class X> +inline +sc_bitref<X>& +sc_bitref<X>::operator = ( const sc_bitref<X>& a ) +{ + if( &a != this ) { + this->m_obj.set_bit( this->m_index, a.value() ); + } + return *this; +} + + +// bitwise assignment operators + +template <class X> +inline +sc_bitref<X>& +sc_bitref<X>::operator &= ( const sc_bitref_r<X>& a ) +{ + if( &a != this ) { + this->m_obj.set_bit( this->m_index, + sc_logic::and_table[this->value()][a.value()] ); + } + return *this; +} + +template <class X> +inline +sc_bitref<X>& +sc_bitref<X>::operator &= ( const sc_logic& a ) +{ + this->m_obj.set_bit( this->m_index, + sc_logic::and_table[this->value()][a.value()] ); + return *this; +} + + +template <class X> +inline +sc_bitref<X>& +sc_bitref<X>::operator |= ( const sc_bitref_r<X>& a ) +{ + if( &a != this ) { + this->m_obj.set_bit( this->m_index, + sc_logic::or_table[this->value()][a.value()] ); + } + return *this; +} + +template <class X> +inline +sc_bitref<X>& +sc_bitref<X>::operator |= ( const sc_logic& a ) +{ + this->m_obj.set_bit( this->m_index, + sc_logic::or_table[this->value()][a.value()] ); + return *this; +} + + +template <class X> +inline +sc_bitref<X>& +sc_bitref<X>::operator ^= ( const sc_bitref_r<X>& a ) +{ + if( &a != this ) { + this->m_obj.set_bit( this->m_index, + sc_logic::xor_table[this->value()][a.value()] ); + } + return *this; +} + +template <class X> +inline +sc_bitref<X>& +sc_bitref<X>::operator ^= ( const sc_logic& a ) +{ + this->m_obj.set_bit( this->m_index, + sc_logic::xor_table[this->value()][a.value()] ); + return *this; +} + + +// bitwise operators and functions + +// bitwise complement + +template <class X> +inline +sc_bitref<X>& +sc_bitref<X>::b_not() +{ + this->m_obj.set_bit( this->m_index, + sc_logic::not_table[this->value()] ); + return *this; +} + + +// common methods + +template <class X> +inline +void +sc_bitref<X>::set_bit( int n, sc_logic_value_t value ) +{ + if( n == 0 ) { + this->m_obj.set_bit( this->m_index, value ); + } else { + SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 ); + } +} + +template <class X> +inline +void +sc_bitref<X>::set_word( int n, sc_digit w ) +{ + unsigned int bi = this->m_index % (8*sizeof(sc_digit)); + sc_digit temp; + unsigned int wi = this->m_index / (8*sizeof(sc_digit)); + if( n == 0 ) { + temp = this->m_obj.get_word(wi); + temp = (temp & ~(1 << bi)) | ((w&1) << bi); + this->m_obj.set_word(wi, temp); + } else { + SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 ); + } + +} + +template <class X> +inline +void +sc_bitref<X>::set_cword( int n, sc_digit w ) +{ + unsigned int bi = this->m_index % (8*sizeof(sc_digit)); + sc_digit temp; + unsigned int wi = this->m_index / (8*sizeof(sc_digit)); + if( n == 0 ) { + temp = this->m_obj.get_cword(wi); + temp = (temp & ~(1 << bi)) | ((w&1) << bi); + this->m_obj.set_cword(wi, temp); + } else { + SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 ); + } +} + +// other methods + +template <class X> +inline +void +sc_bitref<X>::scan( ::std::istream& is ) +{ + char c; + is >> c; + *this = c; +} + + +// l-value concatenation operators and functions + +template <class T1, class T2> +inline +sc_concref<sc_bitref<T1>,sc_bitref<T2> > +operator , ( sc_bitref<T1> a, sc_bitref<T2> b ) +{ + return sc_concref<sc_bitref<T1>,sc_bitref<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref<sc_bitref<T1>,sc_subref<T2> > +operator , ( sc_bitref<T1> a, sc_subref<T2> b ) +{ + return sc_concref<sc_bitref<T1>,sc_subref<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref<sc_bitref<T1>,sc_concref<T2,T3> > +operator , ( sc_bitref<T1> a, sc_concref<T2,T3> b ) +{ + return sc_concref<sc_bitref<T1>,sc_concref<T2,T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref<sc_bitref<T1>,T2> +operator , ( sc_bitref<T1> a, sc_proxy<T2>& b ) +{ + return sc_concref<sc_bitref<T1>,T2>( + *a.clone(), b.back_cast(), 1 ); +} + + +template <class T1, class T2> +inline +sc_concref<sc_bitref<T1>,sc_bitref<T2> > +concat( sc_bitref<T1> a, sc_bitref<T2> b ) +{ + return sc_concref<sc_bitref<T1>,sc_bitref<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref<sc_bitref<T1>,sc_subref<T2> > +concat( sc_bitref<T1> a, sc_subref<T2> b ) +{ + return sc_concref<sc_bitref<T1>,sc_subref<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref<sc_bitref<T1>,sc_concref<T2,T3> > +concat( sc_bitref<T1> a, sc_concref<T2,T3> b ) +{ + return sc_concref<sc_bitref<T1>,sc_concref<T2,T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref<sc_bitref<T1>,T2> +concat( sc_bitref<T1> a, sc_proxy<T2>& b ) +{ + return sc_concref<sc_bitref<T1>,T2>( + *a.clone(), b.back_cast(), 1 ); +} + + +template <class X> +inline +::std::istream& +operator >> ( ::std::istream& is, sc_bitref<X> a ) +{ + a.scan( is ); + return is; +} + + +// ---------------------------------------------------------------------------- +// CLASS TEMPLATE : sc_subref_r<X> +// +// Proxy class for sc_proxy part selection (r-value only). +// ---------------------------------------------------------------------------- + +template <class X> +inline +void +sc_subref_r<X>::check_bounds() +{ + int len = m_obj.length(); + if( m_hi < 0 || m_hi >= len || m_lo < 0 || m_lo >= len ) { + SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 ); + } + if( reversed() ) { + m_len = m_lo - m_hi + 1; + } else { + m_len = m_hi - m_lo + 1; + } +} + + +// common methods + +template <class X> +inline +sc_logic_value_t +sc_subref_r<X>::get_bit( int n ) const +{ + if( reversed() ) { + return m_obj.get_bit( m_lo - n ); + } else { + return m_obj.get_bit( m_lo + n ); + } +} + +template <class X> +inline +void +sc_subref_r<X>::set_bit( int n, sc_logic_value_t value ) +{ + if( reversed() ) { + m_obj.set_bit( m_lo - n, value ); + } else { + m_obj.set_bit( m_lo + n, value ); + } +} + + +template <class X> +inline +sc_digit +sc_subref_r<X>::get_word( int i ) const +{ + int n1 = 0; + int n2 = 0; + sc_digit result = 0; + int k = 0; + if( reversed() ) { + n1 = m_lo - i * SC_DIGIT_SIZE; + n2 = sc_max( n1 - SC_DIGIT_SIZE, m_hi - 1 ); + for( int n = n1; n > n2; n -- ) { + result |= (m_obj[n].value() & SC_DIGIT_ONE) << k ++; + } + } else { + n1 = m_lo + i * SC_DIGIT_SIZE; + n2 = sc_min( n1 + SC_DIGIT_SIZE, m_hi + 1 ); + for( int n = n1; n < n2; n ++ ) { + result |= (m_obj[n].value() & SC_DIGIT_ONE) << k ++; + } + } + return result; +} + +template <class X> +inline +void +sc_subref_r<X>::set_word( int i, sc_digit w ) +{ + int n1 = 0; + int n2 = 0; + int k = 0; + if( reversed() ) { + n1 = m_lo - i * SC_DIGIT_SIZE; + n2 = sc_max( n1 - SC_DIGIT_SIZE, m_hi - 1 ); + for( int n = n1; n > n2; n -- ) { + m_obj.set_bit( n, sc_logic_value_t( + ( (w >> k ++) & SC_DIGIT_ONE ) | + ( m_obj[n].value() & SC_DIGIT_TWO ) ) ); + } + } else { + n1 = m_lo + i * SC_DIGIT_SIZE; + n2 = sc_min( n1 + SC_DIGIT_SIZE, m_hi + 1 ); + for( int n = n1; n < n2; n ++ ) { + m_obj.set_bit( n, sc_logic_value_t( + ( (w >> k ++) & SC_DIGIT_ONE ) | + ( m_obj[n].value() & SC_DIGIT_TWO ) ) ); + } + } +} + + +template <class X> +inline +sc_digit +sc_subref_r<X>::get_cword( int i ) const +{ + int n1 = 0; + int n2 = 0; + sc_digit result = 0; + int k = 0; + if( reversed() ) { + n1 = m_lo - i * SC_DIGIT_SIZE; + n2 = sc_max( n1 - SC_DIGIT_SIZE, m_hi - 1 ); + for( int n = n1; n > n2; n -- ) { + result |= ((m_obj[n].value() & SC_DIGIT_TWO) >> 1) << k ++; + } + } else { + n1 = m_lo + i * SC_DIGIT_SIZE; + n2 = sc_min( n1 + SC_DIGIT_SIZE, m_hi + 1 ); + for( int n = n1; n < n2; n ++ ) { + result |= ((m_obj[n].value() & SC_DIGIT_TWO) >> 1) << k ++; + } + } + return result; +} + +template <class X> +inline +void +sc_subref_r<X>::set_cword( int i, sc_digit w ) +{ + int n1 = 0; + int n2 = 0; + int k = 0; + if( reversed() ) { + n1 = m_lo - i * SC_DIGIT_SIZE; + n2 = sc_max( n1 - SC_DIGIT_SIZE, m_hi - 1 ); + for( int n = n1; n > n2; n -- ) { + m_obj.set_bit( n, sc_logic_value_t( + ( ((w >> k ++) & SC_DIGIT_ONE) << 1 ) | + ( m_obj[n].value() & SC_DIGIT_ONE ) ) ); + } + } else { + n1 = m_lo + i * SC_DIGIT_SIZE; + n2 = sc_min( n1 + SC_DIGIT_SIZE, m_hi + 1 ); + for( int n = n1; n < n2; n ++ ) { + m_obj.set_bit( n, sc_logic_value_t( + ( ((w >> k ++) & SC_DIGIT_ONE) << 1 ) | + ( m_obj[n].value() & SC_DIGIT_ONE ) ) ); + } + } +} + + +// other methods + +template <class X> +inline +bool +sc_subref_r<X>::is_01() const +{ + int sz = size(); + for( int i = 0; i < sz; ++ i ) { + if( get_cword( i ) != SC_DIGIT_ZERO ) { + return false; + } + } + return true; +} + + +// r-value concatenation operators and functions + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> > +operator , ( sc_subref_r<T1> a, sc_bitref_r<T2> b ) +{ + return sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> > +operator , ( sc_subref_r<T1> a, sc_subref_r<T2> b ) +{ + return sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> > +operator , ( sc_subref_r<T1> a, sc_concref_r<T2,T3> b ) +{ + return sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,T2> +operator , ( sc_subref_r<T1> a, const sc_proxy<T2>& b ) +{ + return sc_concref_r<sc_subref_r<T1>,T2>( + *a.clone(), b.back_cast(), 1 ); +} + + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> > +concat( sc_subref_r<T1> a, sc_bitref_r<T2> b ) +{ + return sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> > +concat( sc_subref_r<T1> a, sc_subref_r<T2> b ) +{ + return sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> > +concat( sc_subref_r<T1> a, sc_concref_r<T2,T3> b ) +{ + return sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,T2> +concat( sc_subref_r<T1> a, const sc_proxy<T2>& b ) +{ + return sc_concref_r<sc_subref_r<T1>,T2>( + *a.clone(), b.back_cast(), 1 ); +} + + +#ifdef SC_DT_MIXED_COMMA_OPERATORS + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> > +operator , ( sc_subref_r<T1> a, sc_bitref<T2> b ) +{ + return sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> > +operator , ( sc_subref<T1> a, sc_bitref_r<T2> b ) +{ + return sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> > +operator , ( sc_subref_r<T1> a, sc_subref<T2> b ) +{ + return sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> > +operator , ( sc_subref<T1> a, sc_subref_r<T2> b ) +{ + return sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> > +operator , ( sc_subref_r<T1> a, sc_concref<T2,T3> b ) +{ + return sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> > +operator , ( sc_subref<T1> a, sc_concref_r<T2,T3> b ) +{ + return sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,T2> +operator , ( sc_subref<T1> a, const sc_proxy<T2>& b ) +{ + return sc_concref_r<sc_subref_r<T1>,T2>( + *a.clone(), b.back_cast(), 1 ); +} + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,T2> +operator , ( sc_subref_r<T1> a, sc_proxy<T2>& b ) +{ + return sc_concref_r<sc_subref_r<T1>,T2>( + *a.clone(), b.back_cast(), 1 ); +} + + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> > +concat( sc_subref_r<T1> a, sc_bitref<T2> b ) +{ + return sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> > +concat( sc_subref<T1> a, sc_bitref_r<T2> b ) +{ + return sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> > +concat( sc_subref_r<T1> a, sc_subref<T2> b ) +{ + return sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> > +concat( sc_subref<T1> a, sc_subref_r<T2> b ) +{ + return sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> > +concat( sc_subref_r<T1> a, sc_concref<T2,T3> b ) +{ + return sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> > +concat( sc_subref<T1> a, sc_concref_r<T2,T3> b ) +{ + return sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,T2> +concat( sc_subref<T1> a, const sc_proxy<T2>& b ) +{ + return sc_concref_r<sc_subref_r<T1>,T2>( + *a.clone(), b.back_cast(), 1 ); +} + +template <class T1, class T2> +inline +sc_concref_r<sc_subref_r<T1>,T2> +concat( sc_subref_r<T1> a, sc_proxy<T2>& b ) +{ + return sc_concref_r<sc_subref_r<T1>,T2>( + *a.clone(), b.back_cast(), 1 ); +} + +#endif + + +// ---------------------------------------------------------------------------- +// CLASS TEMPLATE : sc_subref<X> +// +// Proxy class for sc_proxy part selection (r-value and l-value). +// ---------------------------------------------------------------------------- + +// assignment operators + +// sc_subref<X>::operator = ( const sc_subref_r<X>& ) in sc_lv_base.h +// sc_subref<X>::operator = ( const sc_subref<X>& ) in sc_lv_base.h + + +// other methods + +template <class T> +inline +void +sc_subref<T>::scan( ::std::istream& is ) +{ + std::string s; + is >> s; + *this = s.c_str(); +} + + +// l-value concatenation operators and functions + +template <class T1, class T2> +inline +sc_concref<sc_subref<T1>,sc_bitref<T2> > +operator , ( sc_subref<T1> a, sc_bitref<T2> b ) +{ + return sc_concref<sc_subref<T1>,sc_bitref<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref<sc_subref<T1>,sc_subref<T2> > +operator , ( sc_subref<T1> a, sc_subref<T2> b ) +{ + return sc_concref<sc_subref<T1>,sc_subref<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref<sc_subref<T1>,sc_concref<T2,T3> > +operator , ( sc_subref<T1> a, sc_concref<T2,T3> b ) +{ + return sc_concref<sc_subref<T1>,sc_concref<T2,T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref<sc_subref<T1>,T2> +operator , ( sc_subref<T1> a, sc_proxy<T2>& b ) +{ + return sc_concref<sc_subref<T1>,T2>( + *a.clone(), b.back_cast(), 1 ); +} + + +template <class T1, class T2> +inline +sc_concref<sc_subref<T1>,sc_bitref<T2> > +concat( sc_subref<T1> a, sc_bitref<T2> b ) +{ + return sc_concref<sc_subref<T1>,sc_bitref<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref<sc_subref<T1>,sc_subref<T2> > +concat( sc_subref<T1> a, sc_subref<T2> b ) +{ + return sc_concref<sc_subref<T1>,sc_subref<T2> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref<sc_subref<T1>,sc_concref<T2,T3> > +concat( sc_subref<T1> a, sc_concref<T2,T3> b ) +{ + return sc_concref<sc_subref<T1>,sc_concref<T2,T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2> +inline +sc_concref<sc_subref<T1>,T2> +concat( sc_subref<T1> a, sc_proxy<T2>& b ) +{ + return sc_concref<sc_subref<T1>,T2>( + *a.clone(), b.back_cast(), 1 ); +} + + +template <class X> +inline +::std::istream& +operator >> ( ::std::istream& is, sc_subref<X> a ) +{ + a.scan( is ); + return is; +} + + +// ---------------------------------------------------------------------------- +// CLASS TEMPLATE : sc_concref_r<X,Y> +// +// Proxy class for sc_proxy concatenation (r-value only). +// ---------------------------------------------------------------------------- + +// destructor + +template <class X, class Y> +inline +sc_concref_r<X,Y>::~sc_concref_r() +{ + if( -- m_refs == 0 ) { + delete &m_refs; + if( m_delete == 0 ) { + return; + } + if( m_delete & 1 ) { + delete &m_left; + } + if( m_delete & 2 ) { + delete &m_right; + } + } +} + + +// common methods + +template <class X, class Y> +inline +sc_logic_value_t +sc_concref_r<X,Y>::get_bit( int n ) const +{ + int r_len = m_right.length(); + if( n < r_len ) { + return m_right.get_bit( n ); + } else if( n < r_len + m_left.length() ) { + return m_left.get_bit( n - r_len ); + } else { + SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 ); + // never reached + return Log_0; + } +} + +template <class X, class Y> +inline +void +sc_concref_r<X,Y>::set_bit( int n, sc_logic_value_t v ) +{ + int r_len = m_right.length(); + if( n < r_len ) { + m_right.set_bit( n, v ); + } else if( n < r_len + m_left.length() ) { + m_left.set_bit( n - r_len, v ); + } else { + SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 ); + } +} + + +template <class X, class Y> +inline +sc_digit +sc_concref_r<X,Y>::get_word( int i ) const +{ + if( i < 0 || i >= size() ) { + SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 ); + } + // 0 <= i < size() + Y& r = m_right; + int r_len = r.length(); + int border = r_len / SC_DIGIT_SIZE; + if( i < border ) { + return r.get_word( i ); + } + // border <= i < size() + X& l = m_left; + int shift = r_len % SC_DIGIT_SIZE; + int j = i - border; + if( shift == 0 ) { + return l.get_word( j ); + } + // border <= i < size() && shift != 0 + int nshift = SC_DIGIT_SIZE - shift; + if( i == border ) { + sc_digit rl_mask = ~SC_DIGIT_ZERO >> nshift; + return ( (r.get_word( i ) & rl_mask) | (l.get_word( 0 ) << shift) ); + } + // border < i < size() && shift != 0 + if ( j < l.size() ) + return ( (l.get_word( j - 1 ) >> nshift) | (l.get_word( j ) << shift) ); + else + return (l.get_word( j - 1 ) >> nshift); +} + +template <class X, class Y> +inline +void +sc_concref_r<X,Y>::set_word( int i, sc_digit w ) +{ + if( i < 0 || i >= size() ) { + SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 ); + } + // 0 <= i < size() + Y& r = m_right; + int r_len = r.length(); + int border = r_len / SC_DIGIT_SIZE; + if( i < border ) { + r.set_word( i, w ); + return; + } + // border <= i < size() + X& l = m_left; + int shift = r_len % SC_DIGIT_SIZE; + int j = i - border; + if( shift == 0 ) { + l.set_word( j, w ); + return; + } + // border <= i < size() && shift != 0 + int nshift = SC_DIGIT_SIZE - shift; + sc_digit lh_mask = ~SC_DIGIT_ZERO << nshift; + if( i == border ) { + sc_digit rl_mask = ~SC_DIGIT_ZERO >> nshift; + r.set_word( i, w & rl_mask ); + l.set_word( 0, (l.get_word( 0 ) & lh_mask) | (w >> shift) ); + return; + } + // border < i < size() && shift != 0 + sc_digit ll_mask = ~SC_DIGIT_ZERO >> shift; + l.set_word( j - 1, (l.get_word( j - 1 ) & ll_mask) | (w << nshift) ); + if ( j < l.size() ) + l.set_word( j, (l.get_word( j ) & lh_mask) | (w >> shift) ); +} + + +template <class X, class Y> +inline +sc_digit +sc_concref_r<X,Y>::get_cword( int i ) const +{ + if( i < 0 || i >= size() ) { + SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 ); + } + // 0 <= i < size() + Y& r = m_right; + int r_len = r.length(); + int border = r_len / SC_DIGIT_SIZE; + if( i < border ) { + return r.get_cword( i ); + } + // border <= i < size() + X& l = m_left; + int shift = r_len % SC_DIGIT_SIZE; + int j = i - border; + if( shift == 0 ) { + return l.get_cword( j ); + } + // border <= i < size() && shift != 0 + int nshift = SC_DIGIT_SIZE - shift; + if( i == border ) { + sc_digit rl_mask = ~SC_DIGIT_ZERO >> nshift; + return ( (r.get_cword( i ) & rl_mask) | (l.get_cword( 0 ) << shift) ); + } + // border < i < size() && shift != 0 + if ( j < l.size() ) + return ( (l.get_cword(j - 1) >> nshift) | (l.get_cword(j) << shift) ); + else + return (l.get_cword( j - 1 ) >> nshift); +} + +template <class X, class Y> +inline +void +sc_concref_r<X,Y>::set_cword( int i, sc_digit w ) +{ + if( i < 0 || i >= size() ) { + SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 ); + } + // 0 <= i < size() + Y& r = m_right; + int r_len = r.length(); + int border = r_len / SC_DIGIT_SIZE; + if( i < border ) { + r.set_cword( i, w ); + return; + } + // border <= i < size() + X& l = m_left; + int shift = r_len % SC_DIGIT_SIZE; + int j = i - border; + if( shift == 0 ) { + l.set_cword( j, w ); + return; + } + // border <= i < size() && shift != 0 + int nshift = SC_DIGIT_SIZE - shift; + sc_digit lh_mask = ~SC_DIGIT_ZERO << nshift; + if( i == border ) { + sc_digit rl_mask = ~SC_DIGIT_ZERO >> nshift; + r.set_cword( i, w & rl_mask ); + l.set_cword( 0, (l.get_cword( 0 ) & lh_mask) | (w >> shift) ); + return; + } + // border < i < size() && shift != 0 + sc_digit ll_mask = ~SC_DIGIT_ZERO >> shift; + l.set_cword( j - 1, (l.get_cword( j - 1 ) & ll_mask) | (w << nshift) ); + if ( j < l.size() ) + l.set_cword( j, (l.get_cword( j ) & lh_mask) | (w >> shift) ); +} + + +// r-value concatenation operators and functions + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> > +operator , ( sc_concref_r<T1,T2> a, sc_bitref_r<T3> b ) +{ + return sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> > +operator , ( sc_concref_r<T1,T2> a, sc_subref_r<T3> b ) +{ + return sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3, class T4> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> > +operator , ( sc_concref_r<T1,T2> a, sc_concref_r<T3,T4> b ) +{ + return sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,T3> +operator , ( sc_concref_r<T1,T2> a, const sc_proxy<T3>& b ) +{ + return sc_concref_r<sc_concref_r<T1,T2>,T3>( + *a.clone(), b.back_cast(), 1 ); +} + + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> > +concat( sc_concref_r<T1,T2> a, sc_bitref_r<T3> b ) +{ + return sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> > +concat( sc_concref_r<T1,T2> a, sc_subref_r<T3> b ) +{ + return sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3, class T4> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> > +concat( sc_concref_r<T1,T2> a, sc_concref_r<T3,T4> b ) +{ + return sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,T3> +concat( sc_concref_r<T1,T2> a, const sc_proxy<T3>& b ) +{ + return sc_concref_r<sc_concref_r<T1,T2>,T3>( + *a.clone(), b.back_cast(), 1 ); +} + + +#ifdef SC_DT_MIXED_COMMA_OPERATORS + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> > +operator , ( sc_concref_r<T1,T2> a, sc_bitref<T3> b ) +{ + return sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> > +operator , ( sc_concref<T1,T2> a, sc_bitref_r<T3> b ) +{ + return sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> > +operator , ( sc_concref_r<T1,T2> a, sc_subref<T3> b ) +{ + return sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> > +operator , ( sc_concref<T1,T2> a, sc_subref_r<T3> b ) +{ + return sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3, class T4> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> > +operator , ( sc_concref_r<T1,T2> a, sc_concref<T3,T4> b ) +{ + return sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3, class T4> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> > +operator , ( sc_concref<T1,T2> a, sc_concref_r<T3,T4> b ) +{ + return sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,T3> +operator , ( sc_concref<T1,T2> a, const sc_proxy<T3>& b ) +{ + return sc_concref_r<sc_concref_r<T1,T2>,T3>( + *a.clone(), b.back_cast(), 1 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,T3> +operator , ( sc_concref_r<T1,T2> a, sc_proxy<T3>& b ) +{ + return sc_concref_r<sc_concref_r<T1,T2>,T3>( + *a.clone(), b.back_cast(), 1 ); +} + + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> > +concat( sc_concref_r<T1,T2> a, sc_bitref<T3> b ) +{ + return sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> > +concat( sc_concref<T1,T2> a, sc_bitref_r<T3> b ) +{ + return sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> > +concat( sc_concref_r<T1,T2> a, sc_subref<T3> b ) +{ + return sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> > +concat( sc_concref<T1,T2> a, sc_subref_r<T3> b ) +{ + return sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3, class T4> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> > +concat( sc_concref_r<T1,T2> a, sc_concref<T3,T4> b ) +{ + return sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3, class T4> +inline +sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> > +concat( sc_concref<T1,T2> a, sc_concref_r<T3,T4> b ) +{ + return sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,T3> +concat( sc_concref<T1,T2> a, const sc_proxy<T3>& b ) +{ + return sc_concref_r<sc_concref_r<T1,T2>,T3>( + *a.clone(), b.back_cast(), 1 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<sc_concref_r<T1,T2>,T3> +concat( sc_concref_r<T1,T2> a, sc_proxy<T3>& b ) +{ + return sc_concref_r<sc_concref_r<T1,T2>,T3>( + *a.clone(), b.back_cast(), 1 ); +} + +#endif + + +// ---------------------------------------------------------------------------- +// CLASS TEMPLATE : sc_concref<X,Y> +// +// Proxy class for sc_proxy concatenation (r-value and l-value). +// ---------------------------------------------------------------------------- + +// other methods + +template <class T1, class T2> +inline +void +sc_concref<T1,T2>::scan( ::std::istream& is ) +{ + std::string s; + is >> s; + *this = s.c_str(); +} + + +// l-value concatenation operators and functions + +template <class T1, class T2, class T3> +inline +sc_concref<sc_concref<T1,T2>,sc_bitref<T3> > +operator , ( sc_concref<T1,T2> a, sc_bitref<T3> b ) +{ + return sc_concref<sc_concref<T1,T2>,sc_bitref<T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref<sc_concref<T1,T2>,sc_subref<T3> > +operator , ( sc_concref<T1,T2> a, sc_subref<T3> b ) +{ + return sc_concref<sc_concref<T1,T2>,sc_subref<T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3, class T4> +inline +sc_concref<sc_concref<T1,T2>,sc_concref<T3,T4> > +operator , ( sc_concref<T1,T2> a, sc_concref<T3,T4> b ) +{ + return sc_concref<sc_concref<T1,T2>,sc_concref<T3,T4> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref<sc_concref<T1,T2>,T3> +operator , ( sc_concref<T1,T2> a, sc_proxy<T3>& b ) +{ + return sc_concref<sc_concref<T1,T2>,T3>( + *a.clone(), b.back_cast(), 1 ); +} + + +template <class T1, class T2, class T3> +inline +sc_concref<sc_concref<T1,T2>,sc_bitref<T3> > +concat( sc_concref<T1,T2> a, sc_bitref<T3> b ) +{ + return sc_concref<sc_concref<T1,T2>,sc_bitref<T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref<sc_concref<T1,T2>,sc_subref<T3> > +concat( sc_concref<T1,T2> a, sc_subref<T3> b ) +{ + return sc_concref<sc_concref<T1,T2>,sc_subref<T3> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3, class T4> +inline +sc_concref<sc_concref<T1,T2>,sc_concref<T3,T4> > +concat( sc_concref<T1,T2> a, sc_concref<T3,T4> b ) +{ + return sc_concref<sc_concref<T1,T2>,sc_concref<T3,T4> >( + *a.clone(), *b.clone(), 3 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref<sc_concref<T1,T2>,T3> +concat( sc_concref<T1,T2> a, sc_proxy<T3>& b ) +{ + return sc_concref<sc_concref<T1,T2>,T3>( + *a.clone(), b.back_cast(), 1 ); +} + + +template <class X, class Y> +inline +::std::istream& +operator >> ( ::std::istream& is, sc_concref<X,Y> a ) +{ + a.scan( is ); + return is; +} + + +// ---------------------------------------------------------------------------- +// CLASS TEMPLATE : sc_proxy<T> +// +// Base class template for bit/logic vector classes. +// (Barton/Nackmann implementation) +// ---------------------------------------------------------------------------- + +// r-value concatenation operators and functions + +template <class T1, class T2> +inline +sc_concref_r<T1,sc_bitref_r<T2> > +operator , ( const sc_proxy<T1>& a, sc_bitref_r<T2> b ) +{ + return sc_concref_r<T1,sc_bitref_r<T2> >( + a.back_cast(), *b.clone(), 2 ); +} + +template <class T1, class T2> +inline +sc_concref_r<T1,sc_subref_r<T2> > +operator , ( const sc_proxy<T1>& a, sc_subref_r<T2> b ) +{ + return sc_concref_r<T1,sc_subref_r<T2> >( + a.back_cast(), *b.clone(), 2 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<T1,sc_concref_r<T2,T3> > +operator , ( const sc_proxy<T1>& a, sc_concref_r<T2,T3> b ) +{ + return sc_concref_r<T1,sc_concref_r<T2,T3> >( + a.back_cast(), *b.clone(), 2 ); +} + +template <class T1, class T2> +inline +sc_concref_r<T1,T2> +operator , ( const sc_proxy<T1>& a, const sc_proxy<T2>& b ) +{ + return sc_concref_r<T1,T2>( + a.back_cast(), b.back_cast() ); +} + + +template <class T1, class T2> +inline +sc_concref_r<T1,sc_bitref_r<T2> > +concat( const sc_proxy<T1>& a, sc_bitref_r<T2> b ) +{ + return sc_concref_r<T1,sc_bitref_r<T2> >( + a.back_cast(), *b.clone(), 2 ); +} + +template <class T1, class T2> +inline +sc_concref_r<T1,sc_subref_r<T2> > +concat( const sc_proxy<T1>& a, sc_subref_r<T2> b ) +{ + return sc_concref_r<T1,sc_subref_r<T2> >( + a.back_cast(), *b.clone(), 2 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<T1,sc_concref_r<T2,T3> > +concat( const sc_proxy<T1>& a, sc_concref_r<T2,T3> b ) +{ + return sc_concref_r<T1,sc_concref_r<T2,T3> >( + a.back_cast(), *b.clone(), 2 ); +} + +template <class T1, class T2> +inline +sc_concref_r<T1,T2> +concat( const sc_proxy<T1>& a, const sc_proxy<T2>& b ) +{ + return sc_concref_r<T1,T2>( + a.back_cast(), b.back_cast() ); +} + + +#ifdef SC_DT_MIXED_COMMA_OPERATORS + +template <class T1, class T2> +inline +sc_concref_r<T1,sc_bitref_r<T2> > +operator , ( const sc_proxy<T1>& a, sc_bitref<T2> b ) +{ + return sc_concref_r<T1,sc_bitref_r<T2> >( + a.back_cast(), *b.clone(), 2 ); +} + +template <class T1, class T2> +inline +sc_concref_r<T1,sc_bitref_r<T2> > +operator , ( sc_proxy<T1>& a, sc_bitref_r<T2> b ) +{ + return sc_concref_r<T1,sc_bitref_r<T2> >( + a.back_cast(), *b.clone(), 2 ); +} + +template <class T1, class T2> +inline +sc_concref_r<T1,sc_subref_r<T2> > +operator , ( const sc_proxy<T1>& a, sc_subref<T2> b ) +{ + return sc_concref_r<T1,sc_subref_r<T2> >( + a.back_cast(), *b.clone(), 2 ); +} + +template <class T1, class T2> +inline +sc_concref_r<T1,sc_subref_r<T2> > +operator , ( sc_proxy<T1>& a, sc_subref_r<T2> b ) +{ + return sc_concref_r<T1,sc_subref_r<T2> >( + a.back_cast(), *b.clone(), 2 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<T1,sc_concref_r<T2,T3> > +operator , ( const sc_proxy<T1>& a, sc_concref<T2,T3> b ) +{ + return sc_concref_r<T1,sc_concref_r<T2,T3> >( + a.back_cast(), *b.clone(), 2 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<T1,sc_concref_r<T2,T3> > +operator , ( sc_proxy<T1>& a, sc_concref_r<T2,T3> b ) +{ + return sc_concref_r<T1,sc_concref_r<T2,T3> >( + a.back_cast(), *b.clone(), 2 ); +} + +template <class T1, class T2> +inline +sc_concref_r<T1,T2> +operator , ( const sc_proxy<T1>& a, sc_proxy<T2>& b ) +{ + return sc_concref_r<T1,T2>( + a.back_cast(), b.back_cast() ); +} + +template <class T1, class T2> +inline +sc_concref_r<T1,T2> +operator , ( sc_proxy<T1>& a, const sc_proxy<T2>& b ) +{ + return sc_concref_r<T1,T2>( + a.back_cast(), b.back_cast() ); +} + + +template <class T1, class T2> +inline +sc_concref_r<T1,sc_bitref_r<T2> > +concat( const sc_proxy<T1>& a, sc_bitref<T2> b ) +{ + return sc_concref_r<T1,sc_bitref_r<T2> >( + a.back_cast(), *b.clone(), 2 ); +} + +template <class T1, class T2> +inline +sc_concref_r<T1,sc_bitref_r<T2> > +concat( sc_proxy<T1>& a, sc_bitref_r<T2> b ) +{ + return sc_concref_r<T1,sc_bitref_r<T2> >( + a.back_cast(), *b.clone(), 2 ); +} + +template <class T1, class T2> +inline +sc_concref_r<T1,sc_subref_r<T2> > +concat( const sc_proxy<T1>& a, sc_subref<T2> b ) +{ + return sc_concref_r<T1,sc_subref_r<T2> >( + a.back_cast(), *b.clone(), 2 ); +} + +template <class T1, class T2> +inline +sc_concref_r<T1,sc_subref_r<T2> > +concat( sc_proxy<T1>& a, sc_subref_r<T2> b ) +{ + return sc_concref_r<T1,sc_subref_r<T2> >( + a.back_cast(), *b.clone(), 2 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<T1,sc_concref_r<T2,T3> > +concat( const sc_proxy<T1>& a, sc_concref<T2,T3> b ) +{ + return sc_concref_r<T1,sc_concref_r<T2,T3> >( + a.back_cast(), *b.clone(), 2 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref_r<T1,sc_concref_r<T2,T3> > +concat( sc_proxy<T1>& a, sc_concref_r<T2,T3> b ) +{ + return sc_concref_r<T1,sc_concref_r<T2,T3> >( + a.back_cast(), *b.clone(), 2 ); +} + +template <class T1, class T2> +inline +sc_concref_r<T1,T2> +concat( const sc_proxy<T1>& a, sc_proxy<T2>& b ) +{ + return sc_concref_r<T1,T2>( + a.back_cast(), b.back_cast() ); +} + +template <class T1, class T2> +inline +sc_concref_r<T1,T2> +concat( sc_proxy<T1>& a, const sc_proxy<T2>& b ) +{ + return sc_concref_r<T1,T2>( + a.back_cast(), b.back_cast() ); +} + +#endif + + +// l-value concatenation operators and functions + +template <class T1, class T2> +inline +sc_concref<T1,sc_bitref<T2> > +operator , ( sc_proxy<T1>& a, sc_bitref<T2> b ) +{ + return sc_concref<T1,sc_bitref<T2> >( + a.back_cast(), *b.clone(), 2 ); +} + +template <class T1, class T2> +inline +sc_concref<T1,sc_subref<T2> > +operator , ( sc_proxy<T1>& a, sc_subref<T2> b ) +{ + return sc_concref<T1,sc_subref<T2> >( + a.back_cast(), *b.clone(), 2 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref<T1,sc_concref<T2,T3> > +operator , ( sc_proxy<T1>& a, sc_concref<T2,T3> b ) +{ + return sc_concref<T1,sc_concref<T2,T3> >( + a.back_cast(), *b.clone(), 2 ); +} + +template <class T1, class T2> +inline +sc_concref<T1,T2> +operator , ( sc_proxy<T1>& a, sc_proxy<T2>& b ) +{ + return sc_concref<T1,T2>( + a.back_cast(), b.back_cast() ); +} + + +template <class T1, class T2> +inline +sc_concref<T1,sc_bitref<T2> > +concat( sc_proxy<T1>& a, sc_bitref<T2> b ) +{ + return sc_concref<T1,sc_bitref<T2> >( + a.back_cast(), *b.clone(), 2 ); +} + +template <class T1, class T2> +inline +sc_concref<T1,sc_subref<T2> > +concat( sc_proxy<T1>& a, sc_subref<T2> b ) +{ + return sc_concref<T1,sc_subref<T2> >( + a.back_cast(), *b.clone(), 2 ); +} + +template <class T1, class T2, class T3> +inline +sc_concref<T1,sc_concref<T2,T3> > +concat( sc_proxy<T1>& a, sc_concref<T2,T3> b ) +{ + return sc_concref<T1,sc_concref<T2,T3> >( + a.back_cast(), *b.clone(), 2 ); +} + +template <class T1, class T2> +inline +sc_concref<T1,T2> +concat( sc_proxy<T1>& a, sc_proxy<T2>& b ) +{ + return sc_concref<T1,T2>( + a.back_cast(), b.back_cast() ); +} + +} // namespace sc_dt + +// $Log: sc_bit_proxies.h,v $ +// Revision 1.10 2011/09/05 21:19:53 acg +// Philipp A. Hartmann: added parentheses to expressions to eliminate +// compiler warnings. +// +// Revision 1.9 2011/09/01 15:03:42 acg +// Philipp A. Hartmann: add parentheses to eliminate compiler warnings. +// +// Revision 1.8 2011/08/29 18:04:32 acg +// Philipp A. Hartmann: miscellaneous clean ups. +// +// Revision 1.7 2011/08/24 22:05:40 acg +// Torsten Maehne: initialization changes to remove warnings. +// +// Revision 1.6 2010/02/22 14:25:43 acg +// Andy Goodrich: removed 'mutable' directive from references, since it +// is not a legal C++ construct. +// +// Revision 1.5 2009/02/28 00:26:14 acg +// Andy Goodrich: bug fixes. +// +// Revision 1.4 2007/03/14 17:48:37 acg +// Andy Goodrich: fixed bug. +// +// Revision 1.3 2007/01/18 19:29:18 acg +// Andy Goodrich: fixed bug in concatenations of bit selects on sc_lv and +// sc_bv types. The offending code was in sc_bitref<X>::set_word and +// sc_bitref<X>::get_word. These methods were not writing the bit they +// represented, but rather writing an entire word whose index was the +// index of the bit they represented. This not only did not write the +// correct bit, but clobbered a word that might not even be in the +// variable the reference was for. +// +// Revision 1.2 2007/01/17 22:45:08 acg +// Andy Goodrich: fixed sc_bitref<X>::set_bit(). +// +// Revision 1.1.1.1 2006/12/15 20:31:36 acg +// SystemC 2.2 +// +// Revision 1.3 2006/01/13 18:53:53 acg +// Andy Goodrich: added $Log command so that CVS comments are reproduced in +// the source. +// + + +#endif |