1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
10 -- Copyright (C) 1992-2002, Free Software Foundation, Inc. --
12 -- GNAT is free software; you can redistribute it and/or modify it under --
13 -- terms of the GNU General Public License as published by the Free Soft- --
14 -- ware Foundation; either version 2, or (at your option) any later ver- --
15 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
16 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
17 -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
18 -- for more details. You should have received a copy of the GNU General --
19 -- Public License distributed with GNAT; see file COPYING. If not, write --
20 -- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
21 -- MA 02111-1307, USA. --
23 -- As a special exception, if other files instantiate generics from this --
24 -- unit, or you link this unit with other files to produce an executable, --
25 -- this unit does not by itself cause the resulting executable to be --
26 -- covered by the GNU General Public License. This exception does not --
27 -- however invalidate any other reasons why the executable file might be --
28 -- covered by the GNU Public License. --
30 -- GNAT was originally developed by the GNAT team at New York University. --
31 -- Extensive contributions were provided by Ada Core Technologies Inc. --
33 ------------------------------------------------------------------------------
35 -- Support for universal integer arithmetic
37 -- WARNING: There is a C version of this package. Any changes to this
38 -- source file must be properly reflected in the C header file sinfo.h
42 pragma Elaborate_All
(Table
);
43 with Types
; use Types
;
47 -------------------------------------------------
48 -- Basic Types and Constants for Uintp Package --
49 -------------------------------------------------
52 -- The basic universal integer type
54 No_Uint
: constant Uint
;
55 -- A constant value indicating a missing or unset Uint value
57 Uint_0
: constant Uint
;
58 Uint_1
: constant Uint
;
59 Uint_2
: constant Uint
;
60 Uint_3
: constant Uint
;
61 Uint_4
: constant Uint
;
62 Uint_5
: constant Uint
;
63 Uint_6
: constant Uint
;
64 Uint_7
: constant Uint
;
65 Uint_8
: constant Uint
;
66 Uint_9
: constant Uint
;
67 Uint_10
: constant Uint
;
68 Uint_12
: 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_128
: constant Uint
;
77 Uint_Minus_1
: constant Uint
;
78 Uint_Minus_2
: constant Uint
;
79 Uint_Minus_3
: constant Uint
;
80 Uint_Minus_4
: constant Uint
;
81 Uint_Minus_5
: constant Uint
;
82 Uint_Minus_6
: constant Uint
;
83 Uint_Minus_7
: constant Uint
;
84 Uint_Minus_8
: constant Uint
;
85 Uint_Minus_9
: constant Uint
;
86 Uint_Minus_12
: constant Uint
;
87 Uint_Minus_128
: constant Uint
;
94 -- Initialize Uint tables. Note that Initialize must not be called if
95 -- Tree_Read is used. Note also that there is no lock routine in this
96 -- unit, these are among the few tables that can be expanded during
100 -- Initializes internal tables from current tree file using Tree_Read.
101 -- Note that Initialize should not be called if Tree_Read is used.
102 -- Tree_Read includes all necessary initialization.
104 procedure Tree_Write
;
105 -- Writes out internal tables to current tree file using Tree_Write.
107 function UI_Abs
(Right
: Uint
) return Uint
;
108 pragma Inline
(UI_Abs
);
109 -- Returns abs function of universal integer.
111 function UI_Add
(Left
: Uint
; Right
: Uint
) return Uint
;
112 function UI_Add
(Left
: Int
; Right
: Uint
) return Uint
;
113 function UI_Add
(Left
: Uint
; Right
: Int
) return Uint
;
114 -- Returns sum of two integer values.
116 function UI_Decimal_Digits_Hi
(U
: Uint
) return Nat
;
117 -- Returns an estimate of the number of decimal digits required to
118 -- represent the absolute value of U. This estimate is correct or high,
119 -- i.e. it never returns a value that is too low. The accuracy of the
120 -- estimate affects only the effectiveness of comparison optimizations
123 function UI_Decimal_Digits_Lo
(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 low,
126 -- i.e. it never returns a value that is too high. The accuracy of the
127 -- estimate affects only the effectiveness of comparison optimizations
130 function UI_Div
(Left
: Uint
; Right
: Uint
) return Uint
;
131 function UI_Div
(Left
: Int
; Right
: Uint
) return Uint
;
132 function UI_Div
(Left
: Uint
; Right
: Int
) return Uint
;
133 -- Returns quotient of two integer values. Fatal error if Right = 0
135 function UI_Eq
(Left
: Uint
; Right
: Uint
) return Boolean;
136 function UI_Eq
(Left
: Int
; Right
: Uint
) return Boolean;
137 function UI_Eq
(Left
: Uint
; Right
: Int
) return Boolean;
138 pragma Inline
(UI_Eq
);
139 -- Compares integer values for equality.
141 function UI_Expon
(Left
: Uint
; Right
: Uint
) return Uint
;
142 function UI_Expon
(Left
: Int
; Right
: Uint
) return Uint
;
143 function UI_Expon
(Left
: Uint
; Right
: Int
) return Uint
;
144 function UI_Expon
(Left
: Int
; Right
: Int
) return Uint
;
145 -- Returns result of exponentiating two integer values
146 -- Fatal error if Right is negative.
148 function UI_GCD
(Uin
, Vin
: Uint
) return Uint
;
149 -- Computes GCD of input values. Assumes Uin >= Vin >= 0.
151 function UI_Ge
(Left
: Uint
; Right
: Uint
) return Boolean;
152 function UI_Ge
(Left
: Int
; Right
: Uint
) return Boolean;
153 function UI_Ge
(Left
: Uint
; Right
: Int
) return Boolean;
154 pragma Inline
(UI_Ge
);
155 -- Compares integer values for greater than or equal.
157 function UI_Gt
(Left
: Uint
; Right
: Uint
) return Boolean;
158 function UI_Gt
(Left
: Int
; Right
: Uint
) return Boolean;
159 function UI_Gt
(Left
: Uint
; Right
: Int
) return Boolean;
160 pragma Inline
(UI_Gt
);
161 -- Compares integer values for greater than.
163 function UI_Is_In_Int_Range
(Input
: Uint
) return Boolean;
164 pragma Inline
(UI_Is_In_Int_Range
);
165 -- Determines if universal integer is in Int range.
167 function UI_Le
(Left
: Uint
; Right
: Uint
) return Boolean;
168 function UI_Le
(Left
: Int
; Right
: Uint
) return Boolean;
169 function UI_Le
(Left
: Uint
; Right
: Int
) return Boolean;
170 pragma Inline
(UI_Le
);
171 -- Compares integer values for less than or equal.
173 function UI_Lt
(Left
: Uint
; Right
: Uint
) return Boolean;
174 function UI_Lt
(Left
: Int
; Right
: Uint
) return Boolean;
175 function UI_Lt
(Left
: Uint
; Right
: Int
) return Boolean;
176 -- Compares integer values for less than.
178 function UI_Max
(Left
: Uint
; Right
: Uint
) return Uint
;
179 function UI_Max
(Left
: Int
; Right
: Uint
) return Uint
;
180 function UI_Max
(Left
: Uint
; Right
: Int
) return Uint
;
181 -- Returns maximum of two integer values
183 function UI_Min
(Left
: Uint
; Right
: Uint
) return Uint
;
184 function UI_Min
(Left
: Int
; Right
: Uint
) return Uint
;
185 function UI_Min
(Left
: Uint
; Right
: Int
) return Uint
;
186 -- Returns minimum of two integer values.
188 function UI_Mod
(Left
: Uint
; Right
: Uint
) return Uint
;
189 function UI_Mod
(Left
: Int
; Right
: Uint
) return Uint
;
190 function UI_Mod
(Left
: Uint
; Right
: Int
) return Uint
;
191 pragma Inline
(UI_Mod
);
192 -- Returns mod function of two integer values.
194 function UI_Mul
(Left
: Uint
; Right
: Uint
) return Uint
;
195 function UI_Mul
(Left
: Int
; Right
: Uint
) return Uint
;
196 function UI_Mul
(Left
: Uint
; Right
: Int
) return Uint
;
197 -- Returns product of two integer values
199 function UI_Ne
(Left
: Uint
; Right
: Uint
) return Boolean;
200 function UI_Ne
(Left
: Int
; Right
: Uint
) return Boolean;
201 function UI_Ne
(Left
: Uint
; Right
: Int
) return Boolean;
202 pragma Inline
(UI_Ne
);
203 -- Compares integer values for inequality.
205 function UI_Negate
(Right
: Uint
) return Uint
;
206 pragma Inline
(UI_Negate
);
207 -- Returns negative of universal integer.
209 function UI_Rem
(Left
: Uint
; Right
: Uint
) return Uint
;
210 function UI_Rem
(Left
: Int
; Right
: Uint
) return Uint
;
211 function UI_Rem
(Left
: Uint
; Right
: Int
) return Uint
;
212 -- Returns rem of two integer values.
214 function UI_Sub
(Left
: Uint
; Right
: Uint
) return Uint
;
215 function UI_Sub
(Left
: Int
; Right
: Uint
) return Uint
;
216 function UI_Sub
(Left
: Uint
; Right
: Int
) return Uint
;
217 pragma Inline
(UI_Sub
);
218 -- Returns difference of two integer values
220 function UI_From_Dint
(Input
: Dint
) return Uint
;
221 -- Converts Dint value to universal integer form.
223 function UI_From_Int
(Input
: Int
) return Uint
;
224 -- Converts Int value to universal integer form.
226 function UI_To_Int
(Input
: Uint
) return Int
;
227 -- Converts universal integer value to Int. Fatal error
228 -- if value is not in appropriate range.
230 function Num_Bits
(Input
: Uint
) return Nat
;
231 -- Approximate number of binary bits in given universal integer.
232 -- This function is used for capacity checks, and it can be one
233 -- bit off without affecting its usage.
235 ---------------------
236 -- Output Routines --
237 ---------------------
239 type UI_Format
is (Hex
, Decimal
, Auto
);
240 -- Used to determine whether UI_Image/UI_Write output is in hexadecimal
241 -- or decimal format. Auto, the default setting, lets the routine make
242 -- a decision based on the value.
244 UI_Image_Max
: constant := 32;
245 UI_Image_Buffer
: String (1 .. UI_Image_Max
);
246 UI_Image_Length
: Natural;
247 -- Buffer used for UI_Image as described below
249 procedure UI_Image
(Input
: Uint
; Format
: UI_Format
:= Auto
);
250 -- Places a representation of Uint, consisting of a possible minus sign,
251 -- followed by the value in UI_Image_Buffer. The form of the value is an
252 -- integer literal in either decimal (no base) or hexadecimal (base 16)
253 -- format. If Hex is True on entry, then hex mode is forced, otherwise
254 -- UI_Image makes a guess at which output format is more convenient. The
255 -- value must fit in UI_Image_Buffer. If necessary, the result is an
256 -- approximation of the proper value, using an exponential format. The
257 -- image of No_Uint is output as a single question mark.
259 procedure UI_Write
(Input
: Uint
; Format
: UI_Format
:= Auto
);
260 -- Writes a representation of Uint, consisting of a possible minus sign,
261 -- followed by the value to the output file. The form of the value is an
262 -- integer literal in either decimal (no base) or hexadecimal (base 16)
263 -- format as appropriate. UI_Format shows which format to use. Auto,
264 -- the default, asks UI_Write to make a guess at which output format
265 -- will be more convenient to read.
267 procedure pid
(Input
: Uint
);
268 pragma Export
(Ada
, pid
);
269 -- Writes representation of Uint in decimal with a terminating line
270 -- return. This is intended for use from the debugger.
272 procedure pih
(Input
: Uint
);
273 pragma Export
(Ada
, pih
);
274 -- Writes representation of Uint in hex with a terminating line return.
275 -- This is intended for use from the debugger.
277 ------------------------
278 -- Operator Renamings --
279 ------------------------
281 function "+" (Left
: Uint
; Right
: Uint
) return Uint
renames UI_Add
;
282 function "+" (Left
: Int
; Right
: Uint
) return Uint
renames UI_Add
;
283 function "+" (Left
: Uint
; Right
: Int
) return Uint
renames UI_Add
;
285 function "/" (Left
: Uint
; Right
: Uint
) return Uint
renames UI_Div
;
286 function "/" (Left
: Int
; Right
: Uint
) return Uint
renames UI_Div
;
287 function "/" (Left
: Uint
; Right
: Int
) return Uint
renames UI_Div
;
289 function "*" (Left
: Uint
; Right
: Uint
) return Uint
renames UI_Mul
;
290 function "*" (Left
: Int
; Right
: Uint
) return Uint
renames UI_Mul
;
291 function "*" (Left
: Uint
; Right
: Int
) return Uint
renames UI_Mul
;
293 function "-" (Left
: Uint
; Right
: Uint
) return Uint
renames UI_Sub
;
294 function "-" (Left
: Int
; Right
: Uint
) return Uint
renames UI_Sub
;
295 function "-" (Left
: Uint
; Right
: Int
) return Uint
renames UI_Sub
;
297 function "**" (Left
: Uint
; Right
: Uint
) return Uint
renames UI_Expon
;
298 function "**" (Left
: Uint
; Right
: Int
) return Uint
renames UI_Expon
;
299 function "**" (Left
: Int
; Right
: Uint
) return Uint
renames UI_Expon
;
300 function "**" (Left
: Int
; Right
: Int
) return Uint
renames UI_Expon
;
302 function "abs" (Real
: Uint
) return Uint
renames UI_Abs
;
304 function "mod" (Left
: Uint
; Right
: Uint
) return Uint
renames UI_Mod
;
305 function "mod" (Left
: Int
; Right
: Uint
) return Uint
renames UI_Mod
;
306 function "mod" (Left
: Uint
; Right
: Int
) return Uint
renames UI_Mod
;
308 function "rem" (Left
: Uint
; Right
: Uint
) return Uint
renames UI_Rem
;
309 function "rem" (Left
: Int
; Right
: Uint
) return Uint
renames UI_Rem
;
310 function "rem" (Left
: Uint
; Right
: Int
) return Uint
renames UI_Rem
;
312 function "-" (Real
: Uint
) return Uint
renames UI_Negate
;
314 function "=" (Left
: Uint
; Right
: Uint
) return Boolean renames UI_Eq
;
315 function "=" (Left
: Int
; Right
: Uint
) return Boolean renames UI_Eq
;
316 function "=" (Left
: Uint
; Right
: Int
) return Boolean renames UI_Eq
;
318 function ">=" (Left
: Uint
; Right
: Uint
) return Boolean renames UI_Ge
;
319 function ">=" (Left
: Int
; Right
: Uint
) return Boolean renames UI_Ge
;
320 function ">=" (Left
: Uint
; Right
: Int
) return Boolean renames UI_Ge
;
322 function ">" (Left
: Uint
; Right
: Uint
) return Boolean renames UI_Gt
;
323 function ">" (Left
: Int
; Right
: Uint
) return Boolean renames UI_Gt
;
324 function ">" (Left
: Uint
; Right
: Int
) return Boolean renames UI_Gt
;
326 function "<=" (Left
: Uint
; Right
: Uint
) return Boolean renames UI_Le
;
327 function "<=" (Left
: Int
; Right
: Uint
) return Boolean renames UI_Le
;
328 function "<=" (Left
: Uint
; Right
: Int
) return Boolean renames UI_Le
;
330 function "<" (Left
: Uint
; Right
: Uint
) return Boolean renames UI_Lt
;
331 function "<" (Left
: Int
; Right
: Uint
) return Boolean renames UI_Lt
;
332 function "<" (Left
: Uint
; Right
: Int
) return Boolean renames UI_Lt
;
334 -----------------------------
335 -- Mark/Release Processing --
336 -----------------------------
338 -- The space used by Uint data is not automatically reclaimed. However,
339 -- a mark-release regime is implemented which allows storage to be
340 -- released back to a previously noted mark. This is used for example
341 -- when doing comparisons, where only intermediate results get stored
342 -- that do not need to be saved for future use.
344 type Save_Mark
is private;
346 function Mark
return Save_Mark
;
347 -- Note mark point for future release
349 procedure Release
(M
: Save_Mark
);
350 -- Release storage allocated since mark was noted
352 procedure Release_And_Save
(M
: Save_Mark
; UI
: in out Uint
);
353 -- Like Release, except that the given Uint value (which is typically
354 -- among the data being released) is recopied after the release, so
355 -- that it is the most recent item, and UI is updated to point to
356 -- its copied location.
358 procedure Release_And_Save
(M
: Save_Mark
; UI1
, UI2
: in out Uint
);
359 -- Like Release, except that the given Uint values (which are typically
360 -- among the data being released) are recopied after the release, so
361 -- that they are the most recent items, and UI1 and UI2 are updated if
362 -- necessary to point to the copied locations. This routine is careful
363 -- to do things in the right order, so that the values do not clobber
366 -----------------------------------
367 -- Representation of Uint Values --
368 -----------------------------------
372 type Uint
is new Int
range Uint_Low_Bound
.. Uint_High_Bound
;
373 for Uint
'Size use 32;
375 No_Uint
: constant Uint
:= Uint
(Uint_Low_Bound
);
377 -- Uint values are represented as multiple precision integers stored in
378 -- a multi-digit format using Base as the base. This value is chosen so
379 -- that the product Base*Base is within the range of allowed Int values.
381 -- Base is defined to allow efficient execution of the primitive
382 -- operations (a0, b0, c0) defined in the section "The Classical
383 -- Algorithms" (sec. 4.3.1) of Donald Knuth's "The Art of Computer
384 -- Programming", Vol. 2. These algorithms are used in this package.
386 Base_Bits
: constant := 15;
387 -- Number of bits in base value
389 Base
: constant Int
:= 2 ** Base_Bits
;
391 -- Values in the range -(Base+1) .. maxdirect are encoded directly as
392 -- Uint values by adding a bias value. The value of maxdirect is chosen
393 -- so that a directly represented number always fits in two digits when
394 -- represented in base format.
396 Min_Direct
: constant Int
:= -(Base
- 1);
397 Max_Direct
: constant Int
:= (Base
- 1) * (Base
- 1);
399 -- The following values define the bias used to store Uint values which
400 -- are in this range, as well as the biased values for the first and
401 -- last values in this range. We use a new derived type for these
402 -- constants to avoid accidental use of Uint arithmetic on these
403 -- values, which is never correct.
405 type Ctrl
is range Int
'First .. Int
'Last;
407 Uint_Direct_Bias
: constant Ctrl
:= Ctrl
(Uint_Low_Bound
) + Ctrl
(Base
);
408 Uint_Direct_First
: constant Ctrl
:= Uint_Direct_Bias
+ Ctrl
(Min_Direct
);
409 Uint_Direct_Last
: constant Ctrl
:= Uint_Direct_Bias
+ Ctrl
(Max_Direct
);
411 Uint_0
: constant Uint
:= Uint
(Uint_Direct_Bias
);
412 Uint_1
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 1);
413 Uint_2
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 2);
414 Uint_3
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 3);
415 Uint_4
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 4);
416 Uint_5
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 5);
417 Uint_6
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 6);
418 Uint_7
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 7);
419 Uint_8
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 8);
420 Uint_9
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 9);
421 Uint_10
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 10);
422 Uint_12
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 12);
423 Uint_15
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 15);
424 Uint_16
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 16);
425 Uint_24
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 24);
426 Uint_32
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 32);
427 Uint_63
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 63);
428 Uint_64
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 64);
429 Uint_128
: constant Uint
:= Uint
(Uint_Direct_Bias
+ 128);
431 Uint_Minus_1
: constant Uint
:= Uint
(Uint_Direct_Bias
- 1);
432 Uint_Minus_2
: constant Uint
:= Uint
(Uint_Direct_Bias
- 2);
433 Uint_Minus_3
: constant Uint
:= Uint
(Uint_Direct_Bias
- 3);
434 Uint_Minus_4
: constant Uint
:= Uint
(Uint_Direct_Bias
- 4);
435 Uint_Minus_5
: constant Uint
:= Uint
(Uint_Direct_Bias
- 5);
436 Uint_Minus_6
: constant Uint
:= Uint
(Uint_Direct_Bias
- 6);
437 Uint_Minus_7
: constant Uint
:= Uint
(Uint_Direct_Bias
- 7);
438 Uint_Minus_8
: constant Uint
:= Uint
(Uint_Direct_Bias
- 8);
439 Uint_Minus_9
: constant Uint
:= Uint
(Uint_Direct_Bias
- 9);
440 Uint_Minus_12
: constant Uint
:= Uint
(Uint_Direct_Bias
- 12);
441 Uint_Minus_128
: constant Uint
:= Uint
(Uint_Direct_Bias
- 128);
443 type Save_Mark
is record
448 -- Values outside the range that is represented directly are stored
449 -- using two tables. The secondary table Udigits contains sequences of
450 -- Int values consisting of the digits of the number in a radix Base
451 -- system. The digits are stored from most significant to least
452 -- significant with the first digit only carrying the sign.
454 -- There is one entry in the primary Uints table for each distinct Uint
455 -- value. This table entry contains the length (number of digits) and
456 -- a starting offset of the value in the Udigits table.
458 Uint_First_Entry
: constant Uint
:= Uint
(Uint_Table_Start
);
460 -- Some subprograms defined in this package manipulate the Udigits
461 -- table directly, while for others it is more convenient to work with
462 -- locally defined arrays of the digits of the Universal Integers.
463 -- The type UI_Vector is defined for this purpose and some internal
464 -- subprograms used for converting from one to the other are defined.
466 type UI_Vector
is array (Pos
range <>) of Int
;
467 -- Vector containing the integer values of a Uint value
469 -- Note: An earlier version of this package used pointers of arrays
470 -- of Ints (dynamically allocated) for the Uint type. The change
471 -- leads to a few less natural idioms used throughout this code, but
472 -- eliminates all uses of the heap except for the table package itself.
473 -- For example, Uint parameters are often converted to UI_Vectors for
474 -- internal manipulation. This is done by creating the local UI_Vector
475 -- using the function N_Digits on the Uint to find the size needed for
476 -- the vector, and then calling Init_Operand to copy the values out
477 -- of the table into the vector.
479 type Uint_Entry
is record
481 -- Length of entry in Udigits table in digits (i.e. in words)
484 -- Starting location in Udigits table of this Uint value
487 package Uints
is new Table
.Table
(
488 Table_Component_Type
=> Uint_Entry
,
489 Table_Index_Type
=> Uint
,
490 Table_Low_Bound
=> Uint_First_Entry
,
491 Table_Initial
=> Alloc
.Uints_Initial
,
492 Table_Increment
=> Alloc
.Uints_Increment
,
493 Table_Name
=> "Uints");
495 package Udigits
is new Table
.Table
(
496 Table_Component_Type
=> Int
,
497 Table_Index_Type
=> Int
,
498 Table_Low_Bound
=> 0,
499 Table_Initial
=> Alloc
.Udigits_Initial
,
500 Table_Increment
=> Alloc
.Udigits_Increment
,
501 Table_Name
=> "Udigits");
503 -- Note: the reason these tables are defined here in the private part of
504 -- the spec, rather than in the body, is that they are refrerenced