sc_signed.h

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

    // other methods

    void scan( istream& is = cin );

private:

    // disabled
    sc_signed_bitref();
};


// l-value concatenation operators and functions

template <class T1, class T2>
inline
sc_signed_concref<sc_signed_bitref,sc_signed_concref<T1,T2> >
operator , ( sc_signed_bitref, sc_signed_concref<T1,T2> );

inline
sc_signed_concref<sc_signed_bitref,sc_signed_bitref>
operator , ( sc_signed_bitref, sc_signed_bitref );

inline
sc_signed_concref<sc_signed_bitref,sc_signed_subref>
operator , ( sc_signed_bitref, sc_signed_subref );

inline
sc_signed_concref<sc_signed_bitref,sc_signed>
operator , ( sc_signed_bitref, sc_signed& );


template <class T1, class T2>
inline
sc_signed_concref<sc_signed_bitref,sc_signed_concref<T1,T2> >
concat( sc_signed_bitref, sc_signed_concref<T1,T2> );

inline
sc_signed_concref<sc_signed_bitref,sc_signed_bitref>
concat( sc_signed_bitref, sc_signed_bitref );

inline
sc_signed_concref<sc_signed_bitref,sc_signed_subref>
concat( sc_signed_bitref, sc_signed_subref );

inline
sc_signed_concref<sc_signed_bitref,sc_signed>
concat( sc_signed_bitref, sc_signed& );


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


// ----------------------------------------------------------------------------
//  CLASS : sc_signed_subref_r
//
//  Proxy class for sc_signed part selection (r-value only).
// ----------------------------------------------------------------------------

class sc_signed_subref_r
{
    friend class sc_signed;

protected:

    // constructor

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

    // copy constructor

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


    // cloning

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


    // capacity

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


    // implicit conversion to sc_signed

