sc_unsigned.h revision 12027:1eb7dc7aa10b
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_unsigned.h -- Arbitrary precision unsigned arithmetic. 23 24 This file includes the definitions of sc_unsigned_bitref, 25 sc_unsigned_subref, and sc_unsigned classes. The first two classes 26 are proxy classes to reference one bit and a range of bits of a 27 sc_unsigned number, respectively. 28 29 An sc_signed number has the sign-magnitude representation 30 internally. However, its interface guarantees a 2's-complement 31 representation. The sign-magnitude representation is chosen 32 because of its efficiency: The sc_signed and sc_unsigned types are 33 optimized for arithmetic rather than bitwise operations. For 34 arithmetic operations, the sign-magnitude representation performs 35 better. 36 37 It is also important to note that an sc_unsigned number with n 38 bits is equivalent to an sc_signed non-negative number with n + 1 39 bits. 40 41 The implementations of sc_signed and sc_unsigned classes are 42 almost identical: Most of the member and friend functions are 43 defined in sc_nbcommon.cpp and sc_nbfriends.cpp so that they can 44 be shared by both of these classes. These functions are chosed by 45 defining a few macros before including them such as IF_SC_SIGNED 46 and CLASS_TYPE. Our implementation choices are mostly dictated by 47 performance considerations in that we tried to provide the most 48 efficient sc_signed and sc_unsigned types without compromising 49 their interface. 50 51 For the behavior of operators, we have two semantics: the old and 52 new. The most important difference between these two semantics is 53 that the old semantics is closer to C/C++ semantics in that the 54 result type of a binary operator on unsigned and signed arguments 55 is unsigned; the new semantics, on the other hand, requires the 56 result type be signed. The new semantics is required by the VSIA 57 C/C++ data types standard. We have implemented the new semantics. 58 59 Original Author: Ali Dasdan, Synopsys, Inc. 60 61 *****************************************************************************/ 62 63/***************************************************************************** 64 65 MODIFICATION LOG - modifiers, enter your name, affiliation, date and 66 changes you are making here. 67 68 Name, Affiliation, Date: 69 Description of Modification: 70 71 *****************************************************************************/ 72 73// $Log: sc_unsigned.h,v $ 74// Revision 1.4 2011/08/24 22:05:46 acg 75// Torsten Maehne: initialization changes to remove warnings. 76// 77// Revision 1.3 2011/02/18 20:19:15 acg 78// Andy Goodrich: updating Copyright notice. 79// 80// Revision 1.2 2009/02/28 00:26:26 acg 81// Andy Goodrich: bug fixes. 82// 83// Revision 1.1.1.1 2006/12/15 20:20:05 acg 84// SystemC 2.3 85// 86// Revision 1.5 2006/05/08 17:50:02 acg 87// Andy Goodrich: Added David Long's declarations for friend operators, 88// functions, and methods, to keep the Microsoft compiler happy. 89// 90// Revision 1.4 2006/03/13 20:25:27 acg 91// Andy Goodrich: Addition of function declarations, e.g., xor_signed_friend() 92// to keep gcc 4.x happy. 93// 94// Revision 1.3 2006/01/13 18:49:32 acg 95// Added $Log command so that CVS check in comments are reproduced in the 96// source. 97// 98 99#ifndef SC_UNSIGNED_H 100#define SC_UNSIGNED_H 101 102 103#include "sysc/kernel/sc_object.h" 104#include "sysc/datatypes/misc/sc_value_base.h" 105#include "sysc/utils/sc_iostream.h" 106#include "sysc/utils/sc_temporary.h" 107#include "sysc/datatypes/int/sc_length_param.h" 108#include "sysc/datatypes/int/sc_nbdefs.h" 109#include "sysc/datatypes/int/sc_nbutils.h" 110#include "sysc/datatypes/int/sc_nbexterns.h" 111#include "sysc/utils/sc_temporary.h" 112 113 114namespace sc_dt 115{ 116 117// classes defined in this module 118class sc_unsigned_bitref_r; 119class sc_unsigned_bitref; 120class sc_unsigned_subref_r; 121class sc_unsigned_subref; 122class sc_concatref; 123class sc_unsigned; 124 125// forward class declarations 126class sc_bv_base; 127class sc_lv_base; 128class sc_int_base; 129class sc_uint_base; 130class sc_int_subref_r; 131class sc_uint_subref_r; 132class sc_signed; 133class sc_signed_subref_r; 134class sc_fxval; 135class sc_fxval_fast; 136class sc_fxnum; 137class sc_fxnum_fast; 138 139// Helper function declarions 140int compare_unsigned(small_type us, 141 int unb, 142 int und, 143 const sc_digit *ud, 144 small_type vs, 145 int vnb, 146 int vnd, 147 const sc_digit *vd, 148 small_type if_u_signed=0, 149 small_type if_v_signed=0); 150 151sc_unsigned add_unsigned_friend(small_type us, 152 int unb, 153 int und, 154 const sc_digit *ud, 155 small_type vs, 156 int vnb, 157 int vnd, 158 const sc_digit *vd); 159 160sc_unsigned sub_unsigned_friend(small_type us, 161 int unb, 162 int und, 163 const sc_digit *ud, 164 small_type vs, 165 int vnb, 166 int vnd, 167 const sc_digit *vd); 168 169sc_unsigned mul_unsigned_friend(small_type s, 170 int unb, 171 int und, 172 const sc_digit *ud, 173 int vnb, 174 int vnd, 175 const sc_digit *vd); 176 177sc_unsigned div_unsigned_friend(small_type s, 178 int unb, 179 int und, 180 const sc_digit *ud, 181 int vnb, 182 int vnd, 183 const sc_digit *vd); 184 185sc_unsigned mod_unsigned_friend(small_type us, 186 int unb, 187 int und, 188 const sc_digit *ud, 189 int vnb, 190 int vnd, 191 const sc_digit *vd); 192 193sc_unsigned and_unsigned_friend(small_type us, 194 int unb, 195 int und, 196 const sc_digit *ud, 197 small_type vs, 198 int vnb, 199 int vnd, 200 const sc_digit *vd); 201 202 203sc_unsigned or_unsigned_friend(small_type us, 204 int unb, 205 int und, 206 const sc_digit *ud, 207 small_type vs, 208 int vnb, 209 int vnd, 210 const sc_digit *vd); 211 212sc_unsigned xor_unsigned_friend(small_type us, 213 int unb, 214 int und, 215 const sc_digit *ud, 216 small_type vs, 217 int vnb, 218 int vnd, 219 const sc_digit *vd); 220 221// friend operator declarations 222 // ARITHMETIC OPERATORS: 223 224 // ADDition operators: 225 226 sc_signed operator + (const sc_unsigned& u, const sc_signed& v); 227 sc_signed operator + (const sc_signed& u, const sc_unsigned& v); 228 229 sc_unsigned operator + (const sc_unsigned& u, const sc_unsigned& v); 230 sc_signed operator + (const sc_unsigned& u, int64 v); 231 sc_unsigned operator + (const sc_unsigned& u, uint64 v); 232 sc_signed operator + (const sc_unsigned& u, long v); 233 sc_unsigned operator + (const sc_unsigned& u, unsigned long v); 234 sc_signed operator + (const sc_unsigned& u, int v); 235 inline sc_unsigned operator + (const sc_unsigned& u, unsigned int v); 236 237 sc_signed operator + (int64 u, const sc_unsigned& v); 238 sc_unsigned operator + (uint64 u, const sc_unsigned& v); 239 sc_signed operator + (long u, const sc_unsigned& v); 240 sc_unsigned operator + (unsigned long u, const sc_unsigned& v); 241 sc_signed operator + (int u, const sc_unsigned& v); 242 inline sc_unsigned operator + (unsigned int u, const sc_unsigned& v); 243 244 sc_unsigned operator + (const sc_unsigned& u, const sc_uint_base& v); 245 sc_signed operator + (const sc_unsigned& u, const sc_int_base& v); 246 sc_unsigned operator + (const sc_uint_base& u, const sc_unsigned& v); 247 sc_signed operator + (const sc_int_base& u, const sc_unsigned& v); 248 249 // SUBtraction operators: 250 251 sc_signed operator - (const sc_unsigned& u, const sc_signed& v); 252 sc_signed operator - (const sc_signed& u, const sc_unsigned& v); 253 254 sc_signed operator - (const sc_unsigned& u, const sc_unsigned& v); 255 sc_signed operator - (const sc_unsigned& u, int64 v); 256 sc_signed operator - (const sc_unsigned& u, uint64 v); 257 sc_signed operator - (const sc_unsigned& u, long v); 258 sc_signed operator - (const sc_unsigned& u, unsigned long v); 259 sc_signed operator - (const sc_unsigned& u, int v); 260 sc_signed operator - (const sc_unsigned& u, unsigned int v); 261 262 sc_signed operator - (int64 u, const sc_unsigned& v); 263 sc_signed operator - (uint64 u, const sc_unsigned& v); 264 sc_signed operator - (long u, const sc_unsigned& v); 265 sc_signed operator - (unsigned long u, const sc_unsigned& v); 266 sc_signed operator - (int u, const sc_unsigned& v); 267 sc_signed operator - (unsigned int u, const sc_unsigned& v); 268 269 sc_signed operator - (const sc_unsigned& u, const sc_uint_base& v); 270 sc_signed operator - (const sc_unsigned& u, const sc_int_base& v); 271 sc_signed operator - (const sc_uint_base& u, const sc_unsigned& v); 272 sc_signed operator - (const sc_int_base& u, const sc_unsigned& v); 273 274 // MULtiplication operators: 275 276 sc_signed operator * (const sc_unsigned& u, const sc_signed& v); 277 sc_signed operator * (const sc_signed& u, const sc_unsigned& v); 278 279 sc_unsigned operator * (const sc_unsigned& u, const sc_unsigned& v); 280 sc_signed operator * (const sc_unsigned& u, int64 v); 281 sc_unsigned operator * (const sc_unsigned& u, uint64 v); 282 sc_signed operator * (const sc_unsigned& u, long v); 283 sc_unsigned operator * (const sc_unsigned& u, unsigned long v); 284 sc_signed operator * (const sc_unsigned& u, int v); 285 inline sc_unsigned operator * (const sc_unsigned& u, unsigned int v); 286 287 sc_signed operator * (int64 u, const sc_unsigned& v); 288 sc_unsigned operator * (uint64 u, const sc_unsigned& v); 289 sc_signed operator * (long u, const sc_unsigned& v); 290 sc_unsigned operator * (unsigned long u, const sc_unsigned& v); 291 sc_signed operator * (int u, const sc_unsigned& v); 292 inline sc_unsigned operator * (unsigned int u, const sc_unsigned& v); 293 294 sc_unsigned operator * (const sc_unsigned& u, const sc_uint_base& v); 295 sc_signed operator * (const sc_unsigned& u, const sc_int_base& v); 296 sc_unsigned operator * (const sc_uint_base& u, const sc_unsigned& v); 297 sc_signed operator * (const sc_int_base& u, const sc_unsigned& v); 298 299 // DIVision operators: 300 301 sc_signed operator / (const sc_unsigned& u, const sc_signed& v); 302 sc_signed operator / (const sc_signed& u, const sc_unsigned& v); 303 304 sc_unsigned operator / (const sc_unsigned& u, const sc_unsigned& v); 305 sc_signed operator / (const sc_unsigned& u, int64 v); 306 sc_unsigned operator / (const sc_unsigned& u, uint64 v); 307 sc_signed operator / (const sc_unsigned& u, long v); 308 sc_unsigned operator / (const sc_unsigned& u, unsigned long v); 309 sc_signed operator / (const sc_unsigned& u, int v); 310 inline sc_unsigned operator / (const sc_unsigned& u, unsigned int v); 311 312 sc_signed operator / (int64 u, const sc_unsigned& v); 313 sc_unsigned operator / (uint64 u, const sc_unsigned& v); 314 sc_signed operator / (long u, const sc_unsigned& v); 315 sc_unsigned operator / (unsigned long u, const sc_unsigned& v); 316 sc_signed operator / (int u, const sc_unsigned& v); 317 inline sc_unsigned operator / (unsigned int u, const sc_unsigned& v); 318 319 sc_unsigned operator / (const sc_unsigned& u, const sc_uint_base& v); 320 sc_signed operator / (const sc_unsigned& u, const sc_int_base& v); 321 sc_unsigned operator / (const sc_uint_base& u, const sc_unsigned& v); 322 sc_signed operator / (const sc_int_base& u, const sc_unsigned& v); 323 324 // MODulo operators: 325 326 sc_signed operator % (const sc_unsigned& u, const sc_signed& v); 327 sc_signed operator % (const sc_signed& u, const sc_unsigned& v); 328 329 sc_unsigned operator % (const sc_unsigned& u, const sc_unsigned& v); 330 sc_signed operator % (const sc_unsigned& u, int64 v); 331 sc_unsigned operator % (const sc_unsigned& u, uint64 v); 332 sc_signed operator % (const sc_unsigned& u, long v); 333 sc_unsigned operator % (const sc_unsigned& u, unsigned long v); 334 sc_signed operator % (const sc_unsigned& u, int v); 335 inline sc_unsigned operator % (const sc_unsigned& u, unsigned int v); 336 337 sc_signed operator % (int64 u, const sc_unsigned& v); 338 sc_unsigned operator % (uint64 u, const sc_unsigned& v); 339 sc_signed operator % (long u, const sc_unsigned& v); 340 sc_unsigned operator % (unsigned long u, const sc_unsigned& v); 341 sc_signed operator % (int u, const sc_unsigned& v); 342 inline sc_unsigned operator % (unsigned int u, const sc_unsigned& v); 343 344 sc_unsigned operator % (const sc_unsigned& u, const sc_uint_base& v); 345 sc_signed operator % (const sc_unsigned& u, const sc_int_base& v); 346 sc_unsigned operator % (const sc_uint_base& u, const sc_unsigned& v); 347 sc_signed operator % (const sc_int_base& u, const sc_unsigned& v); 348 349 // BITWISE OPERATORS: 350 351 // Bitwise AND operators: 352 353 sc_signed operator & (const sc_unsigned& u, const sc_signed& v); 354 sc_signed operator & (const sc_signed& u, const sc_unsigned& v); 355 356 sc_unsigned operator & (const sc_unsigned& u, const sc_unsigned& v); 357 sc_signed operator & (const sc_unsigned& u, int64 v); 358 sc_unsigned operator & (const sc_unsigned& u, uint64 v); 359 sc_signed operator & (const sc_unsigned& u, long v); 360 sc_unsigned operator & (const sc_unsigned& u, unsigned long v); 361 sc_signed operator & (const sc_unsigned& u, int v); 362 inline sc_unsigned operator & (const sc_unsigned& u, unsigned int v); 363 364 sc_signed operator & (int64 u, const sc_unsigned& v); 365 sc_unsigned operator & (uint64 u, const sc_unsigned& v); 366 sc_signed operator & (long u, const sc_unsigned& v); 367 sc_unsigned operator & (unsigned long u, const sc_unsigned& v); 368 sc_signed operator & (int u, const sc_unsigned& v); 369 inline sc_unsigned operator & (unsigned int u, const sc_unsigned& v); 370 371 sc_unsigned operator & (const sc_unsigned& u, const sc_uint_base& v); 372 sc_signed operator & (const sc_unsigned& u, const sc_int_base& v); 373 sc_unsigned operator & (const sc_uint_base& u, const sc_unsigned& v); 374 sc_signed operator & (const sc_int_base& u, const sc_unsigned& v); 375 376 // Bitwise OR operators: 377 378 sc_signed operator | (const sc_unsigned& u, const sc_signed& v); 379 sc_signed operator | (const sc_signed& u, const sc_unsigned& v); 380 381 sc_unsigned operator | (const sc_unsigned& u, const sc_unsigned& v); 382 sc_signed operator | (const sc_unsigned& u, int64 v); 383 sc_unsigned operator | (const sc_unsigned& u, uint64 v); 384 sc_signed operator | (const sc_unsigned& u, long v); 385 sc_unsigned operator | (const sc_unsigned& u, unsigned long v); 386 sc_signed operator | (const sc_unsigned& u, int v); 387 inline sc_unsigned operator | (const sc_unsigned& u, unsigned int v); 388 389 sc_signed operator | (int64 u, const sc_unsigned& v); 390 sc_unsigned operator | (uint64 u, const sc_unsigned& v); 391 sc_signed operator | (long u, const sc_unsigned& v); 392 sc_unsigned operator | (unsigned long u, const sc_unsigned& v); 393 sc_signed operator | (int u, const sc_unsigned& v); 394 inline sc_unsigned operator | (unsigned int u, const sc_unsigned& v); 395 396 sc_unsigned operator | (const sc_unsigned& u, const sc_uint_base& v); 397 sc_signed operator | (const sc_unsigned& u, const sc_int_base& v); 398 sc_unsigned operator | (const sc_uint_base& u, const sc_unsigned& v); 399 sc_signed operator | (const sc_int_base& u, const sc_unsigned& v); 400 401 // Bitwise XOR operators: 402 403 sc_signed operator ^ (const sc_unsigned& u, const sc_signed& v); 404 sc_signed operator ^ (const sc_signed& u, const sc_unsigned& v); 405 406 sc_unsigned operator ^ (const sc_unsigned& u, const sc_unsigned& v); 407 sc_signed operator ^ (const sc_unsigned& u, int64 v); 408 sc_unsigned operator ^ (const sc_unsigned& u, uint64 v); 409 sc_signed operator ^ (const sc_unsigned& u, long v); 410 sc_unsigned operator ^ (const sc_unsigned& u, unsigned long v); 411 sc_signed operator ^ (const sc_unsigned& u, int v); 412 inline sc_unsigned operator ^ (const sc_unsigned& u, unsigned int v); 413 414 sc_signed operator ^ (int64 u, const sc_unsigned& v); 415 sc_unsigned operator ^ (uint64 u, const sc_unsigned& v); 416 sc_signed operator ^ (long u, const sc_unsigned& v); 417 sc_unsigned operator ^ (unsigned long u, const sc_unsigned& v); 418 sc_signed operator ^ (int u, const sc_unsigned& v); 419 inline sc_unsigned operator ^ (unsigned int u, const sc_unsigned& v); 420 421 sc_unsigned operator ^ (const sc_unsigned& u, const sc_uint_base& v); 422 sc_signed operator ^ (const sc_unsigned& u, const sc_int_base& v); 423 sc_unsigned operator ^ (const sc_uint_base& u, const sc_unsigned& v); 424 sc_signed operator ^ (const sc_int_base& u, const sc_unsigned& v); 425 426 // SHIFT OPERATORS: 427 428 // LEFT SHIFT operators: 429 430 sc_unsigned operator << (const sc_unsigned& u, const sc_signed& v); 431 sc_signed operator << (const sc_signed& u, const sc_unsigned& v); 432 433 sc_unsigned operator << (const sc_unsigned& u, const sc_unsigned& v); 434 sc_unsigned operator << (const sc_unsigned& u, int64 v); 435 sc_unsigned operator << (const sc_unsigned& u, uint64 v); 436 sc_unsigned operator << (const sc_unsigned& u, long v); 437 sc_unsigned operator << (const sc_unsigned& u, unsigned long v); 438 inline sc_unsigned operator << (const sc_unsigned& u, int v); 439 inline sc_unsigned operator << (const sc_unsigned& u, unsigned int v); 440 441 sc_unsigned operator << (const sc_unsigned& u, const sc_uint_base& v); 442 sc_unsigned operator << (const sc_unsigned& u, const sc_int_base& v); 443 444 // RIGHT SHIFT operators: 445 446 sc_unsigned operator >> (const sc_unsigned& u, const sc_signed& v); 447 sc_signed operator >> (const sc_signed& u, const sc_unsigned& v); 448 449 sc_unsigned operator >> (const sc_unsigned& u, const sc_unsigned& v); 450 sc_unsigned operator >> (const sc_unsigned& u, int64 v); 451 sc_unsigned operator >> (const sc_unsigned& u, uint64 v); 452 sc_unsigned operator >> (const sc_unsigned& u, long v); 453 sc_unsigned operator >> (const sc_unsigned& u, unsigned long v); 454 inline sc_unsigned operator >> (const sc_unsigned& u, int v); 455 inline sc_unsigned operator >> (const sc_unsigned& u, unsigned int v); 456 457 sc_unsigned operator >> ( const sc_unsigned& , const sc_uint_base& ); 458 sc_unsigned operator >> ( const sc_unsigned&, const sc_int_base& ); 459 460 // Unary arithmetic operators 461 sc_unsigned operator + (const sc_unsigned& u); 462 sc_signed operator - (const sc_unsigned& u); 463 464 // LOGICAL OPERATORS: 465 466 // Logical EQUAL operators: 467 468 bool operator == (const sc_unsigned& u, const sc_signed& v); 469 bool operator == (const sc_signed& u, const sc_unsigned& v); 470 471 bool operator == (const sc_unsigned& u, const sc_unsigned& v); 472 bool operator == (const sc_unsigned& u, int64 v); 473 bool operator == (const sc_unsigned& u, uint64 v); 474 bool operator == (const sc_unsigned& u, long v); 475 bool operator == (const sc_unsigned& u, unsigned long v); 476 inline bool operator == (const sc_unsigned& u, int v); 477 inline bool operator == (const sc_unsigned& u, unsigned int v); 478 479 bool operator == (int64 u, const sc_unsigned& v); 480 bool operator == (uint64 u, const sc_unsigned& v); 481 bool operator == (long u, const sc_unsigned& v); 482 bool operator == (unsigned long u, const sc_unsigned& v); 483 inline bool operator == (int u, const sc_unsigned& v); 484 inline bool operator == (unsigned int u, const sc_unsigned& v) ; 485 486 bool operator == (const sc_unsigned& u, const sc_uint_base& v); 487 bool operator == (const sc_unsigned& u, const sc_int_base& v); 488 bool operator == (const sc_uint_base& u, const sc_unsigned& v); 489 bool operator == (const sc_int_base& u, const sc_unsigned& v); 490 491 // Logical NOT_EQUAL operators: 492 493 bool operator != (const sc_unsigned& u, const sc_signed& v); 494 bool operator != (const sc_signed& u, const sc_unsigned& v); 495 496 bool operator != (const sc_unsigned& u, const sc_unsigned& v); 497 bool operator != (const sc_unsigned& u, int64 v); 498 bool operator != (const sc_unsigned& u, uint64 v); 499 bool operator != (const sc_unsigned& u, long v); 500 bool operator != (const sc_unsigned& u, unsigned long v); 501 inline bool operator != (const sc_unsigned& u, int v); 502 inline bool operator != (const sc_unsigned& u, unsigned int v); 503 504 bool operator != (int64 u, const sc_unsigned& v); 505 bool operator != (uint64 u, const sc_unsigned& v); 506 bool operator != (long u, const sc_unsigned& v); 507 bool operator != (unsigned long u, const sc_unsigned& v); 508 inline bool operator != (int u, const sc_unsigned& v); 509 inline bool operator != (unsigned int u, const sc_unsigned& v); 510 511 bool operator != (const sc_unsigned& u, const sc_uint_base& v); 512 bool operator != (const sc_unsigned& u, const sc_int_base& v); 513 bool operator != (const sc_uint_base& u, const sc_unsigned& v); 514 bool operator != (const sc_int_base& u, const sc_unsigned& v); 515 516 // Logical LESS_THAN operators: 517 518 bool operator < (const sc_unsigned& u, const sc_signed& v); 519 bool operator < (const sc_signed& u, const sc_unsigned& v); 520 521 bool operator < (const sc_unsigned& u, const sc_unsigned& v); 522 bool operator < (const sc_unsigned& u, int64 v); 523 bool operator < (const sc_unsigned& u, uint64 v); 524 bool operator < (const sc_unsigned& u, long v); 525 bool operator < (const sc_unsigned& u, unsigned long v); 526 inline bool operator < (const sc_unsigned& u, int v); 527 inline bool operator < (const sc_unsigned& u, unsigned int v); 528 529 bool operator < (int64 u, const sc_unsigned& v); 530 bool operator < (uint64 u, const sc_unsigned& v); 531 bool operator < (long u, const sc_unsigned& v); 532 bool operator < (unsigned long u, const sc_unsigned& v); 533 inline bool operator < (int u, const sc_unsigned& v); 534 inline bool operator < (unsigned int u, const sc_unsigned& v); 535 536 bool operator < (const sc_unsigned& u, const sc_uint_base& v); 537 bool operator < (const sc_unsigned& u, const sc_int_base& v); 538 bool operator < (const sc_uint_base& u, const sc_unsigned& v); 539 bool operator < (const sc_int_base& u, const sc_unsigned& v); 540 541 // Logical LESS_THAN_AND_EQUAL operators: 542 543 bool operator <= (const sc_unsigned& u, const sc_signed& v); 544 bool operator <= (const sc_signed& u, const sc_unsigned& v); 545 546 bool operator <= (const sc_unsigned& u, const sc_unsigned& v); 547 bool operator <= (const sc_unsigned& u, int64 v); 548 bool operator <= (const sc_unsigned& u, uint64 v); 549 bool operator <= (const sc_unsigned& u, long v); 550 bool operator <= (const sc_unsigned& u, unsigned long v); 551 inline bool operator <= (const sc_unsigned& u, int v); 552 inline bool operator <= (const sc_unsigned& u, unsigned int v); 553 554 bool operator <= (int64 u, const sc_unsigned& v); 555 bool operator <= (uint64 u, const sc_unsigned& v); 556 bool operator <= (long u, const sc_unsigned& v); 557 bool operator <= (unsigned long u, const sc_unsigned& v); 558 inline bool operator <= (int u, const sc_unsigned& v); 559 inline bool operator <= (unsigned int u, const sc_unsigned& v); 560 561 bool operator <= (const sc_unsigned& u, const sc_uint_base& v); 562 bool operator <= (const sc_unsigned& u, const sc_int_base& v); 563 bool operator <= (const sc_uint_base& u, const sc_unsigned& v); 564 bool operator <= (const sc_int_base& u, const sc_unsigned& v); 565 566 // Logical GREATER_THAN operators: 567 568 bool operator > (const sc_unsigned& u, const sc_signed& v); 569 bool operator > (const sc_signed& u, const sc_unsigned& v); 570 571 bool operator > (const sc_unsigned& u, const sc_unsigned& v); 572 bool operator > (const sc_unsigned& u, int64 v); 573 bool operator > (const sc_unsigned& u, uint64 v); 574 bool operator > (const sc_unsigned& u, long v); 575 bool operator > (const sc_unsigned& u, unsigned long v); 576 inline bool operator > (const sc_unsigned& u, int v); 577 inline bool operator > (const sc_unsigned& u, unsigned int v); 578 579 bool operator > (int64 u, const sc_unsigned& v); 580 bool operator > (uint64 u, const sc_unsigned& v); 581 bool operator > (long u, const sc_unsigned& v); 582 bool operator > (unsigned long u, const sc_unsigned& v); 583 inline bool operator > (int u, const sc_unsigned& v); 584 inline bool operator > (unsigned int u, const sc_unsigned& v); 585 586 bool operator > (const sc_unsigned& u, const sc_uint_base& v); 587 bool operator > (const sc_unsigned& u, const sc_int_base& v); 588 bool operator > (const sc_uint_base& u, const sc_unsigned& v); 589 bool operator > (const sc_int_base& u, const sc_unsigned& v); 590 591 // Logical GREATER_THAN_AND_EQUAL operators: 592 593 bool operator >= (const sc_unsigned& u, const sc_signed& v); 594 bool operator >= (const sc_signed& u, const sc_unsigned& v); 595 596 bool operator >= (const sc_unsigned& u, const sc_unsigned& v); 597 bool operator >= (const sc_unsigned& u, int64 v); 598 bool operator >= (const sc_unsigned& u, uint64 v); 599 bool operator >= (const sc_unsigned& u, long v); 600 bool operator >= (const sc_unsigned& u, unsigned long v); 601 inline bool operator >= (const sc_unsigned& u, int v); 602 inline bool operator >= (const sc_unsigned& u, unsigned int v); 603 604 bool operator >= (int64 u, const sc_unsigned& v); 605 bool operator >= (uint64 u, const sc_unsigned& v); 606 bool operator >= (long u, const sc_unsigned& v); 607 bool operator >= (unsigned long u, const sc_unsigned& v); 608 inline bool operator >= (int u, const sc_unsigned& v); 609 inline bool operator >= (unsigned int u, const sc_unsigned& v); 610 611 bool operator >= (const sc_unsigned& u, const sc_uint_base& v); 612 bool operator >= (const sc_unsigned& u, const sc_int_base& v); 613 bool operator >= (const sc_uint_base& u, const sc_unsigned& v); 614 bool operator >= (const sc_int_base& u, const sc_unsigned& v); 615 616 // Bitwise NOT operator (unary). 617 sc_unsigned operator ~ (const sc_unsigned& u); 618 619// ---------------------------------------------------------------------------- 620// CLASS : sc_unsigned_bitref_r 621// 622// Proxy class for sc_unsigned bit selection (r-value only). 623// ---------------------------------------------------------------------------- 624 625class sc_unsigned_bitref_r : public sc_value_base 626{ 627 friend class sc_unsigned; 628 629protected: 630 631 // construction and initialization: 632 633 sc_unsigned_bitref_r() : sc_value_base(), m_index(0), m_obj_p(0) 634 {} 635 636 void initialize( const sc_unsigned* obj_p, int index_ ) 637 { 638 m_obj_p = CCAST<sc_unsigned*>( obj_p ); 639 m_index = index_; 640 } 641 642public: 643 644 // destructor 645 646 virtual ~sc_unsigned_bitref_r() 647 {} 648 649 // copy constructor 650 651 sc_unsigned_bitref_r( const sc_unsigned_bitref_r& a ) 652 : sc_value_base(a), m_index( a.m_index ), m_obj_p( a.m_obj_p ) 653 {} 654 655 // capacity 656 657 int length() const 658 { return 1; } 659 660 661 // implicit conversion to bool 662 663 operator uint64 () const; 664 bool operator ! () const; 665 bool operator ~ () const; 666 667 668 // explicit conversions 669 670 uint64 value() const 671 { return operator uint64(); } 672 673 bool to_bool() const 674 { return operator uint64(); } 675 676 677 // concatenation support 678 679 virtual int concat_length(bool* xz_present_p) const 680 { if ( xz_present_p ) *xz_present_p = false; return 1; } 681 virtual uint64 concat_get_uint64() const 682 { return (uint64)operator uint64(); } 683 virtual bool concat_get_ctrl( sc_digit* dst_p, int low_i ) const 684 { 685 int bit_mask = 1 << (low_i % BITS_PER_DIGIT); 686 int word_i = low_i / BITS_PER_DIGIT; 687 dst_p[word_i] &= ~bit_mask; 688 return false; 689 } 690 virtual bool concat_get_data( sc_digit* dst_p, int low_i ) const 691 { 692 int bit_mask = 1 << (low_i % BITS_PER_DIGIT); 693 bool result; // True if non-zero. 694 int word_i = low_i / BITS_PER_DIGIT; 695 if ( operator uint64() ) 696 { 697 dst_p[word_i] |= bit_mask; 698 result = true; 699 } 700 else 701 { 702 dst_p[word_i] &= ~bit_mask; 703 result = false; 704 } 705 return result; 706 } 707 708 // other methods 709 710 void print( ::std::ostream& os = ::std::cout ) const 711 { os << to_bool(); } 712 713protected: 714 715 int m_index; 716 sc_unsigned* m_obj_p; 717 718private: 719 720 // disabled 721 const sc_unsigned_bitref_r& operator = ( const sc_unsigned_bitref_r& ); 722}; 723 724 725 726inline 727::std::ostream& 728operator << ( ::std::ostream&, const sc_unsigned_bitref_r& ); 729 730 731// ---------------------------------------------------------------------------- 732// CLASS : sc_unsigned_bitref 733// 734// Proxy class for sc_unsigned bit selection (r-value and l-value). 735// ---------------------------------------------------------------------------- 736 737class sc_unsigned_bitref 738 : public sc_unsigned_bitref_r 739{ 740 friend class sc_unsigned; 741 friend class sc_core::sc_vpool<sc_unsigned_bitref>; 742 743 744protected: // construction 745 746 sc_unsigned_bitref() : sc_unsigned_bitref_r() 747 {} 748 749public: 750 751 // copy constructor 752 753 sc_unsigned_bitref( const sc_unsigned_bitref& a ) 754 : sc_unsigned_bitref_r( a ) 755 {} 756 757 758 // assignment operators 759 760 const sc_unsigned_bitref& operator = ( const sc_unsigned_bitref_r& ); 761 const sc_unsigned_bitref& operator = ( const sc_unsigned_bitref& ); 762 const sc_unsigned_bitref& operator = ( bool ); 763 764 const sc_unsigned_bitref& operator &= ( bool ); 765 const sc_unsigned_bitref& operator |= ( bool ); 766 const sc_unsigned_bitref& operator ^= ( bool ); 767 768 // concatenation methods 769 770 virtual void concat_set(int64 src, int low_i); 771 virtual void concat_set(const sc_signed& src, int low_i); 772 virtual void concat_set(const sc_unsigned& src, int low_i); 773 virtual void concat_set(uint64 src, int low_i); 774 775 776 // other methods 777 778 void scan( ::std::istream& is = ::std::cin ); 779 780protected: 781 static sc_core::sc_vpool<sc_unsigned_bitref> m_pool; 782}; 783 784 785 786inline 787::std::istream& 788operator >> ( ::std::istream&, sc_unsigned_bitref& ); 789 790 791// ---------------------------------------------------------------------------- 792// CLASS : sc_unsigned_subref_r 793// 794// Proxy class for sc_unsigned part selection (r-value only). 795// ---------------------------------------------------------------------------- 796 797class sc_unsigned_subref_r : public sc_value_base 798{ 799 friend class sc_signed; 800 friend class sc_unsigned; 801 friend class sc_unsigned_signal; 802 803protected: 804 805 // constructor 806 807 sc_unsigned_subref_r() : sc_value_base(), m_left(0), m_obj_p(0), m_right(0) 808 {} 809 810 void initialize( const sc_unsigned* obj_p, int left_, int right_ ) 811 { 812 m_obj_p = CCAST<sc_unsigned*>( obj_p ); 813 m_left = left_; 814 m_right = right_; 815 } 816 817public: 818 819 // destructor 820 821 virtual ~sc_unsigned_subref_r() 822 {} 823 824 825 // copy constructor 826 827 sc_unsigned_subref_r( const sc_unsigned_subref_r& a ) 828 : sc_value_base(a), m_left( a.m_left ), m_obj_p( a.m_obj_p ), 829 m_right( a.m_right ) 830 {} 831 832 833 // capacity 834 835 int length() const 836 { return m_left >= m_right ? (m_left-m_right+1) : (m_right-m_left+1 ); } 837 838 839 // implicit conversion to sc_unsigned 840 841 operator sc_unsigned () const; 842 843 844 // explicit conversions 845 846 int to_int() const; 847 unsigned int to_uint() const; 848 long to_long() const; 849 unsigned long to_ulong() const; 850 int64 to_int64() const; 851 uint64 to_uint64() const; 852 double to_double() const; 853 854 855 // explicit conversion to character string 856 857 const std::string to_string( sc_numrep numrep = SC_DEC ) const; 858 const std::string to_string( sc_numrep numrep, bool w_prefix ) const; 859 860 861 // concatenation support 862 863 virtual int concat_length(bool* xz_present_p) const 864 { 865 if ( xz_present_p ) *xz_present_p = false; 866 return m_left - m_right + 1; 867 } 868 virtual uint64 concat_get_uint64() const; 869 virtual bool concat_get_ctrl( sc_digit* dst_p, int low_i ) const; 870 virtual bool concat_get_data( sc_digit* dst_p, int low_i ) const; 871 872 // reduce methods 873 874 bool and_reduce() const; 875 bool nand_reduce() const; 876 bool or_reduce() const; 877 bool nor_reduce() const; 878 bool xor_reduce() const ; 879 bool xnor_reduce() const; 880 881 // other methods 882 883 void print( ::std::ostream& os = ::std::cout ) const 884 { os << to_string(sc_io_base(os,SC_DEC),sc_io_show_base(os)); } 885 886protected: 887 888 int m_left; // Left-most bit in this part selection. 889 sc_unsigned* m_obj_p; // Target of this part selection. 890 int m_right; // Right-most bit in this part selection. 891 892private: 893 894 // disabled 895 const sc_unsigned_subref_r& operator = ( const sc_unsigned_subref_r& ); 896}; 897 898 899 900inline 901::std::ostream& 902operator << ( ::std::ostream&, const sc_unsigned_subref_r& ); 903 904 905// ---------------------------------------------------------------------------- 906// CLASS : sc_unsigned_subref 907// 908// Proxy class for sc_unsigned part selection (r-value and l-value). 909// ---------------------------------------------------------------------------- 910 911class sc_unsigned_subref 912 : public sc_unsigned_subref_r 913{ 914 friend class sc_unsigned; 915 friend class sc_core::sc_vpool<sc_unsigned_subref>; 916 917 918 // constructor 919 920protected: 921 sc_unsigned_subref() : sc_unsigned_subref_r() 922 {} 923 924public: 925 926 // copy constructor 927 928 sc_unsigned_subref( const sc_unsigned_subref& a ) 929 : sc_unsigned_subref_r( a ) 930 {} 931 932 // assignment operators 933 934 const sc_unsigned_subref& operator = ( const sc_unsigned_subref_r& a ); 935 const sc_unsigned_subref& operator = ( const sc_unsigned_subref& a ); 936 const sc_unsigned_subref& operator = ( const sc_unsigned& a ); 937 938 template<class T> 939 const sc_unsigned_subref& operator = ( const sc_generic_base<T>& a ); 940 const sc_unsigned_subref& operator = ( const sc_signed_subref_r& a ); 941 const sc_unsigned_subref& operator = ( const sc_signed& a ); 942 943 const sc_unsigned_subref& operator = ( const char* a ); 944 const sc_unsigned_subref& operator = ( unsigned long a ); 945 const sc_unsigned_subref& operator = ( long a ); 946 947 const sc_unsigned_subref& operator = ( unsigned int a ) 948 { return operator = ( (unsigned long) a ); } 949 950 const sc_unsigned_subref& operator = ( int a ) 951 { return operator = ( (long) a ); } 952 953 const sc_unsigned_subref& operator = ( uint64 a ); 954 const sc_unsigned_subref& operator = ( int64 a ); 955 const sc_unsigned_subref& operator = ( double a ); 956 const sc_unsigned_subref& operator = ( const sc_int_base& a ); 957 const sc_unsigned_subref& operator = ( const sc_uint_base& a ); 958 959 // concatenation methods 960 961 virtual void concat_set(int64 src, int low_i); 962 virtual void concat_set(const sc_signed& src, int low_i); 963 virtual void concat_set(const sc_unsigned& src, int low_i); 964 virtual void concat_set(uint64 src, int low_i); 965 966 // other methods 967 968 void scan( ::std::istream& is = ::std::cin ); 969 970protected: 971 static sc_core::sc_vpool<sc_unsigned_subref> m_pool; 972}; 973 974 975 976inline 977::std::istream& 978operator >> ( ::std::istream&, sc_unsigned_subref& ); 979 980 981// ---------------------------------------------------------------------------- 982// CLASS : sc_unsigned 983// 984// Arbitrary precision unsigned number. 985// ---------------------------------------------------------------------------- 986 987class sc_unsigned : public sc_value_base 988{ 989 friend class sc_concatref; 990 friend class sc_unsigned_bitref_r; 991 friend class sc_unsigned_bitref; 992 friend class sc_unsigned_subref_r; 993 friend class sc_unsigned_subref; 994 friend class sc_signed; 995 friend class sc_signed_subref; 996 friend class sc_signed_subref_r; 997 998 // Needed for types using sc_unsigned. 999 typedef bool elemtype; 1000 1001public: 1002 1003 // constructors 1004 1005 explicit sc_unsigned( int nb = sc_length_param().len() ); 1006 sc_unsigned( const sc_unsigned& v ); 1007 sc_unsigned( const sc_signed& v ); 1008 template<class T> 1009 explicit sc_unsigned( const sc_generic_base<T>& v ); 1010 explicit sc_unsigned( const sc_bv_base& v ); 1011 explicit sc_unsigned( const sc_lv_base& v ); 1012 explicit sc_unsigned( const sc_int_subref_r& v ); 1013 explicit sc_unsigned( const sc_uint_subref_r& v ); 1014 explicit sc_unsigned( const sc_signed_subref_r& v ); 1015 explicit sc_unsigned( const sc_unsigned_subref_r& v ); 1016 1017 1018 1019 // assignment operators 1020 1021 const sc_unsigned& operator = (const sc_unsigned& v); 1022 const sc_unsigned& operator = (const sc_unsigned_subref_r& a ); 1023 1024 template<class T> 1025 const sc_unsigned& operator = ( const sc_generic_base<T>& a ) 1026 { a->to_sc_unsigned(*this); return *this; } 1027 1028 const sc_unsigned& operator = (const sc_signed& v); 1029 const sc_unsigned& operator = (const sc_signed_subref_r& a ); 1030 1031 const sc_unsigned& operator = ( const char* v); 1032 const sc_unsigned& operator = ( int64 v); 1033 const sc_unsigned& operator = ( uint64 v); 1034 const sc_unsigned& operator = ( long v); 1035 const sc_unsigned& operator = ( unsigned long v); 1036 1037 const sc_unsigned& operator = ( int v) 1038 { return operator=((long) v); } 1039 1040 const sc_unsigned& operator = ( unsigned int v) 1041 { return operator=((unsigned long) v); } 1042 1043 const sc_unsigned& operator = ( double v); 1044 const sc_unsigned& operator = ( const sc_int_base& v); 1045 const sc_unsigned& operator = ( const sc_uint_base& v); 1046 1047 const sc_unsigned& operator = ( const sc_bv_base& ); 1048 const sc_unsigned& operator = ( const sc_lv_base& ); 1049 1050#ifdef SC_INCLUDE_FX 1051 const sc_unsigned& operator = ( const sc_fxval& ); 1052 const sc_unsigned& operator = ( const sc_fxval_fast& ); 1053 const sc_unsigned& operator = ( const sc_fxnum& ); 1054 const sc_unsigned& operator = ( const sc_fxnum_fast& ); 1055#endif 1056 1057 1058 // destructor 1059 1060 virtual ~sc_unsigned() 1061 { 1062# ifndef SC_MAX_NBITS 1063 delete [] digit; 1064# endif 1065 } 1066 1067 // Concatenation support: 1068 1069 sc_digit* get_raw() const { return digit; } 1070 virtual int concat_length(bool* xz_present_p) const 1071 { if ( xz_present_p ) *xz_present_p = false; return nbits-1; } 1072 virtual bool concat_get_ctrl( sc_digit* dst_p, int low_i ) const; 1073 virtual bool concat_get_data( sc_digit* dst_p, int low_i ) const; 1074 virtual uint64 concat_get_uint64() const; 1075 virtual void concat_set(int64 src, int low_i); 1076 virtual void concat_set(const sc_signed& src, int low_i); 1077 virtual void concat_set(const sc_unsigned& src, int low_i); 1078 virtual void concat_set(uint64 src, int low_i); 1079 1080 // Increment operators. 1081 1082 sc_unsigned& operator ++ (); 1083 const sc_unsigned operator ++ (int); 1084 1085 // Decrement operators. 1086 1087 sc_unsigned& operator -- (); 1088 const sc_unsigned operator -- (int); 1089 1090 1091 // bit selection 1092 1093 inline void check_index( int i ) const 1094 { if ( (i < 0) || (i >= nbits-1) ) invalid_index(i); } 1095 1096 void invalid_index( int i ) const; 1097 1098 sc_unsigned_bitref& operator [] ( int i ) 1099 { 1100 check_index(i); 1101 sc_unsigned_bitref* result_p = 1102 sc_unsigned_bitref::m_pool.allocate(); 1103 result_p->initialize( this, i ); 1104 return *result_p; 1105 } 1106 1107 const sc_unsigned_bitref_r& operator [] ( int i ) const 1108 { 1109 check_index(i); 1110 sc_unsigned_bitref* result_p = 1111 sc_unsigned_bitref::m_pool.allocate(); 1112 result_p->initialize( this, i ); 1113 return *result_p; 1114 } 1115 1116 sc_unsigned_bitref& bit( int i ) 1117 { 1118 check_index(i); 1119 sc_unsigned_bitref* result_p = 1120 sc_unsigned_bitref::m_pool.allocate(); 1121 result_p->initialize( this, i ); 1122 return *result_p; 1123 } 1124 1125 const sc_unsigned_bitref_r& bit( int i ) const 1126 { 1127 check_index(i); 1128 sc_unsigned_bitref* result_p = 1129 sc_unsigned_bitref::m_pool.allocate(); 1130 result_p->initialize( this, i ); 1131 return *result_p; 1132 } 1133 1134 1135 // part selection 1136 1137 // Subref operators. Help access the range of bits from the ith to 1138 // jth. These indices have arbitrary precedence with respect to each 1139 // other, i.e., we can have i <= j or i > j. Note the equivalence 1140 // between range(i, j) and operator (i, j). Also note that 1141 // operator (i, i) returns an unsigned number that corresponds to the 1142 // bit operator [i], so these two forms are not the same. 1143 1144 inline void check_range( int l, int r ) const 1145 { 1146 if ( l < r ) 1147 { 1148 if ( (l < 0) || (r >= nbits-1) ) invalid_range(l,r); 1149 } 1150 else 1151 { 1152 if ( (r < 0) || (l >= nbits-1) ) invalid_range(l,r); 1153 } 1154 } 1155 1156 void invalid_range( int l, int r ) const; 1157 1158 sc_unsigned_subref& range( int i, int j ) 1159 { 1160 check_range(i,j); 1161 sc_unsigned_subref* result_p = 1162 sc_unsigned_subref::m_pool.allocate(); 1163 result_p->initialize( this, i, j ); 1164 return *result_p; 1165 } 1166 1167 const sc_unsigned_subref_r& range( int i, int j ) const 1168 { 1169 check_range(i,j); 1170 sc_unsigned_subref* result_p = 1171 sc_unsigned_subref::m_pool.allocate(); 1172 result_p->initialize( this, i, j ); 1173 return *result_p; 1174 } 1175 1176 sc_unsigned_subref& operator () ( int i, int j ) 1177 { 1178 check_range(i,j); 1179 sc_unsigned_subref* result_p = 1180 sc_unsigned_subref::m_pool.allocate(); 1181 result_p->initialize( this, i, j ); 1182 return *result_p; 1183 } 1184 1185 const sc_unsigned_subref_r& operator () ( int i, int j ) const 1186 { 1187 check_range(i,j); 1188 sc_unsigned_subref* result_p = 1189 sc_unsigned_subref::m_pool.allocate(); 1190 result_p->initialize( this, i, j ); 1191 return *result_p; 1192 } 1193 1194 // explicit conversions 1195 1196 int to_int() const; 1197 unsigned int to_uint() const; 1198 long to_long() const; 1199 unsigned long to_ulong() const; 1200 int64 to_int64() const; 1201 uint64 to_uint64() const; 1202 double to_double() const; 1203 1204#ifdef SC_DT_DEPRECATED 1205 int to_signed() const 1206 { return to_int(); } 1207 1208 unsigned int to_unsigned() const 1209 { return to_uint(); } 1210#endif 1211 1212 // explicit conversion to character string 1213 1214 const std::string to_string( sc_numrep numrep = SC_DEC ) const; 1215 const std::string to_string( sc_numrep numrep, bool w_prefix ) const; 1216 1217 // Print functions. dump prints the internals of the class. 1218 1219 void print( ::std::ostream& os = ::std::cout ) const 1220 { os << to_string(sc_io_base(os,SC_DEC),sc_io_show_base(os)); } 1221 1222 void scan( ::std::istream& is = ::std::cin ); 1223 1224 void dump( ::std::ostream& os = ::std::cout ) const; 1225 1226 1227 // Functions to find various properties. 1228 int length() const { return nbits - 1; } // Bit width. 1229 bool iszero() const; // Is the number zero? 1230 bool sign() const { return 0; } // Sign. 1231 1232 // reduce methods 1233 1234 bool and_reduce() const; 1235 1236 bool nand_reduce() const 1237 { return ( ! and_reduce() ); } 1238 1239 bool or_reduce() const; 1240 1241 bool nor_reduce() const 1242 { return ( ! or_reduce() ); } 1243 1244 bool xor_reduce() const; 1245 1246 bool xnor_reduce() const 1247 { return ( ! xor_reduce() ); } 1248 1249 1250 // Functions to access individual bits. 1251 bool test(int i) const; // Is the ith bit 0 or 1? 1252 void set(int i); // Set the ith bit to 1. 1253 void clear(int i); // Set the ith bit to 0. 1254 void set(int i, bool v) // Set the ith bit to v. 1255 { if (v) set(i); else clear(i); } 1256 void invert(int i) // Negate the ith bit. 1257 { if (test(i)) clear(i); else set(i); } 1258 1259 // Make the number equal to its mirror image. 1260 void reverse(); 1261 1262 // Get/set a packed bit representation of the number. 1263 void get_packed_rep(sc_digit *buf) const; 1264 void set_packed_rep(sc_digit *buf); 1265 1266 /* 1267 The comparison of the old and new semantics are as follows: 1268 1269 Let s = sc_signed, 1270 u = sc_unsigned, 1271 un = { uint64, unsigned long, unsigned int }, 1272 sn = { int64, long, int, char* }, and 1273 OP = { +, -, *, /, % }. 1274 1275 Old semantics: New semantics: 1276 u OP u -> u u OP u -> u 1277 s OP u -> u s OP u -> s 1278 u OP s -> u u OP s -> s 1279 s OP s -> s s OP s -> s 1280 1281 u OP un = un OP u -> u u OP un = un OP u -> u 1282 u OP sn = sn OP u -> u u OP sn = sn OP u -> s 1283 1284 s OP un = un OP s -> s s OP un = un OP s -> s 1285 s OP sn = sn OP s -> s s OP sn = sn OP s -> s 1286 1287 In the new semantics, the result is u if both operands are u; the 1288 result is s otherwise. The only exception is subtraction. The result 1289 of a subtraction is always s. 1290 1291 The old semantics is like C/C++ semantics on integer types; the 1292 new semantics is due to the VSIA C/C++ data types standard. 1293 */ 1294 1295 // ARITHMETIC OPERATORS: 1296 1297 // ADDition operators: 1298 1299 friend sc_signed operator + (const sc_unsigned& u, const sc_signed& v); 1300 friend sc_signed operator + (const sc_signed& u, const sc_unsigned& v); 1301 1302 friend sc_unsigned operator + (const sc_unsigned& u, const sc_unsigned& v); 1303 friend sc_signed operator + (const sc_unsigned& u, int64 v); 1304 friend sc_unsigned operator + (const sc_unsigned& u, uint64 v); 1305 friend sc_signed operator + (const sc_unsigned& u, long v); 1306 friend sc_unsigned operator + (const sc_unsigned& u, unsigned long v); 1307 friend sc_signed operator + (const sc_unsigned& u, int v); 1308 friend sc_unsigned operator + (const sc_unsigned& u, unsigned int v) 1309 { return operator+(u, (unsigned long) v); } 1310 1311 friend sc_signed operator + (int64 u, const sc_unsigned& v); 1312 friend sc_unsigned operator + (uint64 u, const sc_unsigned& v); 1313 friend sc_signed operator + (long u, const sc_unsigned& v); 1314 friend sc_unsigned operator + (unsigned long u, const sc_unsigned& v); 1315 friend sc_signed operator + (int u, const sc_unsigned& v); 1316 friend sc_unsigned operator + (unsigned int u, const sc_unsigned& v) 1317 { return operator+((unsigned long) u, v); } 1318 1319 const sc_unsigned& operator += (const sc_signed& v); 1320 const sc_unsigned& operator += (const sc_unsigned& v); 1321 const sc_unsigned& operator += (int64 v); 1322 const sc_unsigned& operator += (uint64 v); 1323 const sc_unsigned& operator += (long v); 1324 const sc_unsigned& operator += (unsigned long v); 1325 const sc_unsigned& operator += (int v) 1326 { return operator+=((long) v); } 1327 const sc_unsigned& operator += (unsigned int v) 1328 { return operator+=((unsigned long) v); } 1329 1330 friend sc_unsigned operator + (const sc_unsigned& u, const sc_uint_base& v); 1331 friend sc_signed operator + (const sc_unsigned& u, const sc_int_base& v); 1332 friend sc_unsigned operator + (const sc_uint_base& u, const sc_unsigned& v); 1333 friend sc_signed operator + (const sc_int_base& u, const sc_unsigned& v); 1334 const sc_unsigned& operator += (const sc_int_base& v); 1335 const sc_unsigned& operator += (const sc_uint_base& v); 1336 1337 // SUBtraction operators: 1338 1339 friend sc_signed operator - (const sc_unsigned& u, const sc_signed& v); 1340 friend sc_signed operator - (const sc_signed& u, const sc_unsigned& v); 1341 1342 friend sc_signed operator - (const sc_unsigned& u, const sc_unsigned& v); 1343 friend sc_signed operator - (const sc_unsigned& u, int64 v); 1344 friend sc_signed operator - (const sc_unsigned& u, uint64 v); 1345 friend sc_signed operator - (const sc_unsigned& u, long v); 1346 friend sc_signed operator - (const sc_unsigned& u, unsigned long v); 1347 friend sc_signed operator - (const sc_unsigned& u, int v); 1348 friend sc_signed operator - (const sc_unsigned& u, unsigned int v); 1349 1350 friend sc_signed operator - (int64 u, const sc_unsigned& v); 1351 friend sc_signed operator - (uint64 u, const sc_unsigned& v); 1352 friend sc_signed operator - (long u, const sc_unsigned& v); 1353 friend sc_signed operator - (unsigned long u, const sc_unsigned& v); 1354 friend sc_signed operator - (int u, const sc_unsigned& v); 1355 friend sc_signed operator - (unsigned int u, const sc_unsigned& v); 1356 1357 const sc_unsigned& operator -= (const sc_signed& v); 1358 const sc_unsigned& operator -= (const sc_unsigned& v); 1359 const sc_unsigned& operator -= (int64 v); 1360 const sc_unsigned& operator -= (uint64 v); 1361 const sc_unsigned& operator -= (long v); 1362 const sc_unsigned& operator -= (unsigned long v); 1363 const sc_unsigned& operator -= (int v) 1364 { return operator-=((long) v); } 1365 const sc_unsigned& operator -= (unsigned int v) 1366 { return operator-=((unsigned long) v); } 1367 1368 friend sc_signed operator - (const sc_unsigned& u, const sc_uint_base& v); 1369 friend sc_signed operator - (const sc_unsigned& u, const sc_int_base& v); 1370 friend sc_signed operator - (const sc_uint_base& u, const sc_unsigned& v); 1371 friend sc_signed operator - (const sc_int_base& u, const sc_unsigned& v); 1372 const sc_unsigned& operator -= (const sc_int_base& v); 1373 const sc_unsigned& operator -= (const sc_uint_base& v); 1374 1375 // MULtiplication operators: 1376 1377 friend sc_signed operator * (const sc_unsigned& u, const sc_signed& v); 1378 friend sc_signed operator * (const sc_signed& u, const sc_unsigned& v); 1379 1380 friend sc_unsigned operator * (const sc_unsigned& u, const sc_unsigned& v); 1381 friend sc_signed operator * (const sc_unsigned& u, int64 v); 1382 friend sc_unsigned operator * (const sc_unsigned& u, uint64 v); 1383 friend sc_signed operator * (const sc_unsigned& u, long v); 1384 friend sc_unsigned operator * (const sc_unsigned& u, unsigned long v); 1385 friend sc_signed operator * (const sc_unsigned& u, int v); 1386 friend sc_unsigned operator * (const sc_unsigned& u, unsigned int v) 1387 { return operator*(u, (unsigned long) v); } 1388 1389 friend sc_signed operator * (int64 u, const sc_unsigned& v); 1390 friend sc_unsigned operator * (uint64 u, const sc_unsigned& v); 1391 friend sc_signed operator * (long u, const sc_unsigned& v); 1392 friend sc_unsigned operator * (unsigned long u, const sc_unsigned& v); 1393 friend sc_signed operator * (int u, const sc_unsigned& v); 1394 friend sc_unsigned operator * (unsigned int u, const sc_unsigned& v) 1395 { return operator*((unsigned long) u, v); } 1396 1397 const sc_unsigned& operator *= (const sc_signed& v); 1398 const sc_unsigned& operator *= (const sc_unsigned& v); 1399 const sc_unsigned& operator *= (int64 v); 1400 const sc_unsigned& operator *= (uint64 v); 1401 const sc_unsigned& operator *= (long v); 1402 const sc_unsigned& operator *= (unsigned long v); 1403 const sc_unsigned& operator *= (int v) 1404 { return operator*=((long) v); } 1405 const sc_unsigned& operator *= (unsigned int v) 1406 { return operator*=((unsigned long) v); } 1407 1408 friend sc_unsigned operator * (const sc_unsigned& u, const sc_uint_base& v); 1409 friend sc_signed operator * (const sc_unsigned& u, const sc_int_base& v); 1410 friend sc_unsigned operator * (const sc_uint_base& u, const sc_unsigned& v); 1411 friend sc_signed operator * (const sc_int_base& u, const sc_unsigned& v); 1412 const sc_unsigned& operator *= (const sc_int_base& v); 1413 const sc_unsigned& operator *= (const sc_uint_base& v); 1414 1415 // DIVision operators: 1416 1417 friend sc_signed operator / (const sc_unsigned& u, const sc_signed& v); 1418 friend sc_signed operator / (const sc_signed& u, const sc_unsigned& v); 1419 1420 friend sc_unsigned operator / (const sc_unsigned& u, const sc_unsigned& v); 1421 friend sc_signed operator / (const sc_unsigned& u, int64 v); 1422 friend sc_unsigned operator / (const sc_unsigned& u, uint64 v); 1423 friend sc_signed operator / (const sc_unsigned& u, long v); 1424 friend sc_unsigned operator / (const sc_unsigned& u, unsigned long v); 1425 friend sc_signed operator / (const sc_unsigned& u, int v); 1426 friend sc_unsigned operator / (const sc_unsigned& u, unsigned int v) 1427 { return operator/(u, (unsigned long) v); } 1428 1429 friend sc_signed operator / (int64 u, const sc_unsigned& v); 1430 friend sc_unsigned operator / (uint64 u, const sc_unsigned& v); 1431 friend sc_signed operator / (long u, const sc_unsigned& v); 1432 friend sc_unsigned operator / (unsigned long u, const sc_unsigned& v); 1433 friend sc_signed operator / (int u, const sc_unsigned& v); 1434 friend sc_unsigned operator / (unsigned int u, const sc_unsigned& v) 1435 { return operator/((unsigned long) u, v); } 1436 1437 const sc_unsigned& operator /= (const sc_signed& v); 1438 const sc_unsigned& operator /= (const sc_unsigned& v); 1439 const sc_unsigned& operator /= (int64 v); 1440 const sc_unsigned& operator /= (uint64 v); 1441 const sc_unsigned& operator /= (long v); 1442 const sc_unsigned& operator /= (unsigned long v); 1443 const sc_unsigned& operator /= (int v) 1444 { return operator/=((long) v); } 1445 const sc_unsigned& operator /= (unsigned int v) 1446 { return operator/=((unsigned long) v); } 1447 1448 friend sc_unsigned operator / (const sc_unsigned& u, const sc_uint_base& v); 1449 friend sc_signed operator / (const sc_unsigned& u, const sc_int_base& v); 1450 friend sc_unsigned operator / (const sc_uint_base& u, const sc_unsigned& v); 1451 friend sc_signed operator / (const sc_int_base& u, const sc_unsigned& v); 1452 const sc_unsigned& operator /= (const sc_int_base& v); 1453 const sc_unsigned& operator /= (const sc_uint_base& v); 1454 1455 // MODulo operators: 1456 1457 friend sc_signed operator % (const sc_unsigned& u, const sc_signed& v); 1458 friend sc_signed operator % (const sc_signed& u, const sc_unsigned& v); 1459 1460 friend sc_unsigned operator % (const sc_unsigned& u, const sc_unsigned& v); 1461 friend sc_signed operator % (const sc_unsigned& u, int64 v); 1462 friend sc_unsigned operator % (const sc_unsigned& u, uint64 v); 1463 friend sc_signed operator % (const sc_unsigned& u, long v); 1464 friend sc_unsigned operator % (const sc_unsigned& u, unsigned long v); 1465 friend sc_signed operator % (const sc_unsigned& u, int v); 1466 friend sc_unsigned operator % (const sc_unsigned& u, unsigned int v) 1467 { return operator%(u, (unsigned long) v); } 1468 1469 friend sc_signed operator % (int64 u, const sc_unsigned& v); 1470 friend sc_unsigned operator % (uint64 u, const sc_unsigned& v); 1471 friend sc_signed operator % (long u, const sc_unsigned& v); 1472 friend sc_unsigned operator % (unsigned long u, const sc_unsigned& v); 1473 friend sc_signed operator % (int u, const sc_unsigned& v); 1474 friend sc_unsigned operator % (unsigned int u, const sc_unsigned& v) 1475 { return operator%((unsigned long) u, v); } 1476 1477 const sc_unsigned& operator %= (const sc_signed& v); 1478 const sc_unsigned& operator %= (const sc_unsigned& v); 1479 const sc_unsigned& operator %= (int64 v); 1480 const sc_unsigned& operator %= (uint64 v); 1481 const sc_unsigned& operator %= (long v); 1482 const sc_unsigned& operator %= (unsigned long v); 1483 const sc_unsigned& operator %= (int v) 1484 { return operator%=((long) v); } 1485 const sc_unsigned& operator %= (unsigned int v) 1486 { return operator%=((unsigned long) v); } 1487 1488 friend sc_unsigned operator % (const sc_unsigned& u, const sc_uint_base& v); 1489 friend sc_signed operator % (const sc_unsigned& u, const sc_int_base& v); 1490 friend sc_unsigned operator % (const sc_uint_base& u, const sc_unsigned& v); 1491 friend sc_signed operator % (const sc_int_base& u, const sc_unsigned& v); 1492 const sc_unsigned& operator %= (const sc_int_base& v); 1493 const sc_unsigned& operator %= (const sc_uint_base& v); 1494 1495 // BITWISE OPERATORS: 1496 1497 // Bitwise AND operators: 1498 1499 friend sc_signed operator & (const sc_unsigned& u, const sc_signed& v); 1500 friend sc_signed operator & (const sc_signed& u, const sc_unsigned& v); 1501 1502 friend sc_unsigned operator & (const sc_unsigned& u, const sc_unsigned& v); 1503 friend sc_signed operator & (const sc_unsigned& u, int64 v); 1504 friend sc_unsigned operator & (const sc_unsigned& u, uint64 v); 1505 friend sc_signed operator & (const sc_unsigned& u, long v); 1506 friend sc_unsigned operator & (const sc_unsigned& u, unsigned long v); 1507 friend sc_signed operator & (const sc_unsigned& u, int v); 1508 friend sc_unsigned operator & (const sc_unsigned& u, unsigned int v) 1509 { return operator&(u, (unsigned long) v); } 1510 1511 friend sc_signed operator & (int64 u, const sc_unsigned& v); 1512 friend sc_unsigned operator & (uint64 u, const sc_unsigned& v); 1513 friend sc_signed operator & (long u, const sc_unsigned& v); 1514 friend sc_unsigned operator & (unsigned long u, const sc_unsigned& v); 1515 friend sc_signed operator & (int u, const sc_unsigned& v); 1516 friend sc_unsigned operator & (unsigned int u, const sc_unsigned& v) 1517 { return operator&((unsigned long) u, v); } 1518 1519 const sc_unsigned& operator &= (const sc_signed& v); 1520 const sc_unsigned& operator &= (const sc_unsigned& v); 1521 const sc_unsigned& operator &= (int64 v); 1522 const sc_unsigned& operator &= (uint64 v); 1523 const sc_unsigned& operator &= (long v); 1524 const sc_unsigned& operator &= (unsigned long v); 1525 const sc_unsigned& operator &= (int v) 1526 { return operator&=((long) v); } 1527 const sc_unsigned& operator &= (unsigned int v) 1528 { return operator&=((unsigned long) v); } 1529 1530 friend sc_unsigned operator & (const sc_unsigned& u, const sc_uint_base& v); 1531 friend sc_signed operator & (const sc_unsigned& u, const sc_int_base& v); 1532 friend sc_unsigned operator & (const sc_uint_base& u, const sc_unsigned& v); 1533 friend sc_signed operator & (const sc_int_base& u, const sc_unsigned& v); 1534 const sc_unsigned& operator &= (const sc_int_base& v); 1535 const sc_unsigned& operator &= (const sc_uint_base& v); 1536 1537 // Bitwise OR operators: 1538 1539 friend sc_signed operator | (const sc_unsigned& u, const sc_signed& v); 1540 friend sc_signed operator | (const sc_signed& u, const sc_unsigned& v); 1541 1542 friend sc_unsigned operator | (const sc_unsigned& u, const sc_unsigned& v); 1543 friend sc_signed operator | (const sc_unsigned& u, int64 v); 1544 friend sc_unsigned operator | (const sc_unsigned& u, uint64 v); 1545 friend sc_signed operator | (const sc_unsigned& u, long v); 1546 friend sc_unsigned operator | (const sc_unsigned& u, unsigned long v); 1547 friend sc_signed operator | (const sc_unsigned& u, int v); 1548 friend sc_unsigned operator | (const sc_unsigned& u, unsigned int v) 1549 { return operator|(u, (unsigned long) v); } 1550 1551 friend sc_signed operator | (int64 u, const sc_unsigned& v); 1552 friend sc_unsigned operator | (uint64 u, const sc_unsigned& v); 1553 friend sc_signed operator | (long u, const sc_unsigned& v); 1554 friend sc_unsigned operator | (unsigned long u, const sc_unsigned& v); 1555 friend sc_signed operator | (int u, const sc_unsigned& v); 1556 friend sc_unsigned operator | (unsigned int u, const sc_unsigned& v) 1557 { return operator|((unsigned long) u, v); } 1558 1559 const sc_unsigned& operator |= (const sc_signed& v); 1560 const sc_unsigned& operator |= (const sc_unsigned& v); 1561 const sc_unsigned& operator |= (int64 v); 1562 const sc_unsigned& operator |= (uint64 v); 1563 const sc_unsigned& operator |= (long v); 1564 const sc_unsigned& operator |= (unsigned long v); 1565 const sc_unsigned& operator |= (int v) 1566 { return operator|=((long) v); } 1567 const sc_unsigned& operator |= (unsigned int v) 1568 { return operator|=((unsigned long) v); } 1569 1570 friend sc_unsigned operator | (const sc_unsigned& u, const sc_uint_base& v); 1571 friend sc_signed operator | (const sc_unsigned& u, const sc_int_base& v); 1572 friend sc_unsigned operator | (const sc_uint_base& u, const sc_unsigned& v); 1573 friend sc_signed operator | (const sc_int_base& u, const sc_unsigned& v); 1574 const sc_unsigned& operator |= (const sc_int_base& v); 1575 const sc_unsigned& operator |= (const sc_uint_base& v); 1576 1577 // Bitwise XOR operators: 1578 1579 friend sc_signed operator ^ (const sc_unsigned& u, const sc_signed& v); 1580 friend sc_signed operator ^ (const sc_signed& u, const sc_unsigned& v); 1581 1582 friend sc_unsigned operator ^ (const sc_unsigned& u, const sc_unsigned& v); 1583 friend sc_signed operator ^ (const sc_unsigned& u, int64 v); 1584 friend sc_unsigned operator ^ (const sc_unsigned& u, uint64 v); 1585 friend sc_signed operator ^ (const sc_unsigned& u, long v); 1586 friend sc_unsigned operator ^ (const sc_unsigned& u, unsigned long v); 1587 friend sc_signed operator ^ (const sc_unsigned& u, int v); 1588 friend sc_unsigned operator ^ (const sc_unsigned& u, unsigned int v) 1589 { return operator^(u, (unsigned long) v); } 1590 1591 friend sc_signed operator ^ (int64 u, const sc_unsigned& v); 1592 friend sc_unsigned operator ^ (uint64 u, const sc_unsigned& v); 1593 friend sc_signed operator ^ (long u, const sc_unsigned& v); 1594 friend sc_unsigned operator ^ (unsigned long u, const sc_unsigned& v); 1595 friend sc_signed operator ^ (int u, const sc_unsigned& v); 1596 friend sc_unsigned operator ^ (unsigned int u, const sc_unsigned& v) 1597 { return operator^((unsigned long) u, v); } 1598 1599 const sc_unsigned& operator ^= (const sc_signed& v); 1600 const sc_unsigned& operator ^= (const sc_unsigned& v); 1601 const sc_unsigned& operator ^= (int64 v); 1602 const sc_unsigned& operator ^= (uint64 v); 1603 const sc_unsigned& operator ^= (long v); 1604 const sc_unsigned& operator ^= (unsigned long v); 1605 const sc_unsigned& operator ^= (int v) 1606 { return operator^=((long) v); } 1607 const sc_unsigned& operator ^= (unsigned int v) 1608 { return operator^=((unsigned long) v); } 1609 1610 friend sc_unsigned operator ^ (const sc_unsigned& u, const sc_uint_base& v); 1611 friend sc_signed operator ^ (const sc_unsigned& u, const sc_int_base& v); 1612 friend sc_unsigned operator ^ (const sc_uint_base& u, const sc_unsigned& v); 1613 friend sc_signed operator ^ (const sc_int_base& u, const sc_unsigned& v); 1614 const sc_unsigned& operator ^= (const sc_int_base& v); 1615 const sc_unsigned& operator ^= (const sc_uint_base& v); 1616 1617 // SHIFT OPERATORS: 1618 1619 // LEFT SHIFT operators: 1620 1621 friend sc_unsigned operator << (const sc_unsigned& u, const sc_signed& v); 1622 friend sc_signed operator << (const sc_signed& u, const sc_unsigned& v); 1623 1624 friend sc_unsigned operator << (const sc_unsigned& u, const sc_unsigned& v); 1625 friend sc_unsigned operator << (const sc_unsigned& u, int64 v); 1626 friend sc_unsigned operator << (const sc_unsigned& u, uint64 v); 1627 friend sc_unsigned operator << (const sc_unsigned& u, long v); 1628 friend sc_unsigned operator << (const sc_unsigned& u, unsigned long v); 1629 friend sc_unsigned operator << (const sc_unsigned& u, int v) 1630 { return operator<<(u, (long) v); } 1631 friend sc_unsigned operator << (const sc_unsigned& u, unsigned int v) 1632 { return operator<<(u, (unsigned long) v); } 1633 1634 const sc_unsigned& operator <<= (const sc_signed& v); 1635 const sc_unsigned& operator <<= (const sc_unsigned& v); 1636 const sc_unsigned& operator <<= (int64 v); 1637 const sc_unsigned& operator <<= (uint64 v); 1638 const sc_unsigned& operator <<= (long v); 1639 const sc_unsigned& operator <<= (unsigned long v); 1640 const sc_unsigned& operator <<= (int v) 1641 { return operator<<=((long) v); } 1642 const sc_unsigned& operator <<= (unsigned int v) 1643 { return operator<<=((unsigned long) v); } 1644 1645 friend sc_unsigned operator << (const sc_unsigned& u, const sc_uint_base& v); 1646 friend sc_unsigned operator << (const sc_unsigned& u, const sc_int_base& v); 1647 const sc_unsigned& operator <<= (const sc_int_base& v); 1648 const sc_unsigned& operator <<= (const sc_uint_base& v); 1649 1650 // RIGHT SHIFT operators: 1651 1652 friend sc_unsigned operator >> (const sc_unsigned& u, const sc_signed& v); 1653 friend sc_signed operator >> (const sc_signed& u, const sc_unsigned& v); 1654 1655 friend sc_unsigned operator >> (const sc_unsigned& u, const sc_unsigned& v); 1656 friend sc_unsigned operator >> (const sc_unsigned& u, int64 v); 1657 friend sc_unsigned operator >> (const sc_unsigned& u, uint64 v); 1658 friend sc_unsigned operator >> (const sc_unsigned& u, long v); 1659 friend sc_unsigned operator >> (const sc_unsigned& u, unsigned long v); 1660 friend sc_unsigned operator >> (const sc_unsigned& u, int v) 1661 { return operator>>(u, (long) v); } 1662 friend sc_unsigned operator >> (const sc_unsigned& u, unsigned int v) 1663 { return operator>>(u, (unsigned long) v); } 1664 1665 const sc_unsigned& operator >>= (const sc_signed& v); 1666 const sc_unsigned& operator >>= (const sc_unsigned& v); 1667 const sc_unsigned& operator >>= (int64 v); 1668 const sc_unsigned& operator >>= (uint64 v); 1669 const sc_unsigned& operator >>= (long v); 1670 const sc_unsigned& operator >>= (unsigned long v); 1671 const sc_unsigned& operator >>= (int v) 1672 { return operator>>=((long) v); } 1673 const sc_unsigned& operator >>= (unsigned int v) 1674 { return operator>>=((unsigned long) v); } 1675 1676 friend sc_unsigned operator >> ( const sc_unsigned& , const sc_uint_base& ); 1677 friend sc_unsigned operator >> ( const sc_unsigned&, const sc_int_base& ); 1678 const sc_unsigned& operator >>= (const sc_int_base& v); 1679 const sc_unsigned& operator >>= (const sc_uint_base& v); 1680 1681 // Unary arithmetic operators 1682 friend sc_unsigned operator + (const sc_unsigned& u); 1683 friend sc_signed operator - (const sc_unsigned& u); 1684 1685 // LOGICAL OPERATORS: 1686 1687 // Logical EQUAL operators: 1688 1689 friend bool operator == (const sc_unsigned& u, const sc_signed& v); 1690 friend bool operator == (const sc_signed& u, const sc_unsigned& v); 1691 1692 friend bool operator == (const sc_unsigned& u, const sc_unsigned& v); 1693 friend bool operator == (const sc_unsigned& u, int64 v); 1694 friend bool operator == (const sc_unsigned& u, uint64 v); 1695 friend bool operator == (const sc_unsigned& u, long v); 1696 friend bool operator == (const sc_unsigned& u, unsigned long v); 1697 friend bool operator == (const sc_unsigned& u, int v) 1698 { return operator==(u, (long) v); } 1699 friend bool operator == (const sc_unsigned& u, unsigned int v) 1700 { return operator==(u, (unsigned long) v); } 1701 1702 friend bool operator == (int64 u, const sc_unsigned& v); 1703 friend bool operator == (uint64 u, const sc_unsigned& v); 1704 friend bool operator == (long u, const sc_unsigned& v); 1705 friend bool operator == (unsigned long u, const sc_unsigned& v); 1706 friend bool operator == (int u, const sc_unsigned& v) 1707 { return operator==((long) u, v); } 1708 friend bool operator == (unsigned int u, const sc_unsigned& v) 1709 { return operator==((unsigned long) u, v); } 1710 1711 friend bool operator == (const sc_unsigned& u, const sc_uint_base& v); 1712 friend bool operator == (const sc_unsigned& u, const sc_int_base& v); 1713 friend bool operator == (const sc_uint_base& u, const sc_unsigned& v); 1714 friend bool operator == (const sc_int_base& u, const sc_unsigned& v); 1715 1716 // Logical NOT_EQUAL operators: 1717 1718 friend bool operator != (const sc_unsigned& u, const sc_signed& v); 1719 friend bool operator != (const sc_signed& u, const sc_unsigned& v); 1720 1721 friend bool operator != (const sc_unsigned& u, const sc_unsigned& v); 1722 friend bool operator != (const sc_unsigned& u, int64 v); 1723 friend bool operator != (const sc_unsigned& u, uint64 v); 1724 friend bool operator != (const sc_unsigned& u, long v); 1725 friend bool operator != (const sc_unsigned& u, unsigned long v); 1726 friend bool operator != (const sc_unsigned& u, int v) 1727 { return operator!=(u, (long) v); } 1728 friend bool operator != (const sc_unsigned& u, unsigned int v) 1729 { return operator!=(u, (unsigned long) v); } 1730 1731 friend bool operator != (int64 u, const sc_unsigned& v); 1732 friend bool operator != (uint64 u, const sc_unsigned& v); 1733 friend bool operator != (long u, const sc_unsigned& v); 1734 friend bool operator != (unsigned long u, const sc_unsigned& v); 1735 friend bool operator != (int u, const sc_unsigned& v) 1736 { return operator!=((long) u, v); } 1737 friend bool operator != (unsigned int u, const sc_unsigned& v) 1738 { return operator!=((unsigned long) u, v); } 1739 1740 friend bool operator != (const sc_unsigned& u, const sc_uint_base& v); 1741 friend bool operator != (const sc_unsigned& u, const sc_int_base& v); 1742 friend bool operator != (const sc_uint_base& u, const sc_unsigned& v); 1743 friend bool operator != (const sc_int_base& u, const sc_unsigned& v); 1744 1745 // Logical LESS_THAN operators: 1746 1747 friend bool operator < (const sc_unsigned& u, const sc_signed& v); 1748 friend bool operator < (const sc_signed& u, const sc_unsigned& v); 1749 1750 friend bool operator < (const sc_unsigned& u, const sc_unsigned& v); 1751 friend bool operator < (const sc_unsigned& u, int64 v); 1752 friend bool operator < (const sc_unsigned& u, uint64 v); 1753 friend bool operator < (const sc_unsigned& u, long v); 1754 friend bool operator < (const sc_unsigned& u, unsigned long v); 1755 friend bool operator < (const sc_unsigned& u, int v) 1756 { return operator<(u, (long) v); } 1757 friend bool operator < (const sc_unsigned& u, unsigned int v) 1758 { return operator<(u, (unsigned long) v); } 1759 1760 friend bool operator < (int64 u, const sc_unsigned& v); 1761 friend bool operator < (uint64 u, const sc_unsigned& v); 1762 friend bool operator < (long u, const sc_unsigned& v); 1763 friend bool operator < (unsigned long u, const sc_unsigned& v); 1764 friend bool operator < (int u, const sc_unsigned& v) 1765 { return operator<((long) u, v); } 1766 friend bool operator < (unsigned int u, const sc_unsigned& v) 1767 { return operator<((unsigned long) u, v); } 1768 1769 friend bool operator < (const sc_unsigned& u, const sc_uint_base& v); 1770 friend bool operator < (const sc_unsigned& u, const sc_int_base& v); 1771 friend bool operator < (const sc_uint_base& u, const sc_unsigned& v); 1772 friend bool operator < (const sc_int_base& u, const sc_unsigned& v); 1773 1774 // Logical LESS_THAN_AND_EQUAL operators: 1775 1776 friend bool operator <= (const sc_unsigned& u, const sc_signed& v); 1777 friend bool operator <= (const sc_signed& u, const sc_unsigned& v); 1778 1779 friend bool operator <= (const sc_unsigned& u, const sc_unsigned& v); 1780 friend bool operator <= (const sc_unsigned& u, int64 v); 1781 friend bool operator <= (const sc_unsigned& u, uint64 v); 1782 friend bool operator <= (const sc_unsigned& u, long v); 1783 friend bool operator <= (const sc_unsigned& u, unsigned long v); 1784 friend bool operator <= (const sc_unsigned& u, int v) 1785 { return operator<=(u, (long) v); } 1786 friend bool operator <= (const sc_unsigned& u, unsigned int v) 1787 { return operator<=(u, (unsigned long) v); } 1788 1789 friend bool operator <= (int64 u, const sc_unsigned& v); 1790 friend bool operator <= (uint64 u, const sc_unsigned& v); 1791 friend bool operator <= (long u, const sc_unsigned& v); 1792 friend bool operator <= (unsigned long u, const sc_unsigned& v); 1793 friend bool operator <= (int u, const sc_unsigned& v) 1794 { return operator<=((long) u, v); } 1795 friend bool operator <= (unsigned int u, const sc_unsigned& v) 1796 { return operator<=((unsigned long) u, v); } 1797 1798 friend bool operator <= (const sc_unsigned& u, const sc_uint_base& v); 1799 friend bool operator <= (const sc_unsigned& u, const sc_int_base& v); 1800 friend bool operator <= (const sc_uint_base& u, const sc_unsigned& v); 1801 friend bool operator <= (const sc_int_base& u, const sc_unsigned& v); 1802 1803 // Logical GREATER_THAN operators: 1804 1805 friend bool operator > (const sc_unsigned& u, const sc_signed& v); 1806 friend bool operator > (const sc_signed& u, const sc_unsigned& v); 1807 1808 friend bool operator > (const sc_unsigned& u, const sc_unsigned& v); 1809 friend bool operator > (const sc_unsigned& u, int64 v); 1810 friend bool operator > (const sc_unsigned& u, uint64 v); 1811 friend bool operator > (const sc_unsigned& u, long v); 1812 friend bool operator > (const sc_unsigned& u, unsigned long v); 1813 friend bool operator > (const sc_unsigned& u, int v) 1814 { return operator>(u, (long) v); } 1815 friend bool operator > (const sc_unsigned& u, unsigned int v) 1816 { return operator>(u, (unsigned long) v); } 1817 1818 friend bool operator > (int64 u, const sc_unsigned& v); 1819 friend bool operator > (uint64 u, const sc_unsigned& v); 1820 friend bool operator > (long u, const sc_unsigned& v); 1821 friend bool operator > (unsigned long u, const sc_unsigned& v); 1822 friend bool operator > (int u, const sc_unsigned& v) 1823 { return operator>((long) u, v); } 1824 friend bool operator > (unsigned int u, const sc_unsigned& v) 1825 { return operator>((unsigned long) u, v); } 1826 1827 friend bool operator > (const sc_unsigned& u, const sc_uint_base& v); 1828 friend bool operator > (const sc_unsigned& u, const sc_int_base& v); 1829 friend bool operator > (const sc_uint_base& u, const sc_unsigned& v); 1830 friend bool operator > (const sc_int_base& u, const sc_unsigned& v); 1831 1832 // Logical GREATER_THAN_AND_EQUAL operators: 1833 1834 friend bool operator >= (const sc_unsigned& u, const sc_signed& v); 1835 friend bool operator >= (const sc_signed& u, const sc_unsigned& v); 1836 1837 friend bool operator >= (const sc_unsigned& u, const sc_unsigned& v); 1838 friend bool operator >= (const sc_unsigned& u, int64 v); 1839 friend bool operator >= (const sc_unsigned& u, uint64 v); 1840 friend bool operator >= (const sc_unsigned& u, long v); 1841 friend bool operator >= (const sc_unsigned& u, unsigned long v); 1842 friend bool operator >= (const sc_unsigned& u, int v) 1843 { return operator>=(u, (long) v); } 1844 friend bool operator >= (const sc_unsigned& u, unsigned int v) 1845 { return operator>=(u, (unsigned long) v); } 1846 1847 friend bool operator >= (int64 u, const sc_unsigned& v); 1848 friend bool operator >= (uint64 u, const sc_unsigned& v); 1849 friend bool operator >= (long u, const sc_unsigned& v); 1850 friend bool operator >= (unsigned long u, const sc_unsigned& v); 1851 friend bool operator >= (int u, const sc_unsigned& v) 1852 { return operator>=((long) u, v); } 1853 friend bool operator >= (unsigned int u, const sc_unsigned& v) 1854 { return operator>=((unsigned long) u, v); } 1855 1856 friend bool operator >= (const sc_unsigned& u, const sc_uint_base& v); 1857 friend bool operator >= (const sc_unsigned& u, const sc_int_base& v); 1858 friend bool operator >= (const sc_uint_base& u, const sc_unsigned& v); 1859 friend bool operator >= (const sc_int_base& u, const sc_unsigned& v); 1860 1861 // Bitwise NOT operator (unary). 1862 friend sc_unsigned operator ~ (const sc_unsigned& u); 1863 1864 // Helper functions. 1865 friend int compare_unsigned(small_type us, 1866 int unb, 1867 int und, 1868 const sc_digit *ud, 1869 small_type vs, 1870 int vnb, 1871 int vnd, 1872 const sc_digit *vd, 1873 small_type if_u_signed, 1874 small_type if_v_signed); 1875 1876 friend sc_unsigned add_unsigned_friend(small_type us, 1877 int unb, 1878 int und, 1879 const sc_digit *ud, 1880 small_type vs, 1881 int vnb, 1882 int vnd, 1883 const sc_digit *vd); 1884 1885 friend sc_unsigned sub_unsigned_friend(small_type us, 1886 int unb, 1887 int und, 1888 const sc_digit *ud, 1889 small_type vs, 1890 int vnb, 1891 int vnd, 1892 const sc_digit *vd); 1893 1894 friend sc_unsigned mul_unsigned_friend(small_type s, 1895 int unb, 1896 int und, 1897 const sc_digit *ud, 1898 int vnb, 1899 int vnd, 1900 const sc_digit *vd); 1901 1902 friend sc_unsigned div_unsigned_friend(small_type s, 1903 int unb, 1904 int und, 1905 const sc_digit *ud, 1906 int vnb, 1907 int vnd, 1908 const sc_digit *vd); 1909 1910 friend sc_unsigned mod_unsigned_friend(small_type us, 1911 int unb, 1912 int und, 1913 const sc_digit *ud, 1914 int vnb, 1915 int vnd, 1916 const sc_digit *vd); 1917 1918 friend sc_unsigned and_unsigned_friend(small_type us, 1919 int unb, 1920 int und, 1921 const sc_digit *ud, 1922 small_type vs, 1923 int vnb, 1924 int vnd, 1925 const sc_digit *vd); 1926 1927 friend sc_unsigned or_unsigned_friend(small_type us, 1928 int unb, 1929 int und, 1930 const sc_digit *ud, 1931 small_type vs, 1932 int vnb, 1933 int vnd, 1934 const sc_digit *vd); 1935 1936 friend sc_unsigned xor_unsigned_friend(small_type us, 1937 int unb, 1938 int und, 1939 const sc_digit *ud, 1940 small_type vs, 1941 int vnb, 1942 int vnd, 1943 const sc_digit *vd); 1944 1945public: 1946 static sc_core::sc_vpool<sc_unsigned> m_pool; 1947 1948private: 1949 1950 small_type sgn; // Shortened as s. 1951 int nbits; // Shortened as nb. 1952 int ndigits; // Shortened as nd. 1953 1954#ifdef SC_MAX_NBITS 1955 sc_digit digit[DIV_CEIL(SC_MAX_NBITS)]; // Shortened as d. 1956#else 1957 sc_digit *digit; // Shortened as d. 1958#endif 1959 1960 // Private constructors: 1961 1962 // Create a copy of v with sign s. 1963 sc_unsigned(const sc_unsigned& v, small_type s); 1964 sc_unsigned(const sc_signed& v, small_type s); 1965 1966 // Create an unsigned number with the given attributes. 1967 sc_unsigned(small_type s, int nb, int nd, 1968 sc_digit *d, bool alloc = true); 1969 1970 // Create an unsigned number using the bits u[l..r]. 1971 sc_unsigned(const sc_signed* u, int l, int r); 1972 sc_unsigned(const sc_unsigned* u, int l, int r); 1973 1974 // Private member functions. The called functions are inline functions. 1975 1976 small_type default_sign() const 1977 { return SC_POS; } 1978 1979 int num_bits(int nb) const { return nb + 1; } 1980 1981 bool check_if_outside(int bit_num) const; 1982 1983 void copy_digits(int nb, int nd, const sc_digit *d) 1984 { copy_digits_unsigned(sgn, nbits, ndigits, digit, nb, nd, d); } 1985 1986 void makezero() 1987 { sgn = make_zero(ndigits, digit); } 1988 1989 // Conversion functions between 2's complement (2C) and 1990 // sign-magnitude (SM): 1991 void convert_2C_to_SM() 1992 { sgn = convert_unsigned_2C_to_SM(nbits, ndigits, digit); } 1993 1994 void convert_SM_to_2C_to_SM() 1995 { sgn = convert_unsigned_SM_to_2C_to_SM(sgn, nbits, ndigits, digit); } 1996 1997 void convert_SM_to_2C() 1998 { convert_unsigned_SM_to_2C(sgn, ndigits, digit); } 1999 2000}; 2001 2002 2003 2004inline 2005::std::ostream& 2006operator << ( ::std::ostream&, const sc_unsigned& ); 2007 2008inline 2009::std::istream& 2010operator >> ( ::std::istream&, sc_unsigned& ); 2011 2012 2013// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII 2014 2015// ---------------------------------------------------------------------------- 2016// CLASS : sc_unsigned_bitref_r 2017// 2018// Proxy class for sc_unsigned bit selection (r-value only). 2019// ---------------------------------------------------------------------------- 2020 2021 2022inline 2023::std::ostream& 2024operator << ( ::std::ostream& os, const sc_unsigned_bitref_r& a ) 2025{ 2026 a.print( os ); 2027 return os; 2028} 2029 2030 2031// ---------------------------------------------------------------------------- 2032// CLASS : sc_unsigned_bitref 2033// 2034// Proxy class for sc_unsigned bit selection (r-value and l-value). 2035// ---------------------------------------------------------------------------- 2036 2037template<class T> 2038inline const sc_unsigned_subref& sc_unsigned_subref::operator = ( 2039 const sc_generic_base<T>& a ) 2040{ 2041 sc_unsigned temp( length() ); 2042 a->to_sc_unsigned(temp); 2043 return *this = temp; 2044} 2045 2046inline 2047::std::istream& 2048operator >> ( ::std::istream& is, sc_unsigned_bitref& a ) 2049{ 2050 a.scan( is ); 2051 return is; 2052} 2053 2054 2055// ---------------------------------------------------------------------------- 2056// CLASS : sc_unsigned_subref_r 2057// 2058// Proxy class for sc_unsigned part selection (r-value only). 2059// ---------------------------------------------------------------------------- 2060 2061// reduce methods 2062 2063inline bool sc_unsigned_subref_r::and_reduce() const 2064{ 2065 const sc_unsigned* target_p = m_obj_p; 2066 for ( int i = m_right; i <= m_left; i++ ) 2067 if ( !target_p->test(i) ) return false; 2068 return true; 2069} 2070 2071inline bool sc_unsigned_subref_r::nand_reduce() const 2072{ 2073 return !and_reduce(); 2074} 2075 2076inline bool sc_unsigned_subref_r::or_reduce() const 2077{ 2078 const sc_unsigned* target_p = m_obj_p; 2079 for ( int i = m_right; i <= m_left; i++ ) 2080 if ( target_p->test(i) ) return true; 2081 return false; 2082} 2083 2084inline bool sc_unsigned_subref_r::nor_reduce() const 2085{ 2086 return !or_reduce(); 2087} 2088 2089inline bool sc_unsigned_subref_r::xor_reduce() const 2090{ 2091 int odd; 2092 const sc_unsigned* target_p = m_obj_p; 2093 odd = 0; 2094 for ( int i = m_right; i <= m_left; i++ ) 2095 if ( target_p->test(i) ) odd = ~odd; 2096 return odd ? true : false; 2097} 2098 2099inline bool sc_unsigned_subref_r::xnor_reduce() const 2100{ 2101 return !xor_reduce(); 2102} 2103 2104 2105inline 2106::std::ostream& 2107operator << ( ::std::ostream& os, const sc_unsigned_subref_r& a ) 2108{ 2109 a.print( os ); 2110 return os; 2111} 2112 2113 2114// ---------------------------------------------------------------------------- 2115// CLASS : sc_unsigned_subref 2116// 2117// Proxy class for sc_unsigned part selection (r-value and l-value). 2118// ---------------------------------------------------------------------------- 2119 2120// assignment operators 2121 2122inline 2123const sc_unsigned_subref& 2124sc_unsigned_subref::operator = ( const char* a ) 2125{ 2126 sc_unsigned aa( length() ); 2127 return ( *this = aa = a ); 2128} 2129 2130 2131inline 2132::std::istream& 2133operator >> ( ::std::istream& is, sc_unsigned_subref& a ) 2134{ 2135 a.scan( is ); 2136 return is; 2137} 2138 2139 2140 2141// ---------------------------------------------------------------------------- 2142// CLASS : sc_unsigned 2143// 2144// Arbitrary precision signed number. 2145// ---------------------------------------------------------------------------- 2146 2147template<class T> 2148sc_unsigned::sc_unsigned( const sc_generic_base<T>& v ) 2149{ 2150 int nb = v->length(); 2151 sgn = default_sign(); 2152 if( nb > 0 ) { 2153 nbits = num_bits( nb ); 2154 } else { 2155 char msg[BUFSIZ]; 2156 std::sprintf( msg, 2157 "sc_unsigned( sc_generic_base<T> ) : nb = %d is not valid", nb); 2158 SC_REPORT_ERROR( sc_core::SC_ID_INIT_FAILED_, msg ); 2159 } 2160 ndigits = DIV_CEIL(nbits); 2161# ifdef SC_MAX_NBITS 2162 test_bound(nb); 2163# else 2164 digit = new sc_digit[ndigits]; 2165# endif 2166 makezero(); 2167 v->to_sc_unsigned(*this); 2168} 2169 2170 2171inline 2172::std::ostream& 2173operator << ( ::std::ostream& os, const sc_unsigned& a ) 2174{ 2175 a.print( os ); 2176 return os; 2177} 2178 2179inline 2180::std::istream& 2181operator >> ( ::std::istream& is, sc_unsigned& a ) 2182{ 2183 a.scan( is ); 2184 return is; 2185} 2186 2187 2188} // namespace sc_dt 2189 2190 2191#endif 2192