generic inside a package

[megha26]

We are trying to write a pckg to use in the code of complex multiplication.

Its showing error for this part of the package.

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
use work.fixed_float_types.all;
package fixed_generic_pkg is
generic (fixed_round_style : fixed_round_style_type := fixed_round;
fixed_overflow_style : fixed_overflow_style_type := fixed_saturate;
fixed_guard_bits : natural := 3;
no_warning : boolean := false
);
......
......


The error is ' parse error, unexpected generic'. If we can't use generic inside a package then whay may be the alternative for this?? please help us out....

thanks in advce..

 

[bigdogguru]

You may be able to use GENERIC in a PACKAGE depending of the software and version. What synthesis or simulation software and version are you using. There maybe something else causing the error, can you upload the entire package code? This will help pinpoint the problem. Also include your defined types in work.fixed_float_types.all.

 

[devas]

Hi,

Declaring generics in a package has been added to the standard in VHDL-2008. If your simulator/synthesis tool does not support this (part of the) VHDL-2008 standard you will receive parser errors.

Devas

 

[megha26]

Thanks a lot for helping....

 

[bigdogguru]

No problem,

Devas is correct and that is why I inquired as to the software you were using. Use of GENERIC in PACKAGE is in the current standard, VHDL - 2008, but unfortunately is not well supported in the current software packages. I also noticed the code snippet you used as an example is from Peter Ashenden's The Designer's Guide to VHDL, Third Edition. It's a great reference book as long as you keep in mind it tends to run ahead of the curve as far as supported features.

 

[megha26]

This is the package we've used...............
Its the package from the same book.... ' The Designer's Guide to VHDL'...

........................................................................................
library ieee;
use ieee.std_logic_1164.all;
use work.fixed_generic_pkg.all;

package fixed_pkg is new ieee.fixed_generic_pkg
generic map (
fixed_round_style => ieee.fixed_float_types.fixed_round,
fixed_overflow_style => ieee.fixed_float_types.fixed_saturate,
fixed_guard_bits => 3,
no_warning => false
);
end package fixed_pkg;

...........................................................................................

use std.textio.all;
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
use work.fixed_float_types.all;
package fixed_generic_pkg is
generic (fixed_round_style : fixed_round_style_type := fixed_round;
fixed_overflow_style : fixed_overflow_style_type := fixed_saturate;
fixed_guard_bits : natural := 3;
no_warning : boolean := false
);

-- Author David Bishop (dbishop@vhdl.org)

constant CopyRightNotice : string :=
--"Copyright 2008 by IEEE. All rights reserved.";
type unresolved_ufixed is array (integer range <>) of std_ulogic;
type unresolved_sfixed is array (integer range <>) of std_ulogic;
alias u_ufixed is unresolved_ufixed;
alias u_sfixed is unresolved_sfixed;
subtype ufixed is (resolved) unresolved_ufixed;
subtype sfixed is (resolved) unresolved_sfixed;
function "abs" (arg : unresolved_sfixed) return unresolved_sfixed;
function "-" (arg : unresolved_sfixed) return unresolved_sfixed;
function "+" (l, r : unresolved_ufixed) return unresolved_ufixed;
function "+" (l : unresolved_ufixed; r : real) return unresolved_ufixed;
function "+" (l : real; r : unresolved_ufixed) return unresolved_ufixed;
function "+" (l : unresolved_ufixed; r : natural) return unresolved_ufixed;
function "+" (l : natural; r : unresolved_ufixed) return unresolved_ufixed;
function "+" (l, r : unresolved_sfixed) return unresolved_sfixed;
function "+" (l : unresolved_sfixed; r : real) return unresolved_sfixed;
function "+" (l : real; r : unresolved_sfixed) return unresolved_sfixed;
function "+" (l : unresolved_sfixed; r : integer) return unresolved_sfixed;
function "+" (l : integer; r : unresolved_sfixed) return unresolved_sfixed;
function "-" (l, r : unresolved_ufixed) return unresolved_ufixed;
function "-" (l : unresolved_ufixed; r : real) return unresolved_ufixed;
function "-" (l : real; r : unresolved_ufixed) return unresolved_ufixed;
function "-" (l : unresolved_ufixed; r : natural) return unresolved_ufixed;
function "-" (l : natural; r : unresolved_ufixed) return unresolved_ufixed;
function "-" (l, r : unresolved_sfixed) return unresolved_sfixed;
function "-" (l : unresolved_sfixed; r : real) return unresolved_sfixed;
function "-" (l : real; r : unresolved_sfixed) return unresolved_sfixed;
function "-" (l : unresolved_sfixed; r : integer) return unresolved_sfixed;
function "-" (l : integer; r : unresolved_sfixed) return unresolved_sfixed;
function "*" (l, r : unresolved_ufixed) return unresolved_ufixed;
function "*" (l : unresolved_ufixed; r : real) return unresolved_ufixed;
function "*" (l : real; r : unresolved_ufixed) return unresolved_ufixed;
function "*" (l : unresolved_ufixed; r : natural) return unresolved_ufixed;
function "*" (l : natural; r : unresolved_ufixed) return unresolved_ufixed;
function "*" (l, r : unresolved_sfixed) return unresolved_sfixed;
function "*" (l : unresolved_sfixed; r : real) return unresolved_sfixed;
function "*" (l : real; r : unresolved_sfixed) return unresolved_sfixed;
function "*" (l : unresolved_sfixed; r : integer) return unresolved_sfixed;
function "*" (l : integer; r : unresolved_sfixed) return unresolved_sfixed;
function "/" (l, r : unresolved_ufixed) return unresolved_ufixed;
function "/" (l : unresolved_ufixed; r : real) return unresolved_ufixed;
function "/" (l : real; r : unresolved_ufixed) return unresolved_ufixed;
function "/" (l : unresolved_ufixed; r : natural) return unresolved_ufixed;
function "/" (l : natural; r : unresolved_ufixed) return unresolved_ufixed;
function "/" (l, r : unresolved_sfixed) return unresolved_sfixed;
function "/" (l : unresolved_sfixed; r : real) return unresolved_sfixed;
function "/" (l : real; r : unresolved_sfixed) return unresolved_sfixed;
function "/" (l : unresolved_sfixed; r : integer) return unresolved_sfixed;
function "/" (l : integer; r : unresolved_sfixed) return unresolved_sfixed;
function "rem" (l, r : unresolved_ufixed) return unresolved_ufixed;
function "rem" (l : unresolved_ufixed; r : real) return unresolved_ufixed;
function "rem" (l : real; r : unresolved_ufixed) return unresolved_ufixed;
function "rem" (l : unresolved_ufixed; r : natural) return unresolved_ufixed;
function "rem" (l : natural; r : unresolved_ufixed) return unresolved_ufixed;
function "rem" (l, r : unresolved_sfixed) return unresolved_sfixed;
function "rem" (l : unresolved_sfixed; r : real) return unresolved_sfixed;
function "rem" (l : real; r : unresolved_sfixed) return unresolved_sfixed;
function "rem" (l : unresolved_sfixed; r : integer) return unresolved_sfixed;
function "rem" (l : integer; r : unresolved_sfixed) return unresolved_sfixed;
function "mod" (l, r : unresolved_ufixed) return unresolved_ufixed;
function "mod" (l : unresolved_ufixed; r : real) return unresolved_ufixed;
function "mod" (l : real; r : unresolved_ufixed) return unresolved_ufixed;
function "mod" (l : unresolved_ufixed; r : natural) return unresolved_ufixed;
function "mod" (l : natural; r : unresolved_ufixed) return unresolved_ufixed;
function "mod" (l, r : unresolved_sfixed) return unresolved_sfixed;
function "mod" (l : unresolved_sfixed; r : real) return unresolved_sfixed;
function "mod" (l : real; r : unresolved_sfixed) return unresolved_sfixed;
function "mod" (l : unresolved_sfixed; r : integer) return unresolved_sfixed;
function "mod" (l : integer; r : unresolved_sfixed) return unresolved_sfixed;
end fixed_generic_pkg;

