1.. _Standard_Library_Routines: 2 3************************* 4Standard Library Routines 5************************* 6 7The Ada Reference Manual contains in Annex A a full description of an 8extensive set of standard library routines that can be used in any Ada 9program, and which must be provided by all Ada compilers. They are 10analogous to the standard C library used by C programs. 11 12GNAT implements all of the facilities described in annex A, and for most 13purposes the description in the Ada Reference Manual, or appropriate Ada 14text book, will be sufficient for making use of these facilities. 15 16In the case of the input-output facilities, 17:ref:`The_Implementation_of_Standard_I/O`, 18gives details on exactly how GNAT interfaces to the 19file system. For the remaining packages, the Ada Reference Manual 20should be sufficient. The following is a list of the packages included, 21together with a brief description of the functionality that is provided. 22 23For completeness, references are included to other predefined library 24routines defined in other sections of the Ada Reference Manual (these are 25cross-indexed from Annex A). For further details see the relevant 26package declarations in the run-time library. In particular, a few units 27are not implemented, as marked by the presence of pragma Unimplemented_Unit, 28and in this case the package declaration contains comments explaining why 29the 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. This package is currently not 277 implemented other than by providing stubs which will always return 278 Language_Unknown/Country_Unknown. 279 280 281``Ada.Numerics`` 282 This package contains some standard constants and exceptions used 283 throughout the numerics packages. Note that the constants pi and e are 284 defined here, and it is better to use these definitions than rolling 285 your own. 286 287 288``Ada.Numerics.Complex_Arrays`` *(G.3.2)* 289 Provides operations on arrays of complex numbers. 290 291 292``Ada.Numerics.Complex_Elementary_Functions`` 293 Provides the implementation of standard elementary functions (such as 294 log and trigonometric functions) operating on complex numbers using the 295 standard ``Float`` and the ``Complex`` and ``Imaginary`` types 296 created by the package ``Numerics.Complex_Types``. 297 298 299``Ada.Numerics.Complex_Types`` 300 This is a predefined instantiation of 301 ``Numerics.Generic_Complex_Types`` using ``Standard.Float`` to 302 build the type ``Complex`` and ``Imaginary``. 303 304 305``Ada.Numerics.Discrete_Random`` 306 This generic package provides a random number generator suitable for generating 307 uniformly distributed values of a specified discrete subtype. 308 309 310``Ada.Numerics.Float_Random`` 311 This package provides a random number generator suitable for generating 312 uniformly distributed floating point values in the unit interval. 313 314 315``Ada.Numerics.Generic_Complex_Elementary_Functions`` 316 This is a generic version of the package that provides the 317 implementation of standard elementary functions (such as log and 318 trigonometric functions) for an arbitrary complex type. 319 320 The following predefined instantiations of this package are provided: 321 322 * ``Short_Float`` 323 324 ``Ada.Numerics.Short_Complex_Elementary_Functions`` 325 326 * ``Float`` 327 328 ``Ada.Numerics.Complex_Elementary_Functions`` 329 330 * ``Long_Float`` 331 332 ``Ada.Numerics.Long_Complex_Elementary_Functions`` 333 334``Ada.Numerics.Generic_Complex_Types`` 335 This is a generic package that allows the creation of complex types, 336 with associated complex arithmetic operations. 337 338 The following predefined instantiations of this package exist 339 340 * ``Short_Float`` 341 342 ``Ada.Numerics.Short_Complex_Complex_Types`` 343 344 * ``Float`` 345 346 ``Ada.Numerics.Complex_Complex_Types`` 347 348 * ``Long_Float`` 349 350 ``Ada.Numerics.Long_Complex_Complex_Types`` 351 352``Ada.Numerics.Generic_Elementary_Functions`` 353 This is a generic package that provides the implementation of standard 354 elementary functions (such as log an trigonometric functions) for an 355 arbitrary float type. 356 357 The following predefined instantiations of this package exist 358 359 * ``Short_Float`` 360 361 ``Ada.Numerics.Short_Elementary_Functions`` 362 363 * ``Float`` 364 365 ``Ada.Numerics.Elementary_Functions`` 366 367 * ``Long_Float`` 368 369 ``Ada.Numerics.Long_Elementary_Functions`` 370 371``Ada.Numerics.Generic_Real_Arrays`` *(G.3.1)* 372 Generic operations on arrays of reals 373 374``Ada.Numerics.Real_Arrays`` *(G.3.1)* 375 Preinstantiation of Ada.Numerics.Generic_Real_Arrays (Float). 376 377``Ada.Real_Time`` *(D.8)* 378 This package provides facilities similar to those of ``Calendar``, but 379 operating with a finer clock suitable for real time control. Note that 380 annex D requires that there be no backward clock jumps, and GNAT generally 381 guarantees this behavior, but of course if the external clock on which 382 the GNAT runtime depends is deliberately reset by some external event, 383 then such a backward jump may occur. 384 385``Ada.Real_Time.Timing_Events`` *(D.15)* 386 Not implemented in GNAT. 387 388``Ada.Sequential_IO`` *(A.8.1)* 389 This package provides input-output facilities for sequential files, 390 which can contain a sequence of values of a single type, which can be 391 any Ada type, including indefinite (unconstrained) types. 392 393``Ada.Storage_IO`` *(A.9)* 394 This package provides a facility for mapping arbitrary Ada types to and 395 from a storage buffer. It is primarily intended for the creation of new 396 IO packages. 397 398``Ada.Streams`` *(13.13.1)* 399 This is a generic package that provides the basic support for the 400 concept of streams as used by the stream attributes (``Input``, 401 ``Output``, ``Read`` and ``Write``). 402 403``Ada.Streams.Stream_IO`` *(A.12.1)* 404 This package is a specialization of the type ``Streams`` defined in 405 package ``Streams`` together with a set of operations providing 406 Stream_IO capability. The Stream_IO model permits both random and 407 sequential access to a file which can contain an arbitrary set of values 408 of one or more Ada types. 409 410``Ada.Strings`` *(A.4.1)* 411 This package provides some basic constants used by the string handling 412 packages. 413 414 415``Ada.Strings.Bounded`` *(A.4.4)* 416 This package provides facilities for handling variable length 417 strings. The bounded model requires a maximum length. It is thus 418 somewhat more limited than the unbounded model, but avoids the use of 419 dynamic allocation or finalization. 420 421``Ada.Strings.Bounded.Equal_Case_Insensitive`` *(A.4.10)* 422 Provides case-insensitive comparisons of bounded strings 423 424``Ada.Strings.Bounded.Hash`` *(A.4.9)* 425 This package provides a generic hash function for bounded strings 426 427``Ada.Strings.Bounded.Hash_Case_Insensitive`` *(A.4.9)* 428 This package provides a generic hash function for bounded strings that 429 converts the string to be hashed to lower case. 430 431``Ada.Strings.Bounded.Less_Case_Insensitive`` *(A.4.10)* 432 This package provides a comparison function for bounded strings that works 433 in a case insensitive manner by converting to lower case before the comparison. 434 435``Ada.Strings.Fixed`` *(A.4.3)* 436 This package provides facilities for handling fixed length strings. 437 438``Ada.Strings.Fixed.Equal_Case_Insensitive`` *(A.4.10)* 439 This package provides an equality function for fixed strings that compares 440 the strings after converting both to lower case. 441 442``Ada.Strings.Fixed.Hash_Case_Insensitive`` *(A.4.9)* 443 This package provides a case insensitive hash function for fixed strings that 444 converts the string to lower case before computing the hash. 445 446``Ada.Strings.Fixed.Less_Case_Insensitive`` *(A.4.10)* 447 This package provides a comparison function for fixed strings that works 448 in a case insensitive manner by converting to lower case before the comparison. 449 450``Ada.Strings.Hash`` *(A.4.9)* 451 This package provides a hash function for strings. 452 453``Ada.Strings.Hash_Case_Insensitive`` *(A.4.9)* 454 This package provides a hash function for strings that is case insensitive. 455 The string is converted to lower case before computing the hash. 456 457``Ada.Strings.Less_Case_Insensitive`` *(A.4.10)* 458 This package provides a comparison function for\\strings that works 459 in a case insensitive manner by converting to lower case before the comparison. 460 461``Ada.Strings.Maps`` *(A.4.2)* 462 This package provides facilities for handling character mappings and 463 arbitrarily defined subsets of characters. For instance it is useful in 464 defining specialized translation tables. 465 466``Ada.Strings.Maps.Constants`` *(A.4.6)* 467 This package provides a standard set of predefined mappings and 468 predefined character sets. For example, the standard upper to lower case 469 conversion table is found in this package. Note that upper to lower case 470 conversion is non-trivial if you want to take the entire set of 471 characters, including extended characters like E with an acute accent, 472 into account. You should use the mappings in this package (rather than 473 adding 32 yourself) to do case mappings. 474 475``Ada.Strings.Unbounded`` *(A.4.5)* 476 This package provides facilities for handling variable length 477 strings. The unbounded model allows arbitrary length strings, but 478 requires the use of dynamic allocation and finalization. 479 480``Ada.Strings.Unbounded.Equal_Case_Insensitive`` *(A.4.10)* 481 Provides case-insensitive comparisons of unbounded strings 482 483``Ada.Strings.Unbounded.Hash`` *(A.4.9)* 484 This package provides a generic hash function for unbounded strings 485 486``Ada.Strings.Unbounded.Hash_Case_Insensitive`` *(A.4.9)* 487 This package provides a generic hash function for unbounded strings that 488 converts the string to be hashed to lower case. 489 490``Ada.Strings.Unbounded.Less_Case_Insensitive`` *(A.4.10)* 491 This package provides a comparison function for unbounded strings that works 492 in a case insensitive manner by converting to lower case before the comparison. 493 494``Ada.Strings.UTF_Encoding`` *(A.4.11)* 495 This package provides basic definitions for dealing with UTF-encoded strings. 496 497``Ada.Strings.UTF_Encoding.Conversions`` *(A.4.11)* 498 This package provides conversion functions for UTF-encoded strings. 499 500``Ada.Strings.UTF_Encoding.Strings`` *(A.4.11)* 501 502``Ada.Strings.UTF_Encoding.Wide_Strings`` *(A.4.11)* 503 504``Ada.Strings.UTF_Encoding.Wide_Wide_Strings`` *(A.4.11)* 505 These packages provide facilities for handling UTF encodings for 506 Strings, Wide_Strings and Wide_Wide_Strings. 507 508``Ada.Strings.Wide_Bounded`` *(A.4.7)* 509 510``Ada.Strings.Wide_Fixed`` *(A.4.7)* 511 512``Ada.Strings.Wide_Maps`` *(A.4.7)* 513 514``Ada.Strings.Wide_Unbounded`` *(A.4.7)* 515 These packages provide analogous capabilities to the corresponding 516 packages without ``Wide_`` in the name, but operate with the types 517 ``Wide_String`` and ``Wide_Character`` instead of ``String`` 518 and ``Character``. Versions of all the child packages are available. 519 520``Ada.Strings.Wide_Wide_Bounded`` *(A.4.7)* 521 522``Ada.Strings.Wide_Wide_Fixed`` *(A.4.7)* 523 524``Ada.Strings.Wide_Wide_Maps`` *(A.4.7)* 525 526``Ada.Strings.Wide_Wide_Unbounded`` *(A.4.7)* 527 These packages provide analogous capabilities to the corresponding 528 packages without ``Wide_`` in the name, but operate with the types 529 ``Wide_Wide_String`` and ``Wide_Wide_Character`` instead 530 of ``String`` and ``Character``. 531 532``Ada.Synchronous_Barriers`` *(D.10.1)* 533 This package provides facilities for synchronizing tasks at a low level 534 with barriers. 535 536``Ada.Synchronous_Task_Control`` *(D.10)* 537 This package provides some standard facilities for controlling task 538 communication in a synchronous manner. 539 540``Ada.Synchronous_Task_Control.EDF`` *(D.10)* 541 Not implemented in GNAT. 542 543``Ada.Tags`` 544 This package contains definitions for manipulation of the tags of tagged 545 values. 546 547``Ada.Tags.Generic_Dispatching_Constructor`` *(3.9)* 548 This package provides a way of constructing tagged class-wide values given 549 only the tag value. 550 551``Ada.Task_Attributes`` *(C.7.2)* 552 This package provides the capability of associating arbitrary 553 task-specific data with separate tasks. 554 555``Ada.Task_Identifification`` *(C.7.1)* 556 This package provides capabilities for task identification. 557 558``Ada.Task_Termination`` *(C.7.3)* 559 This package provides control over task termination. 560 561``Ada.Text_IO`` 562 This package provides basic text input-output capabilities for 563 character, string and numeric data. The subpackages of this 564 package are listed next. Note that although these are defined 565 as subpackages in the RM, they are actually transparently 566 implemented as child packages in GNAT, meaning that they 567 are only loaded if needed. 568 569``Ada.Text_IO.Decimal_IO`` 570 Provides input-output facilities for decimal fixed-point types 571 572``Ada.Text_IO.Enumeration_IO`` 573 Provides input-output facilities for enumeration types. 574 575``Ada.Text_IO.Fixed_IO`` 576 Provides input-output facilities for ordinary fixed-point types. 577 578``Ada.Text_IO.Float_IO`` 579 Provides input-output facilities for float types. The following 580 predefined instantiations of this generic package are available: 581 582 * ``Short_Float`` 583 584 ``Short_Float_Text_IO`` 585 586 * ``Float`` 587 588 ``Float_Text_IO`` 589 590 * ``Long_Float`` 591 592 ``Long_Float_Text_IO`` 593 594``Ada.Text_IO.Integer_IO`` 595 Provides input-output facilities for integer types. The following 596 predefined instantiations of this generic package are available: 597 598 * ``Short_Short_Integer`` 599 600 ``Ada.Short_Short_Integer_Text_IO`` 601 602 * ``Short_Integer`` 603 604 ``Ada.Short_Integer_Text_IO`` 605 606 * ``Integer`` 607 608 ``Ada.Integer_Text_IO`` 609 610 * ``Long_Integer`` 611 612 ``Ada.Long_Integer_Text_IO`` 613 614 * ``Long_Long_Integer`` 615 616 ``Ada.Long_Long_Integer_Text_IO`` 617 618``Ada.Text_IO.Modular_IO`` 619 Provides input-output facilities for modular (unsigned) types. 620 621``Ada.Text_IO.Bounded_IO (A.10.11)`` 622 Provides input-output facilities for bounded strings. 623 624``Ada.Text_IO.Complex_IO (G.1.3)`` 625 This package provides basic text input-output capabilities for complex 626 data. 627 628``Ada.Text_IO.Editing (F.3.3)`` 629 This package contains routines for edited output, analogous to the use 630 of pictures in COBOL. The picture formats used by this package are a 631 close copy of the facility in COBOL. 632 633``Ada.Text_IO.Text_Streams (A.12.2)`` 634 This package provides a facility that allows Text_IO files to be treated 635 as streams, so that the stream attributes can be used for writing 636 arbitrary data, including binary data, to Text_IO files. 637 638``Ada.Text_IO.Unbounded_IO (A.10.12)`` 639 This package provides input-output facilities for unbounded strings. 640 641``Ada.Unchecked_Conversion (13.9)`` 642 This generic package allows arbitrary conversion from one type to 643 another of the same size, providing for breaking the type safety in 644 special circumstances. 645 646 If the types have the same Size (more accurately the same Value_Size), 647 then the effect is simply to transfer the bits from the source to the 648 target type without any modification. This usage is well defined, and 649 for simple types whose representation is typically the same across 650 all implementations, gives a portable method of performing such 651 conversions. 652 653 If the types do not have the same size, then the result is implementation 654 defined, and thus may be non-portable. The following describes how GNAT 655 handles such unchecked conversion cases. 656 657 If the types are of different sizes, and are both discrete types, then 658 the effect is of a normal type conversion without any constraint checking. 659 In particular if the result type has a larger size, the result will be 660 zero or sign extended. If the result type has a smaller size, the result 661 will be truncated by ignoring high order bits. 662 663 If the types are of different sizes, and are not both discrete types, 664 then the conversion works as though pointers were created to the source 665 and target, and the pointer value is converted. The effect is that bits 666 are copied from successive low order storage units and bits of the source 667 up to the length of the target type. 668 669 A warning is issued if the lengths differ, since the effect in this 670 case is implementation dependent, and the above behavior may not match 671 that of some other compiler. 672 673 A pointer to one type may be converted to a pointer to another type using 674 unchecked conversion. The only case in which the effect is undefined is 675 when one or both pointers are pointers to unconstrained array types. In 676 this case, the bounds information may get incorrectly transferred, and in 677 particular, GNAT uses double size pointers for such types, and it is 678 meaningless to convert between such pointer types. GNAT will issue a 679 warning if the alignment of the target designated type is more strict 680 than the alignment of the source designated type (since the result may 681 be unaligned in this case). 682 683 A pointer other than a pointer to an unconstrained array type may be 684 converted to and from System.Address. Such usage is common in Ada 83 685 programs, but note that Ada.Address_To_Access_Conversions is the 686 preferred method of performing such conversions in Ada 95 and Ada 2005. 687 Neither 688 unchecked conversion nor Ada.Address_To_Access_Conversions should be 689 used in conjunction with pointers to unconstrained objects, since 690 the bounds information cannot be handled correctly in this case. 691 692``Ada.Unchecked_Deallocation`` *(13.11.2)* 693 This generic package allows explicit freeing of storage previously 694 allocated by use of an allocator. 695 696``Ada.Wide_Text_IO`` *(A.11)* 697 This package is similar to ``Ada.Text_IO``, except that the external 698 file supports wide character representations, and the internal types are 699 ``Wide_Character`` and ``Wide_String`` instead of ``Character`` 700 and ``String``. The corresponding set of nested packages and child 701 packages are defined. 702 703``Ada.Wide_Wide_Text_IO`` *(A.11)* 704 This package is similar to ``Ada.Text_IO``, except that the external 705 file supports wide character representations, and the internal types are 706 ``Wide_Character`` and ``Wide_String`` instead of ``Character`` 707 and ``String``. The corresponding set of nested packages and child 708 packages are defined. 709 710For packages in Interfaces and System, all the RM defined packages are 711available in GNAT, see the Ada 2012 RM for full details. 712