VHDL: mapa de puertos en error de proceso

Estoy diseñando una ALU en VHDL. En otro archivo llamado adder16bit, he diseñado mi sumador y quiero usarlo de diferentes maneras, por ejemplo, si ALU_OP es ADD, quiero que lo haga además, si es SUB, quiero que se reste, etc. Estoy usando una declaración de caso para detectar cómo usar el sumador de la manera adecuada. Aparentemente, la asignación de puertos con diferentes entradas en cada caso no funciona y ahora estoy atascado.

Los errores que estoy recibiendo:

  

Error (10500): error de sintaxis VHDL en ALU.vhd (26) cerca del texto "puerto"; esperando "(", o "'", o "."
  Error (10500): Error de sintaxis VHDL en ALU.vhd (35) cerca del texto ";"; esperando ":=", o "<="
  Error (10500): Error de sintaxis VHDL en ALU.vhd (38) cerca del texto "puerto"; esperando "(", o "'", o "."
  Error (10500): Error de sintaxis VHDL en ALU.vhd (47) cerca del texto ";"; esperando ":=", o "<="
  Error (10500): Error de sintaxis VHDL en ALU.vhd (50) cerca del texto "puerto"; esperando "(", o "'", o "."
  Error (10500): Error de sintaxis VHDL en ALU.vhd (59) cerca del texto ";"; esperando ":=", o "<="
  Error (10500): Error de sintaxis VHDL en ALU.vhd (62) cerca del texto "puerto"; esperando "(", o "'", o "."
  Error (10500): Error de sintaxis VHDL en ALU.vhd (63) cerca del texto ";"; esperando ")", o ","
  Error (10500): Error de sintaxis VHDL en ALU.vhd (65) cerca del texto "= >"; esperando "(", o "'", o "."
  Error (10500): Error de sintaxis VHDL en ALU.vhd (66) cerca del texto "= >"; esperando "(", o "'", o "."
  Error (10500): Error de sintaxis VHDL en ALU.vhd (102) cerca del texto "puerto"; esperando "(", o "'", o "."
  Error (10500): Error de sintaxis VHDL en ALU.vhd (103) cerca del texto ";"; esperando ")", o ","
  Error (10500): Error de sintaxis VHDL en ALU.vhd (111) cerca del texto ";"; esperando ":=", o "<="

código:

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
entity ALU is
    port(
        ALU_A, ALU_B : in STD_LOGIC_VECTOR(15 downto 0); 
        ALU_output : out STD_LOGIC_VECTOR(15 downto 0);
        ALU_OP : in STD_LOGIC_VECTOR(4 downto 0)
    );
end ALU;
architecture behavioral of ALU is
    signal Nflag, Zflag, Cflag, Vflag : STD_LOGIC;
    signal flagsRegister : STD_LOGIC_VECTOR(15 downto 0);
component adder16bit
    port(
        adder_input_A, adder_input_B : in STD_LOGIC_VECTOR(15 downto 0);
        adder_output : out STD_LOGIC_VECTOR(15 downto 0);
        carry_in : in STD_LOGIC;
        N, Z, C, V : out STD_LOGIC
    );
end component;
begin
    process(ALU_OP)
    begin
        case ALU_OP is
            when "00000" => --problems!
                normalAddition: adder16bit port map(
                    ALU_A => adder_input_A,
                    ALU_B => adder_input_B,
                    ALU_output => adder_output,
                    '0' => carry_in,
                    Nflag => N,
                    Zflag => Z,
                    Cflag => C,
                    Vflag => V
                );
                flagsRegister <= "000000000000" & N & Z & C & V;
            when "00001" =>
                normalSubtraction: adder16bit port map(
                    ALU_A => adder_input_A,
                    not(ALU_B) => adder_input_B,
                    ALU_output => adder_output,
                    '1' => carry_in,
                    Nflag => N,
                    Zflag => Z,
                    Cflag => C,
                    Vflag => V
                );
                flagsRegister <= "000000000000" & N & Z & C & V;
            when "00010" =>
                addWithCarry: adder16bit port map(
                    ALU_A => adder_input_A,
                    ALU_B => adder_input_B,
                    ALU_output => adder_output,
                    flagsRegister(1) => carry_in,
                    Nflag => N,
                    Zflag => Z,
                    Cflag => C,
                    Vflag => V
                );
                flagsRegister <= "000000000000" & N & Z & C & V;
            when "00011" =>
                subtractWithCarry: adder16bit port map(
                    ALU_A => adder_input_A;
                    not(ALU_B) => adder_input_B;
                    ALU_output => adder_output;
                    flagsRegister(1) => carry_in,
                    Nflag => N,
                    Zflag => Z,
                    Cflag => C,
                    Vflag => V
                );
                flagsRegister <= "000000000000" & N & Z & C & V;
            when "00100" =>
                ALU_output <= STD_LOGIC_VECTOR(unsigned(ALU_A) + 1);
            when "00101" =>
                ALU_output <= STD_LOGIC_VECTOR(unsigned(ALU_A) - 1);
            when "00110" =>
                ALU_output <= ALU_A and ALU_B;
            when "00111" =>
                ALU_output <= ALU_A or ALU_B;
            when "01000" =>
                ALU_output <= ALU_A xor ALU_B;
            when "01001" =>
                ALU_output <= SHIFT_LEFT(unsigned(ALU_A), ALU_B(3 downto 0));
                flagsRegister <= "000000000000" & flagsRegister(3) & flagsRegister(2) & ALU_A(15) & flagsRegister(0); --bit 15 gets shifted into C flag
            when "01010" =>
                ALU_output <= SHIFT_RIGHT(unsigned(ALU_A), ALU_B(3 downto 0));
                flagsRegister <= "000000000000" & flagsRegister(3) & flagsRegister(2) & ALU_A(0) & flagsRegister(0); --bit 0 gets shifted into C flag
            when "01011" =>
                flagsRegister <= "000000000000" & flagsRegister(3) & flagsRegister(2) & '1' & flagsRegister(0);
            when "01100" =>
                flagsRegister <= "000000000000" & flagsRegister(3) & flagsRegister(2) & '0' & flagsRegister(0);
            when "01101" =>
                --set interrupt
                null;
            when "01110" =>
                --clear interrupt
                null;
            when "01111" =>
                ALU_out <= ALU_A;
            when "10000" =>
                LWandSW: adder16bit port map(
                    ALU_A => adder_input_A;
                    ALU_B => adder_input_B;
                    ALU_output => adder_output;
                    '0' => carry_in;
                    Nflags => N,
                    Zflags => Z,
                    Cflags => C,
                    Vflags => V
                    );
            when others =>
                null;
        end case;
    end process;
end behavioral;