Subversion Repositories mips_enhanced

library ieee;

use ieee.std_logic_1164.all;

use std.textio.all;

package txt_util is

  -- prints a message to the screen

  procedure print(text : string);

  -- prints the message when active

  -- useful for debug switches

  procedure print(active : boolean; text : string);

  -- converts std_logic into a character

  function chr(sl : std_logic) return character;

  -- converts std_logic into a string (1 to 1)

  function str(sl : std_logic) return string;

  -- converts std_logic_vector into a string (binary base)

  function str(slv : std_logic_vector) return string;

  -- converts boolean into a string

  function str(b : boolean) return string;

  -- converts an integer into a single character

  -- (can also be used for hex conversion and other bases)

  function chr(int : integer) return character;

  -- converts integer into string using specified base

  function str(int : integer; base : integer) return string;

  -- converts integer to string, using base 10

  function str(int : integer) return string;

  -- convert std_logic_vector into a string in hex format

  function hstr(slv : std_logic_vector) return string;

  -- functions to manipulate strings

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

  -- convert a character to upper case

  function to_upper(c : character) return character;

  -- convert a character to lower case

  function to_lower(c : character) return character;

  -- convert a string to upper case

  function to_upper(s : string) return string;

  -- convert a string to lower case

  function to_lower(s : string) return string;

  -- functions to convert strings into other formats

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

  -- converts a character into std_logic

  function to_std_logic(c : character) return std_logic;

  -- converts a string into std_logic_vector

  function to_std_logic_vector(s : string) return std_logic_vector;

  -- file I/O

  -----------

  -- read variable length string from input file

  procedure str_read(file in_file :     text;

                     res_string   : out string);

  -- print string to a file and start new line

  procedure print(file out_file :    text;

                  new_string    : in string);

  -- print character to a file and start new line

  procedure print(file out_file :    text;

                  char          : in character);

end txt_util;

