1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 1992-2008, 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 2, 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. See the GNU General Public License --
17 -- for more details. You should have received a copy of the GNU General --
18 -- Public License distributed with GNAT; see file COPYING. If not, write --
19 -- to the Free Software Foundation, 51 Franklin Street, Fifth Floor, --
20 -- Boston, MA 02110-1301, USA. --
22 -- As a special exception, if other files instantiate generics from this --
23 -- unit, or you link this unit with other files to produce an executable, --
24 -- this unit does not by itself cause the resulting executable to be --
25 -- covered by the GNU General Public License. This exception does not --
26 -- however invalidate any other reasons why the executable file might be --
27 -- covered by the GNU Public License. --
29 -- GNAT was originally developed by the GNAT team at New York University. --
30 -- Extensive contributions were provided by Ada Core Technologies Inc. --
32 ------------------------------------------------------------------------------
34 -- Support for universal integer arithmetic
36 -- WARNING: There is a C version of this package. Any changes to this
37 -- source file must be properly reflected in the C header file sinfo.h
41 pragma Elaborate_All
(Table
);
42 with Types
; use Types
;
46 -------------------------------------------------
47 -- Basic Types and Constants for Uintp Package --
48 -------------------------------------------------
51 -- The basic universal integer type
53 No_Uint
: constant Uint
;
54 -- A constant value indicating a missing or unset Uint value
56 Uint_0
: constant Uint
;
57 Uint_1
: constant Uint
;
58 Uint_2
: constant Uint
;
59 Uint_3
: constant Uint
;
60 Uint_4
: constant Uint
;
61 Uint_5
: constant Uint
;
62 Uint_6
: constant Uint
;
63 Uint_7
: constant Uint
;
64 Uint_8
: constant Uint
;
65 Uint_9
: constant Uint
;
66 Uint_10
: constant Uint
;
67 Uint_11
: constant Uint
;
68 Uint_12
: constant Uint
;
69 Uint_13
: constant Uint
;
70 Uint_14
: constant Uint
;
71 Uint_15
: constant Uint
;
72 Uint_16
: constant Uint
;
73 Uint_24
: constant Uint
;
74 Uint_32
: constant Uint
;
75 Uint_63
: constant Uint
;
76 Uint_64
: constant Uint
;
77 Uint_80
: constant Uint
;
78 Uint_128
: constant Uint
;
80 Uint_Minus_1
: constant Uint
;
81 Uint_Minus_2
: constant Uint
;
82 Uint_Minus_3
: constant Uint
;
83 Uint_Minus_4
: constant Uint
;
84 Uint_Minus_5
: constant Uint
;
85 Uint_Minus_6
: constant Uint
;
86 Uint_Minus_7
: constant Uint
;
87 Uint_Minus_8
: constant Uint
;
88 Uint_Minus_9
: constant Uint
;
89 Uint_Minus_12
: constant Uint
;
90 Uint_Minus_36
: constant Uint
;
91 Uint_Minus_63
: constant Uint
;
92 Uint_Minus_80
: constant Uint
;
93 Uint_Minus_128
: constant Uint
;
100 -- Initialize Uint tables. Note that Initialize must not be called if
101 -- Tree_Read is used. Note also that there is no lock routine in this
102 -- unit, these are among the few tables that can be expanded during
106 -- Initializes internal tables from current tree file using the relevant
107 -- Table.Tree_Read routines. Note that Initialize should not be called if
108 -- Tree_Read is used. Tree_Read includes all necessary initialization.
110 procedure Tree_Write
;
111 -- Writes out internal tables to current tree file using the relevant
112 -- Table.Tree_Write routines.
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_Dint
(Input
: Dint
) return Uint
;
239 -- Converts Dint value to universal integer form
241 function UI_From_Int
(Input
: Int
) return Uint
;
242 -- Converts Int value to universal integer form
244 function UI_From_CC
(Input
: Char_Code
) return Uint
;
245 -- Converts Char_Code value to universal integer form
247 function UI_To_Int
(Input
: Uint
) return Int
;
248 -- Converts universal integer value to Int. Fatal error if value is not in
249 -- appropriate range.
251 function UI_To_CC
(Input
: Uint
) return Char_Code
;
252 -- Converts universal integer value to Char_Code. Fatal error if value is
253 -- not in Char_Code range.
255 function Num_Bits
(Input
: Uint
) return Nat
;
256 -- Approximate number of binary bits in given universal integer.
257 -- This function is used for capacity checks, and it can be one
258 -- bit off without affecting its usage.
260 ---------------------
261 -- Output Routines --
262 ---------------------
264 type UI_Format
is (Hex
, Decimal
, Auto
);
265 -- Used to determine whether UI_Image/UI_Write output is in hexadecimal
266 -- or decimal format. Auto, the default setting, lets the routine make
267 -- a decision based on the value.
269 UI_Image_Max
: constant := 32;
270 UI_Image_Buffer
: String (1 .. UI_Image_Max
);
271 UI_Image_Length
: Natural;
272 -- Buffer used for UI_Image as described below
274 procedure UI_Image
(Input
: Uint
; Format
: UI_Format
:= Auto
);
275 -- Places a representation of Uint, consisting of a possible minus sign,
276 -- followed by the value in UI_Image_Buffer. The form of the value is an
277 -- integer literal in either decimal (no base) or hexadecimal (base 16)
278 -- format. If Hex is True on entry, then hex mode is forced, otherwise
279 -- UI_Image makes a guess at which output format is more convenient. The
280 -- value must fit in UI_Image_Buffer. If necessary, the result is an
281 -- approximation of the proper value, using an exponential format. The
282 -- image of No_Uint is output as a single question mark.
284 procedure UI_Write
(Input
: Uint
; Format
: UI_Format
:= Auto
);
285 -- Writes a representation of Uint, consisting of a possible minus sign,
286 -- followed by the value to the output file. The form of the value is an
287 -- integer literal in either decimal (no base) or hexadecimal (base 16)
288 -- format as appropriate. UI_Format shows which format to use. Auto,
289 -- the default, asks UI_Write to make a guess at which output format
290 -- will be more convenient to read.
292 procedure pid
(Input
: Uint
);
293 pragma Export
(Ada
, pid
);
294 -- Writes representation of Uint in decimal with a terminating line
295 -- return. This is intended for use from the debugger.
297 procedure pih
(Input
: Uint
);
298 pragma Export
(Ada
, pih
);
299 -- Writes representation of Uint in hex with a terminating line return.
300 -- This is intended for use from the debugger.
302 ------------------------
303 -- Operator Renamings --
304 ------------------------
306 function "+" (Left
: Uint
; Right
: Uint
) return Uint
renames UI_Add
;
307 function "+" (Left
: Int
; Right
: Uint
) return Uint
renames UI_Add
;
308 function "+" (Left
: Uint
; Right
: Int
) return Uint
renames UI_Add
;
310 function "/" (Left
: Uint
; Right
: Uint
) return Uint
renames UI_Div
;
311 function "/" (Left
: Int
; Right
: Uint
) return Uint
renames UI_Div
;
312 function "/" (Left
: Uint
; Right
: Int
) return Uint
renames UI_Div
;
314 function "*" (Left
: Uint
; Right
: Uint
) return Uint
renames UI_Mul
;
315 function "*" (Left
: Int
; Right
: Uint
) return Uint
renames UI_Mul
;
316 function "*" (Left
: Uint
; Right
: Int
) return Uint
renames UI_Mul
;
318 function "-" (Left
: Uint
; Right
: Uint
) return Uint
renames UI_Sub
;
319 function "-" (Left
: Int
; Right
: Uint
) return Uint
renames UI_Sub
;
320 function "-" (Left
: Uint
; Right
: Int
) return Uint
renames UI_Sub
;
322 function "**" (Left
: Uint
; Right
: Uint
) return Uint
renames UI_Expon
;
323 function "**" (Left
: Uint
; Right
: Int
) return Uint
renames UI_Expon
;
324 function "**" (Left
: Int
; Right
: Uint
) return Uint
renames UI_Expon
;
325 function "**" (Left
: Int
; Right
: Int
) return Uint
renames UI_Expon
;
327 function "abs" (Real
: Uint
) return Uint
renames UI_Abs
;
329 function "mod" (Left
: Uint
; Right
: Uint
) return Uint
renames UI_Mod
;
330 function "mod" (Left
: Int
; Right
: Uint
) return Uint
renames UI_Mod
;
331 function "mod" (Left
: Uint
; Right
: Int
) return Uint
renames UI_Mod
;
333 function "rem" (Left
: Uint
; Right
: Uint
) return Uint
renames UI_Rem
;
334 function "rem" (Left
: Int
; Right
: Uint
) return Uint
renames UI_Rem
;
335 function "rem" (Left
: Uint
; Right
: Int
) return Uint
renames UI_Rem
;
337 function "-" (Real
: Uint
) return Uint
renames UI_Negate
;
339 function "=" (Left
: Uint
; Right
: Uint
) return Boolean renames UI_Eq
;
340 function "=" (Left
: Int
; Right
: Uint
) return Boolean renames UI_Eq
;
341 function "=" (Left
: Uint
; Right
: Int
) return Boolean renames UI_Eq
;
343 function ">=" (Left
: Uint
; Right
: Uint
) return Boolean renames UI_Ge
;
344 function ">=" (Left
: Int
; Right
: Uint
) return Boolean renames UI_Ge
;
345 function ">=" (Left
: Uint
; Right
: Int
) return Boolean renames UI_Ge
;
347 function ">" (Left
: Uint
; Right
: Uint
) return Boolean renames UI_Gt
;
348 function ">" (Left
: Int
; Right
: Uint
) return Boolean renames UI_Gt
;
349 function ">" (Left
: Uint
; Right
: Int
) return Boolean renames UI_Gt
;
351 function "<=" (Left
: Uint
; Right
: Uint
) return Boolean renames UI_Le
;
352 function "<=" (Left
: Int
; Right
: Uint
) return Boolean renames UI_Le
;
353 function "<=" (Left
: Uint
; Right
: Int
) return Boolean renames UI_Le
;
355 function "<" (Left
: Uint
; Right
: Uint
) return Boolean renames UI_Lt
;
356 function "<" (Left
: Int
; Right
: Uint
) return Boolean renames UI_Lt
;
357 function "<" (Left
: Uint
; Right
: Int
) return Boolean renames UI_Lt
;
359 -----------------------------
360 -- Mark/Release Processing --
361 -----------------------------
363 -- The space used by Uint data is not automatically reclaimed. However,
364 -- a mark-release regime is implemented which allows storage to be
365 -- released back to a previously noted mark. This is used for example
366 -- when doing comparisons, where only intermediate results get stored
367 -- that do not need to be saved for future use.
369 type Save_Mark
is private;
371 function Mark
return Save_Mark
;
372 -- Note mark point for future release
374 procedure Release
(M
: Save_Mark
);
375 -- Release storage allocated since mark was noted
377 procedure Release_And_Save
(M
: Save_Mark
; UI
: in out Uint
);
378 -- Like Release, except that the given Uint value (which is typically
379 -- among the data being released) is recopied after the release, so
380 -- that it is the most recent item, and UI is updated to point to
381 -- its copied location.
383 procedure Release_And_Save
(M
: Save_Mark
; UI1
, UI2
: in out Uint
);
384 -- Like Release, except that the given Uint values (which are typically
385 -- among the data being released) are recopied after the release, so
386 -- that they are the most recent items, and UI1 and UI2 are updated if
387 -- necessary to point to the copied locations. This routine is careful
388 -- to do things in the right order, so that the values do not clobber
391 -----------------------------------
392 -- Representation of Uint Values --
393 -----------------------------------
397 type Uint
is new Int
range Uint_Low_Bound
.. Uint_High_Bound
;
398 for Uint
'Size use 32;
400 No_Uint
: constant Uint
:= Uint
(Uint_Low_Bound
);
402 -- Uint values are represented as multiple precision integers stored in
403 -- a multi-digit format using Base as the base. This value is chosen so
404 -- that the product Base*Base is within the range of allowed Int values.
406 -- Base is defined to allow efficient execution of the primitive operations
407 -- (a0, b0, c0) defined in the section "The Classical Algorithms"
408 -- (sec. 4.3.1) of Donald Knuth's "The Art of Computer Programming",
409 -- Vol. 2. These algorithms are used in this package.
411 Base_Bits
: constant := 15;
412 -- Number of bits in base value
414 Base
: constant Int
:= 2 ** Base_Bits
;
416 -- Values in the range -(Base+1) .. Max_Direct are encoded directly as
417 -- Uint values by adding a bias value. The value of Max_Direct is chosen
418 -- so that a directly represented number always fits in two digits when
419 -- represented in base format.
421 Min_Direct
: constant Int
:= -(Base
- 1);
422 Max_Direct
: constant Int
:= (Base
- 1) * (Base
- 1);
424 -- The following values define the bias used to store Uint values which
425 -- are in this range, as well as the biased values for the first and last
426 -- values in this range. We use a new derived type for these constants to
427 -- avoid accidental use of Uint arithmetic on these values, which is never
430 type Ctrl
is range Int
'First .. Int
'Last;
432 Uint_Direct_Bias
: constant Ctrl
:= Ctrl
(Uint_Low_Bound
) + Ctrl
(Base
);
433 Uint_Direct_First
: constant Ctrl
:= Uint_Direct_Bias
+ Ctrl
(Min_Direct
);
434 Uint_Direct_Last
: constant Ctrl
:= Uint_Direct_Bias
+ Ctrl
(Max_Direct
);
436 Uint_0
: constant Uint
:= Uint
(Uint_Direct_Bias
);
437 Uint_1
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 1);
438 Uint_2
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 2);
439 Uint_3
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 3);
440 Uint_4
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 4);
441 Uint_5
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 5);
442 Uint_6
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 6);
443 Uint_7
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 7);
444 Uint_8
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 8);
445 Uint_9
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 9);
446 Uint_10
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 10);
447 Uint_11
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 11);
448 Uint_12
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 12);
449 Uint_13
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 13);
450 Uint_14
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 14);
451 Uint_15
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 15);
452 Uint_16
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 16);
453 Uint_24
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 24);
454 Uint_32
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 32);
455 Uint_63
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 63);
456 Uint_64
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 64);
457 Uint_80
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 80);
458 Uint_128
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 128);
460 Uint_Minus_1
: constant Uint
:= Uint
(Uint_Direct_Bias
- 1);
461 Uint_Minus_2
: constant Uint
:= Uint
(Uint_Direct_Bias
- 2);
462 Uint_Minus_3
: constant Uint
:= Uint
(Uint_Direct_Bias
- 3);
463 Uint_Minus_4
: constant Uint
:= Uint
(Uint_Direct_Bias
- 4);
464 Uint_Minus_5
: constant Uint
:= Uint
(Uint_Direct_Bias
- 5);
465 Uint_Minus_6
: constant Uint
:= Uint
(Uint_Direct_Bias
- 6);
466 Uint_Minus_7
: constant Uint
:= Uint
(Uint_Direct_Bias
- 7);
467 Uint_Minus_8
: constant Uint
:= Uint
(Uint_Direct_Bias
- 8);
468 Uint_Minus_9
: constant Uint
:= Uint
(Uint_Direct_Bias
- 9);
469 Uint_Minus_12
: constant Uint
:= Uint
(Uint_Direct_Bias
- 12);
470 Uint_Minus_36
: constant Uint
:= Uint
(Uint_Direct_Bias
- 36);
471 Uint_Minus_63
: constant Uint
:= Uint
(Uint_Direct_Bias
- 63);
472 Uint_Minus_80
: constant Uint
:= Uint
(Uint_Direct_Bias
- 80);
473 Uint_Minus_128
: constant Uint
:= Uint
(Uint_Direct_Bias
- 128);
475 type Save_Mark
is record
480 -- Values outside the range that is represented directly are stored using
481 -- two tables. The secondary table Udigits contains sequences of Int values
482 -- consisting of the digits of the number in a radix Base system. The
483 -- digits are stored from most significant to least significant with the
484 -- first digit only carrying the sign.
486 -- There is one entry in the primary Uints table for each distinct Uint
487 -- value. This table entry contains the length (number of digits) and
488 -- a starting offset of the value in the Udigits table.
490 Uint_First_Entry
: constant Uint
:= Uint
(Uint_Table_Start
);
492 -- Some subprograms defined in this package manipulate the Udigits table
493 -- directly, while for others it is more convenient to work with locally
494 -- defined arrays of the digits of the Universal Integers. The type
495 -- UI_Vector is defined for this purpose and some internal subprograms
496 -- used for converting from one to the other are defined.
498 type UI_Vector
is array (Pos
range <>) of Int
;
499 -- Vector containing the integer values of a Uint value
501 -- Note: An earlier version of this package used pointers of arrays
502 -- of Ints (dynamically allocated) for the Uint type. The change
503 -- leads to a few less natural idioms used throughout this code, but
504 -- eliminates all uses of the heap except for the table package itself.
505 -- For example, Uint parameters are often converted to UI_Vectors for
506 -- internal manipulation. This is done by creating the local UI_Vector
507 -- using the function N_Digits on the Uint to find the size needed for
508 -- the vector, and then calling Init_Operand to copy the values out
509 -- of the table into the vector.
511 type Uint_Entry
is record
513 -- Length of entry in Udigits table in digits (i.e. in words)
516 -- Starting location in Udigits table of this Uint value
519 package Uints
is new Table
.Table
(
520 Table_Component_Type
=> Uint_Entry
,
521 Table_Index_Type
=> Uint
'Base,
522 Table_Low_Bound
=> Uint_First_Entry
,
523 Table_Initial
=> Alloc
.Uints_Initial
,
524 Table_Increment
=> Alloc
.Uints_Increment
,
525 Table_Name
=> "Uints");
527 package Udigits
is new Table
.Table
(
528 Table_Component_Type
=> Int
,
529 Table_Index_Type
=> Int
,
530 Table_Low_Bound
=> 0,
531 Table_Initial
=> Alloc
.Udigits_Initial
,
532 Table_Increment
=> Alloc
.Udigits_Increment
,
533 Table_Name
=> "Udigits");
535 -- Note: the reason these tables are defined here in the private part of
536 -- the spec, rather than in the body, is that they are referenced directly