C:/systemc-2.1.v1/src/sysc/datatypes/bit/sc_lv_base.h

#include "sysc/datatypes/bit/sc_bit_ids.h"
#include "sysc/datatypes/bit/sc_bv_base.h"
#include "sysc/datatypes/bit/sc_logic.h"
#include "sysc/datatypes/int/sc_length_param.h"

ネームスペース

namespace  sc_dt

構成

class  sc_dt::sc_lv_base

マクロ定義

#define DEFN_BITWISE_AND_ASN_OP_T(tp)
#define DEFN_BITWISE_AND_OP_T_A(tp)
#define DEFN_BITWISE_AND_OP_T_B(tp)
#define DEFN_BITWISE_OR_ASN_OP_T(tp)
#define DEFN_BITWISE_OR_OP_T_A(tp)
#define DEFN_BITWISE_OR_OP_T_B(tp)
#define DEFN_BITWISE_XOR_ASN_OP_T(tp)
#define DEFN_BITWISE_XOR_OP_T_A(tp)
#define DEFN_BITWISE_XOR_OP_T_B(tp)
#define DEFN_REL_OP_T(tp)

関数

template<class X, class Y>
X & sc_dt::operator &= (sc_proxy< X > &px, const sc_proxy< Y > &py)
template<class X, class Y>
const sc_lv_base sc_dt::operator & (const sc_proxy< X > &px, const sc_proxy< Y > &py)
template<class X, class Y>
X & sc_dt::operator|= (sc_proxy< X > &px, const sc_proxy< Y > &py)
template<class X, class Y>
const sc_lv_base sc_dt::operator| (const sc_proxy< X > &px, const sc_proxy< Y > &py)
template<class X, class Y>
X & sc_dt::operator^= (sc_proxy< X > &px, const sc_proxy< Y > &py)
template<class X, class Y>
const sc_lv_base sc_dt::operator^ (const sc_proxy< X > &px, const sc_proxy< Y > &py)
template<class X>
const sc_lv_base sc_dt::lrotate (const sc_proxy< X > &x, int n)
template<class X>
const sc_lv_base sc_dt::rrotate (const sc_proxy< X > &x, int n)
template<class X>
const sc_lv_base sc_dt::reverse (const sc_proxy< X > &x)
template<class X, class Y>
bool sc_dt::operator== (const sc_proxy< X > &px, const sc_proxy< Y > &py)
template<class T>
sc_concref_r< sc_bitref_r< T >
, sc_lv_base > 		sc_dt::operator, (sc_bitref_r< T >, const char *)
template<class T>
sc_concref_r< sc_lv_base,
sc_bitref_r< T > > 		sc_dt::operator, (const char *, sc_bitref_r< T >)
template<class T>
sc_concref_r< sc_bitref_r< T >
, sc_lv_base > 		sc_dt::operator, (sc_bitref_r< T >, const sc_logic &)
template<class T>
sc_concref_r< sc_lv_base,
sc_bitref_r< T > > 		sc_dt::operator, (const sc_logic &, sc_bitref_r< T >)
template<class T>
sc_concref_r< sc_bitref_r< T >
, sc_lv_base > 		sc_dt::operator, (sc_bitref_r< T >, bool)
template<class T>
sc_concref_r< sc_lv_base,
sc_bitref_r< T > > 		sc_dt::operator, (bool, sc_bitref_r< T >)
template<class T>
sc_concref_r< sc_bitref_r< T >
, sc_lv_base > 		sc_dt::concat (sc_bitref_r< T >, const char *)
template<class T>
sc_concref_r< sc_lv_base,
sc_bitref_r< T > > 		sc_dt::concat (const char *, sc_bitref_r< T >)
template<class T>
sc_concref_r< sc_bitref_r< T >
, sc_lv_base > 		sc_dt::concat (sc_bitref_r< T >, const sc_logic &)
template<class T>
sc_concref_r< sc_lv_base,
sc_bitref_r< T > > 		sc_dt::concat (const sc_logic &, sc_bitref_r< T >)
template<class T>
sc_concref_r< sc_bitref_r< T >
, sc_lv_base > 		sc_dt::concat (sc_bitref_r< T >, bool)
template<class T>
sc_concref_r< sc_lv_base,
sc_bitref_r< T > > 		sc_dt::concat (bool, sc_bitref_r< T >)
template<class T>
sc_concref_r< sc_subref_r< T >
, sc_lv_base > 		sc_dt::operator, (sc_subref_r< T >, const char *)
template<class T>
sc_concref_r< sc_lv_base,
sc_subref_r< T > > 		sc_dt::operator, (const char *, sc_subref_r< T >)
template<class T>
sc_concref_r< sc_subref_r< T >
, sc_lv_base > 		sc_dt::operator, (sc_subref_r< T >, const sc_logic &)
template<class T>
sc_concref_r< sc_lv_base,
sc_subref_r< T > > 		sc_dt::operator, (const sc_logic &, sc_subref_r< T >)
template<class T>
sc_concref_r< sc_subref_r< T >
, sc_lv_base > 		sc_dt::operator, (sc_subref_r< T >, bool)
template<class T>
sc_concref_r< sc_lv_base,
sc_subref_r< T > > 		sc_dt::operator, (bool, sc_subref_r< T >)
template<class T>
sc_concref_r< sc_subref_r< T >
, sc_lv_base > 		sc_dt::concat (sc_subref_r< T >, const char *)
template<class T>
sc_concref_r< sc_lv_base,
sc_subref_r< T > > 		sc_dt::concat (const char *, sc_subref_r< T >)
template<class T>
sc_concref_r< sc_subref_r< T >
, sc_lv_base > 		sc_dt::concat (sc_subref_r< T >, const sc_logic &)
template<class T>
sc_concref_r< sc_lv_base,
sc_subref_r< T > > 		sc_dt::concat (const sc_logic &, sc_subref_r< T >)
template<class T>
sc_concref_r< sc_subref_r< T >
, sc_lv_base > 		sc_dt::concat (sc_subref_r< T >, bool)
template<class T>
sc_concref_r< sc_lv_base,
sc_subref_r< T > > 		sc_dt::concat (bool, sc_subref_r< T >)
template<class T1, class T2>
sc_concref_r< sc_concref_r< T1,
T2 >, sc_lv_base > 		sc_dt::operator, (sc_concref_r< T1, T2 >, const char *)
template<class T1, class T2>
sc_concref_r< sc_lv_base,
sc_concref_r< T1, T2 > > 		sc_dt::operator, (const char *, sc_concref_r< T1, T2 >)
template<class T1, class T2>
sc_concref_r< sc_concref_r< T1,
T2 >, sc_lv_base > 		sc_dt::operator, (sc_concref_r< T1, T2 >, const sc_logic &)
template<class T1, class T2>
sc_concref_r< sc_lv_base,
sc_concref_r< T1, T2 > > 		sc_dt::operator, (const sc_logic &, sc_concref_r< T1, T2 >)
template<class T1, class T2>
sc_concref_r< sc_concref_r< T1,
T2 >, sc_lv_base > 		sc_dt::operator, (sc_concref_r< T1, T2 >, bool)
template<class T1, class T2>
sc_concref_r< sc_lv_base,
sc_concref_r< T1, T2 > > 		sc_dt::operator, (bool, sc_concref_r< T1, T2 >)
template<class T1, class T2>
sc_concref_r< sc_concref_r< T1,
T2 >, sc_lv_base > 		sc_dt::concat (sc_concref_r< T1, T2 >, const char *)
template<class T1, class T2>
sc_concref_r< sc_lv_base,
sc_concref_r< T1, T2 > > 		sc_dt::concat (const char *, sc_concref_r< T1, T2 >)
template<class T1, class T2>
sc_concref_r< sc_concref_r< T1,
T2 >, sc_lv_base > 		sc_dt::concat (sc_concref_r< T1, T2 >, const sc_logic &)
template<class T1, class T2>
sc_concref_r< sc_lv_base,
sc_concref_r< T1, T2 > > 		sc_dt::concat (const sc_logic &, sc_concref_r< T1, T2 >)
template<class T1, class T2>
sc_concref_r< sc_concref_r< T1,
T2 >, sc_lv_base > 		sc_dt::concat (sc_concref_r< T1, T2 >, bool)
template<class T1, class T2>
sc_concref_r< sc_lv_base,
sc_concref_r< T1, T2 > > 		sc_dt::concat (bool, sc_concref_r< T1, T2 >)
template<class T>
sc_concref_r< T, sc_lv_base > sc_dt::operator, (const sc_proxy< T > &, const char *)
template<class T>
sc_concref_r< sc_lv_base, T > sc_dt::operator, (const char *, const sc_proxy< T > &)
template<class T>
sc_concref_r< T, sc_lv_base > sc_dt::operator, (const sc_proxy< T > &, const sc_logic &)
template<class T>
sc_concref_r< sc_lv_base, T > sc_dt::operator, (const sc_logic &, const sc_proxy< T > &)
template<class T>
sc_concref_r< T, sc_lv_base > sc_dt::operator, (const sc_proxy< T > &, bool)
template<class T>
sc_concref_r< sc_lv_base, T > sc_dt::operator, (bool, const sc_proxy< T > &)
template<class T>
sc_concref_r< T, sc_lv_base > sc_dt::concat (const sc_proxy< T > &, const char *)
template<class T>
sc_concref_r< sc_lv_base, T > sc_dt::concat (const char *, const sc_proxy< T > &)
template<class T>
sc_concref_r< T, sc_lv_base > sc_dt::concat (const sc_proxy< T > &, const sc_logic &)
template<class T>
sc_concref_r< sc_lv_base, T > sc_dt::concat (const sc_logic &, const sc_proxy< T > &)
template<class T>
sc_concref_r< T, sc_lv_base > sc_dt::concat (const sc_proxy< T > &, bool)
template<class T>
sc_concref_r< sc_lv_base, T > sc_dt::concat (bool, const sc_proxy< T > &)

