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