package body txt_util is

  -- prints text to the screen

  procedure print(text : string) is

    variable msg_line : line;

  begin

    write(msg_line, text);

    writeline(output, msg_line);

  end print;

  -- prints text to the screen when active

  procedure print(active : boolean; text : string) is

  begin

    if active then

      print(text);

    end if;

  end print;

  -- converts std_logic into a character

  function chr(sl : std_logic) return character is

    variable c : character;

  begin

    case sl is

      when 'U' => c := 'U';

      when 'X' => c := 'X';

      when '0' => c := '0';

      when '1' => c := '1';

      when 'Z' => c := 'Z';

      when 'W' => c := 'W';

      when 'L' => c := 'L';

      when 'H' => c := 'H';

      when '-' => c := '-';

    end case;

    return c;

  end chr;

  -- converts std_logic into a string (1 to 1)

  function str(sl : std_logic) return string is

    variable s : string(1 to 1);

  begin

    s(1) := chr(sl);

    return s;

  end str;

  -- converts std_logic_vector into a string (binary base)

  -- (this also takes care of the fact that the range of

  --  a string is natural while a std_logic_vector may

  --  have an integer range)

  function str(slv : std_logic_vector) return string is

    variable result : string (1 to slv'length);

    variable r      : integer;

  begin

    r := 1;

    for i in slv'range loop

      result(r) := chr(slv(i));

      r         := r + 1;

    end loop;

    return result;

  end str;

  function str(b : boolean) return string is

  begin

    if b then

      return "true";

    else

      return "false";

    end if;

  end str;

  -- converts an integer into a character

  -- for 0 to 9 the obvious mapping is used, higher

  -- values are mapped to the characters A-Z

  -- (this is usefull for systems with base > 10)

  -- (adapted from Steve Vogwell's posting in comp.lang.vhdl)

  function chr(int : integer) return character is

    variable c : character;

  begin

    case int is

      when 0      => c := '0';

      when 1      => c := '1';

      when 2      => c := '2';

      when 3      => c := '3';

      when 4      => c := '4';

      when 5      => c := '5';

      when 6      => c := '6';

      when 7      => c := '7';

      when 8      => c := '8';

      when 9      => c := '9';

      when 10     => c := 'A';

      when 11     => c := 'B';

      when 12     => c := 'C';

      when 13     => c := 'D';

      when 14     => c := 'E';

      when 15     => c := 'F';

      when 16     => c := 'G';

      when 17     => c := 'H';

      when 18     => c := 'I';

      when 19     => c := 'J';

      when 20     => c := 'K';

      when 21     => c := 'L';

      when 22     => c := 'M';

      when 23     => c := 'N';

      when 24     => c := 'O';

      when 25     => c := 'P';

      when 26     => c := 'Q';

      when 27     => c := 'R';

      when 28     => c := 'S';

      when 29     => c := 'T';

      when 30     => c := 'U';

      when 31     => c := 'V';

      when 32     => c := 'W';

      when 33     => c := 'X';

      when 34     => c := 'Y';

      when 35     => c := 'Z';

      when others => c := '?';

    end case;

    return c;

  end chr;

  -- convert integer to string using specified base

  -- (adapted from Steve Vogwell's posting in comp.lang.vhdl)

  function str(int : integer; base : integer) return string is

    variable temp    : string(1 to 10);

    variable num     : integer;

    variable abs_int : integer;

    variable len     : integer := 1;

    variable power   : integer := 1;

  begin

    -- bug fix for negative numbers

    abs_int := abs(int);

    num := abs_int;

    while num >= base loop              -- Determine how many

      len := len + 1;                   -- characters required

      num := num / base;                -- to represent the

    end loop;  -- number.

    for i in len downto 1 loop                 -- Convert the number to

      temp(i) := chr(abs_int/power mod base);  -- a string starting

      power   := power * base;                 -- with the right hand

    end loop;  -- side.

    -- return result and add sign if required

    if int < 0 then

      return '-'& temp(1 to len);

    else

      return temp(1 to len);

    end if;

  end str;

  -- convert integer to string, using base 10

  function str(int : integer) return string is

  begin

    return str(int, 10);

  end str;

  -- converts a std_logic_vector into a hex string.

  function hstr(slv : std_logic_vector) return string is

    variable hexlen  : integer;

    variable longslv : std_logic_vector(67 downto 0) := (others => '0');

    variable hex     : string(1 to 16);

    variable fourbit : std_logic_vector(3 downto 0);

  begin

    hexlen := (slv'left+1)/4;

    if (slv'left+1) mod 4 /= 0 then

      hexlen := hexlen + 1;

    end if;

    longslv(slv'left downto 0) := slv;

    for i in (hexlen -1) downto 0 loop

      fourbit := longslv(((i*4)+3) downto (i*4));

      case fourbit is

        when "0000" => hex(hexlen -I) := '0';

        when "0001" => hex(hexlen -I) := '1';

        when "0010" => hex(hexlen -I) := '2';

        when "0011" => hex(hexlen -I) := '3';

        when "0100" => hex(hexlen -I) := '4';

        when "0101" => hex(hexlen -I) := '5';

        when "0110" => hex(hexlen -I) := '6';

        when "0111" => hex(hexlen -I) := '7';

        when "1000" => hex(hexlen -I) := '8';

        when "1001" => hex(hexlen -I) := '9';

        when "1010" => hex(hexlen -I) := 'A';

        when "1011" => hex(hexlen -I) := 'B';

        when "1100" => hex(hexlen -I) := 'C';

        when "1101" => hex(hexlen -I) := 'D';

        when "1110" => hex(hexlen -I) := 'E';

        when "1111" => hex(hexlen -I) := 'F';

        when "ZZZZ" => hex(hexlen -I) := 'z';

        when "UUUU" => hex(hexlen -I) := 'u';

        when "XXXX" => hex(hexlen -I) := 'x';

        when others => hex(hexlen -I) := '?';

      end case;

    end loop;

    return hex(1 to hexlen);

  end hstr;

  -- functions to manipulate strings

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

  -- convert a character to upper case

  function to_upper(c : character) return character is

    variable u : character;

  begin

    case c is

      when 'a'    => u := 'A';

      when 'b'    => u := 'B';

      when 'c'    => u := 'C';

      when 'd'    => u := 'D';

      when 'e'    => u := 'E';

      when 'f'    => u := 'F';

      when 'g'    => u := 'G';

      when 'h'    => u := 'H';

      when 'i'    => u := 'I';

      when 'j'    => u := 'J';

      when 'k'    => u := 'K';

      when 'l'    => u := 'L';

      when 'm'    => u := 'M';

      when 'n'    => u := 'N';

      when 'o'    => u := 'O';

      when 'p'    => u := 'P';

      when 'q'    => u := 'Q';

      when 'r'    => u := 'R';

      when 's'    => u := 'S';

      when 't'    => u := 'T';

      when 'u'    => u := 'U';

      when 'v'    => u := 'V';

      when 'w'    => u := 'W';

      when 'x'    => u := 'X';

      when 'y'    => u := 'Y';

      when 'z'    => u := 'Z';

      when others => u := c;

    end case;

    return u;

  end to_upper;

  -- convert a character to lower case

  function to_lower(c : character) return character is

    variable l : character;

  begin

    case c is

      when 'A'    => l := 'a';

      when 'B'    => l := 'b';

      when 'C'    => l := 'c';

      when 'D'    => l := 'd';

      when 'E'    => l := 'e';

      when 'F'    => l := 'f';

      when 'G'    => l := 'g';

      when 'H'    => l := 'h';

      when 'I'    => l := 'i';

      when 'J'    => l := 'j';

      when 'K'    => l := 'k';

      when 'L'    => l := 'l';

      when 'M'    => l := 'm';

      when 'N'    => l := 'n';

      when 'O'    => l := 'o';

      when 'P'    => l := 'p';

      when 'Q'    => l := 'q';

      when 'R'    => l := 'r';

      when 'S'    => l := 's';

      when 'T'    => l := 't';

      when 'U'    => l := 'u';

      when 'V'    => l := 'v';

      when 'W'    => l := 'w';

      when 'X'    => l := 'x';

      when 'Y'    => l := 'y';

      when 'Z'    => l := 'z';

      when others => l := c;

    end case;

    return l;

  end to_lower;

  -- convert a string to upper case

  function to_upper(s : string) return string is

    variable uppercase : string (s'range);

  begin

    for i in s'range loop

      uppercase(i) := to_upper(s(i));

    end loop;

    return uppercase;

  end to_upper;

  -- convert a string to lower case

  function to_lower(s : string) return string is

    variable lowercase : string (s'range);

  begin

    for i in s'range loop

      lowercase(i) := to_lower(s(i));

    end loop;

    return lowercase;

  end to_lower;

-- functions to convert strings into other types

-- converts a character into a std_logic

  function to_std_logic(c : character) return std_logic is

    variable sl : std_logic;

  begin

    case c is

      when 'U' =>

        sl := 'U';

      when 'X' =>

        sl := 'X';

      when '0' =>

        sl := '0';

      when '1' =>

        sl := '1';

      when 'Z' =>

        sl := 'Z';

      when 'W' =>

        sl := 'W';

      when 'L' =>

        sl := 'L';

      when 'H' =>

        sl := 'H';

      when '-' =>

        sl := '-';

      when others =>

        sl := 'X';

    end case;

    return sl;

  end to_std_logic;

-- converts a string into std_logic_vector

  function to_std_logic_vector(s : string) return std_logic_vector is

    variable slv : std_logic_vector(s'high-s'low downto 0);

    variable k   : integer;

  begin

    k := s'high-s'low;

    for i in s'range loop

      slv(k) := to_std_logic(s(i));

      k      := k - 1;

    end loop;

    return slv;

  end to_std_logic_vector;

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

--  file I/O  --

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

-- read variable length string from input file

  procedure str_read(file in_file :     text;

                     res_string   : out string) is

    variable l         : line;

    variable c         : character;

    variable is_string : boolean;

  begin

    readline(in_file, l);

    -- clear the contents of the result string

    for i in res_string'range loop

      res_string(i) := ' ';

    end loop;

    -- read all characters of the line, up to the length  

    -- of the results string

    for i in res_string'range loop

      read(l, c, is_string);

      res_string(i) := c;

      if not is_string then             -- found end of line

        exit;

      end if;

    end loop;

  end str_read;

-- print string to a file

  procedure print(file out_file :    text;

                  new_string    : in string) is

    variable l : line;

  begin

    write(l, new_string);

    writeline(out_file, l);

  end print;

-- print character to a file and start new line

  procedure print(file out_file :    text;

                  char          : in character) is

    variable l : line;

  begin

    write(l, char);

    writeline(out_file, l);

  end print;

-- appends contents of a string to a file until line feed occurs

-- (LF is considered to be the end of the string)

  procedure str_write(file out_file :    text;

                      new_string    : in string) is

  begin

    for i in new_string'range loop

      print(out_file, new_string(i));

      if new_string(i) = LF then        -- end of string

        exit;

      end if;

    end loop;

  end str_write;

end txt_util;