Subversion Repositories mips_enhanced

--------------------------------------------------------------------------------

--  File Name: conversions_p.vhd

--------------------------------------------------------------------------------

--  Copyright (C) 1997, 1998, 2001 Free Model Foundry; http://eda.org/fmf/

-- 

--  This program is free software; you can redistribute it and/or modify

--  it under the terms of the GNU General Public License version 2 as

--  published by the Free Software Foundation.

-- 

--  This package was written by SEVA Technologies, Inc. and donated to the FMF.

--  www.seva.com

--

--  MODIFICATION HISTORY:

-- 

--  version: |  author:  | mod date: | changes made:

--    V1.0     R. Steele   97 DEC 05   Added header and formatting to SEVA file

--    V1.1     R. Munden   98 NOV 28   Corrected some comments

--                                     Corrected function b

--    V1.2     R. Munden   01 MAY 27   Corrected function to_nat for weak values

--                                     and combined into a single file

-- 

--------------------------------------------------------------------------------

LIBRARY IEEE;   USE IEEE.std_logic_1164.ALL;

--------------------------------------------------------------------------------

--  CONVERSION FUNCTION SELECTION TABLES

--------------------------------------------------------------------------------

-- 

--  FROM         TO: std_logic_vector std_logic  natural     time     string

--  -----------------|---------------|---------|---------|---------|-----------

--  std_logic_vector |      N/A      |   N/A   |  to_nat | combine | see below

--  std_logic        |      N/A      |   N/A   |  to_nat | combine | see below

--  natural          |     to_slv    |  to_sl  |   N/A   | to_time | see below

--  time             |      N/A      |   N/A   |  to_nat | N/A     | to_time_str

--  hex string       |       h       |   N/A   |    h    | combine | N/A

--  decimal string   |       d       |   N/A   |    d    | combine | N/A

--  octal string     |       o       |   N/A   |    o    | combine | N/A

--  binary string    |       b       |   N/A   |    b    | combine | N/A

--  -----------------|---------------|---------|---------|---------|-----------

--

--  FROM           TO: hex string decimal string octal string  binary string 

--  -----------------|------------|-------------|------------|----------------

--  std_logic_vector | to_hex_str | to_int_str  | to_oct_str |  to_bin_str

--  std_logic        |    N/A     |    N/A      |    N/A     |  to_bin_str

--  natural          | to_hex_str | to_int_str  | to_oct_str |  to_bin_str

--  -----------------|------------|-------------|------------|----------------

-- 

--------------------------------------------------------------------------------

