diff options
Diffstat (limited to 'ext/systemc/src/sysc/communication/sc_signal_ports.h')
-rw-r--r-- | ext/systemc/src/sysc/communication/sc_signal_ports.h | 1931 |
1 files changed, 1931 insertions, 0 deletions
diff --git a/ext/systemc/src/sysc/communication/sc_signal_ports.h b/ext/systemc/src/sysc/communication/sc_signal_ports.h new file mode 100644 index 000000000..22c83c583 --- /dev/null +++ b/ext/systemc/src/sysc/communication/sc_signal_ports.h @@ -0,0 +1,1931 @@ +/***************************************************************************** + + 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_ports.h -- The sc_signal<T> port classes. + + Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21 + + CHANGE LOG APPEARS AT THE END OF THE FILE + *****************************************************************************/ + +#ifndef SC_SIGNAL_PORTS_H +#define SC_SIGNAL_PORTS_H + + +#include "sysc/communication/sc_event_finder.h" +#include "sysc/communication/sc_port.h" +#include "sysc/communication/sc_signal_ifs.h" +#include "sysc/datatypes/bit/sc_logic.h" +#include "sysc/tracing/sc_trace.h" + +#if ! defined( SC_DISABLE_VIRTUAL_BIND ) +# define SC_VIRTUAL_ virtual +#else +# define SC_VIRTUAL_ /* non-virtual */ +#endif + +namespace sc_core { + +// ---------------------------------------------------------------------------- +// STRUCT : sc_trace_params +// +// Struct for storing the trace file and object name of an sc_trace call. +// FOR INTERNAL USE ONLY! +// ---------------------------------------------------------------------------- + +extern void sc_deprecated_add_trace(); + +struct sc_trace_params +{ + sc_trace_file* tf; + std::string name; + + sc_trace_params( sc_trace_file* tf_, const std::string& name_ ) + : tf( tf_ ), name( name_ ) + {} +}; + + +typedef std::vector<sc_trace_params*> sc_trace_params_vec; + + +// ---------------------------------------------------------------------------- +// CLASS : sc_in<T> +// +// The sc_signal<T> input port class. +// ---------------------------------------------------------------------------- + +template <class T> +class sc_in +: public sc_port<sc_signal_in_if<T>,1,SC_ONE_OR_MORE_BOUND> +{ +public: + + // typedefs + + typedef T data_type; + + typedef sc_signal_in_if<data_type> if_type; + typedef sc_port<if_type,1,SC_ONE_OR_MORE_BOUND> base_type; + typedef sc_in<data_type> this_type; + typedef typename base_type::port_type base_port_type; + + typedef if_type in_if_type; + typedef base_type in_port_type; + typedef sc_signal_inout_if<data_type> inout_if_type; + typedef sc_port<inout_if_type,1,SC_ONE_OR_MORE_BOUND> inout_port_type; + +public: + + // constructors + + sc_in() + : base_type(), m_traces( 0 ), + m_change_finder_p(0) + {} + + explicit sc_in( const char* name_ ) + : base_type( name_ ), m_traces( 0 ), + m_change_finder_p(0) + {} + + explicit sc_in( const in_if_type& interface_ ) + : base_type( CCAST<in_if_type&>( interface_ ) ), m_traces( 0 ), + m_change_finder_p(0) + {} + + sc_in( const char* name_, const in_if_type& interface_ ) + : base_type( name_, CCAST<in_if_type&>( interface_ ) ), m_traces( 0 ), + m_change_finder_p(0) + {} + + explicit sc_in( in_port_type& parent_ ) + : base_type( parent_ ), m_traces( 0 ), + m_change_finder_p(0) + {} + + sc_in( const char* name_, in_port_type& parent_ ) + : base_type( name_, parent_ ), m_traces( 0 ), + m_change_finder_p(0) + {} + + explicit sc_in( inout_port_type& parent_ ) + : base_type(), m_traces( 0 ), + m_change_finder_p(0) + { sc_port_base::bind( parent_ ); } + + sc_in( const char* name_, inout_port_type& parent_ ) + : base_type( name_ ), m_traces( 0 ), + m_change_finder_p(0) + { sc_port_base::bind( parent_ ); } + + sc_in( this_type& parent_ ) + : base_type( parent_ ), m_traces( 0 ), + m_change_finder_p(0) + {} + + sc_in( const char* name_, this_type& parent_ ) + : base_type( name_, parent_ ), m_traces( 0 ), + m_change_finder_p(0) + {} + + + // destructor + + virtual ~sc_in() + { + remove_traces(); + delete m_change_finder_p; + } + + + // bind to in interface + + SC_VIRTUAL_ void bind( const in_if_type& interface_ ) + { sc_port_base::bind( CCAST<in_if_type&>( interface_ ) ); } + + SC_VIRTUAL_ void bind( in_if_type& interface_ ) + { this->bind( CCAST<const in_if_type&>( interface_ ) ); } + + void operator () ( const in_if_type& interface_ ) + { this->bind( interface_ ); } + + + // bind to parent in port + + SC_VIRTUAL_ void bind( in_port_type& parent_ ) + { sc_port_base::bind( parent_ ); } + + void operator () ( in_port_type& parent_ ) + { this->bind( parent_ ); } + + + // bind to parent inout port + + SC_VIRTUAL_ void bind( inout_port_type& parent_ ) + { sc_port_base::bind( parent_ ); } + + void operator () ( inout_port_type& parent_ ) + { this->bind( parent_ ); } + + + // interface access shortcut methods + + // get the default event + + const sc_event& default_event() const + { return (*this)->default_event(); } + + + // get the value changed event + + const sc_event& value_changed_event() const + { return (*this)->value_changed_event(); } + + + // read the current value + + const data_type& read() const + { return (*this)->read(); } + + operator const data_type& () const + { return (*this)->read(); } + + + // was there a value changed event? + + bool event() const + { return (*this)->event(); } + + + // (other) event finder method(s) + + sc_event_finder& value_changed() const + { + if ( !m_change_finder_p ) + { + m_change_finder_p = new sc_event_finder_t<in_if_type>( + *this, &in_if_type::value_changed_event ); + } + return *m_change_finder_p; + } + + + // called when elaboration is done + /* WHEN DEFINING THIS METHOD IN A DERIVED CLASS, */ + /* MAKE SURE THAT THIS METHOD IS CALLED AS WELL. */ + + virtual void end_of_elaboration(); + + virtual const char* kind() const + { return "sc_in"; } + + + void add_trace( sc_trace_file*, const std::string& ) const; + + // called by sc_trace + void add_trace_internal( sc_trace_file*, const std::string& ) const; + +protected: + + void remove_traces() const; + + mutable sc_trace_params_vec* m_traces; + +protected: + + // called by pbind (for internal use only) + virtual int vbind( sc_interface& ); + virtual int vbind( sc_port_base& ); + + // implement virtual base_type port-binding function + // - avoids warnings on some compilers + // - should only be called, when using sc_port_b explicitly + // - errors are detected during elaboration + + SC_VIRTUAL_ void bind( base_port_type& parent_ ) + { sc_port_base::bind( parent_ ); } + + +private: + mutable sc_event_finder* m_change_finder_p; + +private: + + // disabled + sc_in( const this_type& ); + this_type& operator = ( const this_type& ); + +#ifdef __GNUC__ + // Needed to circumvent a problem in the g++-2.95.2 compiler: + // This unused variable forces the compiler to instantiate + // an object of T template so an implicit conversion from + // read() to a C++ intrinsic data type will work. + static data_type dummy; +#endif +}; + +template<typename T> +::std::ostream& operator << ( ::std::ostream& os, const sc_in<T>& a ) +{ + return os << a->read(); +} + +// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII + + +// called when elaboration is done + +template <class T> +inline +void +sc_in<T>::end_of_elaboration() +{ + if( m_traces != 0 ) { + for( int i = 0; i < (int)m_traces->size(); ++ i ) { + sc_trace_params* p = (*m_traces)[i]; + in_if_type* iface = DCAST<in_if_type*>( this->get_interface() ); + sc_trace( p->tf, iface->read(), p->name ); + } + remove_traces(); + } +} + + +// called by sc_trace + +template <class T> +inline +void +sc_in<T>::add_trace_internal( sc_trace_file* tf_, const std::string& name_ ) +const +{ + if( tf_ != 0 ) { + if( m_traces == 0 ) { + m_traces = new sc_trace_params_vec; + } + m_traces->push_back( new sc_trace_params( tf_, name_ ) ); + } +} + +template <class T> +inline +void +sc_in<T>::add_trace( sc_trace_file* tf_, const std::string& name_ ) +const +{ + sc_deprecated_add_trace(); + add_trace_internal(tf_, name_); +} + +template <class T> +inline +void +sc_in<T>::remove_traces() const +{ + if( m_traces != 0 ) { + for( int i = (int)m_traces->size() - 1; i >= 0; -- i ) { + delete (*m_traces)[i]; + } + delete m_traces; + m_traces = 0; + } +} + + +// called by pbind (for internal use only) + +template <class T> +inline +int +sc_in<T>::vbind( sc_interface& interface_ ) +{ + return sc_port_b<if_type>::vbind( interface_ ); +} + +template <class T> +inline +int +sc_in<T>::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 + return 2; +} + + +// ---------------------------------------------------------------------------- +// CLASS : sc_in<bool> +// +// Specialization of sc_in<T> for type bool. +// ---------------------------------------------------------------------------- + +template <> +class sc_in<bool> : + public sc_port<sc_signal_in_if<bool>,1,SC_ONE_OR_MORE_BOUND> +{ +public: + + // typedefs + + typedef bool data_type; + + typedef sc_signal_in_if<data_type> if_type; + typedef sc_port<if_type,1,SC_ONE_OR_MORE_BOUND> base_type; + typedef sc_in<data_type> this_type; + typedef /* typename */ base_type::port_type base_port_type; + + typedef if_type in_if_type; + typedef base_type in_port_type; + typedef sc_signal_inout_if<data_type> inout_if_type; + typedef sc_port<inout_if_type,1,SC_ONE_OR_MORE_BOUND> inout_port_type; + +public: + + // constructors + + sc_in() + : base_type(), m_traces( 0 ), m_change_finder_p(0), + m_neg_finder_p(0), m_pos_finder_p(0) + {} + + explicit sc_in( const char* name_ ) + : base_type( name_ ), m_traces( 0 ), m_change_finder_p(0), + m_neg_finder_p(0), m_pos_finder_p(0) + {} + + explicit sc_in( const in_if_type& interface_ ) + : base_type( CCAST<in_if_type&>( interface_ ) ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + + sc_in( const char* name_, const in_if_type& interface_ ) + : base_type( name_, CCAST<in_if_type&>( interface_ ) ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + + explicit sc_in( in_port_type& parent_ ) + : base_type( parent_ ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + + sc_in( const char* name_, in_port_type& parent_ ) + : base_type( name_, parent_ ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + + explicit sc_in( inout_port_type& parent_ ) + : base_type(), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + { sc_port_base::bind( parent_ ); } + + sc_in( const char* name_, inout_port_type& parent_ ) + : base_type( name_ ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + { sc_port_base::bind( parent_ ); } + + sc_in( this_type& parent_ ) + : base_type( parent_ ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + +#if defined(TESTING) + sc_in( const this_type& parent_ ) + : base_type( *(in_if_type*)parent_.get_interface() ) , m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} +#endif + + sc_in( const char* name_, this_type& parent_ ) + : base_type( name_, parent_ ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + + + // destructor + + virtual ~sc_in() + { + remove_traces(); + delete m_change_finder_p; + delete m_neg_finder_p; + delete m_pos_finder_p; + } + + + // bind to in interface + + SC_VIRTUAL_ void bind( const in_if_type& interface_ ) + { sc_port_base::bind( CCAST<in_if_type&>( interface_ ) ); } + + SC_VIRTUAL_ void bind( in_if_type& interface_ ) + { this->bind( CCAST<const in_if_type&>( interface_ ) ); } + + void operator () ( const in_if_type& interface_ ) + { this->bind( interface_ ); } + + + // bind to parent in port + + SC_VIRTUAL_ void bind( in_port_type& parent_ ) + { sc_port_base::bind( parent_ ); } + + void operator () ( in_port_type& parent_ ) + { this->bind( parent_ ); } + + + // bind to parent inout port + + SC_VIRTUAL_ void bind( inout_port_type& parent_ ) + { sc_port_base::bind( parent_ ); } + + void operator () ( inout_port_type& parent_ ) + { this->bind( parent_ ); } + + + // interface access shortcut methods + + // get the default event + + const sc_event& default_event() const + { return (*this)->default_event(); } + + + // get the value changed event + + const sc_event& value_changed_event() const + { return (*this)->value_changed_event(); } + + // get the positive edge event + + const sc_event& posedge_event() const + { return (*this)->posedge_event(); } + + // get the negative edge event + + const sc_event& negedge_event() const + { return (*this)->negedge_event(); } + + + // read the current value + + const data_type& read() const + { return (*this)->read(); } + + operator const data_type& () const + { return (*this)->read(); } + + + // use for positive edge sensitivity + + sc_event_finder& pos() const + { + if ( !m_pos_finder_p ) + { + m_pos_finder_p = new sc_event_finder_t<in_if_type>( + *this, &in_if_type::posedge_event ); + } + return *m_pos_finder_p; + } + + // use for negative edge sensitivity + + sc_event_finder& neg() const + { + if ( !m_neg_finder_p ) + { + m_neg_finder_p = new sc_event_finder_t<in_if_type>( + *this, &in_if_type::negedge_event ); + } + return *m_neg_finder_p; + } + + + // was there a value changed event? + + bool event() const + { return (*this)->event(); } + + // was there a positive edge event? + + bool posedge() const + { return (*this)->posedge(); } + + // was there a negative edge event? + + bool negedge() const + { return (*this)->negedge(); } + + // (other) event finder method(s) + + sc_event_finder& value_changed() const + { + if ( !m_change_finder_p ) + { + m_change_finder_p = new sc_event_finder_t<in_if_type>( + *this, &in_if_type::value_changed_event ); + } + return *m_change_finder_p; + } + + + // called when elaboration is done + /* WHEN DEFINING THIS METHOD IN A DERIVED CLASS, */ + /* MAKE SURE THAT THIS METHOD IS CALLED AS WELL. */ + + virtual void end_of_elaboration(); + + virtual const char* kind() const + { return "sc_in"; } + + + void add_trace( sc_trace_file*, const std::string& ) const; + + // called by sc_trace + void add_trace_internal( sc_trace_file*, const std::string& ) const; + +protected: + + void remove_traces() const; + + mutable sc_trace_params_vec* m_traces; + +protected: + + // called by pbind (for internal use only) + virtual int vbind( sc_interface& ); + virtual int vbind( sc_port_base& ); + + // implement virtual base_type port-binding function + // - avoids warnings on some compilers + // - should only be called, when using sc_port_b explicitly + // - errors are detected during elaboration + + SC_VIRTUAL_ void bind( base_port_type& parent_ ) + { sc_port_base::bind( parent_ ); } + +private: + mutable sc_event_finder* m_change_finder_p; + mutable sc_event_finder* m_neg_finder_p; + mutable sc_event_finder* m_pos_finder_p; + +private: + + // disabled +#if defined(TESTING) +#else + sc_in( const this_type& ); +#endif + this_type& operator = ( const this_type& ); + +#ifdef __GNUC__ + // Needed to circumvent a problem in the g++-2.95.2 compiler: + // This unused variable forces the compiler to instantiate + // an object of T template so an implicit conversion from + // read() to a C++ intrinsic data type will work. + static data_type dummy; +#endif +}; + + +// ---------------------------------------------------------------------------- +// CLASS : sc_in<sc_dt::sc_logic> +// +// Specialization of sc_in<T> for type sc_dt::sc_logic. +// ---------------------------------------------------------------------------- + +template <> +class sc_in<sc_dt::sc_logic> +: public sc_port<sc_signal_in_if<sc_dt::sc_logic>,1,SC_ONE_OR_MORE_BOUND> +{ +public: + + // typedefs + + typedef sc_dt::sc_logic data_type; + + typedef sc_signal_in_if<data_type> if_type; + typedef sc_port<if_type,1,SC_ONE_OR_MORE_BOUND> base_type; + typedef sc_in<data_type> this_type; + typedef /* typename */ base_type::port_type base_port_type; + + typedef if_type in_if_type; + typedef base_type in_port_type; + typedef sc_signal_inout_if<data_type> inout_if_type; + typedef sc_port<inout_if_type,1,SC_ONE_OR_MORE_BOUND> inout_port_type; + +public: + + // constructors + + sc_in() + : base_type(), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + + explicit sc_in( const char* name_ ) + : base_type( name_ ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + + explicit sc_in( const in_if_type& interface_ ) + : base_type( CCAST<in_if_type&>( interface_ ) ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + + sc_in( const char* name_, const in_if_type& interface_ ) + : base_type( name_, CCAST<in_if_type&>( interface_ ) ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + + explicit sc_in( in_port_type& parent_ ) + : base_type( parent_ ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + + sc_in( const char* name_, in_port_type& parent_ ) + : base_type( name_, parent_ ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + + explicit sc_in( inout_port_type& parent_ ) + : base_type(), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + { sc_port_base::bind( parent_ ); } + + sc_in( const char* name_, inout_port_type& parent_ ) + : base_type( name_ ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + { sc_port_base::bind( parent_ ); } + + sc_in( this_type& parent_ ) + : base_type( parent_ ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + + sc_in( const char* name_, this_type& parent_ ) + : base_type( name_, parent_ ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + + + // destructor + + virtual ~sc_in() + { + remove_traces(); + delete m_change_finder_p; + delete m_neg_finder_p; + delete m_pos_finder_p; + } + + + // bind to in interface + + SC_VIRTUAL_ void bind( const in_if_type& interface_ ) + { sc_port_base::bind( CCAST<in_if_type&>( interface_ ) ); } + + SC_VIRTUAL_ void bind( in_if_type& interface_ ) + { this->bind( CCAST<const in_if_type&>( interface_ ) ); } + + void operator () ( const in_if_type& interface_ ) + { this->bind( interface_ ); } + + + // bind to parent in port + + SC_VIRTUAL_ void bind( in_port_type& parent_ ) + { sc_port_base::bind( parent_ ); } + + void operator () ( in_port_type& parent_ ) + { this->bind( parent_ ); } + + + // bind to parent inout port + + SC_VIRTUAL_ void bind( inout_port_type& parent_ ) + { sc_port_base::bind( parent_ ); } + + void operator () ( inout_port_type& parent_ ) + { this->bind( parent_ ); } + + + // interface access shortcut methods + + // get the default event + + const sc_event& default_event() const + { return (*this)->default_event(); } + + + // get the value changed event + + const sc_event& value_changed_event() const + { return (*this)->value_changed_event(); } + + // get the positive edge event + + const sc_event& posedge_event() const + { return (*this)->posedge_event(); } + + // get the negative edge event + + const sc_event& negedge_event() const + { return (*this)->negedge_event(); } + + + // read the current value + + const data_type& read() const + { return (*this)->read(); } + + operator const data_type& () const + { return (*this)->read(); } + + + // use for positive edge sensitivity + + sc_event_finder& pos() const + { + if ( !m_pos_finder_p ) + { + m_pos_finder_p = new sc_event_finder_t<in_if_type>( + *this, &in_if_type::posedge_event ); + } + return *m_pos_finder_p; + } + + // use for negative edge sensitivity + + sc_event_finder& neg() const + { + if ( !m_neg_finder_p ) + { + m_neg_finder_p = new sc_event_finder_t<in_if_type>( + *this, &in_if_type::negedge_event ); + } + return *m_neg_finder_p; + } + + + // was there a value changed event? + + bool event() const + { return (*this)->event(); } + + // was there a positive edge event? + + bool posedge() const + { return (*this)->posedge(); } + + // was there a negative edge event? + + bool negedge() const + { return (*this)->negedge(); } + + // (other) event finder method(s) + + sc_event_finder& value_changed() const + { + if ( !m_change_finder_p ) + { + m_change_finder_p = new sc_event_finder_t<in_if_type>( + *this, &in_if_type::value_changed_event ); + } + return *m_change_finder_p; + } + + + // called when elaboration is done + /* WHEN DEFINING THIS METHOD IN A DERIVED CLASS, */ + /* MAKE SURE THAT THIS METHOD IS CALLED AS WELL. */ + + virtual void end_of_elaboration(); + + virtual const char* kind() const + { return "sc_in"; } + + + void add_trace( sc_trace_file*, const std::string& ) const; + + // called by sc_trace + void add_trace_internal( sc_trace_file*, const std::string& ) const; + +protected: + + void remove_traces() const; + + mutable sc_trace_params_vec* m_traces; + +protected: + + // called by pbind (for internal use only) + virtual int vbind( sc_interface& ); + virtual int vbind( sc_port_base& ); + + // implement virtual base_type port-binding function + // - avoids warnings on some compilers + // - should only be called, when using sc_port_b explicitly + // - errors are detected during elaboration + + SC_VIRTUAL_ void bind( base_port_type& parent_ ) + { sc_port_base::bind( parent_ ); } + +private: + mutable sc_event_finder* m_change_finder_p; + mutable sc_event_finder* m_neg_finder_p; + mutable sc_event_finder* m_pos_finder_p; + +private: + + // disabled + sc_in( const this_type& ); + this_type& operator = ( const this_type& ); + +#ifdef __GNUC__ + // Needed to circumvent a problem in the g++-2.95.2 compiler: + // This unused variable forces the compiler to instantiate + // an object of T template so an implicit conversion from + // read() to a C++ intrinsic data type will work. + static data_type dummy; +#endif +}; + + +// ---------------------------------------------------------------------------- +// CLASS : sc_inout<T> +// +// The sc_signal<T> input/output port class. +// ---------------------------------------------------------------------------- + +template <class T> +class sc_inout +: public sc_port<sc_signal_inout_if<T>,1,SC_ONE_OR_MORE_BOUND> +{ +public: + + // typedefs + + typedef T data_type; + + typedef sc_signal_inout_if<data_type> if_type; + typedef sc_port<if_type,1,SC_ONE_OR_MORE_BOUND> base_type; + typedef sc_inout<data_type> this_type; + + typedef sc_signal_in_if<data_type> in_if_type; + typedef sc_port<in_if_type,1,SC_ONE_OR_MORE_BOUND> in_port_type; + typedef if_type inout_if_type; + typedef base_type inout_port_type; + +public: + + // constructors + + sc_inout() + : base_type(), m_init_val( 0 ), m_traces( 0 ), + m_change_finder_p(0) + {} + + explicit sc_inout( const char* name_ ) + : base_type( name_ ), m_init_val( 0 ), m_traces( 0 ), + m_change_finder_p(0) + {} + + explicit sc_inout( inout_if_type& interface_ ) + : base_type( interface_ ), m_init_val( 0 ), m_traces( 0 ), + m_change_finder_p(0) + {} + + sc_inout( const char* name_, inout_if_type& interface_ ) + : base_type( name_, interface_ ), m_init_val( 0 ), m_traces( 0 ), + m_change_finder_p(0) + {} + + explicit sc_inout( inout_port_type& parent_ ) + : base_type( parent_ ), m_init_val( 0 ), m_traces( 0 ), + m_change_finder_p(0) + {} + + sc_inout( const char* name_, inout_port_type& parent_ ) + : base_type( name_, parent_ ), m_init_val( 0 ), m_traces( 0 ), + m_change_finder_p(0) + {} + + sc_inout( this_type& parent_ ) + : base_type( parent_ ), m_init_val( 0 ), m_traces( 0 ), + m_change_finder_p(0) + {} + + sc_inout( const char* name_, this_type& parent_ ) + : base_type( name_, parent_ ), m_init_val( 0 ), m_traces( 0 ), + m_change_finder_p(0) + {} + + + // destructor + + virtual ~sc_inout(); + + + // interface access shortcut methods + + // get the default event + + const sc_event& default_event() const + { return (*this)->default_event(); } + + + // get the value changed event + + const sc_event& value_changed_event() const + { return (*this)->value_changed_event(); } + + + // read the current value + + const data_type& read() const + { return (*this)->read(); } + + operator const data_type& () const + { return (*this)->read(); } + + + // was there a value changed event? + + bool event() const + { return (*this)->event(); } + + + // write the new value + + void write( const data_type& value_ ) + { (*this)->write( value_ ); } + + this_type& operator = ( const data_type& value_ ) + { (*this)->write( value_ ); return *this; } + + this_type& operator = ( const in_if_type& interface_ ) + { (*this)->write( interface_.read() ); return *this; } + + this_type& operator = ( const in_port_type& port_ ) + { (*this)->write( port_->read() ); return *this; } + + this_type& operator = ( const inout_port_type& port_ ) + { (*this)->write( port_->read() ); return *this; } + + this_type& operator = ( const this_type& port_ ) + { (*this)->write( port_->read() ); return *this; } + + + // set initial value (can also be called when port is not bound yet) + + void initialize( const data_type& value_ ); + + void initialize( const in_if_type& interface_ ) + { initialize( interface_.read() ); } + + + // called when elaboration is done + /* WHEN DEFINING THIS METHOD IN A DERIVED CLASS, */ + /* MAKE SURE THAT THIS METHOD IS CALLED AS WELL. */ + + virtual void end_of_elaboration(); + + + // (other) event finder method(s) + + sc_event_finder& value_changed() const + { + if ( !m_change_finder_p ) + { + m_change_finder_p = new sc_event_finder_t<in_if_type>( + *this, &in_if_type::value_changed_event ); + } + return *m_change_finder_p; + } + + virtual const char* kind() const + { return "sc_inout"; } + +protected: + + data_type* m_init_val; + +public: + + // called by sc_trace + void add_trace_internal( sc_trace_file*, const std::string& ) const; + + void add_trace( sc_trace_file*, const std::string& ) const; + +protected: + + void remove_traces() const; + + mutable sc_trace_params_vec* m_traces; + +private: + mutable sc_event_finder* m_change_finder_p; + +private: + + // disabled + sc_inout( const this_type& ); + +#ifdef __GNUC__ + // Needed to circumvent a problem in the g++-2.95.2 compiler: + // This unused variable forces the compiler to instantiate + // an object of T template so an implicit conversion from + // read() to a C++ intrinsic data type will work. + static data_type dummy; +#endif +}; + +template<typename T> +::std::ostream& operator << ( ::std::ostream& os, const sc_inout<T>& a ) +{ + return os << a->read(); +} + +// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII + + +// destructor + +template <class T> +inline +sc_inout<T>::~sc_inout() +{ + delete m_change_finder_p; + delete m_init_val; + remove_traces(); +} + + +// set initial value (can also be called when port is not bound yet) + +template <class T> +inline +void +sc_inout<T>::initialize( const data_type& value_ ) +{ + inout_if_type* iface = DCAST<inout_if_type*>( this->get_interface() ); + if( iface != 0 ) { + iface->write( value_ ); + } else { + if( m_init_val == 0 ) { + m_init_val = new data_type; + } + *m_init_val = value_; + } +} + + +// called when elaboration is done + +template <class T> +inline +void +sc_inout<T>::end_of_elaboration() +{ + if( m_init_val != 0 ) { + write( *m_init_val ); + delete m_init_val; + m_init_val = 0; + } + if( m_traces != 0 ) { + for( int i = 0; i < (int)m_traces->size(); ++ i ) { + sc_trace_params* p = (*m_traces)[i]; + in_if_type* iface = DCAST<in_if_type*>( this->get_interface() ); + sc_trace( p->tf, iface->read(), p->name ); + } + remove_traces(); + } +} + + +// called by sc_trace + +template <class T> +inline +void +sc_inout<T>::add_trace_internal( sc_trace_file* tf_, const std::string& name_) +const +{ + if( tf_ != 0 ) { + if( m_traces == 0 ) { + m_traces = new sc_trace_params_vec; + } + m_traces->push_back( new sc_trace_params( tf_, name_ ) ); + } +} + +template <class T> +inline +void +sc_inout<T>::add_trace( sc_trace_file* tf_, const std::string& name_) const +{ + sc_deprecated_add_trace(); + add_trace_internal(tf_, name_); +} + +template <class T> +inline +void +sc_inout<T>::remove_traces() const +{ + if( m_traces != 0 ) { + for( int i = m_traces->size() - 1; i >= 0; -- i ) { + delete (*m_traces)[i]; + } + delete m_traces; + m_traces = 0; + } +} + + +// ---------------------------------------------------------------------------- +// CLASS : sc_inout<bool> +// +// Specialization of sc_inout<T> for type bool. +// ---------------------------------------------------------------------------- + +template <> +class sc_inout<bool> : + public sc_port<sc_signal_inout_if<bool>,1,SC_ONE_OR_MORE_BOUND> +{ +public: + + // typedefs + + typedef bool data_type; + + typedef sc_signal_inout_if<data_type> if_type; + typedef sc_port<if_type,1,SC_ONE_OR_MORE_BOUND> base_type; + typedef sc_inout<data_type> this_type; + + typedef sc_signal_in_if<data_type> in_if_type; + typedef sc_port<in_if_type,1,SC_ONE_OR_MORE_BOUND> in_port_type; + typedef if_type inout_if_type; + typedef base_type inout_port_type; + +public: + + // constructors + + sc_inout() + : base_type(), m_init_val( 0 ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + + explicit sc_inout( const char* name_ ) + : base_type( name_ ), m_init_val( 0 ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + + explicit sc_inout( inout_if_type& interface_ ) + : base_type( interface_ ), m_init_val( 0 ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + + sc_inout( const char* name_, inout_if_type& interface_ ) + : base_type( name_, interface_ ), m_init_val( 0 ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + + explicit sc_inout( inout_port_type& parent_ ) + : base_type( parent_ ), m_init_val( 0 ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + + sc_inout( const char* name_, inout_port_type& parent_ ) + : base_type( name_, parent_ ), m_init_val( 0 ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + + sc_inout( this_type& parent_ ) + : base_type( parent_ ), m_init_val( 0 ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + + sc_inout( const char* name_, this_type& parent_ ) + : base_type( name_, parent_ ), m_init_val( 0 ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + + + // destructor + + virtual ~sc_inout(); + + + // interface access shortcut methods + + // get the default event + + const sc_event& default_event() const + { return (*this)->default_event(); } + + + // get the value changed event + + const sc_event& value_changed_event() const + { return (*this)->value_changed_event(); } + + // get the positive edge event + + const sc_event& posedge_event() const + { return (*this)->posedge_event(); } + + // get the negative edge event + + const sc_event& negedge_event() const + { return (*this)->negedge_event(); } + + + // read the current value + + const data_type& read() const + { return (*this)->read(); } + + operator const data_type& () const + { return (*this)->read(); } + + + // use for positive edge sensitivity + + sc_event_finder& pos() const + { + if ( !m_pos_finder_p ) + { + m_pos_finder_p = new sc_event_finder_t<in_if_type>( + *this, &in_if_type::posedge_event ); + } + return *m_pos_finder_p; + } + + // use for negative edge sensitivity + + sc_event_finder& neg() const + { + if ( !m_neg_finder_p ) + { + m_neg_finder_p = new sc_event_finder_t<in_if_type>( + *this, &in_if_type::negedge_event ); + } + return *m_neg_finder_p; + } + + + // was there a value changed event? + + bool event() const + { return (*this)->event(); } + + // was there a positive edge event? + + bool posedge() const + { return (*this)->posedge(); } + + // was there a negative edge event? + + bool negedge() const + { return (*this)->negedge(); } + + // write the new value + + void write( const data_type& value_ ) + { (*this)->write( value_ ); } + + this_type& operator = ( const data_type& value_ ) + { (*this)->write( value_ ); return *this; } + + this_type& operator = ( const in_if_type& interface_ ) + { (*this)->write( interface_.read() ); return *this; } + + this_type& operator = ( const in_port_type& port_ ) + { (*this)->write( port_->read() ); return *this; } + + this_type& operator = ( const inout_port_type& port_ ) + { (*this)->write( port_->read() ); return *this; } + + this_type& operator = ( const this_type& port_ ) + { (*this)->write( port_->read() ); return *this; } + + + // set initial value (can also be called when port is not bound yet) + + void initialize( const data_type& value_ ); + + void initialize( const in_if_type& interface_ ) + { initialize( interface_.read() ); } + + + // called when elaboration is done + /* WHEN DEFINING THIS METHOD IN A DERIVED CLASS, */ + /* MAKE SURE THAT THIS METHOD IS CALLED AS WELL. */ + + virtual void end_of_elaboration(); + + + // (other) event finder method(s) + + sc_event_finder& value_changed() const + { + if ( !m_change_finder_p ) + { + m_change_finder_p = new sc_event_finder_t<in_if_type>( + *this, &in_if_type::value_changed_event ); + } + return *m_change_finder_p; + } + + virtual const char* kind() const + { return "sc_inout"; } + +protected: + + data_type* m_init_val; + +public: + + // called by sc_trace + void add_trace_internal( sc_trace_file*, const std::string& ) const; + + void add_trace( sc_trace_file*, const std::string& ) const; + +protected: + + void remove_traces() const; + + mutable sc_trace_params_vec* m_traces; + +private: + mutable sc_event_finder* m_change_finder_p; + mutable sc_event_finder* m_neg_finder_p; + mutable sc_event_finder* m_pos_finder_p; + +private: + + // disabled + sc_inout( const this_type& ); + +#ifdef __GNUC__ + // Needed to circumvent a problem in the g++-2.95.2 compiler: + // This unused variable forces the compiler to instantiate + // an object of T template so an implicit conversion from + // read() to a C++ intrinsic data type will work. + static data_type dummy; +#endif +}; + + +// ---------------------------------------------------------------------------- +// CLASS : sc_inout<sc_dt::sc_logic> +// +// Specialization of sc_inout<T> for type sc_dt::sc_logic. +// ---------------------------------------------------------------------------- + +template <> +class sc_inout<sc_dt::sc_logic> +: public sc_port<sc_signal_inout_if<sc_dt::sc_logic>,1,SC_ONE_OR_MORE_BOUND> +{ +public: + + // typedefs + + typedef sc_dt::sc_logic data_type; + + typedef sc_signal_inout_if<data_type> if_type; + typedef sc_port<if_type,1,SC_ONE_OR_MORE_BOUND> base_type; + typedef sc_inout<data_type> this_type; + + typedef sc_signal_in_if<data_type> in_if_type; + typedef sc_port<in_if_type,1,SC_ONE_OR_MORE_BOUND> in_port_type; + typedef if_type inout_if_type; + typedef base_type inout_port_type; + +public: + + // constructors + + sc_inout() + : base_type(), m_init_val( 0 ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + + explicit sc_inout( const char* name_ ) + : base_type( name_ ), m_init_val( 0 ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + + explicit sc_inout( inout_if_type& interface_ ) + : base_type( interface_ ), m_init_val( 0 ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + + sc_inout( const char* name_, inout_if_type& interface_ ) + : base_type( name_, interface_ ), m_init_val( 0 ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + + explicit sc_inout( inout_port_type& parent_ ) + : base_type( parent_ ), m_init_val( 0 ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + + sc_inout( const char* name_, inout_port_type& parent_ ) + : base_type( name_, parent_ ), m_init_val( 0 ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + + sc_inout( this_type& parent_ ) + : base_type( parent_ ), m_init_val( 0 ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + + sc_inout( const char* name_, this_type& parent_ ) + : base_type( name_, parent_ ), m_init_val( 0 ), m_traces( 0 ), + m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0) + {} + + + // destructor + + virtual ~sc_inout(); + + + // interface access shortcut methods + + // get the default event + + const sc_event& default_event() const + { return (*this)->default_event(); } + + + // get the value changed event + + const sc_event& value_changed_event() const + { return (*this)->value_changed_event(); } + + // get the positive edge event + + const sc_event& posedge_event() const + { return (*this)->posedge_event(); } + + // get the negative edge event + + const sc_event& negedge_event() const + { return (*this)->negedge_event(); } + + + // read the current value + + const data_type& read() const + { return (*this)->read(); } + + operator const data_type& () const + { return (*this)->read(); } + + + // use for positive edge sensitivity + + sc_event_finder& pos() const + { + if ( !m_pos_finder_p ) + { + m_pos_finder_p = new sc_event_finder_t<in_if_type>( + *this, &in_if_type::posedge_event ); + } + return *m_pos_finder_p; + } + + // use for negative edge sensitivity + + sc_event_finder& neg() const + { + if ( !m_neg_finder_p ) + { + m_neg_finder_p = new sc_event_finder_t<in_if_type>( + *this, &in_if_type::negedge_event ); + } + return *m_neg_finder_p; + } + + + // was there a value changed event? + + bool event() const + { return (*this)->event(); } + + // was there a positive edge event? + + bool posedge() const + { return (*this)->posedge(); } + + // was there a negative edge event? + + bool negedge() const + { return (*this)->negedge(); } + + // write the new value + + void write( const data_type& value_ ) + { (*this)->write( value_ ); } + + this_type& operator = ( const data_type& value_ ) + { (*this)->write( value_ ); return *this; } + + this_type& operator = ( const in_if_type& interface_ ) + { (*this)->write( interface_.read() ); return *this; } + + this_type& operator = ( const in_port_type& port_ ) + { (*this)->write( port_->read() ); return *this; } + + this_type& operator = ( const inout_port_type& port_ ) + { (*this)->write( port_->read() ); return *this; } + + this_type& operator = ( const this_type& port_ ) + { (*this)->write( port_->read() ); return *this; } + + + // set initial value (can also be called when port is not bound yet) + + void initialize( const data_type& value_ ); + + void initialize( const in_if_type& interface_ ) + { initialize( interface_.read() ); } + + + // called when elaboration is done + /* WHEN DEFINING THIS METHOD IN A DERIVED CLASS, */ + /* MAKE SURE THAT THIS METHOD IS CALLED AS WELL. */ + + virtual void end_of_elaboration(); + + + // (other) event finder method(s) + + sc_event_finder& value_changed() const + { + if ( !m_change_finder_p ) + { + m_change_finder_p = new sc_event_finder_t<in_if_type>( + *this, &in_if_type::value_changed_event ); + } + return *m_change_finder_p; + } + + virtual const char* kind() const + { return "sc_inout"; } + +protected: + + data_type* m_init_val; + +public: + + // called by sc_trace + void add_trace_internal( sc_trace_file*, const std::string& ) const; + + void add_trace( sc_trace_file*, const std::string& ) const; + +protected: + + void remove_traces() const; + + mutable sc_trace_params_vec* m_traces; + +private: + mutable sc_event_finder* m_change_finder_p; + mutable sc_event_finder* m_neg_finder_p; + mutable sc_event_finder* m_pos_finder_p; + +private: + + // disabled + sc_inout( const this_type& ); + +#ifdef __GNUC__ + // Needed to circumvent a problem in the g++-2.95.2 compiler: + // This unused variable forces the compiler to instantiate + // an object of T template so an implicit conversion from + // read() to a C++ intrinsic data type will work. + static data_type dummy; +#endif +}; + + +// ---------------------------------------------------------------------------- +// CLASS : sc_out<T> +// +// The sc_signal<T> output port class. +// ---------------------------------------------------------------------------- + +// sc_out can also read from its port, hence no difference with sc_inout. +// For debugging reasons, a class is provided instead of a define. + +template <class T> +class sc_out +: public sc_inout<T> +{ +public: + + // typedefs + + typedef T data_type; + + typedef sc_out<data_type> this_type; + typedef sc_inout<data_type> base_type; + + typedef typename base_type::in_if_type in_if_type; + typedef typename base_type::in_port_type in_port_type; + typedef typename base_type::inout_if_type inout_if_type; + typedef typename base_type::inout_port_type inout_port_type; + +public: + + // constructors + + sc_out() + : base_type() + {} + + explicit sc_out( const char* name_ ) + : base_type( name_ ) + {} + + explicit sc_out( inout_if_type& interface_ ) + : base_type( interface_ ) + {} + + sc_out( const char* name_, inout_if_type& interface_ ) + : base_type( name_, interface_ ) + {} + + explicit sc_out( inout_port_type& parent_ ) + : base_type( parent_ ) + {} + + sc_out( const char* name_, inout_port_type& parent_ ) + : base_type( name_, parent_ ) + {} + + sc_out( this_type& parent_ ) + : base_type( parent_ ) + {} + + sc_out( const char* name_, this_type& parent_ ) + : base_type( name_, parent_ ) + {} + + + // destructor (does nothing) + + virtual ~sc_out() + {} + + + // write the new value + + this_type& operator = ( const data_type& value_ ) + { (*this)->write( value_ ); return *this; } + + this_type& operator = ( const in_if_type& interface_ ) + { (*this)->write( interface_.read() ); return *this; } + + this_type& operator = ( const in_port_type& port_ ) + { (*this)->write( port_->read() ); return *this; } + + this_type& operator = ( const inout_port_type& port_ ) + { (*this)->write( port_->read() ); return *this; } + + this_type& operator = ( const this_type& port_ ) + { (*this)->write( port_->read() ); return *this; } + + virtual const char* kind() const + { return "sc_out"; } + +private: + + // disabled + sc_out( const this_type& ); +}; + + +// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII + + +// ---------------------------------------------------------------------------- +// FUNCTION : sc_trace +// ---------------------------------------------------------------------------- + +template <class T> +inline +void +sc_trace(sc_trace_file* tf, const sc_in<T>& port, const std::string& name) +{ + const sc_signal_in_if<T>* iface = 0; + if (sc_get_curr_simcontext()->elaboration_done() ) + { + iface = DCAST<const sc_signal_in_if<T>*>( port.get_interface() ); + } + + if ( iface ) + sc_trace( tf, iface->read(), name ); + else + port.add_trace_internal( tf, name ); +} + +template <class T> +inline +void +sc_trace( sc_trace_file* tf, const sc_inout<T>& port, + const std::string& name ) +{ + const sc_signal_in_if<T>* iface = 0; + if (sc_get_curr_simcontext()->elaboration_done() ) + { + iface =DCAST<const sc_signal_in_if<T>*>( port.get_interface() ); + } + + if ( iface ) + sc_trace( tf, iface->read(), name ); + else + port.add_trace_internal( tf, name ); +} + +} // namespace sc_core + +#undef SC_VIRTUAL_ + +/***************************************************************************** + + MODIFICATION LOG - modifiers, enter your name, affiliation, date and + changes you are making here. + + Name, Affiliation, Date: Jason Elbaum, Motorola, Inc., 2001-11-12 + Description of Modification: Added a static, private, otherwise + unused data member to the sc_in + and sc_inout classes to address + a bug in the GNU compiler *only*. + This works around a bug in g++ 2.95.2 + regarding implicit casting from a + templated class to a C++ intrinsic type. + + *****************************************************************************/ +//$Log: sc_signal_ports.h,v $ +//Revision 1.10 2011/08/29 18:04:32 acg +// Philipp A. Hartmann: miscellaneous clean ups. +// +//Revision 1.9 2011/08/26 20:45:43 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/08/07 19:08:01 acg +// Andy Goodrich: moved logs to end of file so line number synching works +// better between versions. +// +//Revision 1.7 2011/08/07 18:53:09 acg +// Philipp A. Hartmann: add virtual instances of the bind function for +// base classes to eliminate warning messages for clang platforms. +// +//Revision 1.6 2011/04/02 00:03:23 acg +// Andy Goodrich: catch the other bind()'s that I missed in Philipp's update. +// +//Revision 1.5 2011/04/01 22:33:31 acg +// Philipp A. Harmann: Use const interface signature to implement non-const +// interface signature for virtual bind(...). +// +//Revision 1.4 2011/03/30 16:46:10 acg +// Andy Goodrich: added a signature and removed a virtual specification +// to eliminate warnings with certain compilers. +// +//Revision 1.3 2011/02/18 20:23:45 acg +// Andy Goodrich: Copyright update. +// +//Revision 1.2 2011/01/20 16:52:15 acg +// Andy Goodrich: changes for IEEE 1666 2011. +// +//Revision 1.1.1.1 2006/12/15 20:20:04 acg +//SystemC 2.3 +// +//Revision 1.11 2006/04/18 23:36:50 acg +// Andy Goodrich: made add_trace_internal public until I can figure out +// how to do a friend specification for sc_trace in an environment where +// there are partial template and full template specifications for its +// arguments. +// +//Revision 1.10 2006/04/18 18:01:26 acg +// Andy Goodrich: added an add_trace_internal() method to the various port +// classes so that sc_trace has something to call that won't emit an +// IEEE 1666 deprecation message. +// +//Revision 1.9 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.8 2006/02/02 23:42:37 acg +// Andy Goodrich: implemented a much better fix to the sc_event_finder +// proliferation problem. This new version allocates only a single event +// finder for each port for each type of event, e.g., pos(), neg(), and +// value_change(). The event finder persists as long as the port does, +// which is what the LRM dictates. Because only a single instance is +// allocated for each event type per port there is not a potential +// explosion of storage as was true in the 2.0.1/2.1 versions. +// +//Revision 1.7 2006/02/02 21:38:12 acg +// Andy Goodrich: fix to the comment log. +// +//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/13 18:47:42 acg +//Added $Log command so that CVS comments are reproduced in the source. +// +//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.18 2005/09/15 23:01:52 acg +//Added std:: prefix to appropriate methods and types to get around +//issues with the Edison Front End. +// +//Revision 1.17 2005/06/10 22:43:55 acg +//Added CVS change log annotation. +// + +#endif + +// Taf! |