scx_signal_int.h

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

inline void sc_signal<sc_dt::sc_int<W> >::check_writer()
{
    sc_process_b* writer_p = sc_get_curr_process_handle();
    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_int<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_int<W> >::concat_set(sc_dt::int64 src, int low_i)
{
    if ( low_i < 64 )
    {
        base_write(src >> low_i);
    }
    else
    {
        base_write( src >> 63 );
    } 
}

SC_TEMPLATE
inline void sc_signal<sc_dt::sc_int<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_int64() );
}

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

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

SC_TEMPLATE
inline void sc_signal<sc_dt::sc_int<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_int<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_int<W> >::event() const
	{ return base_event(); }


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


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


SC_TEMPLATE // Return a kind value of "sc_signal".
inline const char* sc_signal<sc_dt::sc_int<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_int_sigref& sc_signal<sc_dt::sc_int<W> >::operator () (int left, int right)
{
    sc_int_sigref* result_p;   // Value to return.

	result_p = sc_int_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_int_sigref& sc_signal<sc_dt::sc_int<W> >::operator [] ( int bit )
{
    return operator () (bit,bit);
}


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

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

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

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

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

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

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

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

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

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


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

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

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

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

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


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


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


SC_TEMPLATE // Read a portion of a value.
inline sc_dt::uint64 sc_signal<sc_dt::sc_int<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_int<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_int<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_int<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_int<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_int<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_int<W> >::update()
{
    if ( m_changed_event_p )
    {
		// This pointer required for HP aCC.
        sc_dt::int64 old_val = this->m_val;
        sc_dt::sc_int_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_int_base::operator = (m_new_val);
    }
}


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


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


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


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


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_int<W> >::write_part( sc_dt::uint64 v, int left, int right ) 
{
    sc_dt::int64  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);
	if ( m_new_val != new_v ) request_update();
    m_new_val = new_v;
}


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

    // typedefs

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

    typedef if_type                               in_if_type;
    typedef base_type                             in_port_type;
    typedef sc_signal_inout_if<sc_dt::sc_int<W> > inout_if_type;
    typedef sc_inout<sc_dt::sc_int<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_);}
    void operator () ( inout_port_type& parent_ )
        { sc_port_base::bind(parent_);}

  protected:
    // called by pbind (for internal use only)
    virtual inline int vbind( sc_interface& interface_ )
        {
            return sc_port_b<if_type>::vbind( interface_ );
        }       
    virtual inline int vbind( sc_port_base& parent_ )
        {
            in_port_type* in_parent = DCAST<in_port_type*>( &parent_ );  
            if( in_parent != 0 ) {
                sc_port_base::bind( *in_parent );
                return 0;
            }
            inout_port_type* inout_parent = DCAST<inout_port_type*>( &parent_ );
            if( inout_parent != 0 ) {
                sc_port_base::bind( *inout_parent );
                return 0;
            }
            // type mismatch