LIBRARY IEEE;
USE IEEE.std_logic_1164.all;

PACKAGE pkg_kue2 IS

-- ·¿¤ÎÄêµÁ
   SUBTYPE logic17 IS std_logic_vector(16 DOWNTO 0);
   SUBTYPE logic9  IS std_logic_vector(8 DOWNTO 0);
   SUBTYPE logic8  IS std_logic_vector(7 DOWNTO 0);
   SUBTYPE logic7  IS std_logic_vector(6 DOWNTO 0);
   SUBTYPE logic6  IS std_logic_vector(5 DOWNTO 0);
   SUBTYPE logic5  IS std_logic_vector(4 DOWNTO 0);
   SUBTYPE logic4  IS std_logic_vector(3 DOWNTO 0);
   SUBTYPE logic3  IS std_logic_vector(2 DOWNTO 0);
   SUBTYPE logic2  IS std_logic_vector(1 DOWNTO 0);
   TYPE OBType IS (OB_MC_P,  OB_MC_D,  OB_PC,    OB_FLAG,
                   OB_ACC,   OB_IX,    OB_DBi,   OB_DBo,
                   OB_MAR,   OB_IR,    OB_CONT0, OB_CONT1,
                   OB_CONT2, OB_CONT3, OB_CONT4, OB_CONT5);
   TYPE ActionType IS (No,Ss,Si,Sp);
   TYPE PhaseType IS (P0,P1,P2,P3,P4);
   TYPE BccType IS (BA,  BVF, BNZ, BZ,  BZP, BN,  BP,  BZN,
                    BNI, BNO, BNC, BC,  BGE, BLT, BGT, BLE);
   TYPE ShiftType IS (SRA, SLA, SRL, SLL, RRA, RLA, RRL, RLL);
   TYPE ArithType IS (A_SBC, A_ADC, A_SUB, A_ADD, A_EOR, A_OR, A_AND, A_CMP);
   TYPE AddressType IS (Acc_Ix, Num_Val, ABS_Addr, Ind_Addr);
   TYPE InstType IS (NOPinst, HLTinst, OUTinst, INinst, RCF_SCFinst,
                     BCCinst, SSM_RSMinst, LDinst, STinst, CALinst);
   TYPE SyncStatusType IS (WAIT_s, RUN_s, READY_s);
   TYPE RAM  IS ARRAY (natural RANGE <>) OF logic8;
   
   FUNCTION ob_decode(ob_sel : IN logic4) RETURN OBType;

   FUNCTION bcc_check(s           : IN logic4;
                      flag        : IN logic4;
                      ibuf_flg_in : IN std_logic;
                      obuf_flg_in : IN std_logic) RETURN std_logic;

   FUNCTION arith_decode(s : IN logic3) RETURN ArithType;

   FUNCTION shift_decode(s : IN logic3) RETURN ShiftType;

   FUNCTION addr_decode(ir : IN logic2) RETURN AddressType;

   FUNCTION inst_decode(ir : IN logic8) RETURN InstType;

   FUNCTION alu_decode(ope : IN logic4) RETURN ArithType;

   FUNCTION add_sub(l,r   : IN logic9;
                    carry : IN std_logic;
                    flag  : IN boolean) RETURN logic9; 

END pkg_kue2;

