blob: 1b408fc4f4600454e18fe30c8b6d9bcfa0ff473e [file] [log] [blame]
------------------------------------------------------------------------------
-- --
-- GNAT COMPILER COMPONENTS --
-- --
-- U I N T P --
-- --
-- S p e c --
-- --
-- Copyright (C) 1992-2022, 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. See the GNU General Public License --
-- for more details. You should have received a copy of the GNU General --
-- Public License distributed with GNAT; see file COPYING3. If not, go to --
-- http://www.gnu.org/licenses for a complete copy of the license. --
-- --
-- GNAT was originally developed by the GNAT team at New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc. --
-- --
------------------------------------------------------------------------------
-- Support for universal integer arithmetic
-- WARNING: There is a C version of this package. Any changes to this
-- source file must be properly reflected in the C header file uintp.h
with Alloc;
with Table;
pragma Elaborate_All (Table);
with Types; use Types;
package Uintp is
-------------------------------------------------
-- Basic Types and Constants for Uintp Package --
-------------------------------------------------
type Uint is private;
-- The basic universal integer type
No_Uint : constant Uint;
-- A constant value indicating a missing or unset Uint value
Uint_0 : constant Uint;
Uint_1 : constant Uint;
Uint_2 : constant Uint;
Uint_3 : constant Uint;
Uint_4 : constant Uint;
Uint_5 : constant Uint;
Uint_6 : constant Uint;
Uint_7 : constant Uint;
Uint_8 : constant Uint;
Uint_9 : constant Uint;
Uint_10 : constant Uint;
Uint_11 : constant Uint;
Uint_12 : constant Uint;
Uint_13 : constant Uint;
Uint_14 : constant Uint;
Uint_15 : constant Uint;
Uint_16 : constant Uint;
Uint_24 : constant Uint;
Uint_31 : constant Uint;
Uint_32 : constant Uint;
Uint_63 : constant Uint;
Uint_64 : constant Uint;
Uint_80 : constant Uint;
Uint_127 : constant Uint;
Uint_128 : constant Uint;
Uint_256 : constant Uint;
Uint_Minus_1 : constant Uint;
Uint_Minus_2 : constant Uint;
Uint_Minus_3 : constant Uint;
Uint_Minus_4 : constant Uint;
Uint_Minus_5 : constant Uint;
Uint_Minus_6 : constant Uint;
Uint_Minus_7 : constant Uint;
Uint_Minus_8 : constant Uint;
Uint_Minus_9 : constant Uint;
Uint_Minus_12 : constant Uint;
Uint_Minus_18 : constant Uint;
Uint_Minus_31 : constant Uint;
Uint_Minus_36 : constant Uint;
Uint_Minus_63 : constant Uint;
Uint_Minus_76 : constant Uint;
Uint_Minus_80 : constant Uint;
Uint_Minus_127 : constant Uint;
Uint_Minus_128 : constant Uint;
-- Functions for detecting No_Uint. Note that clients of this package
-- cannot use "=" and "/=" to compare with No_Uint; they must use No
-- and Present instead.
function No (X : Uint) return Boolean is (X = No_Uint);
-- Note that this is using the predefined "=", not the "=" declared below,
-- which would blow up on No_Uint.
function Present (X : Uint) return Boolean is (not No (X));
subtype Valid_Uint is Uint with Predicate => Present (Valid_Uint);
subtype Unat is Valid_Uint with Predicate => Unat >= Uint_0; -- natural
subtype Upos is Valid_Uint with Predicate => Upos >= Uint_1; -- positive
subtype Nonzero_Uint is Valid_Uint with Predicate => Nonzero_Uint /= Uint_0;
subtype Unegative is Valid_Uint with Predicate => Unegative < Uint_0;
subtype Ubool is Valid_Uint with
Predicate => Ubool = Uint_0 or else Ubool = Uint_1;
subtype Opt_Ubool is Uint with
Predicate => No (Opt_Ubool) or else Opt_Ubool in Ubool;
-----------------
-- Subprograms --
-----------------
procedure Initialize;
-- Initialize Uint tables. Note also that there is no lock routine in this
-- unit, these are among the few tables that can be expanded during
-- gigi processing.
function UI_Abs (Right : Valid_Uint) return Unat;
pragma Inline (UI_Abs);
-- Returns abs function of universal integer
function UI_Add (Left : Valid_Uint; Right : Valid_Uint) return Valid_Uint;
function UI_Add (Left : Int; Right : Valid_Uint) return Valid_Uint;
function UI_Add (Left : Valid_Uint; Right : Int) return Valid_Uint;
-- Returns sum of two integer values
function UI_Decimal_Digits_Hi (U : Valid_Uint) return Nat;
-- Returns an estimate of the number of decimal digits required to
-- represent the absolute value of U. This estimate is correct or high,
-- i.e. it never returns a value that is too low. The accuracy of the
-- estimate affects only the effectiveness of comparison optimizations
-- in Urealp.
function UI_Decimal_Digits_Lo (U : Valid_Uint) return Nat;
-- Returns an estimate of the number of decimal digits required to
-- represent the absolute value of U. This estimate is correct or low,
-- i.e. it never returns a value that is too high. The accuracy of the
-- estimate affects only the effectiveness of comparison optimizations
-- in Urealp.
function UI_Div (Left : Valid_Uint; Right : Nonzero_Uint) return Valid_Uint;
function UI_Div (Left : Int; Right : Nonzero_Uint) return Valid_Uint;
function UI_Div (Left : Valid_Uint; Right : Nonzero_Int) return Valid_Uint;
-- Returns quotient of two integer values. Fatal error if Right = 0
function UI_Eq (Left : Valid_Uint; Right : Valid_Uint) return Boolean;
function UI_Eq (Left : Int; Right : Valid_Uint) return Boolean;
function UI_Eq (Left : Valid_Uint; Right : Int) return Boolean;
pragma Inline (UI_Eq);
-- Compares integer values for equality
function UI_Expon (Left : Valid_Uint; Right : Unat) return Valid_Uint;
function UI_Expon (Left : Int; Right : Unat) return Valid_Uint;
function UI_Expon (Left : Valid_Uint; Right : Nat) return Valid_Uint;
function UI_Expon (Left : Int; Right : Nat) return Valid_Uint;
-- Returns result of exponentiating two integer values.
-- Fatal error if Right is negative.
function UI_GCD (Uin, Vin : Valid_Uint) return Valid_Uint;
-- Computes GCD of input values. Assumes Uin >= Vin >= 0
function UI_Ge (Left : Valid_Uint; Right : Valid_Uint) return Boolean;
function UI_Ge (Left : Int; Right : Valid_Uint) return Boolean;
function UI_Ge (Left : Valid_Uint; Right : Int) return Boolean;
pragma Inline (UI_Ge);
-- Compares integer values for greater than or equal
function UI_Gt (Left : Valid_Uint; Right : Valid_Uint) return Boolean;
function UI_Gt (Left : Int; Right : Valid_Uint) return Boolean;
function UI_Gt (Left : Valid_Uint; Right : Int) return Boolean;
pragma Inline (UI_Gt);
-- Compares integer values for greater than
function UI_Is_In_Int_Range (Input : Valid_Uint) return Boolean;
pragma Inline (UI_Is_In_Int_Range);
-- Determines if universal integer is in Int range.
function UI_Le (Left : Valid_Uint; Right : Valid_Uint) return Boolean;
function UI_Le (Left : Int; Right : Valid_Uint) return Boolean;
function UI_Le (Left : Valid_Uint; Right : Int) return Boolean;
pragma Inline (UI_Le);
-- Compares integer values for less than or equal
function UI_Lt (Left : Valid_Uint; Right : Valid_Uint) return Boolean;
function UI_Lt (Left : Int; Right : Valid_Uint) return Boolean;
function UI_Lt (Left : Valid_Uint; Right : Int) return Boolean;
-- Compares integer values for less than
function UI_Max (Left : Valid_Uint; Right : Valid_Uint) return Valid_Uint;
function UI_Max (Left : Int; Right : Valid_Uint) return Valid_Uint;
function UI_Max (Left : Valid_Uint; Right : Int) return Valid_Uint;
-- Returns maximum of two integer values
function UI_Min (Left : Valid_Uint; Right : Valid_Uint) return Valid_Uint;
function UI_Min (Left : Int; Right : Valid_Uint) return Valid_Uint;
function UI_Min (Left : Valid_Uint; Right : Int) return Valid_Uint;
-- Returns minimum of two integer values
function UI_Mod (Left : Valid_Uint; Right : Nonzero_Uint) return Valid_Uint;
function UI_Mod (Left : Int; Right : Nonzero_Uint) return Valid_Uint;
function UI_Mod (Left : Valid_Uint; Right : Nonzero_Int) return Valid_Uint;
pragma Inline (UI_Mod);
-- Returns mod function of two integer values
function UI_Mul (Left : Valid_Uint; Right : Valid_Uint) return Valid_Uint;
function UI_Mul (Left : Int; Right : Valid_Uint) return Valid_Uint;
function UI_Mul (Left : Valid_Uint; Right : Int) return Valid_Uint;
-- Returns product of two integer values
function UI_Ne (Left : Valid_Uint; Right : Valid_Uint) return Boolean;
function UI_Ne (Left : Int; Right : Valid_Uint) return Boolean;
function UI_Ne (Left : Valid_Uint; Right : Int) return Boolean;
pragma Inline (UI_Ne);
-- Compares integer values for inequality
function UI_Negate (Right : Valid_Uint) return Valid_Uint;
pragma Inline (UI_Negate);
-- Returns negative of universal integer
function UI_Rem (Left : Valid_Uint; Right : Nonzero_Uint) return Valid_Uint;
function UI_Rem (Left : Int; Right : Nonzero_Uint) return Valid_Uint;
function UI_Rem (Left : Valid_Uint; Right : Nonzero_Int) return Valid_Uint;
-- Returns rem of two integer values
function UI_Sub (Left : Valid_Uint; Right : Valid_Uint) return Valid_Uint;
function UI_Sub (Left : Int; Right : Valid_Uint) return Valid_Uint;
function UI_Sub (Left : Valid_Uint; Right : Int) return Valid_Uint;
pragma Inline (UI_Sub);
-- Returns difference of two integer values
function UI_From_Int (Input : Int) return Valid_Uint;
-- Converts Int value to universal integer form
generic
type In_T is range <>;
function UI_From_Integral (Input : In_T) return Valid_Uint;
-- Likewise, but converts from any integer type. Must not be applied to
-- biased types (instantiation will provide a warning if actual is a biased
-- type).
function UI_From_CC (Input : Char_Code) return Valid_Uint;
-- Converts Char_Code value to universal integer form
function UI_To_Int (Input : Valid_Uint) return Int;
-- Converts universal integer value to Int. Constraint_Error if value is
-- not in appropriate range.
type Unsigned_64 is mod 2**64;
function UI_To_Unsigned_64 (Input : Valid_Uint) return Unsigned_64;
-- Converts universal integer value to Unsigned_64. Constraint_Error if
-- value is not in appropriate range.
function UI_To_CC (Input : Valid_Uint) return Char_Code;
-- Converts universal integer value to Char_Code. Constraint_Error if value
-- is not in Char_Code range.
function Num_Bits (Input : Valid_Uint) return Nat;
-- Approximate number of binary bits in given universal integer. This
-- function is used for capacity checks, and it can be one bit off
-- without affecting its usage.
---------------------
-- Output Routines --
---------------------
type UI_Format is (Hex, Decimal, Auto);
-- Used to determine whether UI_Image/UI_Write output is in hexadecimal
-- or decimal format. Auto, the default setting, lets the routine make a
-- decision based on the value.
UI_Image_Max : constant := 1024;
UI_Image_Buffer : String (1 .. UI_Image_Max);
UI_Image_Length : Natural;
-- Buffer used for UI_Image as described below
procedure UI_Image (Input : Uint; Format : UI_Format := Auto);
-- Places a representation of Uint, consisting of a possible minus sign,
-- followed by the value in UI_Image_Buffer. The form of the value is an
-- integer literal in either decimal (no base) or hexadecimal (base 16)
-- format. If Hex is True on entry, then hex mode is forced, otherwise
-- UI_Image makes a guess at which output format is more convenient. The
-- value must fit in UI_Image_Buffer. The actual length of the result is
-- returned in UI_Image_Length. If necessary to meet this requirement, the
-- result is an approximation of the proper value, using an exponential
-- format. The image of No_Uint is output as a single question mark.
function UI_Image (Input : Uint; Format : UI_Format := Auto) return String;
-- Functional form, in which the result is returned as a string. This call
-- also leaves the result in UI_Image_Buffer/Length as described above.
procedure UI_Write (Input : Uint; Format : UI_Format := Auto);
-- Writes a representation of Uint, consisting of a possible minus sign,
-- followed by the value to the output file. The form of the value is an
-- integer literal in either decimal (no base) or hexadecimal (base 16)
-- format as appropriate. UI_Format shows which format to use. Auto, the
-- default, asks UI_Write to make a guess at which output format will be
-- more convenient to read.
procedure pid (Input : Uint);
pragma Export (Ada, pid);
-- Writes representation of Uint in decimal with a terminating line
-- return. This is intended for use from the debugger.
procedure pih (Input : Uint);
pragma Export (Ada, pih);
-- Writes representation of Uint in hex with a terminating line return.
-- This is intended for use from the debugger.
------------------------
-- Operator Renamings --
------------------------
function "+" (Left : Valid_Uint; Right : Valid_Uint) return Valid_Uint
renames UI_Add;
function "+" (Left : Int; Right : Valid_Uint) return Valid_Uint
renames UI_Add;
function "+" (Left : Valid_Uint; Right : Int) return Valid_Uint
renames UI_Add;
function "/" (Left : Valid_Uint; Right : Nonzero_Uint) return Valid_Uint
renames UI_Div;
function "/" (Left : Int; Right : Nonzero_Uint) return Valid_Uint
renames UI_Div;
function "/" (Left : Valid_Uint; Right : Nonzero_Int) return Valid_Uint
renames UI_Div;
function "*" (Left : Valid_Uint; Right : Valid_Uint) return Valid_Uint
renames UI_Mul;
function "*" (Left : Int; Right : Valid_Uint) return Valid_Uint
renames UI_Mul;
function "*" (Left : Valid_Uint; Right : Int) return Valid_Uint
renames UI_Mul;
function "-" (Left : Valid_Uint; Right : Valid_Uint) return Valid_Uint
renames UI_Sub;
function "-" (Left : Int; Right : Valid_Uint) return Valid_Uint
renames UI_Sub;
function "-" (Left : Valid_Uint; Right : Int) return Valid_Uint
renames UI_Sub;
function "**" (Left : Valid_Uint; Right : Unat) return Valid_Uint
renames UI_Expon;
function "**" (Left : Valid_Uint; Right : Nat) return Valid_Uint
renames UI_Expon;
function "**" (Left : Int; Right : Unat) return Valid_Uint
renames UI_Expon;
function "**" (Left : Int; Right : Nat) return Valid_Uint
renames UI_Expon;
function "abs" (Real : Valid_Uint) return Unat
renames UI_Abs;
function "mod" (Left : Valid_Uint; Right : Nonzero_Uint) return Valid_Uint
renames UI_Mod;
function "mod" (Left : Int; Right : Nonzero_Uint) return Valid_Uint
renames UI_Mod;
function "mod" (Left : Valid_Uint; Right : Nonzero_Int) return Valid_Uint
renames UI_Mod;
function "rem" (Left : Valid_Uint; Right : Nonzero_Uint) return Valid_Uint
renames UI_Rem;
function "rem" (Left : Int; Right : Nonzero_Uint) return Valid_Uint
renames UI_Rem;
function "rem" (Left : Valid_Uint; Right : Nonzero_Int) return Valid_Uint
renames UI_Rem;
function "-" (Real : Valid_Uint) return Valid_Uint
renames UI_Negate;
function "=" (Left : Valid_Uint; Right : Valid_Uint) return Boolean
renames UI_Eq;
function "=" (Left : Int; Right : Valid_Uint) return Boolean
renames UI_Eq;
function "=" (Left : Valid_Uint; Right : Int) return Boolean
renames UI_Eq;
function ">=" (Left : Valid_Uint; Right : Valid_Uint) return Boolean
renames UI_Ge;
function ">=" (Left : Int; Right : Valid_Uint) return Boolean
renames UI_Ge;
function ">=" (Left : Valid_Uint; Right : Int) return Boolean
renames UI_Ge;
function ">" (Left : Valid_Uint; Right : Valid_Uint) return Boolean
renames UI_Gt;
function ">" (Left : Int; Right : Valid_Uint) return Boolean
renames UI_Gt;
function ">" (Left : Valid_Uint; Right : Int) return Boolean
renames UI_Gt;
function "<=" (Left : Valid_Uint; Right : Valid_Uint) return Boolean
renames UI_Le;
function "<=" (Left : Int; Right : Valid_Uint) return Boolean
renames UI_Le;
function "<=" (Left : Valid_Uint; Right : Int) return Boolean
renames UI_Le;
function "<" (Left : Valid_Uint; Right : Valid_Uint) return Boolean
renames UI_Lt;
function "<" (Left : Int; Right : Valid_Uint) return Boolean
renames UI_Lt;
function "<" (Left : Valid_Uint; Right : Int) return Boolean
renames UI_Lt;
-----------------------------
-- Mark/Release Processing --
-----------------------------
-- The space used by Uint data is not automatically reclaimed. However, a
-- mark-release regime is implemented which allows storage to be released
-- back to a previously noted mark. This is used for example when doing
-- comparisons, where only intermediate results get stored that do not
-- need to be saved for future use.
type Save_Mark is private;
function Mark return Save_Mark;
-- Note mark point for future release
procedure Release (M : Save_Mark);
-- Release storage allocated since mark was noted
procedure Release_And_Save (M : Save_Mark; UI : in out Valid_Uint);
-- Like Release, except that the given Uint value (which is typically among
-- the data being released) is recopied after the release, so that it is
-- the most recent item, and UI is updated to point to its copied location.
procedure Release_And_Save (M : Save_Mark; UI1, UI2 : in out Valid_Uint);
-- Like Release, except that the given Uint values (which are typically
-- among the data being released) are recopied after the release, so that
-- they are the most recent items, and UI1 and UI2 are updated if necessary
-- to point to the copied locations. This routine is careful to do things
-- in the right order, so that the values do not clobber one another.
-----------------------------------
-- Representation of Uint Values --
-----------------------------------
private
type Uint is new Int range Uint_Low_Bound .. Uint_High_Bound;
for Uint'Size use 32;
No_Uint : constant Uint := Uint (Uint_Low_Bound);
-- Uint values are represented as multiple precision integers stored in
-- a multi-digit format using Base as the base. This value is chosen so
-- that the product Base*Base is within the range of allowed Int values.
-- Base is defined to allow efficient execution of the primitive operations
-- (a0, b0, c0) defined in the section "The Classical Algorithms"
-- (sec. 4.3.1) of Donald Knuth's "The Art of Computer Programming",
-- Vol. 2. These algorithms are used in this package. In particular,
-- the product of two single digits in this base fits in a 32-bit integer.
Base_Bits : constant := 15;
-- Number of bits in base value
Base : constant Int := 2**Base_Bits;
-- Values in the range -(Base-1) .. Max_Direct are encoded directly as
-- Uint values by adding a bias value. The value of Max_Direct is chosen
-- so that a directly represented number always fits in two digits when
-- represented in base format.
Min_Direct : constant Int := -(Base - 1);
Max_Direct : constant Int := (Base - 1) * (Base - 1);
-- The following values define the bias used to store Uint values which
-- are in this range, as well as the biased values for the first and last
-- values in this range. We use a new derived type for these constants to
-- avoid accidental use of Uint arithmetic on these values, which is never
-- correct.
type Ctrl is new Int;
Uint_Direct_Bias : constant Ctrl := Ctrl (Uint_Low_Bound) + Ctrl (Base);
Uint_Direct_First : constant Ctrl := Uint_Direct_Bias + Ctrl (Min_Direct);
Uint_Direct_Last : constant Ctrl := Uint_Direct_Bias + Ctrl (Max_Direct);
Uint_0 : constant Uint := Uint (Uint_Direct_Bias + 0);
Uint_1 : constant Uint := Uint (Uint_Direct_Bias + 1);
Uint_2 : constant Uint := Uint (Uint_Direct_Bias + 2);
Uint_3 : constant Uint := Uint (Uint_Direct_Bias + 3);
Uint_4 : constant Uint := Uint (Uint_Direct_Bias + 4);
Uint_5 : constant Uint := Uint (Uint_Direct_Bias + 5);
Uint_6 : constant Uint := Uint (Uint_Direct_Bias + 6);
Uint_7 : constant Uint := Uint (Uint_Direct_Bias + 7);
Uint_8 : constant Uint := Uint (Uint_Direct_Bias + 8);
Uint_9 : constant Uint := Uint (Uint_Direct_Bias + 9);
Uint_10 : constant Uint := Uint (Uint_Direct_Bias + 10);
Uint_11 : constant Uint := Uint (Uint_Direct_Bias + 11);
Uint_12 : constant Uint := Uint (Uint_Direct_Bias + 12);
Uint_13 : constant Uint := Uint (Uint_Direct_Bias + 13);
Uint_14 : constant Uint := Uint (Uint_Direct_Bias + 14);
Uint_15 : constant Uint := Uint (Uint_Direct_Bias + 15);
Uint_16 : constant Uint := Uint (Uint_Direct_Bias + 16);
Uint_24 : constant Uint := Uint (Uint_Direct_Bias + 24);
Uint_31 : constant Uint := Uint (Uint_Direct_Bias + 31);
Uint_32 : constant Uint := Uint (Uint_Direct_Bias + 32);
Uint_63 : constant Uint := Uint (Uint_Direct_Bias + 63);
Uint_64 : constant Uint := Uint (Uint_Direct_Bias + 64);
Uint_80 : constant Uint := Uint (Uint_Direct_Bias + 80);
Uint_127 : constant Uint := Uint (Uint_Direct_Bias + 127);
Uint_128 : constant Uint := Uint (Uint_Direct_Bias + 128);
Uint_256 : constant Uint := Uint (Uint_Direct_Bias + 256);
Uint_Minus_1 : constant Uint := Uint (Uint_Direct_Bias - 1);
Uint_Minus_2 : constant Uint := Uint (Uint_Direct_Bias - 2);
Uint_Minus_3 : constant Uint := Uint (Uint_Direct_Bias - 3);
Uint_Minus_4 : constant Uint := Uint (Uint_Direct_Bias - 4);
Uint_Minus_5 : constant Uint := Uint (Uint_Direct_Bias - 5);
Uint_Minus_6 : constant Uint := Uint (Uint_Direct_Bias - 6);
Uint_Minus_7 : constant Uint := Uint (Uint_Direct_Bias - 7);
Uint_Minus_8 : constant Uint := Uint (Uint_Direct_Bias - 8);
Uint_Minus_9 : constant Uint := Uint (Uint_Direct_Bias - 9);
Uint_Minus_12 : constant Uint := Uint (Uint_Direct_Bias - 12);
Uint_Minus_18 : constant Uint := Uint (Uint_Direct_Bias - 18);
Uint_Minus_31 : constant Uint := Uint (Uint_Direct_Bias - 31);
Uint_Minus_36 : constant Uint := Uint (Uint_Direct_Bias - 36);
Uint_Minus_63 : constant Uint := Uint (Uint_Direct_Bias - 63);
Uint_Minus_76 : constant Uint := Uint (Uint_Direct_Bias - 76);
Uint_Minus_80 : constant Uint := Uint (Uint_Direct_Bias - 80);
Uint_Minus_127 : constant Uint := Uint (Uint_Direct_Bias - 127);
Uint_Minus_128 : constant Uint := Uint (Uint_Direct_Bias - 128);
Uint_Max_Simple_Mul : constant := Uint_Direct_Bias + 2**15;
-- If two values are directly represented and less than or equal to this
-- value, then we know the product fits in a 32-bit integer. This allows
-- UI_Mul to efficiently compute the product in this case.
type Save_Mark is record
Save_Uint : Valid_Uint;
Save_Udigit : Int;
end record;
-- Values outside the range that is represented directly are stored using
-- two tables. The secondary table Udigits contains sequences of Int values
-- consisting of the digits of the number in a radix Base system. The
-- digits are stored from most significant to least significant with the
-- first digit only carrying the sign.
-- There is one entry in the primary Uints table for each distinct Uint
-- value. This table entry contains the length (number of digits) and
-- a starting offset of the value in the Udigits table.
Uint_First_Entry : constant Uint := Uint (Uint_Table_Start);
-- Some subprograms defined in this package manipulate the Udigits table
-- directly, while for others it is more convenient to work with locally
-- defined arrays of the digits of the Universal Integers. The type
-- UI_Vector is declared in the package body for this purpose and some
-- internal subprograms used for converting from one to the other are
-- defined.
type Uint_Entry is record
Length : aliased Pos;
-- Length of entry in Udigits table in digits (i.e. in words)
Loc : aliased Int;
-- Starting location in Udigits table of this Uint value
end record;
package Uints is new Table.Table (
Table_Component_Type => Uint_Entry,
Table_Index_Type => Uint'Base,
Table_Low_Bound => Uint_First_Entry,
Table_Initial => Alloc.Uints_Initial,
Table_Increment => Alloc.Uints_Increment,
Table_Name => "Uints");
package Udigits is new Table.Table (
Table_Component_Type => Int,
Table_Index_Type => Int,
Table_Low_Bound => 0,
Table_Initial => Alloc.Udigits_Initial,
Table_Increment => Alloc.Udigits_Increment,
Table_Name => "Udigits");
-- Note: the reason these tables are defined here in the private part of
-- the spec, rather than in the body, is that they are referenced directly
-- by gigi.
end Uintp;