Subversion Repositories xmatchpro

------------------------------------------------------------------------

-- LPM 220 Component Declaration Package  (Support string type generic)

-- These models are based on LPM version 220 (EIA-IS103 October 1998).

------------------------------------------------------------------------

-- Version Quartus v1.1 (lpm 220)      Date 01/23/01

--

-- 01/23/01: Adding use_eab=on support for lpm_ram_io, lpm_ram_dp and

--           lpm_ram_dq.

------------------------------------------------------------------------

-- Version 2.1.1 (lpm 220) Date 07/27/00

--

-- LPM_LATCH:

--     Changed Data port to be initialized with 0's.

-- LPM_DIVIDE:

--     Added LPM_REMAINDERPOSITIVE parameter.  This is a non-LPM 220

--     standard parameter.  It defaults to TRUE for LPM 220 behaviour.

-- LPM_ADD_SUB:

--     Changed default value of CIN port to HIGH (0) when subtract.

--     This behaviour is different from LPM 220 specification, which

--     probably states the incorrect default value.

------------------------------------------------------------------------

-- Version 2.1 (lpm 220) Date 04/05/00

--

-- LPM_CONSTANT:

--     Changed LPM_WIDTH type from positive to natural.

-- LPM_INV:

--     Changed LPM_WIDTH type from positive to natural.

-- LPM_AND:

--     Changed LPM_WIDTH and LPM_SIZE type from positive to natural.

-- LPM_OR:

--     Changed LPM_WIDTH and LPM_SIZE type from positive to natural.

-- LPM_XOR:

--     Changed LPM_WIDTH and LPM_SIZE type from positive to natural.

-- LPM_BUSTRI:

--     Changed LPM_WIDTH type from positive to natural.

-- LPM_MUX:

--     Changed LPM_WIDTH, LPM_SIZE and LPM_WIDTHS type from positive

--       to natural.

--     Changed LPM_PIPELINE type from integer to natural.

-- LPM_DECODE:

--     Changed LPM_WIDTH and LPM_DECODES type from positive to natural.

--     Changed LPM_PIPELINE type from integer to natural.

-- LPM_CLSHIFT:

--     Changed LPM_WIDTH and LPM_WIDTHDIST type from positive to

--       natural.

-- LPM_ADD_SUB:

--     Changed LPM_WIDTH type from positive to natural.

--     Changed LPM_PIPELINE type from integer to natural.

-- LPM_COMPARE:

--     Changed LPM_WIDTH type from positive to natural.

--     Changed LPM_PIPELINE type from integer to natural.

-- LPM_MULT:

--     Changed LPM_WIDTHA, LPM_WIDTHB and LPM_WIDTHP type from positive

--       to natural.

--     Changed LPM_PIPELINE type from integer to natural.

-- LPM_DIVIDE:

--     Changed LPM_WIDTHN and LPM_WIDTHD from positive to natural.

--     Changed LPM_PIPELINE type from integer to natural.

-- LPM_ABS:

--     Changed LPM_WIDTH type from positive to natural.

-- LPM_COUNTER:

--     Changed LPM_WIDTH type from positive to natural.

-- LPM_LATCH:

--     Changed LPM_WIDTH type from positive to natural.

-- LPM_FF:

--     Changed LPM_WIDTH type from positive to natural.

-- LPM_SHIFTREG:

--     Changed LPM_WIDTH type from positive to natural.

-- LPM_RAM_DQ:

--     Changed LPM_WIDTH and LPM_WIDTHAD from positive to natural.

-- LPM_RAM_DP:

--     Changed LPM_WIDTH and LPM_WIDTHAD from positive to natural.

-- LPM_RAM_IO:

--     Changed LPM_WIDTH and LPM_WIDTHAD from positive to natural.

-- LPM_ROM:

--     Changed LPM_WIDTH and LPM_WIDTHAD from positive to natural.

-- LPM_FIFO:

--     Changed LPM_WIDTH, LPM_WIDTHU and LPM_NUMWORDS from positive to

--       natural.

-- LPM_FIFO_DC:

--     Changed LPM_WIDTH, LPM_WIDTHU and LPM_NUMWORDS from positive to

--       natural.

-- LPM_TTABLE:

--     Changed LPM_WIDTHIN and LPM_WIDTHOUT from positive to natural.

-- LPM_FSM:

--     Changed LPM_WIDTHIN, LPM_WIDTHOUT and LPM_WIDTHS from positive

