1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
|
------------------------------------------------------------------------------
-- --
-- GNAT COMPILER COMPONENTS --
-- --
-- U I N T P --
-- --
-- S p e c --
-- --
-- Copyright (C) 1992-2021, 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_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 Ubool is Valid_Uint with Predicate => Ubool in Uint_0 | 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_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;
|