---------------------------------------------------------------------
-- VHDL Design : SMAX-functions
--
-- Author(s) :   H.Buettner
-- Date :        12.07.94
---------------------------------------------------------------------

PACKAGE smaxpck IS
-------------------
  CONSTANT unit_delay : Time := 1 ns;
  SUBTYPE Clock IS BIT;

  FUNCTION ctl_AF(expression : BIT) RETURN BIT;
  FUNCTION ctl_AG(expression : BIT) RETURN BIT;
  FUNCTION ctl_AU(expression1, expression2 : BIT) RETURN BIT;
  FUNCTION ctl_AX(expression : BIT) RETURN BIT;
  FUNCTION ctl_EF(expression : BIT) RETURN BIT;
  FUNCTION ctl_EG(expression : BIT) RETURN BIT;
  FUNCTION ctl_EU(expression1, expression2 : BIT) RETURN BIT;
  FUNCTION ctl_EX(expression : BIT) RETURN BIT;

  FUNCTION smax_adc(bitvector1, bitvector2 : Bit_Vector; carry : BIT) RETURN 
 Bit_Vector;
  FUNCTION smax_add(bitvector1, bitvector2 : Bit_Vector) RETURN Bit_Vector;
  FUNCTION smax_dcr(bitvector1 : Bit_Vector) RETURN Bit_Vector;
  FUNCTION smax_fae(onebit : BIT; n : INTEGER) RETURN Bit_Vector;
  FUNCTION smax_inc(bitvector1 : Bit_Vector) RETURN Bit_Vector;
  FUNCTION smax_lsh(bitvector : Bit_Vector; carry : BIT) RETURN Bit_Vector;
  FUNCTION smax_mint(bitvector : Bit_Vector; n : INTEGER) RETURN BIT;
  FUNCTION smax_maxt(bitvector : Bit_Vector; n : INTEGER) RETURN BIT;
  FUNCTION smax_mpx1(bitvector1, choice : Bit_Vector) RETURN BIT;
  FUNCTION smax_mpx1(bitvector : Bit_Vector; onebit : BIT) RETURN BIT;
  FUNCTION smax_rol(bitvector : Bit_Vector) RETURN Bit_Vector;
  FUNCTION smax_ror(bitvector : Bit_Vector) RETURN Bit_Vector;
  FUNCTION smax_rsh(carry : BIT; bitvector : Bit_Vector) RETURN Bit_Vector;
  FUNCTION sbb1carry(a, b, c : BIT) RETURN BIT;
  FUNCTION sbb1result(a, b, c : BIT) RETURN BIT;
  FUNCTION smax_sbb(bitvector1, bitvector2 : Bit_Vector; carry : BIT) RETURN 
 Bit_Vector;
  FUNCTION smax_sub(bitvector1, bitvector2 : Bit_Vector) RETURN Bit_Vector;

  FUNCTION smax_select(bitvector : Bit_Vector; lb, rb : INTEGER) RETURN 
 Bit_Vector;
-- the function smax_select is not used!

  FUNCTION bitvector2int (bitvector : Bit_Vector) RETURN INTEGER;
  FUNCTION bool2bit (bool : BOOLEAN) RETURN BIT;
  PROCEDURE int2bitvector (n : IN INTEGER; bitvector : OUT Bit_Vector);
END smaxpck;

