scx_signal_uint.h

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

inline void sc_signal<sc_dt::sc_uint<W> >::check_writer()
{
    sc_process_b* writer_p = sc_get_current_process_b();
    if( m_writer_p == 0 ) 
    {   
        m_writer_p = writer_p;
    } 
    else if( m_writer_p != writer_p ) 
    {   
        sc_signal_invalid_writer( name(), kind(),
                                  m_writer_p->name(), writer_p->name() );
    }
}


//------------------------------------------------------------------------------
//"sc_signal<sc_dt::sc_uint<W> >::concat_set"
//
// These virtual methods allow value assignments to this object instance
// from various sources. The position within the supplied source of the 
// low order bit for this object instance's value is low_i.
//     src   = source value.
//     low_i = bit within src to serve as low order bit of this object 
//             instance's value.
//------------------------------------------------------------------------------
SC_TEMPLATE
inline void sc_signal<sc_dt::sc_uint<W> >::concat_set(
    sc_dt::int64 src, int low_i)
{
    if ( low_i < 64 )
    {
        base_write(src >> low_i);
    }
    else
    {
        base_write( (src < 0 ) ? src >> 63 : 0 );
    } 
}

SC_TEMPLATE
inline void sc_signal<sc_dt::sc_uint<W> >::concat_set(
    const sc_dt::sc_lv_base& src, int low_i)
{
    sc_dt::sc_unsigned tmp(src.length());
    tmp = src >> low_i;
    base_write( tmp.to_uint64() );
}

SC_TEMPLATE
inline void sc_signal<sc_dt::sc_uint<W> >::concat_set(
    const sc_dt::sc_signed& src, int low_i)
{
    base_write( (src >> low_i).to_uint64());
}

SC_TEMPLATE
inline void sc_signal<sc_dt::sc_uint<W> >::concat_set(
    const sc_dt::sc_unsigned& src, int low_i)
{
    base_write( (src >> low_i).to_uint64());
}

SC_TEMPLATE
inline void sc_signal<sc_dt::sc_uint<W> >::concat_set(
    sc_dt::uint64 src, int low_i)
{
    base_write( ( low_i < 64 ) ? src >> low_i : 0 );
}



SC_TEMPLATE // Return the default event for this object instance.
inline const sc_event& sc_signal<sc_dt::sc_uint<W> >::default_event() const 
	{ return base_value_changed_event(); }


SC_TEMPLATE // Return true if a changed event happened in the last delta cycle.
inline bool sc_signal<sc_dt::sc_uint<W> >::event() const
	{ return base_event(); }


SC_TEMPLATE // Return a reference to the value of this object instance.
inline const sc_dt::sc_uint<W>& 
sc_signal<sc_dt::sc_uint<W> >::get_data_ref() const
	{ return *this; }


#if 0
SC_TEMPLATE // Return a pointer to this object instance.
inline sc_signal<sc_dt::sc_uint<W> >& sc_signal<sc_dt::sc_uint<W> >::get_signal() 
	{ return *this; }
#endif // 0


SC_TEMPLATE // Return a kind value of "sc_signal".
inline const char* sc_signal<sc_dt::sc_uint<W> >::kind() const
{
	return "sc_signal";
}


//------------------------------------------------------------------------------
//"sc_signal_uint::operator ()
//
// This operator returns a part selection of this object instance.
//     left  = left-hand bit of the selection.
//     right = right-hand bit of the selection.
//------------------------------------------------------------------------------
SC_TEMPLATE
inline sc_uint_sigref& sc_signal<sc_dt::sc_uint<W> >::operator () 
    (int left, int right)
{
    sc_uint_sigref* result_p;   // Value to return.

	result_p = sc_uint_sigref::m_pool.allocate();
	result_p->initialize(this, left, right);
	return *result_p;
}


//------------------------------------------------------------------------------
//"sc_signal_uint::operator []"
//
// This operator returns a bit selection of this object instance.
//     i = bit to be selected.
//------------------------------------------------------------------------------
SC_TEMPLATE
inline sc_uint_sigref& sc_signal<sc_dt::sc_uint<W> >::operator [] ( int bit )
{
    return operator () (bit,bit);
}

SC_TEMPLATE
inline void sc_signal<sc_dt::sc_uint<W> >::operator = ( 
    const this_type& new_val )
	{ base_write( (sc_dt::uint64)new_val ); }

SC_TEMPLATE
inline void sc_signal<sc_dt::sc_uint<W> >::operator = ( sc_dt::uint64 new_val )
	{ base_write(new_val); }


