cores
/
a2i
mirror of https://github.com/OpenPOWERFoundation/a2i
3
2
Fork 1
Code Issues 1 Projects Releases Wiki Activity
You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '82ea7bbccd'
${ noResults }
a2i/rel/build/ip_user/a2x_axi/a2x_axi/src/ibm/std_ulogic_support.vhdl

2695 lines
96 KiB
VHDL
Raw Blame History Unescape Escape

This file contains invisible Unicode characters!

This file contains invisible Unicode characters that may be processed differently from what appears below. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to reveal hidden characters.

-- © IBM Corp. 2020
-- Licensed under the Apache License, Version 2.0 (the "License"), as modified by
-- the terms below; you may not use the files in this repository except in
-- compliance with the License as modified.
-- You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
--
-- Modified Terms:
--
-- 1) For the purpose of the patent license granted to you in Section 3 of the
-- License, the "Work" hereby includes implementations of the work of authorship
-- in physical form.
--
-- 2) Notwithstanding any terms to the contrary in the License, any licenses
-- necessary for implementation of the Work that are available from OpenPOWER
-- via the Power ISA End User License Agreement (EULA) are explicitly excluded
-- hereunder, and may be obtained from OpenPOWER under the terms and conditions
-- of the EULA.
--
-- Unless required by applicable law or agreed to in writing, the reference design
-- distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-- WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
-- for the specific language governing permissions and limitations under the License.
--
-- Additional rights, including the ability to physically implement a softcore that
-- is compliant with the required sections of the Power ISA Specification, are
-- available at no cost under the terms of the OpenPOWER Power ISA EULA, which can be
-- obtained (along with the Power ISA) here: https://openpowerfoundation.org.
--***************************************************************************
-- Copyright 2020 International Business Machines
--
-- Licensed under the Apache License, Version 2.0 (the “License”);
-- you may not use this file except in compliance with the License.
-- You may obtain a copy of the License at
-- http://www.apache.org/licenses/LICENSE-2.0
--
-- The patent license granted to you in Section 3 of the License, as applied
-- to the “Work,” hereby includes implementations of the Work in physical form.
--
-- Unless required by applicable law or agreed to in writing, the reference design
-- distributed under the License is distributed on an “AS IS” BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- See the License for the specific language governing permissions and
-- limitations under the License.
--
--***************************************************************************
library ieee, ibm ;
use ieee.std_logic_1164.all ;
use ieee.numeric_std.all ;
package std_ulogic_support is
type base_t is ( bin, oct, dec, hex );
-------------------------------------------------------------------
-- Overloaded Relational Operator that can return std_ulogic
-------------------------------------------------------------------
function "=" ( l,r : integer ) return std_ulogic;
function "/=" ( l,r : integer ) return std_ulogic;
function ">" ( l,r : integer ) return std_ulogic;
function ">=" ( l,r : integer ) return std_ulogic;
function "<" ( l,r : integer ) return std_ulogic;
function "<=" ( l,r : integer ) return std_ulogic;
function "=" ( l,r : std_ulogic ) return std_ulogic;
function "/=" ( l,r : std_ulogic ) return std_ulogic;
function ">" ( l,r : std_ulogic ) return std_ulogic;
function ">=" ( l,r : std_ulogic ) return std_ulogic;
function "<" ( l,r : std_ulogic ) return std_ulogic;
function "<=" ( l,r : std_ulogic ) return std_ulogic;
function "=" ( l, r : std_ulogic_vector ) return std_ulogic;
function "/=" ( l, r : std_ulogic_vector ) return std_ulogic;
function ">" ( l, r : std_ulogic_vector ) return std_ulogic;
function ">=" ( l, r : std_ulogic_vector ) return std_ulogic;
function "<" ( l, r : std_ulogic_vector ) return std_ulogic;
function "<=" ( l, r : std_ulogic_vector ) return std_ulogic;
-- synopsys translate_off
attribute like_builtin of "=" :function is true;
attribute like_builtin of "/=" :function is true;
attribute like_builtin of ">" :function is true;
attribute like_builtin of ">=" :function is true;
attribute like_builtin of "<" :function is true;
attribute like_builtin of "<=" :function is true;
-- Synopsys translate_on
-------------------------------------------------------------------
-- Relational Functions that can return Boolean
-------------------------------------------------------------------
function eq( l,r : std_ulogic ) return boolean;
function ne( l,r : std_ulogic ) return boolean;
function gt( l,r : std_ulogic ) return boolean;
function ge( l,r : std_ulogic ) return boolean;
function lt( l,r : std_ulogic ) return boolean;
function le( l,r : std_ulogic ) return boolean;
-------------------------------------------------------------------
-- Relational Functions that can return std_ulogic
-------------------------------------------------------------------
function eq( l,r : std_ulogic ) return std_ulogic;
function ne( l,r : std_ulogic ) return std_ulogic;
function gt( l,r : std_ulogic ) return std_ulogic;
function ge( l,r : std_ulogic ) return std_ulogic;
function lt( l,r : std_ulogic ) return std_ulogic;
function le( l,r : std_ulogic ) return std_ulogic;
-------------------------------------------------------------------
-- Vectorized Relational Functions
-------------------------------------------------------------------
function eq( l,r : std_ulogic_vector ) return boolean;
function ne( l,r : std_ulogic_vector ) return boolean;
function gt( l,r : std_ulogic_vector ) return boolean;
function ge( l,r : std_ulogic_vector ) return boolean;
function lt( l,r : std_ulogic_vector ) return boolean;
function le( l,r : std_ulogic_vector ) return boolean;
function eq( l,r : std_ulogic_vector ) return std_ulogic;
function ne( l,r : std_ulogic_vector ) return std_ulogic;
function gt( l,r : std_ulogic_vector ) return std_ulogic;
function ge( l,r : std_ulogic_vector ) return std_ulogic;
function lt( l,r : std_ulogic_vector ) return std_ulogic;
function le( l,r : std_ulogic_vector ) return std_ulogic;
-- Synopsys translate_off
attribute functionality of eq : function is "=";
attribute functionality of ne : function is "/=";
attribute functionality of gt : function is ">";
attribute functionality of ge : function is ">=";
attribute functionality of lt : function is "<";
attribute functionality of le : function is "<=";
attribute dc_allow of eq : function is true;
attribute dc_allow of ne : function is true;
-- Synopsys translate_on
-------------------------------------------------------------------
-- Type Conversion Functions
-------------------------------------------------------------------
-- Boolean conversion to other types
function tconv( b : boolean ) return bit;
function tconv( b : boolean ) return std_ulogic;
-- Synopsys translate_off
function tconv( b : boolean ) return string;
-- Synopsys translate_on
-- Bit to other types
function tconv( b : bit ) return boolean;
function tconv( b : bit ) return integer;
function tconv( b : bit ) return std_ulogic;
-- Synopsys translate_off
function tconv( b : bit ) return character;
function tconv( b : bit ) return string;
-- Synopsys translate_on
-- Bit_vector to other types
function tconv( b : bit_vector ) return integer;
function tconv( b : bit_vector ) return std_ulogic_vector;
-- function tconv( b : bit_vector ) return std_logic_vector;
-- synopsys translate_off
function tconv( b : bit_vector ) return string;
function tconv( b : bit_vector; base : base_t ) return string;
-- synopsys translate_on
-- Integer conversion to other types
function tconv( n : integer; w: positive ) return bit_vector ;
function tconv( n : integer; w: positive ) return std_ulogic_vector ;
-- synopsys translate_off
function tconv( n : integer; w: positive ) return string ;
function tconv( n : integer ) return string ;
-- synopsys translate_on
-- Synopsys translate_off
-- String conversion to other types
function tconv( s : string ) return integer ;
function tconv( s : string; base : base_t ) return integer ;
function tconv( s : string ) return bit ;
function tconv( s : string ) return bit_vector ;
function tconv( s : string; base : base_t ) return bit_vector ;
function tconv( s : string ) return std_ulogic ;
function tconv( s : string ) return std_ulogic_vector ;
function tconv( s : string; base : base_t ) return std_ulogic_vector ;
-- Synopsys translate_on
-- Std_uLogic to other types
function tconv( s : std_ulogic ) return boolean;
function tconv( s : std_ulogic ) return bit;
function tconv( s : std_ulogic ) return integer;
function tconv( s : std_ulogic ) return std_ulogic_vector;
-- synopsys translate_off
function tconv( s : std_ulogic ) return character;
function tconv( s : std_ulogic ) return string;
-- synopsys translate_on
-- std_ulogic_vector to other types
function tconv( s : std_ulogic_vector ) return bit_vector;
function tconv( s : std_ulogic_vector ) return std_logic_vector;
function tconv( s : std_ulogic_vector ) return integer;
function tconv( s : std_ulogic_vector ) return std_ulogic;
-- synopsys translate_off
function tconv( s : std_ulogic_vector ) return string;
function tconv( s : std_ulogic_vector; base : base_t ) return string;
-- synopsys translate_on
-- std_logic_vector to other types
-- function tconv( s : std_logic_vector ) return bit_vector;
-- function tconv( s : std_logic_vector ) return std_ulogic_vector;
-- function tconv( s : std_logic_vector ) return integer;
-- synopsys translate_off
-- function tconv( s : std_logic_vector ) return string;
-- function tconv( s : std_logic_vector; base : base_t ) return string;
-- synopsys translate_on
-- synopsys translate_off
function hexstring( d : std_ulogic_vector ) return string ;
function octstring( d : std_ulogic_vector ) return string ;
function bitstring( d : std_ulogic_vector ) return string ;
-- synopsys translate_on
-------------------------------------------------------------------
-- HIS ATTRIBUTEs for Type Conversion Functions
-------------------------------------------------------------------
-- Synopsys translate_off
attribute type_convert of tconv : function is true;
-------------------------------------------------------------------
-- synthesis ATTRIBUTEs for Type Conversion Functions
-------------------------------------------------------------------
attribute btr_name of tconv : function is "PASS";
attribute pin_bit_information of tconv : function is
(1 => (" ","A0 ","INCR","PIN_BIT_SCALAR"),
2 => (" ","10 ","INCR","PIN_BIT_SCALAR"));
-- Synopsys translate_on
--============================================================================
-- Match Functions
--============================================================================
function std_match (l, r: std_ulogic) return std_ulogic;
function std_match (l, r: std_ulogic_vector) return std_ulogic;
-- Synopsys translate_off
attribute functionality of std_match : function is "=";
attribute dc_allow of std_match : function is true;
-- Synopsys translate_on
--==============================================================
-- Shift and Rotate Functions
--==============================================================
-- Id: S.1
function shift_left (arg: std_ulogic_vector; count: natural) return std_ulogic_vector;
-- Result subtype: std_ulogic_vector(ARG'LENGTH-1 downto 0)
-- Result: Performs a shift-left on an std_ulogic_vector vector COUNT times.
-- The vacated positions are filled with '0'.
-- The COUNT leftmost elements are lost.
-- Id: S.2
function shift_right (arg: std_ulogic_vector; count: natural) return std_ulogic_vector;
-- Result subtype: std_ulogic_vector(ARG'LENGTH-1 downto 0)
-- Result: Performs a shift-right on an std_ulogic_vector vector COUNT times.
-- The vacated positions are filled with '0'.
-- The COUNT rightmost elements are lost.
-- Id: S.5
function rotate_left (arg: std_ulogic_vector; count: natural) return std_ulogic_vector;
-- Result subtype: std_ulogic_vector(ARG'LENGTH-1 downto 0)
-- Result: Performs a rotate-left of an std_ulogic_vector vector COUNT times.
-- Id: S.6
function rotate_right (arg: std_ulogic_vector; count: natural) return std_ulogic_vector;
-- Result subtype: std_ulogic_vector(ARG'LENGTH-1 downto 0)
-- Result: Performs a rotate-right of an std_ulogic_vector vector COUNT times.
-- Id: S.9
function "sll" (arg: std_ulogic_vector; count: integer) return std_ulogic_vector;
-- Result subtype: std_ulogic_vector(ARG'LENGTH-1 downto 0)
-- Result: SHIFT_LEFT(ARG, COUNT)
-- Id: S.11
function "srl" (arg: std_ulogic_vector; count: integer) return std_ulogic_vector;
-- Result subtype: std_ulogic_vector(ARG'LENGTH-1 downto 0)
-- Result: SHIFT_RIGHT(ARG, COUNT)
-- Id: S.13
function "rol" (arg: std_ulogic_vector; count: integer) return std_ulogic_vector;
-- Result subtype: std_ulogic_vector(ARG'LENGTH-1 downto 0)
-- Result: ROTATE_LEFT(ARG, COUNT)
-- Id: S.15
function "ror" (arg: std_ulogic_vector; count: integer) return std_ulogic_vector;
-- Result subtype: std_ulogic_vector(ARG'LENGTH-1 downto 0)
-- Result: ROTATE_RIGHT(ARG, COUNT)
--===========================================================
--End shift and rotate functions.............................
--===========================================================
end std_ulogic_support ;
package body std_ulogic_support is
-------------------------------------------------------------------
-- Look Up tables for operator overloading
-------------------------------------------------------------------
-- Types used for overloaded operator lookup tables
-------------------------------------------------------------------
-- Synopsys synthesis_off
type std_ulogic_to_character_type is array( std_ulogic ) of character;
constant std_ulogic_to_character : std_ulogic_to_character_type :=
( 'U','X','0','1','Z','W','L','H','-');
type stdlogic_2d is array ( std_ulogic, std_ulogic ) of std_ulogic;
type b_stdlogic_2d is array ( std_ulogic, std_ulogic ) of boolean;
-- Synopsys synthesis_on
-------------------------------------------------------------------
-- Logic operation lookup tables
-------------------------------------------------------------------
-- Synopsys synthesis_off
-- LessThan Logic Operator
constant lt_table : stdlogic_2D := (
-- RHS U X 0 1 Z W L H - |
-- LHS ---------------------------------------------------+---
( 'U', 'U', 'U', 'U', 'U', 'U', 'U', 'U', 'U' ), -- | U
( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | X
( 'U', 'X', '0', '1', 'X', 'X', '0', '1', 'X' ), -- | 0
( 'U', 'X', '0', '0', 'X', 'X', '0', '0', 'X' ), -- | 1
( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | Z
( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | W
( 'U', 'X', '0', '1', 'X', 'X', '0', '1', 'X' ), -- | L
( 'U', 'X', '0', '0', 'X', 'X', '0', '0', 'X' ), -- | H
( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | -
others=>(others=>'-')
);
constant b_lt_table : b_stdlogic_2D := (
'U'=>( others=>false ),
'X'=>( others=>false ),
'0'=>( '1'=>true, 'H'=>true, others=>false ),
'1'=>( others=>false ),
'Z'=>( others=>false ),
'W'=>( others=>false ),
'L'=>( '1'=>true, 'H'=>true, others=>false ),
'H'=>( others=>false ),
'-'=>( others=>false ),
others=>( others=>false )
);
-- LessThanorEqual Logic Operator
constant le_table : stdlogic_2D := (
-- RHS U X 0 1 Z W L H - |
-- LHS ---------------------------------------------------+---
( 'U', 'U', 'U', 'U', 'U', 'U', 'U', 'U', 'U' ), -- | U
( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | X
( 'U', 'X', '1', '1', 'X', 'X', '1', '1', 'X' ), -- | 0
( 'U', 'X', '0', '0', 'X', 'X', '0', '0', 'X' ), -- | 1
( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | Z
( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | W
( 'U', 'X', '1', '1', 'X', 'X', '0', '1', 'X' ), -- | L
( 'U', 'X', '0', '0', 'X', 'X', '0', '0', 'X' ), -- | H
( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | -
others=>(others=>'-')
);
constant b_le_table : b_stdlogic_2D := (
-- RHS => - 0 U X 1 Z W L H
-- LHS --------------------------------------------------------------------------------------------------
'U'=>( others=>false ),
'X'=>( others=>false ),
'0'=>( '0'=>true, '1'=>true, 'L'=>true, 'H'=>true, others=>false ),
'1'=>( '1'=>true, 'H'=>true, others=>false ),
'Z'=>( others=>false ),
'W'=>( others=>false ),
'L'=>( '0'=>true, '1'=>true, 'L'=>true, 'H'=>true, others=>false ),
'H'=>( '1'=>true, 'H'=>true, others=>false ),
'-'=>( others=>false ),
others=>( others=>false )
);
-- GreaterThan Logic Operator
constant gt_table : stdlogic_2D := (
-- RHS U X 0 1 Z W L H - |
-- LHS ---------------------------------------------------+---
( 'U', 'U', 'U', 'U', 'U', 'U', 'U', 'U', 'U' ), -- | U
( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | X
( 'U', 'X', '0', '0', 'X', 'X', '0', '0', 'X' ), -- | 0
( 'U', 'X', '1', '0', 'X', 'X', '1', '0', 'X' ), -- | 1
( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | Z
( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | W
( 'U', 'X', '0', '0', 'X', 'X', '0', '0', 'X' ), -- | L
( 'U', 'X', '1', '0', 'X', 'X', '1', '0', 'X' ), -- | H
( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | -
others=>(others=>'-')
);
constant b_gt_table : b_stdlogic_2D := (
-- LHS => ( RHS )
'U'=>( others=>false ),
'X'=>( others=>false ),
'0'=>( others=>false ),
'1'=>( '0'=>true, 'L'=>true, others=>false ),
'Z'=>( others=>false ),
'W'=>( others=>false ),
'L'=>( others=>false ),
'H'=>( '0'=>true, 'L'=>true, others=>false ),
'-'=>( others=>false ),
others=>(others=>false));
-- GreaterThanorEqual Logic Operator
constant ge_table : stdlogic_2D := (
-- RHS U X 0 1 Z W L H - |
-- LHS ---------------------------------------------------+---
( 'U', 'U', 'U', 'U', 'U', 'U', 'U', 'U', 'U' ), -- | U
( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | X
( 'U', 'X', '1', '0', 'X', 'X', '1', '0', 'X' ), -- | 0
( 'U', 'X', '1', '1', 'X', 'X', '1', '1', 'X' ), -- | 1
( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | Z
( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | W
( 'U', 'X', '1', '0', 'X', 'X', '1', '0', 'X' ), -- | L
( 'U', 'X', '1', '1', 'X', 'X', '1', '1', 'X' ), -- | H
( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | -
others=>(others=>'-')
);
constant b_ge_table : b_stdlogic_2D := (
-- RHS => - 0 U X 1 Z W L H
-- LHS --------------------------------------------------------------------------------------------------
'U'=>( others=>false ),
'X'=>( others=>false ),
'0'=>( '0'=>true, 'L'=>true, others=>false ),
'1'=>( '0'=>true, '1'=>true, 'L'=>true, 'H'=>true, others=>false ),
'Z'=>( others=>false ),
'W'=>( others=>false ),
'L'=>( '0'=>true, 'L'=>true, others=>false ),
'H'=>( '0'=>true, '1'=>true, 'L'=>true, 'H'=>true, others=>false ),
'-'=>( others=>false ),
others=>( others=>false )
);
-- Synopsys synthesis_on
-------------------------------------------------------------------
-- Relational Functions returning Boolean
-------------------------------------------------------------------
function eq( l,r : std_ulogic ) return boolean is
begin
return std_match( l, r );
end eq;
function ne( l,r : std_ulogic ) return boolean is
begin
return not( std_match( l, r ) );
end ne;
function gt( l,r : std_ulogic ) return boolean is
variable result : boolean;
-- pragma built_in SYN_GT
begin
-- Synopsys translate_off
assert ( l /= '-' ) and ( r /= '-' )
report "Invalid dont_care in relational function"
severity error;
result := b_gt_table( l, r );
-- Synopsys translate_on
return result;
end gt;
function ge( l,r : std_ulogic ) return boolean is
variable result : boolean;
-- pragma built_in SYN_GEQ
begin
-- synopsys translate_off
assert ( l /= '-' ) and ( r /= '-' )
report "Invalid dont_care in relational function"
severity error;
result := b_ge_table( l, r );
-- synopsys translate_on
return result;
end ge;
function lt( l,r : std_ulogic ) return boolean is
variable result : boolean;
-- pragma built_in SYN_LT
begin
-- synopsys translate_off
assert ( l /= '-' ) and ( r /= '-' )
report "Invalid dont_care in relational function"
severity error;
result := b_lt_table( l, r );
-- synopsys translate_on
return result;
end lt;
function le( l,r : std_ulogic ) return boolean is
variable result : boolean;
-- pragma built_in SYN_LEQ
begin
-- synopsys translate_off
assert ( l /= '-' ) and ( r /= '-' )
report "Invalid dont_care in relational function"
severity error;
result := b_le_table( l, r );
-- synopsys translate_on
return result;
end le;
-------------------------------------------------------------------
-- Relational Functions returning std_ulogic
-------------------------------------------------------------------
function eq( l,r : std_ulogic ) return std_ulogic is
begin
return std_match( l, r );
end eq;
function ne( l,r : std_ulogic ) return std_ulogic is
begin
return not std_match( l, r ) ;
end ne;
function gt( l,r : std_ulogic ) return std_ulogic is
variable result : std_ulogic;
-- pragma built_in SYN_GT
begin
-- Synopsys translate_off
assert ( l /= '-' ) and ( r /= '-' )
report "Invalid dont_care in relational function"
severity error;
result := gt_table( l, r );
-- synopsys translate_on
return result;
end gt;
function ge( l,r : std_ulogic ) return std_ulogic is
variable result : std_ulogic;
-- pragma built_in SYN_GEQ
begin
-- Synopsys translate_off
assert ( l /= '-' ) and ( r /= '-' )
report "Invalid dont_care in relational function"
severity error;
result := ge_table( l, r );
-- Synopsys translate_on
return result;
end ge;
function lt( l,r : std_ulogic ) return std_ulogic is
variable result : std_ulogic;
-- pragma built_in SYN_LT
begin
-- Synopsys translate_off
assert ( l /= '-' ) and ( r /= '-' )
report "Invalid dont_care in relational function"
severity error;
result := lt_table( l, r );
-- Synopsys translate_on
return result;
end lt;
function le( l,r : std_ulogic ) return std_ulogic is
variable result : std_ulogic;
-- pragma built_in SYN_LEQ
begin
-- Synopsys translate_off
assert ( l /= '-' ) and ( r /= '-' )
report "Invalid dont_care in relational function"
severity error;
result := le_table( l, r );
-- Synopsys translate_on
return result;
end le;
--
-- utility function get rid of most meta values
--
function to_x01d( d : std_ulogic ) return std_ulogic is
-- pragma built_in SYN_FEED_THRU
variable result : std_ulogic;
begin
-- Synopsys translate_off
case d is
when '0' | 'L' => result := '0';
when '1' | 'H' => result := '1';
when '-' => result := '-';
when others => result := 'X';
end case;
-- Synopsys translate_on
return result;
end to_x01d;
-------------------------------------------------------------------
-- Vectored Relational Functions returning Boolean
-------------------------------------------------------------------
function eq( l,r : std_ulogic_vector) return boolean is
variable result : boolean ;
begin
result := std_match(l,r);
return result;
end eq;
---------------------------------------------------------------------
function ne( l,r : std_ulogic_vector) return boolean is
variable result : boolean ;
begin
result := not std_match(l,r);
return result;
end ne;
-------------------------------------------------------------------
function gt( l,r : std_ulogic_vector) return boolean is
variable result : boolean ;
begin
result := unsigned(l) > unsigned(r);
return result;
end gt;
-------------------------------------------------------------------
function ge( l,r : std_ulogic_vector) return boolean is
variable result : boolean ;
begin
result := unsigned(l) >= unsigned(r);
return result;
end ge;
-------------------------------------------------------------------
function lt( l,r : std_ulogic_vector) return boolean is
variable result : boolean ;
begin
result := unsigned(l) < unsigned(r);
return result;
end lt;
-------------------------------------------------------------------
function le( l,r : std_ulogic_vector) return boolean is
variable result : boolean ;
begin
result := unsigned(l) <= unsigned(r);
return result;
end le;
-------------------------------------------------------------------
-- vectored relational functions returning std_ulogic
-------------------------------------------------------------------
function eq( l,r : std_ulogic_vector) return std_ulogic is
variable result : std_ulogic ;
begin
result := std_match( l, r ) ;
--result := (l ?= r);
return result;
end eq;
---------------------------------------------------------------------
function ne( l,r : std_ulogic_vector) return std_ulogic is
variable result :std_ulogic ;
begin
result := not std_match( l, r ) ;
--result := not (l ?= r);
return result;
end ne;
-------------------------------------------------------------------
function gt( l,r : std_ulogic_vector) return std_ulogic is
variable result : boolean ;
-- pragma built_in SYN_GT
begin
result := unsigned(l) > unsigned(r);
if (result = true ) then
return '1' ;
else
return '0';
end if ;
end gt;
-------------------------------------------------------------------
function ge( l,r : std_ulogic_vector) return std_ulogic is
variable result : boolean ;
-- pragma built_in SYN_GEQ
begin
result := unsigned(l) >= unsigned(r);
if (result = true ) then
return '1' ;
else
return '0';
end if ;
end ge;
-------------------------------------------------------------------
function lt( l,r : std_ulogic_vector) return std_ulogic is
variable result : boolean ;
-- pragma built_in SYN_LT
begin
result := unsigned(l) < unsigned(r);
if (result = true ) then
return '1' ;
else
return '0';
end if ;
end lt;
-------------------------------------------------------------------
function le( l,r : std_ulogic_vector) return std_ulogic is
variable result : boolean ;
-- pragma built_in SYN_LEQ
begin
result := unsigned(l) <= unsigned(r);
if (result = true ) then
return '1' ;
else
return '0';
end if ;
end le;
-------------------------------------------------------------------
-- Type Conversion Functions
-------------------------------------------------------------------
-------------------------------------------------------------------
-- Boolean Conversions
-------------------------------------------------------------------
function tconv ( b : boolean ) return bit is
-- pragma built_in SYN_FEED_THRU
begin
case b is
when false => return('0');
when true => return('1');
end case;
end tconv ;
-- Synopsys translate_off
function tconv ( b : boolean ) return string is
begin
case b is
when false => return("FALSE");
when true => return("TRUE");
end case;
end tconv ;
-- Synopsys translate_on
function tconv ( b : boolean ) return std_ulogic is
-- pragma built_in SYN_FEED_THRU
begin
case b is
when false => return('0');
when true => return('1');
end case;
end tconv ;
-------------------------------------------------------------------
-- Bit Conversions
-------------------------------------------------------------------
function tconv ( b : bit ) return boolean is
-- pragma built_in SYN_FEED_THRU
begin
case b is
when '0' => return(false);
when '1' => return(true);
end case;
end tconv ;
-- Synopsys translate_off
function tconv ( b : bit ) return character is
begin
case b is
when '0' => return('0');
when '1' => return('1');
end case;
end tconv ;
function tconv ( b : bit ) return string is
begin
case b is
when '0' => return("0");
when '1' => return("1");
end case;
end tconv ;
-- Synopsys translate_on
function tconv ( b : bit ) return integer is
-- pragma built_in SYN_UNSIGNED_TO_INTEGER
begin
case b is
when '0' => return(0);
when '1' => return(1);
end case;
end tconv ;
function tconv ( b : bit ) return std_ulogic is
-- pragma built_in SYN_FEED_THRU
begin
case b is
when '0' => return('0');
when '1' => return('1');
end case;
end tconv ;
-------------------------------------------------------------------
-- Bit_vector Conversions
-------------------------------------------------------------------
function tconv ( b : bit_vector ) return integer is
variable int_result : integer ;
variable int_exp : integer ;
variable new_value : bit_vector(1 to b'length);
-- pragma built_in SYN_UNSIGNED_TO_INTEGER
begin
-- Synopsys translate_off
int_result := 0;
int_exp := 0;
new_value := b;
for i in new_value'length to 1 loop
if b(i)='1' then
int_result := int_result + (2**int_exp);
end if;
int_exp := int_exp + 1;
end loop;
-- synopsys translate_on
return int_result;
end tconv ;
-- Synopsys translate_off
function tconv ( b : bit_vector ) return string is
alias sv : bit_vector ( 1 to b'length ) is b;
variable result : string ( 1 to b'length );
begin
result := (others => '0');
for i in result'range loop
case sv(i) is
when '0' => result(i) := '0';
when '1' => result(i) := '1';
end case;
end loop;
return result;
end tconv ;
-- Synopsys translate_on
-- Synopsys translate_off
function tconv ( b : bit_vector; base : base_t ) return string is
alias sv : bit_vector ( 1 to b'length ) is b;
variable result : string ( 1 to b'length );
variable start : positive;
variable extra : natural;
variable resultlength : positive;
subtype bv is bit_vector( 1 to 1 );
subtype qv is bit_vector( 1 to 2 );
subtype ov is bit_vector( 1 to 3 );
subtype hv is bit_vector( 1 to 4 );
begin
case base is
when bin =>
resultlength := sv'length;
start := 1;
for i in start to resultlength loop
case sv( i ) is
when '0' => result( i ) := '0';
when '1' => result( i ) := '1';
end case;
end loop;
when oct =>
extra := sv'length rem ov'length;
case extra is
when 0 =>
resultlength := b'length/ov'length;
start := 1;
when 1 =>
resultlength := ( b'length/ov'length ) + 1;
start := 2;
case sv( 1 ) is
when '0' => result( 1 ) := '0';
when '1' => result( 1 ) := '1';
end case;
when 2 =>
resultlength := ( b'length/ov'length ) + 1;
start := 2;
case qv'( sv( 1 to 2 ) ) is
when "00" => result( 1 ) := '0';
when "01" => result( 1 ) := '1';
when "10" => result( 1 ) := '2';
when "11" => result( 1 ) := '3';
end case;
when others =>
assert false report "TCONV fatal condition" severity failure;
end case;
for i in 0 to resultLength - start loop
case ov'( SV( (ov'length*i)+(extra+1) to (ov'length*i)+(extra+3) ) ) is
when "000" => result( i+start ) := '0';
when "001" => result( i+start ) := '1';
when "010" => result( i+start ) := '2';
when "011" => result( i+start ) := '3';
when "100" => result( i+start ) := '4';
when "101" => result( i+start ) := '5';
when "110" => result( i+start ) := '6';
when "111" => result( i+start ) := '7';
when others => result( i+start ) := '.';
end case;
end loop;
when hex =>
extra := b'length rem hv'length;
case extra is
when 0 =>
resultLength := b'length/hv'length;
start := 1;
when 1 =>
resultLength := ( b'length/hv'length ) + 1;
start := 2;
case sv( 1 ) is
when '0' => result( 1 ) := '0';
when '1' => result( 1 ) := '1';
end case;
when 2 =>
resultLength := ( b'length/hv'length ) + 1;
start := 2;
case qv'( sv( 1 to 2 ) ) is
when "00" => result( 1 ) := '0';
when "01" => result( 1 ) := '1';
when "10" => result( 1 ) := '2';
when "11" => result( 1 ) := '3';
end case;
when 3 =>
resultLength := ( b'length/hv'length ) + 1;
start := 2;
case ov'( sv( 1 to 3 ) ) is
when o"0" => result( 1 ) := '0';
when o"1" => result( 1 ) := '1';
when o"2" => result( 1 ) := '2';
when o"3" => result( 1 ) := '3';
when o"4" => result( 1 ) := '4';
when o"5" => result( 1 ) := '5';
when o"6" => result( 1 ) := '6';
when o"7" => result( 1 ) := '7';
end case;
when others =>
assert false report "TCONV fatal condition" severity failure;
end case;
for i in 0 to resultLength - start loop
case hv'( SV( (hv'length*i)+(extra+1) to (hv'length*i)+(extra+4) ) ) is
when "0000" => result( i+start ) := '0';
when "0001" => result( i+start ) := '1';
when "0010" => result( i+start ) := '2';
when "0011" => result( i+start ) := '3';
when "0100" => result( i+start ) := '4';
when "0101" => result( i+start ) := '5';
when "0110" => result( i+start ) := '6';
when "0111" => result( i+start ) := '7';
when "1000" => result( i+start ) := '8';
when "1001" => result( i+start ) := '9';
when "1010" => result( i+start ) := 'A';
when "1011" => result( i+start ) := 'B';
when "1100" => result( i+start ) := 'C';
when "1101" => result( i+start ) := 'D';
when "1110" => result( i+start ) := 'E';
when "1111" => result( i+start ) := 'F';
when others => result( i+start ) := '.';
end case;
end loop;
when others =>
assert false report "Unsupported base passed." severity warning;
end case;
return result( 1 to resultLength );
end tconv ;
-- Synopsys translate_on
function tconv ( b : bit_vector ) return std_ulogic_vector is
alias sv : bit_vector ( 1 to b'length ) is b;
variable result : std_ulogic_vector ( 1 to b'length );
-- pragma built_in SYN_FEED_THRU
begin
for i in result'range loop
case sv(i) is
when '0' => result(i) := '0';
when '1' => result(i) := '1';
end case;
end loop;
return result;
end tconv ;
--function tconv ( b : bit_vector ) return std_logic_vector is
-- alias sv : bit_vector ( 1 to b'length ) is b;
-- variable result : std_logic_vector ( 1 to b'length );
---- pragma built_in SYN_FEED_THRU
--begin
-- for i in result'range loop
-- case sv(i) is
-- when '0' => result(i) := '0';
-- when '1' => result(i) := '1';
-- end case;
-- end loop;
-- return result;
--end tconv ;
-------------------------------------------------------------------
-- Integer conversion to other types
-------------------------------------------------------------------
function tconv ( n : integer;w : positive) return bit_vector is
variable result : bit_vector(w-1 downto 0) ;
variable ib : integer;
variable test : integer;
-- pragma built_in SYN_INTEGER_TO_UNSIGNED
begin
if n < 0 then
result := (others => '0');
else
ib := n;
result := (others => '0');
for i in result'reverse_range loop
exit when ib = 0;
test := ib rem 2;
if test = 1 then
result(i) := '1';
else
result(i) := '0';
end if;
ib := ib / 2;
end loop;
end if;
-- synopsys translate_off
assert n >= 0
report "tconv: n < 0 is not permitted"
severity warning;
assert ib = 0
report "tconv: integer overflows requested result width"
severity warning;
-- synopsys translate_on
return result;
end tconv;
function tconv ( n : integer; w : positive) return std_ulogic_vector is
variable result : std_ulogic_vector(w-1 downto 0) ;
variable ib : integer;
variable test : integer;
-- pragma built_in SYN_INTEGER_TO_UNSIGNED
begin
if n < 0 then
result := (others => 'X');
else
ib := n;
result := (others => '0');
for i in result'reverse_range loop
exit when ib = 0;
test := ib rem 2;
if test = 1 then
result(i) := '1';
else
result(i) := '0';
end if;
ib := ib / 2;
end loop;
end if;
-- Synopsys translate_off
assert n >= 0
report "tconv: n < 0 is not permitted"
severity warning;
assert ib = 0
report "tconv: integer overflows requested result width"
severity warning;
-- Synopsys translate_on
return result;
end tconv;
-- Synopsys translate_off
function tconv ( n : integer; w : positive ) return string is
subtype digit is integer range 0 to 9;
variable result : string( 1 to w ) ;
variable ib : integer;
variable msd : integer;
variable sign : character := '-';
variable test : digit;
begin
ib := abs n;
for i in result'reverse_range loop
test := ib rem 10;
case test is
when 0 => result(i) := '0';
when 1 => result(i) := '1';
when 2 => result(i) := '2';
when 3 => result(i) := '3';
when 4 => result(i) := '4';
when 5 => result(i) := '5';
when 6 => result(i) := '6';
when 7 => result(i) := '7';
when 8 => result(i) := '8';
when 9 => result(i) := '9';
end case;
ib := ib / 10;
exit when ib = 0;
end loop;
if ib < 0 then
result(1) := sign;
end if;
assert
not( ( ( ib < 0 ) and ( ( abs ib ) > ( 10**(w-1) - 1 ) ) ) or
( ( ib >= 0 ) and ( ib > ( 10**w - 1 ) ) ) )
report "tconv: integer overflows requested result width"
severity warning;
return result;
end tconv;
-- Synopsys translate_on
-- Synopsys translate_off
function tconv ( n : integer) return string is
subtype digit is integer range 0 to 9;
variable result : string( 1 to 10 ) ;
variable ib : integer;
variable msd : integer;
variable sign : character := '-';
variable test : digit;
begin
ib := abs n ;
for i in result'reverse_range loop
test := ib rem 10;
case test is
when 0 => result(i) := '0';
when 1 => result(i) := '1';
when 2 => result(i) := '2';
when 3 => result(i) := '3';
when 4 => result(i) := '4';
when 5 => result(i) := '5';
when 6 => result(i) := '6';
when 7 => result(i) := '7';
when 8 => result(i) := '8';
when 9 => result(i) := '9';
end case;
ib := ib / 10;
if ib = 0 then
msd := i;
exit;
end if;
end loop;
if ib < 0 then
return sign & result(msd to 10);
else
return result(msd to 10);
end if;
end tconv;
-- Synopsys translate_on
-------------------------------------------------------------------
-- String conversion to other types
-------------------------------------------------------------------
-- Synopsys translate_off
function TConv ( s : string ) return integer is
variable result : integer ;
alias si : string( s'length downto 1 ) is s;
variable invalid : boolean ;
begin
invalid := false ;
for i in si'range loop
case si( i ) is
when '0' => null;
when '1' => result := result + 10 ** ( i - 1 ) ;
when '2' => result := result + 2 * 10 ** ( i - 1 ) ;
when '3' => result := result + 3 * 10 ** ( i - 1 ) ;
when '4' => result := result + 4 * 10 ** ( i - 1 ) ;
when '5' => result := result + 5 * 10 ** ( i - 1 ) ;
when '6' => result := result + 6 * 10 ** ( i - 1 ) ;
when '7' => result := result + 7 * 10 ** ( i - 1 ) ;
when '8' => result := result + 8 * 10 ** ( i - 1 ) ;
when '9' => result := result + 9 * 10 ** ( i - 1 ) ;
when others => invalid := true;
end case;
end loop;
assert not invalid
report "String contained characters other than 0 thru 9" &
"; treating invalid characters as 0's"
severity warning;
return result;
end tconv;
-- Synopsys translate_on
-- Synopsys translate_off
function tconv ( s : string; base : base_t ) return integer is
alias sv : string ( s'length downto 1 ) is s;
variable result : integer ;
variable invalid : boolean ;
variable vc_len : integer ;
variable validchars : string(1 to 20) := "0 thru 9 or A thru F";
begin
invalid := false ;
case base is
when bin =>
vc_len := 6;
validchars(1 to 6) := "0 or 1";
for i in sv'range loop
case sv( i ) is
when '0' => null;
when '1' => result := result + 2 ** ( i - 1 ) ;
when others => invalid := true;
end case;
end loop;
when oct =>
vc_len := 8;
validchars(1 to 8) := "0 thru 7";
for i in sv'range loop
case sv( i ) is
when '0' => null;
when '1' => result := result + 8 ** ( i - 1 ) ;
when '2' => result := result + 2 * 8 ** ( i - 1 ) ;
when '3' => result := result + 3 * 8 ** ( i - 1 ) ;
when '4' => result := result + 4 * 8 ** ( i - 1 ) ;
when '5' => result := result + 5 * 8 ** ( i - 1 ) ;
when '6' => result := result + 6 * 8 ** ( i - 1 ) ;
when '7' => result := result + 7 * 8 ** ( i - 1 ) ;
when others => invalid := true;
end case;
end loop;
when dec =>
vc_len := 8;
validchars(1 to 8) := "0 thru 9";
for i in sv'range loop
case sv( i ) is
when '0' => null;
when '1' => result := result + 10 ** ( i - 1 ) ;
when '2' => result := result + 2 * 10 ** ( i - 1 ) ;
when '3' => result := result + 3 * 10 ** ( i - 1 ) ;
when '4' => result := result + 4 * 10 ** ( i - 1 ) ;
when '5' => result := result + 5 * 10 ** ( i - 1 ) ;
when '6' => result := result + 6 * 10 ** ( i - 1 ) ;
when '7' => result := result + 7 * 10 ** ( i - 1 ) ;
when '8' => result := result + 8 * 10 ** ( i - 1 ) ;
when '9' => result := result + 9 * 10 ** ( i - 1 ) ;
when others => invalid := true;
end case;
end loop;
when hex =>
for i in sv'range loop
case sv( i ) is
when '0' => null;
when '1' => result := result + 16 ** ( i - 1 ) ;
when '2' => result := result + 2 * 16 ** ( i - 1 ) ;
when '3' => result := result + 3 * 16 ** ( i - 1 ) ;
when '4' => result := result + 4 * 16 ** ( i - 1 ) ;
when '5' => result := result + 5 * 16 ** ( i - 1 ) ;
when '6' => result := result + 6 * 16 ** ( i - 1 ) ;
when '7' => result := result + 7 * 16 ** ( i - 1 ) ;
when '8' => result := result + 8 * 16 ** ( i - 1 ) ;
when '9' => result := result + 9 * 16 ** ( i - 1 ) ;
when 'A' | 'a' => result := result + 10 * 16 ** ( i - 1 ) ;
when 'B' | 'b' => result := result + 11 * 16 ** ( i - 1 ) ;
when 'C' | 'c' => result := result + 12 * 16 ** ( i - 1 ) ;
when 'D' | 'd' => result := result + 13 * 16 ** ( i - 1 ) ;
when 'E' | 'e' => result := result + 14 * 16 ** ( i - 1 ) ;
when 'F' | 'f' => result := result + 15 * 16 ** ( i - 1 ) ;
when others => invalid := true;
end case;
end loop;
when others =>
assert false report "Unsupported base passed." severity warning;
end case;
assert not invalid
report "String contained characters other than " &
validchars(1 to vc_len) & "; treating invalid characters as 0's"
severity warning;
return result;
end;
-- Synopsys translate_on
-- Synopsys translate_off
function tconv ( s : string ) return bit is
variable result : bit;
alias si : string( 1 to s'length ) is s;
variable invalid : boolean := false;
begin
assert s'length = 1
report "String conversion to bit longer that 1 character"
severity warning;
case si(1) is
when '0' => result := '0';
when '1' => result := '1';
when others =>
invalid := true;
result := '0';
end case;
assert not invalid
report "String contained characters other than 0 or 1; " &
"treating invalid characters as 0's"
severity warning;
return result;
end tconv;
-- Synopsys translate_on
-- Synopsys translate_off
function tconv ( s : string ) return bit_vector is
variable result : bit_vector( 1 to s'length );
alias si : string( 1 to s'length ) is s;
variable invalid : boolean := false;
begin
for i in si'range loop
case si(i) is
when '0' => result( i ) := '0';
when '1' => result( i ) := '1';
when others =>
invalid := true;
result( i ) := '0';
end case;
end loop;
assert not invalid
report "String contained characters other than 0 or 1; " &
"treating invalid characters as 0's"
severity warning;
return result( 1 to result'length );
end tconv;
-- Synopsys translate_on
-- Synopsys translate_off
function tconv ( s : string; base : base_t ) return bit_vector is
variable result : bit_vector( 1 to 4*s'length );
alias si : string( 1 to s'length ) is s;
variable invalid : boolean := false;
begin
case base is
when bin =>
for i in si'range loop
case si(i) is
when '0' => result( i ) := '0';
when '1' => result( i ) := '1';
when others =>
invalid := true;
result( i ) := '0';
end case;
end loop;
assert not invalid
report "String contained characters other than 0 or 1; " &
"treated invalid characters as 0's"
severity warning;
return result(1 to s'length) ;
when oct =>
for i in si'range loop
case si(i) is
when '0' => result( (3*i)-2 to 3*i ) := o"0";
when '1' => result( (3*i)-2 to 3*i ) := o"1";
when '2' => result( (3*i)-2 to 3*i ) := o"2";
when '3' => result( (3*i)-2 to 3*i ) := o"3";
when '4' => result( (3*i)-2 to 3*i ) := o"4";
when '5' => result( (3*i)-2 to 3*i ) := o"5";
when '6' => result( (3*i)-2 to 3*i ) := o"6";
when '7' => result( (3*i)-2 to 3*i ) := o"7";
when others =>
invalid := true;
result( (3*i)-2 to 3*i ) := o"0";
end case;
end loop;
assert not invalid
report "String contained characters other than 0 through 7; " &
"treated invalid characters as 0's"
severity warning;
return result( 1 to 3*s'length );
when hex =>
for i in si'range loop
case si(i) is
when '0' => result( (4*i)-3 to 4*i ) := x"0";
when '1' => result( (4*i)-3 to 4*i ) := x"1";
when '2' => result( (4*i)-3 to 4*i ) := x"2";
when '3' => result( (4*i)-3 to 4*i ) := x"3";
when '4' => result( (4*i)-3 to 4*i ) := x"4";
when '5' => result( (4*i)-3 to 4*i ) := x"5";
when '6' => result( (4*i)-3 to 4*i ) := x"6";
when '7' => result( (4*i)-3 to 4*i ) := x"7";
when '8' => result( (4*i)-3 to 4*i ) := x"8";
when '9' => result( (4*i)-3 to 4*i ) := x"9";
when 'A' | 'a' => result( (4*i)-3 to 4*i ) := x"A";
when 'B' | 'b' => result( (4*i)-3 to 4*i ) := x"B";
when 'C' | 'c' => result( (4*i)-3 to 4*i ) := x"C";
when 'D' | 'd' => result( (4*i)-3 to 4*i ) := x"D";
when 'E' | 'e' => result( (4*i)-3 to 4*i ) := x"E";
when 'F' | 'f' => result( (4*i)-3 to 4*i ) := x"F";
when others =>
invalid := true;
result( (4*i)-3 to 4*i ) := x"0";
end case;
end loop;
assert not invalid
report "String contained characters other than 0 through 9 or " &
"A through F; " &
"treated invalid characters as 0's"
severity warning;
return result( 1 to 4*s'length );
when others =>
assert false report "Unsupported base passed." severity warning;
return result ;
end case;
end tconv;
-- Synopsys translate_on
-- Synopsys translate_off
function tconv ( s : string ) return std_ulogic is
variable result : std_ulogic;
alias si : string( 1 to s'length ) is s;
variable invalid : boolean := false;
begin
assert s'length = 1
report "String conversion to bit longer that 1 character"
severity warning;
case si(1) is
when '0' => result := '0';
when '1' => result := '1';
when others =>
invalid := true;
result := 'X';
end case;
assert not invalid
report "String contained characters other than 0 or 1; " &
"treating invalid characters as X's"
severity warning;
return result;
end tconv;
-- Synopsys translate_on
-- Synopsys translate_off
function tconv ( s : string ) return std_ulogic_vector is
variable result : std_ulogic_vector( 1 to s'length );
alias si : string( 1 to s'length ) is s;
variable invalid : boolean := false;
begin
for i in si'range loop
case si(i) is
when '0' => result( i ) := '0';
when '1' => result( i ) := '1';
when others =>
invalid := true;
result( i ) := 'X';
end case;
end loop;
assert not invalid
report "String contained characters other than 0 or 1; " &
"treating invalid characters as X's"
severity warning;
return result( 1 to result'length );
end tconv;
-- Synopsys translate_on
-- Synopsys translate_off
function tconv ( s : string; base : base_t ) return std_ulogic_vector is
variable result : std_ulogic_vector( 1 to 4*s'length );
alias si : string( 1 to s'length ) is s;
variable invalid : boolean := false;
begin
case base is
when bin =>
for i in si'range loop
case si(i) is
when '0' => result( i ) := '0';
when '1' => result( i ) := '1';
when others =>
invalid := true;
result( i ) := '0';
end case;
end loop;
assert not invalid
report "String contained characters other than 0 or 1; " &
"treated invalid characters as 0's"
severity warning;
return result(1 to s'length) ;
when oct =>
for i in si'range loop
case si(i) is
when '0' => result( (3*i)-2 to 3*i ) := "000";
when '1' => result( (3*i)-2 to 3*i ) := "001";
when '2' => result( (3*i)-2 to 3*i ) := "010";
when '3' => result( (3*i)-2 to 3*i ) := "011";
when '4' => result( (3*i)-2 to 3*i ) := "100";
when '5' => result( (3*i)-2 to 3*i ) := "101";
when '6' => result( (3*i)-2 to 3*i ) := "110";
when '7' => result( (3*i)-2 to 3*i ) := "111";
when others =>
invalid := true;
result( (3*i)-2 to 3*i ) := "XXX";
end case;
end loop;
assert not invalid
report "String contained characters other than 0 through 7; " &
"treated invalid characters as X's"
severity warning;
return result( 1 to 3*s'length );
when hex =>
for i in si'range loop
case si(i) is
when '0' => result( (4*i)-3 to 4*i ) := "0000";
when '1' => result( (4*i)-3 to 4*i ) := "0001";
when '2' => result( (4*i)-3 to 4*i ) := "0010";
when '3' => result( (4*i)-3 to 4*i ) := "0011";
when '4' => result( (4*i)-3 to 4*i ) := "0100";
when '5' => result( (4*i)-3 to 4*i ) := "0101";
when '6' => result( (4*i)-3 to 4*i ) := "0110";
when '7' => result( (4*i)-3 to 4*i ) := "0111";
when '8' => result( (4*i)-3 to 4*i ) := "1000";
when '9' => result( (4*i)-3 to 4*i ) := "1001";
when 'A' | 'a' => result( (4*i)-3 to 4*i ) := "1010";
when 'B' | 'b' => result( (4*i)-3 to 4*i ) := "1011";
when 'C' | 'c' => result( (4*i)-3 to 4*i ) := "1100";
when 'D' | 'd' => result( (4*i)-3 to 4*i ) := "1101";
when 'E' | 'e' => result( (4*i)-3 to 4*i ) := "1110";
when 'F' | 'f' => result( (4*i)-3 to 4*i ) := "1111";
when others =>
invalid := true;
result( (4*i)-3 to 4*i ) := "XXXX";
end case;
end loop;
assert not invalid
report "String contained characters other than 0 through 9 or " &
"A through F; " &
"treated invalid characters as X's"
severity warning;
return result( 1 to 4*s'length );
when others =>
assert false report "Unsupported base passed." severity warning;
return result ;
end case;
end tconv;
-- Synopsys translate_on
-------------------------------------------------------------------
-- Std_uLogic Conversions
-------------------------------------------------------------------
function tconv ( s : std_ulogic ) return boolean is
-- pragma built_in SYN_FEED_THRU
begin
case s is
when '0' => return(false);
when '1' => return(true);
when 'L' => return(false);
when 'H' => return(true);
when others => return(false);
end case;
end;
function tconv ( s : std_ulogic ) return bit is
-- pragma built_in SYN_FEED_THRU
begin
case s is
when '0' => return('0');
when '1' => return('1');
when 'L' => return('0');
when 'H' => return('1');
when others => return('0');
end case;
end;
-- Synopsys translate_off
function tconv ( s : std_ulogic ) return character is
begin
case s is
when '0' => return('0');
when 'L' => return('L');
when '1' => return('1');
when 'H' => return('H');
when 'U' => return('U');
when 'W' => return('W');
when '-' => return('-');
when 'Z' => return('Z');
when others => return('X');
end case;
end;
-- Synopsys translate_on
-- Synopsys translate_off
function tconv ( s : std_ulogic ) return string is
begin
case s is
when '0' => return("0");
when 'L' => return("L");
when '1' => return("1");
when 'H' => return("H");
when 'U' => return("U");
when 'W' => return("W");
when '-' => return("-");
when 'Z' => return("Z");
when others => return("X");
end case;
end;
-- Synopsys translate_on
function tconv ( s : std_ulogic ) return integer is
-- pragma built_in SYN_UNSIGNED_TO_INTEGER
begin
case s is
when '0' => return(0);
when 'L' => return(0);
when '1' => return(1);
when 'H' => return(1);
when 'U' => return(0);
when 'W' => return(0);
when '-' => return(0);
when 'Z' => return(0);
when others => return(0);
end case;
end;
function tconv ( s : std_ulogic ) return std_ulogic_vector is
-- pragma built_in SYN_FEED_THRU
begin
case s is
when '0' => return("0");
when 'L' => return("L");
when '1' => return("1");
when 'H' => return("H");
when 'U' => return("U");
when 'W' => return("W");
when '-' => return("-");
when 'Z' => return("Z");
when others => return("X");
end case;
end;
-------------------------------------------------------------------
-- std_ulogic_vector Conversions
-------------------------------------------------------------------
function tconv ( s : std_ulogic_vector ) return bit_vector is
alias sv : std_ulogic_vector ( 1 to s'length ) is s;
variable result : bit_vector ( 1 to s'length ) ;
-- pragma built_in SYN_FEED_THRU
begin
for i in result'range loop
case sv(i) is
when '0' => result(i) := '0';
when '1' => result(i) := '1';
when 'L' => result(i) := '0';
when 'H' => result(i) := '1';
when others => result(i) := '0';
end case;
end loop;
return result;
end;
function tconv ( s : std_ulogic_vector ) return std_logic_vector is
alias sv : std_ulogic_vector ( 1 to s'length ) is s;
variable result : std_logic_vector ( 1 to s'length ) := (others => 'X');
-- pragma built_in SYN_FEED_THRU
begin
for i in result'range loop
case sv(i) is
when '0' => result(i) := '0';
when '1' => result(i) := '1';
when 'L' => result(i) := '0';
when 'H' => result(i) := '1';
when 'W' => result(i) := 'W';
when '-' => result(i) := '-';
when 'U' => result(i) := 'U';
when 'X' => result(i) := 'X';
when 'Z' => result(i) := 'Z';
end case;
end loop;
return result;
end;
function tconv ( s : std_ulogic_vector ) return integer is
variable int_result : integer ;
variable int_exp : integer ;
variable new_value : std_ulogic_vector(1 to s'length) ;
variable invalid : boolean ;
-- pragma built_in SYN_UNSIGNED_TO_INTEGER
begin
-- Synopsys translate_off
int_result := 0;
int_exp := 0;
invalid := false ;
new_value := s ;
for i in new_value'length downto 1 loop
case new_value(i) is
when '1' => int_result := int_result + (2**int_exp);
when '0' => null;
when others =>
invalid := true;
end case;
int_exp := int_exp + 1;
end loop;
assert not invalid
report "The std_ulogic_Vector input contained values " &
"other than '0' and '1'. They were treated as zeroes."
severity warning;
-- Synopsys translate_on
return int_result;
end tconv ;
-- Synopsys translate_off
function tconv ( s : std_ulogic_vector ) return string is
alias sv : std_ulogic_vector ( 1 to s'length ) is s;
variable result : string ( 1 to s'length ) := (others => 'X');
begin
for i in result'range loop
case sv(i) is
when '0' => result(i) := '0';
when 'L' => result(i) := 'L';
when '1' => result(i) := '1';
when 'H' => result(i) := 'H';
when 'U' => result(i) := 'U';
when '-' => result(i) := '-';
when 'W' => result(i) := 'W';
when 'Z' => result(i) := 'Z';
when others => result(i) := 'X';
end case;
end loop;
return result;
end;
-- Synopsys translate_on
-- Synopsys translate_off
function tconv ( s : std_ulogic_vector; base : base_t ) return string is
alias sv : std_ulogic_vector ( 1 to s'length ) is s;
variable result : string ( 1 to s'length );
variable start : positive;
variable extra : natural;
variable resultLength : positive;
subtype bv is std_ulogic_vector( 1 to 1 );
subtype qv is std_ulogic_vector( 1 to 2 );
subtype ov is std_ulogic_vector( 1 to 3 );
subtype hv is std_ulogic_vector( 1 to 4 );
begin
case base is
when bin =>
resultLength := sv'length;
start := 1;
for i in start to resultLength loop
case sv( i ) is
when '0' => result( i ) := '0';
when '1' => result( i ) := '1';
when 'X' => result( i ) := 'X';
when 'L' => result( i ) := 'L';
when 'H' => result( i ) := 'H';
when 'W' => result( i ) := 'W';
when '-' => result( i ) := '-';
when 'U' => result( i ) := 'U';
when 'Z' => result( i ) := 'Z';
end case;
end loop;
when oct =>
extra := sv'length rem ov'length;
case extra is
when 0 =>
resultLength := s'length/ov'length;
start := 1;
when 1 =>
resultLength := ( s'length/ov'length ) + 1;
start := 2;
case sv( 1 ) is
when '0' => result( 1 ) := '0';
when '1' => result( 1 ) := '1';
when '-' => result( 1 ) := '-';
when 'X' => result( 1 ) := 'X';
when 'U' => result( 1 ) := 'U';
when 'Z' => result( 1 ) := 'Z';
when others => result( 1 ) := '.';
end case;
when 2 =>
resultLength := ( s'length/ov'length ) + 1;
start := 2;
case qv'( sv( 1 to 2 ) ) is
when "00" => result( 1 ) := '0';
when "01" => result( 1 ) := '1';
when "10" => result( 1 ) := '2';
when "11" => result( 1 ) := '3';
when "--" => result( 1 ) := '-';
when "XX" => result( 1 ) := 'X';
when "UU" => result( 1 ) := 'U';
when "ZZ" => result( 1 ) := 'Z';
when others => result( 1 ) := '.';
end case;
when others =>
assert false report "TCONV fatal condition" severity failure;
end case;
for i in 0 to resultLength - start loop
case ov'( SV( (ov'length*i)+(extra+1) to (ov'length*i)+(extra+3) ) ) is
when "000" => result( i+start ) := '0';
when "001" => result( i+start ) := '1';
when "010" => result( i+start ) := '2';
when "011" => result( i+start ) := '3';
when "100" => result( i+start ) := '4';
when "101" => result( i+start ) := '5';
when "110" => result( i+start ) := '6';
when "111" => result( i+start ) := '7';
when "---" => result( i+start ) := '-';
when "XXX" => result( i+start ) := 'X';
when "UUU" => result( i+start ) := 'U';
when "ZZZ" => result( i+start ) := 'Z';
when others => result( i+start ) := '.';
end case;
end loop;
when hex =>
extra := s'length rem hv'length;
case extra is
when 0 =>
resultLength := s'length/hv'length;
start := 1;
when 1 =>
resultLength := ( s'length/hv'length ) + 1;
start := 2;
case sv( 1 ) is
when '0' => result( 1 ) := '0';
when '1' => result( 1 ) := '1';
when '-' => result( 1 ) := '-';
when 'X' => result( 1 ) := 'X';
when 'U' => result( 1 ) := 'U';
when 'Z' => result( 1 ) := 'Z';
when others => result( 1 ) := '.';
end case;
when 2 =>
resultLength := ( s'length/hv'length ) + 1;
start := 2;
case qv'( sv( 1 to 2 ) ) is
when "00" => result( 1 ) := '0';
when "01" => result( 1 ) := '1';
when "10" => result( 1 ) := '2';
when "11" => result( 1 ) := '3';
when "--" => result( 1 ) := '-';
when "XX" => result( 1 ) := 'X';
when "UU" => result( 1 ) := 'U';
when "ZZ" => result( 1 ) := 'Z';
when others => result( 1 ) := '.';
end case;
when 3 =>
resultLength := ( s'length/hv'length ) + 1;
start := 2;
case ov'( sv( 1 to 3 ) ) is
when "000" => result( 1 ) := '0';
when "001" => result( 1 ) := '1';
when "010" => result( 1 ) := '2';
when "011" => result( 1 ) := '3';
when "100" => result( 1 ) := '4';
when "101" => result( 1 ) := '5';
when "110" => result( 1 ) := '6';
when "111" => result( 1 ) := '7';
when "---" => result( 1 ) := '-';
when "XXX" => result( 1 ) := 'X';
when "UUU" => result( 1 ) := 'U';
when "ZZZ" => result( 1 ) := 'Z';
when others => result( 1 ) := '.';
end case;
when others =>
assert false report "TCONV fatal condition" severity failure;
end case;
for i in 0 to resultLength - start loop
case hv'( SV( (hv'length*i)+(extra+1) to (hv'length*i)+(extra+4) ) ) is
when "0000" => result( i+start ) := '0';
when "0001" => result( i+start ) := '1';
when "0010" => result( i+start ) := '2';
when "0011" => result( i+start ) := '3';
when "0100" => result( i+start ) := '4';
when "0101" => result( i+start ) := '5';
when "0110" => result( i+start ) := '6';
when "0111" => result( i+start ) := '7';
when "1000" => result( i+start ) := '8';
when "1001" => result( i+start ) := '9';
when "1010" => result( i+start ) := 'A';
when "1011" => result( i+start ) := 'B';
when "1100" => result( i+start ) := 'C';
when "1101" => result( i+start ) := 'D';
when "1110" => result( i+start ) := 'E';
when "1111" => result( i+start ) := 'F';
when "----" => result( i+start ) := '-';
when "XXXX" => result( i+start ) := 'X';
when "UUUU" => result( i+start ) := 'U';
when "ZZZZ" => result( i+start ) := 'Z';
when others => result( i+start ) := '.';
end case;
end loop;
when others =>
assert false report "Unsupported base passed." severity warning;
end case;
return result( 1 to resultLength );
end;
-- Synopsys translate_on
function tconv ( s : std_ulogic_vector ) return std_ulogic is
alias sv : std_ulogic_vector( 1 to s'length ) is s;
variable result : std_ulogic;
-- pragma built_in SYN_FEED_THRU
begin
case sv(s'length) is
when '0' => return('0');
when 'L' => return('L');
when '1' => return('1');
when 'H' => return('H');
when 'U' => return('U');
when 'W' => return('W');
when '-' => return('-');
when 'Z' => return('Z');
when others => return('X');
end case;
end;
-------------------------------------------------------------------
-- std_logic_vector Conversions
-------------------------------------------------------------------
--function tconv ( s : std_logic_vector ) return bit_vector is
-- alias sv : std_logic_vector ( 1 to s'length ) is s;
-- variable result : bit_vector ( 1 to s'length ) := (others => '0');
---- pragma built_in SYN_FEED_THRU
--begin
-- for i in result'range loop
-- case sv(i) is
-- when '0' => result(i) := '0';
-- when '1' => result(i) := '1';
-- when 'L' => result(i) := '0';
-- when 'H' => result(i) := '1';
-- when others => result(i) := '0';
-- end case;
-- end loop;
-- return result;
--end;
--function tconv ( s : std_logic_vector ) return std_ulogic_vector is
-- alias sv : std_logic_vector ( 1 to s'length ) is s;
-- variable result : std_ulogic_vector ( 1 to s'length ) := (others => 'X');
---- pragma built_in SYN_FEED_THRU
--begin
-- for i in result'range loop
-- case sv(i) is
-- when '0' => result(i) := '0';
-- when '1' => result(i) := '1';
-- when 'L' => result(i) := '0';
-- when 'H' => result(i) := '1';
-- when 'W' => result(i) := 'W';
-- when '-' => result(i) := '-';
-- when 'U' => result(i) := 'U';
-- when 'X' => result(i) := 'X';
-- when 'Z' => result(i) := 'Z';
-- end case;
-- end loop;
-- return result;
--end;
--function tconv ( s : std_logic_vector ) return integer is
-- variable int_result : integer := 0;
-- variable int_exp : integer := 0;
-- alias new_value : std_logic_vector(1 to s'length) is s ;
-- variable invalid : boolean := false;
---- pragma built_in SYN_UNSIGNED_TO_INTEGER
--begin
---- Synopsys translate_off
-- for i in new_value'length downto 1 loop
-- case new_value(i) is
-- when '1' => int_result := int_result + (2**int_exp);
-- when '0' => null;
-- when others =>
-- invalid := true;
-- end case;
-- int_exp := int_exp + 1;
-- end loop;
-- assert not invalid
-- report "The std_logic_Vector input contained values " &
-- "other than '0' and '1'. They were treated as zeroes."
-- severity warning;
---- Synopsys translate_on
-- return int_result;
--end tconv ;
-- Synopsys translate_off
--function tconv ( s : std_logic_vector ) return string is
-- alias sv : std_logic_vector ( 1 to s'length ) is s;
-- variable result : string ( 1 to s'length ) := (others => 'X');
--begin
-- for i in result'range loop
-- case sv(i) is
-- when '0' => result(i) := '0';
-- when 'L' => result(i) := 'L';
-- when '1' => result(i) := '1';
-- when 'H' => result(i) := 'H';
-- when 'U' => result(i) := 'U';
-- when '-' => result(i) := '-';
-- when 'W' => result(i) := 'W';
-- when 'Z' => result(i) := 'Z';
-- when others => result(i) := 'X';
-- end case;
-- end loop;
-- return result;
--end;
-- Synopsys translate_on
-- Synopsys translate_off
--function tconv ( s : std_logic_vector; base : base_t ) return string is
-- alias sv : std_logic_vector ( 1 to s'length ) is s;
-- variable result : string ( 1 to s'length );
-- variable start : positive;
-- variable extra : natural;
-- variable resultlength : positive;
-- subtype bv is std_logic_vector( 1 to 1 );
-- subtype qv is std_logic_vector( 1 to 2 );
-- subtype ov is std_logic_vector( 1 to 3 );
-- subtype hv is std_logic_vector( 1 to 4 );
--begin
-- case base is
-- when bin =>
-- resultLength := sv'length;
-- start := 1;
-- for i in start to resultLength loop
-- case sv( i ) is
-- when '0' => result( i ) := '0';
-- when '1' => result( i ) := '1';
-- when 'X' => result( i ) := 'X';
-- when 'L' => result( i ) := 'L';
-- when 'H' => result( i ) := 'H';
-- when 'W' => result( i ) := 'W';
-- when '-' => result( i ) := '-';
-- when 'U' => result( i ) := 'U';
-- when 'Z' => result( i ) := 'Z';
-- end case;
-- end loop;
-- when oct =>
-- extra := sv'length rem ov'length;
-- case extra is
-- when 0 =>
-- resultLength := s'length/ov'length;
-- start := 1;
-- when 1 =>
-- resultLength := ( s'length/ov'length ) + 1;
-- start := 2;
-- case sv( 1 ) is
-- when '0' => result( 1 ) := '0';
-- when '1' => result( 1 ) := '1';
-- when '-' => result( 1 ) := '-';
-- when 'X' => result( 1 ) := 'X';
-- when 'U' => result( 1 ) := 'U';
-- when 'Z' => result( 1 ) := 'Z';
-- when others => result( 1 ) := '.';
-- end case;
-- when 2 =>
-- resultLength := ( s'length/ov'length ) + 1;
-- start := 2;
-- case qv'( sv( 1 to 2 ) ) is
-- when "00" => result( 1 ) := '0';
-- when "01" => result( 1 ) := '1';
-- when "10" => result( 1 ) := '2';
-- when "11" => result( 1 ) := '3';
-- when "--" => result( 1 ) := '-';
-- when "XX" => result( 1 ) := 'X';
-- when "UU" => result( 1 ) := 'U';
-- when "ZZ" => result( 1 ) := 'Z';
-- when others => result( 1 ) := '.';
-- end case;
-- when others =>
-- assert false report "TCONV fatal condition" severity failure;
-- end case;
-- for i in 0 to resultLength - start loop
-- case ov'( sv( (ov'length*i)+(extra+1) to (ov'length*i)+(extra+3) ) ) is
-- when "000" => result( i+start ) := '0';
-- when "001" => result( i+start ) := '1';
-- when "010" => result( i+start ) := '2';
-- when "011" => result( i+start ) := '3';
-- when "100" => result( i+start ) := '4';
-- when "101" => result( i+start ) := '5';
-- when "110" => result( i+start ) := '6';
-- when "111" => result( i+start ) := '7';
-- when "---" => result( i+start ) := '-';
-- when "XXX" => result( i+start ) := 'X';
-- when "UUU" => result( i+start ) := 'U';
-- when "ZZZ" => result( i+start ) := 'Z';
-- when others => result( i+start ) := '.';
-- end case;
-- end loop;
-- when hex =>
-- extra := s'length rem hv'length;
-- case extra is
-- when 0 =>
-- resultLength := s'length/hv'length;
-- start := 1;
-- when 1 =>
-- resultLength := ( s'length/hv'length ) + 1;
-- start := 2;
-- case sv( 1 ) is
-- when '0' => result( 1 ) := '0';
-- when '1' => result( 1 ) := '1';
-- when '-' => result( 1 ) := '-';
-- when 'X' => result( 1 ) := 'X';
-- when 'U' => result( 1 ) := 'U';
-- when 'Z' => result( 1 ) := 'Z';
-- when others => result( 1 ) := '.';
-- end case;
-- when 2 =>
-- resultLength := ( s'length/hv'length ) + 1;
-- start := 2;
-- case qv'( sv( 1 to 2 ) ) is
-- when "00" => result( 1 ) := '0';
-- when "01" => result( 1 ) := '1';
-- when "10" => result( 1 ) := '2';
-- when "11" => result( 1 ) := '3';
-- when "--" => result( 1 ) := '-';
-- when "XX" => result( 1 ) := 'X';
-- when "UU" => result( 1 ) := 'U';
-- when "ZZ" => result( 1 ) := 'Z';
-- when others => result( 1 ) := '.';
-- end case;
-- when 3 =>
-- resultLength := ( s'length/hv'length ) + 1;
-- start := 2;
-- case ov'( sv( 1 to 3 ) ) is
-- when "000" => result( 1 ) := '0';
-- when "001" => result( 1 ) := '1';
-- when "010" => result( 1 ) := '2';
-- when "011" => result( 1 ) := '3';
-- when "100" => result( 1 ) := '4';
-- when "101" => result( 1 ) := '5';
-- when "110" => result( 1 ) := '6';
-- when "111" => result( 1 ) := '7';
-- when "---" => result( 1 ) := '-';
-- when "XXX" => result( 1 ) := 'X';
-- when "UUU" => result( 1 ) := 'U';
-- when "ZZZ" => result( 1 ) := 'Z';
-- when others => result( 1 ) := '.';
-- end case;
-- when others =>
-- assert false report "TCONV fatal condition" severity failure;
-- end case;
-- for i in 0 to resultLength - start loop
-- case hv'( SV( (hv'length*i)+(extra+1) to (hv'length*i)+(extra+4) ) ) is
-- when "0000" => result( i+start ) := '0';
-- when "0001" => result( i+start ) := '1';
-- when "0010" => result( i+start ) := '2';
-- when "0011" => result( i+start ) := '3';
-- when "0100" => result( i+start ) := '4';
-- when "0101" => result( i+start ) := '5';
-- when "0110" => result( i+start ) := '6';
-- when "0111" => result( i+start ) := '7';
-- when "1000" => result( i+start ) := '8';
-- when "1001" => result( i+start ) := '9';
-- when "1010" => result( i+start ) := 'A';
-- when "1011" => result( i+start ) := 'B';
-- when "1100" => result( i+start ) := 'C';
-- when "1101" => result( i+start ) := 'D';
-- when "1110" => result( i+start ) := 'E';
-- when "1111" => result( i+start ) := 'F';
-- when "----" => result( i+start ) := '-';
-- when "XXXX" => result( i+start ) := 'X';
-- when "UUUU" => result( i+start ) := 'U';
-- when "ZZZZ" => result( i+start ) := 'Z';
-- when others => result( i+start ) := '.';
-- end case;
-- end loop;
-- when others =>
-- assert false report "Unsupported base passed." severity warning;
-- end case;
-- return result( 1 to resultLength );
--end;
-- Synopsys translate_on
-- Synopsys translate_off
function hexstring( d : std_ulogic_vector ) return string is
variable nd :
Std_Ulogic_vector( 0 to ((d'length + (4 - (d'length mod 4))) - 1) ) := ( others => '0' );
variable r : string(1 to (nd'length/4));
variable hexsize : integer;
variable offset : integer;
subtype iv4 is Std_Ulogic_vector(1 to 4);
begin
offset := d'length mod 4;
if offset = 0 then
hexsize := d'length / 4;
nd( 0 to d'length - 1 ) := d;
else
hexsize := nd'length / 4;
nd( ( nd'left + (4 - offset) ) to nd'right ) := d;
end if;
for i in 0 to hexsize - 1 loop
case iv4( nd( ( i * 4 ) to ( ( i * 4 ) + 3 ) ) ) is
when "0000" => r(i + 1) := '0';
when "0001" => r(i + 1) := '1';
when "0010" => r(i + 1) := '2';
when "0011" => r(i + 1) := '3';
when "0100" => r(i + 1) := '4';
when "0101" => r(i + 1) := '5';
when "0110" => r(i + 1) := '6';
when "0111" => r(i + 1) := '7';
when "1000" => r(i + 1) := '8';
when "1001" => r(i + 1) := '9';
when "1010" => r(i + 1) := 'A';
when "1011" => r(i + 1) := 'B';
when "1100" => r(i + 1) := 'C';
when "1101" => r(i + 1) := 'D';
when "1110" => r(i + 1) := 'E';
when "1111" => r(i + 1) := 'F';
when "----" => r(i + 1) := '-';
when "XXXX" => r(i + 1) := 'X';
when "UUUU" => r(i + 1) := 'U';
when "ZZZZ" => r(i + 1) := 'Z';
when others => r(i + 1) := '.';
end case;
end loop;
return r(1 to hexsize);
end hexstring;
-- Synopsys translate_on
-- Synopsys translate_off
function octstring( d : std_ulogic_vector ) return string is
variable nd :
Std_Ulogic_vector( 0 to ((d'length + (3 - (d'length mod 3))) - 1) ) := ( others => '0' );
variable offset : integer;
variable r : string(1 to (nd'length/3));
variable octsize : integer;
subtype iv3 is Std_Ulogic_vector(1 to 3);
begin
offset := d'length mod 3;
if offset = 0 then
octsize := d'length / 3;
nd( 0 to d'length - 1 ) := d;
else
octsize := nd'length / 3;
nd( ( nd'left + (3 - offset) ) to nd'right ) := d;
end if;
for i in 0 to octsize - 1 loop
case iv3( nd( ( i * 3 ) to ( ( i * 3 ) + 2 ) ) ) is
when "000" => r(i + 1) := '0';
when "001" => r(i + 1) := '1';
when "010" => r(i + 1) := '2';
when "011" => r(i + 1) := '3';
when "100" => r(i + 1) := '4';
when "101" => r(i + 1) := '5';
when "110" => r(i + 1) := '6';
when "111" => r(i + 1) := '7';
when "---" => r(i + 1) := '-';
when "XXX" => r(i + 1) := 'X';
when "UUU" => r(i + 1) := 'U';
when "ZZZ" => r(i + 1) := 'Z';
when others => r(i + 1) := '.';
end case;
end loop;
return r;
end octstring;
-- Synopsys translate_on
-- Synopsys translate_off
function bitstring( d : std_ulogic_vector ) return string is
variable nd :
Std_Ulogic_vector(0 to ( d'length - 1 ) ) := ( others => '0' );
variable r : string(1 to (nd'length));
begin
nd := d;
for i in nd'range loop
r(i + 1) := std_ulogic_to_character( nd(i) );
end loop;
return r;
end bitstring;
-- Synopsys translate_on
-------------------------------------------------------------------
-- Std_Match functions
-------------------------------------------------------------------
constant no_warning: boolean := false; -- default to emit warnings
-- Id: M.1a
function std_match (l, r: std_ulogic) return std_ulogic is
begin
if (l ?= r) then
return '1' ;
else
return '0' ;
end if ;
end std_match;
-- Id: M.4b
function std_match (l, r: std_ulogic_vector) return std_ulogic is
variable result : boolean ;
begin
if (l ?= r) then
return '1' ;
else
return '0' ;
end if;
end std_match;
-------------------------------------------------------------------
-- Overloaded Relational Operators returning std_ulogic
-------------------------------------------------------------------
function "=" ( l,r : integer ) return std_ulogic is
-- pragma built_in SYN_EQL
begin
if (l - r) = 0 then
return ('1');
else
return ('0');
end if ;
end "=";
function "/=" ( l,r : integer ) return std_ulogic is
-- pragma built_in SYN_NEQ
begin
if (l - r) = 0 then
return ('0');
else
return ('1');
end if ;
end "/=";
function ">" ( l,r : integer ) return std_ulogic is
-- pragma built_in SYN_GT
begin
if (l - r) > 0 then
return ('1');
else
return ('0');
end if ;
end ">";
function ">=" ( l,r : integer ) return std_ulogic is
-- pragma built_in SYN_GEQ
begin
if (l - r) >= 0 then
return ('1');
else
return ('0');
end if ;
end ">=";
function "<" ( l,r : integer ) return std_ulogic is
-- pragma built_in SYN_LT
begin
if (r - l) > 0 then
return ('1');
else
return ('0');
end if ;
end "<";
function "<=" ( l,r : integer ) return std_ulogic is
-- pragma built_in SYN_LEQ
begin
if (r - l) >= 0 then
return ('1');
else
return ('0');
end if ;
end "<=";
-------------------------------------------------------------------
-- Overloaded Relational Operators returning STD_uLogic
-------------------------------------------------------------------
function "=" ( l,r : std_ulogic ) return std_ulogic is
-- pragma built_in SYN_EQL
begin
return ( tconv( l = r ) );
end "=";
function "/=" ( l,r : std_ulogic ) return std_ulogic is
-- pragma built_in SYN_NEQ
begin
return ( tconv( l /= r ) );
end "/=";
function ">" ( l,r : std_ulogic ) return std_ulogic is
-- pragma built_in SYN_GT
begin
return ( tconv( l > r ) );
end ">";
function ">=" ( l,r : std_ulogic ) return std_ulogic is
-- pragma built_in SYN_GEQ
begin
return ( tconv( l >= r ) );
end ">=";
function "<" ( l,r : std_ulogic ) return std_ulogic is
-- pragma built_in SYN_LT
begin
return ( tconv( l < r ) );
end "<";
function "<=" ( l,r : std_ulogic ) return std_ulogic is
-- pragma built_in SYN_LEQ
begin
return ( tconv( l <= r ) );
end "<=";
-------------------------------------------------------------------
-- Overloaded Relational Operators returning STD_uLogic
-------------------------------------------------------------------
function "=" ( l,r : std_ulogic_vector) return std_ulogic is
-- pragma built_in SYN_EQL
begin
-- Synopsys translate_off
if l'length /= r'length then
assert false
report "The bit lengths of the two inputs to the = " &
"operator are unequal. "
severity error;
return '0' ;
end if ;
-- Synopsys translate_on
return ( tconv( l = r ) );
end "=";
-------------------------------------------------------------------
function "/=" ( l,r : std_ulogic_vector) return std_ulogic is
-- pragma built_in SYN_NEQ
begin
-- Synopsys translate_off
if l'length /= r'length then
assert false
report "The bit lengths of the two inputs to the /= " &
"operator are unequal. "
severity error;
return '0' ;
end if ;
-- Synopsys translate_on
return ( tconv( l /= r ) );
end "/=";
-------------------------------------------------------------------
function ">" ( l,r : std_ulogic_vector) return std_ulogic is
-- pragma built_in SYN_GT
begin
-- Synopsys translate_off
if l'length /= r'length then
assert false
report "The bit lengths of the two inputs to the > " &
"operator are unequal. "
severity error;
return '0' ;
end if ;
-- Synopsys translate_on
return ( tconv( l > r ) );
end ">";
-------------------------------------------------------------------
function ">=" ( l,r : std_ulogic_vector) return std_ulogic is
-- pragma built_in SYN_GEQ
begin
-- Synopsys translate_off
if l'length /= r'length then
assert false
report "The bit lengths of the two inputs to the >= " &
"operator are unequal. "
severity error;
return '0' ;
end if ;
-- Synopsys translate_on
return ( tconv( l >= r ) );
end ">=";
-------------------------------------------------------------------
function "<" ( l,r : std_ulogic_vector) return std_ulogic is
-- pragma built_in SYN_LT
begin
-- Synopsys translate_off
if l'length /= r'length then
assert false
report "The bit lengths of the two inputs to the < " &
"operator are unequal. "
severity error;
return '0' ;
end if ;
-- Synopsys translate_on
return ( tconv( l < r ) );
end "<";
-------------------------------------------------------------------
function "<=" ( l,r : std_ulogic_vector) return std_ulogic is
-- pragma built_in SYN_LEQ
begin
-- Synopsys translate_off
if l'length /= r'length then
assert false
report "The bit lengths of the two inputs to the <= " &
"operator are unequal. "
severity error;
return '0' ;
end if ;
-- Synopsys translate_on
return ( tconv( l <= r ) );
end "<=";
--==============================================================
-- Shift and Rotate Functions
--==============================================================
----------Local Subprograms - shift/rotate ops-------------------
-- Synopsys translate_off
constant NAU: std_ulogic_vector(0 downto 1) := (others => '0');
-- Synopsys translate_on
function xsll (arg: std_ulogic_vector; count: natural) return std_ulogic_vector
is
constant arg_l: integer := arg'length-1;
alias xarg: std_ulogic_vector(arg_l downto 0) is arg;
variable result: std_ulogic_vector(arg_l downto 0) ;
-- pragma built_in SYN_SLLU
begin
result := (others => '0');
if count <= arg_l then
result(arg_l downto count) := xarg(arg_l-count downto 0);
end if;
return result;
end xsll;
function xsrl (arg: std_ulogic_vector; count: natural) return std_ulogic_vector
is
constant arg_l: integer := arg'length-1;
alias xarg: std_ulogic_vector(arg_l downto 0) is arg;
variable result: std_ulogic_vector(arg_l downto 0) ;
-- pragma built_in SYN_SRLU
begin
result := (others => '0');
if count <= arg_l then
result(arg_l-count downto 0) := xarg(arg_l downto count);
end if;
return result;
end xsrl;
function xsra (arg: std_ulogic_vector; count: natural) return std_ulogic_vector
is
constant arg_l: integer := arg'length-1;
alias xarg: std_ulogic_vector(arg_l downto 0) is arg;
variable result: std_ulogic_vector(arg_l downto 0);
variable xcount: natural ;
-- pragma built_in SYN_SHR
begin
xcount := count;
if ((arg'length <= 1) or (xcount = 0)) then return arg;
else
if (xcount > arg_l) then xcount := arg_l;
end if;
result(arg_l-xcount downto 0) := xarg(arg_l downto xcount);
result(arg_l downto (arg_l - xcount + 1)) := (others => xarg(arg_l));
end if;
return result;
end xsra;
function xrol (arg: std_ulogic_vector; count: natural) return std_ulogic_vector
is
constant arg_l: integer := arg'length-1;
alias xarg: std_ulogic_vector(arg_l downto 0) is arg;
variable result: std_ulogic_vector(arg_l downto 0) ;
variable countm: integer;
-- pragma built_in SYN_ROLU
begin
result := xarg;
countm := count mod (arg_l + 1);
if countm /= 0 then
result(arg_l downto countm) := xarg(arg_l-countm downto 0);
result(countm-1 downto 0) := xarg(arg_l downto arg_l-countm+1);
end if;
return result;
end xrol;
function xror (arg: std_ulogic_vector; count: natural) return std_ulogic_vector
is
constant arg_l: integer := arg'length-1;
alias xarg: std_ulogic_vector(arg_l downto 0) is arg;
variable result: std_ulogic_vector(arg_l downto 0) ;
variable countm: integer;
-- pragma built_in SYN_RORU
begin
countm := count mod (arg_l + 1);
result := xarg;
if countm /= 0 then
result(arg_l-countm downto 0) := xarg(arg_l downto countm);
result(arg_l downto arg_l-countm+1) := xarg(countm-1 downto 0);
end if;
return result;
end xror;
--===================================================================
-- Id: S.1
function shift_left (arg: std_ulogic_vector; count: natural) return std_ulogic_vector is
-- pragma built_in SYN_SLLU
begin
-- Synopsys translate_off
if (arg'length < 1) then return NAU;
end if;
-- Synopsys translate_on
return std_ulogic_vector( xsll( std_ulogic_vector(arg), count ) );
end shift_left;
-- Id: S.2
function shift_right (arg: std_ulogic_vector; count: natural) return std_ulogic_vector is
-- pragma built_in SYN_SRLU
begin
-- Synopsys translate_off
if (arg'length < 1) then return NAU;
end if;
-- Synopsys translate_on
return std_ulogic_vector( xsrl( std_ulogic_vector(arg), count ) );
end shift_right;
-- Id: S.5
function rotate_left (arg: std_ulogic_vector; count: natural) return std_ulogic_vector is
-- pragma built_in SYN_ROLU
begin
-- Synopsys translate_off
if (arg'length < 1) then return NAU;
end if;
-- Synopsys translate_on
return std_ulogic_vector( xrol( std_ulogic_vector(arg), count ) );
end rotate_left;
-- Id: S.6
function rotate_right (arg: std_ulogic_vector; count: natural) return std_ulogic_vector is
-- pragma built_in SYN_RORU
begin
-- Synopsys translate_off
if (arg'length < 1) then return NAU;
end if;
-- Synopsys translate_on
return std_ulogic_vector( xror( std_ulogic_vector(arg), count ) );
end rotate_right;
-- Id: S.9
function "sll" (arg: std_ulogic_vector; count: integer) return std_ulogic_vector is
-- pragma built_in SYN_SLL
begin
if (count >= 0) then
return shift_left(arg, count);
else
return shift_right(arg, -count);
end if;
end "sll";
-- Id: S.11
function "srl" (arg: std_ulogic_vector; count: integer) return std_ulogic_vector is
-- pragma built_in SYN_SRL
begin
if (count >= 0) then
return shift_right(arg, count);
else
return shift_left(arg, -count);
end if;
end "srl";
-- Id: S.13
function "rol" (arg: std_ulogic_vector; count: integer) return std_ulogic_vector is
-- pragma built_in SYN_ROL
begin
if (count >= 0) then
return rotate_left(arg, count);
else
return rotate_right(arg, -count);
end if;
end "rol";
-- Id: S.15
function "ror" (arg: std_ulogic_vector; count: integer) return std_ulogic_vector is
-- pragma built_in SYN_ROR
begin
if (count >= 0) then
return rotate_right(arg, count);
else
return rotate_left(arg, -count);
end if;
end "ror";
--==============================================================
--End Shift and Rotate Functions
--==============================================================
end std_ulogic_support ;
Reference in New Issue View Git Blame Copy Permalink