sc_unsigned.h

来自「基于4个mips核的noc设计」· C头文件 代码 · 共 1,850 行 · 第 1/5 页

    // assignment operators

    sc_unsigned_bitref& operator = ( const sc_unsigned_bitref_r& );
    sc_unsigned_bitref& operator = ( const sc_unsigned_bitref& );
    sc_unsigned_bitref& operator = ( bool );

    sc_unsigned_bitref& operator &= ( bool );
    sc_unsigned_bitref& operator |= ( bool );
    sc_unsigned_bitref& operator ^= ( bool );


    // other methods

    void scan( istream& is = cin );

private:

    // disabled
    sc_unsigned_bitref();
};


// l-value concatenation operators and functions

template <class T1, class T2>
inline
sc_unsigned_concref<sc_unsigned_bitref,sc_unsigned_concref<T1,T2> >
operator , ( sc_unsigned_bitref, sc_unsigned_concref<T1,T2> );

inline
sc_unsigned_concref<sc_unsigned_bitref,sc_unsigned_bitref>
operator , ( sc_unsigned_bitref, sc_unsigned_bitref );

inline
sc_unsigned_concref<sc_unsigned_bitref,sc_unsigned_subref>
operator , ( sc_unsigned_bitref, sc_unsigned_subref );

inline
sc_unsigned_concref<sc_unsigned_bitref,sc_unsigned>
operator , ( sc_unsigned_bitref, sc_unsigned& );


template <class T1, class T2>
inline
sc_unsigned_concref<sc_unsigned_bitref,sc_unsigned_concref<T1,T2> >
concat( sc_unsigned_bitref, sc_unsigned_concref<T1,T2> );

inline
sc_unsigned_concref<sc_unsigned_bitref,sc_unsigned_bitref>
concat( sc_unsigned_bitref, sc_unsigned_bitref );

inline
sc_unsigned_concref<sc_unsigned_bitref,sc_unsigned_subref>
concat( sc_unsigned_bitref, sc_unsigned_subref );

inline
sc_unsigned_concref<sc_unsigned_bitref,sc_unsigned>
concat( sc_unsigned_bitref, sc_unsigned& );


inline
istream&
operator >> ( istream&, sc_unsigned_bitref& );


// ----------------------------------------------------------------------------
//  CLASS : sc_unsigned_subref_r
//
//  Proxy class for sc_unsigned part selection (r-value only).
// ----------------------------------------------------------------------------

class sc_unsigned_subref_r
{
    friend class sc_unsigned;

protected:

    // constructor

    sc_unsigned_subref_r( const sc_unsigned& obj_, int left_, int right_ )
	: m_obj( CCAST<sc_unsigned&>( obj_ ) ),
	  m_left( left_ ), m_right( right_ )
	{}
  
public:

    // copy constructor

    sc_unsigned_subref_r( const sc_unsigned_subref_r& a )
	: m_obj( a.m_obj ), m_left( a.m_left ), m_right( a.m_right )
	{}


    // cloning

    sc_unsigned_subref_r* clone() const
	{ return new sc_unsigned_subref_r( *this ); }


    // capacity

    int length() const
        { return ( m_left - m_right + 1 ); }


    // implicit conversion to sc_unsigned

    operator sc_unsigned () const;


    // explicit conversions

    int           to_int() const;
    unsigned int  to_uint() const;
    long          to_long() const;
    unsigned long to_ulong() const;
    int64         to_int64() const;
    uint64        to_uint64() const;
    double        to_double() const;


    // explicit conversion to character string

    const sc_string to_string( sc_numrep numrep = SC_DEC ) const;
    const sc_string to_string( sc_numrep numrep, bool w_prefix ) const;


    // other methods

    void print( ostream& os = cout ) const
	{ os << to_string(); }

protected:

    sc_unsigned& m_obj;
    int          m_left;
    int          m_right;

private:

    // disabled
    sc_unsigned_subref_r();
    sc_unsigned_subref_r& operator = ( const sc_unsigned_subref_r& );
};


// r-value concatenation operators and functions

