------------------------------------------------------------------------------ -- "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;