1-- ----------------------------------------------------------------------------- 2-- 3-- Copyright 1995 by IEEE. All rights reserved. 4-- 5-- This source file is considered by the IEEE to be an essential part of the use 6-- of the standard 1076.3 and as such may be distributed without change, except 7-- as permitted by the standard. This source file may not be sold or distributed 8-- for profit. This package may be modified to include additional data required 9-- by tools, but must in no way change the external interfaces or simulation 10-- behaviour of the description. It is permissible to add comments and/or 11-- attributes to the package declarations, but not to change or delete any 12-- original lines of the approved package declaration. The package body may be 13-- changed only in accordance with the terms of clauses 7.1 and 7.2 of the 14-- standard. 15-- 16-- Title : Standard VHDL Synthesis Package (1076.3, NUMERIC_BIT) 17-- 18-- Library : This package shall be compiled into a library symbolically 19-- : named IEEE. 20-- 21-- Developers : IEEE DASC Synthesis Working Group, PAR 1076.3 22-- 23-- Purpose : This package defines numeric types and arithmetic functions 24-- : for use with synthesis tools. Two numeric types are defined: 25-- : -- > UNSIGNED: represents an UNSIGNED number in vector form 26-- : -- > SIGNED: represents a SIGNED number in vector form 27-- : The base element type is type BIT. 28-- : The leftmost bit is treated as the most significant bit. 29-- : Signed vectors are represented in two's complement form. 30-- : This package contains overloaded arithmetic operators on 31-- : the SIGNED and UNSIGNED types. The package also contains 32-- : useful type conversions functions, clock detection 33-- : functions, and other utility functions. 34-- : 35-- : If any argument to a function is a null array, a null array is 36-- : returned (exceptions, if any, are noted individually). 37-- 38-- Limitation : 39-- 40-- Note : No declarations or definitions shall be included in, 41-- : or excluded from this package. The "package declaration" 42-- : defines the types, subtypes and declarations of 43-- : NUMERIC_BIT. The NUMERIC_BIT package body shall be 44-- : considered the formal definition of the semantics of 45-- : this package. Tool developers may choose to implement 46-- : the package body in the most efficient manner available 47-- : to them. 48-- : 49-- ----------------------------------------------------------------------------- 50-- Version : 2.4 51-- Date : 12 April 1995 52-- ----------------------------------------------------------------------------- 53 54--============================================================================== 55--======================= Package Body ========================================= 56--============================================================================== 57 58package body NUMERIC_BIT is 59 60 -- null range array constants 61 62 constant NAU: UNSIGNED(0 downto 1) := (others => '0'); 63 constant NAS: SIGNED(0 downto 1) := (others => '0'); 64 65 -- implementation controls 66 67 constant NO_WARNING: BOOLEAN := FALSE; -- default to emit warnings 68 69 --=========================Local Subprograms ================================= 70 71 function MAX (LEFT, RIGHT: INTEGER) return INTEGER is 72 begin 73 if LEFT > RIGHT then return LEFT; 74 else return RIGHT; 75 end if; 76 end MAX; 77 78 function MIN (LEFT, RIGHT: INTEGER) return INTEGER is 79 begin 80 if LEFT < RIGHT then return LEFT; 81 else return RIGHT; 82 end if; 83 end MIN; 84 85 function SIGNED_NUM_BITS (ARG: INTEGER) return NATURAL is 86 variable NBITS: NATURAL; 87 variable N: NATURAL; 88 begin 89 if ARG >= 0 then 90 N := ARG; 91 else 92 N := -(ARG+1); 93 end if; 94 NBITS := 1; 95 while N > 0 loop 96 NBITS := NBITS+1; 97 N := N / 2; 98 end loop; 99 return NBITS; 100 end SIGNED_NUM_BITS; 101 102 function UNSIGNED_NUM_BITS (ARG: NATURAL) return NATURAL is 103 variable NBITS: NATURAL; 104 variable N: NATURAL; 105 begin 106 N := ARG; 107 NBITS := 1; 108 while N > 1 loop 109 NBITS := NBITS+1; 110 N := N / 2; 111 end loop; 112 return NBITS; 113 end UNSIGNED_NUM_BITS; 114 115 ------------------------------------------------------------------------------ 116 -- this internal function computes the addition of two UNSIGNED 117 -- with input carry 118 -- * the two arguments are of the same length 119 120 function ADD_UNSIGNED (L, R: UNSIGNED; C: BIT) return UNSIGNED is 121 constant L_LEFT: INTEGER := L'LENGTH-1; 122 alias XL: UNSIGNED(L_LEFT downto 0) is L; 123 alias XR: UNSIGNED(L_LEFT downto 0) is R; 124 variable RESULT: UNSIGNED(L_LEFT downto 0); 125 variable CBIT: BIT := C; 126 begin 127 for I in 0 to L_LEFT loop 128 RESULT(I) := CBIT xor XL(I) xor XR(I); 129 CBIT := (CBIT and XL(I)) or (CBIT and XR(I)) or (XL(I) and XR(I)); 130 end loop; 131 return RESULT; 132 end ADD_UNSIGNED; 133 134 -- this internal function computes the addition of two SIGNED 135 -- with input carry 136 -- * the two arguments are of the same length 137 138 function ADD_SIGNED (L, R: SIGNED; C: BIT) return SIGNED is 139 constant L_LEFT: INTEGER := L'LENGTH-1; 140 alias XL: SIGNED(L_LEFT downto 0) is L; 141 alias XR: SIGNED(L_LEFT downto 0) is R; 142 variable RESULT: SIGNED(L_LEFT downto 0); 143 variable CBIT: BIT := C; 144 begin 145 for I in 0 to L_LEFT loop 146 RESULT(I) := CBIT xor XL(I) xor XR(I); 147 CBIT := (CBIT and XL(I)) or (CBIT and XR(I)) or (XL(I) and XR(I)); 148 end loop; 149 return RESULT; 150 end ADD_SIGNED; 151 152 ------------------------------------------------------------------------------ 153 154 -- this internal procedure computes UNSIGNED division 155 -- giving the quotient and remainder. 156 procedure DIVMOD (NUM, XDENOM: UNSIGNED; XQUOT, XREMAIN: out UNSIGNED) is 157 variable TEMP: UNSIGNED(NUM'LENGTH downto 0); 158 variable QUOT: UNSIGNED(MAX(NUM'LENGTH, XDENOM'LENGTH)-1 downto 0); 159 alias DENOM: UNSIGNED(XDENOM'LENGTH-1 downto 0) is XDENOM; 160 variable TOPBIT: INTEGER; 161 begin 162 TEMP := "0"&NUM; 163 QUOT := (others => '0'); 164 TOPBIT := -1; 165 for J in DENOM'RANGE loop 166 if DENOM(J)='1' then 167 TOPBIT := J; 168 exit; 169 end if; 170 end loop; 171 assert TOPBIT >= 0 report "DIV, MOD, or REM by zero" severity ERROR; 172 173 for J in NUM'LENGTH-(TOPBIT+1) downto 0 loop 174 if TEMP(TOPBIT+J+1 downto J) >= "0"&DENOM(TOPBIT downto 0) then 175 TEMP(TOPBIT+J+1 downto J) := (TEMP(TOPBIT+J+1 downto J)) 176 -("0"&DENOM(TOPBIT downto 0)); 177 QUOT(J) := '1'; 178 end if; 179 assert TEMP(TOPBIT+J+1)='0' 180 report "internal error in the division algorithm" 181 severity ERROR; 182 end loop; 183 XQUOT := RESIZE(QUOT, XQUOT'LENGTH); 184 XREMAIN := RESIZE(TEMP, XREMAIN'LENGTH); 185 end DIVMOD; 186 187 -----------------Local Subprograms - shift/rotate ops------------------------- 188 189 function XSLL (ARG: BIT_VECTOR; COUNT: NATURAL) return BIT_VECTOR is 190 constant ARG_L: INTEGER := ARG'LENGTH-1; 191 alias XARG: BIT_VECTOR(ARG_L downto 0) is ARG; 192 variable RESULT: BIT_VECTOR(ARG_L downto 0) := (others => '0'); 193 begin 194 if COUNT <= ARG_L then 195 RESULT(ARG_L downto COUNT) := XARG(ARG_L-COUNT downto 0); 196 end if; 197 return RESULT; 198 end XSLL; 199 200 function XSRL (ARG: BIT_VECTOR; COUNT: NATURAL) return BIT_VECTOR is 201 constant ARG_L: INTEGER := ARG'LENGTH-1; 202 alias XARG: BIT_VECTOR(ARG_L downto 0) is ARG; 203 variable RESULT: BIT_VECTOR(ARG_L downto 0) := (others => '0'); 204 begin 205 if COUNT <= ARG_L then 206 RESULT(ARG_L-COUNT downto 0) := XARG(ARG_L downto COUNT); 207 end if; 208 return RESULT; 209 end XSRL; 210 211 function XSRA (ARG: BIT_VECTOR; COUNT: NATURAL) return BIT_VECTOR is 212 constant ARG_L: INTEGER := ARG'LENGTH-1; 213 alias XARG: BIT_VECTOR(ARG_L downto 0) is ARG; 214 variable RESULT: BIT_VECTOR(ARG_L downto 0); 215 variable XCOUNT: NATURAL := COUNT; 216 begin 217 if ((ARG'LENGTH <= 1) or (XCOUNT = 0)) then return ARG; 218 else 219 if (XCOUNT > ARG_L) then XCOUNT := ARG_L; 220 end if; 221 RESULT(ARG_L-XCOUNT downto 0) := XARG(ARG_L downto XCOUNT); 222 RESULT(ARG_L downto (ARG_L - XCOUNT + 1)) := (others => XARG(ARG_L)); 223 end if; 224 return RESULT; 225 end XSRA; 226 227 function XROL (ARG: BIT_VECTOR; COUNT: NATURAL) return BIT_VECTOR is 228 constant ARG_L: INTEGER := ARG'LENGTH-1; 229 alias XARG: BIT_VECTOR(ARG_L downto 0) is ARG; 230 variable RESULT: BIT_VECTOR(ARG_L downto 0) := XARG; 231 variable COUNTM: INTEGER; 232 begin 233 COUNTM := COUNT mod (ARG_L + 1); 234 if COUNTM /= 0 then 235 RESULT(ARG_L downto COUNTM) := XARG(ARG_L-COUNTM downto 0); 236 RESULT(COUNTM-1 downto 0) := XARG(ARG_L downto ARG_L-COUNTM+1); 237 end if; 238 return RESULT; 239 end XROL; 240 241 function XROR (ARG: BIT_VECTOR; COUNT: NATURAL) return BIT_VECTOR is 242 constant ARG_L: INTEGER := ARG'LENGTH-1; 243 alias XARG: BIT_VECTOR(ARG_L downto 0) is ARG; 244 variable RESULT: BIT_VECTOR(ARG_L downto 0) := XARG; 245 variable COUNTM: INTEGER; 246 begin 247 COUNTM := COUNT mod (ARG_L + 1); 248 if COUNTM /= 0 then 249 RESULT(ARG_L-COUNTM downto 0) := XARG(ARG_L downto COUNTM); 250 RESULT(ARG_L downto ARG_L-COUNTM+1) := XARG(COUNTM-1 downto 0); 251 end if; 252 return RESULT; 253 end XROR; 254 255 ---------------- Local Subprograms - Relational Operators -------------------- 256 257 -- General "=" for UNSIGNED vectors, same length 258 -- 259 function UNSIGNED_EQUAL (L, R: UNSIGNED) return BOOLEAN is 260 begin 261 return BIT_VECTOR(L) = BIT_VECTOR(R); 262 end UNSIGNED_EQUAL; 263 264 -- 265 -- General "=" for SIGNED vectors, same length 266 -- 267 function SIGNED_EQUAL (L, R: SIGNED) return BOOLEAN is 268 begin 269 return BIT_VECTOR(L) = BIT_VECTOR(R); 270 end SIGNED_EQUAL; 271 272 -- 273 -- General "<" for UNSIGNED vectors, same length 274 -- 275 function UNSIGNED_LESS (L, R: UNSIGNED) return BOOLEAN is 276 begin 277 return BIT_VECTOR(L) < BIT_VECTOR(R); 278 end UNSIGNED_LESS; 279 280 -- 281 -- General "<" function for SIGNED vectors, same length 282 -- 283 function SIGNED_LESS (L, R: SIGNED) return BOOLEAN is 284 -- Need aliases to assure index direction 285 variable INTERN_L: SIGNED(0 to L'LENGTH-1); 286 variable INTERN_R: SIGNED(0 to R'LENGTH-1); 287 begin 288 INTERN_L := L; 289 INTERN_R := R; 290 INTERN_L(0) := not INTERN_L(0); 291 INTERN_R(0) := not INTERN_R(0); 292 return BIT_VECTOR(INTERN_L) < BIT_VECTOR(INTERN_R); 293 end SIGNED_LESS; 294 295 -- 296 -- General "<=" function for UNSIGNED vectors, same length 297 -- 298 function UNSIGNED_LESS_OR_EQUAL (L, R: UNSIGNED) return BOOLEAN is 299 begin 300 return BIT_VECTOR(L) <= BIT_VECTOR(R); 301 end UNSIGNED_LESS_OR_EQUAL; 302 303 -- 304 -- General "<=" function for SIGNED vectors, same length 305 -- 306 function SIGNED_LESS_OR_EQUAL (L, R: SIGNED) return BOOLEAN is 307 -- Need aliases to assure index direction 308 variable INTERN_L: SIGNED(0 to L'LENGTH-1); 309 variable INTERN_R: SIGNED(0 to R'LENGTH-1); 310 begin 311 INTERN_L := L; 312 INTERN_R := R; 313 INTERN_L(0) := not INTERN_L(0); 314 INTERN_R(0) := not INTERN_R(0); 315 return BIT_VECTOR(INTERN_L) <= BIT_VECTOR(INTERN_R); 316 end SIGNED_LESS_OR_EQUAL; 317 318 --====================== Exported Functions ================================== 319 320 -- Id: A.1 321 function "abs" (ARG: SIGNED) return SIGNED is 322 constant ARG_LEFT: INTEGER := ARG'LENGTH-1; 323 variable RESULT: SIGNED(ARG_LEFT downto 0); 324 begin 325 if ARG'LENGTH < 1 then return NAS; 326 end if; 327 RESULT := ARG; 328 if RESULT(RESULT'LEFT) = '1' then 329 RESULT := -RESULT; 330 end if; 331 return RESULT; 332 end "abs"; 333 334 -- Id: A.2 335 function "-" (ARG: SIGNED) return SIGNED is 336 constant ARG_LEFT: INTEGER := ARG'LENGTH-1; 337 alias XARG: SIGNED(ARG_LEFT downto 0) is ARG; 338 variable RESULT: SIGNED(ARG_LEFT downto 0); 339 variable CBIT: BIT := '1'; 340 begin 341 if ARG'LENGTH < 1 then return NAS; 342 end if; 343 for I in 0 to RESULT'LEFT loop 344 RESULT(I) := not(XARG(I)) xor CBIT; 345 CBIT := CBIT and not(XARG(I)); 346 end loop; 347 return RESULT; 348 end "-"; 349 350 --============================================================================ 351 352 -- Id: A.3 353 function "+" (L, R: UNSIGNED) return UNSIGNED is 354 constant L_LEFT: INTEGER := L'LENGTH-1; 355 constant R_LEFT: INTEGER := R'LENGTH-1; 356 constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); 357 begin 358 if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAU; 359 end if; 360 return ADD_UNSIGNED(RESIZE(L, SIZE), RESIZE(R, SIZE), '0'); 361 end "+"; 362 363 -- Id: A.4 364 function "+" (L, R: SIGNED) return SIGNED is 365 constant L_LEFT: INTEGER := L'LENGTH-1; 366 constant R_LEFT: INTEGER := R'LENGTH-1; 367 constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); 368 begin 369 if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAS; 370 end if; 371 return ADD_SIGNED(RESIZE(L, SIZE), RESIZE(R, SIZE), '0'); 372 end "+"; 373 374 -- Id: A.5 375 function "+" (L: UNSIGNED; R: NATURAL) return UNSIGNED is 376 begin 377 return L + TO_UNSIGNED(R, L'LENGTH); 378 end "+"; 379 380 -- Id: A.6 381 function "+" (L: NATURAL; R: UNSIGNED) return UNSIGNED is 382 begin 383 return TO_UNSIGNED(L, R'LENGTH) + R; 384 end "+"; 385 386 -- Id: A.7 387 function "+" (L: SIGNED; R: INTEGER) return SIGNED is 388 begin 389 return L + TO_SIGNED(R, L'LENGTH); 390 end "+"; 391 392 -- Id: A.8 393 function "+" (L: INTEGER; R: SIGNED) return SIGNED is 394 begin 395 return TO_SIGNED(L, R'LENGTH) + R; 396 end "+"; 397 398 --============================================================================ 399 400 -- Id: A.9 401 function "-" (L, R: UNSIGNED) return UNSIGNED is 402 constant L_LEFT: INTEGER := L'LENGTH-1; 403 constant R_LEFT: INTEGER := R'LENGTH-1; 404 constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); 405 begin 406 if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAU; 407 end if; 408 return ADD_UNSIGNED(RESIZE(L, SIZE), 409 not(RESIZE(R, SIZE)), 410 '1'); 411 end "-"; 412 413 -- Id: A.10 414 function "-" (L, R: SIGNED) return SIGNED is 415 constant L_LEFT: INTEGER := L'LENGTH-1; 416 constant R_LEFT: INTEGER := R'LENGTH-1; 417 constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); 418 begin 419 if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAS; 420 end if; 421 return ADD_SIGNED(RESIZE(L, SIZE), 422 not(RESIZE(R, SIZE)), 423 '1'); 424 end "-"; 425 426 -- Id: A.11 427 function "-" (L: UNSIGNED; R: NATURAL) return UNSIGNED is 428 begin 429 return L - TO_UNSIGNED(R, L'LENGTH); 430 end "-"; 431 432 -- Id: A.12 433 function "-" (L: NATURAL; R: UNSIGNED) return UNSIGNED is 434 begin 435 return TO_UNSIGNED(L, R'LENGTH) - R; 436 end "-"; 437 438 -- Id: A.13 439 function "-" (L: SIGNED; R: INTEGER) return SIGNED is 440 begin 441 return L - TO_SIGNED(R, L'LENGTH); 442 end "-"; 443 444 -- Id: A.14 445 function "-" (L: INTEGER; R: SIGNED) return SIGNED is 446 begin 447 return TO_SIGNED(L, R'LENGTH) - R; 448 end "-"; 449 450 --============================================================================ 451 452 -- Id: A.15 453 function "*" (L, R: UNSIGNED) return UNSIGNED is 454 constant L_LEFT: INTEGER := L'LENGTH-1; 455 constant R_LEFT: INTEGER := R'LENGTH-1; 456 alias XL: UNSIGNED(L_LEFT downto 0) is L; 457 alias XR: UNSIGNED(R_LEFT downto 0) is R; 458 variable RESULT: UNSIGNED((L'LENGTH+R'LENGTH-1) downto 0) := (others => '0'); 459 variable ADVAL: UNSIGNED((L'LENGTH+R'LENGTH-1) downto 0); 460 begin 461 if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAU; 462 end if; 463 ADVAL := RESIZE(XR, RESULT'LENGTH); 464 for I in 0 to L_LEFT loop 465 if XL(I)='1' then RESULT := RESULT + ADVAL; 466 end if; 467 ADVAL := SHIFT_LEFT(ADVAL, 1); 468 end loop; 469 return RESULT; 470 end "*"; 471 472 -- Id: A.16 473 function "*" (L, R: SIGNED) return SIGNED is 474 constant L_LEFT: INTEGER := L'LENGTH-1; 475 constant R_LEFT: INTEGER := R'LENGTH-1; 476 variable XL: SIGNED(L_LEFT downto 0); 477 variable XR: SIGNED(R_LEFT downto 0); 478 variable RESULT: SIGNED((L_LEFT+R_LEFT+1) downto 0) := (others => '0'); 479 variable ADVAL: SIGNED((L_LEFT+R_LEFT+1) downto 0); 480 begin 481 if ((L_LEFT < 0) or (R_LEFT < 0)) then return NAS; 482 end if; 483 XL := L; 484 XR := R; 485 ADVAL := RESIZE(XR, RESULT'LENGTH); 486 for I in 0 to L_LEFT-1 loop 487 if XL(I)='1' then RESULT := RESULT + ADVAL; 488 end if; 489 ADVAL := SHIFT_LEFT(ADVAL, 1); 490 end loop; 491 if XL(L_LEFT)='1' then 492 RESULT := RESULT - ADVAL; 493 end if; 494 return RESULT; 495 end "*"; 496 497 -- Id: A.17 498 function "*" (L: UNSIGNED; R: NATURAL) return UNSIGNED is 499 begin 500 return L * TO_UNSIGNED(R, L'LENGTH); 501 end "*"; 502 503 -- Id: A.18 504 function "*" (L: NATURAL; R: UNSIGNED) return UNSIGNED is 505 begin 506 return TO_UNSIGNED(L, R'LENGTH) * R; 507 end "*"; 508 509 -- Id: A.19 510 function "*" (L: SIGNED; R: INTEGER) return SIGNED is 511 begin 512 return L * TO_SIGNED(R, L'LENGTH); 513 end "*"; 514 515 -- Id: A.20 516 function "*" (L: INTEGER; R: SIGNED) return SIGNED is 517 begin 518 return TO_SIGNED(L, R'LENGTH) * R; 519 end "*"; 520 521 --============================================================================ 522 523 -- Id: A.21 524 function "/" (L, R: UNSIGNED) return UNSIGNED is 525 variable FQUOT: UNSIGNED(L'LENGTH-1 downto 0); 526 variable FREMAIN: UNSIGNED(R'LENGTH-1 downto 0); 527 begin 528 if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAU; 529 end if; 530 DIVMOD(L, R, FQUOT, FREMAIN); 531 return FQUOT; 532 end "/"; 533 534 -- Id: A.22 535 function "/" (L, R: SIGNED) return SIGNED is 536 variable FQUOT: UNSIGNED(L'LENGTH-1 downto 0); 537 variable FREMAIN: UNSIGNED(R'LENGTH-1 downto 0); 538 variable XNUM: UNSIGNED(L'LENGTH-1 downto 0); 539 variable XDENOM: UNSIGNED(R'LENGTH-1 downto 0); 540 variable QNEG: BOOLEAN := FALSE; 541 begin 542 if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAS; 543 end if; 544 if L(L'LEFT)='1' then 545 XNUM := UNSIGNED(-L); 546 QNEG := TRUE; 547 else 548 XNUM := UNSIGNED(L); 549 end if; 550 if R(R'LEFT)='1' then 551 XDENOM := UNSIGNED(-R); 552 QNEG := not QNEG; 553 else 554 XDENOM := UNSIGNED(R); 555 end if; 556 DIVMOD(XNUM, XDENOM, FQUOT, FREMAIN); 557 if QNEG then FQUOT := "0"-FQUOT; 558 end if; 559 return SIGNED(FQUOT); 560 end "/"; 561 562 -- Id: A.23 563 function "/" (L: UNSIGNED; R: NATURAL) return UNSIGNED is 564 constant R_LENGTH: NATURAL := MAX(L'LENGTH, UNSIGNED_NUM_BITS(R)); 565 variable XR, QUOT: UNSIGNED(R_LENGTH-1 downto 0); 566 begin 567 if (L'LENGTH < 1) then return NAU; 568 end if; 569 if (R_LENGTH > L'LENGTH) then 570 QUOT := (others => '0'); 571 return RESIZE(QUOT, L'LENGTH); 572 end if; 573 XR := TO_UNSIGNED(R, R_LENGTH); 574 QUOT := RESIZE((L / XR), QUOT'LENGTH); 575 return RESIZE(QUOT, L'LENGTH); 576 end "/"; 577 578 -- Id: A.24 579 function "/" (L: NATURAL; R: UNSIGNED) return UNSIGNED is 580 constant L_LENGTH: NATURAL := MAX(UNSIGNED_NUM_BITS(L), R'LENGTH); 581 variable XL, QUOT: UNSIGNED(L_LENGTH-1 downto 0); 582 begin 583 if (R'LENGTH < 1) then return NAU; 584 end if; 585 XL := TO_UNSIGNED(L, L_LENGTH); 586 QUOT := RESIZE((XL / R), QUOT'LENGTH); 587 if L_LENGTH > R'LENGTH 588 and QUOT(L_LENGTH-1 downto R'LENGTH) 589 /= (L_LENGTH-1 downto R'LENGTH => '0') 590 then 591 assert NO_WARNING report "NUMERIC_BIT.""/"": Quotient Truncated" 592 severity WARNING; 593 end if; 594 return RESIZE(QUOT, R'LENGTH); 595 end "/"; 596 597 -- Id: A.25 598 function "/" (L: SIGNED; R: INTEGER) return SIGNED is 599 constant R_LENGTH: NATURAL := MAX(L'LENGTH, SIGNED_NUM_BITS(R)); 600 variable XR, QUOT: SIGNED(R_LENGTH-1 downto 0); 601 begin 602 if (L'LENGTH < 1) then return NAS; 603 end if; 604 if (R_LENGTH > L'LENGTH) then 605 QUOT := (others => '0'); 606 return RESIZE(QUOT, L'LENGTH); 607 end if; 608 XR := TO_SIGNED(R, R_LENGTH); 609 QUOT := RESIZE((L / XR), QUOT'LENGTH); 610 return RESIZE(QUOT, L'LENGTH); 611 end "/"; 612 613 -- Id: A.26 614 function "/" (L: INTEGER; R: SIGNED) return SIGNED is 615 constant L_LENGTH: NATURAL := MAX(SIGNED_NUM_BITS(L), R'LENGTH); 616 variable XL, QUOT: SIGNED(L_LENGTH-1 downto 0); 617 begin 618 if (R'LENGTH < 1) then return NAS; 619 end if; 620 XL := TO_SIGNED(L, L_LENGTH); 621 QUOT := RESIZE((XL / R), QUOT'LENGTH); 622 if L_LENGTH > R'LENGTH and QUOT(L_LENGTH-1 downto R'LENGTH) 623 /= (L_LENGTH-1 downto R'LENGTH => QUOT(R'LENGTH-1)) 624 then 625 assert NO_WARNING report "NUMERIC_BIT.""/"": Quotient Truncated" 626 severity WARNING; 627 end if; 628 return RESIZE(QUOT, R'LENGTH); 629 end "/"; 630 631 --============================================================================ 632 633 -- Id: A.27 634 function "rem" (L, R: UNSIGNED) return UNSIGNED is 635 variable FQUOT: UNSIGNED(L'LENGTH-1 downto 0); 636 variable FREMAIN: UNSIGNED(R'LENGTH-1 downto 0); 637 begin 638 if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAU; 639 end if; 640 DIVMOD(L, R, FQUOT, FREMAIN); 641 return FREMAIN; 642 end "rem"; 643 644 -- Id: A.28 645 function "rem" (L, R: SIGNED) return SIGNED is 646 variable FQUOT: UNSIGNED(L'LENGTH-1 downto 0); 647 variable FREMAIN: UNSIGNED(R'LENGTH-1 downto 0); 648 variable XNUM: UNSIGNED(L'LENGTH-1 downto 0); 649 variable XDENOM: UNSIGNED(R'LENGTH-1 downto 0); 650 variable RNEG: BOOLEAN := FALSE; 651 begin 652 if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAS; 653 end if; 654 if L(L'LEFT)='1' then 655 XNUM := UNSIGNED(-L); 656 RNEG := TRUE; 657 else 658 XNUM := UNSIGNED(L); 659 end if; 660 if R(R'LEFT)='1' then 661 XDENOM := UNSIGNED(-R); 662 else 663 XDENOM := UNSIGNED(R); 664 end if; 665 DIVMOD(XNUM, XDENOM, FQUOT, FREMAIN); 666 if RNEG then 667 FREMAIN := "0"-FREMAIN; 668 end if; 669 return SIGNED(FREMAIN); 670 end "rem"; 671 672 -- Id: A.29 673 function "rem" (L: UNSIGNED; R: NATURAL) return UNSIGNED is 674 constant R_LENGTH: NATURAL := MAX(L'LENGTH, UNSIGNED_NUM_BITS(R)); 675 variable XR, XREM: UNSIGNED(R_LENGTH-1 downto 0); 676 begin 677 if (L'LENGTH < 1) then return NAU; 678 end if; 679 XR := TO_UNSIGNED(R, R_LENGTH); 680 XREM := RESIZE((L rem XR), XREM'LENGTH); 681 if R_LENGTH > L'LENGTH and XREM(R_LENGTH-1 downto L'LENGTH) 682 /= (R_LENGTH-1 downto L'LENGTH => '0') 683 then 684 assert NO_WARNING report "NUMERIC_BIT.""rem"": Remainder Truncated" 685 severity WARNING; 686 end if; 687 return RESIZE(XREM, L'LENGTH); 688 end "rem"; 689 690 -- Id: A.30 691 function "rem" (L: NATURAL; R: UNSIGNED) return UNSIGNED is 692 constant L_LENGTH: NATURAL := MAX(UNSIGNED_NUM_BITS(L), R'LENGTH); 693 variable XL, XREM: UNSIGNED(L_LENGTH-1 downto 0); 694 begin 695 if (R'LENGTH < 1) then return NAU; 696 end if; 697 XL := TO_UNSIGNED(L, L_LENGTH); 698 XREM := RESIZE((XL rem R), XREM'LENGTH); 699 if L_LENGTH > R'LENGTH and XREM(L_LENGTH-1 downto R'LENGTH) 700 /= (L_LENGTH-1 downto R'LENGTH => '0') 701 then 702 assert NO_WARNING report "NUMERIC_BIT.""rem"": Remainder Truncated" 703 severity WARNING; 704 end if; 705 return RESIZE(XREM, R'LENGTH); 706 end "rem"; 707 708 -- Id: A.31 709 function "rem" (L: SIGNED; R: INTEGER) return SIGNED is 710 constant R_LENGTH: NATURAL := MAX(L'LENGTH, SIGNED_NUM_BITS(R)); 711 variable XR, XREM: SIGNED(R_LENGTH-1 downto 0); 712 begin 713 if (L'LENGTH < 1) then return NAS; 714 end if; 715 XR := TO_SIGNED(R, R_LENGTH); 716 XREM := RESIZE((L rem XR), XREM'LENGTH); 717 if R_LENGTH > L'LENGTH and XREM(R_LENGTH-1 downto L'LENGTH) 718 /= (R_LENGTH-1 downto L'LENGTH => XREM(L'LENGTH-1)) 719 then 720 assert NO_WARNING report "NUMERIC_BIT.""rem"": Remainder Truncated" 721 severity WARNING; 722 end if; 723 return RESIZE(XREM, L'LENGTH); 724 end "rem"; 725 726 -- Id: A.32 727 function "rem" (L: INTEGER; R: SIGNED) return SIGNED is 728 constant L_LENGTH: NATURAL := MAX(SIGNED_NUM_BITS(L), R'LENGTH); 729 variable XL, XREM: SIGNED(L_LENGTH-1 downto 0); 730 begin 731 if (R'LENGTH < 1) then return NAS; 732 end if; 733 XL := TO_SIGNED(L, L_LENGTH); 734 XREM := RESIZE((XL rem R), XREM'LENGTH); 735 if L_LENGTH > R'LENGTH and XREM(L_LENGTH-1 downto R'LENGTH) 736 /= (L_LENGTH-1 downto R'LENGTH => XREM(R'LENGTH-1)) 737 then 738 assert NO_WARNING report "NUMERIC_BIT.""rem"": Remainder Truncated" 739 severity WARNING; 740 end if; 741 return RESIZE(XREM, R'LENGTH); 742 end "rem"; 743 744 --============================================================================ 745 746 -- Id: A.33 747 function "mod" (L, R: UNSIGNED) return UNSIGNED is 748 variable FQUOT: UNSIGNED(L'LENGTH-1 downto 0); 749 variable FREMAIN: UNSIGNED(R'LENGTH-1 downto 0); 750 begin 751 if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAU; 752 end if; 753 DIVMOD(L, R, FQUOT, FREMAIN); 754 return FREMAIN; 755 end "mod"; 756 757 -- Id: A.34 758 function "mod" (L, R: SIGNED) return SIGNED is 759 variable FQUOT: UNSIGNED(L'LENGTH-1 downto 0); 760 variable FREMAIN: UNSIGNED(R'LENGTH-1 downto 0); 761 variable XNUM: UNSIGNED(L'LENGTH-1 downto 0); 762 variable XDENOM: UNSIGNED(R'LENGTH-1 downto 0); 763 variable RNEG: BOOLEAN := FALSE; 764 begin 765 if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAS; 766 end if; 767 if L(L'LEFT)='1' then 768 XNUM := UNSIGNED(-L); 769 else 770 XNUM := UNSIGNED(L); 771 end if; 772 if R(R'LEFT)='1' then 773 XDENOM := UNSIGNED(-R); 774 RNEG := TRUE; 775 else 776 XDENOM := UNSIGNED(R); 777 end if; 778 DIVMOD(XNUM, XDENOM, FQUOT, FREMAIN); 779 if RNEG and L(L'LEFT)='1' then 780 FREMAIN := "0"-FREMAIN; 781 elsif RNEG and FREMAIN/="0" then 782 FREMAIN := FREMAIN-XDENOM; 783 elsif L(L'LEFT)='1' and FREMAIN/="0" then 784 FREMAIN := XDENOM-FREMAIN; 785 end if; 786 return SIGNED(FREMAIN); 787 end "mod"; 788 789 -- Id: A.35 790 function "mod" (L: UNSIGNED; R: NATURAL) return UNSIGNED is 791 constant R_LENGTH: NATURAL := MAX(L'LENGTH, UNSIGNED_NUM_BITS(R)); 792 variable XR, XREM: UNSIGNED(R_LENGTH-1 downto 0); 793 begin 794 if (L'LENGTH < 1) then return NAU; 795 end if; 796 XR := TO_UNSIGNED(R, R_LENGTH); 797 XREM := RESIZE((L mod XR), XREM'LENGTH); 798 if R_LENGTH > L'LENGTH and XREM(R_LENGTH-1 downto L'LENGTH) 799 /= (R_LENGTH-1 downto L'LENGTH => '0') 800 then 801 assert NO_WARNING report "NUMERIC_BIT.""mod"": modulus Truncated" 802 severity WARNING; 803 end if; 804 return RESIZE(XREM, L'LENGTH); 805 end "mod"; 806 807 -- Id: A.36 808 function "mod" (L: NATURAL; R: UNSIGNED) return UNSIGNED is 809 constant L_LENGTH: NATURAL := MAX(UNSIGNED_NUM_BITS(L), R'LENGTH); 810 variable XL, XREM: UNSIGNED(L_LENGTH-1 downto 0); 811 begin 812 if (R'LENGTH < 1) then return NAU; 813 end if; 814 XL := TO_UNSIGNED(L, L_LENGTH); 815 XREM := RESIZE((XL mod R), XREM'LENGTH); 816 if L_LENGTH > R'LENGTH and XREM(L_LENGTH-1 downto R'LENGTH) 817 /= (L_LENGTH-1 downto R'LENGTH => '0') 818 then 819 assert NO_WARNING report "NUMERIC_BIT.""mod"": modulus Truncated" 820 severity WARNING; 821 end if; 822 return RESIZE(XREM, R'LENGTH); 823 end "mod"; 824 825 -- Id: A.37 826 function "mod" (L: SIGNED; R: INTEGER) return SIGNED is 827 constant R_LENGTH: NATURAL := MAX(L'LENGTH, SIGNED_NUM_BITS(R)); 828 variable XR, XREM: SIGNED(R_LENGTH-1 downto 0); 829 begin 830 if (L'LENGTH < 1) then return NAS; 831 end if; 832 XR := TO_SIGNED(R, R_LENGTH); 833 XREM := RESIZE((L mod XR), XREM'LENGTH); 834 if R_LENGTH > L'LENGTH and XREM(R_LENGTH-1 downto L'LENGTH) 835 /= (R_LENGTH-1 downto L'LENGTH => XREM(L'LENGTH-1)) 836 then 837 assert NO_WARNING report "NUMERIC_BIT.""mod"": modulus Truncated" 838 severity WARNING; 839 end if; 840 return RESIZE(XREM, L'LENGTH); 841 end "mod"; 842 843 -- Id: A.38 844 function "mod" (L: INTEGER; R: SIGNED) return SIGNED is 845 constant L_LENGTH: NATURAL := MAX(SIGNED_NUM_BITS(L), R'LENGTH); 846 variable XL, XREM: SIGNED(L_LENGTH-1 downto 0); 847 begin 848 if (R'LENGTH < 1) then return NAS; 849 end if; 850 XL := TO_SIGNED(L, L_LENGTH); 851 XREM := RESIZE((XL mod R), XREM'LENGTH); 852 if L_LENGTH > R'LENGTH and XREM(L_LENGTH-1 downto R'LENGTH) 853 /= (L_LENGTH-1 downto R'LENGTH => XREM(R'LENGTH-1)) 854 then 855 assert NO_WARNING report "NUMERIC_BIT.""mod"": modulus Truncated" 856 severity WARNING; 857 end if; 858 return RESIZE(XREM, R'LENGTH); 859 end "mod"; 860 861 --============================================================================ 862 863 -- Id: C.1 864 function ">" (L, R: UNSIGNED) return BOOLEAN is 865 variable SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); 866 begin 867 if ((L'LENGTH < 1) or (R'LENGTH < 1)) then 868 assert NO_WARNING 869 report "NUMERIC_BIT."">"": null argument detected, returning FALSE" 870 severity WARNING; 871 return FALSE; 872 end if; 873 return not UNSIGNED_LESS_OR_EQUAL(RESIZE(L, SIZE), RESIZE(R, SIZE)); 874 end ">"; 875 876 -- Id: C.2 877 function ">" (L, R: SIGNED) return BOOLEAN is 878 variable SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); 879 begin 880 if ((L'LENGTH < 1) or (R'LENGTH < 1)) then 881 assert NO_WARNING 882 report "NUMERIC_BIT."">"": null argument detected, returning FALSE" 883 severity WARNING; 884 return FALSE; 885 end if; 886 return not SIGNED_LESS_OR_EQUAL(RESIZE(L, SIZE), RESIZE(R, SIZE)); 887 end ">"; 888 889 -- Id: C.3 890 function ">" (L: NATURAL; R: UNSIGNED) return BOOLEAN is 891 begin 892 if (R'LENGTH < 1) then 893 assert NO_WARNING 894 report "NUMERIC_BIT."">"": null argument detected, returning FALSE" 895 severity WARNING; 896 return FALSE; 897 end if; 898 if UNSIGNED_NUM_BITS(L) > R'LENGTH then return TRUE; 899 end if; 900 return not UNSIGNED_LESS_OR_EQUAL(TO_UNSIGNED(L, R'LENGTH), R); 901 end ">"; 902 903 -- Id: C.4 904 function ">" (L: INTEGER; R: SIGNED) return BOOLEAN is 905 begin 906 if (R'LENGTH < 1) then 907 assert NO_WARNING 908 report "NUMERIC_BIT."">"": null argument detected, returning FALSE" 909 severity WARNING; 910 return FALSE; 911 end if; 912 if SIGNED_NUM_BITS(L) > R'LENGTH then return L > 0; 913 end if; 914 return not SIGNED_LESS_OR_EQUAL(TO_SIGNED(L, R'LENGTH), R); 915 end ">"; 916 917 -- Id: C.5 918 function ">" (L: UNSIGNED; R: NATURAL) return BOOLEAN is 919 begin 920 if (L'LENGTH < 1) then 921 assert NO_WARNING 922 report "NUMERIC_BIT."">"": null argument detected, returning FALSE" 923 severity WARNING; 924 return FALSE; 925 end if; 926 if UNSIGNED_NUM_BITS(R) > L'LENGTH then return FALSE; 927 end if; 928 return not UNSIGNED_LESS_OR_EQUAL(L, TO_UNSIGNED(R, L'LENGTH)); 929 end ">"; 930 931 -- Id: C.6 932 function ">" (L: SIGNED; R: INTEGER) return BOOLEAN is 933 begin 934 if (L'LENGTH < 1) then 935 assert NO_WARNING 936 report "NUMERIC_BIT."">"": null argument detected, returning FALSE" 937 severity WARNING; 938 return FALSE; 939 end if; 940 if SIGNED_NUM_BITS(R) > L'LENGTH then return 0 > R; 941 end if; 942 return not SIGNED_LESS_OR_EQUAL(L, TO_SIGNED(R, L'LENGTH)); 943 end ">"; 944 945 --============================================================================ 946 947 -- Id: C.7 948 function "<" (L, R: UNSIGNED) return BOOLEAN is 949 variable SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); 950 begin 951 if ((L'LENGTH < 1) or (R'LENGTH < 1)) then 952 assert NO_WARNING 953 report "NUMERIC_BIT.""<"": null argument detected, returning FALSE" 954 severity WARNING; 955 return FALSE; 956 end if; 957 return UNSIGNED_LESS(RESIZE(L, SIZE), RESIZE(R, SIZE)); 958 end "<"; 959 960 -- Id: C.8 961 function "<" (L, R: SIGNED) return BOOLEAN is 962 variable SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); 963 begin 964 if ((L'LENGTH < 1) or (R'LENGTH < 1)) then 965 assert NO_WARNING 966 report "NUMERIC_BIT.""<"": null argument detected, returning FALSE" 967 severity WARNING; 968 return FALSE; 969 end if; 970 return SIGNED_LESS(RESIZE(L, SIZE), RESIZE(R, SIZE)); 971 end "<"; 972 973 -- Id: C.9 974 function "<" (L: NATURAL; R: UNSIGNED) return BOOLEAN is 975 begin 976 if (R'LENGTH < 1) then 977 assert NO_WARNING 978 report "NUMERIC_BIT.""<"": null argument detected, returning FALSE" 979 severity WARNING; 980 return FALSE; 981 end if; 982 if UNSIGNED_NUM_BITS(L) > R'LENGTH then return L < 0; 983 end if; 984 return UNSIGNED_LESS(TO_UNSIGNED(L, R'LENGTH), R); 985 end "<"; 986 987 -- Id: C.10 988 function "<" (L: INTEGER; R: SIGNED) return BOOLEAN is 989 begin 990 if (R'LENGTH < 1) then 991 assert NO_WARNING 992 report "NUMERIC_BIT.""<"": null argument detected, returning FALSE" 993 severity WARNING; 994 return FALSE; 995 end if; 996 if SIGNED_NUM_BITS(L) > R'LENGTH then return L < 0; 997 end if; 998 return SIGNED_LESS(TO_SIGNED(L, R'LENGTH), R); 999 end "<"; 1000 1001 -- Id: C.11 1002 function "<" (L: UNSIGNED; R: NATURAL) return BOOLEAN is 1003 begin 1004 if (L'LENGTH < 1) then 1005 assert NO_WARNING 1006 report "NUMERIC_BIT.""<"": null argument detected, returning FALSE" 1007 severity WARNING; 1008 return FALSE; 1009 end if; 1010 if UNSIGNED_NUM_BITS(R) > L'LENGTH then return 0 < R; 1011 end if; 1012 return UNSIGNED_LESS(L, TO_UNSIGNED(R, L'LENGTH)); 1013 end "<"; 1014 1015 -- Id: C.12 1016 function "<" (L: SIGNED; R: INTEGER) return BOOLEAN is 1017 begin 1018 if (L'LENGTH < 1) then 1019 assert NO_WARNING 1020 report "NUMERIC_BIT.""<"": null argument detected, returning FALSE" 1021 severity WARNING; 1022 return FALSE; 1023 end if; 1024 if SIGNED_NUM_BITS(R) > L'LENGTH then return 0 < R; 1025 end if; 1026 return SIGNED_LESS(L, TO_SIGNED(R, L'LENGTH)); 1027 end "<"; 1028 1029 --============================================================================ 1030 1031 -- Id: C.13 1032 function "<=" (L, R: UNSIGNED) return BOOLEAN is 1033 variable SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); 1034 begin 1035 if ((L'LENGTH < 1) or (R'LENGTH < 1)) then 1036 assert NO_WARNING 1037 report "NUMERIC_BIT.""<="": null argument detected, returning FALSE" 1038 severity WARNING; 1039 return FALSE; 1040 end if; 1041 return UNSIGNED_LESS_OR_EQUAL(RESIZE(L, SIZE), RESIZE(R, SIZE)); 1042 end "<="; 1043 1044 -- Id: C.14 1045 function "<=" (L, R: SIGNED) return BOOLEAN is 1046 variable SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); 1047 begin 1048 if ((L'LENGTH < 1) or (R'LENGTH < 1)) then 1049 assert NO_WARNING 1050 report "NUMERIC_BIT.""<="": null argument detected, returning FALSE" 1051 severity WARNING; 1052 return FALSE; 1053 end if; 1054 return SIGNED_LESS_OR_EQUAL(RESIZE(L, SIZE), RESIZE(R, SIZE)); 1055 end "<="; 1056 1057 -- Id: C.15 1058 function "<=" (L: NATURAL; R: UNSIGNED) return BOOLEAN is 1059 begin 1060 if (R'LENGTH < 1) then 1061 assert NO_WARNING 1062 report "NUMERIC_BIT.""<="": null argument detected, returning FALSE" 1063 severity WARNING; 1064 return FALSE; 1065 end if; 1066 if UNSIGNED_NUM_BITS(L) > R'LENGTH then return L < 0; 1067 end if; 1068 return UNSIGNED_LESS_OR_EQUAL(TO_UNSIGNED(L, R'LENGTH), R); 1069 end "<="; 1070 1071 -- Id: C.16 1072 function "<=" (L: INTEGER; R: SIGNED) return BOOLEAN is 1073 begin 1074 if (R'LENGTH < 1) then 1075 assert NO_WARNING 1076 report "NUMERIC_BIT.""<="": null argument detected, returning FALSE" 1077 severity WARNING; 1078 return FALSE; 1079 end if; 1080 if SIGNED_NUM_BITS(L) > R'LENGTH then return L < 0; 1081 end if; 1082 return SIGNED_LESS_OR_EQUAL(TO_SIGNED(L, R'LENGTH), R); 1083 end "<="; 1084 1085 -- Id: C.17 1086 function "<=" (L: UNSIGNED; R: NATURAL) return BOOLEAN is 1087 begin 1088 if (L'LENGTH < 1) then 1089 assert NO_WARNING 1090 report "NUMERIC_BIT.""<="": null argument detected, returning FALSE" 1091 severity WARNING; 1092 return FALSE; 1093 end if; 1094 if UNSIGNED_NUM_BITS(R) > L'LENGTH then return 0 < R; 1095 end if; 1096 return UNSIGNED_LESS_OR_EQUAL(L, TO_UNSIGNED(R, L'LENGTH)); 1097 end "<="; 1098 1099 -- Id: C.18 1100 function "<=" (L: SIGNED; R: INTEGER) return BOOLEAN is 1101 begin 1102 if (L'LENGTH < 1) then 1103 assert NO_WARNING 1104 report "NUMERIC_BIT.""<="": null argument detected, returning FALSE" 1105 severity WARNING; 1106 return FALSE; 1107 end if; 1108 if SIGNED_NUM_BITS(R) > L'LENGTH then return 0 < R; 1109 end if; 1110 return SIGNED_LESS_OR_EQUAL(L, TO_SIGNED(R, L'LENGTH)); 1111 end "<="; 1112 1113 --============================================================================ 1114 1115 -- Id: C.19 1116 function ">=" (L, R: UNSIGNED) return BOOLEAN is 1117 variable SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); 1118 begin 1119 if ((L'LENGTH < 1) or (R'LENGTH < 1)) then 1120 assert NO_WARNING 1121 report "NUMERIC_BIT."">="": null argument detected, returning FALSE" 1122 severity WARNING; 1123 return FALSE; 1124 end if; 1125 return not UNSIGNED_LESS(RESIZE(L, SIZE), RESIZE(R, SIZE)); 1126 end ">="; 1127 1128 -- Id: C.20 1129 function ">=" (L, R: SIGNED) return BOOLEAN is 1130 variable SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); 1131 begin 1132 if ((L'LENGTH < 1) or (R'LENGTH < 1)) then 1133 assert NO_WARNING 1134 report "NUMERIC_BIT."">="": null argument detected, returning FALSE" 1135 severity WARNING; 1136 return FALSE; 1137 end if; 1138 return not SIGNED_LESS(RESIZE(L, SIZE), RESIZE(R, SIZE)); 1139 end ">="; 1140 1141 -- Id: C.21 1142 function ">=" (L: NATURAL; R: UNSIGNED) return BOOLEAN is 1143 begin 1144 if (R'LENGTH < 1) then 1145 assert NO_WARNING 1146 report "NUMERIC_BIT."">="": null argument detected, returning FALSE" 1147 severity WARNING; 1148 return FALSE; 1149 end if; 1150 if UNSIGNED_NUM_BITS(L) > R'LENGTH then return L > 0; 1151 end if; 1152 return not UNSIGNED_LESS(TO_UNSIGNED(L, R'LENGTH), R); 1153 end ">="; 1154 1155 -- Id: C.22 1156 function ">=" (L: INTEGER; R: SIGNED) return BOOLEAN is 1157 begin 1158 if (R'LENGTH < 1) then 1159 assert NO_WARNING 1160 report "NUMERIC_BIT."">="": null argument detected, returning FALSE" 1161 severity WARNING; 1162 return FALSE; 1163 end if; 1164 if SIGNED_NUM_BITS(L) > R'LENGTH then return L > 0; 1165 end if; 1166 return not SIGNED_LESS(TO_SIGNED(L, R'LENGTH), R); 1167 end ">="; 1168 1169 -- Id: C.23 1170 function ">=" (L: UNSIGNED; R: NATURAL) return BOOLEAN is 1171 begin 1172 if (L'LENGTH < 1) then 1173 assert NO_WARNING 1174 report "NUMERIC_BIT."">="": null argument detected, returning FALSE" 1175 severity WARNING; 1176 return FALSE; 1177 end if; 1178 if UNSIGNED_NUM_BITS(R) > L'LENGTH then return 0 > R; 1179 end if; 1180 return not UNSIGNED_LESS(L, TO_UNSIGNED(R, L'LENGTH)); 1181 end ">="; 1182 1183 -- Id: C.24 1184 function ">=" (L: SIGNED; R: INTEGER) return BOOLEAN is 1185 begin 1186 if (L'LENGTH < 1) then 1187 assert NO_WARNING 1188 report "NUMERIC_BIT."">="": null argument detected, returning FALSE" 1189 severity WARNING; 1190 return FALSE; 1191 end if; 1192 if SIGNED_NUM_BITS(R) > L'LENGTH then return 0 > R; 1193 end if; 1194 return not SIGNED_LESS(L, TO_SIGNED(R, L'LENGTH)); 1195 end ">="; 1196 1197 --============================================================================ 1198 1199 -- Id: C.25 1200 function "=" (L, R: UNSIGNED) return BOOLEAN is 1201 variable SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); 1202 begin 1203 if ((L'LENGTH < 1) or (R'LENGTH < 1)) then 1204 assert NO_WARNING 1205 report "NUMERIC_BIT.""="": null argument detected, returning FALSE" 1206 severity WARNING; 1207 return FALSE; 1208 end if; 1209 return UNSIGNED_EQUAL(RESIZE(L, SIZE), RESIZE(R, SIZE)); 1210 end "="; 1211 1212 -- Id: C.26 1213 function "=" (L, R: SIGNED) return BOOLEAN is 1214 variable SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); 1215 begin 1216 if ((L'LENGTH < 1) or (R'LENGTH < 1)) then 1217 assert NO_WARNING 1218 report "NUMERIC_BIT.""="": null argument detected, returning FALSE" 1219 severity WARNING; 1220 return FALSE; 1221 end if; 1222 return SIGNED_EQUAL(RESIZE(L, SIZE), RESIZE(R, SIZE)); 1223 end "="; 1224 1225 -- Id: C.27 1226 function "=" (L: NATURAL; R: UNSIGNED) return BOOLEAN is 1227 begin 1228 if (R'LENGTH < 1) then 1229 assert NO_WARNING 1230 report "NUMERIC_BIT.""="": null argument detected, returning FALSE" 1231 severity WARNING; 1232 return FALSE; 1233 end if; 1234 if UNSIGNED_NUM_BITS(L) > R'LENGTH then return FALSE; 1235 end if; 1236 return UNSIGNED_EQUAL(TO_UNSIGNED(L, R'LENGTH), R); 1237 end "="; 1238 1239 -- Id: C.28 1240 function "=" (L: INTEGER; R: SIGNED) return BOOLEAN is 1241 begin 1242 if (R'LENGTH < 1) then 1243 assert NO_WARNING 1244 report "NUMERIC_BIT.""="": null argument detected, returning FALSE" 1245 severity WARNING; 1246 return FALSE; 1247 end if; 1248 if SIGNED_NUM_BITS(L) > R'LENGTH then return FALSE; 1249 end if; 1250 return SIGNED_EQUAL(TO_SIGNED(L, R'LENGTH), R); 1251 end "="; 1252 1253 -- Id: C.29 1254 function "=" (L: UNSIGNED; R: NATURAL) return BOOLEAN is 1255 begin 1256 if (L'LENGTH < 1) then 1257 assert NO_WARNING 1258 report "NUMERIC_BIT.""="": null argument detected, returning FALSE" 1259 severity WARNING; 1260 return FALSE; 1261 end if; 1262 if UNSIGNED_NUM_BITS(R) > L'LENGTH then return FALSE; 1263 end if; 1264 return UNSIGNED_EQUAL(L, TO_UNSIGNED(R, L'LENGTH)); 1265 end "="; 1266 1267 -- Id: C.30 1268 function "=" (L: SIGNED; R: INTEGER) return BOOLEAN is 1269 begin 1270 if (L'LENGTH < 1) then 1271 assert NO_WARNING 1272 report "NUMERIC_BIT.""="": null argument detected, returning FALSE" 1273 severity WARNING; 1274 return FALSE; 1275 end if; 1276 if SIGNED_NUM_BITS(R) > L'LENGTH then return FALSE; 1277 end if; 1278 return SIGNED_EQUAL(L, TO_SIGNED(R, L'LENGTH)); 1279 end "="; 1280 1281 --============================================================================ 1282 1283 -- Id: C.31 1284 function "/=" (L, R: UNSIGNED) return BOOLEAN is 1285 variable SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); 1286 begin 1287 if ((L'LENGTH < 1) or (R'LENGTH < 1)) then 1288 assert NO_WARNING 1289 report "NUMERIC_BIT.""/="": null argument detected, returning TRUE" 1290 severity WARNING; 1291 return TRUE; 1292 end if; 1293 return not(UNSIGNED_EQUAL(RESIZE(L, SIZE), RESIZE(R, SIZE))); 1294 end "/="; 1295 1296 -- Id: C.32 1297 function "/=" (L, R: SIGNED) return BOOLEAN is 1298 variable SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); 1299 begin 1300 if ((L'LENGTH < 1) or (R'LENGTH < 1)) then 1301 assert NO_WARNING 1302 report "NUMERIC_BIT.""/="": null argument detected, returning TRUE" 1303 severity WARNING; 1304 return TRUE; 1305 end if; 1306 return not(SIGNED_EQUAL(RESIZE(L, SIZE), RESIZE(R, SIZE))); 1307 end "/="; 1308 1309 -- Id: C.33 1310 function "/=" (L: NATURAL; R: UNSIGNED) return BOOLEAN is 1311 begin 1312 if (R'LENGTH < 1) then 1313 assert NO_WARNING 1314 report "NUMERIC_BIT.""/="": null argument detected, returning TRUE" 1315 severity WARNING; 1316 return TRUE; 1317 end if; 1318 if UNSIGNED_NUM_BITS(L) > R'LENGTH then return TRUE; 1319 end if; 1320 return not(UNSIGNED_EQUAL(TO_UNSIGNED(L, R'LENGTH), R)); 1321 end "/="; 1322 1323 -- Id: C.34 1324 function "/=" (L: INTEGER; R: SIGNED) return BOOLEAN is 1325 begin 1326 if (R'LENGTH < 1) then 1327 assert NO_WARNING 1328 report "NUMERIC_BIT.""/="": null argument detected, returning TRUE" 1329 severity WARNING; 1330 return TRUE; 1331 end if; 1332 if SIGNED_NUM_BITS(L) > R'LENGTH then return TRUE; 1333 end if; 1334 return not(SIGNED_EQUAL(TO_SIGNED(L, R'LENGTH), R)); 1335 end "/="; 1336 1337 -- Id: C.35 1338 function "/=" (L: UNSIGNED; R: NATURAL) return BOOLEAN is 1339 begin 1340 if (L'LENGTH < 1) then 1341 assert NO_WARNING 1342 report "NUMERIC_BIT.""/="": null argument detected, returning TRUE" 1343 severity WARNING; 1344 return TRUE; 1345 end if; 1346 if UNSIGNED_NUM_BITS(R) > L'LENGTH then return TRUE; 1347 end if; 1348 return not(UNSIGNED_EQUAL(L, TO_UNSIGNED(R, L'LENGTH))); 1349 end "/="; 1350 1351 -- Id: C.36 1352 function "/=" (L: SIGNED; R: INTEGER) return BOOLEAN is 1353 begin 1354 if (L'LENGTH < 1) then 1355 assert NO_WARNING 1356 report "NUMERIC_BIT.""/="": null argument detected, returning TRUE" 1357 severity WARNING; 1358 return TRUE; 1359 end if; 1360 if SIGNED_NUM_BITS(R) > L'LENGTH then return TRUE; 1361 end if; 1362 return not(SIGNED_EQUAL(L, TO_SIGNED(R, L'LENGTH))); 1363 end "/="; 1364 1365 --============================================================================ 1366 1367 -- Id: S.1 1368 function SHIFT_LEFT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED is 1369 begin 1370 if (ARG'LENGTH < 1) then return NAU; 1371 end if; 1372 return UNSIGNED(XSLL(BIT_VECTOR(ARG), COUNT)); 1373 end SHIFT_LEFT; 1374 1375 -- Id: S.2 1376 function SHIFT_RIGHT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED is 1377 begin 1378 if (ARG'LENGTH < 1) then return NAU; 1379 end if; 1380 return UNSIGNED(XSRL(BIT_VECTOR(ARG), COUNT)); 1381 end SHIFT_RIGHT; 1382 1383 -- Id: S.3 1384 function SHIFT_LEFT (ARG: SIGNED; COUNT: NATURAL) return SIGNED is 1385 begin 1386 if (ARG'LENGTH < 1) then return NAS; 1387 end if; 1388 return SIGNED(XSLL(BIT_VECTOR(ARG), COUNT)); 1389 end SHIFT_LEFT; 1390 1391 -- Id: S.4 1392 function SHIFT_RIGHT (ARG: SIGNED; COUNT: NATURAL) return SIGNED is 1393 begin 1394 if (ARG'LENGTH < 1) then return NAS; 1395 end if; 1396 return SIGNED(XSRA(BIT_VECTOR(ARG), COUNT)); 1397 end SHIFT_RIGHT; 1398 1399 --============================================================================ 1400 1401 -- Id: S.5 1402 function ROTATE_LEFT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED is 1403 begin 1404 if (ARG'LENGTH < 1) then return NAU; 1405 end if; 1406 return UNSIGNED(XROL(BIT_VECTOR(ARG), COUNT)); 1407 end ROTATE_LEFT; 1408 1409 -- Id: S.6 1410 function ROTATE_RIGHT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED is 1411 begin 1412 if (ARG'LENGTH < 1) then return NAU; 1413 end if; 1414 return UNSIGNED(XROR(BIT_VECTOR(ARG), COUNT)); 1415 end ROTATE_RIGHT; 1416 1417 -- Id: S.7 1418 function ROTATE_LEFT (ARG: SIGNED; COUNT: NATURAL) return SIGNED is 1419 begin 1420 if (ARG'LENGTH < 1) then return NAS; 1421 end if; 1422 return SIGNED(XROL(BIT_VECTOR(ARG), COUNT)); 1423 end ROTATE_LEFT; 1424 1425 -- Id: S.8 1426 function ROTATE_RIGHT (ARG: SIGNED; COUNT: NATURAL) return SIGNED is 1427 begin 1428 if (ARG'LENGTH < 1) then return NAS; 1429 end if; 1430 return SIGNED(XROR(BIT_VECTOR(ARG), COUNT)); 1431 end ROTATE_RIGHT; 1432 1433 --============================================================================ 1434 1435--START-!V87 1436 ------------------------------------------------------------------------------ 1437 -- Note : Function S.9 is not compatible with VHDL 1076-1987. Comment 1438 -- out the function (declaration and body) for VHDL 1076-1987 compatibility. 1439 ------------------------------------------------------------------------------ 1440 -- Id: S.9 1441 function "sll" (ARG: UNSIGNED; COUNT: INTEGER) return UNSIGNED is 1442 begin 1443 if (COUNT >= 0) then 1444 return SHIFT_LEFT(ARG, COUNT); 1445 else 1446 return SHIFT_RIGHT(ARG, -COUNT); 1447 end if; 1448 end "sll"; 1449 1450 ------------------------------------------------------------------------------ 1451 -- Note : Function S.10 is not compatible with VHDL 1076-1987. Comment 1452 -- out the function (declaration and body) for VHDL 1076-1987 compatibility. 1453 ------------------------------------------------------------------------------ 1454 -- Id: S.10 1455 function "sll" (ARG: SIGNED; COUNT: INTEGER) return SIGNED is 1456 begin 1457 if (COUNT >= 0) then 1458 return SHIFT_LEFT(ARG, COUNT); 1459 else 1460 return SIGNED(SHIFT_RIGHT(UNSIGNED(ARG), -COUNT)); 1461 end if; 1462 end "sll"; 1463 1464 ------------------------------------------------------------------------------ 1465 -- Note : Function S.11 is not compatible with VHDL 1076-1987. Comment 1466 -- out the function (declaration and body) for VHDL 1076-1987 compatibility. 1467 ------------------------------------------------------------------------------ 1468 -- Id: S.11 1469 function "srl" (ARG: UNSIGNED; COUNT: INTEGER) return UNSIGNED is 1470 begin 1471 if (COUNT >= 0) then 1472 return SHIFT_RIGHT(ARG, COUNT); 1473 else 1474 return SHIFT_LEFT(ARG, -COUNT); 1475 end if; 1476 end "srl"; 1477 1478 ------------------------------------------------------------------------------ 1479 -- Note : Function S.12 is not compatible with VHDL 1076-1987. Comment 1480 -- out the function (declaration and body) for VHDL 1076-1987 compatibility. 1481 ------------------------------------------------------------------------------ 1482 -- Id: S.12 1483 function "srl" (ARG: SIGNED; COUNT: INTEGER) return SIGNED is 1484 begin 1485 if (COUNT >= 0) then 1486 return SIGNED(SHIFT_RIGHT(UNSIGNED(ARG), COUNT)); 1487 else 1488 return SHIFT_LEFT(ARG, -COUNT); 1489 end if; 1490 end "srl"; 1491 1492 ------------------------------------------------------------------------------ 1493 -- Note : Function S.13 is not compatible with VHDL 1076-1987. Comment 1494 -- out the function (declaration and body) for VHDL 1076-1987 compatibility. 1495 ------------------------------------------------------------------------------ 1496 -- Id: S.13 1497 function "rol" (ARG: UNSIGNED; COUNT: INTEGER) return UNSIGNED is 1498 begin 1499 if (COUNT >= 0) then 1500 return ROTATE_LEFT(ARG, COUNT); 1501 else 1502 return ROTATE_RIGHT(ARG, -COUNT); 1503 end if; 1504 end "rol"; 1505 1506 ------------------------------------------------------------------------------ 1507 -- Note : Function S.14 is not compatible with VHDL 1076-1987. Comment 1508 -- out the function (declaration and body) for VHDL 1076-1987 compatibility. 1509 ------------------------------------------------------------------------------ 1510 -- Id: S.14 1511 function "rol" (ARG: SIGNED; COUNT: INTEGER) return SIGNED is 1512 begin 1513 if (COUNT >= 0) then 1514 return ROTATE_LEFT(ARG, COUNT); 1515 else 1516 return ROTATE_RIGHT(ARG, -COUNT); 1517 end if; 1518 end "rol"; 1519 1520 ------------------------------------------------------------------------------ 1521 -- Note : Function S.15 is not compatible with VHDL 1076-1987. Comment 1522 -- out the function (declaration and body) for VHDL 1076-1987 compatibility. 1523 ------------------------------------------------------------------------------ 1524 -- Id: S.15 1525 function "ror" (ARG: UNSIGNED; COUNT: INTEGER) return UNSIGNED is 1526 begin 1527 if (COUNT >= 0) then 1528 return ROTATE_RIGHT(ARG, COUNT); 1529 else 1530 return ROTATE_LEFT(ARG, -COUNT); 1531 end if; 1532 end "ror"; 1533 1534 ------------------------------------------------------------------------------ 1535 -- Note : Function S.16 is not compatible with VHDL 1076-1987. Comment 1536 -- out the function (declaration and body) for VHDL 1076-1987 compatibility. 1537 ------------------------------------------------------------------------------ 1538 -- Id: S.16 1539 function "ror" (ARG: SIGNED; COUNT: INTEGER) return SIGNED is 1540 begin 1541 if (COUNT >= 0) then 1542 return ROTATE_RIGHT(ARG, COUNT); 1543 else 1544 return ROTATE_LEFT(ARG, -COUNT); 1545 end if; 1546 end "ror"; 1547 1548--END-!V87 1549 --============================================================================ 1550 1551 -- Id: D.1 1552 function TO_INTEGER (ARG: UNSIGNED) return NATURAL is 1553 constant ARG_LEFT: INTEGER := ARG'LENGTH-1; 1554 alias XARG: UNSIGNED(ARG_LEFT downto 0) is ARG; 1555 variable RESULT: NATURAL := 0; 1556 begin 1557 if (ARG'LENGTH < 1) then 1558 assert NO_WARNING 1559 report "NUMERIC_BIT.TO_INTEGER: null detected, returning 0" 1560 severity WARNING; 1561 return 0; 1562 end if; 1563 for I in XARG'RANGE loop 1564 RESULT := RESULT+RESULT; 1565 if XARG(I) = '1' then 1566 RESULT := RESULT + 1; 1567 end if; 1568 end loop; 1569 return RESULT; 1570 end TO_INTEGER; 1571 1572 -- Id: D.2 1573 function TO_INTEGER (ARG: SIGNED) return INTEGER is 1574 begin 1575 if (ARG'LENGTH < 1) then 1576 assert NO_WARNING 1577 report "NUMERIC_BIT.TO_INTEGER: null detected, returning 0" 1578 severity WARNING; 1579 return 0; 1580 end if; 1581 if ARG(ARG'LEFT) = '0' then 1582 return TO_INTEGER(UNSIGNED(ARG)); 1583 else 1584 return (- (TO_INTEGER(UNSIGNED(- (ARG + 1)))) -1); 1585 end if; 1586 end TO_INTEGER; 1587 1588 -- Id: D.3 1589 function TO_UNSIGNED (ARG, SIZE: NATURAL) return UNSIGNED is 1590 variable RESULT: UNSIGNED(SIZE-1 downto 0); 1591 variable I_VAL: NATURAL := ARG; 1592 begin 1593 if (SIZE < 1) then return NAU; 1594 end if; 1595 for I in 0 to RESULT'LEFT loop 1596 if (I_VAL mod 2) = 0 then 1597 RESULT(I) := '0'; 1598 else RESULT(I) := '1'; 1599 end if; 1600 I_VAL := I_VAL/2; 1601 end loop; 1602 if not(I_VAL =0) then 1603 assert NO_WARNING 1604 report "NUMERIC_BIT.TO_UNSIGNED: vector truncated" 1605 severity WARNING; 1606 end if; 1607 return RESULT; 1608 end TO_UNSIGNED; 1609 1610 -- Id: D.4 1611 function TO_SIGNED (ARG: INTEGER; 1612 SIZE: NATURAL) return SIGNED is 1613 variable RESULT: SIGNED(SIZE-1 downto 0); 1614 variable B_VAL: BIT := '0'; 1615 variable I_VAL: INTEGER := ARG; 1616 begin 1617 if (SIZE < 1) then return NAS; 1618 end if; 1619 if (ARG < 0) then 1620 B_VAL := '1'; 1621 I_VAL := -(ARG+1); 1622 end if; 1623 for I in 0 to RESULT'LEFT loop 1624 if (I_VAL mod 2) = 0 then 1625 RESULT(I) := B_VAL; 1626 else 1627 RESULT(I) := not B_VAL; 1628 end if; 1629 I_VAL := I_VAL/2; 1630 end loop; 1631 if ((I_VAL/=0) or (B_VAL/=RESULT(RESULT'LEFT))) then 1632 assert NO_WARNING 1633 report "NUMERIC_BIT.TO_SIGNED: vector truncated" 1634 severity WARNING; 1635 end if; 1636 return RESULT; 1637 end TO_SIGNED; 1638 1639 --============================================================================ 1640 1641 -- Id: R.1 1642 function RESIZE (ARG: SIGNED; NEW_SIZE: NATURAL) return SIGNED is 1643 alias INVEC: SIGNED(ARG'LENGTH-1 downto 0) is ARG; 1644 variable RESULT: SIGNED(NEW_SIZE-1 downto 0) := (others => '0'); 1645 constant BOUND: INTEGER := MIN(ARG'LENGTH, RESULT'LENGTH)-2; 1646 begin 1647 if (NEW_SIZE < 1) then return NAS; 1648 end if; 1649 if (ARG'LENGTH = 0) then return RESULT; 1650 end if; 1651 RESULT := (others => ARG(ARG'LEFT)); 1652 if BOUND >= 0 then 1653 RESULT(BOUND downto 0) := INVEC(BOUND downto 0); 1654 end if; 1655 return RESULT; 1656 end RESIZE; 1657 1658 -- Id: R.2 1659 function RESIZE (ARG: UNSIGNED; NEW_SIZE: NATURAL) return UNSIGNED is 1660 constant ARG_LEFT: INTEGER := ARG'LENGTH-1; 1661 alias XARG: UNSIGNED(ARG_LEFT downto 0) is ARG; 1662 variable RESULT: UNSIGNED(NEW_SIZE-1 downto 0) := (others => '0'); 1663 begin 1664 if (NEW_SIZE < 1) then return NAU; 1665 end if; 1666 if XARG'LENGTH =0 then return RESULT; 1667 end if; 1668 if (RESULT'LENGTH < ARG'LENGTH) then 1669 RESULT(RESULT'LEFT downto 0) := XARG(RESULT'LEFT downto 0); 1670 else 1671 RESULT(RESULT'LEFT downto XARG'LEFT+1) := (others => '0'); 1672 RESULT(XARG'LEFT downto 0) := XARG; 1673 end if; 1674 return RESULT; 1675 end RESIZE; 1676 1677 --============================================================================ 1678 1679 -- Id: L.1 1680 function "not" (L: UNSIGNED) return UNSIGNED is 1681 variable RESULT: UNSIGNED(L'LENGTH-1 downto 0); 1682 begin 1683 RESULT := UNSIGNED(not(BIT_VECTOR(L))); 1684 return RESULT; 1685 end "not"; 1686 1687 -- Id: L.2 1688 function "and" (L, R: UNSIGNED) return UNSIGNED is 1689 variable RESULT: UNSIGNED(L'LENGTH-1 downto 0); 1690 begin 1691 RESULT := UNSIGNED(BIT_VECTOR(L) and BIT_VECTOR(R)); 1692 return RESULT; 1693 end "and"; 1694 1695 -- Id: L.3 1696 function "or" (L, R: UNSIGNED) return UNSIGNED is 1697 variable RESULT: UNSIGNED(L'LENGTH-1 downto 0); 1698 begin 1699 RESULT := UNSIGNED(BIT_VECTOR(L) or BIT_VECTOR(R)); 1700 return RESULT; 1701 end "or"; 1702 1703 -- Id: L.4 1704 function "nand" (L, R: UNSIGNED) return UNSIGNED is 1705 variable RESULT: UNSIGNED(L'LENGTH-1 downto 0); 1706 begin 1707 RESULT := UNSIGNED(BIT_VECTOR(L) nand BIT_VECTOR(R)); 1708 return RESULT; 1709 end "nand"; 1710 1711 -- Id: L.5 1712 function "nor" (L, R: UNSIGNED) return UNSIGNED is 1713 variable RESULT: UNSIGNED(L'LENGTH-1 downto 0); 1714 begin 1715 RESULT := UNSIGNED(BIT_VECTOR(L) nor BIT_VECTOR(R)); 1716 return RESULT; 1717 end "nor"; 1718 1719 -- Id: L.6 1720 function "xor" (L, R: UNSIGNED) return UNSIGNED is 1721 variable RESULT: UNSIGNED(L'LENGTH-1 downto 0); 1722 begin 1723 RESULT := UNSIGNED(BIT_VECTOR(L) xor BIT_VECTOR(R)); 1724 return RESULT; 1725 end "xor"; 1726 1727--START-!V87 1728 ------------------------------------------------------------------------------ 1729 -- Note : Function L.7 is not compatible with VHDL 1076-1987. Comment 1730 -- out the function (declaration and body) for VHDL 1076-1987 compatibility. 1731 ------------------------------------------------------------------------------ 1732 -- Id: L.7 1733 function "xnor" (L, R: UNSIGNED) return UNSIGNED is 1734 variable RESULT: UNSIGNED(L'LENGTH-1 downto 0); 1735 begin 1736 RESULT := UNSIGNED(BIT_VECTOR(L) xnor BIT_VECTOR(R)); 1737 return RESULT; 1738 end "xnor"; 1739--END-!V87 1740 1741 -- Id: L.8 1742 function "not" (L: SIGNED) return SIGNED is 1743 variable RESULT: SIGNED(L'LENGTH-1 downto 0); 1744 begin 1745 RESULT := SIGNED(not(BIT_VECTOR(L))); 1746 return RESULT; 1747 end "not"; 1748 1749 -- Id: L.9 1750 function "and" (L, R: SIGNED) return SIGNED is 1751 variable RESULT: SIGNED(L'LENGTH-1 downto 0); 1752 begin 1753 RESULT := SIGNED(BIT_VECTOR(L) and BIT_VECTOR(R)); 1754 return RESULT; 1755 end "and"; 1756 1757 -- Id: L.10 1758 function "or" (L, R: SIGNED) return SIGNED is 1759 variable RESULT: SIGNED(L'LENGTH-1 downto 0); 1760 begin 1761 RESULT := SIGNED(BIT_VECTOR(L) or BIT_VECTOR(R)); 1762 return RESULT; 1763 end "or"; 1764 1765 -- Id: L.11 1766 function "nand" (L, R: SIGNED) return SIGNED is 1767 variable RESULT: SIGNED(L'LENGTH-1 downto 0); 1768 begin 1769 RESULT := SIGNED(BIT_VECTOR(L) nand BIT_VECTOR(R)); 1770 return RESULT; 1771 end "nand"; 1772 1773 -- Id: L.12 1774 function "nor" (L, R: SIGNED) return SIGNED is 1775 variable RESULT: SIGNED(L'LENGTH-1 downto 0); 1776 begin 1777 RESULT := SIGNED(BIT_VECTOR(L) nor BIT_VECTOR(R)); 1778 return RESULT; 1779 end "nor"; 1780 1781 -- Id: L.13 1782 function "xor" (L, R: SIGNED) return SIGNED is 1783 variable RESULT: SIGNED(L'LENGTH-1 downto 0); 1784 begin 1785 RESULT := SIGNED(BIT_VECTOR(L) xor BIT_VECTOR(R)); 1786 return RESULT; 1787 end "xor"; 1788 1789--START-!V87 1790 ------------------------------------------------------------------------------ 1791 -- Note : Function L.14 is not compatible with VHDL 1076-1987. Comment 1792 -- out the function (declaration and body) for VHDL 1076-1987 compatibility. 1793 ------------------------------------------------------------------------------ 1794 -- Id: L.14 1795 function "xnor" (L, R: SIGNED) return SIGNED is 1796 variable RESULT: SIGNED(L'LENGTH-1 downto 0); 1797 begin 1798 RESULT := SIGNED(BIT_VECTOR(L) xnor BIT_VECTOR(R)); 1799 return RESULT; 1800 end "xnor"; 1801--END-!V87 1802 1803 --============================================================================ 1804 1805 -- Id: E.1 1806 function RISING_EDGE (signal S: BIT) return BOOLEAN is 1807 begin 1808 return S'EVENT and S = '1'; 1809 end RISING_EDGE; 1810 1811 -- Id: E.2 1812 function FALLING_EDGE (signal S: BIT) return BOOLEAN is 1813 begin 1814 return S'EVENT and S = '0'; 1815 end FALLING_EDGE; 1816 1817 --============================================================================ 1818end NUMERIC_BIT; 1819