マクロ定義

#define DEFN_BITWISE_AND_ASN_OP_T ( tp   ) 

値:

template <class X>                                                            \
inline                                                                        \
X&                                                                            \
sc_proxy<X>::operator &= ( tp b )                                             \
{                                                                             \
    X& x = back_cast();                                                       \
    sc_lv_base a( x.length() );                                               \
    a = b;                                                                    \
    return b_and_assign_( x, a );                                             \
}

#define DEFN_BITWISE_AND_OP_T_A ( tp   ) 

値:

template <class X>                                                            \
inline                                                                        \
const sc_lv_base                                                              \
sc_proxy<X>::operator & ( tp b ) const                                        \
{                                                                             \
    sc_lv_base a( back_cast() );                                              \
    return ( a &= b );                                                        \
}

#define DEFN_BITWISE_AND_OP_T_B ( tp   ) 

値:

template <class X>                                                            \
inline                                                                        \
const sc_lv_base                                                              \
operator & ( tp b, const sc_proxy<X>& px )                                    \
{                                                                             \
    return ( px & b );                                                        \
}

#define DEFN_BITWISE_OR_ASN_OP_T ( tp   ) 

値:

template <class X>                                                            \
inline                                                                        \
X&                                                                            \
sc_proxy<X>::operator |= ( tp b )                                             \
{                                                                             \
    X& x = back_cast();                                                       \
    sc_lv_base a( x.length() );                                               \
    a = b;                                                                    \
    return b_or_assign_( x, a );                                              \
}

