1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 1992-2020, Free Software Foundation, Inc. --
11 -- GNAT is free software; you can redistribute it and/or modify it under --
12 -- terms of the GNU General Public License as published by the Free Soft- --
13 -- ware Foundation; either version 3, or (at your option) any later ver- --
14 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
15 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
16 -- or FITNESS FOR A PARTICULAR PURPOSE. --
18 -- As a special exception under Section 7 of GPL version 3, you are granted --
19 -- additional permissions described in the GCC Runtime Library Exception, --
20 -- version 3.1, as published by the Free Software Foundation. --
22 -- You should have received a copy of the GNU General Public License and --
23 -- a copy of the GCC Runtime Library Exception along with this program; --
24 -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
25 -- <http://www.gnu.org/licenses/>. --
27 -- GNAT was originally developed by the GNAT team at New York University. --
28 -- Extensive contributions were provided by Ada Core Technologies Inc. --
30 ------------------------------------------------------------------------------
32 -- Support for universal integer arithmetic
34 -- WARNING: There is a C version of this package. Any changes to this
35 -- source file must be properly reflected in the C header file uintp.h
39 pragma Elaborate_All (Table);
40 with Types; use Types;
44 -------------------------------------------------
45 -- Basic Types and Constants for Uintp Package --
46 -------------------------------------------------
49 -- The basic universal integer type
51 No_Uint : constant Uint;
52 -- A constant value indicating a missing or unset Uint value
54 Uint_0 : constant Uint;
55 Uint_1 : constant Uint;
56 Uint_2 : constant Uint;
57 Uint_3 : constant Uint;
58 Uint_4 : constant Uint;
59 Uint_5 : constant Uint;
60 Uint_6 : constant Uint;
61 Uint_7 : constant Uint;
62 Uint_8 : constant Uint;
63 Uint_9 : constant Uint;
64 Uint_10 : constant Uint;
65 Uint_11 : constant Uint;
66 Uint_12 : constant Uint;
67 Uint_13 : constant Uint;
68 Uint_14 : constant Uint;
69 Uint_15 : constant Uint;
70 Uint_16 : constant Uint;
71 Uint_24 : constant Uint;
72 Uint_32 : constant Uint;
73 Uint_63 : constant Uint;
74 Uint_64 : constant Uint;
75 Uint_80 : constant Uint;
76 Uint_128 : constant Uint;
78 Uint_Minus_1 : constant Uint;
79 Uint_Minus_2 : constant Uint;
80 Uint_Minus_3 : constant Uint;
81 Uint_Minus_4 : constant Uint;
82 Uint_Minus_5 : constant Uint;
83 Uint_Minus_6 : constant Uint;
84 Uint_Minus_7 : constant Uint;
85 Uint_Minus_8 : constant Uint;
86 Uint_Minus_9 : constant Uint;
87 Uint_Minus_12 : constant Uint;
88 Uint_Minus_36 : constant Uint;
89 Uint_Minus_63 : constant Uint;
90 Uint_Minus_80 : constant Uint;
91 Uint_Minus_128 : constant Uint;
93 type UI_Vector is array (Pos range <>) of Int;
94 -- Vector containing the integer values of a Uint value
96 -- Note: An earlier version of this package used pointers of arrays of Ints
97 -- (dynamically allocated) for the Uint type. The change leads to a few
98 -- less natural idioms used throughout this code, but eliminates all uses
99 -- of the heap except for the table package itself. For example, Uint
100 -- parameters are often converted to UI_Vectors for internal manipulation.
101 -- This is done by creating the local UI_Vector using the function N_Digits
102 -- on the Uint to find the size needed for the vector, and then calling
103 -- Init_Operand to copy the values out of the table into the vector.
109 procedure Initialize;
110 -- Initialize Uint tables. Note also that there is no lock routine in this
111 -- unit, these are among the few tables that can be expanded during
114 function UI_Abs (Right : Uint) return Uint;
115 pragma Inline (UI_Abs);
116 -- Returns abs function of universal integer
118 function UI_Add (Left : Uint; Right : Uint) return Uint;
119 function UI_Add (Left : Int; Right : Uint) return Uint;
120 function UI_Add (Left : Uint; Right : Int) return Uint;
121 -- Returns sum of two integer values
123 function UI_Decimal_Digits_Hi (U : Uint) return Nat;
124 -- Returns an estimate of the number of decimal digits required to
125 -- represent the absolute value of U. This estimate is correct or high,
126 -- i.e. it never returns a value that is too low. The accuracy of the
127 -- estimate affects only the effectiveness of comparison optimizations
130 function UI_Decimal_Digits_Lo (U : Uint) return Nat;
131 -- Returns an estimate of the number of decimal digits required to
132 -- represent the absolute value of U. This estimate is correct or low,
133 -- i.e. it never returns a value that is too high. The accuracy of the
134 -- estimate affects only the effectiveness of comparison optimizations
137 function UI_Div (Left : Uint; Right : Uint) return Uint;
138 function UI_Div (Left : Int; Right : Uint) return Uint;
139 function UI_Div (Left : Uint; Right : Int) return Uint;
140 -- Returns quotient of two integer values. Fatal error if Right = 0
142 function UI_Eq (Left : Uint; Right : Uint) return Boolean;
143 function UI_Eq (Left : Int; Right : Uint) return Boolean;
144 function UI_Eq (Left : Uint; Right : Int) return Boolean;
145 pragma Inline (UI_Eq);
146 -- Compares integer values for equality
148 function UI_Expon (Left : Uint; Right : Uint) return Uint;
149 function UI_Expon (Left : Int; Right : Uint) return Uint;
150 function UI_Expon (Left : Uint; Right : Int) return Uint;
151 function UI_Expon (Left : Int; Right : Int) return Uint;
152 -- Returns result of exponentiating two integer values.
153 -- Fatal error if Right is negative.
155 function UI_GCD (Uin, Vin : Uint) return Uint;
156 -- Computes GCD of input values. Assumes Uin >= Vin >= 0
158 function UI_Ge (Left : Uint; Right : Uint) return Boolean;
159 function UI_Ge (Left : Int; Right : Uint) return Boolean;
160 function UI_Ge (Left : Uint; Right : Int) return Boolean;
161 pragma Inline (UI_Ge);
162 -- Compares integer values for greater than or equal
164 function UI_Gt (Left : Uint; Right : Uint) return Boolean;
165 function UI_Gt (Left : Int; Right : Uint) return Boolean;
166 function UI_Gt (Left : Uint; Right : Int) return Boolean;
167 pragma Inline (UI_Gt);
168 -- Compares integer values for greater than
170 function UI_Is_In_Int_Range (Input : Uint) return Boolean;
171 pragma Inline (UI_Is_In_Int_Range);
172 -- Determines if universal integer is in Int range
174 function UI_Le (Left : Uint; Right : Uint) return Boolean;
175 function UI_Le (Left : Int; Right : Uint) return Boolean;
176 function UI_Le (Left : Uint; Right : Int) return Boolean;
177 pragma Inline (UI_Le);
178 -- Compares integer values for less than or equal
180 function UI_Lt (Left : Uint; Right : Uint) return Boolean;
181 function UI_Lt (Left : Int; Right : Uint) return Boolean;
182 function UI_Lt (Left : Uint; Right : Int) return Boolean;
183 -- Compares integer values for less than
185 function UI_Max (Left : Uint; Right : Uint) return Uint;
186 function UI_Max (Left : Int; Right : Uint) return Uint;
187 function UI_Max (Left : Uint; Right : Int) return Uint;
188 -- Returns maximum of two integer values
190 function UI_Min (Left : Uint; Right : Uint) return Uint;
191 function UI_Min (Left : Int; Right : Uint) return Uint;
192 function UI_Min (Left : Uint; Right : Int) return Uint;
193 -- Returns minimum of two integer values
195 function UI_Mod (Left : Uint; Right : Uint) return Uint;
196 function UI_Mod (Left : Int; Right : Uint) return Uint;
197 function UI_Mod (Left : Uint; Right : Int) return Uint;
198 pragma Inline (UI_Mod);
199 -- Returns mod function of two integer values
201 function UI_Mul (Left : Uint; Right : Uint) return Uint;
202 function UI_Mul (Left : Int; Right : Uint) return Uint;
203 function UI_Mul (Left : Uint; Right : Int) return Uint;
204 -- Returns product of two integer values
206 function UI_Ne (Left : Uint; Right : Uint) return Boolean;
207 function UI_Ne (Left : Int; Right : Uint) return Boolean;
208 function UI_Ne (Left : Uint; Right : Int) return Boolean;
209 pragma Inline (UI_Ne);
210 -- Compares integer values for inequality
212 function UI_Negate (Right : Uint) return Uint;
213 pragma Inline (UI_Negate);
214 -- Returns negative of universal integer
216 function UI_Rem (Left : Uint; Right : Uint) return Uint;
217 function UI_Rem (Left : Int; Right : Uint) return Uint;
218 function UI_Rem (Left : Uint; Right : Int) return Uint;
219 -- Returns rem of two integer values
221 function UI_Sub (Left : Uint; Right : Uint) return Uint;
222 function UI_Sub (Left : Int; Right : Uint) return Uint;
223 function UI_Sub (Left : Uint; Right : Int) return Uint;
224 pragma Inline (UI_Sub);
225 -- Returns difference of two integer values
227 function UI_Modular_Exponentiation
230 Modulo : Uint) return Uint;
231 -- Efficiently compute (B**E) rem Modulo
233 function UI_Modular_Inverse (N : Uint; Modulo : Uint) return Uint;
234 -- Compute the multiplicative inverse of N in modular arithmetics with the
235 -- given Modulo (uses Euclid's algorithm). Note: the call is considered
236 -- to be erroneous (and the behavior is undefined) if n is not invertible.
238 function UI_From_Int (Input : Int) return Uint;
239 -- Converts Int value to universal integer form
242 type In_T is range <>;
243 function UI_From_Integral (Input : In_T) return Uint;
244 -- Likewise, but converts from any integer type. Must not be applied to
245 -- biased types (instantiation will provide a warning if actual is a biased
248 function UI_From_CC (Input : Char_Code) return Uint;
249 -- Converts Char_Code value to universal integer form
251 function UI_To_Int (Input : Uint) return Int;
252 -- Converts universal integer value to Int. Constraint_Error if value is
253 -- not in appropriate range.
255 function UI_To_CC (Input : Uint) return Char_Code;
256 -- Converts universal integer value to Char_Code. Constraint_Error if value
257 -- is not in Char_Code range.
259 function Num_Bits (Input : Uint) return Nat;
260 -- Approximate number of binary bits in given universal integer. This
261 -- function is used for capacity checks, and it can be one bit off
262 -- without affecting its usage.
264 function Vector_To_Uint
266 Negative : Boolean) return Uint;
267 -- Functions that calculate values in UI_Vectors, call this function to
268 -- create and return the Uint value. In_Vec contains the multiple precision
269 -- (Base) representation of a non-negative value. Leading zeroes are
270 -- permitted. Negative is set if the desired result is the negative of the
271 -- given value. The result will be either the appropriate directly
272 -- represented value, or a table entry in the proper canonical format is
273 -- created and returned.
275 -- Note that Init_Operand puts a signed value in the result vector, but
276 -- Vector_To_Uint is always presented with a non-negative value. The
277 -- processing of signs is something that is done by the caller before
278 -- calling Vector_To_Uint.
280 ---------------------
281 -- Output Routines --
282 ---------------------
284 type UI_Format is (Hex, Decimal, Auto);
285 -- Used to determine whether UI_Image/UI_Write output is in hexadecimal
286 -- or decimal format. Auto, the default setting, lets the routine make a
287 -- decision based on the value.
289 UI_Image_Max : constant := 48; -- Enough for a 128-bit number
290 UI_Image_Buffer : String (1 .. UI_Image_Max);
291 UI_Image_Length : Natural;
292 -- Buffer used for UI_Image as described below
294 procedure UI_Image (Input : Uint; Format : UI_Format := Auto);
295 -- Places a representation of Uint, consisting of a possible minus sign,
296 -- followed by the value in UI_Image_Buffer. The form of the value is an
297 -- integer literal in either decimal (no base) or hexadecimal (base 16)
298 -- format. If Hex is True on entry, then hex mode is forced, otherwise
299 -- UI_Image makes a guess at which output format is more convenient. The
300 -- value must fit in UI_Image_Buffer. The actual length of the result is
301 -- returned in UI_Image_Length. If necessary to meet this requirement, the
302 -- result is an approximation of the proper value, using an exponential
303 -- format. The image of No_Uint is output as a single question mark.
305 function UI_Image (Input : Uint; Format : UI_Format := Auto) return String;
306 -- Functional form, in which the result is returned as a string. This call
307 -- also leaves the result in UI_Image_Buffer/Length as described above.
309 procedure UI_Write (Input : Uint; Format : UI_Format := Auto);
310 -- Writes a representation of Uint, consisting of a possible minus sign,
311 -- followed by the value to the output file. The form of the value is an
312 -- integer literal in either decimal (no base) or hexadecimal (base 16)
313 -- format as appropriate. UI_Format shows which format to use. Auto, the
314 -- default, asks UI_Write to make a guess at which output format will be
315 -- more convenient to read.
317 procedure pid (Input : Uint);
318 pragma Export (Ada, pid);
319 -- Writes representation of Uint in decimal with a terminating line
320 -- return. This is intended for use from the debugger.
322 procedure pih (Input : Uint);
323 pragma Export (Ada, pih);
324 -- Writes representation of Uint in hex with a terminating line return.
325 -- This is intended for use from the debugger.
327 ------------------------
328 -- Operator Renamings --
329 ------------------------
331 function "+" (Left : Uint; Right : Uint) return Uint renames UI_Add;
332 function "+" (Left : Int; Right : Uint) return Uint renames UI_Add;
333 function "+" (Left : Uint; Right : Int) return Uint renames UI_Add;
335 function "/" (Left : Uint; Right : Uint) return Uint renames UI_Div;
336 function "/" (Left : Int; Right : Uint) return Uint renames UI_Div;
337 function "/" (Left : Uint; Right : Int) return Uint renames UI_Div;
339 function "*" (Left : Uint; Right : Uint) return Uint renames UI_Mul;
340 function "*" (Left : Int; Right : Uint) return Uint renames UI_Mul;
341 function "*" (Left : Uint; Right : Int) return Uint renames UI_Mul;
343 function "-" (Left : Uint; Right : Uint) return Uint renames UI_Sub;
344 function "-" (Left : Int; Right : Uint) return Uint renames UI_Sub;
345 function "-" (Left : Uint; Right : Int) return Uint renames UI_Sub;
347 function "**" (Left : Uint; Right : Uint) return Uint renames UI_Expon;
348 function "**" (Left : Uint; Right : Int) return Uint renames UI_Expon;
349 function "**" (Left : Int; Right : Uint) return Uint renames UI_Expon;
350 function "**" (Left : Int; Right : Int) return Uint renames UI_Expon;
352 function "abs" (Real : Uint) return Uint renames UI_Abs;
354 function "mod" (Left : Uint; Right : Uint) return Uint renames UI_Mod;
355 function "mod" (Left : Int; Right : Uint) return Uint renames UI_Mod;
356 function "mod" (Left : Uint; Right : Int) return Uint renames UI_Mod;
358 function "rem" (Left : Uint; Right : Uint) return Uint renames UI_Rem;
359 function "rem" (Left : Int; Right : Uint) return Uint renames UI_Rem;
360 function "rem" (Left : Uint; Right : Int) return Uint renames UI_Rem;
362 function "-" (Real : Uint) return Uint renames UI_Negate;
364 function "=" (Left : Uint; Right : Uint) return Boolean renames UI_Eq;
365 function "=" (Left : Int; Right : Uint) return Boolean renames UI_Eq;
366 function "=" (Left : Uint; Right : Int) return Boolean renames UI_Eq;
368 function ">=" (Left : Uint; Right : Uint) return Boolean renames UI_Ge;
369 function ">=" (Left : Int; Right : Uint) return Boolean renames UI_Ge;
370 function ">=" (Left : Uint; Right : Int) return Boolean renames UI_Ge;
372 function ">" (Left : Uint; Right : Uint) return Boolean renames UI_Gt;
373 function ">" (Left : Int; Right : Uint) return Boolean renames UI_Gt;
374 function ">" (Left : Uint; Right : Int) return Boolean renames UI_Gt;
376 function "<=" (Left : Uint; Right : Uint) return Boolean renames UI_Le;
377 function "<=" (Left : Int; Right : Uint) return Boolean renames UI_Le;
378 function "<=" (Left : Uint; Right : Int) return Boolean renames UI_Le;
380 function "<" (Left : Uint; Right : Uint) return Boolean renames UI_Lt;
381 function "<" (Left : Int; Right : Uint) return Boolean renames UI_Lt;
382 function "<" (Left : Uint; Right : Int) return Boolean renames UI_Lt;
384 -----------------------------
385 -- Mark/Release Processing --
386 -----------------------------
388 -- The space used by Uint data is not automatically reclaimed. However, a
389 -- mark-release regime is implemented which allows storage to be released
390 -- back to a previously noted mark. This is used for example when doing
391 -- comparisons, where only intermediate results get stored that do not
392 -- need to be saved for future use.
394 type Save_Mark is private;
396 function Mark return Save_Mark;
397 -- Note mark point for future release
399 procedure Release (M : Save_Mark);
400 -- Release storage allocated since mark was noted
402 procedure Release_And_Save (M : Save_Mark; UI : in out Uint);
403 -- Like Release, except that the given Uint value (which is typically among
404 -- the data being released) is recopied after the release, so that it is
405 -- the most recent item, and UI is updated to point to its copied location.
407 procedure Release_And_Save (M : Save_Mark; UI1, UI2 : in out Uint);
408 -- Like Release, except that the given Uint values (which are typically
409 -- among the data being released) are recopied after the release, so that
410 -- they are the most recent items, and UI1 and UI2 are updated if necessary
411 -- to point to the copied locations. This routine is careful to do things
412 -- in the right order, so that the values do not clobber one another.
414 -----------------------------------
415 -- Representation of Uint Values --
416 -----------------------------------
420 type Uint is new Int range Uint_Low_Bound .. Uint_High_Bound;
421 for Uint'Size use 32;
423 No_Uint : constant Uint := Uint (Uint_Low_Bound);
425 -- Uint values are represented as multiple precision integers stored in
426 -- a multi-digit format using Base as the base. This value is chosen so
427 -- that the product Base*Base is within the range of allowed Int values.
429 -- Base is defined to allow efficient execution of the primitive operations
430 -- (a0, b0, c0) defined in the section "The Classical Algorithms"
431 -- (sec. 4.3.1) of Donald Knuth's "The Art of Computer Programming",
432 -- Vol. 2. These algorithms are used in this package. In particular,
433 -- the product of two single digits in this base fits in a 32-bit integer.
435 Base_Bits : constant := 15;
436 -- Number of bits in base value
438 Base : constant Int := 2**Base_Bits;
440 -- Values in the range -(Base-1) .. Max_Direct are encoded directly as
441 -- Uint values by adding a bias value. The value of Max_Direct is chosen
442 -- so that a directly represented number always fits in two digits when
443 -- represented in base format.
445 Min_Direct : constant Int := -(Base - 1);
446 Max_Direct : constant Int := (Base - 1) * (Base - 1);
448 -- The following values define the bias used to store Uint values which
449 -- are in this range, as well as the biased values for the first and last
450 -- values in this range. We use a new derived type for these constants to
451 -- avoid accidental use of Uint arithmetic on these values, which is never
454 type Ctrl is new Int;
456 Uint_Direct_Bias : constant Ctrl := Ctrl (Uint_Low_Bound) + Ctrl (Base);
457 Uint_Direct_First : constant Ctrl := Uint_Direct_Bias + Ctrl (Min_Direct);
458 Uint_Direct_Last : constant Ctrl := Uint_Direct_Bias + Ctrl (Max_Direct);
460 Uint_0 : constant Uint := Uint (Uint_Direct_Bias + 0);
461 Uint_1 : constant Uint := Uint (Uint_Direct_Bias + 1);
462 Uint_2 : constant Uint := Uint (Uint_Direct_Bias + 2);
463 Uint_3 : constant Uint := Uint (Uint_Direct_Bias + 3);
464 Uint_4 : constant Uint := Uint (Uint_Direct_Bias + 4);
465 Uint_5 : constant Uint := Uint (Uint_Direct_Bias + 5);
466 Uint_6 : constant Uint := Uint (Uint_Direct_Bias + 6);
467 Uint_7 : constant Uint := Uint (Uint_Direct_Bias + 7);
468 Uint_8 : constant Uint := Uint (Uint_Direct_Bias + 8);
469 Uint_9 : constant Uint := Uint (Uint_Direct_Bias + 9);
470 Uint_10 : constant Uint := Uint (Uint_Direct_Bias + 10);
471 Uint_11 : constant Uint := Uint (Uint_Direct_Bias + 11);
472 Uint_12 : constant Uint := Uint (Uint_Direct_Bias + 12);
473 Uint_13 : constant Uint := Uint (Uint_Direct_Bias + 13);
474 Uint_14 : constant Uint := Uint (Uint_Direct_Bias + 14);
475 Uint_15 : constant Uint := Uint (Uint_Direct_Bias + 15);
476 Uint_16 : constant Uint := Uint (Uint_Direct_Bias + 16);
477 Uint_24 : constant Uint := Uint (Uint_Direct_Bias + 24);
478 Uint_32 : constant Uint := Uint (Uint_Direct_Bias + 32);
479 Uint_63 : constant Uint := Uint (Uint_Direct_Bias + 63);
480 Uint_64 : constant Uint := Uint (Uint_Direct_Bias + 64);
481 Uint_80 : constant Uint := Uint (Uint_Direct_Bias + 80);
482 Uint_128 : constant Uint := Uint (Uint_Direct_Bias + 128);
484 Uint_Minus_1 : constant Uint := Uint (Uint_Direct_Bias - 1);
485 Uint_Minus_2 : constant Uint := Uint (Uint_Direct_Bias - 2);
486 Uint_Minus_3 : constant Uint := Uint (Uint_Direct_Bias - 3);
487 Uint_Minus_4 : constant Uint := Uint (Uint_Direct_Bias - 4);
488 Uint_Minus_5 : constant Uint := Uint (Uint_Direct_Bias - 5);
489 Uint_Minus_6 : constant Uint := Uint (Uint_Direct_Bias - 6);
490 Uint_Minus_7 : constant Uint := Uint (Uint_Direct_Bias - 7);
491 Uint_Minus_8 : constant Uint := Uint (Uint_Direct_Bias - 8);
492 Uint_Minus_9 : constant Uint := Uint (Uint_Direct_Bias - 9);
493 Uint_Minus_12 : constant Uint := Uint (Uint_Direct_Bias - 12);
494 Uint_Minus_36 : constant Uint := Uint (Uint_Direct_Bias - 36);
495 Uint_Minus_63 : constant Uint := Uint (Uint_Direct_Bias - 63);
496 Uint_Minus_80 : constant Uint := Uint (Uint_Direct_Bias - 80);
497 Uint_Minus_128 : constant Uint := Uint (Uint_Direct_Bias - 128);
499 Uint_Max_Simple_Mul : constant := Uint_Direct_Bias + 2**15;
500 -- If two values are directly represented and less than or equal to this
501 -- value, then we know the product fits in a 32-bit integer. This allows
502 -- UI_Mul to efficiently compute the product in this case.
504 type Save_Mark is record
509 -- Values outside the range that is represented directly are stored using
510 -- two tables. The secondary table Udigits contains sequences of Int values
511 -- consisting of the digits of the number in a radix Base system. The
512 -- digits are stored from most significant to least significant with the
513 -- first digit only carrying the sign.
515 -- There is one entry in the primary Uints table for each distinct Uint
516 -- value. This table entry contains the length (number of digits) and
517 -- a starting offset of the value in the Udigits table.
519 Uint_First_Entry : constant Uint := Uint (Uint_Table_Start);
521 -- Some subprograms defined in this package manipulate the Udigits table
522 -- directly, while for others it is more convenient to work with locally
523 -- defined arrays of the digits of the Universal Integers. The type
524 -- UI_Vector is defined for this purpose and some internal subprograms
525 -- used for converting from one to the other are defined.
527 type Uint_Entry is record
529 -- Length of entry in Udigits table in digits (i.e. in words)
532 -- Starting location in Udigits table of this Uint value
535 package Uints is new Table.Table (
536 Table_Component_Type => Uint_Entry,
537 Table_Index_Type => Uint'Base,
538 Table_Low_Bound => Uint_First_Entry,
539 Table_Initial => Alloc.Uints_Initial,
540 Table_Increment => Alloc.Uints_Increment,
541 Table_Name => "Uints");
543 package Udigits is new Table.Table (
544 Table_Component_Type => Int,
545 Table_Index_Type => Int,
546 Table_Low_Bound => 0,
547 Table_Initial => Alloc.Udigits_Initial,
548 Table_Increment => Alloc.Udigits_Increment,
549 Table_Name => "Udigits");
551 -- Note: the reason these tables are defined here in the private part of
552 -- the spec, rather than in the body, is that they are referenced directly