--       to natural.

-- LPM_INPAD:

--     Changed LPM_WIDTH type from positive to natural.

-- LPM_OUTPAD:

--     Changed LPM_WIDTH type from positive to natural.

-- LPM_BIPAD:

--     Changed LPM_WIDTH type from positive to natural.

------------------------------------------------------------------------

-- Version 1.8 (lpm 220) Date 10/21/99

--

-- Fixed str_to_int() to correctly convert string to integer.

------------------------------------------------------------------------

-- Version 1.7 (lpm 220) Date 07/13/99

--

-- Changed OutEnab and WE in LPM_RAM_IO to default to 'Z'.

------------------------------------------------------------------------

-- Version 1.6 (lpm 220) Date 06/14/99

--

-- Added LPM_HINT and LPM_TYPE to all, if not existed.

-- Changed all clock signals default value to '0'.

-- Changed default values of parameters to comply with the spec.

--

-- LPM_BUSTRI:

--     Renamed TRDATA to TRIDATA.

-- LPM_MULT:

--     Changed LPM_WIDTHS type from positive to natural, default to 0.

-- LPM_DIVIDE:

--     Discarded LPM_WIDTHD and LPM_WIDTHR.

-- LPM_COUNTER:

--     Discarded EQ.

--     Added CIN and COUT.

--     Changed LPM_MODULUS type from integer to natural.

-- LPM_FF:

--     Added LPM_PVALUE, default to "UNUSED".

--     Changed LPM_FFTYPE default value from "FFTYPE_DFF" to "DFF".

-- LPM_SHIFTREG:

--     Added LPM_PVALUE, default to "UNUSED".

-- LPM_RAM_DQ:

--     Changed LPM_NUMWORDS type from integer to natrual.

--     Changed WE to have no default value.

-- LPM_RAM_DP:

--     Changed LPM_NUMWORDS type from integer to natrual.

--     Changed RDCLKEN default value from '0' to '1'.

-- LPM_RAM_IO:

--     Changed LPM_NUMWORDS type from integer to natrual.

-- LPM_ROM:

--     Changed LPM_NUMWORDS type from integer to natrual.

-- LPM_FIFO:

--     Added LPM_WIDTHU default value '1'.

--     Added ACLR and SCLR default value '0'.

-- LPM_FSM:

--     Added LPM_PVALUE, default to "UNUSED".

--     Added TESTENAB and TESTIN, default to '0'.

--     Added TESTOUT.

------------------------------------------------------------------------

-- Version 1.5 (lpm 220) Date 05/10/99

--

-- Added 0 default value to LPM_NUMWORD parameter in LPM_RAM_DQ,

-- LPM_RAM_IO, and LPM_ROM. Also added 0 default value to LPM_MODULUS.

------------------------------------------------------------------------

-- Version 1.4 (lpm 220) Date 02/05/99

--

-- Removed the constant declarations for string type parameters.

-- Changed LPM_NUMWORDS type from string to positive.

-- Added LPM_DIVIDE, LPM_RAM_DP, LPM_FIFO, and LPM_SCFIFO functions.

------------------------------------------------------------------------

-- Version 1.3   Date 07/30/97

------------------------------------------------------------------------

-- Excluded:

--

-- 1. LPM_POLARITY.

-- 2. SCAN pins are eliminated from storage functions.

------------------------------------------------------------------------

-- Assumptions:

--

--    LPM_SVALUE, LPM_AVALUE, LPM_MODULUS, and LPM_NUMWORDS, LPM_HINT,

--    LPM_STRENGTH, LPM_DIRECTION, and LPM_PVALUE  default value is

--    string "UNUSED".

------------------------------------------------------------------------

library IEEE;

use IEEE.std_logic_1164.all;

package LPM_COMPONENTS is

constant L_CONSTANT : string := "LPM_CONSTANT";

constant L_INV      : string := "LPM_INV";

constant L_AND      : string := "LPM_AND";

constant L_OR       : string := "LPM_OR";

constant L_XOR      : string := "LPM_XOR";

constant L_BUSTRI   : string := "LPM_BUSTRI";

constant L_MUX      : string := "LPM_MUX";

constant L_DECODE   : string := "LPM_DECODE";

constant L_CLSHIFT  : string := "LPM_CLSHIFT";

constant L_ADD_SUB  : string := "LPM_ADD_SUB";

constant L_COMPARE  : string := "LPM_COMPARE";

