obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

1 files changed, 1635 insertions, 0 deletions

diff --git a/gcc/ada/urealp.adb b/gcc/ada/urealp.adb
new file mode 100644
index 000000000..e28ee59f1
--- /dev/null
+++ b/gcc/ada/urealp.adb
@@ -0,0 +1,1635 @@
+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT COMPILER COMPONENTS                         --
+--                                                                          --
+--                               U R E A L P                                --
+--                                                                          --
+--                                 B o d y                                  --
+--                                                                          --
+--          Copyright (C) 1992-2010, Free Software Foundation, Inc.         --
+--                                                                          --
+-- GNAT is free software;  you can  redistribute it  and/or modify it under --
+-- terms of the  GNU General Public License as published  by the Free Soft- --
+-- ware  Foundation;  either version 3,  or (at your option) any later ver- --
+-- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
+-- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
+-- or FITNESS FOR A PARTICULAR PURPOSE.                                     --
+--                                                                          --
+-- As a special exception under Section 7 of GPL version 3, you are granted --
+-- additional permissions described in the GCC Runtime Library Exception,   --
+-- version 3.1, as published by the Free Software Foundation.               --
+--                                                                          --
+-- You should have received a copy of the GNU General Public License and    --
+-- a copy of the GCC Runtime Library Exception along with this program;     --
+-- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    --
+-- <http://www.gnu.org/licenses/>.                                          --
+--                                                                          --
+-- GNAT was originally developed  by the GNAT team at  New York University. --
+-- Extensive contributions were provided by Ada Core Technologies Inc.      --
+--                                                                          --
+------------------------------------------------------------------------------
+
+with Alloc;
+with Output;  use Output;
+with Table;
+with Tree_IO; use Tree_IO;
+
+package body Urealp is
+
+   Ureal_First_Entry : constant Ureal := Ureal'Succ (No_Ureal);
+   --  First subscript allocated in Ureal table (note that we can't just
+   --  add 1 to No_Ureal, since "+" means something different for Ureals!
+
+   type Ureal_Entry is record
+      Num  : Uint;
+      --  Numerator (always non-negative)
+
+      Den : Uint;
+      --  Denominator (always non-zero, always positive if base is zero)
+
+      Rbase : Nat;
+      --  Base value. If Rbase is zero, then the value is simply Num / Den.
+      --  If Rbase is non-zero, then the value is Num / (Rbase ** Den)
+
+      Negative : Boolean;
+      --  Flag set if value is negative
+   end record;
+
+   --  The following representation clause ensures that the above record
+   --  has no holes. We do this so that when instances of this record are
+   --  written by Tree_Gen, we do not write uninitialized values to the file.
+
+   for Ureal_Entry use record
+      Num      at  0 range 0 .. 31;
+      Den      at  4 range 0 .. 31;
+      Rbase    at  8 range 0 .. 31;
+      Negative at 12 range 0 .. 31;
+   end record;
+
+   for Ureal_Entry'Size use 16 * 8;
+   --  This ensures that we did not leave out any fields
+
+   package Ureals is new Table.Table (
+     Table_Component_Type => Ureal_Entry,
+     Table_Index_Type     => Ureal'Base,
+     Table_Low_Bound      => Ureal_First_Entry,
+     Table_Initial        => Alloc.Ureals_Initial,
+     Table_Increment      => Alloc.Ureals_Increment,
+     Table_Name           => "Ureals");
+
+   --  The following universal reals are the values returned by the constant
+   --  functions. They are initialized by the initialization procedure.
+
+   UR_0       : Ureal;
+   UR_M_0     : Ureal;
+   UR_Tenth   : Ureal;
+   UR_Half    : Ureal;
+   UR_1       : Ureal;
+   UR_2       : Ureal;
+   UR_10      : Ureal;
+   UR_10_36   : Ureal;
+   UR_M_10_36 : Ureal;
+   UR_100     : Ureal;
+   UR_2_128   : Ureal;
+   UR_2_80    : Ureal;
+   UR_2_M_128 : Ureal;
+   UR_2_M_80  : Ureal;
+
+   Num_Ureal_Constants : constant := 10;
+   --  This is used for an assertion check in Tree_Read and Tree_Write to
+   --  help remember to add values to these routines when we add to the list.
+
+   Normalized_Real : Ureal := No_Ureal;
+   --  Used to memoize Norm_Num and Norm_Den, if either of these functions
+   --  is called, this value is set and Normalized_Entry contains the result
+   --  of the normalization. On subsequent calls, this is used to avoid the
+   --  call to Normalize if it has already been made.
+
+   Normalized_Entry : Ureal_Entry;
+   --  Entry built by most recent call to Normalize
+
+   -----------------------
+   -- Local Subprograms --
+   -----------------------
+
+   function Decimal_Exponent_Hi (V : Ureal) return Int;
+   --  Returns an estimate of the exponent of Val represented as a normalized
+   --  decimal number (non-zero digit before decimal point), The estimate is
+   --  either correct, or high, but never low. The accuracy of the estimate
+   --  affects only the efficiency of the comparison routines.
+
+   function Decimal_Exponent_Lo (V : Ureal) return Int;
+   --  Returns an estimate of the exponent of Val represented as a normalized
+   --  decimal number (non-zero digit before decimal point), The estimate is
+   --  either correct, or low, but never high. The accuracy of the estimate
+   --  affects only the efficiency of the comparison routines.
+
+   function Equivalent_Decimal_Exponent (U : Ureal_Entry) return Int;
+   --  U is a Ureal entry for which the base value is non-zero, the value
+   --  returned is the equivalent decimal exponent value, i.e. the value of
+   --  Den, adjusted as though the base were base 10. The value is rounded
+   --  to the nearest integer, and so can be one off.
+
+   function Is_Integer (Num, Den : Uint) return Boolean;
+   --  Return true if the real quotient of Num / Den is an integer value
+
+   function Normalize (Val : Ureal_Entry) return Ureal_Entry;
+   --  Normalizes the Ureal_Entry by reducing it to lowest terms (with a base
+   --  value of 0).
+
+   function Same (U1, U2 : Ureal) return Boolean;
+   pragma Inline (Same);
+   --  Determines if U1 and U2 are the same Ureal. Note that we cannot use
+   --  the equals operator for this test, since that tests for equality, not
+   --  identity.
+
+   function Store_Ureal (Val : Ureal_Entry) return Ureal;
+   --  This store a new entry in the universal reals table and return its index
+   --  in the table.
+
+   function Store_Ureal_Normalized (Val : Ureal_Entry) return Ureal;
+   pragma Inline (Store_Ureal_Normalized);
+   --  Like Store_Ureal, but normalizes its operand first.
+
+   -------------------------
+   -- Decimal_Exponent_Hi --
+   -------------------------
+
+   function Decimal_Exponent_Hi (V : Ureal) return Int is
+      Val : constant Ureal_Entry := Ureals.Table (V);
+
+   begin
+      --  Zero always returns zero
+
+      if UR_Is_Zero (V) then
+         return 0;
+
+      --  For numbers in rational form, get the maximum number of digits in the
+      --  numerator and the minimum number of digits in the denominator, and
+      --  subtract. For example:
+
+      --     1000 / 99 = 1.010E+1
+      --     9999 / 10 = 9.999E+2
+
+      --  This estimate may of course be high, but that is acceptable
+
+      elsif Val.Rbase = 0 then
+         return UI_Decimal_Digits_Hi (Val.Num) -
+                UI_Decimal_Digits_Lo (Val.Den);
+
+      --  For based numbers, just subtract the decimal exponent from the
+      --  high estimate of the number of digits in the numerator and add
+      --  one to accommodate possible round off errors for non-decimal
+      --  bases. For example:
+
+      --     1_500_000 / 10**4 = 1.50E-2
+
+      else -- Val.Rbase /= 0
+         return UI_Decimal_Digits_Hi (Val.Num) -
+                Equivalent_Decimal_Exponent (Val) + 1;
+      end if;
+   end Decimal_Exponent_Hi;
+
+   -------------------------
+   -- Decimal_Exponent_Lo --
+   -------------------------
+
+   function Decimal_Exponent_Lo (V : Ureal) return Int is
+      Val : constant Ureal_Entry := Ureals.Table (V);
+
+   begin
+      --  Zero always returns zero
+
+      if UR_Is_Zero (V) then
+         return 0;
+
+      --  For numbers in rational form, get min digits in numerator, max digits
+      --  in denominator, and subtract and subtract one more for possible loss
+      --  during the division. For example:
+
+      --     1000 / 99 = 1.010E+1
+      --     9999 / 10 = 9.999E+2
+
+      --  This estimate may of course be low, but that is acceptable
+
+      elsif Val.Rbase = 0 then
+         return UI_Decimal_Digits_Lo (Val.Num) -
+                UI_Decimal_Digits_Hi (Val.Den) - 1;
+
+      --  For based numbers, just subtract the decimal exponent from the
+      --  low estimate of the number of digits in the numerator and subtract
+      --  one to accommodate possible round off errors for non-decimal
+      --  bases. For example:
+
+      --     1_500_000 / 10**4 = 1.50E-2
+
+      else -- Val.Rbase /= 0
+         return UI_Decimal_Digits_Lo (Val.Num) -
+                Equivalent_Decimal_Exponent (Val) - 1;
+      end if;
+   end Decimal_Exponent_Lo;
+
+   -----------------
+   -- Denominator --
+   -----------------
+
+   function Denominator (Real : Ureal) return Uint is
+   begin
+      return Ureals.Table (Real).Den;
+   end Denominator;
+
+   ---------------------------------
+   -- Equivalent_Decimal_Exponent --
+   ---------------------------------
+
+   function Equivalent_Decimal_Exponent (U : Ureal_Entry) return Int is
+
+      --  The following table is a table of logs to the base 10
+
+      Logs : constant array (Nat range 1 .. 16) of Long_Float := (
+                1 => 0.000000000000000,
+                2 => 0.301029995663981,
+                3 => 0.477121254719662,
+                4 => 0.602059991327962,
+                5 => 0.698970004336019,
+                6 => 0.778151250383644,
+                7 => 0.845098040014257,
+                8 => 0.903089986991944,
+                9 => 0.954242509439325,
+               10 => 1.000000000000000,
+               11 => 1.041392685158230,
+               12 => 1.079181246047620,
+               13 => 1.113943352306840,
+               14 => 1.146128035678240,
+               15 => 1.176091259055680,
+               16 => 1.204119982655920);
+
+   begin
+      pragma Assert (U.Rbase /= 0);
+      return Int (Long_Float (UI_To_Int (U.Den)) * Logs (U.Rbase));
+   end Equivalent_Decimal_Exponent;
+
+   ----------------
+   -- Initialize --
+   ----------------
+
+   procedure Initialize is
+   begin
+      Ureals.Init;
+      UR_0       := UR_From_Components (Uint_0, Uint_1,         0, False);
+      UR_M_0     := UR_From_Components (Uint_0, Uint_1,         0, True);
+      UR_Half    := UR_From_Components (Uint_1, Uint_1,         2, False);
+      UR_Tenth   := UR_From_Components (Uint_1, Uint_1,        10, False);
+      UR_1       := UR_From_Components (Uint_1, Uint_1,         0, False);
+      UR_2       := UR_From_Components (Uint_1, Uint_Minus_1,   2, False);
+      UR_10      := UR_From_Components (Uint_1, Uint_Minus_1,  10, False);
+      UR_10_36   := UR_From_Components (Uint_1, Uint_Minus_36, 10, False);
+      UR_M_10_36 := UR_From_Components (Uint_1, Uint_Minus_36, 10, True);
+      UR_100     := UR_From_Components (Uint_1, Uint_Minus_2,  10, False);
+      UR_2_128   := UR_From_Components (Uint_1, Uint_Minus_128, 2, False);
+      UR_2_M_128 := UR_From_Components (Uint_1, Uint_128,       2, False);
+      UR_2_80    := UR_From_Components (Uint_1, Uint_Minus_80,  2, False);
+      UR_2_M_80  := UR_From_Components (Uint_1, Uint_80,        2, False);
+   end Initialize;
+
+   ----------------
+   -- Is_Integer --
+   ----------------
+
+   function Is_Integer (Num, Den : Uint) return Boolean is
+   begin
+      return (Num / Den) * Den = Num;
+   end Is_Integer;
+
+   ----------
+   -- Mark --
+   ----------
+
+   function Mark return Save_Mark is
+   begin
+      return Save_Mark (Ureals.Last);
+   end Mark;
+
+   --------------
+   -- Norm_Den --
+   --------------
+
+   function Norm_Den (Real : Ureal) return Uint is
+   begin
+      if not Same (Real, Normalized_Real) then
+         Normalized_Real  := Real;
+         Normalized_Entry := Normalize (Ureals.Table (Real));
+      end if;
+
+      return Normalized_Entry.Den;
+   end Norm_Den;
+
+   --------------
+   -- Norm_Num --
+   --------------
+
+   function Norm_Num (Real : Ureal) return Uint is
+   begin
+      if not Same (Real, Normalized_Real) then
+         Normalized_Real  := Real;
+         Normalized_Entry := Normalize (Ureals.Table (Real));
+      end if;
+
+      return Normalized_Entry.Num;
+   end Norm_Num;
+
+   ---------------
+   -- Normalize --
+   ---------------
+
+   function Normalize (Val : Ureal_Entry) return Ureal_Entry is
+      J   : Uint;
+      K   : Uint;
+      Tmp : Uint;
+      Num : Uint;
+      Den : Uint;
+      M   : constant Uintp.Save_Mark := Uintp.Mark;
+
+   begin
+      --  Start by setting J to the greatest of the absolute values of the
+      --  numerator and the denominator (taking into account the base value),
+      --  and K to the lesser of the two absolute values. The gcd of Num and
+      --  Den is the gcd of J and K.
+
+      if Val.Rbase = 0 then
+         J := Val.Num;
+         K := Val.Den;
+
+      elsif Val.Den < 0 then
+         J := Val.Num * Val.Rbase ** (-Val.Den);
+         K := Uint_1;
+
+      else
+         J := Val.Num;
+         K := Val.Rbase ** Val.Den;
+      end if;
+
+      Num := J;
+      Den := K;
+
+      if K > J then
+         Tmp := J;
+         J := K;
+         K := Tmp;
+      end if;
+
+      J := UI_GCD (J, K);
+      Num := Num / J;
+      Den := Den / J;
+      Uintp.Release_And_Save (M, Num, Den);
+
+      --  Divide numerator and denominator by gcd and return result
+
+      return (Num      => Num,
+              Den      => Den,
+              Rbase    => 0,
+              Negative => Val.Negative);
+   end Normalize;
+
+   ---------------
+   -- Numerator --
+   ---------------
+
+   function Numerator (Real : Ureal) return Uint is
+   begin
+      return Ureals.Table (Real).Num;
+   end Numerator;
+
+   --------
+   -- pr --
+   --------
+
+   procedure pr (Real : Ureal) is
+   begin
+      UR_Write (Real);
+      Write_Eol;
+   end pr;
+
+   -----------
+   -- Rbase --
+   -----------
+
+   function Rbase (Real : Ureal) return Nat is
+   begin
+      return Ureals.Table (Real).Rbase;
+   end Rbase;
+
+   -------------
+   -- Release --
+   -------------
+
+   procedure Release (M : Save_Mark) is
+   begin
+      Ureals.Set_Last (Ureal (M));
+   end Release;
+
+   ----------
+   -- Same --
+   ----------
+
+   function Same (U1, U2 : Ureal) return Boolean is
+   begin
+      return Int (U1) = Int (U2);
+   end Same;
+
+   -----------------
+   -- Store_Ureal --
+   -----------------
+
+   function Store_Ureal (Val : Ureal_Entry) return Ureal is
+   begin
+      Ureals.Append (Val);
+
+      --  Normalize representation of signed values
+
+      if Val.Num < 0 then
+         Ureals.Table (Ureals.Last).Negative := True;
+         Ureals.Table (Ureals.Last).Num := -Val.Num;
+      end if;
+
+      return Ureals.Last;
+   end Store_Ureal;
+
+   ----------------------------
+   -- Store_Ureal_Normalized --
+   ----------------------------
+
+   function Store_Ureal_Normalized (Val : Ureal_Entry) return Ureal is
+   begin
+      return Store_Ureal (Normalize (Val));
+   end Store_Ureal_Normalized;
+
+   ---------------
+   -- Tree_Read --
+   ---------------
+
+   procedure Tree_Read is
+   begin
+      pragma Assert (Num_Ureal_Constants = 10);
+
+      Ureals.Tree_Read;
+      Tree_Read_Int (Int (UR_0));
+      Tree_Read_Int (Int (UR_M_0));
+      Tree_Read_Int (Int (UR_Tenth));
+      Tree_Read_Int (Int (UR_Half));
+      Tree_Read_Int (Int (UR_1));
+      Tree_Read_Int (Int (UR_2));
+      Tree_Read_Int (Int (UR_10));
+      Tree_Read_Int (Int (UR_100));
+      Tree_Read_Int (Int (UR_2_128));
+      Tree_Read_Int (Int (UR_2_M_128));
+
+      --  Clear the normalization cache
+
+      Normalized_Real := No_Ureal;
+   end Tree_Read;
+
+   ----------------
+   -- Tree_Write --
+   ----------------
+
+   procedure Tree_Write is
+   begin
+      pragma Assert (Num_Ureal_Constants = 10);
+
+      Ureals.Tree_Write;
+      Tree_Write_Int (Int (UR_0));
+      Tree_Write_Int (Int (UR_M_0));
+      Tree_Write_Int (Int (UR_Tenth));
+      Tree_Write_Int (Int (UR_Half));
+      Tree_Write_Int (Int (UR_1));
+      Tree_Write_Int (Int (UR_2));
+      Tree_Write_Int (Int (UR_10));
+      Tree_Write_Int (Int (UR_100));
+      Tree_Write_Int (Int (UR_2_128));
+      Tree_Write_Int (Int (UR_2_M_128));
+   end Tree_Write;
+
+   ------------
+   -- UR_Abs --
+   ------------
+
+   function UR_Abs (Real : Ureal) return Ureal is
+      Val : constant Ureal_Entry := Ureals.Table (Real);
+
+   begin
+      return Store_Ureal
+               ((Num      => Val.Num,
+                 Den      => Val.Den,
+                 Rbase    => Val.Rbase,
+                 Negative => False));
+   end UR_Abs;
+
+   ------------
+   -- UR_Add --
+   ------------
+
+   function UR_Add (Left : Uint; Right : Ureal) return Ureal is
+   begin
+      return UR_From_Uint (Left) + Right;
+   end UR_Add;
+
+   function UR_Add (Left : Ureal; Right : Uint) return Ureal is
+   begin
+      return Left + UR_From_Uint (Right);
+   end UR_Add;
+
+   function UR_Add (Left : Ureal; Right : Ureal) return Ureal is
+      Lval : Ureal_Entry := Ureals.Table (Left);
+      Rval : Ureal_Entry := Ureals.Table (Right);
+      Num  : Uint;
+
+   begin
+      --  Note, in the temporary Ureal_Entry values used in this procedure,
+      --  we store the sign as the sign of the numerator (i.e. xxx.Num may
+      --  be negative, even though in stored entries this can never be so)
+
+      if Lval.Rbase /= 0 and then Lval.Rbase = Rval.Rbase then
+         declare
+            Opd_Min, Opd_Max   : Ureal_Entry;
+            Exp_Min, Exp_Max   : Uint;
+
+         begin
+            if Lval.Negative then
+               Lval.Num := (-Lval.Num);
+            end if;
+
+            if Rval.Negative then
+               Rval.Num := (-Rval.Num);
+            end if;
+
+            if Lval.Den < Rval.Den then
+               Exp_Min := Lval.Den;
+               Exp_Max := Rval.Den;
+               Opd_Min := Lval;
+               Opd_Max := Rval;
+            else
+               Exp_Min := Rval.Den;
+               Exp_Max := Lval.Den;
+               Opd_Min := Rval;
+               Opd_Max := Lval;
+            end if;
+
+            Num :=
+              Opd_Min.Num * Lval.Rbase ** (Exp_Max - Exp_Min) + Opd_Max.Num;
+
+            if Num = 0 then
+               return Store_Ureal
+                        ((Num      => Uint_0,
+                          Den      => Uint_1,
+                          Rbase    => 0,
+                          Negative => Lval.Negative));
+
+            else
+               return Store_Ureal
+                        ((Num      => abs Num,
+                          Den      => Exp_Max,
+                          Rbase    => Lval.Rbase,
+                          Negative => (Num < 0)));
+            end if;
+         end;
+
+      else
+         declare
+            Ln : Ureal_Entry := Normalize (Lval);
+            Rn : Ureal_Entry := Normalize (Rval);
+
+         begin
+            if Ln.Negative then
+               Ln.Num := (-Ln.Num);
+            end if;
+
+            if Rn.Negative then
+               Rn.Num := (-Rn.Num);
+            end if;
+
+            Num := (Ln.Num * Rn.Den) + (Rn.Num * Ln.Den);
+
+            if Num = 0 then
+               return Store_Ureal
+                        ((Num      => Uint_0,
+                          Den      => Uint_1,
+                          Rbase    => 0,
+                          Negative => Lval.Negative));
+
+            else
+               return Store_Ureal_Normalized
+                        ((Num      => abs Num,
+                          Den      => Ln.Den * Rn.Den,
+                          Rbase    => 0,
+                          Negative => (Num < 0)));
+            end if;
+         end;
+      end if;
+   end UR_Add;
+
+   ----------------
+   -- UR_Ceiling --
+   ----------------
+
+   function UR_Ceiling (Real : Ureal) return Uint is
+      Val : constant Ureal_Entry := Normalize (Ureals.Table (Real));
+   begin
+      if Val.Negative then
+         return UI_Negate (Val.Num / Val.Den);
+      else
+         return (Val.Num + Val.Den - 1) / Val.Den;
+      end if;
+   end UR_Ceiling;
+
+   ------------
+   -- UR_Div --
+   ------------
+
+   function UR_Div (Left : Uint; Right : Ureal) return Ureal is
+   begin
+      return UR_From_Uint (Left) / Right;
+   end UR_Div;
+
+   function UR_Div (Left : Ureal; Right : Uint) return Ureal is
+   begin
+      return Left / UR_From_Uint (Right);
+   end UR_Div;
+
+   function UR_Div (Left, Right : Ureal) return Ureal is
+      Lval : constant Ureal_Entry := Ureals.Table (Left);
+      Rval : constant Ureal_Entry := Ureals.Table (Right);
+      Rneg : constant Boolean     := Rval.Negative xor Lval.Negative;
+
+   begin
+      pragma Assert (Rval.Num /= Uint_0);
+
+      if Lval.Rbase = 0 then
+         if Rval.Rbase = 0 then
+            return Store_Ureal_Normalized
+                     ((Num      => Lval.Num * Rval.Den,
+                       Den      => Lval.Den * Rval.Num,
+                       Rbase    => 0,
+                       Negative => Rneg));
+
+         elsif Is_Integer (Lval.Num, Rval.Num * Lval.Den) then
+            return Store_Ureal
+                     ((Num      => Lval.Num / (Rval.Num * Lval.Den),
+                       Den      => (-Rval.Den),
+                       Rbase    => Rval.Rbase,
+                       Negative => Rneg));
+
+         elsif Rval.Den < 0 then
+            return Store_Ureal_Normalized
+                     ((Num      => Lval.Num,
+                       Den      => Rval.Rbase ** (-Rval.Den) *
+                                   Rval.Num *
+                                   Lval.Den,
+                       Rbase    => 0,
+                       Negative => Rneg));
+
+         else
+            return Store_Ureal_Normalized
+                     ((Num      => Lval.Num * Rval.Rbase ** Rval.Den,
+                       Den      => Rval.Num * Lval.Den,
+                       Rbase    => 0,
+                       Negative => Rneg));
+         end if;
+
+      elsif Is_Integer (Lval.Num, Rval.Num) then
+         if Rval.Rbase = Lval.Rbase then
+            return Store_Ureal
+                     ((Num      => Lval.Num / Rval.Num,
+                       Den      => Lval.Den - Rval.Den,
+                       Rbase    => Lval.Rbase,
+                       Negative => Rneg));
+
+         elsif Rval.Rbase = 0 then
+            return Store_Ureal
+                     ((Num      => (Lval.Num / Rval.Num) * Rval.Den,
+                       Den      => Lval.Den,
+                       Rbase    => Lval.Rbase,
+                       Negative => Rneg));
+
+         elsif Rval.Den < 0 then
+            declare
+               Num, Den : Uint;
+
+            begin
+               if Lval.Den < 0 then
+                  Num := (Lval.Num / Rval.Num) * (Lval.Rbase ** (-Lval.Den));
+                  Den := Rval.Rbase ** (-Rval.Den);
+               else
+                  Num := Lval.Num / Rval.Num;
+                  Den := (Lval.Rbase ** Lval.Den) *
+                         (Rval.Rbase ** (-Rval.Den));
+               end if;
+
+               return Store_Ureal
+                        ((Num      => Num,
+                          Den      => Den,
+                          Rbase    => 0,
+                          Negative => Rneg));
+            end;
+
+         else
+            return Store_Ureal
+                     ((Num      => (Lval.Num / Rval.Num) *
+                                   (Rval.Rbase ** Rval.Den),
+                       Den      => Lval.Den,
+                       Rbase    => Lval.Rbase,
+                       Negative => Rneg));
+         end if;
+
+      else
+         declare
+            Num, Den : Uint;
+
+         begin
+            if Lval.Den < 0 then
+               Num := Lval.Num * (Lval.Rbase ** (-Lval.Den));
+               Den := Rval.Num;
+            else
+               Num := Lval.Num;
+               Den := Rval.Num * (Lval.Rbase ** Lval.Den);
+            end if;
+
+            if Rval.Rbase /= 0 then
+               if Rval.Den < 0 then
+                  Den := Den * (Rval.Rbase ** (-Rval.Den));
+               else
+                  Num := Num * (Rval.Rbase ** Rval.Den);
+               end if;
+
+            else
+               Num := Num * Rval.Den;
+            end if;
+
+            return Store_Ureal_Normalized
+                     ((Num      => Num,
+                       Den      => Den,
+                       Rbase    => 0,
+                       Negative => Rneg));
+         end;
+      end if;
+   end UR_Div;
+
+   -----------
+   -- UR_Eq --
+   -----------
+
+   function UR_Eq (Left, Right : Ureal) return Boolean is
+   begin
+      return not UR_Ne (Left, Right);
+   end UR_Eq;
+
+   ---------------------
+   -- UR_Exponentiate --
+   ---------------------
+
+   function UR_Exponentiate (Real : Ureal; N : Uint) return Ureal is
+      X    : constant Uint := abs N;
+      Bas  : Ureal;
+      Val  : Ureal_Entry;
+      Neg  : Boolean;
+      IBas : Uint;
+
+   begin
+      --  If base is negative, then the resulting sign depends on whether
+      --  the exponent is even or odd (even => positive, odd = negative)
+
+      if UR_Is_Negative (Real) then
+         Neg := (N mod 2) /= 0;
+         Bas := UR_Negate (Real);
+      else
+         Neg := False;
+         Bas := Real;
+      end if;
+
+      Val := Ureals.Table (Bas);
+
+      --  If the base is a small integer, then we can return the result in
+      --  exponential form, which can save a lot of time for junk exponents.
+
+      IBas := UR_Trunc (Bas);
+
+      if IBas <= 16
+        and then UR_From_Uint (IBas) = Bas
+      then
+         return Store_Ureal
+                  ((Num      => Uint_1,
+                    Den      => -N,
+                    Rbase    => UI_To_Int (UR_Trunc (Bas)),
+                    Negative => Neg));
+
+      --  If the exponent is negative then we raise the numerator and the
+      --  denominator (after normalization) to the absolute value of the
+      --  exponent and we return the reciprocal. An assert error will happen
+      --  if the numerator is zero.
+
+      elsif N < 0 then
+         pragma Assert (Val.Num /= 0);
+         Val := Normalize (Val);
+
+         return Store_Ureal
+                  ((Num      => Val.Den ** X,
+                    Den      => Val.Num ** X,
+                    Rbase    => 0,
+                    Negative => Neg));
+
+      --  If positive, we distinguish the case when the base is not zero, in
+      --  which case the new denominator is just the product of the old one
+      --  with the exponent,
+
+      else
+         if Val.Rbase /= 0 then
+
+            return Store_Ureal
+                     ((Num      => Val.Num ** X,
+                       Den      => Val.Den * X,
+                       Rbase    => Val.Rbase,
+                       Negative => Neg));
+
+         --  And when the base is zero, in which case we exponentiate
+         --  the old denominator.
+
+         else
+            return Store_Ureal
+                     ((Num      => Val.Num ** X,
+                       Den      => Val.Den ** X,
+                       Rbase    => 0,
+                       Negative => Neg));
+         end if;
+      end if;
+   end UR_Exponentiate;
+
+   --------------
+   -- UR_Floor --
+   --------------
+
+   function UR_Floor (Real : Ureal) return Uint is
+      Val : constant Ureal_Entry := Normalize (Ureals.Table (Real));
+   begin
+      if Val.Negative then
+         return UI_Negate ((Val.Num + Val.Den - 1) / Val.Den);
+      else
+         return Val.Num / Val.Den;
+      end if;
+   end UR_Floor;
+
+   ------------------------
+   -- UR_From_Components --
+   ------------------------
+
+   function UR_From_Components
+     (Num      : Uint;
+      Den      : Uint;
+      Rbase    : Nat := 0;
+      Negative : Boolean := False)
+      return     Ureal
+   is
+   begin
+      return Store_Ureal
+               ((Num      => Num,
+                 Den      => Den,
+                 Rbase    => Rbase,
+                 Negative => Negative));
+   end UR_From_Components;
+
+   ------------------
+   -- UR_From_Uint --
+   ------------------
+
+   function UR_From_Uint (UI : Uint) return Ureal is
+   begin
+      return UR_From_Components
+               (abs UI, Uint_1, Negative => (UI < 0));
+   end UR_From_Uint;
+
+   -----------
+   -- UR_Ge --
+   -----------
+
+   function UR_Ge (Left, Right : Ureal) return Boolean is
+   begin
+      return not (Left < Right);
+   end UR_Ge;
+
+   -----------
+   -- UR_Gt --
+   -----------
+
+   function UR_Gt (Left, Right : Ureal) return Boolean is
+   begin
+      return (Right < Left);
+   end UR_Gt;
+
+   --------------------
+   -- UR_Is_Negative --
+   --------------------
+
+   function UR_Is_Negative (Real : Ureal) return Boolean is
+   begin
+      return Ureals.Table (Real).Negative;
+   end UR_Is_Negative;
+
+   --------------------
+   -- UR_Is_Positive --
+   --------------------
+
+   function UR_Is_Positive (Real : Ureal) return Boolean is
+   begin
+      return not Ureals.Table (Real).Negative
+        and then Ureals.Table (Real).Num /= 0;
+   end UR_Is_Positive;
+
+   ----------------
+   -- UR_Is_Zero --
+   ----------------
+
+   function UR_Is_Zero (Real : Ureal) return Boolean is
+   begin
+      return Ureals.Table (Real).Num = 0;
+   end UR_Is_Zero;
+
+   -----------
+   -- UR_Le --
+   -----------
+
+   function UR_Le (Left, Right : Ureal) return Boolean is
+   begin
+      return not (Right < Left);
+   end UR_Le;
+
+   -----------
+   -- UR_Lt --
+   -----------
+
+   function UR_Lt (Left, Right : Ureal) return Boolean is
+   begin
+      --  An operand is not less than itself
+
+      if Same (Left, Right) then
+         return False;
+
+      --  Deal with zero cases
+
+      elsif UR_Is_Zero (Left) then
+         return UR_Is_Positive (Right);
+
+      elsif UR_Is_Zero (Right) then
+         return Ureals.Table (Left).Negative;
+
+      --  Different signs are decisive (note we dealt with zero cases)
+
+      elsif Ureals.Table (Left).Negative
+        and then not Ureals.Table (Right).Negative
+      then
+         return True;
+
+      elsif not Ureals.Table (Left).Negative
+        and then Ureals.Table (Right).Negative
+      then
+         return False;
+
+      --  Signs are same, do rapid check based on worst case estimates of
+      --  decimal exponent, which will often be decisive. Precise test
+      --  depends on whether operands are positive or negative.
+
+      elsif Decimal_Exponent_Hi (Left) < Decimal_Exponent_Lo (Right) then
+         return UR_Is_Positive (Left);
+
+      elsif Decimal_Exponent_Lo (Left) > Decimal_Exponent_Hi (Right) then
+         return UR_Is_Negative (Left);
+
+      --  If we fall through, full gruesome test is required. This happens
+      --  if the numbers are close together, or in some weird (/=10) base.
+
+      else
+         declare
+            Imrk   : constant Uintp.Save_Mark  := Mark;
+            Rmrk   : constant Urealp.Save_Mark := Mark;
+            Lval   : Ureal_Entry;
+            Rval   : Ureal_Entry;
+            Result : Boolean;
+
+         begin
+            Lval := Ureals.Table (Left);
+            Rval := Ureals.Table (Right);
+
+            --  An optimization. If both numbers are based, then subtract
+            --  common value of base to avoid unnecessarily giant numbers
+
+            if Lval.Rbase = Rval.Rbase and then Lval.Rbase /= 0 then
+               if Lval.Den < Rval.Den then
+                  Rval.Den := Rval.Den - Lval.Den;
+                  Lval.Den := Uint_0;
+               else
+                  Lval.Den := Lval.Den - Rval.Den;
+                  Rval.Den := Uint_0;
+               end if;
+            end if;
+
+            Lval := Normalize (Lval);
+            Rval := Normalize (Rval);
+
+            if Lval.Negative then
+               Result := (Lval.Num * Rval.Den) > (Rval.Num * Lval.Den);
+            else
+               Result := (Lval.Num * Rval.Den) < (Rval.Num * Lval.Den);
+            end if;
+
+            Release (Imrk);
+            Release (Rmrk);
+            return Result;
+         end;
+      end if;
+   end UR_Lt;
+
+   ------------
+   -- UR_Max --
+   ------------
+
+   function UR_Max (Left, Right : Ureal) return Ureal is
+   begin
+      if Left >= Right then
+         return Left;
+      else
+         return Right;
+      end if;
+   end UR_Max;
+
+   ------------
+   -- UR_Min --
+   ------------
+
+   function UR_Min (Left, Right : Ureal) return Ureal is
+   begin
+      if Left <= Right then
+         return Left;
+      else
+         return Right;
+      end if;
+   end UR_Min;
+
+   ------------
+   -- UR_Mul --
+   ------------
+
+   function UR_Mul (Left : Uint; Right : Ureal) return Ureal is
+   begin
+      return UR_From_Uint (Left) * Right;
+   end UR_Mul;
+
+   function UR_Mul (Left : Ureal; Right : Uint) return Ureal is
+   begin
+      return Left * UR_From_Uint (Right);
+   end UR_Mul;
+
+   function UR_Mul (Left, Right : Ureal) return Ureal is
+      Lval : constant Ureal_Entry := Ureals.Table (Left);
+      Rval : constant Ureal_Entry := Ureals.Table (Right);
+      Num  : Uint                 := Lval.Num * Rval.Num;
+      Den  : Uint;
+      Rneg : constant Boolean     := Lval.Negative xor Rval.Negative;
+
+   begin
+      if Lval.Rbase = 0 then
+         if Rval.Rbase = 0 then
+            return Store_Ureal_Normalized
+                     ((Num      => Num,
+                       Den      => Lval.Den * Rval.Den,
+                       Rbase    => 0,
+                       Negative => Rneg));
+
+         elsif Is_Integer (Num, Lval.Den) then
+            return Store_Ureal
+                     ((Num      => Num / Lval.Den,
+                       Den      => Rval.Den,
+                       Rbase    => Rval.Rbase,
+                       Negative => Rneg));
+
+         elsif Rval.Den < 0 then
+            return Store_Ureal_Normalized
+                     ((Num      => Num * (Rval.Rbase ** (-Rval.Den)),
+                       Den      => Lval.Den,
+                       Rbase    => 0,
+                       Negative => Rneg));
+
+         else
+            return Store_Ureal_Normalized
+                     ((Num      => Num,
+                       Den      => Lval.Den * (Rval.Rbase ** Rval.Den),
+                       Rbase    => 0,
+                       Negative => Rneg));
+         end if;
+
+      elsif Lval.Rbase = Rval.Rbase then
+         return Store_Ureal
+                  ((Num      => Num,
+                    Den      => Lval.Den + Rval.Den,
+                    Rbase    => Lval.Rbase,
+                    Negative => Rneg));
+
+      elsif Rval.Rbase = 0 then
+         if Is_Integer (Num, Rval.Den) then
+            return Store_Ureal
+                     ((Num      => Num / Rval.Den,
+                       Den      => Lval.Den,
+                       Rbase    => Lval.Rbase,
+                       Negative => Rneg));
+
+         elsif Lval.Den < 0 then
+            return Store_Ureal_Normalized
+                     ((Num      => Num * (Lval.Rbase ** (-Lval.Den)),
+                       Den      => Rval.Den,
+                       Rbase    => 0,
+                       Negative => Rneg));
+
+         else
+            return Store_Ureal_Normalized
+                     ((Num      => Num,
+                       Den      => Rval.Den * (Lval.Rbase ** Lval.Den),
+                       Rbase    => 0,
+                       Negative => Rneg));
+         end if;
+
+      else
+         Den := Uint_1;
+
+         if Lval.Den < 0 then
+            Num := Num * (Lval.Rbase ** (-Lval.Den));
+         else
+            Den := Den * (Lval.Rbase ** Lval.Den);
+         end if;
+
+         if Rval.Den < 0 then
+            Num := Num * (Rval.Rbase ** (-Rval.Den));
+         else
+            Den := Den * (Rval.Rbase ** Rval.Den);
+         end if;
+
+         return Store_Ureal_Normalized
+                  ((Num      => Num,
+                    Den      => Den,
+                    Rbase    => 0,
+                    Negative => Rneg));
+      end if;
+   end UR_Mul;
+
+   -----------
+   -- UR_Ne --
+   -----------
+
+   function UR_Ne (Left, Right : Ureal) return Boolean is
+   begin
+      --  Quick processing for case of identical Ureal values (note that
+      --  this also deals with comparing two No_Ureal values).
+
+      if Same (Left, Right) then
+         return False;
+
+      --  Deal with case of one or other operand is No_Ureal, but not both
+
+      elsif Same (Left, No_Ureal) or else Same (Right, No_Ureal) then
+         return True;
+
+      --  Do quick check based on number of decimal digits
+
+      elsif Decimal_Exponent_Hi (Left) < Decimal_Exponent_Lo (Right) or else
+            Decimal_Exponent_Lo (Left) > Decimal_Exponent_Hi (Right)
+      then
+         return True;
+
+      --  Otherwise full comparison is required
+
+      else
+         declare
+            Imrk   : constant Uintp.Save_Mark  := Mark;
+            Rmrk   : constant Urealp.Save_Mark := Mark;
+            Lval   : constant Ureal_Entry := Normalize (Ureals.Table (Left));
+            Rval   : constant Ureal_Entry := Normalize (Ureals.Table (Right));
+            Result : Boolean;
+
+         begin
+            if UR_Is_Zero (Left) then
+               return not UR_Is_Zero (Right);
+
+            elsif UR_Is_Zero (Right) then
+               return not UR_Is_Zero (Left);
+
+            --  Both operands are non-zero
+
+            else
+               Result :=
+                  Rval.Negative /= Lval.Negative
+                    or else Rval.Num /= Lval.Num
+                    or else Rval.Den /= Lval.Den;
+               Release (Imrk);
+               Release (Rmrk);
+               return Result;
+            end if;
+         end;
+      end if;
+   end UR_Ne;
+
+   ---------------
+   -- UR_Negate --
+   ---------------
+
+   function UR_Negate (Real : Ureal) return Ureal is
+   begin
+      return Store_Ureal
+               ((Num      => Ureals.Table (Real).Num,
+                 Den      => Ureals.Table (Real).Den,
+                 Rbase    => Ureals.Table (Real).Rbase,
+                 Negative => not Ureals.Table (Real).Negative));
+   end UR_Negate;
+
+   ------------
+   -- UR_Sub --
+   ------------
+
+   function UR_Sub (Left : Uint; Right : Ureal) return Ureal is
+   begin
+      return UR_From_Uint (Left) + UR_Negate (Right);
+   end UR_Sub;
+
+   function UR_Sub (Left : Ureal; Right : Uint) return Ureal is
+   begin
+      return Left + UR_From_Uint (-Right);
+   end UR_Sub;
+
+   function UR_Sub (Left, Right : Ureal) return Ureal is
+   begin
+      return Left + UR_Negate (Right);
+   end UR_Sub;
+
+   ----------------
+   -- UR_To_Uint --
+   ----------------
+
+   function UR_To_Uint (Real : Ureal) return Uint is
+      Val : constant Ureal_Entry := Normalize (Ureals.Table (Real));
+      Res : Uint;
+
+   begin
+      Res := (Val.Num + (Val.Den / 2)) / Val.Den;
+
+      if Val.Negative then
+         return UI_Negate (Res);
+      else
+         return Res;
+      end if;
+   end UR_To_Uint;
+
+   --------------
+   -- UR_Trunc --
+   --------------
+
+   function UR_Trunc (Real : Ureal) return Uint is
+      Val : constant Ureal_Entry := Normalize (Ureals.Table (Real));
+   begin
+      if Val.Negative then
+         return -(Val.Num / Val.Den);
+      else
+         return Val.Num / Val.Den;
+      end if;
+   end UR_Trunc;
+
+   --------------
+   -- UR_Write --
+   --------------
+
+   procedure UR_Write (Real : Ureal; Brackets : Boolean := False) is
+      Val : constant Ureal_Entry := Ureals.Table (Real);
+      T   : Uint;
+
+   begin
+      --  If value is negative, we precede the constant by a minus sign
+
+      if Val.Negative then
+         Write_Char ('-');
+      end if;
+
+      --  Zero is zero
+
+      if Val.Num = 0 then
+         Write_Str ("0.0");
+
+      --  For constants with a denominator of zero, the value is simply the
+      --  numerator value, since we are dividing by base**0, which is 1.
+
+      elsif Val.Den = 0 then
+         UI_Write (Val.Num, Decimal);
+         Write_Str (".0");
+
+      --  Small powers of 2 get written in decimal fixed-point format
+
+      elsif Val.Rbase = 2
+        and then Val.Den <= 3
+        and then Val.Den >= -16
+      then
+         if Val.Den = 1 then
+            T := Val.Num * (10/2);
+            UI_Write (T / 10, Decimal);
+            Write_Char ('.');
+            UI_Write (T mod 10, Decimal);
+
+         elsif Val.Den = 2 then
+            T := Val.Num * (100/4);
+            UI_Write (T / 100, Decimal);
+            Write_Char ('.');
+            UI_Write (T mod 100 / 10, Decimal);
+
+            if T mod 10 /= 0 then
+               UI_Write (T mod 10, Decimal);
+            end if;
+
+         elsif Val.Den = 3 then
+            T := Val.Num * (1000 / 8);
+            UI_Write (T / 1000, Decimal);
+            Write_Char ('.');
+            UI_Write (T mod 1000 / 100, Decimal);
+
+            if T mod 100 /= 0 then
+               UI_Write (T mod 100 / 10, Decimal);
+
+               if T mod 10 /= 0 then
+                  UI_Write (T mod 10, Decimal);
+               end if;
+            end if;
+
+         else
+            UI_Write (Val.Num * (Uint_2 ** (-Val.Den)), Decimal);
+            Write_Str (".0");
+         end if;
+
+      --  Constants in base 10 or 16 can be written in normal Ada literal
+      --  style, as long as they fit in the UI_Image_Buffer. Using hexadecimal
+      --  notation, 4 bytes are required for the 16# # part, and every fifth
+      --  character is an underscore. So, a buffer of size N has room for
+      --     ((N - 4) - (N - 4) / 5) * 4 bits,
+      --  or at least
+      --     N * 16 / 5 - 12 bits.
+
+      elsif (Val.Rbase = 10 or else Val.Rbase = 16)
+        and then Num_Bits (Val.Num) < UI_Image_Buffer'Length * 16 / 5 - 12
+      then
+         pragma Assert (Val.Den /= 0);
+
+         --  Use fixed-point format for small scaling values
+
+         if (Val.Rbase = 10 and then Val.Den < 0 and then Val.Den > -3)
+              or else (Val.Rbase = 16 and then Val.Den = -1)
+         then
+            UI_Write (Val.Num * Val.Rbase**(-Val.Den), Decimal);
+            Write_Str (".0");
+
+         --  Write hexadecimal constants in exponential notation with a zero
+         --  unit digit. This matches the Ada canonical form for floating point
+         --  numbers, and also ensures that the underscores end up in the
+         --  correct place.
+
+         elsif Val.Rbase = 16 then
+            UI_Image (Val.Num, Hex);
+            pragma Assert (Val.Rbase = 16);
+
+            Write_Str ("16#0.");
+            Write_Str (UI_Image_Buffer (4 .. UI_Image_Length));
+
+            --  For exponent, exclude 16# # and underscores from length
+
+            UI_Image_Length := UI_Image_Length - 4;
+            UI_Image_Length := UI_Image_Length - UI_Image_Length / 5;
+
+            Write_Char ('E');
+            UI_Write (Int (UI_Image_Length) - Val.Den, Decimal);
+
+         elsif Val.Den = 1 then
+            UI_Write (Val.Num / 10, Decimal);
+            Write_Char ('.');
+            UI_Write (Val.Num mod 10, Decimal);
+
+         elsif Val.Den = 2 then
+            UI_Write (Val.Num / 100, Decimal);
+            Write_Char ('.');
+            UI_Write (Val.Num / 10 mod 10, Decimal);
+            UI_Write (Val.Num mod 10, Decimal);
+
+         --  Else use decimal exponential format
+
+         else
+            --  Write decimal constants with a non-zero unit digit. This
+            --  matches usual scientific notation.
+
+            UI_Image (Val.Num, Decimal);
+            Write_Char (UI_Image_Buffer (1));
+            Write_Char ('.');
+
+            if UI_Image_Length = 1 then
+               Write_Char ('0');
+            else
+               Write_Str (UI_Image_Buffer (2 .. UI_Image_Length));
+            end if;
+
+            Write_Char ('E');
+            UI_Write (Int (UI_Image_Length - 1) - Val.Den, Decimal);
+         end if;
+
+      --  Constants in a base other than 10 can still be easily written in
+      --  normal Ada literal style if the numerator is one.
+
+      elsif Val.Rbase /= 0 and then Val.Num = 1 then
+         Write_Int (Val.Rbase);
+         Write_Str ("#1.0#E");
+         UI_Write (-Val.Den);
+
+      --  Other constants with a base other than 10 are written using one
+      --  of the following forms, depending on the sign of the number
+      --  and the sign of the exponent (= minus denominator value)
+
+      --    numerator.0*base**exponent
+      --    numerator.0*base**-exponent
+
+      --  And of course an exponent of 0 can be omitted
+
+      elsif Val.Rbase /= 0 then
+         if Brackets then
+            Write_Char ('[');
+         end if;
+
+         UI_Write (Val.Num, Decimal);
+         Write_Str (".0");
+
+         if Val.Den /= 0 then
+            Write_Char ('*');
+            Write_Int (Val.Rbase);
+            Write_Str ("**");
+
+            if Val.Den <= 0 then
+               UI_Write (-Val.Den, Decimal);
+            else
+               Write_Str ("(-");
+               UI_Write (Val.Den, Decimal);
+               Write_Char (')');
+            end if;
+         end if;
+
+         if Brackets then
+            Write_Char (']');
+         end if;
+
+      --  Rationals where numerator is divisible by denominator can be output
+      --  as literals after we do the division. This includes the common case
+      --  where the denominator is 1.
+
+      elsif Val.Num mod Val.Den = 0 then
+         UI_Write (Val.Num / Val.Den, Decimal);
+         Write_Str (".0");
+
+      --  Other non-based (rational) constants are written in num/den style
+
+      else
+         if Brackets then
+            Write_Char ('[');
+         end if;
+
+         UI_Write (Val.Num, Decimal);
+         Write_Str (".0/");
+         UI_Write (Val.Den, Decimal);
+         Write_Str (".0");
+
+         if Brackets then
+            Write_Char (']');
+         end if;
+      end if;
+   end UR_Write;
+
+   -------------
+   -- Ureal_0 --
+   -------------
+
+   function Ureal_0 return Ureal is
+   begin
+      return UR_0;
+   end Ureal_0;
+
+   -------------
+   -- Ureal_1 --
+   -------------
+
+   function Ureal_1 return Ureal is
+   begin
+      return UR_1;
+   end Ureal_1;
+
+   -------------
+   -- Ureal_2 --
+   -------------
+
+   function Ureal_2 return Ureal is
+   begin
+      return UR_2;
+   end Ureal_2;
+
+   --------------
+   -- Ureal_10 --
+   --------------
+
+   function Ureal_10 return Ureal is
+   begin
+      return UR_10;
+   end Ureal_10;
+
+   ---------------
+   -- Ureal_100 --
+   ---------------
+
+   function Ureal_100 return Ureal is
+   begin
+      return UR_100;
+   end Ureal_100;
+
+   -----------------
+   -- Ureal_10_36 --
+   -----------------
+
+   function Ureal_10_36 return Ureal is
+   begin
+      return UR_10_36;
+   end Ureal_10_36;
+
+   ----------------
+   -- Ureal_2_80 --
+   ----------------
+
+   function Ureal_2_80 return Ureal is
+   begin
+      return UR_2_80;
+   end Ureal_2_80;
+
+   -----------------
+   -- Ureal_2_128 --
+   -----------------
+
+   function Ureal_2_128 return Ureal is
+   begin
+      return UR_2_128;
+   end Ureal_2_128;
+
+   -------------------
+   -- Ureal_2_M_80 --
+   -------------------
+
+   function Ureal_2_M_80 return Ureal is
+   begin
+      return UR_2_M_80;
+   end Ureal_2_M_80;
+
+   -------------------
+   -- Ureal_2_M_128 --
+   -------------------
+
+   function Ureal_2_M_128 return Ureal is
+   begin
+      return UR_2_M_128;
+   end Ureal_2_M_128;
+
+   ----------------
+   -- Ureal_Half --
+   ----------------
+
+   function Ureal_Half return Ureal is
+   begin
+      return UR_Half;
+   end Ureal_Half;
+
+   ---------------
+   -- Ureal_M_0 --
+   ---------------
+
+   function Ureal_M_0 return Ureal is
+   begin
+      return UR_M_0;
+   end Ureal_M_0;
+
+   -------------------
+   -- Ureal_M_10_36 --
+   -------------------
+
+   function Ureal_M_10_36 return Ureal is
+   begin
+      return UR_M_10_36;
+   end Ureal_M_10_36;
+
+   -----------------
+   -- Ureal_Tenth --
+   -----------------
+
+   function Ureal_Tenth return Ureal is
+   begin
+      return UR_Tenth;
+   end Ureal_Tenth;
+
+end Urealp;