[Bug ada/14068] New: gnatmake fails with error box

[Bug ada/14068] New: gnatmake fails with error box

[broeg at gmx dot de]

gnatmake / gcc -c stops with error message below.

commandline input:
[broeg@tiscali rk]$ gnatmake constants.ads
gcc -c constants.ads
+===========================GNAT BUG DETECTED==============================+
| 3.3.1 (Mandrake Linux 9.2 3.3.1-2mdk) (i586-mandrake-linux-gnu) GCC error:|
| in convert_move, at expr.c:568                                           |
| No source file position information available                            |
| Please submit a bug report; see http://gcc.gnu.org/bugs.html.            |
| Include the entire contents of this bug box in the report.               |
| Include the exact gcc or gnatmake command that you entered.              |
| Also include sources listed below in gnatchop format                     |
| concatenated together with no headers between files.                     |
+==========================================================================+
 
Please include these source files with error report
 
constants.ads
number_types.ads
variable_float_operations.ads
var_flt_operations.ads
variable_float_elementary_functions.ads
variable_float_io.ads
float_conversions.ads
 
==========================
version:
 gcc -v
Reading specs from /usr/lib/gcc-lib/i586-mandrake-linux-gnu/3.3.1/specs
Configured with: ../configure --prefix=/usr --libdir=/usr/lib
--with-slibdir=/lib --mandir=/usr/share/man --infodir=/usr/share/info
--enable-shared --enable-threads=posix --disable-checking --enable-long-long
--enable-__cxa_atexit --enable-languages=c,c++,ada,f77,objc,java,pascal
--host=i586-mandrake-linux-gnu --with-system-zlib
Thread model: posix
gcc version 3.3.1 (Mandrake Linux 9.2 3.3.1-2mdk)

gnat is version 
GNATMAKE 3.3.1 (Mandrake Linux 9.2 3.3.1-2mdk) Copyright 1995-2002 Free Software
Foundation, Inc.

both files are part of the binary mandrake distribution 9.2

note: 3.2.1 produces the same bug.





##################################################################
source code :
(use gnatchop to split)
##################################################################

-- File Name acc_flotype.a   April 4th  1991

-- Converts the binary representation of x to VARIABLE_FLOAT and vice versa

With Variable_Float_Operations;
Use Variable_Float_Operations;

Package Float_Conversions is

Function Extend(x : FLOAT; rel_err : FLOAT := 0.0)
         return VARIABLE_FLOAT;

Function Shorten(x : VARIABLE_FLOAT) return FLOAT;

Conversion_Error        : Exception;

End Float_Conversions;
--| CVS: $Header: /astro/broeg/Repository_CVS/ada/runge_kutta/number_types.ads,v
3.0 2003/07/10 12:31:48 broeg Exp $

--------------------------------------------------------
--| number_types.ads - belongs to the COROT project.
--------------------------------------------------------

--------------------------------------------------------
--| purpose:
--| --------
--| package To Define The basic floating point number and provide all basic 
--| operations. 
--| The user can switch between machine numbers and variable_floats of 
--| Brian Doman by uncommenting the appropriate line of code.
--| It also provides the basic vector operations.

--| implementation:
--| ---------------
--| All functions refering to machine precision use type real_machine.
--| All arbitrary precision functions use variable_float;
--| the change is made by subtyping the appropriate type to the name real;

--| In general all functions are simply renamed here. Only some machine
--| precision functions are provided to give the same Functions as for 
--| the arbitrary precision package, even when they do nothing.


--| Author:
--| ------
--| Christopher Broeg, April 25th, 2003
--| large modification: March 20th, 2003
--|                     (make all operations visible)
--| Last Modified: see CVS header above.
--------------------------------------------------------
with Ada.Numerics.Generic_Elementary_Functions;  --in case digits 18 is used;
with Ada.Text_IO;
with Interfaces;

