Debian Codegraph @

gcc/ada/doc/gnat_rm/standard_library_routines.rst

raw
1 .. _Standard_Library_Routines:
2
3 *************************
4 Standard Library Routines
5 *************************
6
7 The Ada Reference Manual contains in Annex A a full description of an
8 extensive set of standard library routines that can be used in any Ada
9 program, and which must be provided by all Ada compilers. They are
10 analogous to the standard C library used by C programs.
11
12 GNAT implements all of the facilities described in annex A, and for most
13 purposes the description in the Ada Reference Manual, or appropriate Ada
14 text book, will be sufficient for making use of these facilities.
15
16 In the case of the input-output facilities,
17 :ref:`The_Implementation_of_Standard_I/O`,
18 gives details on exactly how GNAT interfaces to the
19 file system. For the remaining packages, the Ada Reference Manual
20 should be sufficient. The following is a list of the packages included,
21 together with a brief description of the functionality that is provided.
22
23 For completeness, references are included to other predefined library
24 routines defined in other sections of the Ada Reference Manual (these are
25 cross-indexed from Annex A). For further details see the relevant
26 package declarations in the run-time library. In particular, a few units
27 are not implemented, as marked by the presence of pragma Unimplemented_Unit,
28 and in this case the package declaration contains comments explaining why
29 the unit is not implemented.
30
31
32
33 ``Ada`` *(A.2)*
34 This is a parent package for all the standard library packages. It is
35 usually included implicitly in your program, and itself contains no
36 useful data or routines.
37
38
39 ``Ada.Assertions`` *(11.4.2)*
40 ``Assertions`` provides the ``Assert`` subprograms, and also
41 the declaration of the ``Assertion_Error`` exception.
42
43
44 ``Ada.Asynchronous_Task_Control`` *(D.11)*
45 ``Asynchronous_Task_Control`` provides low level facilities for task
46 synchronization. It is typically not implemented. See package spec for details.
47
48
49 ``Ada.Calendar`` *(9.6)*
50 ``Calendar`` provides time of day access, and routines for
51 manipulating times and durations.
52
53
54 ``Ada.Calendar.Arithmetic`` *(9.6.1)*
55 This package provides additional arithmetic
56 operations for ``Calendar``.
57
58
59 ``Ada.Calendar.Formatting`` *(9.6.1)*
60 This package provides formatting operations for ``Calendar``.
61
62
63 ``Ada.Calendar.Time_Zones`` *(9.6.1)*
64 This package provides additional ``Calendar`` facilities
65 for handling time zones.
66
67
68 ``Ada.Characters`` *(A.3.1)*
69 This is a dummy parent package that contains no useful entities
70
71
72 ``Ada.Characters.Conversions`` *(A.3.2)*
73 This package provides character conversion functions.
74
75
76 ``Ada.Characters.Handling`` *(A.3.2)*
77 This package provides some basic character handling capabilities,
78 including classification functions for classes of characters (e.g., test
79 for letters, or digits).
80
81
82 ``Ada.Characters.Latin_1`` *(A.3.3)*
83 This package includes a complete set of definitions of the characters
84 that appear in type CHARACTER. It is useful for writing programs that
85 will run in international environments. For example, if you want an
86 upper case E with an acute accent in a string, it is often better to use
87 the definition of ``UC_E_Acute`` in this package. Then your program
88 will print in an understandable manner even if your environment does not
89 support these extended characters.
90
91
92 ``Ada.Command_Line`` *(A.15)*
93 This package provides access to the command line parameters and the name
94 of the current program (analogous to the use of ``argc`` and ``argv``
95 in C), and also allows the exit status for the program to be set in a
96 system-independent manner.
97
98
99 ``Ada.Complex_Text_IO`` *(G.1.3)*
100 This package provides text input and output of complex numbers.
101
102
103 ``Ada.Containers`` *(A.18.1)*
104 A top level package providing a few basic definitions used by all the
105 following specific child packages that provide specific kinds of
106 containers.
107
108 ``Ada.Containers.Bounded_Priority_Queues`` *(A.18.31)*
109
110 ``Ada.Containers.Bounded_Synchronized_Queues`` *(A.18.29)*
111
112 ``Ada.Containers.Doubly_Linked_Lists`` *(A.18.3)*
113
114 ``Ada.Containers.Generic_Array_Sort`` *(A.18.26)*
115
116 ``Ada.Containers.Generic_Constrained_Array_Sort`` *(A.18.26)*
117
118 ``Ada.Containers.Generic_Sort`` *(A.18.26)*
119
120 ``Ada.Containers.Hashed_Maps`` *(A.18.5)*
121
122 ``Ada.Containers.Hashed_Sets`` *(A.18.8)*
123
124 ``Ada.Containers.Indefinite_Doubly_Linked_Lists`` *(A.18.12)*
125
126 ``Ada.Containers.Indefinite_Hashed_Maps`` *(A.18.13)*
127
128 ``Ada.Containers.Indefinite_Hashed_Sets`` *(A.18.15)*
129
130 ``Ada.Containers.Indefinite_Holders`` *(A.18.18)*
131
132 ``Ada.Containers.Indefinite_Multiway_Trees`` *(A.18.17)*
133
134 ``Ada.Containers.Indefinite_Ordered_Maps`` *(A.18.14)*
135
136 ``Ada.Containers.Indefinite_Ordered_Sets`` *(A.18.16)*
137
138 ``Ada.Containers.Indefinite_Vectors`` *(A.18.11)*
139
140 ``Ada.Containers.Multiway_Trees`` *(A.18.10)*
141
142 ``Ada.Containers.Ordered_Maps`` *(A.18.6)*
143
144 ``Ada.Containers.Ordered_Sets`` *(A.18.9)*
145
146 ``Ada.Containers.Synchronized_Queue_Interfaces`` *(A.18.27)*
147
148 ``Ada.Containers.Unbounded_Priority_Queues`` *(A.18.30)*
149
150 ``Ada.Containers.Unbounded_Synchronized_Queues`` *(A.18.28)*
151
152 ``Ada.Containers.Vectors`` *(A.18.2)*
153
154 ``Ada.Directories`` *(A.16)*
155 This package provides operations on directories.
156
157
158 ``Ada.Directories.Hierarchical_File_Names`` *(A.16.1)*
159 This package provides additional directory operations handling
160 hiearchical file names.
161
162
163 ``Ada.Directories.Information`` *(A.16)*
164 This is an implementation defined package for additional directory
165 operations, which is not implemented in GNAT.
166
167
168 ``Ada.Decimal`` *(F.2)*
169 This package provides constants describing the range of decimal numbers
170 implemented, and also a decimal divide routine (analogous to the COBOL
171 verb DIVIDE ... GIVING ... REMAINDER ...)
172
173
174 ``Ada.Direct_IO`` *(A.8.4)*
175 This package provides input-output using a model of a set of records of
176 fixed-length, containing an arbitrary definite Ada type, indexed by an
177 integer record number.
178
179
180 ``Ada.Dispatching`` *(D.2.1)*
181 A parent package containing definitions for task dispatching operations.
182
183
184 ``Ada.Dispatching.EDF`` *(D.2.6)*
185 Not implemented in GNAT.
186
187
188 ``Ada.Dispatching.Non_Preemptive`` *(D.2.4)*
189 Not implemented in GNAT.
190
191
192 ``Ada.Dispatching.Round_Robin`` *(D.2.5)*
193 Not implemented in GNAT.
194
195
196 ``Ada.Dynamic_Priorities`` *(D.5)*
197 This package allows the priorities of a task to be adjusted dynamically
198 as the task is running.
199
200
201 ``Ada.Environment_Variables`` *(A.17)*
202 This package provides facilities for accessing environment variables.
203
204
205 ``Ada.Exceptions`` *(11.4.1)*
206 This package provides additional information on exceptions, and also
207 contains facilities for treating exceptions as data objects, and raising
208 exceptions with associated messages.
209
210
211 ``Ada.Execution_Time`` *(D.14)*
212 This package provides CPU clock functionalities. It is not implemented on
213 all targets (see package spec for details).
214
215
216 ``Ada.Execution_Time.Group_Budgets`` *(D.14.2)*
217 Not implemented in GNAT.
218
219
220 ``Ada.Execution_Time.Timers`` *(D.14.1)'*
221 Not implemented in GNAT.
222
223
224 ``Ada.Finalization`` *(7.6)*
225 This package contains the declarations and subprograms to support the
226 use of controlled types, providing for automatic initialization and
227 finalization (analogous to the constructors and destructors of C++).
228
229
230 ``Ada.Float_Text_IO`` *(A.10.9)*
231 A library level instantiation of Text_IO.Float_IO for type Float.
232
233
234 ``Ada.Float_Wide_Text_IO`` *(A.10.9)*
235 A library level instantiation of Wide_Text_IO.Float_IO for type Float.
236
237
238 ``Ada.Float_Wide_Wide_Text_IO`` *(A.10.9)*
239 A library level instantiation of Wide_Wide_Text_IO.Float_IO for type Float.
240
241
242 ``Ada.Integer_Text_IO`` *(A.10.9)*
243 A library level instantiation of Text_IO.Integer_IO for type Integer.
244
245
246 ``Ada.Integer_Wide_Text_IO`` *(A.10.9)*
247 A library level instantiation of Wide_Text_IO.Integer_IO for type Integer.
248
249
250 ``Ada.Integer_Wide_Wide_Text_IO`` *(A.10.9)*
251 A library level instantiation of Wide_Wide_Text_IO.Integer_IO for type Integer.
252
253
254 ``Ada.Interrupts`` *(C.3.2)*
255 This package provides facilities for interfacing to interrupts, which
256 includes the set of signals or conditions that can be raised and
257 recognized as interrupts.
258
259
260 ``Ada.Interrupts.Names`` *(C.3.2)*
261 This package provides the set of interrupt names (actually signal
262 or condition names) that can be handled by GNAT.
263
264
265 ``Ada.IO_Exceptions`` *(A.13)*
266 This package defines the set of exceptions that can be raised by use of
267 the standard IO packages.
268
269
270 ``Ada.Iterator_Interfaces`` *(5.5.1)*
271 This package provides a generic interface to generalized iterators.
272
273
274 ``Ada.Locales`` *(A.19)*
275 This package provides declarations providing information (Language
276 and Country) about the current locale.
277
278
279 ``Ada.Numerics``
280 This package contains some standard constants and exceptions used
281 throughout the numerics packages. Note that the constants pi and e are
282 defined here, and it is better to use these definitions than rolling
283 your own.
284
285
286 ``Ada.Numerics.Complex_Arrays`` *(G.3.2)*
287 Provides operations on arrays of complex numbers.
288
289
290 ``Ada.Numerics.Complex_Elementary_Functions``
291 Provides the implementation of standard elementary functions (such as
292 log and trigonometric functions) operating on complex numbers using the
293 standard ``Float`` and the ``Complex`` and ``Imaginary`` types
294 created by the package ``Numerics.Complex_Types``.
295
296
297 ``Ada.Numerics.Complex_Types``
298 This is a predefined instantiation of
299 ``Numerics.Generic_Complex_Types`` using ``Standard.Float`` to
300 build the type ``Complex`` and ``Imaginary``.
301
302
303 ``Ada.Numerics.Discrete_Random``
304 This generic package provides a random number generator suitable for generating
305 uniformly distributed values of a specified discrete subtype.
306
307
308 ``Ada.Numerics.Float_Random``
309 This package provides a random number generator suitable for generating
310 uniformly distributed floating point values in the unit interval.
311
312
313 ``Ada.Numerics.Generic_Complex_Elementary_Functions``
314 This is a generic version of the package that provides the
315 implementation of standard elementary functions (such as log and
316 trigonometric functions) for an arbitrary complex type.
317
318 The following predefined instantiations of this package are provided:
319
320 * ``Short_Float``
321
322 ``Ada.Numerics.Short_Complex_Elementary_Functions``
323
324 * ``Float``
325
326 ``Ada.Numerics.Complex_Elementary_Functions``
327
328 * ``Long_Float``
329
330 ``Ada.Numerics.Long_Complex_Elementary_Functions``
331
332 ``Ada.Numerics.Generic_Complex_Types``
333 This is a generic package that allows the creation of complex types,
334 with associated complex arithmetic operations.
335
336 The following predefined instantiations of this package exist
337
338 * ``Short_Float``
339
340 ``Ada.Numerics.Short_Complex_Complex_Types``
341
342 * ``Float``
343
344 ``Ada.Numerics.Complex_Complex_Types``
345
346 * ``Long_Float``
347
348 ``Ada.Numerics.Long_Complex_Complex_Types``
349
350 ``Ada.Numerics.Generic_Elementary_Functions``
351 This is a generic package that provides the implementation of standard
352 elementary functions (such as log an trigonometric functions) for an
353 arbitrary float type.
354
355 The following predefined instantiations of this package exist
356
357 * ``Short_Float``
358
359 ``Ada.Numerics.Short_Elementary_Functions``
360
361 * ``Float``
362
363 ``Ada.Numerics.Elementary_Functions``
364
365 * ``Long_Float``
366
367 ``Ada.Numerics.Long_Elementary_Functions``
368
369 ``Ada.Numerics.Generic_Real_Arrays`` *(G.3.1)*
370 Generic operations on arrays of reals
371
372 ``Ada.Numerics.Real_Arrays`` *(G.3.1)*
373 Preinstantiation of Ada.Numerics.Generic_Real_Arrays (Float).
374
375 ``Ada.Real_Time`` *(D.8)*
376 This package provides facilities similar to those of ``Calendar``, but
377 operating with a finer clock suitable for real time control. Note that
378 annex D requires that there be no backward clock jumps, and GNAT generally
379 guarantees this behavior, but of course if the external clock on which
380 the GNAT runtime depends is deliberately reset by some external event,
381 then such a backward jump may occur.
382
383 ``Ada.Real_Time.Timing_Events`` *(D.15)*
384 Not implemented in GNAT.
385
386 ``Ada.Sequential_IO`` *(A.8.1)*
387 This package provides input-output facilities for sequential files,
388 which can contain a sequence of values of a single type, which can be
389 any Ada type, including indefinite (unconstrained) types.
390
391 ``Ada.Storage_IO`` *(A.9)*
392 This package provides a facility for mapping arbitrary Ada types to and
393 from a storage buffer. It is primarily intended for the creation of new
394 IO packages.
395
396 ``Ada.Streams`` *(13.13.1)*
397 This is a generic package that provides the basic support for the
398 concept of streams as used by the stream attributes (``Input``,
399 ``Output``, ``Read`` and ``Write``).
400
401 ``Ada.Streams.Stream_IO`` *(A.12.1)*
402 This package is a specialization of the type ``Streams`` defined in
403 package ``Streams`` together with a set of operations providing
404 Stream_IO capability. The Stream_IO model permits both random and
405 sequential access to a file which can contain an arbitrary set of values
406 of one or more Ada types.
407
408 ``Ada.Strings`` *(A.4.1)*
409 This package provides some basic constants used by the string handling
410 packages.
411
412
413 ``Ada.Strings.Bounded`` *(A.4.4)*
414 This package provides facilities for handling variable length
415 strings. The bounded model requires a maximum length. It is thus
416 somewhat more limited than the unbounded model, but avoids the use of
417 dynamic allocation or finalization.
418
419 ``Ada.Strings.Bounded.Equal_Case_Insensitive`` *(A.4.10)*
420 Provides case-insensitive comparisons of bounded strings
421
422 ``Ada.Strings.Bounded.Hash`` *(A.4.9)*
423 This package provides a generic hash function for bounded strings
424
425 ``Ada.Strings.Bounded.Hash_Case_Insensitive`` *(A.4.9)*
426 This package provides a generic hash function for bounded strings that
427 converts the string to be hashed to lower case.
428
429 ``Ada.Strings.Bounded.Less_Case_Insensitive`` *(A.4.10)*
430 This package provides a comparison function for bounded strings that works
431 in a case insensitive manner by converting to lower case before the comparison.
432
433 ``Ada.Strings.Fixed`` *(A.4.3)*
434 This package provides facilities for handling fixed length strings.
435
436 ``Ada.Strings.Fixed.Equal_Case_Insensitive`` *(A.4.10)*
437 This package provides an equality function for fixed strings that compares
438 the strings after converting both to lower case.
439
440 ``Ada.Strings.Fixed.Hash_Case_Insensitive`` *(A.4.9)*
441 This package provides a case insensitive hash function for fixed strings that
442 converts the string to lower case before computing the hash.
443
444 ``Ada.Strings.Fixed.Less_Case_Insensitive`` *(A.4.10)*
445 This package provides a comparison function for fixed strings that works
446 in a case insensitive manner by converting to lower case before the comparison.
447
448 ``Ada.Strings.Hash`` *(A.4.9)*
449 This package provides a hash function for strings.
450
451 ``Ada.Strings.Hash_Case_Insensitive`` *(A.4.9)*
452 This package provides a hash function for strings that is case insensitive.
453 The string is converted to lower case before computing the hash.
454
455 ``Ada.Strings.Less_Case_Insensitive`` *(A.4.10)*
456 This package provides a comparison function for\\strings that works
457 in a case insensitive manner by converting to lower case before the comparison.
458
459 ``Ada.Strings.Maps`` *(A.4.2)*
460 This package provides facilities for handling character mappings and
461 arbitrarily defined subsets of characters. For instance it is useful in
462 defining specialized translation tables.
463
464 ``Ada.Strings.Maps.Constants`` *(A.4.6)*
465 This package provides a standard set of predefined mappings and
466 predefined character sets. For example, the standard upper to lower case
467 conversion table is found in this package. Note that upper to lower case
468 conversion is non-trivial if you want to take the entire set of
469 characters, including extended characters like E with an acute accent,
470 into account. You should use the mappings in this package (rather than
471 adding 32 yourself) to do case mappings.
472
473 ``Ada.Strings.Unbounded`` *(A.4.5)*
474 This package provides facilities for handling variable length
475 strings. The unbounded model allows arbitrary length strings, but
476 requires the use of dynamic allocation and finalization.
477
478 ``Ada.Strings.Unbounded.Equal_Case_Insensitive`` *(A.4.10)*
479 Provides case-insensitive comparisons of unbounded strings
480
481 ``Ada.Strings.Unbounded.Hash`` *(A.4.9)*
482 This package provides a generic hash function for unbounded strings
483
484 ``Ada.Strings.Unbounded.Hash_Case_Insensitive`` *(A.4.9)*
485 This package provides a generic hash function for unbounded strings that
486 converts the string to be hashed to lower case.
487
488 ``Ada.Strings.Unbounded.Less_Case_Insensitive`` *(A.4.10)*
489 This package provides a comparison function for unbounded strings that works
490 in a case insensitive manner by converting to lower case before the comparison.
491
492 ``Ada.Strings.UTF_Encoding`` *(A.4.11)*
493 This package provides basic definitions for dealing with UTF-encoded strings.
494
495 ``Ada.Strings.UTF_Encoding.Conversions`` *(A.4.11)*
496 This package provides conversion functions for UTF-encoded strings.
497
498 ``Ada.Strings.UTF_Encoding.Strings`` *(A.4.11)*
499
500 ``Ada.Strings.UTF_Encoding.Wide_Strings`` *(A.4.11)*
501
502 ``Ada.Strings.UTF_Encoding.Wide_Wide_Strings`` *(A.4.11)*
503 These packages provide facilities for handling UTF encodings for
504 Strings, Wide_Strings and Wide_Wide_Strings.
505
506 ``Ada.Strings.Wide_Bounded`` *(A.4.7)*
507
508 ``Ada.Strings.Wide_Fixed`` *(A.4.7)*
509
510 ``Ada.Strings.Wide_Maps`` *(A.4.7)*
511
512 ``Ada.Strings.Wide_Unbounded`` *(A.4.7)*
513 These packages provide analogous capabilities to the corresponding
514 packages without ``Wide_`` in the name, but operate with the types
515 ``Wide_String`` and ``Wide_Character`` instead of ``String``
516 and ``Character``. Versions of all the child packages are available.
517
518 ``Ada.Strings.Wide_Wide_Bounded`` *(A.4.7)*
519
520 ``Ada.Strings.Wide_Wide_Fixed`` *(A.4.7)*
521
522 ``Ada.Strings.Wide_Wide_Maps`` *(A.4.7)*
523
524 ``Ada.Strings.Wide_Wide_Unbounded`` *(A.4.7)*
525 These packages provide analogous capabilities to the corresponding
526 packages without ``Wide_`` in the name, but operate with the types
527 ``Wide_Wide_String`` and ``Wide_Wide_Character`` instead
528 of ``String`` and ``Character``.
529
530 ``Ada.Synchronous_Barriers`` *(D.10.1)*
531 This package provides facilities for synchronizing tasks at a low level
532 with barriers.
533
534 ``Ada.Synchronous_Task_Control`` *(D.10)*
535 This package provides some standard facilities for controlling task
536 communication in a synchronous manner.
537
538 ``Ada.Synchronous_Task_Control.EDF`` *(D.10)*
539 Not implemented in GNAT.
540
541 ``Ada.Tags``
542 This package contains definitions for manipulation of the tags of tagged
543 values.
544
545 ``Ada.Tags.Generic_Dispatching_Constructor`` *(3.9)*
546 This package provides a way of constructing tagged class-wide values given
547 only the tag value.
548
549 ``Ada.Task_Attributes`` *(C.7.2)*
550 This package provides the capability of associating arbitrary
551 task-specific data with separate tasks.
552
553 ``Ada.Task_Identifification`` *(C.7.1)*
554 This package provides capabilities for task identification.
555
556 ``Ada.Task_Termination`` *(C.7.3)*
557 This package provides control over task termination.
558
559 ``Ada.Text_IO``
560 This package provides basic text input-output capabilities for
561 character, string and numeric data. The subpackages of this
562 package are listed next. Note that although these are defined
563 as subpackages in the RM, they are actually transparently
564 implemented as child packages in GNAT, meaning that they
565 are only loaded if needed.
566
567 ``Ada.Text_IO.Decimal_IO``
568 Provides input-output facilities for decimal fixed-point types
569
570 ``Ada.Text_IO.Enumeration_IO``
571 Provides input-output facilities for enumeration types.
572
573 ``Ada.Text_IO.Fixed_IO``
574 Provides input-output facilities for ordinary fixed-point types.
575
576 ``Ada.Text_IO.Float_IO``
577 Provides input-output facilities for float types. The following
578 predefined instantiations of this generic package are available:
579
580 * ``Short_Float``
581
582 ``Short_Float_Text_IO``
583
584 * ``Float``
585
586 ``Float_Text_IO``
587
588 * ``Long_Float``
589
590 ``Long_Float_Text_IO``
591
592 ``Ada.Text_IO.Integer_IO``
593 Provides input-output facilities for integer types. The following
594 predefined instantiations of this generic package are available:
595
596 * ``Short_Short_Integer``
597
598 ``Ada.Short_Short_Integer_Text_IO``
599
600 * ``Short_Integer``
601
602 ``Ada.Short_Integer_Text_IO``
603
604 * ``Integer``
605
606 ``Ada.Integer_Text_IO``
607
608 * ``Long_Integer``
609
610 ``Ada.Long_Integer_Text_IO``
611
612 * ``Long_Long_Integer``
613
614 ``Ada.Long_Long_Integer_Text_IO``
615
616 ``Ada.Text_IO.Modular_IO``
617 Provides input-output facilities for modular (unsigned) types.
618
619 ``Ada.Text_IO.Bounded_IO (A.10.11)``
620 Provides input-output facilities for bounded strings.
621
622 ``Ada.Text_IO.Complex_IO (G.1.3)``
623 This package provides basic text input-output capabilities for complex
624 data.
625
626 ``Ada.Text_IO.Editing (F.3.3)``
627 This package contains routines for edited output, analogous to the use
628 of pictures in COBOL. The picture formats used by this package are a
629 close copy of the facility in COBOL.
630
631 ``Ada.Text_IO.Text_Streams (A.12.2)``
632 This package provides a facility that allows Text_IO files to be treated
633 as streams, so that the stream attributes can be used for writing
634 arbitrary data, including binary data, to Text_IO files.
635
636 ``Ada.Text_IO.Unbounded_IO (A.10.12)``
637 This package provides input-output facilities for unbounded strings.
638
639 ``Ada.Unchecked_Conversion (13.9)``
640 This generic package allows arbitrary conversion from one type to
641 another of the same size, providing for breaking the type safety in
642 special circumstances.
643
644 If the types have the same Size (more accurately the same Value_Size),
645 then the effect is simply to transfer the bits from the source to the
646 target type without any modification. This usage is well defined, and
647 for simple types whose representation is typically the same across
648 all implementations, gives a portable method of performing such
649 conversions.
650
651 If the types do not have the same size, then the result is implementation
652 defined, and thus may be non-portable. The following describes how GNAT
653 handles such unchecked conversion cases.
654
655 If the types are of different sizes, and are both discrete types, then
656 the effect is of a normal type conversion without any constraint checking.
657 In particular if the result type has a larger size, the result will be
658 zero or sign extended. If the result type has a smaller size, the result
659 will be truncated by ignoring high order bits.
660
661 If the types are of different sizes, and are not both discrete types,
662 then the conversion works as though pointers were created to the source
663 and target, and the pointer value is converted. The effect is that bits
664 are copied from successive low order storage units and bits of the source
665 up to the length of the target type.
666
667 A warning is issued if the lengths differ, since the effect in this
668 case is implementation dependent, and the above behavior may not match
669 that of some other compiler.
670
671 A pointer to one type may be converted to a pointer to another type using
672 unchecked conversion. The only case in which the effect is undefined is
673 when one or both pointers are pointers to unconstrained array types. In
674 this case, the bounds information may get incorrectly transferred, and in
675 particular, GNAT uses double size pointers for such types, and it is
676 meaningless to convert between such pointer types. GNAT will issue a
677 warning if the alignment of the target designated type is more strict
678 than the alignment of the source designated type (since the result may
679 be unaligned in this case).
680
681 A pointer other than a pointer to an unconstrained array type may be
682 converted to and from System.Address. Such usage is common in Ada 83
683 programs, but note that Ada.Address_To_Access_Conversions is the
684 preferred method of performing such conversions in Ada 95 and Ada 2005.
685 Neither
686 unchecked conversion nor Ada.Address_To_Access_Conversions should be
687 used in conjunction with pointers to unconstrained objects, since
688 the bounds information cannot be handled correctly in this case.
689
690 ``Ada.Unchecked_Deallocation`` *(13.11.2)*
691 This generic package allows explicit freeing of storage previously
692 allocated by use of an allocator.
693
694 ``Ada.Wide_Text_IO`` *(A.11)*
695 This package is similar to ``Ada.Text_IO``, except that the external
696 file supports wide character representations, and the internal types are
697 ``Wide_Character`` and ``Wide_String`` instead of ``Character``
698 and ``String``. The corresponding set of nested packages and child
699 packages are defined.
700
701 ``Ada.Wide_Wide_Text_IO`` *(A.11)*
702 This package is similar to ``Ada.Text_IO``, except that the external
703 file supports wide character representations, and the internal types are
704 ``Wide_Character`` and ``Wide_String`` instead of ``Character``
705 and ``String``. The corresponding set of nested packages and child
706 packages are defined.
707
708 For packages in Interfaces and System, all the RM defined packages are
709 available in GNAT, see the Ada 2012 RM for full details.