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_bit_proxies.h -- Proxy classes for vector data types. 23 24 Original Author: Gene Bushuyev, Synopsys, Inc. 25 26 CHANGE LOG AT THE END OF THE FILE 27 *****************************************************************************/ 28 29#ifndef SC_BIT_PROXIES_H 30#define SC_BIT_PROXIES_H 31 32 33#include "sysc/datatypes/bit/sc_bit_ids.h" 34#include "sysc/datatypes/bit/sc_proxy.h" 35 36 37namespace sc_dt 38{ 39 40// classes defined in this module 41template <class X> class sc_bitref_r; 42template <class X> class sc_bitref; 43template <class X> class sc_subref_r; 44template <class X> class sc_subref; 45template <class X, class Y> class sc_concref_r; 46template <class X, class Y> class sc_concref; 47 48 49// ---------------------------------------------------------------------------- 50// CLASS TEMPLATE : sc_bitref_r<T> 51// 52// Proxy class for sc_proxy bit selection (r-value only). 53// ---------------------------------------------------------------------------- 54 55template <class T> 56class sc_bitref_r 57{ 58 friend class sc_bv_base; 59 friend class sc_lv_base; 60 61public: 62 63 // typedefs 64 65 typedef typename T::traits_type traits_type; 66 typedef typename traits_type::bit_type bit_type; 67 68 // constructor 69 70 sc_bitref_r( const T& obj_, int index_ ) 71 : m_obj( CCAST<T&>( obj_ ) ), m_index( index_ ) 72 {} 73 74 75 // copy constructor 76 77 sc_bitref_r( const sc_bitref_r<T>& a ) 78 : m_obj( a.m_obj ), m_index( a.m_index ) 79 {} 80 81 // cloning 82 83 sc_bitref_r<T>* clone() const 84 { return new sc_bitref_r<T>( *this ); } 85 86 87 // bitwise operators and functions 88 89 // bitwise complement 90 91 const bit_type operator ~ () const 92 { return bit_type( sc_logic::not_table[value()] ); } 93 94 95 // implicit conversion to bit_type 96 97 operator const bit_type() const 98 { return bit_type( m_obj.get_bit( m_index ) ); } 99 100 101 // explicit conversions 102 103 sc_logic_value_t value() const 104 { return m_obj.get_bit( m_index ); } 105 106 107 bool is_01() const 108 { return sc_logic( value() ).is_01(); } 109 110 bool to_bool() const 111 { return sc_logic( value() ).to_bool(); } 112 113 char to_char() const 114 { return sc_logic( value() ).to_char(); } 115 116 117 // common methods 118 119 int length() const 120 { return 1; } 121 122 int size() const 123 { return ( (length() - 1) / SC_DIGIT_SIZE + 1 ); } 124 125 sc_logic_value_t get_bit( int n ) const; 126 127 sc_digit get_word( int i ) const; 128 sc_digit get_cword( int i ) const; 129 130 131 // other methods 132 133 void print( ::std::ostream& os = ::std::cout ) const 134 { os << to_char(); } 135 136protected: 137 138 T& m_obj; 139 int m_index; 140 141private: 142 143 // disabled 144 sc_bitref_r(); 145 sc_bitref_r<T>& operator = ( const sc_bitref_r<T>& ); 146}; 147 148 149// bitwise operators and functions 150 151// bitwise and 152 153template <class T1, class T2> 154inline 155const sc_logic 156operator & ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b ); 157 158 159// bitwise or 160 161template <class T1, class T2> 162inline 163const sc_logic 164operator | ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b ); 165 166 167// bitwise xor 168 169template <class T1, class T2> 170inline 171const sc_logic 172operator ^ ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b ); 173 174 175// relational operators and functions 176 177template <class T1, class T2> 178inline 179bool 180operator == ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b ); 181 182template <class T1, class T2> 183inline 184bool 185operator != ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b ); 186 187 188// r-value concatenation operators and functions 189 190template <class T1, class T2> 191inline 192sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> > 193operator , ( sc_bitref_r<T1>, sc_bitref_r<T2> ); 194 195template <class T1, class T2> 196inline 197sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> > 198operator , ( sc_bitref_r<T1>, sc_subref_r<T2> ); 199 200template <class T1, class T2, class T3> 201inline 202sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> > 203operator , ( sc_bitref_r<T1>, sc_concref_r<T2,T3> ); 204 205template <class T1, class T2> 206inline 207sc_concref_r<sc_bitref_r<T1>,T2> 208operator , ( sc_bitref_r<T1>, const sc_proxy<T2>& ); 209 210template <class T> 211inline 212sc_concref_r<sc_bitref_r<T>,sc_lv_base> 213operator , ( sc_bitref_r<T>, const char* ); 214 215template <class T> 216inline 217sc_concref_r<sc_lv_base,sc_bitref_r<T> > 218operator , ( const char*, sc_bitref_r<T> ); 219 220template <class T> 221inline 222sc_concref_r<sc_bitref_r<T>,sc_lv_base> 223operator , ( sc_bitref_r<T>, const sc_logic& ); 224 225template <class T> 226inline 227sc_concref_r<sc_lv_base,sc_bitref_r<T> > 228operator , ( const sc_logic&, sc_bitref_r<T> ); 229 230template <class T> 231inline 232sc_concref_r<sc_bitref_r<T>,sc_lv_base> 233operator , ( sc_bitref_r<T>, bool ); 234 235template <class T> 236inline 237sc_concref_r<sc_lv_base,sc_bitref_r<T> > 238operator , ( bool, sc_bitref_r<T> ); 239 240 241template <class T1, class T2> 242inline 243sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> > 244concat( sc_bitref_r<T1>, sc_bitref_r<T2> ); 245 246template <class T1, class T2> 247inline 248sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> > 249concat( sc_bitref_r<T1>, sc_subref_r<T2> ); 250 251template <class T1, class T2, class T3> 252inline 253sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> > 254concat( sc_bitref_r<T1>, sc_concref_r<T2,T3> ); 255 256template <class T1, class T2> 257inline 258sc_concref_r<sc_bitref_r<T1>,T2> 259concat( sc_bitref_r<T1>, const sc_proxy<T2>& ); 260 261template <class T> 262inline 263sc_concref_r<sc_bitref_r<T>,sc_lv_base> 264concat( sc_bitref_r<T>, const char* ); 265 266template <class T> 267inline 268sc_concref_r<sc_lv_base,sc_bitref_r<T> > 269concat( const char*, sc_bitref_r<T> ); 270 271template <class T> 272inline 273sc_concref_r<sc_bitref_r<T>,sc_lv_base> 274concat( sc_bitref_r<T>, const sc_logic& ); 275 276template <class T> 277inline 278sc_concref_r<sc_lv_base,sc_bitref_r<T> > 279concat( const sc_logic&, sc_bitref_r<T> ); 280 281template <class T> 282inline 283sc_concref_r<sc_bitref_r<T>,sc_lv_base> 284concat( sc_bitref_r<T>, bool ); 285 286template <class T> 287inline 288sc_concref_r<sc_lv_base,sc_bitref_r<T> > 289concat( bool, sc_bitref_r<T> ); 290 291 292#ifdef SC_DT_MIXED_COMMA_OPERATORS 293 294template <class T1, class T2> 295inline 296sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> > 297operator , ( sc_bitref_r<T1>, sc_bitref<T2> ); 298 299template <class T1, class T2> 300inline 301sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> > 302operator , ( sc_bitref<T1>, sc_bitref_r<T2> ); 303 304template <class T1, class T2> 305inline 306sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> > 307operator , ( sc_bitref_r<T1>, sc_subref<T2> ); 308 309template <class T1, class T2> 310inline 311sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> > 312operator , ( sc_bitref<T1>, sc_subref_r<T2> ); 313 314template <class T1, class T2, class T3> 315inline 316sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> > 317operator , ( sc_bitref_r<T1>, sc_concref<T2,T3> ); 318 319template <class T1, class T2, class T3> 320inline 321sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> > 322operator , ( sc_bitref<T1>, sc_concref_r<T2,T3> ); 323 324template <class T1, class T2> 325inline 326sc_concref_r<sc_bitref_r<T1>,T2> 327operator , ( sc_bitref<T1>, const sc_proxy<T2>& ); 328 329template <class T1, class T2> 330inline 331sc_concref_r<sc_bitref_r<T1>,T2> 332operator , ( sc_bitref_r<T1>, sc_proxy<T2>& ); 333 334template <class T> 335inline 336sc_concref_r<sc_bitref_r<T>,sc_lv_base> 337operator , ( sc_bitref<T>, const char* ); 338 339template <class T> 340inline 341sc_concref_r<sc_lv_base,sc_bitref_r<T> > 342operator , ( const char*, sc_bitref<T> ); 343 344template <class T> 345inline 346sc_concref_r<sc_bitref_r<T>,sc_lv_base> 347operator , ( sc_bitref<T>, const sc_logic& ); 348 349template <class T> 350inline 351sc_concref_r<sc_lv_base,sc_bitref_r<T> > 352operator , ( const sc_logic&, sc_bitref<T> ); 353 354template <class T> 355inline 356sc_concref_r<sc_bitref_r<T>,sc_lv_base> 357operator , ( sc_bitref<T>, bool ); 358 359template <class T> 360inline 361sc_concref_r<sc_lv_base,sc_bitref_r<T> > 362operator , ( bool, sc_bitref<T> ); 363 364 365template <class T1, class T2> 366inline 367sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> > 368concat( sc_bitref_r<T1>, sc_bitref<T2> ); 369 370template <class T1, class T2> 371inline 372sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> > 373concat( sc_bitref<T1>, sc_bitref_r<T2> ); 374 375template <class T1, class T2> 376inline 377sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> > 378concat( sc_bitref_r<T1>, sc_subref<T2> ); 379 380template <class T1, class T2> 381inline 382sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> > 383concat( sc_bitref<T1>, sc_subref_r<T2> ); 384 385template <class T1, class T2, class T3> 386inline 387sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> > 388concat( sc_bitref_r<T1>, sc_concref<T2,T3> ); 389 390template <class T1, class T2, class T3> 391inline 392sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> > 393concat( sc_bitref<T1>, sc_concref_r<T2,T3> ); 394 395template <class T1, class T2> 396inline 397sc_concref_r<sc_bitref_r<T1>,T2> 398concat( sc_bitref<T1>, const sc_proxy<T2>& ); 399 400template <class T1, class T2> 401inline 402sc_concref_r<sc_bitref_r<T1>,T2> 403concat( sc_bitref_r<T1>, sc_proxy<T2>& ); 404 405template <class T> 406inline 407sc_concref_r<sc_bitref_r<T>,sc_lv_base> 408concat( sc_bitref<T>, const char* ); 409 410template <class T> 411inline 412sc_concref_r<sc_lv_base,sc_bitref_r<T> > 413concat( const char*, sc_bitref<T> ); 414 415template <class T> 416inline 417sc_concref_r<sc_bitref_r<T>,sc_lv_base> 418concat( sc_bitref<T>, const sc_logic& ); 419 420template <class T> 421inline 422sc_concref_r<sc_lv_base,sc_bitref_r<T> > 423concat( const sc_logic&, sc_bitref<T> ); 424 425template <class T> 426inline 427sc_concref_r<sc_bitref_r<T>,sc_lv_base> 428concat( sc_bitref<T>, bool ); 429 430template <class T> 431inline 432sc_concref_r<sc_lv_base,sc_bitref_r<T> > 433concat( bool, sc_bitref<T> ); 434 435#endif 436 437 438// ---------------------------------------------------------------------------- 439// CLASS TEMPLATE : sc_bitref<X> 440// 441// Proxy class for sc_proxy bit selection (r-value and l-value). 442// ---------------------------------------------------------------------------- 443 444template <class X> 445class sc_bitref 446 : public sc_bitref_r<X> 447{ 448 friend class sc_bv_base; 449 friend class sc_lv_base; 450 451public: 452 453 // constructor 454 455 sc_bitref( X& obj_, int index_ ) 456 : sc_bitref_r<X>( obj_, index_ ) 457 {} 458 459 460 // copy constructor 461 462 sc_bitref( const sc_bitref<X>& a ) 463 : sc_bitref_r<X>( a ) 464 {} 465 466 467 // cloning 468 469 sc_bitref<X>* clone() const 470 { return new sc_bitref<X>( *this ); } 471 472 473 // assignment operators 474 475 sc_bitref<X>& operator = ( const sc_bitref_r<X>& a ); 476 sc_bitref<X>& operator = ( const sc_bitref<X>& a ); 477 478 sc_bitref<X>& operator = ( const sc_logic& a ) 479 { this->m_obj.set_bit( this->m_index, a.value() ); return *this; } 480 481 sc_bitref<X>& operator = ( sc_logic_value_t v ) 482 { *this = sc_logic( v ); return *this; } 483 484 sc_bitref<X>& operator = ( bool a ) 485 { *this = sc_logic( a ); return *this; } 486 487 sc_bitref<X>& operator = ( char a ) 488 { *this = sc_logic( a ); return *this; } 489 490 sc_bitref<X>& operator = ( int a ) 491 { *this = sc_logic( a ); return *this; } 492 493 sc_bitref<X>& operator = ( const sc_bit& a ) 494 { *this = sc_logic( a ); return *this; } 495 496 497 // bitwise assignment operators 498 499 sc_bitref<X>& operator &= ( const sc_bitref_r<X>& a ); 500 sc_bitref<X>& operator &= ( const sc_logic& a ); 501 502 sc_bitref<X>& operator &= ( sc_logic_value_t v ) 503 { *this &= sc_logic( v ); return *this; } 504 505 sc_bitref<X>& operator &= ( bool a ) 506 { *this &= sc_logic( a ); return *this; } 507 508 sc_bitref<X>& operator &= ( char a ) 509 { *this &= sc_logic( a ); return *this; } 510 511 sc_bitref<X>& operator &= ( int a ) 512 { *this &= sc_logic( a ); return *this; } 513 514 515 sc_bitref<X>& operator |= ( const sc_bitref_r<X>& a ); 516 sc_bitref<X>& operator |= ( const sc_logic& a ); 517 518 sc_bitref<X>& operator |= ( sc_logic_value_t v ) 519 { *this |= sc_logic( v ); return *this; } 520 521 sc_bitref<X>& operator |= ( bool a ) 522 { *this |= sc_logic( a ); return *this; } 523 524 sc_bitref<X>& operator |= ( char a ) 525 { *this |= sc_logic( a ); return *this; } 526 527 sc_bitref<X>& operator |= ( int a ) 528 { *this |= sc_logic( a ); return *this; } 529 530 531 sc_bitref<X>& operator ^= ( const sc_bitref_r<X>& a ); 532 sc_bitref<X>& operator ^= ( const sc_logic& a ); 533 534 sc_bitref<X>& operator ^= ( sc_logic_value_t v ) 535 { *this ^= sc_logic( v ); return *this; } 536 537 sc_bitref<X>& operator ^= ( bool a ) 538 { *this ^= sc_logic( a ); return *this; } 539 540 sc_bitref<X>& operator ^= ( char a ) 541 { *this ^= sc_logic( a ); return *this; } 542 543 sc_bitref<X>& operator ^= ( int a ) 544 { *this ^= sc_logic( a ); return *this; } 545 546 547 // bitwise operators and functions 548 549 // bitwise complement 550 551 sc_bitref<X>& b_not(); 552 553 554 // common methods 555 556 void set_bit( int n, sc_logic_value_t value ); 557 558 void set_word( int i, sc_digit w ); 559 void set_cword( int i, sc_digit w ); 560 561 void clean_tail() 562 { this->m_obj.clean_tail(); } 563 564 565 // other methods 566 567 void scan( ::std::istream& is = ::std::cin ); 568 569private: 570 571 // disabled 572 sc_bitref(); 573}; 574 575 576// l-value concatenation operators and functions 577 578template <class T1, class T2> 579inline 580sc_concref<sc_bitref<T1>,sc_bitref<T2> > 581operator , ( sc_bitref<T1>, sc_bitref<T2> ); 582 583template <class T1, class T2> 584inline 585sc_concref<sc_bitref<T1>,sc_subref<T2> > 586operator , ( sc_bitref<T1>, sc_subref<T2> ); 587 588template <class T1, class T2, class T3> 589inline 590sc_concref<sc_bitref<T1>,sc_concref<T2,T3> > 591operator , ( sc_bitref<T1>, sc_concref<T2,T3> ); 592 593template <class T1, class T2> 594inline 595sc_concref<sc_bitref<T1>,T2> 596operator , ( sc_bitref<T1>, sc_proxy<T2>& ); 597 598 599template <class T1, class T2> 600inline 601sc_concref<sc_bitref<T1>,sc_bitref<T2> > 602concat( sc_bitref<T1>, sc_bitref<T2> ); 603 604template <class T1, class T2> 605inline 606sc_concref<sc_bitref<T1>,sc_subref<T2> > 607concat( sc_bitref<T1>, sc_subref<T2> ); 608 609template <class T1, class T2, class T3> 610inline 611sc_concref<sc_bitref<T1>,sc_concref<T2,T3> > 612concat( sc_bitref<T1>, sc_concref<T2,T3> ); 613 614template <class T1, class T2> 615inline 616sc_concref<sc_bitref<T1>,T2> 617concat( sc_bitref<T1>, sc_proxy<T2>& ); 618 619 620template <class T> 621::std::istream& 622operator >> ( ::std::istream&, sc_bitref<T> ); 623 624 625// ---------------------------------------------------------------------------- 626// CLASS TEMPLATE : sc_subref_r<X> 627// 628// Proxy class for sc_proxy part selection (r-value only). 629// ---------------------------------------------------------------------------- 630 631template <class X> 632class sc_subref_r 633 : public sc_proxy<sc_subref_r<X> > 634{ 635 void check_bounds(); 636 637public: 638 639 // constructor 640 641 sc_subref_r( const X& obj_, int hi_, int lo_ ) 642 : m_obj( CCAST<X&>( obj_ ) ), m_hi( hi_ ), m_lo( lo_ ), m_len( 0 ) 643 { check_bounds(); } 644 645 646 // copy constructor 647 648 sc_subref_r( const sc_subref_r<X>& a ) 649 : m_obj( a.m_obj ), m_hi( a.m_hi ), m_lo( a.m_lo ), m_len( a.m_len ) 650 {} 651 652 653 // cloning 654 655 sc_subref_r<X>* clone() const 656 { return new sc_subref_r<X>( *this ); } 657 658 659 // common methods 660 661 int length() const 662 { return m_len; } 663 664 int size() const 665 { return ( (length() - 1) / SC_DIGIT_SIZE + 1 ); } 666 667 sc_logic_value_t get_bit( int n ) const; 668 void set_bit( int n, sc_logic_value_t value ); 669 670 sc_digit get_word( int i )const; 671 void set_word( int i, sc_digit w ); 672 673 sc_digit get_cword( int i ) const; 674 void set_cword( int i, sc_digit w ); 675 676 void clean_tail() 677 { m_obj.clean_tail(); } 678 679 680 // other methods 681 682 bool is_01() const; 683 684 bool reversed() const 685 { return m_lo > m_hi; } 686 687protected: 688 689 X& m_obj; 690 int m_hi; 691 int m_lo; 692 int m_len; 693 694private: 695 696 // disabled 697 sc_subref_r(); 698 sc_subref_r<X>& operator = ( const sc_subref_r<X>& ); 699}; 700 701 702// r-value concatenation operators and functions 703 704template <class T1, class T2> 705inline 706sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> > 707operator , ( sc_subref_r<T1>, sc_bitref_r<T2> ); 708 709template <class T1, class T2> 710inline 711sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> > 712operator , ( sc_subref_r<T1>, sc_subref_r<T2> ); 713 714template <class T1, class T2, class T3> 715inline 716sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> > 717operator , ( sc_subref_r<T1>, sc_concref_r<T2,T3> ); 718 719template <class T1, class T2> 720inline 721sc_concref_r<sc_subref_r<T1>,T2> 722operator , ( sc_subref_r<T1>, const sc_proxy<T2>& ); 723 724template <class T> 725inline 726sc_concref_r<sc_subref_r<T>,sc_lv_base> 727operator , ( sc_subref_r<T>, const char* ); 728 729template <class T> 730inline 731sc_concref_r<sc_lv_base,sc_subref_r<T> > 732operator , ( const char*, sc_subref_r<T> ); 733 734template <class T> 735inline 736sc_concref_r<sc_subref_r<T>,sc_lv_base> 737operator , ( sc_subref_r<T>, const sc_logic& ); 738 739template <class T> 740inline 741sc_concref_r<sc_lv_base,sc_subref_r<T> > 742operator , ( const sc_logic&, sc_subref_r<T> ); 743 744template <class T> 745inline 746sc_concref_r<sc_subref_r<T>,sc_bv_base> 747operator , ( sc_subref_r<T>, bool ); 748 749template <class T> 750inline 751sc_concref_r<sc_bv_base,sc_subref_r<T> > 752operator , ( bool, sc_subref_r<T> ); 753 754 755template <class T1, class T2> 756inline 757sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> > 758concat( sc_subref_r<T1>, sc_bitref_r<T2> ); 759 760template <class T1, class T2> 761inline 762sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> > 763concat( sc_subref_r<T1>, sc_subref_r<T2> ); 764 765template <class T1, class T2, class T3> 766inline 767sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> > 768concat( sc_subref_r<T1>, sc_concref_r<T2,T3> ); 769 770template <class T1, class T2> 771inline 772sc_concref_r<sc_subref_r<T1>,T2> 773concat( sc_subref_r<T1>, const sc_proxy<T2>& ); 774 775template <class T> 776inline 777sc_concref_r<sc_subref_r<T>,sc_lv_base> 778concat( sc_subref_r<T>, const char* ); 779 780template <class T> 781inline 782sc_concref_r<sc_lv_base,sc_subref_r<T> > 783concat( const char*, sc_subref_r<T> ); 784 785template <class T> 786inline 787sc_concref_r<sc_subref_r<T>,sc_lv_base> 788concat( sc_subref_r<T>, const sc_logic& ); 789 790template <class T> 791inline 792sc_concref_r<sc_lv_base,sc_subref_r<T> > 793concat( const sc_logic&, sc_subref_r<T> ); 794 795template <class T> 796inline 797sc_concref_r<sc_subref_r<T>,sc_bv_base> 798concat( sc_subref_r<T>, bool ); 799 800template <class T> 801inline 802sc_concref_r<sc_bv_base,sc_subref_r<T> > 803concat( bool, sc_subref_r<T> ); 804 805 806#ifdef SC_DT_MIXED_COMMA_OPERATORS 807 808template <class T1, class T2> 809inline 810sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> > 811operator , ( sc_subref_r<T1>, sc_bitref<T2> ); 812 813template <class T1, class T2> 814inline 815sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> > 816operator , ( sc_subref<T1>, sc_bitref_r<T2> ); 817 818template <class T1, class T2> 819inline 820sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> > 821operator , ( sc_subref_r<T1>, sc_subref<T2> ); 822 823template <class T1, class T2> 824inline 825sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> > 826operator , ( sc_subref<T1>, sc_subref_r<T2> ); 827 828template <class T1, class T2, class T3> 829inline 830sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> > 831operator , ( sc_subref_r<T1>, sc_concref<T2,T3> ); 832 833template <class T1, class T2, class T3> 834inline 835sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> > 836operator , ( sc_subref<T1>, sc_concref_r<T2,T3> ); 837 838template <class T1, class T2> 839inline 840sc_concref_r<sc_subref_r<T1>,T2> 841operator , ( sc_subref<T1>, const sc_proxy<T2>& ); 842 843template <class T1, class T2> 844inline 845sc_concref_r<sc_subref_r<T1>,T2> 846operator , ( sc_subref_r<T1>, sc_proxy<T2>& ); 847 848template <class T> 849inline 850sc_concref_r<sc_subref_r<T>,sc_lv_base> 851operator , ( sc_subref<T>, const char* ); 852 853template <class T> 854inline 855sc_concref_r<sc_lv_base,sc_subref_r<T> > 856operator , ( const char*, sc_subref<T> ); 857 858template <class T> 859inline 860sc_concref_r<sc_subref_r<T>,sc_lv_base> 861operator , ( sc_subref<T>, const sc_logic& ); 862 863template <class T> 864inline 865sc_concref_r<sc_lv_base,sc_subref_r<T> > 866operator , ( const sc_logic&, sc_subref<T> ); 867 868template <class T> 869inline 870sc_concref_r<sc_subref_r<T>,sc_bv_base> 871operator , ( sc_subref<T>, bool ); 872 873template <class T> 874inline 875sc_concref_r<sc_bv_base,sc_subref_r<T> > 876operator , ( bool, sc_subref<T> ); 877 878 879template <class T1, class T2> 880inline 881sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> > 882concat( sc_subref_r<T1>, sc_bitref<T2> ); 883 884template <class T1, class T2> 885inline 886sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> > 887concat( sc_subref<T1>, sc_bitref_r<T2> ); 888 889template <class T1, class T2> 890inline 891sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> > 892concat( sc_subref_r<T1>, sc_subref<T2> ); 893 894template <class T1, class T2> 895inline 896sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> > 897concat( sc_subref<T1>, sc_subref_r<T2> ); 898 899template <class T1, class T2, class T3> 900inline 901sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> > 902concat( sc_subref_r<T1>, sc_concref<T2,T3> ); 903 904template <class T1, class T2, class T3> 905inline 906sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> > 907concat( sc_subref<T1>, sc_concref_r<T2,T3> ); 908 909template <class T1, class T2> 910inline 911sc_concref_r<sc_subref_r<T1>,T2> 912concat( sc_subref<T1>, const sc_proxy<T2>& ); 913 914template <class T1, class T2> 915inline 916sc_concref_r<sc_subref_r<T1>,T2> 917concat( sc_subref_r<T1>, sc_proxy<T2>& ); 918 919template <class T> 920inline 921sc_concref_r<sc_subref_r<T>,sc_lv_base> 922concat( sc_subref<T>, const char* ); 923 924template <class T> 925inline 926sc_concref_r<sc_lv_base,sc_subref_r<T> > 927concat( const char*, sc_subref<T> ); 928 929template <class T> 930inline 931sc_concref_r<sc_subref_r<T>,sc_lv_base> 932concat( sc_subref<T>, const sc_logic& ); 933 934template <class T> 935inline 936sc_concref_r<sc_lv_base,sc_subref_r<T> > 937concat( const sc_logic&, sc_subref<T> ); 938 939template <class T> 940inline 941sc_concref_r<sc_subref_r<T>,sc_bv_base> 942concat( sc_subref<T>, bool ); 943 944template <class T> 945inline 946sc_concref_r<sc_bv_base,sc_subref_r<T> > 947concat( bool, sc_subref<T> ); 948 949#endif 950 951 952// ---------------------------------------------------------------------------- 953// CLASS TEMPLATE : sc_subref<X> 954// 955// Proxy class for sc_proxy part selection (r-value and l-value). 956// ---------------------------------------------------------------------------- 957 958template <class X> 959class sc_subref 960 : public sc_subref_r<X> 961{ 962public: 963 964 // typedefs 965 966 typedef sc_subref_r<X> base_type; 967 968 969 // constructor 970 971 sc_subref( X& obj_, int hi_, int lo_ ) 972 : sc_subref_r<X>( obj_, hi_, lo_ ) 973 {} 974 975 976 // copy constructor 977 978 sc_subref( const sc_subref<X>& a ) 979 : sc_subref_r<X>( a ) 980 {} 981 982 983 // cloning 984 985 sc_subref<X>* clone() const 986 { return new sc_subref<X>( *this ); } 987 988 989 // assignment operators 990 991 template <class Y> 992 sc_subref<X>& operator = ( const sc_proxy<Y>& a ) 993 { base_type::assign_( a ); return *this; } 994 995 sc_subref<X>& operator = ( const sc_subref_r<X>& a ); 996 sc_subref<X>& operator = ( const sc_subref<X>& a ); 997 998 sc_subref<X>& operator = ( const char* a ) 999 { base_type::assign_( a ); return *this; } 1000 1001 sc_subref<X>& operator = ( const bool* a ) 1002 { base_type::assign_( a ); return *this; } 1003 1004 sc_subref<X>& operator = ( const sc_logic* a ) 1005 { base_type::assign_( a ); return *this; } 1006 1007 sc_subref<X>& operator = ( const sc_unsigned& a ) 1008 { base_type::assign_( a ); return *this; } 1009 1010 sc_subref<X>& operator = ( const sc_signed& a ) 1011 { base_type::assign_( a ); return *this; } 1012 1013 sc_subref<X>& operator = ( const sc_uint_base& a ) 1014 { base_type::assign_( a ); return *this; } 1015 1016 sc_subref<X>& operator = ( const sc_int_base& a ) 1017 { base_type::assign_( a ); return *this; } 1018 1019 sc_subref<X>& operator = ( unsigned long a ) 1020 { base_type::assign_( a ); return *this; } 1021 1022 sc_subref<X>& operator = ( long a ) 1023 { base_type::assign_( a ); return *this; } 1024 1025 sc_subref<X>& operator = ( unsigned int a ) 1026 { base_type::assign_( a ); return *this; } 1027 1028 sc_subref<X>& operator = ( int a ) 1029 { base_type::assign_( a ); return *this; } 1030 1031 sc_subref<X>& operator = ( uint64 a ) 1032 { base_type::assign_( a ); return *this; } 1033 1034 sc_subref<X>& operator = ( int64 a ) 1035 { base_type::assign_( a ); return *this; } 1036 1037 1038 // other methods 1039 1040 void scan( ::std::istream& = ::std::cin ); 1041 1042private: 1043 1044 // disabled 1045 sc_subref(); 1046}; 1047 1048 1049// l-value concatenation operators and functions 1050 1051template <class T1, class T2> 1052inline 1053sc_concref<sc_subref<T1>,sc_bitref<T2> > 1054operator , ( sc_subref<T1>, sc_bitref<T2> ); 1055 1056template <class T1, class T2> 1057inline 1058sc_concref<sc_subref<T1>,sc_subref<T2> > 1059operator , ( sc_subref<T1>, sc_subref<T2> ); 1060 1061template <class T1, class T2, class T3> 1062inline 1063sc_concref<sc_subref<T1>,sc_concref<T2,T3> > 1064operator , ( sc_subref<T1>, sc_concref<T2,T3> ); 1065 1066template <class T1, class T2> 1067inline 1068sc_concref<sc_subref<T1>,T2> 1069operator , ( sc_subref<T1>, sc_proxy<T2>& ); 1070 1071 1072template <class T1, class T2> 1073inline 1074sc_concref<sc_subref<T1>,sc_bitref<T2> > 1075concat( sc_subref<T1>, sc_bitref<T2> ); 1076 1077template <class T1, class T2> 1078inline 1079sc_concref<sc_subref<T1>,sc_subref<T2> > 1080concat( sc_subref<T1>, sc_subref<T2> ); 1081 1082template <class T1, class T2, class T3> 1083inline 1084sc_concref<sc_subref<T1>,sc_concref<T2,T3> > 1085concat( sc_subref<T1>, sc_concref<T2,T3> ); 1086 1087template <class T1, class T2> 1088inline 1089sc_concref<sc_subref<T1>,T2> 1090concat( sc_subref<T1>, sc_proxy<T2>& ); 1091 1092 1093template <class T> 1094inline 1095::std::istream& 1096operator >> ( ::std::istream&, sc_subref<T> ); 1097 1098 1099// ---------------------------------------------------------------------------- 1100// CLASS TEMPLATE : sc_concref_r<X,Y> 1101// 1102// Proxy class for sc_proxy concatenation (r-value only). 1103// ---------------------------------------------------------------------------- 1104 1105template <class X, class Y> 1106class sc_concref_r 1107 : public sc_proxy<sc_concref_r<X,Y> > 1108{ 1109public: 1110 1111 // constructor 1112 1113 sc_concref_r( const X& left_, const Y& right_, int delete_ = 0 ) 1114 : m_left( CCAST<X&>( left_ ) ), m_right( CCAST<Y&>( right_ ) ), 1115 m_delete( delete_ ), m_refs( *new int( 1 ) ) 1116 {} 1117 1118 1119 // copy constructor 1120 1121 sc_concref_r( const sc_concref_r<X,Y>& a ) 1122 : m_left( a.m_left ), m_right( a.m_right ), 1123 m_delete( a.m_delete ), m_refs( a.m_refs ) 1124 { ++ m_refs; } 1125 1126 1127 // destructor 1128 1129 virtual ~sc_concref_r(); 1130 1131 1132 // cloning 1133 1134 sc_concref_r<X,Y>* clone() const 1135 { return new sc_concref_r<X,Y>( *this ); } 1136 1137 1138 // common methods 1139 1140 int length() const 1141 { return ( m_left.length() + m_right.length() ); } 1142 1143 int size() const 1144 { return ( (length() - 1) / SC_DIGIT_SIZE + 1 ); } 1145 1146 sc_logic_value_t get_bit( int n ) const; 1147 void set_bit( int n, sc_logic_value_t value ); 1148 1149 sc_digit get_word( int i ) const; 1150 void set_word( int i, sc_digit w ); 1151 1152 sc_digit get_cword( int i ) const; 1153 void set_cword( int i, sc_digit w ); 1154 1155 void clean_tail() 1156 { m_left.clean_tail(); m_right.clean_tail(); } 1157 1158 1159 // other methods 1160 1161 bool is_01() const 1162 { return ( m_left.is_01() && m_right.is_01() ); } 1163 1164protected: 1165 1166 X& m_left; 1167 Y& m_right; 1168 mutable int m_delete; 1169 int& m_refs; 1170 1171private: 1172 1173 // disabled 1174 sc_concref_r(); 1175 sc_concref_r<X,Y>& operator = ( const sc_concref_r<X,Y>& ); 1176}; 1177 1178 1179// r-value concatenation operators and functions 1180 1181template <class T1, class T2, class T3> 1182inline 1183sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> > 1184operator , ( sc_concref_r<T1,T2>, sc_bitref_r<T3> ); 1185 1186template <class T1, class T2, class T3> 1187inline 1188sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> > 1189operator , ( sc_concref_r<T1,T2>, sc_subref_r<T3> ); 1190 1191template <class T1, class T2, class T3, class T4> 1192inline 1193sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> > 1194operator , ( sc_concref_r<T1,T2>, sc_concref_r<T3,T4> ); 1195 1196template <class T1, class T2, class T3> 1197inline 1198sc_concref_r<sc_concref_r<T1,T2>,T3> 1199operator , ( sc_concref_r<T1,T2>, const sc_proxy<T3>& ); 1200 1201template <class T1, class T2> 1202inline 1203sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base> 1204operator , ( sc_concref_r<T1,T2>, const char* ); 1205 1206template <class T1, class T2> 1207inline 1208sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> > 1209operator , ( const char*, sc_concref_r<T1,T2> ); 1210 1211template <class T1, class T2> 1212inline 1213sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base> 1214operator , ( sc_concref_r<T1,T2>, const sc_logic& ); 1215 1216template <class T1, class T2> 1217inline 1218sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> > 1219operator , ( const sc_logic&, sc_concref_r<T1,T2> ); 1220 1221template <class T1, class T2> 1222inline 1223sc_concref_r<sc_concref_r<T1,T2>,sc_bv_base> 1224operator , ( sc_concref_r<T1,T2>, bool ); 1225 1226template <class T1, class T2> 1227inline 1228sc_concref_r<sc_bv_base,sc_concref_r<T1,T2> > 1229operator , ( bool, sc_concref_r<T1,T2> ); 1230 1231 1232template <class T1, class T2, class T3> 1233inline 1234sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> > 1235concat( sc_concref_r<T1,T2>, sc_bitref_r<T3> ); 1236 1237template <class T1, class T2, class T3> 1238inline 1239sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> > 1240concat( sc_concref_r<T1,T2>, sc_subref_r<T3> ); 1241 1242template <class T1, class T2, class T3, class T4> 1243inline 1244sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> > 1245concat( sc_concref_r<T1,T2>, sc_concref_r<T3,T4> ); 1246 1247template <class T1, class T2, class T3> 1248inline 1249sc_concref_r<sc_concref_r<T1,T2>,T3> 1250concat( sc_concref_r<T1,T2>, const sc_proxy<T3>& ); 1251 1252template <class T1, class T2> 1253inline 1254sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base> 1255concat( sc_concref_r<T1,T2>, const char* ); 1256 1257template <class T1, class T2> 1258inline 1259sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> > 1260concat( const char*, sc_concref_r<T1,T2> ); 1261 1262template <class T1, class T2> 1263inline 1264sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base> 1265concat( sc_concref_r<T1,T2>, const sc_logic& ); 1266 1267template <class T1, class T2> 1268inline 1269sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> > 1270concat( const sc_logic&, sc_concref_r<T1,T2> ); 1271 1272template <class T1, class T2> 1273inline 1274sc_concref_r<sc_concref_r<T1,T2>,sc_bv_base> 1275concat( sc_concref_r<T1,T2>, bool ); 1276 1277template <class T1, class T2> 1278inline 1279sc_concref_r<sc_bv_base,sc_concref_r<T1,T2> > 1280concat( bool, sc_concref_r<T1,T2> ); 1281 1282 1283#ifdef SC_DT_MIXED_COMMA_OPERATORS 1284 1285template <class T1, class T2, class T3> 1286inline 1287sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> > 1288operator , ( sc_concref_r<T1,T2>, sc_bitref<T3> ); 1289 1290template <class T1, class T2, class T3> 1291inline 1292sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> > 1293operator , ( sc_concref<T1,T2>, sc_bitref_r<T3> ); 1294 1295template <class T1, class T2, class T3> 1296inline 1297sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> > 1298operator , ( sc_concref_r<T1,T2>, sc_subref<T3> ); 1299 1300template <class T1, class T2, class T3> 1301inline 1302sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> > 1303operator , ( sc_concref<T1,T2>, sc_subref_r<T3> ); 1304 1305template <class T1, class T2, class T3, class T4> 1306inline 1307sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> > 1308operator , ( sc_concref_r<T1,T2>, sc_concref<T3,T4> ); 1309 1310template <class T1, class T2, class T3, class T4> 1311inline 1312sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> > 1313operator , ( sc_concref<T1,T2>, sc_concref_r<T3,T4> ); 1314 1315template <class T1, class T2, class T3> 1316inline 1317sc_concref_r<sc_concref_r<T1,T2>,T3> 1318operator , ( sc_concref<T1,T2>, const sc_proxy<T3>& ); 1319 1320template <class T1, class T2, class T3> 1321inline 1322sc_concref_r<sc_concref_r<T1,T2>,T3> 1323operator , ( sc_concref_r<T1,T2>, sc_proxy<T3>& ); 1324 1325template <class T1, class T2> 1326inline 1327sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base> 1328operator , ( sc_concref<T1,T2>, const char* ); 1329 1330template <class T1, class T2> 1331inline 1332sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> > 1333operator , ( const char*, sc_concref<T1,T2> ); 1334 1335template <class T1, class T2> 1336inline 1337sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base> 1338operator , ( sc_concref<T1,T2>, const sc_logic& ); 1339 1340template <class T1, class T2> 1341inline 1342sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> > 1343operator , ( const sc_logic&, sc_concref<T1,T2> ); 1344 1345template <class T1, class T2> 1346inline 1347sc_concref_r<sc_concref_r<T1,T2>,sc_bv_base> 1348operator , ( sc_concref<T1,T2>, bool ); 1349 1350template <class T1, class T2> 1351inline 1352sc_concref_r<sc_bv_base,sc_concref_r<T1,T2> > 1353operator , ( bool, sc_concref<T1,T2> ); 1354 1355 1356template <class T1, class T2, class T3> 1357inline 1358sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> > 1359concat( sc_concref_r<T1,T2>, sc_bitref<T3> ); 1360 1361template <class T1, class T2, class T3> 1362inline 1363sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> > 1364concat( sc_concref<T1,T2>, sc_bitref_r<T3> ); 1365 1366template <class T1, class T2, class T3> 1367inline 1368sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> > 1369concat( sc_concref_r<T1,T2>, sc_subref<T3> ); 1370 1371template <class T1, class T2, class T3> 1372inline 1373sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> > 1374concat( sc_concref<T1,T2>, sc_subref_r<T3> ); 1375 1376template <class T1, class T2, class T3, class T4> 1377inline 1378sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> > 1379concat( sc_concref_r<T1,T2>, sc_concref<T3,T4> ); 1380 1381template <class T1, class T2, class T3, class T4> 1382inline 1383sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> > 1384concat( sc_concref<T1,T2>, sc_concref_r<T3,T4> ); 1385 1386template <class T1, class T2, class T3> 1387inline 1388sc_concref_r<sc_concref_r<T1,T2>,T3> 1389concat( sc_concref<T1,T2>, const sc_proxy<T3>& ); 1390 1391template <class T1, class T2, class T3> 1392inline 1393sc_concref_r<sc_concref_r<T1,T2>,T3> 1394concat( sc_concref_r<T1,T2>, sc_proxy<T3>& ); 1395 1396template <class T1, class T2> 1397inline 1398sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base> 1399concat( sc_concref<T1,T2>, const char* ); 1400 1401template <class T1, class T2> 1402inline 1403sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> > 1404concat( const char*, sc_concref<T1,T2> ); 1405 1406template <class T1, class T2> 1407inline 1408sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base> 1409concat( sc_concref<T1,T2>, const sc_logic& ); 1410 1411template <class T1, class T2> 1412inline 1413sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> > 1414concat( const sc_logic&, sc_concref<T1,T2> ); 1415 1416template <class T1, class T2> 1417inline 1418sc_concref_r<sc_concref_r<T1,T2>,sc_bv_base> 1419concat( sc_concref<T1,T2>, bool ); 1420 1421template <class T1, class T2> 1422inline 1423sc_concref_r<sc_bv_base,sc_concref_r<T1,T2> > 1424concat( bool, sc_concref<T1,T2> ); 1425 1426#endif 1427 1428 1429// ---------------------------------------------------------------------------- 1430// CLASS TEMPLATE : sc_concref<X,Y> 1431// 1432// Proxy class for sc_proxy concatenation (r-value and l-value). 1433// ---------------------------------------------------------------------------- 1434 1435template <class X, class Y> 1436class sc_concref 1437 : public sc_concref_r<X,Y> 1438{ 1439public: 1440 1441 // typedefs 1442 1443 typedef sc_concref_r<X,Y> base_type; 1444 1445 1446 // constructor 1447 1448 sc_concref( X& left_, Y& right_, int delete_ = 0 ) 1449 : sc_concref_r<X,Y>( left_, right_, delete_ ) 1450 {} 1451 1452 1453 // copy constructor 1454 1455 sc_concref( const sc_concref<X,Y>& a ) 1456 : sc_concref_r<X,Y>( a ) 1457 {} 1458 1459 1460 // cloning 1461 1462 sc_concref<X,Y>* clone() const 1463 { return new sc_concref<X,Y>( *this ); } 1464 1465 1466 // assignment operators 1467 1468 template <class Z> 1469 sc_concref<X,Y>& operator = ( const sc_proxy<Z>& a ) 1470 { base_type::assign_( a ); return *this; } 1471 1472 sc_concref<X,Y>& operator = ( const sc_concref<X,Y>& a ) 1473 { base_type::assign_( a ); return *this; } 1474 1475 sc_concref<X,Y>& operator = ( const char* a ) 1476 { base_type::assign_( a ); return *this; } 1477 1478 sc_concref<X,Y>& operator = ( const bool* a ) 1479 { base_type::assign_( a ); return *this; } 1480 1481 sc_concref<X,Y>& operator = ( const sc_logic* a ) 1482 { base_type::assign_( a ); return *this; } 1483 1484 sc_concref<X,Y>& operator = ( const sc_unsigned& a ) 1485 { base_type::assign_( a ); return *this; } 1486 1487 sc_concref<X,Y>& operator = ( const sc_signed& a ) 1488 { base_type::assign_( a ); return *this; } 1489 1490 sc_concref<X,Y>& operator = ( const sc_uint_base& a ) 1491 { base_type::assign_( a ); return *this; } 1492 1493 sc_concref<X,Y>& operator = ( const sc_int_base& a ) 1494 { base_type::assign_( a ); return *this; } 1495 1496 sc_concref<X,Y>& operator = ( unsigned long a ) 1497 { base_type::assign_( a ); return *this; } 1498 1499 sc_concref<X,Y>& operator = ( long a ) 1500 { base_type::assign_( a ); return *this; } 1501 1502 sc_concref<X,Y>& operator = ( unsigned int a ) 1503 { base_type::assign_( a ); return *this; } 1504 1505 sc_concref<X,Y>& operator = ( int a ) 1506 { base_type::assign_( a ); return *this; } 1507 1508 sc_concref<X,Y>& operator = ( uint64 a ) 1509 { base_type::assign_( a ); return *this; } 1510 1511 sc_concref<X,Y>& operator = ( int64 a ) 1512 { base_type::assign_( a ); return *this; } 1513 1514 1515 // other methods 1516 1517 void scan( ::std::istream& = ::std::cin ); 1518 1519private: 1520 1521 // disabled 1522 sc_concref(); 1523}; 1524 1525 1526// l-value concatenation operators and functions 1527 1528template <class T1, class T2, class T3> 1529inline 1530sc_concref<sc_concref<T1,T2>,sc_bitref<T3> > 1531operator , ( sc_concref<T1,T2>, sc_bitref<T3> ); 1532 1533template <class T1, class T2, class T3> 1534inline 1535sc_concref<sc_concref<T1,T2>,sc_subref<T3> > 1536operator , ( sc_concref<T1,T2>, sc_subref<T3> ); 1537 1538template <class T1, class T2, class T3, class T4> 1539inline 1540sc_concref<sc_concref<T1,T2>,sc_concref<T3,T4> > 1541operator , ( sc_concref<T1,T2>, sc_concref<T3,T4> ); 1542 1543template <class T1, class T2, class T3> 1544inline 1545sc_concref<sc_concref<T1,T2>,T3> 1546operator , ( sc_concref<T1,T2>, sc_proxy<T3>& ); 1547 1548 1549template <class T1, class T2, class T3> 1550inline 1551sc_concref<sc_concref<T1,T2>,sc_bitref<T3> > 1552concat( sc_concref<T1,T2>, sc_bitref<T3> ); 1553 1554template <class T1, class T2, class T3> 1555inline 1556sc_concref<sc_concref<T1,T2>,sc_subref<T3> > 1557concat( sc_concref<T1,T2>, sc_subref<T3> ); 1558 1559template <class T1, class T2, class T3, class T4> 1560inline 1561sc_concref<sc_concref<T1,T2>,sc_concref<T3,T4> > 1562concat( sc_concref<T1,T2>, sc_concref<T3,T4> ); 1563 1564template <class T1, class T2, class T3> 1565inline 1566sc_concref<sc_concref<T1,T2>,T3> 1567concat( sc_concref<T1,T2>, sc_proxy<T3>& ); 1568 1569 1570template <class T1, class T2> 1571inline 1572::std::istream& 1573operator >> ( ::std::istream&, sc_concref<T1,T2> ); 1574 1575 1576// ---------------------------------------------------------------------------- 1577// CLASS TEMPLATE : sc_proxy<T> 1578// 1579// Base class template for bit/logic vector classes. 1580// (Barton/Nackmann implementation) 1581// ---------------------------------------------------------------------------- 1582 1583// r-value concatenation operators and functions 1584 1585template <class T1, class T2> 1586inline 1587sc_concref_r<T1,sc_bitref_r<T2> > 1588operator , ( const sc_proxy<T1>&, sc_bitref_r<T2> ); 1589 1590template <class T1, class T2> 1591inline 1592sc_concref_r<T1,sc_subref_r<T2> > 1593operator , ( const sc_proxy<T1>&, sc_subref_r<T2> ); 1594 1595template <class T1, class T2, class T3> 1596inline 1597sc_concref_r<T1,sc_concref_r<T2,T3> > 1598operator , ( const sc_proxy<T1>&, sc_concref_r<T2,T3> ); 1599 1600template <class T1, class T2> 1601inline 1602sc_concref_r<T1,T2> 1603operator , ( const sc_proxy<T1>&, const sc_proxy<T2>& ); 1604 1605template <class T> 1606inline 1607sc_concref_r<T,sc_lv_base> 1608operator , ( const sc_proxy<T>&, const char* ); 1609 1610template <class T> 1611inline 1612sc_concref_r<sc_lv_base,T> 1613operator , ( const char*, const sc_proxy<T>& ); 1614 1615template <class T> 1616inline 1617sc_concref_r<T,sc_lv_base> 1618operator , ( const sc_proxy<T>&, const sc_logic& ); 1619 1620template <class T> 1621inline 1622sc_concref_r<sc_lv_base,T> 1623operator , ( const sc_logic&, const sc_proxy<T>& ); 1624 1625template <class T> 1626inline 1627sc_concref_r<T,sc_bv_base> 1628operator , ( const sc_proxy<T>&, bool ); 1629 1630template <class T> 1631inline 1632sc_concref_r<sc_bv_base,T> 1633operator , ( bool, const sc_proxy<T>& ); 1634 1635 1636template <class T1, class T2> 1637inline 1638sc_concref_r<T1,sc_bitref_r<T2> > 1639concat( const sc_proxy<T1>&, sc_bitref_r<T2> ); 1640 1641template <class T1, class T2> 1642inline 1643sc_concref_r<T1,sc_subref_r<T2> > 1644concat( const sc_proxy<T1>&, sc_subref_r<T2> ); 1645 1646template <class T1, class T2, class T3> 1647inline 1648sc_concref_r<T1,sc_concref_r<T2,T3> > 1649concat( const sc_proxy<T1>&, sc_concref_r<T2,T3> ); 1650 1651template <class T1, class T2> 1652inline 1653sc_concref_r<T1,T2> 1654concat( const sc_proxy<T1>&, const sc_proxy<T2>& ); 1655 1656template <class T> 1657inline 1658sc_concref_r<T,sc_lv_base> 1659concat( const sc_proxy<T>&, const char* ); 1660 1661template <class T> 1662inline 1663sc_concref_r<sc_lv_base,T> 1664concat( const char*, const sc_proxy<T>& ); 1665 1666template <class T> 1667inline 1668sc_concref_r<T,sc_lv_base> 1669concat( const sc_proxy<T>&, const sc_logic& ); 1670 1671template <class T> 1672inline 1673sc_concref_r<sc_lv_base,T> 1674concat( const sc_logic&, const sc_proxy<T>& ); 1675 1676template <class T> 1677inline 1678sc_concref_r<T,sc_bv_base> 1679concat( const sc_proxy<T>&, bool ); 1680 1681template <class T> 1682inline 1683sc_concref_r<sc_bv_base,T> 1684concat( bool, const sc_proxy<T>& ); 1685 1686 1687#ifdef SC_DT_MIXED_COMMA_OPERATORS 1688 1689template <class T1, class T2> 1690inline 1691sc_concref_r<T1,sc_bitref_r<T2> > 1692operator , ( const sc_proxy<T1>&, sc_bitref<T2> ); 1693 1694template <class T1, class T2> 1695inline 1696sc_concref_r<T1,sc_bitref_r<T2> > 1697operator , ( sc_proxy<T1>&, sc_bitref_r<T2> ); 1698 1699template <class T1, class T2> 1700inline 1701sc_concref_r<T1,sc_subref_r<T2> > 1702operator , ( const sc_proxy<T1>&, sc_subref<T2> ); 1703 1704template <class T1, class T2> 1705inline 1706sc_concref_r<T1,sc_subref_r<T2> > 1707operator , ( sc_proxy<T1>&, sc_subref_r<T2> ); 1708 1709template <class T1, class T2, class T3> 1710inline 1711sc_concref_r<T1,sc_concref_r<T2,T3> > 1712operator , ( const sc_proxy<T1>&, sc_concref<T2,T3> ); 1713 1714template <class T1, class T2, class T3> 1715inline 1716sc_concref_r<T1,sc_concref_r<T2,T3> > 1717operator , ( sc_proxy<T1>&, sc_concref_r<T2,T3> ); 1718 1719template <class T1, class T2> 1720inline 1721sc_concref_r<T1,T2> 1722operator , ( const sc_proxy<T1>&, sc_proxy<T2>& ); 1723 1724template <class T1, class T2> 1725inline 1726sc_concref_r<T1,T2> 1727operator , ( sc_proxy<T1>&, const sc_proxy<T2>& ); 1728 1729template <class T> 1730inline 1731sc_concref_r<T,sc_lv_base> 1732operator , ( sc_proxy<T>&, const char* ); 1733 1734template <class T> 1735inline 1736sc_concref_r<sc_lv_base,T> 1737operator , ( const char*, sc_proxy<T>& ); 1738 1739template <class T> 1740inline 1741sc_concref_r<T,sc_lv_base> 1742operator , ( sc_proxy<T>&, const sc_logic& ); 1743 1744template <class T> 1745inline 1746sc_concref_r<sc_lv_base,T> 1747operator , ( const sc_logic&, sc_proxy<T>& ); 1748 1749template <class T> 1750inline 1751sc_concref_r<T,sc_bv_base> 1752operator , ( sc_proxy<T>&, bool ); 1753 1754template <class T> 1755inline 1756sc_concref_r<sc_bv_base,T> 1757operator , ( bool, sc_proxy<T>& ); 1758 1759 1760template <class T1, class T2> 1761inline 1762sc_concref_r<T1,sc_bitref_r<T2> > 1763concat( const sc_proxy<T1>&, sc_bitref<T2> ); 1764 1765template <class T1, class T2> 1766inline 1767sc_concref_r<T1,sc_bitref_r<T2> > 1768concat( sc_proxy<T1>&, sc_bitref_r<T2> ); 1769 1770template <class T1, class T2> 1771inline 1772sc_concref_r<T1,sc_subref_r<T2> > 1773concat( const sc_proxy<T1>&, sc_subref<T2> ); 1774 1775template <class T1, class T2> 1776inline 1777sc_concref_r<T1,sc_subref_r<T2> > 1778concat( sc_proxy<T1>&, sc_subref_r<T2> ); 1779 1780template <class T1, class T2, class T3> 1781inline 1782sc_concref_r<T1,sc_concref_r<T2,T3> > 1783concat( const sc_proxy<T1>&, sc_concref<T2,T3> ); 1784 1785template <class T1, class T2, class T3> 1786inline 1787sc_concref_r<T1,sc_concref_r<T2,T3> > 1788concat( sc_proxy<T1>&, sc_concref_r<T2,T3> ); 1789 1790template <class T1, class T2> 1791inline 1792sc_concref_r<T1,T2> 1793concat( const sc_proxy<T1>&, sc_proxy<T2>& ); 1794 1795template <class T1, class T2> 1796inline 1797sc_concref_r<T1,T2> 1798concat( sc_proxy<T1>&, const sc_proxy<T2>& ); 1799 1800template <class T> 1801inline 1802sc_concref_r<T,sc_lv_base> 1803concat( sc_proxy<T>&, const char* ); 1804 1805template <class T> 1806inline 1807sc_concref_r<sc_lv_base,T> 1808concat( const char*, sc_proxy<T>& ); 1809 1810template <class T> 1811inline 1812sc_concref_r<T,sc_lv_base> 1813concat( sc_proxy<T>&, const sc_logic& ); 1814 1815template <class T> 1816inline 1817sc_concref_r<sc_lv_base,T> 1818concat( const sc_logic&, sc_proxy<T>& ); 1819 1820template <class T> 1821inline 1822sc_concref_r<T,sc_bv_base> 1823concat( sc_proxy<T>&, bool ); 1824 1825template <class T> 1826inline 1827sc_concref_r<sc_bv_base,T> 1828concat( bool, sc_proxy<T>& ); 1829 1830#endif 1831 1832 1833// l-value concatenation operators and functions 1834 1835template <class T1, class T2> 1836inline 1837sc_concref<T1,sc_bitref<T2> > 1838operator , ( sc_proxy<T1>&, sc_bitref<T2> ); 1839 1840template <class T1, class T2> 1841inline 1842sc_concref<T1,sc_subref<T2> > 1843operator , ( sc_proxy<T1>&, sc_subref<T2> ); 1844 1845template <class T1, class T2, class T3> 1846inline 1847sc_concref<T1,sc_concref<T2,T3> > 1848operator , ( sc_proxy<T1>&, sc_concref<T2,T3> ); 1849 1850template <class T1, class T2> 1851inline 1852sc_concref<T1,T2> 1853operator , ( sc_proxy<T1>&, sc_proxy<T2>& ); 1854 1855 1856template <class T1, class T2> 1857inline 1858sc_concref<T1,sc_bitref<T2> > 1859concat( sc_proxy<T1>&, sc_bitref<T2> ); 1860 1861template <class T1, class T2> 1862inline 1863sc_concref<T1,sc_subref<T2> > 1864concat( sc_proxy<T1>&, sc_subref<T2> ); 1865 1866template <class T1, class T2, class T3> 1867inline 1868sc_concref<T1,sc_concref<T2,T3> > 1869concat( sc_proxy<T1>&, sc_concref<T2,T3> ); 1870 1871template <class T1, class T2> 1872inline 1873sc_concref<T1,T2> 1874concat( sc_proxy<T1>&, sc_proxy<T2>& ); 1875 1876 1877// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII 1878 1879// ---------------------------------------------------------------------------- 1880// CLASS TEMPLATE : sc_bitref_r<T> 1881// 1882// Proxy class for sc_proxy bit selection (r-value only). 1883// ---------------------------------------------------------------------------- 1884 1885// bitwise operators and functions 1886 1887// bitwise and 1888 1889template <class T1, class T2> 1890inline 1891const sc_logic 1892operator & ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b ) 1893{ 1894 return sc_logic( sc_logic::and_table[a.value()][b.value()] ); 1895} 1896 1897 1898// bitwise or 1899 1900template <class T1, class T2> 1901inline 1902const sc_logic 1903operator | ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b ) 1904{ 1905 return sc_logic( sc_logic::or_table[a.value()][b.value()] ); 1906} 1907 1908 1909// bitwise xor 1910 1911template <class T1, class T2> 1912inline 1913const sc_logic 1914operator ^ ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b ) 1915{ 1916 return sc_logic( sc_logic::xor_table[a.value()][b.value()] ); 1917} 1918 1919 1920// relational operators and functions 1921 1922template <class T1, class T2> 1923inline 1924bool 1925operator == ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b ) 1926{ 1927 return ( (int) a.value() == b.value() ); 1928} 1929 1930template <class T1, class T2> 1931inline 1932bool 1933operator != ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b ) 1934{ 1935 return ( (int) a.value() != b.value() ); 1936} 1937 1938 1939// common methods 1940 1941template <class T> 1942inline 1943sc_logic_value_t 1944sc_bitref_r<T>::get_bit( int n ) const 1945{ 1946 if( n == 0 ) { 1947 return m_obj.get_bit( m_index ); 1948 } else { 1949 SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_ , 0 ); 1950 // never reached 1951 return Log_0; 1952 } 1953} 1954 1955 1956template <class T> 1957inline 1958sc_digit 1959sc_bitref_r<T>::get_word( int n ) const 1960{ 1961 if( n == 0 ) { 1962 return ( get_bit( n ) & SC_DIGIT_ONE ); 1963 } else { 1964 SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 ); 1965 // never reached 1966 return 0; 1967 } 1968} 1969 1970template <class T> 1971inline 1972sc_digit 1973sc_bitref_r<T>::get_cword( int n ) const 1974{ 1975 if( n == 0 ) { 1976 return ( (get_bit( n ) & SC_DIGIT_TWO) >> 1 ); 1977 } else { 1978 SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 ); 1979 // never reached 1980 return 0; 1981 } 1982} 1983 1984 1985// r-value concatenation operators and functions 1986 1987template <class T1, class T2> 1988inline 1989sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> > 1990operator , ( sc_bitref_r<T1> a, sc_bitref_r<T2> b ) 1991{ 1992 return sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >( 1993 *a.clone(), *b.clone(), 3 ); 1994} 1995 1996template <class T1, class T2> 1997inline 1998sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> > 1999operator , ( sc_bitref_r<T1> a, sc_subref_r<T2> b ) 2000{ 2001 return sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >( 2002 *a.clone(), *b.clone(), 3 ); 2003} 2004 2005template <class T1, class T2, class T3> 2006inline 2007sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> > 2008operator , ( sc_bitref_r<T1> a, sc_concref_r<T2,T3> b ) 2009{ 2010 return sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >( 2011 *a.clone(), *b.clone(), 3 ); 2012} 2013 2014template <class T1, class T2> 2015inline 2016sc_concref_r<sc_bitref_r<T1>,T2> 2017operator , ( sc_bitref_r<T1> a, const sc_proxy<T2>& b ) 2018{ 2019 return sc_concref_r<sc_bitref_r<T1>,T2>( 2020 *a.clone(), b.back_cast(), 1 ); 2021} 2022 2023 2024template <class T1, class T2> 2025inline 2026sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> > 2027concat( sc_bitref_r<T1> a, sc_bitref_r<T2> b ) 2028{ 2029 return sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >( 2030 *a.clone(), *b.clone(), 3 ); 2031} 2032 2033template <class T1, class T2> 2034inline 2035sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> > 2036concat( sc_bitref_r<T1> a, sc_subref_r<T2> b ) 2037{ 2038 return sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >( 2039 *a.clone(), *b.clone(), 3 ); 2040} 2041 2042template <class T1, class T2, class T3> 2043inline 2044sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> > 2045concat( sc_bitref_r<T1> a, sc_concref_r<T2,T3> b ) 2046{ 2047 return sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >( 2048 *a.clone(), *b.clone(), 3 ); 2049} 2050 2051template <class T1, class T2> 2052inline 2053sc_concref_r<sc_bitref_r<T1>,T2> 2054concat( sc_bitref_r<T1> a, const sc_proxy<T2>& b ) 2055{ 2056 return sc_concref_r<sc_bitref_r<T1>,T2>( 2057 *a.clone(), b.back_cast(), 1 ); 2058} 2059 2060 2061#ifdef SC_DT_MIXED_COMMA_OPERATORS 2062 2063template <class T1, class T2> 2064inline 2065sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> > 2066operator , ( sc_bitref_r<T1> a, sc_bitref<T2> b ) 2067{ 2068 return sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >( 2069 *a.clone(), *b.clone(), 3 ); 2070} 2071 2072template <class T1, class T2> 2073inline 2074sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> > 2075operator , ( sc_bitref<T1> a, sc_bitref_r<T2> b ) 2076{ 2077 return sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >( 2078 *a.clone(), *b.clone(), 3 ); 2079} 2080 2081template <class T1, class T2> 2082inline 2083sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> > 2084operator , ( sc_bitref_r<T1> a, sc_subref<T2> b ) 2085{ 2086 return sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >( 2087 *a.clone(), *b.clone(), 3 ); 2088} 2089 2090template <class T1, class T2> 2091inline 2092sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> > 2093operator , ( sc_bitref<T1> a, sc_subref_r<T2> b ) 2094{ 2095 return sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >( 2096 *a.clone(), *b.clone(), 3 ); 2097} 2098 2099template <class T1, class T2, class T3> 2100inline 2101sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> > 2102operator , ( sc_bitref_r<T1> a, sc_concref<T2,T3> b ) 2103{ 2104 return sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >( 2105 *a.clone(), *b.clone(), 3 ); 2106} 2107 2108template <class T1, class T2, class T3> 2109inline 2110sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> > 2111operator , ( sc_bitref<T1> a, sc_concref_r<T2,T3> b ) 2112{ 2113 return sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >( 2114 *a.clone(), *b.clone(), 3 ); 2115} 2116 2117template <class T1, class T2> 2118inline 2119sc_concref_r<sc_bitref_r<T1>,T2> 2120operator , ( sc_bitref<T1> a, const sc_proxy<T2>& b ) 2121{ 2122 return sc_concref_r<sc_bitref_r<T1>,T2>( 2123 *a.clone(), b.back_cast(), 1 ); 2124} 2125 2126template <class T1, class T2> 2127inline 2128sc_concref_r<sc_bitref_r<T1>,T2> 2129operator , ( sc_bitref_r<T1> a, sc_proxy<T2>& b ) 2130{ 2131 return sc_concref_r<sc_bitref_r<T1>,T2>( 2132 *a.clone(), b.back_cast(), 1 ); 2133} 2134 2135 2136template <class T1, class T2> 2137inline 2138sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> > 2139concat( sc_bitref_r<T1> a, sc_bitref<T2> b ) 2140{ 2141 return sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >( 2142 *a.clone(), *b.clone(), 3 ); 2143} 2144 2145template <class T1, class T2> 2146inline 2147sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> > 2148concat( sc_bitref<T1> a, sc_bitref_r<T2> b ) 2149{ 2150 return sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >( 2151 *a.clone(), *b.clone(), 3 ); 2152} 2153 2154template <class T1, class T2> 2155inline 2156sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> > 2157concat( sc_bitref_r<T1> a, sc_subref<T2> b ) 2158{ 2159 return sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >( 2160 *a.clone(), *b.clone(), 3 ); 2161} 2162 2163template <class T1, class T2> 2164inline 2165sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> > 2166concat( sc_bitref<T1> a, sc_subref_r<T2> b ) 2167{ 2168 return sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >( 2169 *a.clone(), *b.clone(), 3 ); 2170} 2171 2172template <class T1, class T2, class T3> 2173inline 2174sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> > 2175concat( sc_bitref_r<T1> a, sc_concref<T2,T3> b ) 2176{ 2177 return sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >( 2178 *a.clone(), *b.clone(), 3 ); 2179} 2180 2181template <class T1, class T2, class T3> 2182inline 2183sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> > 2184concat( sc_bitref<T1> a, sc_concref_r<T2,T3> b ) 2185{ 2186 return sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >( 2187 *a.clone(), *b.clone(), 3 ); 2188} 2189 2190template <class T1, class T2> 2191inline 2192sc_concref_r<sc_bitref_r<T1>,T2> 2193concat( sc_bitref<T1> a, const sc_proxy<T2>& b ) 2194{ 2195 return sc_concref_r<sc_bitref_r<T1>,T2>( 2196 *a.clone(), b.back_cast(), 1 ); 2197} 2198 2199template <class T1, class T2> 2200inline 2201sc_concref_r<sc_bitref_r<T1>,T2> 2202concat( sc_bitref_r<T1> a, sc_proxy<T2>& b ) 2203{ 2204 return sc_concref_r<sc_bitref_r<T1>,T2>( 2205 *a.clone(), b.back_cast(), 1 ); 2206} 2207 2208#endif 2209 2210 2211// ---------------------------------------------------------------------------- 2212// CLASS TEMPLATE : sc_bitref<X> 2213// 2214// Proxy class for sc_proxy bit selection (r-value and l-value). 2215// ---------------------------------------------------------------------------- 2216 2217// assignment operators 2218 2219template <class X> 2220inline 2221sc_bitref<X>& 2222sc_bitref<X>::operator = ( const sc_bitref_r<X>& a ) 2223{ 2224 this->m_obj.set_bit( this->m_index, a.value() ); 2225 return *this; 2226} 2227 2228template <class X> 2229inline 2230sc_bitref<X>& 2231sc_bitref<X>::operator = ( const sc_bitref<X>& a ) 2232{ 2233 if( &a != this ) { 2234 this->m_obj.set_bit( this->m_index, a.value() ); 2235 } 2236 return *this; 2237} 2238 2239 2240// bitwise assignment operators 2241 2242template <class X> 2243inline 2244sc_bitref<X>& 2245sc_bitref<X>::operator &= ( const sc_bitref_r<X>& a ) 2246{ 2247 if( &a != this ) { 2248 this->m_obj.set_bit( this->m_index, 2249 sc_logic::and_table[this->value()][a.value()] ); 2250 } 2251 return *this; 2252} 2253 2254template <class X> 2255inline 2256sc_bitref<X>& 2257sc_bitref<X>::operator &= ( const sc_logic& a ) 2258{ 2259 this->m_obj.set_bit( this->m_index, 2260 sc_logic::and_table[this->value()][a.value()] ); 2261 return *this; 2262} 2263 2264 2265template <class X> 2266inline 2267sc_bitref<X>& 2268sc_bitref<X>::operator |= ( const sc_bitref_r<X>& a ) 2269{ 2270 if( &a != this ) { 2271 this->m_obj.set_bit( this->m_index, 2272 sc_logic::or_table[this->value()][a.value()] ); 2273 } 2274 return *this; 2275} 2276 2277template <class X> 2278inline 2279sc_bitref<X>& 2280sc_bitref<X>::operator |= ( const sc_logic& a ) 2281{ 2282 this->m_obj.set_bit( this->m_index, 2283 sc_logic::or_table[this->value()][a.value()] ); 2284 return *this; 2285} 2286 2287 2288template <class X> 2289inline 2290sc_bitref<X>& 2291sc_bitref<X>::operator ^= ( const sc_bitref_r<X>& a ) 2292{ 2293 if( &a != this ) { 2294 this->m_obj.set_bit( this->m_index, 2295 sc_logic::xor_table[this->value()][a.value()] ); 2296 } 2297 return *this; 2298} 2299 2300template <class X> 2301inline 2302sc_bitref<X>& 2303sc_bitref<X>::operator ^= ( const sc_logic& a ) 2304{ 2305 this->m_obj.set_bit( this->m_index, 2306 sc_logic::xor_table[this->value()][a.value()] ); 2307 return *this; 2308} 2309 2310 2311// bitwise operators and functions 2312 2313// bitwise complement 2314 2315template <class X> 2316inline 2317sc_bitref<X>& 2318sc_bitref<X>::b_not() 2319{ 2320 this->m_obj.set_bit( this->m_index, 2321 sc_logic::not_table[this->value()] ); 2322 return *this; 2323} 2324 2325 2326// common methods 2327 2328template <class X> 2329inline 2330void 2331sc_bitref<X>::set_bit( int n, sc_logic_value_t value ) 2332{ 2333 if( n == 0 ) { 2334 this->m_obj.set_bit( this->m_index, value ); 2335 } else { 2336 SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 ); 2337 } 2338} 2339 2340template <class X> 2341inline 2342void 2343sc_bitref<X>::set_word( int n, sc_digit w ) 2344{ 2345 unsigned int bi = this->m_index % (8*sizeof(sc_digit)); 2346 sc_digit temp; 2347 unsigned int wi = this->m_index / (8*sizeof(sc_digit)); 2348 if( n == 0 ) { 2349 temp = this->m_obj.get_word(wi); 2350 temp = (temp & ~(1 << bi)) | ((w&1) << bi); 2351 this->m_obj.set_word(wi, temp); 2352 } else { 2353 SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 ); 2354 } 2355 2356} 2357 2358template <class X> 2359inline 2360void 2361sc_bitref<X>::set_cword( int n, sc_digit w ) 2362{ 2363 unsigned int bi = this->m_index % (8*sizeof(sc_digit)); 2364 sc_digit temp; 2365 unsigned int wi = this->m_index / (8*sizeof(sc_digit)); 2366 if( n == 0 ) { 2367 temp = this->m_obj.get_cword(wi); 2368 temp = (temp & ~(1 << bi)) | ((w&1) << bi); 2369 this->m_obj.set_cword(wi, temp); 2370 } else { 2371 SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 ); 2372 } 2373} 2374 2375// other methods 2376 2377template <class X> 2378inline 2379void 2380sc_bitref<X>::scan( ::std::istream& is ) 2381{ 2382 char c; 2383 is >> c; 2384 *this = c; 2385} 2386 2387 2388// l-value concatenation operators and functions 2389 2390template <class T1, class T2> 2391inline 2392sc_concref<sc_bitref<T1>,sc_bitref<T2> > 2393operator , ( sc_bitref<T1> a, sc_bitref<T2> b ) 2394{ 2395 return sc_concref<sc_bitref<T1>,sc_bitref<T2> >( 2396 *a.clone(), *b.clone(), 3 ); 2397} 2398 2399template <class T1, class T2> 2400inline 2401sc_concref<sc_bitref<T1>,sc_subref<T2> > 2402operator , ( sc_bitref<T1> a, sc_subref<T2> b ) 2403{ 2404 return sc_concref<sc_bitref<T1>,sc_subref<T2> >( 2405 *a.clone(), *b.clone(), 3 ); 2406} 2407 2408template <class T1, class T2, class T3> 2409inline 2410sc_concref<sc_bitref<T1>,sc_concref<T2,T3> > 2411operator , ( sc_bitref<T1> a, sc_concref<T2,T3> b ) 2412{ 2413 return sc_concref<sc_bitref<T1>,sc_concref<T2,T3> >( 2414 *a.clone(), *b.clone(), 3 ); 2415} 2416 2417template <class T1, class T2> 2418inline 2419sc_concref<sc_bitref<T1>,T2> 2420operator , ( sc_bitref<T1> a, sc_proxy<T2>& b ) 2421{ 2422 return sc_concref<sc_bitref<T1>,T2>( 2423 *a.clone(), b.back_cast(), 1 ); 2424} 2425 2426 2427template <class T1, class T2> 2428inline 2429sc_concref<sc_bitref<T1>,sc_bitref<T2> > 2430concat( sc_bitref<T1> a, sc_bitref<T2> b ) 2431{ 2432 return sc_concref<sc_bitref<T1>,sc_bitref<T2> >( 2433 *a.clone(), *b.clone(), 3 ); 2434} 2435 2436template <class T1, class T2> 2437inline 2438sc_concref<sc_bitref<T1>,sc_subref<T2> > 2439concat( sc_bitref<T1> a, sc_subref<T2> b ) 2440{ 2441 return sc_concref<sc_bitref<T1>,sc_subref<T2> >( 2442 *a.clone(), *b.clone(), 3 ); 2443} 2444 2445template <class T1, class T2, class T3> 2446inline 2447sc_concref<sc_bitref<T1>,sc_concref<T2,T3> > 2448concat( sc_bitref<T1> a, sc_concref<T2,T3> b ) 2449{ 2450 return sc_concref<sc_bitref<T1>,sc_concref<T2,T3> >( 2451 *a.clone(), *b.clone(), 3 ); 2452} 2453 2454template <class T1, class T2> 2455inline 2456sc_concref<sc_bitref<T1>,T2> 2457concat( sc_bitref<T1> a, sc_proxy<T2>& b ) 2458{ 2459 return sc_concref<sc_bitref<T1>,T2>( 2460 *a.clone(), b.back_cast(), 1 ); 2461} 2462 2463 2464template <class X> 2465inline 2466::std::istream& 2467operator >> ( ::std::istream& is, sc_bitref<X> a ) 2468{ 2469 a.scan( is ); 2470 return is; 2471} 2472 2473 2474// ---------------------------------------------------------------------------- 2475// CLASS TEMPLATE : sc_subref_r<X> 2476// 2477// Proxy class for sc_proxy part selection (r-value only). 2478// ---------------------------------------------------------------------------- 2479 2480template <class X> 2481inline 2482void 2483sc_subref_r<X>::check_bounds() 2484{ 2485 int len = m_obj.length(); 2486 if( m_hi < 0 || m_hi >= len || m_lo < 0 || m_lo >= len ) { 2487 SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 ); 2488 } 2489 if( reversed() ) { 2490 m_len = m_lo - m_hi + 1; 2491 } else { 2492 m_len = m_hi - m_lo + 1; 2493 } 2494} 2495 2496 2497// common methods 2498 2499template <class X> 2500inline 2501sc_logic_value_t 2502sc_subref_r<X>::get_bit( int n ) const 2503{ 2504 if( reversed() ) { 2505 return m_obj.get_bit( m_lo - n ); 2506 } else { 2507 return m_obj.get_bit( m_lo + n ); 2508 } 2509} 2510 2511template <class X> 2512inline 2513void 2514sc_subref_r<X>::set_bit( int n, sc_logic_value_t value ) 2515{ 2516 if( reversed() ) { 2517 m_obj.set_bit( m_lo - n, value ); 2518 } else { 2519 m_obj.set_bit( m_lo + n, value ); 2520 } 2521} 2522 2523 2524template <class X> 2525inline 2526sc_digit 2527sc_subref_r<X>::get_word( int i ) const 2528{ 2529 int n1 = 0; 2530 int n2 = 0; 2531 sc_digit result = 0; 2532 int k = 0; 2533 if( reversed() ) { 2534 n1 = m_lo - i * SC_DIGIT_SIZE; 2535 n2 = sc_max( n1 - SC_DIGIT_SIZE, m_hi - 1 ); 2536 for( int n = n1; n > n2; n -- ) { 2537 result |= (m_obj[n].value() & SC_DIGIT_ONE) << k ++; 2538 } 2539 } else { 2540 n1 = m_lo + i * SC_DIGIT_SIZE; 2541 n2 = sc_min( n1 + SC_DIGIT_SIZE, m_hi + 1 ); 2542 for( int n = n1; n < n2; n ++ ) { 2543 result |= (m_obj[n].value() & SC_DIGIT_ONE) << k ++; 2544 } 2545 } 2546 return result; 2547} 2548 2549template <class X> 2550inline 2551void 2552sc_subref_r<X>::set_word( int i, sc_digit w ) 2553{ 2554 int n1 = 0; 2555 int n2 = 0; 2556 int k = 0; 2557 if( reversed() ) { 2558 n1 = m_lo - i * SC_DIGIT_SIZE; 2559 n2 = sc_max( n1 - SC_DIGIT_SIZE, m_hi - 1 ); 2560 for( int n = n1; n > n2; n -- ) { 2561 m_obj.set_bit( n, sc_logic_value_t( 2562 ( (w >> k ++) & SC_DIGIT_ONE ) | 2563 ( m_obj[n].value() & SC_DIGIT_TWO ) ) ); 2564 } 2565 } else { 2566 n1 = m_lo + i * SC_DIGIT_SIZE; 2567 n2 = sc_min( n1 + SC_DIGIT_SIZE, m_hi + 1 ); 2568 for( int n = n1; n < n2; n ++ ) { 2569 m_obj.set_bit( n, sc_logic_value_t( 2570 ( (w >> k ++) & SC_DIGIT_ONE ) | 2571 ( m_obj[n].value() & SC_DIGIT_TWO ) ) ); 2572 } 2573 } 2574} 2575 2576 2577template <class X> 2578inline 2579sc_digit 2580sc_subref_r<X>::get_cword( int i ) const 2581{ 2582 int n1 = 0; 2583 int n2 = 0; 2584 sc_digit result = 0; 2585 int k = 0; 2586 if( reversed() ) { 2587 n1 = m_lo - i * SC_DIGIT_SIZE; 2588 n2 = sc_max( n1 - SC_DIGIT_SIZE, m_hi - 1 ); 2589 for( int n = n1; n > n2; n -- ) { 2590 result |= ((m_obj[n].value() & SC_DIGIT_TWO) >> 1) << k ++; 2591 } 2592 } else { 2593 n1 = m_lo + i * SC_DIGIT_SIZE; 2594 n2 = sc_min( n1 + SC_DIGIT_SIZE, m_hi + 1 ); 2595 for( int n = n1; n < n2; n ++ ) { 2596 result |= ((m_obj[n].value() & SC_DIGIT_TWO) >> 1) << k ++; 2597 } 2598 } 2599 return result; 2600} 2601 2602template <class X> 2603inline 2604void 2605sc_subref_r<X>::set_cword( int i, sc_digit w ) 2606{ 2607 int n1 = 0; 2608 int n2 = 0; 2609 int k = 0; 2610 if( reversed() ) { 2611 n1 = m_lo - i * SC_DIGIT_SIZE; 2612 n2 = sc_max( n1 - SC_DIGIT_SIZE, m_hi - 1 ); 2613 for( int n = n1; n > n2; n -- ) { 2614 m_obj.set_bit( n, sc_logic_value_t( 2615 ( ((w >> k ++) & SC_DIGIT_ONE) << 1 ) | 2616 ( m_obj[n].value() & SC_DIGIT_ONE ) ) ); 2617 } 2618 } else { 2619 n1 = m_lo + i * SC_DIGIT_SIZE; 2620 n2 = sc_min( n1 + SC_DIGIT_SIZE, m_hi + 1 ); 2621 for( int n = n1; n < n2; n ++ ) { 2622 m_obj.set_bit( n, sc_logic_value_t( 2623 ( ((w >> k ++) & SC_DIGIT_ONE) << 1 ) | 2624 ( m_obj[n].value() & SC_DIGIT_ONE ) ) ); 2625 } 2626 } 2627} 2628 2629 2630// other methods 2631 2632template <class X> 2633inline 2634bool 2635sc_subref_r<X>::is_01() const 2636{ 2637 int sz = size(); 2638 for( int i = 0; i < sz; ++ i ) { 2639 if( get_cword( i ) != SC_DIGIT_ZERO ) { 2640 return false; 2641 } 2642 } 2643 return true; 2644} 2645 2646 2647// r-value concatenation operators and functions 2648 2649template <class T1, class T2> 2650inline 2651sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> > 2652operator , ( sc_subref_r<T1> a, sc_bitref_r<T2> b ) 2653{ 2654 return sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >( 2655 *a.clone(), *b.clone(), 3 ); 2656} 2657 2658template <class T1, class T2> 2659inline 2660sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> > 2661operator , ( sc_subref_r<T1> a, sc_subref_r<T2> b ) 2662{ 2663 return sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >( 2664 *a.clone(), *b.clone(), 3 ); 2665} 2666 2667template <class T1, class T2, class T3> 2668inline 2669sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> > 2670operator , ( sc_subref_r<T1> a, sc_concref_r<T2,T3> b ) 2671{ 2672 return sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >( 2673 *a.clone(), *b.clone(), 3 ); 2674} 2675 2676template <class T1, class T2> 2677inline 2678sc_concref_r<sc_subref_r<T1>,T2> 2679operator , ( sc_subref_r<T1> a, const sc_proxy<T2>& b ) 2680{ 2681 return sc_concref_r<sc_subref_r<T1>,T2>( 2682 *a.clone(), b.back_cast(), 1 ); 2683} 2684 2685 2686template <class T1, class T2> 2687inline 2688sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> > 2689concat( sc_subref_r<T1> a, sc_bitref_r<T2> b ) 2690{ 2691 return sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >( 2692 *a.clone(), *b.clone(), 3 ); 2693} 2694 2695template <class T1, class T2> 2696inline 2697sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> > 2698concat( sc_subref_r<T1> a, sc_subref_r<T2> b ) 2699{ 2700 return sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >( 2701 *a.clone(), *b.clone(), 3 ); 2702} 2703 2704template <class T1, class T2, class T3> 2705inline 2706sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> > 2707concat( sc_subref_r<T1> a, sc_concref_r<T2,T3> b ) 2708{ 2709 return sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >( 2710 *a.clone(), *b.clone(), 3 ); 2711} 2712 2713template <class T1, class T2> 2714inline 2715sc_concref_r<sc_subref_r<T1>,T2> 2716concat( sc_subref_r<T1> a, const sc_proxy<T2>& b ) 2717{ 2718 return sc_concref_r<sc_subref_r<T1>,T2>( 2719 *a.clone(), b.back_cast(), 1 ); 2720} 2721 2722 2723#ifdef SC_DT_MIXED_COMMA_OPERATORS 2724 2725template <class T1, class T2> 2726inline 2727sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> > 2728operator , ( sc_subref_r<T1> a, sc_bitref<T2> b ) 2729{ 2730 return sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >( 2731 *a.clone(), *b.clone(), 3 ); 2732} 2733 2734template <class T1, class T2> 2735inline 2736sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> > 2737operator , ( sc_subref<T1> a, sc_bitref_r<T2> b ) 2738{ 2739 return sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >( 2740 *a.clone(), *b.clone(), 3 ); 2741} 2742 2743template <class T1, class T2> 2744inline 2745sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> > 2746operator , ( sc_subref_r<T1> a, sc_subref<T2> b ) 2747{ 2748 return sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >( 2749 *a.clone(), *b.clone(), 3 ); 2750} 2751 2752template <class T1, class T2> 2753inline 2754sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> > 2755operator , ( sc_subref<T1> a, sc_subref_r<T2> b ) 2756{ 2757 return sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >( 2758 *a.clone(), *b.clone(), 3 ); 2759} 2760 2761template <class T1, class T2, class T3> 2762inline 2763sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> > 2764operator , ( sc_subref_r<T1> a, sc_concref<T2,T3> b ) 2765{ 2766 return sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >( 2767 *a.clone(), *b.clone(), 3 ); 2768} 2769 2770template <class T1, class T2, class T3> 2771inline 2772sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> > 2773operator , ( sc_subref<T1> a, sc_concref_r<T2,T3> b ) 2774{ 2775 return sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >( 2776 *a.clone(), *b.clone(), 3 ); 2777} 2778 2779template <class T1, class T2> 2780inline 2781sc_concref_r<sc_subref_r<T1>,T2> 2782operator , ( sc_subref<T1> a, const sc_proxy<T2>& b ) 2783{ 2784 return sc_concref_r<sc_subref_r<T1>,T2>( 2785 *a.clone(), b.back_cast(), 1 ); 2786} 2787 2788template <class T1, class T2> 2789inline 2790sc_concref_r<sc_subref_r<T1>,T2> 2791operator , ( sc_subref_r<T1> a, sc_proxy<T2>& b ) 2792{ 2793 return sc_concref_r<sc_subref_r<T1>,T2>( 2794 *a.clone(), b.back_cast(), 1 ); 2795} 2796 2797 2798template <class T1, class T2> 2799inline 2800sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> > 2801concat( sc_subref_r<T1> a, sc_bitref<T2> b ) 2802{ 2803 return sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >( 2804 *a.clone(), *b.clone(), 3 ); 2805} 2806 2807template <class T1, class T2> 2808inline 2809sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> > 2810concat( sc_subref<T1> a, sc_bitref_r<T2> b ) 2811{ 2812 return sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >( 2813 *a.clone(), *b.clone(), 3 ); 2814} 2815 2816template <class T1, class T2> 2817inline 2818sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> > 2819concat( sc_subref_r<T1> a, sc_subref<T2> b ) 2820{ 2821 return sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >( 2822 *a.clone(), *b.clone(), 3 ); 2823} 2824 2825template <class T1, class T2> 2826inline 2827sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> > 2828concat( sc_subref<T1> a, sc_subref_r<T2> b ) 2829{ 2830 return sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >( 2831 *a.clone(), *b.clone(), 3 ); 2832} 2833 2834template <class T1, class T2, class T3> 2835inline 2836sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> > 2837concat( sc_subref_r<T1> a, sc_concref<T2,T3> b ) 2838{ 2839 return sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >( 2840 *a.clone(), *b.clone(), 3 ); 2841} 2842 2843template <class T1, class T2, class T3> 2844inline 2845sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> > 2846concat( sc_subref<T1> a, sc_concref_r<T2,T3> b ) 2847{ 2848 return sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >( 2849 *a.clone(), *b.clone(), 3 ); 2850} 2851 2852template <class T1, class T2> 2853inline 2854sc_concref_r<sc_subref_r<T1>,T2> 2855concat( sc_subref<T1> a, const sc_proxy<T2>& b ) 2856{ 2857 return sc_concref_r<sc_subref_r<T1>,T2>( 2858 *a.clone(), b.back_cast(), 1 ); 2859} 2860 2861template <class T1, class T2> 2862inline 2863sc_concref_r<sc_subref_r<T1>,T2> 2864concat( sc_subref_r<T1> a, sc_proxy<T2>& b ) 2865{ 2866 return sc_concref_r<sc_subref_r<T1>,T2>( 2867 *a.clone(), b.back_cast(), 1 ); 2868} 2869 2870#endif 2871 2872 2873// ---------------------------------------------------------------------------- 2874// CLASS TEMPLATE : sc_subref<X> 2875// 2876// Proxy class for sc_proxy part selection (r-value and l-value). 2877// ---------------------------------------------------------------------------- 2878 2879// assignment operators 2880 2881// sc_subref<X>::operator = ( const sc_subref_r<X>& ) in sc_lv_base.h 2882// sc_subref<X>::operator = ( const sc_subref<X>& ) in sc_lv_base.h 2883 2884 2885// other methods 2886 2887template <class T> 2888inline 2889void 2890sc_subref<T>::scan( ::std::istream& is ) 2891{ 2892 std::string s; 2893 is >> s; 2894 *this = s.c_str(); 2895} 2896 2897 2898// l-value concatenation operators and functions 2899 2900template <class T1, class T2> 2901inline 2902sc_concref<sc_subref<T1>,sc_bitref<T2> > 2903operator , ( sc_subref<T1> a, sc_bitref<T2> b ) 2904{ 2905 return sc_concref<sc_subref<T1>,sc_bitref<T2> >( 2906 *a.clone(), *b.clone(), 3 ); 2907} 2908 2909template <class T1, class T2> 2910inline 2911sc_concref<sc_subref<T1>,sc_subref<T2> > 2912operator , ( sc_subref<T1> a, sc_subref<T2> b ) 2913{ 2914 return sc_concref<sc_subref<T1>,sc_subref<T2> >( 2915 *a.clone(), *b.clone(), 3 ); 2916} 2917 2918template <class T1, class T2, class T3> 2919inline 2920sc_concref<sc_subref<T1>,sc_concref<T2,T3> > 2921operator , ( sc_subref<T1> a, sc_concref<T2,T3> b ) 2922{ 2923 return sc_concref<sc_subref<T1>,sc_concref<T2,T3> >( 2924 *a.clone(), *b.clone(), 3 ); 2925} 2926 2927template <class T1, class T2> 2928inline 2929sc_concref<sc_subref<T1>,T2> 2930operator , ( sc_subref<T1> a, sc_proxy<T2>& b ) 2931{ 2932 return sc_concref<sc_subref<T1>,T2>( 2933 *a.clone(), b.back_cast(), 1 ); 2934} 2935 2936 2937template <class T1, class T2> 2938inline 2939sc_concref<sc_subref<T1>,sc_bitref<T2> > 2940concat( sc_subref<T1> a, sc_bitref<T2> b ) 2941{ 2942 return sc_concref<sc_subref<T1>,sc_bitref<T2> >( 2943 *a.clone(), *b.clone(), 3 ); 2944} 2945 2946template <class T1, class T2> 2947inline 2948sc_concref<sc_subref<T1>,sc_subref<T2> > 2949concat( sc_subref<T1> a, sc_subref<T2> b ) 2950{ 2951 return sc_concref<sc_subref<T1>,sc_subref<T2> >( 2952 *a.clone(), *b.clone(), 3 ); 2953} 2954 2955template <class T1, class T2, class T3> 2956inline 2957sc_concref<sc_subref<T1>,sc_concref<T2,T3> > 2958concat( sc_subref<T1> a, sc_concref<T2,T3> b ) 2959{ 2960 return sc_concref<sc_subref<T1>,sc_concref<T2,T3> >( 2961 *a.clone(), *b.clone(), 3 ); 2962} 2963 2964template <class T1, class T2> 2965inline 2966sc_concref<sc_subref<T1>,T2> 2967concat( sc_subref<T1> a, sc_proxy<T2>& b ) 2968{ 2969 return sc_concref<sc_subref<T1>,T2>( 2970 *a.clone(), b.back_cast(), 1 ); 2971} 2972 2973 2974template <class X> 2975inline 2976::std::istream& 2977operator >> ( ::std::istream& is, sc_subref<X> a ) 2978{ 2979 a.scan( is ); 2980 return is; 2981} 2982 2983 2984// ---------------------------------------------------------------------------- 2985// CLASS TEMPLATE : sc_concref_r<X,Y> 2986// 2987// Proxy class for sc_proxy concatenation (r-value only). 2988// ---------------------------------------------------------------------------- 2989 2990// destructor 2991 2992template <class X, class Y> 2993inline 2994sc_concref_r<X,Y>::~sc_concref_r() 2995{ 2996 if( -- m_refs == 0 ) { 2997 delete &m_refs; 2998 if( m_delete == 0 ) { 2999 return; 3000 } 3001 if( m_delete & 1 ) { 3002 delete &m_left; 3003 } 3004 if( m_delete & 2 ) { 3005 delete &m_right; 3006 } 3007 } 3008} 3009 3010 3011// common methods 3012 3013template <class X, class Y> 3014inline 3015sc_logic_value_t 3016sc_concref_r<X,Y>::get_bit( int n ) const 3017{ 3018 int r_len = m_right.length(); 3019 if( n < r_len ) { 3020 return m_right.get_bit( n ); 3021 } else if( n < r_len + m_left.length() ) { 3022 return m_left.get_bit( n - r_len ); 3023 } else { 3024 SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 ); 3025 // never reached 3026 return Log_0; 3027 } 3028} 3029 3030template <class X, class Y> 3031inline 3032void 3033sc_concref_r<X,Y>::set_bit( int n, sc_logic_value_t v ) 3034{ 3035 int r_len = m_right.length(); 3036 if( n < r_len ) { 3037 m_right.set_bit( n, v ); 3038 } else if( n < r_len + m_left.length() ) { 3039 m_left.set_bit( n - r_len, v ); 3040 } else { 3041 SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 ); 3042 } 3043} 3044 3045 3046template <class X, class Y> 3047inline 3048sc_digit 3049sc_concref_r<X,Y>::get_word( int i ) const 3050{ 3051 if( i < 0 || i >= size() ) { 3052 SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 ); 3053 } 3054 // 0 <= i < size() 3055 Y& r = m_right; 3056 int r_len = r.length(); 3057 int border = r_len / SC_DIGIT_SIZE; 3058 if( i < border ) { 3059 return r.get_word( i ); 3060 } 3061 // border <= i < size() 3062 X& l = m_left; 3063 int shift = r_len % SC_DIGIT_SIZE; 3064 int j = i - border; 3065 if( shift == 0 ) { 3066 return l.get_word( j ); 3067 } 3068 // border <= i < size() && shift != 0 3069 int nshift = SC_DIGIT_SIZE - shift; 3070 if( i == border ) { 3071 sc_digit rl_mask = ~SC_DIGIT_ZERO >> nshift; 3072 return ( (r.get_word( i ) & rl_mask) | (l.get_word( 0 ) << shift) ); 3073 } 3074 // border < i < size() && shift != 0 3075 if ( j < l.size() ) 3076 return ( (l.get_word( j - 1 ) >> nshift) | (l.get_word( j ) << shift) ); 3077 else 3078 return (l.get_word( j - 1 ) >> nshift); 3079} 3080 3081template <class X, class Y> 3082inline 3083void 3084sc_concref_r<X,Y>::set_word( int i, sc_digit w ) 3085{ 3086 if( i < 0 || i >= size() ) { 3087 SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 ); 3088 } 3089 // 0 <= i < size() 3090 Y& r = m_right; 3091 int r_len = r.length(); 3092 int border = r_len / SC_DIGIT_SIZE; 3093 if( i < border ) { 3094 r.set_word( i, w ); 3095 return; 3096 } 3097 // border <= i < size() 3098 X& l = m_left; 3099 int shift = r_len % SC_DIGIT_SIZE; 3100 int j = i - border; 3101 if( shift == 0 ) { 3102 l.set_word( j, w ); 3103 return; 3104 } 3105 // border <= i < size() && shift != 0 3106 int nshift = SC_DIGIT_SIZE - shift; 3107 sc_digit lh_mask = ~SC_DIGIT_ZERO << nshift; 3108 if( i == border ) { 3109 sc_digit rl_mask = ~SC_DIGIT_ZERO >> nshift; 3110 r.set_word( i, w & rl_mask ); 3111 l.set_word( 0, (l.get_word( 0 ) & lh_mask) | (w >> shift) ); 3112 return; 3113 } 3114 // border < i < size() && shift != 0 3115 sc_digit ll_mask = ~SC_DIGIT_ZERO >> shift; 3116 l.set_word( j - 1, (l.get_word( j - 1 ) & ll_mask) | (w << nshift) ); 3117 if ( j < l.size() ) 3118 l.set_word( j, (l.get_word( j ) & lh_mask) | (w >> shift) ); 3119} 3120 3121 3122template <class X, class Y> 3123inline 3124sc_digit 3125sc_concref_r<X,Y>::get_cword( int i ) const 3126{ 3127 if( i < 0 || i >= size() ) { 3128 SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 ); 3129 } 3130 // 0 <= i < size() 3131 Y& r = m_right; 3132 int r_len = r.length(); 3133 int border = r_len / SC_DIGIT_SIZE; 3134 if( i < border ) { 3135 return r.get_cword( i ); 3136 } 3137 // border <= i < size() 3138 X& l = m_left; 3139 int shift = r_len % SC_DIGIT_SIZE; 3140 int j = i - border; 3141 if( shift == 0 ) { 3142 return l.get_cword( j ); 3143 } 3144 // border <= i < size() && shift != 0 3145 int nshift = SC_DIGIT_SIZE - shift; 3146 if( i == border ) { 3147 sc_digit rl_mask = ~SC_DIGIT_ZERO >> nshift; 3148 return ( (r.get_cword( i ) & rl_mask) | (l.get_cword( 0 ) << shift) ); 3149 } 3150 // border < i < size() && shift != 0 3151 if ( j < l.size() ) 3152 return ( (l.get_cword(j - 1) >> nshift) | (l.get_cword(j) << shift) ); 3153 else 3154 return (l.get_cword( j - 1 ) >> nshift); 3155} 3156 3157template <class X, class Y> 3158inline 3159void 3160sc_concref_r<X,Y>::set_cword( int i, sc_digit w ) 3161{ 3162 if( i < 0 || i >= size() ) { 3163 SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 ); 3164 } 3165 // 0 <= i < size() 3166 Y& r = m_right; 3167 int r_len = r.length(); 3168 int border = r_len / SC_DIGIT_SIZE; 3169 if( i < border ) { 3170 r.set_cword( i, w ); 3171 return; 3172 } 3173 // border <= i < size() 3174 X& l = m_left; 3175 int shift = r_len % SC_DIGIT_SIZE; 3176 int j = i - border; 3177 if( shift == 0 ) { 3178 l.set_cword( j, w ); 3179 return; 3180 } 3181 // border <= i < size() && shift != 0 3182 int nshift = SC_DIGIT_SIZE - shift; 3183 sc_digit lh_mask = ~SC_DIGIT_ZERO << nshift; 3184 if( i == border ) { 3185 sc_digit rl_mask = ~SC_DIGIT_ZERO >> nshift; 3186 r.set_cword( i, w & rl_mask ); 3187 l.set_cword( 0, (l.get_cword( 0 ) & lh_mask) | (w >> shift) ); 3188 return; 3189 } 3190 // border < i < size() && shift != 0 3191 sc_digit ll_mask = ~SC_DIGIT_ZERO >> shift; 3192 l.set_cword( j - 1, (l.get_cword( j - 1 ) & ll_mask) | (w << nshift) ); 3193 if ( j < l.size() ) 3194 l.set_cword( j, (l.get_cword( j ) & lh_mask) | (w >> shift) ); 3195} 3196 3197 3198// r-value concatenation operators and functions 3199 3200template <class T1, class T2, class T3> 3201inline 3202sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> > 3203operator , ( sc_concref_r<T1,T2> a, sc_bitref_r<T3> b ) 3204{ 3205 return sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >( 3206 *a.clone(), *b.clone(), 3 ); 3207} 3208 3209template <class T1, class T2, class T3> 3210inline 3211sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> > 3212operator , ( sc_concref_r<T1,T2> a, sc_subref_r<T3> b ) 3213{ 3214 return sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >( 3215 *a.clone(), *b.clone(), 3 ); 3216} 3217 3218template <class T1, class T2, class T3, class T4> 3219inline 3220sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> > 3221operator , ( sc_concref_r<T1,T2> a, sc_concref_r<T3,T4> b ) 3222{ 3223 return sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >( 3224 *a.clone(), *b.clone(), 3 ); 3225} 3226 3227template <class T1, class T2, class T3> 3228inline 3229sc_concref_r<sc_concref_r<T1,T2>,T3> 3230operator , ( sc_concref_r<T1,T2> a, const sc_proxy<T3>& b ) 3231{ 3232 return sc_concref_r<sc_concref_r<T1,T2>,T3>( 3233 *a.clone(), b.back_cast(), 1 ); 3234} 3235 3236 3237template <class T1, class T2, class T3> 3238inline 3239sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> > 3240concat( sc_concref_r<T1,T2> a, sc_bitref_r<T3> b ) 3241{ 3242 return sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >( 3243 *a.clone(), *b.clone(), 3 ); 3244} 3245 3246template <class T1, class T2, class T3> 3247inline 3248sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> > 3249concat( sc_concref_r<T1,T2> a, sc_subref_r<T3> b ) 3250{ 3251 return sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >( 3252 *a.clone(), *b.clone(), 3 ); 3253} 3254 3255template <class T1, class T2, class T3, class T4> 3256inline 3257sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> > 3258concat( sc_concref_r<T1,T2> a, sc_concref_r<T3,T4> b ) 3259{ 3260 return sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >( 3261 *a.clone(), *b.clone(), 3 ); 3262} 3263 3264template <class T1, class T2, class T3> 3265inline 3266sc_concref_r<sc_concref_r<T1,T2>,T3> 3267concat( sc_concref_r<T1,T2> a, const sc_proxy<T3>& b ) 3268{ 3269 return sc_concref_r<sc_concref_r<T1,T2>,T3>( 3270 *a.clone(), b.back_cast(), 1 ); 3271} 3272 3273 3274#ifdef SC_DT_MIXED_COMMA_OPERATORS 3275 3276template <class T1, class T2, class T3> 3277inline 3278sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> > 3279operator , ( sc_concref_r<T1,T2> a, sc_bitref<T3> b ) 3280{ 3281 return sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >( 3282 *a.clone(), *b.clone(), 3 ); 3283} 3284 3285template <class T1, class T2, class T3> 3286inline 3287sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> > 3288operator , ( sc_concref<T1,T2> a, sc_bitref_r<T3> b ) 3289{ 3290 return sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >( 3291 *a.clone(), *b.clone(), 3 ); 3292} 3293 3294template <class T1, class T2, class T3> 3295inline 3296sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> > 3297operator , ( sc_concref_r<T1,T2> a, sc_subref<T3> b ) 3298{ 3299 return sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >( 3300 *a.clone(), *b.clone(), 3 ); 3301} 3302 3303template <class T1, class T2, class T3> 3304inline 3305sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> > 3306operator , ( sc_concref<T1,T2> a, sc_subref_r<T3> b ) 3307{ 3308 return sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >( 3309 *a.clone(), *b.clone(), 3 ); 3310} 3311 3312template <class T1, class T2, class T3, class T4> 3313inline 3314sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> > 3315operator , ( sc_concref_r<T1,T2> a, sc_concref<T3,T4> b ) 3316{ 3317 return sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >( 3318 *a.clone(), *b.clone(), 3 ); 3319} 3320 3321template <class T1, class T2, class T3, class T4> 3322inline 3323sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> > 3324operator , ( sc_concref<T1,T2> a, sc_concref_r<T3,T4> b ) 3325{ 3326 return sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >( 3327 *a.clone(), *b.clone(), 3 ); 3328} 3329 3330template <class T1, class T2, class T3> 3331inline 3332sc_concref_r<sc_concref_r<T1,T2>,T3> 3333operator , ( sc_concref<T1,T2> a, const sc_proxy<T3>& b ) 3334{ 3335 return sc_concref_r<sc_concref_r<T1,T2>,T3>( 3336 *a.clone(), b.back_cast(), 1 ); 3337} 3338 3339template <class T1, class T2, class T3> 3340inline 3341sc_concref_r<sc_concref_r<T1,T2>,T3> 3342operator , ( sc_concref_r<T1,T2> a, sc_proxy<T3>& b ) 3343{ 3344 return sc_concref_r<sc_concref_r<T1,T2>,T3>( 3345 *a.clone(), b.back_cast(), 1 ); 3346} 3347 3348 3349template <class T1, class T2, class T3> 3350inline 3351sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> > 3352concat( sc_concref_r<T1,T2> a, sc_bitref<T3> b ) 3353{ 3354 return sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >( 3355 *a.clone(), *b.clone(), 3 ); 3356} 3357 3358template <class T1, class T2, class T3> 3359inline 3360sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> > 3361concat( sc_concref<T1,T2> a, sc_bitref_r<T3> b ) 3362{ 3363 return sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >( 3364 *a.clone(), *b.clone(), 3 ); 3365} 3366 3367template <class T1, class T2, class T3> 3368inline 3369sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> > 3370concat( sc_concref_r<T1,T2> a, sc_subref<T3> b ) 3371{ 3372 return sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >( 3373 *a.clone(), *b.clone(), 3 ); 3374} 3375 3376template <class T1, class T2, class T3> 3377inline 3378sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> > 3379concat( sc_concref<T1,T2> a, sc_subref_r<T3> b ) 3380{ 3381 return sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >( 3382 *a.clone(), *b.clone(), 3 ); 3383} 3384 3385template <class T1, class T2, class T3, class T4> 3386inline 3387sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> > 3388concat( sc_concref_r<T1,T2> a, sc_concref<T3,T4> b ) 3389{ 3390 return sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >( 3391 *a.clone(), *b.clone(), 3 ); 3392} 3393 3394template <class T1, class T2, class T3, class T4> 3395inline 3396sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> > 3397concat( sc_concref<T1,T2> a, sc_concref_r<T3,T4> b ) 3398{ 3399 return sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >( 3400 *a.clone(), *b.clone(), 3 ); 3401} 3402 3403template <class T1, class T2, class T3> 3404inline 3405sc_concref_r<sc_concref_r<T1,T2>,T3> 3406concat( sc_concref<T1,T2> a, const sc_proxy<T3>& b ) 3407{ 3408 return sc_concref_r<sc_concref_r<T1,T2>,T3>( 3409 *a.clone(), b.back_cast(), 1 ); 3410} 3411 3412template <class T1, class T2, class T3> 3413inline 3414sc_concref_r<sc_concref_r<T1,T2>,T3> 3415concat( sc_concref_r<T1,T2> a, sc_proxy<T3>& b ) 3416{ 3417 return sc_concref_r<sc_concref_r<T1,T2>,T3>( 3418 *a.clone(), b.back_cast(), 1 ); 3419} 3420 3421#endif 3422 3423 3424// ---------------------------------------------------------------------------- 3425// CLASS TEMPLATE : sc_concref<X,Y> 3426// 3427// Proxy class for sc_proxy concatenation (r-value and l-value). 3428// ---------------------------------------------------------------------------- 3429 3430// other methods 3431 3432template <class T1, class T2> 3433inline 3434void 3435sc_concref<T1,T2>::scan( ::std::istream& is ) 3436{ 3437 std::string s; 3438 is >> s; 3439 *this = s.c_str(); 3440} 3441 3442 3443// l-value concatenation operators and functions 3444 3445template <class T1, class T2, class T3> 3446inline 3447sc_concref<sc_concref<T1,T2>,sc_bitref<T3> > 3448operator , ( sc_concref<T1,T2> a, sc_bitref<T3> b ) 3449{ 3450 return sc_concref<sc_concref<T1,T2>,sc_bitref<T3> >( 3451 *a.clone(), *b.clone(), 3 ); 3452} 3453 3454template <class T1, class T2, class T3> 3455inline 3456sc_concref<sc_concref<T1,T2>,sc_subref<T3> > 3457operator , ( sc_concref<T1,T2> a, sc_subref<T3> b ) 3458{ 3459 return sc_concref<sc_concref<T1,T2>,sc_subref<T3> >( 3460 *a.clone(), *b.clone(), 3 ); 3461} 3462 3463template <class T1, class T2, class T3, class T4> 3464inline 3465sc_concref<sc_concref<T1,T2>,sc_concref<T3,T4> > 3466operator , ( sc_concref<T1,T2> a, sc_concref<T3,T4> b ) 3467{ 3468 return sc_concref<sc_concref<T1,T2>,sc_concref<T3,T4> >( 3469 *a.clone(), *b.clone(), 3 ); 3470} 3471 3472template <class T1, class T2, class T3> 3473inline 3474sc_concref<sc_concref<T1,T2>,T3> 3475operator , ( sc_concref<T1,T2> a, sc_proxy<T3>& b ) 3476{ 3477 return sc_concref<sc_concref<T1,T2>,T3>( 3478 *a.clone(), b.back_cast(), 1 ); 3479} 3480 3481 3482template <class T1, class T2, class T3> 3483inline 3484sc_concref<sc_concref<T1,T2>,sc_bitref<T3> > 3485concat( sc_concref<T1,T2> a, sc_bitref<T3> b ) 3486{ 3487 return sc_concref<sc_concref<T1,T2>,sc_bitref<T3> >( 3488 *a.clone(), *b.clone(), 3 ); 3489} 3490 3491template <class T1, class T2, class T3> 3492inline 3493sc_concref<sc_concref<T1,T2>,sc_subref<T3> > 3494concat( sc_concref<T1,T2> a, sc_subref<T3> b ) 3495{ 3496 return sc_concref<sc_concref<T1,T2>,sc_subref<T3> >( 3497 *a.clone(), *b.clone(), 3 ); 3498} 3499 3500template <class T1, class T2, class T3, class T4> 3501inline 3502sc_concref<sc_concref<T1,T2>,sc_concref<T3,T4> > 3503concat( sc_concref<T1,T2> a, sc_concref<T3,T4> b ) 3504{ 3505 return sc_concref<sc_concref<T1,T2>,sc_concref<T3,T4> >( 3506 *a.clone(), *b.clone(), 3 ); 3507} 3508 3509template <class T1, class T2, class T3> 3510inline 3511sc_concref<sc_concref<T1,T2>,T3> 3512concat( sc_concref<T1,T2> a, sc_proxy<T3>& b ) 3513{ 3514 return sc_concref<sc_concref<T1,T2>,T3>( 3515 *a.clone(), b.back_cast(), 1 ); 3516} 3517 3518 3519template <class X, class Y> 3520inline 3521::std::istream& 3522operator >> ( ::std::istream& is, sc_concref<X,Y> a ) 3523{ 3524 a.scan( is ); 3525 return is; 3526} 3527 3528 3529// ---------------------------------------------------------------------------- 3530// CLASS TEMPLATE : sc_proxy<T> 3531// 3532// Base class template for bit/logic vector classes. 3533// (Barton/Nackmann implementation) 3534// ---------------------------------------------------------------------------- 3535 3536// r-value concatenation operators and functions 3537 3538template <class T1, class T2> 3539inline 3540sc_concref_r<T1,sc_bitref_r<T2> > 3541operator , ( const sc_proxy<T1>& a, sc_bitref_r<T2> b ) 3542{ 3543 return sc_concref_r<T1,sc_bitref_r<T2> >( 3544 a.back_cast(), *b.clone(), 2 ); 3545} 3546 3547template <class T1, class T2> 3548inline 3549sc_concref_r<T1,sc_subref_r<T2> > 3550operator , ( const sc_proxy<T1>& a, sc_subref_r<T2> b ) 3551{ 3552 return sc_concref_r<T1,sc_subref_r<T2> >( 3553 a.back_cast(), *b.clone(), 2 ); 3554} 3555 3556template <class T1, class T2, class T3> 3557inline 3558sc_concref_r<T1,sc_concref_r<T2,T3> > 3559operator , ( const sc_proxy<T1>& a, sc_concref_r<T2,T3> b ) 3560{ 3561 return sc_concref_r<T1,sc_concref_r<T2,T3> >( 3562 a.back_cast(), *b.clone(), 2 ); 3563} 3564 3565template <class T1, class T2> 3566inline 3567sc_concref_r<T1,T2> 3568operator , ( const sc_proxy<T1>& a, const sc_proxy<T2>& b ) 3569{ 3570 return sc_concref_r<T1,T2>( 3571 a.back_cast(), b.back_cast() ); 3572} 3573 3574 3575template <class T1, class T2> 3576inline 3577sc_concref_r<T1,sc_bitref_r<T2> > 3578concat( const sc_proxy<T1>& a, sc_bitref_r<T2> b ) 3579{ 3580 return sc_concref_r<T1,sc_bitref_r<T2> >( 3581 a.back_cast(), *b.clone(), 2 ); 3582} 3583 3584template <class T1, class T2> 3585inline 3586sc_concref_r<T1,sc_subref_r<T2> > 3587concat( const sc_proxy<T1>& a, sc_subref_r<T2> b ) 3588{ 3589 return sc_concref_r<T1,sc_subref_r<T2> >( 3590 a.back_cast(), *b.clone(), 2 ); 3591} 3592 3593template <class T1, class T2, class T3> 3594inline 3595sc_concref_r<T1,sc_concref_r<T2,T3> > 3596concat( const sc_proxy<T1>& a, sc_concref_r<T2,T3> b ) 3597{ 3598 return sc_concref_r<T1,sc_concref_r<T2,T3> >( 3599 a.back_cast(), *b.clone(), 2 ); 3600} 3601 3602template <class T1, class T2> 3603inline 3604sc_concref_r<T1,T2> 3605concat( const sc_proxy<T1>& a, const sc_proxy<T2>& b ) 3606{ 3607 return sc_concref_r<T1,T2>( 3608 a.back_cast(), b.back_cast() ); 3609} 3610 3611 3612#ifdef SC_DT_MIXED_COMMA_OPERATORS 3613 3614template <class T1, class T2> 3615inline 3616sc_concref_r<T1,sc_bitref_r<T2> > 3617operator , ( const sc_proxy<T1>& a, sc_bitref<T2> b ) 3618{ 3619 return sc_concref_r<T1,sc_bitref_r<T2> >( 3620 a.back_cast(), *b.clone(), 2 ); 3621} 3622 3623template <class T1, class T2> 3624inline 3625sc_concref_r<T1,sc_bitref_r<T2> > 3626operator , ( sc_proxy<T1>& a, sc_bitref_r<T2> b ) 3627{ 3628 return sc_concref_r<T1,sc_bitref_r<T2> >( 3629 a.back_cast(), *b.clone(), 2 ); 3630} 3631 3632template <class T1, class T2> 3633inline 3634sc_concref_r<T1,sc_subref_r<T2> > 3635operator , ( const sc_proxy<T1>& a, sc_subref<T2> b ) 3636{ 3637 return sc_concref_r<T1,sc_subref_r<T2> >( 3638 a.back_cast(), *b.clone(), 2 ); 3639} 3640 3641template <class T1, class T2> 3642inline 3643sc_concref_r<T1,sc_subref_r<T2> > 3644operator , ( sc_proxy<T1>& a, sc_subref_r<T2> b ) 3645{ 3646 return sc_concref_r<T1,sc_subref_r<T2> >( 3647 a.back_cast(), *b.clone(), 2 ); 3648} 3649 3650template <class T1, class T2, class T3> 3651inline 3652sc_concref_r<T1,sc_concref_r<T2,T3> > 3653operator , ( const sc_proxy<T1>& a, sc_concref<T2,T3> b ) 3654{ 3655 return sc_concref_r<T1,sc_concref_r<T2,T3> >( 3656 a.back_cast(), *b.clone(), 2 ); 3657} 3658 3659template <class T1, class T2, class T3> 3660inline 3661sc_concref_r<T1,sc_concref_r<T2,T3> > 3662operator , ( sc_proxy<T1>& a, sc_concref_r<T2,T3> b ) 3663{ 3664 return sc_concref_r<T1,sc_concref_r<T2,T3> >( 3665 a.back_cast(), *b.clone(), 2 ); 3666} 3667 3668template <class T1, class T2> 3669inline 3670sc_concref_r<T1,T2> 3671operator , ( const sc_proxy<T1>& a, sc_proxy<T2>& b ) 3672{ 3673 return sc_concref_r<T1,T2>( 3674 a.back_cast(), b.back_cast() ); 3675} 3676 3677template <class T1, class T2> 3678inline 3679sc_concref_r<T1,T2> 3680operator , ( sc_proxy<T1>& a, const sc_proxy<T2>& b ) 3681{ 3682 return sc_concref_r<T1,T2>( 3683 a.back_cast(), b.back_cast() ); 3684} 3685 3686 3687template <class T1, class T2> 3688inline 3689sc_concref_r<T1,sc_bitref_r<T2> > 3690concat( const sc_proxy<T1>& a, sc_bitref<T2> b ) 3691{ 3692 return sc_concref_r<T1,sc_bitref_r<T2> >( 3693 a.back_cast(), *b.clone(), 2 ); 3694} 3695 3696template <class T1, class T2> 3697inline 3698sc_concref_r<T1,sc_bitref_r<T2> > 3699concat( sc_proxy<T1>& a, sc_bitref_r<T2> b ) 3700{ 3701 return sc_concref_r<T1,sc_bitref_r<T2> >( 3702 a.back_cast(), *b.clone(), 2 ); 3703} 3704 3705template <class T1, class T2> 3706inline 3707sc_concref_r<T1,sc_subref_r<T2> > 3708concat( const sc_proxy<T1>& a, sc_subref<T2> b ) 3709{ 3710 return sc_concref_r<T1,sc_subref_r<T2> >( 3711 a.back_cast(), *b.clone(), 2 ); 3712} 3713 3714template <class T1, class T2> 3715inline 3716sc_concref_r<T1,sc_subref_r<T2> > 3717concat( sc_proxy<T1>& a, sc_subref_r<T2> b ) 3718{ 3719 return sc_concref_r<T1,sc_subref_r<T2> >( 3720 a.back_cast(), *b.clone(), 2 ); 3721} 3722 3723template <class T1, class T2, class T3> 3724inline 3725sc_concref_r<T1,sc_concref_r<T2,T3> > 3726concat( const sc_proxy<T1>& a, sc_concref<T2,T3> b ) 3727{ 3728 return sc_concref_r<T1,sc_concref_r<T2,T3> >( 3729 a.back_cast(), *b.clone(), 2 ); 3730} 3731 3732template <class T1, class T2, class T3> 3733inline 3734sc_concref_r<T1,sc_concref_r<T2,T3> > 3735concat( sc_proxy<T1>& a, sc_concref_r<T2,T3> b ) 3736{ 3737 return sc_concref_r<T1,sc_concref_r<T2,T3> >( 3738 a.back_cast(), *b.clone(), 2 ); 3739} 3740 3741template <class T1, class T2> 3742inline 3743sc_concref_r<T1,T2> 3744concat( const sc_proxy<T1>& a, sc_proxy<T2>& b ) 3745{ 3746 return sc_concref_r<T1,T2>( 3747 a.back_cast(), b.back_cast() ); 3748} 3749 3750template <class T1, class T2> 3751inline 3752sc_concref_r<T1,T2> 3753concat( sc_proxy<T1>& a, const sc_proxy<T2>& b ) 3754{ 3755 return sc_concref_r<T1,T2>( 3756 a.back_cast(), b.back_cast() ); 3757} 3758 3759#endif 3760 3761 3762// l-value concatenation operators and functions 3763 3764template <class T1, class T2> 3765inline 3766sc_concref<T1,sc_bitref<T2> > 3767operator , ( sc_proxy<T1>& a, sc_bitref<T2> b ) 3768{ 3769 return sc_concref<T1,sc_bitref<T2> >( 3770 a.back_cast(), *b.clone(), 2 ); 3771} 3772 3773template <class T1, class T2> 3774inline 3775sc_concref<T1,sc_subref<T2> > 3776operator , ( sc_proxy<T1>& a, sc_subref<T2> b ) 3777{ 3778 return sc_concref<T1,sc_subref<T2> >( 3779 a.back_cast(), *b.clone(), 2 ); 3780} 3781 3782template <class T1, class T2, class T3> 3783inline 3784sc_concref<T1,sc_concref<T2,T3> > 3785operator , ( sc_proxy<T1>& a, sc_concref<T2,T3> b ) 3786{ 3787 return sc_concref<T1,sc_concref<T2,T3> >( 3788 a.back_cast(), *b.clone(), 2 ); 3789} 3790 3791template <class T1, class T2> 3792inline 3793sc_concref<T1,T2> 3794operator , ( sc_proxy<T1>& a, sc_proxy<T2>& b ) 3795{ 3796 return sc_concref<T1,T2>( 3797 a.back_cast(), b.back_cast() ); 3798} 3799 3800 3801template <class T1, class T2> 3802inline 3803sc_concref<T1,sc_bitref<T2> > 3804concat( sc_proxy<T1>& a, sc_bitref<T2> b ) 3805{ 3806 return sc_concref<T1,sc_bitref<T2> >( 3807 a.back_cast(), *b.clone(), 2 ); 3808} 3809 3810template <class T1, class T2> 3811inline 3812sc_concref<T1,sc_subref<T2> > 3813concat( sc_proxy<T1>& a, sc_subref<T2> b ) 3814{ 3815 return sc_concref<T1,sc_subref<T2> >( 3816 a.back_cast(), *b.clone(), 2 ); 3817} 3818 3819template <class T1, class T2, class T3> 3820inline 3821sc_concref<T1,sc_concref<T2,T3> > 3822concat( sc_proxy<T1>& a, sc_concref<T2,T3> b ) 3823{ 3824 return sc_concref<T1,sc_concref<T2,T3> >( 3825 a.back_cast(), *b.clone(), 2 ); 3826} 3827 3828template <class T1, class T2> 3829inline 3830sc_concref<T1,T2> 3831concat( sc_proxy<T1>& a, sc_proxy<T2>& b ) 3832{ 3833 return sc_concref<T1,T2>( 3834 a.back_cast(), b.back_cast() ); 3835} 3836 3837} // namespace sc_dt 3838 3839// $Log: sc_bit_proxies.h,v $ 3840// Revision 1.10 2011/09/05 21:19:53 acg 3841// Philipp A. Hartmann: added parentheses to expressions to eliminate 3842// compiler warnings. 3843// 3844// Revision 1.9 2011/09/01 15:03:42 acg 3845// Philipp A. Hartmann: add parentheses to eliminate compiler warnings. 3846// 3847// Revision 1.8 2011/08/29 18:04:32 acg 3848// Philipp A. Hartmann: miscellaneous clean ups. 3849// 3850// Revision 1.7 2011/08/24 22:05:40 acg 3851// Torsten Maehne: initialization changes to remove warnings. 3852// 3853// Revision 1.6 2010/02/22 14:25:43 acg 3854// Andy Goodrich: removed 'mutable' directive from references, since it 3855// is not a legal C++ construct. 3856// 3857// Revision 1.5 2009/02/28 00:26:14 acg 3858// Andy Goodrich: bug fixes. 3859// 3860// Revision 1.4 2007/03/14 17:48:37 acg 3861// Andy Goodrich: fixed bug. 3862// 3863// Revision 1.3 2007/01/18 19:29:18 acg 3864// Andy Goodrich: fixed bug in concatenations of bit selects on sc_lv and 3865// sc_bv types. The offending code was in sc_bitref<X>::set_word and 3866// sc_bitref<X>::get_word. These methods were not writing the bit they 3867// represented, but rather writing an entire word whose index was the 3868// index of the bit they represented. This not only did not write the 3869// correct bit, but clobbered a word that might not even be in the 3870// variable the reference was for. 3871// 3872// Revision 1.2 2007/01/17 22:45:08 acg 3873// Andy Goodrich: fixed sc_bitref<X>::set_bit(). 3874// 3875// Revision 1.1.1.1 2006/12/15 20:31:36 acg 3876// SystemC 2.2 3877// 3878// Revision 1.3 2006/01/13 18:53:53 acg 3879// Andy Goodrich: added $Log command so that CVS comments are reproduced in 3880// the source. 3881// 3882 3883 3884#endif 3885