    operator sc_signed () 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_signed& m_obj;
    int        m_left;
    int        m_right;

private:

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


// r-value concatenation operators and functions

template <class T1, class T2>
inline
sc_signed_concref_r<sc_signed_subref_r,sc_signed_concref_r<T1,T2> >
operator , ( sc_signed_subref_r, sc_signed_concref_r<T1,T2> );

inline
sc_signed_concref_r<sc_signed_subref_r,sc_signed_bitref_r>
operator , ( sc_signed_subref_r, sc_signed_bitref_r );

inline
sc_signed_concref_r<sc_signed_subref_r,sc_signed_subref_r>
operator , ( sc_signed_subref_r, sc_signed_subref_r );

inline
sc_signed_concref_r<sc_signed_subref_r,sc_signed>
operator , ( sc_signed_subref_r, const sc_signed& );

inline
sc_signed_concref_r<sc_signed_subref_r,sc_signed>
operator , ( sc_signed_subref_r, bool );

inline
sc_signed_concref_r<sc_signed,sc_signed_subref_r>
operator , ( bool, sc_signed_subref_r );


template <class T1, class T2>
inline
sc_signed_concref_r<sc_signed_subref_r,sc_signed_concref_r<T1,T2> >
concat( sc_signed_subref_r, sc_signed_concref_r<T1,T2> );

inline
sc_signed_concref_r<sc_signed_subref_r,sc_signed_bitref_r>
concat( sc_signed_subref_r, sc_signed_bitref_r );

inline
sc_signed_concref_r<sc_signed_subref_r,sc_signed_subref_r>
concat( sc_signed_subref_r, sc_signed_subref_r );

inline
sc_signed_concref_r<sc_signed_subref_r,sc_signed>
concat( sc_signed_subref_r, const sc_signed& );

inline
sc_signed_concref_r<sc_signed_subref_r,sc_signed>
concat( sc_signed_subref_r, bool );

inline
sc_signed_concref_r<sc_signed,sc_signed_subref_r>
concat( bool, sc_signed_subref_r );


#ifdef SC_DT_MIXED_COMMA_OPERATORS

template <class T1, class T2>
inline
sc_signed_concref_r<sc_signed_subref_r,sc_signed_concref_r<T1,T2> >
operator , ( sc_signed_subref_r, sc_signed_concref<T1,T2> );

template <class T1, class T2>
inline
sc_signed_concref_r<sc_signed_subref_r,sc_signed_concref_r<T1,T2> >
operator , ( sc_signed_subref, sc_signed_concref_r<T1,T2> );

inline
sc_signed_concref_r<sc_signed_subref_r,sc_signed_bitref_r>
operator , ( sc_signed_subref_r, sc_signed_bitref );

inline
sc_signed_concref_r<sc_signed_subref_r,sc_signed_bitref_r>
operator , ( sc_signed_subref, sc_signed_bitref_r );

inline
sc_signed_concref_r<sc_signed_subref_r,sc_signed_subref_r>
operator , ( sc_signed_subref_r, sc_signed_subref );

inline
sc_signed_concref_r<sc_signed_subref_r,sc_signed_subref_r>
operator , ( sc_signed_subref, sc_signed_subref_r );

inline
sc_signed_concref_r<sc_signed_subref_r,sc_signed>
operator , ( sc_signed_subref_r, sc_signed& );

inline
sc_signed_concref_r<sc_signed_subref_r,sc_signed>
operator , ( sc_signed_subref, const sc_signed& );

inline
sc_signed_concref_r<sc_signed_subref_r,sc_signed>
operator , ( sc_signed_subref, bool );

inline
sc_signed_concref_r<sc_signed,sc_signed_subref_r>
operator , ( bool, sc_signed_subref );


template <class T1, class T2>
inline
sc_signed_concref_r<sc_signed_subref_r,sc_signed_concref_r<T1,T2> >
concat( sc_signed_subref_r, sc_signed_concref<T1,T2> );

template <class T1, class T2>
inline
sc_signed_concref_r<sc_signed_subref_r,sc_signed_concref_r<T1,T2> >
concat( sc_signed_subref, sc_signed_concref_r<T1,T2> );

inline
sc_signed_concref_r<sc_signed_subref_r,sc_signed_bitref_r>
concat( sc_signed_subref_r, sc_signed_bitref );

inline
sc_signed_concref_r<sc_signed_subref_r,sc_signed_bitref_r>
concat( sc_signed_subref, sc_signed_bitref_r );

inline
sc_signed_concref_r<sc_signed_subref_r,sc_signed_subref_r>
concat( sc_signed_subref_r, sc_signed_subref );

inline
sc_signed_concref_r<sc_signed_subref_r,sc_signed_subref_r>
concat( sc_signed_subref, sc_signed_subref_r );

inline
sc_signed_concref_r<sc_signed_subref_r,sc_signed>
concat( sc_signed_subref_r, sc_signed& );

inline
sc_signed_concref_r<sc_signed_subref_r,sc_signed>
concat( sc_signed_subref, const sc_signed& );

inline
sc_signed_concref_r<sc_signed_subref_r,sc_signed>
concat( sc_signed_subref, bool );

inline
sc_signed_concref_r<sc_signed,sc_signed_subref_r>
concat( bool, sc_signed_subref );

#endif


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


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

class sc_signed_subref
    : public sc_signed_subref_r
{
    friend class sc_signed;


    // constructor

    sc_signed_subref( sc_signed& obj_, int left_, int right_ )
	: sc_signed_subref_r( obj_, left_, right_ )
	{}
  
public:

    // copy constructor

    sc_signed_subref( const sc_signed_subref& a )
	: sc_signed_subref_r( a )
	{}


    // cloning

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


    // assignment operators

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

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

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

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

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

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

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

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


    // other methods

    void scan( istream& is = cin );

private:

    // disabled
    sc_signed_subref();
};


// l-value concatenation operators and functions

template <class T1, class T2>
inline
sc_signed_concref<sc_signed_subref,sc_signed_concref<T1,T2> >
operator , ( sc_signed_subref, sc_signed_concref<T1,T2> );

inline
sc_signed_concref<sc_signed_subref,sc_signed_bitref>
operator , ( sc_signed_subref, sc_signed_bitref );

inline
sc_signed_concref<sc_signed_subref,sc_signed_subref>
operator , ( sc_signed_subref, sc_signed_subref );