constant L_MULT     : string := "LPM_MULT";

constant L_DIVIDE   : string := "LPM_DIVIDE";

constant L_ABS      : string := "LPM_ABS";

constant L_COUNTER  : string := "LPM_COUNTER";

constant L_LATCH    : string := "LPM_LATCH";

constant L_FF       : string := "LPM_FF";

constant L_SHIFTREG : string := "LPM_SHIFTREG";

constant L_RAM_DQ   : string := "LPM_RAM_DQ";

constant L_RAM_DP   : string := "LPM_RAM_DP";

constant L_RAM_IO   : string := "LPM_RAM_IO";

constant L_ROM      : string := "LPM_ROM";

constant L_FIFO     : string := "LPM_FIFO";

constant L_FIFO_DC  : string := "LPM_FIFO_DC";

constant L_TTABLE   : string := "LPM_TTABLE";

constant L_FSM      : string := "LPM_FSM";

constant L_INPAD    : string := "LPM_INPAD";

constant L_OUTPAD   : string := "LPM_OUTPAD";

constant L_BIPAD    : string := "LPM_BIPAD";

type STD_LOGIC_2D is array (NATURAL RANGE <>, NATURAL RANGE <>) of STD_LOGIC;

function str_to_int(S : string) return integer;

------------------------------------------------------------------------

-- GATES ---------------------------------------------------------------

------------------------------------------------------------------------

component LPM_CONSTANT

        generic (LPM_WIDTH : natural;    -- MUST be greater than 0

                                 LPM_CVALUE : natural;

                                 LPM_STRENGTH : string := "UNUSED";

                                 LPM_TYPE : string := L_CONSTANT;

                                 LPM_HINT : string := "UNUSED");

                port (RESULT : out std_logic_vector(LPM_WIDTH-1 downto 0));

end component;

component LPM_INV

        generic (LPM_WIDTH : natural;    -- MUST be greater than 0

                                 LPM_TYPE : string := L_INV;

                                 LPM_HINT : string := "UNUSED");

                port (DATA : in std_logic_vector(LPM_WIDTH-1 downto 0);

                          RESULT : out std_logic_vector(LPM_WIDTH-1 downto 0));

end component;

component LPM_AND

        generic (LPM_WIDTH : natural;    -- MUST be greater than 0

                 LPM_SIZE : natural;    -- MUST be greater than 0

                                 LPM_TYPE : string := L_AND;

                                 LPM_HINT : string := "UNUSED");

                port (DATA : in std_logic_2D(LPM_SIZE-1 downto 0, LPM_WIDTH-1 downto 0);

                          RESULT : out std_logic_vector(LPM_WIDTH-1 downto 0));

end component;

component LPM_OR

        generic (LPM_WIDTH : natural;    -- MUST be greater than 0

                 LPM_SIZE : natural;    -- MUST be greater than 0

                                 LPM_TYPE : string := L_OR;

                                 LPM_HINT : string := "UNUSED");

                port (DATA : in std_logic_2D(LPM_SIZE-1 downto 0, LPM_WIDTH-1 downto 0);

                          RESULT : out std_logic_vector(LPM_WIDTH-1 downto 0));

end component;

component LPM_XOR

        generic (LPM_WIDTH : natural;    -- MUST be greater than 0

                 LPM_SIZE : natural;    -- MUST be greater than 0

                                 LPM_TYPE : string := L_XOR;

                                 LPM_HINT : string := "UNUSED");

                port (DATA : in std_logic_2D(LPM_SIZE-1 downto 0, LPM_WIDTH-1 downto 0);

                          RESULT : out std_logic_vector(LPM_WIDTH-1 downto 0));

end component;

component LPM_BUSTRI

        generic (LPM_WIDTH : natural;    -- MUST be greater than 0

                                 LPM_TYPE : string := L_BUSTRI;

                                 LPM_HINT : string := "UNUSED");

                port (DATA : in std_logic_vector(LPM_WIDTH-1 downto 0);

                          ENABLEDT : in std_logic := '0';

                          ENABLETR : in std_logic := '0';

                          RESULT : out std_logic_vector(LPM_WIDTH-1 downto 0);

                          TRIDATA : inout std_logic_vector(LPM_WIDTH-1 downto 0));

end component;