PACKAGE conversions IS

    ----------------------------------------------------------------------------

    -- the conversions in this package are not guaranteed to be synthesizable.

    --

    -- others functions available

    -- fill         creates a variable length string of the fill character

    --

    -- 

    --

    -- input parameters of type natural or integer can be in the form:

    --    normal              -> 8, 99, 4_237

    --    base#value#         -> 2#0101#, 16#fa4C#,  8#6_734#

    --    with exponents(x10) -> 8e4, 16#2e#E4

    --

    -- input parameters of type string can be in the form:

    --    "99", "4_237", "0101", "1010_1010"

    --

    -- for bit/bit_vector <-> std_logic/std_logic_vector conversions use 

    --   package std_logic_1164

    --     to_bit(std_logic)

    --     to_bitvector(std_logic_vector)

    --     to_stdlogic(bit)

    --     to_stdlogicvector(bit_vector)

    --

    -- for "synthesizable" signed/unsigned/std_logic_vector/integer

    -- conversions use

    --   package std_logic_arith 

    --     conv_integer(signed/unsigned)

    --     conv_unsigned(integer/signed,size)

    --     conv_signed(integer/unsigned,size)

    --     conv_std_logic_vector(integer/signed/unsigned,size)

    --

    -- for "synthesizable" std_logic_vector -> integer conversions use

    --   package std_logic_unsigned/std_logic_signed

    --            <these packages are mutually exclusive>

    --     conv_integer(std_logic_vector)

    --            <except for this conversion, these packages are unnecessary)

    --     to minimize compile problems write:

    --       use std_logic_unsigned.conv_integer;

    --       use std_logic_signed.conv_integer;

    --

    -- std_logic_vector, signed and unsigned types are "closely related"

    -- no type conversion functions are needed, use type casting or qualified

    -- expressions

    --

    --   type1(object of type2)          <type casting>

    --   type1'(expression of type2)     <qualified expression>

    --

    -- most conversions have 4 parmeters:

    --   x         : value to be converted 

    --   rtn_len   : size of the return value

    --   justify   : justify value 'left' or 'right', default is right

    --   basespec  : print the base of the value - 'yes'/'no', default is yes

    --

    -- Typical ways to call these functions:

    --     simple, all defaults used

    --     to_bin_str(x)

    --         x will be converted to a string of minimum size with a 

    --           base specification appended for clarity

    --         if x is 10101 then return is b"10101" 

    --

    --   to control size of return string

    --     to_hex_str(x,                

    --                6)                

    --         length of string returned will be 6 characters

    --         value will be right justified in the field  

    --         if x is 10101 then return is ....h"15"

    --          where '.' represents a blank 

    --          if 'rtn_len' parm defaults or is set to 0 then

    --           return string will always be minimum size

    --

    --   to left justify and suppress base specification

    --     to_int_str(x,

    --                6,

    --                justify => left, 

    --                basespec => yes)

    --         length of return string will be 6 characters

    --         the base specification will be suppressed

    --         if x is 10101 then return is 21.... 

    --           where '.' represents a blank 

    --

    -- other usage notes

    --

    --   if rtn_len less than or equal to x'length then ignore 

    --      rtn_len and return string of x'length

    --   the 'justify' parm is effectively ignored in this case

    --

    --   if rtn_len greater than x'length then return string 

    --      of rtn_len with blanks based on 'justify' parm

    --

    -- these routines do not handle negative numbers

    ----------------------------------------------------------------------------

    type justify_side is (left, right);

    type b_spec       is (no  , yes);

    -- std_logic_vector to binary string

    function to_bin_str(x          : std_logic_vector;

                        rtn_len    : natural      := 0;

                        justify    : justify_side := right;

                        basespec   : b_spec       := yes)

      return string;

    -- std_logic to binary string

    function to_bin_str(x          : std_logic;

                        rtn_len    : natural      := 0;

                        justify    : justify_side := right;

                        basespec   : b_spec       := yes)

      return string;

    -- natural to binary string

    function to_bin_str(x          : natural;

                        rtn_len    : natural      := 0;

                        justify    : justify_side := right;

                        basespec   : b_spec       := yes)

      return string;

      -- see note above regarding possible formats for x

    -- std_logic_vector to hex string

    function to_hex_str(x          : std_logic_vector;

                        rtn_len    : natural      := 0;

                        justify    : justify_side := right;

                        basespec   : b_spec       := yes)

      return string;

    -- natural to hex string

    function to_hex_str(x          : natural;

                        rtn_len    : natural      := 0;

                        justify    : justify_side := right;

                        basespec   : b_spec       := yes)

      return string;

      -- see note above regarding possible formats for x

    -- std_logic_vector to octal string

    function to_oct_str(x          : std_logic_vector;

                        rtn_len    : natural      := 0;

                        justify    : justify_side := right;

                        basespec   : b_spec       := yes)

      return string;

    -- natural to octal string

    function to_oct_str(x          : natural;

                        rtn_len    : natural      := 0;

                        justify    : justify_side := right;

                        basespec   : b_spec       := yes)

      return string;

      -- see note above regarding possible formats for x

    -- natural to integer string

    function to_int_str(x          : natural;

                        rtn_len    : natural      := 0;

                        justify    : justify_side := right;

                        basespec   : b_spec       := yes)

      return string;

      -- see note above regarding possible formats for x

    -- std_logic_vector to integer string

    function to_int_str(x          : std_logic_vector;

                        rtn_len    : natural      := 0;

                        justify    : justify_side := right;

                        basespec   : b_spec       := yes)

      return string;

    -- time to string

    function to_time_str (x          : time)

      return string;

    -- add characters to a string

    function fill        (fill_char  : character    := '*';

                          rtn_len    : integer      := 1)

      return string;

      -- usage:

        -- fill

          -- returns *

        -- fill(' ',10)    

          -- returns ..........  when '.' represents a blank

        -- fill(lf) or fill(ht)  

          -- returns line feed character or tab character respectively

    -- std_logic_vector to natural

    function to_nat      (x        : std_logic_vector)

      return natural;

    -- std_logic to natural

    function to_nat      (x        : std_logic)

      return natural;

    -- time to natural

    function to_nat      (x        : time)

      return natural;

    -- hex string to std_logic_vector

    function h         (x          : string;

                        rtn_len    : positive range 1 to 32 := 32)

      return std_logic_vector;

    -- if rtn_len is < than x'length*4, result will be truncated on the left

    -- if x is other than characters 0 to 9 or a,A to f,F 

    --   or x,X,z,Z,u,U,-,w,W, result will be 0

    -- decimal string to std_logic_vector

    function d         (x          : string;

                        rtn_len    : positive range 1 to 32 := 32)

      return std_logic_vector;

    -- if rtn_len is < than x'length*4, result will be truncated on the left

    -- if x is other than characters 0 to 9 or x,X,z,Z,u,U,-,w,W,

    --   result will be 0

    -- octal string to std_logic_vector

    function o         (x          : string;

                        rtn_len    : positive range 1 to 32 := 32)

      return std_logic_vector;

    -- if rtn_len is < than x'length*4, result will be truncated on the left

    -- if x is other than characters 0 to 7 or x,X,z,Z,u,U,-,w,W,

    --   result will be 0

    -- binary string to std_logic_vector

    function b         (x          : string;

                        rtn_len    : positive range 1 to 32 := 32)

      return std_logic_vector;

    -- if rtn_len is < than x'length*4, result will be truncated on the left

    -- if x is other than characters 0 to 1 or x,X,z,Z,u,U,-,w,W, 

    --   result will be 0

    -- hex string to natural

    function h         (x          : string)

      return natural;

    -- if x is other than characters 0 to 9 or a,A to f,F, result will be 0

    -- decimal string to natural

    function d         (x          : string)

      return natural;

    -- if x is other than characters 0 to 9, result will be 0

    -- octal string to natural

    function o         (x          : string)

      return natural;

    -- if x is other than characters 0 to 7, result will be 0

    -- binary string to natural

    function b         (x          : string)

      return natural;

    -- if x is other than characters 0 to 1, result will be 0

    -- natural to std_logic_vector

    function to_slv    (x          : natural;

                        rtn_len    : positive range 1 to 32 := 32)

      return std_logic_vector;

      -- if rtn_len is < than sizeof(x), result will be truncated on the left

      -- see note above regarding possible formats for x

    -- natural to std_logic

    function to_sl     (x          : natural)

      return std_logic;

    -- natural to time

    function to_time   (x          : natural)

      return time;

      -- see note above regarding possible formats for x