--Doman's arbitrary precision package:
with Variable_Float_Operations,
  Variable_Float_Elementary_Functions,
  Variable_Float_Io,Float_Conversions;

package Number_Types is 
   
   -- in case machine precision is used:
   type Real_Machine is digits 18;              --  to be changed later, i.e.
digits 18
   package Numerics_Real is new Ada.Numerics.Generic_Elementary_Functions
(Real_Machine);
   -- supply exponentiation operation and make it visible:
   function "**" (Left,Right : Real_Machine) return Real_Machine renames
Numerics_Real."**";
   function Log (Left,Right : Real_Machine) return Real_Machine renames
Numerics_Real.Log;
   function Cos (X : Real_Machine) return Real_Machine renames Numerics_Real.Cos;
   function Exp (X : Real_Machine) return Real_Machine renames Numerics_Real.Exp;
   
   package Float_Io is new Ada.Text_IO.Float_Io(Real_Machine);
   
   procedure Put (Item :    Real_machine;
                  Fore : in Ada.Text_IO.Field :=Float_Io.Default_fore;
                  Aft  : in Ada.Text_IO.Field :=Float_Io.Default_aft;
                  Exp  : in Ada.Text_IO.Field :=Float_Io.Default_exp);
   procedure get (Item  :    out Real_machine;
                  width : in     Ada.Text_IO.Field :=0)
     renames Float_Io.Get;

   
   -- Integer type for fortran interface:  fortran_integer DOES NOT WORK!!!!!
   subtype Integer_Fortran_Interface is Interfaces.Integer_8;
   
   use Variable_Float_Operations;
   
   --------------------------------------------------------------
   -- choose between machine precision and arbitrary precision:--
   --------------------------------------------------------------
   -- machine precision:
   ------------------
 subtype Real is Real_Machine;
   -- arbitrary precision:
      --------------------
--subtype Real is VARIABLE_FLOAT;   -- change default_significance when necessary!!!
                                     -- in variable_float_operations.ads
   --------------------------------------------------------------

   

   
     
   type Int is new Integer;             --  for now the basic integer type
   
   subtype Count_Type is Integer range 0 .. Integer'Last;      --  cannot be
negative
   
   type Real_Array is array (Positive range <>) of Real;

   function Number_From_String (Str : in String ) return Real_Machine;
   function Number_From_String (Str : in String ) return Variable_Float;
   function Ten_To_The_Minus_X (Exponent : in Positive) return Real;
   
   