PACKAGE BODY smaxpck IS
------------------------
  FUNCTION ctl_AF(expression : BIT) RETURN BIT IS
    VARIABLE result : BIT;
  BEGIN
    ASSERT result = '1'
      REPORT "Use of the CTL-Formula AF"
      SEVERITY FAILURE;
    RETURN result;
  END ctl_AF;

  FUNCTION ctl_AG(expression : BIT) RETURN BIT IS
    VARIABLE result : BIT;
  BEGIN
    ASSERT result = '1'
      REPORT "Use of the CTL-Formula AG"
      SEVERITY FAILURE;
    RETURN result;
  END ctl_AG;

  FUNCTION ctl_AU(expression1, expression2 : BIT) RETURN BIT IS
    VARIABLE result : BIT;
  BEGIN
    ASSERT result = '1'
      REPORT "Use of the CTL-Formula AU"
      SEVERITY FAILURE;
    RETURN result;
  END ctl_AU;

  FUNCTION ctl_AX(expression : BIT) RETURN BIT IS
    VARIABLE result : BIT;
  BEGIN
    ASSERT result = '1'
      REPORT "Use of the CTL-Formula AX"
      SEVERITY FAILURE;
    RETURN result;
  END ctl_AX;

  FUNCTION ctl_EF(expression : BIT) RETURN BIT IS
    VARIABLE result : BIT;
  BEGIN
    ASSERT result = '1'
      REPORT "Use of the CTL-Formula EF"
      SEVERITY FAILURE;
    RETURN result;
  END ctl_EF;

  FUNCTION ctl_EG(expression : BIT) RETURN BIT IS
    VARIABLE result : BIT;
  BEGIN
    ASSERT result = '1'
      REPORT "Use of the CTL-Formula EG"
      SEVERITY FAILURE;
    RETURN result;
  END ctl_EG;

  FUNCTION ctl_EU(expression1, expression2 : BIT) RETURN BIT IS
    VARIABLE result : BIT;
  BEGIN
    ASSERT result = '1'
      REPORT "Use of the CTL-Formula EU"
      SEVERITY FAILURE;
    RETURN result;
  END ctl_EU;

  FUNCTION ctl_EX(expression : BIT) RETURN BIT IS
    VARIABLE result : BIT;
  BEGIN
    ASSERT result = '1'
      REPORT "Use of the CTL-Formula EX"
      SEVERITY FAILURE;
    RETURN result;
  END ctl_EX;

  FUNCTION smax_adc(bitvector1, bitvector2 : Bit_vector; carry : BIT)
  RETURN Bit_vector IS
    VARIABLE sum : INTEGER;
    VARIABLE result : Bit_vector(1 TO (bitvector1'LENGTH + 1));
  BEGIN
    sum := bitvector2int(bitvector1) + bitvector2int(bitvector2) 
                                     + BIT'POS(carry);
    int2bitvector(sum,result);
    RETURN result;
  END smax_adc;

  FUNCTION smax_add(bitvector1, bitvector2 : Bit_vector) RETURN Bit_vector IS
    VARIABLE sum : INTEGER;
    VARIABLE result : Bit_vector(1 TO bitvector1'LENGTH);
  BEGIN
    sum := bitvector2int(bitvector1) + bitvector2int(bitvector2);
    int2bitvector(sum,result);
    RETURN result;
  END smax_add;

  FUNCTION smax_dcr(bitvector1 : Bit_vector) RETURN Bit_vector IS
    VARIABLE sum : INTEGER;
    VARIABLE result : Bit_vector(1 TO bitvector1'LENGTH);
  BEGIN
    IF bitvector2int(bitvector1) = 0 THEN
      FOR index IN 1 TO bitvector1'LENGTH LOOP
        result(index) := '1';
      END LOOP;
    ELSE
      sum := bitvector2int(bitvector1) - 1;
      int2bitvector(sum,result);
    END IF;
    RETURN result;
  END smax_dcr;

  FUNCTION smax_fae(onebit : BIT; n : INTEGER) RETURN Bit_vector IS
    VARIABLE result : Bit_vector(1 TO n);
  BEGIN
    FOR index IN 1 TO n LOOP
      result(index) := onebit;
    END LOOP;
    RETURN result;
  END smax_fae;

  FUNCTION smax_inc(bitvector1 : Bit_vector) RETURN Bit_vector IS
    VARIABLE sum : INTEGER;
    VARIABLE result : Bit_vector(1 TO bitvector1'LENGTH);
  BEGIN
    sum := bitvector2int(bitvector1) + 1;
    int2bitvector(sum,result);
    RETURN result;
  END smax_inc;

  FUNCTION smax_lsh(bitvector : Bit_vector; carry : BIT) RETURN Bit_vector IS
    VARIABLE result : Bit_vector(1 TO bitvector'LENGTH);
  BEGIN
    IF bitvector'LEFT < bitvector'RIGHT THEN
      result(1 TO (bitvector'LENGTH - 1)) := 
        bitvector((bitvector'LEFT + 1) TO bitvector'RIGHT);
    ELSE
      result(1 TO (bitvector'LENGTH - 1)) := 
        bitvector((bitvector'LEFT + 1) DOWNTO bitvector'RIGHT);
    END IF;
    result(bitvector'LENGTH) := carry;
    RETURN result;
  END smax_lsh;

  FUNCTION smax_mint(bitvector : Bit_vector; n : INTEGER) RETURN BIT IS
    VARIABLE result : BIT := '0';
  BEGIN
    IF bitvector2int(bitvector) = n THEN
      result := '1';
    END IF;
    RETURN result;
  END smax_mint;

  FUNCTION smax_maxt(bitvector : Bit_vector; n : INTEGER) RETURN BIT IS
    VARIABLE result : BIT := '1';
  BEGIN
    IF bitvector2int(bitvector) = n THEN
      result := '0';
    END IF;
    RETURN result;
  END smax_maxt;

  FUNCTION smax_mpx1(bitvector1, choice : Bit_vector) RETURN BIT IS
    VARIABLE result : BIT;
  BEGIN
    IF bitvector1'LEFT < bitvector1'RIGHT THEN
      result := bitvector1(bitvector1'LEFT + bitvector2int(choice));
    ELSE
      result := bitvector1(bitvector1'LEFT - bitvector2int(choice));
    END IF;
    RETURN result;
  END smax_mpx1;

  FUNCTION smax_mpx1(bitvector : Bit_vector; onebit : BIT) RETURN BIT IS
    VARIABLE result : BIT := bitvector(bitvector'LEFT);
  BEGIN
    IF onebit = '1' THEN
      result := bitvector(bitvector'RIGHT);
    END IF;
    RETURN result;
  END smax_mpx1;

  FUNCTION smax_rol(bitvector : Bit_vector) RETURN Bit_vector IS
    VARIABLE result : Bit_vector(1 TO bitvector'LENGTH);
  BEGIN
    IF bitvector'LEFT < bitvector'RIGHT THEN
      result(1 TO (bitvector'LENGTH - 1)) := 
        bitvector((bitvector'LEFT + 1) TO bitvector'RIGHT);
    ELSE
      result(1 TO (bitvector'LENGTH - 1)) := 
        bitvector((bitvector'LEFT + 1) DOWNTO bitvector'RIGHT);
    END IF;
    result(bitvector'LENGTH) := bitvector(bitvector'LEFT);
    RETURN result;
  END smax_rol;

  FUNCTION smax_ror(bitvector : Bit_vector) RETURN Bit_vector IS
    VARIABLE result : Bit_vector(1 TO bitvector'LENGTH);
  BEGIN
    IF bitvector'LEFT < bitvector'RIGHT THEN
      result(2 TO bitvector'LENGTH) := 
        bitvector(bitvector'LEFT TO (bitvector'RIGHT - 1));
    ELSE
      result(2 TO bitvector'LENGTH) := 
        bitvector(bitvector'LEFT DOWNTO (bitvector'RIGHT - 1));
    END IF;
    result(1) := bitvector(bitvector'RIGHT);
    RETURN result;
  END smax_ror;

  FUNCTION smax_rsh(carry : BIT; bitvector : Bit_vector) RETURN Bit_vector IS
    VARIABLE result : Bit_vector(1 TO bitvector'LENGTH);
  BEGIN
    IF bitvector'LEFT < bitvector'RIGHT THEN
      result(2 TO bitvector'LENGTH) := 
        bitvector(bitvector'LEFT TO (bitvector'RIGHT - 1));
    ELSE
      result(2 TO bitvector'LENGTH) := 
        bitvector(bitvector'LEFT DOWNTO (bitvector'RIGHT - 1));
    END IF;
    result(1) := carry;
    RETURN result;
  END smax_rsh;

  FUNCTION sbb1carry(a, b, c : BIT) RETURN BIT IS
-- use in sbb and sub
    VARIABLE carry : BIT;
  BEGIN
    carry := (not a and c) or (b and c) or (not a and b);
    RETURN carry;
  END sbb1carry;

  FUNCTION sbb1result(a, b, c : BIT) RETURN BIT IS
-- use in sbb and sub
    VARIABLE result : BIT;
  BEGIN
    result := a xor b xor c;
    RETURN result;
  END sbb1result;

  FUNCTION smax_sbb(bitvector1, bitvector2 : Bit_vector; carry : BIT) RETURN 
 Bit_vector IS
    VARIABLE sum : INTEGER;
    VARIABLE carry_i : BIT;
    VARIABLE result : Bit_vector(1 TO (bitvector1'LENGTH + 1));
  BEGIN
    carry_i := carry;
    IF bitvector1'LEFT < bitvector1'RIGHT THEN
      IF bitvector2'LEFT < bitvector2'RIGHT THEN
        FOR index IN result'RIGHT DOWNTO 2 LOOP
          result(index) :=
            sbb1result(bitvector1(bitvector1'RIGHT - (result'LENGTH - index)),
                       bitvector2(bitvector2'RIGHT - (result'LENGTH - index)),
                       carry_i);
          carry_i :=
            sbb1carry(bitvector1(bitvector1'RIGHT - (result'LENGTH - index)),
                      bitvector2(bitvector2'RIGHT - (result'LENGTH - index)),
                      carry_i);
        END LOOP;
      ELSE
        FOR index IN result'RIGHT DOWNTO 2 LOOP
          result(index) :=
            sbb1result(bitvector1(bitvector1'RIGHT - (result'LENGTH - index)),
                       bitvector2(bitvector2'RIGHT + (result'LENGTH - index)),
                       carry_i);
          carry_i :=
            sbb1carry(bitvector1(bitvector1'RIGHT - (result'LENGTH - index)),
                      bitvector2(bitvector2'RIGHT + (result'LENGTH - index)),
                      carry_i);
        END LOOP;
      END IF;
    ELSE
      IF bitvector2'LEFT < bitvector2'RIGHT THEN
        FOR index IN result'RIGHT DOWNTO 2 LOOP
          result(index) :=
            sbb1result(bitvector1(bitvector1'RIGHT + (result'LENGTH - index)),
                       bitvector2(bitvector2'RIGHT - (result'LENGTH - index)),
                       carry_i);
          carry_i :=
            sbb1carry(bitvector1(bitvector1'RIGHT + (result'LENGTH - index)),
                      bitvector2(bitvector2'RIGHT - (result'LENGTH - index)),
                      carry_i);
        END LOOP;
      ELSE
        FOR index IN result'RIGHT DOWNTO 2 LOOP
          result(index) :=
            sbb1result(bitvector1(bitvector1'RIGHT + (result'LENGTH - index)),
                       bitvector2(bitvector2'RIGHT + (result'LENGTH - index)),
                       carry_i);
          carry_i :=
            sbb1carry(bitvector1(bitvector1'RIGHT + (result'LENGTH - index)),
                      bitvector2(bitvector2'RIGHT + (result'LENGTH - index)),
                      carry_i);
        END LOOP;
      END IF;
    END IF;
    result(1) := carry_i;
    RETURN result;
  END smax_sbb;

  FUNCTION smax_select(bitvector : Bit_vector; lb, rb : INTEGER) RETURN 
 Bit_vector IS
    VARIABLE result : Bit_vector(1 TO (abs(lb - rb) + 1));
  BEGIN
    IF lb < rb THEN
      FOR index IN result'range LOOP
        result(index) := bitvector(lb + index - 1);
      END LOOP;
    ELSE
      FOR index IN result'range LOOP
        result(index) := bitvector(lb - index + 1);
      END LOOP;
    END IF;
    RETURN result;
  END smax_select;

  FUNCTION smax_sub(bitvector1, bitvector2 : Bit_vector) RETURN Bit_vector IS
    VARIABLE sum : INTEGER;
    VARIABLE carry_i : BIT := '0';
    VARIABLE result : Bit_vector(1 TO bitvector1'LENGTH);
  BEGIN
    IF bitvector1'LEFT < bitvector1'RIGHT THEN
      IF bitvector2'LEFT < bitvector2'RIGHT THEN
        FOR index IN result'RIGHT DOWNTO 1 LOOP
          result(index) :=
            sbb1result(bitvector1(bitvector1'RIGHT - (result'LENGTH - index)),
                       bitvector2(bitvector2'RIGHT - (result'LENGTH - index)),
                       carry_i);
          carry_i :=
            sbb1carry(bitvector1(bitvector1'RIGHT - (result'LENGTH - index)),
                      bitvector2(bitvector2'RIGHT - (result'LENGTH - index)),
                      carry_i);
        END LOOP;
      ELSE
        FOR index IN result'RIGHT DOWNTO 1 LOOP
          result(index) :=
            sbb1result(bitvector1(bitvector1'RIGHT - (result'LENGTH - index)),
                       bitvector2(bitvector2'RIGHT + (result'LENGTH - index)),
                       carry_i);
          carry_i :=
            sbb1carry(bitvector1(bitvector1'RIGHT - (result'LENGTH - index)),
                      bitvector2(bitvector2'RIGHT + (result'LENGTH - index)),
                      carry_i);
        END LOOP;
      END IF;
    ELSE
      IF bitvector2'LEFT < bitvector2'RIGHT THEN
        FOR index IN result'RIGHT DOWNTO 1 LOOP
          result(index) :=
            sbb1result(bitvector1(bitvector1'RIGHT + (result'LENGTH - index)),
                       bitvector2(bitvector2'RIGHT - (result'LENGTH - index)),
                       carry_i);
          carry_i :=
            sbb1carry(bitvector1(bitvector1'RIGHT + (result'LENGTH - index)),
                      bitvector2(bitvector2'RIGHT - (result'LENGTH - index)),
                      carry_i);
        END LOOP;
      ELSE
        FOR index IN result'RIGHT DOWNTO 1 LOOP
          result(index) :=
            sbb1result(bitvector1(bitvector1'RIGHT + (result'LENGTH - index)),
                       bitvector2(bitvector2'RIGHT + (result'LENGTH - index)),
                       carry_i);
          carry_i :=
            sbb1carry(bitvector1(bitvector1'RIGHT + (result'LENGTH - index)),
                      bitvector2(bitvector2'RIGHT + (result'LENGTH - index)),
                      carry_i);
        END LOOP;
      END IF;
    END IF;
    RETURN result;
  END smax_sub;

  FUNCTION bitvector2int(bitvector : Bit_vector) RETURN INTEGER IS
    VARIABLE result : INTEGER := 0;
  BEGIN
    IF bitvector'LEFT < bitvector'RIGHT THEN
      FOR index IN bitvector'LEFT TO bitvector'RIGHT LOOP
        result := result*2 + BIT'POS(bitvector(index));
      END LOOP;
    ELSE
      FOR index IN bitvector'LEFT DOWNTO bitvector'RIGHT LOOP
        result := result*2 + BIT'POS(bitvector(index));
      END LOOP;
    END IF;
    RETURN result;
  END bitvector2int;

  FUNCTION bool2bit (bool : BOOLEAN) RETURN BIT IS
    VARIABLE result : BIT := '0';
  BEGIN
    IF bool = true THEN
      result := '1';
    END IF;
    RETURN result;
  END bool2bit;

  PROCEDURE int2bitvector(n : IN INTEGER; bitvector : OUT Bit_vector) IS
    VARIABLE temp : INTEGER;
    VARIABLE result : Bit_vector(bitvector'RANGE);
  BEGIN
    temp := n;
    IF bitvector'LEFT < bitvector'RIGHT THEN
      FOR index IN bitvector'RIGHT DOWNTO bitvector'LEFT LOOP
        result(index) := BIT'VAL(temp REM 2);
        temp := temp / 2;
      END LOOP;
    ELSE
      FOR index IN bitvector'RIGHT TO bitvector'LEFT LOOP
        result(index) := BIT'VAL(temp REM 2);
        temp := temp / 2;
      END LOOP;
    END IF;
    bitvector := result;
  END int2bitvector;

END smaxpck;