END conversions;

-- 

--------------------------------------------------------------------------------

-- 

PACKAGE BODY conversions IS

    -- private declarations for this package 

    type basetype     is (binary, octal, decimal, hex);

    function max(x,y: integer) return integer is

    begin

      if x > y then return x; else return y; end if;

    end max;

    function min(x,y: integer) return integer is

    begin

      if x < y then return x; else return y; end if;

    end min;

    -- consider function sizeof for string/slv/???, return natural

    --  function size(len: natural) return natural is

    --  begin

    --    if len=0 then

    --      return 31;

    --    else return len;

    --    end if;

    --  end size;

      function nextmultof (x    : positive;

                           size : positive) return positive is

      begin

        case x mod size is

          when 0      => return size * x/size;

          when others => return size * (x/size + 1);

        end case;

      end nextmultof;

      function rtn_base (base : basetype) return character is

      begin

        case base is

          when binary  => return 'b';

          when octal   => return 'o';

          when decimal => return 'd';

          when hex     => return 'h';

        end case;

      end rtn_base;

      function format (r          : string;

                       base       : basetype;

                       rtn_len    : natural     ;

                       justify    : justify_side;

                       basespec   : b_spec) return string is

        variable int_rtn_len : integer;

      begin

        if basespec=yes then

          int_rtn_len := rtn_len - 3;

        else

          int_rtn_len := rtn_len;

        end if;

        if int_rtn_len <= r'length then

          case basespec is

            when no  => return r ;

            when yes => return rtn_base(base) & '"' & r & '"';

          end case;

        else

          case justify is

            when left  =>

              case basespec is

                when no  =>

                  return r & fill(' ',int_rtn_len - r'length);

                when yes  =>

                  return rtn_base(base) & '"' & r & '"' &

                         fill(' ',int_rtn_len - r'length);

              end case;

            when right =>

              case basespec is

                when no  =>

                  return fill(' ',int_rtn_len - r'length) & r ;

                when yes  =>

                  return fill(' ',int_rtn_len - r'length) &

                         rtn_base(base) & '"' & r & '"';

              end case;

          end case;

        end if;

      end format;

      -- convert numeric string of any base to natural

      function cnvt_base (x      : string;

                          inbase : natural range 2 to 16) return natural is

        -- assumes x is an unsigned number string of base 'inbase'

        -- values larger than natural'high are not supported

        variable r,t   : natural  := 0;

        variable place : positive := 1;

      begin

        for i in x'reverse_range loop

          case x(i) is

            when '0'     => t := 0;

            when '1'     => t := 1;

            when '2'     => t := 2;

            when '3'     => t := 3;

            when '4'     => t := 4;

            when '5'     => t := 5;

            when '6'     => t := 6;

            when '7'     => t := 7;

            when '8'     => t := 8;

            when '9'     => t := 9;

            when 'a'|'A' => t := 10;

            when 'b'|'B' => t := 11;

            when 'c'|'C' => t := 12;

            when 'd'|'D' => t := 13;

            when 'e'|'E' => t := 14;

            when 'f'|'F' => t := 15;

            when '_'     => t := 0;    -- ignore these characters

                            place := place / inbase;

            when others  =>

              assert false

                report lf &

                       "CNVT_BASE found input value larger than base: " & lf &

                       "Input value: " & x(i) &

                         " Base: " & to_int_str(inbase) & lf &

                       "converting input to integer 0"

                severity warning;

              return 0;

          end case;

          if t / inbase > 1 then       -- invalid value for base

            assert false

              report lf &

                     "CNVT_BASE found input value larger than base: " & lf &

                     "Input value: " & x(i) &

                       " Base: " & to_int_str(inbase) & lf &

                     "converting input to integer 0"

              severity warning;

            return 0;

          else

            r     := r + (t * place);

            place := place * inbase;

          end if;

        end loop;

        return r;

      end cnvt_base;

    function extend (x   : std_logic;

                     len : positive) return std_logic_vector is

      variable v : std_logic_vector(1 to len) := (others => x);

    begin

      return v;

    end extend;

    -- implementation of public declarations

    function to_bin_str(x          : std_logic_vector;

                        rtn_len    : natural      := 0;

                        justify    : justify_side := right;

                        basespec   : b_spec       := yes) return string is

      variable int : std_logic_vector(1 to x'length):=x;

      variable r   : string(1 to x'length):=(others=>'$');

    begin

      for i in int'range loop

        r(i to i) := to_bin_str(int(i),basespec=>no);

      end loop;

      return format (r,binary,rtn_len,justify,basespec);

    end to_bin_str;

    function to_bin_str(x          : std_logic;

                        rtn_len    : natural      := 0;

                        justify    : justify_side := right;

                        basespec   : b_spec       := yes) return string is

      variable r   : string(1 to 1);

    begin

        case x is

          when '0'    => r(1) := '0';

          when '1'    => r(1) := '1';

          when 'U'    => r(1) := 'U';

          when 'X'    => r(1) := 'X';

          when 'Z'    => r(1) := 'Z';

          when 'W'    => r(1) := 'W';

          when 'H'    => r(1) := 'H';

          when 'L'    => r(1) := 'L';

          when '-'    => r(1) := '-';

        end case;

      return format (r,binary,rtn_len,justify,basespec);

    end to_bin_str;

    function to_bin_str(x          : natural;

                        rtn_len    : natural      := 0;

                        justify    : justify_side := right;

                        basespec   : b_spec       := yes) return string is

      variable int : natural := x;

      variable ptr : positive range 2 to 32 := 32;

      variable r   : string(2 to 32):=(others=>'$');

    begin

      if int = 0 then

        return format ("0",binary,rtn_len,justify,basespec);

      end if;

      while int > 0 loop

        case int rem 2 is

          when 0 => r(ptr) := '0';

          when 1 => r(ptr) := '1';

          when others =>

            assert false report lf & "TO_BIN_STR, shouldn't happen"

            severity failure;

            return "$";

           null;

        end case;

        int := int / 2;

        ptr := ptr - 1;

      end loop;

      return format (r(ptr+1 to 32),binary,rtn_len,justify,basespec);

    end to_bin_str;

    function to_hex_str(x          : std_logic_vector;

                        rtn_len    : natural      := 0;

                        justify    : justify_side := right;

                        basespec   : b_spec       := yes) return string is

      -- will return x'length/4

      variable nxt : positive := nextmultof(x'length,4);

      variable int : std_logic_vector(1 to nxt):= (others => '0');

      variable ptr : positive range 1 to (nxt/4)+1 := 1;

      variable r   : string(1 to nxt/4):=(others=>'$');

      subtype slv4 is std_logic_vector(1 to 4);

    begin

      int(nxt-x'length+1 to nxt) := x;

      if nxt-x'length > 0 and x(x'left) /= '1' then

        int(1 to nxt-x'length) := extend(x(x'left),nxt-x'length);

      end if;

      for i in int'range loop

        next when i rem 4 /= 1;

        case slv4'(int(i to i+3)) is

          when "0000" => r(ptr) := '0';

          when "0001" => r(ptr) := '1';

          when "0010" => r(ptr) := '2';

          when "0011" => r(ptr) := '3';

          when "0100" => r(ptr) := '4';

          when "0101" => r(ptr) := '5';

          when "0110" => r(ptr) := '6';

          when "0111" => r(ptr) := '7';

          when "1000" => r(ptr) := '8';

          when "1001" => r(ptr) := '9';

          when "1010" => r(ptr) := 'A';

          when "1011" => r(ptr) := 'B';

          when "1100" => r(ptr) := 'C';

          when "1101" => r(ptr) := 'D';

          when "1110" => r(ptr) := 'E';

          when "1111" => r(ptr) := 'F';

          when "ZZZZ" => r(ptr) := 'Z';

          when "WWWW" => r(ptr) := 'W';

          when "LLLL" => r(ptr) := 'L';

          when "HHHH" => r(ptr) := 'H';

          when "UUUU" => r(ptr) := 'U';

          when "XXXX" => r(ptr) := 'X';

          when "----" => r(ptr) := '-';

          when others =>

            assert false

              report lf &

                     "TO_HEX_STR found illegal value: " &

                       to_bin_str(int(i to i+3)) & lf &

                     "converting input to '-'"

              severity warning;

            r(ptr) := '-';

        end case;

        ptr := ptr + 1;

      end loop;

      return format (r,hex,rtn_len,justify,basespec);

    end to_hex_str;

    function to_hex_str(x          : natural;

                        rtn_len    : natural      := 0;

                        justify    : justify_side := right;

                        basespec   : b_spec       := yes)     return string is

      variable int : natural := x;

      variable ptr : positive range 1 to 20 := 20;

      variable r   : string(1 to 20):=(others=>'$');

    begin

      if x=0 then return format ("0",hex,rtn_len,justify,basespec); end if;

      while int > 0 loop

        case int rem 16 is

          when 0  => r(ptr) := '0';

          when 1  => r(ptr) := '1';

          when 2  => r(ptr) := '2';

          when 3  => r(ptr) := '3';

          when 4  => r(ptr) := '4';

          when 5  => r(ptr) := '5';

          when 6  => r(ptr) := '6';

          when 7  => r(ptr) := '7';

          when 8  => r(ptr) := '8';

          when 9  => r(ptr) := '9';

          when 10 => r(ptr) := 'A';

          when 11 => r(ptr) := 'B';

          when 12 => r(ptr) := 'C';

          when 13 => r(ptr) := 'D';

          when 14 => r(ptr) := 'E';

          when 15 => r(ptr) := 'F';

          when others =>

            assert false report lf & "TO_HEX_STR, shouldn't happen"

            severity failure;

            return "$";

        end case;

        int := int / 16;

        ptr := ptr - 1;

      end loop;

      return format (r(ptr+1 to 20),hex,rtn_len,justify,basespec);

    end to_hex_str;

      function to_oct_str(x          : std_logic_vector;

                          rtn_len    : natural      := 0;

                          justify    : justify_side := right;

                          basespec   : b_spec       := yes) return string is

        -- will return x'length/3

        variable nxt : positive := nextmultof(x'length,3);

        variable int : std_logic_vector(1 to nxt):= (others => '0');

        variable ptr : positive range 1 to (nxt/3)+1 := 1;

        variable r   : string(1 to nxt/3):=(others=>'$');

        subtype slv3 is std_logic_vector(1 to 3);

      begin

        int(nxt-x'length+1 to nxt) := x;

        if nxt-x'length > 0 and x(x'left) /= '1' then

          int(1 to nxt-x'length) := extend(x(x'left),nxt-x'length);

        end if;

        for i in int'range loop

          next when i rem 3 /= 1;

          case slv3'(int(i to i+2)) is

            when "000" => r(ptr) := '0';

            when "001" => r(ptr) := '1';

            when "010" => r(ptr) := '2';

            when "011" => r(ptr) := '3';

            when "100" => r(ptr) := '4';

            when "101" => r(ptr) := '5';

            when "110" => r(ptr) := '6';