summaryrefslogtreecommitdiffstats
path: root/ieee_proposed/rtl/numeric_std_additions.vhd
diff options
context:
space:
mode:
authorBert Lange <b.lange@hzdr.de>2015-04-15 13:54:39 +0200
committerBert Lange <b.lange@hzdr.de>2015-04-15 13:54:39 +0200
commit8c5a743259480ebd0cfdbb17fbde8584e34b2aa4 (patch)
tree794887f475d6abb4bdde21c94105f7fcdde1bdd4 /ieee_proposed/rtl/numeric_std_additions.vhd
parenta1c964908b51599bf624bd2d253419c7e629f195 (diff)
downloadzpu-8c5a743259480ebd0cfdbb17fbde8584e34b2aa4.zip
zpu-8c5a743259480ebd0cfdbb17fbde8584e34b2aa4.tar.gz
clean up
Diffstat (limited to 'ieee_proposed/rtl/numeric_std_additions.vhd')
-rw-r--r--ieee_proposed/rtl/numeric_std_additions.vhd2886
1 files changed, 0 insertions, 2886 deletions
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;
OpenPOWER on IntegriCloud