1------------------------------------------------------------------------------ 2-- -- 3-- GNAT COMPILER COMPONENTS -- 4-- -- 5-- U I N T P -- 6-- -- 7-- S p e c -- 8-- -- 9-- Copyright (C) 1992-2020, Free Software Foundation, Inc. -- 10-- -- 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. 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 COPYING3. If not, go to -- 19-- http://www.gnu.org/licenses for a complete copy of the license. -- 20-- -- 21-- GNAT was originally developed by the GNAT team at New York University. -- 22-- Extensive contributions were provided by Ada Core Technologies Inc. -- 23-- -- 24------------------------------------------------------------------------------ 25 26-- Support for universal integer arithmetic 27 28-- WARNING: There is a C version of this package. Any changes to this 29-- source file must be properly reflected in the C header file uintp.h 30 31with Alloc; 32with Table; 33pragma Elaborate_All (Table); 34with Types; use Types; 35 36package Uintp is 37 38 ------------------------------------------------- 39 -- Basic Types and Constants for Uintp Package -- 40 ------------------------------------------------- 41 42 type Uint is private; 43 -- The basic universal integer type 44 45 No_Uint : constant Uint; 46 -- A constant value indicating a missing or unset Uint value 47 48 Uint_0 : constant Uint; 49 Uint_1 : constant Uint; 50 Uint_2 : constant Uint; 51 Uint_3 : constant Uint; 52 Uint_4 : constant Uint; 53 Uint_5 : constant Uint; 54 Uint_6 : constant Uint; 55 Uint_7 : constant Uint; 56 Uint_8 : constant Uint; 57 Uint_9 : constant Uint; 58 Uint_10 : constant Uint; 59 Uint_11 : constant Uint; 60 Uint_12 : constant Uint; 61 Uint_13 : constant Uint; 62 Uint_14 : constant Uint; 63 Uint_15 : constant Uint; 64 Uint_16 : constant Uint; 65 Uint_24 : constant Uint; 66 Uint_31 : constant Uint; 67 Uint_32 : constant Uint; 68 Uint_63 : constant Uint; 69 Uint_64 : constant Uint; 70 Uint_80 : constant Uint; 71 Uint_127 : constant Uint; 72 Uint_128 : constant Uint; 73 74 Uint_Minus_1 : constant Uint; 75 Uint_Minus_2 : constant Uint; 76 Uint_Minus_3 : constant Uint; 77 Uint_Minus_4 : constant Uint; 78 Uint_Minus_5 : constant Uint; 79 Uint_Minus_6 : constant Uint; 80 Uint_Minus_7 : constant Uint; 81 Uint_Minus_8 : constant Uint; 82 Uint_Minus_9 : constant Uint; 83 Uint_Minus_12 : constant Uint; 84 Uint_Minus_18 : constant Uint; 85 Uint_Minus_31 : constant Uint; 86 Uint_Minus_36 : constant Uint; 87 Uint_Minus_63 : constant Uint; 88 Uint_Minus_76 : constant Uint; 89 Uint_Minus_80 : constant Uint; 90 Uint_Minus_127 : constant Uint; 91 Uint_Minus_128 : constant Uint; 92 93 type UI_Vector is array (Pos range <>) of Int; 94 -- Vector containing the integer values of a Uint value 95 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. 104 105 ----------------- 106 -- Subprograms -- 107 ----------------- 108 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 112 -- gigi processing. 113 114 function UI_Abs (Right : Uint) return Uint; 115 pragma Inline (UI_Abs); 116 -- Returns abs function of universal integer 117 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 122 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 128 -- in Urealp. 129 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 135 -- in Urealp. 136 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 141 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 147 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. 154 155 function UI_GCD (Uin, Vin : Uint) return Uint; 156 -- Computes GCD of input values. Assumes Uin >= Vin >= 0 157 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 163 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 169 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 173 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 179 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 184 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 189 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 194 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 200 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 205 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 211 212 function UI_Negate (Right : Uint) return Uint; 213 pragma Inline (UI_Negate); 214 -- Returns negative of universal integer 215 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 220 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 226 227 function UI_Modular_Exponentiation 228 (B : Uint; 229 E : Uint; 230 Modulo : Uint) return Uint; 231 -- Efficiently compute (B**E) rem Modulo 232 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. 237 238 function UI_From_Int (Input : Int) return Uint; 239 -- Converts Int value to universal integer form 240 241 generic 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 246 -- type). 247 248 function UI_From_CC (Input : Char_Code) return Uint; 249 -- Converts Char_Code value to universal integer form 250 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. 254 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. 258 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. 263 264 function Vector_To_Uint 265 (In_Vec : UI_Vector; 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. 274 -- 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. 279 280 --------------------- 281 -- Output Routines -- 282 --------------------- 283 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. 288 289 UI_Image_Max : constant := 1024; 290 UI_Image_Buffer : String (1 .. UI_Image_Max); 291 UI_Image_Length : Natural; 292 -- Buffer used for UI_Image as described below 293 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. 304 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. 308 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. 316 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. 321 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. 326 327 ------------------------ 328 -- Operator Renamings -- 329 ------------------------ 330 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; 334 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; 338 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; 342 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; 346 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; 351 352 function "abs" (Real : Uint) return Uint renames UI_Abs; 353 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; 357 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; 361 362 function "-" (Real : Uint) return Uint renames UI_Negate; 363 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; 367 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; 371 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; 375 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; 379 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; 383 384 ----------------------------- 385 -- Mark/Release Processing -- 386 ----------------------------- 387 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. 393 394 type Save_Mark is private; 395 396 function Mark return Save_Mark; 397 -- Note mark point for future release 398 399 procedure Release (M : Save_Mark); 400 -- Release storage allocated since mark was noted 401 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. 406 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. 413 414 ----------------------------------- 415 -- Representation of Uint Values -- 416 ----------------------------------- 417 418private 419 420 type Uint is new Int range Uint_Low_Bound .. Uint_High_Bound; 421 for Uint'Size use 32; 422 423 No_Uint : constant Uint := Uint (Uint_Low_Bound); 424 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. 428 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. 434 435 Base_Bits : constant := 15; 436 -- Number of bits in base value 437 438 Base : constant Int := 2**Base_Bits; 439 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. 444 445 Min_Direct : constant Int := -(Base - 1); 446 Max_Direct : constant Int := (Base - 1) * (Base - 1); 447 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 452 -- correct. 453 454 type Ctrl is new Int; 455 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); 459 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_31 : constant Uint := Uint (Uint_Direct_Bias + 31); 479 Uint_32 : constant Uint := Uint (Uint_Direct_Bias + 32); 480 Uint_63 : constant Uint := Uint (Uint_Direct_Bias + 63); 481 Uint_64 : constant Uint := Uint (Uint_Direct_Bias + 64); 482 Uint_80 : constant Uint := Uint (Uint_Direct_Bias + 80); 483 Uint_127 : constant Uint := Uint (Uint_Direct_Bias + 127); 484 Uint_128 : constant Uint := Uint (Uint_Direct_Bias + 128); 485 486 Uint_Minus_1 : constant Uint := Uint (Uint_Direct_Bias - 1); 487 Uint_Minus_2 : constant Uint := Uint (Uint_Direct_Bias - 2); 488 Uint_Minus_3 : constant Uint := Uint (Uint_Direct_Bias - 3); 489 Uint_Minus_4 : constant Uint := Uint (Uint_Direct_Bias - 4); 490 Uint_Minus_5 : constant Uint := Uint (Uint_Direct_Bias - 5); 491 Uint_Minus_6 : constant Uint := Uint (Uint_Direct_Bias - 6); 492 Uint_Minus_7 : constant Uint := Uint (Uint_Direct_Bias - 7); 493 Uint_Minus_8 : constant Uint := Uint (Uint_Direct_Bias - 8); 494 Uint_Minus_9 : constant Uint := Uint (Uint_Direct_Bias - 9); 495 Uint_Minus_12 : constant Uint := Uint (Uint_Direct_Bias - 12); 496 Uint_Minus_18 : constant Uint := Uint (Uint_Direct_Bias - 18); 497 Uint_Minus_31 : constant Uint := Uint (Uint_Direct_Bias - 31); 498 Uint_Minus_36 : constant Uint := Uint (Uint_Direct_Bias - 36); 499 Uint_Minus_63 : constant Uint := Uint (Uint_Direct_Bias - 63); 500 Uint_Minus_76 : constant Uint := Uint (Uint_Direct_Bias - 76); 501 Uint_Minus_80 : constant Uint := Uint (Uint_Direct_Bias - 80); 502 Uint_Minus_127 : constant Uint := Uint (Uint_Direct_Bias - 127); 503 Uint_Minus_128 : constant Uint := Uint (Uint_Direct_Bias - 128); 504 505 Uint_Max_Simple_Mul : constant := Uint_Direct_Bias + 2**15; 506 -- If two values are directly represented and less than or equal to this 507 -- value, then we know the product fits in a 32-bit integer. This allows 508 -- UI_Mul to efficiently compute the product in this case. 509 510 type Save_Mark is record 511 Save_Uint : Uint; 512 Save_Udigit : Int; 513 end record; 514 515 -- Values outside the range that is represented directly are stored using 516 -- two tables. The secondary table Udigits contains sequences of Int values 517 -- consisting of the digits of the number in a radix Base system. The 518 -- digits are stored from most significant to least significant with the 519 -- first digit only carrying the sign. 520 521 -- There is one entry in the primary Uints table for each distinct Uint 522 -- value. This table entry contains the length (number of digits) and 523 -- a starting offset of the value in the Udigits table. 524 525 Uint_First_Entry : constant Uint := Uint (Uint_Table_Start); 526 527 -- Some subprograms defined in this package manipulate the Udigits table 528 -- directly, while for others it is more convenient to work with locally 529 -- defined arrays of the digits of the Universal Integers. The type 530 -- UI_Vector is defined for this purpose and some internal subprograms 531 -- used for converting from one to the other are defined. 532 533 type Uint_Entry is record 534 Length : Pos; 535 -- Length of entry in Udigits table in digits (i.e. in words) 536 537 Loc : Int; 538 -- Starting location in Udigits table of this Uint value 539 end record; 540 541 package Uints is new Table.Table ( 542 Table_Component_Type => Uint_Entry, 543 Table_Index_Type => Uint'Base, 544 Table_Low_Bound => Uint_First_Entry, 545 Table_Initial => Alloc.Uints_Initial, 546 Table_Increment => Alloc.Uints_Increment, 547 Table_Name => "Uints"); 548 549 package Udigits is new Table.Table ( 550 Table_Component_Type => Int, 551 Table_Index_Type => Int, 552 Table_Low_Bound => 0, 553 Table_Initial => Alloc.Udigits_Initial, 554 Table_Increment => Alloc.Udigits_Increment, 555 Table_Name => "Udigits"); 556 557 -- Note: the reason these tables are defined here in the private part of 558 -- the spec, rather than in the body, is that they are referenced directly 559 -- by gigi. 560 561end Uintp; 562