template <class T1, class T2>
inline
sc_unsigned_concref_r<sc_unsigned_subref_r,sc_unsigned_concref_r<T1,T2> >
operator , ( sc_unsigned_subref_r, sc_unsigned_concref_r<T1,T2> );

inline
sc_unsigned_concref_r<sc_unsigned_subref_r,sc_unsigned_bitref_r>
operator , ( sc_unsigned_subref_r, sc_unsigned_bitref_r );

inline
sc_unsigned_concref_r<sc_unsigned_subref_r,sc_unsigned_subref_r>
operator , ( sc_unsigned_subref_r, sc_unsigned_subref_r );

inline
sc_unsigned_concref_r<sc_unsigned_subref_r,sc_unsigned>
operator , ( sc_unsigned_subref_r, const sc_unsigned& );

inline
sc_unsigned_concref_r<sc_unsigned_subref_r,sc_unsigned>
operator , ( sc_unsigned_subref_r, bool );

inline
sc_unsigned_concref_r<sc_unsigned,sc_unsigned_subref_r>
operator , ( bool, sc_unsigned_subref_r );


template <class T1, class T2>
inline
sc_unsigned_concref_r<sc_unsigned_subref_r,sc_unsigned_concref_r<T1,T2> >
concat( sc_unsigned_subref_r, sc_unsigned_concref_r<T1,T2> );

inline
sc_unsigned_concref_r<sc_unsigned_subref_r,sc_unsigned_bitref_r>
concat( sc_unsigned_subref_r, sc_unsigned_bitref_r );

inline
sc_unsigned_concref_r<sc_unsigned_subref_r,sc_unsigned_subref_r>
concat( sc_unsigned_subref_r, sc_unsigned_subref_r );

inline
sc_unsigned_concref_r<sc_unsigned_subref_r,sc_unsigned>
concat( sc_unsigned_subref_r, const sc_unsigned& );

inline
sc_unsigned_concref_r<sc_unsigned_subref_r,sc_unsigned>
concat( sc_unsigned_subref_r, bool );

inline
sc_unsigned_concref_r<sc_unsigned,sc_unsigned_subref_r>
concat( bool, sc_unsigned_subref_r );


#ifdef SC_DT_MIXED_COMMA_OPERATORS

template <class T1, class T2>
inline
sc_unsigned_concref_r<sc_unsigned_subref_r,sc_unsigned_concref_r<T1,T2> >
operator , ( sc_unsigned_subref_r, sc_unsigned_concref<T1,T2> );

template <class T1, class T2>
inline
sc_unsigned_concref_r<sc_unsigned_subref_r,sc_unsigned_concref_r<T1,T2> >
operator , ( sc_unsigned_subref, sc_unsigned_concref_r<T1,T2> );

inline
sc_unsigned_concref_r<sc_unsigned_subref_r,sc_unsigned_bitref_r>
operator , ( sc_unsigned_subref_r, sc_unsigned_bitref );

inline
sc_unsigned_concref_r<sc_unsigned_subref_r,sc_unsigned_bitref_r>
operator , ( sc_unsigned_subref, sc_unsigned_bitref_r );

inline
sc_unsigned_concref_r<sc_unsigned_subref_r,sc_unsigned_subref_r>
operator , ( sc_unsigned_subref_r, sc_unsigned_subref );

inline
sc_unsigned_concref_r<sc_unsigned_subref_r,sc_unsigned_subref_r>
operator , ( sc_unsigned_subref, sc_unsigned_subref_r );

inline
sc_unsigned_concref_r<sc_unsigned_subref_r,sc_unsigned>
operator , ( sc_unsigned_subref_r, sc_unsigned& );

inline
sc_unsigned_concref_r<sc_unsigned_subref_r,sc_unsigned>
operator , ( sc_unsigned_subref, const sc_unsigned& );

inline
sc_unsigned_concref_r<sc_unsigned_subref_r,sc_unsigned>
operator , ( sc_unsigned_subref, bool );

inline
sc_unsigned_concref_r<sc_unsigned,sc_unsigned_subref_r>
operator , ( bool, sc_unsigned_subref );


template <class T1, class T2>
inline
sc_unsigned_concref_r<sc_unsigned_subref_r,sc_unsigned_concref_r<T1,T2> >
concat( sc_unsigned_subref_r, sc_unsigned_concref<T1,T2> );