component LPM_MUX

        generic (LPM_WIDTH : natural;    -- MUST be greater than 0

                 LPM_SIZE : natural;    -- MUST be greater than 0

                 LPM_WIDTHS : natural;    -- MUST be greater than 0

                 LPM_PIPELINE : natural := 0;

                                 LPM_TYPE : string := L_MUX;

                                 LPM_HINT : string := "UNUSED");

                port (DATA : in std_logic_2D(LPM_SIZE-1 downto 0, LPM_WIDTH-1 downto 0);

                          ACLR : in std_logic := '0';

                          CLOCK : in std_logic := '0';

                          CLKEN : in std_logic := '1';

                          SEL : in std_logic_vector(LPM_WIDTHS-1 downto 0);

                          RESULT : out std_logic_vector(LPM_WIDTH-1 downto 0));

end component;

component LPM_DECODE

        generic (LPM_WIDTH : natural;    -- MUST be greater than 0

                 LPM_DECODES : natural;    -- MUST be greater than 0

                 LPM_PIPELINE : natural := 0;

                                 LPM_TYPE : string := L_DECODE;

                                 LPM_HINT : string := "UNUSED");

                port (DATA : in std_logic_vector(LPM_WIDTH-1 downto 0);

                          CLOCK : in std_logic := '0';

                          CLKEN : in std_logic := '1';

                          ACLR : in std_logic := '0';

                          ENABLE : in std_logic := '1';

                          EQ : out std_logic_vector(LPM_DECODES-1 downto 0));

end component;

component LPM_CLSHIFT

        generic (LPM_WIDTH : natural;    -- MUST be greater than 0

                 LPM_WIDTHDIST : natural;    -- MUST be greater than 0

                                 LPM_SHIFTTYPE : string := "LOGICAL";

                                 LPM_TYPE : string := L_CLSHIFT;

                                 LPM_HINT : string := "UNUSED");

                port (DATA : in STD_LOGIC_VECTOR(LPM_WIDTH-1 downto 0);

                          DISTANCE : in STD_LOGIC_VECTOR(LPM_WIDTHDIST-1 downto 0);

                          DIRECTION : in STD_LOGIC := '0';

                          RESULT : out STD_LOGIC_VECTOR(LPM_WIDTH-1 downto 0);

                          UNDERFLOW : out STD_LOGIC;

                          OVERFLOW : out STD_LOGIC);

end component;

------------------------------------------------------------------------

-- ARITHMETIC COMPONENTS -----------------------------------------------

------------------------------------------------------------------------

component LPM_ADD_SUB

        generic (LPM_WIDTH : natural;    -- MUST be greater than 0

                                 LPM_DIRECTION : string := "UNUSED";

                                 LPM_REPRESENTATION: string := "SIGNED";

                 LPM_PIPELINE : natural := 0;

                                 LPM_TYPE : string := L_ADD_SUB;

                                 LPM_HINT : string := "UNUSED");

                port (DATAA : in std_logic_vector(LPM_WIDTH-1 downto 0);

                          DATAB : in std_logic_vector(LPM_WIDTH-1 downto 0);

                          ACLR : in std_logic := '0';

                          CLOCK : in std_logic := '0';

                          CLKEN : in std_logic := '1';

              CIN : in std_logic := 'Z';

                          ADD_SUB : in std_logic := '1';

                          RESULT : out std_logic_vector(LPM_WIDTH-1 downto 0);

                          COUT : out std_logic;

                          OVERFLOW : out std_logic);

end component;

component LPM_COMPARE

        generic (LPM_WIDTH : natural;    -- MUST be greater than 0

                                 LPM_REPRESENTATION : string := "UNSIGNED";

                 LPM_PIPELINE : natural := 0;

                                 LPM_TYPE: string := L_COMPARE;

                                 LPM_HINT : string := "UNUSED");

                port (DATAA : in std_logic_vector(LPM_WIDTH-1 downto 0);

                          DATAB : in std_logic_vector(LPM_WIDTH-1 downto 0);

                          ACLR : in std_logic := '0';

                          CLOCK : in std_logic := '0';

                          CLKEN : in std_logic := '1';

                          AGB : out std_logic;

                          AGEB : out std_logic;

                          AEB : out std_logic;

                          ANEB : out std_logic;

                          ALB : out std_logic;

                          ALEB : out std_logic);

end component;

