--****************************************************************************** --** @(#) Design Unit: PACKAGE utilities.std_logic_1164_utils() --** @(#) Part Class: Utilities --** @(#) File: std_logic_1164_utils.vhd --** @(#) Version: 1.2 --** @(#) Date: 07/23/98 --** @(#) Description: Subprograms for type conversions between types in --** @(#) Description: std.standard and ieee.std_logic_1164 and other support --** @(#) Description: functions associated with package ieee.std_logic_1164 --** --****************************************************************************** --** File: std_logic_1164_utils.vhd --** --** Description: PACKAGE BODY std_logic_1164_utils --** See PACKAGE Declaration --** --****************************************************************************** --** History: @(#)std_logic_1164_utils.vhd 1.2 07/23/98 --** Version | Who | When | What --** 1.1 | VLS | 01-20-95 | Original (Vince Sanders) --** 1.2 | VLS | 05-08-95 | Added Procedures READ, --** Changed SEVERITY_LEVELS --** --****************************************************************************** --** --****************************************************************************** --** --** Organization: --** Microsystems Prototyping Laboratory --** Mississippi State University --** P.O. Box 9627 --** Mississippi State, MS 39762 --** Phone : (601) 325-3670 --** FAX : (601) 325-7692 --** E-Mail : mpl-vhdl@ERC.MsState.Edu --** WWW : http://www.ERC.MsState.Edu/mpl --** --** Disclaimer: --** All information, models, programs, code, etc... --** is provided as-is with no warranty of any kind with regard to this --** material, either expressed or implied, including, but not limited to, --** the implied warranties of merchantability and fitness for a particular --** purpose. --** --** Bug Reports and Information: --** Please report all bugs/fixes/problems/comments to the --** above organization. If you would like to be put on the --** mailing list for updates/bug fixes/etc... and future model --** releases please send email to the above organization. --** --****************************************************************************** LIBRARY ieee; USE ieee.std_logic_1164.ALL; LIBRARY std; USE std.textio.ALL; LIBRARY utilities; USE utilities.standard_utils.ALL; PACKAGE BODY std_logic_1164_utils IS --############################################################################## -- Conversions FROM ieee.std_logic_1164 TO ieee.std_logic_1164 --############################################################################## -------------------------------------------------------------------------------- -- To_Std_Ulogic_Vector -------------------------------------------------------------------------------- ------------------------------------------------------------------------------ FUNCTION To_Std_Ulogic_Vector (v : Std_Logic_Vector) RETURN Std_Ulogic_Vector IS BEGIN RETURN ieee.std_logic_1164.To_StdULogicVector(v); END To_Std_Ulogic_Vector; ------------------------------------------------------------------------------ -------------------------------------------------------------------------------- -------------------------------------------------------------------------------- -- To_Std_Logic_Vector -------------------------------------------------------------------------------- ------------------------------------------------------------------------------ FUNCTION To_Std_Logic_Vector (v : Std_Ulogic_Vector) RETURN Std_Logic_Vector IS BEGIN RETURN ieee.std_logic_1164.To_StdLogicVector(v); END To_Std_Logic_Vector; ------------------------------------------------------------------------------ -------------------------------------------------------------------------------- --############################################################################## -- Conversions FROM ieee.std_logic_1164 TO std.standard --############################################################################## -------------------------------------------------------------------------------- -- To_Bit -------------------------------------------------------------------------------- ------------------------------------------------------------------------------ -- In Package ieee.std_logic_1164 --FUNCTION To_Bit (v : Std_Ulogic; xmap : Bit := '0') RETURN Bit; ------------------------------------------------------------------------------ -------------------------------------------------------------------------------- -- To_Bit_Vector -------------------------------------------------------------------------------- ------------------------------------------------------------------------------ FUNCTION To_Bit_Vector (v : Std_Ulogic_Vector; xmap : Bit := '0') RETURN Bit_Vector IS BEGIN RETURN ieee.std_logic_1164.To_BitVector(v, xmap); END To_Bit_Vector; ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ FUNCTION To_Bit_Vector (v : Std_Logic_Vector; xmap : Bit := '0') RETURN Bit_Vector IS BEGIN RETURN ieee.std_logic_1164.To_BitVector(v, xmap); END To_Bit_Vector; ------------------------------------------------------------------------------ -------------------------------------------------------------------------------- -- To_Boolean -------------------------------------------------------------------------------- ------------------------------------------------------------------------------ FUNCTION To_Boolean (v : Std_Ulogic; xmap : Boolean := FALSE) RETURN Boolean IS BEGIN CASE v IS WHEN '0' | 'L' => RETURN FALSE; WHEN '1' | 'H' => RETURN TRUE; WHEN OTHERS => ASSERT FALSE REPORT LF& "WARNING: FUNCTION To_Boolean (v : Std_Ulogic; xmap : Boolean := FALSE) RETURN Boolean;"&LF& " Std_Ulogic := "&To_String(v)&" ==> Boolean := "&To_String(xmap)&LF& LF SEVERITY WARNING; RETURN xmap; END CASE; END To_Boolean; ------------------------------------------------------------------------------ -------------------------------------------------------------------------------- -------------------------------------------------------------------------------- -- To_Character -------------------------------------------------------------------------------- ------------------------------------------------------------------------------ FUNCTION To_Character (v : Std_Ulogic) RETURN Character IS BEGIN CASE v IS WHEN 'U' => RETURN 'U'; WHEN 'X' => RETURN 'X'; WHEN '0' => RETURN '0'; WHEN '1' => RETURN '1'; WHEN 'Z' => RETURN 'Z'; WHEN 'W' => RETURN 'W'; WHEN 'L' => RETURN 'L'; WHEN 'H' => RETURN 'H'; WHEN '-' => RETURN '-'; END CASE; END To_Character; ------------------------------------------------------------------------------ -------------------------------------------------------------------------------- -------------------------------------------------------------------------------- -- To_Integer -------------------------------------------------------------------------------- ------------------------------------------------------------------------------ FUNCTION To_Integer (v : Std_Ulogic; xmap : Std_Ulogic01 := '0') RETURN Integer IS BEGIN CASE v IS WHEN '0' | 'L' => RETURN 0; WHEN '1' | 'H' => RETURN 1; WHEN OTHERS => ASSERT FALSE REPORT LF& "WARNING: FUNCTION To_Integer (v : Std_Ulogic; xmap : Std_Ulogic := '0') RETURN Integer;"&LF& " Std_Ulogic := "&To_String(v)&" ==> Integer := "&To_String(To_Integer(xmap))&LF& LF SEVERITY WARNING; RETURN To_Integer(xmap); END CASE; END To_Integer; ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ FUNCTION To_Integer (v : Std_Ulogic_Vector; xmap : Std_Ulogic01 := '0') RETURN Integer IS VARIABLE vv : Std_Ulogic_Vector(v'RANGE) := To_X01(v); VARIABLE result : Integer := 0; BEGIN IF (Is_X(vv)) THEN FOR i IN vv'RANGE LOOP IF (vv(i) = 'X') THEN vv(i) := xmap; END IF; END LOOP; ASSERT FALSE REPORT LF& "WARNING: FUNCTION To_Integer (v : Std_Ulogic_Vector; xmap : Std_Ulogic01 := '0') RETURN Integer;"&LF& " Std_Ulogic_Vector := "&To_String(v)&" ==> Std_Ulogic_Vector := "&To_String(vv)&LF& LF SEVERITY WARNING; END IF; FOR i IN vv'RANGE LOOP result := result * 2 + Std_Ulogic'POS(vv(i)) - Std_Ulogic'POS('0'); END LOOP; RETURN result; END To_Integer; ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ FUNCTION To_Integer (v : Std_Logic_Vector; xmap : Std_Ulogic01 := '0') RETURN Integer IS VARIABLE vv : Std_Logic_Vector(v'RANGE) := To_X01(v); VARIABLE result : Integer := 0; BEGIN IF (Is_X(vv)) THEN FOR i IN vv'RANGE LOOP IF (vv(i) = 'X') THEN vv(i) := xmap; END IF; END LOOP; ASSERT FALSE REPORT LF& "WARNING: FUNCTION To_Integer (v : Std_Logic_Vector; xmap : Std_Ulogic01 := '0') RETURN Integer;"&LF& " Std_Logic_Vector := "&To_String(v)&" ==> Std_Logic_Vector := "&To_String(vv)&LF& LF SEVERITY WARNING; END IF; FOR i IN vv'RANGE LOOP result := result * 2 + Std_Ulogic'POS(vv(i)) - Std_Ulogic'POS('0'); END LOOP; RETURN result; END To_Integer; ------------------------------------------------------------------------------ -------------------------------------------------------------------------------- -------------------------------------------------------------------------------- -- To_String -------------------------------------------------------------------------------- ------------------------------------------------------------------------------ FUNCTION To_String (v : Std_Ulogic) RETURN String IS VARIABLE result : String(1 TO 1); BEGIN result(1) := To_Character(v); RETURN result; END To_String; ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ FUNCTION To_String (v : Std_Ulogic_Vector) RETURN String IS ALIAS va : Std_Ulogic_Vector(1 TO v'LENGTH) IS v; VARIABLE result : String(1 TO v'LENGTH); BEGIN FOR i IN result'RANGE LOOP result(i) := To_Character(va(i)); END LOOP; RETURN result; END To_String; ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ FUNCTION To_String (v : Std_Logic_Vector) RETURN String IS ALIAS va : Std_Logic_Vector(1 TO v'LENGTH) IS v; VARIABLE result : String(1 TO v'LENGTH); BEGIN FOR i IN result'RANGE LOOP result(i) := To_Character(va(i)); END LOOP; RETURN result; END To_String; ------------------------------------------------------------------------------ -------------------------------------------------------------------------------- --############################################################################## -- Conversions FROM std.standard TO ieee.std_logic_1164 --############################################################################## -------------------------------------------------------------------------------- -- To_Std_Ulogic -------------------------------------------------------------------------------- ------------------------------------------------------------------------------ FUNCTION To_Std_Ulogic (v : Bit) RETURN Std_Ulogic IS BEGIN RETURN ieee.std_logic_1164.To_StdULogic(v); END To_Std_Ulogic; ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ FUNCTION To_Std_Ulogic (v : Boolean) RETURN Std_Ulogic IS BEGIN CASE v IS WHEN FALSE => RETURN '0'; WHEN TRUE => RETURN '1'; END CASE; END To_Std_Ulogic; ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ FUNCTION To_Std_Ulogic (v : Character; xmap : Std_Ulogic := 'X') RETURN Std_Ulogic IS BEGIN CASE v IS WHEN 'U' => RETURN 'U'; WHEN 'X' => RETURN 'X'; WHEN '0' => RETURN '0'; WHEN '1' => RETURN '1'; WHEN 'Z' => RETURN 'Z'; WHEN 'W' => RETURN 'W'; WHEN 'L' => RETURN 'L'; WHEN 'H' => RETURN 'H'; WHEN '-' => RETURN '-'; WHEN OTHERS => ASSERT FALSE REPORT LF& "WARNING: FUNCTION To_Std_Ulogic (v : Character; xmap : Std_Ulogic := 'X') RETURN Std_Ulogic;"&LF& " Character := "&v&" ==> Std_Ulogic := "&To_Character(xmap)&LF& LF SEVERITY WARNING; RETURN xmap; END CASE; END To_Std_Ulogic; ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ FUNCTION To_Std_Ulogic (v : String; xmap : Std_Ulogic := 'X') RETURN Std_Ulogic IS ALIAS va : String(1 TO v'LENGTH) IS v; BEGIN ASSERT NOT (v'LENGTH > 1) REPORT LF& "WARNING: FUNCTION To_Std_Ulogic (v : String; xmap : Std_Ulogic := 'X') RETURN Std_Ulogic;"&LF& " String := "&v&" ==> v'LENGTH > 1, RETURNING To_Std_Ulogic(v'LEFT)"&LF& LF SEVERITY WARNING; RETURN To_Std_Ulogic(va(1), xmap); END To_Std_Ulogic; ------------------------------------------------------------------------------ -------------------------------------------------------------------------------- -------------------------------------------------------------------------------- -- To_Std_Ulogic_Vector -------------------------------------------------------------------------------- ------------------------------------------------------------------------------ FUNCTION To_Std_Ulogic_Vector (v : Bit_Vector) RETURN Std_Ulogic_Vector IS BEGIN RETURN ieee.std_logic_1164.To_StdULogicVector(v); END To_Std_Ulogic_Vector; ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ FUNCTION To_Std_Ulogic_Vector (v : Integer; length : Positive) RETURN Std_Ulogic_Vector IS VARIABLE tmp : Integer := v; VARIABLE result : Std_Ulogic_Vector(length - 1 DOWNTO 0); BEGIN IF (v > (2 ** length - 1)) THEN result := (OTHERS => '1'); ASSERT FALSE REPORT LF& "WARNING: FUNCTION To_Std_Ulogic_Vector (v : Integer; length : Positive) RETURN Std_Ulogic_Vector;"&LF& " Integer := "&To_String(v)&" ==> Std_Ulogic_Vector("&To_String(length - 1)&" DOWNTO 0) := "&To_String(result)&LF& LF SEVERITY WARNING; RETURN result; END IF; FOR i IN result'REVERSE_RANGE LOOP result(i) := Std_Ulogic'VAL(tmp MOD 2 + Std_Ulogic'POS('0')); tmp := tmp / 2; END LOOP; RETURN result; END To_Std_Ulogic_Vector; ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ FUNCTION To_Std_Ulogic_Vector (v : String; xmap : Std_Ulogic := 'X') RETURN Std_Ulogic_Vector IS ALIAS va : String(1 TO v'LENGTH) IS v; VARIABLE result : Std_Ulogic_Vector(1 TO v'LENGTH); BEGIN FOR i IN 1 TO result'LENGTH LOOP result(i) := To_Std_Ulogic(va(i), xmap); END LOOP; RETURN result; END To_Std_Ulogic_Vector; ------------------------------------------------------------------------------ -------------------------------------------------------------------------------- -------------------------------------------------------------------------------- -- To_Std_Logic_Vector -------------------------------------------------------------------------------- ------------------------------------------------------------------------------ FUNCTION To_Std_Logic_Vector (v : Bit_Vector) RETURN Std_Logic_Vector IS BEGIN RETURN ieee.std_logic_1164.To_StdLogicVector(v); END To_Std_Logic_Vector; ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ FUNCTION To_Std_Logic_Vector (v : Integer; length : Positive) RETURN Std_Logic_Vector IS VARIABLE tmp : Integer := v; VARIABLE result : Std_Logic_Vector(length - 1 DOWNTO 0); BEGIN IF (v > (2 ** length - 1)) THEN result := (OTHERS => '1'); ASSERT FALSE REPORT LF& "WARNING: FUNCTION To_Std_Logic_Vector (v : Integer; length : Positive) RETURN Std_Logic_Vector;"&LF& " Integer := "&To_String(v)&" ==> Std_Logic_Vector("&To_String(length - 1)&" DOWNTO 0) := "&To_String(result)&LF& LF SEVERITY WARNING; RETURN result; END IF; FOR i IN result'REVERSE_RANGE LOOP result(i) := Std_Logic'VAL(tmp MOD 2 + Std_Logic'POS('0')); tmp := tmp / 2; END LOOP; RETURN result; END To_Std_Logic_Vector; ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ FUNCTION To_Std_Logic_Vector (v : String; xmap : Std_Ulogic := 'X') RETURN Std_Logic_Vector IS ALIAS va : String(1 TO v'LENGTH) IS v; VARIABLE result : Std_Logic_Vector(1 TO v'LENGTH); BEGIN FOR i IN 1 TO result'LENGTH LOOP result(i) := To_Std_Ulogic(va(i), xmap); END LOOP; RETURN result; END To_Std_Logic_Vector; ------------------------------------------------------------------------------ -------------------------------------------------------------------------------- --############################################################################## -- Read, Write --############################################################################## -------------------------------------------------------------------------------- -- Read -------------------------------------------------------------------------------- ------------------------------------------------------------------------------ PROCEDURE READ (l : INOUT Line; value : OUT Std_Logic; good : OUT Boolean) IS VARIABLE cc : Character; VARIABLE ok : Boolean := FALSE; VARIABLE tmpl : Line; BEGIN IF (l /= NULL AND l'LENGTH /= 0) THEN tmpl := NEW String'(l.ALL); Skip_White(tmpl); READ(tmpl, cc, ok); IF (ok) THEN CASE cc IS WHEN 'U' => value := 'U'; WHEN 'X' => value := 'X'; WHEN '0' => value := '0'; WHEN '1' => value := '1'; WHEN 'Z' => value := 'Z'; WHEN 'W' => value := 'W'; WHEN 'L' => value := 'L'; WHEN 'H' => value := 'H'; WHEN '-' => value := '-'; WHEN OTHERS => ok := FALSE; END CASE; END IF; IF (ok) THEN DEALLOCATE(l); l := tmpl; ELSE DEALLOCATE(tmpl); END IF; END IF; good := ok; END READ; ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ PROCEDURE READ (l : INOUT Line; value : OUT Std_Logic) IS VARIABLE good : Boolean; BEGIN READ(l, value, good); ASSERT good REPORT LF& "ERROR: PROCEDURE READ (l : INOUT Line; value : OUT Std_Logic);"&LF& " Could NOT READ TYPE From Line" &LF& LF SEVERITY ERROR; END READ; ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ PROCEDURE READ (l : INOUT Line; value : OUT Std_Ulogic_Vector; good : OUT Boolean) IS VARIABLE cc : Character; VARIABLE ok : Boolean := FALSE; VARIABLE tmpl : Line; BEGIN IF (l /= NULL AND l'LENGTH /= 0) THEN tmpl := NEW String'(l.ALL); Skip_White(tmpl); FOR ii IN value'RANGE LOOP READ(tmpl, cc, ok); IF (ok) THEN CASE cc IS WHEN 'U' => value(ii) := 'U'; WHEN 'X' => value(ii) := 'X'; WHEN '0' => value(ii) := '0'; WHEN '1' => value(ii) := '1'; WHEN 'Z' => value(ii) := 'Z'; WHEN 'W' => value(ii) := 'W'; WHEN 'L' => value(ii) := 'L'; WHEN 'H' => value(ii) := 'H'; WHEN '-' => value(ii) := '-'; WHEN OTHERS => ok := FALSE; END CASE; END IF; EXIT WHEN (NOT ok); END LOOP; IF (ok) THEN DEALLOCATE(l); l := tmpl; ELSE DEALLOCATE(tmpl); END IF; END IF; good := ok; END READ; ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ PROCEDURE READ (l : INOUT Line; value : OUT Std_Ulogic_Vector) IS VARIABLE good : Boolean; BEGIN READ(l, value, good); ASSERT good REPORT LF& "ERROR: PROCEDURE READ (l : INOUT Line; value : OUT Std_Ulogic_Vector);"&LF& " Could NOT READ TYPE From Line" &LF& LF SEVERITY ERROR; END READ; ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ PROCEDURE READ (l : INOUT Line; value : OUT Std_Logic_Vector; good : OUT Boolean) IS VARIABLE cc : Character; VARIABLE ok : Boolean := FALSE; VARIABLE tmpl : Line; BEGIN IF (l /= NULL AND l'LENGTH /= 0) THEN tmpl := NEW String'(l.ALL); Skip_White(tmpl); FOR ii IN value'RANGE LOOP READ(tmpl, cc, ok); IF (ok) THEN CASE cc IS WHEN 'U' => value(ii) := 'U'; WHEN 'X' => value(ii) := 'X'; WHEN '0' => value(ii) := '0'; WHEN '1' => value(ii) := '1'; WHEN 'Z' => value(ii) := 'Z'; WHEN 'W' => value(ii) := 'W'; WHEN 'L' => value(ii) := 'L'; WHEN 'H' => value(ii) := 'H'; WHEN '-' => value(ii) := '-'; WHEN OTHERS => ok := FALSE; END CASE; END IF; EXIT WHEN (NOT ok); END LOOP; IF (ok) THEN DEALLOCATE(l); l := tmpl; ELSE DEALLOCATE(tmpl); END IF; END IF; good := ok; END READ; ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ PROCEDURE READ (l : INOUT Line; value : OUT Std_Logic_Vector) IS VARIABLE good : Boolean; BEGIN READ(l, value, good); ASSERT good REPORT LF& "ERROR: PROCEDURE READ (l : INOUT Line; value : OUT Std_Logic_Vector);"&LF& " Could NOT READ TYPE From Line" &LF& LF SEVERITY ERROR; END READ; ------------------------------------------------------------------------------ -------------------------------------------------------------------------------- -------------------------------------------------------------------------------- -- Write -------------------------------------------------------------------------------- ------------------------------------------------------------------------------ PROCEDURE WRITE (l : INOUT Line; value : IN Std_Ulogic; justified : IN Side := RIGHT; field : IN Width := 0) IS BEGIN WRITE(l, To_Character(value), justified, field); END WRITE; ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ PROCEDURE WRITE (l : INOUT Line; value : IN Std_Ulogic_Vector; justified : IN Side := RIGHT; field : IN Width := 0) IS BEGIN WRITE(l, To_String(value), justified, field); END WRITE; ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ PROCEDURE WRITE (l : INOUT Line; value : IN Std_Logic_Vector; justified : IN Side := RIGHT; field : IN Width := 0) IS BEGIN WRITE(l, To_String(value), justified, field); END WRITE; ------------------------------------------------------------------------------ -------------------------------------------------------------------------------- --############################################################################## -- Misc Functions --############################################################################## -------------------------------------------------------------------------------- -- To_Logic -------------------------------------------------------------------------------- ------------------------------------------------------------------------------ FUNCTION To_Logic (v : Character; xmap : Std_Ulogic := 'X') RETURN Std_Ulogic IS BEGIN RETURN To_Std_Ulogic(v, xmap); END To_Logic; ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ FUNCTION To_Logic (v : String; xmap : Std_Ulogic := 'X') RETURN Std_Ulogic IS BEGIN RETURN To_Std_Ulogic(v, xmap); END To_Logic; ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ FUNCTION To_Logic (v : String; xmap : Std_Ulogic := 'X') RETURN Std_Ulogic_Vector IS BEGIN RETURN To_Std_Ulogic_Vector(v, xmap); END To_Logic; ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ FUNCTION To_Logic (v : String; xmap : Std_Ulogic := 'X') RETURN Std_Logic_Vector IS BEGIN RETURN To_Std_Logic_Vector(v, xmap); END To_Logic; ------------------------------------------------------------------------------ -------------------------------------------------------------------------------- -------------------------------------------------------------------------------- -- Reduce Logic Functions -------------------------------------------------------------------------------- ------------------------------------------------------------------------------ FUNCTION Reduce_AND (v : Std_Ulogic_Vector) RETURN Std_Ulogic IS VARIABLE result : Std_Ulogic := '1'; BEGIN FOR i IN v'RANGE LOOP result := result AND v(i); EXIT WHEN result = '0'; END LOOP; RETURN result; END Reduce_AND; ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ FUNCTION Reduce_AND (v : Std_Logic_Vector) RETURN Std_Ulogic IS VARIABLE result : Std_Ulogic := '1'; BEGIN FOR i IN v'RANGE LOOP result := result AND v(i); EXIT WHEN result = '0'; END LOOP; RETURN result; END Reduce_AND; ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ FUNCTION Reduce_OR (v : Std_Ulogic_Vector) RETURN Std_Ulogic IS VARIABLE result : Std_Ulogic := '0'; BEGIN FOR i IN v'RANGE LOOP result := result OR v(i); EXIT WHEN result = '1'; END LOOP; RETURN result; END Reduce_OR; ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ FUNCTION Reduce_OR (v : Std_Logic_Vector) RETURN Std_Ulogic IS VARIABLE result : Std_Ulogic := '0'; BEGIN FOR i IN v'RANGE LOOP result := result OR v(i); EXIT WHEN result = '1'; END LOOP; RETURN result; END Reduce_OR; ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ FUNCTION Reduce_XOR (v : Std_Ulogic_Vector) RETURN Std_Ulogic IS VARIABLE result : Std_Ulogic := '0'; BEGIN FOR i IN v'RANGE LOOP result := result XOR v(i); END LOOP; RETURN result; END Reduce_XOR; ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ FUNCTION Reduce_XOR (v : Std_Logic_Vector) RETURN Std_Ulogic IS VARIABLE result : Std_Ulogic := '0'; BEGIN FOR i IN v'RANGE LOOP result := result XOR v(i); END LOOP; RETURN result; END Reduce_XOR; ------------------------------------------------------------------------------ -------------------------------------------------------------------------------- END std_logic_1164_utils;