template <class T1, class T2>
inline
sc_unsigned_concref_r<sc_unsigned_subref_r,sc_unsigned_concref_r<T1,T2> >
concat( sc_unsigned_subref, sc_unsigned_concref_r<T1,T2> );

inline
sc_unsigned_concref_r<sc_unsigned_subref_r,sc_unsigned_bitref_r>
concat( sc_unsigned_subref_r, sc_unsigned_bitref );

inline
sc_unsigned_concref_r<sc_unsigned_subref_r,sc_unsigned_bitref_r>
concat( sc_unsigned_subref, sc_unsigned_bitref_r );

inline
sc_unsigned_concref_r<sc_unsigned_subref_r,sc_unsigned_subref_r>
concat( sc_unsigned_subref_r, sc_unsigned_subref );

inline
sc_unsigned_concref_r<sc_unsigned_subref_r,sc_unsigned_subref_r>
concat( sc_unsigned_subref, sc_unsigned_subref_r );

inline
sc_unsigned_concref_r<sc_unsigned_subref_r,sc_unsigned>
concat( sc_unsigned_subref_r, sc_unsigned& );

inline
sc_unsigned_concref_r<sc_unsigned_subref_r,sc_unsigned>
concat( sc_unsigned_subref, const sc_unsigned& );

inline
sc_unsigned_concref_r<sc_unsigned_subref_r,sc_unsigned>
concat( sc_unsigned_subref, bool );

inline
sc_unsigned_concref_r<sc_unsigned,sc_unsigned_subref_r>
concat( bool, sc_unsigned_subref );

#endif


inline
ostream&
operator << ( ostream&, const sc_unsigned_subref_r& );


// ----------------------------------------------------------------------------
//  CLASS : sc_unsigned_subref
//
//  Proxy class for sc_unsigned part selection (r-value and l-value).
// ----------------------------------------------------------------------------

class sc_unsigned_subref
    : public sc_unsigned_subref_r
{
    friend class sc_unsigned;


    // constructor

    sc_unsigned_subref( sc_unsigned& obj_, int left_, int right_ )
	: sc_unsigned_subref_r( obj_, left_, right_ )
	{}
  
public:

    // copy constructor

    sc_unsigned_subref( const sc_unsigned_subref& a )
	: sc_unsigned_subref_r( a )
	{}


    // cloning

    sc_unsigned_subref* clone() const
	{ return new sc_unsigned_subref( *this ); }


    // assignment operators

    sc_unsigned_subref& operator = ( const sc_unsigned_subref_r& a );
    sc_unsigned_subref& operator = ( const sc_unsigned_subref& a );
    sc_unsigned_subref& operator = ( const sc_unsigned& a );

    template <class T1, class T2>
    sc_unsigned_subref& operator = ( const sc_unsigned_concref_r<T1,T2>& a )
	{ NOT_YET_IMPLEMENTED; return *this; }

    sc_unsigned_subref& operator = ( const sc_signed_subref_r& a );
    sc_unsigned_subref& operator = ( const sc_signed& a );

    template <class T1, class T2>
    sc_unsigned_subref& operator = ( const sc_signed_concref_r<T1,T2>& a )
	{ NOT_YET_IMPLEMENTED; return *this; }

    sc_unsigned_subref& operator = ( const char* a );
    sc_unsigned_subref& operator = ( unsigned long a );
    sc_unsigned_subref& operator = ( long a );

    sc_unsigned_subref& operator = ( unsigned int a )
	{ return operator = ( (unsigned long) a ); }

    sc_unsigned_subref& operator = ( int a )
	{ return operator = ( (long) a ); }

    sc_unsigned_subref& operator = ( uint64 a );
    sc_unsigned_subref& operator = ( int64 a );
    sc_unsigned_subref& operator = ( double a );  
    sc_unsigned_subref& operator = ( const sc_int_base& a );
    sc_unsigned_subref& operator = ( const sc_uint_base& a );


    // other methods

    void scan( istream& is = cin );

private:

    // disabled
    sc_unsigned_subref();