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