--
--
--                                   DISCLAIMER
--
--        This code is the sole property of the Institute for Technology
--        Development (ITD), Jackson, Mississippi, and is distributed for
--        the purpose of providing examples of VHDL models written to
--        modeling standards.  This code may not be used for commercial
--        purposes, and may not be redistributed without permission from
--        the Institute for Technology Development.  ITD assumes no 
--        responsibility for errors, omissions, uses made, or decisions
--        based on its use.  No warranties, expressed or implied, are given.
--
--        ------------------------------------------------------------------

------------------------------------------------------------------------------
------------------------------------------------------------------------------
package body BASICDEFS is
-----------------------------------------------------------------------
--
--   The following is a preliminary definition of the basic logic system 
--   and associated operators/functions used for the EIA VHDL Model 
--   Commercial Component Specification.
--
--   Created by Dave Cantwell/Hughes  (714-670-4677)
--            & Len Finegold/General Dynamics 
--
--   COPYRIGHT C Hughes Aircraft Co. 1989
--   Created 1/25/90
--   Version 0.1
------------------------------------------------------------------------
-- CONSTANT DECLARATIONS FOR USE IN SIGNAL & VARIABLE ASSIGNMENTS
------------------------------------------------------------------------
   constant MAX_SIZE : POSITIVE := 32;  -- This is a deferred constant 
    		  -- which should be initialized to the largest size bus 
                  -- in design

   constant UNINITIALIZED : logic_mv := 'U';
   constant UNKNOWN       : logic_mv := 'X';
   constant ZERO          : logic_mv := '0';
   constant ONE           : logic_mv := '1';
   constant HIGHZ         : logic_mv := 'Z';
   constant LOW           : logic_mv := 'L';
   constant HIGH          : logic_mv := 'H';
   constant UNDRIVEN      : logic_mv := 'W';

   constant ALL_UNINITIALIZED  : logic_mv_vector(MAX_SIZE-1 DOWNTO 0) 
				:= (others => UNINITIALIZED);
   constant ALL_UNKNOWN       : logic_mv_vector(MAX_SIZE-1 DOWNTO 0) 
				:= (others => UNKNOWN);
   constant ALL_ZERO          : logic_mv_vector(MAX_SIZE-1 DOWNTO 0) 
				:= (others => ZERO);
   constant ALL_ONE           : logic_mv_vector(MAX_SIZE-1 DOWNTO 0) 
				:= (others => ONE);
   constant ALL_HIGHZ         : logic_mv_vector(MAX_SIZE-1 DOWNTO 0)
				:= (others => HIGHZ);
   constant ALL_LOW           : logic_mv_vector(MAX_SIZE-1 DOWNTO 0) 
				:= (others => LOW);
   constant ALL_HIGH          : logic_mv_vector(MAX_SIZE-1 DOWNTO 0)
				:= (others => HIGH);
--
------------------------------------------------------------------------
-- TYPE DECLARATIONS FOR USE IN SUBPROGRAM BODIES
------------------------------------------------------------------------
--
   type logic_mv_array is array (logic_mv) of logic_mv;
--
------------------------------------------------------------------------
-- SCALAR FUNCTIONS
------------------------------------------------------------------------
--
FUNCTION "and" ( i1,i2 :  logic_mv )	RETURN logic_mv is

   constant Table  : logic_mv_table :=
--        U        X        0        1        Z        L        H        W
      ((UNINITIALIZED, UNINITIALIZED, ZERO,    UNINITIALIZED, UNINITIALIZED, ZERO,    UNINITIALIZED, UNINITIALIZED), -- U 
       (UNINITIALIZED, UNKNOWN, ZERO,    UNKNOWN, UNKNOWN, ZERO,    UNKNOWN, UNKNOWN), -- X
       (ZERO,    ZERO,    ZERO,    ZERO,    ZERO,    ZERO,    ZERO,    ZERO   ), -- 0
       (UNINITIALIZED, UNKNOWN, ZERO,    ONE,     UNKNOWN, ZERO,    ONE,     UNKNOWN), -- 1
       (UNINITIALIZED, UNKNOWN, ZERO,    UNKNOWN, UNKNOWN, ZERO,    UNKNOWN, UNKNOWN), -- Z
       (ZERO,    ZERO,    ZERO,    ZERO,    ZERO,    ZERO,    ZERO,    ZERO   ), -- L
       (UNINITIALIZED, UNKNOWN, ZERO,    ONE,     UNKNOWN, ZERO,    ONE,     UNKNOWN), -- H
       (UNINITIALIZED, UNKNOWN, ZERO,    UNKNOWN, UNKNOWN, ZERO,    UNKNOWN, UNKNOWN));-- W
       