PACKAGE BODY pkg_kue2 IS 
   FUNCTION ob_decode(ob_sel  : IN logic4) RETURN OBType IS 
      VARIABLE mode : OBType;
   BEGIN
      CASE ob_sel IS 
         WHEN "0000" => mode := OB_MC_P;
         WHEN "0001" => mode := OB_MC_D;
         WHEN "0010" => mode := OB_PC;
         WHEN "0011" => mode := OB_FLAG;
         WHEN "0100" => mode := OB_ACC;
         WHEN "0101" => mode := OB_IX;
         WHEN "0110" => mode := OB_DBi;
         WHEN "0111" => mode := OB_DBo;
         WHEN "1000" => mode := OB_MAR;
         WHEN "1001" => mode := OB_IR;
         WHEN "1010" => mode := OB_CONT0;
         WHEN "1011" => mode := OB_CONT1;
         WHEN "1100" => mode := OB_CONT2;
         WHEN "1101" => mode := OB_CONT3;
         WHEN "1110" => mode := OB_CONT4;
         WHEN "1111" => mode := OB_CONT5;
         WHEN OTHERS => NULL;
      END CASE;
      RETURN mode;
   END ob_decode;

   FUNCTION bcc_check(s           : IN logic4;
                      flag        : IN logic4;
                      ibuf_flg_in : IN std_logic;
                      obuf_flg_in : IN std_logic) RETURN std_logic IS 
      VARIABLE cond : std_logic;
   BEGIN 
      CASE s IS
         WHEN "0000" => cond := '1';
         WHEN "0001" => cond := NOT flag(0);
         WHEN "0010" => cond := NOT flag(1);
         WHEN "0011" => cond := NOT (flag(0) OR flag(1));
         WHEN "0100" => cond := NOT ibuf_flg_in;
         WHEN "0101" => cond := NOT flag(3);
         WHEN "0110" => cond := NOT (flag(1) XOR flag(2));
         WHEN "0111" => cond := NOT ((flag(1) XOR flag(2)) OR flag(0));
         WHEN "1000" => cond := flag(2);
         WHEN "1001" => cond := flag(0);
         WHEN "1010" => cond := flag(1);
         WHEN "1011" => cond := flag(0) OR flag(1);
         WHEN "1100" => cond := obuf_flg_in;
         WHEN "1101" => cond := flag(3);
         WHEN "1110" => cond := flag(1) XOR flag(2);
         WHEN "1111" => cond := (flag(1) XOR flag(2)) OR flag(0);
         WHEN OTHERS => NULL;
      END CASE;
      RETURN cond;
   END; 

   FUNCTION arith_decode(s : IN logic3) RETURN ArithType IS 
      VARIABLE mode : ArithType;
   BEGIN
      CASE s IS
         WHEN "000"  => mode := A_SBC;
         WHEN "001"  => mode := A_ADC;
         WHEN "010"  => mode := A_SUB;
         WHEN "011"  => mode := A_ADD;
         WHEN "100"  => mode := A_EOR;
         WHEN "101"  => mode := A_OR;
         WHEN "110"  => mode := A_AND;
         WHEN "111"  => mode := A_CMP;
         WHEN OTHERS => NULL;
      END CASE;
      RETURN mode;
   END;


   FUNCTION shift_decode(s : IN logic3) RETURN ShiftType IS
      VARIABLE mode : ShiftType;
   BEGIN
      CASE s(2 DOWNTO 0) IS
         WHEN "000"  => mode := SRA;
         WHEN "001"  => mode := SLA;
         WHEN "010"  => mode := SRL;
         WHEN "011"  => mode := SLL;
         WHEN "100"  => mode := RRA;
         WHEN "101"  => mode := RLA;
         WHEN "110"  => mode := RRL;
         WHEN "111"  => mode := RLL;
         WHEN OTHERS => NULL; 
      END CASE;
      RETURN mode;
   END;

   FUNCTION addr_decode(ir : IN logic2) RETURN AddressType IS 
      VARIABLE mode : AddressType;
   BEGIN
      CASE ir IS
         WHEN "00" => mode := Acc_Ix;
         WHEN "01" => mode := Num_Val;
         WHEN "10" => mode := Abs_Addr;
         WHEN "11" => mode := Ind_Addr;
         WHEN OTHERS => NULL; 
      END CASE;
      RETURN mode;
   END; 

   FUNCTION inst_decode(ir : IN logic8) RETURN InstType IS 
      VARIABLE inst : InstType;
   BEGIN 
      IF (ir(7) = '0') THEN 
         CASE ir(6 DOWNTO 4) IS
            WHEN "000" =>
               IF (ir(3) = '0') THEN 
                  inst := NOPinst;
               ELSE
                  inst := HLTinst;
               END IF; 
            WHEN "001" => 
               IF (ir(3) = '0') THEN 
                  inst := OUTinst;
               ELSE
                  inst := INinst;
               END IF; 
            WHEN "010" => inst := RCF_SCFinst;
            WHEN "011" => inst := BCCinst;
            WHEN "100" => inst := SSM_RSMinst;
            WHEN "110" => inst := LDinst;
            WHEN "111" => inst := STinst;
            WHEN OTHERS => inst := HLTinst;
         END CASE;
      ELSE
         inst := CALinst;
      END IF;
      RETURN inst;
   END;

   FUNCTION alu_decode(ope : IN logic4) RETURN ArithType IS
      VARIABLE mode : ArithType;
   BEGIN
      IF (ope(3) = '0') THEN
         mode := A_OR;
      ELSE 
         CASE ope(2 DOWNTO 0) IS
            WHEN "000"  => mode := A_SBC;
            WHEN "001"  => mode := A_ADC;
            WHEN "011"  => mode := A_ADD;
            WHEN "100"  => mode := A_EOR;
            WHEN "101"  => mode := A_OR;
            WHEN "110"  => mode := A_AND;
            WHEN OTHERS => mode := A_SUB;
         END CASE;
      END IF;
      RETURN mode;
   END ;

   FUNCTION add_sub(l,r   : IN logic9;
                    carry : IN std_logic;
                    flag  : IN boolean) RETURN logic9 IS
      VARIABLE c       : std_logic;
      VARIABLE a,b,sum : logic9;
   BEGIN
      a := l;
      IF (flag) THEN 
         b := r;
         c := carry;
      ELSE
         b := NOT r;
         c := NOT carry;
      END IF;
      FOR i IN 0 TO 8 LOOP
         sum(i) := a(i) XOR b(i) XOR c;
         c      := (a(i) AND b(i)) OR (a(i) AND c) OR (c AND b(i));
      END LOOP;
      RETURN sum;
   END;
      
END pkg_kue2;