#define DEFN_BITWISE_OR_OP_T_A ( tp   ) 

値:

template <class X>                                                            \
inline                                                                        \
const sc_lv_base                                                              \
sc_proxy<X>::operator | ( tp b ) const                                        \
{                                                                             \
    sc_lv_base a( back_cast() );                                              \
    return ( a |= b );                                                        \
}

#define DEFN_BITWISE_OR_OP_T_B ( tp   ) 

値:

template <class X>                                                            \
inline                                                                        \
const sc_lv_base                                                              \
operator | ( tp b, const sc_proxy<X>& px )                                    \
{                                                                             \
    return ( px | b );                                                        \
}

#define DEFN_BITWISE_XOR_ASN_OP_T ( tp   ) 

値:

template <class X>                                                            \
inline                                                                        \
X&                                                                            \
sc_proxy<X>::operator ^= ( tp b )                                             \
{                                                                             \
    X& x = back_cast();                                                       \
    sc_lv_base a( x.length() );                                               \
    a = b;                                                                    \
    return b_xor_assign_( x, a );                                             \
}

#define DEFN_BITWISE_XOR_OP_T_A ( tp   ) 

値:

template <class X>                                                            \
inline                                                                        \
const sc_lv_base                                                              \
sc_proxy<X>::operator ^ ( tp b ) const                                        \
{                                                                             \
    sc_lv_base a( back_cast() );                                              \
    return ( a ^= b );                                                        \
}

#define DEFN_BITWISE_XOR_OP_T_B ( tp   ) 

値:

template <class X>                                                            \
inline                                                                        \
const sc_lv_base                                                              \
operator ^ ( tp b, const sc_proxy<X>& px )                                    \
{                                                                             \
    return ( px ^ b );                                                        \
}

#define DEFN_REL_OP_T ( tp   ) 

値:

template <class X>                                                            \
inline                                                                        \
bool                                                                          \
sc_proxy<X>::operator == ( tp b ) const                                       \
{                                                                             \
    const X& x = back_cast();                                                 \
    sc_lv_base y( x.length() );                                               \
    y = b;                                                                    \
    return ( x == y );                                                        \
}

SystemCに対してFri Jun 6 07:39:53 2008に生成されました。  doxygen 1.5.6