1/*****************************************************************************
2
3  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
4  more contributor license agreements.  See the NOTICE file distributed
5  with this work for additional information regarding copyright ownership.
6  Accellera licenses this file to you under the Apache License, Version 2.0
7  (the "License"); you may not use this file except in compliance with the
8  License.  You may obtain a copy of the License at
9
10    http://www.apache.org/licenses/LICENSE-2.0
11
12  Unless required by applicable law or agreed to in writing, software
13  distributed under the License is distributed on an "AS IS" BASIS,
14  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
15  implied.  See the License for the specific language governing
16  permissions and limitations under the License.
17
18 *****************************************************************************/
19
20/*****************************************************************************
21
22  sc_sensitive.cpp --
23
24  Original Author: Stan Y. Liao, Synopsys, Inc.
25                   Martin Janssen, Synopsys, Inc.
26
27  CHANGE LOG AT THE END OF THE FILE
28 *****************************************************************************/
29
30
31#include "sysc/kernel/sc_event.h"
32#include "sysc/kernel/sc_kernel_ids.h"
33#include "sysc/kernel/sc_module.h"
34#include "sysc/kernel/sc_cthread_process.h"
35#include "sysc/kernel/sc_method_process.h"
36#include "sysc/kernel/sc_thread_process.h"
37#include "sysc/kernel/sc_process_handle.h"
38#include "sysc/kernel/sc_sensitive.h"
39#include "sysc/communication/sc_signal_ports.h"
40#include "sysc/utils/sc_utils_ids.h"
41
42namespace sc_core {
43
44// support functions
45
46static
47sc_method_handle
48as_method_handle( sc_process_b* handle_ )
49{
50    return DCAST<sc_method_handle>( handle_ );
51}
52
53static
54sc_thread_handle
55as_thread_handle( sc_process_b* handle_ )
56{
57    return DCAST<sc_thread_handle>( handle_ );
58}
59
60static
61void
62warn_no_parens()
63{
64    static bool warn_no_parentheses=true;
65    if ( warn_no_parentheses )
66    {
67	warn_no_parentheses=false;
68	SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
69	    "use of () to specify sensitivity is deprecated, use << instead" );
70    }
71}
72
73// ----------------------------------------------------------------------------
74//  CLASS : sc_sensitive
75//
76//  Static sensitivity class for events.
77// ----------------------------------------------------------------------------
78
79// constructor
80
81sc_sensitive::sc_sensitive( sc_module* module_ )
82: m_module( module_ ),
83  m_mode( SC_NONE_ ),
84  m_handle( 0 )
85{}
86
87
88// destructor
89
90sc_sensitive::~sc_sensitive()
91{}
92
93
94// changing between process handles
95
96sc_sensitive&
97sc_sensitive::operator << ( sc_process_handle handle_ )
98{
99    switch ( handle_.proc_kind() )
100	{
101      case SC_CTHREAD_PROC_:
102      case SC_THREAD_PROC_:
103        m_mode = SC_THREAD_;
104	break;
105      case SC_METHOD_PROC_:
106	m_mode = SC_METHOD_;
107	break;
108      default:
109	assert(0);
110    }
111    m_handle = (sc_process_b*)handle_;
112    return *this;
113}
114
115sc_sensitive&
116sc_sensitive::operator << ( const sc_event& event_ )
117{
118    // check
119    if( sc_is_running() ) {
120	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_, "simulation running" );
121    }
122
123    // make sensitive
124    switch( m_mode ) {
125    case SC_METHOD_:
126    case SC_THREAD_: {
127	m_handle->add_static_event( event_ );
128	break;
129    }
130    case SC_NONE_:
131        /* do nothing */
132        break;
133    }
134
135    return *this;
136}
137
138void
139sc_sensitive::make_static_sensitivity(
140    sc_process_b* handle_, const sc_event& event_)
141{
142    handle_->add_static_event( event_ );
143}
144
145
146sc_sensitive&
147sc_sensitive::operator << ( const sc_interface& interface_ )
148{
149    // check
150    if( sc_is_running() ) {
151	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_, "simulation running" );
152    }
153
154    // make sensitive
155    switch( m_mode ) {
156    case SC_METHOD_:
157    case SC_THREAD_: {
158	m_handle->add_static_event( interface_.default_event() );
159	break;
160    }
161    case SC_NONE_:
162        /* do nothing */
163        break;
164    }
165
166    return *this;
167}
168
169void
170sc_sensitive::make_static_sensitivity(
171    sc_process_b* handle_, const sc_interface& interface_)
172{
173    handle_->add_static_event( interface_.default_event() );
174}
175
176sc_sensitive&
177sc_sensitive::operator << ( const sc_port_base& port_ )
178{
179    // check
180    if( sc_is_running() ) {
181	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_, "simulation running" );
182    }
183
184    // make sensitive
185    switch( m_mode ) {
186    case SC_METHOD_: {
187	port_.make_sensitive( as_method_handle( m_handle ) );
188	break;
189    }
190    case SC_THREAD_: {
191	port_.make_sensitive( as_thread_handle( m_handle ) );
192	break;
193    }
194    case SC_NONE_:
195        /* do nothing */
196        break;
197    }
198
199    return *this;
200}
201
202void
203sc_sensitive::make_static_sensitivity(
204    sc_process_b* handle_, const sc_port_base& port_)
205{
206    sc_method_handle handle_m = as_method_handle( handle_ );
207    if ( handle_m ) {
208	port_.make_sensitive( handle_m );
209	return;
210    }
211    sc_thread_handle handle_t = as_thread_handle( handle_ );
212    // assert(handle_t);
213    port_.make_sensitive( handle_t );
214}
215
216sc_sensitive&
217sc_sensitive::operator << ( sc_event_finder& event_finder_ )
218{
219    // check
220    if( sc_is_running() ) {
221	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_, "simulation running" );
222    }
223
224    // make sensitive
225    switch( m_mode ) {
226    case SC_METHOD_: {
227	event_finder_.port().make_sensitive( as_method_handle( m_handle ),
228					     &event_finder_ );
229	break;
230    }
231    case SC_THREAD_: {
232	event_finder_.port().make_sensitive( as_thread_handle( m_handle ),
233					     &event_finder_ );
234	break;
235    }
236    case SC_NONE_:
237        /* do nothing */
238        break;
239    }
240
241    return *this;
242}
243
244void
245sc_sensitive::make_static_sensitivity(
246    sc_process_b* handle_, sc_event_finder& event_finder_)
247{
248    if (sc_is_running()) {
249      handle_->add_static_event( event_finder_.find_event() );
250    } else {
251	sc_method_handle handle_m = as_method_handle( handle_ );
252	if ( handle_m ) {
253	    event_finder_.port().make_sensitive( handle_m, &event_finder_ );
254	    return;
255        }
256	sc_thread_handle handle_t = as_thread_handle( handle_ );
257	// assert(handle_t);
258	event_finder_.port().make_sensitive( handle_t, &event_finder_);
259    }
260}
261
262
263sc_sensitive&
264sc_sensitive::operator () ( const sc_event& event_ )
265{
266    warn_no_parens();
267    return operator << ( event_ );
268}
269
270sc_sensitive&
271sc_sensitive::operator () ( const sc_interface& interface_ )
272{
273    warn_no_parens();
274    return operator << ( interface_ );
275}
276
277sc_sensitive&
278sc_sensitive::operator () ( const sc_port_base& port_ )
279{
280    warn_no_parens();
281    return operator << ( port_ );
282}
283
284sc_sensitive&
285sc_sensitive::operator () ( sc_event_finder& event_finder_ )
286{
287    warn_no_parens();
288    return operator << ( event_finder_ );
289}
290
291
292sc_sensitive&
293sc_sensitive::operator () ( sc_cthread_handle handle_,
294			    sc_event_finder& event_finder_ )
295{
296    event_finder_.port().make_sensitive( handle_, &event_finder_ );
297    return *this;
298}
299
300sc_sensitive&
301sc_sensitive::operator () ( sc_cthread_handle handle_,
302			    const in_if_b_type& interface_ )
303{
304    handle_->add_static_event( interface_.posedge_event() );
305    return *this;
306}
307
308sc_sensitive&
309sc_sensitive::operator () ( sc_cthread_handle handle_,
310			    const in_if_l_type& interface_ )
311{
312    handle_->add_static_event( interface_.posedge_event() );
313    return *this;
314}
315
316sc_sensitive&
317sc_sensitive::operator () ( sc_cthread_handle handle_,
318			    const in_port_b_type& port_ )
319{
320    port_.make_sensitive( handle_, &port_.pos() );
321    return *this;
322}
323
324sc_sensitive&
325sc_sensitive::operator () ( sc_cthread_handle handle_,
326			    const in_port_l_type& port_ )
327{
328    port_.make_sensitive( handle_, &port_.pos() );
329    return *this;
330}
331
332sc_sensitive&
333sc_sensitive::operator () ( sc_cthread_handle handle_,
334			    const inout_port_b_type& port_ )
335{
336    port_.make_sensitive( handle_, &port_.pos() );
337    return *this;
338}
339
340sc_sensitive&
341sc_sensitive::operator () ( sc_cthread_handle handle_,
342			    const inout_port_l_type& port_ )
343{
344    port_.make_sensitive( handle_, &port_.pos() );
345    return *this;
346}
347
348void sc_sensitive::reset()
349{
350    m_mode = SC_NONE_;
351}
352
353
354// ----------------------------------------------------------------------------
355//  CLASS : sc_sensitive_pos
356//
357//  Static sensitivity class for positive edge events.
358// ----------------------------------------------------------------------------
359
360static void sc_deprecated_sensitive_pos()
361{
362    static bool warn_sensitive_pos=true;
363    if ( warn_sensitive_pos )
364    {
365        warn_sensitive_pos=false;
366        SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
367	 "sc_sensitive_pos is deprecated use sc_sensitive << with pos() instead" );
368    }
369}
370
371// constructor
372
373sc_sensitive_pos::sc_sensitive_pos( sc_module* module_ )
374: m_module( module_ ),
375  m_mode( SC_NONE_ ),
376  m_handle( 0 )
377{}
378
379
380// destructor
381
382sc_sensitive_pos::~sc_sensitive_pos()
383{}
384
385
386// changing between process handles
387
388sc_sensitive_pos&
389sc_sensitive_pos::operator << ( sc_process_handle handle_ )
390{
391    switch ( handle_.proc_kind() )
392	{
393      case SC_CTHREAD_PROC_:
394      case SC_THREAD_PROC_:
395        m_mode = SC_THREAD_;
396	break;
397      case SC_METHOD_PROC_:
398	m_mode = SC_METHOD_;
399	break;
400      default:
401	assert(0);
402    }
403    m_handle = (sc_process_b*)handle_;
404    return *this;
405}
406
407sc_sensitive_pos&
408sc_sensitive_pos::operator << ( sc_method_handle handle_ )
409{
410    m_mode = SC_METHOD_;
411    m_handle = handle_;
412    return *this;
413}
414
415sc_sensitive_pos&
416sc_sensitive_pos::operator << ( sc_thread_handle handle_ )
417{
418    m_mode = SC_THREAD_;
419    m_handle = handle_;
420    return *this;
421}
422
423
424sc_sensitive_pos&
425sc_sensitive_pos::operator << ( const in_if_b_type& interface_ )
426{
427    sc_deprecated_sensitive_pos();
428    // check
429    if( sc_is_running() ) {
430	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_POS_, "simulation running" );
431    }
432
433    // make sensitive
434    switch( m_mode ) {
435    case SC_METHOD_:
436    case SC_THREAD_: {
437	m_handle->add_static_event( interface_.posedge_event() );
438	break;
439    }
440    case SC_NONE_:
441        /* do nothing */
442        break;
443    }
444
445    return *this;
446}
447
448sc_sensitive_pos&
449sc_sensitive_pos::operator << ( const in_if_l_type& interface_ )
450{
451    sc_deprecated_sensitive_pos();
452    // check
453    if( sc_is_running() ) {
454	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_POS_, "simulation running" );
455    }
456
457    // make sensitive
458    switch( m_mode ) {
459    case SC_METHOD_:
460    case SC_THREAD_: {
461	m_handle->add_static_event( interface_.posedge_event() );
462	break;
463    }
464    case SC_NONE_:
465        /* do nothing */
466        break;
467    }
468
469    return *this;
470}
471
472sc_sensitive_pos&
473sc_sensitive_pos::operator << ( const in_port_b_type& port_ )
474{
475    sc_deprecated_sensitive_pos();
476    // check
477    if( sc_is_running() ) {
478	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_POS_, "simulation running" );
479    }
480
481    // make sensitive
482    switch( m_mode ) {
483    case SC_METHOD_: {
484	port_.make_sensitive( as_method_handle( m_handle ), &port_.pos() );
485	break;
486    }
487    case SC_THREAD_: {
488	port_.make_sensitive( as_thread_handle( m_handle ), &port_.pos() );
489	break;
490    }
491    case SC_NONE_:
492        /* do nothing */
493        break;
494    }
495
496    return *this;
497}
498
499sc_sensitive_pos&
500sc_sensitive_pos::operator << ( const in_port_l_type& port_ )
501{
502    sc_deprecated_sensitive_pos();
503    // check
504    if( sc_is_running() ) {
505	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_POS_, "simulation running" );
506    }
507
508    // make sensitive
509    switch( m_mode ) {
510    case SC_METHOD_: {
511	port_.make_sensitive( as_method_handle( m_handle ), &port_.pos() );
512	break;
513    }
514    case SC_THREAD_: {
515	port_.make_sensitive( as_thread_handle( m_handle ), &port_.pos() );
516	break;
517    }
518    case SC_NONE_:
519        /* do nothing */
520        break;
521    }
522
523    return *this;
524}
525
526sc_sensitive_pos&
527sc_sensitive_pos::operator << ( const inout_port_b_type& port_ )
528{
529    sc_deprecated_sensitive_pos();
530    // check
531    if( sc_is_running() ) {
532	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_POS_, "simulation running" );
533    }
534
535    // make sensitive
536    switch( m_mode ) {
537    case SC_METHOD_: {
538	port_.make_sensitive( as_method_handle( m_handle ), &port_.pos() );
539	break;
540    }
541    case SC_THREAD_: {
542	port_.make_sensitive( as_thread_handle( m_handle ), &port_.pos() );
543	break;
544    }
545    case SC_NONE_:
546        /* do nothing */
547        break;
548    }
549
550    return *this;
551}
552
553sc_sensitive_pos&
554sc_sensitive_pos::operator << ( const inout_port_l_type& port_ )
555{
556    sc_deprecated_sensitive_pos();
557    // check
558    if( sc_is_running() ) {
559	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_POS_, "simulation running" );
560    }
561
562    // make sensitive
563    switch( m_mode ) {
564    case SC_METHOD_: {
565	port_.make_sensitive( as_method_handle( m_handle ), &port_.pos() );
566	break;
567    }
568    case SC_THREAD_: {
569	port_.make_sensitive( as_thread_handle( m_handle ), &port_.pos() );
570	break;
571    }
572    case SC_NONE_:
573        /* do nothing */
574        break;
575    }
576
577    return *this;
578}
579
580
581sc_sensitive_pos&
582sc_sensitive_pos::operator () ( const in_if_b_type& interface_ )
583{
584    warn_no_parens();
585    return operator << ( interface_ );
586}
587
588sc_sensitive_pos&
589sc_sensitive_pos::operator () ( const in_if_l_type& interface_ )
590{
591    warn_no_parens();
592    return operator << ( interface_ );
593}
594
595sc_sensitive_pos&
596sc_sensitive_pos::operator () ( const in_port_b_type& port_ )
597{
598    warn_no_parens();
599    return operator << ( port_ );
600}
601
602sc_sensitive_pos&
603sc_sensitive_pos::operator () ( const in_port_l_type& port_ )
604{
605    warn_no_parens();
606    return operator << ( port_ );
607}
608
609sc_sensitive_pos&
610sc_sensitive_pos::operator () ( const inout_port_b_type& port_ )
611{
612    warn_no_parens();
613    return operator << ( port_ );
614}
615
616sc_sensitive_pos&
617sc_sensitive_pos::operator () ( const inout_port_l_type& port_ )
618{
619    warn_no_parens();
620    return operator << ( port_ );
621}
622
623void sc_sensitive_pos::reset()
624{
625    m_mode = SC_NONE_;
626}
627
628
629// ----------------------------------------------------------------------------
630//  CLASS : sc_sensitive_neg
631//
632//  Static sensitivity class for negative edge events.
633// ----------------------------------------------------------------------------
634
635static void sc_deprecated_sensitive_neg()
636{
637    static bool warn_sensitive_neg=true;
638    if ( warn_sensitive_neg )
639    {
640        warn_sensitive_neg=false;
641        SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
642	 "sc_sensitive_neg is deprecated use sc_sensitive << with neg() instead" );
643    }
644}
645
646// constructor
647
648sc_sensitive_neg::sc_sensitive_neg( sc_module* module_ )
649: m_module( module_ ),
650  m_mode( SC_NONE_ ),
651  m_handle( 0 )
652{}
653
654
655// destructor
656
657sc_sensitive_neg::~sc_sensitive_neg()
658{}
659
660
661// changing between process handles
662
663sc_sensitive_neg&
664sc_sensitive_neg::operator << ( sc_process_handle handle_ )
665{
666    switch ( handle_.proc_kind() )
667	{
668      case SC_CTHREAD_PROC_:
669      case SC_THREAD_PROC_:
670        m_mode = SC_THREAD_;
671	break;
672      case SC_METHOD_PROC_:
673	m_mode = SC_METHOD_;
674	break;
675      default:
676	assert(0);
677    }
678    m_handle = (sc_process_b*)handle_;
679    return *this;
680}
681
682sc_sensitive_neg&
683sc_sensitive_neg::operator << ( sc_method_handle handle_ )
684{
685    m_mode = SC_METHOD_;
686    m_handle = handle_;
687    return *this;
688}
689
690sc_sensitive_neg&
691sc_sensitive_neg::operator << ( sc_thread_handle handle_ )
692{
693    m_mode = SC_THREAD_;
694    m_handle = handle_;
695    return *this;
696}
697
698
699sc_sensitive_neg&
700sc_sensitive_neg::operator << ( const in_if_b_type& interface_ )
701{
702    sc_deprecated_sensitive_neg();
703    // check
704    if( sc_is_running() ) {
705	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_NEG_, "simulation running" );
706    }
707
708    // make sensitive
709    switch( m_mode ) {
710    case SC_METHOD_:
711    case SC_THREAD_: {
712	m_handle->add_static_event( interface_.negedge_event() );
713	break;
714    }
715    case SC_NONE_:
716        /* do nothing */
717        break;
718    }
719
720    return *this;
721}
722
723sc_sensitive_neg&
724sc_sensitive_neg::operator << ( const in_if_l_type& interface_ )
725{
726    sc_deprecated_sensitive_neg();
727    // check
728    if( sc_is_running() ) {
729	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_NEG_, "simulation running" );
730    }
731
732    // make sensitive
733    switch( m_mode ) {
734    case SC_METHOD_:
735    case SC_THREAD_: {
736	m_handle->add_static_event( interface_.negedge_event() );
737	break;
738    }
739    case SC_NONE_:
740        /* do nothing */
741        break;
742    }
743
744    return *this;
745}
746
747sc_sensitive_neg&
748sc_sensitive_neg::operator << ( const in_port_b_type& port_ )
749{
750    sc_deprecated_sensitive_neg();
751    // check
752    if( sc_is_running() ) {
753	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_NEG_, "simulation running" );
754    }
755
756    // make sensitive
757    switch( m_mode ) {
758    case SC_METHOD_: {
759	port_.make_sensitive( as_method_handle( m_handle ), &port_.neg() );
760	break;
761    }
762    case SC_THREAD_: {
763	port_.make_sensitive( as_thread_handle( m_handle ), &port_.neg() );
764	break;
765    }
766    case SC_NONE_:
767        /* do nothing */
768        break;
769    }
770
771    return *this;
772}
773
774sc_sensitive_neg&
775sc_sensitive_neg::operator << ( const in_port_l_type& port_ )
776{
777    sc_deprecated_sensitive_neg();
778    // check
779    if( sc_is_running() ) {
780	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_NEG_, "simulation running" );
781    }
782
783    // make sensitive
784    switch( m_mode ) {
785    case SC_METHOD_: {
786	port_.make_sensitive( as_method_handle( m_handle ), &port_.neg() );
787	break;
788    }
789    case SC_THREAD_: {
790	port_.make_sensitive( as_thread_handle( m_handle ), &port_.neg() );
791	break;
792    }
793    case SC_NONE_:
794        /* do nothing */
795        break;
796    }
797
798    return *this;
799}
800
801sc_sensitive_neg&
802sc_sensitive_neg::operator << ( const inout_port_b_type& port_ )
803{
804    sc_deprecated_sensitive_neg();
805    // check
806    if( sc_is_running() ) {
807	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_NEG_, "simulation running" );
808    }
809
810    // make sensitive
811    switch( m_mode ) {
812    case SC_METHOD_: {
813	port_.make_sensitive( as_method_handle( m_handle ), &port_.neg() );
814	break;
815    }
816    case SC_THREAD_: {
817	port_.make_sensitive( as_thread_handle( m_handle ), &port_.neg() );
818	break;
819    }
820    case SC_NONE_:
821        /* do nothing */
822        break;
823    }
824
825    return *this;
826}
827
828sc_sensitive_neg&
829sc_sensitive_neg::operator << ( const inout_port_l_type& port_ )
830{
831    sc_deprecated_sensitive_neg();
832    // check
833    if( sc_is_running() ) {
834	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_NEG_, "simulation running" );
835    }
836
837    // make sensitive
838    switch( m_mode ) {
839    case SC_METHOD_: {
840	port_.make_sensitive( as_method_handle( m_handle ), &port_.neg() );
841	break;
842    }
843    case SC_THREAD_: {
844	port_.make_sensitive( as_thread_handle( m_handle ), &port_.neg() );
845	break;
846    }
847    case SC_NONE_:
848        /* do nothing */
849        break;
850    }
851
852    return *this;
853}
854
855
856sc_sensitive_neg&
857sc_sensitive_neg::operator () ( const in_if_b_type& interface_ )
858{
859    warn_no_parens();
860    return operator << ( interface_ );
861}
862
863sc_sensitive_neg&
864sc_sensitive_neg::operator () ( const in_if_l_type& interface_ )
865{
866    warn_no_parens();
867    return operator << ( interface_ );
868}
869
870sc_sensitive_neg&
871sc_sensitive_neg::operator () ( const in_port_b_type& port_ )
872{
873    warn_no_parens();
874    return operator << ( port_ );
875}
876
877sc_sensitive_neg&
878sc_sensitive_neg::operator () ( const in_port_l_type& port_ )
879{
880    warn_no_parens();
881    return operator << ( port_ );
882}
883
884sc_sensitive_neg&
885sc_sensitive_neg::operator () ( const inout_port_b_type& port_ )
886{
887    warn_no_parens();
888    return operator << ( port_ );
889}
890
891sc_sensitive_neg&
892sc_sensitive_neg::operator () ( const inout_port_l_type& port_ )
893{
894    warn_no_parens();
895    return operator << ( port_ );
896}
897
898void sc_sensitive_neg::reset()
899{
900    m_mode = SC_NONE_;
901}
902
903} // namespace sc_core
904
905/*****************************************************************************
906
907  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
908  changes you are making here.
909
910      Name, Affiliation, Date: Bishnupriya Bhattacharya, Cadence Design Systems,
911                               25 August, 2003
912  Description of Modification: add make_static_sensitivity() routines to support
913                               dynamic method process creation with static
914                               sensitivity
915
916 *****************************************************************************/
917
918// $Log: sc_sensitive.cpp,v $
919// Revision 1.5  2011/08/26 20:46:10  acg
920//  Andy Goodrich: moved the modification log to the end of the file to
921//  eliminate source line number skew when check-ins are done.
922//
923// Revision 1.4  2011/02/18 20:27:14  acg
924//  Andy Goodrich: Updated Copyrights.
925//
926// Revision 1.3  2011/02/13 21:47:38  acg
927//  Andy Goodrich: update copyright notice.
928//
929// Revision 1.2  2008/05/22 17:06:26  acg
930//  Andy Goodrich: updated copyright notice to include 2008.
931//
932// Revision 1.1.1.1  2006/12/15 20:20:05  acg
933// SystemC 2.3
934//
935// Revision 1.8  2006/04/11 23:13:21  acg
936//   Andy Goodrich: Changes for reduced reset support that only includes
937//   sc_cthread, but has preliminary hooks for expanding to method and thread
938//   processes also.
939//
940// Revision 1.7  2006/01/27 17:31:24  acg
941//  Andy Goodrich: removed debugging comments from << operator code for types
942//  that are deprecated.
943//
944// Revision 1.6  2006/01/26 21:04:54  acg
945//  Andy Goodrich: deprecation message changes and additional messages.
946//
947// Revision 1.5  2006/01/25 00:31:19  acg
948//  Andy Goodrich: Changed over to use a standard message id of
949//  SC_ID_IEEE_1666_DEPRECATION for all deprecation messages.
950//
951// Revision 1.4  2006/01/24 20:49:05  acg
952// Andy Goodrich: changes to remove the use of deprecated features within the
953// simulator, and to issue warning messages when deprecated features are used.
954//
955// Revision 1.3  2006/01/13 18:44:30  acg
956// Added $Log to record CVS changes into the source.
957//
958
959// Taf!
960