SC_TEMPLATE 
inline void sc_signal<sc_dt::sc_uint<W> >::operator = ( const char* new_val )
	{ m_new_val = sc_dt::sc_uint<64>(new_val); request_update(); }


SC_TEMPLATE
inline void sc_signal<sc_dt::sc_uint<W> >::operator = ( sc_dt::int64 new_val )
	{ base_write((sc_dt::uint64)new_val); }


SC_TEMPLATE
inline void sc_signal<sc_dt::sc_uint<W> >::operator = ( int new_val )
	{ base_write((sc_dt::uint64)new_val); }


SC_TEMPLATE
inline void sc_signal<sc_dt::sc_uint<W> >::operator = ( long new_val ) 
	{ base_write((sc_dt::uint64)new_val); }


SC_TEMPLATE
inline void sc_signal<sc_dt::sc_uint<W> >::operator = ( short new_val ) 
	{ base_write((sc_dt::uint64)new_val); }


SC_TEMPLATE
inline void sc_signal<sc_dt::sc_uint<W> >::operator = ( unsigned int new_val ) 
	{ base_write((sc_dt::uint64)new_val); }


SC_TEMPLATE
inline void sc_signal<sc_dt::sc_uint<W> >::operator = ( unsigned long new_val )
	{ base_write((sc_dt::uint64)new_val); }


SC_TEMPLATE
inline void sc_signal<sc_dt::sc_uint<W> >::operator = ( unsigned short new_val )
	{ base_write((sc_dt::uint64)new_val); }


SC_TEMPLATE
template<typename T>
inline void sc_signal<sc_dt::sc_uint<W> >::operator = ( 
	const sc_dt::sc_generic_base<T>& new_val )
	{ base_write(new_val->to_uint64()); }


SC_TEMPLATE
inline void sc_signal<sc_dt::sc_uint<W> >::operator = ( 
    const sc_dt::sc_signed& new_val )
	{ base_write(new_val.to_uint64()); }


SC_TEMPLATE
inline void sc_signal<sc_dt::sc_uint<W> >::operator = ( 
    const sc_dt::sc_unsigned& new_val )
	{ base_write(new_val.to_uint64()); }

SC_TEMPLATE
inline void sc_signal<sc_dt::sc_uint<W> >::operator = ( 
    const sc_dt::sc_bv_base& new_val )
	{ base_write( (sc_dt::sc_uint<W>)new_val ); }

SC_TEMPLATE
inline void sc_signal<sc_dt::sc_uint<W> >::operator = ( 
    const sc_dt::sc_lv_base& new_val )
	{ base_write( (sc_dt::sc_uint<W>)new_val ); }


SC_TEMPLATE
inline sc_dt::sc_uint_base* sc_signal<sc_dt::sc_uint<W> >::part_read_target()
    { return this; }


SC_TEMPLATE
inline const sc_dt::sc_uint<W>& sc_signal<sc_dt::sc_uint<W> >::read() const
	{ return *this; }


SC_TEMPLATE // Read a portion of a value.
inline sc_dt::uint64 sc_signal<sc_dt::sc_uint<W> >::read_part( int left, int right ) const
{
	// This pointer required for HP aCC.
    return (this->m_val & ~sc_dt::mask_int[left][right]) >> right;
}

SC_TEMPLATE
inline void sc_signal<sc_dt::sc_uint<W> >::register_port( 
	sc_port_base& port_, const char* if_typename_ )
{
#       ifdef DEBUG_SYSTEMC
		std::string nm( if_typename_ );
		if( nm == typeid( sc_signal_inout_if<sc_dt::sc_uint<W> > ).name() ) 
		{
			if( m_output_p != 0 ) 
			{
				sc_signal_invalid_writer( name(), kind(),
					 m_output_p->name(), port_.name() );
			}
			m_output_p = &port_;
		}
#       endif
}


SC_TEMPLATE // Autogenerated name object instance constructor.
inline sc_signal<sc_dt::sc_uint<W> >::sc_signal() : 
	sc_prim_channel(sc_gen_unique_name( "signal" )),
	m_changed_event_p(0),
	m_output_p(0),
	m_writer_p(0)
{ }


SC_TEMPLATE // Explicitly named object instance constructor.
inline sc_signal<sc_dt::sc_uint<W> >::sc_signal(const char* name_) : 
	sc_prim_channel(name_),
	m_changed_event_p(0),
	m_output_p(0),
	m_writer_p(0)
{ }


