From 977ff5e02c6d2f9bfdabcf8b4e98b81e2d83e849 Mon Sep 17 00:00:00 2001 From: gingold Date: Sat, 24 Sep 2005 05:10:24 +0000 Subject: First import from sources --- libraries/ieee/math_complex-body.vhdl | 394 +++++ libraries/ieee/math_complex.vhdl | 126 ++ libraries/ieee/math_real-body.vhdl | 410 +++++ libraries/ieee/math_real.vhdl | 223 +++ libraries/ieee/numeric_bit-body.vhdl | 1818 ++++++++++++++++++++++ libraries/ieee/numeric_bit.vhdl | 813 ++++++++++ libraries/ieee/numeric_std-body.vhdl | 2545 +++++++++++++++++++++++++++++++ libraries/ieee/numeric_std.vhdl | 853 +++++++++++ libraries/ieee/std_logic_1164.vhdl | 175 +++ libraries/ieee/std_logic_1164_body.vhdl | 830 ++++++++++ 10 files changed, 8187 insertions(+) create mode 100644 libraries/ieee/math_complex-body.vhdl create mode 100644 libraries/ieee/math_complex.vhdl create mode 100644 libraries/ieee/math_real-body.vhdl create mode 100644 libraries/ieee/math_real.vhdl create mode 100644 libraries/ieee/numeric_bit-body.vhdl create mode 100644 libraries/ieee/numeric_bit.vhdl create mode 100644 libraries/ieee/numeric_std-body.vhdl create mode 100644 libraries/ieee/numeric_std.vhdl create mode 100644 libraries/ieee/std_logic_1164.vhdl create mode 100644 libraries/ieee/std_logic_1164_body.vhdl (limited to 'libraries/ieee') diff --git a/libraries/ieee/math_complex-body.vhdl b/libraries/ieee/math_complex-body.vhdl new file mode 100644 index 000000000..9b8b75ad4 --- /dev/null +++ b/libraries/ieee/math_complex-body.vhdl @@ -0,0 +1,394 @@ +--------------------------------------------------------------- +-- +-- This source file may be used and distributed without restriction. +-- No declarations or definitions shall be included in this package. +-- This package cannot be sold or distributed for profit. +-- +-- **************************************************************** +-- * * +-- * W A R N I N G * +-- * * +-- * This DRAFT version IS NOT endorsed or approved by IEEE * +-- * * +-- **************************************************************** +-- +-- Title: PACKAGE BODY MATH_COMPLEX +-- +-- Purpose: VHDL declarations for mathematical package MATH_COMPLEX +-- which contains common complex constants and basic complex +-- functions and operations. +-- +-- Author: IEEE VHDL Math Package Study Group +-- +-- Notes: +-- The package body uses package IEEE.MATH_REAL +-- +-- The package body shall be considered the formal definition of +-- the semantics of this package. Tool developers may choose to implement +-- the package body in the most efficient manner available to them. +-- +-- Source code for this package body comes from the following +-- following sources: +-- IEEE VHDL Math Package Study Group participants, +-- U. of Mississippi, Mentor Graphics, Synopsys, +-- Viewlogic/Vantage, Communications of the ACM (June 1988, Vol +-- 31, Number 6, pp. 747, Pierre L'Ecuyer, Efficient and Portable +-- Random Number Generators, Handbook of Mathematical Functions +-- by Milton Abramowitz and Irene A. Stegun (Dover). +-- +-- History: +-- Version 0.1 Jose A. Torres 4/23/93 First draft +-- Version 0.2 Jose A. Torres 5/28/93 Fixed potentially illegal code +-- +------------------------------------------------------------- +Library IEEE; + +Use IEEE.MATH_REAL.all; -- real trascendental operations + +Package body MATH_COMPLEX is + + function CABS(Z: in complex ) return real is + -- returns absolute value (magnitude) of Z + variable ztemp : complex_polar; + begin + ztemp := COMPLEX_TO_POLAR(Z); + return ztemp.mag; + end CABS; + + function CARG(Z: in complex ) return real is + -- returns argument (angle) in radians of a complex number + variable ztemp : complex_polar; + begin + ztemp := COMPLEX_TO_POLAR(Z); + return ztemp.arg; + end CARG; + + function CMPLX(X: in real; Y: in real := 0.0 ) return complex is + -- returns complex number X + iY + begin + return COMPLEX'(X, Y); + end CMPLX; + + function "-" (Z: in complex ) return complex is + -- unary minus; returns -x -jy for z= x + jy + begin + return COMPLEX'(-z.Re, -z.Im); + end "-"; + + function "-" (Z: in complex_polar ) return complex_polar is + -- unary minus; returns (z.mag, z.arg + MATH_PI) + begin + return COMPLEX_POLAR'(z.mag, z.arg + MATH_PI); + end "-"; + + function CONJ (Z: in complex) return complex is + -- returns complex conjugate (x-jy for z = x+ jy) + begin + return COMPLEX'(z.Re, -z.Im); + end CONJ; + + function CONJ (Z: in complex_polar) return complex_polar is + -- returns complex conjugate (z.mag, -z.arg) + begin + return COMPLEX_POLAR'(z.mag, -z.arg); + end CONJ; + + function CSQRT(Z: in complex ) return complex_vector is + -- returns square root of Z; 2 values + variable ztemp : complex_polar; + variable zout : complex_vector (0 to 1); + variable temp : real; + begin + ztemp := COMPLEX_TO_POLAR(Z); + temp := SQRT(ztemp.mag); + zout(0).re := temp*COS(ztemp.arg/2.0); + zout(0).im := temp*SIN(ztemp.arg/2.0); + + zout(1).re := temp*COS(ztemp.arg/2.0 + MATH_PI); + zout(1).im := temp*SIN(ztemp.arg/2.0 + MATH_PI); + + return zout; + end CSQRT; + + function CEXP(Z: in complex ) return complex is + -- returns e**Z + begin + return COMPLEX'(EXP(Z.re)*COS(Z.im), EXP(Z.re)*SIN(Z.im)); + end CEXP; + + function COMPLEX_TO_POLAR(Z: in complex ) return complex_polar is + -- converts complex to complex_polar + begin + return COMPLEX_POLAR'(sqrt(z.re**2 + z.im**2),atan2(z.re,z.im)); + end COMPLEX_TO_POLAR; + + function POLAR_TO_COMPLEX(Z: in complex_polar ) return complex is + -- converts complex_polar to complex + begin + return COMPLEX'( z.mag*cos(z.arg), z.mag*sin(z.arg) ); + end POLAR_TO_COMPLEX; + + + -- + -- arithmetic operators + -- + + function "+" ( L: in complex; R: in complex ) return complex is + begin + return COMPLEX'(L.Re + R.Re, L.Im + R.Im); + end "+"; + + function "+" (L: in complex_polar; R: in complex_polar) return complex is + variable zL, zR : complex; + begin + zL := POLAR_TO_COMPLEX( L ); + zR := POLAR_TO_COMPLEX( R ); + return COMPLEX'(zL.Re + zR.Re, zL.Im + zR.Im); + end "+"; + + function "+" ( L: in complex_polar; R: in complex ) return complex is + variable zL : complex; + begin + zL := POLAR_TO_COMPLEX( L ); + return COMPLEX'(zL.Re + R.Re, zL.Im + R.Im); + end "+"; + + function "+" ( L: in complex; R: in complex_polar) return complex is + variable zR : complex; + begin + zR := POLAR_TO_COMPLEX( R ); + return COMPLEX'(L.Re + zR.Re, L.Im + zR.Im); + end "+"; + + function "+" ( L: in real; R: in complex ) return complex is + begin + return COMPLEX'(L + R.Re, R.Im); + end "+"; + + function "+" ( L: in complex; R: in real ) return complex is + begin + return COMPLEX'(L.Re + R, L.Im); + end "+"; + + function "+" ( L: in real; R: in complex_polar) return complex is + variable zR : complex; + begin + zR := POLAR_TO_COMPLEX( R ); + return COMPLEX'(L + zR.Re, zR.Im); + end "+"; + + function "+" ( L: in complex_polar; R: in real) return complex is + variable zL : complex; + begin + zL := POLAR_TO_COMPLEX( L ); + return COMPLEX'(zL.Re + R, zL.Im); + end "+"; + + function "-" ( L: in complex; R: in complex ) return complex is + begin + return COMPLEX'(L.Re - R.Re, L.Im - R.Im); + end "-"; + + function "-" ( L: in complex_polar; R: in complex_polar) return complex is + variable zL, zR : complex; + begin + zL := POLAR_TO_COMPLEX( L ); + zR := POLAR_TO_COMPLEX( R ); + return COMPLEX'(zL.Re - zR.Re, zL.Im - zR.Im); + end "-"; + + function "-" ( L: in complex_polar; R: in complex ) return complex is + variable zL : complex; + begin + zL := POLAR_TO_COMPLEX( L ); + return COMPLEX'(zL.Re - R.Re, zL.Im - R.Im); + end "-"; + + function "-" ( L: in complex; R: in complex_polar) return complex is + variable zR : complex; + begin + zR := POLAR_TO_COMPLEX( R ); + return COMPLEX'(L.Re - zR.Re, L.Im - zR.Im); + end "-"; + + function "-" ( L: in real; R: in complex ) return complex is + begin + return COMPLEX'(L - R.Re, -1.0 * R.Im); + end "-"; + + function "-" ( L: in complex; R: in real ) return complex is + begin + return COMPLEX'(L.Re - R, L.Im); + end "-"; + + function "-" ( L: in real; R: in complex_polar) return complex is + variable zR : complex; + begin + zR := POLAR_TO_COMPLEX( R ); + return COMPLEX'(L - zR.Re, -1.0*zR.Im); + end "-"; + + function "-" ( L: in complex_polar; R: in real) return complex is + variable zL : complex; + begin + zL := POLAR_TO_COMPLEX( L ); + return COMPLEX'(zL.Re - R, zL.Im); + end "-"; + + function "*" ( L: in complex; R: in complex ) return complex is + begin + return COMPLEX'(L.Re * R.Re - L.Im * R.Im, L.Re * R.Im + L.Im * R.Re); + end "*"; + + function "*" ( L: in complex_polar; R: in complex_polar) return complex is + variable zout : complex_polar; + begin + zout.mag := L.mag * R.mag; + zout.arg := L.arg + R.arg; + return POLAR_TO_COMPLEX(zout); + end "*"; + + function "*" ( L: in complex_polar; R: in complex ) return complex is + variable zL : complex; + begin + zL := POLAR_TO_COMPLEX( L ); + return COMPLEX'(zL.Re*R.Re - zL.Im * R.Im, zL.Re * R.Im + zL.Im*R.Re); + end "*"; + + function "*" ( L: in complex; R: in complex_polar) return complex is + variable zR : complex; + begin + zR := POLAR_TO_COMPLEX( R ); + return COMPLEX'(L.Re*zR.Re - L.Im * zR.Im, L.Re * zR.Im + L.Im*zR.Re); + end "*"; + + function "*" ( L: in real; R: in complex ) return complex is + begin + return COMPLEX'(L * R.Re, L * R.Im); + end "*"; + + function "*" ( L: in complex; R: in real ) return complex is + begin + return COMPLEX'(L.Re * R, L.Im * R); + end "*"; + + function "*" ( L: in real; R: in complex_polar) return complex is + variable zR : complex; + begin + zR := POLAR_TO_COMPLEX( R ); + return COMPLEX'(L * zR.Re, L * zR.Im); + end "*"; + + function "*" ( L: in complex_polar; R: in real) return complex is + variable zL : complex; + begin + zL := POLAR_TO_COMPLEX( L ); + return COMPLEX'(zL.Re * R, zL.Im * R); + end "*"; + + function "/" ( L: in complex; R: in complex ) return complex is + variable magrsq : REAL := R.Re ** 2 + R.Im ** 2; + begin + if (magrsq = 0.0) then + assert FALSE report "Attempt to divide by (0,0)" + severity ERROR; + return COMPLEX'(REAL'RIGHT, REAL'RIGHT); + else + return COMPLEX'( (L.Re * R.Re + L.Im * R.Im) / magrsq, + (L.Im * R.Re - L.Re * R.Im) / magrsq); + end if; + end "/"; + + function "/" ( L: in complex_polar; R: in complex_polar) return complex is + variable zout : complex_polar; + begin + if (R.mag = 0.0) then + assert FALSE report "Attempt to divide by (0,0)" + severity ERROR; + return COMPLEX'(REAL'RIGHT, REAL'RIGHT); + else + zout.mag := L.mag/R.mag; + zout.arg := L.arg - R.arg; + return POLAR_TO_COMPLEX(zout); + end if; + end "/"; + + function "/" ( L: in complex_polar; R: in complex ) return complex is + variable zL : complex; + variable temp : REAL := R.Re ** 2 + R.Im ** 2; + begin + if (temp = 0.0) then + assert FALSE report "Attempt to divide by (0.0,0.0)" + severity ERROR; + return COMPLEX'(REAL'RIGHT, REAL'RIGHT); + else + zL := POLAR_TO_COMPLEX( L ); + return COMPLEX'( (zL.Re * R.Re + zL.Im * R.Im) / temp, + (zL.Im * R.Re - zL.Re * R.Im) / temp); + end if; + end "/"; + + function "/" ( L: in complex; R: in complex_polar) return complex is + variable zR : complex := POLAR_TO_COMPLEX( R ); + variable temp : REAL := zR.Re ** 2 + zR.Im ** 2; + begin + if (R.mag = 0.0) or (temp = 0.0) then + assert FALSE report "Attempt to divide by (0.0,0.0)" + severity ERROR; + return COMPLEX'(REAL'RIGHT, REAL'RIGHT); + else + return COMPLEX'( (L.Re * zR.Re + L.Im * zR.Im) / temp, + (L.Im * zR.Re - L.Re * zR.Im) / temp); + end if; + end "/"; + + function "/" ( L: in real; R: in complex ) return complex is + variable temp : REAL := R.Re ** 2 + R.Im ** 2; + begin + if (temp = 0.0) then + assert FALSE report "Attempt to divide by (0.0,0.0)" + severity ERROR; + return COMPLEX'(REAL'RIGHT, REAL'RIGHT); + else + temp := L / temp; + return COMPLEX'( temp * R.Re, -temp * R.Im ); + end if; + end "/"; + + function "/" ( L: in complex; R: in real ) return complex is + begin + if (R = 0.0) then + assert FALSE report "Attempt to divide by (0.0,0.0)" + severity ERROR; + return COMPLEX'(REAL'RIGHT, REAL'RIGHT); + else + return COMPLEX'(L.Re / R, L.Im / R); + end if; + end "/"; + + function "/" ( L: in real; R: in complex_polar) return complex is + variable zR : complex := POLAR_TO_COMPLEX( R ); + variable temp : REAL := zR.Re ** 2 + zR.Im ** 2; + begin + if (R.mag = 0.0) or (temp = 0.0) then + assert FALSE report "Attempt to divide by (0.0,0.0)" + severity ERROR; + return COMPLEX'(REAL'RIGHT, REAL'RIGHT); + else + temp := L / temp; + return COMPLEX'( temp * zR.Re, -temp * zR.Im ); + end if; + end "/"; + + function "/" ( L: in complex_polar; R: in real) return complex is + variable zL : complex := POLAR_TO_COMPLEX( L ); + begin + if (R = 0.0) then + assert FALSE report "Attempt to divide by (0.0,0.0)" + severity ERROR; + return COMPLEX'(REAL'RIGHT, REAL'RIGHT); + else + return COMPLEX'(zL.Re / R, zL.Im / R); + end if; + end "/"; +end MATH_COMPLEX; diff --git a/libraries/ieee/math_complex.vhdl b/libraries/ieee/math_complex.vhdl new file mode 100644 index 000000000..2f9376bfb --- /dev/null +++ b/libraries/ieee/math_complex.vhdl @@ -0,0 +1,126 @@ +--------------------------------------------------------------- +-- +-- This source file may be used and distributed without restriction. +-- No declarations or definitions shall be included in this package. +-- This package cannot be sold or distributed for profit. +-- +-- **************************************************************** +-- * * +-- * W A R N I N G * +-- * * +-- * This DRAFT version IS NOT endorsed or approved by IEEE * +-- * * +-- **************************************************************** +-- +-- Title: PACKAGE MATH_COMPLEX +-- +-- Purpose: VHDL declarations for mathematical package MATH_COMPLEX +-- which contains common complex constants and basic complex +-- functions and operations. +-- +-- Author: IEEE VHDL Math Package Study Group +-- +-- Notes: +-- The package body uses package IEEE.MATH_REAL +-- +-- The package body shall be considered the formal definition of +-- the semantics of this package. Tool developers may choose to implement +-- the package body in the most efficient manner available to them. +-- +-- History: +-- Version 0.1 (Strawman) Jose A. Torres 6/22/92 +-- Version 0.2 Jose A. Torres 1/15/93 +-- Version 0.3 Jose A. Torres 4/13/93 +-- Version 0.4 Jose A. Torres 4/19/93 +-- Version 0.5 Jose A. Torres 4/20/93 +-- Version 0.6 Jose A. Torres 4/23/93 Added unary minus +-- and CONJ for polar +-- Version 0.7 Jose A. Torres 5/28/93 Rev up for compatibility +-- with package body. +------------------------------------------------------------- +Library IEEE; + +Package MATH_COMPLEX is + + + type COMPLEX is record RE, IM: real; end record; + type COMPLEX_VECTOR is array (integer range <>) of COMPLEX; + type COMPLEX_POLAR is record MAG: real; ARG: real; end record; + + constant CBASE_1: complex := COMPLEX'(1.0, 0.0); + constant CBASE_j: complex := COMPLEX'(0.0, 1.0); + constant CZERO: complex := COMPLEX'(0.0, 0.0); + + function CABS(Z: in complex ) return real; + -- returns absolute value (magnitude) of Z + + function CARG(Z: in complex ) return real; + -- returns argument (angle) in radians of a complex number + + function CMPLX(X: in real; Y: in real:= 0.0 ) return complex; + -- returns complex number X + iY + + function "-" (Z: in complex ) return complex; + -- unary minus + + function "-" (Z: in complex_polar ) return complex_polar; + -- unary minus + + function CONJ (Z: in complex) return complex; + -- returns complex conjugate + + function CONJ (Z: in complex_polar) return complex_polar; + -- returns complex conjugate + + function CSQRT(Z: in complex ) return complex_vector; + -- returns square root of Z; 2 values + + function CEXP(Z: in complex ) return complex; + -- returns e**Z + + function COMPLEX_TO_POLAR(Z: in complex ) return complex_polar; + -- converts complex to complex_polar + + function POLAR_TO_COMPLEX(Z: in complex_polar ) return complex; + -- converts complex_polar to complex + + + -- arithmetic operators + + function "+" ( L: in complex; R: in complex ) return complex; + function "+" ( L: in complex_polar; R: in complex_polar) return complex; + function "+" ( L: in complex_polar; R: in complex ) return complex; + function "+" ( L: in complex; R: in complex_polar) return complex; + function "+" ( L: in real; R: in complex ) return complex; + function "+" ( L: in complex; R: in real ) return complex; + function "+" ( L: in real; R: in complex_polar) return complex; + function "+" ( L: in complex_polar; R: in real) return complex; + + function "-" ( L: in complex; R: in complex ) return complex; + function "-" ( L: in complex_polar; R: in complex_polar) return complex; + function "-" ( L: in complex_polar; R: in complex ) return complex; + function "-" ( L: in complex; R: in complex_polar) return complex; + function "-" ( L: in real; R: in complex ) return complex; + function "-" ( L: in complex; R: in real ) return complex; + function "-" ( L: in real; R: in complex_polar) return complex; + function "-" ( L: in complex_polar; R: in real) return complex; + + function "*" ( L: in complex; R: in complex ) return complex; + function "*" ( L: in complex_polar; R: in complex_polar) return complex; + function "*" ( L: in complex_polar; R: in complex ) return complex; + function "*" ( L: in complex; R: in complex_polar) return complex; + function "*" ( L: in real; R: in complex ) return complex; + function "*" ( L: in complex; R: in real ) return complex; + function "*" ( L: in real; R: in complex_polar) return complex; + function "*" ( L: in complex_polar; R: in real) return complex; + + + function "/" ( L: in complex; R: in complex ) return complex; + function "/" ( L: in complex_polar; R: in complex_polar) return complex; + function "/" ( L: in complex_polar; R: in complex ) return complex; + function "/" ( L: in complex; R: in complex_polar) return complex; + function "/" ( L: in real; R: in complex ) return complex; + function "/" ( L: in complex; R: in real ) return complex; + function "/" ( L: in real; R: in complex_polar) return complex; + function "/" ( L: in complex_polar; R: in real) return complex; +end MATH_COMPLEX; diff --git a/libraries/ieee/math_real-body.vhdl b/libraries/ieee/math_real-body.vhdl new file mode 100644 index 000000000..1473f6787 --- /dev/null +++ b/libraries/ieee/math_real-body.vhdl @@ -0,0 +1,410 @@ +--------------------------------------------------------------- +-- +-- This source file may be used and distributed without restriction. +-- No declarations or definitions shall be added to this package. +-- This package cannot be sold or distributed for profit. +-- +-- **************************************************************** +-- * * +-- * W A R N I N G * +-- * * +-- * This DRAFT version IS NOT endorsed or approved by IEEE * +-- * * +-- **************************************************************** +-- +-- Title: PACKAGE BODY MATH_REAL +-- +-- Library: This package shall be compiled into a library +-- symbolically named IEEE. +-- +-- Purpose: VHDL declarations for mathematical package MATH_REAL +-- which contains common real constants, common real +-- functions, and real trascendental functions. +-- +-- Author: IEEE VHDL Math Package Study Group +-- +-- Notes: +-- The package body shall be considered the formal definition of +-- the semantics of this package. Tool developers may choose to implement +-- the package body in the most efficient manner available to them. +-- +-- Source code and algorithms for this package body comes from the +-- following sources: +-- IEEE VHDL Math Package Study Group participants, +-- U. of Mississippi, Mentor Graphics, Synopsys, +-- Viewlogic/Vantage, Communications of the ACM (June 1988, Vol +-- 31, Number 6, pp. 747, Pierre L'Ecuyer, Efficient and Portable +-- Random Number Generators), Handbook of Mathematical Functions +-- by Milton Abramowitz and Irene A. Stegun (Dover). +-- +-- History: +-- Version 0.1 Jose A. Torres 4/23/93 First draft +-- Version 0.2 Jose A. Torres 5/28/93 Fixed potentially illegal code +-- +-- GHDL history +-- 2005-04-07 Initial version. +------------------------------------------------------------- +Library IEEE; + +Package body MATH_REAL is + -- + -- non-trascendental functions + -- + function SIGN (X: real ) return real is + -- returns 1.0 if X > 0.0; 0.0 if X == 0.0; -1.0 if X < 0.0 + begin + assert false severity failure; + end SIGN; + + function CEIL (X : real ) return real is + begin + assert false severity failure; + end CEIL; + + function FLOOR (X : real ) return real is + begin + assert false severity failure; + end FLOOR; + + function ROUND (X : real ) return real is + begin + assert false severity failure; + end ROUND; + + function FMAX (X, Y : real ) return real is + begin + assert false severity failure; + end FMAX; + + function FMIN (X, Y : real ) return real is + begin + assert false severity failure; + end FMIN; + + -- + -- Pseudo-random number generators + -- + + procedure UNIFORM(variable Seed1,Seed2:inout integer;variable X:out real) is + -- returns a pseudo-random number with uniform distribution in the + -- interval (0.0, 1.0). + -- Before the first call to UNIFORM, the seed values (Seed1, Seed2) must + -- be initialized to values in the range [1, 2147483562] and + -- [1, 2147483398] respectively. The seed values are modified after + -- each call to UNIFORM. + -- This random number generator is portable for 32-bit computers, and + -- it has period ~2.30584*(10**18) for each set of seed values. + -- + -- For VHDL-1992, the seeds will be global variables, functions to + -- initialize their values (INIT_SEED) will be provided, and the UNIFORM + -- procedure call will be modified accordingly. + + variable z, k: integer; + begin + k := Seed1/53668; + Seed1 := 40014 * (Seed1 - k * 53668) - k * 12211; + + if Seed1 < 0 then + Seed1 := Seed1 + 2147483563; + end if; + + + k := Seed2/52774; + Seed2 := 40692 * (Seed2 - k * 52774) - k * 3791; + + if Seed2 < 0 then + Seed2 := Seed2 + 2147483399; + end if; + + z := Seed1 - Seed2; + if z < 1 then + z := z + 2147483562; + end if; + + X := REAL(Z)*4.656613e-10; + end UNIFORM; + + + function SRAND (seed: in integer ) return integer is + begin + assert false severity failure; + end SRAND; + + function RAND return integer is + begin + assert false severity failure; + end RAND; + + function GET_RAND_MAX return integer is + -- The value this function returns should be the same as + -- RAND_MAX in /usr/include/stdlib.h + begin + assert false + report "Be sure to update GET_RAND_MAX in mathpack.vhd" + severity note; + return 2147483647; -- i386 linux + end GET_RAND_MAX; + + -- + -- trascendental and trigonometric functions + -- + function c_sqrt (x : real ) return real; + attribute foreign of c_sqrt : function is "VHPIDIRECT sqrt"; + + function c_sqrt (x : real ) return real is + begin + assert false severity failure; + end c_sqrt; + + function SQRT (X : real ) return real is + begin + -- check validity of argument + if ( X < 0.0 ) then + assert false report "X < 0 in SQRT(X)" + severity ERROR; + return (0.0); + end if; + return c_sqrt(X); + end SQRT; + + function CBRT (X : real ) return real is + begin + assert false severity failure; + end CBRT; + + function "**" (X : integer; Y : real) return real is + -- returns Y power of X ==> X**Y; + -- error if X = 0 and Y <= 0.0 + -- error if X < 0 and Y does not have an integer value + begin + -- check validity of argument + if ( X = 0 ) and ( Y <= 0.0 ) then + assert false report "X = 0 and Y <= 0.0 in X**Y" + severity ERROR; + return (0.0); + end if; + + if ( X < 0 ) and ( Y /= REAL(INTEGER(Y)) ) then + assert false + report "X < 0 and Y \= integer in X**Y" + severity ERROR; + return (0.0); + end if; + + -- compute the result + return EXP (Y * LOG (REAL(X))); + end "**"; + + function "**" (X : real; Y : real) return real is + -- returns Y power of X ==> X**Y; + -- error if X = 0.0 and Y <= 0.0 + -- error if X < 0.0 and Y does not have an integer value + begin + -- check validity of argument + if ( X = 0.0 ) and ( Y <= 0.0 ) then + assert false report "X = 0.0 and Y <= 0.0 in X**Y" + severity ERROR; + return (0.0); + end if; + + if ( X < 0.0 ) and ( Y /= REAL(INTEGER(Y)) ) then + assert false report "X < 0.0 and Y \= integer in X**Y" + severity ERROR; + return (0.0); + end if; + + -- compute the result + return EXP (Y * LOG (X)); + end "**"; + + function EXP (X : real ) return real is + begin + assert false severity failure; + end EXP; + + function c_log (x : real ) return real; + attribute foreign of c_log : function is "VHPIDIRECT log"; + + function c_log (x : real ) return real is + begin + assert false severity failure; + end c_log; + + function LOG (X : real ) return real is + -- returns natural logarithm of X; X > 0 + -- + -- This function computes the exponential using the following series: + -- log(x) = 2[ (x-1)/(x+1) + (((x-1)/(x+1))**3)/3.0 + ...] ; x > 0 + -- + begin + -- check validity of argument + if ( x <= 0.0 ) then + assert false report "X <= 0 in LOG(X)" + severity ERROR; + return(REAL'LOW); + end if; + return c_log(x); + end LOG; + + function LOG (BASE: positive; X : real) return real is + -- returns logarithm base BASE of X; X > 0 + begin + -- check validity of argument + if ( BASE <= 0 ) or ( x <= 0.0 ) then + assert false report "BASE <= 0 or X <= 0.0 in LOG(BASE, X)" + severity ERROR; + return(REAL'LOW); + end if; + -- compute the value + return (LOG(X)/LOG(REAL(BASE))); + end LOG; + + function SIN (X : real ) return real is + begin + assert false severity failure; + end SIN; + + + function COS (x : REAL) return REAL is + begin + assert false severity failure; + end COS; + + function TAN (x : REAL) return REAL is + begin + assert false severity failure; + end TAN; + + function c_asin (x : real ) return real; + attribute foreign of c_asin : function is "VHPIDIRECT asin"; + + function c_asin (x : real ) return real is + begin + assert false severity failure; + end c_asin; + + function ASIN (x : real ) return real is + -- returns -PI/2 < asin X < PI/2; | X | <= 1 + begin + if abs x > 1.0 then + assert false + report "Out of range parameter passed to ASIN" + severity ERROR; + return x; + else + return c_asin(x); + end if; + end ASIN; + + function c_acos (x : real ) return real; + attribute foreign of c_acos : function is "VHPIDIRECT acos"; + + function c_acos (x : real ) return real is + begin + assert false severity failure; + end c_acos; + + function ACOS (x : REAL) return REAL is + -- returns 0 < acos X < PI; | X | <= 1 + begin + if abs x > 1.0 then + assert false + report "Out of range parameter passed to ACOS" + severity ERROR; + return x; + else + return c_acos(x); + end if; + end ACOS; + + function ATAN (x : REAL) return REAL is + -- returns -PI/2 < atan X < PI/2 + begin + assert false severity failure; + end ATAN; + + function c_atan2 (x : real; y : real) return real; + attribute foreign of c_atan2 : function is "VHPIDIRECT atan2"; + + function c_atan2 (x : real; y: real) return real is + begin + assert false severity failure; + end c_atan2; + + function ATAN2 (x : REAL; y : REAL) return REAL is + -- returns atan (X/Y); -PI < atan2(X,Y) < PI; Y /= 0.0 + begin + if y = 0.0 and x = 0.0 then + assert false + report "atan2(0.0, 0.0) is undetermined, returned 0,0" + severity NOTE; + return 0.0; + else + return c_atan2(x,y); + end if; + end ATAN2; + + + function SINH (X : real) return real is + -- hyperbolic sine; returns (e**X - e**(-X))/2 + begin + assert false severity failure; + end SINH; + + function COSH (X : real) return real is + -- hyperbolic cosine; returns (e**X + e**(-X))/2 + begin + assert false severity failure; + end COSH; + + function TANH (X : real) return real is + -- hyperbolic tangent; -- returns (e**X - e**(-X))/(e**X + e**(-X)) + begin + assert false severity failure; + end TANH; + + function ASINH (X : real) return real is + -- returns ln( X + sqrt( X**2 + 1)) + begin + assert false severity failure; + end ASINH; + + function c_acosh (x : real ) return real; + attribute foreign of c_acosh : function is "VHPIDIRECT acosh"; + + function c_acosh (x : real ) return real is + begin + assert false severity failure; + end c_acosh; + + function ACOSH (X : real) return real is + -- returns ln( X + sqrt( X**2 - 1)); X >= 1 + begin + if abs x >= 1.0 then + assert false report "Out of range parameter passed to ACOSH" + severity ERROR; + return x; + end if; + return c_acosh(x); + end ACOSH; + + function c_atanh (x : real ) return real; + attribute foreign of c_atanh : function is "VHPIDIRECT atanh"; + + function c_atanh (x : real ) return real is + begin + assert false severity failure; + end c_atanh; + + function ATANH (X : real) return real is + -- returns (ln( (1 + X)/(1 - X)))/2 ; | X | < 1 + begin + if abs x < 1.0 then + assert false report "Out of range parameter passed to ATANH" + severity ERROR; + return x; + end if; + return c_atanh(x); + end ATANH; + +end MATH_REAL; diff --git a/libraries/ieee/math_real.vhdl b/libraries/ieee/math_real.vhdl new file mode 100644 index 000000000..c70d2160b --- /dev/null +++ b/libraries/ieee/math_real.vhdl @@ -0,0 +1,223 @@ +------------------------------------------------------------------------ +-- +-- This source file may be used and distributed without restriction. +-- No declarations or definitions shall be added to this package. +-- This package cannot be sold or distributed for profit. +-- +-- **************************************************************** +-- * * +-- * W A R N I N G * +-- * * +-- * This DRAFT version IS NOT endorsed or approved by IEEE * +-- * * +-- **************************************************************** +-- +-- Title: PACKAGE MATH_REAL +-- +-- Library: This package shall be compiled into a library +-- symbolically named IEEE. +-- +-- Purpose: VHDL declarations for mathematical package MATH_REAL +-- which contains common real constants, common real +-- functions, and real trascendental functions. +-- +-- Author: IEEE VHDL Math Package Study Group +-- +-- Notes: +-- The package body shall be considered the formal definition of +-- the semantics of this package. Tool developers may choose to implement +-- the package body in the most efficient manner available to them. +-- +-- History: +-- Version 0.1 (Strawman) Jose A. Torres 6/22/92 +-- Version 0.2 Jose A. Torres 1/15/93 +-- Version 0.3 Jose A. Torres 4/13/93 +-- Version 0.4 Jose A. Torres 4/19/93 +-- Version 0.5 Jose A. Torres 4/20/93 Added RANDOM() +-- Version 0.6 Jose A. Torres 4/23/93 Renamed RANDOM as +-- UNIFORM. Modified +-- rights banner. +-- Version 0.7 Jose A. Torres 5/28/93 Rev up for compatibility +-- with package body. +-- +-- GHDL history +-- 2005-04-07 Initial version. +-- 2005-09-01 Some PI constants added. +------------------------------------------------------------- +Library IEEE; + +Package MATH_REAL is + + -- + -- commonly used constants + -- + constant MATH_E : real := 2.71828_18284_59045_23536; -- e + constant MATH_1_OVER_E : real := 0.36787_94411_71442_32160; -- 1/e + constant MATH_PI : real := 3.14159_26535_89793_23846; -- pi + constant MATH_2_PI : real := 2.0 * MATH_PI; -- 2 * pi + constant MATH_1_OVER_PI : real := 0.31830_98861_83790_67154; -- 1/pi + constant MATH_PI_OVER_2 : real := 1.57079_63267_94896_61923; -- pi / 2 + constant MATH_PI_OVER_4 : real := 0.78539_81633_97448_30962; -- pi / 4 + constant MATH_LOG_OF_2 : real := 0.69314_71805_59945_30942; + -- natural log of 2 + constant MATH_LOG_OF_10: real := 2.30258_50929_94045_68402; + -- natural log of10 + constant MATH_LOG2_OF_E: real := 1.44269_50408_88963_4074; + -- log base 2 of e + constant MATH_LOG10_OF_E: real := 0.43429_44819_03251_82765; + -- log base 10 of e + constant MATH_SQRT2: real := 1.41421_35623_73095_04880; + -- sqrt of 2 + constant MATH_SQRT1_2: real := 0.70710_67811_86547_52440; + -- sqrt of 1/2 + constant MATH_SQRT_PI: real := 1.77245_38509_05516_02730; + -- sqrt of pi + constant MATH_DEG_TO_RAD: real := 0.01745_32925_19943_29577; + -- conversion factor from degree to radian + constant MATH_RAD_TO_DEG: real := 57.29577_95130_82320_87685; + -- conversion factor from radian to degree + + -- + -- function declarations + -- + function SIGN (X: real ) return real; + -- returns 1.0 if X > 0.0; 0.0 if X == 0.0; -1.0 if X < 0.0 + + function CEIL (X : real ) return real; + attribute foreign of ceil : function is "VHPIDIRECT ceil"; + -- returns smallest integer value (as real) not less than X + + function FLOOR (X : real ) return real; + attribute foreign of floor : function is "VHPIDIRECT floor"; + -- returns largest integer value (as real) not greater than X + + function ROUND (X : real ) return real; + attribute foreign of round : function is "VHPIDIRECT round"; + -- returns integer FLOOR(X + 0.5) if X > 0; + -- return integer CEIL(X - 0.5) if X < 0 + + function FMAX (X, Y : real ) return real; + attribute foreign of fmax : function is "VHPIDIRECT fmax"; + -- returns the algebraically larger of X and Y + + function FMIN (X, Y : real ) return real; + attribute foreign of fmin : function is "VHPIDIRECT fmin"; + -- returns the algebraically smaller of X and Y + + procedure UNIFORM (variable Seed1,Seed2:inout integer; variable X:out real); + -- returns a pseudo-random number with uniform distribution in the + -- interval (0.0, 1.0). + -- Before the first call to UNIFORM, the seed values (Seed1, Seed2) must + -- be initialized to values in the range [1, 2147483562] and + -- [1, 2147483398] respectively. The seed values are modified after + -- each call to UNIFORM. + -- This random number generator is portable for 32-bit computers, and + -- it has period ~2.30584*(10**18) for each set of seed values. + -- + -- For VHDL-1992, the seeds will be global variables, functions to + -- initialize their values (INIT_SEED) will be provided, and the UNIFORM + -- procedure call will be modified accordingly. + + function SRAND (seed: in integer ) return integer; + attribute foreign of srand : function is "VHPIDIRECT srand"; + -- + -- sets value of seed for sequence of + -- pseudo-random numbers. + -- It uses the foreign native C function srand(). + + function RAND return integer; + attribute foreign of rand : function is "VHPIDIRECT rand"; + -- + -- returns an integer pseudo-random number with uniform distribution. + -- It uses the foreign native C function rand(). + -- Seed for the sequence is initialized with the + -- SRAND() function and value of the seed is changed every + -- time SRAND() is called, but it is not visible. + -- The range of generated values is platform dependent. + + function GET_RAND_MAX return integer; + -- + -- returns the upper bound of the range of the + -- pseudo-random numbers generated by RAND(). + -- The support for this function is platform dependent, and + -- it uses foreign native C functions or constants. + -- It may not be available in some platforms. + -- Note: the value of (RAND() / GET_RAND_MAX()) is a + -- pseudo-random number distributed between 0 & 1. + + function SQRT (X : real ) return real; + -- returns square root of X; X >= 0 + + function CBRT (X : real ) return real; + attribute foreign of cbrt : function is "VHPIDIRECT cbrt"; + -- returns cube root of X + + function "**" (X : integer; Y : real) return real; + -- returns Y power of X ==> X**Y; + -- error if X = 0 and Y <= 0.0 + -- error if X < 0 and Y does not have an integer value + + function "**" (X : real; Y : real) return real; + -- returns Y power of X ==> X**Y; + -- error if X = 0.0 and Y <= 0.0 + -- error if X < 0.0 and Y does not have an integer value + + function EXP (X : real ) return real; + attribute foreign of exp : function is "VHPIDIRECT exp"; + -- returns e**X; where e = MATH_E + + function LOG (X : real ) return real; + -- returns natural logarithm of X; X > 0 + + function LOG (BASE: positive; X : real) return real; + -- returns logarithm base BASE of X; X > 0 + + function SIN (X : real ) return real; + attribute foreign of sin : function is "VHPIDIRECT sin"; + -- returns sin X; X in radians + + function COS ( X : real ) return real; + attribute foreign of cos : function is "VHPIDIRECT cos"; + -- returns cos X; X in radians + + function TAN (X : real ) return real; + attribute foreign of tan : function is "VHPIDIRECT tan"; + -- returns tan X; X in radians + -- X /= ((2k+1) * PI/2), where k is an integer + + function ASIN (X : real ) return real; + -- returns -PI/2 < asin X < PI/2; | X | <= 1 + + function ACOS (X : real ) return real; + -- returns 0 < acos X < PI; | X | <= 1 + + function ATAN (X : real) return real; + attribute foreign of atan : function is "VHPIDIRECT atan"; + -- returns -PI/2 < atan X < PI/2 + + function ATAN2 (X : real; Y : real) return real; + -- returns atan (X/Y); -PI < atan2(X,Y) < PI; Y /= 0.0 + + function SINH (X : real) return real; + attribute foreign of sinh : function is "VHPIDIRECT sinh"; + -- hyperbolic sine; returns (e**X - e**(-X))/2 + + function COSH (X : real) return real; + attribute foreign of cosh : function is "VHPIDIRECT cosh"; + -- hyperbolic cosine; returns (e**X + e**(-X))/2 + + function TANH (X : real) return real; + attribute foreign of tanh : function is "VHPIDIRECT tanh"; + -- hyperbolic tangent; -- returns (e**X - e**(-X))/(e**X + e**(-X)) + + function ASINH (X : real) return real; + attribute foreign of asinh : function is "VHPIDIRECT asinh"; + -- returns ln( X + sqrt( X**2 + 1)) + + function ACOSH (X : real) return real; + -- returns ln( X + sqrt( X**2 - 1)); X >= 1 + + function ATANH (X : real) return real; + -- returns (ln( (1 + X)/(1 - X)))/2 ; | X | < 1 + +end MATH_REAL; diff --git a/libraries/ieee/numeric_bit-body.vhdl b/libraries/ieee/numeric_bit-body.vhdl new file mode 100644 index 000000000..895594631 --- /dev/null +++ b/libraries/ieee/numeric_bit-body.vhdl @@ -0,0 +1,1818 @@ +-- ----------------------------------------------------------------------------- +-- +-- Copyright 1995 by IEEE. All rights reserved. +-- +-- This source file is considered by the IEEE to be an essential part of the use +-- of the standard 1076.3 and as such may be distributed without change, except +-- as permitted by the standard. This source file may not be sold or distributed +-- for profit. This package may be modified to include additional data required +-- by tools, but must in no way change the external interfaces or simulation +-- behaviour of the description. It is permissible to add comments and/or +-- attributes to the package declarations, but not to change or delete any +-- original lines of the approved package declaration. The package body may be +-- changed only in accordance with the terms of clauses 7.1 and 7.2 of the +-- standard. +-- +-- Title : Standard VHDL Synthesis Package (1076.3, NUMERIC_BIT) +-- +-- Library : This package shall be compiled into a library symbolically +-- : named IEEE. +-- +-- Developers : IEEE DASC Synthesis Working Group, PAR 1076.3 +-- +-- Purpose : This package defines numeric types and arithmetic functions +-- : for use with synthesis tools. Two numeric types are defined: +-- : -- > UNSIGNED: represents an UNSIGNED number in vector form +-- : -- > SIGNED: represents a SIGNED number in vector form +-- : The base element type is type BIT. +-- : The leftmost bit is treated as the most significant bit. +-- : Signed vectors are represented in two's complement form. +-- : This package contains overloaded arithmetic operators on +-- : the SIGNED and UNSIGNED types. The package also contains +-- : useful type conversions functions, clock detection +-- : functions, and other utility functions. +-- : +-- : If any argument to a function is a null array, a null array is +-- : returned (exceptions, if any, are noted individually). +-- +-- Limitation : +-- +-- Note : No declarations or definitions shall be included in, +-- : or excluded from this package. The "package declaration" +-- : defines the types, subtypes and declarations of +-- : NUMERIC_BIT. The NUMERIC_BIT package body shall be +-- : considered the formal definition of the semantics of +-- : this package. Tool developers may choose to implement +-- : the package body in the most efficient manner available +-- : to them. +-- : +-- ----------------------------------------------------------------------------- +-- Version : 2.4 +-- Date : 12 April 1995 +-- ----------------------------------------------------------------------------- + +--============================================================================== +--======================= Package Body ========================================= +--============================================================================== + +package body NUMERIC_BIT is + + -- null range array constants + + constant NAU: UNSIGNED(0 downto 1) := (others => '0'); + constant NAS: SIGNED(0 downto 1) := (others => '0'); + + -- implementation controls + + constant NO_WARNING: BOOLEAN := FALSE; -- default to emit warnings + + --=========================Local Subprograms ================================= + + function MAX (LEFT, RIGHT: INTEGER) return INTEGER is + begin + if LEFT > RIGHT then return LEFT; + else return RIGHT; + end if; + end MAX; + + function MIN (LEFT, RIGHT: INTEGER) return INTEGER is + begin + if LEFT < RIGHT then return LEFT; + else return RIGHT; + end if; + end MIN; + + function SIGNED_NUM_BITS (ARG: INTEGER) return NATURAL is + variable NBITS: NATURAL; + variable N: NATURAL; + begin + if ARG >= 0 then + N := ARG; + else + N := -(ARG+1); + end if; + NBITS := 1; + while N > 0 loop + NBITS := NBITS+1; + N := N / 2; + end loop; + return NBITS; + end SIGNED_NUM_BITS; + + function UNSIGNED_NUM_BITS (ARG: NATURAL) return NATURAL is + variable NBITS: NATURAL; + variable N: NATURAL; + begin + N := ARG; + NBITS := 1; + while N > 1 loop + NBITS := NBITS+1; + N := N / 2; + end loop; + return NBITS; + end UNSIGNED_NUM_BITS; + + ------------------------------------------------------------------------------ + -- this internal function computes the addition of two UNSIGNED + -- with input carry + -- * the two arguments are of the same length + + function ADD_UNSIGNED (L, R: UNSIGNED; C: BIT) return UNSIGNED is + constant L_LEFT: INTEGER := L'LENGTH-1; + alias XL: UNSIGNED(L_LEFT downto 0) is L; + alias XR: UNSIGNED(L_LEFT downto 0) is R; + variable RESULT: UNSIGNED(L_LEFT downto 0); + variable CBIT: BIT := C; + begin + for I in 0 to L_LEFT loop + RESULT(I) := CBIT xor XL(I) xor XR(I); + CBIT := (CBIT and XL(I)) or (CBIT and XR(I)) or (XL(I) and XR(I)); + end loop; + return RESULT; + end ADD_UNSIGNED; + + -- this internal function computes the addition of two SIGNED + -- with input carry + -- * the two arguments are of the same length + + function ADD_SIGNED (L, R: SIGNED; C: BIT) return SIGNED is + constant L_LEFT: INTEGER := L'LENGTH-1; + alias XL: SIGNED(L_LEFT downto 0) is L; + alias XR: SIGNED(L_LEFT downto 0) is R; + variable RESULT: SIGNED(L_LEFT downto 0); + variable CBIT: BIT := C; + begin + for I in 0 to L_LEFT loop + RESULT(I) := CBIT xor XL(I) xor XR(I); + CBIT := (CBIT and XL(I)) or (CBIT and XR(I)) or (XL(I) and XR(I)); + end loop; + return RESULT; + end ADD_SIGNED; + + ------------------------------------------------------------------------------ + + -- this internal procedure computes UNSIGNED division + -- giving the quotient and remainder. + procedure DIVMOD (NUM, XDENOM: UNSIGNED; XQUOT, XREMAIN: out UNSIGNED) is + variable TEMP: UNSIGNED(NUM'LENGTH downto 0); + variable QUOT: UNSIGNED(MAX(NUM'LENGTH, XDENOM'LENGTH)-1 downto 0); + alias DENOM: UNSIGNED(XDENOM'LENGTH-1 downto 0) is XDENOM; + variable TOPBIT: INTEGER; + begin + TEMP := "0"&NUM; + QUOT := (others => '0'); + TOPBIT := -1; + for J in DENOM'RANGE loop + if DENOM(J)='1' then + TOPBIT := J; + exit; + end if; + end loop; + assert TOPBIT >= 0 report "DIV, MOD, or REM by zero" severity ERROR; + + for J in NUM'LENGTH-(TOPBIT+1) downto 0 loop + if TEMP(TOPBIT+J+1 downto J) >= "0"&DENOM(TOPBIT downto 0) then + TEMP(TOPBIT+J+1 downto J) := (TEMP(TOPBIT+J+1 downto J)) + -("0"&DENOM(TOPBIT downto 0)); + QUOT(J) := '1'; + end if; + assert TEMP(TOPBIT+J+1)='0' + report "internal error in the division algorithm" + severity ERROR; + end loop; + XQUOT := RESIZE(QUOT, XQUOT'LENGTH); + XREMAIN := RESIZE(TEMP, XREMAIN'LENGTH); + end DIVMOD; + + -----------------Local Subprograms - shift/rotate ops------------------------- + + function XSLL (ARG: BIT_VECTOR; COUNT: NATURAL) return BIT_VECTOR is + constant ARG_L: INTEGER := ARG'LENGTH-1; + alias XARG: BIT_VECTOR(ARG_L downto 0) is ARG; + variable RESULT: BIT_VECTOR(ARG_L downto 0) := (others => '0'); + begin + if COUNT <= ARG_L then + RESULT(ARG_L downto COUNT) := XARG(ARG_L-COUNT downto 0); + end if; + return RESULT; + end XSLL; + + function XSRL (ARG: BIT_VECTOR; COUNT: NATURAL) return BIT_VECTOR is + constant ARG_L: INTEGER := ARG'LENGTH-1; + alias XARG: BIT_VECTOR(ARG_L downto 0) is ARG; + variable RESULT: BIT_VECTOR(ARG_L downto 0) := (others => '0'); + begin + if COUNT <= ARG_L then + RESULT(ARG_L-COUNT downto 0) := XARG(ARG_L downto COUNT); + end if; + return RESULT; + end XSRL; + + function XSRA (ARG: BIT_VECTOR; COUNT: NATURAL) return BIT_VECTOR is + constant ARG_L: INTEGER := ARG'LENGTH-1; + alias XARG: BIT_VECTOR(ARG_L downto 0) is ARG; + variable RESULT: BIT_VECTOR(ARG_L downto 0); + variable XCOUNT: NATURAL := COUNT; + begin + if ((ARG'LENGTH <= 1) or (XCOUNT = 0)) then return ARG; + else + if (XCOUNT > ARG_L) then XCOUNT := ARG_L; + end if; + RESULT(ARG_L-XCOUNT downto 0) := XARG(ARG_L downto XCOUNT); + RESULT(ARG_L downto (ARG_L - XCOUNT + 1)) := (others => XARG(ARG_L)); + end if; + return RESULT; + end XSRA; + + function XROL (ARG: BIT_VECTOR; COUNT: NATURAL) return BIT_VECTOR is + constant ARG_L: INTEGER := ARG'LENGTH-1; + alias XARG: BIT_VECTOR(ARG_L downto 0) is ARG; + variable RESULT: BIT_VECTOR(ARG_L downto 0) := XARG; + variable COUNTM: INTEGER; + begin + COUNTM := COUNT mod (ARG_L + 1); + if COUNTM /= 0 then + RESULT(ARG_L downto COUNTM) := XARG(ARG_L-COUNTM downto 0); + RESULT(COUNTM-1 downto 0) := XARG(ARG_L downto ARG_L-COUNTM+1); + end if; + return RESULT; + end XROL; + + function XROR (ARG: BIT_VECTOR; COUNT: NATURAL) return BIT_VECTOR is + constant ARG_L: INTEGER := ARG'LENGTH-1; + alias XARG: BIT_VECTOR(ARG_L downto 0) is ARG; + variable RESULT: BIT_VECTOR(ARG_L downto 0) := XARG; + variable COUNTM: INTEGER; + begin + COUNTM := COUNT mod (ARG_L + 1); + if COUNTM /= 0 then + RESULT(ARG_L-COUNTM downto 0) := XARG(ARG_L downto COUNTM); + RESULT(ARG_L downto ARG_L-COUNTM+1) := XARG(COUNTM-1 downto 0); + end if; + return RESULT; + end XROR; + + ---------------- Local Subprograms - Relational Operators -------------------- + + -- General "=" for UNSIGNED vectors, same length + -- + function UNSIGNED_EQUAL (L, R: UNSIGNED) return BOOLEAN is + begin + return BIT_VECTOR(L) = BIT_VECTOR(R); + end UNSIGNED_EQUAL; + + -- + -- General "=" for SIGNED vectors, same length + -- + function SIGNED_EQUAL (L, R: SIGNED) return BOOLEAN is + begin + return BIT_VECTOR(L) = BIT_VECTOR(R); + end SIGNED_EQUAL; + + -- + -- General "<" for UNSIGNED vectors, same length + -- + function UNSIGNED_LESS (L, R: UNSIGNED) return BOOLEAN is + begin + return BIT_VECTOR(L) < BIT_VECTOR(R); + end UNSIGNED_LESS; + + -- + -- General "<" function for SIGNED vectors, same length + -- + function SIGNED_LESS (L, R: SIGNED) return BOOLEAN is + -- Need aliases to assure index direction + variable INTERN_L: SIGNED(0 to L'LENGTH-1); + variable INTERN_R: SIGNED(0 to R'LENGTH-1); + begin + INTERN_L := L; + INTERN_R := R; + INTERN_L(0) := not INTERN_L(0); + INTERN_R(0) := not INTERN_R(0); + return BIT_VECTOR(INTERN_L) < BIT_VECTOR(INTERN_R); + end SIGNED_LESS; + + -- + -- General "<=" function for UNSIGNED vectors, same length + -- + function UNSIGNED_LESS_OR_EQUAL (L, R: UNSIGNED) return BOOLEAN is + begin + return BIT_VECTOR(L) <= BIT_VECTOR(R); + end UNSIGNED_LESS_OR_EQUAL; + + -- + -- General "<=" function for SIGNED vectors, same length + -- + function SIGNED_LESS_OR_EQUAL (L, R: SIGNED) return BOOLEAN is + -- Need aliases to assure index direction + variable INTERN_L: SIGNED(0 to L'LENGTH-1); + variable INTERN_R: SIGNED(0 to R'LENGTH-1); + begin + INTERN_L := L; + INTERN_R := R; + INTERN_L(0) := not INTERN_L(0); + INTERN_R(0) := not INTERN_R(0); + return BIT_VECTOR(INTERN_L) <= BIT_VECTOR(INTERN_R); + end SIGNED_LESS_OR_EQUAL; + + --====================== Exported Functions ================================== + + -- Id: A.1 + function "abs" (ARG: SIGNED) return SIGNED is + constant ARG_LEFT: INTEGER := ARG'LENGTH-1; + variable RESULT: SIGNED(ARG_LEFT downto 0); + begin + if ARG'LENGTH < 1 then return NAS; + end if; + RESULT := ARG; + if RESULT(RESULT'LEFT) = '1' then + RESULT := -RESULT; + end if; + return RESULT; + end "abs"; + + -- Id: A.2 + function "-" (ARG: SIGNED) return SIGNED is + constant ARG_LEFT: INTEGER := ARG'LENGTH-1; + alias XARG: SIGNED(ARG_LEFT downto 0) is ARG; + variable RESULT: SIGNED(ARG_LEFT downto 0); + variable CBIT: BIT := '1'; + begin + if ARG'LENGTH < 1 then return NAS; + end if; + for I in 0 to RESULT'LEFT loop + RESULT(I) := not(XARG(I)) xor CBIT; + CBIT := CBIT and not(XARG(I)); + end loop; + return RESULT; + end "-"; + + --============================================================================ + + -- Id: A.3 + function "+" (L, R: UNSIGNED) return UNSIGNED is + constant L_LEFT: INTEGER := L'LENGTH-1; + constant R_LEFT: INTEGER := R'LENGTH-1; + constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAU; + end if; + return ADD_UNSIGNED(RESIZE(L, SIZE), RESIZE(R, SIZE), '0'); + end "+"; + + -- Id: A.4 + function "+" (L, R: SIGNED) return SIGNED is + constant L_LEFT: INTEGER := L'LENGTH-1; + constant R_LEFT: INTEGER := R'LENGTH-1; + constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAS; + end if; + return ADD_SIGNED(RESIZE(L, SIZE), RESIZE(R, SIZE), '0'); + end "+"; + + -- Id: A.5 + function "+" (L: UNSIGNED; R: NATURAL) return UNSIGNED is + begin + return L + TO_UNSIGNED(R, L'LENGTH); + end "+"; + + -- Id: A.6 + function "+" (L: NATURAL; R: UNSIGNED) return UNSIGNED is + begin + return TO_UNSIGNED(L, R'LENGTH) + R; + end "+"; + + -- Id: A.7 + function "+" (L: SIGNED; R: INTEGER) return SIGNED is + begin + return L + TO_SIGNED(R, L'LENGTH); + end "+"; + + -- Id: A.8 + function "+" (L: INTEGER; R: SIGNED) return SIGNED is + begin + return TO_SIGNED(L, R'LENGTH) + R; + end "+"; + + --============================================================================ + + -- Id: A.9 + function "-" (L, R: UNSIGNED) return UNSIGNED is + constant L_LEFT: INTEGER := L'LENGTH-1; + constant R_LEFT: INTEGER := R'LENGTH-1; + constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAU; + end if; + return ADD_UNSIGNED(RESIZE(L, SIZE), + not(RESIZE(R, SIZE)), + '1'); + end "-"; + + -- Id: A.10 + function "-" (L, R: SIGNED) return SIGNED is + constant L_LEFT: INTEGER := L'LENGTH-1; + constant R_LEFT: INTEGER := R'LENGTH-1; + constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAS; + end if; + return ADD_SIGNED(RESIZE(L, SIZE), + not(RESIZE(R, SIZE)), + '1'); + end "-"; + + -- Id: A.11 + function "-" (L: UNSIGNED; R: NATURAL) return UNSIGNED is + begin + return L - TO_UNSIGNED(R, L'LENGTH); + end "-"; + + -- Id: A.12 + function "-" (L: NATURAL; R: UNSIGNED) return UNSIGNED is + begin + return TO_UNSIGNED(L, R'LENGTH) - R; + end "-"; + + -- Id: A.13 + function "-" (L: SIGNED; R: INTEGER) return SIGNED is + begin + return L - TO_SIGNED(R, L'LENGTH); + end "-"; + + -- Id: A.14 + function "-" (L: INTEGER; R: SIGNED) return SIGNED is + begin + return TO_SIGNED(L, R'LENGTH) - R; + end "-"; + + --============================================================================ + + -- Id: A.15 + function "*" (L, R: UNSIGNED) return UNSIGNED is + constant L_LEFT: INTEGER := L'LENGTH-1; + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XL: UNSIGNED(L_LEFT downto 0) is L; + alias XR: UNSIGNED(R_LEFT downto 0) is R; + variable RESULT: UNSIGNED((L'LENGTH+R'LENGTH-1) downto 0) := (others => '0'); + variable ADVAL: UNSIGNED((L'LENGTH+R'LENGTH-1) downto 0); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAU; + end if; + ADVAL := RESIZE(XR, RESULT'LENGTH); + for I in 0 to L_LEFT loop + if XL(I)='1' then RESULT := RESULT + ADVAL; + end if; + ADVAL := SHIFT_LEFT(ADVAL, 1); + end loop; + return RESULT; + end "*"; + + -- Id: A.16 + function "*" (L, R: SIGNED) return SIGNED is + constant L_LEFT: INTEGER := L'LENGTH-1; + constant R_LEFT: INTEGER := R'LENGTH-1; + variable XL: SIGNED(L_LEFT downto 0); + variable XR: SIGNED(R_LEFT downto 0); + variable RESULT: SIGNED((L_LEFT+R_LEFT+1) downto 0) := (others => '0'); + variable ADVAL: SIGNED((L_LEFT+R_LEFT+1) downto 0); + begin + if ((L_LEFT < 0) or (R_LEFT < 0)) then return NAS; + end if; + XL := L; + XR := R; + ADVAL := RESIZE(XR, RESULT'LENGTH); + for I in 0 to L_LEFT-1 loop + if XL(I)='1' then RESULT := RESULT + ADVAL; + end if; + ADVAL := SHIFT_LEFT(ADVAL, 1); + end loop; + if XL(L_LEFT)='1' then + RESULT := RESULT - ADVAL; + end if; + return RESULT; + end "*"; + + -- Id: A.17 + function "*" (L: UNSIGNED; R: NATURAL) return UNSIGNED is + begin + return L * TO_UNSIGNED(R, L'LENGTH); + end "*"; + + -- Id: A.18 + function "*" (L: NATURAL; R: UNSIGNED) return UNSIGNED is + begin + return TO_UNSIGNED(L, R'LENGTH) * R; + end "*"; + + -- Id: A.19 + function "*" (L: SIGNED; R: INTEGER) return SIGNED is + begin + return L * TO_SIGNED(R, L'LENGTH); + end "*"; + + -- Id: A.20 + function "*" (L: INTEGER; R: SIGNED) return SIGNED is + begin + return TO_SIGNED(L, R'LENGTH) * R; + end "*"; + + --============================================================================ + + -- Id: A.21 + function "/" (L, R: UNSIGNED) return UNSIGNED is + variable FQUOT: UNSIGNED(L'LENGTH-1 downto 0); + variable FREMAIN: UNSIGNED(R'LENGTH-1 downto 0); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAU; + end if; + DIVMOD(L, R, FQUOT, FREMAIN); + return FQUOT; + end "/"; + + -- Id: A.22 + function "/" (L, R: SIGNED) return SIGNED is + variable FQUOT: UNSIGNED(L'LENGTH-1 downto 0); + variable FREMAIN: UNSIGNED(R'LENGTH-1 downto 0); + variable XNUM: UNSIGNED(L'LENGTH-1 downto 0); + variable XDENOM: UNSIGNED(R'LENGTH-1 downto 0); + variable QNEG: BOOLEAN := FALSE; + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAS; + end if; + if L(L'LEFT)='1' then + XNUM := UNSIGNED(-L); + QNEG := TRUE; + else + XNUM := UNSIGNED(L); + end if; + if R(R'LEFT)='1' then + XDENOM := UNSIGNED(-R); + QNEG := not QNEG; + else + XDENOM := UNSIGNED(R); + end if; + DIVMOD(XNUM, XDENOM, FQUOT, FREMAIN); + if QNEG then FQUOT := "0"-FQUOT; + end if; + return SIGNED(FQUOT); + end "/"; + + -- Id: A.23 + function "/" (L: UNSIGNED; R: NATURAL) return UNSIGNED is + constant R_LENGTH: NATURAL := MAX(L'LENGTH, UNSIGNED_NUM_BITS(R)); + variable XR, QUOT: UNSIGNED(R_LENGTH-1 downto 0); + begin + if (L'LENGTH < 1) then return NAU; + end if; + if (R_LENGTH > L'LENGTH) then + QUOT := (others => '0'); + return RESIZE(QUOT, L'LENGTH); + end if; + XR := TO_UNSIGNED(R, R_LENGTH); + QUOT := RESIZE((L / XR), QUOT'LENGTH); + return RESIZE(QUOT, L'LENGTH); + end "/"; + + -- Id: A.24 + function "/" (L: NATURAL; R: UNSIGNED) return UNSIGNED is + constant L_LENGTH: NATURAL := MAX(UNSIGNED_NUM_BITS(L), R'LENGTH); + variable XL, QUOT: UNSIGNED(L_LENGTH-1 downto 0); + begin + if (R'LENGTH < 1) then return NAU; + end if; + XL := TO_UNSIGNED(L, L_LENGTH); + QUOT := RESIZE((XL / R), QUOT'LENGTH); + if L_LENGTH > R'LENGTH + and QUOT(L_LENGTH-1 downto R'LENGTH) + /= (L_LENGTH-1 downto R'LENGTH => '0') + then + assert NO_WARNING report "NUMERIC_BIT.""/"": Quotient Truncated" + severity WARNING; + end if; + return RESIZE(QUOT, R'LENGTH); + end "/"; + + -- Id: A.25 + function "/" (L: SIGNED; R: INTEGER) return SIGNED is + constant R_LENGTH: NATURAL := MAX(L'LENGTH, SIGNED_NUM_BITS(R)); + variable XR, QUOT: SIGNED(R_LENGTH-1 downto 0); + begin + if (L'LENGTH < 1) then return NAS; + end if; + if (R_LENGTH > L'LENGTH) then + QUOT := (others => '0'); + return RESIZE(QUOT, L'LENGTH); + end if; + XR := TO_SIGNED(R, R_LENGTH); + QUOT := RESIZE((L / XR), QUOT'LENGTH); + return RESIZE(QUOT, L'LENGTH); + end "/"; + + -- Id: A.26 + function "/" (L: INTEGER; R: SIGNED) return SIGNED is + constant L_LENGTH: NATURAL := MAX(SIGNED_NUM_BITS(L), R'LENGTH); + variable XL, QUOT: SIGNED(L_LENGTH-1 downto 0); + begin + if (R'LENGTH < 1) then return NAS; + end if; + XL := TO_SIGNED(L, L_LENGTH); + QUOT := RESIZE((XL / R), QUOT'LENGTH); + if L_LENGTH > R'LENGTH and QUOT(L_LENGTH-1 downto R'LENGTH) + /= (L_LENGTH-1 downto R'LENGTH => QUOT(R'LENGTH-1)) + then + assert NO_WARNING report "NUMERIC_BIT.""/"": Quotient Truncated" + severity WARNING; + end if; + return RESIZE(QUOT, R'LENGTH); + end "/"; + + --============================================================================ + + -- Id: A.27 + function "rem" (L, R: UNSIGNED) return UNSIGNED is + variable FQUOT: UNSIGNED(L'LENGTH-1 downto 0); + variable FREMAIN: UNSIGNED(R'LENGTH-1 downto 0); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAU; + end if; + DIVMOD(L, R, FQUOT, FREMAIN); + return FREMAIN; + end "rem"; + + -- Id: A.28 + function "rem" (L, R: SIGNED) return SIGNED is + variable FQUOT: UNSIGNED(L'LENGTH-1 downto 0); + variable FREMAIN: UNSIGNED(R'LENGTH-1 downto 0); + variable XNUM: UNSIGNED(L'LENGTH-1 downto 0); + variable XDENOM: UNSIGNED(R'LENGTH-1 downto 0); + variable RNEG: BOOLEAN := FALSE; + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAS; + end if; + if L(L'LEFT)='1' then + XNUM := UNSIGNED(-L); + RNEG := TRUE; + else + XNUM := UNSIGNED(L); + end if; + if R(R'LEFT)='1' then + XDENOM := UNSIGNED(-R); + else + XDENOM := UNSIGNED(R); + end if; + DIVMOD(XNUM, XDENOM, FQUOT, FREMAIN); + if RNEG then + FREMAIN := "0"-FREMAIN; + end if; + return SIGNED(FREMAIN); + end "rem"; + + -- Id: A.29 + function "rem" (L: UNSIGNED; R: NATURAL) return UNSIGNED is + constant R_LENGTH: NATURAL := MAX(L'LENGTH, UNSIGNED_NUM_BITS(R)); + variable XR, XREM: UNSIGNED(R_LENGTH-1 downto 0); + begin + if (L'LENGTH < 1) then return NAU; + end if; + XR := TO_UNSIGNED(R, R_LENGTH); + XREM := RESIZE((L rem XR), XREM'LENGTH); + if R_LENGTH > L'LENGTH and XREM(R_LENGTH-1 downto L'LENGTH) + /= (R_LENGTH-1 downto L'LENGTH => '0') + then + assert NO_WARNING report "NUMERIC_BIT.""rem"": Remainder Truncated" + severity WARNING; + end if; + return RESIZE(XREM, L'LENGTH); + end "rem"; + + -- Id: A.30 + function "rem" (L: NATURAL; R: UNSIGNED) return UNSIGNED is + constant L_LENGTH: NATURAL := MAX(UNSIGNED_NUM_BITS(L), R'LENGTH); + variable XL, XREM: UNSIGNED(L_LENGTH-1 downto 0); + begin + if (R'LENGTH < 1) then return NAU; + end if; + XL := TO_UNSIGNED(L, L_LENGTH); + XREM := RESIZE((XL rem R), XREM'LENGTH); + if L_LENGTH > R'LENGTH and XREM(L_LENGTH-1 downto R'LENGTH) + /= (L_LENGTH-1 downto R'LENGTH => '0') + then + assert NO_WARNING report "NUMERIC_BIT.""rem"": Remainder Truncated" + severity WARNING; + end if; + return RESIZE(XREM, R'LENGTH); + end "rem"; + + -- Id: A.31 + function "rem" (L: SIGNED; R: INTEGER) return SIGNED is + constant R_LENGTH: NATURAL := MAX(L'LENGTH, SIGNED_NUM_BITS(R)); + variable XR, XREM: SIGNED(R_LENGTH-1 downto 0); + begin + if (L'LENGTH < 1) then return NAS; + end if; + XR := TO_SIGNED(R, R_LENGTH); + XREM := RESIZE((L rem XR), XREM'LENGTH); + if R_LENGTH > L'LENGTH and XREM(R_LENGTH-1 downto L'LENGTH) + /= (R_LENGTH-1 downto L'LENGTH => XREM(L'LENGTH-1)) + then + assert NO_WARNING report "NUMERIC_BIT.""rem"": Remainder Truncated" + severity WARNING; + end if; + return RESIZE(XREM, L'LENGTH); + end "rem"; + + -- Id: A.32 + function "rem" (L: INTEGER; R: SIGNED) return SIGNED is + constant L_LENGTH: NATURAL := MAX(SIGNED_NUM_BITS(L), R'LENGTH); + variable XL, XREM: SIGNED(L_LENGTH-1 downto 0); + begin + if (R'LENGTH < 1) then return NAS; + end if; + XL := TO_SIGNED(L, L_LENGTH); + XREM := RESIZE((XL rem R), XREM'LENGTH); + if L_LENGTH > R'LENGTH and XREM(L_LENGTH-1 downto R'LENGTH) + /= (L_LENGTH-1 downto R'LENGTH => XREM(R'LENGTH-1)) + then + assert NO_WARNING report "NUMERIC_BIT.""rem"": Remainder Truncated" + severity WARNING; + end if; + return RESIZE(XREM, R'LENGTH); + end "rem"; + + --============================================================================ + + -- Id: A.33 + function "mod" (L, R: UNSIGNED) return UNSIGNED is + variable FQUOT: UNSIGNED(L'LENGTH-1 downto 0); + variable FREMAIN: UNSIGNED(R'LENGTH-1 downto 0); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAU; + end if; + DIVMOD(L, R, FQUOT, FREMAIN); + return FREMAIN; + end "mod"; + + -- Id: A.34 + function "mod" (L, R: SIGNED) return SIGNED is + variable FQUOT: UNSIGNED(L'LENGTH-1 downto 0); + variable FREMAIN: UNSIGNED(R'LENGTH-1 downto 0); + variable XNUM: UNSIGNED(L'LENGTH-1 downto 0); + variable XDENOM: UNSIGNED(R'LENGTH-1 downto 0); + variable RNEG: BOOLEAN := FALSE; + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAS; + end if; + if L(L'LEFT)='1' then + XNUM := UNSIGNED(-L); + else + XNUM := UNSIGNED(L); + end if; + if R(R'LEFT)='1' then + XDENOM := UNSIGNED(-R); + RNEG := TRUE; + else + XDENOM := UNSIGNED(R); + end if; + DIVMOD(XNUM, XDENOM, FQUOT, FREMAIN); + if RNEG and L(L'LEFT)='1' then + FREMAIN := "0"-FREMAIN; + elsif RNEG and FREMAIN/="0" then + FREMAIN := FREMAIN-XDENOM; + elsif L(L'LEFT)='1' and FREMAIN/="0" then + FREMAIN := XDENOM-FREMAIN; + end if; + return SIGNED(FREMAIN); + end "mod"; + + -- Id: A.35 + function "mod" (L: UNSIGNED; R: NATURAL) return UNSIGNED is + constant R_LENGTH: NATURAL := MAX(L'LENGTH, UNSIGNED_NUM_BITS(R)); + variable XR, XREM: UNSIGNED(R_LENGTH-1 downto 0); + begin + if (L'LENGTH < 1) then return NAU; + end if; + XR := TO_UNSIGNED(R, R_LENGTH); + XREM := RESIZE((L mod XR), XREM'LENGTH); + if R_LENGTH > L'LENGTH and XREM(R_LENGTH-1 downto L'LENGTH) + /= (R_LENGTH-1 downto L'LENGTH => '0') + then + assert NO_WARNING report "NUMERIC_BIT.""mod"": modulus Truncated" + severity WARNING; + end if; + return RESIZE(XREM, L'LENGTH); + end "mod"; + + -- Id: A.36 + function "mod" (L: NATURAL; R: UNSIGNED) return UNSIGNED is + constant L_LENGTH: NATURAL := MAX(UNSIGNED_NUM_BITS(L), R'LENGTH); + variable XL, XREM: UNSIGNED(L_LENGTH-1 downto 0); + begin + if (R'LENGTH < 1) then return NAU; + end if; + XL := TO_UNSIGNED(L, L_LENGTH); + XREM := RESIZE((XL mod R), XREM'LENGTH); + if L_LENGTH > R'LENGTH and XREM(L_LENGTH-1 downto R'LENGTH) + /= (L_LENGTH-1 downto R'LENGTH => '0') + then + assert NO_WARNING report "NUMERIC_BIT.""mod"": modulus Truncated" + severity WARNING; + end if; + return RESIZE(XREM, R'LENGTH); + end "mod"; + + -- Id: A.37 + function "mod" (L: SIGNED; R: INTEGER) return SIGNED is + constant R_LENGTH: NATURAL := MAX(L'LENGTH, SIGNED_NUM_BITS(R)); + variable XR, XREM: SIGNED(R_LENGTH-1 downto 0); + begin + if (L'LENGTH < 1) then return NAS; + end if; + XR := TO_SIGNED(R, R_LENGTH); + XREM := RESIZE((L mod XR), XREM'LENGTH); + if R_LENGTH > L'LENGTH and XREM(R_LENGTH-1 downto L'LENGTH) + /= (R_LENGTH-1 downto L'LENGTH => XREM(L'LENGTH-1)) + then + assert NO_WARNING report "NUMERIC_BIT.""mod"": modulus Truncated" + severity WARNING; + end if; + return RESIZE(XREM, L'LENGTH); + end "mod"; + + -- Id: A.38 + function "mod" (L: INTEGER; R: SIGNED) return SIGNED is + constant L_LENGTH: NATURAL := MAX(SIGNED_NUM_BITS(L), R'LENGTH); + variable XL, XREM: SIGNED(L_LENGTH-1 downto 0); + begin + if (R'LENGTH < 1) then return NAS; + end if; + XL := TO_SIGNED(L, L_LENGTH); + XREM := RESIZE((XL mod R), XREM'LENGTH); + if L_LENGTH > R'LENGTH and XREM(L_LENGTH-1 downto R'LENGTH) + /= (L_LENGTH-1 downto R'LENGTH => XREM(R'LENGTH-1)) + then + assert NO_WARNING report "NUMERIC_BIT.""mod"": modulus Truncated" + severity WARNING; + end if; + return RESIZE(XREM, R'LENGTH); + end "mod"; + + --============================================================================ + + -- Id: C.1 + function ">" (L, R: UNSIGNED) return BOOLEAN is + variable SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then + assert NO_WARNING + report "NUMERIC_BIT."">"": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + return not UNSIGNED_LESS_OR_EQUAL(RESIZE(L, SIZE), RESIZE(R, SIZE)); + end ">"; + + -- Id: C.2 + function ">" (L, R: SIGNED) return BOOLEAN is + variable SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then + assert NO_WARNING + report "NUMERIC_BIT."">"": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + return not SIGNED_LESS_OR_EQUAL(RESIZE(L, SIZE), RESIZE(R, SIZE)); + end ">"; + + -- Id: C.3 + function ">" (L: NATURAL; R: UNSIGNED) return BOOLEAN is + begin + if (R'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_BIT."">"": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if UNSIGNED_NUM_BITS(L) > R'LENGTH then return TRUE; + end if; + return not UNSIGNED_LESS_OR_EQUAL(TO_UNSIGNED(L, R'LENGTH), R); + end ">"; + + -- Id: C.4 + function ">" (L: INTEGER; R: SIGNED) return BOOLEAN is + begin + if (R'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_BIT."">"": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if SIGNED_NUM_BITS(L) > R'LENGTH then return L > 0; + end if; + return not SIGNED_LESS_OR_EQUAL(TO_SIGNED(L, R'LENGTH), R); + end ">"; + + -- Id: C.5 + function ">" (L: UNSIGNED; R: NATURAL) return BOOLEAN is + begin + if (L'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_BIT."">"": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if UNSIGNED_NUM_BITS(R) > L'LENGTH then return FALSE; + end if; + return not UNSIGNED_LESS_OR_EQUAL(L, TO_UNSIGNED(R, L'LENGTH)); + end ">"; + + -- Id: C.6 + function ">" (L: SIGNED; R: INTEGER) return BOOLEAN is + begin + if (L'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_BIT."">"": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if SIGNED_NUM_BITS(R) > L'LENGTH then return 0 > R; + end if; + return not SIGNED_LESS_OR_EQUAL(L, TO_SIGNED(R, L'LENGTH)); + end ">"; + + --============================================================================ + + -- Id: C.7 + function "<" (L, R: UNSIGNED) return BOOLEAN is + variable SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then + assert NO_WARNING + report "NUMERIC_BIT.""<"": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + return UNSIGNED_LESS(RESIZE(L, SIZE), RESIZE(R, SIZE)); + end "<"; + + -- Id: C.8 + function "<" (L, R: SIGNED) return BOOLEAN is + variable SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then + assert NO_WARNING + report "NUMERIC_BIT.""<"": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + return SIGNED_LESS(RESIZE(L, SIZE), RESIZE(R, SIZE)); + end "<"; + + -- Id: C.9 + function "<" (L: NATURAL; R: UNSIGNED) return BOOLEAN is + begin + if (R'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_BIT.""<"": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if UNSIGNED_NUM_BITS(L) > R'LENGTH then return L < 0; + end if; + return UNSIGNED_LESS(TO_UNSIGNED(L, R'LENGTH), R); + end "<"; + + -- Id: C.10 + function "<" (L: INTEGER; R: SIGNED) return BOOLEAN is + begin + if (R'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_BIT.""<"": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if SIGNED_NUM_BITS(L) > R'LENGTH then return L < 0; + end if; + return SIGNED_LESS(TO_SIGNED(L, R'LENGTH), R); + end "<"; + + -- Id: C.11 + function "<" (L: UNSIGNED; R: NATURAL) return BOOLEAN is + begin + if (L'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_BIT.""<"": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if UNSIGNED_NUM_BITS(R) > L'LENGTH then return 0 < R; + end if; + return UNSIGNED_LESS(L, TO_UNSIGNED(R, L'LENGTH)); + end "<"; + + -- Id: C.12 + function "<" (L: SIGNED; R: INTEGER) return BOOLEAN is + begin + if (L'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_BIT.""<"": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if SIGNED_NUM_BITS(R) > L'LENGTH then return 0 < R; + end if; + return SIGNED_LESS(L, TO_SIGNED(R, L'LENGTH)); + end "<"; + + --============================================================================ + + -- Id: C.13 + function "<=" (L, R: UNSIGNED) return BOOLEAN is + variable SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then + assert NO_WARNING + report "NUMERIC_BIT.""<="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + return UNSIGNED_LESS_OR_EQUAL(RESIZE(L, SIZE), RESIZE(R, SIZE)); + end "<="; + + -- Id: C.14 + function "<=" (L, R: SIGNED) return BOOLEAN is + variable SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then + assert NO_WARNING + report "NUMERIC_BIT.""<="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + return SIGNED_LESS_OR_EQUAL(RESIZE(L, SIZE), RESIZE(R, SIZE)); + end "<="; + + -- Id: C.15 + function "<=" (L: NATURAL; R: UNSIGNED) return BOOLEAN is + begin + if (R'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_BIT.""<="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if UNSIGNED_NUM_BITS(L) > R'LENGTH then return L < 0; + end if; + return UNSIGNED_LESS_OR_EQUAL(TO_UNSIGNED(L, R'LENGTH), R); + end "<="; + + -- Id: C.16 + function "<=" (L: INTEGER; R: SIGNED) return BOOLEAN is + begin + if (R'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_BIT.""<="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if SIGNED_NUM_BITS(L) > R'LENGTH then return L < 0; + end if; + return SIGNED_LESS_OR_EQUAL(TO_SIGNED(L, R'LENGTH), R); + end "<="; + + -- Id: C.17 + function "<=" (L: UNSIGNED; R: NATURAL) return BOOLEAN is + begin + if (L'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_BIT.""<="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if UNSIGNED_NUM_BITS(R) > L'LENGTH then return 0 < R; + end if; + return UNSIGNED_LESS_OR_EQUAL(L, TO_UNSIGNED(R, L'LENGTH)); + end "<="; + + -- Id: C.18 + function "<=" (L: SIGNED; R: INTEGER) return BOOLEAN is + begin + if (L'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_BIT.""<="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if SIGNED_NUM_BITS(R) > L'LENGTH then return 0 < R; + end if; + return SIGNED_LESS_OR_EQUAL(L, TO_SIGNED(R, L'LENGTH)); + end "<="; + + --============================================================================ + + -- Id: C.19 + function ">=" (L, R: UNSIGNED) return BOOLEAN is + variable SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then + assert NO_WARNING + report "NUMERIC_BIT."">="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + return not UNSIGNED_LESS(RESIZE(L, SIZE), RESIZE(R, SIZE)); + end ">="; + + -- Id: C.20 + function ">=" (L, R: SIGNED) return BOOLEAN is + variable SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then + assert NO_WARNING + report "NUMERIC_BIT."">="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + return not SIGNED_LESS(RESIZE(L, SIZE), RESIZE(R, SIZE)); + end ">="; + + -- Id: C.21 + function ">=" (L: NATURAL; R: UNSIGNED) return BOOLEAN is + begin + if (R'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_BIT."">="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if UNSIGNED_NUM_BITS(L) > R'LENGTH then return L > 0; + end if; + return not UNSIGNED_LESS(TO_UNSIGNED(L, R'LENGTH), R); + end ">="; + + -- Id: C.22 + function ">=" (L: INTEGER; R: SIGNED) return BOOLEAN is + begin + if (R'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_BIT."">="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if SIGNED_NUM_BITS(L) > R'LENGTH then return L > 0; + end if; + return not SIGNED_LESS(TO_SIGNED(L, R'LENGTH), R); + end ">="; + + -- Id: C.23 + function ">=" (L: UNSIGNED; R: NATURAL) return BOOLEAN is + begin + if (L'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_BIT."">="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if UNSIGNED_NUM_BITS(R) > L'LENGTH then return 0 > R; + end if; + return not UNSIGNED_LESS(L, TO_UNSIGNED(R, L'LENGTH)); + end ">="; + + -- Id: C.24 + function ">=" (L: SIGNED; R: INTEGER) return BOOLEAN is + begin + if (L'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_BIT."">="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if SIGNED_NUM_BITS(R) > L'LENGTH then return 0 > R; + end if; + return not SIGNED_LESS(L, TO_SIGNED(R, L'LENGTH)); + end ">="; + + --============================================================================ + + -- Id: C.25 + function "=" (L, R: UNSIGNED) return BOOLEAN is + variable SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then + assert NO_WARNING + report "NUMERIC_BIT.""="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + return UNSIGNED_EQUAL(RESIZE(L, SIZE), RESIZE(R, SIZE)); + end "="; + + -- Id: C.26 + function "=" (L, R: SIGNED) return BOOLEAN is + variable SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then + assert NO_WARNING + report "NUMERIC_BIT.""="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + return SIGNED_EQUAL(RESIZE(L, SIZE), RESIZE(R, SIZE)); + end "="; + + -- Id: C.27 + function "=" (L: NATURAL; R: UNSIGNED) return BOOLEAN is + begin + if (R'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_BIT.""="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if UNSIGNED_NUM_BITS(L) > R'LENGTH then return FALSE; + end if; + return UNSIGNED_EQUAL(TO_UNSIGNED(L, R'LENGTH), R); + end "="; + + -- Id: C.28 + function "=" (L: INTEGER; R: SIGNED) return BOOLEAN is + begin + if (R'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_BIT.""="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if SIGNED_NUM_BITS(L) > R'LENGTH then return FALSE; + end if; + return SIGNED_EQUAL(TO_SIGNED(L, R'LENGTH), R); + end "="; + + -- Id: C.29 + function "=" (L: UNSIGNED; R: NATURAL) return BOOLEAN is + begin + if (L'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_BIT.""="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if UNSIGNED_NUM_BITS(R) > L'LENGTH then return FALSE; + end if; + return UNSIGNED_EQUAL(L, TO_UNSIGNED(R, L'LENGTH)); + end "="; + + -- Id: C.30 + function "=" (L: SIGNED; R: INTEGER) return BOOLEAN is + begin + if (L'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_BIT.""="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if SIGNED_NUM_BITS(R) > L'LENGTH then return FALSE; + end if; + return SIGNED_EQUAL(L, TO_SIGNED(R, L'LENGTH)); + end "="; + + --============================================================================ + + -- Id: C.31 + function "/=" (L, R: UNSIGNED) return BOOLEAN is + variable SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then + assert NO_WARNING + report "NUMERIC_BIT.""/="": null argument detected, returning TRUE" + severity WARNING; + return TRUE; + end if; + return not(UNSIGNED_EQUAL(RESIZE(L, SIZE), RESIZE(R, SIZE))); + end "/="; + + -- Id: C.32 + function "/=" (L, R: SIGNED) return BOOLEAN is + variable SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then + assert NO_WARNING + report "NUMERIC_BIT.""/="": null argument detected, returning TRUE" + severity WARNING; + return TRUE; + end if; + return not(SIGNED_EQUAL(RESIZE(L, SIZE), RESIZE(R, SIZE))); + end "/="; + + -- Id: C.33 + function "/=" (L: NATURAL; R: UNSIGNED) return BOOLEAN is + begin + if (R'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_BIT.""/="": null argument detected, returning TRUE" + severity WARNING; + return TRUE; + end if; + if UNSIGNED_NUM_BITS(L) > R'LENGTH then return TRUE; + end if; + return not(UNSIGNED_EQUAL(TO_UNSIGNED(L, R'LENGTH), R)); + end "/="; + + -- Id: C.34 + function "/=" (L: INTEGER; R: SIGNED) return BOOLEAN is + begin + if (R'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_BIT.""/="": null argument detected, returning TRUE" + severity WARNING; + return TRUE; + end if; + if SIGNED_NUM_BITS(L) > R'LENGTH then return TRUE; + end if; + return not(SIGNED_EQUAL(TO_SIGNED(L, R'LENGTH), R)); + end "/="; + + -- Id: C.35 + function "/=" (L: UNSIGNED; R: NATURAL) return BOOLEAN is + begin + if (L'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_BIT.""/="": null argument detected, returning TRUE" + severity WARNING; + return TRUE; + end if; + if UNSIGNED_NUM_BITS(R) > L'LENGTH then return TRUE; + end if; + return not(UNSIGNED_EQUAL(L, TO_UNSIGNED(R, L'LENGTH))); + end "/="; + + -- Id: C.36 + function "/=" (L: SIGNED; R: INTEGER) return BOOLEAN is + begin + if (L'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_BIT.""/="": null argument detected, returning TRUE" + severity WARNING; + return TRUE; + end if; + if SIGNED_NUM_BITS(R) > L'LENGTH then return TRUE; + end if; + return not(SIGNED_EQUAL(L, TO_SIGNED(R, L'LENGTH))); + end "/="; + + --============================================================================ + + -- Id: S.1 + function SHIFT_LEFT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED is + begin + if (ARG'LENGTH < 1) then return NAU; + end if; + return UNSIGNED(XSLL(BIT_VECTOR(ARG), COUNT)); + end SHIFT_LEFT; + + -- Id: S.2 + function SHIFT_RIGHT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED is + begin + if (ARG'LENGTH < 1) then return NAU; + end if; + return UNSIGNED(XSRL(BIT_VECTOR(ARG), COUNT)); + end SHIFT_RIGHT; + + -- Id: S.3 + function SHIFT_LEFT (ARG: SIGNED; COUNT: NATURAL) return SIGNED is + begin + if (ARG'LENGTH < 1) then return NAS; + end if; + return SIGNED(XSLL(BIT_VECTOR(ARG), COUNT)); + end SHIFT_LEFT; + + -- Id: S.4 + function SHIFT_RIGHT (ARG: SIGNED; COUNT: NATURAL) return SIGNED is + begin + if (ARG'LENGTH < 1) then return NAS; + end if; + return SIGNED(XSRA(BIT_VECTOR(ARG), COUNT)); + end SHIFT_RIGHT; + + --============================================================================ + + -- Id: S.5 + function ROTATE_LEFT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED is + begin + if (ARG'LENGTH < 1) then return NAU; + end if; + return UNSIGNED(XROL(BIT_VECTOR(ARG), COUNT)); + end ROTATE_LEFT; + + -- Id: S.6 + function ROTATE_RIGHT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED is + begin + if (ARG'LENGTH < 1) then return NAU; + end if; + return UNSIGNED(XROR(BIT_VECTOR(ARG), COUNT)); + end ROTATE_RIGHT; + + -- Id: S.7 + function ROTATE_LEFT (ARG: SIGNED; COUNT: NATURAL) return SIGNED is + begin + if (ARG'LENGTH < 1) then return NAS; + end if; + return SIGNED(XROL(BIT_VECTOR(ARG), COUNT)); + end ROTATE_LEFT; + + -- Id: S.8 + function ROTATE_RIGHT (ARG: SIGNED; COUNT: NATURAL) return SIGNED is + begin + if (ARG'LENGTH < 1) then return NAS; + end if; + return SIGNED(XROR(BIT_VECTOR(ARG), COUNT)); + end ROTATE_RIGHT; + + --============================================================================ + +--START-V93 + ------------------------------------------------------------------------------ + -- Note : Function S.9 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.9 + function "sll" (ARG: UNSIGNED; COUNT: INTEGER) return UNSIGNED is + begin + if (COUNT >= 0) then + return SHIFT_LEFT(ARG, COUNT); + else + return SHIFT_RIGHT(ARG, -COUNT); + end if; + end "sll"; + + ------------------------------------------------------------------------------ + -- Note : Function S.10 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.10 + function "sll" (ARG: SIGNED; COUNT: INTEGER) return SIGNED is + begin + if (COUNT >= 0) then + return SHIFT_LEFT(ARG, COUNT); + else + return SIGNED(SHIFT_RIGHT(UNSIGNED(ARG), -COUNT)); + end if; + end "sll"; + + ------------------------------------------------------------------------------ + -- Note : Function S.11 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.11 + function "srl" (ARG: UNSIGNED; COUNT: INTEGER) return UNSIGNED is + begin + if (COUNT >= 0) then + return SHIFT_RIGHT(ARG, COUNT); + else + return SHIFT_LEFT(ARG, -COUNT); + end if; + end "srl"; + + ------------------------------------------------------------------------------ + -- Note : Function S.12 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.12 + function "srl" (ARG: SIGNED; COUNT: INTEGER) return SIGNED is + begin + if (COUNT >= 0) then + return SIGNED(SHIFT_RIGHT(UNSIGNED(ARG), COUNT)); + else + return SHIFT_LEFT(ARG, -COUNT); + end if; + end "srl"; + + ------------------------------------------------------------------------------ + -- Note : Function S.13 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.13 + function "rol" (ARG: UNSIGNED; COUNT: INTEGER) return UNSIGNED is + begin + if (COUNT >= 0) then + return ROTATE_LEFT(ARG, COUNT); + else + return ROTATE_RIGHT(ARG, -COUNT); + end if; + end "rol"; + + ------------------------------------------------------------------------------ + -- Note : Function S.14 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.14 + function "rol" (ARG: SIGNED; COUNT: INTEGER) return SIGNED is + begin + if (COUNT >= 0) then + return ROTATE_LEFT(ARG, COUNT); + else + return ROTATE_RIGHT(ARG, -COUNT); + end if; + end "rol"; + + ------------------------------------------------------------------------------ + -- Note : Function S.15 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.15 + function "ror" (ARG: UNSIGNED; COUNT: INTEGER) return UNSIGNED is + begin + if (COUNT >= 0) then + return ROTATE_RIGHT(ARG, COUNT); + else + return ROTATE_LEFT(ARG, -COUNT); + end if; + end "ror"; + + ------------------------------------------------------------------------------ + -- Note : Function S.16 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.16 + function "ror" (ARG: SIGNED; COUNT: INTEGER) return SIGNED is + begin + if (COUNT >= 0) then + return ROTATE_RIGHT(ARG, COUNT); + else + return ROTATE_LEFT(ARG, -COUNT); + end if; + end "ror"; + +--END-V93 + --============================================================================ + + -- Id: D.1 + function TO_INTEGER (ARG: UNSIGNED) return NATURAL is + constant ARG_LEFT: INTEGER := ARG'LENGTH-1; + alias XARG: UNSIGNED(ARG_LEFT downto 0) is ARG; + variable RESULT: NATURAL := 0; + begin + if (ARG'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_BIT.TO_INTEGER: null detected, returning 0" + severity WARNING; + return 0; + end if; + for I in XARG'RANGE loop + RESULT := RESULT+RESULT; + if XARG(I) = '1' then + RESULT := RESULT + 1; + end if; + end loop; + return RESULT; + end TO_INTEGER; + + -- Id: D.2 + function TO_INTEGER (ARG: SIGNED) return INTEGER is + begin + if (ARG'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_BIT.TO_INTEGER: null detected, returning 0" + severity WARNING; + return 0; + end if; + if ARG(ARG'LEFT) = '0' then + return TO_INTEGER(UNSIGNED(ARG)); + else + return (- (TO_INTEGER(UNSIGNED(- (ARG + 1)))) -1); + end if; + end TO_INTEGER; + + -- Id: D.3 + function TO_UNSIGNED (ARG, SIZE: NATURAL) return UNSIGNED is + variable RESULT: UNSIGNED(SIZE-1 downto 0); + variable I_VAL: NATURAL := ARG; + begin + if (SIZE < 1) then return NAU; + end if; + for I in 0 to RESULT'LEFT loop + if (I_VAL mod 2) = 0 then + RESULT(I) := '0'; + else RESULT(I) := '1'; + end if; + I_VAL := I_VAL/2; + end loop; + if not(I_VAL =0) then + assert NO_WARNING + report "NUMERIC_BIT.TO_UNSIGNED: vector truncated" + severity WARNING; + end if; + return RESULT; + end TO_UNSIGNED; + + -- Id: D.4 + function TO_SIGNED (ARG: INTEGER; + SIZE: NATURAL) return SIGNED is + variable RESULT: SIGNED(SIZE-1 downto 0); + variable B_VAL: BIT := '0'; + variable I_VAL: INTEGER := ARG; + begin + if (SIZE < 1) then return NAS; + end if; + if (ARG < 0) then + B_VAL := '1'; + I_VAL := -(ARG+1); + end if; + for I in 0 to RESULT'LEFT loop + if (I_VAL mod 2) = 0 then + RESULT(I) := B_VAL; + else + RESULT(I) := not B_VAL; + end if; + I_VAL := I_VAL/2; + end loop; + if ((I_VAL/=0) or (B_VAL/=RESULT(RESULT'LEFT))) then + assert NO_WARNING + report "NUMERIC_BIT.TO_SIGNED: vector truncated" + severity WARNING; + end if; + return RESULT; + end TO_SIGNED; + + --============================================================================ + + -- Id: R.1 + function RESIZE (ARG: SIGNED; NEW_SIZE: NATURAL) return SIGNED is + alias INVEC: SIGNED(ARG'LENGTH-1 downto 0) is ARG; + variable RESULT: SIGNED(NEW_SIZE-1 downto 0) := (others => '0'); + constant BOUND: INTEGER := MIN(ARG'LENGTH, RESULT'LENGTH)-2; + begin + if (NEW_SIZE < 1) then return NAS; + end if; + if (ARG'LENGTH = 0) then return RESULT; + end if; + RESULT := (others => ARG(ARG'LEFT)); + if BOUND >= 0 then + RESULT(BOUND downto 0) := INVEC(BOUND downto 0); + end if; + return RESULT; + end RESIZE; + + -- Id: R.2 + function RESIZE (ARG: UNSIGNED; NEW_SIZE: NATURAL) return UNSIGNED is + constant ARG_LEFT: INTEGER := ARG'LENGTH-1; + alias XARG: UNSIGNED(ARG_LEFT downto 0) is ARG; + variable RESULT: UNSIGNED(NEW_SIZE-1 downto 0) := (others => '0'); + begin + if (NEW_SIZE < 1) then return NAU; + end if; + if XARG'LENGTH =0 then return RESULT; + end if; + if (RESULT'LENGTH < ARG'LENGTH) then + RESULT(RESULT'LEFT downto 0) := XARG(RESULT'LEFT downto 0); + else + RESULT(RESULT'LEFT downto XARG'LEFT+1) := (others => '0'); + RESULT(XARG'LEFT downto 0) := XARG; + end if; + return RESULT; + end RESIZE; + + --============================================================================ + + -- Id: L.1 + function "not" (L: UNSIGNED) return UNSIGNED is + variable RESULT: UNSIGNED(L'LENGTH-1 downto 0); + begin + RESULT := UNSIGNED(not(BIT_VECTOR(L))); + return RESULT; + end "not"; + + -- Id: L.2 + function "and" (L, R: UNSIGNED) return UNSIGNED is + variable RESULT: UNSIGNED(L'LENGTH-1 downto 0); + begin + RESULT := UNSIGNED(BIT_VECTOR(L) and BIT_VECTOR(R)); + return RESULT; + end "and"; + + -- Id: L.3 + function "or" (L, R: UNSIGNED) return UNSIGNED is + variable RESULT: UNSIGNED(L'LENGTH-1 downto 0); + begin + RESULT := UNSIGNED(BIT_VECTOR(L) or BIT_VECTOR(R)); + return RESULT; + end "or"; + + -- Id: L.4 + function "nand" (L, R: UNSIGNED) return UNSIGNED is + variable RESULT: UNSIGNED(L'LENGTH-1 downto 0); + begin + RESULT := UNSIGNED(BIT_VECTOR(L) nand BIT_VECTOR(R)); + return RESULT; + end "nand"; + + -- Id: L.5 + function "nor" (L, R: UNSIGNED) return UNSIGNED is + variable RESULT: UNSIGNED(L'LENGTH-1 downto 0); + begin + RESULT := UNSIGNED(BIT_VECTOR(L) nor BIT_VECTOR(R)); + return RESULT; + end "nor"; + + -- Id: L.6 + function "xor" (L, R: UNSIGNED) return UNSIGNED is + variable RESULT: UNSIGNED(L'LENGTH-1 downto 0); + begin + RESULT := UNSIGNED(BIT_VECTOR(L) xor BIT_VECTOR(R)); + return RESULT; + end "xor"; + +--START-V93 + ------------------------------------------------------------------------------ + -- Note : Function L.7 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: L.7 + function "xnor" (L, R: UNSIGNED) return UNSIGNED is + variable RESULT: UNSIGNED(L'LENGTH-1 downto 0); + begin + RESULT := UNSIGNED(BIT_VECTOR(L) xnor BIT_VECTOR(R)); + return RESULT; + end "xnor"; +--END-V93 + + -- Id: L.8 + function "not" (L: SIGNED) return SIGNED is + variable RESULT: SIGNED(L'LENGTH-1 downto 0); + begin + RESULT := SIGNED(not(BIT_VECTOR(L))); + return RESULT; + end "not"; + + -- Id: L.9 + function "and" (L, R: SIGNED) return SIGNED is + variable RESULT: SIGNED(L'LENGTH-1 downto 0); + begin + RESULT := SIGNED(BIT_VECTOR(L) and BIT_VECTOR(R)); + return RESULT; + end "and"; + + -- Id: L.10 + function "or" (L, R: SIGNED) return SIGNED is + variable RESULT: SIGNED(L'LENGTH-1 downto 0); + begin + RESULT := SIGNED(BIT_VECTOR(L) or BIT_VECTOR(R)); + return RESULT; + end "or"; + + -- Id: L.11 + function "nand" (L, R: SIGNED) return SIGNED is + variable RESULT: SIGNED(L'LENGTH-1 downto 0); + begin + RESULT := SIGNED(BIT_VECTOR(L) nand BIT_VECTOR(R)); + return RESULT; + end "nand"; + + -- Id: L.12 + function "nor" (L, R: SIGNED) return SIGNED is + variable RESULT: SIGNED(L'LENGTH-1 downto 0); + begin + RESULT := SIGNED(BIT_VECTOR(L) nor BIT_VECTOR(R)); + return RESULT; + end "nor"; + + -- Id: L.13 + function "xor" (L, R: SIGNED) return SIGNED is + variable RESULT: SIGNED(L'LENGTH-1 downto 0); + begin + RESULT := SIGNED(BIT_VECTOR(L) xor BIT_VECTOR(R)); + return RESULT; + end "xor"; + +--START-V93 + ------------------------------------------------------------------------------ + -- Note : Function L.14 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: L.14 + function "xnor" (L, R: SIGNED) return SIGNED is + variable RESULT: SIGNED(L'LENGTH-1 downto 0); + begin + RESULT := SIGNED(BIT_VECTOR(L) xnor BIT_VECTOR(R)); + return RESULT; + end "xnor"; +--END-V93 + + --============================================================================ + + -- Id: E.1 + function RISING_EDGE (signal S: BIT) return BOOLEAN is + begin + return S'EVENT and S = '1'; + end RISING_EDGE; + + -- Id: E.2 + function FALLING_EDGE (signal S: BIT) return BOOLEAN is + begin + return S'EVENT and S = '0'; + end FALLING_EDGE; + + --============================================================================ +end NUMERIC_BIT; diff --git a/libraries/ieee/numeric_bit.vhdl b/libraries/ieee/numeric_bit.vhdl new file mode 100644 index 000000000..8f049f21a --- /dev/null +++ b/libraries/ieee/numeric_bit.vhdl @@ -0,0 +1,813 @@ +-- ----------------------------------------------------------------------------- +-- +-- Copyright 1995 by IEEE. All rights reserved. +-- +-- This source file is considered by the IEEE to be an essential part of the use +-- of the standard 1076.3 and as such may be distributed without change, except +-- as permitted by the standard. This source file may not be sold or distributed +-- for profit. This package may be modified to include additional data required +-- by tools, but must in no way change the external interfaces or simulation +-- behaviour of the description. It is permissible to add comments and/or +-- attributes to the package declarations, but not to change or delete any +-- original lines of the approved package declaration. The package body may be +-- changed only in accordance with the terms of clauses 7.1 and 7.2 of the +-- standard. +-- +-- Title : Standard VHDL Synthesis Package (1076.3, NUMERIC_BIT) +-- +-- Library : This package shall be compiled into a library symbolically +-- : named IEEE. +-- +-- Developers : IEEE DASC Synthesis Working Group, PAR 1076.3 +-- +-- Purpose : This package defines numeric types and arithmetic functions +-- : for use with synthesis tools. Two numeric types are defined: +-- : -- > UNSIGNED: represents an UNSIGNED number in vector form +-- : -- > SIGNED: represents a SIGNED number in vector form +-- : The base element type is type BIT. +-- : The leftmost bit is treated as the most significant bit. +-- : Signed vectors are represented in two's complement form. +-- : This package contains overloaded arithmetic operators on +-- : the SIGNED and UNSIGNED types. The package also contains +-- : useful type conversions functions, clock detection +-- : functions, and other utility functions. +-- : +-- : If any argument to a function is a null array, a null array is +-- : returned (exceptions, if any, are noted individually). +-- +-- Limitation : +-- +-- Note : No declarations or definitions shall be included in, +-- : or excluded from this package. The "package declaration" +-- : defines the types, subtypes and declarations of +-- : NUMERIC_BIT. The NUMERIC_BIT package body shall be +-- : considered the formal definition of the semantics of +-- : this package. Tool developers may choose to implement +-- : the package body in the most efficient manner available +-- : to them. +-- : +-- ----------------------------------------------------------------------------- +-- Version : 2.4 +-- Date : 12 April 1995 +-- ----------------------------------------------------------------------------- + +package NUMERIC_BIT is + constant CopyRightNotice: STRING + := "Copyright 1995 IEEE. All rights reserved."; + + --============================================================================ + -- Numeric array type definitions + --============================================================================ + + type UNSIGNED is array (NATURAL range <> ) of BIT; + type SIGNED is array (NATURAL range <> ) of BIT; + + --============================================================================ + -- Arithmetic Operators: + --============================================================================ + + -- Id: A.1 + function "abs" (ARG: SIGNED) return SIGNED; + -- Result subtype: SIGNED(ARG'LENGTH-1 downto 0). + -- Result: Returns the absolute value of a SIGNED vector ARG. + + -- Id: A.2 + function "-" (ARG: SIGNED) return SIGNED; + -- Result subtype: SIGNED(ARG'LENGTH-1 downto 0). + -- Result: Returns the value of the unary minus operation on a + -- SIGNED vector ARG. + + --============================================================================ + + -- Id: A.3 + function "+" (L, R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(MAX(L'LENGTH, R'LENGTH)-1 downto 0). + -- Result: Adds two UNSIGNED vectors that may be of different lengths. + + -- Id: A.4 + function "+" (L, R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(MAX(L'LENGTH, R'LENGTH)-1 downto 0). + -- Result: Adds two SIGNED vectors that may be of different lengths. + + -- Id: A.5 + function "+" (L: UNSIGNED; R: NATURAL) return UNSIGNED; + -- Result subtype: UNSIGNED(L'LENGTH-1 downto 0). + -- Result: Adds an UNSIGNED vector, L, with a non-negative INTEGER, R. + + -- Id: A.6 + function "+" (L: NATURAL; R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(R'LENGTH-1 downto 0). + -- Result: Adds a non-negative INTEGER, L, with an UNSIGNED vector, R. + + -- Id: A.7 + function "+" (L: INTEGER; R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(R'LENGTH-1 downto 0). + -- Result: Adds an INTEGER, L(may be positive or negative), to a SIGNED + -- vector, R. + + -- Id: A.8 + function "+" (L: SIGNED; R: INTEGER) return SIGNED; + -- Result subtype: SIGNED(L'LENGTH-1 downto 0). + -- Result: Adds a SIGNED vector, L, to an INTEGER, R. + + --============================================================================ + + -- Id: A.9 + function "-" (L, R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(MAX(L'LENGTH, R'LENGTH)-1 downto 0). + -- Result: Subtracts two UNSIGNED vectors that may be of different lengths. + + -- Id: A.10 + function "-" (L, R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(MAX(L'LENGTH, R'LENGTH)-1 downto 0). + -- Result: Subtracts a SIGNED vector, R, from another SIGNED vector, L, + -- that may possibly be of different lengths. + + -- Id: A.11 + function "-" (L: UNSIGNED; R: NATURAL) return UNSIGNED; + -- Result subtype: UNSIGNED(L'LENGTH-1 downto 0). + -- Result: Subtracts a non-negative INTEGER, R, from an UNSIGNED vector, L. + + -- Id: A.12 + function "-" (L: NATURAL; R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(R'LENGTH-1 downto 0). + -- Result: Subtracts an UNSIGNED vector, R, from a non-negative INTEGER, L. + + -- Id: A.13 + function "-" (L: SIGNED; R: INTEGER) return SIGNED; + -- Result subtype: SIGNED(L'LENGTH-1 downto 0). + -- Result: Subtracts an INTEGER, R, from a SIGNED vector, L. + + -- Id: A.14 + function "-" (L: INTEGER; R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(R'LENGTH-1 downto 0). + -- Result: Subtracts a SIGNED vector, R, from an INTEGER, L. + + --============================================================================ + + -- Id: A.15 + function "*" (L, R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED((L'LENGTH+R'LENGTH-1) downto 0). + -- Result: Performs the multiplication operation on two UNSIGNED vectors + -- that may possibly be of different lengths. + + -- Id: A.16 + function "*" (L, R: SIGNED) return SIGNED; + -- Result subtype: SIGNED((L'LENGTH+R'LENGTH-1) downto 0) + -- Result: Multiplies two SIGNED vectors that may possibly be of + -- different lengths. + + -- Id: A.17 + function "*" (L: UNSIGNED; R: NATURAL) return UNSIGNED; + -- Result subtype: UNSIGNED((L'LENGTH+L'LENGTH-1) downto 0). + -- Result: Multiplies an UNSIGNED vector, L, with a non-negative + -- INTEGER, R. R is converted to an UNSIGNED vector of + -- size L'LENGTH before multiplication. + + -- Id: A.18 + function "*" (L: NATURAL; R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED((R'LENGTH+R'LENGTH-1) downto 0). + -- Result: Multiplies an UNSIGNED vector, R, with a non-negative + -- INTEGER, L. L is converted to an UNSIGNED vector of + -- size R'LENGTH before multiplication. + + -- Id: A.19 + function "*" (L: SIGNED; R: INTEGER) return SIGNED; + -- Result subtype: SIGNED((L'LENGTH+L'LENGTH-1) downto 0) + -- Result: Multiplies a SIGNED vector, L, with an INTEGER, R. R is + -- converted to a SIGNED vector of size L'LENGTH before + -- multiplication. + + -- Id: A.20 + function "*" (L: INTEGER; R: SIGNED) return SIGNED; + -- Result subtype: SIGNED((R'LENGTH+R'LENGTH-1) downto 0) + -- Result: Multiplies a SIGNED vector, R, with an INTEGER, L. L is + -- converted to a SIGNED vector of size R'LENGTH before + -- multiplication. + + --============================================================================ + -- + -- NOTE: If second argument is zero for "/" operator, a severity level + -- of ERROR is issued. + + -- Id: A.21 + function "/" (L, R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(L'LENGTH-1 downto 0) + -- Result: Divides an UNSIGNED vector, L, by another UNSIGNED vector, R. + + -- Id: A.22 + function "/" (L, R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(L'LENGTH-1 downto 0) + -- Result: Divides an SIGNED vector, L, by another SIGNED vector, R. + + -- Id: A.23 + function "/" (L: UNSIGNED; R: NATURAL) return UNSIGNED; + -- Result subtype: UNSIGNED(L'LENGTH-1 downto 0) + -- Result: Divides an UNSIGNED vector, L, by a non-negative INTEGER, R. + -- If NO_OF_BITS(R) > L'LENGTH, result is truncated to L'LENGTH. + + -- Id: A.24 + function "/" (L: NATURAL; R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(R'LENGTH-1 downto 0) + -- Result: Divides a non-negative INTEGER, L, by an UNSIGNED vector, R. + -- If NO_OF_BITS(L) > R'LENGTH, result is truncated to R'LENGTH. + + -- Id: A.25 + function "/" (L: SIGNED; R: INTEGER) return SIGNED; + -- Result subtype: SIGNED(L'LENGTH-1 downto 0) + -- Result: Divides a SIGNED vector, L, by an INTEGER, R. + -- If NO_OF_BITS(R) > L'LENGTH, result is truncated to L'LENGTH. + + -- Id: A.26 + function "/" (L: INTEGER; R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(R'LENGTH-1 downto 0) + -- Result: Divides an INTEGER, L, by a SIGNED vector, R. + -- If NO_OF_BITS(L) > R'LENGTH, result is truncated to R'LENGTH. + + --============================================================================ + -- + -- NOTE: If second argument is zero for "rem" operator, a severity level + -- of ERROR is issued. + + -- Id: A.27 + function "rem" (L, R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(R'LENGTH-1 downto 0) + -- Result: Computes "L rem R" where L and R are UNSIGNED vectors. + + -- Id: A.28 + function "rem" (L, R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(R'LENGTH-1 downto 0) + -- Result: Computes "L rem R" where L and R are SIGNED vectors. + + -- Id: A.29 + function "rem" (L: UNSIGNED; R: NATURAL) return UNSIGNED; + -- Result subtype: UNSIGNED(L'LENGTH-1 downto 0) + -- Result: Computes "L rem R" where L is an UNSIGNED vector and R is a + -- non-negative INTEGER. + -- If NO_OF_BITS(R) > L'LENGTH, result is truncated to L'LENGTH. + + -- Id: A.30 + function "rem" (L: NATURAL; R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(R'LENGTH-1 downto 0) + -- Result: Computes "L rem R" where R is an UNSIGNED vector and L is a + -- non-negative INTEGER. + -- If NO_OF_BITS(L) > R'LENGTH, result is truncated to R'LENGTH. + + -- Id: A.31 + function "rem" (L: SIGNED; R: INTEGER) return SIGNED; + -- Result subtype: SIGNED(L'LENGTH-1 downto 0) + -- Result: Computes "L rem R" where L is SIGNED vector and R is an INTEGER. + -- If NO_OF_BITS(R) > L'LENGTH, result is truncated to L'LENGTH. + + -- Id: A.32 + function "rem" (L: INTEGER; R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(R'LENGTH-1 downto 0) + -- Result: Computes "L rem R" where R is SIGNED vector and L is an INTEGER. + -- If NO_OF_BITS(L) > R'LENGTH, result is truncated to R'LENGTH. + + --============================================================================ + -- + -- NOTE: If second argument is zero for "mod" operator, a severity level + -- of ERROR is issued. + + -- Id: A.33 + function "mod" (L, R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(R'LENGTH-1 downto 0) + -- Result: Computes "L mod R" where L and R are UNSIGNED vectors. + + -- Id: A.34 + function "mod" (L, R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(R'LENGTH-1 downto 0) + -- Result: Computes "L mod R" where L and R are SIGNED vectors. + + -- Id: A.35 + function "mod" (L: UNSIGNED; R: NATURAL) return UNSIGNED; + -- Result subtype: UNSIGNED(L'LENGTH-1 downto 0) + -- Result: Computes "L mod R" where L is an UNSIGNED vector and R + -- is a non-negative INTEGER. + -- If NO_OF_BITS(R) > L'LENGTH, result is truncated to L'LENGTH. + + -- Id: A.36 + function "mod" (L: NATURAL; R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(R'LENGTH-1 downto 0) + -- Result: Computes "L mod R" where R is an UNSIGNED vector and L + -- is a non-negative INTEGER. + -- If NO_OF_BITS(L) > R'LENGTH, result is truncated to R'LENGTH. + + -- Id: A.37 + function "mod" (L: SIGNED; R: INTEGER) return SIGNED; + -- Result subtype: SIGNED(L'LENGTH-1 downto 0) + -- Result: Computes "L mod R" where L is a SIGNED vector and + -- R is an INTEGER. + -- If NO_OF_BITS(R) > L'LENGTH, result is truncated to L'LENGTH. + + -- Id: A.38 + function "mod" (L: INTEGER; R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(R'LENGTH-1 downto 0) + -- Result: Computes "L mod R" where L is an INTEGER and + -- R is a SIGNED vector. + -- If NO_OF_BITS(L) > R'LENGTH, result is truncated to R'LENGTH. + + --============================================================================ + -- Comparison Operators + --============================================================================ + + -- Id: C.1 + function ">" (L, R: UNSIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L > R" where L and R are UNSIGNED vectors possibly + -- of different lengths. + + -- Id: C.2 + function ">" (L, R: SIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L > R" where L and R are SIGNED vectors possibly + -- of different lengths. + + -- Id: C.3 + function ">" (L: NATURAL; R: UNSIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L > R" where L is a non-negative INTEGER and + -- R is an UNSIGNED vector. + + -- Id: C.4 + function ">" (L: INTEGER; R: SIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L > R" where L is a INTEGER and + -- R is a SIGNED vector. + + -- Id: C.5 + function ">" (L: UNSIGNED; R: NATURAL) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L > R" where L is an UNSIGNED vector and + -- R is a non-negative INTEGER. + + -- Id: C.6 + function ">" (L: SIGNED; R: INTEGER) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L > R" where L is a SIGNED vector and + -- R is a INTEGER. + + --============================================================================ + + -- Id: C.7 + function "<" (L, R: UNSIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L < R" where L and R are UNSIGNED vectors possibly + -- of different lengths. + + -- Id: C.8 + function "<" (L, R: SIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L < R" where L and R are SIGNED vectors possibly + -- of different lengths. + + -- Id: C.9 + function "<" (L: NATURAL; R: UNSIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L < R" where L is a non-negative INTEGER and + -- R is an UNSIGNED vector. + + -- Id: C.10 + function "<" (L: INTEGER; R: SIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L < R" where L is an INTEGER and + -- R is a SIGNED vector. + + -- Id: C.11 + function "<" (L: UNSIGNED; R: NATURAL) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L < R" where L is an UNSIGNED vector and + -- R is a non-negative INTEGER. + + -- Id: C.12 + function "<" (L: SIGNED; R: INTEGER) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L < R" where L is a SIGNED vector and + -- R is an INTEGER. + + --============================================================================ + + -- Id: C.13 + function "<=" (L, R: UNSIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L <= R" where L and R are UNSIGNED vectors possibly + -- of different lengths. + + -- Id: C.14 + function "<=" (L, R: SIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L <= R" where L and R are SIGNED vectors possibly + -- of different lengths. + + -- Id: C.15 + function "<=" (L: NATURAL; R: UNSIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L <= R" where L is a non-negative INTEGER and + -- R is an UNSIGNED vector. + + -- Id: C.16 + function "<=" (L: INTEGER; R: SIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L <= R" where L is an INTEGER and + -- R is a SIGNED vector. + + -- Id: C.17 + function "<=" (L: UNSIGNED; R: NATURAL) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L <= R" where L is an UNSIGNED vector and + -- R is a non-negative INTEGER. + + -- Id: C.18 + function "<=" (L: SIGNED; R: INTEGER) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L <= R" where L is a SIGNED vector and + -- R is an INTEGER. + + --============================================================================ + + -- Id: C.19 + function ">=" (L, R: UNSIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L >= R" where L and R are UNSIGNED vectors possibly + -- of different lengths. + + -- Id: C.20 + function ">=" (L, R: SIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L >= R" where L and R are SIGNED vectors possibly + -- of different lengths. + + -- Id: C.21 + function ">=" (L: NATURAL; R: UNSIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L >= R" where L is a non-negative INTEGER and + -- R is an UNSIGNED vector. + + -- Id: C.22 + function ">=" (L: INTEGER; R: SIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L >= R" where L is an INTEGER and + -- R is a SIGNED vector. + + -- Id: C.23 + function ">=" (L: UNSIGNED; R: NATURAL) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L >= R" where L is an UNSIGNED vector and + -- R is a non-negative INTEGER. + + -- Id: C.24 + function ">=" (L: SIGNED; R: INTEGER) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L >= R" where L is a SIGNED vector and + -- R is an INTEGER. + + --============================================================================ + + -- Id: C.25 + function "=" (L, R: UNSIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L = R" where L and R are UNSIGNED vectors possibly + -- of different lengths. + + -- Id: C.26 + function "=" (L, R: SIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L = R" where L and R are SIGNED vectors possibly + -- of different lengths. + + -- Id: C.27 + function "=" (L: NATURAL; R: UNSIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L = R" where L is a non-negative INTEGER and + -- R is an UNSIGNED vector. + + -- Id: C.28 + function "=" (L: INTEGER; R: SIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L = R" where L is an INTEGER and + -- R is a SIGNED vector. + + -- Id: C.29 + function "=" (L: UNSIGNED; R: NATURAL) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L = R" where L is an UNSIGNED vector and + -- R is a non-negative INTEGER. + + -- Id: C.30 + function "=" (L: SIGNED; R: INTEGER) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L = R" where L is a SIGNED vector and + -- R is an INTEGER. + + --============================================================================ + + -- Id: C.31 + function "/=" (L, R: UNSIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L /= R" where L and R are UNSIGNED vectors possibly + -- of different lengths. + + -- Id: C.32 + function "/=" (L, R: SIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L /= R" where L and R are SIGNED vectors possibly + -- of different lengths. + + -- Id: C.33 + function "/=" (L: NATURAL; R: UNSIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L /= R" where L is a non-negative INTEGER and + -- R is an UNSIGNED vector. + + -- Id: C.34 + function "/=" (L: INTEGER; R: SIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L /= R" where L is an INTEGER and + -- R is a SIGNED vector. + + -- Id: C.35 + function "/=" (L: UNSIGNED; R: NATURAL) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L /= R" where L is an UNSIGNED vector and + -- R is a non-negative INTEGER. + + -- Id: C.36 + function "/=" (L: SIGNED; R: INTEGER) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L /= R" where L is a SIGNED vector and + -- R is an INTEGER. + + --============================================================================ + -- Shift and Rotate Functions + --============================================================================ + + -- Id: S.1 + function SHIFT_LEFT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED; + -- Result subtype: UNSIGNED(ARG'LENGTH-1 downto 0) + -- Result: Performs a shift-left on an UNSIGNED vector COUNT times. + -- The vacated positions are filled with Bit '0'. + -- The COUNT leftmost bits are lost. + + -- Id: S.2 + function SHIFT_RIGHT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED; + -- Result subtype: UNSIGNED(ARG'LENGTH-1 downto 0) + -- Result: Performs a shift-right on an UNSIGNED vector COUNT times. + -- The vacated positions are filled with Bit '0'. + -- The COUNT rightmost bits are lost. + + -- Id: S.3 + function SHIFT_LEFT (ARG: SIGNED; COUNT: NATURAL) return SIGNED; + -- Result subtype: SIGNED(ARG'LENGTH-1 downto 0) + -- Result: Performs a shift-left on a SIGNED vector COUNT times. + -- The vacated positions are filled with Bit '0'. + -- The COUNT leftmost bits, except ARG'LEFT, are lost. + + -- Id: S.4 + function SHIFT_RIGHT (ARG: SIGNED; COUNT: NATURAL) return SIGNED; + -- Result subtype: SIGNED(ARG'LENGTH-1 downto 0) + -- Result: Performs a shift-right on a SIGNED vector COUNT times. + -- The vacated positions are filled with the leftmost bit, ARG'LEFT. + -- The COUNT rightmost bits are lost. + + --============================================================================ + + -- Id: S.5 + function ROTATE_LEFT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED; + -- Result subtype: UNSIGNED(ARG'LENGTH-1 downto 0) + -- Result: Performs a rotate-left of an UNSIGNED vector COUNT times. + + -- Id: S.6 + function ROTATE_RIGHT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED; + -- Result subtype: UNSIGNED(ARG'LENGTH-1 downto 0) + -- Result: Performs a rotate-right of an UNSIGNED vector COUNT times. + + -- Id: S.7 + function ROTATE_LEFT (ARG: SIGNED; COUNT: NATURAL) return SIGNED; + -- Result subtype: SIGNED(ARG'LENGTH-1 downto 0) + -- Result: Performs a logical rotate-left of a SIGNED vector COUNT times. + + -- Id: S.8 + function ROTATE_RIGHT (ARG: SIGNED; COUNT: NATURAL) return SIGNED; + -- Result subtype: SIGNED(ARG'LENGTH-1 downto 0) + -- Result: Performs a logical rotate-right of a SIGNED vector COUNT times. + + --============================================================================ + + ------------------------------------------------------------------------------ + -- Note : Function S.9 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.9 + function "sll" (ARG: UNSIGNED; COUNT: INTEGER) return UNSIGNED; --V93 + -- Result subtype: UNSIGNED(ARG'LENGTH-1 downto 0) + -- Result: SHIFT_LEFT(ARG, COUNT) + + ------------------------------------------------------------------------------ + -- Note : Function S.10 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.10 + function "sll" (ARG: SIGNED; COUNT: INTEGER) return SIGNED; --V93 + -- Result subtype: SIGNED(ARG'LENGTH-1 downto 0) + -- Result: SHIFT_LEFT(ARG, COUNT) + + ------------------------------------------------------------------------------ + -- Note : Function S.11 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.11 + function "srl" (ARG: UNSIGNED; COUNT: INTEGER) return UNSIGNED; --V93 + -- Result subtype: UNSIGNED(ARG'LENGTH-1 downto 0) + -- Result: SHIFT_RIGHT(ARG, COUNT) + + ------------------------------------------------------------------------------ + -- Note : Function S.12 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.12 + function "srl" (ARG: SIGNED; COUNT: INTEGER) return SIGNED; --V93 + -- Result subtype: SIGNED(ARG'LENGTH-1 downto 0) + -- Result: SIGNED(SHIFT_RIGHT(UNSIGNED(ARG), COUNT)) + + ------------------------------------------------------------------------------ + -- Note : Function S.13 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.13 + function "rol" (ARG: UNSIGNED; COUNT: INTEGER) return UNSIGNED; --V93 + -- Result subtype: UNSIGNED(ARG'LENGTH-1 downto 0) + -- Result: ROTATE_LEFT(ARG, COUNT) + + ------------------------------------------------------------------------------ + -- Note : Function S.14 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.14 + function "rol" (ARG: SIGNED; COUNT: INTEGER) return SIGNED; --V93 + -- Result subtype: SIGNED(ARG'LENGTH-1 downto 0) + -- Result: ROTATE_LEFT(ARG, COUNT) + + ------------------------------------------------------------------------------ + -- Note : Function S.15 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.15 + function "ror" (ARG: UNSIGNED; COUNT: INTEGER) return UNSIGNED; --V93 + -- Result subtype: UNSIGNED(ARG'LENGTH-1 downto 0) + -- Result: ROTATE_RIGHT(ARG, COUNT) + + ------------------------------------------------------------------------------ + -- Note : Function S.16 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.16 + function "ror" (ARG: SIGNED; COUNT: INTEGER) return SIGNED; --V93 + -- Result subtype: SIGNED(ARG'LENGTH-1 downto 0) + -- Result: ROTATE_RIGHT(ARG, COUNT) + + --============================================================================ + -- RESIZE Functions + --============================================================================ + + -- Id: R.1 + function RESIZE (ARG: SIGNED; NEW_SIZE: NATURAL) return SIGNED; + -- Result subtype: SIGNED(NEW_SIZE-1 downto 0) + -- Result: Resizes the SIGNED vector ARG to the specified size. + -- To create a larger vector, the new [leftmost] bit positions + -- are filled with the sign bit (ARG'LEFT). When truncating, + -- the sign bit is retained along with the rightmost part. + + -- Id: R.2 + function RESIZE (ARG: UNSIGNED; NEW_SIZE: NATURAL) return UNSIGNED; + -- Result subtype: UNSIGNED(NEW_SIZE-1 downto 0) + -- Result: Resizes the UNSIGNED vector ARG to the specified size. + -- To create a larger vector, the new [leftmost] bit positions + -- are filled with '0'. When truncating, the leftmost bits + -- are dropped. + + --============================================================================ + -- Conversion Functions + --============================================================================ + + -- Id: D.1 + function TO_INTEGER (ARG: UNSIGNED) return NATURAL; + -- Result subtype: NATURAL. Value cannot be negative since parameter is an + -- UNSIGNED vector. + -- Result: Converts the UNSIGNED vector to an INTEGER. + + -- Id: D.2 + function TO_INTEGER (ARG: SIGNED) return INTEGER; + -- Result subtype: INTEGER + -- Result: Converts a SIGNED vector to an INTEGER. + + -- Id: D.3 + function TO_UNSIGNED (ARG, SIZE: NATURAL) return UNSIGNED; + -- Result subtype: UNSIGNED(SIZE-1 downto 0) + -- Result: Converts a non-negative INTEGER to an UNSIGNED vector with + -- the specified size. + + -- Id: D.4 + function TO_SIGNED (ARG: INTEGER; SIZE: NATURAL) return SIGNED; + -- Result subtype: SIGNED(SIZE-1 downto 0) + -- Result: Converts an INTEGER to a SIGNED vector of the specified size. + + --============================================================================ + -- Logical Operators + --============================================================================ + + -- Id: L.1 + function "not" (L: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(L'LENGTH-1 downto 0) + -- Result: Termwise inversion + + -- Id: L.2 + function "and" (L, R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(L'LENGTH-1 downto 0) + -- Result: Vector AND operation + + -- Id: L.3 + function "or" (L, R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(L'LENGTH-1 downto 0) + -- Result: Vector OR operation + + -- Id: L.4 + function "nand" (L, R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(L'LENGTH-1 downto 0) + -- Result: Vector NAND operation + + -- Id: L.5 + function "nor" (L, R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(L'LENGTH-1 downto 0) + -- Result: Vector NOR operation + + -- Id: L.6 + function "xor" (L, R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(L'LENGTH-1 downto 0) + -- Result: Vector XOR operation + + ------------------------------------------------------------------------------ + -- Note : Function L.7 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: L.7 + function "xnor" (L, R: UNSIGNED) return UNSIGNED; --V93 + -- Result subtype: UNSIGNED(L'LENGTH-1 downto 0) + -- Result: Vector XNOR operation + + -- Id: L.8 + function "not" (L: SIGNED) return SIGNED; + -- Result subtype: SIGNED(L'LENGTH-1 downto 0) + -- Result: Termwise inversion + + -- Id: L.9 + function "and" (L, R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(L'LENGTH-1 downto 0) + -- Result: Vector AND operation + + -- Id: L.10 + function "or" (L, R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(L'LENGTH-1 downto 0) + -- Result: Vector OR operation + + -- Id: L.11 + function "nand" (L, R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(L'LENGTH-1 downto 0) + -- Result: Vector NAND operation + + -- Id: L.12 + function "nor" (L, R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(L'LENGTH-1 downto 0) + -- Result: Vector NOR operation + + -- Id: L.13 + function "xor" (L, R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(L'LENGTH-1 downto 0) + -- Result: Vector XOR operation + + ------------------------------------------------------------------------------ + -- Note : Function L.14 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: L.14 + function "xnor" (L, R: SIGNED) return SIGNED; --V93 + -- Result subtype: SIGNED(L'LENGTH-1 downto 0) + -- Result: Vector XNOR operation + + --============================================================================ + -- Edge Detection Functions + --============================================================================ + + -- Id: E.1 + function RISING_EDGE (signal S: BIT) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Returns TRUE if an event is detected on signal S and the + -- value changed from a '0' to a '1'. + + -- Id: E.2 + function FALLING_EDGE (signal S: BIT) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Returns TRUE if an event is detected on signal S and the + -- value changed from a '1' to a '0'. + +end NUMERIC_BIT; diff --git a/libraries/ieee/numeric_std-body.vhdl b/libraries/ieee/numeric_std-body.vhdl new file mode 100644 index 000000000..a5d609dc3 --- /dev/null +++ b/libraries/ieee/numeric_std-body.vhdl @@ -0,0 +1,2545 @@ +-- -------------------------------------------------------------------- +-- +-- Copyright 1995 by IEEE. All rights reserved. +-- +-- This source file is considered by the IEEE to be an essential part of the use +-- of the standard 1076.3 and as such may be distributed without change, except +-- as permitted by the standard. This source file may not be sold or distributed +-- for profit. This package may be modified to include additional data required +-- by tools, but must in no way change the external interfaces or simulation +-- behaviour of the description. It is permissible to add comments and/or +-- attributes to the package declarations, but not to change or delete any +-- original lines of the approved package declaration. The package body may be +-- changed only in accordance with the terms of clauses 7.1 and 7.2 of the +-- standard. +-- +-- Title : Standard VHDL Synthesis Package (1076.3, NUMERIC_STD) +-- +-- Library : This package shall be compiled into a library symbolically +-- : named IEEE. +-- +-- Developers : IEEE DASC Synthesis Working Group, PAR 1076.3 +-- +-- Purpose : This package defines numeric types and arithmetic functions +-- : for use with synthesis tools. Two numeric types are defined: +-- : -- > UNSIGNED: represents UNSIGNED number in vector form +-- : -- > SIGNED: represents a SIGNED number in vector form +-- : The base element type is type STD_LOGIC. +-- : The leftmost bit is treated as the most significant bit. +-- : Signed vectors are represented in two's complement form. +-- : This package contains overloaded arithmetic operators on +-- : the SIGNED and UNSIGNED types. The package also contains +-- : useful type conversions functions. +-- : +-- : If any argument to a function is a null array, a null array is +-- : returned (exceptions, if any, are noted individually). +-- +-- Limitation : +-- +-- Note : No declarations or definitions shall be included in, +-- : or excluded from this package. The "package declaration" +-- : defines the types, subtypes and declarations of +-- : NUMERIC_STD. The NUMERIC_STD package body shall be +-- : considered the formal definition of the semantics of +-- : this package. Tool developers may choose to implement +-- : the package body in the most efficient manner available +-- : to them. +-- +-- -------------------------------------------------------------------- +-- modification history : +-- -------------------------------------------------------------------- +-- Version: 2.4 +-- Date : 12 April 1995 +-- ----------------------------------------------------------------------------- + +--============================================================================== +--============================= Package Body =================================== +--============================================================================== + +package body NUMERIC_STD is + + -- null range array constants + + constant NAU: UNSIGNED(0 downto 1) := (others => '0'); + constant NAS: SIGNED(0 downto 1) := (others => '0'); + + -- implementation controls + + constant NO_WARNING: BOOLEAN := FALSE; -- default to emit warnings + + --=========================Local Subprograms ================================= + + function MAX (LEFT, RIGHT: INTEGER) return INTEGER is + begin + if LEFT > RIGHT then return LEFT; + else return RIGHT; + end if; + end MAX; + + function MIN (LEFT, RIGHT: INTEGER) return INTEGER is + begin + if LEFT < RIGHT then return LEFT; + else return RIGHT; + end if; + end MIN; + + function SIGNED_NUM_BITS (ARG: INTEGER) return NATURAL is + variable NBITS: NATURAL; + variable N: NATURAL; + begin + if ARG >= 0 then + N := ARG; + else + N := -(ARG+1); + end if; + NBITS := 1; + while N > 0 loop + NBITS := NBITS+1; + N := N / 2; + end loop; + return NBITS; + end SIGNED_NUM_BITS; + + function UNSIGNED_NUM_BITS (ARG: NATURAL) return NATURAL is + variable NBITS: NATURAL; + variable N: NATURAL; + begin + N := ARG; + NBITS := 1; + while N > 1 loop + NBITS := NBITS+1; + N := N / 2; + end loop; + return NBITS; + end UNSIGNED_NUM_BITS; + + ------------------------------------------------------------------------ + + -- this internal function computes the addition of two UNSIGNED + -- with input CARRY + -- * the two arguments are of the same length + + function ADD_UNSIGNED (L, R: UNSIGNED; C: STD_LOGIC) return UNSIGNED is + constant L_LEFT: INTEGER := L'LENGTH-1; + alias XL: UNSIGNED(L_LEFT downto 0) is L; + alias XR: UNSIGNED(L_LEFT downto 0) is R; + variable RESULT: UNSIGNED(L_LEFT downto 0); + variable CBIT: STD_LOGIC := C; + begin + for I in 0 to L_LEFT loop + RESULT(I) := CBIT xor XL(I) xor XR(I); + CBIT := (CBIT and XL(I)) or (CBIT and XR(I)) or (XL(I) and XR(I)); + end loop; + return RESULT; + end ADD_UNSIGNED; + + -- this internal function computes the addition of two SIGNED + -- with input CARRY + -- * the two arguments are of the same length + + function ADD_SIGNED (L, R: SIGNED; C: STD_LOGIC) return SIGNED is + constant L_LEFT: INTEGER := L'LENGTH-1; + alias XL: SIGNED(L_LEFT downto 0) is L; + alias XR: SIGNED(L_LEFT downto 0) is R; + variable RESULT: SIGNED(L_LEFT downto 0); + variable CBIT: STD_LOGIC := C; + begin + for I in 0 to L_LEFT loop + RESULT(I) := CBIT xor XL(I) xor XR(I); + CBIT := (CBIT and XL(I)) or (CBIT and XR(I)) or (XL(I) and XR(I)); + end loop; + return RESULT; + end ADD_SIGNED; + + ----------------------------------------------------------------------------- + + -- this internal procedure computes UNSIGNED division + -- giving the quotient and remainder. + procedure DIVMOD (NUM, XDENOM: UNSIGNED; XQUOT, XREMAIN: out UNSIGNED) is + variable TEMP: UNSIGNED(NUM'LENGTH downto 0); + variable QUOT: UNSIGNED(MAX(NUM'LENGTH, XDENOM'LENGTH)-1 downto 0); + alias DENOM: UNSIGNED(XDENOM'LENGTH-1 downto 0) is XDENOM; + variable TOPBIT: INTEGER; + begin + TEMP := "0"&NUM; + QUOT := (others => '0'); + TOPBIT := -1; + for J in DENOM'RANGE loop + if DENOM(J)='1' then + TOPBIT := J; + exit; + end if; + end loop; + assert TOPBIT >= 0 report "DIV, MOD, or REM by zero" severity ERROR; + + for J in NUM'LENGTH-(TOPBIT+1) downto 0 loop + if TEMP(TOPBIT+J+1 downto J) >= "0"&DENOM(TOPBIT downto 0) then + TEMP(TOPBIT+J+1 downto J) := (TEMP(TOPBIT+J+1 downto J)) + -("0"&DENOM(TOPBIT downto 0)); + QUOT(J) := '1'; + end if; + assert TEMP(TOPBIT+J+1)='0' + report "internal error in the division algorithm" + severity ERROR; + end loop; + XQUOT := RESIZE(QUOT, XQUOT'LENGTH); + XREMAIN := RESIZE(TEMP, XREMAIN'LENGTH); + end DIVMOD; + + -----------------Local Subprograms - shift/rotate ops------------------------- + + function XSLL (ARG: STD_LOGIC_VECTOR; COUNT: NATURAL) return STD_LOGIC_VECTOR + is + constant ARG_L: INTEGER := ARG'LENGTH-1; + alias XARG: STD_LOGIC_VECTOR(ARG_L downto 0) is ARG; + variable RESULT: STD_LOGIC_VECTOR(ARG_L downto 0) := (others => '0'); + begin + if COUNT <= ARG_L then + RESULT(ARG_L downto COUNT) := XARG(ARG_L-COUNT downto 0); + end if; + return RESULT; + end XSLL; + + function XSRL (ARG: STD_LOGIC_VECTOR; COUNT: NATURAL) return STD_LOGIC_VECTOR + is + constant ARG_L: INTEGER := ARG'LENGTH-1; + alias XARG: STD_LOGIC_VECTOR(ARG_L downto 0) is ARG; + variable RESULT: STD_LOGIC_VECTOR(ARG_L downto 0) := (others => '0'); + begin + if COUNT <= ARG_L then + RESULT(ARG_L-COUNT downto 0) := XARG(ARG_L downto COUNT); + end if; + return RESULT; + end XSRL; + + function XSRA (ARG: STD_LOGIC_VECTOR; COUNT: NATURAL) return STD_LOGIC_VECTOR + is + constant ARG_L: INTEGER := ARG'LENGTH-1; + alias XARG: STD_LOGIC_VECTOR(ARG_L downto 0) is ARG; + variable RESULT: STD_LOGIC_VECTOR(ARG_L downto 0); + variable XCOUNT: NATURAL := COUNT; + begin + if ((ARG'LENGTH <= 1) or (XCOUNT = 0)) then return ARG; + else + if (XCOUNT > ARG_L) then XCOUNT := ARG_L; + end if; + RESULT(ARG_L-XCOUNT downto 0) := XARG(ARG_L downto XCOUNT); + RESULT(ARG_L downto (ARG_L - XCOUNT + 1)) := (others => XARG(ARG_L)); + end if; + return RESULT; + end XSRA; + + function XROL (ARG: STD_LOGIC_VECTOR; COUNT: NATURAL) return STD_LOGIC_VECTOR + is + constant ARG_L: INTEGER := ARG'LENGTH-1; + alias XARG: STD_LOGIC_VECTOR(ARG_L downto 0) is ARG; + variable RESULT: STD_LOGIC_VECTOR(ARG_L downto 0) := XARG; + variable COUNTM: INTEGER; + begin + COUNTM := COUNT mod (ARG_L + 1); + if COUNTM /= 0 then + RESULT(ARG_L downto COUNTM) := XARG(ARG_L-COUNTM downto 0); + RESULT(COUNTM-1 downto 0) := XARG(ARG_L downto ARG_L-COUNTM+1); + end if; + return RESULT; + end XROL; + + function XROR (ARG: STD_LOGIC_VECTOR; COUNT: NATURAL) return STD_LOGIC_VECTOR + is + constant ARG_L: INTEGER := ARG'LENGTH-1; + alias XARG: STD_LOGIC_VECTOR(ARG_L downto 0) is ARG; + variable RESULT: STD_LOGIC_VECTOR(ARG_L downto 0) := XARG; + variable COUNTM: INTEGER; + begin + COUNTM := COUNT mod (ARG_L + 1); + if COUNTM /= 0 then + RESULT(ARG_L-COUNTM downto 0) := XARG(ARG_L downto COUNTM); + RESULT(ARG_L downto ARG_L-COUNTM+1) := XARG(COUNTM-1 downto 0); + end if; + return RESULT; + end XROR; + + -----------------Local Subprograms - Relational ops--------------------------- + + -- + -- General "=" for UNSIGNED vectors, same length + -- + function UNSIGNED_EQUAL (L, R: UNSIGNED) return BOOLEAN is + begin + return STD_LOGIC_VECTOR(L) = STD_LOGIC_VECTOR(R); + end UNSIGNED_EQUAL; + + -- + -- General "=" for SIGNED vectors, same length + -- + function SIGNED_EQUAL (L, R: SIGNED) return BOOLEAN is + begin + return STD_LOGIC_VECTOR(L) = STD_LOGIC_VECTOR(R); + end SIGNED_EQUAL; + + -- + -- General "<" for UNSIGNED vectors, same length + -- + function UNSIGNED_LESS (L, R: UNSIGNED) return BOOLEAN is + begin + return STD_LOGIC_VECTOR(L) < STD_LOGIC_VECTOR(R); + end UNSIGNED_LESS; + + -- + -- General "<" function for SIGNED vectors, same length + -- + function SIGNED_LESS (L, R: SIGNED) return BOOLEAN is + variable INTERN_L: SIGNED(0 to L'LENGTH-1); + variable INTERN_R: SIGNED(0 to R'LENGTH-1); + begin + INTERN_L := L; + INTERN_R := R; + INTERN_L(0) := not INTERN_L(0); + INTERN_R(0) := not INTERN_R(0); + return STD_LOGIC_VECTOR(INTERN_L) < STD_LOGIC_VECTOR(INTERN_R); + end SIGNED_LESS; + + -- + -- General "<=" function for UNSIGNED vectors, same length + -- + function UNSIGNED_LESS_OR_EQUAL (L, R: UNSIGNED) return BOOLEAN is + begin + return STD_LOGIC_VECTOR(L) <= STD_LOGIC_VECTOR(R); + end UNSIGNED_LESS_OR_EQUAL; + + -- + -- General "<=" function for SIGNED vectors, same length + -- + function SIGNED_LESS_OR_EQUAL (L, R: SIGNED) return BOOLEAN is + -- Need aliases to assure index direction + variable INTERN_L: SIGNED(0 to L'LENGTH-1); + variable INTERN_R: SIGNED(0 to R'LENGTH-1); + begin + INTERN_L := L; + INTERN_R := R; + INTERN_L(0) := not INTERN_L(0); + INTERN_R(0) := not INTERN_R(0); + return STD_LOGIC_VECTOR(INTERN_L) <= STD_LOGIC_VECTOR(INTERN_R); + end SIGNED_LESS_OR_EQUAL; + + --=========================Exported Functions ========================== + + -- Id: A.1 + function "abs" (ARG: SIGNED) return SIGNED is + constant ARG_LEFT: INTEGER := ARG'LENGTH-1; + alias XARG: SIGNED(ARG_LEFT downto 0) is ARG; + variable RESULT: SIGNED(ARG_LEFT downto 0); + begin + if ARG'LENGTH < 1 then return NAS; + end if; + RESULT := TO_01(XARG, 'X'); + if (RESULT(RESULT'LEFT)='X') then return RESULT; + end if; + if RESULT(RESULT'LEFT) = '1' then + RESULT := -RESULT; + end if; + return RESULT; + end "abs"; + + -- Id: A.2 + function "-" (ARG: SIGNED) return SIGNED is + constant ARG_LEFT: INTEGER := ARG'LENGTH-1; + alias XARG: SIGNED(ARG_LEFT downto 0) is ARG; + variable RESULT, XARG01 : SIGNED(ARG_LEFT downto 0); + variable CBIT: STD_LOGIC := '1'; + begin + if ARG'LENGTH < 1 then return NAS; + end if; + XARG01 := TO_01(ARG, 'X'); + if (XARG01(XARG01'LEFT)='X') then return XARG01; + end if; + for I in 0 to RESULT'LEFT loop + RESULT(I) := not(XARG01(I)) xor CBIT; + CBIT := CBIT and not(XARG01(I)); + end loop; + return RESULT; + end "-"; + + --============================================================================ + + -- Id: A.3 + function "+" (L, R: UNSIGNED) return UNSIGNED is + constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + variable L01 : UNSIGNED(SIZE-1 downto 0); + variable R01 : UNSIGNED(SIZE-1 downto 0); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAU; + end if; + L01 := TO_01(RESIZE(L, SIZE), 'X'); + if (L01(L01'LEFT)='X') then return L01; + end if; + R01 := TO_01(RESIZE(R, SIZE), 'X'); + if (R01(R01'LEFT)='X') then return R01; + end if; + return ADD_UNSIGNED(L01, R01, '0'); + end "+"; + + -- Id: A.4 + function "+" (L, R: SIGNED) return SIGNED is + constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + variable L01 : SIGNED(SIZE-1 downto 0); + variable R01 : SIGNED(SIZE-1 downto 0); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAS; + end if; + L01 := TO_01(RESIZE(L, SIZE), 'X'); + if (L01(L01'LEFT)='X') then return L01; + end if; + R01 := TO_01(RESIZE(R, SIZE), 'X'); + if (R01(R01'LEFT)='X') then return R01; + end if; + return ADD_SIGNED(L01, R01, '0'); + end "+"; + + -- Id: A.5 + function "+" (L: UNSIGNED; R: NATURAL) return UNSIGNED is + begin + return L + TO_UNSIGNED(R, L'LENGTH); + end "+"; + + -- Id: A.6 + function "+" (L: NATURAL; R: UNSIGNED) return UNSIGNED is + begin + return TO_UNSIGNED(L, R'LENGTH) + R; + end "+"; + + -- Id: A.7 + function "+" (L: SIGNED; R: INTEGER) return SIGNED is + begin + return L + TO_SIGNED(R, L'LENGTH); + end "+"; + + -- Id: A.8 + function "+" (L: INTEGER; R: SIGNED) return SIGNED is + begin + return TO_SIGNED(L, R'LENGTH) + R; + end "+"; + + --============================================================================ + + -- Id: A.9 + function "-" (L, R: UNSIGNED) return UNSIGNED is + constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + variable L01 : UNSIGNED(SIZE-1 downto 0); + variable R01 : UNSIGNED(SIZE-1 downto 0); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAU; + end if; + L01 := TO_01(RESIZE(L, SIZE), 'X'); + if (L01(L01'LEFT)='X') then return L01; + end if; + R01 := TO_01(RESIZE(R, SIZE), 'X'); + if (R01(R01'LEFT)='X') then return R01; + end if; + return ADD_UNSIGNED(L01, not(R01), '1'); + end "-"; + + -- Id: A.10 + function "-" (L, R: SIGNED) return SIGNED is + constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + variable L01 : SIGNED(SIZE-1 downto 0); + variable R01 : SIGNED(SIZE-1 downto 0); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAS; + end if; + L01 := TO_01(RESIZE(L, SIZE), 'X'); + if (L01(L01'LEFT)='X') then return L01; + end if; + R01 := TO_01(RESIZE(R, SIZE), 'X'); + if (R01(R01'LEFT)='X') then return R01; + end if; + return ADD_SIGNED(L01, not(R01), '1'); + end "-"; + + -- Id: A.11 + function "-" (L: UNSIGNED; R: NATURAL) return UNSIGNED is + begin + return L - TO_UNSIGNED(R, L'LENGTH); + end "-"; + + -- Id: A.12 + function "-" (L: NATURAL; R: UNSIGNED) return UNSIGNED is + begin + return TO_UNSIGNED(L, R'LENGTH) - R; + end "-"; + + -- Id: A.13 + function "-" (L: SIGNED; R: INTEGER) return SIGNED is + begin + return L - TO_SIGNED(R, L'LENGTH); + end "-"; + + -- Id: A.14 + function "-" (L: INTEGER; R: SIGNED) return SIGNED is + begin + return TO_SIGNED(L, R'LENGTH) - R; + end "-"; + + --============================================================================ + + -- Id: A.15 + function "*" (L, R: UNSIGNED) return UNSIGNED is + constant L_LEFT: INTEGER := L'LENGTH-1; + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XXL: UNSIGNED(L_LEFT downto 0) is L; + alias XXR: UNSIGNED(R_LEFT downto 0) is R; + variable XL: UNSIGNED(L_LEFT downto 0); + variable XR: UNSIGNED(R_LEFT downto 0); + variable RESULT: UNSIGNED((L'LENGTH+R'LENGTH-1) downto 0) := + (others => '0'); + variable ADVAL: UNSIGNED((L'LENGTH+R'LENGTH-1) downto 0); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAU; + end if; + XL := TO_01(XXL, 'X'); + XR := TO_01(XXR, 'X'); + if ((XL(XL'LEFT)='X') or (XR(XR'LEFT)='X')) then + RESULT := (others => 'X'); + return RESULT; + end if; + ADVAL := RESIZE(XR, RESULT'LENGTH); + for I in 0 to L_LEFT loop + if XL(I)='1' then RESULT := RESULT + ADVAL; + end if; + ADVAL := SHIFT_LEFT(ADVAL, 1); + end loop; + return RESULT; + end "*"; + + -- Id: A.16 + function "*" (L, R: SIGNED) return SIGNED is + constant L_LEFT: INTEGER := L'LENGTH-1; + constant R_LEFT: INTEGER := R'LENGTH-1; + variable XL: SIGNED(L_LEFT downto 0); + variable XR: SIGNED(R_LEFT downto 0); + variable RESULT: SIGNED((L_LEFT+R_LEFT+1) downto 0) := (others => '0'); + variable ADVAL: SIGNED((L_LEFT+R_LEFT+1) downto 0); + begin + if ((L_LEFT < 0) or (R_LEFT < 0)) then return NAS; + end if; + XL := TO_01(L, 'X'); + XR := TO_01(R, 'X'); + if ((XL(L_LEFT)='X') or (XR(R_LEFT)='X')) then + RESULT := (others => 'X'); + return RESULT; + end if; + ADVAL := RESIZE(XR, RESULT'LENGTH); + for I in 0 to L_LEFT-1 loop + if XL(I)='1' then RESULT := RESULT + ADVAL; + end if; + ADVAL := SHIFT_LEFT(ADVAL, 1); + end loop; + if XL(L_LEFT)='1' then + RESULT := RESULT - ADVAL; + end if; + return RESULT; + end "*"; + + -- Id: A.17 + function "*" (L: UNSIGNED; R: NATURAL) return UNSIGNED is + begin + return L * TO_UNSIGNED(R, L'LENGTH); + end "*"; + + -- Id: A.18 + function "*" (L: NATURAL; R: UNSIGNED) return UNSIGNED is + begin + return TO_UNSIGNED(L, R'LENGTH) * R; + end "*"; + + -- Id: A.19 + function "*" (L: SIGNED; R: INTEGER) return SIGNED is + begin + return L * TO_SIGNED(R, L'LENGTH); + end "*"; + + -- Id: A.20 + function "*" (L: INTEGER; R: SIGNED) return SIGNED is + begin + return TO_SIGNED(L, R'LENGTH) * R; + end "*"; + + --============================================================================ + + -- Id: A.21 + function "/" (L, R: UNSIGNED) return UNSIGNED is + constant L_LEFT: INTEGER := L'LENGTH-1; + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XXL: UNSIGNED(L_LEFT downto 0) is L; + alias XXR: UNSIGNED(R_LEFT downto 0) is R; + variable XL: UNSIGNED(L_LEFT downto 0); + variable XR: UNSIGNED(R_LEFT downto 0); + variable FQUOT: UNSIGNED(L'LENGTH-1 downto 0); + variable FREMAIN: UNSIGNED(R'LENGTH-1 downto 0); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAU; + end if; + XL := TO_01(XXL, 'X'); + XR := TO_01(XXR, 'X'); + if ((XL(XL'LEFT)='X') or (XR(XR'LEFT)='X')) then + FQUOT := (others => 'X'); + return FQUOT; + end if; + DIVMOD(XL, XR, FQUOT, FREMAIN); + return FQUOT; + end "/"; + + -- Id: A.22 + function "/" (L, R: SIGNED) return SIGNED is + constant L_LEFT: INTEGER := L'LENGTH-1; + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XXL: SIGNED(L_LEFT downto 0) is L; + alias XXR: SIGNED(R_LEFT downto 0) is R; + variable XL: SIGNED(L_LEFT downto 0); + variable XR: SIGNED(R_LEFT downto 0); + variable FQUOT: UNSIGNED(L'LENGTH-1 downto 0); + variable FREMAIN: UNSIGNED(R'LENGTH-1 downto 0); + variable XNUM: UNSIGNED(L'LENGTH-1 downto 0); + variable XDENOM: UNSIGNED(R'LENGTH-1 downto 0); + variable QNEG: BOOLEAN := FALSE; + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAS; + end if; + XL := TO_01(XXL, 'X'); + XR := TO_01(XXR, 'X'); + if ((XL(XL'LEFT)='X') or (XR(XR'LEFT)='X')) then + FQUOT := (others => 'X'); + return SIGNED(FQUOT); + end if; + if XL(XL'LEFT)='1' then + XNUM := UNSIGNED(-XL); + QNEG := TRUE; + else + XNUM := UNSIGNED(XL); + end if; + if XR(XR'LEFT)='1' then + XDENOM := UNSIGNED(-XR); + QNEG := not QNEG; + else + XDENOM := UNSIGNED(XR); + end if; + DIVMOD(XNUM, XDENOM, FQUOT, FREMAIN); + if QNEG then FQUOT := "0"-FQUOT; + end if; + return SIGNED(FQUOT); + end "/"; + + -- Id: A.23 + function "/" (L: UNSIGNED; R: NATURAL) return UNSIGNED is + constant R_LENGTH: NATURAL := MAX(L'LENGTH, UNSIGNED_NUM_BITS(R)); + variable XR, QUOT: UNSIGNED(R_LENGTH-1 downto 0); + begin + if (L'LENGTH < 1) then return NAU; + end if; + if (R_LENGTH > L'LENGTH) then + QUOT := (others => '0'); + return RESIZE(QUOT, L'LENGTH); + end if; + XR := TO_UNSIGNED(R, R_LENGTH); + QUOT := RESIZE((L / XR), QUOT'LENGTH); + return RESIZE(QUOT, L'LENGTH); + end "/"; + + -- Id: A.24 + function "/" (L: NATURAL; R: UNSIGNED) return UNSIGNED is + constant L_LENGTH: NATURAL := MAX(UNSIGNED_NUM_BITS(L), R'LENGTH); + variable XL, QUOT: UNSIGNED(L_LENGTH-1 downto 0); + begin + if (R'LENGTH < 1) then return NAU; + end if; + XL := TO_UNSIGNED(L, L_LENGTH); + QUOT := RESIZE((XL / R), QUOT'LENGTH); + if L_LENGTH > R'LENGTH and QUOT(0)/='X' + and QUOT(L_LENGTH-1 downto R'LENGTH) + /= (L_LENGTH-1 downto R'LENGTH => '0') + then + assert NO_WARNING report "NUMERIC_STD.""/"": Quotient Truncated" + severity WARNING; + end if; + return RESIZE(QUOT, R'LENGTH); + end "/"; + + -- Id: A.25 + function "/" (L: SIGNED; R: INTEGER) return SIGNED is + constant R_LENGTH: NATURAL := MAX(L'LENGTH, SIGNED_NUM_BITS(R)); + variable XR, QUOT: SIGNED(R_LENGTH-1 downto 0); + begin + if (L'LENGTH < 1) then return NAS; + end if; + if (R_LENGTH > L'LENGTH) then + QUOT := (others => '0'); + return RESIZE(QUOT, L'LENGTH); + end if; + XR := TO_SIGNED(R, R_LENGTH); + QUOT := RESIZE((L / XR), QUOT'LENGTH); + return RESIZE(QUOT, L'LENGTH); + end "/"; + + -- Id: A.26 + function "/" (L: INTEGER; R: SIGNED) return SIGNED is + constant L_LENGTH: NATURAL := MAX(SIGNED_NUM_BITS(L), R'LENGTH); + variable XL, QUOT: SIGNED(L_LENGTH-1 downto 0); + begin + if (R'LENGTH < 1) then return NAS; + end if; + XL := TO_SIGNED(L, L_LENGTH); + QUOT := RESIZE((XL / R), QUOT'LENGTH); + if L_LENGTH > R'LENGTH and QUOT(0)/='X' + and QUOT(L_LENGTH-1 downto R'LENGTH) + /= (L_LENGTH-1 downto R'LENGTH => QUOT(R'LENGTH-1)) + then + assert NO_WARNING report "NUMERIC_STD.""/"": Quotient Truncated" + severity WARNING; + end if; + return RESIZE(QUOT, R'LENGTH); + end "/"; + + --============================================================================ + + -- Id: A.27 + function "rem" (L, R: UNSIGNED) return UNSIGNED is + constant L_LEFT: INTEGER := L'LENGTH-1; + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XXL: UNSIGNED(L_LEFT downto 0) is L; + alias XXR: UNSIGNED(R_LEFT downto 0) is R; + variable XL: UNSIGNED(L_LEFT downto 0); + variable XR: UNSIGNED(R_LEFT downto 0); + variable FQUOT: UNSIGNED(L'LENGTH-1 downto 0); + variable FREMAIN: UNSIGNED(R'LENGTH-1 downto 0); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAU; + end if; + XL := TO_01(XXL, 'X'); + XR := TO_01(XXR, 'X'); + if ((XL(XL'LEFT)='X') or (XR(XR'LEFT)='X')) then + FREMAIN := (others => 'X'); + return FREMAIN; + end if; + DIVMOD(XL, XR, FQUOT, FREMAIN); + return FREMAIN; + end "rem"; + + -- Id: A.28 + function "rem" (L, R: SIGNED) return SIGNED is + constant L_LEFT: INTEGER := L'LENGTH-1; + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XXL: SIGNED(L_LEFT downto 0) is L; + alias XXR: SIGNED(R_LEFT downto 0) is R; + variable FQUOT: UNSIGNED(L'LENGTH-1 downto 0); + variable FREMAIN: UNSIGNED(R'LENGTH-1 downto 0); + variable XNUM: UNSIGNED(L'LENGTH-1 downto 0); + variable XDENOM: UNSIGNED(R'LENGTH-1 downto 0); + variable RNEG: BOOLEAN := FALSE; + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAS; + end if; + XNUM := UNSIGNED(TO_01(XXL, 'X')); + XDENOM := UNSIGNED(TO_01(XXR, 'X')); + if ((XNUM(XNUM'LEFT)='X') or (XDENOM(XDENOM'LEFT)='X')) then + FREMAIN := (others => 'X'); + return SIGNED(FREMAIN); + end if; + if XNUM(XNUM'LEFT)='1' then + XNUM := UNSIGNED(-SIGNED(XNUM)); + RNEG := TRUE; + else + XNUM := UNSIGNED(XNUM); + end if; + if XDENOM(XDENOM'LEFT)='1' then + XDENOM := UNSIGNED(-SIGNED(XDENOM)); + else + XDENOM := UNSIGNED(XDENOM); + end if; + DIVMOD(XNUM, XDENOM, FQUOT, FREMAIN); + if RNEG then + FREMAIN := "0"-FREMAIN; + end if; + return SIGNED(FREMAIN); + end "rem"; + + -- Id: A.29 + function "rem" (L: UNSIGNED; R: NATURAL) return UNSIGNED is + constant R_LENGTH: NATURAL := MAX(L'LENGTH, UNSIGNED_NUM_BITS(R)); + variable XR, XREM: UNSIGNED(R_LENGTH-1 downto 0); + begin + if (L'LENGTH < 1) then return NAU; + end if; + XR := TO_UNSIGNED(R, R_LENGTH); + XREM := L rem XR; + if R_LENGTH > L'LENGTH and XREM(0)/='X' + and XREM(R_LENGTH-1 downto L'LENGTH) + /= (R_LENGTH-1 downto L'LENGTH => '0') + then + assert NO_WARNING report "NUMERIC_STD.""rem"": Remainder Truncated" + severity WARNING; + end if; + return RESIZE(XREM, L'LENGTH); + end "rem"; + + -- Id: A.30 + function "rem" (L: NATURAL; R: UNSIGNED) return UNSIGNED is + constant L_LENGTH: NATURAL := MAX(UNSIGNED_NUM_BITS(L), R'LENGTH); + variable XL, XREM: UNSIGNED(L_LENGTH-1 downto 0); + begin + XL := TO_UNSIGNED(L, L_LENGTH); + XREM := XL rem R; + if L_LENGTH > R'LENGTH and XREM(0)/='X' + and XREM(L_LENGTH-1 downto R'LENGTH) + /= (L_LENGTH-1 downto R'LENGTH => '0') + then + assert NO_WARNING report "NUMERIC_STD.""rem"": Remainder Truncated" + severity WARNING; + end if; + return RESIZE(XREM, R'LENGTH); + end "rem"; + + -- Id: A.31 + function "rem" (L: SIGNED; R: INTEGER) return SIGNED is + constant R_LENGTH: NATURAL := MAX(L'LENGTH, SIGNED_NUM_BITS(R)); + variable XR, XREM: SIGNED(R_LENGTH-1 downto 0); + begin + if (L'LENGTH < 1) then return NAS; + end if; + XR := TO_SIGNED(R, R_LENGTH); + XREM := RESIZE((L rem XR), XREM'LENGTH); + if R_LENGTH > L'LENGTH and XREM(0)/='X' + and XREM(R_LENGTH-1 downto L'LENGTH) + /= (R_LENGTH-1 downto L'LENGTH => XREM(L'LENGTH-1)) + then + assert NO_WARNING report "NUMERIC_STD.""rem"": Remainder Truncated" + severity WARNING; + end if; + return RESIZE(XREM, L'LENGTH); + end "rem"; + + -- Id: A.32 + function "rem" (L: INTEGER; R: SIGNED) return SIGNED is + constant L_LENGTH: NATURAL := MAX(SIGNED_NUM_BITS(L), R'LENGTH); + variable XL, XREM: SIGNED(L_LENGTH-1 downto 0); + begin + if (R'LENGTH < 1) then return NAS; + end if; + XL := TO_SIGNED(L, L_LENGTH); + XREM := RESIZE((XL rem R), XREM'LENGTH); + if L_LENGTH > R'LENGTH and XREM(0)/='X' + and XREM(L_LENGTH-1 downto R'LENGTH) + /= (L_LENGTH-1 downto R'LENGTH => XREM(R'LENGTH-1)) + then + assert NO_WARNING report "NUMERIC_STD.""rem"": Remainder Truncated" + severity WARNING; + end if; + return RESIZE(XREM, R'LENGTH); + end "rem"; + + --============================================================================ + + -- Id: A.33 + function "mod" (L, R: UNSIGNED) return UNSIGNED is + constant L_LEFT: INTEGER := L'LENGTH-1; + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XXL: UNSIGNED(L_LEFT downto 0) is L; + alias XXR: UNSIGNED(R_LEFT downto 0) is R; + variable XL: UNSIGNED(L_LEFT downto 0); + variable XR: UNSIGNED(R_LEFT downto 0); + variable FQUOT: UNSIGNED(L'LENGTH-1 downto 0); + variable FREMAIN: UNSIGNED(R'LENGTH-1 downto 0); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAU; + end if; + XL := TO_01(XXL, 'X'); + XR := TO_01(XXR, 'X'); + if ((XL(XL'LEFT)='X') or (XR(XR'LEFT)='X')) then + FREMAIN := (others => 'X'); + return FREMAIN; + end if; + DIVMOD(XL, XR, FQUOT, FREMAIN); + return FREMAIN; + end "mod"; + + -- Id: A.34 + function "mod" (L, R: SIGNED) return SIGNED is + constant L_LEFT: INTEGER := L'LENGTH-1; + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XXL: SIGNED(L_LEFT downto 0) is L; + alias XXR: SIGNED(R_LEFT downto 0) is R; + variable XL: SIGNED(L_LEFT downto 0); + variable XR: SIGNED(R_LEFT downto 0); + variable FQUOT: UNSIGNED(L'LENGTH-1 downto 0); + variable FREMAIN: UNSIGNED(R'LENGTH-1 downto 0); + variable XNUM: UNSIGNED(L'LENGTH-1 downto 0); + variable XDENOM: UNSIGNED(R'LENGTH-1 downto 0); + variable RNEG: BOOLEAN := FALSE; + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAS; + end if; + XL := TO_01(XXL, 'X'); + XR := TO_01(XXR, 'X'); + if ((XL(XL'LEFT)='X') or (XR(XR'LEFT)='X')) then + FREMAIN := (others => 'X'); + return SIGNED(FREMAIN); + end if; + if XL(XL'LEFT)='1' then + XNUM := UNSIGNED(-XL); + else + XNUM := UNSIGNED(XL); + end if; + if XR(XR'LEFT)='1' then + XDENOM := UNSIGNED(-XR); + RNEG := TRUE; + else + XDENOM := UNSIGNED(XR); + end if; + DIVMOD(XNUM, XDENOM, FQUOT, FREMAIN); + if RNEG and L(L'LEFT)='1' then + FREMAIN := "0"-FREMAIN; + elsif RNEG and FREMAIN/="0" then + FREMAIN := FREMAIN-XDENOM; + elsif L(L'LEFT)='1' and FREMAIN/="0" then + FREMAIN := XDENOM-FREMAIN; + end if; + return SIGNED(FREMAIN); + end "mod"; + + -- Id: A.35 + function "mod" (L: UNSIGNED; R: NATURAL) return UNSIGNED is + constant R_LENGTH: NATURAL := MAX(L'LENGTH, UNSIGNED_NUM_BITS(R)); + variable XR, XREM: UNSIGNED(R_LENGTH-1 downto 0); + begin + if (L'LENGTH < 1) then return NAU; + end if; + XR := TO_UNSIGNED(R, R_LENGTH); + XREM := RESIZE((L mod XR), XREM'LENGTH); + if R_LENGTH > L'LENGTH and XREM(0)/='X' + and XREM(R_LENGTH-1 downto L'LENGTH) + /= (R_LENGTH-1 downto L'LENGTH => '0') + then + assert NO_WARNING report "NUMERIC_STD.""mod"": Modulus Truncated" + severity WARNING; + end if; + return RESIZE(XREM, L'LENGTH); + end "mod"; + + -- Id: A.36 + function "mod" (L: NATURAL; R: UNSIGNED) return UNSIGNED is + constant L_LENGTH: NATURAL := MAX(UNSIGNED_NUM_BITS(L), R'LENGTH); + variable XL, XREM: UNSIGNED(L_LENGTH-1 downto 0); + begin + if (R'LENGTH < 1) then return NAU; + end if; + XL := TO_UNSIGNED(L, L_LENGTH); + XREM := RESIZE((XL mod R), XREM'LENGTH); + if L_LENGTH > R'LENGTH and XREM(0)/='X' + and XREM(L_LENGTH-1 downto R'LENGTH) + /= (L_LENGTH-1 downto R'LENGTH => '0') + then + assert NO_WARNING report "NUMERIC_STD.""mod"": Modulus Truncated" + severity WARNING; + end if; + return RESIZE(XREM, R'LENGTH); + end "mod"; + + -- Id: A.37 + function "mod" (L: SIGNED; R: INTEGER) return SIGNED is + constant R_LENGTH: NATURAL := MAX(L'LENGTH, SIGNED_NUM_BITS(R)); + variable XR, XREM: SIGNED(R_LENGTH-1 downto 0); + begin + if (L'LENGTH < 1) then return NAS; + end if; + XR := TO_SIGNED(R, R_LENGTH); + XREM := RESIZE((L mod XR), XREM'LENGTH); + if R_LENGTH > L'LENGTH and XREM(0)/='X' + and XREM(R_LENGTH-1 downto L'LENGTH) + /= (R_LENGTH-1 downto L'LENGTH => XREM(L'LENGTH-1)) + then + assert NO_WARNING report "NUMERIC_STD.""mod"": Modulus Truncated" + severity WARNING; + end if; + return RESIZE(XREM, L'LENGTH); + end "mod"; + + -- Id: A.38 + function "mod" (L: INTEGER; R: SIGNED) return SIGNED is + constant L_LENGTH: NATURAL := MAX(SIGNED_NUM_BITS(L), R'LENGTH); + variable XL, XREM: SIGNED(L_LENGTH-1 downto 0); + begin + if (R'LENGTH < 1) then return NAS; + end if; + XL := TO_SIGNED(L, L_LENGTH); + XREM := RESIZE((XL mod R), XREM'LENGTH); + if L_LENGTH > R'LENGTH and XREM(0)/='X' + and XREM(L_LENGTH-1 downto R'LENGTH) + /= (L_LENGTH-1 downto R'LENGTH => XREM(R'LENGTH-1)) + then + assert NO_WARNING report "NUMERIC_STD.""mod"": Modulus Truncated" + severity WARNING; + end if; + return RESIZE(XREM, R'LENGTH); + end "mod"; + + --============================================================================ + + -- Id: C.1 + function ">" (L, R: UNSIGNED) return BOOLEAN is + constant L_LEFT: INTEGER := L'LENGTH-1; + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XL: UNSIGNED(L_LEFT downto 0) is L; + alias XR: UNSIGNED(R_LEFT downto 0) is R; + constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + variable L01 : UNSIGNED(L_LEFT downto 0); + variable R01 : UNSIGNED(R_LEFT downto 0); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then + assert NO_WARNING + report "NUMERIC_STD."">"": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + L01 := TO_01(XL, 'X'); + R01 := TO_01(XR, 'X'); + if ((L01(L01'LEFT)='X') or (R01(R01'LEFT)='X')) then + assert NO_WARNING + report "NUMERIC_STD."">"": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + return not UNSIGNED_LESS_OR_EQUAL(RESIZE(L01, SIZE), RESIZE(R01, SIZE)); + end ">"; + + -- Id: C.2 + function ">" (L, R: SIGNED) return BOOLEAN is + constant L_LEFT: INTEGER := L'LENGTH-1; + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XL: SIGNED(L_LEFT downto 0) is L; + alias XR: SIGNED(R_LEFT downto 0) is R; + constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + variable L01 : SIGNED(L_LEFT downto 0); + variable R01 : SIGNED(R_LEFT downto 0); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then + assert NO_WARNING + report "NUMERIC_STD."">"": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + L01 := TO_01(XL, 'X'); + R01 := TO_01(XR, 'X'); + if ((L01(L01'LEFT)='X') or (R01(R01'LEFT)='X')) then + assert NO_WARNING + report "NUMERIC_STD."">"": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + return not SIGNED_LESS_OR_EQUAL(RESIZE(L01, SIZE), RESIZE(R01, SIZE)); + end ">"; + + -- Id: C.3 + function ">" (L: NATURAL; R: UNSIGNED) return BOOLEAN is + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XR: UNSIGNED(R_LEFT downto 0) is R; + variable R01 : UNSIGNED(R_LEFT downto 0); + begin + if (R'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_STD."">"": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + R01 := TO_01(XR, 'X'); + if (R01(R01'LEFT)='X') then + assert NO_WARNING + report "NUMERIC_STD."">"": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if UNSIGNED_NUM_BITS(L) > R'LENGTH then return TRUE; + end if; + return not UNSIGNED_LESS_OR_EQUAL(TO_UNSIGNED(L, R01'LENGTH), R01); + end ">"; + + -- Id: C.4 + function ">" (L: INTEGER; R: SIGNED) return BOOLEAN is + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XR: SIGNED(R_LEFT downto 0) is R; + variable R01 : SIGNED(R_LEFT downto 0); + begin + if (R'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_STD."">"": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + R01 := TO_01(XR, 'X'); + if (R01(R01'LEFT)='X') then + assert NO_WARNING + report "NUMERIC_STD."">"": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if SIGNED_NUM_BITS(L) > R'LENGTH then return L > 0; + end if; + return not SIGNED_LESS_OR_EQUAL(TO_SIGNED(L, R01'LENGTH), R01); + end ">"; + + -- Id: C.5 + function ">" (L: UNSIGNED; R: NATURAL) return BOOLEAN is + constant L_LEFT: INTEGER := L'LENGTH-1; + alias XL: UNSIGNED(L_LEFT downto 0) is L; + variable L01 : UNSIGNED(L_LEFT downto 0); + begin + if (L'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_STD."">"": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + L01 := TO_01(XL, 'X'); + if (L01(L01'LEFT)='X') then + assert NO_WARNING + report "NUMERIC_STD."">"": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if UNSIGNED_NUM_BITS(R) > L'LENGTH then return FALSE; + end if; + return not UNSIGNED_LESS_OR_EQUAL(L01, TO_UNSIGNED(R, L01'LENGTH)); + end ">"; + + -- Id: C.6 + function ">" (L: SIGNED; R: INTEGER) return BOOLEAN is + constant L_LEFT: INTEGER := L'LENGTH-1; + alias XL: SIGNED(L_LEFT downto 0) is L; + variable L01 : SIGNED(L_LEFT downto 0); + begin + if (L'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_STD."">"": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + L01 := TO_01(XL, 'X'); + if (L01(L01'LEFT)='X') then + assert NO_WARNING + report "NUMERIC_STD."">"": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if SIGNED_NUM_BITS(R) > L'LENGTH then return 0 > R; + end if; + return not SIGNED_LESS_OR_EQUAL(L01, TO_SIGNED(R, L01'LENGTH)); + end ">"; + + --============================================================================ + + -- Id: C.7 + function "<" (L, R: UNSIGNED) return BOOLEAN is + constant L_LEFT: INTEGER := L'LENGTH-1; + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XL: UNSIGNED(L_LEFT downto 0) is L; + alias XR: UNSIGNED(R_LEFT downto 0) is R; + constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + variable L01 : UNSIGNED(L_LEFT downto 0); + variable R01 : UNSIGNED(R_LEFT downto 0); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then + assert NO_WARNING + report "NUMERIC_STD.""<"": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + L01 := TO_01(XL, 'X'); + R01 := TO_01(XR, 'X'); + if ((L01(L01'LEFT)='X') or (R01(R01'LEFT)='X')) then + assert NO_WARNING + report "NUMERIC_STD.""<"": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + return UNSIGNED_LESS(RESIZE(L01, SIZE), RESIZE(R01, SIZE)); + end "<"; + + -- Id: C.8 + function "<" (L, R: SIGNED) return BOOLEAN is + constant L_LEFT: INTEGER := L'LENGTH-1; + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XL: SIGNED(L_LEFT downto 0) is L; + alias XR: SIGNED(R_LEFT downto 0) is R; + constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + variable L01 : SIGNED(L_LEFT downto 0); + variable R01 : SIGNED(R_LEFT downto 0); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then + assert NO_WARNING + report "NUMERIC_STD.""<"": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + L01 := TO_01(XL, 'X'); + R01 := TO_01(XR, 'X'); + if ((L01(L01'LEFT)='X') or (R01(R01'LEFT)='X')) then + assert NO_WARNING + report "NUMERIC_STD.""<"": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + return SIGNED_LESS(RESIZE(L01, SIZE), RESIZE(R01, SIZE)); + end "<"; + + -- Id: C.9 + function "<" (L: NATURAL; R: UNSIGNED) return BOOLEAN is + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XR: UNSIGNED(R_LEFT downto 0) is R; + variable R01 : UNSIGNED(R_LEFT downto 0); + begin + if (R'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_STD.""<"": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + R01 := TO_01(XR, 'X'); + if (R01(R01'LEFT)='X') then + assert NO_WARNING + report "NUMERIC_STD.""<"": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if UNSIGNED_NUM_BITS(L) > R'LENGTH then return L < 0; + end if; + return UNSIGNED_LESS(TO_UNSIGNED(L, R01'LENGTH), R01); + end "<"; + + -- Id: C.10 + function "<" (L: INTEGER; R: SIGNED) return BOOLEAN is + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XR: SIGNED(R_LEFT downto 0) is R; + variable R01 : SIGNED(R_LEFT downto 0); + begin + if (R'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_STD.""<"": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + R01 := TO_01(XR, 'X'); + if (R01(R01'LEFT)='X') then + assert NO_WARNING + report "NUMERIC_STD.""<"": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if SIGNED_NUM_BITS(L) > R'LENGTH then return L < 0; + end if; + return SIGNED_LESS(TO_SIGNED(L, R01'LENGTH), R01); + end "<"; + + -- Id: C.11 + function "<" (L: UNSIGNED; R: NATURAL) return BOOLEAN is + constant L_LEFT: INTEGER := L'LENGTH-1; + alias XL: UNSIGNED(L_LEFT downto 0) is L; + variable L01 : UNSIGNED(L_LEFT downto 0); + begin + if (L'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_STD.""<"": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + L01 := TO_01(XL, 'X'); + if (L01(L01'LEFT)='X') then + assert NO_WARNING + report "NUMERIC_STD.""<"": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if UNSIGNED_NUM_BITS(R) > L'LENGTH then return 0 < R; + end if; + return UNSIGNED_LESS(L01, TO_UNSIGNED(R, L01'LENGTH)); + end "<"; + + -- Id: C.12 + function "<" (L: SIGNED; R: INTEGER) return BOOLEAN is + constant L_LEFT: INTEGER := L'LENGTH-1; + alias XL: SIGNED(L_LEFT downto 0) is L; + variable L01 : SIGNED(L_LEFT downto 0); + begin + if (L'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_STD.""<"": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + L01 := TO_01(XL, 'X'); + if (L01(L01'LEFT)='X') then + assert NO_WARNING + report "NUMERIC_STD.""<"": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if SIGNED_NUM_BITS(R) > L'LENGTH then return 0 < R; + end if; + return SIGNED_LESS(L01, TO_SIGNED(R, L01'LENGTH)); + end "<"; + + --============================================================================ + + -- Id: C.13 + function "<=" (L, R: UNSIGNED) return BOOLEAN is + constant L_LEFT: INTEGER := L'LENGTH-1; + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XL: UNSIGNED(L_LEFT downto 0) is L; + alias XR: UNSIGNED(R_LEFT downto 0) is R; + constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + variable L01 : UNSIGNED(L_LEFT downto 0); + variable R01 : UNSIGNED(R_LEFT downto 0); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then + assert NO_WARNING + report "NUMERIC_STD.""<="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + L01 := TO_01(XL, 'X'); + R01 := TO_01(XR, 'X'); + if ((L01(L01'LEFT)='X') or (R01(R01'LEFT)='X')) then + assert NO_WARNING + report "NUMERIC_STD.""<="": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + return UNSIGNED_LESS_OR_EQUAL(RESIZE(L01, SIZE), RESIZE(R01, SIZE)); + end "<="; + + -- Id: C.14 + function "<=" (L, R: SIGNED) return BOOLEAN is + constant L_LEFT: INTEGER := L'LENGTH-1; + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XL: SIGNED(L_LEFT downto 0) is L; + alias XR: SIGNED(R_LEFT downto 0) is R; + constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + variable L01 : SIGNED(L_LEFT downto 0); + variable R01 : SIGNED(R_LEFT downto 0); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then + assert NO_WARNING + report "NUMERIC_STD.""<="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + L01 := TO_01(XL, 'X'); + R01 := TO_01(XR, 'X'); + if ((L01(L01'LEFT)='X') or (R01(R01'LEFT)='X')) then + assert NO_WARNING + report "NUMERIC_STD.""<="": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + return SIGNED_LESS_OR_EQUAL(RESIZE(L01, SIZE), RESIZE(R01, SIZE)); + end "<="; + + -- Id: C.15 + function "<=" (L: NATURAL; R: UNSIGNED) return BOOLEAN is + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XR: UNSIGNED(R_LEFT downto 0) is R; + variable R01 : UNSIGNED(R_LEFT downto 0); + begin + if (R'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_STD.""<="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + R01 := TO_01(XR, 'X'); + if (R01(R01'LEFT)='X') then + assert NO_WARNING + report "NUMERIC_STD.""<="": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if UNSIGNED_NUM_BITS(L) > R'LENGTH then return L < 0; + end if; + return UNSIGNED_LESS_OR_EQUAL(TO_UNSIGNED(L, R01'LENGTH), R01); + end "<="; + + -- Id: C.16 + function "<=" (L: INTEGER; R: SIGNED) return BOOLEAN is + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XR: SIGNED(R_LEFT downto 0) is R; + variable R01 : SIGNED(R_LEFT downto 0); + begin + if (R'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_STD.""<="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + R01 := TO_01(XR, 'X'); + if (R01(R01'LEFT)='X') then + assert NO_WARNING + report "NUMERIC_STD.""<="": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if SIGNED_NUM_BITS(L) > R'LENGTH then return L < 0; + end if; + return SIGNED_LESS_OR_EQUAL(TO_SIGNED(L, R01'LENGTH), R01); + end "<="; + + -- Id: C.17 + function "<=" (L: UNSIGNED; R: NATURAL) return BOOLEAN is + constant L_LEFT: INTEGER := L'LENGTH-1; + alias XL: UNSIGNED(L_LEFT downto 0) is L; + variable L01 : UNSIGNED(L_LEFT downto 0); + begin + if (L_LEFT < 0) then + assert NO_WARNING + report "NUMERIC_STD.""<="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + L01 := TO_01(XL, 'X'); + if (L01(L01'LEFT)='X') then + assert NO_WARNING + report "NUMERIC_STD.""<="": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if UNSIGNED_NUM_BITS(R) > L'LENGTH then return 0 < R; + end if; + return UNSIGNED_LESS_OR_EQUAL(L01, TO_UNSIGNED(R, L01'LENGTH)); + end "<="; + + -- Id: C.18 + function "<=" (L: SIGNED; R: INTEGER) return BOOLEAN is + constant L_LEFT: INTEGER := L'LENGTH-1; + alias XL: SIGNED(L_LEFT downto 0) is L; + variable L01 : SIGNED(L_LEFT downto 0); + begin + if (L_LEFT < 0) then + assert NO_WARNING + report "NUMERIC_STD.""<="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + L01 := TO_01(XL, 'X'); + if (L01(L01'LEFT)='X') then + assert NO_WARNING + report "NUMERIC_STD.""<="": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if SIGNED_NUM_BITS(R) > L'LENGTH then return 0 < R; + end if; + return SIGNED_LESS_OR_EQUAL(L01, TO_SIGNED(R, L01'LENGTH)); + end "<="; + + --============================================================================ + + -- Id: C.19 + function ">=" (L, R: UNSIGNED) return BOOLEAN is + constant L_LEFT: INTEGER := L'LENGTH-1; + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XL: UNSIGNED(L_LEFT downto 0) is L; + alias XR: UNSIGNED(R_LEFT downto 0) is R; + constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + variable L01 : UNSIGNED(L_LEFT downto 0); + variable R01 : UNSIGNED(R_LEFT downto 0); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then + assert NO_WARNING + report "NUMERIC_STD."">="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + L01 := TO_01(XL, 'X'); + R01 := TO_01(XR, 'X'); + if ((L01(L01'LEFT)='X') or (R01(R01'LEFT)='X')) then + assert NO_WARNING + report "NUMERIC_STD."">="": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + return not UNSIGNED_LESS(RESIZE(L01, SIZE), RESIZE(R01, SIZE)); + end ">="; + + -- Id: C.20 + function ">=" (L, R: SIGNED) return BOOLEAN is + constant L_LEFT: INTEGER := L'LENGTH-1; + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XL: SIGNED(L_LEFT downto 0) is L; + alias XR: SIGNED(R_LEFT downto 0) is R; + constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + variable L01 : SIGNED(L_LEFT downto 0); + variable R01 : SIGNED(R_LEFT downto 0); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then + assert NO_WARNING + report "NUMERIC_STD."">="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + L01 := TO_01(XL, 'X'); + R01 := TO_01(XR, 'X'); + if ((L01(L01'LEFT)='X') or (R01(R01'LEFT)='X')) then + assert NO_WARNING + report "NUMERIC_STD."">="": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + return not SIGNED_LESS(RESIZE(L01, SIZE), RESIZE(R01, SIZE)); + end ">="; + + -- Id: C.21 + function ">=" (L: NATURAL; R: UNSIGNED) return BOOLEAN is + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XR: UNSIGNED(R_LEFT downto 0) is R; + variable R01 : UNSIGNED(R_LEFT downto 0); + begin + if (R'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_STD."">="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + R01 := TO_01(XR, 'X'); + if (R01(R01'LEFT)='X') then + assert NO_WARNING + report "NUMERIC_STD."">="": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if UNSIGNED_NUM_BITS(L) > R'LENGTH then return L > 0; + end if; + return not UNSIGNED_LESS(TO_UNSIGNED(L, R01'LENGTH), R01); + end ">="; + + -- Id: C.22 + function ">=" (L: INTEGER; R: SIGNED) return BOOLEAN is + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XR: SIGNED(R_LEFT downto 0) is R; + variable R01 : SIGNED(R_LEFT downto 0); + begin + if (R'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_STD."">="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + R01 := TO_01(XR, 'X'); + if (R01(R01'LEFT)='X') then + assert NO_WARNING + report "NUMERIC_STD."">="": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if SIGNED_NUM_BITS(L) > R'LENGTH then return L > 0; + end if; + return not SIGNED_LESS(TO_SIGNED(L, R01'LENGTH), R01); + end ">="; + + -- Id: C.23 + function ">=" (L: UNSIGNED; R: NATURAL) return BOOLEAN is + constant L_LEFT: INTEGER := L'LENGTH-1; + alias XL: UNSIGNED(L_LEFT downto 0) is L; + variable L01 : UNSIGNED(L_LEFT downto 0); + begin + if (L'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_STD."">="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + L01 := TO_01(XL, 'X'); + if (L01(L01'LEFT)='X') then + assert NO_WARNING + report "NUMERIC_STD."">="": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if UNSIGNED_NUM_BITS(R) > L'LENGTH then return 0 > R; + end if; + return not UNSIGNED_LESS(L01, TO_UNSIGNED(R, L01'LENGTH)); + end ">="; + + -- Id: C.24 + function ">=" (L: SIGNED; R: INTEGER) return BOOLEAN is + constant L_LEFT: INTEGER := L'LENGTH-1; + alias XL: SIGNED(L_LEFT downto 0) is L; + variable L01 : SIGNED(L_LEFT downto 0); + begin + if (L'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_STD."">="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + L01 := TO_01(XL, 'X'); + if (L01(L01'LEFT)='X') then + assert NO_WARNING + report "NUMERIC_STD."">="": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if SIGNED_NUM_BITS(R) > L'LENGTH then return 0 > R; + end if; + return not SIGNED_LESS(L01, TO_SIGNED(R, L01'LENGTH)); + end ">="; + + --============================================================================ + + -- Id: C.25 + function "=" (L, R: UNSIGNED) return BOOLEAN is + constant L_LEFT: INTEGER := L'LENGTH-1; + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XL: UNSIGNED(L_LEFT downto 0) is L; + alias XR: UNSIGNED(R_LEFT downto 0) is R; + constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + variable L01 : UNSIGNED(L_LEFT downto 0); + variable R01 : UNSIGNED(R_LEFT downto 0); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then + assert NO_WARNING + report "NUMERIC_STD.""="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + L01 := TO_01(XL, 'X'); + R01 := TO_01(XR, 'X'); + if ((L01(L01'LEFT)='X') or (R01(R01'LEFT)='X')) then + assert NO_WARNING + report "NUMERIC_STD.""="": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + return UNSIGNED_EQUAL(RESIZE(L01, SIZE), RESIZE(R01, SIZE)); + end "="; + + -- Id: C.26 + function "=" (L, R: SIGNED) return BOOLEAN is + constant L_LEFT: INTEGER := L'LENGTH-1; + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XL: SIGNED(L_LEFT downto 0) is L; + alias XR: SIGNED(R_LEFT downto 0) is R; + constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + variable L01 : SIGNED(L_LEFT downto 0); + variable R01 : SIGNED(R_LEFT downto 0); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then + assert NO_WARNING + report "NUMERIC_STD.""="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + L01 := TO_01(XL, 'X'); + R01 := TO_01(XR, 'X'); + if ((L01(L01'LEFT)='X') or (R01(R01'LEFT)='X')) then + assert NO_WARNING + report "NUMERIC_STD.""="": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + return SIGNED_EQUAL(RESIZE(L01, SIZE), RESIZE(R01, SIZE)); + end "="; + + -- Id: C.27 + function "=" (L: NATURAL; R: UNSIGNED) return BOOLEAN is + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XR: UNSIGNED(R_LEFT downto 0) is R; + variable R01 : UNSIGNED(R_LEFT downto 0); + begin + if (R'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_STD.""="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + R01 := TO_01(XR, 'X'); + if (R01(R01'LEFT)='X') then + assert NO_WARNING + report "NUMERIC_STD.""="": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if UNSIGNED_NUM_BITS(L) > R'LENGTH then return FALSE; + end if; + return UNSIGNED_EQUAL(TO_UNSIGNED(L, R01'LENGTH), R01); + end "="; + + -- Id: C.28 + function "=" (L: INTEGER; R: SIGNED) return BOOLEAN is + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XR: SIGNED(R_LEFT downto 0) is R; + variable R01 : SIGNED(R_LEFT downto 0); + begin + if (R'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_STD.""="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + R01 := TO_01(XR, 'X'); + if (R01(R01'LEFT)='X') then + assert NO_WARNING + report "NUMERIC_STD.""="": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if SIGNED_NUM_BITS(L) > R'LENGTH then return FALSE; + end if; + return SIGNED_EQUAL(TO_SIGNED(L, R01'LENGTH), R01); + end "="; + + -- Id: C.29 + function "=" (L: UNSIGNED; R: NATURAL) return BOOLEAN is + constant L_LEFT: INTEGER := L'LENGTH-1; + alias XL: UNSIGNED(L_LEFT downto 0) is L; + variable L01 : UNSIGNED(L_LEFT downto 0); + begin + if (L'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_STD.""="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + L01 := TO_01(XL, 'X'); + if (L01(L01'LEFT)='X') then + assert NO_WARNING + report "NUMERIC_STD.""="": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if UNSIGNED_NUM_BITS(R) > L'LENGTH then return FALSE; + end if; + return UNSIGNED_EQUAL(L01, TO_UNSIGNED(R, L01'LENGTH)); + end "="; + + -- Id: C.30 + function "=" (L: SIGNED; R: INTEGER) return BOOLEAN is + constant L_LEFT: INTEGER := L'LENGTH-1; + alias XL: SIGNED(L_LEFT downto 0) is L; + variable L01 : SIGNED(L_LEFT downto 0); + begin + if (L'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_STD.""="": null argument detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + L01 := TO_01(XL, 'X'); + if (L01(L01'LEFT)='X') then + assert NO_WARNING + report "NUMERIC_STD.""="": metavalue detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if SIGNED_NUM_BITS(R) > L'LENGTH then return FALSE; + end if; + return SIGNED_EQUAL(L01, TO_SIGNED(R, L01'LENGTH)); + end "="; + + --============================================================================ + + -- Id: C.31 + function "/=" (L, R: UNSIGNED) return BOOLEAN is + constant L_LEFT: INTEGER := L'LENGTH-1; + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XL: UNSIGNED(L_LEFT downto 0) is L; + alias XR: UNSIGNED(R_LEFT downto 0) is R; + constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + variable L01 : UNSIGNED(L_LEFT downto 0); + variable R01 : UNSIGNED(R_LEFT downto 0); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then + assert NO_WARNING + report "NUMERIC_STD.""/="": null argument detected, returning TRUE" + severity WARNING; + return TRUE; + end if; + L01 := TO_01(XL, 'X'); + R01 := TO_01(XR, 'X'); + if ((L01(L01'LEFT)='X') or (R01(R01'LEFT)='X')) then + assert NO_WARNING + report "NUMERIC_STD.""/="": metavalue detected, returning TRUE" + severity WARNING; + return TRUE; + end if; + return not(UNSIGNED_EQUAL(RESIZE(L01, SIZE), RESIZE(R01, SIZE))); + end "/="; + + -- Id: C.32 + function "/=" (L, R: SIGNED) return BOOLEAN is + constant L_LEFT: INTEGER := L'LENGTH-1; + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XL: SIGNED(L_LEFT downto 0) is L; + alias XR: SIGNED(R_LEFT downto 0) is R; + constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH); + variable L01 : SIGNED(L_LEFT downto 0); + variable R01 : SIGNED(R_LEFT downto 0); + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then + assert NO_WARNING + report "NUMERIC_STD.""/="": null argument detected, returning TRUE" + severity WARNING; + return TRUE; + end if; + L01 := TO_01(XL, 'X'); + R01 := TO_01(XR, 'X'); + if ((L01(L01'LEFT)='X') or (R01(R01'LEFT)='X')) then + assert NO_WARNING + report "NUMERIC_STD.""/="": metavalue detected, returning TRUE" + severity WARNING; + return TRUE; + end if; + return not(SIGNED_EQUAL(RESIZE(L01, SIZE), RESIZE(R01, SIZE))); + end "/="; + + -- Id: C.33 + function "/=" (L: NATURAL; R: UNSIGNED) return BOOLEAN is + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XR: UNSIGNED(R_LEFT downto 0) is R; + variable R01 : UNSIGNED(R_LEFT downto 0); + begin + if (R'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_STD.""/="": null argument detected, returning TRUE" + severity WARNING; + return TRUE; + end if; + R01 := TO_01(XR, 'X'); + if (R01(R01'LEFT)='X') then + assert NO_WARNING + report "NUMERIC_STD.""/="": metavalue detected, returning TRUE" + severity WARNING; + return TRUE; + end if; + if UNSIGNED_NUM_BITS(L) > R'LENGTH then return TRUE; + end if; + return not(UNSIGNED_EQUAL(TO_UNSIGNED(L, R01'LENGTH), R01)); + end "/="; + + -- Id: C.34 + function "/=" (L: INTEGER; R: SIGNED) return BOOLEAN is + constant R_LEFT: INTEGER := R'LENGTH-1; + alias XR: SIGNED(R_LEFT downto 0) is R; + variable R01 : SIGNED(R_LEFT downto 0); + begin + if (R'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_STD.""/="": null argument detected, returning TRUE" + severity WARNING; + return TRUE; + end if; + R01 := TO_01(XR, 'X'); + if (R01(R01'LEFT)='X') then + assert NO_WARNING + report "NUMERIC_STD.""/="": metavalue detected, returning TRUE" + severity WARNING; + return TRUE; + end if; + if SIGNED_NUM_BITS(L) > R'LENGTH then return TRUE; + end if; + return not(SIGNED_EQUAL(TO_SIGNED(L, R01'LENGTH), R01)); + end "/="; + + -- Id: C.35 + function "/=" (L: UNSIGNED; R: NATURAL) return BOOLEAN is + constant L_LEFT: INTEGER := L'LENGTH-1; + alias XL: UNSIGNED(L_LEFT downto 0) is L; + variable L01 : UNSIGNED(L_LEFT downto 0); + begin + if (L'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_STD.""/="": null argument detected, returning TRUE" + severity WARNING; + return TRUE; + end if; + L01 := TO_01(XL, 'X'); + if (L01(L01'LEFT)='X') then + assert NO_WARNING + report "NUMERIC_STD.""/="": metavalue detected, returning TRUE" + severity WARNING; + return TRUE; + end if; + if UNSIGNED_NUM_BITS(R) > L'LENGTH then return TRUE; + end if; + return not(UNSIGNED_EQUAL(L01, TO_UNSIGNED(R, L01'LENGTH))); + end "/="; + + -- Id: C.36 + function "/=" (L: SIGNED; R: INTEGER) return BOOLEAN is + constant L_LEFT: INTEGER := L'LENGTH-1; + alias XL: SIGNED(L_LEFT downto 0) is L; + variable L01 : SIGNED(L_LEFT downto 0); + begin + if (L'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_STD.""/="": null argument detected, returning TRUE" + severity WARNING; + return TRUE; + end if; + L01 := TO_01(XL, 'X'); + if (L01(L01'LEFT)='X') then + assert NO_WARNING + report "NUMERIC_STD.""/="": metavalue detected, returning TRUE" + severity WARNING; + return TRUE; + end if; + if SIGNED_NUM_BITS(R) > L'LENGTH then return TRUE; + end if; + return not(SIGNED_EQUAL(L01, TO_SIGNED(R, L01'LENGTH))); + end "/="; + + --============================================================================ + + -- Id: S.1 + function SHIFT_LEFT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED is + begin + if (ARG'LENGTH < 1) then return NAU; + end if; + return UNSIGNED(XSLL(STD_LOGIC_VECTOR(ARG), COUNT)); + end SHIFT_LEFT; + + -- Id: S.2 + function SHIFT_RIGHT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED is + begin + if (ARG'LENGTH < 1) then return NAU; + end if; + return UNSIGNED(XSRL(STD_LOGIC_VECTOR(ARG), COUNT)); + end SHIFT_RIGHT; + + -- Id: S.3 + function SHIFT_LEFT (ARG: SIGNED; COUNT: NATURAL) return SIGNED is + begin + if (ARG'LENGTH < 1) then return NAS; + end if; + return SIGNED(XSLL(STD_LOGIC_VECTOR(ARG), COUNT)); + end SHIFT_LEFT; + + -- Id: S.4 + function SHIFT_RIGHT (ARG: SIGNED; COUNT: NATURAL) return SIGNED is + begin + if (ARG'LENGTH < 1) then return NAS; + end if; + return SIGNED(XSRA(STD_LOGIC_VECTOR(ARG), COUNT)); + end SHIFT_RIGHT; + + --============================================================================ + + -- Id: S.5 + function ROTATE_LEFT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED is + begin + if (ARG'LENGTH < 1) then return NAU; + end if; + return UNSIGNED(XROL(STD_LOGIC_VECTOR(ARG), COUNT)); + end ROTATE_LEFT; + + -- Id: S.6 + function ROTATE_RIGHT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED is + begin + if (ARG'LENGTH < 1) then return NAU; + end if; + return UNSIGNED(XROR(STD_LOGIC_VECTOR(ARG), COUNT)); + end ROTATE_RIGHT; + + + -- Id: S.7 + function ROTATE_LEFT (ARG: SIGNED; COUNT: NATURAL) return SIGNED is + begin + if (ARG'LENGTH < 1) then return NAS; + end if; + return SIGNED(XROL(STD_LOGIC_VECTOR(ARG), COUNT)); + end ROTATE_LEFT; + + -- Id: S.8 + function ROTATE_RIGHT (ARG: SIGNED; COUNT: NATURAL) return SIGNED is + begin + if (ARG'LENGTH < 1) then return NAS; + end if; + return SIGNED(XROR(STD_LOGIC_VECTOR(ARG), COUNT)); + end ROTATE_RIGHT; + + --============================================================================ +--START-V93 + + ------------------------------------------------------------------------------ + -- Note : Function S.9 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.9 + function "sll" (ARG: UNSIGNED; COUNT: INTEGER) return UNSIGNED is + begin + if (COUNT >= 0) then + return SHIFT_LEFT(ARG, COUNT); + else + return SHIFT_RIGHT(ARG, -COUNT); + end if; + end "sll"; + + ------------------------------------------------------------------------------ + -- Note : Function S.10 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.10 + function "sll" (ARG: SIGNED; COUNT: INTEGER) return SIGNED is + begin + if (COUNT >= 0) then + return SHIFT_LEFT(ARG, COUNT); + else + return SIGNED(SHIFT_RIGHT(UNSIGNED(ARG), -COUNT)); + end if; + end "sll"; + + ------------------------------------------------------------------------------ + -- Note : Function S.11 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.11 + function "srl" (ARG: UNSIGNED; COUNT: INTEGER) return UNSIGNED is + begin + if (COUNT >= 0) then + return SHIFT_RIGHT(ARG, COUNT); + else + return SHIFT_LEFT(ARG, -COUNT); + end if; + end "srl"; + + ------------------------------------------------------------------------------ + -- Note : Function S.12 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.12 + function "srl" (ARG: SIGNED; COUNT: INTEGER) return SIGNED is + begin + if (COUNT >= 0) then + return SIGNED(SHIFT_RIGHT(UNSIGNED(ARG), COUNT)); + else + return SHIFT_LEFT(ARG, -COUNT); + end if; + end "srl"; + + ------------------------------------------------------------------------------ + -- Note : Function S.13 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.13 + function "rol" (ARG: UNSIGNED; COUNT: INTEGER) return UNSIGNED is + begin + if (COUNT >= 0) then + return ROTATE_LEFT(ARG, COUNT); + else + return ROTATE_RIGHT(ARG, -COUNT); + end if; + end "rol"; + + ------------------------------------------------------------------------------ + -- Note : Function S.14 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.14 + function "rol" (ARG: SIGNED; COUNT: INTEGER) return SIGNED is + begin + if (COUNT >= 0) then + return ROTATE_LEFT(ARG, COUNT); + else + return ROTATE_RIGHT(ARG, -COUNT); + end if; + end "rol"; + + ------------------------------------------------------------------------------ + -- Note : Function S.15 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.15 + function "ror" (ARG: UNSIGNED; COUNT: INTEGER) return UNSIGNED is + begin + if (COUNT >= 0) then + return ROTATE_RIGHT(ARG, COUNT); + else + return ROTATE_LEFT(ARG, -COUNT); + end if; + end "ror"; + + ------------------------------------------------------------------------------ + -- Note : Function S.16 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.16 + function "ror" (ARG: SIGNED; COUNT: INTEGER) return SIGNED is + begin + if (COUNT >= 0) then + return ROTATE_RIGHT(ARG, COUNT); + else + return ROTATE_LEFT(ARG, -COUNT); + end if; + end "ror"; + +--END-V93 + --============================================================================ + + -- Id: D.1 + function TO_INTEGER (ARG: UNSIGNED) return NATURAL is + constant ARG_LEFT: INTEGER := ARG'LENGTH-1; + alias XXARG: UNSIGNED(ARG_LEFT downto 0) is ARG; + variable XARG: UNSIGNED(ARG_LEFT downto 0); + variable RESULT: NATURAL := 0; + begin + if (ARG'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_STD.TO_INTEGER: null detected, returning 0" + severity WARNING; + return 0; + end if; + XARG := TO_01(XXARG, 'X'); + if (XARG(XARG'LEFT)='X') then + assert NO_WARNING + report "NUMERIC_STD.TO_INTEGER: metavalue detected, returning 0" + severity WARNING; + return 0; + end if; + for I in XARG'RANGE loop + RESULT := RESULT+RESULT; + if XARG(I) = '1' then + RESULT := RESULT + 1; + end if; + end loop; + return RESULT; + end TO_INTEGER; + + -- Id: D.2 + function TO_INTEGER (ARG: SIGNED) return INTEGER is + variable XARG: SIGNED(ARG'LENGTH-1 downto 0); + begin + if (ARG'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_STD.TO_INTEGER: null detected, returning 0" + severity WARNING; + return 0; + end if; + XARG := TO_01(ARG, 'X'); + if (XARG(XARG'LEFT)='X') then + assert NO_WARNING + report "NUMERIC_STD.TO_INTEGER: metavalue detected, returning 0" + severity WARNING; + return 0; + end if; + if XARG(XARG'LEFT) = '0' then + return TO_INTEGER(UNSIGNED(XARG)); + else + return (- (TO_INTEGER(UNSIGNED(- (XARG + 1)))) -1); + end if; + end TO_INTEGER; + + -- Id: D.3 + function TO_UNSIGNED (ARG, SIZE: NATURAL) return UNSIGNED is + variable RESULT: UNSIGNED(SIZE-1 downto 0); + variable I_VAL: NATURAL := ARG; + begin + if (SIZE < 1) then return NAU; + end if; + for I in 0 to RESULT'LEFT loop + if (I_VAL mod 2) = 0 then + RESULT(I) := '0'; + else RESULT(I) := '1'; + end if; + I_VAL := I_VAL/2; + end loop; + if not(I_VAL =0) then + assert NO_WARNING + report "NUMERIC_STD.TO_UNSIGNED: vector truncated" + severity WARNING; + end if; + return RESULT; + end TO_UNSIGNED; + + -- Id: D.4 + function TO_SIGNED (ARG: INTEGER; SIZE: NATURAL) return SIGNED is + variable RESULT: SIGNED(SIZE-1 downto 0); + variable B_VAL: STD_LOGIC := '0'; + variable I_VAL: INTEGER := ARG; + begin + if (SIZE < 1) then return NAS; + end if; + if (ARG < 0) then + B_VAL := '1'; + I_VAL := -(ARG+1); + end if; + for I in 0 to RESULT'LEFT loop + if (I_VAL mod 2) = 0 then + RESULT(I) := B_VAL; + else + RESULT(I) := not B_VAL; + end if; + I_VAL := I_VAL/2; + end loop; + if ((I_VAL/=0) or (B_VAL/=RESULT(RESULT'LEFT))) then + assert NO_WARNING + report "NUMERIC_STD.TO_SIGNED: vector truncated" + severity WARNING; + end if; + return RESULT; + end TO_SIGNED; + + --============================================================================ + + -- Id: R.1 + function RESIZE (ARG: SIGNED; NEW_SIZE: NATURAL) return SIGNED is + alias INVEC: SIGNED(ARG'LENGTH-1 downto 0) is ARG; + variable RESULT: SIGNED(NEW_SIZE-1 downto 0) := (others => '0'); + constant BOUND: INTEGER := MIN(ARG'LENGTH, RESULT'LENGTH)-2; + begin + if (NEW_SIZE < 1) then return NAS; + end if; + if (ARG'LENGTH = 0) then return RESULT; + end if; + RESULT := (others => ARG(ARG'LEFT)); + if BOUND >= 0 then + RESULT(BOUND downto 0) := INVEC(BOUND downto 0); + end if; + return RESULT; + end RESIZE; + + -- Id: R.2 + function RESIZE (ARG: UNSIGNED; NEW_SIZE: NATURAL) return UNSIGNED is + constant ARG_LEFT: INTEGER := ARG'LENGTH-1; + alias XARG: UNSIGNED(ARG_LEFT downto 0) is ARG; + variable RESULT: UNSIGNED(NEW_SIZE-1 downto 0) := (others => '0'); + begin + if (NEW_SIZE < 1) then return NAU; + end if; + if XARG'LENGTH =0 then return RESULT; + end if; + if (RESULT'LENGTH < ARG'LENGTH) then + RESULT(RESULT'LEFT downto 0) := XARG(RESULT'LEFT downto 0); + else + RESULT(RESULT'LEFT downto XARG'LEFT+1) := (others => '0'); + RESULT(XARG'LEFT downto 0) := XARG; + end if; + return RESULT; + end RESIZE; + + --============================================================================ + + -- Id: L.1 + function "not" (L: UNSIGNED) return UNSIGNED is + variable RESULT: UNSIGNED(L'LENGTH-1 downto 0); + begin + RESULT := UNSIGNED(not(STD_LOGIC_VECTOR(L))); + return RESULT; + end "not"; + + -- Id: L.2 + function "and" (L, R: UNSIGNED) return UNSIGNED is + variable RESULT: UNSIGNED(L'LENGTH-1 downto 0); + begin + RESULT := UNSIGNED(STD_LOGIC_VECTOR(L) and STD_LOGIC_VECTOR(R)); + return RESULT; + end "and"; + + -- Id: L.3 + function "or" (L, R: UNSIGNED) return UNSIGNED is + variable RESULT: UNSIGNED(L'LENGTH-1 downto 0); + begin + RESULT := UNSIGNED(STD_LOGIC_VECTOR(L) or STD_LOGIC_VECTOR(R)); + return RESULT; + end "or"; + + -- Id: L.4 + function "nand" (L, R: UNSIGNED) return UNSIGNED is + variable RESULT: UNSIGNED(L'LENGTH-1 downto 0); + begin + RESULT := UNSIGNED(STD_LOGIC_VECTOR(L) nand STD_LOGIC_VECTOR(R)); + return RESULT; + end "nand"; + + -- Id: L.5 + function "nor" (L, R: UNSIGNED) return UNSIGNED is + variable RESULT: UNSIGNED(L'LENGTH-1 downto 0); + begin + RESULT := UNSIGNED(STD_LOGIC_VECTOR(L) nor STD_LOGIC_VECTOR(R)); + return RESULT; + end "nor"; + + -- Id: L.6 + function "xor" (L, R: UNSIGNED) return UNSIGNED is + variable RESULT: UNSIGNED(L'LENGTH-1 downto 0); + begin + RESULT := UNSIGNED(STD_LOGIC_VECTOR(L) xor STD_LOGIC_VECTOR(R)); + return RESULT; + end "xor"; + +--START-V93 + ------------------------------------------------------------------------------ + -- Note : Function L.7 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: L.7 + function "xnor" (L, R: UNSIGNED) return UNSIGNED is + variable RESULT: UNSIGNED(L'LENGTH-1 downto 0); + begin + RESULT := UNSIGNED(STD_LOGIC_VECTOR(L) xnor STD_LOGIC_VECTOR(R)); + return RESULT; + end "xnor"; +--END-V93 + + -- Id: L.8 + function "not" (L: SIGNED) return SIGNED is + variable RESULT: SIGNED(L'LENGTH-1 downto 0); + begin + RESULT := SIGNED(not(STD_LOGIC_VECTOR(L))); + return RESULT; + end "not"; + + -- Id: L.9 + function "and" (L, R: SIGNED) return SIGNED is + variable RESULT: SIGNED(L'LENGTH-1 downto 0); + begin + RESULT := SIGNED(STD_LOGIC_VECTOR(L) and STD_LOGIC_VECTOR(R)); + return RESULT; + end "and"; + + -- Id: L.10 + function "or" (L, R: SIGNED) return SIGNED is + variable RESULT: SIGNED(L'LENGTH-1 downto 0); + begin + RESULT := SIGNED(STD_LOGIC_VECTOR(L) or STD_LOGIC_VECTOR(R)); + return RESULT; + end "or"; + + -- Id: L.11 + function "nand" (L, R: SIGNED) return SIGNED is + variable RESULT: SIGNED(L'LENGTH-1 downto 0); + begin + RESULT := SIGNED(STD_LOGIC_VECTOR(L) nand STD_LOGIC_VECTOR(R)); + return RESULT; + end "nand"; + + -- Id: L.12 + function "nor" (L, R: SIGNED) return SIGNED is + variable RESULT: SIGNED(L'LENGTH-1 downto 0); + begin + RESULT := SIGNED(STD_LOGIC_VECTOR(L) nor STD_LOGIC_VECTOR(R)); + return RESULT; + end "nor"; + + -- Id: L.13 + function "xor" (L, R: SIGNED) return SIGNED is + variable RESULT: SIGNED(L'LENGTH-1 downto 0); + begin + RESULT := SIGNED(STD_LOGIC_VECTOR(L) xor STD_LOGIC_VECTOR(R)); + return RESULT; + end "xor"; + +--START-V93 + ------------------------------------------------------------------------------ + -- Note : Function L.14 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: L.14 + function "xnor" (L, R: SIGNED) return SIGNED is + variable RESULT: SIGNED(L'LENGTH-1 downto 0); + begin + RESULT := SIGNED(STD_LOGIC_VECTOR(L) xnor STD_LOGIC_VECTOR(R)); + return RESULT; + end "xnor"; +--END-V93 + + --============================================================================ + + -- support constants for STD_MATCH: + + type BOOLEAN_TABLE is array(STD_ULOGIC, STD_ULOGIC) of BOOLEAN; + + constant MATCH_TABLE: BOOLEAN_TABLE := ( + -------------------------------------------------------------------------- + -- U X 0 1 Z W L H - + -------------------------------------------------------------------------- + (FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE), -- | U | + (FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE), -- | X | + (FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE), -- | 0 | + (FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, TRUE), -- | 1 | + (FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE), -- | Z | + (FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE), -- | W | + (FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE), -- | L | + (FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, TRUE), -- | H | + ( TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE) -- | - | + ); + + -- Id: M.1 + function STD_MATCH (L, R: STD_ULOGIC) return BOOLEAN is + variable VALUE: STD_ULOGIC; + begin + return MATCH_TABLE(L, R); + end STD_MATCH; + + -- Id: M.2 + function STD_MATCH (L, R: UNSIGNED) return BOOLEAN is + alias LV: UNSIGNED(1 to L'LENGTH) is L; + alias RV: UNSIGNED(1 to R'LENGTH) is R; + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then + assert NO_WARNING + report "NUMERIC_STD.STD_MATCH: null detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if LV'LENGTH /= RV'LENGTH then + assert NO_WARNING + report "NUMERIC_STD.STD_MATCH: L'LENGTH /= R'LENGTH, returning FALSE" + severity WARNING; + return FALSE; + else + for I in LV'LOW to LV'HIGH loop + if not (MATCH_TABLE(LV(I), RV(I))) then + return FALSE; + end if; + end loop; + return TRUE; + end if; + end STD_MATCH; + + -- Id: M.3 + function STD_MATCH (L, R: SIGNED) return BOOLEAN is + alias LV: SIGNED(1 to L'LENGTH) is L; + alias RV: SIGNED(1 to R'LENGTH) is R; + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then + assert NO_WARNING + report "NUMERIC_STD.STD_MATCH: null detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if LV'LENGTH /= RV'LENGTH then + assert NO_WARNING + report "NUMERIC_STD.STD_MATCH: L'LENGTH /= R'LENGTH, returning FALSE" + severity WARNING; + return FALSE; + else + for I in LV'LOW to LV'HIGH loop + if not (MATCH_TABLE(LV(I), RV(I))) then + return FALSE; + end if; + end loop; + return TRUE; + end if; + end STD_MATCH; + + -- Id: M.4 + function STD_MATCH (L, R: STD_LOGIC_VECTOR) return BOOLEAN is + alias LV: STD_LOGIC_VECTOR(1 to L'LENGTH) is L; + alias RV: STD_LOGIC_VECTOR(1 to R'LENGTH) is R; + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then + assert NO_WARNING + report "NUMERIC_STD.STD_MATCH: null detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if LV'LENGTH /= RV'LENGTH then + assert NO_WARNING + report "NUMERIC_STD.STD_MATCH: L'LENGTH /= R'LENGTH, returning FALSE" + severity WARNING; + return FALSE; + else + for I in LV'LOW to LV'HIGH loop + if not (MATCH_TABLE(LV(I), RV(I))) then + return FALSE; + end if; + end loop; + return TRUE; + end if; + end STD_MATCH; + + -- Id: M.5 + function STD_MATCH (L, R: STD_ULOGIC_VECTOR) return BOOLEAN is + alias LV: STD_ULOGIC_VECTOR(1 to L'LENGTH) is L; + alias RV: STD_ULOGIC_VECTOR(1 to R'LENGTH) is R; + begin + if ((L'LENGTH < 1) or (R'LENGTH < 1)) then + assert NO_WARNING + report "NUMERIC_STD.STD_MATCH: null detected, returning FALSE" + severity WARNING; + return FALSE; + end if; + if LV'LENGTH /= RV'LENGTH then + assert NO_WARNING + report "NUMERIC_STD.STD_MATCH: L'LENGTH /= R'LENGTH, returning FALSE" + severity WARNING; + return FALSE; + else + for I in LV'LOW to LV'HIGH loop + if not (MATCH_TABLE(LV(I), RV(I))) then + return FALSE; + end if; + end loop; + return TRUE; + end if; + end STD_MATCH; + + --============================================================================ + + -- function TO_01 is used to convert vectors to the + -- correct form for exported functions, + -- and to report if there is an element which + -- is not in (0, 1, H, L). + + -- Id: T.1 + function TO_01 (S: UNSIGNED; XMAP: STD_LOGIC := '0') return UNSIGNED is + variable RESULT: UNSIGNED(S'LENGTH-1 downto 0); + variable BAD_ELEMENT: BOOLEAN := FALSE; + alias XS: UNSIGNED(S'LENGTH-1 downto 0) is S; + begin + if (S'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_STD.TO_01: null detected, returning NAU" + severity WARNING; + return NAU; + end if; + for I in RESULT'RANGE loop + case XS(I) is + when '0' | 'L' => RESULT(I) := '0'; + when '1' | 'H' => RESULT(I) := '1'; + when others => BAD_ELEMENT := TRUE; + end case; + end loop; + if BAD_ELEMENT then + for I in RESULT'RANGE loop + RESULT(I) := XMAP; -- standard fixup + end loop; + end if; + return RESULT; + end TO_01; + + -- Id: T.2 + function TO_01 (S: SIGNED; XMAP: STD_LOGIC := '0') return SIGNED is + variable RESULT: SIGNED(S'LENGTH-1 downto 0); + variable BAD_ELEMENT: BOOLEAN := FALSE; + alias XS: SIGNED(S'LENGTH-1 downto 0) is S; + begin + if (S'LENGTH < 1) then + assert NO_WARNING + report "NUMERIC_STD.TO_01: null detected, returning NAS" + severity WARNING; + return NAS; + end if; + for I in RESULT'RANGE loop + case XS(I) is + when '0' | 'L' => RESULT(I) := '0'; + when '1' | 'H' => RESULT(I) := '1'; + when others => BAD_ELEMENT := TRUE; + end case; + end loop; + if BAD_ELEMENT then + for I in RESULT'RANGE loop + RESULT(I) := XMAP; -- standard fixup + end loop; + end if; + return RESULT; + end TO_01; + + --============================================================================ + +end NUMERIC_STD; diff --git a/libraries/ieee/numeric_std.vhdl b/libraries/ieee/numeric_std.vhdl new file mode 100644 index 000000000..da22c32b0 --- /dev/null +++ b/libraries/ieee/numeric_std.vhdl @@ -0,0 +1,853 @@ +-- -------------------------------------------------------------------- +-- +-- Copyright 1995 by IEEE. All rights reserved. +-- +-- This source file is considered by the IEEE to be an essential part of the use +-- of the standard 1076.3 and as such may be distributed without change, except +-- as permitted by the standard. This source file may not be sold or distributed +-- for profit. This package may be modified to include additional data required +-- by tools, but must in no way change the external interfaces or simulation +-- behaviour of the description. It is permissible to add comments and/or +-- attributes to the package declarations, but not to change or delete any +-- original lines of the approved package declaration. The package body may be +-- changed only in accordance with the terms of clauses 7.1 and 7.2 of the +-- standard. +-- +-- Title : Standard VHDL Synthesis Package (1076.3, NUMERIC_STD) +-- +-- Library : This package shall be compiled into a library symbolically +-- : named IEEE. +-- +-- Developers : IEEE DASC Synthesis Working Group, PAR 1076.3 +-- +-- Purpose : This package defines numeric types and arithmetic functions +-- : for use with synthesis tools. Two numeric types are defined: +-- : -- > UNSIGNED: represents UNSIGNED number in vector form +-- : -- > SIGNED: represents a SIGNED number in vector form +-- : The base element type is type STD_LOGIC. +-- : The leftmost bit is treated as the most significant bit. +-- : Signed vectors are represented in two's complement form. +-- : This package contains overloaded arithmetic operators on +-- : the SIGNED and UNSIGNED types. The package also contains +-- : useful type conversions functions. +-- : +-- : If any argument to a function is a null array, a null array is +-- : returned (exceptions, if any, are noted individually). +-- +-- Limitation : +-- +-- Note : No declarations or definitions shall be included in, +-- : or excluded from this package. The "package declaration" +-- : defines the types, subtypes and declarations of +-- : NUMERIC_STD. The NUMERIC_STD package body shall be +-- : considered the formal definition of the semantics of +-- : this package. Tool developers may choose to implement +-- : the package body in the most efficient manner available +-- : to them. +-- +-- -------------------------------------------------------------------- +-- modification history : +-- -------------------------------------------------------------------- +-- Version: 2.4 +-- Date : 12 April 1995 +-- ----------------------------------------------------------------------------- +library IEEE; +use IEEE.STD_LOGIC_1164.all; + +package NUMERIC_STD is + constant CopyRightNotice: STRING + := "Copyright 1995 IEEE. All rights reserved."; + + --============================================================================ + -- Numeric array type definitions + --============================================================================ + + type UNSIGNED is array (NATURAL range <>) of STD_LOGIC; + type SIGNED is array (NATURAL range <>) of STD_LOGIC; + + --============================================================================ + -- Arithmetic Operators: + --=========================================================================== + + -- Id: A.1 + function "abs" (ARG: SIGNED) return SIGNED; + -- Result subtype: SIGNED(ARG'LENGTH-1 downto 0). + -- Result: Returns the absolute value of a SIGNED vector ARG. + + -- Id: A.2 + function "-" (ARG: SIGNED) return SIGNED; + -- Result subtype: SIGNED(ARG'LENGTH-1 downto 0). + -- Result: Returns the value of the unary minus operation on a + -- SIGNED vector ARG. + + --============================================================================ + + -- Id: A.3 + function "+" (L, R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(MAX(L'LENGTH, R'LENGTH)-1 downto 0). + -- Result: Adds two UNSIGNED vectors that may be of different lengths. + + -- Id: A.4 + function "+" (L, R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(MAX(L'LENGTH, R'LENGTH)-1 downto 0). + -- Result: Adds two SIGNED vectors that may be of different lengths. + + -- Id: A.5 + function "+" (L: UNSIGNED; R: NATURAL) return UNSIGNED; + -- Result subtype: UNSIGNED(L'LENGTH-1 downto 0). + -- Result: Adds an UNSIGNED vector, L, with a non-negative INTEGER, R. + + -- Id: A.6 + function "+" (L: NATURAL; R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(R'LENGTH-1 downto 0). + -- Result: Adds a non-negative INTEGER, L, with an UNSIGNED vector, R. + + -- Id: A.7 + function "+" (L: INTEGER; R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(R'LENGTH-1 downto 0). + -- Result: Adds an INTEGER, L(may be positive or negative), to a SIGNED + -- vector, R. + + -- Id: A.8 + function "+" (L: SIGNED; R: INTEGER) return SIGNED; + -- Result subtype: SIGNED(L'LENGTH-1 downto 0). + -- Result: Adds a SIGNED vector, L, to an INTEGER, R. + + --============================================================================ + + -- Id: A.9 + function "-" (L, R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(MAX(L'LENGTH, R'LENGTH)-1 downto 0). + -- Result: Subtracts two UNSIGNED vectors that may be of different lengths. + + -- Id: A.10 + function "-" (L, R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(MAX(L'LENGTH, R'LENGTH)-1 downto 0). + -- Result: Subtracts a SIGNED vector, R, from another SIGNED vector, L, + -- that may possibly be of different lengths. + + -- Id: A.11 + function "-" (L: UNSIGNED;R: NATURAL) return UNSIGNED; + -- Result subtype: UNSIGNED(L'LENGTH-1 downto 0). + -- Result: Subtracts a non-negative INTEGER, R, from an UNSIGNED vector, L. + + -- Id: A.12 + function "-" (L: NATURAL; R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(R'LENGTH-1 downto 0). + -- Result: Subtracts an UNSIGNED vector, R, from a non-negative INTEGER, L. + + -- Id: A.13 + function "-" (L: SIGNED; R: INTEGER) return SIGNED; + -- Result subtype: SIGNED(L'LENGTH-1 downto 0). + -- Result: Subtracts an INTEGER, R, from a SIGNED vector, L. + + -- Id: A.14 + function "-" (L: INTEGER; R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(R'LENGTH-1 downto 0). + -- Result: Subtracts a SIGNED vector, R, from an INTEGER, L. + + --============================================================================ + + -- Id: A.15 + function "*" (L, R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED((L'LENGTH+R'LENGTH-1) downto 0). + -- Result: Performs the multiplication operation on two UNSIGNED vectors + -- that may possibly be of different lengths. + + -- Id: A.16 + function "*" (L, R: SIGNED) return SIGNED; + -- Result subtype: SIGNED((L'LENGTH+R'LENGTH-1) downto 0) + -- Result: Multiplies two SIGNED vectors that may possibly be of + -- different lengths. + + -- Id: A.17 + function "*" (L: UNSIGNED; R: NATURAL) return UNSIGNED; + -- Result subtype: UNSIGNED((L'LENGTH+L'LENGTH-1) downto 0). + -- Result: Multiplies an UNSIGNED vector, L, with a non-negative + -- INTEGER, R. R is converted to an UNSIGNED vector of + -- SIZE L'LENGTH before multiplication. + + -- Id: A.18 + function "*" (L: NATURAL; R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED((R'LENGTH+R'LENGTH-1) downto 0). + -- Result: Multiplies an UNSIGNED vector, R, with a non-negative + -- INTEGER, L. L is converted to an UNSIGNED vector of + -- SIZE R'LENGTH before multiplication. + + -- Id: A.19 + function "*" (L: SIGNED; R: INTEGER) return SIGNED; + -- Result subtype: SIGNED((L'LENGTH+L'LENGTH-1) downto 0) + -- Result: Multiplies a SIGNED vector, L, with an INTEGER, R. R is + -- converted to a SIGNED vector of SIZE L'LENGTH before + -- multiplication. + + -- Id: A.20 + function "*" (L: INTEGER; R: SIGNED) return SIGNED; + -- Result subtype: SIGNED((R'LENGTH+R'LENGTH-1) downto 0) + -- Result: Multiplies a SIGNED vector, R, with an INTEGER, L. L is + -- converted to a SIGNED vector of SIZE R'LENGTH before + -- multiplication. + + --============================================================================ + -- + -- NOTE: If second argument is zero for "/" operator, a severity level + -- of ERROR is issued. + + -- Id: A.21 + function "/" (L, R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(L'LENGTH-1 downto 0) + -- Result: Divides an UNSIGNED vector, L, by another UNSIGNED vector, R. + + -- Id: A.22 + function "/" (L, R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(L'LENGTH-1 downto 0) + -- Result: Divides an SIGNED vector, L, by another SIGNED vector, R. + + -- Id: A.23 + function "/" (L: UNSIGNED; R: NATURAL) return UNSIGNED; + -- Result subtype: UNSIGNED(L'LENGTH-1 downto 0) + -- Result: Divides an UNSIGNED vector, L, by a non-negative INTEGER, R. + -- If NO_OF_BITS(R) > L'LENGTH, result is truncated to L'LENGTH. + + -- Id: A.24 + function "/" (L: NATURAL; R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(R'LENGTH-1 downto 0) + -- Result: Divides a non-negative INTEGER, L, by an UNSIGNED vector, R. + -- If NO_OF_BITS(L) > R'LENGTH, result is truncated to R'LENGTH. + + -- Id: A.25 + function "/" (L: SIGNED; R: INTEGER) return SIGNED; + -- Result subtype: SIGNED(L'LENGTH-1 downto 0) + -- Result: Divides a SIGNED vector, L, by an INTEGER, R. + -- If NO_OF_BITS(R) > L'LENGTH, result is truncated to L'LENGTH. + + -- Id: A.26 + function "/" (L: INTEGER; R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(R'LENGTH-1 downto 0) + -- Result: Divides an INTEGER, L, by a SIGNED vector, R. + -- If NO_OF_BITS(L) > R'LENGTH, result is truncated to R'LENGTH. + + --============================================================================ + -- + -- NOTE: If second argument is zero for "rem" operator, a severity level + -- of ERROR is issued. + + -- Id: A.27 + function "rem" (L, R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(R'LENGTH-1 downto 0) + -- Result: Computes "L rem R" where L and R are UNSIGNED vectors. + + -- Id: A.28 + function "rem" (L, R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(R'LENGTH-1 downto 0) + -- Result: Computes "L rem R" where L and R are SIGNED vectors. + + -- Id: A.29 + function "rem" (L: UNSIGNED; R: NATURAL) return UNSIGNED; + -- Result subtype: UNSIGNED(L'LENGTH-1 downto 0) + -- Result: Computes "L rem R" where L is an UNSIGNED vector and R is a + -- non-negative INTEGER. + -- If NO_OF_BITS(R) > L'LENGTH, result is truncated to L'LENGTH. + + -- Id: A.30 + function "rem" (L: NATURAL; R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(R'LENGTH-1 downto 0) + -- Result: Computes "L rem R" where R is an UNSIGNED vector and L is a + -- non-negative INTEGER. + -- If NO_OF_BITS(L) > R'LENGTH, result is truncated to R'LENGTH. + + -- Id: A.31 + function "rem" (L: SIGNED; R: INTEGER) return SIGNED; + -- Result subtype: SIGNED(L'LENGTH-1 downto 0) + -- Result: Computes "L rem R" where L is SIGNED vector and R is an INTEGER. + -- If NO_OF_BITS(R) > L'LENGTH, result is truncated to L'LENGTH. + + -- Id: A.32 + function "rem" (L: INTEGER; R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(R'LENGTH-1 downto 0) + -- Result: Computes "L rem R" where R is SIGNED vector and L is an INTEGER. + -- If NO_OF_BITS(L) > R'LENGTH, result is truncated to R'LENGTH. + + --============================================================================ + -- + -- NOTE: If second argument is zero for "mod" operator, a severity level + -- of ERROR is issued. + + -- Id: A.33 + function "mod" (L, R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(R'LENGTH-1 downto 0) + -- Result: Computes "L mod R" where L and R are UNSIGNED vectors. + + -- Id: A.34 + function "mod" (L, R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(R'LENGTH-1 downto 0) + -- Result: Computes "L mod R" where L and R are SIGNED vectors. + + -- Id: A.35 + function "mod" (L: UNSIGNED; R: NATURAL) return UNSIGNED; + -- Result subtype: UNSIGNED(L'LENGTH-1 downto 0) + -- Result: Computes "L mod R" where L is an UNSIGNED vector and R + -- is a non-negative INTEGER. + -- If NO_OF_BITS(R) > L'LENGTH, result is truncated to L'LENGTH. + + -- Id: A.36 + function "mod" (L: NATURAL; R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(R'LENGTH-1 downto 0) + -- Result: Computes "L mod R" where R is an UNSIGNED vector and L + -- is a non-negative INTEGER. + -- If NO_OF_BITS(L) > R'LENGTH, result is truncated to R'LENGTH. + + -- Id: A.37 + function "mod" (L: SIGNED; R: INTEGER) return SIGNED; + -- Result subtype: SIGNED(L'LENGTH-1 downto 0) + -- Result: Computes "L mod R" where L is a SIGNED vector and + -- R is an INTEGER. + -- If NO_OF_BITS(R) > L'LENGTH, result is truncated to L'LENGTH. + + -- Id: A.38 + function "mod" (L: INTEGER; R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(R'LENGTH-1 downto 0) + -- Result: Computes "L mod R" where L is an INTEGER and + -- R is a SIGNED vector. + -- If NO_OF_BITS(L) > R'LENGTH, result is truncated to R'LENGTH. + + --============================================================================ + -- Comparison Operators + --============================================================================ + + -- Id: C.1 + function ">" (L, R: UNSIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L > R" where L and R are UNSIGNED vectors possibly + -- of different lengths. + + -- Id: C.2 + function ">" (L, R: SIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L > R" where L and R are SIGNED vectors possibly + -- of different lengths. + + -- Id: C.3 + function ">" (L: NATURAL; R: UNSIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L > R" where L is a non-negative INTEGER and + -- R is an UNSIGNED vector. + + -- Id: C.4 + function ">" (L: INTEGER; R: SIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L > R" where L is a INTEGER and + -- R is a SIGNED vector. + + -- Id: C.5 + function ">" (L: UNSIGNED; R: NATURAL) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L > R" where L is an UNSIGNED vector and + -- R is a non-negative INTEGER. + + -- Id: C.6 + function ">" (L: SIGNED; R: INTEGER) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L > R" where L is a SIGNED vector and + -- R is a INTEGER. + + --============================================================================ + + -- Id: C.7 + function "<" (L, R: UNSIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L < R" where L and R are UNSIGNED vectors possibly + -- of different lengths. + + -- Id: C.8 + function "<" (L, R: SIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L < R" where L and R are SIGNED vectors possibly + -- of different lengths. + + -- Id: C.9 + function "<" (L: NATURAL; R: UNSIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L < R" where L is a non-negative INTEGER and + -- R is an UNSIGNED vector. + + -- Id: C.10 + function "<" (L: INTEGER; R: SIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L < R" where L is an INTEGER and + -- R is a SIGNED vector. + + -- Id: C.11 + function "<" (L: UNSIGNED; R: NATURAL) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L < R" where L is an UNSIGNED vector and + -- R is a non-negative INTEGER. + + -- Id: C.12 + function "<" (L: SIGNED; R: INTEGER) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L < R" where L is a SIGNED vector and + -- R is an INTEGER. + + --============================================================================ + + -- Id: C.13 + function "<=" (L, R: UNSIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L <= R" where L and R are UNSIGNED vectors possibly + -- of different lengths. + + -- Id: C.14 + function "<=" (L, R: SIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L <= R" where L and R are SIGNED vectors possibly + -- of different lengths. + + -- Id: C.15 + function "<=" (L: NATURAL; R: UNSIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L <= R" where L is a non-negative INTEGER and + -- R is an UNSIGNED vector. + + -- Id: C.16 + function "<=" (L: INTEGER; R: SIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L <= R" where L is an INTEGER and + -- R is a SIGNED vector. + + -- Id: C.17 + function "<=" (L: UNSIGNED; R: NATURAL) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L <= R" where L is an UNSIGNED vector and + -- R is a non-negative INTEGER. + + -- Id: C.18 + function "<=" (L: SIGNED; R: INTEGER) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L <= R" where L is a SIGNED vector and + -- R is an INTEGER. + + --============================================================================ + + -- Id: C.19 + function ">=" (L, R: UNSIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L >= R" where L and R are UNSIGNED vectors possibly + -- of different lengths. + + -- Id: C.20 + function ">=" (L, R: SIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L >= R" where L and R are SIGNED vectors possibly + -- of different lengths. + + -- Id: C.21 + function ">=" (L: NATURAL; R: UNSIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L >= R" where L is a non-negative INTEGER and + -- R is an UNSIGNED vector. + + -- Id: C.22 + function ">=" (L: INTEGER; R: SIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L >= R" where L is an INTEGER and + -- R is a SIGNED vector. + + -- Id: C.23 + function ">=" (L: UNSIGNED; R: NATURAL) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L >= R" where L is an UNSIGNED vector and + -- R is a non-negative INTEGER. + + -- Id: C.24 + function ">=" (L: SIGNED; R: INTEGER) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L >= R" where L is a SIGNED vector and + -- R is an INTEGER. + + --============================================================================ + + -- Id: C.25 + function "=" (L, R: UNSIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L = R" where L and R are UNSIGNED vectors possibly + -- of different lengths. + + -- Id: C.26 + function "=" (L, R: SIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L = R" where L and R are SIGNED vectors possibly + -- of different lengths. + + -- Id: C.27 + function "=" (L: NATURAL; R: UNSIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L = R" where L is a non-negative INTEGER and + -- R is an UNSIGNED vector. + + -- Id: C.28 + function "=" (L: INTEGER; R: SIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L = R" where L is an INTEGER and + -- R is a SIGNED vector. + + -- Id: C.29 + function "=" (L: UNSIGNED; R: NATURAL) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L = R" where L is an UNSIGNED vector and + -- R is a non-negative INTEGER. + + -- Id: C.30 + function "=" (L: SIGNED; R: INTEGER) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L = R" where L is a SIGNED vector and + -- R is an INTEGER. + + --============================================================================ + + -- Id: C.31 + function "/=" (L, R: UNSIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L /= R" where L and R are UNSIGNED vectors possibly + -- of different lengths. + + -- Id: C.32 + function "/=" (L, R: SIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L /= R" where L and R are SIGNED vectors possibly + -- of different lengths. + + -- Id: C.33 + function "/=" (L: NATURAL; R: UNSIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L /= R" where L is a non-negative INTEGER and + -- R is an UNSIGNED vector. + + -- Id: C.34 + function "/=" (L: INTEGER; R: SIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L /= R" where L is an INTEGER and + -- R is a SIGNED vector. + + -- Id: C.35 + function "/=" (L: UNSIGNED; R: NATURAL) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L /= R" where L is an UNSIGNED vector and + -- R is a non-negative INTEGER. + + -- Id: C.36 + function "/=" (L: SIGNED; R: INTEGER) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: Computes "L /= R" where L is a SIGNED vector and + -- R is an INTEGER. + + --============================================================================ + -- Shift and Rotate Functions + --============================================================================ + + -- Id: S.1 + function SHIFT_LEFT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED; + -- Result subtype: UNSIGNED(ARG'LENGTH-1 downto 0) + -- Result: Performs a shift-left on an UNSIGNED vector COUNT times. + -- The vacated positions are filled with '0'. + -- The COUNT leftmost elements are lost. + + -- Id: S.2 + function SHIFT_RIGHT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED; + -- Result subtype: UNSIGNED(ARG'LENGTH-1 downto 0) + -- Result: Performs a shift-right on an UNSIGNED vector COUNT times. + -- The vacated positions are filled with '0'. + -- The COUNT rightmost elements are lost. + + -- Id: S.3 + function SHIFT_LEFT (ARG: SIGNED; COUNT: NATURAL) return SIGNED; + -- Result subtype: SIGNED(ARG'LENGTH-1 downto 0) + -- Result: Performs a shift-left on a SIGNED vector COUNT times. + -- The vacated positions are filled with '0'. + -- The COUNT leftmost elements are lost. + + -- Id: S.4 + function SHIFT_RIGHT (ARG: SIGNED; COUNT: NATURAL) return SIGNED; + -- Result subtype: SIGNED(ARG'LENGTH-1 downto 0) + -- Result: Performs a shift-right on a SIGNED vector COUNT times. + -- The vacated positions are filled with the leftmost + -- element, ARG'LEFT. The COUNT rightmost elements are lost. + + --============================================================================ + + -- Id: S.5 + function ROTATE_LEFT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED; + -- Result subtype: UNSIGNED(ARG'LENGTH-1 downto 0) + -- Result: Performs a rotate-left of an UNSIGNED vector COUNT times. + + -- Id: S.6 + function ROTATE_RIGHT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED; + -- Result subtype: UNSIGNED(ARG'LENGTH-1 downto 0) + -- Result: Performs a rotate-right of an UNSIGNED vector COUNT times. + + -- Id: S.7 + function ROTATE_LEFT (ARG: SIGNED; COUNT: NATURAL) return SIGNED; + -- Result subtype: SIGNED(ARG'LENGTH-1 downto 0) + -- Result: Performs a logical rotate-left of a SIGNED + -- vector COUNT times. + + -- Id: S.8 + function ROTATE_RIGHT (ARG: SIGNED; COUNT: NATURAL) return SIGNED; + -- Result subtype: SIGNED(ARG'LENGTH-1 downto 0) + -- Result: Performs a logical rotate-right of a SIGNED + -- vector COUNT times. + + --============================================================================ + + --============================================================================ + + ------------------------------------------------------------------------------ + -- Note : Function S.9 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.9 + function "sll" (ARG: UNSIGNED; COUNT: INTEGER) return UNSIGNED; --V93 + -- Result subtype: UNSIGNED(ARG'LENGTH-1 downto 0) + -- Result: SHIFT_LEFT(ARG, COUNT) + + ------------------------------------------------------------------------------ + -- Note : Function S.10 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.10 + function "sll" (ARG: SIGNED; COUNT: INTEGER) return SIGNED; --V93 + -- Result subtype: SIGNED(ARG'LENGTH-1 downto 0) + -- Result: SHIFT_LEFT(ARG, COUNT) + + ------------------------------------------------------------------------------ + -- Note : Function S.11 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.11 + function "srl" (ARG: UNSIGNED; COUNT: INTEGER) return UNSIGNED; --V93 + -- Result subtype: UNSIGNED(ARG'LENGTH-1 downto 0) + -- Result: SHIFT_RIGHT(ARG, COUNT) + + ------------------------------------------------------------------------------ + -- Note : Function S.12 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.12 + function "srl" (ARG: SIGNED; COUNT: INTEGER) return SIGNED; --V93 + -- Result subtype: SIGNED(ARG'LENGTH-1 downto 0) + -- Result: SIGNED(SHIFT_RIGHT(UNSIGNED(ARG), COUNT)) + + ------------------------------------------------------------------------------ + -- Note : Function S.13 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.13 + function "rol" (ARG: UNSIGNED; COUNT: INTEGER) return UNSIGNED; --V93 + -- Result subtype: UNSIGNED(ARG'LENGTH-1 downto 0) + -- Result: ROTATE_LEFT(ARG, COUNT) + + ------------------------------------------------------------------------------ + -- Note : Function S.14 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.14 + function "rol" (ARG: SIGNED; COUNT: INTEGER) return SIGNED; --V93 + -- Result subtype: SIGNED(ARG'LENGTH-1 downto 0) + -- Result: ROTATE_LEFT(ARG, COUNT) + + ------------------------------------------------------------------------------ + -- Note : Function S.15 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.15 + function "ror" (ARG: UNSIGNED; COUNT: INTEGER) return UNSIGNED; --V93 + -- Result subtype: UNSIGNED(ARG'LENGTH-1 downto 0) + -- Result: ROTATE_RIGHT(ARG, COUNT) + + ------------------------------------------------------------------------------ + -- Note : Function S.16 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + ------------------------------------------------------------------------------ + -- Id: S.16 + function "ror" (ARG: SIGNED; COUNT: INTEGER) return SIGNED; --V93 + -- Result subtype: SIGNED(ARG'LENGTH-1 downto 0) + -- Result: ROTATE_RIGHT(ARG, COUNT) + + --============================================================================ + -- RESIZE Functions + --============================================================================ + + -- Id: R.1 + function RESIZE (ARG: SIGNED; NEW_SIZE: NATURAL) return SIGNED; + -- Result subtype: SIGNED(NEW_SIZE-1 downto 0) + -- Result: Resizes the SIGNED vector ARG to the specified size. + -- To create a larger vector, the new [leftmost] bit positions + -- are filled with the sign bit (ARG'LEFT). When truncating, + -- the sign bit is retained along with the rightmost part. + + -- Id: R.2 + function RESIZE (ARG: UNSIGNED; NEW_SIZE: NATURAL) return UNSIGNED; + -- Result subtype: UNSIGNED(NEW_SIZE-1 downto 0) + -- Result: Resizes the SIGNED vector ARG to the specified size. + -- To create a larger vector, the new [leftmost] bit positions + -- are filled with '0'. When truncating, the leftmost bits + -- are dropped. + + --============================================================================ + -- Conversion Functions + --============================================================================ + + -- Id: D.1 + function TO_INTEGER (ARG: UNSIGNED) return NATURAL; + -- Result subtype: NATURAL. Value cannot be negative since parameter is an + -- UNSIGNED vector. + -- Result: Converts the UNSIGNED vector to an INTEGER. + + -- Id: D.2 + function TO_INTEGER (ARG: SIGNED) return INTEGER; + -- Result subtype: INTEGER + -- Result: Converts a SIGNED vector to an INTEGER. + + -- Id: D.3 + function TO_UNSIGNED (ARG, SIZE: NATURAL) return UNSIGNED; + -- Result subtype: UNSIGNED(SIZE-1 downto 0) + -- Result: Converts a non-negative INTEGER to an UNSIGNED vector with + -- the specified SIZE. + + -- Id: D.4 + function TO_SIGNED (ARG: INTEGER; SIZE: NATURAL) return SIGNED; + -- Result subtype: SIGNED(SIZE-1 downto 0) + -- Result: Converts an INTEGER to a SIGNED vector of the specified SIZE. + + --============================================================================ + -- Logical Operators + --============================================================================ + + -- Id: L.1 + function "not" (L: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(L'LENGTH-1 downto 0) + -- Result: Termwise inversion + + -- Id: L.2 + function "and" (L, R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(L'LENGTH-1 downto 0) + -- Result: Vector AND operation + + -- Id: L.3 + function "or" (L, R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(L'LENGTH-1 downto 0) + -- Result: Vector OR operation + + -- Id: L.4 + function "nand" (L, R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(L'LENGTH-1 downto 0) + -- Result: Vector NAND operation + + -- Id: L.5 + function "nor" (L, R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(L'LENGTH-1 downto 0) + -- Result: Vector NOR operation + + -- Id: L.6 + function "xor" (L, R: UNSIGNED) return UNSIGNED; + -- Result subtype: UNSIGNED(L'LENGTH-1 downto 0) + -- Result: Vector XOR operation + + -- --------------------------------------------------------------------------- + -- Note : Function L.7 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + -- --------------------------------------------------------------------------- + -- Id: L.7 + function "xnor" (L, R: UNSIGNED) return UNSIGNED; --V93 + -- Result subtype: UNSIGNED(L'LENGTH-1 downto 0) + -- Result: Vector XNOR operation + + -- Id: L.8 + function "not" (L: SIGNED) return SIGNED; + -- Result subtype: SIGNED(L'LENGTH-1 downto 0) + -- Result: Termwise inversion + + -- Id: L.9 + function "and" (L, R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(L'LENGTH-1 downto 0) + -- Result: Vector AND operation + + -- Id: L.10 + function "or" (L, R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(L'LENGTH-1 downto 0) + -- Result: Vector OR operation + + -- Id: L.11 + function "nand" (L, R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(L'LENGTH-1 downto 0) + -- Result: Vector NAND operation + + -- Id: L.12 + function "nor" (L, R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(L'LENGTH-1 downto 0) + -- Result: Vector NOR operation + + -- Id: L.13 + function "xor" (L, R: SIGNED) return SIGNED; + -- Result subtype: SIGNED(L'LENGTH-1 downto 0) + -- Result: Vector XOR operation + + -- --------------------------------------------------------------------------- + -- Note : Function L.14 is not compatible with VHDL 1076-1987. Comment + -- out the function (declaration and body) for VHDL 1076-1987 compatibility. + -- --------------------------------------------------------------------------- + -- Id: L.14 + function "xnor" (L, R: SIGNED) return SIGNED; --V93 + -- Result subtype: SIGNED(L'LENGTH-1 downto 0) + -- Result: Vector XNOR operation + + --============================================================================ + -- Match Functions + --============================================================================ + + -- Id: M.1 + function STD_MATCH (L, R: STD_ULOGIC) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: terms compared per STD_LOGIC_1164 intent + + -- Id: M.2 + function STD_MATCH (L, R: UNSIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: terms compared per STD_LOGIC_1164 intent + + -- Id: M.3 + function STD_MATCH (L, R: SIGNED) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: terms compared per STD_LOGIC_1164 intent + + -- Id: M.4 + function STD_MATCH (L, R: STD_LOGIC_VECTOR) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: terms compared per STD_LOGIC_1164 intent + + -- Id: M.5 + function STD_MATCH (L, R: STD_ULOGIC_VECTOR) return BOOLEAN; + -- Result subtype: BOOLEAN + -- Result: terms compared per STD_LOGIC_1164 intent + + --============================================================================ + -- Translation Functions + --============================================================================ + + -- Id: T.1 + function TO_01 (S: UNSIGNED; XMAP: STD_LOGIC := '0') return UNSIGNED; + -- Result subtype: UNSIGNED(S'RANGE) + -- Result: Termwise, 'H' is translated to '1', and 'L' is translated + -- to '0'. If a value other than '0'|'1'|'H'|'L' is found, + -- the array is set to (others => XMAP), and a warning is + -- issued. + + -- Id: T.2 + function TO_01 (S: SIGNED; XMAP: STD_LOGIC := '0') return SIGNED; + -- Result subtype: SIGNED(S'RANGE) + -- Result: Termwise, 'H' is translated to '1', and 'L' is translated + -- to '0'. If a value other than '0'|'1'|'H'|'L' is found, + -- the array is set to (others => XMAP), and a warning is + -- issued. + +end NUMERIC_STD; diff --git a/libraries/ieee/std_logic_1164.vhdl b/libraries/ieee/std_logic_1164.vhdl new file mode 100644 index 000000000..c53113be9 --- /dev/null +++ b/libraries/ieee/std_logic_1164.vhdl @@ -0,0 +1,175 @@ +-- -------------------------------------------------------------------- +-- +-- Title : std_logic_1164 multi-value logic system +-- Library : This package shall be compiled into a library +-- : symbolically named IEEE. +-- : +-- Developers: IEEE model standards group (par 1164) +-- Purpose : This packages defines a standard for designers +-- : to use in describing the interconnection data types +-- : used in vhdl modeling. +-- : +-- Limitation: The logic system defined in this package may +-- : be insufficient for modeling switched transistors, +-- : since such a requirement is out of the scope of this +-- : effort. Furthermore, mathematics, primitives, +-- : timing standards, etc. are considered orthogonal +-- : issues as it relates to this package and are therefore +-- : beyond the scope of this effort. +-- : +-- Note : No declarations or definitions shall be included in, +-- : or excluded from this package. The "package declaration" +-- : defines the types, subtypes and declarations of +-- : std_logic_1164. The std_logic_1164 package body shall be +-- : considered the formal definition of the semantics of +-- : this package. Tool developers may choose to implement +-- : the package body in the most efficient manner available +-- : to them. +-- : +-- -------------------------------------------------------------------- +-- modification history : +-- -------------------------------------------------------------------- +-- version | mod. date:| +-- v4.200 | 01/02/92 | +-- -------------------------------------------------------------------- + +PACKAGE std_logic_1164 IS + + ------------------------------------------------------------------- + -- logic state system (unresolved) + ------------------------------------------------------------------- + TYPE std_ulogic IS ( 'U', -- Uninitialized + 'X', -- Forcing Unknown + '0', -- Forcing 0 + '1', -- Forcing 1 + 'Z', -- High Impedance + 'W', -- Weak Unknown + 'L', -- Weak 0 + 'H', -- Weak 1 + '-' -- Don't care + ); + ------------------------------------------------------------------- + -- unconstrained array of std_ulogic for use with the resolution function + ------------------------------------------------------------------- + TYPE std_ulogic_vector IS ARRAY ( NATURAL RANGE <> ) OF std_ulogic; + + ------------------------------------------------------------------- + -- resolution function + ------------------------------------------------------------------- + FUNCTION resolved ( s : std_ulogic_vector ) RETURN std_ulogic; + + ------------------------------------------------------------------- + -- *** industry standard logic type *** + ------------------------------------------------------------------- + SUBTYPE std_logic IS resolved std_ulogic; + + ------------------------------------------------------------------- + -- unconstrained array of std_logic for use in declaring signal arrays + ------------------------------------------------------------------- + TYPE std_logic_vector IS ARRAY ( NATURAL RANGE <>) OF std_logic; + + ------------------------------------------------------------------- + -- common subtypes + ------------------------------------------------------------------- + SUBTYPE X01 IS resolved std_ulogic RANGE 'X' TO '1'; -- ('X','0','1') + SUBTYPE X01Z IS resolved std_ulogic RANGE 'X' TO 'Z'; -- ('X','0','1','Z') + SUBTYPE UX01 IS resolved std_ulogic RANGE 'U' TO '1'; -- ('U','X','0','1') + SUBTYPE UX01Z IS resolved std_ulogic RANGE 'U' TO 'Z'; -- ('U','X','0','1','Z') + + ------------------------------------------------------------------- + -- overloaded logical operators + ------------------------------------------------------------------- + + FUNCTION "and" ( l : std_ulogic; r : std_ulogic ) RETURN UX01; + FUNCTION "nand" ( l : std_ulogic; r : std_ulogic ) RETURN UX01; + FUNCTION "or" ( l : std_ulogic; r : std_ulogic ) RETURN UX01; + FUNCTION "nor" ( l : std_ulogic; r : std_ulogic ) RETURN UX01; + FUNCTION "xor" ( l : std_ulogic; r : std_ulogic ) RETURN UX01; + FUNCTION "xnor" ( l : std_ulogic; r : std_ulogic ) RETURN UX01; --V93 + FUNCTION "not" ( l : std_ulogic ) RETURN UX01; + + ------------------------------------------------------------------- + -- vectorized overloaded logical operators + ------------------------------------------------------------------- + FUNCTION "and" ( l, r : std_logic_vector ) RETURN std_logic_vector; + FUNCTION "and" ( l, r : std_ulogic_vector ) RETURN std_ulogic_vector; + + FUNCTION "nand" ( l, r : std_logic_vector ) RETURN std_logic_vector; + FUNCTION "nand" ( l, r : std_ulogic_vector ) RETURN std_ulogic_vector; + + FUNCTION "or" ( l, r : std_logic_vector ) RETURN std_logic_vector; + FUNCTION "or" ( l, r : std_ulogic_vector ) RETURN std_ulogic_vector; + + FUNCTION "nor" ( l, r : std_logic_vector ) RETURN std_logic_vector; + FUNCTION "nor" ( l, r : std_ulogic_vector ) RETURN std_ulogic_vector; + + FUNCTION "xor" ( l, r : std_logic_vector ) RETURN std_logic_vector; + FUNCTION "xor" ( l, r : std_ulogic_vector ) RETURN std_ulogic_vector; + +-- ----------------------------------------------------------------------- +-- Note : The declaration and implementation of the "xnor" function is +-- specifically commented until at which time the VHDL language has been +-- officially adopted as containing such a function. At such a point, +-- the following comments may be removed along with this notice without +-- further "official" ballotting of this std_logic_1164 package. It is +-- the intent of this effort to provide such a function once it becomes +-- available in the VHDL standard. +-- ----------------------------------------------------------------------- + FUNCTION "xnor" ( l, r : std_logic_vector ) RETURN std_logic_vector; --V93 + FUNCTION "xnor" ( l, r : std_ulogic_vector ) RETURN std_ulogic_vector;--V93 + + FUNCTION "not" ( l : std_logic_vector ) RETURN std_logic_vector; + FUNCTION "not" ( l : std_ulogic_vector ) RETURN std_ulogic_vector; + + ------------------------------------------------------------------- + -- conversion functions + ------------------------------------------------------------------- + FUNCTION To_bit ( s : std_ulogic; xmap : BIT := '0') RETURN BIT; + FUNCTION To_bitvector ( s : std_logic_vector ; xmap : BIT := '0') RETURN BIT_VECTOR; + FUNCTION To_bitvector ( s : std_ulogic_vector; xmap : BIT := '0') RETURN BIT_VECTOR; + + FUNCTION To_StdULogic ( b : BIT ) RETURN std_ulogic; + FUNCTION To_StdLogicVector ( b : BIT_VECTOR ) RETURN std_logic_vector; + FUNCTION To_StdLogicVector ( s : std_ulogic_vector ) RETURN std_logic_vector; + FUNCTION To_StdULogicVector ( b : BIT_VECTOR ) RETURN std_ulogic_vector; + FUNCTION To_StdULogicVector ( s : std_logic_vector ) RETURN std_ulogic_vector; + + ------------------------------------------------------------------- + -- strength strippers and type convertors + ------------------------------------------------------------------- + + FUNCTION To_X01 ( s : std_logic_vector ) RETURN std_logic_vector; + FUNCTION To_X01 ( s : std_ulogic_vector ) RETURN std_ulogic_vector; + FUNCTION To_X01 ( s : std_ulogic ) RETURN X01; + FUNCTION To_X01 ( b : BIT_VECTOR ) RETURN std_logic_vector; + FUNCTION To_X01 ( b : BIT_VECTOR ) RETURN std_ulogic_vector; + FUNCTION To_X01 ( b : BIT ) RETURN X01; + + FUNCTION To_X01Z ( s : std_logic_vector ) RETURN std_logic_vector; + FUNCTION To_X01Z ( s : std_ulogic_vector ) RETURN std_ulogic_vector; + FUNCTION To_X01Z ( s : std_ulogic ) RETURN X01Z; + FUNCTION To_X01Z ( b : BIT_VECTOR ) RETURN std_logic_vector; + FUNCTION To_X01Z ( b : BIT_VECTOR ) RETURN std_ulogic_vector; + FUNCTION To_X01Z ( b : BIT ) RETURN X01Z; + + FUNCTION To_UX01 ( s : std_logic_vector ) RETURN std_logic_vector; + FUNCTION To_UX01 ( s : std_ulogic_vector ) RETURN std_ulogic_vector; + FUNCTION To_UX01 ( s : std_ulogic ) RETURN UX01; + FUNCTION To_UX01 ( b : BIT_VECTOR ) RETURN std_logic_vector; + FUNCTION To_UX01 ( b : BIT_VECTOR ) RETURN std_ulogic_vector; + FUNCTION To_UX01 ( b : BIT ) RETURN UX01; + + ------------------------------------------------------------------- + -- edge detection + ------------------------------------------------------------------- + FUNCTION rising_edge (SIGNAL s : std_ulogic) RETURN BOOLEAN; + FUNCTION falling_edge (SIGNAL s : std_ulogic) RETURN BOOLEAN; + + ------------------------------------------------------------------- + -- object contains an unknown + ------------------------------------------------------------------- + FUNCTION Is_X ( s : std_ulogic_vector ) RETURN BOOLEAN; + FUNCTION Is_X ( s : std_logic_vector ) RETURN BOOLEAN; + FUNCTION Is_X ( s : std_ulogic ) RETURN BOOLEAN; + +END std_logic_1164; diff --git a/libraries/ieee/std_logic_1164_body.vhdl b/libraries/ieee/std_logic_1164_body.vhdl new file mode 100644 index 000000000..65c5965e0 --- /dev/null +++ b/libraries/ieee/std_logic_1164_body.vhdl @@ -0,0 +1,830 @@ +-- -------------------------------------------------------------------- +-- +-- Title : std_logic_1164 multi-value logic system +-- Library : This package shall be compiled into a library +-- : symbolically named IEEE. +-- : +-- Developers: IEEE model standards group (par 1164) +-- Purpose : This packages defines a standard for designers +-- : to use in describing the interconnection data types +-- : used in vhdl modeling. +-- : +-- Limitation: The logic system defined in this package may +-- : be insufficient for modeling switched transistors, +-- : since such a requirement is out of the scope of this +-- : effort. Furthermore, mathematics, primitives, +-- : timing standards, etc. are considered orthogonal +-- : issues as it relates to this package and are therefore +-- : beyond the scope of this effort. +-- : +-- Note : No declarations or definitions shall be included in, +-- : or excluded from this package. The "package declaration" +-- : defines the types, subtypes and declarations of +-- : std_logic_1164. The std_logic_1164 package body shall be +-- : considered the formal definition of the semantics of +-- : this package. Tool developers may choose to implement +-- : the package body in the most efficient manner available +-- : to them. +-- : +-- -------------------------------------------------------------------- +-- modification history : +-- -------------------------------------------------------------------- +-- version | mod. date:| +-- v4.200 | 01/02/91 | +-- -------------------------------------------------------------------- + +PACKAGE BODY std_logic_1164 IS + ------------------------------------------------------------------- + -- local types + ------------------------------------------------------------------- + TYPE stdlogic_1d IS ARRAY (std_ulogic) OF std_ulogic; + TYPE stdlogic_table IS ARRAY(std_ulogic, std_ulogic) OF std_ulogic; + + ------------------------------------------------------------------- + -- resolution function + ------------------------------------------------------------------- + CONSTANT resolution_table : stdlogic_table := ( + -- --------------------------------------------------------- + -- | U X 0 1 Z W L H - | | + -- --------------------------------------------------------- + ( 'U', 'U', 'U', 'U', 'U', 'U', 'U', 'U', 'U' ), -- | U | + ( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | X | + ( 'U', 'X', '0', 'X', '0', '0', '0', '0', 'X' ), -- | 0 | + ( 'U', 'X', 'X', '1', '1', '1', '1', '1', 'X' ), -- | 1 | + ( 'U', 'X', '0', '1', 'Z', 'W', 'L', 'H', 'X' ), -- | Z | + ( 'U', 'X', '0', '1', 'W', 'W', 'W', 'W', 'X' ), -- | W | + ( 'U', 'X', '0', '1', 'L', 'W', 'L', 'W', 'X' ), -- | L | + ( 'U', 'X', '0', '1', 'H', 'W', 'W', 'H', 'X' ), -- | H | + ( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ) -- | - | + ); + + FUNCTION resolved ( s : std_ulogic_vector ) RETURN std_ulogic IS + VARIABLE result : std_ulogic := 'Z'; -- weakest state default + BEGIN + -- the test for a single driver is essential otherwise the + -- loop would return 'X' for a single driver of '-' and that + -- would conflict with the value of a single driver unresolved + -- signal. + IF (s'LENGTH = 1) THEN RETURN s(s'LOW); + ELSE + FOR i IN s'RANGE LOOP + result := resolution_table(result, s(i)); + END LOOP; + END IF; + RETURN result; + END resolved; + + ------------------------------------------------------------------- + -- tables for logical operations + ------------------------------------------------------------------- + + -- truth table for "and" function + CONSTANT and_table : stdlogic_table := ( + -- ---------------------------------------------------- + -- | U X 0 1 Z W L H - | | + -- ---------------------------------------------------- + ( 'U', 'U', '0', 'U', 'U', 'U', '0', 'U', 'U' ), -- | U | + ( 'U', 'X', '0', 'X', 'X', 'X', '0', 'X', 'X' ), -- | X | + ( '0', '0', '0', '0', '0', '0', '0', '0', '0' ), -- | 0 | + ( 'U', 'X', '0', '1', 'X', 'X', '0', '1', 'X' ), -- | 1 | + ( 'U', 'X', '0', 'X', 'X', 'X', '0', 'X', 'X' ), -- | Z | + ( 'U', 'X', '0', 'X', 'X', 'X', '0', 'X', 'X' ), -- | W | + ( '0', '0', '0', '0', '0', '0', '0', '0', '0' ), -- | L | + ( 'U', 'X', '0', '1', 'X', 'X', '0', '1', 'X' ), -- | H | + ( 'U', 'X', '0', 'X', 'X', 'X', '0', 'X', 'X' ) -- | - | + ); + + -- truth table for "or" function + CONSTANT or_table : stdlogic_table := ( + -- ---------------------------------------------------- + -- | U X 0 1 Z W L H - | | + -- ---------------------------------------------------- + ( 'U', 'U', 'U', '1', 'U', 'U', 'U', '1', 'U' ), -- | U | + ( 'U', 'X', 'X', '1', 'X', 'X', 'X', '1', 'X' ), -- | X | + ( 'U', 'X', '0', '1', 'X', 'X', '0', '1', 'X' ), -- | 0 | + ( '1', '1', '1', '1', '1', '1', '1', '1', '1' ), -- | 1 | + ( 'U', 'X', 'X', '1', 'X', 'X', 'X', '1', 'X' ), -- | Z | + ( 'U', 'X', 'X', '1', 'X', 'X', 'X', '1', 'X' ), -- | W | + ( 'U', 'X', '0', '1', 'X', 'X', '0', '1', 'X' ), -- | L | + ( '1', '1', '1', '1', '1', '1', '1', '1', '1' ), -- | H | + ( 'U', 'X', 'X', '1', 'X', 'X', 'X', '1', 'X' ) -- | - | + ); + + -- truth table for "xor" function + CONSTANT xor_table : stdlogic_table := ( + -- ---------------------------------------------------- + -- | U X 0 1 Z W L H - | | + -- ---------------------------------------------------- + ( 'U', 'U', 'U', 'U', 'U', 'U', 'U', 'U', 'U' ), -- | U | + ( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | X | + ( 'U', 'X', '0', '1', 'X', 'X', '0', '1', 'X' ), -- | 0 | + ( 'U', 'X', '1', '0', 'X', 'X', '1', '0', 'X' ), -- | 1 | + ( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | Z | + ( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | W | + ( 'U', 'X', '0', '1', 'X', 'X', '0', '1', 'X' ), -- | L | + ( 'U', 'X', '1', '0', 'X', 'X', '1', '0', 'X' ), -- | H | + ( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ) -- | - | + ); + + -- truth table for "not" function + CONSTANT not_table: stdlogic_1d := + -- ------------------------------------------------- + -- | U X 0 1 Z W L H - | + -- ------------------------------------------------- + ( 'U', 'X', '1', '0', 'X', 'X', '1', '0', 'X' ); + + ------------------------------------------------------------------- + -- overloaded logical operators ( with optimizing hints ) + ------------------------------------------------------------------- + + FUNCTION "and" ( l : std_ulogic; r : std_ulogic ) RETURN UX01 IS + BEGIN + RETURN (and_table(l, r)); + END "and"; + + FUNCTION "nand" ( l : std_ulogic; r : std_ulogic ) RETURN UX01 IS + BEGIN + RETURN (not_table ( and_table(l, r))); + END "nand"; + + FUNCTION "or" ( l : std_ulogic; r : std_ulogic ) RETURN UX01 IS + BEGIN + RETURN (or_table(l, r)); + END "or"; + + FUNCTION "nor" ( l : std_ulogic; r : std_ulogic ) RETURN UX01 IS + BEGIN + RETURN (not_table ( or_table( l, r ))); + END "nor"; + + FUNCTION "xor" ( l : std_ulogic; r : std_ulogic ) RETURN UX01 IS + BEGIN + RETURN (xor_table(l, r)); + END "xor"; + +--START-V93 + FUNCTION "xnor" ( l : std_ulogic; r : std_ulogic ) RETURN UX01 IS + BEGIN + RETURN not_table(xor_table(l, r)); + END "xnor"; +--END-V93 + + FUNCTION "not" ( l : std_ulogic ) RETURN UX01 IS + BEGIN + RETURN (not_table(l)); + END "not"; + + ------------------------------------------------------------------- + -- and + ------------------------------------------------------------------- + FUNCTION "and" ( l,r : std_logic_vector ) RETURN std_logic_vector IS + ALIAS lv : std_logic_vector ( 1 TO l'LENGTH ) IS l; + ALIAS rv : std_logic_vector ( 1 TO r'LENGTH ) IS r; + VARIABLE result : std_logic_vector ( 1 TO l'LENGTH ); + BEGIN + IF ( l'LENGTH /= r'LENGTH ) THEN + ASSERT FALSE + REPORT "arguments of overloaded 'and' operator are not of the same length" + SEVERITY FAILURE; + ELSE + FOR i IN result'RANGE LOOP + result(i) := and_table (lv(i), rv(i)); + END LOOP; + END IF; + RETURN result; + END "and"; + --------------------------------------------------------------------- + FUNCTION "and" ( l,r : std_ulogic_vector ) RETURN std_ulogic_vector IS + ALIAS lv : std_ulogic_vector ( 1 TO l'LENGTH ) IS l; + ALIAS rv : std_ulogic_vector ( 1 TO r'LENGTH ) IS r; + VARIABLE result : std_ulogic_vector ( 1 TO l'LENGTH ); + BEGIN + IF ( l'LENGTH /= r'LENGTH ) THEN + ASSERT FALSE + REPORT "arguments of overloaded 'and' operator are not of the same length" + SEVERITY FAILURE; + ELSE + FOR i IN result'RANGE LOOP + result(i) := and_table (lv(i), rv(i)); + END LOOP; + END IF; + RETURN result; + END "and"; + ------------------------------------------------------------------- + -- nand + ------------------------------------------------------------------- + FUNCTION "nand" ( l,r : std_logic_vector ) RETURN std_logic_vector IS + ALIAS lv : std_logic_vector ( 1 TO l'LENGTH ) IS l; + ALIAS rv : std_logic_vector ( 1 TO r'LENGTH ) IS r; + VARIABLE result : std_logic_vector ( 1 TO l'LENGTH ); + BEGIN + IF ( l'LENGTH /= r'LENGTH ) THEN + ASSERT FALSE + REPORT "arguments of overloaded 'nand' operator are not of the same length" + SEVERITY FAILURE; + ELSE + FOR i IN result'RANGE LOOP + result(i) := not_table(and_table (lv(i), rv(i))); + END LOOP; + END IF; + RETURN result; + END "nand"; + --------------------------------------------------------------------- + FUNCTION "nand" ( l,r : std_ulogic_vector ) RETURN std_ulogic_vector IS + ALIAS lv : std_ulogic_vector ( 1 TO l'LENGTH ) IS l; + ALIAS rv : std_ulogic_vector ( 1 TO r'LENGTH ) IS r; + VARIABLE result : std_ulogic_vector ( 1 TO l'LENGTH ); + BEGIN + IF ( l'LENGTH /= r'LENGTH ) THEN + ASSERT FALSE + REPORT "arguments of overloaded 'nand' operator are not of the same length" + SEVERITY FAILURE; + ELSE + FOR i IN result'RANGE LOOP + result(i) := not_table(and_table (lv(i), rv(i))); + END LOOP; + END IF; + RETURN result; + END "nand"; + ------------------------------------------------------------------- + -- or + ------------------------------------------------------------------- + FUNCTION "or" ( l,r : std_logic_vector ) RETURN std_logic_vector IS + ALIAS lv : std_logic_vector ( 1 TO l'LENGTH ) IS l; + ALIAS rv : std_logic_vector ( 1 TO r'LENGTH ) IS r; + VARIABLE result : std_logic_vector ( 1 TO l'LENGTH ); + BEGIN + IF ( l'LENGTH /= r'LENGTH ) THEN + ASSERT FALSE + REPORT "arguments of overloaded 'or' operator are not of the same length" + SEVERITY FAILURE; + ELSE + FOR i IN result'RANGE LOOP + result(i) := or_table (lv(i), rv(i)); + END LOOP; + END IF; + RETURN result; + END "or"; + --------------------------------------------------------------------- + FUNCTION "or" ( l,r : std_ulogic_vector ) RETURN std_ulogic_vector IS + ALIAS lv : std_ulogic_vector ( 1 TO l'LENGTH ) IS l; + ALIAS rv : std_ulogic_vector ( 1 TO r'LENGTH ) IS r; + VARIABLE result : std_ulogic_vector ( 1 TO l'LENGTH ); + BEGIN + IF ( l'LENGTH /= r'LENGTH ) THEN + ASSERT FALSE + REPORT "arguments of overloaded 'or' operator are not of the same length" + SEVERITY FAILURE; + ELSE + FOR i IN result'RANGE LOOP + result(i) := or_table (lv(i), rv(i)); + END LOOP; + END IF; + RETURN result; + END "or"; + ------------------------------------------------------------------- + -- nor + ------------------------------------------------------------------- + FUNCTION "nor" ( l,r : std_logic_vector ) RETURN std_logic_vector IS + ALIAS lv : std_logic_vector ( 1 TO l'LENGTH ) IS l; + ALIAS rv : std_logic_vector ( 1 TO r'LENGTH ) IS r; + VARIABLE result : std_logic_vector ( 1 TO l'LENGTH ); + BEGIN + IF ( l'LENGTH /= r'LENGTH ) THEN + ASSERT FALSE + REPORT "arguments of overloaded 'nor' operator are not of the same length" + SEVERITY FAILURE; + ELSE + FOR i IN result'RANGE LOOP + result(i) := not_table(or_table (lv(i), rv(i))); + END LOOP; + END IF; + RETURN result; + END "nor"; + --------------------------------------------------------------------- + FUNCTION "nor" ( l,r : std_ulogic_vector ) RETURN std_ulogic_vector IS + ALIAS lv : std_ulogic_vector ( 1 TO l'LENGTH ) IS l; + ALIAS rv : std_ulogic_vector ( 1 TO r'LENGTH ) IS r; + VARIABLE result : std_ulogic_vector ( 1 TO l'LENGTH ); + BEGIN + IF ( l'LENGTH /= r'LENGTH ) THEN + ASSERT FALSE + REPORT "arguments of overloaded 'nor' operator are not of the same length" + SEVERITY FAILURE; + ELSE + FOR i IN result'RANGE LOOP + result(i) := not_table(or_table (lv(i), rv(i))); + END LOOP; + END IF; + RETURN result; + END "nor"; + --------------------------------------------------------------------- + -- xor + ------------------------------------------------------------------- + FUNCTION "xor" ( l,r : std_logic_vector ) RETURN std_logic_vector IS + ALIAS lv : std_logic_vector ( 1 TO l'LENGTH ) IS l; + ALIAS rv : std_logic_vector ( 1 TO r'LENGTH ) IS r; + VARIABLE result : std_logic_vector ( 1 TO l'LENGTH ); + BEGIN + IF ( l'LENGTH /= r'LENGTH ) THEN + ASSERT FALSE + REPORT "arguments of overloaded 'xor' operator are not of the same length" + SEVERITY FAILURE; + ELSE + FOR i IN result'RANGE LOOP + result(i) := xor_table (lv(i), rv(i)); + END LOOP; + END IF; + RETURN result; + END "xor"; + --------------------------------------------------------------------- + FUNCTION "xor" ( l,r : std_ulogic_vector ) RETURN std_ulogic_vector IS + ALIAS lv : std_ulogic_vector ( 1 TO l'LENGTH ) IS l; + ALIAS rv : std_ulogic_vector ( 1 TO r'LENGTH ) IS r; + VARIABLE result : std_ulogic_vector ( 1 TO l'LENGTH ); + BEGIN + IF ( l'LENGTH /= r'LENGTH ) THEN + ASSERT FALSE + REPORT "arguments of overloaded 'xor' operator are not of the same length" + SEVERITY FAILURE; + ELSE + FOR i IN result'RANGE LOOP + result(i) := xor_table (lv(i), rv(i)); + END LOOP; + END IF; + RETURN result; + END "xor"; +-- ------------------------------------------------------------------- +-- -- xnor +-- ------------------------------------------------------------------- +-- ----------------------------------------------------------------------- +-- Note : The declaration and implementation of the "xnor" function is +-- specifically commented until at which time the VHDL language has been +-- officially adopted as containing such a function. At such a point, +-- the following comments may be removed along with this notice without +-- further "official" ballotting of this std_logic_1164 package. It is +-- the intent of this effort to provide such a function once it becomes +-- available in the VHDL standard. +-- ----------------------------------------------------------------------- +--START-V93 + FUNCTION "xnor" ( l,r : std_logic_vector ) RETURN std_logic_vector IS + ALIAS lv : std_logic_vector ( 1 TO l'LENGTH ) IS l; + ALIAS rv : std_logic_vector ( 1 TO r'LENGTH ) IS r; + VARIABLE result : std_logic_vector ( 1 TO l'LENGTH ); + BEGIN + IF ( l'LENGTH /= r'LENGTH ) THEN + ASSERT FALSE + REPORT "arguments of overloaded 'xnor' operator are not of the same length" + SEVERITY FAILURE; + ELSE + FOR i IN result'RANGE LOOP + result(i) := not_table(xor_table (lv(i), rv(i))); + END LOOP; + END IF; + RETURN result; + END "xnor"; + --------------------------------------------------------------------- + FUNCTION "xnor" ( l,r : std_ulogic_vector ) RETURN std_ulogic_vector IS + ALIAS lv : std_ulogic_vector ( 1 TO l'LENGTH ) IS l; + ALIAS rv : std_ulogic_vector ( 1 TO r'LENGTH ) IS r; + VARIABLE result : std_ulogic_vector ( 1 TO l'LENGTH ); + BEGIN + IF ( l'LENGTH /= r'LENGTH ) THEN + ASSERT FALSE + REPORT "arguments of overloaded 'xnor' operator are not of the same length" + SEVERITY FAILURE; + ELSE + FOR i IN result'RANGE LOOP + result(i) := not_table(xor_table (lv(i), rv(i))); + END LOOP; + END IF; + RETURN result; + END "xnor"; +--END-V93 + ------------------------------------------------------------------- + -- not + ------------------------------------------------------------------- + FUNCTION "not" ( l : std_logic_vector ) RETURN std_logic_vector IS + ALIAS lv : std_logic_vector ( 1 TO l'LENGTH ) IS l; + VARIABLE result : std_logic_vector ( 1 TO l'LENGTH ) := (OTHERS => 'X'); + BEGIN + FOR i IN result'RANGE LOOP + result(i) := not_table( lv(i) ); + END LOOP; + RETURN result; + END; + --------------------------------------------------------------------- + FUNCTION "not" ( l : std_ulogic_vector ) RETURN std_ulogic_vector IS + ALIAS lv : std_ulogic_vector ( 1 TO l'LENGTH ) IS l; + VARIABLE result : std_ulogic_vector ( 1 TO l'LENGTH ) := (OTHERS => 'X'); + BEGIN + FOR i IN result'RANGE LOOP + result(i) := not_table( lv(i) ); + END LOOP; + RETURN result; + END; + ------------------------------------------------------------------- + -- conversion tables + ------------------------------------------------------------------- + TYPE logic_x01_table IS ARRAY (std_ulogic'LOW TO std_ulogic'HIGH) OF X01; + TYPE logic_x01z_table IS ARRAY (std_ulogic'LOW TO std_ulogic'HIGH) OF X01Z; + TYPE logic_ux01_table IS ARRAY (std_ulogic'LOW TO std_ulogic'HIGH) OF UX01; + ---------------------------------------------------------- + -- table name : cvt_to_x01 + -- + -- parameters : + -- in : std_ulogic -- some logic value + -- returns : x01 -- state value of logic value + -- purpose : to convert state-strength to state only + -- + -- example : if (cvt_to_x01 (input_signal) = '1' ) then ... + -- + ---------------------------------------------------------- + CONSTANT cvt_to_x01 : logic_x01_table := ( + 'X', -- 'U' + 'X', -- 'X' + '0', -- '0' + '1', -- '1' + 'X', -- 'Z' + 'X', -- 'W' + '0', -- 'L' + '1', -- 'H' + 'X' -- '-' + ); + + ---------------------------------------------------------- + -- table name : cvt_to_x01z + -- + -- parameters : + -- in : std_ulogic -- some logic value + -- returns : x01z -- state value of logic value + -- purpose : to convert state-strength to state only + -- + -- example : if (cvt_to_x01z (input_signal) = '1' ) then ... + -- + ---------------------------------------------------------- + CONSTANT cvt_to_x01z : logic_x01z_table := ( + 'X', -- 'U' + 'X', -- 'X' + '0', -- '0' + '1', -- '1' + 'Z', -- 'Z' + 'X', -- 'W' + '0', -- 'L' + '1', -- 'H' + 'X' -- '-' + ); + + ---------------------------------------------------------- + -- table name : cvt_to_ux01 + -- + -- parameters : + -- in : std_ulogic -- some logic value + -- returns : ux01 -- state value of logic value + -- purpose : to convert state-strength to state only + -- + -- example : if (cvt_to_ux01 (input_signal) = '1' ) then ... + -- + ---------------------------------------------------------- + CONSTANT cvt_to_ux01 : logic_ux01_table := ( + 'U', -- 'U' + 'X', -- 'X' + '0', -- '0' + '1', -- '1' + 'X', -- 'Z' + 'X', -- 'W' + '0', -- 'L' + '1', -- 'H' + 'X' -- '-' + ); + + ------------------------------------------------------------------- + -- conversion functions + ------------------------------------------------------------------- + FUNCTION To_bit ( s : std_ulogic; xmap : BIT := '0') RETURN BIT IS + BEGIN + CASE s IS + WHEN '0' | 'L' => RETURN ('0'); + WHEN '1' | 'H' => RETURN ('1'); + WHEN OTHERS => RETURN xmap; + END CASE; + END; + -------------------------------------------------------------------- + FUNCTION To_bitvector ( s : std_logic_vector ; xmap : BIT := '0') RETURN BIT_VECTOR IS + ALIAS sv : std_logic_vector ( s'LENGTH-1 DOWNTO 0 ) IS s; + VARIABLE result : BIT_VECTOR ( s'LENGTH-1 DOWNTO 0 ); + BEGIN + FOR i IN result'RANGE LOOP + CASE sv(i) IS + WHEN '0' | 'L' => result(i) := '0'; + WHEN '1' | 'H' => result(i) := '1'; + WHEN OTHERS => result(i) := xmap; + END CASE; + END LOOP; + RETURN result; + END; + -------------------------------------------------------------------- + FUNCTION To_bitvector ( s : std_ulogic_vector; xmap : BIT := '0') RETURN BIT_VECTOR IS + ALIAS sv : std_ulogic_vector ( s'LENGTH-1 DOWNTO 0 ) IS s; + VARIABLE result : BIT_VECTOR ( s'LENGTH-1 DOWNTO 0 ); + BEGIN + FOR i IN result'RANGE LOOP + CASE sv(i) IS + WHEN '0' | 'L' => result(i) := '0'; + WHEN '1' | 'H' => result(i) := '1'; + WHEN OTHERS => result(i) := xmap; + END CASE; + END LOOP; + RETURN result; + END; + -------------------------------------------------------------------- + FUNCTION To_StdULogic ( b : BIT ) RETURN std_ulogic IS + BEGIN + CASE b IS + WHEN '0' => RETURN '0'; + WHEN '1' => RETURN '1'; + END CASE; + END; + -------------------------------------------------------------------- + FUNCTION To_StdLogicVector ( b : BIT_VECTOR ) RETURN std_logic_vector IS + ALIAS bv : BIT_VECTOR ( b'LENGTH-1 DOWNTO 0 ) IS b; + VARIABLE result : std_logic_vector ( b'LENGTH-1 DOWNTO 0 ); + BEGIN + FOR i IN result'RANGE LOOP + CASE bv(i) IS + WHEN '0' => result(i) := '0'; + WHEN '1' => result(i) := '1'; + END CASE; + END LOOP; + RETURN result; + END; + -------------------------------------------------------------------- + FUNCTION To_StdLogicVector ( s : std_ulogic_vector ) RETURN std_logic_vector IS + ALIAS sv : std_ulogic_vector ( s'LENGTH-1 DOWNTO 0 ) IS s; + VARIABLE result : std_logic_vector ( s'LENGTH-1 DOWNTO 0 ); + BEGIN + FOR i IN result'RANGE LOOP + result(i) := sv(i); + END LOOP; + RETURN result; + END; + -------------------------------------------------------------------- + FUNCTION To_StdULogicVector ( b : BIT_VECTOR ) RETURN std_ulogic_vector IS + ALIAS bv : BIT_VECTOR ( b'LENGTH-1 DOWNTO 0 ) IS b; + VARIABLE result : std_ulogic_vector ( b'LENGTH-1 DOWNTO 0 ); + BEGIN + FOR i IN result'RANGE LOOP + CASE bv(i) IS + WHEN '0' => result(i) := '0'; + WHEN '1' => result(i) := '1'; + END CASE; + END LOOP; + RETURN result; + END; + -------------------------------------------------------------------- + FUNCTION To_StdULogicVector ( s : std_logic_vector ) RETURN std_ulogic_vector IS + ALIAS sv : std_logic_vector ( s'LENGTH-1 DOWNTO 0 ) IS s; + VARIABLE result : std_ulogic_vector ( s'LENGTH-1 DOWNTO 0 ); + BEGIN + FOR i IN result'RANGE LOOP + result(i) := sv(i); + END LOOP; + RETURN result; + END; + + ------------------------------------------------------------------- + -- strength strippers and type convertors + ------------------------------------------------------------------- + -- to_x01 + ------------------------------------------------------------------- + FUNCTION To_X01 ( s : std_logic_vector ) RETURN std_logic_vector IS + ALIAS sv : std_logic_vector ( 1 TO s'LENGTH ) IS s; + VARIABLE result : std_logic_vector ( 1 TO s'LENGTH ); + BEGIN + FOR i IN result'RANGE LOOP + result(i) := cvt_to_x01 (sv(i)); + END LOOP; + RETURN result; + END; + -------------------------------------------------------------------- + FUNCTION To_X01 ( s : std_ulogic_vector ) RETURN std_ulogic_vector IS + ALIAS sv : std_ulogic_vector ( 1 TO s'LENGTH ) IS s; + VARIABLE result : std_ulogic_vector ( 1 TO s'LENGTH ); + BEGIN + FOR i IN result'RANGE LOOP + result(i) := cvt_to_x01 (sv(i)); + END LOOP; + RETURN result; + END; + -------------------------------------------------------------------- + FUNCTION To_X01 ( s : std_ulogic ) RETURN X01 IS + BEGIN + RETURN (cvt_to_x01(s)); + END; + -------------------------------------------------------------------- + FUNCTION To_X01 ( b : BIT_VECTOR ) RETURN std_logic_vector IS + ALIAS bv : BIT_VECTOR ( 1 TO b'LENGTH ) IS b; + VARIABLE result : std_logic_vector ( 1 TO b'LENGTH ); + BEGIN + FOR i IN result'RANGE LOOP + CASE bv(i) IS + WHEN '0' => result(i) := '0'; + WHEN '1' => result(i) := '1'; + END CASE; + END LOOP; + RETURN result; + END; + -------------------------------------------------------------------- + FUNCTION To_X01 ( b : BIT_VECTOR ) RETURN std_ulogic_vector IS + ALIAS bv : BIT_VECTOR ( 1 TO b'LENGTH ) IS b; + VARIABLE result : std_ulogic_vector ( 1 TO b'LENGTH ); + BEGIN + FOR i IN result'RANGE LOOP + CASE bv(i) IS + WHEN '0' => result(i) := '0'; + WHEN '1' => result(i) := '1'; + END CASE; + END LOOP; + RETURN result; + END; + -------------------------------------------------------------------- + FUNCTION To_X01 ( b : BIT ) RETURN X01 IS + BEGIN + CASE b IS + WHEN '0' => RETURN('0'); + WHEN '1' => RETURN('1'); + END CASE; + END; + -------------------------------------------------------------------- + -- to_x01z + ------------------------------------------------------------------- + FUNCTION To_X01Z ( s : std_logic_vector ) RETURN std_logic_vector IS + ALIAS sv : std_logic_vector ( 1 TO s'LENGTH ) IS s; + VARIABLE result : std_logic_vector ( 1 TO s'LENGTH ); + BEGIN + FOR i IN result'RANGE LOOP + result(i) := cvt_to_x01z (sv(i)); + END LOOP; + RETURN result; + END; + -------------------------------------------------------------------- + FUNCTION To_X01Z ( s : std_ulogic_vector ) RETURN std_ulogic_vector IS + ALIAS sv : std_ulogic_vector ( 1 TO s'LENGTH ) IS s; + VARIABLE result : std_ulogic_vector ( 1 TO s'LENGTH ); + BEGIN + FOR i IN result'RANGE LOOP + result(i) := cvt_to_x01z (sv(i)); + END LOOP; + RETURN result; + END; + -------------------------------------------------------------------- + FUNCTION To_X01Z ( s : std_ulogic ) RETURN X01Z IS + BEGIN + RETURN (cvt_to_x01z(s)); + END; + -------------------------------------------------------------------- + FUNCTION To_X01Z ( b : BIT_VECTOR ) RETURN std_logic_vector IS + ALIAS bv : BIT_VECTOR ( 1 TO b'LENGTH ) IS b; + VARIABLE result : std_logic_vector ( 1 TO b'LENGTH ); + BEGIN + FOR i IN result'RANGE LOOP + CASE bv(i) IS + WHEN '0' => result(i) := '0'; + WHEN '1' => result(i) := '1'; + END CASE; + END LOOP; + RETURN result; + END; + -------------------------------------------------------------------- + FUNCTION To_X01Z ( b : BIT_VECTOR ) RETURN std_ulogic_vector IS + ALIAS bv : BIT_VECTOR ( 1 TO b'LENGTH ) IS b; + VARIABLE result : std_ulogic_vector ( 1 TO b'LENGTH ); + BEGIN + FOR i IN result'RANGE LOOP + CASE bv(i) IS + WHEN '0' => result(i) := '0'; + WHEN '1' => result(i) := '1'; + END CASE; + END LOOP; + RETURN result; + END; + -------------------------------------------------------------------- + FUNCTION To_X01Z ( b : BIT ) RETURN X01Z IS + BEGIN + CASE b IS + WHEN '0' => RETURN('0'); + WHEN '1' => RETURN('1'); + END CASE; + END; + -------------------------------------------------------------------- + -- to_ux01 + ------------------------------------------------------------------- + FUNCTION To_UX01 ( s : std_logic_vector ) RETURN std_logic_vector IS + ALIAS sv : std_logic_vector ( 1 TO s'LENGTH ) IS s; + VARIABLE result : std_logic_vector ( 1 TO s'LENGTH ); + BEGIN + FOR i IN result'RANGE LOOP + result(i) := cvt_to_ux01 (sv(i)); + END LOOP; + RETURN result; + END; + -------------------------------------------------------------------- + FUNCTION To_UX01 ( s : std_ulogic_vector ) RETURN std_ulogic_vector IS + ALIAS sv : std_ulogic_vector ( 1 TO s'LENGTH ) IS s; + VARIABLE result : std_ulogic_vector ( 1 TO s'LENGTH ); + BEGIN + FOR i IN result'RANGE LOOP + result(i) := cvt_to_ux01 (sv(i)); + END LOOP; + RETURN result; + END; + -------------------------------------------------------------------- + FUNCTION To_UX01 ( s : std_ulogic ) RETURN UX01 IS + BEGIN + RETURN (cvt_to_ux01(s)); + END; + -------------------------------------------------------------------- + FUNCTION To_UX01 ( b : BIT_VECTOR ) RETURN std_logic_vector IS + ALIAS bv : BIT_VECTOR ( 1 TO b'LENGTH ) IS b; + VARIABLE result : std_logic_vector ( 1 TO b'LENGTH ); + BEGIN + FOR i IN result'RANGE LOOP + CASE bv(i) IS + WHEN '0' => result(i) := '0'; + WHEN '1' => result(i) := '1'; + END CASE; + END LOOP; + RETURN result; + END; + -------------------------------------------------------------------- + FUNCTION To_UX01 ( b : BIT_VECTOR ) RETURN std_ulogic_vector IS + ALIAS bv : BIT_VECTOR ( 1 TO b'LENGTH ) IS b; + VARIABLE result : std_ulogic_vector ( 1 TO b'LENGTH ); + BEGIN + FOR i IN result'RANGE LOOP + CASE bv(i) IS + WHEN '0' => result(i) := '0'; + WHEN '1' => result(i) := '1'; + END CASE; + END LOOP; + RETURN result; + END; + -------------------------------------------------------------------- + FUNCTION To_UX01 ( b : BIT ) RETURN UX01 IS + BEGIN + CASE b IS + WHEN '0' => RETURN('0'); + WHEN '1' => RETURN('1'); + END CASE; + END; + + ------------------------------------------------------------------- + -- edge detection + ------------------------------------------------------------------- + FUNCTION rising_edge (SIGNAL s : std_ulogic) RETURN BOOLEAN IS + BEGIN + RETURN (s'EVENT AND (To_X01(s) = '1') AND + (To_X01(s'LAST_VALUE) = '0')); + END; + + FUNCTION falling_edge (SIGNAL s : std_ulogic) RETURN BOOLEAN IS + BEGIN + RETURN (s'EVENT AND (To_X01(s) = '0') AND + (To_X01(s'LAST_VALUE) = '1')); + END; + + ------------------------------------------------------------------- + -- object contains an unknown + ------------------------------------------------------------------- + FUNCTION Is_X ( s : std_ulogic_vector ) RETURN BOOLEAN IS + BEGIN + FOR i IN s'RANGE LOOP + CASE s(i) IS + WHEN 'U' | 'X' | 'Z' | 'W' | '-' => RETURN TRUE; + WHEN OTHERS => NULL; + END CASE; + END LOOP; + RETURN FALSE; + END; + -------------------------------------------------------------------- + FUNCTION Is_X ( s : std_logic_vector ) RETURN BOOLEAN IS + BEGIN + FOR i IN s'RANGE LOOP + CASE s(i) IS + WHEN 'U' | 'X' | 'Z' | 'W' | '-' => RETURN TRUE; + WHEN OTHERS => NULL; + END CASE; + END LOOP; + RETURN FALSE; + END; + -------------------------------------------------------------------- + FUNCTION Is_X ( s : std_ulogic ) RETURN BOOLEAN IS + BEGIN + CASE s IS + WHEN 'U' | 'X' | 'Z' | 'W' | '-' => RETURN TRUE; + WHEN OTHERS => NULL; + END CASE; + RETURN FALSE; + END; + +END std_logic_1164; -- cgit v1.2.3