aboutsummaryrefslogtreecommitdiffstats
path: root/libraries/ieee
diff options
context:
space:
mode:
authorgingold <gingold@b72b5c32-5f01-0410-b925-b5c7b92870f7>2005-09-24 05:10:24 +0000
committergingold <gingold@b72b5c32-5f01-0410-b925-b5c7b92870f7>2005-09-24 05:10:24 +0000
commit977ff5e02c6d2f9bfdabcf8b4e98b81e2d83e849 (patch)
tree7bcf8e7aff40a8b54d4af83e90cccd73568e77bb /libraries/ieee
downloadghdl-977ff5e02c6d2f9bfdabcf8b4e98b81e2d83e849.tar.gz
ghdl-977ff5e02c6d2f9bfdabcf8b4e98b81e2d83e849.tar.bz2
ghdl-977ff5e02c6d2f9bfdabcf8b4e98b81e2d83e849.zip
First import from sources
Diffstat (limited to 'libraries/ieee')
-rw-r--r--libraries/ieee/math_complex-body.vhdl394
-rw-r--r--libraries/ieee/math_complex.vhdl126
-rw-r--r--libraries/ieee/math_real-body.vhdl410
-rw-r--r--libraries/ieee/math_real.vhdl223
-rw-r--r--libraries/ieee/numeric_bit-body.vhdl1818
-rw-r--r--libraries/ieee/numeric_bit.vhdl813
-rw-r--r--libraries/ieee/numeric_std-body.vhdl2545
-rw-r--r--libraries/ieee/numeric_std.vhdl853
-rw-r--r--libraries/ieee/std_logic_1164.vhdl175
-rw-r--r--libraries/ieee/std_logic_1164_body.vhdl830
10 files changed, 8187 insertions, 0 deletions
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;
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-07 18:19:24 +0000