component LPM_MULT

        generic (LPM_WIDTHA : natural;    -- MUST be greater than 0

                 LPM_WIDTHB : natural;    -- MUST be greater than 0

                                 LPM_WIDTHS : natural := 0;

                 LPM_WIDTHP : natural;    -- MUST be greater than 0

                                 LPM_REPRESENTATION : string := "UNSIGNED";

                 LPM_PIPELINE : natural := 0;

                                 LPM_TYPE: string := L_MULT;

                                 LPM_HINT : string := "UNUSED");

                port (DATAA : in std_logic_vector(LPM_WIDTHA-1 downto 0);

                          DATAB : in std_logic_vector(LPM_WIDTHB-1 downto 0);

                          ACLR : in std_logic := '0';

                          CLOCK : in std_logic := '0';

                          CLKEN : in std_logic := '1';

                          SUM : in std_logic_vector(LPM_WIDTHS-1 downto 0) := (OTHERS => '0');

                          RESULT : out std_logic_vector(LPM_WIDTHP-1 downto 0));

end component;

component LPM_DIVIDE

        generic (LPM_WIDTHN : natural;    -- MUST be greater than 0

                 LPM_WIDTHD : natural;    -- MUST be greater than 0

                                 LPM_NREPRESENTATION : string := "UNSIGNED";

                                 LPM_DREPRESENTATION : string := "UNSIGNED";

                 LPM_REMAINDERPOSITIVE : string := "TRUE";

                 LPM_PIPELINE : natural := 0;

                                 LPM_TYPE : string := L_DIVIDE;

                                 LPM_HINT : string := "UNUSED");

                port (NUMER : in std_logic_vector(LPM_WIDTHN-1 downto 0);

                          DENOM : in std_logic_vector(LPM_WIDTHD-1 downto 0);

                          ACLR : in std_logic := '0';

                          CLOCK : in std_logic := '0';

                          CLKEN : in std_logic := '1';

                          QUOTIENT : out std_logic_vector(LPM_WIDTHN-1 downto 0);

                          REMAIN : out std_logic_vector(LPM_WIDTHD-1 downto 0));

end component;

component LPM_ABS

        generic (LPM_WIDTH : natural;    -- MUST be greater than 0

                                 LPM_TYPE: string := L_ABS;

                                 LPM_HINT : string := "UNUSED");

                port (DATA : in std_logic_vector(LPM_WIDTH-1 downto 0);

                          RESULT : out std_logic_vector(LPM_WIDTH-1 downto 0);

                          OVERFLOW : out std_logic);

end component;

component LPM_COUNTER

        generic (LPM_WIDTH : natural;    -- MUST be greater than 0

                                 LPM_MODULUS : natural := 0;

                                 LPM_DIRECTION : string := "UNUSED";

                                 LPM_AVALUE : string := "UNUSED";

                                 LPM_SVALUE : string := "UNUSED";

                                 LPM_PVALUE : string := "UNUSED";

                                 LPM_TYPE: string := L_COUNTER;

                                 LPM_HINT : string := "UNUSED");

                port (DATA : in std_logic_vector(LPM_WIDTH-1 downto 0):= (OTHERS => '0');

                          CLOCK : in std_logic ;

                          CLK_EN : in std_logic := '1';

                          CNT_EN : in std_logic := '1';

                          UPDOWN : in std_logic := '1';

                          SLOAD : in std_logic := '0';

                          SSET : in std_logic := '0';

                          SCLR : in std_logic := '0';

                          ALOAD : in std_logic := '0';

                          ASET : in std_logic := '0';

                          ACLR : in std_logic := '0';

              CIN : in std_logic := '1';

                          COUT : out std_logic := '0';

                          Q : out std_logic_vector(LPM_WIDTH-1 downto 0));

end component;

------------------------------------------------------------------------

-- STORAGE COMPONENTS --------------------------------------------------

------------------------------------------------------------------------

component LPM_LATCH

        generic (LPM_WIDTH : natural;    -- MUST be greater than 0

                                 LPM_AVALUE : string := "UNUSED";

                                 LPM_PVALUE : string := "UNUSED";

                                 LPM_TYPE: string := L_LATCH;

                                 LPM_HINT : string := "UNUSED");

        port (DATA : in std_logic_vector(LPM_WIDTH-1 downto 0) := (OTHERS => '0');

                          GATE : in std_logic;

                          ASET : in std_logic := '0';

                          ACLR : in std_logic := '0';

                          Q : out std_logic_vector(LPM_WIDTH-1 downto 0));

end component;

