Subversion Repositories xmatchpro

--This library is free software; you can redistribute it and/or
--modify it under the terms of the GNU Lesser General Public
--License as published by the Free Software Foundation; either
--version 2.1 of the License, or (at your option) any later version.
 
--This library is distributed in the hope that it will be useful,
--but WITHOUT ANY WARRANTY; without even the implied warranty of
--MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
--Lesser General Public License for more details.
 
--You should have received a copy of the GNU Lesser General Public
--License along with this library; if not, write to the Free Software
--Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-- e_mail : j.l.nunez-yanez@byacom.co.uk
 
---------------------------------------------
--  ENTITY       = PARSER                  --
--  version      = 1.0                     --
--  last update  = 30/05/00                --
--  author       = Jose Nunez              --
---------------------------------------------
 
 
-- FUNCTION
-- The parser is the core of the parsing unit
 
--  PIN LIST
 
--  DATA_IN    = data to be parse from the buffer
--  MASK = 4 bit indicatin how many bytes of the 32 are valid
--  DATA_OUT_32  = output data to the search register
--  MASK = to know the length of the tuple
--  SPACE_TUPLE = tuple formed only by spaces
--  CLEAR    = asynchronous clear
--  CLK      = master clock
 
 
library ieee;
use ieee.std_logic_1164.all;
library dzx;
use dzx.bit_arith.all;
use dzx.bit_utils.all;
 
entity PARSER is
port (
	  DATA_IN : in bit_vector(55 downto 0);
	  LENGTH_IN : in bit_vector(2 downto 0);
	  ENABLE : in bit; -- hold the state when the buffer is empty but still more data in the block
	  FINISH : in bit; -- last block is over
	  DATA_SEARCH : out bit_vector(31 downto 0);
	  DATA_OUT : out bit_vector(55 downto 0);
	  MASK : out bit_vector(4 downto 0);
	  LENGTH_OUT : out bit_vector(2 downto 0)
);
end PARSER;
 
 
architecture STRUCTURAL of PARSER is
 
 
signal VECTOR_PARSER, NORMAL_MASK, SPACE_MASK, TEMP_MASK: bit_vector(3 downto 0);
signal DATA_PARSER : bit_vector(31 downto 0);
signal SPACE : bit;
 
 
begin
 
DATA_PARSER <= DATA_IN(55 downto 24); -- parse only the more significant 4 bytes
 
COMPARATOR : process (DATA_PARSER)
begin
	for I in 3 downto 0 loop
		if DATA_PARSER(8*I+7 downto 8*I)="00100000" then -- comparing with 32
			VECTOR_PARSER(I)<='1';
		else
			VECTOR_PARSER(I)<='0';
	   	end if;
	end loop;
end process COMPARATOR;
 
 
NORMAL_WORD : process(VECTOR_PARSER)
variable A_ROW,B_ROW: bit_vector(3 downto 0);
 
begin
for I in 0 to 1 loop
	A_ROW(2*I) := VECTOR_PARSER(2*I) or VECTOR_PARSER(2*I+1);
	A_ROW(2*I+1) := VECTOR_PARSER(2*I+1);
end loop;
 
for I in 0 to 1 loop
	B_ROW(I) := A_ROW(I) or A_ROW(2);
	B_ROW(I+2) := A_ROW(I+2);
end loop;
 
NORMAL_MASK <= not('0' & B_ROW(3 downto 1));
 
end process NORMAL_WORD;
 
 
SPACE_WORD : process(VECTOR_PARSER)
variable A_ROW,B_ROW: bit_vector(3 downto 0);
 
begin
for I in 0 to 1 loop
	A_ROW(2*I) := VECTOR_PARSER(2*I) and VECTOR_PARSER(2*I+1);
	A_ROW(2*I+1) := VECTOR_PARSER(2*I+1);
end loop;
 
for I in 0 to 1 loop
	B_ROW(I) := A_ROW(I) and A_ROW(2);
	B_ROW(I+2) := A_ROW(I+2);
end loop;
 
SPACE_MASK <= B_ROW;
 
end process SPACE_WORD;
 
 
MASK_GENERATION: process(SPACE_MASK, NORMAL_MASK,LENGTH_IN)
variable INTERMEDIATE : bit_vector(3 downto 0);
variable OR_LENGTH : bit;
 
begin
 
OR_LENGTH := or_bits(LENGTH_IN);
 
for I in 3 downto 0 loop
	INTERMEDIATE(I) := not(SPACE_MASK(3)) and NORMAL_MASK(I);
end loop;
 
if (OR_LENGTH = '1') then
 
	TEMP_MASK <= (INTERMEDIATE or SPACE_MASK);
else
	TEMP_MASK <= "0000";
 
end if;
 
end process MASK_GENERATION;
 
 
LENGTH_CALCULATION : process(TEMP_MASK, LENGTH_IN, ENABLE, FINISH)
variable COM_LENGTH: bit_vector(2 downto 0);
 
begin
 
if (ENABLE = '1' or FINISH = '1') then
	case TEMP_MASK is
		when "1000" => COM_LENGTH := "001";
		when "1100" => COM_LENGTH := "010";
		when "1110" => COM_LENGTH := "011";
		when "1111" => COM_LENGTH := "100";
		when others => COM_LENGTH := "000";
	end case;
else
	COM_LENGTH := "000";
end if;
 
if (LENGTH_IN > COM_LENGTH) then      -- to handle the added artificial last byte
	LENGTH_OUT <= LENGTH_IN - COM_LENGTH;
else
	LENGTH_OUT <= "000";
end if;
 
end process LENGTH_CALCULATION;
 
-- space not present in tuple when space signal set to 1
 
SPACE_EXTENSION : process(TEMP_MASK, DATA_PARSER)
begin
if (TEMP_MASK(0) = '1' and DATA_PARSER(7 downto 0) /= "00100000") then
	SPACE <= '1';
else
	SPACE <= '0';
end if;
end process SPACE_EXTENSION;
 
 
 
MASK <= TEMP_MASK & SPACE;
 
 
SHIFT_OLD_DATA : process(TEMP_MASK, DATA_IN, ENABLE, FINISH)
 
begin
if (ENABLE = '1' or FINISH = '1') then
	case TEMP_MASK is
		when "1000" => DATA_OUT <= DATA_IN(47 downto 0) & "00000000";
		when "1100" => DATA_OUT <= DATA_IN(39 downto 0) & "0000000000000000";
		when "1110" => DATA_OUT <= DATA_IN(31 downto 0) & "000000000000000000000000";
		when "1111" => DATA_OUT <= DATA_IN(23 downto 0) & "00000000000000000000000000000000";
 		when others => DATA_OUT <= "00000000000000000000000000000000000000000000000000000000";
	end case;
else
	DATA_OUT <= DATA_IN;
end if;
end process SHIFT_OLD_DATA;
 
DATA_SEARCH <= DATA_IN(55 downto 24);
 
end structural;