-- -------------------------------------------------------------------- -- -- File name : std_logic_1164_extensions.pkg_body.vhdl -- Title : STD_LOGIC_1164_EXTENSIONS package ( multivalue logic system ) -- Library : -- Author(s) : MENTOR GRAPHICS CORPORATION. -- Purpose : To define the declarations made in the package -- : -- Notes : -- -------------------------------------------------------------------- -- Modification History : -- -------------------------------------------------------------------- -- Version No:| Author:| Mod. Date:| Changes Made: -- v1.000 | kk | 05/26/91 | define functions declared in the package. -- v1.001 | bsg | 07/02/91 | Change 'D' back to '-' as to perposal -- -------------------------------------------------------------------- -- -------------------------------------------------------------------- LIBRARY IEEE; PACKAGE BODY std_logic_1164_extensions is USE IEEE.std_logic_1164.ALL; ------------------------------------------------------------------- -- Local Types ------------------------------------------------------------------- TYPE stdlogic_1D is array (std_ulogic) of std_ulogic; TYPE stdlogic_table is array(std_ulogic, std_ulogic) of std_ulogic; TYPE stdlogic_boolean_table is array(std_ulogic, std_ulogic) of boolean; -------------------------------------------------------------------- -------------------------------------------------------------------- -- FUNCTIONS DEFINED FOR SYNTHESIS -------------------------------------------------------------------- -------------------------------------------------------------------- FUNCTION std_ulogic_wired_x ( input : std_ulogic_vector ) RETURN std_ulogic IS VARIABLE result : std_ulogic := 'Z'; -- weakest state default CONSTANT resolution_table : stdlogic_table := ( -- --------------------------------------------------------- -- | U X 0 1 Z W L H D | | -- --------------------------------------------------------- ( 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | U | ( 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | X | ( 'X', 'X', '0', 'X', '0', 'X', '0', 'X', '0' ), -- | 0 | ( 'X', 'X', 'X', '1', '1', 'X', 'X', '1', '1' ), -- | 1 | ( 'X', 'X', '0', '1', 'Z', 'X', '0', '1', 'Z' ), -- | Z | ( 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | W | ( 'X', 'X', '0', 'X', '0', 'X', '0', 'X', '0' ), -- | L | ( 'X', 'X', 'X', '1', '1', 'X', 'X', '1', '1' ), -- | H | ( 'X', 'X', '0', '1', 'Z', 'X', '0', '1', 'Z' ) -- | D | ); BEGIN -- Iterate through all inputs FOR i IN input'RANGE LOOP result := resolution_table(result, input(i)); END LOOP; -- Return the resultant value RETURN result; END std_ulogic_wired_x; FUNCTION std_ulogic_wired_or ( input : std_ulogic_vector ) RETURN std_ulogic IS VARIABLE result : std_ulogic := '-'; -- weakest state default CONSTANT resolution_table : stdlogic_table := ( -- --------------------------------------------------------- -- | U X 0 1 Z W L H D | | -- --------------------------------------------------------- ( 'X', 'X', 'X', '1', 'X', 'X', 'X', '1', 'X' ), -- | U | ( 'X', 'X', 'X', '1', 'X', 'X', 'X', '1', 'X' ), -- | X | ( 'X', 'X', '0', '1', '0', 'X', '0', '1', '0' ), -- | 0 | ( '1', '1', '1', '1', '1', '1', '1', '1', '1' ), -- | 1 | ( 'X', 'X', '0', '1', 'Z', 'X', '0', '1', 'Z' ), -- | Z | ( 'X', 'X', 'X', '1', 'X', 'X', 'X', '1', 'X' ), -- | W | ( 'X', 'X', '0', '1', '0', 'X', '0', '1', '0' ), -- | L | ( '1', '1', '1', '1', '1', '1', '1', '1', '1' ), -- | H | ( 'X', 'X', '0', '1', 'Z', 'X', '0', '1', 'Z' ) -- | D | ); BEGIN -- Iterate through all inputs FOR i IN input'RANGE LOOP result := resolution_table(result, input(i)); END LOOP; -- Return the resultant value RETURN result; END std_ulogic_wired_or; FUNCTION std_ulogic_wired_and ( input : std_ulogic_vector ) RETURN std_ulogic IS VARIABLE result : std_ulogic := '-'; -- weakest state default CONSTANT resolution_table : stdlogic_table := ( -- --------------------------------------------------------- -- | U X 0 1 Z W L H D | | -- --------------------------------------------------------- ( 'X', 'X', '0', 'X', 'X', 'X', '0', 'X', 'X' ), -- | U | ( 'X', 'X', '0', 'X', 'X', 'X', '0', 'X', 'X' ), -- | X | ( '0', '0', '0', '0', '0', '0', '0', '0', '0' ), -- | 0 | ( 'X', 'X', '0', '1', '1', 'X', '0', '1', '1' ), -- | 1 | ( 'X', 'X', '0', '1', 'Z', 'X', '0', '1', 'Z' ), -- | Z | ( 'X', 'X', '0', 'X', 'X', 'X', '0', 'X', 'X' ), -- | W | ( '0', '0', '0', '0', '0', '0', '0', '0', '0' ), -- | L | ( 'X', 'X', '0', '1', '1', 'X', '0', '1', '1' ), -- | H | ( 'X', 'X', '0', '1', 'Z', 'X', '0', '1', 'Z' ) -- | D | ); BEGIN -- Iterate through all inputs FOR i IN input'RANGE LOOP result := resolution_table(result, input(i)); END LOOP; -- Return the resultant value RETURN result; END std_ulogic_wired_and; ------------------------------------------------------------------- -- Overloaded Logical Operators ( with optimizing hints ) ------------------------------------------------------------------- -- truth table for "and" function CONSTANT and_table : stdlogic_table := ( -- ---------------------------------------------------- -- | U X 0 1 Z W L H D | | -- ---------------------------------------------------- ( 'U', 'U', '0', 'U', 'U', 'U', '0', 'U', 'U' ), -- | U | ( 'U', 'X', '0', 'X', 'X', 'X', '0', 'X', 'X' ), -- | X | ( '0', '0', '0', '0', '0', '0', '0', '0', '0' ), -- | 0 | ( 'U', 'X', '0', '1', 'X', 'X', '0', '1', 'X' ), -- | 1 | ( 'U', 'X', '0', 'X', 'X', 'X', '0', 'X', 'X' ), -- | Z | ( 'U', 'X', '0', 'X', 'X', 'X', '0', 'X', 'X' ), -- | W | ( '0', '0', '0', '0', '0', '0', '0', '0', '0' ), -- | L | ( 'U', 'X', '0', '1', 'X', 'X', '0', '1', 'X' ), -- | H | ( 'U', 'X', '0', 'X', 'X', 'X', '0', 'X', 'X' ) -- | D | ); -- truth table for "or" function CONSTANT or_table : stdlogic_table := ( -- ---------------------------------------------------- -- | U X 0 1 Z W L H D | | -- ---------------------------------------------------- ( 'U', 'U', 'U', '1', 'U', 'U', 'U', '1', 'U' ), -- | U | ( 'U', 'X', 'X', '1', 'X', 'X', 'X', '1', 'X' ), -- | X | ( 'U', 'X', '0', '1', 'X', 'X', '0', '1', 'X' ), -- | 0 | ( '1', '1', '1', '1', '1', '1', '1', '1', '1' ), -- | 1 | ( 'U', 'X', 'X', '1', 'X', 'X', 'X', '1', 'X' ), -- | Z | ( 'U', 'X', 'X', '1', 'X', 'X', 'X', '1', 'X' ), -- | W | ( 'U', 'X', '0', '1', 'X', 'X', '0', '1', 'X' ), -- | L | ( '1', '1', '1', '1', '1', '1', '1', '1', '1' ), -- | H | ( 'U', 'X', 'X', '1', 'X', 'X', 'X', '1', 'X' ) -- | D | ); -- truth table for "xor" function CONSTANT xor_table : stdlogic_table := ( -- ---------------------------------------------------- -- | U X 0 1 Z W L H D | | -- ---------------------------------------------------- ( 'U', 'U', 'U', 'U', 'U', 'U', 'U', 'U', 'U' ), -- | U | ( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | X | ( 'U', 'X', '0', '1', 'X', 'X', '0', '1', 'X' ), -- | 0 | ( 'U', 'X', '1', '0', 'X', 'X', '1', '0', 'X' ), -- | 1 | ( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | Z | ( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | W | ( 'U', 'X', '0', '1', 'X', 'X', '0', '1', 'X' ), -- | L | ( 'U', 'X', '1', '0', 'X', 'X', '1', '0', 'X' ), -- | H | ( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ) -- | D | ); -- truth table for "not" function CONSTANT not_table: stdlogic_1D := -- ------------------------------------------------- -- | U X 0 1 Z W L H D | -- ------------------------------------------------- ( 'U', 'X', '1', '0', 'X', 'X', '1', '0', 'X' ); -- FUNCTION "and" ( l : std_ulogic; r : std_ulogic ) RETURN std_ulogic IS -- BEGIN -- RETURN (and_table(L, R)); -- END "and"; -- -- FUNCTION "nand" ( l : std_ulogic; r : std_ulogic ) RETURN std_ulogic IS -- BEGIN -- RETURN (not_table ( and_table(L, R))); -- END "nand"; -- -- FUNCTION "or" ( l : std_ulogic; r : std_ulogic ) RETURN std_ulogic IS -- BEGIN -- RETURN (or_table(L, R)); -- END "or"; -- -- FUNCTION "nor" ( l : std_ulogic; r : std_ulogic ) RETURN std_ulogic IS -- BEGIN -- RETURN (not_table ( or_table( L, R ))); -- END "nor"; -- -- FUNCTION "xor" ( l : std_ulogic; r : std_ulogic ) RETURN std_ulogic IS -- BEGIN -- RETURN (xor_table(L, R)); -- END "xor"; -- -- FUNCTION "not" ( l : std_ulogic ) RETURN std_ulogic IS -- BEGIN -- RETURN (not_table(L)); -- END "not"; --///////////////////Vector Functions//////////////////// -- Some useful generic functions --//// Zero Extend //// -- -- Function zxt -- FUNCTION zxt( q : std_ulogic_vector; i : integer ) return std_ulogic_vector IS VARIABLE qs : std_ulogic_vector (1 to i); VARIABLE qt : std_ulogic_vector (1 to q'length); BEGIN qt := q; if i < q'length then qs := qt( (q'length-i+1) to qt'right); elsif i > q'length then qs := (others=>'0'); qs := qs(1 to (i-q'length)) & qt; else qs := qt; end if; return qs; END; --//// Sign Extend //// -- -- Function sxt -- FUNCTION sxt( q : std_ulogic_vector; i : integer ) return std_ulogic_vector IS VARIABLE qs : std_ulogic_vector (1 to i); VARIABLE qt : std_ulogic_vector (1 to q'length); BEGIN qt := q; if i < q'length then qs := qt( (q'length-i+1) to qt'right); elsif i > q'length then qs := (others=>q(q'left)); qs := qs(1 to (i-q'length)) & qt; else qs := qt; end if; return qs; END; --//// Zero Extend //// -- -- Function zxt -- FUNCTION zxt( q : std_logic_vector; i : integer ) return std_logic_vector IS VARIABLE qs : std_logic_vector (1 to i); VARIABLE qt : std_logic_vector (1 to q'length); BEGIN qt := q; if i < q'length then qs := qt( (q'length-i+1) to qt'right); elsif i > q'length then qs := (others=>'0'); qs := qs(1 to (i-q'length)) & qt; else qs := qt; end if; return qs; END; --//// Sign Extend //// -- -- Function sxt -- FUNCTION sxt( q : std_logic_vector; i : integer ) return std_logic_vector IS VARIABLE qs : std_logic_vector (1 to i); VARIABLE qt : std_logic_vector (1 to q'length); BEGIN qt := q; if i < q'length then qs := qt( (q'length-i+1) to qt'right); elsif i > q'length then qs := (others=>q(q'left)); qs := qs(1 to (i-q'length)) & qt; else qs := qt; end if; return qs; END; FUNCTION max (l, r :integer) RETURN integer IS BEGIN IF l > r THEN RETURN l; ELSE RETURN r; END IF; END max; ------------------------------------------------------------------- -- Vectorized Overloaded Logical Operators ------------------------------------------------------------------- -- FUNCTION "and" ( L,R : std_ulogic_vector ) RETURN std_ulogic_vector IS -- VARIABLE ml : integer := max( L'LENGTH, R'LENGTH ); -- VARIABLE lt : std_ulogic_vector ( 1 to ml ); -- VARIABLE rt : std_ulogic_vector ( 1 to ml ); -- VARIABLE res : std_ulogic_vector ( 1 to ml ); -- begin -- lt := zxt( l, ml ); -- rt := zxt( r, ml ); -- FOR i IN res'RANGE LOOP -- res(i) := and_table( lt(i), rt(i) ); -- END LOOP; -- RETURN res; -- end "and"; -- -- --------------------------------------------------------------------- -- -- FUNCTION "nand" ( L,R : std_ulogic_vector ) RETURN std_ulogic_vector IS -- VARIABLE ml : integer := max( L'LENGTH, R'LENGTH ); -- VARIABLE lt : std_ulogic_vector ( 1 to ml ); -- VARIABLE rt : std_ulogic_vector ( 1 to ml ); -- VARIABLE res : std_ulogic_vector ( 1 to ml ); -- begin -- lt := zxt( l, ml ); -- rt := zxt( r, ml ); -- FOR i IN res'RANGE LOOP -- res(i) := not_table( and_table( lt(i), rt(i) ) ); -- END LOOP; -- RETURN res; -- end "nand"; -- -- --------------------------------------------------------------------- -- -- FUNCTION "or" ( L,R : std_ulogic_vector ) RETURN std_ulogic_vector IS -- VARIABLE ml : integer := max( L'LENGTH, R'LENGTH ); -- VARIABLE lt : std_ulogic_vector ( 1 to ml ); -- VARIABLE rt : std_ulogic_vector ( 1 to ml ); -- VARIABLE res : std_ulogic_vector ( 1 to ml ); -- begin -- lt := zxt( l, ml ); -- rt := zxt( r, ml ); -- FOR i IN res'RANGE LOOP -- res(i) := or_table( lt(i), rt(i) ); -- END LOOP; -- RETURN res; -- end "or"; -- -- --------------------------------------------------------------------- -- -- FUNCTION "nor" ( L,R : std_ulogic_vector ) RETURN std_ulogic_vector IS -- VARIABLE ml : integer := max( L'LENGTH, R'LENGTH ); -- VARIABLE lt : std_ulogic_vector ( 1 to ml ); -- VARIABLE rt : std_ulogic_vector ( 1 to ml ); -- VARIABLE res : std_ulogic_vector ( 1 to ml ); -- begin -- lt := zxt( l, ml ); -- rt := zxt( r, ml ); -- FOR i IN res'RANGE LOOP -- res(i) := not_table( or_table( lt(i), rt(i) ) ); -- END LOOP; -- RETURN res; -- end "nor"; -- -- --------------------------------------------------------------------- -- -- FUNCTION "xor" ( L,R : std_ulogic_vector ) RETURN std_ulogic_vector IS -- VARIABLE ml : integer := max( L'LENGTH, R'LENGTH ); -- VARIABLE lt : std_ulogic_vector ( 1 to ml ); -- VARIABLE rt : std_ulogic_vector ( 1 to ml ); -- VARIABLE res : std_ulogic_vector ( 1 to ml ); -- begin -- lt := zxt( l, ml ); -- rt := zxt( r, ml ); -- FOR i IN res'RANGE LOOP -- res(i) := xor_table( lt(i), rt(i) ); -- END LOOP; -- RETURN res; -- end "xor"; -- -- --------------------------------------------------------------------- -- -- FUNCTION "not" ( l : std_ulogic_vector ) RETURN std_ulogic_vector IS -- VARIABLE result : std_ulogic_vector ( L'RANGE ) := (Others => 'X'); -- begin -- for i in result'range loop -- result(i) := not_table( L(i) ); -- end loop; -- return result; -- end "not"; --------------------------------------------------------------------- -- truth table for "=" function CONSTANT eq_table : stdlogic_boolean_table := ( -- ---------------------------------------------------------------------------- -- | U X 0 1 Z W L H D | | -- ---------------------------------------------------------------------------- ( FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE ), -- | U | ( FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE ), -- | X | ( FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE ), -- | 0 | ( FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE ), -- | 1 | ( FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE ), -- | Z | ( FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE ), -- | W | ( FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE ), -- | L | ( FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE ), -- | H | ( FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE ) -- | D | ); FUNCTION "=" ( l, r : std_ulogic ) RETURN boolean IS begin return eq_table( l, r ); end "="; FUNCTION "=" ( l, r : std_ulogic ) RETURN std_ulogic IS begin return NOT xor_table( l, r ); -- same table as exclusive or end "="; --------------------------------------------------------------------- -- truth table for "/=" function CONSTANT neq_table : stdlogic_boolean_table := ( -- ---------------------------------------------------------------------------- -- | U X 0 1 Z W L H D | | -- ---------------------------------------------------------------------------- ( FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE ), -- | U | ( FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE ), -- | X | ( FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE ), -- | 0 | ( FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE ), -- | 1 | ( FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE ), -- | Z | ( FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE ), -- | W | ( FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE ), -- | L | ( FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE ), -- | H | ( FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE ) -- | D | ); FUNCTION "/=" ( l, r : std_ulogic ) RETURN boolean IS begin return neq_table( l, r ); end "/="; FUNCTION "/=" ( l, r : std_ulogic ) RETURN std_ulogic IS begin return xor_table( l, r ); -- same table as exclusive or end "/="; --------------------------------------------------------------------- -- truth table for "<" function CONSTANT ltb_table : stdlogic_boolean_table := ( -- ---------------------------------------------------------------------------- -- | U X 0 1 Z W L H D | | -- ---------------------------------------------------------------------------- ( FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE ), -- | U | ( FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE ), -- | X | ( FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE ), -- | 0 | ( FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE ), -- | 1 | ( FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE ), -- | Z | ( FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE ), -- | W | ( FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE ), -- | L | ( FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE ), -- | H | ( FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE ) -- | D | ); -- truth table for "<" function CONSTANT lt_table : stdlogic_table := ( -- ---------------------------------------------------- -- | U X 0 1 Z W L H D | | -- ---------------------------------------------------- ( 'U', 'U', 'U', 'U', 'U', 'U', 'U', 'U', 'U' ), -- | U | ( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | X | ( 'U', 'X', '0', '1', 'X', 'X', '0', '1', 'X' ), -- | 0 | ( 'U', 'X', '0', '0', 'X', 'X', '0', '0', 'X' ), -- | 1 | ( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | Z | ( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | W | ( 'U', 'X', '0', '1', 'X', 'X', '0', '1', 'X' ), -- | L | ( 'U', 'X', '0', '0', 'X', 'X', '0', '0', 'X' ), -- | H | ( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ) -- | D | ); FUNCTION "<" ( l, r : std_ulogic ) RETURN boolean IS begin return ltb_table( l, r ); end "<"; FUNCTION "<" ( l, r : std_ulogic ) RETURN std_ulogic IS begin return lt_table( l, r ); end "<"; --------------------------------------------------------------------- -- truth table for ">" function CONSTANT gtb_table : stdlogic_boolean_table := ( -- ---------------------------------------------------------------------------- -- | U X 0 1 Z W L H D | | -- ---------------------------------------------------------------------------- ( FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE ), -- | U | ( FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE ), -- | X | ( FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE ), -- | 0 | ( FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE ), -- | 1 | ( FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE ), -- | Z | ( FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE ), -- | W | ( FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE ), -- | L | ( FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE ), -- | H | ( FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE ) -- | D | ); -- truth table for ">" function CONSTANT gt_table : stdlogic_table := ( -- ---------------------------------------------------- -- | U X 0 1 Z W L H D | | -- ---------------------------------------------------- ( 'U', 'U', 'U', 'U', 'U', 'U', 'U', 'U', 'U' ), -- | U | ( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | X | ( 'U', 'X', '0', '0', 'X', 'X', '0', '0', 'X' ), -- | 0 | ( 'U', 'X', '1', '0', 'X', 'X', '1', '0', 'X' ), -- | 1 | ( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | Z | ( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | W | ( 'U', 'X', '0', '0', 'X', 'X', '0', '0', 'X' ), -- | L | ( 'U', 'X', '1', '0', 'X', 'X', '1', '0', 'X' ), -- | H | ( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ) -- | D | ); FUNCTION ">" ( l, r : std_ulogic ) RETURN boolean IS begin return gtb_table( l, r ); end ">"; FUNCTION ">" ( l, r : std_ulogic ) RETURN std_ulogic IS begin return gt_table( l, r ); end ">"; --------------------------------------------------------------------- -- truth table for "<=" function CONSTANT leb_table : stdlogic_boolean_table := ( -- ---------------------------------------------------------------------------- -- | U X 0 1 Z W L H D | | -- ---------------------------------------------------------------------------- ( FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE ), -- | U | ( FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE ), -- | X | ( TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE ), -- | 0 | ( FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE ), -- | 1 | ( FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE ), -- | Z | ( FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE ), -- | W | ( TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE ), -- | L | ( FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE ), -- | H | ( FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE ) -- | D | ); -- truth table for "<=" function CONSTANT le_table : stdlogic_table := ( -- ---------------------------------------------------- -- | U X 0 1 Z W L H D | | -- ---------------------------------------------------- ( 'U', 'U', 'U', '1', 'U', 'U', 'U', '1', 'U' ), -- | U | ( 'U', 'X', 'X', '1', 'X', 'X', 'X', '1', 'X' ), -- | X | ( '1', '1', '1', '1', '1', '1', '1', '1', '1' ), -- | 0 | ( 'U', 'X', '0', '1', 'X', 'X', '0', '1', 'X' ), -- | 1 | ( 'U', 'X', 'X', '1', 'X', 'X', 'X', '1', 'X' ), -- | Z | ( 'U', 'X', 'X', '1', 'X', 'X', 'X', '1', 'X' ), -- | W | ( '1', '1', '1', '1', '1', '1', '1', '1', '1' ), -- | L | ( 'U', 'X', '0', '1', 'X', 'X', '0', '1', 'X' ), -- | H | ( 'U', 'X', 'X', '1', 'X', 'X', 'X', '1', 'X' ) -- | D | ); FUNCTION "<=" ( l, r : std_ulogic ) RETURN boolean IS begin return leb_table( l, r ); end "<="; FUNCTION "<=" ( l, r : std_ulogic ) RETURN std_ulogic IS begin return le_table( l, r ); end "<="; --------------------------------------------------------------------- -- truth table for ">=" function CONSTANT geb_table : stdlogic_boolean_table := ( -- ---------------------------------------------------------------------------- -- | U X 0 1 Z W L H D | | -- ---------------------------------------------------------------------------- ( FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE ), -- | U | ( FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE ), -- | X | ( FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE ), -- | 0 | ( TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE ), -- | 1 | ( FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE ), -- | Z | ( FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE ), -- | W | ( FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE ), -- | L | ( TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE ), -- | H | ( FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE ) -- | D | ); -- truth table for ">=" function CONSTANT ge_table : stdlogic_table := ( -- ---------------------------------------------------- -- | U X 0 1 Z W L H D | | -- ---------------------------------------------------- ( 'U', 'U', '1', 'U', 'U', 'U', '1', 'U', 'U' ), -- | U | ( 'U', 'X', '1', 'X', 'X', 'X', '1', 'X', 'X' ), -- | X | ( 'U', 'X', '1', '0', 'X', 'X', '1', '0', 'X' ), -- | 0 | ( '1', '1', '1', '1', '1', '1', '1', '1', '1' ), -- | 1 | ( 'U', 'X', '1', 'X', 'X', 'X', '1', 'X', 'X' ), -- | Z | ( 'U', 'X', '1', 'X', 'X', 'X', '1', 'X', 'X' ), -- | W | ( 'U', 'X', '1', '0', 'X', 'X', '1', '0', 'X' ), -- | L | ( '1', '1', '1', '1', '1', '1', '1', '1', '1' ), -- | H | ( 'U', 'X', '1', 'X', 'X', 'X', '1', 'X', 'X' ) -- | D | ); FUNCTION ">=" ( l, r : std_ulogic ) RETURN boolean IS begin return geb_table( l, r ); end ">="; FUNCTION ">=" ( l, r : std_ulogic ) RETURN std_ulogic IS begin return ge_table( l, r ); end ">="; --------------------------------------------------------------------- FUNCTION "+" ( l, r : std_ulogic ) RETURN std_ulogic IS begin return xor_table( l, r ); end "+"; FUNCTION "-" ( l, r : std_ulogic ) RETURN std_ulogic IS begin return xor_table( l, r ); end "-"; --------------------------------------------------------------------- FUNCTION "<" ( L,R : std_ulogic_vector ) RETURN std_ulogic IS VARIABLE ml : integer := max( L'LENGTH, R'LENGTH ); VARIABLE lt : std_ulogic_vector ( 1 to ml ); VARIABLE rt : std_ulogic_vector ( 1 to ml ); VARIABLE res : std_ulogic_vector ( 1 to ml ); begin lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN lt'RANGE LOOP IF not ( lt(i) = rt(i) ) THEN return lt(i) < rt(i); END IF; END LOOP; RETURN '0'; end "<"; FUNCTION ">" ( L,R : std_ulogic_vector ) RETURN std_ulogic IS VARIABLE ml : integer := max( L'LENGTH, R'LENGTH ); VARIABLE lt : std_ulogic_vector ( 1 to ml ); VARIABLE rt : std_ulogic_vector ( 1 to ml ); VARIABLE res : std_ulogic_vector ( 1 to ml ); begin lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN lt'RANGE LOOP IF not ( lt(i) = rt(i) ) THEN return lt(i) > rt(i); END IF; END LOOP; RETURN '0'; end ">"; FUNCTION "=" ( L,R : std_ulogic_vector ) RETURN std_ulogic IS VARIABLE ml : integer := max( L'LENGTH, R'LENGTH ); VARIABLE lt : std_ulogic_vector ( 1 to ml ); VARIABLE rt : std_ulogic_vector ( 1 to ml ); VARIABLE res : std_ulogic_vector ( 1 to ml ); begin lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN res'RANGE LOOP IF not ( lt(i) = rt(i) ) THEN return lt(i) = rt(i); END IF; END LOOP; RETURN '1'; end "="; FUNCTION "/=" ( L,R : std_ulogic_vector ) RETURN std_ulogic IS VARIABLE ml : integer := max( L'LENGTH, R'LENGTH ); VARIABLE lt : std_ulogic_vector ( 1 to ml ); VARIABLE rt : std_ulogic_vector ( 1 to ml ); VARIABLE res : std_ulogic_vector ( 1 to ml ); begin lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN res'RANGE LOOP IF ( lt(i) /= rt(i) ) /= '0' THEN return lt(i) /= rt(i); END IF; END LOOP; RETURN lt( lt'RIGHT ) /= rt( rt'RIGHT ); end "/="; TYPE std_ulogic_fuzzy_state IS ('U', 'X', 'T', 'F', 'N'); TYPE std_ulogic_fuzzy_state_table IS ARRAY ( std_ulogic, std_ulogic ) OF std_ulogic_fuzzy_state; -- truth table for "<=" function CONSTANT le_fuzzy_table : std_ulogic_fuzzy_state_table := ( -- ---------------------------------------------------- -- | U X 0 1 Z W L H D | | -- ---------------------------------------------------- ( 'U', 'U', 'U', 'N', 'U', 'U', 'U', 'N', 'U' ), -- | U | ( 'U', 'X', 'X', 'N', 'X', 'X', 'X', 'N', 'X' ), -- | X | ( 'N', 'N', 'N', 'T', 'N', 'N', 'N', 'T', 'N' ), -- | 0 | ( 'U', 'X', 'F', 'N', 'X', 'X', 'F', 'N', 'X' ), -- | 1 | ( 'U', 'X', 'X', 'N', 'X', 'X', 'X', 'N', 'X' ), -- | Z | ( 'U', 'X', 'X', 'N', 'X', 'X', 'X', 'N', 'X' ), -- | W | ( 'N', 'N', 'N', 'T', 'N', 'N', 'N', 'T', 'N' ), -- | L | ( 'U', 'X', 'F', 'N', 'X', 'X', 'F', 'N', 'X' ), -- | H | ( 'U', 'X', 'X', 'N', 'X', 'X', 'X', 'N', 'X' ) -- | D | ); FUNCTION "<=" ( L,R : std_ulogic_vector ) RETURN std_ulogic IS VARIABLE ml : integer := max( L'LENGTH, R'LENGTH ); VARIABLE lt : std_ulogic_vector ( 1 to ml ); VARIABLE rt : std_ulogic_vector ( 1 to ml ); VARIABLE res : std_ulogic_fuzzy_state; begin lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN lt'RANGE LOOP res := le_fuzzy_table( lt(i), rt(i) ); CASE res IS WHEN 'U' => RETURN 'U'; WHEN 'X' => RETURN 'X'; WHEN 'T' => RETURN '1'; WHEN 'F' => RETURN '0'; WHEN OTHERS => null; END CASE; END LOOP; RETURN '1'; end "<="; -- truth table for ">=" function CONSTANT ge_fuzzy_table : std_ulogic_fuzzy_state_table := ( -- ---------------------------------------------------- -- | U X 0 1 Z W L H D | | -- ---------------------------------------------------- ( 'U', 'U', 'N', 'U', 'U', 'U', 'N', 'U', 'U' ), -- | U | ( 'U', 'X', 'N', 'X', 'X', 'X', 'N', 'X', 'X' ), -- | X | ( 'U', 'X', 'N', 'F', 'X', 'X', 'N', 'F', 'X' ), -- | 0 | ( 'N', 'N', 'T', 'N', 'N', 'N', 'T', 'N', 'N' ), -- | 1 | ( 'U', 'X', 'N', 'X', 'X', 'X', 'N', 'X', 'X' ), -- | Z | ( 'U', 'X', 'N', 'X', 'X', 'X', 'N', 'X', 'X' ), -- | W | ( 'U', 'X', 'N', 'F', 'X', 'X', 'N', 'F', 'X' ), -- | L | ( 'N', 'N', 'T', 'N', 'N', 'N', 'T', 'N', 'N' ), -- | H | ( 'U', 'X', 'N', 'X', 'X', 'X', 'N', 'X', 'X' ) -- | D | ); FUNCTION ">=" ( L,R : std_ulogic_vector ) RETURN std_ulogic IS VARIABLE ml : integer := max( L'LENGTH, R'LENGTH ); VARIABLE lt : std_ulogic_vector ( 1 to ml ); VARIABLE rt : std_ulogic_vector ( 1 to ml ); VARIABLE res : std_ulogic_fuzzy_state; begin lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN lt'RANGE LOOP res := ge_fuzzy_table( lt(i), rt(i) ); CASE res IS WHEN 'U' => RETURN 'U'; WHEN 'X' => RETURN 'X'; WHEN 'T' => RETURN '1'; WHEN 'F' => RETURN '0'; WHEN OTHERS => null; END CASE; END LOOP; RETURN '1'; end ">="; --------------------------------------------------------------------- FUNCTION "<" ( L,R : std_ulogic_vector ) RETURN boolean IS VARIABLE ml : integer := max( L'LENGTH, R'LENGTH ); VARIABLE lt : std_ulogic_vector ( 1 to ml ); VARIABLE rt : std_ulogic_vector ( 1 to ml ); VARIABLE res : std_ulogic_vector ( 1 to ml ); begin lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN lt'RANGE LOOP IF not ( lt(i) = rt(i) ) THEN return lt(i) < rt(i); END IF; END LOOP; RETURN FALSE; end "<"; FUNCTION ">" ( L,R : std_ulogic_vector ) RETURN boolean IS VARIABLE ml : integer := max( L'LENGTH, R'LENGTH ); VARIABLE lt : std_ulogic_vector ( 1 to ml ); VARIABLE rt : std_ulogic_vector ( 1 to ml ); VARIABLE res : std_ulogic_vector ( 1 to ml ); begin lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN lt'RANGE LOOP IF not ( lt(i) = rt(i) ) THEN return lt(i) > rt(i); END IF; END LOOP; RETURN FALSE; end ">"; FUNCTION "=" ( L,R : std_ulogic_vector ) RETURN boolean IS VARIABLE ml : integer := max( L'LENGTH, R'LENGTH ); VARIABLE lt : std_ulogic_vector ( 1 to ml ); VARIABLE rt : std_ulogic_vector ( 1 to ml ); VARIABLE res : std_ulogic_vector ( 1 to ml ); begin lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN lt'RANGE LOOP IF ( lt(i) = rt(i) ) /= '1' THEN return FALSE; END IF; END LOOP; RETURN TRUE; end "="; FUNCTION "/=" ( L,R : std_ulogic_vector ) RETURN boolean IS VARIABLE ml : integer := max( L'LENGTH, R'LENGTH ); VARIABLE lt : std_ulogic_vector ( 1 to ml ); VARIABLE rt : std_ulogic_vector ( 1 to ml ); VARIABLE res : std_ulogic_vector ( 1 to ml ); begin lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN lt'RANGE LOOP IF ( lt(i) /= rt(i) ) /= '0' THEN return TRUE; END IF; END LOOP; RETURN FALSE; end "/="; FUNCTION "<=" ( L,R : std_ulogic_vector ) RETURN boolean IS VARIABLE ml : integer := max( L'LENGTH, R'LENGTH ); VARIABLE lt : std_ulogic_vector ( 1 to ml ); VARIABLE rt : std_ulogic_vector ( 1 to ml ); VARIABLE res : std_ulogic_fuzzy_state; begin lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN lt'RANGE LOOP res := le_fuzzy_table( lt(i), rt(i) ); CASE res IS WHEN 'U' => RETURN FALSE; WHEN 'X' => RETURN FALSE; WHEN 'T' => RETURN TRUE; WHEN 'F' => RETURN FALSE; WHEN OTHERS => null; END CASE; END LOOP; RETURN TRUE; end "<="; FUNCTION ">=" ( L,R : std_ulogic_vector ) RETURN boolean IS VARIABLE ml : integer := max( L'LENGTH, R'LENGTH ); VARIABLE lt : std_ulogic_vector ( 1 to ml ); VARIABLE rt : std_ulogic_vector ( 1 to ml ); VARIABLE res : std_ulogic_fuzzy_state; begin lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN lt'RANGE LOOP res := ge_fuzzy_table( lt(i), rt(i) ); CASE res IS WHEN 'U' => RETURN FALSE; WHEN 'X' => RETURN FALSE; WHEN 'T' => RETURN TRUE; WHEN 'F' => RETURN FALSE; WHEN OTHERS => null; END CASE; END LOOP; RETURN TRUE; end ">="; --------------------------------------------------------------------- FUNCTION "<" ( L,R : std_logic_vector ) RETURN std_logic IS VARIABLE ml : integer := max( L'LENGTH, R'LENGTH ); VARIABLE lt : std_logic_vector ( 1 to ml ); VARIABLE rt : std_logic_vector ( 1 to ml ); VARIABLE res : std_logic_vector ( 1 to ml ); begin lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN lt'RANGE LOOP IF not ( lt(i) = rt(i) ) THEN return lt(i) < rt(i); END IF; END LOOP; RETURN '0'; end "<"; FUNCTION ">" ( L,R : std_logic_vector ) RETURN std_logic IS VARIABLE ml : integer := max( L'LENGTH, R'LENGTH ); VARIABLE lt : std_logic_vector ( 1 to ml ); VARIABLE rt : std_logic_vector ( 1 to ml ); VARIABLE res : std_logic_vector ( 1 to ml ); begin lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN lt'RANGE LOOP IF not ( lt(i) = rt(i) ) THEN return lt(i) > rt(i); END IF; END LOOP; RETURN '0'; end ">"; FUNCTION "=" ( L,R : std_logic_vector ) RETURN std_logic IS VARIABLE ml : integer := max( L'LENGTH, R'LENGTH ); VARIABLE lt : std_logic_vector ( 1 to ml ); VARIABLE rt : std_logic_vector ( 1 to ml ); VARIABLE res : std_logic_vector ( 1 to ml ); begin lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN res'RANGE LOOP IF not ( lt(i) = rt(i) ) THEN return lt(i) = rt(i); END IF; END LOOP; RETURN '1'; end "="; FUNCTION "/=" ( L,R : std_logic_vector ) RETURN std_logic IS VARIABLE ml : integer := max( L'LENGTH, R'LENGTH ); VARIABLE lt : std_logic_vector ( 1 to ml ); VARIABLE rt : std_logic_vector ( 1 to ml ); VARIABLE res : std_logic_vector ( 1 to ml ); begin lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN res'RANGE LOOP IF ( lt(i) /= rt(i) ) /= '0' THEN return lt(i) /= rt(i); END IF; END LOOP; RETURN lt( lt'RIGHT ) /= rt( rt'RIGHT ); end "/="; TYPE std_logic_fuzzy_state IS ('U', 'X', 'T', 'F', 'N'); TYPE std_logic_fuzzy_state_table IS ARRAY ( std_logic, std_logic ) OF std_logic_fuzzy_state; -- truth table for "<=" function CONSTANT le_lfuzzy_table : std_logic_fuzzy_state_table := ( -- ---------------------------------------------------- -- | U X 0 1 Z W L H D | | -- ---------------------------------------------------- ( 'U', 'U', 'U', 'N', 'U', 'U', 'U', 'N', 'U' ), -- | U | ( 'U', 'X', 'X', 'N', 'X', 'X', 'X', 'N', 'X' ), -- | X | ( 'N', 'N', 'N', 'T', 'N', 'N', 'N', 'T', 'N' ), -- | 0 | ( 'U', 'X', 'F', 'N', 'X', 'X', 'F', 'N', 'X' ), -- | 1 | ( 'U', 'X', 'X', 'N', 'X', 'X', 'X', 'N', 'X' ), -- | Z | ( 'U', 'X', 'X', 'N', 'X', 'X', 'X', 'N', 'X' ), -- | W | ( 'N', 'N', 'N', 'T', 'N', 'N', 'N', 'T', 'N' ), -- | L | ( 'U', 'X', 'F', 'N', 'X', 'X', 'F', 'N', 'X' ), -- | H | ( 'U', 'X', 'X', 'N', 'X', 'X', 'X', 'N', 'X' ) -- | D | ); FUNCTION "<=" ( L,R : std_logic_vector ) RETURN std_logic IS VARIABLE ml : integer := max( L'LENGTH, R'LENGTH ); VARIABLE lt : std_logic_vector ( 1 to ml ); VARIABLE rt : std_logic_vector ( 1 to ml ); VARIABLE res : std_logic_fuzzy_state; begin lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN lt'RANGE LOOP res := le_lfuzzy_table( lt(i), rt(i) ); CASE res IS WHEN 'U' => RETURN 'U'; WHEN 'X' => RETURN 'X'; WHEN 'T' => RETURN '1'; WHEN 'F' => RETURN '0'; WHEN OTHERS => null; END CASE; END LOOP; RETURN '1'; end "<="; -- truth table for ">=" function CONSTANT ge_lfuzzy_table : std_logic_fuzzy_state_table := ( -- ---------------------------------------------------- -- | U X 0 1 Z W L H D | | -- ---------------------------------------------------- ( 'U', 'U', 'N', 'U', 'U', 'U', 'N', 'U', 'U' ), -- | U | ( 'U', 'X', 'N', 'X', 'X', 'X', 'N', 'X', 'X' ), -- | X | ( 'U', 'X', 'N', 'F', 'X', 'X', 'N', 'F', 'X' ), -- | 0 | ( 'N', 'N', 'T', 'N', 'N', 'N', 'T', 'N', 'N' ), -- | 1 | ( 'U', 'X', 'N', 'X', 'X', 'X', 'N', 'X', 'X' ), -- | Z | ( 'U', 'X', 'N', 'X', 'X', 'X', 'N', 'X', 'X' ), -- | W | ( 'U', 'X', 'N', 'F', 'X', 'X', 'N', 'F', 'X' ), -- | L | ( 'N', 'N', 'T', 'N', 'N', 'N', 'T', 'N', 'N' ), -- | H | ( 'U', 'X', 'N', 'X', 'X', 'X', 'N', 'X', 'X' ) -- | D | ); FUNCTION ">=" ( L,R : std_logic_vector ) RETURN std_logic IS VARIABLE ml : integer := max( L'LENGTH, R'LENGTH ); VARIABLE lt : std_logic_vector ( 1 to ml ); VARIABLE rt : std_logic_vector ( 1 to ml ); VARIABLE res : std_logic_fuzzy_state; begin lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN lt'RANGE LOOP res := ge_lfuzzy_table( lt(i), rt(i) ); CASE res IS WHEN 'U' => RETURN 'U'; WHEN 'X' => RETURN 'X'; WHEN 'T' => RETURN '1'; WHEN 'F' => RETURN '0'; WHEN OTHERS => null; END CASE; END LOOP; RETURN '1'; end ">="; --------------------------------------------------------------------- FUNCTION "<" ( L,R : std_logic_vector ) RETURN boolean IS VARIABLE ml : integer := max( L'LENGTH, R'LENGTH ); VARIABLE lt : std_logic_vector ( 1 to ml ); VARIABLE rt : std_logic_vector ( 1 to ml ); VARIABLE res : std_logic_vector ( 1 to ml ); begin lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN lt'RANGE LOOP IF not ( lt(i) = rt(i) ) THEN return lt(i) < rt(i); END IF; END LOOP; RETURN FALSE; end "<"; FUNCTION ">" ( L,R : std_logic_vector ) RETURN boolean IS VARIABLE ml : integer := max( L'LENGTH, R'LENGTH ); VARIABLE lt : std_logic_vector ( 1 to ml ); VARIABLE rt : std_logic_vector ( 1 to ml ); VARIABLE res : std_logic_vector ( 1 to ml ); begin lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN lt'RANGE LOOP IF not ( lt(i) = rt(i) ) THEN return lt(i) > rt(i); END IF; END LOOP; RETURN FALSE; end ">"; FUNCTION "=" ( L,R : std_logic_vector ) RETURN boolean IS VARIABLE ml : integer := max( L'LENGTH, R'LENGTH ); VARIABLE lt : std_logic_vector ( 1 to ml ); VARIABLE rt : std_logic_vector ( 1 to ml ); VARIABLE res : std_logic_vector ( 1 to ml ); begin lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN lt'RANGE LOOP IF ( lt(i) = rt(i) ) /= '1' THEN return FALSE; END IF; END LOOP; RETURN TRUE; end "="; FUNCTION "/=" ( L,R : std_logic_vector ) RETURN boolean IS VARIABLE ml : integer := max( L'LENGTH, R'LENGTH ); VARIABLE lt : std_logic_vector ( 1 to ml ); VARIABLE rt : std_logic_vector ( 1 to ml ); VARIABLE res : std_logic_vector ( 1 to ml ); begin lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN lt'RANGE LOOP IF ( lt(i) /= rt(i) ) /= '0' THEN return TRUE; END IF; END LOOP; RETURN FALSE; end "/="; FUNCTION "<=" ( L,R : std_logic_vector ) RETURN boolean IS VARIABLE ml : integer := max( L'LENGTH, R'LENGTH ); VARIABLE lt : std_logic_vector ( 1 to ml ); VARIABLE rt : std_logic_vector ( 1 to ml ); VARIABLE res : std_logic_fuzzy_state; begin lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN lt'RANGE LOOP res := le_lfuzzy_table( lt(i), rt(i) ); CASE res IS WHEN 'U' => RETURN FALSE; WHEN 'X' => RETURN FALSE; WHEN 'T' => RETURN TRUE; WHEN 'F' => RETURN FALSE; WHEN OTHERS => null; END CASE; END LOOP; RETURN TRUE; end "<="; FUNCTION ">=" ( L,R : std_logic_vector ) RETURN boolean IS VARIABLE ml : integer := max( L'LENGTH, R'LENGTH ); VARIABLE lt : std_logic_vector ( 1 to ml ); VARIABLE rt : std_logic_vector ( 1 to ml ); VARIABLE res : std_logic_fuzzy_state; begin lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN lt'RANGE LOOP res := ge_lfuzzy_table( lt(i), rt(i) ); CASE res IS WHEN 'U' => RETURN FALSE; WHEN 'X' => RETURN FALSE; WHEN 'T' => RETURN TRUE; WHEN 'F' => RETURN FALSE; WHEN OTHERS => null; END CASE; END LOOP; RETURN TRUE; end ">="; --------------------------------------------------------------------- FUNCTION "+" (l, r :std_ulogic_vector) RETURN std_ulogic_vector IS VARIABLE ml : integer := max(l'LENGTH,r'LENGTH); VARIABLE lt : std_ulogic_vector(1 TO ml); VARIABLE rt : std_ulogic_vector(1 TO ml); VARIABLE res : std_ulogic_vector(1 TO ml); VARIABLE carry : std_ulogic := '0'; VARIABLE a,b,s1 : std_ulogic; BEGIN lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN res'REVERSE_RANGE LOOP a := lt(i); b := rt(i); s1 := a + b; res(i) := s1 + carry; carry := (a AND b) OR (s1 AND carry); END LOOP; RETURN res; END "+"; FUNCTION "-" (l, r :std_ulogic_vector) RETURN std_ulogic_vector IS VARIABLE ml : integer := max(l'LENGTH,r'LENGTH); VARIABLE lt : std_ulogic_vector(1 TO ml); VARIABLE rt : std_ulogic_vector(1 TO ml); VARIABLE res : std_ulogic_vector(1 TO ml); VARIABLE borrow : std_ulogic := '1'; VARIABLE a,b,s1 : std_ulogic; BEGIN lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN res'REVERSE_RANGE LOOP a := lt(i); b := NOT rt(i); s1 := a + b; res(i) := s1 + borrow; borrow := (a AND b) OR (s1 AND borrow); END LOOP; RETURN res; END "-"; FUNCTION shift( v : std_ulogic_vector ) RETURN std_ulogic_vector IS VARIABLE v1 : std_ulogic_vector( v'RANGE ); BEGIN FOR i IN (v'LEFT+1) TO v'RIGHT LOOP v1(i-1) := v(i); END LOOP; v1(v1'RIGHT) := '0'; RETURN v1; END shift; PROCEDURE copy(a : IN std_ulogic_vector; b : OUT std_ulogic_vector) IS VARIABLE bi : integer := b'RIGHT; BEGIN FOR i in a'REVERSE_RANGE LOOP b(bi) := a(i); bi := bi - 1; END LOOP; END copy; FUNCTION "*" (l, r :std_ulogic_vector) RETURN std_ulogic_vector IS VARIABLE ml : integer := l'LENGTH + r'LENGTH; VARIABLE lt : std_ulogic_vector(1 TO ml); VARIABLE rt : std_ulogic_vector(1 TO ml); VARIABLE prod : std_ulogic_vector(1 TO ml) := (others=>'0'); BEGIN lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN rt'REVERSE_RANGE LOOP IF rt(i) = '1' THEN prod := prod + lt; END IF; lt := shift(lt); END LOOP; RETURN prod; END "*"; FUNCTION rshift( v : std_ulogic_vector ) RETURN std_ulogic_vector IS VARIABLE v1 : std_ulogic_vector( v'RANGE ); BEGIN FOR i IN v'LEFT TO v'RIGHT-1 LOOP v1(i+1) := v(i); END LOOP; v1(v1'LEFT) := '0'; RETURN v1; END rshift; FUNCTION hasX( v : std_ulogic_vector ) RETURN boolean IS BEGIN FOR i IN v'RANGE LOOP IF v(i) = '0' OR v(i) = '1' OR v(i) = 'L' OR v(i) = 'H'THEN NULL; ELSE RETURN TRUE; END IF; END LOOP; RETURN FALSE; END hasX; FUNCTION "/" (l, r :std_ulogic_vector) RETURN std_ulogic_vector IS VARIABLE ml : integer := max(l'LENGTH,r'LENGTH); VARIABLE lt : std_ulogic_vector(0 TO ml+1); VARIABLE rt : std_ulogic_vector(0 TO ml+1); VARIABLE quote : std_ulogic_vector(1 TO ml); VARIABLE tmp : std_ulogic_vector(0 TO ml+1) := (others=>'0'); VARIABLE n : std_ulogic_vector(0 TO ml+1) := (others=>'0'); BEGIN ASSERT NOT (r = "0") REPORT "Attempted divide by ZERO" SEVERITY ERROR; IF hasX(l) OR hasX(r) THEN FOR i IN quote'RANGE LOOP quote(i) := 'X'; END LOOP; ELSE lt := zxt( l, ml+2 ); WHILE lt >= r LOOP rt := zxt( r, ml+2 ); n := (OTHERS=>'0'); n(n'RIGHT) := '1'; WHILE rt <= lt LOOP rt := shift(rt); n := shift(n); END LOOP; rt := rshift(rt); lt := lt - rt; n := rshift(n); tmp := tmp + n; END LOOP; END IF; quote := tmp(2 to ml+1); RETURN quote; END "/"; FUNCTION "MOD" (l, r :std_ulogic_vector) RETURN std_ulogic_vector IS VARIABLE ml : integer := max(l'LENGTH,r'LENGTH); VARIABLE lt : std_ulogic_vector(0 TO ml+1); VARIABLE rt : std_ulogic_vector(0 TO ml+1); VARIABLE quote : std_ulogic_vector(1 TO ml); VARIABLE tmp : std_ulogic_vector(0 TO ml+1) := (others=>'0'); VARIABLE n : std_ulogic_vector(0 TO ml) := (others=>'0'); BEGIN ASSERT NOT (r = "0") REPORT "Attempted divide by ZERO" SEVERITY ERROR; IF hasX(l) OR hasX(r) THEN FOR i IN lt'RANGE LOOP lt(i) := 'X'; END LOOP; ELSE lt := zxt( l, ml+2 ); WHILE lt >= r LOOP rt := zxt( r, ml+2 ); WHILE rt <= lt LOOP rt := shift(rt); END LOOP; rt := rshift(rt); lt := lt - rt; END LOOP; END IF; RETURN lt(2 to ml+1); END "MOD"; FUNCTION "REM" (l, r :std_ulogic_vector) RETURN std_ulogic_vector IS VARIABLE ml : integer := max(l'LENGTH,r'LENGTH); VARIABLE lt : std_ulogic_vector(0 TO ml+1); VARIABLE rt : std_ulogic_vector(0 TO ml+1); VARIABLE quote : std_ulogic_vector(1 TO ml); VARIABLE tmp : std_ulogic_vector(0 TO ml+1) := (others=>'0'); VARIABLE n : std_ulogic_vector(0 TO ml) := (others=>'0'); BEGIN ASSERT NOT (r = "0") REPORT "Attempted divide by ZERO" SEVERITY ERROR; IF hasX(l) OR hasX(r) THEN FOR i IN lt'RANGE LOOP lt(i) := 'X'; END LOOP; ELSE lt := zxt( l, ml+2 ); WHILE lt >= r LOOP rt := zxt( r, ml+2 ); WHILE rt <= lt LOOP rt := shift(rt); END LOOP; rt := rshift(rt); lt := lt - rt; END LOOP; END IF; RETURN lt(2 to ml+1); END "REM"; FUNCTION "**" (l, r :std_ulogic_vector) RETURN std_ulogic_vector IS VARIABLE return_vector : std_ulogic_vector(l'RANGE) := (others=>'0'); VARIABLE tmp : std_ulogic_vector(1 to (2 * l'LENGTH)) := (others=>'0'); CONSTANT lsh_l : integer := l'LENGTH+1; CONSTANT lsh_r : integer := 2 * l'LENGTH; VARIABLE pow : integer; BEGIN IF (hasX(l) OR hasX(r)) THEN FOR i IN return_vector'RANGE LOOP return_vector(i) := 'X'; END LOOP; ELSE pow := To_Integer( r, 0 ); tmp( tmp'right ) := '1'; FOR i IN 1 TO pow LOOP tmp := tmp(lsh_l TO lsh_r) * l; END LOOP; return_vector := tmp(lsh_l TO lsh_r); END IF; RETURN return_vector; END "**"; --------------------------------------------------------------------- FUNCTION "+" (l, r :std_logic_vector) RETURN std_logic_vector IS VARIABLE ml : integer := max(l'LENGTH,r'LENGTH); VARIABLE lt : std_logic_vector(1 TO ml); VARIABLE rt : std_logic_vector(1 TO ml); VARIABLE res : std_logic_vector(1 TO ml); VARIABLE carry : std_logic := '0'; VARIABLE a,b,s1 : std_logic; BEGIN lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN res'REVERSE_RANGE LOOP a := lt(i); b := rt(i); s1 := a + b; res(i) := s1 + carry; carry := (a AND b) OR (s1 AND carry); END LOOP; RETURN res; END "+"; FUNCTION "-" (l, r :std_logic_vector) RETURN std_logic_vector IS VARIABLE ml : integer := max(l'LENGTH,r'LENGTH); VARIABLE lt : std_logic_vector(1 TO ml); VARIABLE rt : std_logic_vector(1 TO ml); VARIABLE res : std_logic_vector(1 TO ml); VARIABLE borrow : std_logic := '1'; VARIABLE a,b,s1 : std_logic; BEGIN lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN res'REVERSE_RANGE LOOP a := lt(i); b := NOT rt(i); s1 := a + b; res(i) := s1 + borrow; borrow := (a AND b) OR (s1 AND borrow); END LOOP; RETURN res; END "-"; FUNCTION shift( v : std_logic_vector ) RETURN std_logic_vector IS VARIABLE v1 : std_logic_vector( v'RANGE ); BEGIN FOR i IN (v'LEFT+1) TO v'RIGHT LOOP v1(i-1) := v(i); END LOOP; v1(v1'RIGHT) := '0'; RETURN v1; END shift; PROCEDURE copy(a : IN std_logic_vector; b : OUT std_logic_vector) IS VARIABLE bi : integer := b'RIGHT; BEGIN FOR i in a'REVERSE_RANGE LOOP b(bi) := a(i); bi := bi - 1; END LOOP; END copy; FUNCTION "*" (l, r :std_logic_vector) RETURN std_logic_vector IS VARIABLE ml : integer := l'LENGTH + r'LENGTH; VARIABLE lt : std_logic_vector(1 TO ml); VARIABLE rt : std_logic_vector(1 TO ml); VARIABLE prod : std_logic_vector(1 TO ml) := (others=>'0'); BEGIN lt := zxt( l, ml ); rt := zxt( r, ml ); FOR i IN rt'REVERSE_RANGE LOOP IF rt(i) = '1' THEN prod := prod + lt; END IF; lt := shift(lt); END LOOP; RETURN prod; END "*"; FUNCTION rshift( v : std_logic_vector ) RETURN std_logic_vector IS VARIABLE v1 : std_logic_vector( v'RANGE ); BEGIN FOR i IN v'LEFT TO v'RIGHT-1 LOOP v1(i+1) := v(i); END LOOP; v1(v1'LEFT) := '0'; RETURN v1; END rshift; FUNCTION hasX( v : std_logic_vector ) RETURN boolean IS BEGIN FOR i IN v'RANGE LOOP IF v(i) = '0' OR v(i) = '1' OR v(i) = 'L' OR v(i) = 'H'THEN NULL; ELSE RETURN TRUE; END IF; END LOOP; RETURN FALSE; END hasX; FUNCTION "/" (l, r :std_logic_vector) RETURN std_logic_vector IS VARIABLE ml : integer := max(l'LENGTH,r'LENGTH); VARIABLE lt : std_logic_vector(0 TO ml+1); VARIABLE rt : std_logic_vector(0 TO ml+1); VARIABLE quote : std_logic_vector(1 TO ml); VARIABLE tmp : std_logic_vector(0 TO ml+1) := (others=>'0'); VARIABLE n : std_logic_vector(0 TO ml+1) := (others=>'0'); BEGIN ASSERT NOT (r = "0") REPORT "Attempted divide by ZERO" SEVERITY ERROR; IF hasX(l) OR hasX(r) THEN FOR i IN quote'RANGE LOOP quote(i) := 'X'; END LOOP; ELSE lt := zxt( l, ml+2 ); WHILE lt >= r LOOP rt := zxt( r, ml+2 ); n := (OTHERS=>'0'); n(n'RIGHT) := '1'; WHILE rt <= lt LOOP rt := shift(rt); n := shift(n); END LOOP; rt := rshift(rt); lt := lt - rt; n := rshift(n); tmp := tmp + n; END LOOP; END IF; quote := tmp(2 to ml+1); RETURN quote; END "/"; FUNCTION "MOD" (l, r :std_logic_vector) RETURN std_logic_vector IS VARIABLE ml : integer := max(l'LENGTH,r'LENGTH); VARIABLE lt : std_logic_vector(0 TO ml+1); VARIABLE rt : std_logic_vector(0 TO ml+1); VARIABLE quote : std_logic_vector(1 TO ml); VARIABLE tmp : std_logic_vector(0 TO ml+1) := (others=>'0'); VARIABLE n : std_logic_vector(0 TO ml) := (others=>'0'); BEGIN ASSERT NOT (r = "0") REPORT "Attempted divide by ZERO" SEVERITY ERROR; IF hasX(l) OR hasX(r) THEN FOR i IN lt'RANGE LOOP lt(i) := 'X'; END LOOP; ELSE lt := zxt( l, ml+2 ); WHILE lt >= r LOOP rt := zxt( r, ml+2 ); WHILE rt <= lt LOOP rt := shift(rt); END LOOP; rt := rshift(rt); lt := lt - rt; END LOOP; END IF; RETURN lt(2 to ml+1); END "MOD"; FUNCTION "REM" (l, r :std_logic_vector) RETURN std_logic_vector IS VARIABLE ml : integer := max(l'LENGTH,r'LENGTH); VARIABLE lt : std_logic_vector(0 TO ml+1); VARIABLE rt : std_logic_vector(0 TO ml+1); VARIABLE quote : std_logic_vector(1 TO ml); VARIABLE tmp : std_logic_vector(0 TO ml+1) := (others=>'0'); VARIABLE n : std_logic_vector(0 TO ml) := (others=>'0'); BEGIN ASSERT NOT (r = "0") REPORT "Attempted divide by ZERO" SEVERITY ERROR; IF hasX(l) OR hasX(r) THEN FOR i IN lt'RANGE LOOP lt(i) := 'X'; END LOOP; ELSE lt := zxt( l, ml+2 ); WHILE lt >= r LOOP rt := zxt( r, ml+2 ); WHILE rt <= lt LOOP rt := shift(rt); END LOOP; rt := rshift(rt); lt := lt - rt; END LOOP; END IF; RETURN lt(2 to ml+1); END "REM"; FUNCTION "**" (l, r :std_logic_vector) RETURN std_logic_vector IS VARIABLE return_vector : std_logic_vector(l'RANGE) := (others=>'0'); VARIABLE tmp : std_logic_vector(1 to (2 * l'LENGTH)) := (others=>'0'); CONSTANT lsh_l : integer := l'LENGTH+1; CONSTANT lsh_r : integer := 2 * l'LENGTH; VARIABLE pow : integer; BEGIN IF (hasX(l) OR hasX(r)) THEN FOR i IN return_vector'RANGE LOOP return_vector(i) := 'X'; END LOOP; ELSE pow := To_Integer( r, 0 ); tmp( tmp'right ) := '1'; FOR i IN 1 TO pow LOOP tmp := tmp(lsh_l TO lsh_r) * l; END LOOP; return_vector := tmp(lsh_l TO lsh_r); END IF; RETURN return_vector; END "**"; --------------------------------------------------------------------- FUNCTION To_StdUlogicVector (val : integer; size : integer) RETURN std_ulogic_vector IS VARIABLE vector : std_ulogic_vector(0 TO size-1); VARIABLE tmp_int : integer := val; VARIABLE carry : std_ulogic := '1'; -- setup to add 1 if needed VARIABLE carry2 : std_ulogic; BEGIN FOR i IN size-1 DOWNTO 0 LOOP IF tmp_int MOD 2 = 1 THEN vector(i) := '1'; ELSE vector(i) := '0'; END IF; tmp_int := tmp_int / 2; END LOOP; IF val < 0 THEN FOR i IN size-1 DOWNTO 0 LOOP carry2 := (NOT vector(i)) AND carry; vector(i) := (NOT vector(i)) XOR carry; carry := carry2; END LOOP; END IF; RETURN vector; END To_StdUlogicVector; FUNCTION To_StdlogicVector (val : integer; size : integer) RETURN std_logic_vector IS VARIABLE vector : std_logic_vector(0 TO size-1); VARIABLE tmp_int : integer := val; VARIABLE carry : std_logic := '1'; -- setup to add 1 if needed VARIABLE carry2 : std_logic; BEGIN FOR i IN size-1 DOWNTO 0 LOOP IF tmp_int MOD 2 = 1 THEN vector(i) := '1'; ELSE vector(i) := '0'; END IF; tmp_int := tmp_int / 2; END LOOP; IF val < 0 THEN FOR i IN size-1 DOWNTO 0 LOOP carry2 := (NOT vector(i)) AND carry; vector(i) := (NOT vector(i)) XOR carry; carry := carry2; END LOOP; END IF; RETURN vector; END To_StdlogicVector; FUNCTION To_Integer (val : std_ulogic_vector; x : integer := 0 ) RETURN integer IS VARIABLE return_int,x_tmp : integer := 0; BEGIN ASSERT val'LENGTH > 0 REPORT "NULL vector, returning 0" SEVERITY NOTE; ASSERT val'LENGTH <= 32 -- implementation dependent limit REPORT "vector too large, conversion may cause overflow" SEVERITY WARNING; IF x /= 0 THEN x_tmp := 1; END IF; IF val(val'LEFT) = '0' OR val(val'LEFT) = 'L' THEN -- positive value FOR i IN val'RANGE LOOP return_int := return_int * 2; CASE val(i) IS WHEN '0'|'L' => NULL; WHEN '1'|'H' => return_int := return_int + 1; WHEN OTHERS => return_int := return_int + x_tmp; END CASE; END LOOP; ELSE -- negative value FOR i IN val'RANGE LOOP return_int := return_int * 2; CASE val(i) IS WHEN '0'|'L' => return_int := return_int + 1; WHEN '1'|'H' => NULL; WHEN OTHERS => return_int := return_int + x_tmp; END CASE; END LOOP; return_int := -(return_int + 1); END IF; RETURN return_int; END To_Integer; FUNCTION To_Integer (val : std_logic_vector; x : integer := 0 ) RETURN integer IS VARIABLE return_int,x_tmp : integer := 0; BEGIN ASSERT val'LENGTH > 0 REPORT "NULL vector, returning 0" SEVERITY NOTE; ASSERT val'LENGTH <= 32 -- implementation dependent limit REPORT "vector too large, conversion may cause overflow" SEVERITY WARNING; IF x /= 0 THEN x_tmp := 1; END IF; IF val(val'LEFT) = '0' OR val(val'LEFT) = 'L' THEN -- positive value FOR i IN val'RANGE LOOP return_int := return_int * 2; CASE val(i) IS WHEN '0'|'L' => NULL; WHEN '1'|'H' => return_int := return_int + 1; WHEN OTHERS => return_int := return_int + x_tmp; END CASE; END LOOP; ELSE -- negative value FOR i IN val'RANGE LOOP return_int := return_int * 2; CASE val(i) IS WHEN '0'|'L' => return_int := return_int + 1; WHEN '1'|'H' => NULL; WHEN OTHERS => return_int := return_int + x_tmp; END CASE; END LOOP; return_int := -(return_int + 1); END IF; RETURN return_int; END To_Integer; END std_logic_1164_extensions;