component LPM_FF

        generic (LPM_WIDTH : natural;    -- MUST be greater than 0

                                 LPM_AVALUE : string := "UNUSED";

                                 LPM_SVALUE : string := "UNUSED";

                                 LPM_PVALUE : string := "UNUSED";

                                 LPM_FFTYPE: string := "DFF";

                                 LPM_TYPE: string := L_FF;

                                 LPM_HINT : string := "UNUSED");

                port (DATA : in std_logic_vector(LPM_WIDTH-1 downto 0);

                          CLOCK : in std_logic;

                          ENABLE : in std_logic := '1';

                          SLOAD : in std_logic := '0';

                          SCLR : in std_logic := '0';

                          SSET : in std_logic := '0';

                          ALOAD : in std_logic := '0';

                          ACLR : in std_logic := '0';

                          ASET : in std_logic := '0';

                          Q : out std_logic_vector(LPM_WIDTH-1 downto 0));

end component;

component LPM_SHIFTREG

        generic (LPM_WIDTH : natural;    -- MUST be greater than 0

                                 LPM_AVALUE : string := "UNUSED";

                                 LPM_SVALUE : string := "UNUSED";

                                 LPM_PVALUE : string := "UNUSED";

                                 LPM_DIRECTION: string := "UNUSED";

                                 LPM_TYPE: string := L_SHIFTREG;

                                 LPM_HINT : string := "UNUSED");

                port (DATA : in std_logic_vector(LPM_WIDTH-1 downto 0) := (OTHERS => '0');

                          CLOCK : in std_logic;

                          ENABLE : in std_logic := '1';

                          SHIFTIN : in std_logic := '1';

                          LOAD : in std_logic := '0';

                          SCLR : in std_logic := '0';

                          SSET : in std_logic := '0';

                          ACLR : in std_logic := '0';

                          ASET : in std_logic := '0';

                          Q : out std_logic_vector(LPM_WIDTH-1 downto 0);

                          SHIFTOUT : out std_logic);

end component;

component LPM_RAM_DQ

        generic (LPM_WIDTH : natural;    -- MUST be greater than 0

                 LPM_WIDTHAD : natural;    -- MUST be greater than 0

                                 LPM_NUMWORDS : natural := 0;

                                 LPM_INDATA : string := "REGISTERED";

                                 LPM_ADDRESS_CONTROL: string := "REGISTERED";

                                 LPM_OUTDATA : string := "REGISTERED";

                                 LPM_FILE : string := "UNUSED";

                                 LPM_TYPE : string := L_RAM_DQ;

                                 USE_EAB  : string := "OFF";

                                 INTENDED_DEVICE_FAMILY  : string := "UNUSED";

                                 LPM_HINT : string := "UNUSED");

                port (DATA : in std_logic_vector(LPM_WIDTH-1 downto 0);

                          ADDRESS : in std_logic_vector(LPM_WIDTHAD-1 downto 0);

                          INCLOCK : in std_logic := '0';

                          OUTCLOCK : in std_logic := '0';

                          WE : in std_logic;

                          Q : out std_logic_vector(LPM_WIDTH-1 downto 0));

end component;

component LPM_RAM_DP

        generic (LPM_WIDTH : natural;    -- MUST be greater than 0

                 LPM_WIDTHAD : natural;    -- MUST be greater than 0

                                 LPM_NUMWORDS : natural := 0;

                                 LPM_INDATA : string := "REGISTERED";

                                 LPM_OUTDATA : string := "REGISTERED";

                                 LPM_RDADDRESS_CONTROL : string := "REGISTERED";

                                 LPM_WRADDRESS_CONTROL : string := "REGISTERED";

                                 LPM_FILE : string := "UNUSED";

                                 LPM_TYPE : string := L_RAM_DP;

                                 USE_EAB  : string := "OFF";

                                 INTENDED_DEVICE_FAMILY  : string := "UNUSED";

                                 RDEN_USED  : string := "TRUE";

                                 LPM_HINT : string := "UNUSED");

                port (RDCLOCK : in std_logic := '0';

                          RDCLKEN : in std_logic := '1';

                          RDADDRESS : in std_logic_vector(LPM_WIDTHad-1 downto 0);

                          RDEN : in std_logic := '1';

                          DATA : in std_logic_vector(LPM_WIDTH-1 downto 0);

                          WRADDRESS : in std_logic_vector(LPM_WIDTHad-1 downto 0);

                          WREN : in std_logic;

                          WRCLOCK : in std_logic := '0';

                          WRCLKEN : in std_logic := '1';

                          Q : out std_logic_vector(LPM_WIDTH-1 downto 0));