package body fixed_generic_pkg is
function divide (l, r : unresolved_ufixed;
round_style : fixed_round_style_type := fixed_round_style;
guard_bits : natural := fixed_guard_bits)
return unresolved_ufixed;
function divide (l, r : unresolved_sfixed;
round_style : fixed_round_style_type := fixed_round_style;
guard_bits : natural := fixed_guard_bits)
return unresolved_sfixed;
function reciprocal (arg : unresolved_ufixed;
round_style : fixed_round_style_type := fixed_round_style;
guard_bits : natural := fixed_guard_bits)
return unresolved_ufixed;
function reciprocal (arg : unresolved_sfixed;
round_style : fixed_round_style_type := fixed_round_style;
guard_bits : natural := fixed_guard_bits)
return unresolved_sfixed;
function remainder (l, r : unresolved_ufixed;
round_style : fixed_round_style_type := fixed_round_style;
guard_bits : natural := fixed_guard_bits)
return unresolved_ufixed;
function remainder (l, r : unresolved_sfixed;
round_style : fixed_round_style_type := fixed_round_style;
guard_bits : natural := fixed_guard_bits)
return unresolved_sfixed;
function modulo (l, r : unresolved_ufixed;
round_style : fixed_round_style_type := fixed_round_style;
guard_bits : natural := fixed_guard_bits)
return unresolved_ufixed;
function modulo (l, r : unresolved_sfixed;
overflow_style : fixed_overflow_style_type := fixed_overflow_style;
round_style : fixed_round_style_type := fixed_round_style;
guard_bits : natural := fixed_guard_bits)
return unresolved_sfixed;
procedure add_carry (l, r : in unresolved_ufixed; c_in : in std_ulogic;
result : out unresolved_ufixed; c_out : out std_ulogic);
procedure add_carry (l, r : in unresolved_sfixed; c_in : in std_ulogic;
result : out unresolved_sfixed; c_out : out std_ulogic);
function scalb (y : unresolved_ufixed; N : integer) return unresolved_ufixed;
function scalb (y : unresolved_ufixed; N : unresolved_signed) return unresolved_ufixed;
function scalb (y : unresolved_sfixed; N : integer) return unresolved_sfixed;
function scalb (y : unresolved_sfixed; N : unresolved_signed) return unresolved_sfixed;
function Is_Negative (arg : unresolved_sfixed) return boolean;
function "=" (l, r : unresolved_ufixed) return boolean;
function "=" (l : unresolved_ufixed; r : real) return boolean;
function "=" (l : real; r : unresolved_ufixed) return boolean;
function "=" (l : unresolved_ufixed; r : natural) return boolean;
function "=" (l : natural; r : unresolved_ufixed) return boolean;
function "=" (l, r : unresolved_sfixed) return boolean;
function "=" (l : unresolved_sfixed; r : real) return boolean;
function "=" (l : real; r : unresolved_sfixed) return boolean;
function "=" (l : unresolved_sfixed; r : natural) return boolean;
function "=" (l : natural; r : unresolved_sfixed) return boolean;
function "/=" (l, r : unresolved_ufixed) return boolean;
function "/=" (l : unresolved_ufixed; r : real) return boolean;
function "/=" (l : real; r : unresolved_ufixed) return boolean;
function "/=" (l : unresolved_ufixed; r : natural) return boolean;
function "/=" (l : natural; r : unresolved_ufixed) return boolean;
function "/=" (l, r : unresolved_sfixed) return boolean;
function "/=" (l : unresolved_sfixed; r : real) return boolean;
function "/=" (l : real; r : unresolved_sfixed) return boolean;
function "/=" (l : unresolved_sfixed; r : natural) return boolean;
function "/=" (l : natural; r : unresolved_sfixed) return boolean;
function "<" (l, r : unresolved_ufixed) return boolean;
function "<" (l : unresolved_ufixed; r : real) return boolean;
function "<" (l : real; r : unresolved_ufixed) return boolean;
function "<" (l : unresolved_ufixed; r : natural) return boolean;
function "<" (l : natural; r : unresolved_ufixed) return boolean;
function "<" (l, r : unresolved_sfixed) return boolean;
function "<" (l : unresolved_sfixed; r : real) return boolean;
function "<" (l : real; r : unresolved_sfixed) return boolean;
function "<" (l : unresolved_sfixed; r : integer) return boolean;
function "<" (l : integer; r : unresolved_sfixed) return boolean;
function "<=" (l, r : unresolved_ufixed) return boolean;
function "<=" (l : unresolved_ufixed; r : real) return boolean;
function "<=" (l : real; r : unresolved_ufixed) return boolean;
function "<=" (l : unresolved_ufixed; r : natural) return boolean;
function "<=" (l : natural; r : unresolved_ufixed) return boolean;
function "<=" (l, r : unresolved_sfixed) return boolean;
function "<=" (l : unresolved_sfixed; r : real) return boolean;
function "<=" (l : real; r : unresolved_sfixed) return boolean;
function "<=" (l : unresolved_sfixed; r : integer) return boolean;
function "<=" (l : integer; r : unresolved_sfixed) return boolean;
function ">" (l, r : unresolved_ufixed) return boolean;
function ">" (l : unresolved_ufixed; r : real) return boolean;
function ">" (l : real; r : unresolved_ufixed) return boolean;
function ">" (l : unresolved_ufixed; r : natural) return boolean;
function ">" (l : natural; r : unresolved_ufixed) return boolean;
function ">" (l, r : unresolved_sfixed) return boolean;
function ">" (l : unresolved_sfixed; r : real) return boolean;
function ">" (l : real; r : unresolved_sfixed) return boolean;
function ">" (l : unresolved_sfixed; r : integer) return boolean;
function ">" (l : integer; r : unresolved_sfixed) return boolean;
function ">=" (l, r : unresolved_ufixed) return boolean;
function ">=" (l : unresolved_ufixed; r : real) return boolean;
function ">=" (l : real; r : unresolved_ufixed) return boolean;
function ">=" (l : unresolved_ufixed; r : natural) return boolean;
function ">=" (l : natural; r : unresolved_ufixed) return boolean;
function ">=" (l, r : unresolved_sfixed) return boolean;
function ">=" (l : unresolved_sfixed; r : real) return boolean;
function ">=" (l : real; r : unresolved_sfixed) return boolean;
function ">=" (l : unresolved_sfixed; r : integer) return boolean;
function ">=" (l : integer; r : unresolved_sfixed) return boolean;
function minimum (l, r : unresolved_ufixed) return unresolved_ufixed;
function minimum (l : unresolved_ufixed; r : real) return unresolved_ufixed;
function minimum (l : real; r : unresolved_ufixed) return unresolved_ufixed;
function minimum (l : unresolved_ufixed; r : natural) return unresolved_ufixed;
function minimum (l : natural; r : unresolved_ufixed) return unresolved_ufixed;
function minimum (l, r : unresolved_sfixed) return unresolved_sfixed;
function minimum (l : unresolved_sfixed; r : real) return unresolved_sfixed;
function minimum (l : real; r : unresolved_sfixed) return unresolved_sfixed;
function minimum (l : unresolved_sfixed; r : integer) return unresolved_sfixed;
function minimum (l : integer; r : unresolved_sfixed) return unresolved_sfixed;
function maximum (l, r : unresolved_ufixed) return unresolved_ufixed;
function maximum (l : unresolved_ufixed; r : real) return unresolved_ufixed;
function maximum (l : real; r : unresolved_ufixed) return unresolved_ufixed;
function maximum (l : unresolved_ufixed; r : natural) return unresolved_ufixed;
function maximum (l : natural; r : unresolved_ufixed) return unresolved_ufixed;
function maximum (l, r : unresolved_sfixed) return unresolved_sfixed;
function maximum (l : unresolved_sfixed; r : real) return unresolved_sfixed;
function maximum (l : real; r : unresolved_sfixed) return unresolved_sfixed;
function maximum (l : unresolved_sfixed; r : integer) return unresolved_sfixed;
function maximum (l : integer; r : unresolved_sfixed) return unresolved_sfixed;
function "?=" (l, r : unresolved_ufixed) return boolean;
function "?=" (l : unresolved_ufixed; r : real) return boolean;
function "?=" (l : real; r : unresolved_ufixed) return boolean;
function "?=" (l : unresolved_ufixed; r : natural) return boolean;
function "?=" (l : natural; r : unresolved_ufixed) return boolean;
function "?=" (l, r : unresolved_sfixed) return boolean;
function "?=" (l : unresolved_sfixed; r : real) return boolean;
function "?=" (l : real; r : unresolved_sfixed) return boolean;
function "?=" (l : unresolved_sfixed; r : natural) return boolean;
function "?=" (l : natural; r : unresolved_sfixed) return boolean;
function "?/=" (l, r : unresolved_ufixed) return boolean;
function "?/=" (l : unresolved_ufixed; r : real) return boolean;
function "?/=" (l : real; r : unresolved_ufixed) return boolean;
function "?/=" (l : unresolved_ufixed; r : natural) return boolean;
function "?/=" (l : natural; r : unresolved_ufixed) return boolean;
function "?/=" (l, r : unresolved_sfixed) return boolean;
function "?/=" (l : unresolved_sfixed; r : real) return boolean;
function "?/=" (l : real; r : unresolved_sfixed) return boolean;
function "?/=" (l : unresolved_sfixed; r : natural) return boolean;
function "?/=" (l : natural; r : unresolved_sfixed) return boolean;
function "?<" (l, r : unresolved_ufixed) return boolean;
function "?<" (l : unresolved_ufixed; r : real) return boolean;
function "?<" (l : real; r : unresolved_ufixed) return boolean;
function "?<" (l : unresolved_ufixed; r : natural) return boolean;
function "?<" (l : natural; r : unresolved_ufixed) return boolean;
function "?<" (l, r : unresolved_sfixed) return boolean;
function "?<" (l : unresolved_sfixed; r : real) return boolean;
function "?<" (l : real; r : unresolved_sfixed) return boolean;
function "?<" (l : unresolved_sfixed; r : integer) return boolean;
function "?<" (l : integer; r : unresolved_sfixed) return boolean;
function "?<=" (l, r : unresolved_ufixed) return boolean;
function "?<=" (l : unresolved_ufixed; r : real) return boolean;
function "?<=" (l : real; r : unresolved_ufixed) return boolean;
function "?<=" (l : unresolved_ufixed; r : natural) return boolean;
function "?<=" (l : natural; r : unresolved_ufixed) return boolean;
function "?<=" (l, r : unresolved_sfixed) return boolean;
function "?<=" (l : unresolved_sfixed; r : real) return boolean;
function "?<=" (l : real; r : unresolved_sfixed) return boolean;
function "?<=" (l : unresolved_sfixed; r : integer) return boolean;
function "?<=" (l : integer; r : unresolved_sfixed) return boolean;
function "?>" (l, r : unresolved_ufixed) return boolean;
function "?>" (l : unresolved_ufixed; r : real) return boolean;
function "?>" (l : real; r : unresolved_ufixed) return boolean;
function "?>" (l : unresolved_ufixed; r : natural) return boolean;
function "?>" (l : natural; r : unresolved_ufixed) return boolean;
function "?>" (l, r : unresolved_sfixed) return boolean;
function "?>" (l : unresolved_sfixed; r : real) return boolean;
function "?>" (l : real; r : unresolved_sfixed) return boolean;
function "?>" (l : unresolved_sfixed; r : integer) return boolean;
function "?>" (l : integer; r : unresolved_sfixed) return boolean;
function "?>=" (l, r : unresolved_ufixed) return boolean;
function "?>=" (l : unresolved_ufixed; r : real) return boolean;
function "?>=" (l : real; r : unresolved_ufixed) return boolean;
function "?>=" (l : unresolved_ufixed; r : natural) return boolean;
function "?>=" (l : natural; r : unresolved_ufixed) return boolean;
function "?>=" (l, r : unresolved_sfixed) return boolean;
function "?>=" (l : unresolved_sfixed; r : real) return boolean;
function "?>=" (l : real; r : unresolved_sfixed) return boolean;
function "?>=" (l : unresolved_sfixed; r : integer) return boolean;
function "?>=" (l : integer; r : unresolved_sfixed) return boolean;
function std_match (l, r : unresolved_ufixed) return boolean;
function std_match (l, r : unresolved_sfixed) return boolean;
function "sll" (arg : unresolved_ufixed; count : integer) return unresolved_ufixed;
function "sll" (arg : unresolved_sfixed; count : integer) return unresolved_sfixed;
function "srl" (arg : unresolved_ufixed; count : integer) return unresolved_ufixed;
function "srl" (arg : unresolved_sfixed; count : integer) return unresolved_sfixed;
function "sla" (arg : unresolved_ufixed; count : integer) return unresolved_ufixed;
function "sla" (arg : unresolved_sfixed; count : integer) return unresolved_sfixed;
function "sra" (arg : unresolved_ufixed; count : integer) return unresolved_ufixed;
function "sra" (arg : unresolved_sfixed; count : integer) return unresolved_sfixed;
function "rol" (arg : unresolved_ufixed; count : integer) return unresolved_ufixed;
function "rol" (arg : unresolved_sfixed; count : integer) return unresolved_sfixed;
function "ror" (arg : unresolved_ufixed; count : integer) return unresolved_ufixed;
function "ror" (arg : unresolved_sfixed; count : integer) return unresolved_sfixed;
function shift_left (arg : unresolved_ufixed; count : natural) return
unresolved_ufixed;
function shift_right (arg : unresolved_ufixed; count : natural) return
unresolved_ufixed;
function shift_left (arg : unresolved_sfixed; count : natural) return
unresolved_sfixed;
function shift_right (arg : unresolved_sfixed; count : natural) return
unresolved_sfixed;
function "and" (l, r : unresolved_ufixed) return unresolved_ufixed;
function "and" (l, r : unresolved_sfixed) return unresolved_sfixed;
function "nand" (l, r : unresolved_ufixed) return unresolved_ufixed;
function "nand" (l, r : unresolved_sfixed) return unresolved_sfixed;
function "or" (l, r : unresolved_ufixed) return unresolved_ufixed;
function "or" (l, r : unresolved_sfixed) return unresolved_sfixed;
function "nor" (l, r : unresolved_ufixed) return unresolved_ufixed;
function "nor" (l, r : unresolved_sfixed) return unresolved_sfixed;
function "xor" (l, r : unresolved_ufixed) return unresolved_ufixed;
function "xor" (l, r : unresolved_sfixed) return unresolved_sfixed;
function "xnor" (l, r : unresolved_ufixed) return unresolved_ufixed;
function "xnor" (l, r : unresolved_sfixed) return unresolved_sfixed;
function "not" (l : unresolved_ufixed) return unresolved_ufixed;
function "not" (l : unresolved_sfixed) return unresolved_sfixed;
function "and" (l : std_ulogic; r : unresolved_ufixed) return unresolved_ufixed;
function "and" (l : unresolved_ufixed; r : std_ulogic) return unresolved_ufixed;
function "and" (l : std_ulogic; r : unresolved_sfixed) return unresolved_sfixed;
function "and" (l : unresolved_sfixed; r : std_ulogic) return unresolved_sfixed;
function "nand" (l : std_ulogic; r : unresolved_ufixed) return unresolved_ufixed;
function "nand" (l : unresolved_ufixed; r : std_ulogic) return unresolved_ufixed;
function "nand" (l : std_ulogic; r : unresolved_sfixed) return unresolved_sfixed;
function "nand" (l : unresolved_sfixed; r : std_ulogic) return unresolved_sfixed;
function "or" (l : std_ulogic; r : unresolved_ufixed) return unresolved_ufixed;
function "or" (l : unresolved_ufixed; r : std_ulogic) return unresolved_ufixed;
function "or" (l : std_ulogic; r : unresolved_sfixed) return unresolved_sfixed;
function "or" (l : unresolved_sfixed; r : std_ulogic) return unresolved_sfixed;
function "nor" (l : std_ulogic; r : unresolved_ufixed) return unresolved_ufixed;
function "nor" (l : unresolved_ufixed; r : std_ulogic) return unresolved_ufixed;
function "nor" (l : std_ulogic; r : unresolved_sfixed) return unresolved_sfixed;
function "nor" (l : unresolved_sfixed; r : std_ulogic) return unresolved_sfixed;
function "xor" (l : std_ulogic; r : unresolved_ufixed) return unresolved_ufixed;
function "xor" (l : unresolved_ufixed; r : std_ulogic) return unresolved_ufixed;
function "xor" (l : std_ulogic; r : unresolved_sfixed) return unresolved_sfixed;
function "xor" (l : unresolved_sfixed; r : std_ulogic) return unresolved_sfixed;
function "xnor" (l : std_ulogic; r : unresolved_ufixed) return unresolved_ufixed;
function "xnor" (l : unresolved_ufixed; r : std_ulogic) return unresolved_ufixed;
function "xnor" (l : std_ulogic; r : unresolved_sfixed) return unresolved_sfixed;
function "xnor" (l : unresolved_sfixed; r : std_ulogic) return unresolved_sfixed;
function "and" (l : unresolved_ufixed) return std_ulogic;
function "and" (l : unresolved_sfixed) return std_ulogic;
function "nand" (l : unresolved_ufixed) return std_ulogic;
function "nand" (l : unresolved_sfixed) return std_ulogic;
function "or" (l : unresolved_ufixed) return std_ulogic;
function "or" (l : unresolved_sfixed) return std_ulogic;
function "nor" (l : unresolved_ufixed) return std_ulogic;
function "nor" (l : unresolved_sfixed) return std_ulogic;
function "xor" (l : unresolved_ufixed) return std_ulogic;
function "xor" (l : unresolved_sfixed) return std_ulogic;
function "xnor" (l : unresolved_ufixed) return std_ulogic;
function "xnor" (l : unresolved_sfixed) return std_ulogic;
function find_leftmost (arg : unresolved_ufixed; y : std_ulogic) return integer;
function find_leftmost (arg : unresolved_sfixed; y : std_ulogic) return integer;
function find_rightmost (arg : unresolved_ufixed; y : std_ulogic) return integer;
function find_rightmost (arg : unresolved_sfixed; y : std_ulogic) return integer;
function resize (arg : unresolved_ufixed;
left_index : integer;
right_index : integer;
overflow_style : fixed_overflow_style_type := fixed_overflow_style;
round_style : fixed_round_style_type := fixed_round_style)
return unresolved_ufixed;
function resize (arg : unresolved_ufixed;
size_res : unresolved_ufixed;
overflow_style : fixed_overflow_style_type := fixed_overflow_style;
round_style : fixed_round_style_type := fixed_round_style)
return unresolved_ufixed;
function resize (arg : unresolved_sfixed;
left_index : integer;
right_index : integer;
overflow_style : fixed_overflow_style_type := fixed_overflow_style;
round_style : fixed_round_style_type := fixed_round_style)
return unresolved_sfixed;
function resize (arg : unresolved_sfixed;
size_res : unresolved_sfixed;
overflow_style : fixed_overflow_style_type := fixed_overflow_style;
round_style : fixed_round_style_type := fixed_round_style)
return unresolved_sfixed;
function to_ufixed (arg : natural;
left_index : integer;
right_index : integer := 0;
overflow_style : fixed_overflow_style_type := fixed_overflow_style;
round_style : fixed_round_style_type := fixed_round_style)
return unresolved_ufixed;
function to_ufixed (arg : natural;
size_res : unresolved_ufixed;
overflow_style : fixed_overflow_style_type := fixed_overflow_style;
round_style : fixed_round_style_type := fixed_round_style)
return unresolved_ufixed;
function to_ufixed (arg : real;
left_index : integer;
right_index : integer;
overflow_style : fixed_overflow_style_type := fixed_overflow_style;
round_style : fixed_round_style_type := fixed_round_style;
guard_bits : natural := fixed_guard_bits)
return unresolved_ufixed;
function to_ufixed (arg : real;
size_res : unresolved_ufixed;
overflow_style : fixed_overflow_style_type := fixed_overflow_style;
round_style : fixed_round_style_type := fixed_round_style;
guard_bits : natural := fixed_guard_bits)
return unresolved_ufixed;
function to_ufixed (arg : unresolved_unsigned;
left_index : integer;
right_index : integer := 0;
overflow_style : fixed_overflow_style_type := fixed_overflow_style;
round_style : fixed_round_style_type := fixed_round_style)
return unresolved_ufixed;
function to_ufixed (arg : unresolved_unsigned;
size_res : unresolved_ufixed;
overflow_style : fixed_overflow_style_type := fixed_overflow_style;
round_style : fixed_round_style_type := fixed_round_style)
return unresolved_ufixed;
function to_ufixed (arg : unresolved_unsigned) return unresolved_ufixed;
function to_unsigned (arg : unresolved_ufixed;
size : natural;
overflow_style : fixed_overflow_style_type := fixed_overflow_style;
round_style : fixed_round_style_type := fixed_round_style)
return unresolved_unsigned;
function to_unsigned (arg : unresolved_ufixed;
size_res : unresolved_unsigned;
overflow_style : fixed_overflow_style_type := fixed_overflow_style;
round_style : fixed_round_style_type := fixed_round_style)
return unresolved_unsigned;
function to_real (arg : unresolved_ufixed) return real;
function to_integer (arg : unresolved_ufixed;
overflow_style : fixed_overflow_style_type := fixed_overflow_style;
round_style : fixed_round_style_type := fixed_round_style)
return natural;
function to_sfixed (arg : integer;
left_index : integer;
right_index : integer := 0;
overflow_style : fixed_overflow_style_type := fixed_overflow_style;
round_style : fixed_round_style_type := fixed_round_style)
return unresolved_sfixed;
function to_sfixed (arg : integer;
size_res : unresolved_sfixed;
overflow_style : fixed_overflow_style_type := fixed_overflow_style;
round_style : fixed_round_style_type := fixed_round_style)
return unresolved_sfixed;
function to_sfixed (arg : real;
left_index : integer;
right_index : integer;
overflow_style : fixed_overflow_style_type := fixed_overflow_style;
round_style : fixed_round_style_type := fixed_round_style;
guard_bits : natural := fixed_guard_bits)
return unresolved_sfixed;
function to_sfixed (arg : real;
size_res : unresolved_sfixed;
overflow_style : fixed_overflow_style_type := fixed_overflow_style;
round_style : fixed_round_style_type := fixed_round_style;
guard_bits : natural := fixed_guard_bits)
return unresolved_sfixed;
function to_sfixed (arg : unresolved_signed;
left_index : integer;
right_index : integer := 0;
overflow_style : fixed_overflow_style_type := fixed_overflow_style;
round_style : fixed_round_style_type := fixed_round_style)
return unresolved_sfixed;
function to_sfixed (arg : unresolved_signed;
size_res : unresolved_sfixed;
overflow_style : fixed_overflow_style_type := fixed_overflow_style;
round_style : fixed_round_style_type := fixed_round_style)
return unresolved_sfixed;
function to_sfixed (arg : unresolved_signed) return unresolved_sfixed;
function to_sfixed (arg : unresolved_ufixed) return unresolved_sfixed;
function to_signed (arg : unresolved_sfixed;
size : natural;
overflow_style : fixed_overflow_style_type := fixed_overflow_style;
round_style : fixed_round_style_type := fixed_round_style)
return unresolved_signed;
function to_signed (arg : unresolved_sfixed;
size_res : unresolved_signed;
overflow_style : fixed_overflow_style_type := fixed_overflow_style;
round_style : fixed_round_style_type := fixed_round_style)
return unresolved_signed;
function to_real (arg : unresolved_sfixed) return real;
function to_integer (arg : unresolved_sfixed;
overflow_style : fixed_overflow_style_type := fixed_overflow_style;
round_style : fixed_round_style_type := fixed_round_style)
return integer;
function ufixed_high (left_index, right_index : integer;
operation : character := 'X';
left_index2, right_index2 : integer := 0) return integer;
function ufixed_low (left_index, right_index : integer;
operation : character := 'X';
left_index2, right_index2 : integer := 0) return integer;
function sfixed_high (left_index, right_index : integer;
operation : character := 'X';
left_index2, right_index2 : integer := 0) return integer;
function sfixed_low (left_index, right_index : integer;
operation : character := 'X';
left_index2, right_index2 : integer := 0) return integer;
function ufixed_high (size_res : unresolved_ufixed;
operation : character := 'X';
size_res2 : unresolved_ufixed) return integer;
function ufixed_low (size_res : unresolved_ufixed;
operation : character := 'X';
size_res2 : unresolved_ufixed) return integer;
function sfixed_high (size_res : unresolved_sfixed;
operation : character := 'X';
size_res2 : unresolved_sfixed) return integer;
function sfixed_low (size_res : unresolved_sfixed;
operation : character := 'X';
size_res2 : unresolved_sfixed) return integer;
function saturate (left_index, right_index : integer) return unresolved_ufixed;
function saturate (left_index, right_index : integer) return unresolved_sfixed;
function saturate (size_res : unresolved_ufixed) return unresolved_ufixed;
function saturate (size_res : unresolved_sfixed) return unresolved_sfixed;
function To_01 (s : unresolved_ufixed;
xmap : std_ulogic := '0') return unresolved_ufixed;
function To_01 (s : unresolved_sfixed;
xmap : std_ulogic := '0') return unresolved_sfixed;
function Is_X (arg : unresolved_ufixed) return boolean;
function Is_X (arg : unresolved_sfixed) return boolean;
function To_X01 (arg : unresolved_ufixed) return unresolved_ufixed;
function To_X01 (arg : unresolved_sfixed) return unresolved_sfixed;
function To_X01Z (arg : unresolved_ufixed) return unresolved_ufixed;
function To_X01Z (arg : unresolved_sfixed) return unresolved_sfixed;
function To_UX01 (arg : unresolved_ufixed) return unresolved_ufixed;
function To_UX01 (arg : unresolved_sfixed) return unresolved_sfixed;
function To_SLV (arg : unresolved_ufixed) return std_logic_vector;
alias To_StdLogicVector is To_SLV [unresolved_ufixed return std_logic_vector];
alias To_Std_Logic_Vector is To_SLV [unresolved_ufixed return std_logic_vector];
function To_SLV (arg : unresolved_sfixed) return std_logic_vector;
alias To_StdLogicVector is To_SLV [unresolved_sfixed return std_logic_vector];
alias To_Std_Logic_Vector is To_SLV [unresolved_sfixed return std_logic_vector];
function To_SULV (arg : unresolved_ufixed) return std_ulogic_vector;
alias To_StdULogicVector is To_SULV [unresolved_ufixed return std_ulogic_vector];
alias To_Std_ULogic_Vector is To_SULV [unresolved_ufixed return std_ulogic_vector];
function To_SULV (arg : unresolved_sfixed) return std_ulogic_vector;
alias To_StdULogicVector is To_SULV [unresolved_sfixed return std_ulogic_vector];
alias To_Std_ULogic_Vector is To_SULV [unresolved_sfixed return std_ulogic_vector];
function to_ufixed (arg : std_ulogic_vector;
left_index, right_index : integer) return unresolved_ufixed;
function to_ufixed (arg : std_ulogic_vector;
size_res : unresolved_ufixed) return unresolved_ufixed;
function to_sfixed (arg : std_ulogic_vector;
left_index, right_index : integer) return unresolved_sfixed;
function to_sfixed (arg : std_ulogic_vector;
size_res : unresolved_sfixed) return unresolved_sfixed;
function to_UFix (arg : std_ulogic_vector;
width, fraction : natural) return unresolved_ufixed;
function to_SFix (arg : std_ulogic_vector;
width, fraction : natural) return unresolved_sfixed;
function UFix_high (width, fraction : natural;
operation : character := 'X';
width2, fraction2 : natural := 0) return integer;
function UFix_low (width, fraction : natural;
operation : character := 'X';
width2, fraction2 : natural := 0) return integer;
function SFix_high (width, fraction : natural;
operation : character := 'X';
width2, fraction2 : natural := 0) return integer;
function SFix_low (width, fraction : natural;
operation : character := 'X';
width2, fraction2 : natural := 0) return integer;
function to_string (value : unresolved_ufixed) return string;
function to_string (value : unresolved_sfixed) return string;
alias to_bstring is to_string [unresolved_ufixed return string];
alias to_bstring is to_string [unresolved_sfixed return string];
alias to_binary_string is to_string [unresolved_ufixed return string];
alias to_binary_string is to_string [unresolved_sfixed return string];
function to_ostring (value : unresolved_ufixed) return string;
function to_ostring (value : unresolved_sfixed) return string;
alias to_octal_string is to_ostring [unresolved_ufixed return string];
alias to_octal_string is to_ostring [unresolved_sfixed return string];
function to_hstring (value : unresolved_ufixed) return string;
function to_hstring (value : unresolved_sfixed) return string;
alias to_hex_string is to_hstring [unresolved_ufixed return string];
alias to_hex_string is to_hstring [unresolved_sfixed return string];
function from_string (bstring : string;
left_index, right_index : integer) return unresolved_ufixed;
function from_string (bstring : string;
left_index, right_index : integer) return unresolved_sfixed;
function from_string (bstring : string;
size_res : unresolved_ufixed) return unresolved_ufixed;
function from_string (bstring : string;
size_res : unresolved_sfixed) return unresolved_sfixed;
function from_string (bstring : string) return unresolved_ufixed;
function from_string (bstring : string) return unresolved_sfixed;
alias from_bstring is from_string [string, integer, integer return unresolved_ufixed];
alias from_bstring is from_string [string, integer, integer return unresolved_sfixed];
alias from_bstring is from_string [string, unresolved_ufixed
return unresolved_ufixed];
alias from_bstring is from_string [string, unresolved_sfixed
return unresolved_sfixed];
alias from_bstring is from_string [string return unresolved_ufixed];
alias from_bstring is from_string [string return unresolved_sfixed];
alias from_binary_string is from_string [string, integer, integer
return unresolved_ufixed];
alias from_binary_string is from_string [string, integer, integer
return unresolved_sfixed];
alias from_binary_string is from_string [string, unresolved_ufixed
return unresolved_ufixed];
alias from_binary_string is from_string [string, unresolved_sfixed
return unresolved_sfixed];
alias from_binary_string is from_string [string return unresolved_ufixed];
alias from_binary_string is from_string [string return unresolved_sfixed];
function from_ostring (ostring : string;
left_index, right_index : integer) return unresolved_ufixed;
function from_ostring (ostring : string;
left_index, right_index : integer) return unresolved_sfixed;
function from_ostring (ostring : string;
size_res : unresolved_ufixed) return unresolved_ufixed;
function from_ostring (ostring : string;
size_res : unresolved_sfixed) return unresolved_sfixed;
function from_ostring (ostring : string) return unresolved_ufixed;
function from_ostring ( ostring : string) return unresolved_sfixed;
alias from_octal_string is from_ostring [string, integer, integer
return unresolved_ufixed];
alias from_octal_string is from_ostring [string, integer, integer
return unresolved_sfixed];
alias from_octal_string is from_ostring [string, unresolved_ufixed
return unresolved_ufixed];
alias from_octal_string is from_ostring [string, unresolved_sfixed
return unresolved_sfixed];
alias from_octal_string is from_ostring [string return unresolved_ufixed];
alias from_octal_string is from_ostring [string return unresolved_sfixed];
function from_hstring (hstring : string;
left_index, right_index : integer) return unresolved_ufixed;
function from_hstring (hstring : string;
left_index, right_index : integer) return unresolved_sfixed;
function from_hstring (hstring : string;
size_res : unresolved_ufixed) return unresolved_ufixed;
function from_hstring (hstring : string;
size_res : unresolved_sfixed) return unresolved_sfixed;
function from_hstring (hstring : string) return unresolved_ufixed;
function from_hstring (hstring : string) return unresolved_sfixed;
alias from_hex_string is from_hstring [string, integer, integer
return unresolved_ufixed];
alias from_hex_string is from_hstring [string, integer, integer
return unresolved_sfixed];
alias from_hex_string is from_hstring [string, unresolved_ufixed
return unresolved_ufixed];
alias from_hex_string is from_hstring [string, unresolved_sfixed
return unresolved_sfixed];
alias from_hex_string is from_hstring [string return unresolved_ufixed];
alias from_hex_string is from_hstring [string return unresolved_sfixed];
procedure read(l : inout line; value : out unresolved_ufixed; good : out boolean);
procedure read(l : inout line; value : out unresolved_ufixed);
procedure read(l : inout line; value : out unresolved_sfixed; good : out boolean);
procedure read(l : inout line; value : out unresolved_sfixed);
alias bread is read [line, unresolved_ufixed, boolean];
alias bread is read [line, unresolved_ufixed];
alias bread is read [line, unresolved_sfixed, boolean];
alias bread is read [line, unresolved_sfixed];
alias binary_read is read [line, unresolved_ufixed, boolean];
alias binary_read is read [line, unresolved_ufixed];
alias binary_read is read [line, unresolved_sfixed, boolean];
alias binary_read is read [line, unresolved_sfixed];
procedure oread(l : inout line; value : out unresolved_ufixed; good : out boolean);
procedure oread(l : inout line; value : out unresolved_ufixed);
procedure oread(l : inout line; value : out unresolved_sfixed; good : out boolean);
procedure oread(l : inout line; value : out unresolved_sfixed);
alias octal_read is oread [line, unresolved_ufixed, boolean];
alias octal_read is oread [line, unresolved_ufixed];
alias octal_read is oread [line, unresolved_sfixed, boolean];
alias octal_read is oread [line, unresolved_sfixed];
procedure hread(l : inout line; value : out unresolved_ufixed; good : out boolean);
procedure hread(l : inout line; value : out unresolved_ufixed);
procedure hread(l : inout line; value : out unresolved_sfixed; good : out boolean);
procedure hread(l : inout line; value : out unresolved_sfixed);
alias hex_read is hread [line, unresolved_ufixed, boolean];
alias hex_read is hread [line, unresolved_ufixed];
alias hex_read is hread [line, unresolved_sfixed, boolean];
alias hex_read is hread [line, unresolved_sfixed];
procedure write (l : inout line; value : in unresolved_ufixed;
justified : in side := right; field : in width := 0);
procedure write (l : inout line; value : in unresolved_sfixed;
justified : in side := right; field : in width := 0);
alias bwrite is write [line, unresolved_ufixed, side, width];
alias bwrite is write [line, unresolved_sfixed, side, width];
alias binary_write is write [line, unresolved_ufixed, side, width];
alias binary_write is write [line, unresolved_sfixed, side, width];
procedure owrite (l : inout line; value : in unresolved_ufixed;
justified : in side := right; field : in width := 0);
procedure owrite (l : inout line; value : in unresolved_sfixed;
justified : in side := right; field : in width := 0);
alias octal_write is owrite [line, unresolved_ufixed, side, width];
alias octal_write is owrite [line, unresolved_sfixed, side, width];
procedure hwrite (l : inout line; value : in unresolved_ufixed;
justified : in side := right; field : in width := 0);
procedure hwrite (l : inout line; value : in unresolved_sfixed;
justified : in side := right; field : in width := 0);
alias hex_write is hwrite [line, unresolved_ufixed, side, width];
alias hex_write is hwrite [line, unresolved_sfixed, side, width];
end package fixed_generic_pkg;

..................................................................................................

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;


package fixed_float_types is
type fixed_round_style_type is (fixed_round, fixed_truncate);
type fixed_overflow_style_type is (fixed_saturate, fixed_wrap);
type round_type is (round_nearest, round_inf, round_neginf, round_zero);
end package fixed_float_types;

 

[bigdogguru]

It appears that your compiler, simulator, etc. does not support that VHDL 2008 feature.