ext/systemc/src/sysc/communication/sc_signal.cpp - public/gem5 - Git at Google

 /*****************************************************************************

   Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
   more contributor license agreements.  See the NOTICE file distributed
   with this work for additional information regarding copyright ownership.
   Accellera licenses this file to you under the Apache License, Version 2.0
   (the "License"); you may not use this file except in compliance with the
   License.  You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
   implied.  See the License for the specific language governing
   permissions and limitations under the License.

  *****************************************************************************/

 /*****************************************************************************

   sc_signal.cpp -- The sc_signal<T> primitive channel class.

   Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21

   CHANGE LOG IS AT THE END OF THE FILE
  *****************************************************************************/


 #include "sysc/communication/sc_communication_ids.h"
 #include "sysc/utils/sc_utils_ids.h"
 #include "sysc/communication/sc_signal.h"
 #include "sysc/datatypes/int/sc_signed.h"
 #include "sysc/datatypes/int/sc_unsigned.h"
 #include "sysc/datatypes/bit/sc_lv_base.h"
 #include "sysc/kernel/sc_reset.h"

 #include <sstream>

 using sc_dt::sc_lv_base;
 using sc_dt::sc_signed;
 using sc_dt::sc_unsigned;
 using sc_dt::int64;
 using sc_dt::uint64;

 namespace sc_core {

 // to avoid code bloat in sc_signal<T>

 void
 sc_signal_invalid_writer( sc_object* target, sc_object* first_writer,
                           sc_object* second_writer, bool check_delta )
 {
     if ( second_writer )
     {
         std::stringstream msg;

         msg
             << "\n signal "
                "`" << target->name() << "' "
                "(" << target->kind() << ")"
             << "\n first driver "
                "`" << first_writer->name() << "' "
               " (" << first_writer->kind() << ")"
             << "\n second driver "
                "`" << second_writer->name() << "' "
                "(" << second_writer->kind() << ")";

         if( check_delta )
         {
             msg << "\n first conflicting write in delta cycle "
                 << sc_delta_count();
         }
         SC_REPORT_ERROR( SC_ID_MORE_THAN_ONE_SIGNAL_DRIVER_,
                          msg.str().c_str() );
     }
 }

 bool
 sc_writer_policy_check_port::
   check_port( sc_object* target, sc_port_base * port_, bool is_output )
 {
     if ( is_output && sc_get_curr_simcontext()->write_check() )
     {
         // an out or inout port; only one can be connected
         if( m_output != 0) {
             sc_signal_invalid_writer( target, m_output, port_, false );
             return false;
         } else {
             m_output = port_;
         }
     }
     return true;
 }

 void sc_deprecated_get_data_ref()
 {
     static bool warn_get_data_ref_deprecated=true;
     if ( warn_get_data_ref_deprecated )
     {
         warn_get_data_ref_deprecated=false;
 	SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
 	    "get_data_ref() is deprecated, use read() instead" );
     }
 }

 void sc_deprecated_get_new_value()
 {
     static bool warn_new_value=true;
     if ( warn_new_value )
     {
         warn_new_value=false;
 	SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
 	    "sc_signal<T>::get_new_value() is deprecated");
     }
 }

 void sc_deprecated_trace()
 {
     static bool warn_trace_deprecated=true;
     if ( warn_trace_deprecated )
     {
         warn_trace_deprecated=false;
 	SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
 	    "sc_signal<T>::trace() is deprecated");
     }
 }

 sc_event*
 sc_lazy_kernel_event( sc_event** ev, const char* name )
 {
     if ( !*ev ) {
         std::string kernel_name = SC_KERNEL_EVENT_PREFIX "_";
         kernel_name.append( name );
         *ev = new sc_event( kernel_name.c_str() );
     }
     return *ev;

 }

 // IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII

 template< sc_writer_policy POL >
 void
 sc_signal<bool,POL>::register_port( sc_port_base& port_,
                                     const char* if_typename_ )
 {
     bool is_output = std::string( if_typename_ ) == typeid(if_type).name();
     if( !policy_type::check_port( this, &port_, is_output ) )
        ((void)0); // fallback? error has been suppressed ...
 }


 // write the new value

 template< sc_writer_policy POL >
 void
 sc_signal<bool,POL>::write( const bool& value_ )
 {
     bool value_changed = !( m_cur_val == value_ );
     if ( !policy_type::check_write(this, value_changed) )
         return;
     m_new_val = value_;
     if( value_changed ) {
         request_update();
     }
 }

 template< sc_writer_policy POL >
 inline
 void
 sc_signal<bool,POL>::print( ::std::ostream& os ) const
 {
     os << m_cur_val;
 }

 template< sc_writer_policy POL >
 void
 sc_signal<bool,POL>::dump( ::std::ostream& os ) const
 {
     os << "     name = " << name() << ::std::endl;
     os << "    value = " << m_cur_val << ::std::endl;
     os << "new value = " << m_new_val << ::std::endl;
 }


 template< sc_writer_policy POL >
 void
 sc_signal<bool,POL>::update()
 {
     policy_type::update();
     if( !( m_new_val == m_cur_val ) ) {
         do_update();
     }
 }

 template< sc_writer_policy POL >
 void
 sc_signal<bool,POL>::do_update()
 {
     // order of execution below is important, the notify_processes() call
     // must come after the update of m_cur_val for things to work properly!

     m_cur_val = m_new_val;

     if ( m_reset_p ) m_reset_p->notify_processes();

     if ( m_change_event_p ) m_change_event_p->notify_next_delta();

     sc_event* event_p = this->m_cur_val
                       ? m_posedge_event_p : m_negedge_event_p;
     if ( event_p ) event_p->notify_next_delta();

     m_change_stamp = simcontext()->change_stamp();
 }

 // (edge) event methods

 template< sc_writer_policy POL >
 const sc_event&
 sc_signal<bool,POL>::value_changed_event() const
 {
     return *sc_lazy_kernel_event(&m_change_event_p,"value_changed_event");
 }

 template< sc_writer_policy POL >
 const sc_event&
 sc_signal<bool,POL>::posedge_event() const
 {
     return *sc_lazy_kernel_event(&m_posedge_event_p,"posedge_event");
 }

 template< sc_writer_policy POL >
 const sc_event&
 sc_signal<bool,POL>::negedge_event() const
 {
     return *sc_lazy_kernel_event(&m_negedge_event_p,"negedge_event");
 }


 // reset support:

 template< sc_writer_policy POL >
 sc_reset*
 sc_signal<bool,POL>::is_reset() const
 {
     sc_reset* result_p;
     if ( !m_reset_p ) m_reset_p = new sc_reset( this );
     result_p = m_reset_p;
     return result_p;
 }

 // destructor

 template< sc_writer_policy POL >
 sc_signal<bool,POL>::~sc_signal()
 {
     delete m_change_event_p;
     delete m_negedge_event_p;
     delete m_posedge_event_p;
     delete m_reset_p;
 }

 // IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII

 template< sc_writer_policy POL >
 void
 sc_signal<sc_dt::sc_logic,POL>::register_port( sc_port_base& port_,
                                                const char* if_typename_ )
 {
     bool is_output = std::string( if_typename_ ) == typeid(if_type).name();
     if( !policy_type::check_port( this, &port_, is_output ) )
        ((void)0); // fallback? error has been suppressed ...
 }


 // write the new value

 template< sc_writer_policy POL >
 inline
 void
 sc_signal<sc_dt::sc_logic,POL>::write( const sc_dt::sc_logic& value_ )
 {
     bool value_changed = !( m_cur_val == value_ );
     if ( !policy_type::check_write(this, value_changed) )
         return;

     m_new_val = value_;
     if( value_changed ) {
         request_update();
     }
 }

 template< sc_writer_policy POL >
 inline
 void
 sc_signal<sc_dt::sc_logic,POL>::print( ::std::ostream& os ) const
 {
     os << m_cur_val;
 }

 template< sc_writer_policy POL >
 void
 sc_signal<sc_dt::sc_logic,POL>::dump( ::std::ostream& os ) const
 {
     os << "     name = " << name() << ::std::endl;
     os << "    value = " << m_cur_val << ::std::endl;
     os << "new value = " << m_new_val << ::std::endl;
 }


 template< sc_writer_policy POL >
 void
 sc_signal<sc_dt::sc_logic,POL>::update()
 {
     policy_type::update();
     if( !( m_new_val == m_cur_val ) ) {
         do_update();
     }
 }

 template< sc_writer_policy POL >
 void
 sc_signal<sc_dt::sc_logic,POL>::do_update()
 {
     m_cur_val = m_new_val;

     if ( m_change_event_p ) m_change_event_p->notify_next_delta();

     if( m_posedge_event_p && (this->m_cur_val == sc_dt::SC_LOGIC_1) ) {
         m_posedge_event_p->notify_next_delta();
     }
     else if( m_negedge_event_p && (this->m_cur_val == sc_dt::SC_LOGIC_0) ) {
         m_negedge_event_p->notify_next_delta();
     }

     m_change_stamp = simcontext()->change_stamp();
 }

 // (edge) event methods

 template< sc_writer_policy POL >
 const sc_event&
 sc_signal<sc_dt::sc_logic,POL>::value_changed_event() const
 {
     return *sc_lazy_kernel_event(&m_change_event_p,"value_changed_event");
 }

 template< sc_writer_policy POL >
 const sc_event&
 sc_signal<sc_dt::sc_logic,POL>::posedge_event() const
 {
     return *sc_lazy_kernel_event(&m_posedge_event_p,"posedge_event");
 }

 template< sc_writer_policy POL >
 const sc_event&
 sc_signal<sc_dt::sc_logic,POL>::negedge_event() const
 {
     return *sc_lazy_kernel_event(&m_negedge_event_p,"negedge_event");
 }


 // template instantiations for writer policies

 template class sc_signal<bool,SC_ONE_WRITER>;
 template class sc_signal<bool,SC_MANY_WRITERS>;
 template class sc_signal<bool,SC_UNCHECKED_WRITERS>;

 template class sc_signal<sc_dt::sc_logic,SC_ONE_WRITER>;
 template class sc_signal<sc_dt::sc_logic,SC_MANY_WRITERS>;
 template class sc_signal<sc_dt::sc_logic,SC_UNCHECKED_WRITERS>;

 } // namespace sc_core

 /*
 $Log: sc_signal.cpp,v $
 Revision 1.9  2011/08/26 20:45:42  acg
  Andy Goodrich: moved the modification log to the end of the file to
  eliminate source line number skew when check-ins are done.

 Revision 1.8  2011/02/18 20:23:45  acg
  Andy Goodrich: Copyright update.

 Revision 1.7  2011/02/18 20:08:14  acg
  Philipp A. Hartmann: addition of include for sstream for MSVC.

 Revision 1.6  2011/01/25 20:50:37  acg
  Andy Goodrich: changes for IEEE 1666 2011.

 Revision 1.5  2010/12/07 19:50:36  acg
  Andy Goodrich: addition of writer policies, courtesy of Philipp Hartmann.

 Revision 1.3  2007/04/09 21:59:49  acg
  Andy Goodrich: fixed multiple write notification bug where writes
  done outside the simulator were being treated as multiple writes.

 Revision 1.2  2007/04/02 17:24:01  acg
  Andy Goodrich: added check for null writer pointers in sc_signal invalid
  writer method.

 Revision 1.1.1.1  2006/12/15 20:20:04  acg
 SystemC 2.3

 Revision 1.7  2006/04/11 23:11:57  acg
   Andy Goodrich: Changes for reset support that only includes
   sc_cthread_process instances.

 Revision 1.6  2006/03/13 20:19:44  acg
  Andy Goodrich: changed sc_event instances into pointers to sc_event instances
  that are allocated as needed. This saves considerable storage for large
  numbers of signals, etc.

 Revision 1.5  2006/01/25 00:31:11  acg
  Andy Goodrich: Changed over to use a standard message id of
  SC_ID_IEEE_1666_DEPRECATION for all deprecation messages.

 Revision 1.4  2006/01/24 20:46:32  acg
 Andy Goodrich: changes to eliminate use of deprecated features. For instance,
 using notify(SC_ZERO_TIME) in place of notify_delayed().

 Revision 1.3  2006/01/18 21:42:26  acg
 Andy Goodrich: Changes for check writer support, and tightening up sc_clock
 port usage.

 Revision 1.2  2006/01/03 23:18:26  acg
 Changed copyright to include 2006.

 Revision 1.1.1.1  2005/12/19 23:16:43  acg
 First check in of SystemC 2.1 into its own archive.

 Revision 1.14  2005/09/15 23:01:51  acg
 Added std:: prefix to appropriate methods and types to get around
 issues with the Edison Front End.

 Revision 1.13  2005/05/08 19:04:06  acg
 Fix bug in concat_set(int64,off). Other changes from 2.1 examples usage.

 Revision 1.12  2005/04/04 00:15:51  acg
 Changes for directory name change to sys from systemc.
 Changes for sc_string going to std::string.
 Changes for sc_pvector going to std::vector.
 Changes for reference pools for bit and part selections.
 Changes for const sc_concatref support.

 Revision 1.10  2005/03/21 22:31:32  acg
 Changes to sc_core namespace.

 Revision 1.9  2004/09/27 21:02:54  acg
 Andy Goodrich - Forte Design Systems, Inc.
    - Added a $Log comment so that CVS checkin comments will appear in
      checked out source.

 */

 // Taf!
	/*****************************************************************************

	Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
	more contributor license agreements. See the NOTICE file distributed
	with this work for additional information regarding copyright ownership.
	Accellera licenses this file to you under the Apache License, Version 2.0
	(the "License"); you may not use this file except in compliance with the
	License. You may obtain a copy of the License at

	http://www.apache.org/licenses/LICENSE-2.0

	Unless required by applicable law or agreed to in writing, software
	distributed under the License is distributed on an "AS IS" BASIS,
	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
	implied. See the License for the specific language governing
	permissions and limitations under the License.

	*****************************************************************************/

	/*****************************************************************************

	sc_signal.cpp -- The sc_signal<T> primitive channel class.

	Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21

	CHANGE LOG IS AT THE END OF THE FILE
	*****************************************************************************/


	#include "sysc/communication/sc_communication_ids.h"
	#include "sysc/utils/sc_utils_ids.h"
	#include "sysc/communication/sc_signal.h"
	#include "sysc/datatypes/int/sc_signed.h"
	#include "sysc/datatypes/int/sc_unsigned.h"
	#include "sysc/datatypes/bit/sc_lv_base.h"
	#include "sysc/kernel/sc_reset.h"

	#include <sstream>

	using sc_dt::sc_lv_base;
	using sc_dt::sc_signed;
	using sc_dt::sc_unsigned;
	using sc_dt::int64;
	using sc_dt::uint64;

	namespace sc_core {

	// to avoid code bloat in sc_signal<T>

	void
	sc_signal_invalid_writer( sc_object* target, sc_object* first_writer,
	sc_object* second_writer, bool check_delta )
	{
	if ( second_writer )
	{
	std::stringstream msg;

	msg
	<< "\n signal "
	"`" << target->name() << "' "
	"(" << target->kind() << ")"
	<< "\n first driver "
	"`" << first_writer->name() << "' "
	" (" << first_writer->kind() << ")"
	<< "\n second driver "
	"`" << second_writer->name() << "' "
	"(" << second_writer->kind() << ")";

	if( check_delta )
	{
	msg << "\n first conflicting write in delta cycle "
	<< sc_delta_count();
	}
	SC_REPORT_ERROR( SC_ID_MORE_THAN_ONE_SIGNAL_DRIVER_,
	msg.str().c_str() );
	}
	}

	bool
	sc_writer_policy_check_port::
	check_port( sc_object* target, sc_port_base * port_, bool is_output )
	{
	if ( is_output && sc_get_curr_simcontext()->write_check() )
	{
	// an out or inout port; only one can be connected
	if( m_output != 0) {
	sc_signal_invalid_writer( target, m_output, port_, false );
	return false;
	} else {
	m_output = port_;
	}
	}
	return true;
	}

	void sc_deprecated_get_data_ref()
	{
	static bool warn_get_data_ref_deprecated=true;
	if ( warn_get_data_ref_deprecated )
	{
	warn_get_data_ref_deprecated=false;
	SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
	"get_data_ref() is deprecated, use read() instead" );
	}
	}

	void sc_deprecated_get_new_value()
	{
	static bool warn_new_value=true;
	if ( warn_new_value )
	{
	warn_new_value=false;
	SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
	"sc_signal<T>::get_new_value() is deprecated");
	}
	}

	void sc_deprecated_trace()
	{
	static bool warn_trace_deprecated=true;
	if ( warn_trace_deprecated )
	{
	warn_trace_deprecated=false;
	SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
	"sc_signal<T>::trace() is deprecated");
	}
	}

	sc_event*
	sc_lazy_kernel_event( sc_event** ev, const char* name )
	{
	if ( !*ev ) {
	std::string kernel_name = SC_KERNEL_EVENT_PREFIX "_";
	kernel_name.append( name );
	*ev = new sc_event( kernel_name.c_str() );
	}
	return *ev;

	}

	// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII

	template< sc_writer_policy POL >
	void
	sc_signal<bool,POL>::register_port( sc_port_base& port_,
	const char* if_typename_ )
	{
	bool is_output = std::string( if_typename_ ) == typeid(if_type).name();
	if( !policy_type::check_port( this, &port_, is_output ) )
	((void)0); // fallback? error has been suppressed ...
	}


	// write the new value

	template< sc_writer_policy POL >
	void
	sc_signal<bool,POL>::write( const bool& value_ )
	{
	bool value_changed = !( m_cur_val == value_ );
	if ( !policy_type::check_write(this, value_changed) )
	return;
	m_new_val = value_;
	if( value_changed ) {
	request_update();
	}
	}

	template< sc_writer_policy POL >
	inline
	void
	sc_signal<bool,POL>::print( ::std::ostream& os ) const
	{
	os << m_cur_val;
	}

	template< sc_writer_policy POL >
	void
	sc_signal<bool,POL>::dump( ::std::ostream& os ) const
	{
	os << " name = " << name() << ::std::endl;
	os << " value = " << m_cur_val << ::std::endl;
	os << "new value = " << m_new_val << ::std::endl;
	}


	template< sc_writer_policy POL >
	void
	sc_signal<bool,POL>::update()
	{
	policy_type::update();
	if( !( m_new_val == m_cur_val ) ) {
	do_update();
	}
	}

	template< sc_writer_policy POL >
	void
	sc_signal<bool,POL>::do_update()
	{
	// order of execution below is important, the notify_processes() call
	// must come after the update of m_cur_val for things to work properly!

	m_cur_val = m_new_val;

	if ( m_reset_p ) m_reset_p->notify_processes();

	if ( m_change_event_p ) m_change_event_p->notify_next_delta();

	sc_event* event_p = this->m_cur_val
	? m_posedge_event_p : m_negedge_event_p;
	if ( event_p ) event_p->notify_next_delta();

	m_change_stamp = simcontext()->change_stamp();
	}

	// (edge) event methods

	template< sc_writer_policy POL >
	const sc_event&
	sc_signal<bool,POL>::value_changed_event() const
	{
	return *sc_lazy_kernel_event(&m_change_event_p,"value_changed_event");
	}

	template< sc_writer_policy POL >
	const sc_event&
	sc_signal<bool,POL>::posedge_event() const
	{
	return *sc_lazy_kernel_event(&m_posedge_event_p,"posedge_event");
	}

	template< sc_writer_policy POL >
	const sc_event&
	sc_signal<bool,POL>::negedge_event() const
	{
	return *sc_lazy_kernel_event(&m_negedge_event_p,"negedge_event");
	}


	// reset support:

	template< sc_writer_policy POL >
	sc_reset*
	sc_signal<bool,POL>::is_reset() const
	{
	sc_reset* result_p;
	if ( !m_reset_p ) m_reset_p = new sc_reset( this );
	result_p = m_reset_p;
	return result_p;
	}

	// destructor

	template< sc_writer_policy POL >
	sc_signal<bool,POL>::~sc_signal()
	{
	delete m_change_event_p;
	delete m_negedge_event_p;
	delete m_posedge_event_p;
	delete m_reset_p;
	}

	// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII

	template< sc_writer_policy POL >
	void
	sc_signal<sc_dt::sc_logic,POL>::register_port( sc_port_base& port_,
	const char* if_typename_ )
	{
	bool is_output = std::string( if_typename_ ) == typeid(if_type).name();
	if( !policy_type::check_port( this, &port_, is_output ) )
	((void)0); // fallback? error has been suppressed ...
	}


	// write the new value

	template< sc_writer_policy POL >
	inline
	void
	sc_signal<sc_dt::sc_logic,POL>::write( const sc_dt::sc_logic& value_ )
	{
	bool value_changed = !( m_cur_val == value_ );
	if ( !policy_type::check_write(this, value_changed) )
	return;

	m_new_val = value_;
	if( value_changed ) {
	request_update();
	}
	}

	template< sc_writer_policy POL >
	inline
	void
	sc_signal<sc_dt::sc_logic,POL>::print( ::std::ostream& os ) const
	{
	os << m_cur_val;
	}

	template< sc_writer_policy POL >
	void
	sc_signal<sc_dt::sc_logic,POL>::dump( ::std::ostream& os ) const
	{
	os << " name = " << name() << ::std::endl;
	os << " value = " << m_cur_val << ::std::endl;
	os << "new value = " << m_new_val << ::std::endl;
	}


	template< sc_writer_policy POL >
	void
	sc_signal<sc_dt::sc_logic,POL>::update()
	{
	policy_type::update();
	if( !( m_new_val == m_cur_val ) ) {
	do_update();
	}
	}

	template< sc_writer_policy POL >
	void
	sc_signal<sc_dt::sc_logic,POL>::do_update()
	{
	m_cur_val = m_new_val;

	if ( m_change_event_p ) m_change_event_p->notify_next_delta();

	if( m_posedge_event_p && (this->m_cur_val == sc_dt::SC_LOGIC_1) ) {
	m_posedge_event_p->notify_next_delta();
	}
	else if( m_negedge_event_p && (this->m_cur_val == sc_dt::SC_LOGIC_0) ) {
	m_negedge_event_p->notify_next_delta();
	}

	m_change_stamp = simcontext()->change_stamp();
	}

	// (edge) event methods

	template< sc_writer_policy POL >
	const sc_event&
	sc_signal<sc_dt::sc_logic,POL>::value_changed_event() const
	{
	return *sc_lazy_kernel_event(&m_change_event_p,"value_changed_event");
	}

	template< sc_writer_policy POL >
	const sc_event&
	sc_signal<sc_dt::sc_logic,POL>::posedge_event() const
	{
	return *sc_lazy_kernel_event(&m_posedge_event_p,"posedge_event");
	}

	template< sc_writer_policy POL >
	const sc_event&
	sc_signal<sc_dt::sc_logic,POL>::negedge_event() const
	{
	return *sc_lazy_kernel_event(&m_negedge_event_p,"negedge_event");
	}


	// template instantiations for writer policies

	template class sc_signal<bool,SC_ONE_WRITER>;
	template class sc_signal<bool,SC_MANY_WRITERS>;
	template class sc_signal<bool,SC_UNCHECKED_WRITERS>;

	template class sc_signal<sc_dt::sc_logic,SC_ONE_WRITER>;
	template class sc_signal<sc_dt::sc_logic,SC_MANY_WRITERS>;
	template class sc_signal<sc_dt::sc_logic,SC_UNCHECKED_WRITERS>;

	} // namespace sc_core

	/*
	$Log: sc_signal.cpp,v $
	Revision 1.9 2011/08/26 20:45:42 acg
	Andy Goodrich: moved the modification log to the end of the file to
	eliminate source line number skew when check-ins are done.

	Revision 1.8 2011/02/18 20:23:45 acg
	Andy Goodrich: Copyright update.

	Revision 1.7 2011/02/18 20:08:14 acg
	Philipp A. Hartmann: addition of include for sstream for MSVC.

	Revision 1.6 2011/01/25 20:50:37 acg
	Andy Goodrich: changes for IEEE 1666 2011.

	Revision 1.5 2010/12/07 19:50:36 acg
	Andy Goodrich: addition of writer policies, courtesy of Philipp Hartmann.

	Revision 1.3 2007/04/09 21:59:49 acg
	Andy Goodrich: fixed multiple write notification bug where writes
	done outside the simulator were being treated as multiple writes.

	Revision 1.2 2007/04/02 17:24:01 acg
	Andy Goodrich: added check for null writer pointers in sc_signal invalid
	writer method.

	Revision 1.1.1.1 2006/12/15 20:20:04 acg
	SystemC 2.3

	Revision 1.7 2006/04/11 23:11:57 acg
	Andy Goodrich: Changes for reset support that only includes
	sc_cthread_process instances.

	Revision 1.6 2006/03/13 20:19:44 acg
	Andy Goodrich: changed sc_event instances into pointers to sc_event instances
	that are allocated as needed. This saves considerable storage for large
	numbers of signals, etc.

	Revision 1.5 2006/01/25 00:31:11 acg
	Andy Goodrich: Changed over to use a standard message id of
	SC_ID_IEEE_1666_DEPRECATION for all deprecation messages.

	Revision 1.4 2006/01/24 20:46:32 acg
	Andy Goodrich: changes to eliminate use of deprecated features. For instance,
	using notify(SC_ZERO_TIME) in place of notify_delayed().

	Revision 1.3 2006/01/18 21:42:26 acg
	Andy Goodrich: Changes for check writer support, and tightening up sc_clock
	port usage.

	Revision 1.2 2006/01/03 23:18:26 acg
	Changed copyright to include 2006.

	Revision 1.1.1.1 2005/12/19 23:16:43 acg
	First check in of SystemC 2.1 into its own archive.

	Revision 1.14 2005/09/15 23:01:51 acg
	Added std:: prefix to appropriate methods and types to get around
	issues with the Edison Front End.

	Revision 1.13 2005/05/08 19:04:06 acg
	Fix bug in concat_set(int64,off). Other changes from 2.1 examples usage.

	Revision 1.12 2005/04/04 00:15:51 acg
	Changes for directory name change to sys from systemc.
	Changes for sc_string going to std::string.
	Changes for sc_pvector going to std::vector.
	Changes for reference pools for bit and part selections.
	Changes for const sc_concatref support.

	Revision 1.10 2005/03/21 22:31:32 acg
	Changes to sc_core namespace.

	Revision 1.9 2004/09/27 21:02:54 acg
	Andy Goodrich - Forte Design Systems, Inc.
	- Added a $Log comment so that CVS checkin comments will appear in
	checked out source.

	*/

	// Taf!