end component;

component LPM_RAM_IO

        generic (LPM_WIDTH : natural;    -- MUST be greater than 0

                 LPM_WIDTHAD : natural;    -- MUST be greater than 0

                                 LPM_NUMWORDS : natural := 0;

                                 LPM_INDATA : string := "REGISTERED";

                                 LPM_ADDRESS_CONTROL : string := "REGISTERED";

                                 LPM_OUTDATA : string := "REGISTERED";

                                 LPM_FILE : string := "UNUSED";

                                 LPM_TYPE : string := L_RAM_IO;

                                 INTENDED_DEVICE_FAMILY  : string := "UNUSED";

                                 USE_EAB  : string := "OFF";

                                 LPM_HINT : string := "UNUSED");

                port (ADDRESS : in STD_LOGIC_VECTOR(LPM_WIDTHAD-1 downto 0);

                          INCLOCK : in STD_LOGIC := '0';

                          OUTCLOCK : in STD_LOGIC := '0';

                          MEMENAB : in STD_LOGIC := '1';

                          OUTENAB : in STD_LOGIC := 'Z';

                          WE : in STD_LOGIC := 'Z';

                          DIO : inout STD_LOGIC_VECTOR(LPM_WIDTH-1 downto 0));

end component;

component LPM_ROM

        generic (LPM_WIDTH : natural;    -- MUST be greater than 0

                 LPM_WIDTHAD : natural;    -- MUST be greater than 0

                                 LPM_NUMWORDS : natural := 0;

                                 LPM_ADDRESS_CONTROL : string := "REGISTERED";

                                 LPM_OUTDATA : string := "REGISTERED";

                                 LPM_FILE : string;

                                 LPM_TYPE : string := L_ROM;

                                 INTENDED_DEVICE_FAMILY  : string := "UNUSED";

                                 LPM_HINT : string := "UNUSED");

                port (ADDRESS : in STD_LOGIC_VECTOR(LPM_WIDTHAD-1 downto 0);

                          INCLOCK : in STD_LOGIC := '0';

                          OUTCLOCK : in STD_LOGIC := '0';

                          MEMENAB : in STD_LOGIC := '1';

                          Q : out STD_LOGIC_VECTOR(LPM_WIDTH-1 downto 0));

end component;

component LPM_FIFO

        generic (LPM_WIDTH : natural;    -- MUST be greater than 0

                 LPM_WIDTHU : natural := 1;    -- MUST be greater than 0

                 LPM_NUMWORDS : natural;    -- MUST be greater than 0

                                 LPM_SHOWAHEAD : string := "OFF";

                                 LPM_TYPE : string := L_FIFO;

                                 LPM_HINT : string := "UNUSED");

                port (DATA : in std_logic_vector(LPM_WIDTH-1 downto 0);

                          CLOCK : in std_logic;

                          WRREQ : in std_logic;

                          RDREQ : in std_logic;

                          ACLR : in std_logic := '0';

                          SCLR : in std_logic := '0';

                          Q : out std_logic_vector(LPM_WIDTH-1 downto 0);

                          USEDW : out std_logic_vector(LPM_WIDTHU-1 downto 0);

                          FULL : out std_logic;

                          EMPTY : out std_logic);

end component;

component LPM_FIFO_DC

        generic (LPM_WIDTH : natural;    -- MUST be greater than 0

                 LPM_WIDTHU : natural := 1;    -- MUST be greater than 0

                 LPM_NUMWORDS : natural;    -- MUST be greater than 0

                 LPM_SHOWAHEAD : string := "OFF";

                 LPM_TYPE : string := L_FIFO_DC;

                 UNDERFLOW_CHECKING : string := "ON";

                 OVERFLOW_CHECKING : string := "ON";

                 LPM_HINT : string := "UNUSED");

                port (DATA : in std_logic_vector(LPM_WIDTH-1 downto 0);

                          WRCLOCK : in std_logic;

                          RDCLOCK : in std_logic;

                          WRREQ : in std_logic;

                          RDREQ : in std_logic;

                          ACLR : in std_logic := '0';

                          Q : out std_logic_vector(LPM_WIDTH-1 downto 0);

                          WRUSEDW : out std_logic_vector(LPM_WIDTHU-1 downto 0);

                          RDUSEDW : out std_logic_vector(LPM_WIDTHU-1 downto 0);

                          WRFULL : out std_logic;

                          RDFULL : out std_logic;

                          WREMPTY : out std_logic;

                          RDEMPTY : out std_logic);

