Entity ALLOCATEUR is

     port(
        ck    : in bit ;
        reset :in bit;
        r0  :in bit;
        r1  :in bit; 
        r2  :in bit;
        r3  :in bit;
        g0  :out bit ;
        g1  :out bit ;
        g2  :out bit ;
        g3  :out bit ;
        vdd   :in bit;
        vss   :in bit
     );
     End ALLOCATEUR;

   Architecture FSM of ALLOCATEUR is

     type ETAT_TYPE is      (	WAIT0, 
				WAIT1, 
				WAIT2, 
				WAIT3, 
				ALLOC0, 
				ALLOC1, 
				ALLOC2, 
				ALLOC3) ;
     signal EF, EP : ETAT_TYPE;

-- pragma CURRENT_STATE EP
-- pragma NEXT_STATE EF
-- pragma CLOCK ck

     begin

        process (EP, r0, r1, r2, r3, reset)
        begin

            -- fonction de transition
 
            if(reset='1') then
            EF <= WAIT0 ;
            else
                case EP is
                    when WAIT0 =>
                        if (r1)    then EF <= ALLOC1;
                        elsif (r2) then EF <= ALLOC2;
                        elsif (r3) then EF <= ALLOC3;
                        elsif (r0) then EF <= ALLOC0;
			else            EF <= WAIT0;
			end if;

                    when WAIT1 =>

                    when WAIT2 =>

       		    when WAIT3 =>

                    when ALLOC0 =>
                        if (not(r0)) then EF <= WAIT0;
			else		  EF <= ALLOC0;
			end if;

                    when ALLOC1 =>

                    when ALLOC2 =>

        	    when ALLOC3 =>

    		end case;
end if ;
       
-- fonction de generation 
      
 case EP is
            when WAIT0 =>
                g0 <= '0';
                g1 <= '0';
                g2 <= '0';
                g3 <= '0';

           when WAIT1 =>
                g0 <= '0';
                g1 <= '0';
                g2 <= '0';
    		g3 <= '0';

           when WAIT2 =>
                g0 <= '0';
                g1 <= '0';
                g2 <= '0';
    		g3 <= '0';

   	   when WAIT3 =>
                g0 <= '0';
                g1 <= '0';
                g2 <= '0';
    		g3 <= '0';

           when ALLOC0 =>
                g0 <= '1';
                g1 <= '0';
                g2 <= '0';
  	    	g3 <= '0';

           when ALLOC1 =>
                g0 <= '0';
                g1 <= '1';
                g2 <= '0';
    		g3 <= '0';

           when ALLOC2 =>
                g0 <= '0';
                g1 <= '0';
                g2 <= '1';
    		g3 <= '0';

	   when ALLOC3 =>
                g0 <= '0';
                g1 <= '0';
                g2 <= '0';
                g3 <= '1';
        end case;
end process;

process(ck)
       begin
         if(ck = '1' and not ck' stable) then
           EP <= EF ;
         end if;
 end process;
 
end FSM ;