URL
https://opencores.org/ocsvn/vhld_tb/vhld_tb/trunk
Subversion Repositories vhld_tb
[/] [vhld_tb/] [trunk/] [source/] [std_logic_1164_additions/] [std_logic_1164_additions.vhdl] - Rev 17
Go to most recent revision | Compare with Previous | Blame | View Log
------------------------------------------------------------------------------ -- "std_logic_1164_additions" package contains the additions to the standard -- "std_logic_1164" 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_proposed.std_logic_1164_additions.all; -- Last Modified: $Date: 2007-08-21 03:20:14 $ -- RCS ID: $Id: std_logic_1164_additions.vhdl,v 1.1 2007-08-21 03:20:14 sckoarn Exp $ -- -- Created for VHDL-200X par, David Bishop (dbishop@vhdl.org) ------------------------------------------------------------------------------ library ieee; use ieee.std_logic_1164.all; use std.textio.all; package std_logic_1164_additions is -- NOTE that in the new std_logic_1164, STD_LOGIC_VECTOR is a resolved -- subtype of STD_ULOGIC_VECTOR. Thus there is no need for funcitons which -- take inputs in STD_LOGIC_VECTOR. -- For compatability with VHDL-2002, I have replicated all of these funcitons -- here for STD_LOGIC_VECTOR. -- new aliases alias to_bv is ieee.std_logic_1164.To_bitvector [STD_LOGIC_VECTOR, BIT return BIT_VECTOR]; alias to_bv is ieee.std_logic_1164.To_bitvector [STD_ULOGIC_VECTOR, BIT return BIT_VECTOR]; alias to_bit_vector is ieee.std_logic_1164.To_bitvector [STD_LOGIC_VECTOR, BIT return BIT_VECTOR]; alias to_bit_vector is ieee.std_logic_1164.To_bitvector [STD_ULOGIC_VECTOR, BIT return BIT_VECTOR]; alias to_slv is ieee.std_logic_1164.To_StdLogicVector [BIT_VECTOR return STD_LOGIC_VECTOR]; alias to_slv is ieee.std_logic_1164.To_StdLogicVector [STD_ULOGIC_VECTOR return STD_LOGIC_VECTOR]; alias to_std_logic_vector is ieee.std_logic_1164.To_StdLogicVector [BIT_VECTOR return STD_LOGIC_VECTOR]; alias to_std_logic_vector is ieee.std_logic_1164.To_StdLogicVector [STD_ULOGIC_VECTOR return STD_LOGIC_VECTOR]; alias to_suv is ieee.std_logic_1164.To_StdULogicVector [BIT_VECTOR return STD_ULOGIC_VECTOR]; alias to_suv is ieee.std_logic_1164.To_StdULogicVector [STD_LOGIC_VECTOR return STD_ULOGIC_VECTOR]; alias to_std_ulogic_vector is ieee.std_logic_1164.To_StdULogicVector [BIT_VECTOR return STD_ULOGIC_VECTOR]; alias to_std_ulogic_vector is ieee.std_logic_1164.To_StdULogicVector [STD_LOGIC_VECTOR return STD_ULOGIC_VECTOR]; ------------------------------------------------------------------- -- overloaded shift operators ------------------------------------------------------------------- function "sll" (l : STD_LOGIC_VECTOR; r : INTEGER) return STD_LOGIC_VECTOR; function "sll" (l : STD_ULOGIC_VECTOR; r : INTEGER) return STD_ULOGIC_VECTOR; function "srl" (l : STD_LOGIC_VECTOR; r : INTEGER) return STD_LOGIC_VECTOR; function "srl" (l : STD_ULOGIC_VECTOR; r : INTEGER) return STD_ULOGIC_VECTOR; function "rol" (l : STD_LOGIC_VECTOR; r : INTEGER) return STD_LOGIC_VECTOR; function "rol" (l : STD_ULOGIC_VECTOR; r : INTEGER) return STD_ULOGIC_VECTOR; function "ror" (l : STD_LOGIC_VECTOR; r : INTEGER) return STD_LOGIC_VECTOR; function "ror" (l : STD_ULOGIC_VECTOR; r : INTEGER) return STD_ULOGIC_VECTOR; ------------------------------------------------------------------- -- vector/scalar overloaded logical operators ------------------------------------------------------------------- function "and" (l : STD_LOGIC_VECTOR; r : STD_ULOGIC) return STD_LOGIC_VECTOR; function "and" (l : STD_ULOGIC_VECTOR; r : STD_ULOGIC) return STD_ULOGIC_VECTOR; function "and" (l : STD_ULOGIC; r : STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR; function "and" (l : STD_ULOGIC; r : STD_ULOGIC_VECTOR) return STD_ULOGIC_VECTOR; function "nand" (l : STD_LOGIC_VECTOR; r : STD_ULOGIC) return STD_LOGIC_VECTOR; function "nand" (l : STD_ULOGIC_VECTOR; r : STD_ULOGIC) return STD_ULOGIC_VECTOR; function "nand" (l : STD_ULOGIC; r : STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR; function "nand" (l : STD_ULOGIC; r : STD_ULOGIC_VECTOR) return STD_ULOGIC_VECTOR; function "or" (l : STD_LOGIC_VECTOR; r : STD_ULOGIC) return STD_LOGIC_VECTOR; function "or" (l : STD_ULOGIC_VECTOR; r : STD_ULOGIC) return STD_ULOGIC_VECTOR; function "or" (l : STD_ULOGIC; r : STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR; function "or" (l : STD_ULOGIC; r : STD_ULOGIC_VECTOR) return STD_ULOGIC_VECTOR; function "nor" (l : STD_LOGIC_VECTOR; r : STD_ULOGIC) return STD_LOGIC_VECTOR; function "nor" (l : STD_ULOGIC_VECTOR; r : STD_ULOGIC) return STD_ULOGIC_VECTOR; function "nor" (l : STD_ULOGIC; r : STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR; function "nor" (l : STD_ULOGIC; r : STD_ULOGIC_VECTOR) return STD_ULOGIC_VECTOR; function "xor" (l : STD_LOGIC_VECTOR; r : STD_ULOGIC) return STD_LOGIC_VECTOR; function "xor" (l : STD_ULOGIC_VECTOR; r : STD_ULOGIC) return STD_ULOGIC_VECTOR; function "xor" (l : STD_ULOGIC; r : STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR; function "xor" (l : STD_ULOGIC; r : STD_ULOGIC_VECTOR) return STD_ULOGIC_VECTOR; function "xnor" (l : STD_LOGIC_VECTOR; r : STD_ULOGIC) return STD_LOGIC_VECTOR; function "xnor" (l : STD_ULOGIC_VECTOR; r : STD_ULOGIC) return STD_ULOGIC_VECTOR; function "xnor" (l : STD_ULOGIC; r : STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR; function "xnor" (l : STD_ULOGIC; r : STD_ULOGIC_VECTOR) return STD_ULOGIC_VECTOR; ------------------------------------------------------------------- -- vector-reduction functions. -- "and" functions default to "1", or defaults to "0" ------------------------------------------------------------------- ----------------------------------------------------------------------------- -- %%% Replace the "_reduce" functions with the ones commented out below. ----------------------------------------------------------------------------- -- function "and" ( l : std_logic_vector ) RETURN std_ulogic; -- function "and" ( l : std_ulogic_vector ) RETURN std_ulogic; -- function "nand" ( l : std_logic_vector ) RETURN std_ulogic; -- function "nand" ( l : std_ulogic_vector ) RETURN std_ulogic; -- function "or" ( l : std_logic_vector ) RETURN std_ulogic; -- function "or" ( l : std_ulogic_vector ) RETURN std_ulogic; -- function "nor" ( l : std_logic_vector ) RETURN std_ulogic; -- function "nor" ( l : std_ulogic_vector ) RETURN std_ulogic; -- function "xor" ( l : std_logic_vector ) RETURN std_ulogic; -- function "xor" ( l : std_ulogic_vector ) RETURN std_ulogic; -- function "xnor" ( l : std_logic_vector ) RETURN std_ulogic; -- function "xnor" ( l : std_ulogic_vector ) RETURN std_ulogic; function and_reduce (l : STD_LOGIC_VECTOR) return STD_ULOGIC; function and_reduce (l : STD_ULOGIC_VECTOR) return STD_ULOGIC; function nand_reduce (l : STD_LOGIC_VECTOR) return STD_ULOGIC; function nand_reduce (l : STD_ULOGIC_VECTOR) return STD_ULOGIC; function or_reduce (l : STD_LOGIC_VECTOR) return STD_ULOGIC; function or_reduce (l : STD_ULOGIC_VECTOR) return STD_ULOGIC; function nor_reduce (l : STD_LOGIC_VECTOR) return STD_ULOGIC; function nor_reduce (l : STD_ULOGIC_VECTOR) return STD_ULOGIC; function xor_reduce (l : STD_LOGIC_VECTOR) return STD_ULOGIC; function xor_reduce (l : STD_ULOGIC_VECTOR) return STD_ULOGIC; function xnor_reduce (l : STD_LOGIC_VECTOR) return STD_ULOGIC; function xnor_reduce (l : STD_ULOGIC_VECTOR) return STD_ULOGIC; ------------------------------------------------------------------- -- ?= operators, same functionality as 1076.3 1994 std_match ------------------------------------------------------------------- -- FUNCTION "?=" ( l, r : std_ulogic ) RETURN std_ulogic; -- FUNCTION "?=" ( l, r : std_logic_vector ) RETURN std_ulogic; -- FUNCTION "?=" ( l, r : std_ulogic_vector ) RETURN std_ulogic; -- FUNCTION "?/=" ( l, r : std_ulogic ) RETURN std_ulogic; -- FUNCTION "?/=" ( l, r : std_logic_vector ) RETURN std_ulogic; -- FUNCTION "?/=" ( l, r : std_ulogic_vector ) RETURN std_ulogic; -- FUNCTION "?>" ( l, r : std_ulogic ) RETURN std_ulogic; -- FUNCTION "?>=" ( l, r : std_ulogic ) RETURN std_ulogic; -- FUNCTION "?<" ( l, r : std_ulogic ) RETURN std_ulogic; -- FUNCTION "?<=" ( l, r : std_ulogic ) RETURN std_ulogic; function \?=\ (l, r : STD_ULOGIC) return STD_ULOGIC; function \?=\ (l, r : STD_LOGIC_VECTOR) return STD_ULOGIC; function \?=\ (l, r : STD_ULOGIC_VECTOR) return STD_ULOGIC; function \?/=\ (l, r : STD_ULOGIC) return STD_ULOGIC; function \?/=\ (l, r : STD_LOGIC_VECTOR) return STD_ULOGIC; function \?/=\ (l, r : STD_ULOGIC_VECTOR) return STD_ULOGIC; function \?>\ (l, r : STD_ULOGIC) return STD_ULOGIC; function \?>=\ (l, r : STD_ULOGIC) return STD_ULOGIC; function \?<\ (l, r : STD_ULOGIC) return STD_ULOGIC; function \?<=\ (l, r : STD_ULOGIC) return STD_ULOGIC; -- "??" operator, converts a std_ulogic to a boolean. --%%% Uncomment the following operators -- FUNCTION "??" (S : STD_ULOGIC) RETURN BOOLEAN; --%%% REMOVE the following funciton (for testing only) function \??\ (S : STD_ULOGIC) return BOOLEAN; -- rtl_synthesis off function to_string (value : STD_ULOGIC) return STRING; function to_string (value : STD_ULOGIC_VECTOR) return STRING; function to_string (value : STD_LOGIC_VECTOR) return STRING; -- explicitly defined operations alias TO_BSTRING is TO_STRING [STD_ULOGIC_VECTOR return STRING]; alias TO_BINARY_STRING is TO_STRING [STD_ULOGIC_VECTOR return STRING]; function TO_OSTRING (VALUE : STD_ULOGIC_VECTOR) return STRING; alias TO_OCTAL_STRING is TO_OSTRING [STD_ULOGIC_VECTOR return STRING]; function TO_HSTRING (VALUE : STD_ULOGIC_VECTOR) return STRING; alias TO_HEX_STRING is TO_HSTRING [STD_ULOGIC_VECTOR return STRING]; procedure READ (L : inout LINE; VALUE : out STD_ULOGIC; GOOD : out BOOLEAN); procedure READ (L : inout LINE; VALUE : out STD_ULOGIC); procedure READ (L : inout LINE; VALUE : out STD_ULOGIC_VECTOR; GOOD : out BOOLEAN); procedure READ (L : inout LINE; VALUE : out STD_ULOGIC_VECTOR); procedure WRITE (L : inout LINE; VALUE : in STD_ULOGIC; JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0); procedure WRITE (L : inout LINE; VALUE : in STD_ULOGIC_VECTOR; JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0); alias BREAD is READ [LINE, STD_ULOGIC_VECTOR, BOOLEAN]; alias BREAD is READ [LINE, STD_ULOGIC_VECTOR]; alias BINARY_READ is READ [LINE, STD_ULOGIC_VECTOR, BOOLEAN]; alias BINARY_READ is READ [LINE, STD_ULOGIC_VECTOR]; procedure OREAD (L : inout LINE; VALUE : out STD_ULOGIC_VECTOR; GOOD : out BOOLEAN); procedure OREAD (L : inout LINE; VALUE : out STD_ULOGIC_VECTOR); alias OCTAL_READ is OREAD [LINE, STD_ULOGIC_VECTOR, BOOLEAN]; alias OCTAL_READ is OREAD [LINE, STD_ULOGIC_VECTOR]; procedure HREAD (L : inout LINE; VALUE : out STD_ULOGIC_VECTOR; GOOD : out BOOLEAN); procedure HREAD (L : inout LINE; VALUE : out STD_ULOGIC_VECTOR); alias HEX_READ is HREAD [LINE, STD_ULOGIC_VECTOR, BOOLEAN]; alias HEX_READ is HREAD [LINE, STD_ULOGIC_VECTOR]; alias BWRITE is WRITE [LINE, STD_ULOGIC_VECTOR, SIDE, WIDTH]; alias BINARY_WRITE is WRITE [LINE, STD_ULOGIC_VECTOR, SIDE, WIDTH]; procedure OWRITE (L : inout LINE; VALUE : in STD_ULOGIC_VECTOR; JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0); alias OCTAL_WRITE is OWRITE [LINE, STD_ULOGIC_VECTOR, SIDE, WIDTH]; procedure HWRITE (L : inout LINE; VALUE : in STD_ULOGIC_VECTOR; JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0); alias HEX_WRITE is HWRITE [LINE, STD_ULOGIC_VECTOR, SIDE, WIDTH]; alias TO_BSTRING is TO_STRING [STD_LOGIC_VECTOR return STRING]; alias TO_BINARY_STRING is TO_STRING [STD_LOGIC_VECTOR return STRING]; function TO_OSTRING (VALUE : STD_LOGIC_VECTOR) return STRING; alias TO_OCTAL_STRING is TO_OSTRING [STD_LOGIC_VECTOR return STRING]; function TO_HSTRING (VALUE : STD_LOGIC_VECTOR) return STRING; alias TO_HEX_STRING is TO_HSTRING [STD_LOGIC_VECTOR return STRING]; procedure READ (L : inout LINE; VALUE : out STD_LOGIC_VECTOR; GOOD : out BOOLEAN); procedure READ (L : inout LINE; VALUE : out STD_LOGIC_VECTOR); procedure WRITE (L : inout LINE; VALUE : in STD_LOGIC_VECTOR; JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0); alias BREAD is READ [LINE, STD_LOGIC_VECTOR, BOOLEAN]; alias BREAD is READ [LINE, STD_LOGIC_VECTOR]; alias BINARY_READ is READ [LINE, STD_LOGIC_VECTOR, BOOLEAN]; alias BINARY_READ is READ [LINE, STD_LOGIC_VECTOR]; procedure OREAD (L : inout LINE; VALUE : out STD_LOGIC_VECTOR; GOOD : out BOOLEAN); procedure OREAD (L : inout LINE; VALUE : out STD_LOGIC_VECTOR); alias OCTAL_READ is OREAD [LINE, STD_LOGIC_VECTOR, BOOLEAN]; alias OCTAL_READ is OREAD [LINE, STD_LOGIC_VECTOR]; procedure HREAD (L : inout LINE; VALUE : out STD_LOGIC_VECTOR; GOOD : out BOOLEAN); procedure HREAD (L : inout LINE; VALUE : out STD_LOGIC_VECTOR); alias HEX_READ is HREAD [LINE, STD_LOGIC_VECTOR, BOOLEAN]; alias HEX_READ is HREAD [LINE, STD_LOGIC_VECTOR]; alias BWRITE is WRITE [LINE, STD_LOGIC_VECTOR, SIDE, WIDTH]; alias BINARY_WRITE is WRITE [LINE, STD_LOGIC_VECTOR, SIDE, WIDTH]; procedure OWRITE (L : inout LINE; VALUE : in STD_LOGIC_VECTOR; JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0); alias OCTAL_WRITE is OWRITE [LINE, STD_LOGIC_VECTOR, SIDE, WIDTH]; procedure HWRITE (L : inout LINE; VALUE : in STD_LOGIC_VECTOR; JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0); alias HEX_WRITE is HWRITE [LINE, STD_LOGIC_VECTOR, SIDE, WIDTH]; -- rtl_synthesis on function maximum (l, r : STD_ULOGIC_VECTOR) return STD_ULOGIC_VECTOR; function maximum (l, r : STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR; function maximum (l, r : STD_ULOGIC) return STD_ULOGIC; function minimum (l, r : STD_ULOGIC_VECTOR) return STD_ULOGIC_VECTOR; function minimum (l, r : STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR; function minimum (l, r : STD_ULOGIC) return STD_ULOGIC; end package std_logic_1164_additions; package body std_logic_1164_additions is type stdlogic_table is array(STD_ULOGIC, STD_ULOGIC) of STD_ULOGIC; ----------------------------------------------------------------------------- -- New/updated funcitons for VHDL-200X fast track ----------------------------------------------------------------------------- ------------------------------------------------------------------- -- overloaded shift operators ------------------------------------------------------------------- ------------------------------------------------------------------- -- sll ------------------------------------------------------------------- function "sll" (l : STD_LOGIC_VECTOR; r : INTEGER) return STD_LOGIC_VECTOR is alias lv : STD_LOGIC_VECTOR (1 to l'length) is l; variable result : STD_LOGIC_VECTOR (1 to l'length) := (others => '0'); begin if r >= 0 then result(1 to l'length - r) := lv(r + 1 to l'length); else result := l srl -r; end if; return result; end function "sll"; ------------------------------------------------------------------- function "sll" (l : STD_ULOGIC_VECTOR; r : INTEGER) return STD_ULOGIC_VECTOR is alias lv : STD_ULOGIC_VECTOR (1 to l'length) is l; variable result : STD_ULOGIC_VECTOR (1 to l'length) := (others => '0'); begin if r >= 0 then result(1 to l'length - r) := lv(r + 1 to l'length); else result := l srl -r; end if; return result; end function "sll"; ------------------------------------------------------------------- -- srl ------------------------------------------------------------------- function "srl" (l : STD_LOGIC_VECTOR; r : INTEGER) return STD_LOGIC_VECTOR is alias lv : STD_LOGIC_VECTOR (1 to l'length) is l; variable result : STD_LOGIC_VECTOR (1 to l'length) := (others => '0'); begin if r >= 0 then result(r + 1 to l'length) := lv(1 to l'length - r); else result := l sll -r; end if; return result; end function "srl"; ------------------------------------------------------------------- function "srl" (l : STD_ULOGIC_VECTOR; r : INTEGER) return STD_ULOGIC_VECTOR is alias lv : STD_ULOGIC_VECTOR (1 to l'length) is l; variable result : STD_ULOGIC_VECTOR (1 to l'length) := (others => '0'); begin if r >= 0 then result(r + 1 to l'length) := lv(1 to l'length - r); else result := l sll -r; end if; return result; end function "srl"; ------------------------------------------------------------------- -- rol ------------------------------------------------------------------- function "rol" (l : STD_LOGIC_VECTOR; r : INTEGER) return STD_LOGIC_VECTOR is alias lv : STD_LOGIC_VECTOR (1 to l'length) is l; variable result : STD_LOGIC_VECTOR (1 to l'length); constant rm : INTEGER := r mod l'length; begin if r >= 0 then result(1 to l'length - rm) := lv(rm + 1 to l'length); result(l'length - rm + 1 to l'length) := lv(1 to rm); else result := l ror -r; end if; return result; end function "rol"; ------------------------------------------------------------------- function "rol" (l : STD_ULOGIC_VECTOR; r : INTEGER) return STD_ULOGIC_VECTOR is alias lv : STD_ULOGIC_VECTOR (1 to l'length) is l; variable result : STD_ULOGIC_VECTOR (1 to l'length); constant rm : INTEGER := r mod l'length; begin if r >= 0 then result(1 to l'length - rm) := lv(rm + 1 to l'length); result(l'length - rm + 1 to l'length) := lv(1 to rm); else result := l ror -r; end if; return result; end function "rol"; ------------------------------------------------------------------- -- ror ------------------------------------------------------------------- function "ror" (l : STD_LOGIC_VECTOR; r : INTEGER) return STD_LOGIC_VECTOR is alias lv : STD_LOGIC_VECTOR (1 to l'length) is l; variable result : STD_LOGIC_VECTOR (1 to l'length) := (others => '0'); constant rm : INTEGER := r mod l'length; begin if r >= 0 then result(rm + 1 to l'length) := lv(1 to l'length - rm); result(1 to rm) := lv(l'length - rm + 1 to l'length); else result := l rol -r; end if; return result; end function "ror"; ------------------------------------------------------------------- function "ror" (l : STD_ULOGIC_VECTOR; r : INTEGER) return STD_ULOGIC_VECTOR is alias lv : STD_ULOGIC_VECTOR (1 to l'length) is l; variable result : STD_ULOGIC_VECTOR (1 to l'length) := (others => '0'); constant rm : INTEGER := r mod l'length; begin if r >= 0 then result(rm + 1 to l'length) := lv(1 to l'length - rm); result(1 to rm) := lv(l'length - rm + 1 to l'length); else result := l rol -r; end if; return result; end function "ror"; ------------------------------------------------------------------- -- vector/scalar overloaded logical operators ------------------------------------------------------------------- ------------------------------------------------------------------- -- and ------------------------------------------------------------------- function "and" (l : STD_LOGIC_VECTOR; r : STD_ULOGIC) return STD_LOGIC_VECTOR is alias lv : STD_LOGIC_VECTOR (1 to l'length) is l; variable result : STD_LOGIC_VECTOR (1 to l'length); begin for i in result'range loop result(i) := "and" (lv(i), r); end loop; return result; end function "and"; ------------------------------------------------------------------- function "and" (l : STD_ULOGIC_VECTOR; r : STD_ULOGIC) return STD_ULOGIC_VECTOR is alias lv : STD_ULOGIC_VECTOR (1 to l'length) is l; variable result : STD_ULOGIC_VECTOR (1 to l'length); begin for i in result'range loop result(i) := "and" (lv(i), r); end loop; return result; end function "and"; ------------------------------------------------------------------- function "and" (l : STD_ULOGIC; r : STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR is alias rv : STD_LOGIC_VECTOR (1 to r'length) is r; variable result : STD_LOGIC_VECTOR (1 to r'length); begin for i in result'range loop result(i) := "and" (l, rv(i)); end loop; return result; end function "and"; ------------------------------------------------------------------- function "and" (l : STD_ULOGIC; r : STD_ULOGIC_VECTOR) return STD_ULOGIC_VECTOR is alias rv : STD_ULOGIC_VECTOR (1 to r'length) is r; variable result : STD_ULOGIC_VECTOR (1 to r'length); begin for i in result'range loop result(i) := "and" (l, rv(i)); end loop; return result; end function "and"; ------------------------------------------------------------------- -- nand ------------------------------------------------------------------- function "nand" (l : STD_LOGIC_VECTOR; r : STD_ULOGIC) return STD_LOGIC_VECTOR is alias lv : STD_LOGIC_VECTOR (1 to l'length) is l; variable result : STD_LOGIC_VECTOR (1 to l'length); begin for i in result'range loop result(i) := "not"("and" (lv(i), r)); end loop; return result; end function "nand"; ------------------------------------------------------------------- function "nand" (l : STD_ULOGIC_VECTOR; r : STD_ULOGIC) return STD_ULOGIC_VECTOR is alias lv : STD_ULOGIC_VECTOR (1 to l'length) is l; variable result : STD_ULOGIC_VECTOR (1 to l'length); begin for i in result'range loop result(i) := "not"("and" (lv(i), r)); end loop; return result; end function "nand"; ------------------------------------------------------------------- function "nand" (l : STD_ULOGIC; r : STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR is alias rv : STD_LOGIC_VECTOR (1 to r'length) is r; variable result : STD_LOGIC_VECTOR (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"; ------------------------------------------------------------------- function "nand" (l : STD_ULOGIC; r : STD_ULOGIC_VECTOR) return STD_ULOGIC_VECTOR is alias rv : STD_ULOGIC_VECTOR (1 to r'length) is r; variable result : STD_ULOGIC_VECTOR (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"; ------------------------------------------------------------------- -- or ------------------------------------------------------------------- function "or" (l : STD_LOGIC_VECTOR; r : STD_ULOGIC) return STD_LOGIC_VECTOR is alias lv : STD_LOGIC_VECTOR (1 to l'length) is l; variable result : STD_LOGIC_VECTOR (1 to l'length); begin for i in result'range loop result(i) := "or" (lv(i), r); end loop; return result; end function "or"; ------------------------------------------------------------------- function "or" (l : STD_ULOGIC_VECTOR; r : STD_ULOGIC) return STD_ULOGIC_VECTOR is alias lv : STD_ULOGIC_VECTOR (1 to l'length) is l; variable result : STD_ULOGIC_VECTOR (1 to l'length); begin for i in result'range loop result(i) := "or" (lv(i), r); end loop; return result; end function "or"; ------------------------------------------------------------------- function "or" (l : STD_ULOGIC; r : STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR is alias rv : STD_LOGIC_VECTOR (1 to r'length) is r; variable result : STD_LOGIC_VECTOR (1 to r'length); begin for i in result'range loop result(i) := "or" (l, rv(i)); end loop; return result; end function "or"; ------------------------------------------------------------------- function "or" (l : STD_ULOGIC; r : STD_ULOGIC_VECTOR) return STD_ULOGIC_VECTOR is alias rv : STD_ULOGIC_VECTOR (1 to r'length) is r; variable result : STD_ULOGIC_VECTOR (1 to r'length); begin for i in result'range loop result(i) := "or" (l, rv(i)); end loop; return result; end function "or"; ------------------------------------------------------------------- -- nor ------------------------------------------------------------------- function "nor" (l : STD_LOGIC_VECTOR; r : STD_ULOGIC) return STD_LOGIC_VECTOR is alias lv : STD_LOGIC_VECTOR (1 to l'length) is l; variable result : STD_LOGIC_VECTOR (1 to l'length); begin for i in result'range loop result(i) := "not"("or" (lv(i), r)); end loop; return result; end function "nor"; ------------------------------------------------------------------- function "nor" (l : STD_ULOGIC_VECTOR; r : STD_ULOGIC) return STD_ULOGIC_VECTOR is alias lv : STD_ULOGIC_VECTOR (1 to l'length) is l; variable result : STD_ULOGIC_VECTOR (1 to l'length); begin for i in result'range loop result(i) := "not"("or" (lv(i), r)); end loop; return result; end function "nor"; ------------------------------------------------------------------- function "nor" (l : STD_ULOGIC; r : STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR is alias rv : STD_LOGIC_VECTOR (1 to r'length) is r; variable result : STD_LOGIC_VECTOR (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"; ------------------------------------------------------------------- function "nor" (l : STD_ULOGIC; r : STD_ULOGIC_VECTOR) return STD_ULOGIC_VECTOR is alias rv : STD_ULOGIC_VECTOR (1 to r'length) is r; variable result : STD_ULOGIC_VECTOR (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"; ------------------------------------------------------------------- -- xor ------------------------------------------------------------------- function "xor" (l : STD_LOGIC_VECTOR; r : STD_ULOGIC) return STD_LOGIC_VECTOR is alias lv : STD_LOGIC_VECTOR (1 to l'length) is l; variable result : STD_LOGIC_VECTOR (1 to l'length); begin for i in result'range loop result(i) := "xor" (lv(i), r); end loop; return result; end function "xor"; ------------------------------------------------------------------- function "xor" (l : STD_ULOGIC_VECTOR; r : STD_ULOGIC) return STD_ULOGIC_VECTOR is alias lv : STD_ULOGIC_VECTOR (1 to l'length) is l; variable result : STD_ULOGIC_VECTOR (1 to l'length); begin for i in result'range loop result(i) := "xor" (lv(i), r); end loop; return result; end function "xor"; ------------------------------------------------------------------- function "xor" (l : STD_ULOGIC; r : STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR is alias rv : STD_LOGIC_VECTOR (1 to r'length) is r; variable result : STD_LOGIC_VECTOR (1 to r'length); begin for i in result'range loop result(i) := "xor" (l, rv(i)); end loop; return result; end function "xor"; ------------------------------------------------------------------- function "xor" (l : STD_ULOGIC; r : STD_ULOGIC_VECTOR) return STD_ULOGIC_VECTOR is alias rv : STD_ULOGIC_VECTOR (1 to r'length) is r; variable result : STD_ULOGIC_VECTOR (1 to r'length); begin for i in result'range loop result(i) := "xor" (l, rv(i)); end loop; return result; end function "xor"; ------------------------------------------------------------------- -- xnor ------------------------------------------------------------------- function "xnor" (l : STD_LOGIC_VECTOR; r : STD_ULOGIC) return STD_LOGIC_VECTOR is alias lv : STD_LOGIC_VECTOR (1 to l'length) is l; variable result : STD_LOGIC_VECTOR (1 to l'length); begin for i in result'range loop result(i) := "not"("xor" (lv(i), r)); end loop; return result; end function "xnor"; ------------------------------------------------------------------- function "xnor" (l : STD_ULOGIC_VECTOR; r : STD_ULOGIC) return STD_ULOGIC_VECTOR is alias lv : STD_ULOGIC_VECTOR (1 to l'length) is l; variable result : STD_ULOGIC_VECTOR (1 to l'length); begin for i in result'range loop result(i) := "not"("xor" (lv(i), r)); end loop; return result; end function "xnor"; ------------------------------------------------------------------- function "xnor" (l : STD_ULOGIC; r : STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR is alias rv : STD_LOGIC_VECTOR (1 to r'length) is r; variable result : STD_LOGIC_VECTOR (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"; ------------------------------------------------------------------- function "xnor" (l : STD_ULOGIC; r : STD_ULOGIC_VECTOR) return STD_ULOGIC_VECTOR is alias rv : STD_ULOGIC_VECTOR (1 to r'length) is r; variable result : STD_ULOGIC_VECTOR (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"; ------------------------------------------------------------------- -- vector-reduction functions ------------------------------------------------------------------- ------------------------------------------------------------------- -- and ------------------------------------------------------------------- function and_reduce (l : STD_LOGIC_VECTOR) return STD_ULOGIC is begin return and_reduce (to_StdULogicVector (l)); end function and_reduce; ------------------------------------------------------------------- function and_reduce (l : STD_ULOGIC_VECTOR) return STD_ULOGIC is variable result : STD_ULOGIC := '1'; begin for i in l'reverse_range loop result := (l(i) and result); end loop; return result; end function and_reduce; ------------------------------------------------------------------- -- nand ------------------------------------------------------------------- function nand_reduce (l : STD_LOGIC_VECTOR) return STD_ULOGIC is begin return not (and_reduce(to_StdULogicVector(l))); end function nand_reduce; ------------------------------------------------------------------- function nand_reduce (l : STD_ULOGIC_VECTOR) return STD_ULOGIC is begin return not (and_reduce(l)); end function nand_reduce; ------------------------------------------------------------------- -- or ------------------------------------------------------------------- function or_reduce (l : STD_LOGIC_VECTOR) return STD_ULOGIC is begin return or_reduce (to_StdULogicVector (l)); end function or_reduce; ------------------------------------------------------------------- function or_reduce (l : STD_ULOGIC_VECTOR) return STD_ULOGIC is variable result : STD_ULOGIC := '0'; begin for i in l'reverse_range loop result := (l(i) or result); end loop; return result; end function or_reduce; ------------------------------------------------------------------- -- nor ------------------------------------------------------------------- function nor_reduce (l : STD_LOGIC_VECTOR) return STD_ULOGIC is begin return "not"(or_reduce(To_StdULogicVector(l))); end function nor_reduce; ------------------------------------------------------------------- function nor_reduce (l : STD_ULOGIC_VECTOR) return STD_ULOGIC is begin return "not"(or_reduce(l)); end function nor_reduce; ------------------------------------------------------------------- -- xor ------------------------------------------------------------------- function xor_reduce (l : STD_LOGIC_VECTOR) return STD_ULOGIC is begin return xor_reduce (to_StdULogicVector (l)); end function xor_reduce; ------------------------------------------------------------------- function xor_reduce (l : STD_ULOGIC_VECTOR) return STD_ULOGIC is variable result : STD_ULOGIC := '0'; begin for i in l'reverse_range loop result := (l(i) xor result); end loop; return result; end function xor_reduce; ------------------------------------------------------------------- -- xnor ------------------------------------------------------------------- function xnor_reduce (l : STD_LOGIC_VECTOR) return STD_ULOGIC is begin return "not"(xor_reduce(To_StdULogicVector(l))); end function xnor_reduce; ------------------------------------------------------------------- function xnor_reduce (l : STD_ULOGIC_VECTOR) return STD_ULOGIC is begin return "not"(xor_reduce(l)); end function xnor_reduce; -- %%% End "remove the following functions" -- The following functions are implicity in 1076-2006 -- truth table for "?=" function 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') -- | - | ); ------------------------------------------------------------------- -- ?= functions, Similar to "std_match", but returns "std_ulogic". ------------------------------------------------------------------- -- %%% FUNCTION "?=" ( l, r : std_ulogic ) RETURN std_ulogic IS function \?=\ (l, r : STD_ULOGIC) return STD_ULOGIC is begin return match_logic_table (l, r); end function \?=\; -- %%% END FUNCTION "?="; ------------------------------------------------------------------- -- %%% FUNCTION "?=" ( l, r : std_logic_vector ) RETURN std_ulogic IS function \?=\ (l, r : STD_LOGIC_VECTOR) return STD_ULOGIC is alias lv : STD_LOGIC_VECTOR(1 to l'length) is l; alias rv : STD_LOGIC_VECTOR(1 to r'length) is r; variable result, result1 : STD_ULOGIC; -- result begin -- Logically identical to an "=" operator. if ((l'length < 1) or (r'length < 1)) then report "STD_LOGIC_1164.""?="": null detected, returning X" severity warning; return 'X'; end if; if lv'length /= rv'length then report "STD_LOGIC_1164.""?="": L'LENGTH /= R'LENGTH, returning X" severity warning; return 'X'; else result := '1'; for i in lv'low to lv'high loop result1 := match_logic_table(lv(i), rv(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 \?=\; -- %%% END FUNCTION "?="; ------------------------------------------------------------------- -- %%% FUNCTION "?=" ( l, r : std_ulogic_vector ) RETURN std_ulogic IS function \?=\ (l, r : STD_ULOGIC_VECTOR) return STD_ULOGIC is alias lv : STD_ULOGIC_VECTOR(1 to l'length) is l; alias rv : STD_ULOGIC_VECTOR(1 to r'length) is r; variable result, result1 : STD_ULOGIC; begin if ((l'length < 1) or (r'length < 1)) then report "STD_LOGIC_1164.""?="": null detected, returning X" severity warning; return 'X'; end if; if lv'length /= rv'length then report "STD_LOGIC_1164.""?="": L'LENGTH /= R'LENGTH, returning X" severity warning; return 'X'; else result := '1'; for i in lv'low to lv'high loop result1 := match_logic_table(lv(i), rv(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 \?=\; -- %%% END FUNCTION "?="; -- %%% FUNCTION "?/=" ( l, r : std_ulogic ) RETURN std_ulogic is function \?/=\ (l, r : STD_ULOGIC) return STD_ULOGIC is begin return no_match_logic_table (l, r); end function \?/=\; -- %%% END FUNCTION "?/="; -- %%% FUNCTION "?/=" ( l, r : std_logic_vector ) RETURN std_ulogic is function \?/=\ (l, r : STD_LOGIC_VECTOR) return STD_ULOGIC is alias lv : STD_LOGIC_VECTOR(1 to l'length) is l; alias rv : STD_LOGIC_VECTOR(1 to r'length) is r; variable result, result1 : STD_ULOGIC; -- result begin if ((l'length < 1) or (r'length < 1)) then report "STD_LOGIC_1164.""?/="": null detected, returning X" severity warning; return 'X'; end if; if lv'length /= rv'length then report "STD_LOGIC_1164.""?/="": L'LENGTH /= R'LENGTH, returning X" severity warning; return 'X'; else result := '0'; for i in lv'low to lv'high loop result1 := no_match_logic_table(lv(i), rv(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 \?/=\; -- %%% END FUNCTION "?/="; -- %%% FUNCTION "?/=" ( l, r : std_ulogic_vector ) RETURN std_ulogic is function \?/=\ (l, r : STD_ULOGIC_VECTOR) return STD_ULOGIC is alias lv : STD_ULOGIC_VECTOR(1 to l'length) is l; alias rv : STD_ULOGIC_VECTOR(1 to r'length) is r; variable result, result1 : STD_ULOGIC; begin if ((l'length < 1) or (r'length < 1)) then report "STD_LOGIC_1164.""?/="": null detected, returning X" severity warning; return 'X'; end if; if lv'length /= rv'length then report "STD_LOGIC_1164.""?/="": L'LENGTH /= R'LENGTH, returning X" severity warning; return 'X'; else result := '0'; for i in lv'low to lv'high loop result1 := no_match_logic_table(lv(i), rv(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 \?/=\; -- %%% END FUNCTION "?/="; -- %%% FUNCTION "?>" ( l, r : std_ulogic ) RETURN std_ulogic is function \?>\ (l, r : STD_ULOGIC) return STD_ULOGIC is variable lx, rx : STD_ULOGIC; begin if (l = '-') or (r = '-') then report "STD_LOGIC_1164.""?>"": '-' found in compare string" severity error; return 'X'; else lx := to_x01 (l); rx := to_x01 (r); if lx = 'X' or rx = 'X' then return 'X'; elsif lx > rx then return '1'; else return '0'; end if; end if; end function \?>\; -- %%% END FUNCTION "?>"; -- %%% FUNCTION "?>=" ( l, r : std_ulogic ) RETURN std_ulogic is function \?>=\ (l, r : STD_ULOGIC) return STD_ULOGIC is variable lx, rx : STD_ULOGIC; begin if (l = '-') or (r = '-') then report "STD_LOGIC_1164.""?>="": '-' found in compare string" severity error; return 'X'; else lx := to_x01 (l); rx := to_x01 (r); if lx = 'X' or rx = 'X' then return 'X'; elsif lx >= rx then return '1'; else return '0'; end if; end if; end function \?>=\; -- %%% END FUNCTION "?/>="; -- %%% FUNCTION "?<" ( l, r : std_ulogic ) RETURN std_ulogic is function \?<\ (l, r : STD_ULOGIC) return STD_ULOGIC is variable lx, rx : STD_ULOGIC; begin if (l = '-') or (r = '-') then report "STD_LOGIC_1164.""?<"": '-' found in compare string" severity error; return 'X'; else lx := to_x01 (l); rx := to_x01 (r); if lx = 'X' or rx = 'X' then return 'X'; elsif lx < rx then return '1'; else return '0'; end if; end if; end function \?<\; -- %%% END FUNCTION "?/<"; -- %%% FUNCTION "?<=" ( l, r : std_ulogic ) RETURN std_ulogic is function \?<=\ (l, r : STD_ULOGIC) return STD_ULOGIC is variable lx, rx : STD_ULOGIC; begin if (l = '-') or (r = '-') then report "STD_LOGIC_1164.""?<="": '-' found in compare string" severity error; return 'X'; else lx := to_x01 (l); rx := to_x01 (r); if lx = 'X' or rx = 'X' then return 'X'; elsif lx <= rx then return '1'; else return '0'; end if; end if; end function \?<=\; -- %%% END FUNCTION "?/<="; -- "??" operator, converts a std_ulogic to a boolean. -- %%% FUNCTION "??" function \??\ (S : STD_ULOGIC) return BOOLEAN is begin return S = '1' or S = 'H'; end function \??\; -- %%% END FUNCTION "??"; -- rtl_synthesis off ----------------------------------------------------------------------------- -- This section copied from "std_logic_textio" ----------------------------------------------------------------------------- -- 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 STRING -- 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; GOOD : out BOOLEAN) is variable c : CHARACTER; variable readOk : BOOLEAN; begin VALUE := 'U'; -- initialize to a "U" Skip_whitespace (L); read (l, c, readOk); if not readOk then good := false; else if char_to_MVL9plus(c) = error then good := false; else VALUE := char_to_MVL9(c); good := true; end if; end if; end procedure READ; 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 := false; while i < VALUE'length loop if not readOk then -- Bail out if there was a bad read return; elsif c = '_' then if i = 0 then -- Begins with an "_" return; elsif lastu then -- "__" detected return; else lastu := true; end if; elsif (char_to_MVL9plus(c) = error) then -- Illegal character return; else mv(i) := char_to_MVL9(c); i := i + 1; if i > mv'high then -- reading done good := true; 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) is variable c : CHARACTER; variable readOk : BOOLEAN; begin VALUE := 'U'; -- initialize to a "U" Skip_whitespace (L); read (l, c, readOk); if not readOk then report "STD_LOGIC_1164.READ(STD_ULOGIC) " & "End of string encountered" severity error; return; elsif char_to_MVL9plus(c) = error then report "STD_LOGIC_1164.READ(STD_ULOGIC) Error: Character '" & c & "' read, expected STD_ULOGIC literal." severity error; else VALUE := char_to_MVL9(c); 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 c = ' ' or c = NBSP or c = HT then -- reading done. report "STD_LOGIC_1164.READ(STD_ULOGIC_VECTOR) " & "Short read, Space encounted in input string" severity error; return; 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; procedure WRITE (L : inout LINE; VALUE : in STD_ULOGIC; JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0) is begin write(l, MVL9_to_char(VALUE), justified, field); end procedure WRITE; procedure WRITE (L : inout LINE; VALUE : in STD_ULOGIC_VECTOR; JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0) is variable s : STRING(1 to VALUE'length); variable m : STD_ULOGIC_VECTOR(1 to VALUE'length) := VALUE; begin for i in 1 to VALUE'length loop s(i) := MVL9_to_char(m(i)); end loop; write(l, s, justified, field); end procedure WRITE; -- Read and Write procedures for STD_LOGIC_VECTOR procedure READ (L : inout LINE; VALUE : out STD_LOGIC_VECTOR; GOOD : out BOOLEAN) is variable ivalue : STD_ULOGIC_VECTOR (VALUE'range); begin READ (L => L, VALUE => ivalue, GOOD => GOOD); VALUE := to_stdlogicvector (ivalue); end procedure READ; procedure READ (L : inout LINE; VALUE : out STD_LOGIC_VECTOR) is variable ivalue : STD_ULOGIC_VECTOR (VALUE'range); begin READ (L => L, VALUE => ivalue); VALUE := to_stdlogicvector (ivalue); end procedure READ; procedure WRITE (L : inout LINE; VALUE : in STD_LOGIC_VECTOR; JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0) is variable s : STRING(1 to VALUE'length); variable m : STD_LOGIC_VECTOR(1 to VALUE'length) := VALUE; begin for i in 1 to VALUE'length loop s(i) := MVL9_to_char(m(i)); end loop; write(L, s, justified, field); end procedure WRITE; ----------------------------------------------------------------------- -- Alias for bread and bwrite are provided with call out the read and -- write functions. ----------------------------------------------------------------------- -- Hex Read and Write procedures for STD_ULOGIC_VECTOR. -- Modified from the original to be more forgiving. 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; procedure HWRITE (L : inout LINE; VALUE : in STD_ULOGIC_VECTOR; JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0) is begin write (L, to_hstring (VALUE), JUSTIFIED, FIELD); end procedure HWRITE; -- 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; procedure OWRITE (L : inout LINE; VALUE : in STD_ULOGIC_VECTOR; JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0) is begin write (L, to_ostring(VALUE), JUSTIFIED, FIELD); end procedure OWRITE; -- Hex Read and Write procedures for STD_LOGIC_VECTOR procedure HREAD (L : inout LINE; VALUE : out STD_LOGIC_VECTOR; GOOD : out BOOLEAN) is variable ivalue : STD_ULOGIC_VECTOR (VALUE'range); begin HREAD (L => L, VALUE => ivalue, GOOD => GOOD); VALUE := to_stdlogicvector (ivalue); end procedure HREAD; procedure HREAD (L : inout LINE; VALUE : out STD_LOGIC_VECTOR) is variable ivalue : STD_ULOGIC_VECTOR (VALUE'range); begin HREAD (L => L, VALUE => ivalue); VALUE := to_stdlogicvector (ivalue); end procedure HREAD; procedure HWRITE (L : inout LINE; VALUE : in STD_LOGIC_VECTOR; JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0) is begin write (L, to_hstring(VALUE), JUSTIFIED, FIELD); end procedure HWRITE; -- Octal Read and Write procedures for STD_LOGIC_VECTOR procedure OREAD (L : inout LINE; VALUE : out STD_LOGIC_VECTOR; GOOD : out BOOLEAN) is variable ivalue : STD_ULOGIC_VECTOR (VALUE'range); begin OREAD (L => L, VALUE => ivalue, GOOD => GOOD); VALUE := to_stdlogicvector (ivalue); end procedure OREAD; procedure OREAD (L : inout LINE; VALUE : out STD_LOGIC_VECTOR) is variable ivalue : STD_ULOGIC_VECTOR (VALUE'range); begin OREAD (L => L, VALUE => ivalue); VALUE := to_stdlogicvector (ivalue); end procedure OREAD; procedure OWRITE (L : inout LINE; VALUE : in STD_LOGIC_VECTOR; JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0) is begin write (L, to_ostring(VALUE), JUSTIFIED, FIELD); end procedure OWRITE; ----------------------------------------------------------------------------- -- New string functions for vhdl-200x fast track ----------------------------------------------------------------------------- function to_string (value : STD_ULOGIC) return STRING is variable result : STRING (1 to 1); begin result (1) := MVL9_to_char (value); return result; end function to_string; ------------------------------------------------------------------- -- TO_STRING (an alias called "to_bstring" is provide) ------------------------------------------------------------------- function to_string (value : STD_ULOGIC_VECTOR) return STRING is alias ivalue : STD_ULOGIC_VECTOR(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; ------------------------------------------------------------------- -- TO_HSTRING ------------------------------------------------------------------- function to_hstring (value : STD_ULOGIC_VECTOR) return STRING is constant ne : INTEGER := (value'length+3)/4; variable pad : STD_ULOGIC_VECTOR(0 to (ne*4 - value'length) - 1); variable ivalue : STD_ULOGIC_VECTOR(0 to ne*4 - 1); variable result : STRING(1 to ne); variable quad : STD_ULOGIC_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 & 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; ------------------------------------------------------------------- -- TO_OSTRING ------------------------------------------------------------------- function to_ostring (value : STD_ULOGIC_VECTOR) return STRING is constant ne : INTEGER := (value'length+2)/3; variable pad : STD_ULOGIC_VECTOR(0 to (ne*3 - value'length) - 1); variable ivalue : STD_ULOGIC_VECTOR(0 to ne*3 - 1); variable result : STRING(1 to ne); variable tri : STD_ULOGIC_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 & 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_string (value : STD_LOGIC_VECTOR) return STRING is begin return to_string (to_stdulogicvector (value)); end function to_string; function to_hstring (value : STD_LOGIC_VECTOR) return STRING is begin return to_hstring (to_stdulogicvector (value)); end function to_hstring; function to_ostring (value : STD_LOGIC_VECTOR) return STRING is begin return to_ostring (to_stdulogicvector (value)); end function to_ostring; -- rtl_synthesis on function maximum (L, R : STD_ULOGIC_VECTOR) return STD_ULOGIC_VECTOR is begin -- function maximum if L > R then return L; else return R; end if; end function maximum; -- std_logic_vector output function minimum (L, R : STD_ULOGIC_VECTOR) return STD_ULOGIC_VECTOR is begin -- function minimum if L > R then return R; else return L; end if; end function minimum; function maximum (L, R : STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR is begin -- function maximum if L > R then return L; else return R; end if; end function maximum; -- std_logic_vector output function minimum (L, R : STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR is begin -- function minimum if L > R then return R; else return L; end if; end function minimum; function maximum (L, R : STD_ULOGIC) return STD_ULOGIC is begin -- function maximum if L > R then return L; else return R; end if; end function maximum; -- std_logic_vector output function minimum (L, R : STD_ULOGIC) return STD_ULOGIC is begin -- function minimum if L > R then return R; else return L; end if; end function minimum; end package body std_logic_1164_additions;
Go to most recent revision | Compare with Previous | Blame | View Log