-- Make visible all operations in Variable_Float_Operations:   
-- Elementary Arithmetical Operations for VARIABLE_FLOAT;
   
   
function "+" (X,Y : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Operations."+";
function "+" (X : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Operations."+";
function "-" (X : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Operations."-";
function "-" (X,Y : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Operations."-";
function "*" (X,Y : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Operations."*";
function "/" (X,Y : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Operations."/";

function "+" (N : INTEGER; X : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Operations."+";
function "+" (X : VARIABLE_FLOAT; N : INTEGER) return VARIABLE_FLOAT renames
Variable_Float_Operations."+";
function "-" (N : INTEGER; X : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Operations."-";
function "-" (X : VARIABLE_FLOAT; N : INTEGER) return VARIABLE_FLOAT renames
Variable_Float_Operations."-";
function "*" (N : INTEGER; X : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Operations."*";
function "*" (X : VARIABLE_FLOAT; N : INTEGER) return VARIABLE_FLOAT renames
Variable_Float_Operations."*";
function "/" (X : VARIABLE_FLOAT; N : INTEGER) return VARIABLE_FLOAT renames
Variable_Float_Operations."/";
function "/" (N : INTEGER; X : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Operations."/";
function "**" (X : VARIABLE_FLOAT; N : INTEGER) return VARIABLE_FLOAT renames
Variable_Float_Operations."**";

-- Simple Functions for VARIABLE_FLOAT;

function "ABS" (X : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Operations."ABS";
function MAX (X,Y : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Operations.MAX ;
function MIN (X,Y : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Operations.MIN ;
function Round (X : VARIABLE_FLOAT; L : POSITIVE) return VARIABLE_FLOAT renames
Variable_Float_Operations.Round ;
function Nearest_Integer (X : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Operations.Nearest_Integer;
function Whole_Part (X : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Operations.Whole_Part;
function Fract_Part (X : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Operations.Fract_Part;
function Error_Part (X : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Operations.Error_Part;

-- Conversion to and from INTEGER

function Extend(N : INTEGER) return VARIABLE_FLOAT renames
Variable_Float_Operations.Extend;
function NearestInteger(X : VARIABLE_FLOAT) return INTEGER renames
Variable_Float_Operations.NearestInteger;
function WholePart(X : VARIABLE_FLOAT) return INTEGER renames
Variable_Float_Operations.WholePart;

procedure Set_Error(X : in out VARIABLE_FLOAT; Error : VARIABLE_FLOAT) renames
Variable_Float_Operations.Set_Error;
procedure Set_Error(X : in out VARIABLE_FLOAT; Error_Exp : INTEGER) renames
Variable_Float_Operations.Set_Error;

function Significance(X : VARIABLE_FLOAT) return NATURAL renames
Variable_Float_Operations.Significance;
procedure Set_Default_Significance(N : POSITIVE) renames
Variable_Float_Operations.Set_Default_Significance;
function Default_Significance_Value return POSITIVE renames
Variable_Float_Operations.Default_Significance_Value;

-- Relational Operations for VARIABLE_FLOAT;

function ">" (X,Y : VARIABLE_FLOAT) return BOOLEAN renames
Variable_Float_Operations.">";
function "<" (X,Y : VARIABLE_FLOAT) return BOOLEAN renames
Variable_Float_Operations."<";
function ">=" (X,Y : VARIABLE_FLOAT) return BOOLEAN renames
Variable_Float_Operations.">=";
function "<=" (X,Y : VARIABLE_FLOAT) return BOOLEAN renames
Variable_Float_Operations."<=";

procedure Plus(X : in out VARIABLE_FLOAT; Y : VARIABLE_FLOAT) renames
Variable_Float_Operations.Plus;
procedure Minus(X : in out VARIABLE_FLOAT; Y : VARIABLE_FLOAT) renames
Variable_Float_Operations.Minus;
procedure Times(X : in out VARIABLE_FLOAT; Y : VARIABLE_FLOAT) renames
Variable_Float_Operations.Times;
procedure Div(X : in out VARIABLE_FLOAT; Y : VARIABLE_FLOAT) renames
Variable_Float_Operations.Div;

procedure Plus(X : in out VARIABLE_FLOAT; N : INTEGER) renames
Variable_Float_Operations.Plus;
procedure Minus(X : in out VARIABLE_FLOAT; N : INTEGER) renames
Variable_Float_Operations.Minus;
procedure Times(X : in out VARIABLE_FLOAT; N : INTEGER) renames
Variable_Float_Operations.Times;
procedure Div(X : in out VARIABLE_FLOAT; N : INTEGER) renames
Variable_Float_Operations.Div;
procedure Power(X : in out VARIABLE_FLOAT; N : INTEGER) renames
Variable_Float_Operations.Power;
   
-- Make visible all operations in Variable_Float_Elementary_Functions(only a
selected few):   
-- Mathematical Constants, a minimal set

function Pi(N : POSITIVE := Default_Significance) return VARIABLE_FLOAT renames
Variable_Float_Elementary_Functions.Pi;
-- Elementary Functions

function Sqrt(X : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Elementary_Functions.Sqrt;
procedure Sqrt(X : in out VARIABLE_FLOAT) renames
Variable_Float_Elementary_Functions.Sqrt;

function Exp (X : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Elementary_Functions.Exp;
function Log (X : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Elementary_Functions.Log;
-- log as in ada.elementary_fuctions:
function Log (X,Base : VARIABLE_FLOAT) return VARIABLE_FLOAT;

function Sin(X : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Elementary_Functions.Sin   ;
function Cos(X : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Elementary_Functions.Cos   ;
function Tan(X : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Elementary_Functions.Tan   ;

function Arcsin(X : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Elementary_Functions.Arcsin   ;
function Arccos(X : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Elementary_Functions.Arccos   ;
function Arctan(X : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Elementary_Functions.Arctan   ;

function Sinh(X : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Elementary_Functions.Sinh   ;
function Cosh(X : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Elementary_Functions.Cosh   ;
function Tanh(X : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Elementary_Functions.Tanh   ;

  -- hinzugefuegt von Chris Broeg: 6. mai 2003
function "**" (X,Y : VARIABLE_FLOAT) return VARIABLE_FLOAT renames
Variable_Float_Elementary_Functions."**";


-- Make visible all operations in Variable_Float_IO:   

procedure Put (Item :    VARIABLE_FLOAT;
               Fore : in Ada.Text_IO.Field :=1;
               Aft  : in Ada.Text_IO.Field :=1;
               Exp  : in Ada.Text_IO.Field :=1);
procedure Get (Item :    out VARIABLE_FLOAT;
               Fore : in     Ada.Text_IO.Field :=1;
               Aft  : in     Ada.Text_IO.Field :=1;
               Exp  : in     Ada.Text_IO.Field :=1);

procedure Get (X : out VARIABLE_FLOAT) renames Variable_Float_Io.Get;
function Variable_Float_Value (S : STRING) return VARIABLE_FLOAT renames
Variable_Float_Io.Variable_Float_Value;


-- Make visible all operations in float_conversions:
function Extend(X : FLOAT; Rel_Err : FLOAT := FLOAT'Epsilon/2.0)
         return VARIABLE_FLOAT renames Float_Conversions.Extend;

function Shorten(X : VARIABLE_FLOAT) return FLOAT renames Float_Conversions.Shorten;
--------------------------------------------------------------------------------------
-- End Brian Domans package   
--------------------------------------------------------------------------------------
   function Extend (I : in Integer) return Real_Machine;
   function Extend (X : in Real_Machine) return Real_Machine;
   function Extend (X,Rel_Err : in Real_Machine) return Real_Machine;
   procedure Set_Error (X : in out Real_Machine; Err : in Real_Machine);
   function Shorten (X : in Real_Machine) return Float;
   function Max (X,Y : in Real_Machine) return Real_Machine;
   function Min (X,Y : in Real_Machine) return Real_Machine;
   function Pi return Real_Machine;
   
   function "*" (X : in Integer;Y : in Real_Machine) return Real_Machine;
   function "*" (X : in Real_Machine;Y : in Integer) return Real_Machine;
   function "/" (X : in Real_Machine;Y : in Integer) return Real_Machine;

   function Log10 (X : Real; Base : Real := Extend(10.0)) return Real renames Log;
   
--------------------------------------------------------------------------------------
--Vector type operations:
--------------------------------------------------------------------------------------
   
   function "*" (Left : in Real; Right : in Real_Array) return Real_Array;
     
   function "*" (Left : in Real_Array; Right : in Real) return Real_Array ;
   function "+" (Left,Right : in Real_Array) return Real_Array ;
  
--==============================================================================   
   
   function Maximum (A : in Real_Array) return Real;
   function Minimum (A : in Real_Array) return Real;
   
   pragma Inline ("+","-","*","/","**",Exp,Log,"<",">","<=",">=");

end Number_Types;
-- File name  real_.a   Sept 17th  1990
-- An Accurate Arithmetic Package with Error Estimate by B. G. S. Doman

Package VAR_FLT_Operations is

Subtype N_RANGE is INTEGER range -2..INTEGER'LAST;

Type VAR_FLT is array(N_RANGE range<>) of INTEGER;

d       : constant INTEGER := INTEGER'SIZE/4;   -- i.e.  4 or 8
nnex    : constant INTEGER := 10**(d-1);
nmax    : constant INTEGER := 10*nnex;
td2     : constant INTEGER := 10**(d/2);

-- The range is -2..l, which represents a floating point type in decimal
-- form 0.x(1)x(2).....x(l)*10**x(0) with error bound 0.x(-2)*10**x(-1).
-- i = 1..l are d digit integers, where d is an even no and
-- ABS(x(i)) < 10**d.

Function SGN(k : INTEGER) return INTEGER;
Function MAX(j,k : INTEGER) return INTEGER;
Function MIN(j,k : INTEGER) return INTEGER;
Function Normalise(x : VAR_FLT) return VAR_FLT;
Function Shift_Rt(n : POSITIVE; x : VAR_FLT) return VAR_FLT;

-- Elementary Arithmetical Operations for VAR_FLT;

Function "+" (x,y : VAR_FLT) return VAR_FLT;
Function "-" (x : VAR_FLT) return VAR_FLT;
Function "-" (x,y : VAR_FLT) return VAR_FLT;

Function "+" (k : INTEGER; x : VAR_FLT) return VAR_FLT;
Function "+" (x : VAR_FLT; k : INTEGER) return VAR_FLT;
Function "-" (k : INTEGER; x : VAR_FLT) return VAR_FLT;
Function "-" (x : VAR_FLT; k : INTEGER) return VAR_FLT;
Function "*" (k : INTEGER; x : VAR_FLT) return VAR_FLT;
Function "*" (x : VAR_FLT; k : INTEGER) return VAR_FLT;
Function "*" (x,y : VAR_FLT) return VAR_FLT;
Function "/" (x : VAR_FLT; k : INTEGER) return VAR_FLT;
Function "/" (x,y : VAR_FLT) return VAR_FLT;
Function "**" (x : VAR_FLT; k : INTEGER) return VAR_FLT;

-- Simple Functions for VAR_FLT;

Function "ABS" (x : VAR_FLT) return VAR_FLT;
Function MAX (x,y : VAR_FLT) return VAR_FLT;
Function MIN (x,y : VAR_FLT) return VAR_FLT;
Function Whole_Part(x : VAR_FLT) return VAR_FLT;
Function Nearest_Integer(x : VAR_FLT) return VAR_FLT;
Function Round(x : VAR_FLT; l : POSITIVE) return VAR_FLT;
Function Error_Part(x : VAR_FLT) return VAR_FLT;

-- Conversion to and from INTEGER

Function Extend(n : INTEGER) return VAR_FLT;
Function WholePart(x : VAR_FLT) return INTEGER;         -- added Nov 1st  1993
Function NearestInteger(x : VAR_FLT) return INTEGER;    -- added Nov 1st  1993

-- Relational Operations for VAR_FLT;

Function ">" (x,y : VAR_FLT) return BOOLEAN;
Function "<" (x,y : VAR_FLT) return BOOLEAN;
Function ">=" (x,y : VAR_FLT) return BOOLEAN;
Function "<=" (x,y : VAR_FLT) return BOOLEAN;

End VAR_FLT_Operations;
-- File Name acc_elem_fun_.a    Sept 19th  1990

With Variable_Float_Operations;
Use Variable_Float_Operations;

Package Variable_Float_Elementary_Functions is

-- Mathematical Constants, a minimal set

Function pi(n : POSITIVE := Default_Significance) return VARIABLE_FLOAT;
Function Log_pi(n : POSITIVE := Default_Significance) return VARIABLE_FLOAT;
Function Root_pi(n : POSITIVE := Default_Significance) return VARIABLE_FLOAT;
Function exp_1(n : POSITIVE := Default_Significance) return VARIABLE_FLOAT;
Function Euler_Gamma(n : POSITIVE := Default_Significance) 
                                return VARIABLE_FLOAT;
Function Log_10(n : POSITIVE := Default_Significance) return VARIABLE_FLOAT;
Function Log_2(n : POSITIVE := Default_Significance) return VARIABLE_FLOAT;

-- Elementary Functions

Function sqrt(x : VARIABLE_FLOAT) return VARIABLE_FLOAT;
Procedure sqrt(x : in out VARIABLE_FLOAT);

Function exp(x : VARIABLE_FLOAT) return VARIABLE_FLOAT;
Function log(x : VARIABLE_FLOAT) return VARIABLE_FLOAT;

Function sin(x : VARIABLE_FLOAT) return VARIABLE_FLOAT;
Function cos(x : VARIABLE_FLOAT) return VARIABLE_FLOAT;
Function tan(x : VARIABLE_FLOAT) return VARIABLE_FLOAT;

Function arcsin(x : VARIABLE_FLOAT) return VARIABLE_FLOAT;
Function arccos(x : VARIABLE_FLOAT) return VARIABLE_FLOAT;
Function arctan(x : VARIABLE_FLOAT) return VARIABLE_FLOAT;

Function sinh(x : VARIABLE_FLOAT) return VARIABLE_FLOAT;
Function cosh(x : VARIABLE_FLOAT) return VARIABLE_FLOAT;
Function tanh(x : VARIABLE_FLOAT) return VARIABLE_FLOAT;

-- hinzugefuegt von Chris Broeg: 6. mai 2003
Function "**" (X,y : VARIABLE_FLOAT) return VARIABLE_FLOAT;



End Variable_Float_Elementary_Functions;
-- THIS IS NOT MICHAEL COEN'S VERSION, BUT MY PRIMITIVE VERSION
-- I have not been able to use Michael's version as I have not been able to
-- upload it from disc. The final io will be Michael coen's version which 
-- you already have.

-- File Name acc_io_.ada    Feb 7th 1990

With Variable_Float_Operations,Var_Flt_Operations;
Use Variable_Float_Operations,Var_Flt_Operations;

Package Variable_Float_io is

Procedure Put(z : VAR_FLT);
Procedure Put(x : VARIABLE_FLOAT);
Function Get_No return VAR_FLT;
Function Get_No(s : STRING) return VAR_FLT;
Procedure Get(x : out VARIABLE_FLOAT);
Function Variable_Float_Value(s : STRING) return VARIABLE_FLOAT;

End Variable_Float_io;
-- File name  accurate_.a   Sept 18th  1990
-- An Accurate Arithmetic Package with Error Estimate
--       by B. G. S. Doman and C. J. Pursglove

With VAR_FLT_Operations,Unchecked_Deallocation;
Use VAR_FLT_Operations;
with Ada.Finalization;use Ada.Finalization;

Package Variable_Float_Operations is

   Type Var_Flt_access is access VAR_FLT;
   
   Procedure Free is new Unchecked_Deallocation(VAR_FLT,VAR_Flt_access);

   type Variable_float is new Ada.Finalization.Controlled with
      record
         P : Var_Flt_access;
      end Record;
   

   Default_Significance    : POSITIVE := 30;

-- Elementary Arithmetical Operations for VARIABLE_FLOAT;

Function "+" (x,y : VARIABLE_FLOAT) return VARIABLE_FLOAT;
Function "+" (x : VARIABLE_FLOAT) return VARIABLE_FLOAT;
Function "-" (x : VARIABLE_FLOAT) return VARIABLE_FLOAT;
Function "-" (x,y : VARIABLE_FLOAT) return VARIABLE_FLOAT;
Function "*" (x,y : VARIABLE_FLOAT) return VARIABLE_FLOAT;
Function "/" (x,y : VARIABLE_FLOAT) return VARIABLE_FLOAT;

Function "+" (n : INTEGER; x : VARIABLE_FLOAT) return VARIABLE_FLOAT;
Function "+" (x : VARIABLE_FLOAT; n : INTEGER) return VARIABLE_FLOAT;
Function "-" (n : INTEGER; x : VARIABLE_FLOAT) return VARIABLE_FLOAT;
Function "-" (x : VARIABLE_FLOAT; n : INTEGER) return VARIABLE_FLOAT;
Function "*" (n : INTEGER; x : VARIABLE_FLOAT) return VARIABLE_FLOAT;
Function "*" (x : VARIABLE_FLOAT; n : INTEGER) return VARIABLE_FLOAT;
Function "/" (x : VARIABLE_FLOAT; n : INTEGER) return VARIABLE_FLOAT;
Function "/" (n : INTEGER; x : VARIABLE_FLOAT) return VARIABLE_FLOAT;
Function "**" (x : VARIABLE_FLOAT; n : INTEGER) return VARIABLE_FLOAT;

-- Simple Functions for VARIABLE_FLOAT;

Function "ABS" (x : VARIABLE_FLOAT) return VARIABLE_FLOAT;
Function MAX (x,y : VARIABLE_FLOAT) return VARIABLE_FLOAT;
Function MIN (x,y : VARIABLE_FLOAT) return VARIABLE_FLOAT;
Function Round (x : VARIABLE_FLOAT; l : POSITIVE) return VARIABLE_FLOAT;
Function Nearest_Integer (x : VARIABLE_FLOAT) return VARIABLE_FLOAT;
Function Whole_Part (x : VARIABLE_FLOAT) return VARIABLE_FLOAT;
Function Fract_Part (x : VARIABLE_FLOAT) return VARIABLE_FLOAT;
Function Error_Part (x : VARIABLE_FLOAT) return VARIABLE_FLOAT;

-- Conversion to and from INTEGER

Function Extend(n : INTEGER) return VARIABLE_FLOAT;
Function NearestInteger(x : VARIABLE_FLOAT) return INTEGER;  -- added Nov1 1993
Function WholePart(x : VARIABLE_FLOAT) return INTEGER;       -- added Nov1 1993

Procedure Set_Error(x : in out VARIABLE_FLOAT; error : VARIABLE_FLOAT);
Procedure Set_Error(x : in out VARIABLE_FLOAT; error_exp : INTEGER);

Function Significance(x : VARIABLE_FLOAT) return NATURAL;
Procedure Set_Default_Significance(n : POSITIVE);
Function Default_Significance_Value return POSITIVE;

-- Relational Operations for VARIABLE_FLOAT;

Function ">" (x,y : VARIABLE_FLOAT) return BOOLEAN;
Function "<" (x,y : VARIABLE_FLOAT) return BOOLEAN;
Function ">=" (x,y : VARIABLE_FLOAT) return BOOLEAN;
Function "<=" (x,y : VARIABLE_FLOAT) return BOOLEAN;

Procedure Plus(x : in out VARIABLE_FLOAT; y : VARIABLE_FLOAT);
Procedure Minus(x : in out VARIABLE_FLOAT; y : VARIABLE_FLOAT);
Procedure Times(x : in out VARIABLE_FLOAT; y : VARIABLE_FLOAT);
Procedure Div(x : in out VARIABLE_FLOAT; y : VARIABLE_FLOAT);

Procedure Plus(x : in out VARIABLE_FLOAT; n : INTEGER);
Procedure Minus(x : in out VARIABLE_FLOAT; n : INTEGER);
Procedure Times(x : in out VARIABLE_FLOAT; n : INTEGER);
Procedure Div(x : in out VARIABLE_FLOAT; n : INTEGER);
Procedure Power(x : in out VARIABLE_FLOAT; n : INTEGER);

Variable_Float_Unset_Error,
Variable_Float_Constraint_Error,
Variable_Float_Numeric_Error    : Exception;


private
   procedure Finalize (Object : in out Variable_float);
   
   procedure Adjust (Object : in out Variable_float);
--   procedure Initialize  (Object : in out Variable_float);
   
End Variable_Float_Operations;

-- 
           Summary: gnatmake fails with error box
           Product: gcc
           Version: 3.3.1
            Status: UNCONFIRMED
          Severity: critical
          Priority: P2
         Component: ada
        AssignedTo: unassigned at gcc dot gnu dot org
        ReportedBy: broeg at gmx dot de
                CC: gcc-bugs at gcc dot gnu dot org
  GCC host triplet: 3.3.1
GCC target triplet: 3.3.1


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=14068

[Bug ada/14068] gnatmake fails with error box

[pinskia at gcc dot gnu dot org]

------- Additional Comments From pinskia at gcc dot gnu dot org  2004-02-07 22:11 -------
Can you try a snapshot of 3.4.0, it has even better Ada support than 3.3.x will ever have.

-- 
           What    |Removed                     |Added
----------------------------------------------------------------------------
           Severity|critical                    |normal


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=14068

[Bug ada/14068] gnatmake fails with error box

[charlet at gcc dot gnu dot org]

------- Additional Comments From charlet at gcc dot gnu dot org  2004-02-10 11:56 -------
Most likely fixed in 3.4 and mainline, but in any case, you
did not include constants.ads

Arno

-- 
           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |RESOLVED
         Resolution|                            |INVALID


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=14068

[Bug ada/14068] gnatmake fails with error box

[broeg at gmx dot de]

------- Additional Comments From broeg at gmx dot de  2004-02-10 12:51 -------
I checked it with snapshot of 3.4 and it works with the new version. sorry if I 
forgot to include constants.ads. If you want to check anyway, here it is:
(I reduced it somewhat, so that only number types is needed now.
----------------------------------------------------------------------------
with Number_Types;
use Number_Types;
with Ada.Numerics;
package Constants is
   
   
   -- specific molar Gas Constant for hydrogen
   R_Hydrogen_Molecular : constant Real := (4127.0); -- [J/(kg * K)]
   R_Hydrogen_Atomic : constant Real := (8254.0); -- [J/(kg * K)]
   R_Helium_Atom : constant Real := (2078.0); -- [J/(kg * K)]
   R_Solar_Wrong : constant Real := (6710.0); --for x:y:z = .75:.25:0
   R_Solar : constant Real := (13888.8888); --from solar table at r=.3Rs
   R_Air : constant Real :=  R_Hydrogen_Molecular / (15.0);
   R_Bojan : constant Real := (3614.0); -- Molar Mass=2.3E-3 kg/mol
   
   -- stefan bolzmann konstante:
   Stefan_Boltzmann : constant Real := (5.67051E-6); -- [W/(m^2 * K^4)]
   K                : constant Real := (1.380658e-23); -- [J/K]
                                                       -- gravitation Constant
   G : constant Real := (6.67390E-11);  --[m^3/kg/s^2]
 
   
   -- earth mass
   M_e : constant Real := (5.972E24);   -- [kg]
   
   -- solar luminosity, mass, radius
   L_o : constant Real := (3.846E26);  --[Watt]
   M_o : constant Real := (1.989e30);  --[kg]
   R_o : constant Real := (6.960e8);   --[m]
   
   -- jupiter
   M_Jupiter : constant Real := (1899.0e24);   --[kg]
   
   -- PI
   Pi : constant Real := Number_types.Pi;
   AU : constant Real := (149597870610.0); --[m]
   
   -- integer numbers:
   Eins : constant Real := 1.0;
   Zehn : constant Real := 10.0;
   
   
   --     -- small values;
   Ten_To_The_Minus_200 : constant Real := 1.0e-200;
   
   
end Constants;


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=14068