BEGIN
   
RETURN Table(i1, i2);

END "and";
------------------------------------------------------------------------

FUNCTION "nand" ( i1,i2 :  logic_mv )	RETURN logic_mv is

   constant Table  : logic_mv_table :=
--        U        X        0        1        Z        L        H       W   
      ((UNINITIALIZED, UNINITIALIZED, ONE,     UNINITIALIZED, UNINITIALIZED, ONE,     UNINITIALIZED, UNINITIALIZED), -- U
       (UNINITIALIZED, UNKNOWN, ONE,     UNKNOWN, UNKNOWN, ONE,     UNKNOWN, UNKNOWN), -- X
       (ONE,     ONE,     ONE,     ONE,     ONE,     ONE,     ONE,     ONE    ), -- 0
       (UNINITIALIZED, UNKNOWN, ONE,     ZERO,    UNKNOWN, ONE,     ZERO,    UNKNOWN), -- 1
       (UNINITIALIZED, UNKNOWN, ONE,     UNKNOWN, UNKNOWN, ONE,     UNKNOWN, UNKNOWN), -- Z
       (ONE,     ONE,     ONE,     ONE,     ONE,     ONE,     ONE,     ONE    ), -- L
       (UNINITIALIZED, UNKNOWN, ONE,     ZERO,    UNKNOWN, ONE,     ZERO,    UNKNOWN), -- H
       (UNINITIALIZED, UNKNOWN, ONE,     UNKNOWN, UNKNOWN, ONE,     UNKNOWN, UNKNOWN));-- W
BEGIN
   
RETURN Table(i1, i2);

END "nand";
------------------------------------------------------------------------

FUNCTION "or" ( i1,i2 :  logic_mv )	RETURN logic_mv is

   constant Table  : logic_mv_table :=
--        U        X        0        1        Z        L        H        W   
      ((UNINITIALIZED, UNINITIALIZED, UNINITIALIZED, ONE,     UNINITIALIZED, UNINITIALIZED, ONE,     UNINITIALIZED), -- U
       (UNINITIALIZED, UNKNOWN, UNKNOWN, ONE,     UNKNOWN, UNKNOWN, ONE,     UNKNOWN), -- X
       (UNINITIALIZED, UNKNOWN, ZERO,    ONE,     UNKNOWN, ZERO,    ONE,     UNKNOWN), -- 0 
       (ONE,     ONE,     ONE,     ONE,     ONE,     ONE,     ONE,     ONE    ), -- 1
       (UNINITIALIZED, UNKNOWN, UNKNOWN, ONE,     UNKNOWN, UNKNOWN, ONE,     UNKNOWN), -- Z
       (UNINITIALIZED, UNKNOWN, ZERO,    ONE,     UNKNOWN, ZERO,    ONE,     UNKNOWN), -- L
       (ONE,     ONE,     ONE,     ONE,     ONE,     ONE,     ONE,     ONE    ), -- H
       (UNINITIALIZED, UNKNOWN, UNKNOWN, ONE,     UNKNOWN, UNKNOWN, ONE,     UNKNOWN));-- W
BEGIN
   
RETURN Table(i1, i2);

END "or";
------------------------------------------------------------------------

FUNCTION "nor" ( i1,i2 :  logic_mv )	RETURN logic_mv is

   constant Table  : logic_mv_table :=
