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