------------------------------------------------------------------------------
-- "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: 2006-03-22 15:52:00-05 $
-- RCS ID: $Id: std_logic_1164_additions.vhd,v 1.7 2006-03-22 15:52:00-05 l435385 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

  -- 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_sulv is ieee.std_logic_1164.To_StdULogicVector [BIT_VECTOR return std_ulogic_vector] ;
--  alias to_sulv 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] ;
  
  -- Done as functions because some tools don't like the alias syntax
  function to_bv ( s : std_logic_vector; xmap : BIT  := '0') RETURN BIT_VECTOR;
  function to_bv ( s : std_ulogic_vector; xmap : BIT := '0') RETURN BIT_VECTOR ;
  function to_bit_vector ( s : std_logic_vector; xmap : BIT := '0') RETURN BIT_VECTOR;
  function to_bit_vector ( s : std_ulogic_vector; xmap : BIT := '0') RETURN BIT_VECTOR;
  function to_slv ( b  : BIT_VECTOR ) RETURN std_logic_vector;
  function to_slv ( s  : std_ulogic_vector ) RETURN std_logic_vector ;
  function to_std_logic_vector ( b  : BIT_VECTOR ) RETURN std_logic_vector;
  function to_std_logic_vector ( s  : std_ulogic_vector ) RETURN std_logic_vector ;
  function to_sulv ( b : BIT_VECTOR ) RETURN std_ulogic_vector;
  function to_sulv ( s : std_logic_vector ) RETURN std_ulogic_vector ;
  function to_std_ulogic_vector ( b : BIT_VECTOR ) RETURN std_ulogic_vector;
  function to_std_ulogic_vector ( s : 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;
  -----------------------------------------------------------------------------
  -- std_ulogic and boolean functions
  -----------------------------------------------------------------------------
  function "and"  (L: std_ulogic; R: boolean) return std_ulogic;
  function "and"  (L: boolean; R: std_ulogic) return std_ulogic;
  function "or"   (L: std_ulogic; R: boolean) return std_ulogic;
  function "or"   (L: boolean; R: std_ulogic) return std_ulogic;
  function "xor"  (L: std_ulogic; R: boolean) return std_ulogic;
  function "xor"  (L: boolean; R: std_ulogic) return std_ulogic;
  function "nand" (L: std_ulogic; R: boolean) return std_ulogic;
  function "nand" (L: boolean; R: std_ulogic) return std_ulogic;
  function "nor"  (L: std_ulogic; R: boolean) return std_ulogic;
  function "nor"  (L: boolean; R: std_ulogic) return std_ulogic;
  function "xnor" (L: std_ulogic; R: boolean) return std_ulogic;
  function "xnor" (L: boolean; R: std_ulogic) return std_ulogic;
  -------------------------------------------------------------------
  -- vector-reduction functions.
  -- "and" functions default to "1", or defaults to "0"
  -------------------------------------------------------------------
  -----------------------------------------------------------------------------
  -- %%% Replace the "_reduce" functions with the ones commented out below.
  -----------------------------------------------------------------------------
  -- function "and" ( arg  : std_logic_vector ) RETURN std_ulogic;
  -- function "and" ( arg  : std_ulogic_vector ) RETURN std_ulogic; 
  -- function "nand" ( arg  : std_logic_vector ) RETURN std_ulogic;
  -- function "nand" ( arg  : std_ulogic_vector ) RETURN std_ulogic;
  -- function "or" ( arg  : std_logic_vector ) RETURN std_ulogic;
  -- function "or" ( arg  : std_ulogic_vector ) RETURN std_ulogic;
  -- function "nor" ( arg  : std_logic_vector ) RETURN std_ulogic;
  -- function "nor" ( arg  : std_ulogic_vector ) RETURN std_ulogic;
  -- function "xor" ( arg  : std_logic_vector ) RETURN std_ulogic;
  -- function "xor" ( arg  : std_ulogic_vector ) RETURN std_ulogic;
  -- function "xnor" ( arg  : std_logic_vector ) RETURN std_ulogic;
  -- function "xnor" ( arg  : std_ulogic_vector ) RETURN std_ulogic;
  FUNCTION and_reduce ( arg  : std_logic_vector ) RETURN std_ulogic;
  FUNCTION and_reduce ( arg  : std_ulogic_vector ) RETURN std_ulogic;
  FUNCTION nand_reduce ( arg : std_logic_vector ) RETURN std_ulogic;
  FUNCTION nand_reduce ( arg : std_ulogic_vector ) RETURN std_ulogic;
  FUNCTION or_reduce ( arg   : std_logic_vector ) RETURN std_ulogic;
  FUNCTION or_reduce ( arg   : std_ulogic_vector ) RETURN std_ulogic;
  FUNCTION nor_reduce ( arg  : std_logic_vector ) RETURN std_ulogic;
  FUNCTION nor_reduce ( arg  : std_ulogic_vector ) RETURN std_ulogic;
  FUNCTION xor_reduce ( arg  : std_logic_vector ) RETURN std_ulogic;
  FUNCTION xor_reduce ( arg  : std_ulogic_vector ) RETURN std_ulogic;
  FUNCTION xnor_reduce ( arg : std_logic_vector ) RETURN std_ulogic;
  FUNCTION xnor_reduce ( arg : 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_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_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_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_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_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;
  
  -- "??" 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
  -----------------------------------------------------------------------------
  -- Read and Write functions copied from "std_logic_textio"
  -----------------------------------------------------------------------------
  -- Read and Write procedures for STD_ULOGIC and STD_ULOGIC_VECTOR

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

  -- Read and Write procedures for STD_LOGIC_VECTOR

  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_ULOGIC, BOOLEAN] ;
--  alias bread is read [line, STD_ULOGIC] ;
--  alias bread is read [line, STD_ULOGIC_VECTOR, BOOLEAN] ;
--  alias bread is read [line, STD_ULOGIC_VECTOR] ;
--  alias bread is read [line, STD_LOGIC_VECTOR, BOOLEAN] ;
--  alias bread is read [line, STD_LOGIC_VECTOR] ;
--  alias bwrite is write [line, STD_ULOGIC, side, width] ;
--  alias bwrite is write [line, STD_ULOGIC_VECTOR, side, width] ;
--  alias bwrite is write [line, STD_LOGIC_VECTOR, side, width] ;

  procedure BREAD (L : inout LINE; VALUE : out STD_ULOGIC; GOOD : out BOOLEAN);
  procedure BREAD (L : inout LINE; VALUE : out STD_ULOGIC);

  procedure BREAD (L : inout LINE; VALUE : out STD_ULOGIC_VECTOR; GOOD : out BOOLEAN);
  procedure BREAD (L : inout LINE; VALUE : out STD_ULOGIC_VECTOR);
  procedure BREAD (L : inout LINE; VALUE : out STD_LOGIC_VECTOR; GOOD : out BOOLEAN);
  procedure BREAD (L : inout LINE; VALUE : out STD_LOGIC_VECTOR);
  procedure BWRITE (L : inout LINE; VALUE : in STD_ULOGIC;
  JUSTIFIED          : in    SIDE := RIGHT; FIELD : in WIDTH := 0);

  procedure BWRITE (L : inout LINE; VALUE : in STD_ULOGIC_VECTOR;
  JUSTIFIED          : in    SIDE := RIGHT; FIELD : in WIDTH := 0);
  procedure BWRITE (L : inout LINE; VALUE : in STD_LOGIC_VECTOR;
  JUSTIFIED          : in    SIDE := RIGHT; FIELD : in WIDTH := 0);

  -- Read and Write procedures for Hex values

  procedure HREAD (L : inout LINE; VALUE : out STD_ULOGIC_VECTOR; GOOD : out BOOLEAN);
  procedure HREAD (L : inout LINE; VALUE : out STD_ULOGIC_VECTOR);

  procedure HWRITE (L : inout LINE; VALUE : in STD_ULOGIC_VECTOR;
  JUSTIFIED           : in    SIDE := RIGHT; FIELD : in WIDTH := 0);

  procedure HREAD (L : inout LINE; VALUE : out STD_LOGIC_VECTOR;
  GOOD : out BOOLEAN);
  procedure HREAD (L : inout LINE; VALUE : out STD_LOGIC_VECTOR);

  procedure HWRITE (L : inout LINE; VALUE : in STD_LOGIC_VECTOR;
  JUSTIFIED           : in    SIDE := RIGHT; FIELD : in WIDTH := 0);

  -- Read and Write procedures for Octal values

  procedure OREAD (L : inout LINE; VALUE : out STD_ULOGIC_VECTOR;
  GOOD : out BOOLEAN);
  procedure OREAD (L : inout LINE; VALUE : out STD_ULOGIC_VECTOR);

  procedure OWRITE (L : inout LINE; VALUE : in STD_ULOGIC_VECTOR;
  JUSTIFIED           : in    SIDE := RIGHT; FIELD : in WIDTH := 0);

  procedure OREAD (L : inout LINE; VALUE : out STD_LOGIC_VECTOR;
  GOOD : out BOOLEAN);
  procedure OREAD (L : inout LINE; VALUE : out STD_LOGIC_VECTOR);

  procedure OWRITE (L : inout LINE; VALUE : in STD_LOGIC_VECTOR;
  JUSTIFIED           : in    SIDE := RIGHT; FIELD : in WIDTH := 0);
  -- rtl_synthesis on
  --------------------------------------------------------------------------
  -- Converts a std_logic_vector or std_ulogic vector to a string.
  --------------------------------------------------------------------------
  function to_string (
    value     : in STD_ULOGIC;
    justified : in side  := RIGHT;
    field     : in width := 0
    ) return string;

  function to_string (
    value     : in std_ulogic_vector;
    justified : in side  := RIGHT;
    field     : in width := 0
    ) return string;

  -- alias to_bstring is to_string [std_ulogic_vector, side, width return string];
  function to_bstring (
    value     : in std_ulogic_vector;
    justified : in side  := RIGHT;
    field     : in width := 0
    ) return string;

  function to_hstring (
    value     : in std_ulogic_vector;
    justified : in side  := RIGHT;
    field     : in width := 0
    ) return string;

  function to_ostring (
    value     : in std_ulogic_vector;
    justified : in side  := RIGHT;
    field     : in width := 0
    ) return string ;

  function to_string (
    value     : in std_logic_vector;
    justified : in side  := RIGHT;
    field     : in width := 0
    ) return string;

  -- alias to_bstring is to_string [std_logic_vector, side, width return string];
  function to_bstring (
    value     : in std_logic_vector;
    justified : in side  := RIGHT;
    field     : in width := 0
    ) return string;
  
  function to_hstring (
    value     : in std_logic_vector;
    justified : in side  := RIGHT;
    field     : in width := 0
    ) return string;

  function to_ostring (
    value     : in std_logic_vector;
    justified : in side  := RIGHT;
    field     : in width := 0
    ) return string ;

end package std_logic_1164_additions;

package body std_logic_1164_additions is
  -- alias done as functions
  function to_bv ( s : std_logic_vector; xmap : BIT  := '0')
    RETURN BIT_VECTOR is
  begin
    return To_bitvector (s, xmap);
  end function to_bv;
  function to_bv ( s : std_ulogic_vector; xmap : BIT := '0')
    RETURN BIT_VECTOR is
  begin
    return To_bitvector (s, xmap);
  end function to_bv;
  function to_bit_vector ( s : std_logic_vector; xmap : BIT := '0')
    RETURN BIT_VECTOR is
  begin
    return To_bitvector (s, xmap);
  end function to_bit_vector;
  function to_bit_vector ( s : std_ulogic_vector; xmap : BIT := '0')
    RETURN BIT_VECTOR is
  begin
    return To_bitvector (s, xmap);
  end function to_bit_vector;
  function to_slv ( b  : BIT_VECTOR )
    RETURN STD_LOGIC_VECTOR is
  begin
    return to_StdLogicVector (b);
  end function to_slv;
  function to_slv ( s  : std_ulogic_vector )
    RETURN std_logic_vector  is
  begin
    return to_StdLogicVector (s);
  end function to_slv;
  function to_std_logic_vector ( b  : BIT_VECTOR )
    RETURN std_logic_vector is
  begin
    return to_StdLogicVector (b);
  end function to_std_logic_vector;
  function to_std_logic_vector ( s  : std_ulogic_vector )
    RETURN std_logic_vector  is
  begin
    return to_StdLogicVector (s);
  end function to_std_logic_vector;
  function to_sulv ( b : BIT_VECTOR )
    RETURN std_ulogic_vector is
  begin
    return to_StdULogicVector (b);
  end function to_sulv;
  function to_sulv ( s : std_logic_vector )
    RETURN std_ulogic_vector  is
  begin
    return to_StdULogicVector (s);
  end function to_sulv;
  function to_std_ulogic_vector ( b : BIT_VECTOR )
    RETURN std_ulogic_vector is
  begin
    return to_StdULogicVector (b);
  end function to_std_ulogic_vector;
  function to_std_ulogic_vector ( s : std_logic_vector )
    RETURN std_ulogic_vector is
  begin
    return to_StdULogicVector (s);
  end function to_std_ulogic_vector;

  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 ( l'RANGE ) := (OTHERS => '0');
    ALIAS resultv   : std_logic_vector ( 1 TO l'LENGTH ) IS result;
  BEGIN
    IF r = 0 OR l'LENGTH = 0 THEN
      RETURN l;
    ELSIF r > 0 THEN
      IF r < l'LENGTH THEN
        resultv(1 TO l'LENGTH - r) := lv(r+1 TO l'LENGTH);
      END IF;
      RETURN result;
    ELSE
      RETURN l SRL (-r);
    END IF;
  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 ( l'RANGE ) := (OTHERS => '0');
    ALIAS resultv   : std_ulogic_vector ( 1 TO l'LENGTH ) IS result;
  BEGIN
    IF r = 0 OR l'LENGTH = 0 THEN
      RETURN l;
    ELSIF r > 0 THEN
      IF r < l'LENGTH THEN
        resultv(1 TO l'LENGTH - r) := lv(r+1 TO l'LENGTH);
      END IF;
      RETURN result;
    ELSE
      RETURN l SRL (-r);
    END IF;
  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 ( l'RANGE ) := (OTHERS => '0');
    ALIAS resultv   : std_logic_vector ( 1 TO l'LENGTH ) IS result;
  BEGIN
    IF r = 0 OR l'LENGTH = 0 THEN
      RETURN l;
    ELSIF r > 0 THEN
      IF r < l'LENGTH THEN
        resultv(r+1 TO l'LENGTH) := lv(1 TO l'LENGTH - r);
      END IF;
      RETURN result;
    ELSE
      RETURN l SLL (-r);
    END IF;
  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 ( l'RANGE ) := (OTHERS => '0');
    ALIAS resultv   : std_ulogic_vector ( 1 TO l'LENGTH ) IS result;
  BEGIN
    IF r = 0 OR l'LENGTH = 0 THEN
      RETURN l;
    ELSIF r > 0 THEN
      IF r < l'LENGTH THEN
        resultv(r+1 TO l'LENGTH) := lv(1 TO l'LENGTH - r);
      END IF;
      RETURN result;
    ELSE
      RETURN l SLL (-r);
    END IF;
  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 ( l'RANGE );
    ALIAS resultv   : std_logic_vector ( 1 TO l'LENGTH ) IS result;
    VARIABLE rv     : integer;
  BEGIN
    IF r = 0 OR l'LENGTH = 0 THEN
      RETURN l;
    ELSIF r > 0 THEN
      rv                                     := r MOD l'length;
      resultv(1 TO l'LENGTH - rv )           := lv(rv+1 TO l'LENGTH);
      resultv(l'LENGTH - rv + 1 TO l'length) := lv(1 TO rv);
      RETURN result;
    ELSE
      RETURN l ROR (-r);
    END IF;
  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 ( l'RANGE );
    ALIAS resultv   : std_ulogic_vector ( 1 TO l'LENGTH ) IS result;
    VARIABLE rv     : integer;
  BEGIN
    IF r = 0 OR l'LENGTH = 0 THEN
      RETURN l;
    ELSIF r > 0 THEN
      rv                                     := r MOD l'length;
      resultv(1 TO l'LENGTH - rv )           := lv(rv+1 TO l'LENGTH);
      resultv(l'LENGTH - rv + 1 TO l'LENGTH) := lv(1 TO rv);
      RETURN result;
    ELSE
      RETURN l ROR (-r);
    END IF;
  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 ( l'RANGE );
    ALIAS resultv   : std_logic_vector ( 1 TO l'LENGTH ) IS result;
    VARIABLE rv     : integer;
  BEGIN
    IF r = 0 OR l'LENGTH = 0 THEN
      RETURN l;
    ELSIF r > 0 THEN
      rv                        := r MOD l'length;
      resultv(rv+1 TO l'LENGTH) := lv(1 TO l'LENGTH - rv);
      resultv(1 TO rv)          := lv(l'LENGTH - rv + 1 TO l'LENGTH);
      RETURN result;
    ELSE
      RETURN l ROL (-r);
    END IF;
  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 ( l'RANGE );
    ALIAS resultv   : std_ulogic_vector ( 1 TO l'LENGTH ) IS result;
    VARIABLE rv     : integer;
  BEGIN
    IF r = 0 OR l'LENGTH = 0 THEN
      RETURN l;
    ELSIF r > 0 THEN
      rv                        := r MOD l'length;
      resultv(rv+1 TO l'LENGTH) := lv(1 TO l'LENGTH - rv);
      resultv(1 TO rv)          := lv(l'LENGTH - rv + 1 TO l'LENGTH);
      RETURN result;
    ELSE
      RETURN l ROL (-r);
    END IF;
  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
  -------------------------------------------------------------------
  -- %%% Uncomment the new syntax functions below
--  -------------------------------------------------------------------
--  -- and
--  -------------------------------------------------------------------
--  FUNCTION and ( arg : std_logic_vector ) RETURN std_ulogic IS
--  BEGIN
--    RETURN and (to_StdULogicVector (arg));
--  END FUNCTION and;
--  -------------------------------------------------------------------
--  FUNCTION and ( arg : std_ulogic_vector ) RETURN std_ulogic IS
--    variable Upper, Lower : std_ulogic;
--    variable Half : integer;
--    variable BUS_int : std_ulogic_vector ( arg'length - 1 downto 0 );
--    variable Result : std_ulogic := '1';    -- In the case of a NULL range
--  BEGIN
--    if (arg'LENGTH >= 1) then
--      BUS_int := to_ux01 (arg);
--      if ( BUS_int'length = 1 ) then
--        Result := BUS_int ( BUS_int'left );
--      elsif ( BUS_int'length = 2 ) then
--        Result := "and" (BUS_int(BUS_int'right),BUS_int(BUS_int'left));
--      else
--        Half := ( BUS_int'length + 1 ) / 2 + BUS_int'right;
--        Upper := and ( BUS_int ( BUS_int'left downto Half ));
--        Lower := and ( BUS_int ( Half - 1 downto BUS_int'right ));
--        Result := "and" (Upper, Lower);
--      end if;
--    end if;
--    return Result;
--  END FUNCTION and;

--  -------------------------------------------------------------------
--  -- nand
--  -------------------------------------------------------------------
--  FUNCTION nand ( arg : std_logic_vector ) RETURN std_ulogic IS
--  BEGIN
--    RETURN "not"(and(to_StdULogicVector(arg)));
--  END FUNCTION nand;
--  -------------------------------------------------------------------
--  FUNCTION nand ( arg : std_ulogic_vector ) RETURN std_ulogic IS
--  BEGIN
--    RETURN "not"(and(arg));
--  END FUNCTION nand;

--  -------------------------------------------------------------------
--  -- or
--  -------------------------------------------------------------------
--  FUNCTION or ( arg : std_logic_vector ) RETURN std_ulogic IS
--  BEGIN
--    RETURN or (to_StdULogicVector (arg));
--  END FUNCTION or;
--  -------------------------------------------------------------------
--  FUNCTION or ( arg : std_ulogic_vector ) RETURN std_ulogic IS
--    variable Upper, Lower : std_ulogic;
--    variable Half : integer;
--    variable BUS_int : std_ulogic_vector ( arg'length - 1 downto 0 );
--    variable Result : std_ulogic := '0';    -- In the case of a NULL range
--  BEGIN
--    if (arg'LENGTH >= 1) then
--      BUS_int := to_ux01 (arg);
--      if ( BUS_int'length = 1 ) then
--        Result := BUS_int ( BUS_int'left );
--      elsif ( BUS_int'length = 2 ) then
--        Result := "or" (BUS_int(BUS_int'right), BUS_int(BUS_int'left));
--      else
--        Half := ( BUS_int'length + 1 ) / 2 + BUS_int'right;
--        Upper := or ( BUS_int ( BUS_int'left downto Half ));
--        Lower := or ( BUS_int ( Half - 1 downto BUS_int'right ));
--        Result := "or" (Upper, Lower);
--      end if;
--    end if;
--    return Result;
--  END FUNCTION or;

--  -------------------------------------------------------------------
--  -- nor
--  -------------------------------------------------------------------
--  FUNCTION nor ( arg : std_logic_vector ) RETURN std_ulogic IS
--  BEGIN
--    RETURN "not"(or(To_StdULogicVector(arg)));
--  END FUNCTION nor;
--  -------------------------------------------------------------------
--  FUNCTION nor ( arg : std_ulogic_vector ) RETURN std_ulogic IS
--  BEGIN
--    RETURN "not"(or(arg));
--  END FUNCTION nor;

--  -------------------------------------------------------------------
--  -- xor
--  -------------------------------------------------------------------
--  FUNCTION xor ( arg : std_logic_vector ) RETURN std_ulogic IS
--  BEGIN
--    RETURN xor (to_StdULogicVector (arg));
--  END FUNCTION xor;
--  -------------------------------------------------------------------
--  FUNCTION xor ( arg : std_ulogic_vector ) RETURN std_ulogic IS
--    variable Upper, Lower : std_ulogic;
--    variable Half : integer;
--    variable BUS_int : std_ulogic_vector ( arg'length - 1 downto 0 );
--    variable Result : std_ulogic := '0';    -- In the case of a NULL range
--  BEGIN
--    if (arg'LENGTH >= 1) then
--      BUS_int := to_ux01 (arg);
--      if ( BUS_int'length = 1 ) then
--        Result := BUS_int ( BUS_int'left );
--      elsif ( BUS_int'length = 2 ) then
--        Result := "xor" (BUS_int(BUS_int'right), BUS_int(BUS_int'left));
--      else
--        Half := ( BUS_int'length + 1 ) / 2 + BUS_int'right;
--        Upper := xor ( BUS_int ( BUS_int'left downto Half ));
--        Lower := xor ( BUS_int ( Half - 1 downto BUS_int'right ));
--        Result := "xor" (Upper, Lower);
--      end if;
--    end if;
--    return Result;
--  END FUNCTION xor;

--  -------------------------------------------------------------------
--  -- xnor
--  -------------------------------------------------------------------
--  FUNCTION xnor ( arg : std_logic_vector ) RETURN std_ulogic IS
--  BEGIN
--    RETURN "not"(xor(To_StdULogicVector(arg)));
--  END FUNCTION xnor;
--  -------------------------------------------------------------------
--  FUNCTION xnor ( arg : std_ulogic_vector ) RETURN std_ulogic IS
--  BEGIN
--    RETURN "not"(xor(arg));
--  END FUNCTION xnor;
  ----------------------------------------------------------------------------
  -- %%% Remove the following funcitons (new syntax is above)
  ----------------------------------------------------------------------------
  -------------------------------------------------------------------
  -- and
  -------------------------------------------------------------------
  FUNCTION and_reduce ( arg : std_logic_vector ) RETURN std_ulogic IS
  BEGIN
    RETURN and_reduce (to_StdULogicVector (arg));
  END FUNCTION and_reduce;
  -------------------------------------------------------------------
  FUNCTION and_reduce ( arg : std_ulogic_vector ) RETURN std_ulogic IS
    variable Upper, Lower : std_ulogic;
    variable Half : integer;
    variable BUS_int : std_ulogic_vector ( arg'length - 1 downto 0 );
    variable Result : std_ulogic := '1';    -- In the case of a NULL range
  BEGIN
    if (arg'LENGTH >= 1) then
      BUS_int := to_ux01 (arg);
      if ( BUS_int'length = 1 ) then
        Result := BUS_int ( BUS_int'left );
      elsif ( BUS_int'length = 2 ) then
        Result := "and" (BUS_int(BUS_int'right),BUS_int(BUS_int'left));
      else
        Half := ( BUS_int'length + 1 ) / 2 + BUS_int'right;
        Upper := and_reduce ( BUS_int ( BUS_int'left downto Half ));
        Lower := and_reduce ( BUS_int ( Half - 1 downto BUS_int'right ));
        Result := "and" (Upper, Lower);
      end if;
    end if;
    return Result;
  END FUNCTION and_reduce;

  -------------------------------------------------------------------
  -- nand
  -------------------------------------------------------------------
  FUNCTION nand_reduce ( arg : std_logic_vector ) RETURN std_ulogic IS
  BEGIN
    RETURN "not"(and_reduce(to_StdULogicVector(arg)));
  END FUNCTION nand_reduce;
  -------------------------------------------------------------------
  FUNCTION nand_reduce ( arg : std_ulogic_vector ) RETURN std_ulogic IS
  BEGIN
    RETURN "not"(and_reduce(arg));
  END FUNCTION nand_reduce;

  -------------------------------------------------------------------
  -- or
  -------------------------------------------------------------------
  FUNCTION or_reduce ( arg : std_logic_vector ) RETURN std_ulogic IS
  BEGIN
    RETURN or_reduce (to_StdULogicVector (arg));
  END FUNCTION or_reduce;
  -------------------------------------------------------------------
  FUNCTION or_reduce ( arg : std_ulogic_vector ) RETURN std_ulogic IS
    variable Upper, Lower : std_ulogic;
    variable Half : integer;
    variable BUS_int : std_ulogic_vector ( arg'length - 1 downto 0 );
    variable Result : std_ulogic := '0';    -- In the case of a NULL range
  BEGIN
    if (arg'LENGTH >= 1) then
      BUS_int := to_ux01 (arg);
      if ( BUS_int'length = 1 ) then
        Result := BUS_int ( BUS_int'left );
      elsif ( BUS_int'length = 2 ) then
        Result := "or" (BUS_int(BUS_int'right), BUS_int(BUS_int'left));
      else
        Half := ( BUS_int'length + 1 ) / 2 + BUS_int'right;
        Upper := or_reduce ( BUS_int ( BUS_int'left downto Half ));
        Lower := or_reduce ( BUS_int ( Half - 1 downto BUS_int'right ));
        Result := "or" (Upper, Lower);
      end if;
    end if;
    return Result;
  END FUNCTION or_reduce;

  -------------------------------------------------------------------
  -- nor
  -------------------------------------------------------------------
  FUNCTION nor_reduce ( arg : std_logic_vector ) RETURN std_ulogic IS
  BEGIN
    RETURN "not"(or_reduce(To_StdULogicVector(arg)));
  END FUNCTION nor_reduce;
  -------------------------------------------------------------------
  FUNCTION nor_reduce ( arg : std_ulogic_vector ) RETURN std_ulogic IS
  BEGIN
    RETURN "not"(or_reduce(arg));
  END FUNCTION nor_reduce;

  -------------------------------------------------------------------
  -- xor
  -------------------------------------------------------------------
  FUNCTION xor_reduce ( arg : std_logic_vector ) RETURN std_ulogic IS
  BEGIN
    RETURN xor_reduce (to_StdULogicVector (arg));
  END FUNCTION xor_reduce;
  -------------------------------------------------------------------
  FUNCTION xor_reduce ( arg : std_ulogic_vector ) RETURN std_ulogic IS
    variable Upper, Lower : std_ulogic;
    variable Half : integer;
    variable BUS_int : std_ulogic_vector ( arg'length - 1 downto 0 );
    variable Result : std_ulogic := '0';    -- In the case of a NULL range
  BEGIN
    if (arg'LENGTH >= 1) then
      BUS_int := to_ux01 (arg);
      if ( BUS_int'length = 1 ) then
        Result := BUS_int ( BUS_int'left );
      elsif ( BUS_int'length = 2 ) then
        Result := "xor" (BUS_int(BUS_int'right), BUS_int(BUS_int'left));
      else
        Half := ( BUS_int'length + 1 ) / 2 + BUS_int'right;
        Upper := xor_reduce ( BUS_int ( BUS_int'left downto Half ));
        Lower := xor_reduce ( BUS_int ( Half - 1 downto BUS_int'right ));
        Result := "xor" (Upper, Lower);
      end if;
    end if;
    return Result;
  END FUNCTION xor_reduce;

  -------------------------------------------------------------------
  -- xnor
  -------------------------------------------------------------------
  FUNCTION xnor_reduce ( arg : std_logic_vector ) RETURN std_ulogic IS
  BEGIN
    RETURN "not"(xor_reduce(To_StdULogicVector(arg)));
  END FUNCTION xnor_reduce;
  -------------------------------------------------------------------
  FUNCTION xnor_reduce ( arg : std_ulogic_vector ) RETURN std_ulogic IS
  BEGIN
    RETURN "not"(xor_reduce(arg));
  END FUNCTION xnor_reduce;
  -- %%% End "remove the following functions"
  
  -- Function from Proposal FT18
  function "and"  (L: std_ulogic; R: boolean) return std_ulogic is
  begin
    if R then
      return to_X01(L);
    else
      return '0';
    end if;
  end function "and";
  function "and"  (L: boolean; R: std_ulogic) return std_ulogic is
  begin
    if L then
      return to_X01(R);
    else
      return '0';
    end if;
  end function "and";
  function "or"   (L: std_ulogic; R: boolean) return std_ulogic is
  begin
    if R then
      return '1';
    else
      return to_X01(L);
    end if;
  end function "or";
  function "or"   (L: boolean; R: std_ulogic) return std_ulogic is
  begin
    if L then
      return '1';
    else
      return to_X01(R);
    end if;
  end function "or";
  function "xor"  (L: std_ulogic; R: boolean) return std_ulogic is
  begin
    if R then
      return not to_X01(L);
    else
      return to_X01(L);
    end if;
  end function "xor";
  function "xor"  (L: boolean; R: std_ulogic) return std_ulogic is
  begin
    if L then
      return not to_X01(R);
    else
      return to_X01(R);
    end if;
  end function "xor";
  function "nand" (L: std_ulogic; R: boolean) return std_ulogic is
  begin
    if R then
      return not to_X01(L);
    else
      return '1';
    end if;
  end function "nand";
  function "nand" (L: boolean; R: std_ulogic) return std_ulogic is
  begin
    if L then
      return not to_X01(R);
    else
      return '1';
    end if;
  end function "nand";
  function "nor"  (L: std_ulogic; R: boolean) return std_ulogic is
  begin
    if R then
      return '0';
    else
      return not to_X01(L);
    end if;
  end function "nor";
  function "nor"  (L: boolean; R: std_ulogic) return std_ulogic is
  begin
    if L then
      return '0';
    else
      return not to_X01(R);
    end if;
  end function "nor";
  function "xnor" (L: std_ulogic; R: boolean) return std_ulogic is
  begin
    if R then
      return to_X01(L);
    else
      return not to_X01(L);
    end if;
  end function "xnor";
  function "xnor" (L: boolean; R: std_ulogic) return std_ulogic is
  begin
    if L then
      return to_X01(R);
    else
      return not to_X01(R);
    end if;
  end function "xnor";

    -- Used internally by the ?= operators
  function find_msb (
    arg : STD_ULOGIC_VECTOR;            -- vector argument
    y   : STD_ULOGIC)                   -- look for this bit
    return INTEGER is
    alias xarg : STD_ULOGIC_VECTOR(arg'length-1 downto 0) is arg;
  begin
    for_loop : for i in xarg'range loop
      if xarg(i) = y then
        return i;
      end if;
    end loop;
    return -1;
  end function find_msb;

  function find_msb (
    arg : STD_LOGIC_VECTOR;             -- vector argument
    y   : STD_ULOGIC)                   -- look for this bit
    return INTEGER is
  begin
    return find_msb (STD_ULOGIC_VECTOR (arg), y);
  end function find_msb;

  -- 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_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 lx, rx : STD_LOGIC_VECTOR (l'range);
  begin
    if ((l'length < 1) or (r'length < 1)) then
      report "STD_LOGIC_1164.""?>"": null detected, returning X"
        severity warning;
      return 'X';
    elsif lv'length /= rv'length then
      report "STD_LOGIC_1164.""?>"": L'LENGTH /= R'LENGTH, returning X"
        severity warning;
      return 'X';
    elsif (find_msb (l, '-') /= -1) or (find_msb (r, '-') /= -1) then
      report "STD_LOGIC_1164.""?>"": '-' found in compare string"
        severity error;
      return 'X';
    else
      lx := to_x01(lv);
      rx := to_x01(rv);
      if is_x(lx) or is_x(rx) 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_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 lx, rx : STD_ULOGIC_VECTOR (l'range);
  begin
    if ((l'length < 1) or (r'length < 1)) then
      report "STD_LOGIC_1164.""?>"": null detected, returning X"
        severity warning;
      return 'X';
    elsif lv'length /= rv'length then
      report "STD_LOGIC_1164.""?>"": L'LENGTH /= R'LENGTH, returning X"
        severity warning;
      return 'X';
    elsif (find_msb (l, '-') /= -1) or (find_msb (r, '-') /= -1) then
      report "STD_LOGIC_1164.""?>"": '-' found in compare string"
        severity error;
      return 'X';
    else
      lx := to_x01(lv);
      rx := to_x01(rv);
      if is_x(lx) or is_x(rx) 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_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 lx, rx : STD_LOGIC_VECTOR (l'range);
  begin
    if ((l'length < 1) or (r'length < 1)) then
      report "STD_LOGIC_1164.""?>="": null detected, returning X"
        severity warning;
      return 'X';
    elsif lv'length /= rv'length then
      report "STD_LOGIC_1164.""?>="": L'LENGTH /= R'LENGTH, returning X"
        severity warning;
      return 'X';
    elsif (find_msb (l, '-') /= -1) or (find_msb (r, '-') /= -1) then
      report "STD_LOGIC_1164.""?>="": '-' found in compare string"
        severity error;
      return 'X';
    else
      lx := to_x01(lv);
      rx := to_x01(rv);
      if is_x(lx) or is_x(rx) 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_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 lx, rx : STD_ULOGIC_VECTOR (l'range);
  begin
    if ((l'length < 1) or (r'length < 1)) then
      report "STD_LOGIC_1164.""?>="": null detected, returning X"
        severity warning;
      return 'X';
    elsif lv'length /= rv'length then
      report "STD_LOGIC_1164.""?>="": L'LENGTH /= R'LENGTH, returning X"
        severity warning;
      return 'X';
    elsif (find_msb (l, '-') /= -1) or (find_msb (r, '-') /= -1) then
      report "STD_LOGIC_1164.""?>="": '-' found in compare string"
        severity error;
      return 'X';
    else
      lx := to_x01(lv);
      rx := to_x01(rv);
      if is_x(lx) or is_x(rx) 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_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 lx, rx : STD_LOGIC_VECTOR (l'range);
  begin
    if ((l'length < 1) or (r'length < 1)) then
      report "STD_LOGIC_1164.""?<"": null detected, returning X"
        severity warning;
      return 'X';
    elsif lv'length /= rv'length then
      report "STD_LOGIC_1164.""?<"": L'LENGTH /= R'LENGTH, returning X"
        severity warning;
      return 'X';
    elsif (find_msb (l, '-') /= -1) or (find_msb (r, '-') /= -1) then
      report "STD_LOGIC_1164.""?<"": '-' found in compare string"
        severity error;
      return 'X';
    else
      lx := to_x01(lv);
      rx := to_x01(rv);
      if is_x(lx) or is_x(rx) 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_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 lx, rx : STD_ULOGIC_VECTOR (l'range);
  begin
    if ((l'length < 1) or (r'length < 1)) then
      report "STD_LOGIC_1164.""?<"": null detected, returning X"
        severity warning;
      return 'X';
    elsif lv'length /= rv'length then
      report "STD_LOGIC_1164.""?<"": L'LENGTH /= R'LENGTH, returning X"
        severity warning;
      return 'X';
    elsif (find_msb (l, '-') /= -1) or (find_msb (r, '-') /= -1) then
      report "STD_LOGIC_1164.""?<"": '-' found in compare string"
        severity error;
      return 'X';
    else
      lx := to_x01(lv);
      rx := to_x01(rv);
      if is_x(lx) or is_x(rx) 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_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 lx, rx : STD_LOGIC_VECTOR (l'range);
  begin
    if ((l'length < 1) or (r'length < 1)) then
      report "STD_LOGIC_1164.""?<="": null detected, returning X"
        severity warning;
      return 'X';
    elsif lv'length /= rv'length then
      report "STD_LOGIC_1164.""?<="": L'LENGTH /= R'LENGTH, returning X"
        severity warning;
      return 'X';
    elsif (find_msb (l, '-') /= -1) or (find_msb (r, '-') /= -1) then
      report "STD_LOGIC_1164.""?<="": '-' found in compare string"
        severity error;
      return 'X';
    else
      lx := to_x01(lv);
      rx := to_x01(rv);
      if is_x(lx) or is_x(rx) 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_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 lx, rx : STD_ULOGIC_VECTOR (l'range);
  begin
    if ((l'length < 1) or (r'length < 1)) then
      report "STD_LOGIC_1164.""?<="": null detected, returning X"
        severity warning;
      return 'X';
    elsif lv'length /= rv'length then
      report "STD_LOGIC_1164.""?<="": L'LENGTH /= R'LENGTH, returning X"
        severity warning;
      return 'X';
    elsif (find_msb (l, '-') /= -1) or (find_msb (r, '-') /= -1) then
      report "STD_LOGIC_1164.""?<="": '-' found in compare string"
        severity error;
      return 'X';
    else
      lx := to_x01(lv);
      rx := to_x01(rv);
      if is_x(lx) or is_x(rx) 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

  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"
    loop                                -- skip white space
      read(l, c, readOk);               -- but also exit on a bad read
      exit when (readOk = FALSE) or ((c /= ' ') and (c /= NBSP) and (c /= HT));
    end loop;
    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 s    : string(1 to VALUE'length-1);
    variable mv   : STD_ULOGIC_VECTOR(0 to VALUE'length-1);
    variable readOk : BOOLEAN;
  begin
    VALUE (VALUE'range) := (others => 'U');           -- initialize to a "U"
    loop                                -- skip white space
      read(L, c, readOk);
      exit when (readOk = FALSE) or ((c /= ' ') and (c /= NBSP) and (c /= HT));
    end loop;
    -- Bail out if there was a bad read
    if not readOk then
      good := FALSE;
      return;
    end if;
    if char_to_MVL9plus(c) = ERROR then
      good  := FALSE;
      return;
    end if;
    read(L, s, readOk);
    -- Bail out if there was a bad read
    if not readOk then
      good := FALSE;
      return;
    end if;
    for i in 1 to VALUE'length-1 loop
      if char_to_MVL9plus(s(i)) = ERROR then
        good  := FALSE;
        return;
      end if;
    end loop;
    mv(0) := char_to_MVL9(c);
    for i in 1 to VALUE'length-1 loop
      mv(i) := char_to_MVL9(s(i));
    end loop;
    VALUE := mv;
    good  := TRUE;
  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"
    loop                                -- skip white space
      read(l, c, readOk);
      exit when (readOk = FALSE) or ((c /= ' ') and (c /= NBSP) and (c /= HT));
    end loop;
    if not readOk then
      report "STD_LOGIC_1164.READ(STD_ULOGIC) "
        & "Error 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 s    : string(1 to VALUE'length-1);
    variable mv   : STD_ULOGIC_VECTOR(0 to VALUE'length-1);
  begin
    VALUE (VALUE'range) := (others => 'U');           -- initialize to a "U"
    loop                                -- skip white space
      read(L, c, readOk);
      exit when (readOk = FALSE) or ((c /= ' ') and (c /= NBSP) and (c /= HT));
    end loop;
    if readOk = false then            -- Bail out if there was a bad read
      report "STD_LOGIC_1164.READ(STD_ULOGIC_VECTOR) "
        & "Error end of string encountered"
        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;
    end if;
    read(L, s, readOk);
    if readOk then
    for i in 1 to VALUE'length-1 loop
      if char_to_MVL9plus(s(i)) = ERROR then
        report
          "STD_LOGIC_1164.READ(STD_ULOGIC_VECTOR) Error: Character '" &
          s(i) & "' read, expected STD_ULOGIC literal."
          severity error;
        return;
      end if;
    end loop;
    else
     report "STD_LOGIC_1164.READ(STD_ULOGIC_VECTOR) "
        & "Error end of string encountered"
        severity error;
      return;
    end if;
    mv(0) := char_to_MVL9(c);
    for i in 1 to VALUE'length-1 loop
      mv(i) := char_to_MVL9(s(i));
    end loop;
    VALUE := mv;
  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 m    : STD_LOGIC;
    variable c    : character;
    variable s    : string(1 to VALUE'length-1);
    variable mv   : STD_LOGIC_VECTOR(0 to VALUE'length-1);
    variable readOk : BOOLEAN;
  begin
    VALUE (VALUE'range) := (others => 'U');           -- initialize to a "U"
    loop                                -- skip white space
      read(L, c, readOk);
      exit when (readOk = FALSE) or ((c /= ' ') and (c /= NBSP) and (c /= HT));
    end loop;
    -- Bail out if there was a bad read
    if not readOk then
      good := FALSE;
      return;
    end if;
    if char_to_MVL9plus(c) = ERROR then
      good  := FALSE;
      return;
    end if;
    read(L, s, readOk);
    -- Bail out if there was a bad read
    if not readOk then
      good := FALSE;
      return;
    end if;
    for i in 1 to VALUE'length-1 loop
      if char_to_MVL9plus(s(i)) = ERROR then
        good  := FALSE;
        return;
      end if;
    end loop;
    mv(0) := char_to_MVL9(c);
    for i in 1 to VALUE'length-1 loop
      mv(i) := char_to_MVL9(s(i));
    end loop;
    VALUE := mv;
    good  := TRUE;
  end procedure READ;

  procedure READ (L : inout LINE; VALUE : out STD_LOGIC_VECTOR) is
    variable m    : STD_LOGIC;
    variable c    : character;
    variable readOk : BOOLEAN;
    variable s    : string(1 to VALUE'length-1);
    variable mv   : STD_LOGIC_VECTOR(0 to VALUE'length-1);
  begin
    VALUE (VALUE'range) := (others => 'U');           -- initialize to a "U"
    loop                                -- skip white space
      read(L, c, readOk);
      exit when (readOk = FALSE) or ((c /= ' ') and (c /= NBSP) and (c /= HT));
    end loop;
    if readOk = false then            -- Bail out if there was a bad read
      report "STD_LOGIC_1164.READ(STD_LOGIC_VECTOR) "
        & "Error end of string encountered"
        severity error;
      return;
    elsif char_to_MVL9plus(c) = ERROR then
      report
        "STD_LOGIC_1164.READ(STD_LOGIC_VECTOR) Error: Character '" & 
        c & "' read, expected STD_ULOGIC literal."
        severity error;
      return;
    end if;
    read(L, s, readOk);
    if readOk then
      for i in 1 to VALUE'length-1 loop
        if (char_to_MVL9plus(s(i)) = ERROR) then
          report
            "STD_LOGIC_1164.READ(STD_LOGIC_VECTOR) Error: Character '" &
            s(i) & "' read, expected STD_ULOGIC literal."
            severity error;
          return;
        end if;
      end loop;
    else
      report "STD_LOGIC_1164.READ(STD_LOGIC_VECTOR) "
        & "Error end of string encountered"
        severity error;
      return;
    end if;
    mv(0) := char_to_MVL9(c);
    for i in 1 to VALUE'length-1 loop
      mv(i) := char_to_MVL9(s(i));
    end loop;
    VALUE := mv;
  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 Error: 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 s  : string(1 to ne-1);
  begin
    VALUE (VALUE'range) := (others => 'U');           -- initialize to a "U"
    loop                                -- skip white space
      read(L, c, ok);
      exit when (ok = FALSE) or ((c /= ' ') and (c /= NBSP) and (c /= HT));
    end loop;
    -- Bail out if there was a bad read
    if not ok then
      good := FALSE;
      return;
    end if;
    Char2QuadBits(c, sv(0 to 3), ok, FALSE);
    if not ok then
      good := FALSE;
      return;
    end if;
    read(L, s, ok);
    if not ok then
      good := FALSE;
      return;
    end if;
    for i in 1 to ne-1 loop
      Char2QuadBits(s(i), sv(4*i to 4*i+3), ok, FALSE);
      if not ok then
        good := FALSE;
        return;
      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;
  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 s  : string(1 to ne-1);
  begin
    VALUE (VALUE'range) := (others => 'U');           -- initialize to a "U"
    loop                                -- skip white space
      read(L, c, ok);
      exit when (ok = FALSE) or ((c /= ' ') and (c /= NBSP) and (c /= HT));
    end loop;
    -- Bail out if there was a bad read
    if not ok then
        report "STD_LOGIC_1164.HREAD Error: Failed skipping white space"
        severity error;
      return;
    end if;
    Char2QuadBits(c, sv(0 to 3), ok, TRUE);
    if not ok then
      return;
    end if;
    read(L, s, ok);
    if not ok then
        report "STD_LOGIC_1164.HREAD Error: Failed to read the STRING"
        severity error;
      return;
    end if;
    for i in 1 to ne-1 loop
      Char2QuadBits(s(i), sv(4*i to 4*i+3), ok, TRUE);
      if not ok then
        return;
      end if;
    end loop;
    if or_reduce (sv (0 to pad-1)) = '1' then  -- %%% replace with "or"
        report "STD_LOGIC_1164.HREAD Error: Vector truncated"
        severity error;
    else
      VALUE := sv (pad to sv'high);
    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 s  : string(1 to ne-1);
  begin
    VALUE (VALUE'range) := (others => 'U');           -- initialize to a "U"
    loop                                -- skip white space
      read(L, c, ok);
      exit when (ok = FALSE) or ((c /= ' ') and (c /= NBSP) and (c /= HT));
    end loop;
    -- Bail out if there was a bad read
    if not ok then
      good := FALSE;
      return;
    end if;
    Char2TriBits(c, sv(0 to 2), ok, FALSE);
    if not ok then
      good := FALSE;
      return;
    end if;
    read(L, s, ok);
    if not ok then
      good := FALSE;
      return;
    end if;
    for i in 1 to ne-1 loop
      Char2TriBits(s(i), sv(3*i to 3*i+2), ok, FALSE);
      if not ok then
        good := FALSE;
        return;
      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;
  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 s  : string(1 to ne-1);
  begin
    VALUE (VALUE'range) := (others => 'U');           -- initialize to a "U"
    loop                                -- skip white space
      read(L, c, ok);
      exit when (ok = FALSE) or ((c /= ' ') and (c /= NBSP) and (c /= HT));
    end loop;
    -- Bail out if there was a bad read
    if not ok then
      report "STD_LOGIC_1164.OREAD Error: Failed skipping white space"
        severity error;
      return;
    end if;
    Char2TriBits(c, sv(0 to 2), ok, TRUE);
    if not ok then
      return;
    end if;
    read(L, s, ok);
    if not ok then
      report "STD_LOGIC_1164.OREAD Error: Failed to read the STRING"
        severity error;
      return;
    end if;
    for i in 1 to ne-1 loop
      Char2TriBits(s(i), sv(3*i to 3*i+2), ok, TRUE);
      if not ok then
        return;
      end if;
    end loop;
    if or_reduce (sv (0 to pad-1)) = '1' then  -- %%% replace with "or"
      report "STD_LOGIC_1164.OREAD Error: Vector truncated"
        severity error;
    else
      VALUE := sv (pad to sv'high);
    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 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 s  : string(1 to ne-1);
  begin
    VALUE (VALUE'range) := (others => 'U');           -- initialize to a "U"
    loop                                -- skip white space
      read(l, c, ok);
      exit when (ok = FALSE) or ((c /= ' ') and (c /= NBSP) and (c /= HT));
    end loop;
    -- Bail out if there was a bad read
    if not ok then
      good := FALSE;
      return;
    end if;
    Char2QuadBits(c, sv(0 to 3), ok, FALSE);
    if not ok then
      good := FALSE;
      return;
    end if;
    read(L, s, ok);
    if not ok then
      good := FALSE;
      return;
    end if;
    for i in 1 to ne-1 loop
      Char2QuadBits(s(i), sv(4*i to 4*i+3), ok, FALSE);
      if not ok then
        good := FALSE;
        return;
      end if;
    end loop;
    if or_reduce (sv (0 to pad-1)) = '1' then  -- %%% replace with "or"
      good := false;                    -- vector was truncated.
    else
      VALUE := to_stdlogicvector(sv (pad to sv'high));
      good := true;
    end if;
  end procedure HREAD;

  procedure HREAD (L : inout LINE; VALUE : out STD_LOGIC_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 s  : string(1 to ne-1);
  begin
    VALUE (VALUE'range) := (others => 'U');   -- initialize to a "U"
    loop                                -- skip white space
      read(l, c, ok);
      exit when (ok = FALSE) or ((c /= ' ') and (c /= NBSP) and (c /= HT));
    end loop;
    -- Bail out if there was a bad read
    if not ok then
      report "STD_LOGIC_1164.HREAD Error: Failed skipping white space"
        severity error;
      return;
    end if;
    Char2QuadBits(c, sv(0 to 3), ok, TRUE);
    if not ok then
      return;
    end if;
    read(L, s, ok);
    if not ok then
      report "STD_LOGIC_1164.HREAD Error: Failed to read the STRING"
        severity error;
      return;
    end if;
    for i in 1 to ne-1 loop
      Char2QuadBits(s(i), sv(4*i to 4*i+3), ok, TRUE);
      if not ok then
        return;
      end if;
    end loop;
    VALUE := to_stdlogicvector(sv (pad to sv'high));
    if or_reduce (sv (0 to pad-1)) = '1' then  -- %%% replace with "or"
      report "STD_LOGIC_1164.HREAD Error: Vector truncated"
        severity error;
    end if;
  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 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 s  : string(1 to ne-1);
  begin
    VALUE (VALUE'range) := (others => 'U');           -- initialize to a "U"
    loop                                -- skip white space
      read(L, c, ok);
      exit when (ok = FALSE) or ((c /= ' ') and (c /= NBSP) and (c /= HT));
    end loop;
    -- Bail out if there was a bad read
    if not ok then
      good := FALSE;
      return;
    end if;
    Char2TriBits(c, sv(0 to 2), ok, FALSE);
    if not ok then
      good := FALSE;
      return;
    end if;
    read(L, s, ok);
    if not ok then
      good := FALSE;
      return;
    end if;
    for i in 1 to ne-1 loop
      Char2TriBits(s(i), sv(3*i to 3*i+2), ok, FALSE);
      if not ok then
        good := FALSE;
        return;
      end if;
    end loop;
    VALUE := to_stdlogicvector (sv (pad to sv'high));
    if or_reduce (sv (0 to pad-1)) = '1' then -- %%% replace with "or"
      good := false;                    -- vector was truncated.
    else
      good := true;
    end if;
  end procedure OREAD;

  procedure OREAD (L : inout LINE; VALUE : out STD_LOGIC_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 s  : string(1 to ne-1);
  begin
    VALUE (VALUE'range) := (others => 'U');           -- initialize to a "U"
    loop                                -- skip white space
      read(L, c, ok);
      exit when (ok = FALSE) or ((c /= ' ') and (c /= NBSP) and (c /= HT));
    end loop;
    -- Bail out if there was a bad read
    if not ok then
      report "STD_LOGIC_1164.OREAD Error: Failed skipping white space"
        severity error;
      return;
    end if;
    Char2TriBits(c, sv(0 to 2), ok, TRUE);
    if not ok then
      return;
    end if;
    read(L, s, ok);
    if not ok then
      report "STD_LOGIC_1164.OREAD Error: Failed to read the STRING"
        severity error;
      return;
    end if;
    for i in 1 to ne-1 loop
      Char2TriBits(s(i), sv(3*i to 3*i+2), ok, TRUE);
      if not ok then
        return;
      end if;
    end loop;
    VALUE := to_stdlogicvector (sv (pad to sv'high));
    if or_reduce (sv (0 to pad-1)) = '1' then -- %%% replace with "or"
      report "STD_LOGIC_1164.OREAD Error: Vector truncated"
        severity error;
    end if;
  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 justify (
    value     : STRING;
    justified : SIDE  := right;
    field     : width := 0)
    return STRING is
    constant VAL_LEN : INTEGER             := value'length;
    variable result  : STRING (1 to field) := (others => ' ');
  begin  -- function justify
    -- return value if field is too small
    if VAL_LEN >= field then
      return value;
    end if;
    if justified = left then
      result(1 to VAL_LEN) := value;
    elsif justified = right then
      result(field - VAL_LEN + 1 to field) := value;
    end if;
    return result;
  end function justify;

  -----------------------------------------------------------------------------
  -- New string functions for vhdl-200x fast track
  -----------------------------------------------------------------------------
  function to_string (
    value     : in STD_ULOGIC;
    justified : in side  := RIGHT;
    field     : in width := 0
    ) return STRING is
    variable result : STRING (1 to 1);
  begin
    result (1) := MVL9_to_char (value);
    return justify (result, justified, field);
  end function to_string;
  -------------------------------------------------------------------    
  -- TO_STRING (an alias called "to_bstring" is provide)
  -------------------------------------------------------------------   
  function to_string (
    value     : in std_ulogic_vector;
    justified : in side  := RIGHT;
    field     : in width := 0
    ) 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 justify(result, justified, field);
    end if;
  end function to_string;

  -------------------------------------------------------------------    
  -- TO_HSTRING
  -------------------------------------------------------------------   
  function to_hstring (
    value     : in std_ulogic_vector;
    justified : in side  := RIGHT;
    field     : in width := 0
    ) 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 justify(result, justified, field);
    end if;
  end function to_hstring;

  -------------------------------------------------------------------    
  -- TO_OSTRING
  -------------------------------------------------------------------   
  function to_ostring (
    value     : in std_ulogic_vector;
    justified : in side  := RIGHT;
    field     : in width := 0
    ) 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 justify(result, justified, field);
    end if;
  end function to_ostring;

  function to_string (
    value     : in std_logic_vector;
    justified : in side  := RIGHT;
    field     : in width := 0
    ) return string is
  begin
    return to_string (to_stdulogicvector (value), justified, field);
  end function to_string;

  function to_hstring (
    value     : in std_logic_vector;
    justified : in side  := RIGHT;
    field     : in width := 0
    ) return string is
  begin
    return to_hstring (to_stdulogicvector (value), justified, field);
  end function to_hstring;

  function to_ostring (
    value     : in std_logic_vector;
    justified : in side  := RIGHT;
    field     : in width := 0
    ) return string  is
  begin
    return to_ostring (to_stdulogicvector (value), justified, field);
  end function to_ostring;

  -----------------------------------------------------------------------
  -- Alias for bread and bwrite are provided with call out the read and
  -- write functions.
  -----------------------------------------------------------------------
  function to_bstring (
    value     : in std_ulogic_vector;
    justified : in side  := RIGHT;
    field     : in width := 0
    ) return STRING is
  begin
    return to_string (value, justified, field);
  end function to_bstring;

  function to_bstring (
    value     : in std_logic_vector;
    justified : in side  := RIGHT;
    field     : in width := 0
    ) return STRING is
  begin
    return to_string (value, justified, field);
  end function to_bstring;

  procedure BREAD (L : inout LINE; VALUE : out STD_ULOGIC; GOOD : out BOOLEAN)
    is
  begin
    READ (L, VALUE, GOOD);
  end procedure BREAD;
  procedure BREAD (L : inout LINE; VALUE : out STD_ULOGIC)
    is
  begin
    READ (L, VALUE);
  end procedure BREAD;

  procedure BREAD (L : inout LINE; VALUE : out STD_ULOGIC_VECTOR; GOOD : out BOOLEAN)
    is
  begin
    READ (L, VALUE, GOOD);
  end procedure BREAD;
  procedure BREAD (L : inout LINE; VALUE : out STD_ULOGIC_VECTOR)
    is
  begin
    READ (L, VALUE);
  end procedure BREAD;
  procedure BREAD (L : inout LINE; VALUE : out STD_LOGIC_VECTOR; GOOD : out BOOLEAN)
    is
  begin
    READ (L, VALUE, GOOD);
  end procedure BREAD;
  procedure BREAD (L : inout LINE; VALUE : out STD_LOGIC_VECTOR)
    is
  begin
    READ (L, VALUE);
  end procedure BREAD;
  procedure BWRITE (L : inout LINE; VALUE : in STD_ULOGIC;
  JUSTIFIED          : in    SIDE := RIGHT; FIELD : in WIDTH := 0)
    is
  begin
    WRITE (L, VALUE, JUSTIFIED, FIELD);
  end procedure BWRITE;

  procedure BWRITE (L : inout LINE; VALUE : in STD_ULOGIC_VECTOR;
  JUSTIFIED          : in    SIDE := RIGHT; FIELD : in WIDTH := 0)
    is
  begin
    WRITE (L, VALUE, JUSTIFIED, FIELD);
  end procedure BWRITE;
  procedure BWRITE (L : inout LINE; VALUE : in STD_LOGIC_VECTOR;
  JUSTIFIED          : in    SIDE := RIGHT; FIELD : in WIDTH := 0)
    is
  begin
    WRITE (L, VALUE, JUSTIFIED, FIELD);
  end procedure BWRITE;
  -- rtl_synthesis on
end package body std_logic_1164_additions;
