sc_bit.h

system C源码 一种替代verilog的语言

	{ return m_val; }

    bool operator ! () const  // non-VSIA
	{ return ! m_val; }


    // explicit conversions

    bool to_bool() const  // non-VSIA
	{ return m_val; }

    char to_char() const
	{ return ( m_val ? '1' : '0' ); }


    // relational operators and functions

    // MANDATORY

    friend bool operator == ( const sc_bit& a, const sc_bit& b )
        { return ( a.m_val == b.m_val ); }

    friend bool operator == ( const sc_bit& a, int b )
        { return ( a == sc_bit( b ) ); }

    friend bool operator == ( const sc_bit& a, bool b )
        { return ( a == sc_bit( b ) ); }

    friend bool operator == ( const sc_bit& a, char b )
        { return ( a == sc_bit( b ) ); }

    friend bool operator == ( int a, const sc_bit& b )
	{ return ( sc_bit( a ) == b ); }

    friend bool operator == ( bool a, const sc_bit& b )
	{ return ( sc_bit( a ) == b ); }

    friend bool operator == ( char a, const sc_bit& b )
	{ return ( sc_bit( a ) == b ); }

    // OPTIONAL

    friend bool equal( const sc_bit& a, const sc_bit& b )
        { return ( a == b ); }

    friend bool equal( const sc_bit& a, int b )
        { return ( a == b ); }

    friend bool equal( const sc_bit& a, bool b )
        { return ( a == b ); }

    friend bool equal( const sc_bit& a, char b )
        { return ( a == b ); }

    friend bool equal( int a, const sc_bit& b )
        { return ( a == b ); }

    friend bool equal( bool a, const sc_bit& b )
        { return ( a == b ); }

    friend bool equal( char a, const sc_bit& b )
        { return ( a == b ); }

    // MANDATORY

    friend bool operator != ( const sc_bit& a, const sc_bit& b )
        { return ( a.m_val != b.m_val ); }

    friend bool operator != ( const sc_bit& a, int b )
        { return ( a != sc_bit( b ) ); }

    friend bool operator != ( const sc_bit& a, bool b )
        { return ( a != sc_bit( b ) ); }

    friend bool operator != ( const sc_bit& a, char b )
        { return ( a != sc_bit( b ) ); }

    friend bool operator != ( int a, const sc_bit& b )
        { return ( sc_bit( a ) != b ); }

    friend bool operator != ( bool a, const sc_bit& b )
        { return ( sc_bit( a ) != b ); }

    friend bool operator != ( char a, const sc_bit& b )
        { return ( sc_bit( a ) != b ); }

    // OPTIONAL

    friend bool not_equal( const sc_bit& a, const sc_bit& b )
        { return ( a != b ); }

    friend bool not_equal( const sc_bit& a, int b )
        { return ( a != b ); }

    friend bool not_equal( const sc_bit& a, bool b )
        { return ( a != b ); }

    friend bool not_equal( const sc_bit& a, char b )
        { return ( a != b ); }

    friend bool not_equal( int a, const sc_bit& b )
        { return ( a != b ); }

    friend bool not_equal( bool a, const sc_bit& b )
        { return ( a != b ); }

    friend bool not_equal( char a, const sc_bit& b )
        { return ( a != b ); }


    // bitwise operators and functions

    // bitwise complement

    // MANDATORY

    friend const sc_bit operator ~ ( const sc_bit& a )
        { return sc_bit( ! a.m_val ); }

    // RECOMMENDED

    sc_bit& b_not()
        { m_val = ( ! m_val ); return *this; }

    // OPTIONAL

    friend const sc_bit b_not( const sc_bit& a )
        { return ( ~ a ); }

    // RECOMMENDED

    friend void b_not( sc_bit& r, const sc_bit& a )
        { r = ( ~ a ); }


    // bitwise or

    // MANDATORY

    friend const sc_bit operator | ( const sc_bit& a, const sc_bit& b )
        { return sc_bit( a.m_val || b.m_val ); }

    friend const sc_bit operator | ( const sc_bit& a, int b )
        { return ( a | sc_bit( b ) ); }

    friend const sc_bit operator | ( const sc_bit& a, bool b )
        { return ( a | sc_bit( b ) ); }

    friend const sc_bit operator | ( const sc_bit& a, char b )
        { return ( a | sc_bit( b ) ); }

    friend const sc_bit operator | ( int a, const sc_bit& b )
	{ return ( sc_bit( a ) | b ); }

    friend const sc_bit operator | ( bool a, const sc_bit& b )
	{ return ( sc_bit( a ) | b ); }

    friend const sc_bit operator | ( char a, const sc_bit& b )
	{ return ( sc_bit( a ) | b ); }

    // OPTIONAL

    friend const sc_bit b_or( const sc_bit& a, const sc_bit& b )
        { return ( a | b ); }

    friend const sc_bit b_or( const sc_bit& a, int b )
        { return ( a | b ); }

    friend const sc_bit b_or( const sc_bit& a, bool b )
        { return ( a | b ); }

    friend const sc_bit b_or( const sc_bit& a, char b )
        { return ( a | b ); }

    friend const sc_bit b_or( int a, const sc_bit& b )
        { return ( a | b ); }

    friend const sc_bit b_or( bool a, const sc_bit& b )
        { return ( a | b ); }

    friend const sc_bit b_or( char a, const sc_bit& b )
        { return ( a | b ); }

    // RECOMMENDED

    friend void b_or( sc_bit& r, const sc_bit& a, const sc_bit& b )
        { r = ( a | b ); }

    friend void b_or( sc_bit& r, const sc_bit& a, int b )
        { r = ( a | b ); }

    friend void b_or( sc_bit& r, const sc_bit& a, bool b )
        { r = ( a | b ); }

    friend void b_or( sc_bit& r, const sc_bit& a, char b )
        { r = ( a | b ); }

    friend void b_or( sc_bit& r, int a, const sc_bit& b )
        { r = ( a | b ); }

    friend void b_or( sc_bit& r, bool a, const sc_bit& b )
        { r = ( a | b ); }

    friend void b_or( sc_bit& r, char a, const sc_bit& b )
        { r = ( a | b ); }


    // bitwise and

    // MANDATORY

    friend const sc_bit operator & ( const sc_bit& a, const sc_bit& b )
	{ return sc_bit( a.m_val && b.m_val ); }

    friend const sc_bit operator & ( const sc_bit& a, int b )
	{ return ( a & sc_bit( b ) ); }

    friend const sc_bit operator & ( const sc_bit& a, bool b )
	{ return ( a & sc_bit( b ) ); }

    friend const sc_bit operator & ( const sc_bit& a, char b )
	{ return ( a & sc_bit( b ) ); }

    friend const sc_bit operator & ( int a, const sc_bit& b )
	{ return ( sc_bit( a ) & b ); }

    friend const sc_bit operator & ( bool a, const sc_bit& b )
	{ return ( sc_bit( a ) & b ); }

    friend const sc_bit operator & ( char a, const sc_bit& b )
	{ return ( sc_bit( a ) & b ); }

    // OPTIONAL

    friend const sc_bit b_and( const sc_bit& a, const sc_bit& b )
	{ return ( a & b ); }

    friend const sc_bit b_and( const sc_bit& a, int b )
	{ return ( a & b ); }

    friend const sc_bit b_and( const sc_bit& a, bool b )
	{ return ( a & b ); }

    friend const sc_bit b_and( const sc_bit& a, char b )
	{ return ( a & b ); }

    friend const sc_bit b_and( int a, const sc_bit& b )
	{ return ( a & b ); }

    friend const sc_bit b_and( bool a, const sc_bit& b )
	{ return ( a & b ); }

    friend const sc_bit b_and( char a, const sc_bit& b )
	{ return ( a & b ); }

    // RECOMMENDED

    friend void b_and( sc_bit& r, const sc_bit& a, const sc_bit& b )
	{ r = ( a & b ); }

    friend void b_and( sc_bit& r, const sc_bit& a, int b )
	{ r = ( a & b ); }

    friend void b_and( sc_bit& r, const sc_bit& a, bool b )
	{ r = ( a & b ); }

    friend void b_and( sc_bit& r, const sc_bit& a, char b )
	{ r = ( a & b ); }

    friend void b_and( sc_bit& r, int a, const sc_bit& b )
	{ r = ( a & b ); }

    friend void b_and( sc_bit& r, bool a, const sc_bit& b )
	{ r = ( a & b ); }

    friend void b_and( sc_bit& r, char a, const sc_bit& b )
	{ r = ( a & b ); }


    // bitwise exor

    // MANDATORY

    friend const sc_bit operator ^ ( const sc_bit& a, const sc_bit& b )
	{ return sc_bit( a.m_val != b.m_val ); }

    friend const sc_bit operator ^ ( const sc_bit& a, int b )
	{ return ( a ^ sc_bit( b ) ); }

    friend const sc_bit operator ^ ( const sc_bit& a, bool b )
	{ return ( a ^ sc_bit( b ) ); }

    friend const sc_bit operator ^ ( const sc_bit& a, char b )
	{ return ( a ^ sc_bit( b ) ); }

    friend const sc_bit operator ^ ( int a, const sc_bit& b )
	{ return ( sc_bit( a ) ^ b ); }

    friend const sc_bit operator ^ ( bool a, const sc_bit& b )
	{ return ( sc_bit( a ) ^ b ); }

    friend const sc_bit operator ^ ( char a, const sc_bit& b )
	{ return ( sc_bit( a ) ^ b ); }

    // OPTIONAL

    friend const sc_bit b_xor( const sc_bit& a, const sc_bit& b )
	{ return ( a ^ b ); }

    friend const sc_bit b_xor( const sc_bit& a, int b )
	{ return ( a ^ b ); }

    friend const sc_bit b_xor( const sc_bit& a, bool b )
	{ return ( a ^ b ); }

    friend const sc_bit b_xor( const sc_bit& a, char b )
	{ return ( a ^ b ); }

    friend const sc_bit b_xor( int a, const sc_bit& b )
	{ return ( a ^ b ); }

    friend const sc_bit b_xor( bool a, const sc_bit& b )
	{ return ( a ^ b ); }

    friend const sc_bit b_xor( char a, const sc_bit& b )
	{ return ( a ^ b ); }

    // RECOMMENDED

    friend void b_xor( sc_bit& r, const sc_bit& a, const sc_bit& b )
	{ r = ( a ^ b ); }

    friend void b_xor( sc_bit& r, const sc_bit& a, int b )
	{ r = ( a ^ b ); }

    friend void b_xor( sc_bit& r, const sc_bit& a, bool b )
	{ r = ( a ^ b ); }

    friend void b_xor( sc_bit& r, const sc_bit& a, char b )
	{ r = ( a ^ b ); }

    friend void b_xor( sc_bit& r, int a, const sc_bit& b )
	{ r = ( a ^ b ); }

    friend void b_xor( sc_bit& r, bool a, const sc_bit& b )
	{ r = ( a ^ b ); }

    friend void b_xor( sc_bit& r, char a, const sc_bit& b )
	{ r = ( a ^ b ); }


    // other methods

    void print( ::std::ostream& os = ::std::cout ) const
	{ os << to_bool(); }

    void scan( ::std::istream& = ::std::cin );

private:

    bool m_val;
};


// ----------------------------------------------------------------------------

inline
::std::ostream&
operator << ( ::std::ostream& os, const sc_bit& a )
{
    a.print( os );
    return os;
}

inline
::std::istream&
operator >> ( ::std::istream& is, sc_bit& a )
{
    a.scan( is );
    return is;
}

} // namespace sc_dt


#endif

// Taf!