Debian Codegraph @

gcc/ada/doc/gnat_rm/implementation_defined_characteristics.rst

raw
1 .. _Implementation_Defined_Characteristics:
2
3 **************************************
4 Implementation Defined Characteristics
5 **************************************
6
7 In addition to the implementation dependent pragmas and attributes, and the
8 implementation advice, there are a number of other Ada features that are
9 potentially implementation dependent and are designated as
10 implementation-defined. These are mentioned throughout the Ada Reference
11 Manual, and are summarized in Annex M.
12
13 A requirement for conforming Ada compilers is that they provide
14 documentation describing how the implementation deals with each of these
15 issues. In this chapter you will find each point in Annex M listed,
16 followed by a description of how GNAT handles the implementation dependence.
17
18 You can use this chapter as a guide to minimizing implementation
19 dependent features in your programs if portability to other compilers
20 and other operating systems is an important consideration. The numbers
21 in each entry below correspond to the paragraph numbers in the Ada
22 Reference Manual.
23
24 *
25 "Whether or not each recommendation given in Implementation
26 Advice is followed. See 1.1.2(37)."
27
28 See :ref:`Implementation_Advice`.
29
30 *
31 "Capacity limitations of the implementation. See 1.1.3(3)."
32
33 The complexity of programs that can be processed is limited only by the
34 total amount of available virtual memory, and disk space for the
35 generated object files.
36
37 *
38 "Variations from the standard that are impractical to avoid
39 given the implementation's execution environment. See 1.1.3(6)."
40
41 There are no variations from the standard.
42
43 *
44 "Which code_statements cause external
45 interactions. See 1.1.3(10)."
46
47 Any *code_statement* can potentially cause external interactions.
48
49 *
50 "The coded representation for the text of an Ada
51 program. See 2.1(4)."
52
53 See separate section on source representation.
54
55 *
56 "The semantics of an Ada program whose text is not in
57 Normalization Form C. See 2.1(4)."
58
59 See separate section on source representation.
60
61 *
62 "The representation for an end of line. See 2.2(2)."
63
64 See separate section on source representation.
65
66 *
67 "Maximum supported line length and lexical element
68 length. See 2.2(15)."
69
70 The maximum line length is 255 characters and the maximum length of
71 a lexical element is also 255 characters. This is the default setting
72 if not overridden by the use of compiler switch *-gnaty* (which
73 sets the maximum to 79) or *-gnatyMnn* which allows the maximum
74 line length to be specified to be any value up to 32767. The maximum
75 length of a lexical element is the same as the maximum line length.
76
77 *
78 "Implementation defined pragmas. See 2.8(14)."
79
80 See :ref:`Implementation_Defined_Pragmas`.
81
82 *
83 "Effect of pragma ``Optimize``. See 2.8(27)."
84
85 Pragma ``Optimize``, if given with a ``Time`` or ``Space``
86 parameter, checks that the optimization flag is set, and aborts if it is
87 not.
88
89 *
90 "The message string associated with the Assertion_Error exception raised
91 by the failure of a predicate check if there is no applicable
92 Predicate_Failure aspect. See 3.2.4(31)."
93
94 In the case of a Dynamic_Predicate aspect, the string is
95 "Dynamic_Predicate failed at <source position>", where
96 "<source position>" might be something like "foo.adb:123".
97 The Static_Predicate case is handled analogously.
98
99 *
100 "The predefined integer types declared in
101 ``Standard``. See 3.5.4(25)."
102
103 .. tabularcolumns:: |l|L|
104
105 ========================= =======================================
106 Type Representation
107 ========================= =======================================
108 *Short_Short_Integer* 8-bit signed
109 *Short_Integer* 16-bit signed
110 *Integer* 32-bit signed
111 *Long_Integer* 64-bit signed (on most 64-bit targets,
112 depending on the C definition of long)
113 32-bit signed (on all other targets)
114 *Long_Long_Integer* 64-bit signed
115 *Long_Long_Long_Integer* 128-bit signed (on 64-bit targets)
116 64-bit signed (on 32-bit targets)
117 ========================= =======================================
118
119 *
120 "Any nonstandard integer types and the operators defined
121 for them. See 3.5.4(26)."
122
123 There are no nonstandard integer types.
124
125 *
126 "Any nonstandard real types and the operators defined for
127 them. See 3.5.6(8)."
128
129 There are no nonstandard real types.
130
131 *
132 "What combinations of requested decimal precision and range
133 are supported for floating point types. See 3.5.7(7)."
134
135 The precision and range are defined by the IEEE Standard for Floating-Point
136 Arithmetic (IEEE 754-2019).
137
138 *
139 "The predefined floating point types declared in
140 ``Standard``. See 3.5.7(16)."
141
142 ====================== ===============================================
143 Type Representation
144 ====================== ===============================================
145 *Short_Float* IEEE Binary32 (Single)
146 *Float* IEEE Binary32 (Single)
147 *Long_Float* IEEE Binary64 (Double)
148 *Long_Long_Float* IEEE Binary64 (Double) on non-x86 architectures
149 IEEE 80-bit Extended on x86 architecture
150 ====================== ===============================================
151
152 The default rounding mode specified by the IEEE 754 Standard is assumed both
153 for static and dynamic computations (that is, round to nearest, ties to even).
154 The input routines yield correctly rounded values for Short_Float, Float, and
155 Long_Float at least. The output routines can compute up to twice as many exact
156 digits as the value of ``T'Digits`` for any type, for example 30 digits for
157 Long_Float; if more digits are requested, zeros are printed.
158
159 *
160 "The small of an ordinary fixed point type. See 3.5.9(8)."
161
162 The small is the largest power of two that does not exceed the delta.
163
164 *
165 "What combinations of small, range, and digits are
166 supported for fixed point types. See 3.5.9(10)."
167
168 For an ordinary fixed point type, on 32-bit platforms, the small must lie in
169 2.0**(-80) .. 2.0**80 and the range in -9.0E+36 .. 9.0E+36; any combination
170 is permitted that does not result in a mantissa larger than 63 bits.
171
172 On 64-bit platforms, the small must lie in 2.0**(-127) .. 2.0**127 and the
173 range in -1.0E+76 .. 1.0E+76; any combination is permitted that does not
174 result in a mantissa larger than 63 bits, and any combination is permitted
175 that results in a mantissa between 64 and 127 bits if the small is the
176 ratio of two integers that lie in 1 .. 2.0**127.
177
178 If the small is the ratio of two integers with 64-bit magnitude on 32-bit
179 platforms and 128-bit magnitude on 64-bit platforms, which is the case if
180 no ``small`` clause is provided, then the operations of the fixed point
181 type are entirely implemented by means of integer instructions. In the
182 other cases, some operations, in particular input and output, may be
183 implemented by means of floating-point instructions and may be affected
184 by accuracy issues on architectures other than x86.
185
186 For a decimal fixed point type, on 32-bit platforms, the small must lie in
187 1.0E-18 .. 1.0E+18 and the digits in 1 .. 18. On 64-bit platforms, the
188 small must lie in 1.0E-38 .. 1.0E+38 and the digits in 1 .. 38.
189
190 *
191 "The result of ``Tags.Expanded_Name`` for types declared
192 within an unnamed *block_statement*. See 3.9(10)."
193
194 Block numbers of the form :samp:`B{nnn}`, where *nnn* is a
195 decimal integer are allocated.
196
197 *
198 "The sequence of characters of the value returned by Tags.Expanded_Name
199 (respectively, Tags.Wide_Expanded_Name) when some of the graphic
200 characters of Tags.Wide_Wide_Expanded_Name are not defined in Character
201 (respectively, Wide_Character). See 3.9(10.1)."
202
203 This is handled in the same way as the implementation-defined behavior
204 referenced in A.4.12(34).
205
206 *
207 "Implementation-defined attributes. See 4.1.4(12)."
208
209 See :ref:`Implementation_Defined_Attributes`.
210
211 *
212 "The value of the parameter to Empty for some container aggregates.
213 See 4.3.5(40)."
214
215 As per the suggestion given in the Annotated Ada RM, the default value
216 of the formal parameter is used if one exists and zero is used otherwise.
217
218 *
219 "The maximum number of chunks for a parallel reduction expression without
220 a chunk_specification. See 4.5.10(21)."
221
222 Feature unimplemented.
223
224 *
225 "Rounding of real static expressions which are exactly half-way between
226 two machine numbers. See 4.9(38)."
227
228 Round to even is used in all such cases.
229
230 *
231 "The maximum number of chunks for a parallel generalized iterator without
232 a chunk_specification. See 5.5.2(10)."
233
234 Feature unimplemented.
235
236 *
237 "The number of chunks for an array component iterator. See 5.5.2(11)."
238
239 Feature unimplemented.
240
241 *
242 "Any extensions of the Global aspect. See 6.1.2(43)."
243
244 Feature unimplemented.
245
246 *
247 "The circumstances the implementation passes in the null value for a view
248 conversion of an access type used as an out parameter. See 6.4.1(19)."
249
250 Difficult to characterize.
251
252 *
253 "Any extensions of the Default_Initial_Condition aspect. See 7.3.3(11)."
254
255 SPARK allows specifying *null* as the Default_Initial_Condition
256 aspect of a type. See the SPARK reference manual for further details.
257
258 *
259 "Any implementation-defined time types. See 9.6(6)."
260
261 There are no implementation-defined time types.
262
263 *
264 "The time base associated with relative delays. See 9.6(20)."
265
266 See 9.6(20). The time base used is that provided by the C library
267 function ``gettimeofday``.
268
269 *
270 "The time base of the type ``Calendar.Time``. See 9.6(23)."
271
272 The time base used is that provided by the C library function
273 ``gettimeofday``.
274
275 *
276 "The time zone used for package ``Calendar``
277 operations. See 9.6(24)."
278
279 The time zone used by package ``Calendar`` is the current system time zone
280 setting for local time, as accessed by the C library function
281 ``localtime``.
282
283 *
284 "Any limit on *delay_until_statements* of
285 *select_statements*. See 9.6(29)."
286
287 There are no such limits.
288
289 *
290 "The result of Calendar.Formatting.Image if its argument represents more
291 than 100 hours. See 9.6.1(86)."
292
293 Calendar.Time_Error is raised.
294
295 *
296 "Implementation-defined conflict check policies. See 9.10.1(5)."
297
298 There are no implementation-defined conflict check policies.
299
300 *
301 "The representation for a compilation. See 10.1(2)."
302
303 A compilation is represented by a sequence of files presented to the
304 compiler in a single invocation of the *gcc* command.
305
306 *
307 "Any restrictions on compilations that contain multiple
308 compilation_units. See 10.1(4)."
309
310 No single file can contain more than one compilation unit, but any
311 sequence of files can be presented to the compiler as a single
312 compilation.
313
314 *
315 "The mechanisms for creating an environment and for adding
316 and replacing compilation units. See 10.1.4(3)."
317
318 See separate section on compilation model.
319
320 *
321 "The manner of explicitly assigning library units to a
322 partition. See 10.2(2)."
323
324 If a unit contains an Ada main program, then the Ada units for the partition
325 are determined by recursive application of the rules in the Ada Reference
326 Manual section 10.2(2-6). In other words, the Ada units will be those that
327 are needed by the main program, and then this definition of need is applied
328 recursively to those units, and the partition contains the transitive
329 closure determined by this relationship. In short, all the necessary units
330 are included, with no need to explicitly specify the list. If additional
331 units are required, e.g., by foreign language units, then all units must be
332 mentioned in the context clause of one of the needed Ada units.
333
334 If the partition contains no main program, or if the main program is in
335 a language other than Ada, then GNAT
336 provides the binder options *-z* and *-n* respectively, and in
337 this case a list of units can be explicitly supplied to the binder for
338 inclusion in the partition (all units needed by these units will also
339 be included automatically). For full details on the use of these
340 options, refer to *GNAT Make Program gnatmake* in the
341 :title:`GNAT User's Guide`.
342
343 *
344 "The implementation-defined means, if any, of specifying which compilation
345 units are needed by a given compilation unit. See 10.2(2)."
346
347 The units needed by a given compilation unit are as defined in
348 the Ada Reference Manual section 10.2(2-6). There are no
349 implementation-defined pragmas or other implementation-defined
350 means for specifying needed units.
351
352 *
353 "The manner of designating the main subprogram of a
354 partition. See 10.2(7)."
355
356 The main program is designated by providing the name of the
357 corresponding :file:`ALI` file as the input parameter to the binder.
358
359 *
360 "The order of elaboration of *library_items*. See 10.2(18)."
361
362 The first constraint on ordering is that it meets the requirements of
363 Chapter 10 of the Ada Reference Manual. This still leaves some
364 implementation-dependent choices, which are resolved by analyzing
365 the elaboration code of each unit and identifying implicit
366 elaboration-order dependencies.
367
368 *
369 "Parameter passing and function return for the main
370 subprogram. See 10.2(21)."
371
372 The main program has no parameters. It may be a procedure, or a function
373 returning an integer type. In the latter case, the returned integer
374 value is the return code of the program (overriding any value that
375 may have been set by a call to ``Ada.Command_Line.Set_Exit_Status``).
376
377 *
378 "The mechanisms for building and running partitions. See 10.2(24)."
379
380 GNAT itself supports programs with only a single partition. The GNATDIST
381 tool provided with the GLADE package (which also includes an implementation
382 of the PCS) provides a completely flexible method for building and running
383 programs consisting of multiple partitions. See the separate GLADE manual
384 for details.
385
386 *
387 "The details of program execution, including program
388 termination. See 10.2(25)."
389
390 See separate section on compilation model.
391
392 *
393 "The semantics of any non-active partitions supported by the
394 implementation. See 10.2(28)."
395
396 Passive partitions are supported on targets where shared memory is
397 provided by the operating system. See the GLADE reference manual for
398 further details.
399
400 *
401 "The information returned by ``Exception_Message``. See 11.4.1(10)."
402
403 Exception message returns the null string unless a specific message has
404 been passed by the program.
405
406 *
407 "The result of ``Exceptions.Exception_Name`` for types
408 declared within an unnamed *block_statement*. See 11.4.1(12)."
409
410 Blocks have implementation defined names of the form :samp:`B{nnn}`
411 where *nnn* is an integer.
412
413 *
414 "The information returned by
415 ``Exception_Information``. See 11.4.1(13)."
416
417 ``Exception_Information`` returns a string in the following format::
418
419 *Exception_Name:* nnnnn
420 *Message:* mmmmm
421 *PID:* ppp
422 *Load address:* 0xhhhh
423 *Call stack traceback locations:*
424 0xhhhh 0xhhhh 0xhhhh ... 0xhhh
425
426 where
427
428 * ``nnnn`` is the fully qualified name of the exception in all upper
429 case letters. This line is always present.
430
431 * ``mmmm`` is the message (this line present only if message is non-null)
432
433 * ``ppp`` is the Process Id value as a decimal integer (this line is
434 present only if the Process Id is nonzero). Currently we are
435 not making use of this field.
436
437 * The Load address line, the Call stack traceback locations line and the
438 following values are present only if at least one traceback location was
439 recorded. The Load address indicates the address at which the main executable
440 was loaded; this line may not be present if operating system hasn't relocated
441 the main executable. The values are given in C style format, with lower case
442 letters for a-f, and only as many digits present as are necessary.
443 The line terminator sequence at the end of each line, including
444 the last line is a single ``LF`` character (``16#0A#``).
445
446 *
447 "The sequence of characters of the value returned by
448 Exceptions.Exception_Name (respectively, Exceptions.Wide_Exception_Name)
449 when some of the graphic characters of Exceptions.Wide_Wide_Exception_Name
450 are not defined in Character (respectively, Wide_Character).
451 See 11.4.1(12.1)."
452
453 This is handled in the same way as the implementation-defined behavior
454 referenced in A.4.12(34).
455
456 *
457 "The information returned by Exception_Information. See 11.4.1(13)."
458
459 The exception name and the source location at which the exception was
460 raised are included.
461
462 *
463 "Implementation-defined policy_identifiers and assertion_aspect_marks
464 allowed in a pragma Assertion_Policy. See 11.4.2(9)."
465
466 Implementation-defined assertion_aspect_marks include Assert_And_Cut,
467 Assume, Contract_Cases, Debug, Ghost, Initial_Condition, Loop_Invariant,
468 Loop_Variant, Postcondition, Precondition, Predicate, Refined_Post,
469 Statement_Assertions, and Subprogram_Variant. Implementation-defined
470 policy_identifiers include Ignore and Suppressible.
471
472 *
473 "The default assertion policy. See 11.4.2(10)."
474
475 The default assertion policy is Ignore, although this can be overridden
476 via compiler switches such as "-gnata".
477
478 *
479 "Implementation-defined check names. See 11.5(27)."
480
481 The implementation defined check names include Alignment_Check,
482 Atomic_Synchronization, Duplicated_Tag_Check, Container_Checks,
483 Tampering_Check, Predicate_Check, and Validity_Check. In addition, a user
484 program can add implementation-defined check names by means of the pragma
485 Check_Name. See the description of pragma ``Suppress`` for full details.
486
487 *
488 "Existence and meaning of second parameter of pragma Unsuppress.
489 See 11.5(27.1)."
490
491 The legality rules for and semantics of the second parameter of pragma
492 Unsuppress match those for the second argument of pragma Suppress.
493
494 *
495 "The cases that cause conflicts between the representation of the
496 ancestors of a type_declaration. See 13.1(13.1)."
497
498 No such cases exist.
499
500 *
501 "The interpretation of each representation aspect. See 13.1(20)."
502
503 See separate section on data representations.
504
505 *
506 "Any restrictions placed upon the specification of representation aspects.
507 See 13.1(20)."
508
509 See separate section on data representations.
510
511 *
512 "Implementation-defined aspects, including the syntax for specifying
513 such aspects and the legality rules for such aspects. See 13.1.1(38)."
514
515 See :ref:`Implementation_Defined_Aspects`.
516
517 *
518 "The set of machine scalars. See 13.3(8.1)."
519
520 See separate section on data representations.
521
522 *
523 "The meaning of ``Size`` for indefinite subtypes. See 13.3(48)."
524
525 The Size attribute of an indefinite subtype is not less than the Size
526 attribute of any object of that type.
527
528 *
529 "The meaning of Object_Size for indefinite subtypes. See 13.3(58)."
530
531 The Object_Size attribute of an indefinite subtype is not less than the
532 Object_Size attribute of any object of that type.
533
534 *
535 "The default external representation for a type tag. See 13.3(75)."
536
537 The default external representation for a type tag is the fully expanded
538 name of the type in upper case letters.
539
540 *
541 "What determines whether a compilation unit is the same in
542 two different partitions. See 13.3(76)."
543
544 A compilation unit is the same in two different partitions if and only
545 if it derives from the same source file.
546
547 *
548 "Implementation-defined components. See 13.5.1(15)."
549
550 The only implementation defined component is the tag for a tagged type,
551 which contains a pointer to the dispatching table.
552
553 *
554 "If ``Word_Size`` = ``Storage_Unit``, the default bit
555 ordering. See 13.5.3(5)."
556
557 ``Word_Size`` (32) is not the same as ``Storage_Unit`` (8) for this
558 implementation, so no non-default bit ordering is supported. The default
559 bit ordering corresponds to the natural endianness of the target architecture.
560
561 *
562 "The contents of the visible part of package ``System``. See 13.7(2)."
563
564 See the definition of package System in :file:`system.ads`.
565 Note that two declarations are added to package System.
566
567 .. code-block:: ada
568
569 Max_Priority : constant Positive := Priority'Last;
570 Max_Interrupt_Priority : constant Positive := Interrupt_Priority'Last;
571
572 *
573 "The range of Storage_Elements.Storage_Offset, the modulus of
574 Storage_Elements.Storage_Element, and the declaration of
575 Storage_Elements.Integer_Address. See 13.7.1(11)."
576
577 See the definition of package System.Storage_Elements in :file:`s-stoele.ads`.
578
579 *
580 "The contents of the visible part of package ``System.Machine_Code``,
581 and the meaning of *code_statements*. See 13.8(7)."
582
583 See the definition and documentation in file :file:`s-maccod.ads`.
584
585 *
586 "The result of unchecked conversion for instances with scalar result
587 types whose result is not defined by the language. See 13.9(11)."
588
589 Unchecked conversion between types of the same size
590 results in an uninterpreted transmission of the bits from one type
591 to the other. If the types are of unequal sizes, then in the case of
592 discrete types, a shorter source is first zero or sign extended as
593 necessary, and a shorter target is simply truncated on the left.
594 For all non-discrete types, the source is first copied if necessary
595 to ensure that the alignment requirements of the target are met, then
596 a pointer is constructed to the source value, and the result is obtained
597 by dereferencing this pointer after converting it to be a pointer to the
598 target type. Unchecked conversions where the target subtype is an
599 unconstrained array are not permitted. If the target alignment is
600 greater than the source alignment, then a copy of the result is
601 made with appropriate alignment
602
603 *
604 "The result of unchecked conversion for instances with nonscalar result
605 types whose result is not defined by the language. See 13.9(11)."
606
607 See preceding definition for the scalar result case.
608
609 *
610 "Whether or not the implementation provides user-accessible
611 names for the standard pool type(s). See 13.11(17)."
612
613 There are 3 different standard pools used by the compiler when
614 ``Storage_Pool`` is not specified depending whether the type is local
615 to a subprogram or defined at the library level and whether
616 ``Storage_Size``is specified or not. See documentation in the runtime
617 library units ``System.Pool_Global``, ``System.Pool_Size`` and
618 ``System.Pool_Local`` in files :file:`s-poosiz.ads`,
619 :file:`s-pooglo.ads` and :file:`s-pooloc.ads` for full details on the
620 default pools used. All these pools are accessible by means of `with`\ ing
621 these units.
622
623 *
624 "The meaning of ``Storage_Size`` when neither the Storage_Size nor the
625 Storage_Pool is specified for an access type. See 13.11(18)."
626
627 ``Storage_Size`` is measured in storage units, and refers to the
628 total space available for an access type collection, or to the primary
629 stack space for a task.
630
631 *
632 "The effect of specifying aspect Default_Storage_Pool on an instance
633 of a language-defined generic unit. See 13.11.3(5)."
634
635 Instances of language-defined generic units are treated the same as other
636 instances with respect to the Default_Storage_Pool aspect.
637
638 *
639 "Implementation-defined restrictions allowed in a pragma
640 ``Restrictions``. See 13.12(8.7)."
641
642 See :ref:`Standard_and_Implementation_Defined_Restrictions`.
643
644 *
645 "The consequences of violating limitations on
646 ``Restrictions`` pragmas. See 13.12(9)."
647
648 Restrictions that can be checked at compile time are enforced at
649 compile time; violations are illegal. For other restrictions, any
650 violation during program execution results in erroneous execution.
651
652 *
653 "Implementation-defined usage profiles allowed in a pragma Profile.
654 See 13.12(15)."
655
656 See :ref:`Implementation_Defined_Pragmas`.
657
658 *
659 "The contents of the stream elements read and written by the Read and
660 Write attributes of elementary types. See 13.13.2(9)."
661
662 The representation is the in-memory representation of the base type of
663 the type, using the number of bits corresponding to the
664 ``type'Size`` value, and the natural ordering of the machine.
665
666 *
667 "The names and characteristics of the numeric subtypes
668 declared in the visible part of package ``Standard``. See A.1(3)."
669
670 See items describing the integer and floating-point types supported.
671
672 *
673 "The values returned by Strings.Hash. See A.4.9(3)."
674
675 This hash function has predictable collisions and is subject to
676 equivalent substring attacks. It is not suitable for construction of a
677 hash table keyed on possibly malicious user input.
678
679 *
680 "The value returned by a call to a Text_Buffer Get procedure if any
681 character in the returned sequence is not defined in Character.
682 See A.4.12(34)."
683
684 The contents of a buffer is represented internally as a UTF_8 string.
685 The value return by Text_Buffer.Get is the result of passing that
686 UTF_8 string to UTF_Encoding.Strings.Decode.
687
688 *
689 "The value returned by a call to a Text_Buffer Wide_Get procedure if
690 any character in the returned sequence is not defined in Wide_Character.
691 See A.4.12(34)."
692
693 The contents of a buffer is represented internally as a UTF_8 string.
694 The value return by Text_Buffer.Wide_Get is the result of passing that
695 UTF_8 string to UTF_Encoding.Wide_Strings.Decode.
696
697 *
698 "The accuracy actually achieved by the elementary
699 functions. See A.5.1(1)."
700
701 The elementary functions correspond to the functions available in the C
702 library. Only fast math mode is implemented.
703
704 *
705 "The sign of a zero result from some of the operators or
706 functions in ``Numerics.Generic_Elementary_Functions``, when
707 ``Float_Type'Signed_Zeros`` is ``True``. See A.5.1(46)."
708
709 The sign of zeroes follows the requirements of the IEEE 754 standard on
710 floating-point.
711
712 *
713 "The value of
714 ``Numerics.Float_Random.Max_Image_Width``. See A.5.2(27)."
715
716 Maximum image width is 6864, see library file :file:`s-rannum.ads`.
717
718 *
719 "The value of
720 ``Numerics.Discrete_Random.Max_Image_Width``. See A.5.2(27)."
721
722 Maximum image width is 6864, see library file :file:`s-rannum.ads`.
723
724 *
725 "The string representation of a random number generator's
726 state. See A.5.2(38)."
727
728 The value returned by the Image function is the concatenation of
729 the fixed-width decimal representations of the 624 32-bit integers
730 of the state vector.
731
732 *
733 "The values of the ``Model_Mantissa``,
734 ``Model_Emin``, ``Model_Epsilon``, ``Model``,
735 ``Safe_First``, and ``Safe_Last`` attributes, if the Numerics
736 Annex is not supported. See A.5.3(72)."
737
738 Running the compiler with *-gnatS* to produce a listing of package
739 ``Standard`` displays the values of these attributes.
740
741 *
742 "The value of ``Buffer_Size`` in ``Storage_IO``. See A.9(10)."
743
744 All type representations are contiguous, and the ``Buffer_Size`` is
745 the value of ``type'Size`` rounded up to the next storage unit
746 boundary.
747
748 *
749 "External files for standard input, standard output, and
750 standard error See A.10(5)."
751
752 These files are mapped onto the files provided by the C streams
753 libraries. See source file :file:`i-cstrea.ads` for further details.
754
755 *
756 "The accuracy of the value produced by ``Put``. See A.10.9(36)."
757
758 If more digits are requested in the output than are represented by the
759 precision of the value, zeroes are output in the corresponding least
760 significant digit positions.
761
762 *
763 "Current size for a stream file for which positioning is not supported.
764 See A.12.1(1.1)."
765
766 Positioning is supported.
767
768 *
769 "The meaning of ``Argument_Count``, ``Argument``, and
770 ``Command_Name``. See A.15(1)."
771
772 These are mapped onto the ``argv`` and ``argc`` parameters of the
773 main program in the natural manner.
774
775 *
776 "The interpretation of file names and directory names. See A.16(46)."
777
778 These names are interpreted consistently with the underlying file system.
779
780 *
781 "The maxium value for a file size in Directories. See A.16(87)."
782
783 Directories.File_Size'Last is equal to Long_Long_Integer'Last .
784
785 *
786 "The result for Directories.Size for a directory or special file.
787 See A.16(93)."
788
789 Name_Error is raised.
790
791 *
792 "The result for Directories.Modification_Time for a directory or special file.
793 See A.16(93)."
794
795 Name_Error is raised.
796
797 *
798 "The interpretation of a nonnull search pattern in Directories.
799 See A.16(104)."
800
801 When the ``Pattern`` parameter is not the null string, it is interpreted
802 according to the syntax of regular expressions as defined in the
803 ``GNAT.Regexp`` package.
804
805 See :ref:`GNAT.Regexp_(g-regexp.ads)`.
806
807 *
808 "The results of a Directories search if the contents of the directory are
809 altered while a search is in progress. See A.16(110)."
810
811 The effect of a call to Get_Next_Entry is determined by the current
812 state of the directory.
813
814 *
815 "The definition and meaning of an environment variable. See A.17(1)."
816
817 This definition is determined by the underlying operating system.
818
819 *
820 "The circumstances where an environment variable cannot be defined.
821 See A.17(16)."
822
823 There are no such implementation-defined circumstances.
824
825 *
826 "Environment names for which Set has the effect of Clear. See A.17(17)."
827
828 There are no such names.
829
830 *
831 "The value of Containers.Hash_Type'Modulus. The value of
832 Containers.Count_Type'Last. See A.18.1(7)."
833
834 Containers.Hash_Type'Modulus is 2**32.
835 Containers.Count_Type'Last is 2**31 - 1.
836
837 *
838 "Implementation-defined convention names. See B.1(11)."
839
840 The following convention names are supported
841
842 .. tabularcolumns:: |l|L|
843
844 ======================= ==============================================================================
845 Convention Name Interpretation
846 ======================= ==============================================================================
847 *Ada* Ada
848 *Ada_Pass_By_Copy* Allowed for any types except by-reference types such as limited
849 records. Compatible with convention Ada, but causes any parameters
850 with this convention to be passed by copy.
851 *Ada_Pass_By_Reference* Allowed for any types except by-copy types such as scalars.
852 Compatible with convention Ada, but causes any parameters
853 with this convention to be passed by reference.
854 *Assembler* Assembly language
855 *Asm* Synonym for Assembler
856 *Assembly* Synonym for Assembler
857 *C* C
858 *C_Pass_By_Copy* Allowed only for record types, like C, but also notes that record
859 is to be passed by copy rather than reference.
860 *COBOL* COBOL
861 *C_Plus_Plus (or CPP)* C++
862 *Default* Treated the same as C
863 *External* Treated the same as C
864 *Fortran* Fortran
865 *Intrinsic* For support of pragma ``Import`` with convention Intrinsic, see
866 separate section on Intrinsic Subprograms.
867 *Stdcall* Stdcall (used for Windows implementations only). This convention correspond
868 to the WINAPI (previously called Pascal convention) C/C++ convention under
869 Windows. A routine with this convention cleans the stack before
870 exit. This pragma cannot be applied to a dispatching call.
871 *DLL* Synonym for Stdcall
872 *Win32* Synonym for Stdcall
873 *Stubbed* Stubbed is a special convention used to indicate that the body of the
874 subprogram will be entirely ignored. Any call to the subprogram
875 is converted into a raise of the ``Program_Error`` exception. If a
876 pragma ``Import`` specifies convention ``stubbed`` then no body need
877 be present at all. This convention is useful during development for the
878 inclusion of subprograms whose body has not yet been written.
879 In addition, all otherwise unrecognized convention names are also
880 treated as being synonymous with convention C. In all implementations,
881 use of such other names results in a warning.
882 ======================= ==============================================================================
883
884 *
885 "The meaning of link names. See B.1(36)."
886
887 Link names are the actual names used by the linker.
888
889 *
890 "The manner of choosing link names when neither the link name nor the
891 address of an imported or exported entity is specified. See B.1(36)."
892
893 The default linker name is that which would be assigned by the relevant
894 external language, interpreting the Ada name as being in all lower case
895 letters.
896
897 *
898 "The effect of pragma ``Linker_Options``. See B.1(37)."
899
900 The string passed to ``Linker_Options`` is presented uninterpreted as
901 an argument to the link command, unless it contains ASCII.NUL characters.
902 NUL characters if they appear act as argument separators, so for example
903
904 .. code-block:: ada
905
906 pragma Linker_Options ("-labc" & ASCII.NUL & "-ldef");
907
908 causes two separate arguments ``-labc`` and ``-ldef`` to be passed to the
909 linker. The order of linker options is preserved for a given unit. The final
910 list of options passed to the linker is in reverse order of the elaboration
911 order. For example, linker options for a body always appear before the options
912 from the corresponding package spec.
913
914 *
915 "The contents of the visible part of package
916 ``Interfaces`` and its language-defined descendants. See B.2(1)."
917
918 See files with prefix :file:`i-` in the distributed library.
919
920 *
921 "Implementation-defined children of package
922 ``Interfaces``. The contents of the visible part of package
923 ``Interfaces``. See B.2(11)."
924
925 See files with prefix :file:`i-` in the distributed library.
926
927 *
928 "The definitions of certain types and constants in Interfaces.C.
929 See B.3(41)."
930
931 See source file :file:`i-c.ads`.
932
933 *
934 "The types ``Floating``, ``Long_Floating``,
935 ``Binary``, ``Long_Binary``, ``Decimal_ Element``, and
936 ``COBOL_Character``; and the initialization of the variables
937 ``Ada_To_COBOL`` and ``COBOL_To_Ada``, in
938 ``Interfaces.COBOL``. See B.4(50)."
939
940 ===================== ====================================
941 COBOL Ada
942 ===================== ====================================
943 *Floating* Float
944 *Long_Floating* (Floating) Long_Float
945 *Binary* Integer
946 *Long_Binary* Long_Long_Integer
947 *Decimal_Element* Character
948 *COBOL_Character* Character
949 ===================== ====================================
950
951 For initialization, see the file :file:`i-cobol.ads` in the distributed library.
952
953 *
954 "The types Fortran_Integer, Real, Double_Precision, and Character_Set
955 in Interfaces.Fortran. See B.5(17)."
956
957 See source file :file:`i-fortra.ads`. These types are derived, respectively,
958 from Integer, Float, Long_Float, and Character.
959
960 *
961 "Implementation-defined intrinsic subprograms. See C.1(1)."
962
963 See separate section on Intrinsic Subprograms.
964
965 *
966 "Any restrictions on a protected procedure or its containing type when an
967 aspect Attach_handler or Interrupt_Handler is specified. See C.3.1(17)."
968
969 There are no such restrictions.
970
971 *
972 "Any other forms of interrupt handler supported by the Attach_Handler and
973 Interrupt_Handler aspects. See C.3.1(19)."
974
975 There are no such forms.
976
977 *
978 "The semantics of some attributes and functions of an entity for which
979 aspect Discard_Names is True. See C.5(7)."
980
981 If Discard_Names is True for an enumeration type, the Image attribute
982 provides the image of the Pos of the literal, and Value accepts
983 Pos values.
984
985 If both of the aspects``Discard_Names`` and ``No_Tagged_Streams`` are true
986 for a tagged type, its Expanded_Name and External_Tag values are
987 empty strings. This is useful to avoid exposing entity names at binary
988 level.
989
990 *
991 "The modulus and size of Test_and_Set_Flag. See C.6.3(8)."
992
993 The modulus is 2**8. The size is 8.
994
995 *
996 "The value used to represent the set value for Atomic_Test_and_Set.
997 See C.6.3(10)."
998
999 The value is 1.
1000
1001 *
1002 "The result of the ``Task_Identification.Image``
1003 attribute. See C.7.1(7)."
1004
1005 The result of this attribute is a string that identifies
1006 the object or component that denotes a given task. If a variable ``Var``
1007 has a task type, the image for this task will have the form :samp:`Var_{XXXXXXXX}`,
1008 where the suffix *XXXXXXXX*
1009 is the hexadecimal representation of the virtual address of the corresponding
1010 task control block. If the variable is an array of tasks, the image of each
1011 task will have the form of an indexed component indicating the position of a
1012 given task in the array, e.g., :samp:`Group(5)_{XXXXXXX}`. If the task is a
1013 component of a record, the image of the task will have the form of a selected
1014 component. These rules are fully recursive, so that the image of a task that
1015 is a subcomponent of a composite object corresponds to the expression that
1016 designates this task.
1017
1018 If a task is created by an allocator, its image depends on the context. If the
1019 allocator is part of an object declaration, the rules described above are used
1020 to construct its image, and this image is not affected by subsequent
1021 assignments. If the allocator appears within an expression, the image
1022 includes only the name of the task type.
1023
1024 If the configuration pragma Discard_Names is present, or if the restriction
1025 No_Implicit_Heap_Allocation is in effect, the image reduces to
1026 the numeric suffix, that is to say the hexadecimal representation of the
1027 virtual address of the control block of the task.
1028
1029 *
1030 "The value of ``Current_Task`` when in a protected entry
1031 or interrupt handler. See C.7.1(17)."
1032
1033 Protected entries or interrupt handlers can be executed by any
1034 convenient thread, so the value of ``Current_Task`` is undefined.
1035
1036 *
1037 "Granularity of locking for Task_Attributes. See C.7.2(16)."
1038
1039 No locking is needed if the formal type Attribute has the size and
1040 alignment of either Integer or System.Address and the bit representation
1041 of Initial_Value is all zeroes. Otherwise, locking is performed.
1042
1043 *
1044 "The declarations of ``Any_Priority`` and
1045 ``Priority``. See D.1(11)."
1046
1047 See declarations in file :file:`system.ads`.
1048
1049 *
1050 "Implementation-defined execution resources. See D.1(15)."
1051
1052 There are no implementation-defined execution resources.
1053
1054 *
1055 "Whether, on a multiprocessor, a task that is waiting for
1056 access to a protected object keeps its processor busy. See D.2.1(3)."
1057
1058 On a multi-processor, a task that is waiting for access to a protected
1059 object does not keep its processor busy.
1060
1061 *
1062 "The affect of implementation defined execution resources
1063 on task dispatching. See D.2.1(9)."
1064
1065 Tasks map to threads in the threads package used by GNAT. Where possible
1066 and appropriate, these threads correspond to native threads of the
1067 underlying operating system.
1068
1069 *
1070 "Implementation-defined task dispatching policies. See D.2.2(3)."
1071
1072 There are no implementation-defined task dispatching policies.
1073
1074 *
1075 "The value of Default_Quantum in Dispatching.Round_Robin. See D.2.5(4)."
1076
1077 The value is 10 milliseconds.
1078
1079 *
1080 "Implementation-defined *policy_identifiers* allowed
1081 in a pragma ``Locking_Policy``. See D.3(4)."
1082
1083 The two implementation defined policies permitted in GNAT are
1084 ``Inheritance_Locking`` and ``Concurrent_Readers_Locking``. On
1085 targets that support the ``Inheritance_Locking`` policy, locking is
1086 implemented by inheritance, i.e., the task owning the lock operates
1087 at a priority equal to the highest priority of any task currently
1088 requesting the lock. On targets that support the
1089 ``Concurrent_Readers_Locking`` policy, locking is implemented with a
1090 read/write lock allowing multiple protected object functions to enter
1091 concurrently.
1092
1093 *
1094 "Default ceiling priorities. See D.3(10)."
1095
1096 The ceiling priority of protected objects of the type
1097 ``System.Interrupt_Priority'Last`` as described in the Ada
1098 Reference Manual D.3(10),
1099
1100 *
1101 "The ceiling of any protected object used internally by
1102 the implementation. See D.3(16)."
1103
1104 The ceiling priority of internal protected objects is
1105 ``System.Priority'Last``.
1106
1107 *
1108 "Implementation-defined queuing policies. See D.4(1)."
1109
1110 There are no implementation-defined queuing policies.
1111
1112 *
1113 "Implementation-defined admission policies. See D.4.1(1)."
1114
1115 There are no implementation-defined admission policies.
1116
1117 *
1118 "Any operations that implicitly require heap storage
1119 allocation. See D.7(8)."
1120
1121 The only operation that implicitly requires heap storage allocation is
1122 task creation.
1123
1124 *
1125 "When restriction No_Dynamic_CPU_Assignment applies to a partition, the
1126 processor on which a task with a CPU value of a Not_A_Specific_CPU will
1127 execute. See D.7(10)."
1128
1129 Unknown.
1130
1131 *
1132 "When restriction No_Task_Termination applies to a partition, what happens
1133 when a task terminates. See D.7(15.1)."
1134
1135 Execution is erroneous in that case.
1136
1137 *
1138 "The behavior when restriction Max_Storage_At_Blocking is violated.
1139 See D.7(17)."
1140
1141 Execution is erroneous in that case.
1142
1143 *
1144 "The behavior when restriction Max_Asynchronous_Select_Nesting is violated.
1145 See D.7(18)."
1146
1147 Execution is erroneous in that case.
1148
1149 *
1150 "The behavior when restriction Max_Tasks is violated. See D.7(19)."
1151
1152 Execution is erroneous in that case.
1153
1154 * "Whether the use of pragma Restrictions results in a reduction in program
1155 code or data size or execution time. See D.7(20)."
1156
1157 Yes it can, but the precise circumstances and properties of such reductions
1158 are difficult to characterize.
1159
1160 *
1161 "The value of Barrier_Limit'Last in Synchronous_Barriers. See D.10.1(4)."
1162
1163 Synchronous_Barriers.Barrier_Limit'Last is Integer'Last .
1164
1165 *
1166 "When an aborted task that is waiting on a Synchronous_Barrier is aborted.
1167 See D.10.1(13)."
1168
1169 Difficult to characterize.
1170
1171 *
1172 "The value of Min_Handler_Ceiling in Execution_Time.Group_Budgets.
1173 See D.14.2(7)."
1174
1175 See source file :file:`a-etgrbu.ads`.
1176
1177 *
1178 "The value of CPU_Range'Last in System.Multiprocessors. See D.16(4)."
1179
1180 See source file :file:`s-multip.ads`.
1181
1182 *
1183 "The processor on which the environment task executes in the absence
1184 of a value for the aspect CPU. See D.16(13)."
1185
1186 Unknown.
1187
1188 *
1189 "The means for creating and executing distributed
1190 programs. See E(5)."
1191
1192 The GLADE package provides a utility GNATDIST for creating and executing
1193 distributed programs. See the GLADE reference manual for further details.
1194
1195 *
1196 "Any events that can result in a partition becoming
1197 inaccessible. See E.1(7)."
1198
1199 See the GLADE reference manual for full details on such events.
1200
1201 *
1202 "The scheduling policies, treatment of priorities, and management of
1203 shared resources between partitions in certain cases. See E.1(11)."
1204
1205 See the GLADE reference manual for full details on these aspects of
1206 multi-partition execution.
1207
1208 *
1209 "Whether the execution of the remote subprogram is
1210 immediately aborted as a result of cancellation. See E.4(13)."
1211
1212 See the GLADE reference manual for details on the effect of abort in
1213 a distributed application.
1214
1215 *
1216 "The range of type System.RPC.Partition_Id. See E.5(14)."
1217
1218 System.RPC.Partition_ID'Last is Integer'Last. See source file :file:`s-rpc.ads`.
1219
1220 *
1221 "Implementation-defined interfaces in the PCS. See E.5(26)."
1222
1223 See the GLADE reference manual for a full description of all
1224 implementation defined interfaces.
1225
1226 *
1227 "The values of named numbers in the package
1228 ``Decimal``. See F.2(7)."
1229
1230 ==================== ==========
1231 Named Number Value
1232 ==================== ==========
1233 *Max_Scale* +18
1234 *Min_Scale* -18
1235 *Min_Delta* 1.0E-18
1236 *Max_Delta* 1.0E+18
1237 *Max_Decimal_Digits* 18
1238 ==================== ==========
1239
1240 *
1241 "The value of ``Max_Picture_Length`` in the package
1242 ``Text_IO.Editing``. See F.3.3(16)."
1243
1244 64
1245
1246 *
1247 "The value of ``Max_Picture_Length`` in the package
1248 ``Wide_Text_IO.Editing``. See F.3.4(5)."
1249
1250 64
1251
1252 *
1253 "The accuracy actually achieved by the complex elementary
1254 functions and by other complex arithmetic operations. See G.1(1)."
1255
1256 Standard library functions are used for the complex arithmetic
1257 operations. Only fast math mode is currently supported.
1258
1259 *
1260 "The sign of a zero result (or a component thereof) from
1261 any operator or function in ``Numerics.Generic_Complex_Types``, when
1262 ``Real'Signed_Zeros`` is True. See G.1.1(53)."
1263
1264 The signs of zero values are as recommended by the relevant
1265 implementation advice.
1266
1267 *
1268 "The sign of a zero result (or a component thereof) from
1269 any operator or function in
1270 ``Numerics.Generic_Complex_Elementary_Functions``, when
1271 ``Real'Signed_Zeros`` is ``True``. See G.1.2(45)."
1272
1273 The signs of zero values are as recommended by the relevant
1274 implementation advice.
1275
1276 *
1277 "Whether the strict mode or the relaxed mode is the
1278 default. See G.2(2)."
1279
1280 The strict mode is the default. There is no separate relaxed mode. GNAT
1281 provides a highly efficient implementation of strict mode.
1282
1283 *
1284 "The result interval in certain cases of fixed-to-float
1285 conversion. See G.2.1(10)."
1286
1287 For cases where the result interval is implementation dependent, the
1288 accuracy is that provided by performing all operations in 64-bit IEEE
1289 floating-point format.
1290
1291 *
1292 "The result of a floating point arithmetic operation in
1293 overflow situations, when the ``Machine_Overflows`` attribute of the
1294 result type is ``False``. See G.2.1(13)."
1295
1296 Infinite and NaN values are produced as dictated by the IEEE
1297 floating-point standard.
1298 Note that on machines that are not fully compliant with the IEEE
1299 floating-point standard, such as Alpha, the *-mieee* compiler flag
1300 must be used for achieving IEEE conforming behavior (although at the cost
1301 of a significant performance penalty), so infinite and NaN values are
1302 properly generated.
1303
1304 *
1305 "The result interval for division (or exponentiation by a
1306 negative exponent), when the floating point hardware implements division
1307 as multiplication by a reciprocal. See G.2.1(16)."
1308
1309 Not relevant, division is IEEE exact.
1310
1311 *
1312 "The definition of close result set, which determines the accuracy of
1313 certain fixed point multiplications and divisions. See G.2.3(5)."
1314
1315 Operations in the close result set are performed using IEEE long format
1316 floating-point arithmetic. The input operands are converted to
1317 floating-point, the operation is done in floating-point, and the result
1318 is converted to the target type.
1319
1320 *
1321 "Conditions on a *universal_real* operand of a fixed
1322 point multiplication or division for which the result shall be in the
1323 perfect result set. See G.2.3(22)."
1324
1325 The result is only defined to be in the perfect result set if the result
1326 can be computed by a single scaling operation involving a scale factor
1327 representable in 64 bits.
1328
1329 *
1330 "The result of a fixed point arithmetic operation in
1331 overflow situations, when the ``Machine_Overflows`` attribute of the
1332 result type is ``False``. See G.2.3(27)."
1333
1334 Not relevant, ``Machine_Overflows`` is ``True`` for fixed-point
1335 types.
1336
1337 *
1338 "The result of an elementary function reference in
1339 overflow situations, when the ``Machine_Overflows`` attribute of the
1340 result type is ``False``. See G.2.4(4)."
1341
1342 IEEE infinite and Nan values are produced as appropriate.
1343
1344 *
1345 "The value of the angle threshold, within which certain
1346 elementary functions, complex arithmetic operations, and complex
1347 elementary functions yield results conforming to a maximum relative
1348 error bound. See G.2.4(10)."
1349
1350 Information on this subject is not yet available.
1351
1352 *
1353 "The accuracy of certain elementary functions for
1354 parameters beyond the angle threshold. See G.2.4(10)."
1355
1356 Information on this subject is not yet available.
1357
1358 *
1359 "The result of a complex arithmetic operation or complex
1360 elementary function reference in overflow situations, when the
1361 ``Machine_Overflows`` attribute of the corresponding real type is
1362 ``False``. See G.2.6(5)."
1363
1364 IEEE infinite and Nan values are produced as appropriate.
1365
1366 *
1367 "The accuracy of certain complex arithmetic operations and
1368 certain complex elementary functions for parameters (or components
1369 thereof) beyond the angle threshold. See G.2.6(8)."
1370
1371 Information on those subjects is not yet available.
1372
1373 *
1374 "The accuracy requirements for the subprograms Solve, Inverse,
1375 Determinant, Eigenvalues and Eigensystem for type Real_Matrix.
1376 See G.3.1(81)."
1377
1378 Information on those subjects is not yet available.
1379
1380 *
1381 "The accuracy requirements for the subprograms Solve, Inverse,
1382 Determinant, Eigenvalues and Eigensystem for type Complex_Matrix.
1383 See G.3.2(149)."
1384
1385 Information on those subjects is not yet available.
1386
1387 *
1388 "The consequences of violating No_Hidden_Indirect_Globals. See H.4(23.9)."
1389
1390 Execution is erroneous in that case.