--        U        X        0        1        Z        L        H       W   
      ((UNINITIALIZED, UNINITIALIZED, UNINITIALIZED, ZERO,    UNINITIALIZED, UNINITIALIZED, ZERO,   UNINITIALIZED), -- U
       (UNINITIALIZED, UNKNOWN, UNKNOWN, ZERO,    UNKNOWN, UNKNOWN, ZERO,   UNKNOWN), -- X
       (UNINITIALIZED, UNKNOWN, ONE,     ZERO,    UNKNOWN, ONE,     ZERO,   UNKNOWN), -- 0
       (ZERO,    ZERO,    ZERO,    ZERO,    ZERO,    ZERO,    ZERO,   ZERO   ), -- 1
       (UNINITIALIZED, UNKNOWN, UNKNOWN, ZERO,    UNKNOWN, UNKNOWN, ZERO,   UNKNOWN), -- Z
       (UNINITIALIZED, UNKNOWN, ONE,     ZERO,    UNKNOWN, ONE,     ZERO,   UNKNOWN), -- L
       (ZERO,    ZERO,    ZERO,    ZERO,    ZERO,    ZERO,    ZERO,   ZERO   ), -- H
       (UNINITIALIZED, UNKNOWN, UNKNOWN, ZERO,    UNKNOWN, UNKNOWN, ZERO,   UNKNOWN));-- W
BEGIN
   
RETURN Table(i1, i2);

END "nor";
------------------------------------------------------------------------

FUNCTION "xor" ( i1,i2 :  logic_mv )	RETURN logic_mv is

   constant Table  : logic_mv_table :=
--        U        X        0        1        Z        L        H        W
      ((UNINITIALIZED, UNINITIALIZED, UNINITIALIZED, UNINITIALIZED, UNINITIALIZED, UNINITIALIZED, UNINITIALIZED, UNINITIALIZED), -- U
       (UNINITIALIZED, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN), -- X
       (UNINITIALIZED, UNKNOWN, ZERO,    ONE,     UNKNOWN, ZERO,    ONE,     UNKNOWN), -- 0 
       (UNINITIALIZED, UNKNOWN, ONE,     ZERO,    UNKNOWN, ONE,     ZERO,    UNKNOWN), -- 1
       (UNINITIALIZED, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN), -- Z
       (UNINITIALIZED, UNKNOWN, ZERO,    ONE,     UNKNOWN, ZERO,    ONE,     UNKNOWN), -- L
       (UNINITIALIZED, UNKNOWN, ONE,     ZERO,    UNKNOWN, ONE,     ZERO,    UNKNOWN), -- H
       (UNINITIALIZED, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN));-- W
BEGIN
   
RETURN Table(i1, i2);

END "xor";
------------------------------------------------------------------------

FUNCTION xnor ( i1,i2 :  logic_mv )	RETURN logic_mv is

   constant Table  : logic_mv_table :=
--        U        X        0        1        Z        L        H        W
      ((UNINITIALIZED, UNINITIALIZED, UNINITIALIZED, UNINITIALIZED, UNINITIALIZED, UNINITIALIZED, UNINITIALIZED, UNINITIALIZED), -- U
       (UNINITIALIZED, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN), -- X
       (UNINITIALIZED, UNKNOWN, ONE,     ZERO,    UNKNOWN, ONE,     ZERO,    UNKNOWN), -- 0
       (UNINITIALIZED, UNKNOWN, ZERO,    ONE,     UNKNOWN, ZERO,    ONE,     UNKNOWN), -- 1
       (UNINITIALIZED, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN), -- Z
       (UNINITIALIZED, UNKNOWN, ONE,     ZERO,    UNKNOWN, ONE,     ZERO,    UNKNOWN), -- L
       (UNINITIALIZED, UNKNOWN, ZERO,    ONE,     UNKNOWN, ZERO,    ONE,     UNKNOWN), -- H
       (UNINITIALIZED, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN));-- W
BEGIN
   
RETURN Table(i1, i2);

END xnor;
------------------------------------------------------------------------

FUNCTION "not" ( i1 :  logic_mv )	RETURN logic_mv is

   constant Table  : logic_mv_array :=
--        U        X        0     1      Z     L     H     W
       (UNINITIALIZED, UNKNOWN, ONE, ZERO, UNKNOWN, ONE, ZERO, UNKNOWN);
BEGIN
   