SC_TEMPLATE // Object instance destructor.
inline sc_signal<sc_dt::sc_uint<W> >::~sc_signal() 
{
	if ( m_changed_event_p ) delete m_changed_event_p;
}


SC_TEMPLATE // Update the current value from new value.
inline void sc_signal<sc_dt::sc_uint<W> >::update()
{
    if ( m_changed_event_p )
    {
		// This pointer required for HP aCC.
        sc_dt::uint64 old_val = this->m_val;
		sc_dt::sc_uint_base::operator = (m_new_val);
        if ( old_val != this->m_val )
        {
            m_changed_event_p->notify_delayed();
            m_event_delta = simcontext()->delta_count();
        }
    }
    else
    {
		sc_dt::sc_uint_base::operator = (m_new_val);
    }
}


SC_TEMPLATE // Return the value changed event.
inline const sc_event& sc_signal<sc_dt::sc_uint<W> >::value_changed_event() const
	{ return base_value_changed_event(); }


SC_TEMPLATE // Write a sc_in<sc_dt::sc_uint<W> > value to this object instance.
inline void sc_signal<sc_dt::sc_uint<W> >::write( const sc_in<sc_dt::sc_uint<W> >& value ) 
	{ base_write( value.operator sc_dt::uint64 () ); }


SC_TEMPLATE // Write a sc_inout<sc_dt::sc_uint<W> > value to this object instance.
inline void sc_signal<sc_dt::sc_uint<W> >::write( const sc_inout<sc_dt::sc_uint<W> >& value ) 
	{ base_write( value.operator sc_dt::uint64 () ); }


SC_TEMPLATE // Write a sc_dt::sc_uint<W> value to this object instance.
inline void sc_signal<sc_dt::sc_uint<W> >::write( 
    const sc_dt::sc_uint<W>& value ) 
	{ base_write( value); }


SC_TEMPLATE // Select a portion of a value. 
inline sc_uint_sigref& sc_signal<sc_dt::sc_uint<W> >::select_part(int left, int right)
{
	sc_uint_sigref* result_p = sc_uint_sigref::m_pool.allocate();
	result_p->initialize(this, left, right);
	return *result_p;
}


SC_TEMPLATE // Write a portion of a value. If this is the first write in 
            // a delta cycle we copy the existing value before setting the bits.
inline void sc_signal<sc_dt::sc_uint<W> >::write_part( sc_dt::uint64 v, int left, int right ) 
{
    sc_dt::uint64 new_v;   // New value.
    sc_dt::uint64 keep;    // Keep mask value.

    keep = sc_dt::mask_int[left][right];
    new_v = (m_new_val & keep) | ((v << right) & ~keep);
    m_new_val = new_v;
	request_update();
}


//==============================================================================
// CLASS sc_in<sc_dt::sc_uint<W> >
//
// This class implements an input port whose target acts like an sc_dt::sc_uint<W> data
// value. This class is a specialization of the generic sc_in class to 
// implement tailored support for the sc_dt::sc_uint<W> class.
//==============================================================================
SC_TEMPLATE
class sc_in<sc_dt::sc_uint<W> > : 
    public sc_port<sc_signal_in_if<sc_dt::sc_uint<W> >, 1,
                   SC_ONE_OR_MORE_BOUND>,
    public sc_dt::sc_value_base
{
  public:

    // typedefs

    typedef sc_dt::sc_uint<W>                       data_type;
    typedef sc_signal_in_if<sc_dt::sc_uint<W> >     if_type;
    typedef sc_port<if_type,1,SC_ONE_OR_MORE_BOUND> base_type;
    typedef sc_in<sc_dt::sc_uint<W> >               this_type;

    typedef if_type                                 in_if_type;
    typedef base_type                               in_port_type;
    typedef sc_signal_inout_if<sc_dt::sc_uint<W> >  inout_if_type;
    typedef sc_inout<sc_dt::sc_uint<W> >            inout_port_type;

  public:

    // bind methods and operators:

    void bind( const in_if_type& interface_ ) 
        { sc_port_base::bind( CCAST<in_if_type&>( interface_) );}
    void operator () ( const in_if_type& interface_ )
        { sc_port_base::bind( CCAST<in_if_type&>( interface_) );}
    void bind( in_port_type& parent_ )
        { sc_port_base::bind(parent_);}
    void operator () ( in_port_type& parent_ )
        { sc_port_base::bind(parent_);}
    void bind( inout_port_type& parent_ )
        { sc_port_base::bind(parent_);}