From 8c5a743259480ebd0cfdbb17fbde8584e34b2aa4 Mon Sep 17 00:00:00 2001 From: Bert Lange Date: Wed, 15 Apr 2015 13:54:39 +0200 Subject: clean up --- ieee_proposed/rtl/numeric_std_additions.vhd | 2886 --------------------------- 1 file changed, 2886 deletions(-) delete mode 100644 ieee_proposed/rtl/numeric_std_additions.vhd (limited to 'ieee_proposed/rtl/numeric_std_additions.vhd') diff --git a/ieee_proposed/rtl/numeric_std_additions.vhd b/ieee_proposed/rtl/numeric_std_additions.vhd deleted file mode 100644 index 4440d27..0000000 --- a/ieee_proposed/rtl/numeric_std_additions.vhd +++ /dev/null @@ -1,2886 +0,0 @@ ------------------------------------------------------------------------------- --- "numeric_std_additions" package contains the additions to the standard --- "numeric_std" package proposed by the VHDL-200X-ft working group. --- This package should be compiled into "ieee_proposed" and used as follows: --- use ieee.std_logic_1164.all; --- use ieee.numeric_std.all; --- use ieee_proposed.numeric_std_additions.all; --- (this package is independant of "std_logic_1164_additions") --- Last Modified: $Date: 2007/09/27 14:46:32 $ --- RCS ID: $Id: numeric_std_additions.vhdl,v 1.9 2007/09/27 14:46:32 l435385 Exp $ --- --- Created for VHDL-200X par, David Bishop (dbishop@vhdl.org) ------------------------------------------------------------------------------- -library ieee; -use ieee.std_logic_1164.all; -use ieee.numeric_std.all; -use std.textio.all; - -package numeric_std_additions is - -- Make these a subtype of "signed" and "unsigned" for compatability --- type UNRESOLVED_UNSIGNED is array (NATURAL range <>) of STD_ULOGIC; --- type UNRESOLVED_SIGNED is array (NATURAL range <>) of STD_ULOGIC; - - subtype UNRESOLVED_UNSIGNED is UNSIGNED; - subtype UNRESOLVED_SIGNED is SIGNED; --- alias U_UNSIGNED is UNRESOLVED_UNSIGNED; --- alias U_SIGNED is UNRESOLVED_SIGNED; - subtype U_UNSIGNED is UNSIGNED; - subtype U_SIGNED is SIGNED; - - -- Id: A.3R - function "+"(L : UNSIGNED; R : STD_ULOGIC) return UNSIGNED; - -- Result subtype: UNSIGNED(L'RANGE) - -- Result: Similar to A.3 where R is a one bit UNSIGNED - - -- Id: A.3L - function "+"(L : STD_ULOGIC; R : UNSIGNED) return UNSIGNED; - -- Result subtype: UNSIGNED(R'RANGE) - -- Result: Similar to A.3 where L is a one bit UNSIGNED - - -- Id: A.4R - function "+"(L : SIGNED; R : STD_ULOGIC) return SIGNED; - -- Result subtype: SIGNED(L'RANGE) - -- Result: Similar to A.4 where R is bit 0 of a non-negative - -- SIGNED - - -- Id: A.4L - function "+"(L : STD_ULOGIC; R : SIGNED) return SIGNED; - -- Result subtype: UNSIGNED(R'RANGE) - -- Result: Similar to A.4 where L is bit 0 of a non-negative - -- SIGNED - -- Id: A.9R - function "-"(L : UNSIGNED; R : STD_ULOGIC) return UNSIGNED; - -- Result subtype: UNSIGNED(L'RANGE) - -- Result: Similar to A.9 where R is a one bit UNSIGNED - - -- Id: A.9L - function "-"(L : STD_ULOGIC; R : UNSIGNED) return UNSIGNED; - -- Result subtype: UNSIGNED(R'RANGE) - -- Result: Similar to A.9 where L is a one bit UNSIGNED - - -- Id: A.10R - function "-"(L : SIGNED; R : STD_ULOGIC) return SIGNED; - -- Result subtype: SIGNED(L'RANGE) - -- Result: Similar to A.10 where R is bit 0 of a non-negative - -- SIGNED - - -- Id: A.10L - function "-"(L : STD_ULOGIC; R : SIGNED) return SIGNED; - -- Result subtype: UNSIGNED(R'RANGE) - -- Result: Similar to A.10 where R is bit 0 of a non-negative - -- SIGNED - - -- Id: M.2B - -- %%% function "?=" (L, R : UNSIGNED) return std_ulogic; - -- %%% function "?/=" (L, R : UNSIGNED) return std_ulogic; - -- %%% function "?>" (L, R : UNSIGNED) return std_ulogic; - -- %%% function "?>=" (L, R : UNSIGNED) return std_ulogic; - -- %%% function "?<" (L, R : UNSIGNED) return std_ulogic; - -- %%% function "?<=" (L, R : UNSIGNED) return std_ulogic; --- function \?=\ (L, R : UNSIGNED) return STD_ULOGIC; --- function \?/=\ (L, R : UNSIGNED) return STD_ULOGIC; - function \?>\ (L, R : UNSIGNED) return STD_ULOGIC; - function \?>=\ (L, R : UNSIGNED) return STD_ULOGIC; - function \?<\ (L, R : UNSIGNED) return STD_ULOGIC; - function \?<=\ (L, R : UNSIGNED) return STD_ULOGIC; --- function \?=\ (L : UNSIGNED; R : NATURAL) return STD_ULOGIC; --- function \?/=\ (L : UNSIGNED; R : NATURAL) return STD_ULOGIC; - function \?>\ (L : UNSIGNED; R : NATURAL) return STD_ULOGIC; - function \?>=\ (L : UNSIGNED; R : NATURAL) return STD_ULOGIC; - function \?<\ (L : UNSIGNED; R : NATURAL) return STD_ULOGIC; - function \?<=\ (L : UNSIGNED; R : NATURAL) return STD_ULOGIC; --- function \?=\ (L : NATURAL; R : UNSIGNED) return STD_ULOGIC; --- function \?/=\ (L : NATURAL; R : UNSIGNED) return STD_ULOGIC; - function \?>\ (L : NATURAL; R : UNSIGNED) return STD_ULOGIC; - function \?>=\ (L : NATURAL; R : UNSIGNED) return STD_ULOGIC; - function \?<\ (L : NATURAL; R : UNSIGNED) return STD_ULOGIC; - function \?<=\ (L : NATURAL; R : UNSIGNED) return STD_ULOGIC; - -- Result subtype: STD_ULOGIC - -- Result: terms compared per STD_LOGIC_1164 intent, - -- returns an 'X' if a metavalue is passed - - -- Id: M.3B - -- %%% function "?=" (L, R : SIGNED) return std_ulogic; - -- %%% function "?/=" (L, R : SIGNED) return std_ulogic; - -- %%% function "?>" (L, R : SIGNED) return std_ulogic; - -- %%% function "?>=" (L, R : SIGNED) return std_ulogic; - -- %%% function "?<" (L, R : SIGNED) return std_ulogic; - -- %%% function "?<=" (L, R : SIGNED) return std_ulogic; --- function \?=\ (L, R : SIGNED) return STD_ULOGIC; --- function \?/=\ (L, R : SIGNED) return STD_ULOGIC; - function \?>\ (L, R : SIGNED) return STD_ULOGIC; - function \?>=\ (L, R : SIGNED) return STD_ULOGIC; - function \?<\ (L, R : SIGNED) return STD_ULOGIC; - function \?<=\ (L, R : SIGNED) return STD_ULOGIC; --- function \?=\ (L : SIGNED; R : INTEGER) return STD_ULOGIC; --- function \?/=\ (L : SIGNED; R : INTEGER) return STD_ULOGIC; - function \?>\ (L : SIGNED; R : INTEGER) return STD_ULOGIC; - function \?>=\ (L : SIGNED; R : INTEGER) return STD_ULOGIC; - function \?<\ (L : SIGNED; R : INTEGER) return STD_ULOGIC; - function \?<=\ (L : SIGNED; R : INTEGER) return STD_ULOGIC; --- function \?=\ (L : INTEGER; R : SIGNED) return STD_ULOGIC; --- function \?/=\ (L : INTEGER; R : SIGNED) return STD_ULOGIC; - function \?>\ (L : INTEGER; R : SIGNED) return STD_ULOGIC; - function \?>=\ (L : INTEGER; R : SIGNED) return STD_ULOGIC; - function \?<\ (L : INTEGER; R : SIGNED) return STD_ULOGIC; - function \?<=\ (L : INTEGER; R : SIGNED) return STD_ULOGIC; - -- Result subtype: std_ulogic - -- Result: terms compared per STD_LOGIC_1164 intent, - -- returns an 'X' if a metavalue is passed - - -- size_res versions of these functions (Bugzilla 165) - function TO_UNSIGNED (ARG : NATURAL; SIZE_RES : UNSIGNED) return UNSIGNED; - -- Result subtype: UNRESOLVED_UNSIGNED(SIZE_RES'length-1 downto 0) - function TO_SIGNED (ARG : INTEGER; SIZE_RES : SIGNED) return SIGNED; - -- Result subtype: UNRESOLVED_SIGNED(SIZE_RES'length-1 downto 0) - function RESIZE (ARG, SIZE_RES : UNSIGNED) return UNSIGNED; - -- Result subtype: UNRESOLVED_UNSIGNED (SIZE_RES'length-1 downto 0) - function RESIZE (ARG, SIZE_RES : SIGNED) return SIGNED; - -- Result subtype: UNRESOLVED_SIGNED (SIZE_RES'length-1 downto 0) - ----------------------------------------------------------------------------- - -- New/updated funcitons for VHDL-200X fast track - ----------------------------------------------------------------------------- - - -- Overloaded functions from "std_logic_1164" - function To_X01 (s : UNSIGNED) return UNSIGNED; - function To_X01 (s : SIGNED) return SIGNED; - - function To_X01Z (s : UNSIGNED) return UNSIGNED; - function To_X01Z (s : SIGNED) return SIGNED; - - function To_UX01 (s : UNSIGNED) return UNSIGNED; - function To_UX01 (s : SIGNED) return SIGNED; - - function Is_X (s : UNSIGNED) return BOOLEAN; - function Is_X (s : SIGNED) return BOOLEAN; - - function "sla" (ARG : SIGNED; COUNT : INTEGER) return SIGNED; - function "sla" (ARG : UNSIGNED; COUNT : INTEGER) return UNSIGNED; - - function "sra" (ARG : SIGNED; COUNT : INTEGER) return SIGNED; - function "sra" (ARG : UNSIGNED; COUNT : INTEGER) return UNSIGNED; - - -- Returns the maximum (or minimum) of the two numbers provided. - -- All types (both inputs and the output) must be the same. - -- These override the implicit funcitons, using the local ">" operator - function maximum ( - l, r : UNSIGNED) -- inputs - return UNSIGNED; - - function maximum ( - l, r : SIGNED) -- inputs - return SIGNED; - - function minimum ( - l, r : UNSIGNED) -- inputs - return UNSIGNED; - - function minimum ( - l, r : SIGNED) -- inputs - return SIGNED; - - function maximum ( - l : UNSIGNED; r : NATURAL) -- inputs - return UNSIGNED; - - function maximum ( - l : SIGNED; r : INTEGER) -- inputs - return SIGNED; - - function minimum ( - l : UNSIGNED; r : NATURAL) -- inputs - return UNSIGNED; - - function minimum ( - l : SIGNED; r : INTEGER) -- inputs - return SIGNED; - - function maximum ( - l : NATURAL; r : UNSIGNED) -- inputs - return UNSIGNED; - - function maximum ( - l : INTEGER; r : SIGNED) -- inputs - return SIGNED; - - function minimum ( - l : NATURAL; r : UNSIGNED) -- inputs - return UNSIGNED; - - function minimum ( - l : INTEGER; r : SIGNED) -- inputs - return SIGNED; - -- Finds the first "Y" in the input string. Returns an integer index - -- into that string. If "Y" does not exist in the string, then the - -- "find_rightmost" returns arg'low -1, and "find_leftmost" returns -1 - function find_rightmost ( - arg : UNSIGNED; -- vector argument - y : STD_ULOGIC) -- look for this bit - return INTEGER; - - function find_rightmost ( - arg : SIGNED; -- vector argument - y : STD_ULOGIC) -- look for this bit - return INTEGER; - - function find_leftmost ( - arg : UNSIGNED; -- vector argument - y : STD_ULOGIC) -- look for this bit - return INTEGER; - - function find_leftmost ( - arg : SIGNED; -- vector argument - y : STD_ULOGIC) -- look for this bit - return INTEGER; - - function TO_UNRESOLVED_UNSIGNED (ARG, SIZE : NATURAL) return UNRESOLVED_UNSIGNED; - -- Result subtype: UNRESOLVED_UNSIGNED(SIZE-1 downto 0) - -- Result: Converts a nonnegative INTEGER to an UNRESOLVED_UNSIGNED vector with - -- the specified SIZE. - - alias TO_U_UNSIGNED is - TO_UNRESOLVED_UNSIGNED[NATURAL, NATURAL return UNRESOLVED_UNSIGNED]; - - function TO_UNRESOLVED_SIGNED (ARG : INTEGER; SIZE : NATURAL) return UNRESOLVED_SIGNED; - -- Result subtype: UNRESOLVED_SIGNED(SIZE-1 downto 0) - -- Result: Converts an INTEGER to an UNRESOLVED_SIGNED vector of the specified SIZE. - - alias TO_U_SIGNED is - TO_UNRESOLVED_SIGNED[NATURAL, NATURAL return UNRESOLVED_SIGNED]; - - -- L.15 - function "and" (L : STD_ULOGIC; R : UNSIGNED) return UNSIGNED; - --- L.16 - function "and" (L : UNSIGNED; R : STD_ULOGIC) return UNSIGNED; - --- L.17 - function "or" (L : STD_ULOGIC; R : UNSIGNED) return UNSIGNED; - --- L.18 - function "or" (L : UNSIGNED; R : STD_ULOGIC) return UNSIGNED; - --- L.19 - function "nand" (L : STD_ULOGIC; R : UNSIGNED) return UNSIGNED; - --- L.20 - function "nand" (L : UNSIGNED; R : STD_ULOGIC) return UNSIGNED; - --- L.21 - function "nor" (L : STD_ULOGIC; R : UNSIGNED) return UNSIGNED; - --- L.22 - function "nor" (L : UNSIGNED; R : STD_ULOGIC) return UNSIGNED; - --- L.23 - function "xor" (L : STD_ULOGIC; R : UNSIGNED) return UNSIGNED; - --- L.24 - function "xor" (L : UNSIGNED; R : STD_ULOGIC) return UNSIGNED; - --- L.25 - function "xnor" (L : STD_ULOGIC; R : UNSIGNED) return UNSIGNED; - --- L.26 - function "xnor" (L : UNSIGNED; R : STD_ULOGIC) return UNSIGNED; - --- L.27 - function "and" (L : STD_ULOGIC; R : SIGNED) return SIGNED; - --- L.28 - function "and" (L : SIGNED; R : STD_ULOGIC) return SIGNED; - --- L.29 - function "or" (L : STD_ULOGIC; R : SIGNED) return SIGNED; - --- L.30 - function "or" (L : SIGNED; R : STD_ULOGIC) return SIGNED; - --- L.31 - function "nand" (L : STD_ULOGIC; R : SIGNED) return SIGNED; - --- L.32 - function "nand" (L : SIGNED; R : STD_ULOGIC) return SIGNED; - --- L.33 - function "nor" (L : STD_ULOGIC; R : SIGNED) return SIGNED; - --- L.34 - function "nor" (L : SIGNED; R : STD_ULOGIC) return SIGNED; - --- L.35 - function "xor" (L : STD_ULOGIC; R : SIGNED) return SIGNED; - --- L.36 - function "xor" (L : SIGNED; R : STD_ULOGIC) return SIGNED; - --- L.37 - function "xnor" (L : STD_ULOGIC; R : SIGNED) return SIGNED; - --- L.38 - function "xnor" (L : SIGNED; R : STD_ULOGIC) return SIGNED; - - -- %%% remove 12 functions (old syntax) - function and_reduce(l : SIGNED) return STD_ULOGIC; - -- Result subtype: STD_LOGIC. - -- Result: Result of and'ing all of the bits of the vector. - - function nand_reduce(l : SIGNED) return STD_ULOGIC; - -- Result subtype: STD_LOGIC. - -- Result: Result of nand'ing all of the bits of the vector. - - function or_reduce(l : SIGNED) return STD_ULOGIC; - -- Result subtype: STD_LOGIC. - -- Result: Result of or'ing all of the bits of the vector. - - function nor_reduce(l : SIGNED) return STD_ULOGIC; - -- Result subtype: STD_LOGIC. - -- Result: Result of nor'ing all of the bits of the vector. - - function xor_reduce(l : SIGNED) return STD_ULOGIC; - -- Result subtype: STD_LOGIC. - -- Result: Result of xor'ing all of the bits of the vector. - - function xnor_reduce(l : SIGNED) return STD_ULOGIC; - -- Result subtype: STD_LOGIC. - -- Result: Result of xnor'ing all of the bits of the vector. - - function and_reduce(l : UNSIGNED) return STD_ULOGIC; - -- Result subtype: STD_LOGIC. - -- Result: Result of and'ing all of the bits of the vector. - - function nand_reduce(l : UNSIGNED) return STD_ULOGIC; - -- Result subtype: STD_LOGIC. - -- Result: Result of nand'ing all of the bits of the vector. - - function or_reduce(l : UNSIGNED) return STD_ULOGIC; - -- Result subtype: STD_LOGIC. - -- Result: Result of or'ing all of the bits of the vector. - - function nor_reduce(l : UNSIGNED) return STD_ULOGIC; - -- Result subtype: STD_LOGIC. - -- Result: Result of nor'ing all of the bits of the vector. - - function xor_reduce(l : UNSIGNED) return STD_ULOGIC; - -- Result subtype: STD_LOGIC. - -- Result: Result of xor'ing all of the bits of the vector. - - function xnor_reduce(l : UNSIGNED) return STD_ULOGIC; - -- Result subtype: STD_LOGIC. - -- Result: Result of xnor'ing all of the bits of the vector. - - -- %%% Uncomment the following 12 functions (new syntax) - -- function "and" ( l : SIGNED ) RETURN std_ulogic; - -- function "nand" ( l : SIGNED ) RETURN std_ulogic; - -- function "or" ( l : SIGNED ) RETURN std_ulogic; - -- function "nor" ( l : SIGNED ) RETURN std_ulogic; - -- function "xor" ( l : SIGNED ) RETURN std_ulogic; - -- function "xnor" ( l : SIGNED ) RETURN std_ulogic; - -- function "and" ( l : UNSIGNED ) RETURN std_ulogic; - -- function "nand" ( l : UNSIGNED ) RETURN std_ulogic; - -- function "or" ( l : UNSIGNED ) RETURN std_ulogic; - -- function "nor" ( l : UNSIGNED ) RETURN std_ulogic; - -- function "xor" ( l : UNSIGNED ) RETURN std_ulogic; - -- function "xnor" ( l : UNSIGNED ) RETURN std_ulogic; - - -- rtl_synthesis off --- pragma synthesis_off - ------------------------------------------------------------------- - -- string functions - ------------------------------------------------------------------- - function to_string (value : UNSIGNED) return STRING; - function to_string (value : SIGNED) return STRING; - - -- explicitly defined operations - - alias to_bstring is to_string [UNSIGNED return STRING]; - alias to_bstring is to_string [SIGNED return STRING]; - alias to_binary_string is to_string [UNSIGNED return STRING]; - alias to_binary_string is to_string [SIGNED return STRING]; - - function to_ostring (value : UNSIGNED) return STRING; - function to_ostring (value : SIGNED) return STRING; - alias to_octal_string is to_ostring [UNSIGNED return STRING]; - alias to_octal_string is to_ostring [SIGNED return STRING]; - - function to_hstring (value : UNSIGNED) return STRING; - function to_hstring (value : SIGNED) return STRING; - alias to_hex_string is to_hstring [UNSIGNED return STRING]; - alias to_hex_string is to_hstring [SIGNED return STRING]; - - procedure READ(L : inout LINE; VALUE : out UNSIGNED; GOOD : out BOOLEAN); - - procedure READ(L : inout LINE; VALUE : out UNSIGNED); - - procedure READ(L : inout LINE; VALUE : out SIGNED; GOOD : out BOOLEAN); - - procedure READ(L : inout LINE; VALUE : out SIGNED); - - procedure WRITE (L : inout LINE; VALUE : in UNSIGNED; - JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0); - - procedure WRITE (L : inout LINE; VALUE : in SIGNED; - JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0); - - alias BREAD is READ [LINE, UNSIGNED, BOOLEAN]; - alias BREAD is READ [LINE, SIGNED, BOOLEAN]; - - alias BREAD is READ [LINE, UNSIGNED]; - alias BREAD is READ [LINE, SIGNED]; - - alias BINARY_READ is READ [LINE, UNSIGNED, BOOLEAN]; - alias BINARY_READ is READ [LINE, SIGNED, BOOLEAN]; - - alias BINARY_READ is READ [LINE, UNSIGNED]; - alias BINARY_READ is READ [LINE, SIGNED]; - - procedure OREAD (L : inout LINE; VALUE : out UNSIGNED; GOOD : out BOOLEAN); - procedure OREAD (L : inout LINE; VALUE : out SIGNED; GOOD : out BOOLEAN); - - procedure OREAD (L : inout LINE; VALUE : out UNSIGNED); - procedure OREAD (L : inout LINE; VALUE : out SIGNED); - - alias OCTAL_READ is OREAD [LINE, UNSIGNED, BOOLEAN]; - alias OCTAL_READ is OREAD [LINE, SIGNED, BOOLEAN]; - - alias OCTAL_READ is OREAD [LINE, UNSIGNED]; - alias OCTAL_READ is OREAD [LINE, SIGNED]; - - procedure HREAD (L : inout LINE; VALUE : out UNSIGNED; GOOD : out BOOLEAN); - procedure HREAD (L : inout LINE; VALUE : out SIGNED; GOOD : out BOOLEAN); - - procedure HREAD (L : inout LINE; VALUE : out UNSIGNED); - procedure HREAD (L : inout LINE; VALUE : out SIGNED); - - alias HEX_READ is HREAD [LINE, UNSIGNED, BOOLEAN]; - alias HEX_READ is HREAD [LINE, SIGNED, BOOLEAN]; - - alias HEX_READ is HREAD [LINE, UNSIGNED]; - alias HEX_READ is HREAD [LINE, SIGNED]; - - alias BWRITE is WRITE [LINE, UNSIGNED, SIDE, WIDTH]; - alias BWRITE is WRITE [LINE, SIGNED, SIDE, WIDTH]; - - alias BINARY_WRITE is WRITE [LINE, UNSIGNED, SIDE, WIDTH]; - alias BINARY_WRITE is WRITE [LINE, SIGNED, SIDE, WIDTH]; - - procedure OWRITE (L : inout LINE; VALUE : in UNSIGNED; - JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0); - - procedure OWRITE (L : inout LINE; VALUE : in SIGNED; - JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0); - - alias OCTAL_WRITE is OWRITE [LINE, UNSIGNED, SIDE, WIDTH]; - alias OCTAL_WRITE is OWRITE [LINE, SIGNED, SIDE, WIDTH]; - - procedure HWRITE (L : inout LINE; VALUE : in UNSIGNED; - JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0); - - procedure HWRITE (L : inout LINE; VALUE : in SIGNED; - JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0); - - alias HEX_WRITE is HWRITE [LINE, UNSIGNED, SIDE, WIDTH]; - alias HEX_WRITE is HWRITE [LINE, SIGNED, SIDE, WIDTH]; - - -- rtl_synthesis on --- pragma synthesis_on -end package numeric_std_additions; - -package body numeric_std_additions is - constant NAU : UNSIGNED(0 downto 1) := (others => '0'); - constant NAS : SIGNED(0 downto 1) := (others => '0'); - constant NO_WARNING : BOOLEAN := false; -- default to emit warnings - function MAX (left, right : INTEGER) return INTEGER is - begin - if left > right then return left; - else return right; - end if; - end function MAX; - - -- Id: A.3R - function "+"(L : UNSIGNED; R: STD_ULOGIC) return UNSIGNED is - variable XR : UNSIGNED(L'length-1 downto 0) := (others => '0'); - begin - XR(0) := R; - return (L + XR); - end function "+"; - - -- Id: A.3L - function "+"(L : STD_ULOGIC; R: UNSIGNED) return UNSIGNED is - variable XL : UNSIGNED(R'length-1 downto 0) := (others => '0'); - begin - XL(0) := L; - return (XL + R); - end function "+"; - - -- Id: A.4R - function "+"(L : SIGNED; R: STD_ULOGIC) return SIGNED is - variable XR : SIGNED(L'length-1 downto 0) := (others => '0'); - begin - XR(0) := R; - return (L + XR); - end function "+"; - - -- Id: A.4L - function "+"(L : STD_ULOGIC; R: SIGNED) return SIGNED is - variable XL : SIGNED(R'length-1 downto 0) := (others => '0'); - begin - XL(0) := L; - return (XL + R); - end function "+"; - - -- Id: A.9R - function "-"(L : UNSIGNED; R: STD_ULOGIC) return UNSIGNED is - variable XR : UNSIGNED(L'length-1 downto 0) := (others => '0'); - begin - XR(0) := R; - return (L - XR); - end function "-"; - - -- Id: A.9L - function "-"(L : STD_ULOGIC; R: UNSIGNED) return UNSIGNED is - variable XL : UNSIGNED(R'length-1 downto 0) := (others => '0'); - begin - XL(0) := L; - return (XL - R); - end function "-"; - - -- Id: A.10R - function "-"(L : SIGNED; R: STD_ULOGIC) return SIGNED is - variable XR : SIGNED(L'length-1 downto 0) := (others => '0'); - begin - XR(0) := R; - return (L - XR); - end function "-"; - - -- Id: A.10L - function "-"(L : STD_ULOGIC; R: SIGNED) return SIGNED is - variable XL : SIGNED(R'length-1 downto 0) := (others => '0'); - begin - XL(0) := L; - return (XL - R); - end function "-"; - --- type stdlogic_table is array(STD_ULOGIC, STD_ULOGIC) of STD_ULOGIC; --- constant match_logic_table : stdlogic_table := ( --- ----------------------------------------------------- --- -- U X 0 1 Z W L H - | | --- ----------------------------------------------------- --- ( 'U', 'U', 'U', 'U', 'U', 'U', 'U', 'U', '1' ), -- | U | --- ( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', '1' ), -- | X | --- ( 'U', 'X', '1', '0', 'X', 'X', '1', '0', '1' ), -- | 0 | --- ( 'U', 'X', '0', '1', 'X', 'X', '0', '1', '1' ), -- | 1 | --- ( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', '1' ), -- | Z | --- ( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', '1' ), -- | W | --- ( 'U', 'X', '1', '0', 'X', 'X', '1', '0', '1' ), -- | L | --- ( 'U', 'X', '0', '1', 'X', 'X', '0', '1', '1' ), -- | H | --- ( '1', '1', '1', '1', '1', '1', '1', '1', '1' ) -- | - | --- ); --- constant no_match_logic_table : stdlogic_table := ( --- ----------------------------------------------------- --- -- U X 0 1 Z W L H - | | --- ----------------------------------------------------- --- ('U', 'U', 'U', 'U', 'U', 'U', 'U', 'U', '0'), -- | U | --- ('U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', '0'), -- | X | --- ('U', 'X', '0', '1', 'X', 'X', '0', '1', '0'), -- | 0 | --- ('U', 'X', '1', '0', 'X', 'X', '1', '0', '0'), -- | 1 | --- ('U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', '0'), -- | Z | --- ('U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', '0'), -- | W | --- ('U', 'X', '0', '1', 'X', 'X', '0', '1', '0'), -- | L | --- ('U', 'X', '1', '0', 'X', 'X', '1', '0', '0'), -- | H | --- ('0', '0', '0', '0', '0', '0', '0', '0', '0') -- | - | --- ); - --- %%% FUNCTION "?=" ( l, r : std_ulogic ) RETURN std_ulogic IS --- function \?=\ ( l, r : STD_ULOGIC ) return STD_ULOGIC is --- variable value : STD_ULOGIC; --- begin --- return match_logic_table (l, r); --- end function \?=\; --- function \?/=\ (l, r : STD_ULOGIC) return STD_ULOGIC is --- begin --- return no_match_logic_table (l, r); --- end function \?/=\; - - -- "?=" operator is similar to "std_match", but returns a std_ulogic.. - -- Id: M.2B --- function \?=\ (L, R: UNSIGNED) return STD_ULOGIC 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 LX : UNSIGNED(SIZE-1 downto 0); --- variable RX : UNSIGNED(SIZE-1 downto 0); --- variable result, result1 : STD_ULOGIC; -- result --- begin --- -- Logically identical to an "=" operator. --- if ((L'length < 1) or (R'length < 1)) then --- assert NO_WARNING --- report "NUMERIC_STD.""?="": null detected, returning X" --- severity warning; --- return 'X'; --- else --- LX := RESIZE(XL, SIZE); --- RX := RESIZE(XR, SIZE); --- result := '1'; --- for i in LX'low to LX'high loop --- result1 := \?=\(LX(i), RX(i)); --- if result1 = 'U' then --- return 'U'; --- elsif result1 = 'X' or result = 'X' then --- result := 'X'; --- else --- result := result and result1; --- end if; --- end loop; --- return result; --- end if; --- end function \?=\; - --- -- %%% Replace with the following function --- -- function "?=" (L, R: UNSIGNED) return std_ulogic is --- -- end function "?="; - --- -- Id: M.3B --- function \?=\ (L, R: SIGNED) return STD_ULOGIC 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 LX : SIGNED(SIZE-1 downto 0); --- variable RX : SIGNED(SIZE-1 downto 0); --- variable result, result1 : STD_ULOGIC; -- result --- begin -- ?= --- if ((L'length < 1) or (R'length < 1)) then --- assert NO_WARNING --- report "NUMERIC_STD.""?="": null detected, returning X" --- severity warning; --- return 'X'; --- else --- LX := RESIZE(XL, SIZE); --- RX := RESIZE(XR, SIZE); --- result := '1'; --- for i in LX'low to LX'high loop --- result1 := \?=\ (LX(i), RX(i)); --- if result1 = 'U' then --- return 'U'; --- elsif result1 = 'X' or result = 'X' then --- result := 'X'; --- else --- result := result and result1; --- end if; --- end loop; --- return result; --- end if; --- end function \?=\; - -- %%% Replace with the following function --- function "?=" (L, R: signed) return std_ulogic is --- end function "?="; - - -- Id: C.75 --- function \?=\ (L : NATURAL; R : UNSIGNED) return STD_ULOGIC is --- begin --- return \?=\ (TO_UNSIGNED(L, R'length), R); --- end function \?=\; - --- -- Id: C.76 --- function \?=\ (L : INTEGER; R : SIGNED) return STD_ULOGIC is --- begin --- return \?=\ (TO_SIGNED(L, R'length), R); --- end function \?=\; - --- -- Id: C.77 --- function \?=\ (L : UNSIGNED; R : NATURAL) return STD_ULOGIC is --- begin --- return \?=\ (L, TO_UNSIGNED(R, L'length)); --- end function \?=\; - --- -- Id: C.78 --- function \?=\ (L : SIGNED; R : INTEGER) return STD_ULOGIC is --- begin --- return \?=\ (L, TO_SIGNED(R, L'length)); --- end function \?=\; - --- function \?/=\ (L, R : UNSIGNED) return STD_ULOGIC 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 LX : UNSIGNED(SIZE-1 downto 0); --- variable RX : UNSIGNED(SIZE-1 downto 0); --- variable result, result1 : STD_ULOGIC; -- result --- begin -- ?= --- if ((L'length < 1) or (R'length < 1)) then --- assert NO_WARNING --- report "NUMERIC_STD.""?/="": null detected, returning X" --- severity warning; --- return 'X'; --- else --- LX := RESIZE(XL, SIZE); --- RX := RESIZE(XR, SIZE); --- result := '0'; --- for i in LX'low to LX'high loop --- result1 := \?/=\ (LX(i), RX(i)); --- if result1 = 'U' then --- return 'U'; --- elsif result1 = 'X' or result = 'X' then --- result := 'X'; --- else --- result := result or result1; --- end if; --- end loop; --- return result; --- end if; --- end function \?/=\; --- -- %%% function "?/=" (L, R : UNSIGNED) return std_ulogic is --- -- %%% end function "?/="; --- function \?/=\ (L, R : SIGNED) return STD_ULOGIC 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 LX : SIGNED(SIZE-1 downto 0); --- variable RX : SIGNED(SIZE-1 downto 0); --- variable result, result1 : STD_ULOGIC; -- result --- begin -- ?= --- if ((L'length < 1) or (R'length < 1)) then --- assert NO_WARNING --- report "NUMERIC_STD.""?/="": null detected, returning X" --- severity warning; --- return 'X'; --- else --- LX := RESIZE(XL, SIZE); --- RX := RESIZE(XR, SIZE); --- result := '0'; --- for i in LX'low to LX'high loop --- result1 := \?/=\ (LX(i), RX(i)); --- if result1 = 'U' then --- return 'U'; --- elsif result1 = 'X' or result = 'X' then --- result := 'X'; --- else --- result := result or result1; --- end if; --- end loop; --- return result; --- end if; --- end function \?/=\; --- -- %%% function "?/=" (L, R : SIGNED) return std_ulogic is --- -- %%% end function "?/="; - --- -- Id: C.75 --- function \?/=\ (L : NATURAL; R : UNSIGNED) return STD_ULOGIC is --- begin --- return \?/=\ (TO_UNSIGNED(L, R'length), R); --- end function \?/=\; - --- -- Id: C.76 --- function \?/=\ (L : INTEGER; R : SIGNED) return STD_ULOGIC is --- begin --- return \?/=\ (TO_SIGNED(L, R'length), R); --- end function \?/=\; - --- -- Id: C.77 --- function \?/=\ (L : UNSIGNED; R : NATURAL) return STD_ULOGIC is --- begin --- return \?/=\ (L, TO_UNSIGNED(R, L'length)); --- end function \?/=\; - --- -- Id: C.78 --- function \?/=\ (L : SIGNED; R : INTEGER) return STD_ULOGIC is --- begin --- return \?/=\ (L, TO_SIGNED(R, L'length)); --- end function \?/=\; - - function \?>\ (L, R : UNSIGNED) return STD_ULOGIC is - begin - if ((l'length < 1) or (r'length < 1)) then - assert NO_WARNING - report "NUMERIC_STD.""?>"": null detected, returning X" - severity warning; - return 'X'; - else - for i in L'range loop - if L(i) = '-' then - report "NUMERIC_STD.""?>"": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - for i in R'range loop - if R(i) = '-' then - report "NUMERIC_STD.""?>"": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - if is_x(l) or is_x(r) then - return 'X'; - elsif l > r then - return '1'; - else - return '0'; - end if; - end if; - end function \?>\; - -- %%% function "?>" (L, R : UNSIGNED) return std_ulogic is - -- %%% end function "?>"\; - function \?>\ (L, R : SIGNED) return STD_ULOGIC is - begin - if ((l'length < 1) or (r'length < 1)) then - assert NO_WARNING - report "NUMERIC_STD.""?>"": null detected, returning X" - severity warning; - return 'X'; - else - for i in L'range loop - if L(i) = '-' then - report "NUMERIC_STD.""?>"": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - for i in R'range loop - if R(i) = '-' then - report "NUMERIC_STD.""?>"": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - if is_x(l) or is_x(r) then - return 'X'; - elsif l > r then - return '1'; - else - return '0'; - end if; - end if; - end function \?>\; - -- %%% function "?>" (L, R : SIGNED) return std_ulogic is - -- %%% end function "?>"; - -- Id: C.57 - function \?>\ (L : NATURAL; R : UNSIGNED) return STD_ULOGIC is - begin - return \?>\ (TO_UNSIGNED(L, R'length), R); - end function \?>\; - - -- Id: C.58 - function \?>\ (L : INTEGER; R : SIGNED) return STD_ULOGIC is - begin - return \?>\ (TO_SIGNED(L, R'length),R); - end function \?>\; - - -- Id: C.59 - function \?>\ (L : UNSIGNED; R : NATURAL) return STD_ULOGIC is - begin - return \?>\ (L, TO_UNSIGNED(R, L'length)); - end function \?>\; - - -- Id: C.60 - function \?>\ (L : SIGNED; R : INTEGER) return STD_ULOGIC is - begin - return \?>\ (L, TO_SIGNED(R, L'length)); - end function \?>\; - - function \?>=\ (L, R : UNSIGNED) return STD_ULOGIC is - begin - if ((l'length < 1) or (r'length < 1)) then - assert NO_WARNING - report "NUMERIC_STD.""?>="": null detected, returning X" - severity warning; - return 'X'; - else - for i in L'range loop - if L(i) = '-' then - report "NUMERIC_STD.""?>="": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - for i in R'range loop - if R(i) = '-' then - report "NUMERIC_STD.""?>="": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - if is_x(l) or is_x(r) then - return 'X'; - elsif l >= r then - return '1'; - else - return '0'; - end if; - end if; - end function \?>=\; - -- %%% function "?>=" (L, R : UNSIGNED) return std_ulogic is - -- %%% end function "?>="; - function \?>=\ (L, R : SIGNED) return STD_ULOGIC is - begin - if ((l'length < 1) or (r'length < 1)) then - assert NO_WARNING - report "NUMERIC_STD.""?>="": null detected, returning X" - severity warning; - return 'X'; - else - for i in L'range loop - if L(i) = '-' then - report "NUMERIC_STD.""?>="": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - for i in R'range loop - if R(i) = '-' then - report "NUMERIC_STD.""?>="": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - if is_x(l) or is_x(r) then - return 'X'; - elsif l >= r then - return '1'; - else - return '0'; - end if; - end if; - end function \?>=\; - -- %%% function "?>=" (L, R : SIGNED) return std_ulogic is - -- %%% end function "?>="; - - function \?>=\ (L : NATURAL; R : UNSIGNED) return STD_ULOGIC is - begin - return \?>=\ (TO_UNSIGNED(L, R'length), R); - end function \?>=\; - - -- Id: C.64 - function \?>=\ (L : INTEGER; R : SIGNED) return STD_ULOGIC is - begin - return \?>=\ (TO_SIGNED(L, R'length),R); - end function \?>=\; - - -- Id: C.65 - function \?>=\ (L : UNSIGNED; R : NATURAL) return STD_ULOGIC is - begin - return \?>=\ (L, TO_UNSIGNED(R, L'length)); - end function \?>=\; - - -- Id: C.66 - function \?>=\ (L : SIGNED; R : INTEGER) return STD_ULOGIC is - begin - return \?>=\ (L, TO_SIGNED(R, L'length)); - end function \?>=\; - - function \?<\ (L, R : UNSIGNED) return STD_ULOGIC is - begin - if ((l'length < 1) or (r'length < 1)) then - assert NO_WARNING - report "NUMERIC_STD.""?<"": null detected, returning X" - severity warning; - return 'X'; - else - for i in L'range loop - if L(i) = '-' then - report "NUMERIC_STD.""?<"": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - for i in R'range loop - if R(i) = '-' then - report "NUMERIC_STD.""?<"": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - if is_x(l) or is_x(r) then - return 'X'; - elsif l < r then - return '1'; - else - return '0'; - end if; - end if; - end function \?<\; - -- %%% function "?<" (L, R : UNSIGNED) return std_ulogic is - -- %%% end function "?<"; - function \?<\ (L, R : SIGNED) return STD_ULOGIC is - begin - if ((l'length < 1) or (r'length < 1)) then - assert NO_WARNING - report "NUMERIC_STD.""?<"": null detected, returning X" - severity warning; - return 'X'; - else - for i in L'range loop - if L(i) = '-' then - report "NUMERIC_STD.""?<"": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - for i in R'range loop - if R(i) = '-' then - report "NUMERIC_STD.""?<"": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - if is_x(l) or is_x(r) then - return 'X'; - elsif l < r then - return '1'; - else - return '0'; - end if; - end if; - end function \?<\; - -- %%% function "?<" (L, R : SIGNED) return std_ulogic is - -- %%% end function "?<"; - - -- Id: C.57 - function \?<\ (L : NATURAL; R : UNSIGNED) return STD_ULOGIC is - begin - return \?<\ (TO_UNSIGNED(L, R'length), R); - end function \?<\; - - -- Id: C.58 - function \?<\ (L : INTEGER; R : SIGNED) return STD_ULOGIC is - begin - return \?<\ (TO_SIGNED(L, R'length),R); - end function \?<\; - - -- Id: C.59 - function \?<\ (L : UNSIGNED; R : NATURAL) return STD_ULOGIC is - begin - return \?<\ (L, TO_UNSIGNED(R, L'length)); - end function \?<\; - - -- Id: C.60 - function \?<\ (L : SIGNED; R : INTEGER) return STD_ULOGIC is - begin - return \?<\ (L, TO_SIGNED(R, L'length)); - end function \?<\; - - function \?<=\ (L, R : UNSIGNED) return STD_ULOGIC is - begin - if ((l'length < 1) or (r'length < 1)) then - assert NO_WARNING - report "NUMERIC_STD.""?<="": null detected, returning X" - severity warning; - return 'X'; - else - for i in L'range loop - if L(i) = '-' then - report "NUMERIC_STD.""?<="": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - for i in R'range loop - if R(i) = '-' then - report "NUMERIC_STD.""?<="": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - if is_x(l) or is_x(r) then - return 'X'; - elsif l <= r then - return '1'; - else - return '0'; - end if; - end if; - end function \?<=\; - -- %%% function "?<=" (L, R : UNSIGNED) return std_ulogic is - -- %%% end function "?<="; - function \?<=\ (L, R : SIGNED) return STD_ULOGIC is - begin - if ((l'length < 1) or (r'length < 1)) then - assert NO_WARNING - report "NUMERIC_STD.""?<="": null detected, returning X" - severity warning; - return 'X'; - else - for i in L'range loop - if L(i) = '-' then - report "NUMERIC_STD.""?<="": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - for i in R'range loop - if R(i) = '-' then - report "NUMERIC_STD.""?<="": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - if is_x(l) or is_x(r) then - return 'X'; - elsif l <= r then - return '1'; - else - return '0'; - end if; - end if; - end function \?<=\; - -- %%% function "?<=" (L, R : SIGNED) return std_ulogic is - -- %%% end function "?<="; - -- Id: C.63 - function \?<=\ (L : NATURAL; R : UNSIGNED) return STD_ULOGIC is - begin - return \?<=\ (TO_UNSIGNED(L, R'length), R); - end function \?<=\; - - -- Id: C.64 - function \?<=\ (L : INTEGER; R : SIGNED) return STD_ULOGIC is - begin - return \?<=\ (TO_SIGNED(L, R'length),R); - end function \?<=\; - - -- Id: C.65 - function \?<=\ (L : UNSIGNED; R : NATURAL) return STD_ULOGIC is - begin - return \?<=\ (L, TO_UNSIGNED(R, L'length)); - end function \?<=\; - - -- Id: C.66 - function \?<=\ (L : SIGNED; R : INTEGER) return STD_ULOGIC is - begin - return \?<=\ (L, TO_SIGNED(R, L'length)); - end function \?<=\; - - -- size_res versions of these functions (Bugzilla 165) - function TO_UNSIGNED (ARG : NATURAL; SIZE_RES : UNSIGNED) - return UNSIGNED is - begin - return TO_UNSIGNED (ARG => ARG, - SIZE => SIZE_RES'length); - end function TO_UNSIGNED; - - function TO_SIGNED (ARG : INTEGER; SIZE_RES : SIGNED) - return SIGNED is - begin - return TO_SIGNED (ARG => ARG, - SIZE => SIZE_RES'length); - end function TO_SIGNED; - - function RESIZE (ARG, SIZE_RES : SIGNED) - return SIGNED is - begin - return RESIZE (ARG => ARG, - NEW_SIZE => SIZE_RES'length); - end function RESIZE; - - function RESIZE (ARG, SIZE_RES : UNSIGNED) - return UNSIGNED is - begin - return RESIZE (ARG => ARG, - NEW_SIZE => SIZE_RES'length); - end function RESIZE; - - -- 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 function "sll"; - - ------------------------------------------------------------------------------ - -- Note: Function S.10 is not compatible with IEEE Std 1076-1987. Comment - -- out the function (declaration and body) for IEEE Std 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 function "sll"; - - ------------------------------------------------------------------------------ - -- Note: Function S.11 is not compatible with IEEE Std 1076-1987. Comment - -- out the function (declaration and body) for IEEE Std 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 function "srl"; - - ------------------------------------------------------------------------------ - -- Note: Function S.12 is not compatible with IEEE Std 1076-1987. Comment - -- out the function (declaration and body) for IEEE Std 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 function "srl"; - - ------------------------------------------------------------------------------ - -- Note: Function S.13 is not compatible with IEEE Std 1076-1987. Comment - -- out the function (declaration and body) for IEEE Std 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 function "rol"; - - ------------------------------------------------------------------------------ - -- Note: Function S.14 is not compatible with IEEE Std 1076-1987. Comment - -- out the function (declaration and body) for IEEE Std 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 function "rol"; - - ------------------------------------------------------------------------------ - -- Note: Function S.15 is not compatible with IEEE Std 1076-1987. Comment - -- out the function (declaration and body) for IEEE Std 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 function "ror"; - - ------------------------------------------------------------------------------ - -- Note: Function S.16 is not compatible with IEEE Std 1076-1987. Comment - -- out the function (declaration and body) for IEEE Std 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 function "ror"; - --- begin LCS-2006-120 - - ------------------------------------------------------------------------------ - -- Note: Function S.17 is not compatible with IEEE Std 1076-1987. Comment - -- out the function (declaration and body) for IEEE Std 1076-1987 compatibility. - ------------------------------------------------------------------------------ - -- Id: S.17 - function "sla" (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 function "sla"; - - ------------------------------------------------------------------------------ - -- Note: Function S.18 is not compatible with IEEE Std 1076-1987. Comment - -- out the function (declaration and body) for IEEE Std 1076-1987 compatibility. - ------------------------------------------------------------------------------ - -- Id: S.18 - function "sla" (ARG : SIGNED; COUNT : INTEGER) - return SIGNED is - begin - if (COUNT >= 0) then - return SHIFT_LEFT(ARG, COUNT); - else - return SHIFT_RIGHT(ARG, -COUNT); - end if; - end function "sla"; - - ------------------------------------------------------------------------------ - -- Note: Function S.19 is not compatible with IEEE Std 1076-1987. Comment - -- out the function (declaration and body) for IEEE Std 1076-1987 compatibility. - ------------------------------------------------------------------------------ - -- Id: S.19 - function "sra" (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 function "sra"; - - ------------------------------------------------------------------------------ - -- Note: Function S.20 is not compatible with IEEE Std 1076-1987. Comment - -- out the function (declaration and body) for IEEE Std 1076-1987 compatibility. - ------------------------------------------------------------------------------ - -- Id: S.20 - function "sra" (ARG : SIGNED; COUNT : INTEGER) - return SIGNED is - begin - if (COUNT >= 0) then - return SHIFT_RIGHT(ARG, COUNT); - else - return SHIFT_LEFT(ARG, -COUNT); - end if; - end function "sra"; - - -- These functions are in std_logic_1164 and are defined for - -- std_logic_vector. They are overloaded here. - function To_X01 ( s : UNSIGNED ) return UNSIGNED is - begin - return UNSIGNED (To_X01 (STD_LOGIC_VECTOR (s))); - end function To_X01; - - function To_X01 ( s : SIGNED ) return SIGNED is - begin - return SIGNED (To_X01 (STD_LOGIC_VECTOR (s))); - end function To_X01; - - function To_X01Z ( s : UNSIGNED ) return UNSIGNED is - begin - return UNSIGNED (To_X01Z (STD_LOGIC_VECTOR (s))); - end function To_X01Z; - - function To_X01Z ( s : SIGNED ) return SIGNED is - begin - return SIGNED (To_X01Z (STD_LOGIC_VECTOR (s))); - end function To_X01Z; - - function To_UX01 ( s : UNSIGNED ) return UNSIGNED is - begin - return UNSIGNED (To_UX01 (STD_LOGIC_VECTOR (s))); - end function To_UX01; - - function To_UX01 ( s : SIGNED ) return SIGNED is - begin - return SIGNED (To_UX01 (STD_LOGIC_VECTOR (s))); - end function To_UX01; - - function Is_X ( s : UNSIGNED ) return BOOLEAN is - begin - return Is_X (STD_LOGIC_VECTOR (s)); - end function Is_X; - - function Is_X ( s : SIGNED ) return BOOLEAN is - begin - return Is_X (STD_LOGIC_VECTOR (s)); - end function Is_X; - - ----------------------------------------------------------------------------- - -- New/updated functions for VHDL-200X fast track - ----------------------------------------------------------------------------- - - -- Returns the maximum (or minimum) of the two numbers provided. - -- All types (both inputs and the output) must be the same. - -- These override the implicit functions, using the local ">" operator - -- UNSIGNED output - function MAXIMUM (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; - if L01 < R01 then - return R01; - else - return L01; - end if; - end function MAXIMUM; - - -- signed output - function MAXIMUM (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; - if L01 < R01 then - return R01; - else - return L01; - end if; - end function MAXIMUM; - - -- UNSIGNED output - function MINIMUM (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; - if L01 < R01 then - return L01; - else - return R01; - end if; - end function MINIMUM; - - - -- signed output - function MINIMUM (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; - if L01 < R01 then - return L01; - else - return R01; - end if; - end function MINIMUM; - - -- Id: C.39 - function MINIMUM (L : NATURAL; R : UNSIGNED) - return UNSIGNED is - begin - return MINIMUM(TO_UNSIGNED(L, R'length), R); - end function MINIMUM; - - -- Id: C.40 - function MINIMUM (L : INTEGER; R : SIGNED) - return SIGNED is - begin - return MINIMUM(TO_SIGNED(L, R'length), R); - end function MINIMUM; - - -- Id: C.41 - function MINIMUM (L : UNSIGNED; R : NATURAL) - return UNSIGNED is - begin - return MINIMUM(L, TO_UNSIGNED(R, L'length)); - end function MINIMUM; - - -- Id: C.42 - function MINIMUM (L : SIGNED; R : INTEGER) - return SIGNED is - begin - return MINIMUM(L, TO_SIGNED(R, L'length)); - end function MINIMUM; - - -- Id: C.45 - function MAXIMUM (L : NATURAL; R : UNSIGNED) - return UNSIGNED is - begin - return MAXIMUM(TO_UNSIGNED(L, R'length), R); - end function MAXIMUM; - - -- Id: C.46 - function MAXIMUM (L : INTEGER; R : SIGNED) - return SIGNED is - begin - return MAXIMUM(TO_SIGNED(L, R'length), R); - end function MAXIMUM; - - -- Id: C.47 - function MAXIMUM (L : UNSIGNED; R : NATURAL) - return UNSIGNED is - begin - return MAXIMUM(L, TO_UNSIGNED(R, L'length)); - end function MAXIMUM; - - -- Id: C.48 - function MAXIMUM (L : SIGNED; R : INTEGER) - return SIGNED is - begin - return MAXIMUM(L, TO_SIGNED(R, L'length)); - end function MAXIMUM; - - function find_rightmost ( - arg : UNSIGNED; -- vector argument - y : STD_ULOGIC) -- look for this bit - return INTEGER is - alias xarg : UNSIGNED(arg'length-1 downto 0) is arg; - begin - for_loop: for i in xarg'reverse_range loop - if xarg(i) = y then - return i; - end if; - end loop; - return -1; - end function find_rightmost; - - function find_rightmost ( - arg : SIGNED; -- vector argument - y : STD_ULOGIC) -- look for this bit - return INTEGER is - alias xarg : SIGNED(arg'length-1 downto 0) is arg; - begin - for_loop: for i in xarg'reverse_range loop - if xarg(i) = y then - return i; - end if; - end loop; - return -1; - end function find_rightmost; - - function find_leftmost ( - arg : UNSIGNED; -- vector argument - y : STD_ULOGIC) -- look for this bit - return INTEGER is - alias xarg : UNSIGNED(arg'length-1 downto 0) is arg; - begin - for_loop: for i in xarg'range loop - if xarg(i) = y then - return i; - end if; - end loop; - return -1; - end function find_leftmost; - - function find_leftmost ( - arg : SIGNED; -- vector argument - y : STD_ULOGIC) -- look for this bit - return INTEGER is - alias xarg : SIGNED(arg'length-1 downto 0) is arg; - begin - for_loop: for i in xarg'range loop - if xarg(i) = y then - return i; - end if; - end loop; - return -1; - end function find_leftmost; - - function TO_UNRESOLVED_UNSIGNED (ARG, SIZE : NATURAL) - return UNRESOLVED_UNSIGNED is - begin - return UNRESOLVED_UNSIGNED(to_unsigned (arg, size)); - end function TO_UNRESOLVED_UNSIGNED; - -- Result subtype: UNRESOLVED_UNSIGNED(SIZE-1 downto 0) - -- Result: Converts a nonnegative INTEGER to an UNRESOLVED_UNSIGNED vector with - -- the specified SIZE. - - - function TO_UNRESOLVED_SIGNED (ARG : INTEGER; SIZE : NATURAL) - return UNRESOLVED_SIGNED is - begin - return UNRESOLVED_SIGNED(to_signed (arg, size)); - end function TO_UNRESOLVED_SIGNED; - -- Result subtype: UNRESOLVED_SIGNED(SIZE-1 downto 0) - -- Result: Converts an INTEGER to an UNRESOLVED_SIGNED vector of the specified SIZE. - - -- Performs the boolean operation on every bit in the vector --- L.15 - function "and" (L: STD_ULOGIC; R: UNSIGNED) return UNSIGNED is - alias rv : UNSIGNED ( 1 to r'length ) is r; - variable result : UNSIGNED ( 1 to r'length ); - begin - for i in result'range loop - result(i) := "and" (l, rv(i)); - end loop; - return result; - end function "and"; - --- L.16 - function "and" (L: UNSIGNED; R: STD_ULOGIC) return UNSIGNED is - alias lv : UNSIGNED ( 1 to l'length ) is l; - variable result : UNSIGNED ( 1 to l'length ); - begin - for i in result'range loop - result(i) := "and" (lv(i), r); - end loop; - return result; - end function "and"; - --- L.17 - function "or" (L: STD_ULOGIC; R: UNSIGNED) return UNSIGNED is - alias rv : UNSIGNED ( 1 to r'length ) is r; - variable result : UNSIGNED ( 1 to r'length ); - begin - for i in result'range loop - result(i) := "or" (l, rv(i)); - end loop; - return result; - end function "or"; - --- L.18 - function "or" (L: UNSIGNED; R: STD_ULOGIC) return UNSIGNED is - alias lv : UNSIGNED ( 1 to l'length ) is l; - variable result : UNSIGNED ( 1 to l'length ); - begin - for i in result'range loop - result(i) := "or" (lv(i), r); - end loop; - return result; - end function "or"; - --- L.19 - function "nand" (L: STD_ULOGIC; R: UNSIGNED) return UNSIGNED is - alias rv : UNSIGNED ( 1 to r'length ) is r; - variable result : UNSIGNED ( 1 to r'length ); - begin - for i in result'range loop - result(i) := "not"("and" (l, rv(i))); - end loop; - return result; - end function "nand"; - --- L.20 - function "nand" (L: UNSIGNED; R: STD_ULOGIC) return UNSIGNED is - alias lv : UNSIGNED ( 1 to l'length ) is l; - variable result : UNSIGNED ( 1 to l'length ); - begin - for i in result'range loop - result(i) := "not"("and" (lv(i), r)); - end loop; - return result; - end function "nand"; - --- L.21 - function "nor" (L: STD_ULOGIC; R: UNSIGNED) return UNSIGNED is - alias rv : UNSIGNED ( 1 to r'length ) is r; - variable result : UNSIGNED ( 1 to r'length ); - begin - for i in result'range loop - result(i) := "not"("or" (l, rv(i))); - end loop; - return result; - end function "nor"; - --- L.22 - function "nor" (L: UNSIGNED; R: STD_ULOGIC) return UNSIGNED is - alias lv : UNSIGNED ( 1 to l'length ) is l; - variable result : UNSIGNED ( 1 to l'length ); - begin - for i in result'range loop - result(i) := "not"("or" (lv(i), r)); - end loop; - return result; - end function "nor"; - --- L.23 - function "xor" (L: STD_ULOGIC; R: UNSIGNED) return UNSIGNED is - alias rv : UNSIGNED ( 1 to r'length ) is r; - variable result : UNSIGNED ( 1 to r'length ); - begin - for i in result'range loop - result(i) := "xor" (l, rv(i)); - end loop; - return result; - end function "xor"; - --- L.24 - function "xor" (L: UNSIGNED; R: STD_ULOGIC) return UNSIGNED is - alias lv : UNSIGNED ( 1 to l'length ) is l; - variable result : UNSIGNED ( 1 to l'length ); - begin - for i in result'range loop - result(i) := "xor" (lv(i), r); - end loop; - return result; - end function "xor"; - --- L.25 - function "xnor" (L: STD_ULOGIC; R: UNSIGNED) return UNSIGNED is - alias rv : UNSIGNED ( 1 to r'length ) is r; - variable result : UNSIGNED ( 1 to r'length ); - begin - for i in result'range loop - result(i) := "not"("xor" (l, rv(i))); - end loop; - return result; - end function "xnor"; - --- L.26 - function "xnor" (L: UNSIGNED; R: STD_ULOGIC) return UNSIGNED is - alias lv : UNSIGNED ( 1 to l'length ) is l; - variable result : UNSIGNED ( 1 to l'length ); - begin - for i in result'range loop - result(i) := "not"("xor" (lv(i), r)); - end loop; - return result; - end function "xnor"; - --- L.27 - function "and" (L: STD_ULOGIC; R: SIGNED) return SIGNED is - alias rv : SIGNED ( 1 to r'length ) is r; - variable result : SIGNED ( 1 to r'length ); - begin - for i in result'range loop - result(i) := "and" (l, rv(i)); - end loop; - return result; - end function "and"; - --- L.28 - function "and" (L: SIGNED; R: STD_ULOGIC) return SIGNED is - alias lv : SIGNED ( 1 to l'length ) is l; - variable result : SIGNED ( 1 to l'length ); - begin - for i in result'range loop - result(i) := "and" (lv(i), r); - end loop; - return result; - end function "and"; - --- L.29 - function "or" (L: STD_ULOGIC; R: SIGNED) return SIGNED is - alias rv : SIGNED ( 1 to r'length ) is r; - variable result : SIGNED ( 1 to r'length ); - begin - for i in result'range loop - result(i) := "or" (l, rv(i)); - end loop; - return result; - end function "or"; - --- L.30 - function "or" (L: SIGNED; R: STD_ULOGIC) return SIGNED is - alias lv : SIGNED ( 1 to l'length ) is l; - variable result : SIGNED ( 1 to l'length ); - begin - for i in result'range loop - result(i) := "or" (lv(i), r); - end loop; - return result; - end function "or"; - --- L.31 - function "nand" (L: STD_ULOGIC; R: SIGNED) return SIGNED is - alias rv : SIGNED ( 1 to r'length ) is r; - variable result : SIGNED ( 1 to r'length ); - begin - for i in result'range loop - result(i) := "not"("and" (l, rv(i))); - end loop; - return result; - end function "nand"; - --- L.32 - function "nand" (L: SIGNED; R: STD_ULOGIC) return SIGNED is - alias lv : SIGNED ( 1 to l'length ) is l; - variable result : SIGNED ( 1 to l'length ); - begin - for i in result'range loop - result(i) := "not"("and" (lv(i), r)); - end loop; - return result; - end function "nand"; - --- L.33 - function "nor" (L: STD_ULOGIC; R: SIGNED) return SIGNED is - alias rv : SIGNED ( 1 to r'length ) is r; - variable result : SIGNED ( 1 to r'length ); - begin - for i in result'range loop - result(i) := "not"("or" (l, rv(i))); - end loop; - return result; - end function "nor"; - --- L.34 - function "nor" (L: SIGNED; R: STD_ULOGIC) return SIGNED is - alias lv : SIGNED ( 1 to l'length ) is l; - variable result : SIGNED ( 1 to l'length ); - begin - for i in result'range loop - result(i) := "not"("or" (lv(i), r)); - end loop; - return result; - end function "nor"; - --- L.35 - function "xor" (L: STD_ULOGIC; R: SIGNED) return SIGNED is - alias rv : SIGNED ( 1 to r'length ) is r; - variable result : SIGNED ( 1 to r'length ); - begin - for i in result'range loop - result(i) := "xor" (l, rv(i)); - end loop; - return result; - end function "xor"; - --- L.36 - function "xor" (L: SIGNED; R: STD_ULOGIC) return SIGNED is - alias lv : SIGNED ( 1 to l'length ) is l; - variable result : SIGNED ( 1 to l'length ); - begin - for i in result'range loop - result(i) := "xor" (lv(i), r); - end loop; - return result; - end function "xor"; - --- L.37 - function "xnor" (L: STD_ULOGIC; R: SIGNED) return SIGNED is - alias rv : SIGNED ( 1 to r'length ) is r; - variable result : SIGNED ( 1 to r'length ); - begin - for i in result'range loop - result(i) := "not"("xor" (l, rv(i))); - end loop; - return result; - end function "xnor"; - --- L.38 - function "xnor" (L: SIGNED; R: STD_ULOGIC) return SIGNED is - alias lv : SIGNED ( 1 to l'length ) is l; - variable result : SIGNED ( 1 to l'length ); - begin - for i in result'range loop - result(i) := "not"("xor" (lv(i), r)); - end loop; - return result; - end function "xnor"; - - -------------------------------------------------------------------------- - -- Reduction operations - -------------------------------------------------------------------------- - -- %%% Remove the following 12 funcitons (old syntax) - function and_reduce (l : SIGNED ) return STD_ULOGIC is - begin - return and_reduce (UNSIGNED ( l )); - end function and_reduce; - - function and_reduce ( l : UNSIGNED ) return STD_ULOGIC is - variable Upper, Lower : STD_ULOGIC; - variable Half : INTEGER; - variable BUS_int : UNSIGNED ( l'length - 1 downto 0 ); - variable Result : STD_ULOGIC := '1'; -- In the case of a NULL range - begin - if (l'length >= 1) then - BUS_int := to_ux01 (l); - if ( BUS_int'length = 1 ) then - Result := BUS_int ( BUS_int'left ); - elsif ( BUS_int'length = 2 ) then - Result := "and" (BUS_int(BUS_int'right),BUS_int(BUS_int'left)); - else - Half := ( BUS_int'length + 1 ) / 2 + BUS_int'right; - Upper := and_reduce ( BUS_int ( BUS_int'left downto Half )); - Lower := and_reduce ( BUS_int ( Half - 1 downto BUS_int'right )); - Result := "and" (Upper, Lower); - end if; - end if; - return Result; - end function and_reduce; - - function nand_reduce (l : SIGNED ) return STD_ULOGIC is - begin - return "not" (and_reduce ( l )); - end function nand_reduce; - - function nand_reduce (l : UNSIGNED ) return STD_ULOGIC is - begin - return "not" (and_reduce (l )); - end function nand_reduce; - - function or_reduce (l : SIGNED ) return STD_ULOGIC is - begin - return or_reduce (UNSIGNED ( l )); - end function or_reduce; - - function or_reduce (l : UNSIGNED ) return STD_ULOGIC is - variable Upper, Lower : STD_ULOGIC; - variable Half : INTEGER; - variable BUS_int : UNSIGNED ( l'length - 1 downto 0 ); - variable Result : STD_ULOGIC := '0'; -- In the case of a NULL range - begin - if (l'length >= 1) then - BUS_int := to_ux01 (l); - if ( BUS_int'length = 1 ) then - Result := BUS_int ( BUS_int'left ); - elsif ( BUS_int'length = 2 ) then - Result := "or" (BUS_int(BUS_int'right), BUS_int(BUS_int'left)); - else - Half := ( BUS_int'length + 1 ) / 2 + BUS_int'right; - Upper := or_reduce ( BUS_int ( BUS_int'left downto Half )); - Lower := or_reduce ( BUS_int ( Half - 1 downto BUS_int'right )); - Result := "or" (Upper, Lower); - end if; - end if; - return Result; - end function or_reduce; - - function nor_reduce (l : SIGNED ) return STD_ULOGIC is - begin - return "not"(or_reduce(l)); - end function nor_reduce; - - function nor_reduce (l : UNSIGNED ) return STD_ULOGIC is - begin - return "not"(or_reduce(l)); - end function nor_reduce; - - function xor_reduce (l : SIGNED ) return STD_ULOGIC is - begin - return xor_reduce (UNSIGNED ( l )); - end function xor_reduce; - - function xor_reduce (l : UNSIGNED ) return STD_ULOGIC is - variable Upper, Lower : STD_ULOGIC; - variable Half : INTEGER; - variable BUS_int : UNSIGNED ( l'length - 1 downto 0 ); - variable Result : STD_ULOGIC := '0'; -- In the case of a NULL range - begin - if (l'length >= 1) then - BUS_int := to_ux01 (l); - if ( BUS_int'length = 1 ) then - Result := BUS_int ( BUS_int'left ); - elsif ( BUS_int'length = 2 ) then - Result := "xor" (BUS_int(BUS_int'right), BUS_int(BUS_int'left)); - else - Half := ( BUS_int'length + 1 ) / 2 + BUS_int'right; - Upper := xor_reduce ( BUS_int ( BUS_int'left downto Half )); - Lower := xor_reduce ( BUS_int ( Half - 1 downto BUS_int'right )); - Result := "xor" (Upper, Lower); - end if; - end if; - return Result; - end function xor_reduce; - - function xnor_reduce (l : SIGNED ) return STD_ULOGIC is - begin - return "not"(xor_reduce(l)); - end function xnor_reduce; - - function xnor_reduce (l : UNSIGNED ) return STD_ULOGIC is - begin - return "not"(xor_reduce(l)); - end function xnor_reduce; - - -- %%% Replace the above with the following 12 functions (New syntax) --- function "and" ( l : SIGNED ) return std_ulogic is --- begin --- return and (std_logic_vector ( l )); --- end function "and"; - --- function "and" ( l : UNSIGNED ) return std_ulogic is --- begin --- return and (std_logic_vector ( l )); --- end function "and"; - --- function "nand" ( l : SIGNED ) return std_ulogic is --- begin --- return nand (std_logic_vector ( l )); --- end function "nand"; - --- function "nand" ( l : UNSIGNED ) return std_ulogic is --- begin --- return nand (std_logic_vector ( l )); --- end function "nand"; - --- function "or" ( l : SIGNED ) return std_ulogic is --- begin --- return or (std_logic_vector ( l )); --- end function "or"; - --- function "or" ( l : UNSIGNED ) return std_ulogic is --- begin --- return or (std_logic_vector ( l )); --- end function "or"; - --- function "nor" ( l : SIGNED ) return std_ulogic is --- begin --- return nor (std_logic_vector ( l )); --- end function "nor"; - --- function "nor" ( l : UNSIGNED ) return std_ulogic is --- begin --- return nor (std_logic_vector ( l )); --- end function "nor"; - --- function "xor" ( l : SIGNED ) return std_ulogic is --- begin --- return xor (std_logic_vector ( l )); --- end function "xor"; - --- function "xor" ( l : UNSIGNED ) return std_ulogic is --- begin --- return xor (std_logic_vector ( l )); --- end function "xor"; - --- function "xnor" ( l : SIGNED ) return std_ulogic is --- begin --- return xnor (std_logic_vector ( l )); --- end function "xnor"; - --- function "xnor" ( l : UNSIGNED ) return std_ulogic is --- begin --- return xnor (std_logic_vector ( l )); --- end function "xnor"; - - -- rtl_synthesis off --- pragma synthesis_off - ------------------------------------------------------------------- - -- TO_STRING - ------------------------------------------------------------------- - -- Type and constant definitions used to map STD_ULOGIC values - -- into/from character values. - type MVL9plus is ('U', 'X', '0', '1', 'Z', 'W', 'L', 'H', '-', error); - type char_indexed_by_MVL9 is array (STD_ULOGIC) of CHARACTER; - type MVL9_indexed_by_char is array (CHARACTER) of STD_ULOGIC; - type MVL9plus_indexed_by_char is array (CHARACTER) of MVL9plus; - constant MVL9_to_char : char_indexed_by_MVL9 := "UX01ZWLH-"; - constant char_to_MVL9 : MVL9_indexed_by_char := - ('U' => 'U', 'X' => 'X', '0' => '0', '1' => '1', 'Z' => 'Z', - 'W' => 'W', 'L' => 'L', 'H' => 'H', '-' => '-', others => 'U'); - constant char_to_MVL9plus : MVL9plus_indexed_by_char := - ('U' => 'U', 'X' => 'X', '0' => '0', '1' => '1', 'Z' => 'Z', - 'W' => 'W', 'L' => 'L', 'H' => 'H', '-' => '-', others => error); - - constant NBSP : CHARACTER := CHARACTER'val(160); -- space character - constant NUS : STRING(2 to 1) := (others => ' '); -- NULL array - - function to_string (value : UNSIGNED) return STRING is - alias ivalue : UNSIGNED(1 to value'length) is value; - variable result : STRING(1 to value'length); - begin - if value'length < 1 then - return NUS; - else - for i in ivalue'range loop - result(i) := MVL9_to_char( iValue(i) ); - end loop; - return result; - end if; - end function to_string; - - function to_string (value : SIGNED) return STRING is - alias ivalue : SIGNED(1 to value'length) is value; - variable result : STRING(1 to value'length); - begin - if value'length < 1 then - return NUS; - else - for i in ivalue'range loop - result(i) := MVL9_to_char( iValue(i) ); - end loop; - return result; - end if; - end function to_string; - - function to_hstring (value : SIGNED) return STRING is - constant ne : INTEGER := (value'length+3)/4; - variable pad : STD_LOGIC_VECTOR(0 to (ne*4 - value'length) - 1); - variable ivalue : STD_LOGIC_VECTOR(0 to ne*4 - 1); - variable result : STRING(1 to ne); - variable quad : STD_LOGIC_VECTOR(0 to 3); - begin - if value'length < 1 then - return NUS; - else - if value (value'left) = 'Z' then - pad := (others => 'Z'); - else - pad := (others => value(value'high)); -- Extend sign bit - end if; - ivalue := pad & STD_LOGIC_VECTOR (value); - for i in 0 to ne-1 loop - quad := To_X01Z(ivalue(4*i to 4*i+3)); - case quad is - when x"0" => result(i+1) := '0'; - when x"1" => result(i+1) := '1'; - when x"2" => result(i+1) := '2'; - when x"3" => result(i+1) := '3'; - when x"4" => result(i+1) := '4'; - when x"5" => result(i+1) := '5'; - when x"6" => result(i+1) := '6'; - when x"7" => result(i+1) := '7'; - when x"8" => result(i+1) := '8'; - when x"9" => result(i+1) := '9'; - when x"A" => result(i+1) := 'A'; - when x"B" => result(i+1) := 'B'; - when x"C" => result(i+1) := 'C'; - when x"D" => result(i+1) := 'D'; - when x"E" => result(i+1) := 'E'; - when x"F" => result(i+1) := 'F'; - when "ZZZZ" => result(i+1) := 'Z'; - when others => result(i+1) := 'X'; - end case; - end loop; - return result; - end if; - end function to_hstring; - - function to_ostring (value : SIGNED) return STRING is - constant ne : INTEGER := (value'length+2)/3; - variable pad : STD_LOGIC_VECTOR(0 to (ne*3 - value'length) - 1); - variable ivalue : STD_LOGIC_VECTOR(0 to ne*3 - 1); - variable result : STRING(1 to ne); - variable tri : STD_LOGIC_VECTOR(0 to 2); - begin - if value'length < 1 then - return NUS; - else - if value (value'left) = 'Z' then - pad := (others => 'Z'); - else - pad := (others => value (value'high)); -- Extend sign bit - end if; - ivalue := pad & STD_LOGIC_VECTOR (value); - for i in 0 to ne-1 loop - tri := To_X01Z(ivalue(3*i to 3*i+2)); - case tri is - when o"0" => result(i+1) := '0'; - when o"1" => result(i+1) := '1'; - when o"2" => result(i+1) := '2'; - when o"3" => result(i+1) := '3'; - when o"4" => result(i+1) := '4'; - when o"5" => result(i+1) := '5'; - when o"6" => result(i+1) := '6'; - when o"7" => result(i+1) := '7'; - when "ZZZ" => result(i+1) := 'Z'; - when others => result(i+1) := 'X'; - end case; - end loop; - return result; - end if; - end function to_ostring; - - function to_hstring (value : UNSIGNED) return STRING is - constant ne : INTEGER := (value'length+3)/4; - variable pad : STD_LOGIC_VECTOR(0 to (ne*4 - value'length) - 1); - variable ivalue : STD_LOGIC_VECTOR(0 to ne*4 - 1); - variable result : STRING(1 to ne); - variable quad : STD_LOGIC_VECTOR(0 to 3); - begin - if value'length < 1 then - return NUS; - else - if value (value'left) = 'Z' then - pad := (others => 'Z'); - else - pad := (others => '0'); - end if; - ivalue := pad & STD_LOGIC_VECTOR (value); - for i in 0 to ne-1 loop - quad := To_X01Z(ivalue(4*i to 4*i+3)); - case quad is - when x"0" => result(i+1) := '0'; - when x"1" => result(i+1) := '1'; - when x"2" => result(i+1) := '2'; - when x"3" => result(i+1) := '3'; - when x"4" => result(i+1) := '4'; - when x"5" => result(i+1) := '5'; - when x"6" => result(i+1) := '6'; - when x"7" => result(i+1) := '7'; - when x"8" => result(i+1) := '8'; - when x"9" => result(i+1) := '9'; - when x"A" => result(i+1) := 'A'; - when x"B" => result(i+1) := 'B'; - when x"C" => result(i+1) := 'C'; - when x"D" => result(i+1) := 'D'; - when x"E" => result(i+1) := 'E'; - when x"F" => result(i+1) := 'F'; - when "ZZZZ" => result(i+1) := 'Z'; - when others => result(i+1) := 'X'; - end case; - end loop; - return result; - end if; - end function to_hstring; - - function to_ostring (value : UNSIGNED) return STRING is - constant ne : INTEGER := (value'length+2)/3; - variable pad : STD_LOGIC_VECTOR(0 to (ne*3 - value'length) - 1); - variable ivalue : STD_LOGIC_VECTOR(0 to ne*3 - 1); - variable result : STRING(1 to ne); - variable tri : STD_LOGIC_VECTOR(0 to 2); - begin - if value'length < 1 then - return NUS; - else - if value (value'left) = 'Z' then - pad := (others => 'Z'); - else - pad := (others => '0'); - end if; - ivalue := pad & STD_LOGIC_VECTOR (value); - for i in 0 to ne-1 loop - tri := To_X01Z(ivalue(3*i to 3*i+2)); - case tri is - when o"0" => result(i+1) := '0'; - when o"1" => result(i+1) := '1'; - when o"2" => result(i+1) := '2'; - when o"3" => result(i+1) := '3'; - when o"4" => result(i+1) := '4'; - when o"5" => result(i+1) := '5'; - when o"6" => result(i+1) := '6'; - when o"7" => result(i+1) := '7'; - when "ZZZ" => result(i+1) := 'Z'; - when others => result(i+1) := 'X'; - end case; - end loop; - return result; - end if; - end function to_ostring; - - ----------------------------------------------------------------------------- - -- Read and Write routines - ----------------------------------------------------------------------------- - - -- Routines copied from the "std_logic_1164_additions" package - -- purpose: Skips white space - procedure skip_whitespace ( - L : inout LINE) is - variable readOk : BOOLEAN; - variable c : CHARACTER; - begin - while L /= null and L.all'length /= 0 loop - if (L.all(1) = ' ' or L.all(1) = NBSP or L.all(1) = HT) then - read (l, c, readOk); - else - exit; - end if; - end loop; - end procedure skip_whitespace; - procedure READ (L : inout LINE; VALUE : out STD_ULOGIC_VECTOR; - GOOD : out BOOLEAN) is - variable m : STD_ULOGIC; - variable c : CHARACTER; - variable mv : STD_ULOGIC_VECTOR(0 to VALUE'length-1); - variable readOk : BOOLEAN; - variable i : INTEGER; - variable lastu : BOOLEAN := false; -- last character was an "_" - begin - VALUE := (VALUE'range => 'U'); -- initialize to a "U" - Skip_whitespace (L); - if VALUE'length > 0 then - read (l, c, readOk); - i := 0; - good := true; - while i < VALUE'length loop - if not readOk then -- Bail out if there was a bad read - good := false; - return; - elsif c = '_' then - if i = 0 then - good := false; -- Begins with an "_" - return; - elsif lastu then - good := false; -- "__" detected - return; - else - lastu := true; - end if; - elsif (char_to_MVL9plus(c) = error) then - good := false; -- Illegal character - return; - else - mv(i) := char_to_MVL9(c); - i := i + 1; - if i > mv'high then -- reading done - VALUE := mv; - return; - end if; - lastu := false; - end if; - read(L, c, readOk); - end loop; - else - good := true; -- read into a null array - end if; - end procedure READ; - - procedure READ (L : inout LINE; VALUE : out STD_ULOGIC_VECTOR) is - variable m : STD_ULOGIC; - variable c : CHARACTER; - variable readOk : BOOLEAN; - variable mv : STD_ULOGIC_VECTOR(0 to VALUE'length-1); - variable i : INTEGER; - variable lastu : BOOLEAN := false; -- last character was an "_" - begin - VALUE := (VALUE'range => 'U'); -- initialize to a "U" - Skip_whitespace (L); - if VALUE'length > 0 then -- non Null input string - read (l, c, readOk); - i := 0; - while i < VALUE'length loop - if readOk = false then -- Bail out if there was a bad read - report "STD_LOGIC_1164.READ(STD_ULOGIC_VECTOR) " - & "End of string encountered" - severity error; - return; - elsif c = '_' then - if i = 0 then - report "STD_LOGIC_1164.READ(STD_ULOGIC_VECTOR) " - & "String begins with an ""_""" severity error; - return; - elsif lastu then - report "STD_LOGIC_1164.READ(STD_ULOGIC_VECTOR) " - & "Two underscores detected in input string ""__""" - severity error; - return; - else - lastu := true; - end if; - elsif char_to_MVL9plus(c) = error then - report - "STD_LOGIC_1164.READ(STD_ULOGIC_VECTOR) Error: Character '" & - c & "' read, expected STD_ULOGIC literal." - severity error; - return; - else - mv(i) := char_to_MVL9(c); - i := i + 1; - if i > mv'high then - VALUE := mv; - return; - end if; - lastu := false; - end if; - read(L, c, readOk); - end loop; - end if; - end procedure READ; - - -- purpose: or reduction - function or_reduce ( - arg : STD_ULOGIC_VECTOR) - return STD_ULOGIC is - variable uarg : UNSIGNED (arg'range); - begin - uarg := unsigned(arg); - return or_reduce (uarg); - end function or_reduce; - - procedure Char2QuadBits (C : CHARACTER; - RESULT : out STD_ULOGIC_VECTOR(3 downto 0); - GOOD : out BOOLEAN; - ISSUE_ERROR : in BOOLEAN) is - begin - case c is - when '0' => result := x"0"; good := true; - when '1' => result := x"1"; good := true; - when '2' => result := x"2"; good := true; - when '3' => result := x"3"; good := true; - when '4' => result := x"4"; good := true; - when '5' => result := x"5"; good := true; - when '6' => result := x"6"; good := true; - when '7' => result := x"7"; good := true; - when '8' => result := x"8"; good := true; - when '9' => result := x"9"; good := true; - when 'A' | 'a' => result := x"A"; good := true; - when 'B' | 'b' => result := x"B"; good := true; - when 'C' | 'c' => result := x"C"; good := true; - when 'D' | 'd' => result := x"D"; good := true; - when 'E' | 'e' => result := x"E"; good := true; - when 'F' | 'f' => result := x"F"; good := true; - when 'Z' => result := "ZZZZ"; good := true; - when 'X' => result := "XXXX"; good := true; - when others => - assert not ISSUE_ERROR - report - "STD_LOGIC_1164.HREAD Read a '" & c & - "', expected a Hex character (0-F)." - severity error; - good := false; - end case; - end procedure Char2QuadBits; - - procedure HREAD (L : inout LINE; VALUE : out STD_ULOGIC_VECTOR; - GOOD : out BOOLEAN) is - variable ok : BOOLEAN; - variable c : CHARACTER; - constant ne : INTEGER := (VALUE'length+3)/4; - constant pad : INTEGER := ne*4 - VALUE'length; - variable sv : STD_ULOGIC_VECTOR(0 to ne*4 - 1); - variable i : INTEGER; - variable lastu : BOOLEAN := false; -- last character was an "_" - begin - VALUE := (VALUE'range => 'U'); -- initialize to a "U" - Skip_whitespace (L); - if VALUE'length > 0 then - read (l, c, ok); - i := 0; - while i < ne loop - -- Bail out if there was a bad read - if not ok then - good := false; - return; - elsif c = '_' then - if i = 0 then - good := false; -- Begins with an "_" - return; - elsif lastu then - good := false; -- "__" detected - return; - else - lastu := true; - end if; - else - Char2QuadBits(c, sv(4*i to 4*i+3), ok, false); - if not ok then - good := false; - return; - end if; - i := i + 1; - lastu := false; - end if; - if i < ne then - read(L, c, ok); - end if; - end loop; - if or_reduce (sv (0 to pad-1)) = '1' then -- %%% replace with "or" - good := false; -- vector was truncated. - else - good := true; - VALUE := sv (pad to sv'high); - end if; - else - good := true; -- Null input string, skips whitespace - end if; - end procedure HREAD; - - procedure HREAD (L : inout LINE; VALUE : out STD_ULOGIC_VECTOR) is - variable ok : BOOLEAN; - variable c : CHARACTER; - constant ne : INTEGER := (VALUE'length+3)/4; - constant pad : INTEGER := ne*4 - VALUE'length; - variable sv : STD_ULOGIC_VECTOR(0 to ne*4 - 1); - variable i : INTEGER; - variable lastu : BOOLEAN := false; -- last character was an "_" - begin - VALUE := (VALUE'range => 'U'); -- initialize to a "U" - Skip_whitespace (L); - if VALUE'length > 0 then -- non Null input string - read (l, c, ok); - i := 0; - while i < ne loop - -- Bail out if there was a bad read - if not ok then - report "STD_LOGIC_1164.HREAD " - & "End of string encountered" - severity error; - return; - end if; - if c = '_' then - if i = 0 then - report "STD_LOGIC_1164.HREAD " - & "String begins with an ""_""" severity error; - return; - elsif lastu then - report "STD_LOGIC_1164.HREAD " - & "Two underscores detected in input string ""__""" - severity error; - return; - else - lastu := true; - end if; - else - Char2QuadBits(c, sv(4*i to 4*i+3), ok, true); - if not ok then - return; - end if; - i := i + 1; - lastu := false; - end if; - if i < ne then - read(L, c, ok); - end if; - end loop; - if or_reduce (sv (0 to pad-1)) = '1' then -- %%% replace with "or" - report "STD_LOGIC_1164.HREAD Vector truncated" - severity error; - else - VALUE := sv (pad to sv'high); - end if; - end if; - end procedure HREAD; - - -- Octal Read and Write procedures for STD_ULOGIC_VECTOR. - -- Modified from the original to be more forgiving. - - procedure Char2TriBits (C : CHARACTER; - RESULT : out STD_ULOGIC_VECTOR(2 downto 0); - GOOD : out BOOLEAN; - ISSUE_ERROR : in BOOLEAN) is - begin - case c is - when '0' => result := o"0"; good := true; - when '1' => result := o"1"; good := true; - when '2' => result := o"2"; good := true; - when '3' => result := o"3"; good := true; - when '4' => result := o"4"; good := true; - when '5' => result := o"5"; good := true; - when '6' => result := o"6"; good := true; - when '7' => result := o"7"; good := true; - when 'Z' => result := "ZZZ"; good := true; - when 'X' => result := "XXX"; good := true; - when others => - assert not ISSUE_ERROR - report - "STD_LOGIC_1164.OREAD Error: Read a '" & c & - "', expected an Octal character (0-7)." - severity error; - good := false; - end case; - end procedure Char2TriBits; - - procedure OREAD (L : inout LINE; VALUE : out STD_ULOGIC_VECTOR; - GOOD : out BOOLEAN) is - variable ok : BOOLEAN; - variable c : CHARACTER; - constant ne : INTEGER := (VALUE'length+2)/3; - constant pad : INTEGER := ne*3 - VALUE'length; - variable sv : STD_ULOGIC_VECTOR(0 to ne*3 - 1); - variable i : INTEGER; - variable lastu : BOOLEAN := false; -- last character was an "_" - begin - VALUE := (VALUE'range => 'U'); -- initialize to a "U" - Skip_whitespace (L); - if VALUE'length > 0 then - read (l, c, ok); - i := 0; - while i < ne loop - -- Bail out if there was a bad read - if not ok then - good := false; - return; - elsif c = '_' then - if i = 0 then - good := false; -- Begins with an "_" - return; - elsif lastu then - good := false; -- "__" detected - return; - else - lastu := true; - end if; - else - Char2TriBits(c, sv(3*i to 3*i+2), ok, false); - if not ok then - good := false; - return; - end if; - i := i + 1; - lastu := false; - end if; - if i < ne then - read(L, c, ok); - end if; - end loop; - if or_reduce (sv (0 to pad-1)) = '1' then -- %%% replace with "or" - good := false; -- vector was truncated. - else - good := true; - VALUE := sv (pad to sv'high); - end if; - else - good := true; -- read into a null array - end if; - end procedure OREAD; - - procedure OREAD (L : inout LINE; VALUE : out STD_ULOGIC_VECTOR) is - variable c : CHARACTER; - variable ok : BOOLEAN; - constant ne : INTEGER := (VALUE'length+2)/3; - constant pad : INTEGER := ne*3 - VALUE'length; - variable sv : STD_ULOGIC_VECTOR(0 to ne*3 - 1); - variable i : INTEGER; - variable lastu : BOOLEAN := false; -- last character was an "_" - begin - VALUE := (VALUE'range => 'U'); -- initialize to a "U" - Skip_whitespace (L); - if VALUE'length > 0 then - read (l, c, ok); - i := 0; - while i < ne loop - -- Bail out if there was a bad read - if not ok then - report "STD_LOGIC_1164.OREAD " - & "End of string encountered" - severity error; - return; - elsif c = '_' then - if i = 0 then - report "STD_LOGIC_1164.OREAD " - & "String begins with an ""_""" severity error; - return; - elsif lastu then - report "STD_LOGIC_1164.OREAD " - & "Two underscores detected in input string ""__""" - severity error; - return; - else - lastu := true; - end if; - else - Char2TriBits(c, sv(3*i to 3*i+2), ok, true); - if not ok then - return; - end if; - i := i + 1; - lastu := false; - end if; - if i < ne then - read(L, c, ok); - end if; - end loop; - if or_reduce (sv (0 to pad-1)) = '1' then -- %%% replace with "or" - report "STD_LOGIC_1164.OREAD Vector truncated" - severity error; - else - VALUE := sv (pad to sv'high); - end if; - end if; - end procedure OREAD; - -- End copied code. - - procedure READ (L : inout LINE; VALUE : out UNSIGNED; - GOOD : out BOOLEAN) is - variable ivalue : STD_ULOGIC_VECTOR(value'range); - begin - READ (L => L, - VALUE => ivalue, - GOOD => GOOD); - VALUE := UNSIGNED(ivalue); - end procedure READ; - - procedure READ (L : inout LINE; VALUE : out UNSIGNED) is - variable ivalue : STD_ULOGIC_VECTOR(value'range); - begin - READ (L => L, - VALUE => ivalue); - VALUE := UNSIGNED (ivalue); - end procedure READ; - - procedure READ (L : inout LINE; VALUE : out SIGNED; - GOOD : out BOOLEAN) is - variable ivalue : STD_ULOGIC_VECTOR(value'range); - begin - READ (L => L, - VALUE => ivalue, - GOOD => GOOD); - VALUE := SIGNED(ivalue); - end procedure READ; - - procedure READ (L : inout LINE; VALUE : out SIGNED) is - variable ivalue : STD_ULOGIC_VECTOR(value'range); - begin - READ (L => L, - VALUE => ivalue); - VALUE := SIGNED (ivalue); - end procedure READ; - - procedure WRITE (L : inout LINE; VALUE : in UNSIGNED; - JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0) is - begin - write (L, to_string(VALUE), JUSTIFIED, FIELD); - end procedure WRITE; - - procedure WRITE (L : inout LINE; VALUE : in SIGNED; - JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0) is - begin - write (L, to_string(VALUE), JUSTIFIED, FIELD); - end procedure WRITE; - - procedure OREAD (L : inout LINE; VALUE : out UNSIGNED; - GOOD : out BOOLEAN) is - variable ivalue : STD_ULOGIC_VECTOR(value'range); - begin - OREAD (L => L, - VALUE => ivalue, - GOOD => GOOD); - VALUE := UNSIGNED(ivalue); - end procedure OREAD; - - procedure OREAD (L : inout LINE; VALUE : out SIGNED; - GOOD : out BOOLEAN) is - constant ne : INTEGER := (value'length+2)/3; - constant pad : INTEGER := ne*3 - value'length; - variable ivalue : STD_ULOGIC_VECTOR(0 to ne*3-1); - variable ok : BOOLEAN; - variable expected_padding : STD_ULOGIC_VECTOR(0 to pad-1); - begin - OREAD (L => L, - VALUE => ivalue, -- Read padded STRING - GOOD => ok); - -- Bail out if there was a bad read - if not ok then - GOOD := false; - return; - end if; - expected_padding := (others => ivalue(pad)); - if ivalue(0 to pad-1) /= expected_padding then - GOOD := false; - else - GOOD := true; - VALUE := UNRESOLVED_SIGNED (ivalue (pad to ivalue'high)); - end if; - end procedure OREAD; - - procedure OREAD (L : inout LINE; VALUE : out UNSIGNED) is - variable ivalue : STD_ULOGIC_VECTOR(value'range); - begin - OREAD (L => L, - VALUE => ivalue); - VALUE := UNSIGNED (ivalue); - end procedure OREAD; - - procedure OREAD (L : inout LINE; VALUE : out SIGNED) is - constant ne : INTEGER := (value'length+2)/3; - constant pad : INTEGER := ne*3 - value'length; - variable ivalue : STD_ULOGIC_VECTOR(0 to ne*3-1); - variable expected_padding : STD_ULOGIC_VECTOR(0 to pad-1); - begin - OREAD (L => L, - VALUE => ivalue); -- Read padded string - expected_padding := (others => ivalue(pad)); - if ivalue(0 to pad-1) /= expected_padding then - assert false - report "NUMERIC_STD.OREAD Error: Signed vector truncated" - severity error; - else - VALUE := UNRESOLVED_SIGNED (ivalue (pad to ivalue'high)); - end if; - end procedure OREAD; - - procedure HREAD (L : inout LINE; VALUE : out UNSIGNED; - GOOD : out BOOLEAN) is - variable ivalue : STD_ULOGIC_VECTOR(value'range); - begin - HREAD (L => L, - VALUE => ivalue, - GOOD => GOOD); - VALUE := UNSIGNED(ivalue); - end procedure HREAD; - - procedure HREAD (L : inout LINE; VALUE : out SIGNED; - GOOD : out BOOLEAN) is - constant ne : INTEGER := (value'length+3)/4; - constant pad : INTEGER := ne*4 - value'length; - variable ivalue : STD_ULOGIC_VECTOR(0 to ne*4-1); - variable ok : BOOLEAN; - variable expected_padding : STD_ULOGIC_VECTOR(0 to pad-1); - begin - HREAD (L => L, - VALUE => ivalue, -- Read padded STRING - GOOD => ok); - if not ok then - GOOD := false; - return; - end if; - expected_padding := (others => ivalue(pad)); - if ivalue(0 to pad-1) /= expected_padding then - GOOD := false; - else - GOOD := true; - VALUE := UNRESOLVED_SIGNED (ivalue (pad to ivalue'high)); - end if; - end procedure HREAD; - - procedure HREAD (L : inout LINE; VALUE : out UNSIGNED) is - variable ivalue : STD_ULOGIC_VECTOR(value'range); - begin - HREAD (L => L, - VALUE => ivalue); - VALUE := UNSIGNED (ivalue); - end procedure HREAD; - - procedure HREAD (L : inout LINE; VALUE : out SIGNED) is - constant ne : INTEGER := (value'length+3)/4; - constant pad : INTEGER := ne*4 - value'length; - variable ivalue : STD_ULOGIC_VECTOR(0 to ne*4-1); - variable expected_padding : STD_ULOGIC_VECTOR(0 to pad-1); - begin - HREAD (L => L, - VALUE => ivalue); -- Read padded string - expected_padding := (others => ivalue(pad)); - if ivalue(0 to pad-1) /= expected_padding then - assert false - report "NUMERIC_STD.HREAD Error: Signed vector truncated" - severity error; - else - VALUE := UNRESOLVED_SIGNED (ivalue (pad to ivalue'high)); - end if; - end procedure HREAD; - - procedure OWRITE (L : inout LINE; VALUE : in UNSIGNED; - JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0) is - begin - write (L, to_ostring(VALUE), JUSTIFIED, FIELD); - end procedure OWRITE; - - procedure OWRITE (L : inout LINE; VALUE : in SIGNED; - JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0) is - begin - write (L, to_ostring(VALUE), JUSTIFIED, FIELD); - end procedure OWRITE; - - procedure HWRITE (L : inout LINE; VALUE : in UNSIGNED; - JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0) is - begin - write (L, to_hstring (VALUE), JUSTIFIED, FIELD); - end procedure HWRITE; - - procedure HWRITE (L : inout LINE; VALUE : in SIGNED; - JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0) is - begin - write (L, to_hstring (VALUE), JUSTIFIED, FIELD); - end procedure HWRITE; - - -- rtl_synthesis on --- pragma synthesis_on -end package body numeric_std_additions; -- cgit v1.1