end component;

------------------------------------------------------------------------

-- TABLE PRIMITIVES ----------------------------------------------------

------------------------------------------------------------------------

component LPM_TTABLE

        generic (LPM_WIDTHIN : natural;    -- MUST be greater than 0

                 LPM_WIDTHOUT : natural;    -- MUST be greater than 0

                                 LPM_FILE : string;

                                 LPM_TRUTHTYPE : string := "FD";

                                 LPM_TYPE : string := L_TTABLE;

                                 LPM_HINT : string := "UNUSED");

                port (DATA : in std_logic_vector(LPM_WIDTHIN-1 downto 0);

                          RESULT : out std_logic_vector(LPM_WIDTHOUT-1 downto 0));

end component;

component LPM_FSM

        generic (LPM_WIDTHIN : natural;    -- MUST be greater than 0

                 LPM_WIDTHOUT : natural;    -- MUST be greater than 0

                 LPM_WIDTHS : natural := 1;    -- MUST be greater than 0

                                 LPM_FILE : string ;

                                 LPM_PVALUE : string := "UNUSED";

                                 LPM_AVALUE : string := "UNUSED";

                                 LPM_TRUTHTYPE : string := "FD";

                                 LPM_TYPE : string := L_FSM;

                                 LPM_HINT : string := "UNUSED");

                port (DATA : in std_logic_vector(LPM_WIDTHIN-1 downto 0);

                          CLOCK : in std_logic;

                          ASET : in std_logic := '0';

                          TESTENAB : in std_logic := '0';

                          TESTIN : in std_logic := '0';

                          TESTOUT : out std_logic;

                          STATE : out std_logic_vector(LPM_WIDTHS-1 downto 0);

                          RESULT : out std_logic_vector(LPM_WIDTHOUT-1 downto 0));

end component;

------------------------------------------------------------------------

-- PAD PRIMITIVES ------------------------------------------------------

------------------------------------------------------------------------

component LPM_INPAD

        generic (LPM_WIDTH : natural;    -- MUST be greater than 0

                                 LPM_TYPE : string := L_INPAD;

                                 LPM_HINT : string := "UNUSED");

                port (PAD : in std_logic_vector(LPM_WIDTH-1 downto 0);

                          RESULT : out std_logic_vector(LPM_WIDTH-1 downto 0));

end component;

component LPM_OUTPAD

        generic (LPM_WIDTH : natural;    -- MUST be greater than 0

                                 LPM_TYPE : string := L_OUTPAD;

                                 LPM_HINT : string := "UNUSED");

                port (DATA : in std_logic_vector(LPM_WIDTH-1 downto 0);

                          PAD : out std_logic_vector(LPM_WIDTH-1 downto 0));

end component;

component LPM_BIPAD

        generic (LPM_WIDTH : natural;    -- MUST be greater than 0

                                 LPM_TYPE : string := L_BIPAD;

                                 LPM_HINT : string := "UNUSED");

                port (DATA : in std_logic_vector(LPM_WIDTH-1 downto 0);

                          ENABLE : in std_logic;

                          RESULT : out std_logic_vector(LPM_WIDTH-1 downto 0);

                          PAD : inout std_logic_vector(LPM_WIDTH-1 downto 0));

end component;

end;

package body LPM_COMPONENTS is

    function str_to_int( s : string ) return integer is

        variable len : integer := s'length;

        variable ivalue : integer := 0;

        variable digit : integer;

        begin

        for i in 1 to len loop

                        case s(i) is

                                when '0' =>

                                        digit := 0;

                                when '1' =>

                                        digit := 1;

                                when '2' =>

                                        digit := 2;

                                when '3' =>

                                        digit := 3;

                                when '4' =>

                                        digit := 4;

                                when '5' =>

                                        digit := 5;

                                when '6' =>

                                        digit := 6;

                                when '7' =>

                                        digit := 7;

                                when '8' =>

                                        digit := 8;

                                when '9' =>

                                        digit := 9;

                                when others =>

                                        ASSERT FALSE

                                        REPORT "Illegal Character "&  s(i) & "in string parameter! "

                                        SEVERITY ERROR;

                        end case;

                        ivalue := ivalue * 10 + digit;

                end loop;

                return ivalue;

        end;

end;