| /***************************************************************************** |
| |
| 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 __SYSTEMC_EXT_DT_BIT_SC_BIT_PROXIES_HH__ |
| #define __SYSTEMC_EXT_DT_BIT_SC_BIT_PROXIES_HH__ |
| |
| #include <iostream> |
| |
| #include "../../utils/messages.hh" |
| #include "sc_proxy.hh" |
| |
| namespace sc_dt |
| { |
| |
| // classes defined in this module |
| template <class X, class Traits> |
| class sc_bitref_conv_r; |
| 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_conv_r<T> |
| // |
| // Proxy class for sc_proxy bit selection (r-value only, boolean conversion). |
| // ---------------------------------------------------------------------------- |
| template <class T, class Traits=typename T::traits_type> |
| class sc_bitref_conv_r { /* empty by default */ }; |
| |
| // specialization for bit-vector based sc_proxy classes |
| template<typename T> |
| class sc_bitref_conv_r<T, sc_proxy_traits<sc_bv_base> > |
| { |
| public: |
| #if __cplusplus >= 201103L // explicit operator needs C++11 |
| // explicit conversion to bool |
| explicit operator bool() const |
| { |
| return static_cast<const sc_bitref_r<T> &>(*this).to_bool(); |
| } |
| #endif |
| |
| // explicit (negating) conversion to bool |
| bool |
| operator ! () const |
| { |
| return !static_cast<const sc_bitref_r<T> &>(*this).to_bool(); |
| } |
| }; |
| |
| // ---------------------------------------------------------------------------- |
| // CLASS TEMPLATE : sc_bitref_r<T> |
| // |
| // Proxy class for sc_proxy bit selection (r-value only). |
| // ---------------------------------------------------------------------------- |
| |
| template <class T> |
| class sc_bitref_r : public sc_bitref_conv_r<T> |
| { |
| 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; |
| typedef typename traits_type::value_type value_type; |
| |
| // constructor |
| sc_bitref_r(const T &obj_, int index_) : |
| m_obj(const_cast<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 |
| bit_type |
| operator ~ () const |
| { |
| return bit_type(sc_logic::not_table[value()]); |
| } |
| |
| // implicit conversion to bit_type |
| operator bit_type() const { return bit_type(m_obj.get_bit(m_index)); } |
| |
| // explicit conversions |
| value_type 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); } |
| |
| value_type 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 sc_logic operator & ( |
| const sc_bitref_r<T1> &a, const sc_bitref_r<T2> &b); |
| |
| |
| // bitwise or |
| template <class T1, class T2> |
| inline sc_logic operator | ( |
| const sc_bitref_r<T1> &a, const sc_bitref_r<T2> &b); |
| |
| // bitwise xor |
| template <class T1, class T2> |
| inline 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>); |
| |
| |
| 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>); |
| |
| |
| // ---------------------------------------------------------------------------- |
| // 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: |
| typedef typename sc_bitref_r<X>::value_type value_type; |
| |
| // 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, value_type 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: |
| typedef typename sc_proxy<sc_subref_r<X> >::value_type value_type; |
| |
| // constructor |
| sc_subref_r(const X &obj_, int hi_, int lo_) : |
| m_obj(const_cast<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); } |
| |
| value_type get_bit(int n) const; |
| void set_bit(int n, value_type 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>); |
| |
| |
| 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>); |
| |
| |
| // ---------------------------------------------------------------------------- |
| // 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: |
| typedef typename sc_proxy<sc_concref_r<X, Y> >::value_type value_type; |
| |
| // constructor |
| sc_concref_r(const X &left_, const Y &right_, int delete_=0) : |
| m_left(const_cast<X &>(left_)), m_right(const_cast<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); } |
| |
| value_type get_bit(int n) const; |
| void set_bit(int n, value_type 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>); |
| |
| |
| 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>); |
| |
| |
| // ---------------------------------------------------------------------------- |
| // 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> &); |
| |
| |
| 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> &); |
| |
| |
| // 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 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 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 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 typename sc_bitref_r<T>::value_type |
| 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); |
| 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); |
| 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); |
| 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); |
| } |
| |
| |
| 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); |
| } |
| |
| |
| // ---------------------------------------------------------------------------- |
| // 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, value_type 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); |
| sc_core::sc_abort(); // can't recover from here |
| } |
| if (reversed()) { |
| m_len = m_lo - m_hi + 1; |
| } else { |
| m_len = m_hi - m_lo + 1; |
| } |
| } |
| |
| // common methods |
| template <class X> |
| inline typename sc_subref_r<X>::value_type |
| 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, value_type 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, value_type( |
| ((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, value_type( |
| ((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, value_type( |
| (((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, value_type( |
| (((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); |
| } |
| |
| |
| 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); |
| } |
| |
| |
| // ---------------------------------------------------------------------------- |
| // 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 typename sc_concref_r<X, Y>::value_type |
| sc_concref_r<X, Y>::get_bit(int n) const |
| { |
| int r_len = m_right.length(); |
| if (n < r_len) { |
| return value_type(m_right.get_bit(n)); |
| } else if (n < r_len + m_left.length()) { |
| return value_type(m_left.get_bit(n - r_len)); |
| } else { |
| SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, 0); |
| return Log_0; |
| } |
| } |
| |
| template <class X, class Y> |
| inline void |
| sc_concref_r<X, Y>::set_bit(int n, value_type v) |
| { |
| int r_len = m_right.length(); |
| if (n < r_len) { |
| m_right.set_bit(n, typename Y::value_type(v)); |
| } else if (n < r_len + m_left.length()) { |
| m_left.set_bit(n - r_len, typename X::value_type(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); |
| } |
| |
| |
| 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); |
| } |
| |
| |
| // ---------------------------------------------------------------------------- |
| // 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()); |
| } |
| |
| |
| 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()); |
| } |
| |
| |
| // 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 // __SYSTEMC_EXT_DT_BIT_SC_BIT_PROXIES_HH__ |