RETURN Table(i1);
END "not";
--
------------------------------------------------------------------------
-- VECTORIZED FUNCTIONS
------------------------------------------------------------------------
--
FUNCTION "and" ( i1,i2 :  logic_mv_vector )	RETURN logic_mv_vector is

    alias Arg1 : logic_mv_vector (1 to i1'length) is i1;
    alias Arg2 : logic_mv_vector (1 to i2'length) is i2;
    variable Store : logic_mv_vector (1 to i1'length );

BEGIN
    assert i1'length = i2'length report "Bus width mismatch" severity warning;
    FOR i in Store'range LOOP
        Store(i) := Arg1(i) and Arg2(i);
    END LOOP;
RETURN Store;
END "and";
------------------------------------------------------------------------

FUNCTION "nand" ( i1,i2 :  logic_mv_vector )	RETURN logic_mv_vector is

    alias Arg1 : logic_mv_vector (1 to i1'length) is i1;
    alias Arg2 : logic_mv_vector (1 to i2'length) is i2;
    variable Store : logic_mv_vector( 1 to i1'length);               

BEGIN
    assert i1'length = i2'length report "Bus width mismatch" severity warning;
    FOR i in Store'range LOOP
        Store(i) := Arg1(i) nand Arg2(i);
    END LOOP;
RETURN Store;
END "nand";                              
------------------------------------------------------------------------

FUNCTION "or" ( i1,i2 :  logic_mv_vector )	RETURN logic_mv_vector is

    alias Arg1 : logic_mv_vector (1 to i1'length) is i1;
    alias Arg2 : logic_mv_vector (1 to i2'length) is i2;
    variable Store : logic_mv_vector( 1 to i1'length);

BEGIN
    assert i1'length = i2'length report "Bus width mismatch" severity warning;
    FOR i in Store'range LOOP
        Store(i) := Arg1(i) or Arg2(i);
    END LOOP;
RETURN Store;
END "or";
------------------------------------------------------------------------

FUNCTION "nor" ( i1,i2 :  logic_mv_vector )	RETURN logic_mv_vector is

    alias Arg1 : logic_mv_vector (1 to i1'length) is i1;
    alias Arg2 : logic_mv_vector (1 to i2'length) is i2;
    variable Store : logic_mv_vector( 1 to i1'length );

BEGIN
    assert i1'length = i2'length report "Bus width mismatch" severity warning;
    FOR i in Store'range LOOP
          Store(i) := Arg1(i) nor Arg2(i);
    END LOOP;
RETURN Store;
END "nor";
------------------------------------------------------------------------

FUNCTION "xor" ( i1,i2 :  logic_mv_vector )	RETURN logic_mv_vector is

    alias Arg1 : logic_mv_vector (1 to i1'length) is i1;
    alias Arg2 : logic_mv_vector (1 to i2'length) is i2;
    variable Store : logic_mv_vector( 1 to i1'length );

BEGIN
    assert i1'length = i2'length report "Bus width mismatch" severity warning;
    FOR i in Store'range LOOP
        Store(i) := Arg1(i) xor Arg2(i);
    END LOOP;
RETURN Store;
END "xor";
------------------------------------------------------------------------

FUNCTION xnor ( i1,i2 :  logic_mv_vector )	RETURN logic_mv_vector is

    alias Arg1 : logic_mv_vector (1 to i1'length) is i1;
    alias Arg2 : logic_mv_vector (1 to i2'length) is i2;
    variable Store : logic_mv_vector( 1 to i1'length );

BEGIN
    assert i1'length = i2'length report "Bus width mismatch" severity warning;
    FOR i in Store'range LOOP
        Store(i) := xnor ( Arg1(i), Arg2(i) );
    END LOOP;
RETURN Store;
END xnor;
------------------------------------------------------------------------

FUNCTION "not" ( i1 :  logic_mv_vector )	RETURN logic_mv_vector is

    variable Store : logic_mv_vector( i1'range);

BEGIN
    FOR i in Store'range LOOP
        Store(i) := not i1(i);
    END LOOP;
RETURN Store;
END "not";
--
------------------------------------------------------------------------
--  Comparison Operators
------------------------------------------------------------------------
--
FUNCTION "=" (i1, i2: logic_mv) RETURN logic_mv is
     constant table: logic_mv_table :=
      ((UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN),
       (UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN),
       (UNKNOWN, UNKNOWN, ONE,     ZERO,    UNKNOWN, ONE,     ZERO,    UNKNOWN),
       (UNKNOWN, UNKNOWN, ZERO,    ONE,     UNKNOWN, ZERO,    ONE,     UNKNOWN),
       (UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN),
       (UNKNOWN, UNKNOWN, ONE,     ZERO,    UNKNOWN, ONE,     ZERO,    UNKNOWN),
       (UNKNOWN, UNKNOWN, ZERO,    ONE,     UNKNOWN, ZERO,    ONE,     UNKNOWN),
       (UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN));
BEGIN
   RETURN table (i1,i2);
END "=";
------------------------------------------------------------------------

FUNCTION "/=" (i1, i2: logic_mv) RETURN logic_mv is
     constant table: logic_mv_table :=
      ((UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN),
       (UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN),
       (UNKNOWN, UNKNOWN, ZERO,    ONE,     UNKNOWN, ZERO,    ONE,     UNKNOWN),
       (UNKNOWN, UNKNOWN, ONE,     ZERO,    UNKNOWN, ONE,     ZERO,    UNKNOWN),
       (UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN),
       (UNKNOWN, UNKNOWN, ZERO,    ONE,     UNKNOWN, ZERO,    ONE,     UNKNOWN),
       (UNKNOWN, UNKNOWN, ONE,     ZERO,    UNKNOWN, ONE,     ZERO,    UNKNOWN),
       (UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN));
BEGIN
   RETURN table (i1,i2);
END "/=";
------------------------------------------------------------------------

FUNCTION "=" ( i1,i2 :  logic_mv_vector )	RETURN logic_mv is
    alias Arg1 : logic_mv_vector (1 to i1'length) is i1;
    alias Arg2 : logic_mv_vector (1 to i2'length) is i2;
    variable Store : logic_mv;

BEGIN
    assert i1'length = i2'length report "Bus width mismatch" severity warning;
    FOR i in i1'range LOOP
        Store := Arg1(i) = Arg2(i);
        IF Store /= ONE then 
            RETURN Store;
        END IF;
    END LOOP;
RETURN ONE;
END "=";
------------------------------------------------------------------------

FUNCTION "/=" ( i1,i2 :  logic_mv_vector )	RETURN logic_mv is
    alias Arg1 : logic_mv_vector (1 to i1'length) is i1;
    alias Arg2 : logic_mv_vector (1 to i2'length) is i2;
    variable Store : logic_mv;

BEGIN
    assert i1'Length = i2'length report "Bus width mismatch" severity warning;
    FOR i in i1'range LOOP
        Store := Arg1(i) /= Arg2(i);
        IF Store /= ONE then 
            RETURN Store;
        END IF;
    END LOOP;
RETURN ONE;
END "/=";
--
-------------------------------------------------------------------------
--   Bus Resolution Functions
-------------------------------------------------------------------------
--
FUNCTION Wired_Outputs (signals : logic_mv_vector) RETURN logic_mv_base is
   VARIABLE  result : logic_mv := HIGHZ; -- return 'Z' when no active driver
   constant Table  : logic_mv_table :=
     ((UNINITIALIZED, UNINITIALIZED, UNINITIALIZED, UNINITIALIZED, UNINITIALIZED,  UNINITIALIZED, UNINITIALIZED,  UNINITIALIZED ),
      (UNINITIALIZED, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN,  UNKNOWN, UNKNOWN,  UNKNOWN ),
      (UNINITIALIZED, UNKNOWN, ZERO,    UNKNOWN, ZERO,     ZERO,    ZERO,     ZERO    ),
      (UNINITIALIZED, UNKNOWN, UNKNOWN, ONE,     ONE,      ONE,     ONE,      ONE     ),
      (UNINITIALIZED, UNKNOWN, ZERO,    ONE,     HIGHZ,    LOW,     HIGH,     UNDRIVEN),
      (UNINITIALIZED, UNKNOWN, ZERO,    ONE,     LOW,      LOW,     UNDRIVEN, UNDRIVEN),
      (UNINITIALIZED, UNKNOWN, ZERO,    ONE,     HIGH,     UNDRIVEN, HIGH,    UNDRIVEN),
      (UNINITIALIZED, UNKNOWN, ZERO,    ONE,     UNDRIVEN, UNDRIVEN, UNDRIVEN, UNDRIVEN));
BEGIN
    FOR i in signals'range LOOP
        result := table (result, signals(i));
        exit when result = UNINITIALIZED;
    end loop;
    RETURN result;
end Wired_Outputs ;

--
------------------------------------------------------------------------
--
-------------------------------------------------------------------------
--   Miscellaneous Functions
-------------------------------------------------------------------------
--
--   FUNCTION name: Filter
--   parameters:
--       in   input    --  logic_mv -- data input present value
--   RETURNs:    - translated logic_mv state :
--                 ( HIGH -> ONE;
--                   LOW  -> ZERO;
--                   HIGHZ -> UNKNOWN;
--                   UNDRIVEN -> UNKNOWN )
--
--   purpose: Used to prevent HIGH, LOW and HIGHZ states on an input
--            from being stored and subsequently output from the model.
--
------------------------------------------------------------------------------
FUNCTION Filter (input : logic_mv) RETURN logic_mv is
   constant filter_table  : logic_mv_array :=
      (UNKNOWN, UNKNOWN, ZERO, ONE, UNKNOWN, ZERO, ONE, UNKNOWN);
BEGIN

RETURN filter_table(input) ;
END Filter;
--     
-------------------------------------------------------------------------
--
--   FUNCTION name: Filter2
--   parameters:
--       in   input    --  logic_mv -- data input present value
--   RETURNs:    - translated logic_mv state :
--                   H -> 1
--                   L -> 0
--                   Z -> X
--                   W -> X
--
--   purpose: Used to force the model to treat HIGH inputs as logic ONE
--            and LOW inputs as logic ZERO.
--
----------------------------------------------------------------------------
FUNCTION Filter2 (input : logic_mv) RETURN logic_mv is
    constant Filter_Table2 : logic_mv_array :=
        (UNINITIALIZED, UNKNOWN, ZERO, ONE, UNKNOWN, ZERO, ONE, UNKNOWN);
            
BEGIN
                      
    RETURN Filter_Table2(input);
                                
END Filter2;
----------------------------------------------------------------------------
--	Returns the maximum of two times.
--
FUNCTION MaxTime (a, b: time) RETURN time is
    VARIABLE maximum : time;
BEGIN
	IF (a >= b) THEN
		RETURN a;
	ELSE
		RETURN b;
	END IF;
                                
END MaxTime;
----------------------------------------------------------------------------
--	Returns the minimum of two times.
--
FUNCTION MinTime (a, b: time) RETURN time is
    VARIABLE minimum : time;
BEGIN
	IF (a <= b) THEN
		RETURN a;
	ELSE
		RETURN b;
	END IF;
                                
END MinTime;
----------------------------------------------------------------------------

----------------------------------------------------------------------------
-- SIGNAL DETECTION FUNCTIONS
----------------------------------------------------------------------------
FUNCTION posedge        (signal ck: logic_mv)
                           RETURN boolean is
BEGIN
   IF ck'EVENT then
      case ck'LAST_VALUE is
          when ZERO|LOW  => 
              case ck is
                  when ONE|HIGH => RETURN TRUE ;
                  when others   => RETURN FALSE ;
              END case ;
          when others => RETURN FALSE ;
      END case ;
   else RETURN FALSE ;
   END IF ;
END posedge ;
---------------------------------------------------------------------------
FUNCTION negedge        (signal ck: logic_mv)
                           RETURN boolean is
BEGIN
   IF ck'EVENT then
      case ck'LAST_VALUE is
          when ONE|HIGH    => 
              case ck is
                  when ZERO|LOW    => RETURN TRUE ;
                  when others => RETURN FALSE ;
              END case ;
          when others => RETURN FALSE ;
      END case ;
   else RETURN FALSE ;
   END IF ;
END negedge ;
---------------------------------------------------------------------------
FUNCTION edge           (signal ck: logic_mv)
                            RETURN boolean is
BEGIN
   IF ck'EVENT then
      case ck'LAST_VALUE is
          when ONE|HIGH    => 
              case ck is
                  when ZERO|LOW    => RETURN TRUE ;
                  when others => RETURN FALSE ;
              END case ;
          when ZERO|LOW    => 
              case ck is
                  when ONE|HIGH    => RETURN TRUE ;
                  when others => RETURN FALSE ;
              END case ;
          when others => RETURN FALSE ;
      END case ;
   else RETURN FALSE ;
   END IF ;
END edge ;
----------------------------------------------------------------------------
-- This FUNCTION RETURNs TRUE IF the logic state passed in is not ZERO or ONE

FUNCTION bit_unknown       (v1 : logic_mv)          
                                RETURN boolean is
BEGIN
    case v1 is
        when ZERO => RETURN FALSE ;
        when ONE => RETURN FALSE ;
        when others => RETURN TRUE ;
    END case ;
END bit_unknown ;
---------------------------------------------------------------------------
-- This FUNCTION takes as input an integer and a length and RETURNs
-- a logic_mv vector of the input length with the value of the integer passed
-- in.
-- Example: int_to_bitvector(6,4) would RETURN a logic_mv_vector (of length 4)
-- containing the value 0110.

FUNCTION int_to_bitvector  (int, length:natural)  
                                RETURN logic_mv_vector is
    variable digit: natural := 2 ** (length-1) ;
	variable local: natural ;
	variable result: logic_mv_vector (0 to length-1) ;
BEGIN
	local := int ;
	for i in result'RANGE LOOP
		IF local >= digit then
			result(i) := ONE ;
			local := local-digit ;
		else
			result(i) := ZERO ;
		END IF ;
		digit := digit/2 ;
	END LOOP ;
	RETURN result ;
END int_to_bitvector ;
---------------------------------------------------------------------------
-- This FUNCTION takes as input a logic_mv_vector and RETURNs an integer
-- Example: bitvector_to_int(a), where a is a logic_mv_vector of length
-- 4 containing the value 0110, would RETURN the integer 6.
-- The FUNCTION RETURNs the value 16 when the bit_vector is not a 
-- valid "Bit" string.

FUNCTION bitvector_to_int  (bits: logic_mv_vector)  
                                RETURN natural is

variable result: natural := 0 ;
BEGIN
    for i in bits'RANGE LOOP
		result := result * 2 ;
		IF bits(i) = ONE then
			result := result + 1 ;
	    elsIF bits(i) /= ZERO then
	        RETURN 16 ;		
		END IF ;
	END LOOP ;
	RETURN result ;
END bitvector_to_int ;
---------------------------------------------------------------------------
-- This FUNCTION takes as input a logic_mv_vector and RETURNs
-- TRUE IF any of the bits are unknown, else it RETURNs false.
-- this FUNCTION show

FUNCTION unknown_on_bus    (bus_vector : logic_mv_vector) 
                               RETURN boolean is
BEGIN
	for i in bus_vector'RANGE LOOP
		IF  bit_unknown(bus_vector(i)) then
			RETURN TRUE ;
		END IF ;
	END LOOP ;
	RETURN FALSE;
END unknown_on_bus ;
---------------------------------------------------------------------------

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

FUNCTION F_delay( newlv : in logic_mv; delay01 : in time; delay10 : in time) 
         RETURN time is
BEGIN 
    CASE newlv is
      when ZERO   => RETURN delay10;
      when ONE    => RETURN delay01;
      when others => 
          IF (delay01 > delay10)  THEN
              RETURN delay01;
          ELSE
              RETURN delay10;
          END IF;
    END CASE;
  END F_delay;
--

FUNCTION tp_delay( newlv : in logic_mv; delay01 : in time; delay10 : in time) 
         RETURN time is
BEGIN 
    CASE newlv is
      when '0' | 'L'   => RETURN delay10;
      when '1' | 'H'   => RETURN delay01;
      when others => RETURN 0 ns;
    END CASE;
END tp_delay;
--

FUNCTION enum_to_char (enumval : in logic_mv ) 
         RETURN character is
BEGIN
	case enumval is
		when 'U' => return 'U';
		when 'X' => return 'X';
		when '0' => return '0';
		when '1' => return '1';
		when 'Z' => return 'Z';
		when 'L' => return 'L';
		when 'H' => return 'H';
		when 'W' => return 'W';						
	end case;
         
END enum_to_char;
--

END BASICDEFS;