gcc/ada/doc/gnat_rm/the_gnat_library.rst

   1 .. role:: switch(samp)
   2
   3 .. _The_GNAT_Library:
   4
   5 ****************
   6 The GNAT Library
   7 ****************
   8
   9 The GNAT library contains a number of general and special purpose packages.
  10 It represents functionality that the GNAT developers have found useful, and
  11 which is made available to GNAT users.  The packages described here are fully
  12 supported, and upwards compatibility will be maintained in future releases,
  13 so you can use these facilities with the confidence that the same functionality
  14 will be available in future releases.
  15
  16 The chapter here simply gives a brief summary of the facilities available.
  17 The full documentation is found in the spec file for the package.  The full
  18 sources of these library packages, including both spec and body, are provided
  19 with all GNAT releases.  For example, to find out the full specifications of
  20 the SPITBOL pattern matching capability, including a full tutorial and
  21 extensive examples, look in the :file:`g-spipat.ads` file in the library.
  22
  23 For each entry here, the package name (as it would appear in a ``with``
  24 clause) is given, followed by the name of the corresponding spec file in
  25 parentheses.  The packages are children in four hierarchies, ``Ada``,
  26 ``Interfaces``, ``System``, and ``GNAT``, the latter being a
  27 GNAT-specific hierarchy.
  28
  29 Note that an application program should only use packages in one of these
  30 four hierarchies if the package is defined in the Ada Reference Manual,
  31 or is listed in this section of the GNAT Programmers Reference Manual.
  32 All other units should be considered internal implementation units and
  33 should not be directly ``with``\ ed by application code.  The use of
  34 a ``with`` clause that references one of these internal implementation
  35 units makes an application potentially dependent on changes in versions
  36 of GNAT, and will generate a warning message.
  37
  38 .. _`Ada.Characters.Latin_9_(a-chlat9.ads)`:
  39
  40 ``Ada.Characters.Latin_9`` (:file:`a-chlat9.ads`)
  41 =================================================
  42
  43 .. index:: Ada.Characters.Latin_9 (a-chlat9.ads)
  44
  45 .. index:: Latin_9 constants for Character
  46
  47 This child of ``Ada.Characters``
  48 provides a set of definitions corresponding to those in the
  49 RM-defined package ``Ada.Characters.Latin_1`` but with the
  50 few modifications required for ``Latin-9``
  51 The provision of such a package
  52 is specifically authorized by the Ada Reference Manual
  53 (RM A.3.3(27)).
  54
  55 .. _`Ada.Characters.Wide_Latin_1_(a-cwila1.ads)`:
  56
  57 ``Ada.Characters.Wide_Latin_1`` (:file:`a-cwila1.ads`)
  58 ======================================================
  59
  60 .. index:: Ada.Characters.Wide_Latin_1 (a-cwila1.ads)
  61
  62 .. index:: Latin_1 constants for Wide_Character
  63
  64 This child of ``Ada.Characters``
  65 provides a set of definitions corresponding to those in the
  66 RM-defined package ``Ada.Characters.Latin_1`` but with the
  67 types of the constants being ``Wide_Character``
  68 instead of ``Character``.  The provision of such a package
  69 is specifically authorized by the Ada Reference Manual
  70 (RM A.3.3(27)).
  71
  72 .. _`Ada.Characters.Wide_Latin_9_(a-cwila1.ads)`:
  73
  74 ``Ada.Characters.Wide_Latin_9`` (:file:`a-cwila1.ads`)
  75 ======================================================
  76
  77 .. index:: Ada.Characters.Wide_Latin_9 (a-cwila1.ads)
  78
  79 .. index:: Latin_9 constants for Wide_Character
  80
  81 This child of ``Ada.Characters``
  82 provides a set of definitions corresponding to those in the
  83 GNAT defined package ``Ada.Characters.Latin_9`` but with the
  84 types of the constants being ``Wide_Character``
  85 instead of ``Character``.  The provision of such a package
  86 is specifically authorized by the Ada Reference Manual
  87 (RM A.3.3(27)).
  88
  89 .. _`Ada.Characters.Wide_Wide_Latin_1_(a-chzla1.ads)`:
  90
  91 ``Ada.Characters.Wide_Wide_Latin_1`` (:file:`a-chzla1.ads`)
  92 ===========================================================
  93
  94 .. index:: Ada.Characters.Wide_Wide_Latin_1 (a-chzla1.ads)
  95
  96 .. index:: Latin_1 constants for Wide_Wide_Character
  97
  98 This child of ``Ada.Characters``
  99 provides a set of definitions corresponding to those in the
 100 RM-defined package ``Ada.Characters.Latin_1`` but with the
 101 types of the constants being ``Wide_Wide_Character``
 102 instead of ``Character``.  The provision of such a package
 103 is specifically authorized by the Ada Reference Manual
 104 (RM A.3.3(27)).
 105
 106 .. _`Ada.Characters.Wide_Wide_Latin_9_(a-chzla9.ads)`:
 107
 108 ``Ada.Characters.Wide_Wide_Latin_9`` (:file:`a-chzla9.ads`)
 109 ===========================================================
 110
 111 .. index:: Ada.Characters.Wide_Wide_Latin_9 (a-chzla9.ads)
 112
 113 .. index:: Latin_9 constants for Wide_Wide_Character
 114
 115 This child of ``Ada.Characters``
 116 provides a set of definitions corresponding to those in the
 117 GNAT defined package ``Ada.Characters.Latin_9`` but with the
 118 types of the constants being ``Wide_Wide_Character``
 119 instead of ``Character``.  The provision of such a package
 120 is specifically authorized by the Ada Reference Manual
 121 (RM A.3.3(27)).
 122
 123 .. _`Ada.Containers.Formal_Doubly_Linked_Lists_(a-cfdlli.ads)`:
 124
 125 ``Ada.Containers.Formal_Doubly_Linked_Lists`` (:file:`a-cfdlli.ads`)
 126 ====================================================================
 127
 128 .. index:: Ada.Containers.Formal_Doubly_Linked_Lists (a-cfdlli.ads)
 129
 130 .. index:: Formal container for doubly linked lists
 131
 132 This child of ``Ada.Containers`` defines a modified version of the
 133 Ada 2005 container for doubly linked lists, meant to facilitate formal
 134 verification of code using such containers. The specification of this
 135 unit is compatible with SPARK 2014.
 136
 137 Note that although this container was designed with formal verification
 138 in mind, it may well be generally useful in that it is a simplified more
 139 efficient version than the one defined in the standard. In particular it
 140 does not have the complex overhead required to detect cursor tampering.
 141
 142 .. _`Ada.Containers.Formal_Hashed_Maps_(a-cfhama.ads)`:
 143
 144 ``Ada.Containers.Formal_Hashed_Maps`` (:file:`a-cfhama.ads`)
 145 ============================================================
 146
 147 .. index:: Ada.Containers.Formal_Hashed_Maps (a-cfhama.ads)
 148
 149 .. index:: Formal container for hashed maps
 150
 151 This child of ``Ada.Containers`` defines a modified version of the
 152 Ada 2005 container for hashed maps, meant to facilitate formal
 153 verification of code using such containers. The specification of this
 154 unit is compatible with SPARK 2014.
 155
 156 Note that although this container was designed with formal verification
 157 in mind, it may well be generally useful in that it is a simplified more
 158 efficient version than the one defined in the standard. In particular it
 159 does not have the complex overhead required to detect cursor tampering.
 160
 161 .. _`Ada.Containers.Formal_Hashed_Sets_(a-cfhase.ads)`:
 162
 163 ``Ada.Containers.Formal_Hashed_Sets`` (:file:`a-cfhase.ads`)
 164 ============================================================
 165
 166 .. index:: Ada.Containers.Formal_Hashed_Sets (a-cfhase.ads)
 167
 168 .. index:: Formal container for hashed sets
 169
 170 This child of ``Ada.Containers`` defines a modified version of the
 171 Ada 2005 container for hashed sets, meant to facilitate formal
 172 verification of code using such containers. The specification of this
 173 unit is compatible with SPARK 2014.
 174
 175 Note that although this container was designed with formal verification
 176 in mind, it may well be generally useful in that it is a simplified more
 177 efficient version than the one defined in the standard. In particular it
 178 does not have the complex overhead required to detect cursor tampering.
 179
 180 .. _`Ada.Containers.Formal_Ordered_Maps_(a-cforma.ads)`:
 181
 182 ``Ada.Containers.Formal_Ordered_Maps`` (:file:`a-cforma.ads`)
 183 =============================================================
 184
 185 .. index:: Ada.Containers.Formal_Ordered_Maps (a-cforma.ads)
 186
 187 .. index:: Formal container for ordered maps
 188
 189 This child of ``Ada.Containers`` defines a modified version of the
 190 Ada 2005 container for ordered maps, meant to facilitate formal
 191 verification of code using such containers. The specification of this
 192 unit is compatible with SPARK 2014.
 193
 194 Note that although this container was designed with formal verification
 195 in mind, it may well be generally useful in that it is a simplified more
 196 efficient version than the one defined in the standard. In particular it
 197 does not have the complex overhead required to detect cursor tampering.
 198
 199 .. _`Ada.Containers.Formal_Ordered_Sets_(a-cforse.ads)`:
 200
 201 ``Ada.Containers.Formal_Ordered_Sets`` (:file:`a-cforse.ads`)
 202 =============================================================
 203
 204 .. index:: Ada.Containers.Formal_Ordered_Sets (a-cforse.ads)
 205
 206 .. index:: Formal container for ordered sets
 207
 208 This child of ``Ada.Containers`` defines a modified version of the
 209 Ada 2005 container for ordered sets, meant to facilitate formal
 210 verification of code using such containers. The specification of this
 211 unit is compatible with SPARK 2014.
 212
 213 Note that although this container was designed with formal verification
 214 in mind, it may well be generally useful in that it is a simplified more
 215 efficient version than the one defined in the standard. In particular it
 216 does not have the complex overhead required to detect cursor tampering.
 217
 218 .. _`Ada.Containers.Formal_Vectors_(a-cofove.ads)`:
 219
 220 ``Ada.Containers.Formal_Vectors`` (:file:`a-cofove.ads`)
 221 ========================================================
 222
 223 .. index:: Ada.Containers.Formal_Vectors (a-cofove.ads)
 224
 225 .. index:: Formal container for vectors
 226
 227 This child of ``Ada.Containers`` defines a modified version of the
 228 Ada 2005 container for vectors, meant to facilitate formal
 229 verification of code using such containers. The specification of this
 230 unit is compatible with SPARK 2014.
 231
 232 Note that although this container was designed with formal verification
 233 in mind, it may well be generally useful in that it is a simplified more
 234 efficient version than the one defined in the standard. In particular it
 235 does not have the complex overhead required to detect cursor tampering.
 236
 237 .. _`Ada.Containers.Formal_Indefinite_Vectors_(a-cfinve.ads)`:
 238
 239 ``Ada.Containers.Formal_Indefinite_Vectors`` (:file:`a-cfinve.ads`)
 240 ===================================================================
 241
 242 .. index:: Ada.Containers.Formal_Indefinite_Vectors (a-cfinve.ads)
 243
 244 .. index:: Formal container for vectors
 245
 246 This child of ``Ada.Containers`` defines a modified version of the
 247 Ada 2005 container for vectors of indefinite elements, meant to
 248 facilitate formal verification of code using such containers. The
 249 specification of this unit is compatible with SPARK 2014.
 250
 251 Note that although this container was designed with formal verification
 252 in mind, it may well be generally useful in that it is a simplified more
 253 efficient version than the one defined in the standard. In particular it
 254 does not have the complex overhead required to detect cursor tampering.
 255
 256 .. _`Ada.Containers.Functional_Vectors_(a-cofuve.ads)`:
 257
 258 ``Ada.Containers.Functional_Vectors`` (:file:`a-cofuve.ads`)
 259 =================================================================
 260
 261 .. index:: Ada.Containers.Functional_Vectors (a-cofuve.ads)
 262
 263 .. index:: Functional vectors
 264
 265 This child of ``Ada.Containers`` defines immutable vectors. These
 266 containers are unbounded and may contain indefinite elements. Furthermore, to
 267 be usable in every context, they are neither controlled nor limited. As they
 268 are functional, that is, no primitives are provided which would allow modifying
 269 an existing container, these containers can still be used safely.
 270
 271 Their API features functions creating new containers from existing ones.
 272 As a consequence, these containers are highly inefficient. They are also
 273 memory consuming, as the allocated memory is not reclaimed when the container
 274 is no longer referenced. Thus, they should in general be used in ghost code
 275 and annotations, so that they can be removed from the final executable. The
 276 specification of this unit is compatible with SPARK 2014.
 277
 278 .. _`Ada.Containers.Functional_Sets_(a-cofuse.ads)`:
 279
 280 ``Ada.Containers.Functional_Sets`` (:file:`a-cofuse.ads`)
 281 =================================================================
 282
 283 .. index:: Ada.Containers.Functional_Sets (a-cofuse.ads)
 284
 285 .. index:: Functional sets
 286
 287 This child of ``Ada.Containers`` defines immutable sets. These containers are
 288 unbounded and may contain indefinite elements. Furthermore, to be usable in
 289 every context, they are neither controlled nor limited. As they are functional,
 290 that is, no primitives are provided which would allow modifying an existing
 291 container, these containers can still be used safely.
 292
 293 Their API features functions creating new containers from existing ones.
 294 As a consequence, these containers are highly inefficient. They are also
 295 memory consuming, as the allocated memory is not reclaimed when the container
 296 is no longer referenced. Thus, they should in general be used in ghost code
 297 and annotations, so that they can be removed from the final executable. The
 298 specification of this unit is compatible with SPARK 2014.
 299
 300 .. _`Ada.Containers.Functional_Maps_(a-cofuma.ads)`:
 301
 302 ``Ada.Containers.Functional_Maps`` (:file:`a-cofuma.ads`)
 303 =================================================================
 304
 305 .. index:: Ada.Containers.Functional_Maps (a-cofuma.ads)
 306
 307 .. index:: Functional maps
 308
 309 This child of ``Ada.Containers`` defines immutable maps. These containers are
 310 unbounded and may contain indefinite elements. Furthermore, to be usable in
 311 every context, they are neither controlled nor limited. As they are functional,
 312 that is, no primitives are provided which would allow modifying an existing
 313 container, these containers can still be used safely.
 314
 315 Their API features functions creating new containers from existing ones.
 316 As a consequence, these containers are highly inefficient. They are also
 317 memory consuming, as the allocated memory is not reclaimed when the container
 318 is no longer referenced. Thus, they should in general be used in ghost code
 319 and annotations, so that they can be removed from the final executable. The
 320 specification of this unit is compatible with SPARK 2014.
 321
 322 .. _`Ada.Containers.Bounded_Holders_(a-coboho.ads)`:
 323
 324 ``Ada.Containers.Bounded_Holders`` (:file:`a-coboho.ads`)
 325 =========================================================
 326
 327 .. index:: Ada.Containers.Bounded_Holders (a-coboho.ads)
 328
 329 .. index:: Formal container for vectors
 330
 331 This child of ``Ada.Containers`` defines a modified version of
 332 Indefinite_Holders that avoids heap allocation.
 333
 334 .. _`Ada.Command_Line.Environment_(a-colien.ads)`:
 335
 336 ``Ada.Command_Line.Environment`` (:file:`a-colien.ads`)
 337 =======================================================
 338
 339 .. index:: Ada.Command_Line.Environment (a-colien.ads)
 340
 341 .. index:: Environment entries
 342
 343 This child of ``Ada.Command_Line``
 344 provides a mechanism for obtaining environment values on systems
 345 where this concept makes sense.
 346
 347 .. _`Ada.Command_Line.Remove_(a-colire.ads)`:
 348
 349 ``Ada.Command_Line.Remove`` (:file:`a-colire.ads`)
 350 ==================================================
 351
 352 .. index:: Ada.Command_Line.Remove (a-colire.ads)
 353
 354 .. index:: Removing command line arguments
 355
 356 .. index:: Command line, argument removal
 357
 358 This child of ``Ada.Command_Line``
 359 provides a mechanism for logically removing
 360 arguments from the argument list.  Once removed, an argument is not visible
 361 to further calls on the subprograms in ``Ada.Command_Line`` will not
 362 see the removed argument.
 363
 364 .. _`Ada.Command_Line.Response_File_(a-clrefi.ads)`:
 365
 366 ``Ada.Command_Line.Response_File`` (:file:`a-clrefi.ads`)
 367 =========================================================
 368
 369 .. index:: Ada.Command_Line.Response_File (a-clrefi.ads)
 370
 371 .. index:: Response file for command line
 372
 373 .. index:: Command line, response file
 374
 375 .. index:: Command line, handling long command lines
 376
 377 This child of ``Ada.Command_Line`` provides a mechanism facilities for
 378 getting command line arguments from a text file, called a "response file".
 379 Using a response file allow passing a set of arguments to an executable longer
 380 than the maximum allowed by the system on the command line.
 381
 382 .. _`Ada.Direct_IO.C_Streams_(a-diocst.ads)`:
 383
 384 ``Ada.Direct_IO.C_Streams`` (:file:`a-diocst.ads`)
 385 ==================================================
 386
 387 .. index:: Ada.Direct_IO.C_Streams (a-diocst.ads)
 388
 389 .. index:: C Streams, Interfacing with Direct_IO
 390
 391 This package provides subprograms that allow interfacing between
 392 C streams and ``Direct_IO``.  The stream identifier can be
 393 extracted from a file opened on the Ada side, and an Ada file
 394 can be constructed from a stream opened on the C side.
 395
 396 .. _`Ada.Exceptions.Is_Null_Occurrence_(a-einuoc.ads)`:
 397
 398 ``Ada.Exceptions.Is_Null_Occurrence`` (:file:`a-einuoc.ads`)
 399 ============================================================
 400
 401 .. index:: Ada.Exceptions.Is_Null_Occurrence (a-einuoc.ads)
 402
 403 .. index:: Null_Occurrence, testing for
 404
 405 This child subprogram provides a way of testing for the null
 406 exception occurrence (``Null_Occurrence``) without raising
 407 an exception.
 408
 409 .. _`Ada.Exceptions.Last_Chance_Handler_(a-elchha.ads)`:
 410
 411 ``Ada.Exceptions.Last_Chance_Handler`` (:file:`a-elchha.ads`)
 412 =============================================================
 413
 414 .. index:: Ada.Exceptions.Last_Chance_Handler (a-elchha.ads)
 415
 416 .. index:: Null_Occurrence, testing for
 417
 418 This child subprogram is used for handling otherwise unhandled
 419 exceptions (hence the name last chance), and perform clean ups before
 420 terminating the program. Note that this subprogram never returns.
 421
 422 .. _`Ada.Exceptions.Traceback_(a-exctra.ads)`:
 423
 424 ``Ada.Exceptions.Traceback`` (:file:`a-exctra.ads`)
 425 ===================================================
 426
 427 .. index:: Ada.Exceptions.Traceback (a-exctra.ads)
 428
 429 .. index:: Traceback for Exception Occurrence
 430
 431 This child package provides the subprogram (``Tracebacks``) to
 432 give a traceback array of addresses based on an exception
 433 occurrence.
 434
 435 .. _`Ada.Sequential_IO.C_Streams_(a-siocst.ads)`:
 436
 437 ``Ada.Sequential_IO.C_Streams`` (:file:`a-siocst.ads`)
 438 ======================================================
 439
 440 .. index:: Ada.Sequential_IO.C_Streams (a-siocst.ads)
 441
 442 .. index:: C Streams, Interfacing with Sequential_IO
 443
 444 This package provides subprograms that allow interfacing between
 445 C streams and ``Sequential_IO``.  The stream identifier can be
 446 extracted from a file opened on the Ada side, and an Ada file
 447 can be constructed from a stream opened on the C side.
 448
 449 .. _`Ada.Streams.Stream_IO.C_Streams_(a-ssicst.ads)`:
 450
 451 ``Ada.Streams.Stream_IO.C_Streams`` (:file:`a-ssicst.ads`)
 452 ==========================================================
 453
 454 .. index:: Ada.Streams.Stream_IO.C_Streams (a-ssicst.ads)
 455
 456 .. index:: C Streams, Interfacing with Stream_IO
 457
 458 This package provides subprograms that allow interfacing between
 459 C streams and ``Stream_IO``.  The stream identifier can be
 460 extracted from a file opened on the Ada side, and an Ada file
 461 can be constructed from a stream opened on the C side.
 462
 463 .. _`Ada.Strings.Unbounded.Text_IO_(a-suteio.ads)`:
 464
 465 ``Ada.Strings.Unbounded.Text_IO`` (:file:`a-suteio.ads`)
 466 ========================================================
 467
 468 .. index:: Ada.Strings.Unbounded.Text_IO (a-suteio.ads)
 469
 470 .. index:: Unbounded_String, IO support
 471
 472 .. index:: Text_IO, extensions for unbounded strings
 473
 474 This package provides subprograms for Text_IO for unbounded
 475 strings, avoiding the necessity for an intermediate operation
 476 with ordinary strings.
 477
 478 .. _`Ada.Strings.Wide_Unbounded.Wide_Text_IO_(a-swuwti.ads)`:
 479
 480 ``Ada.Strings.Wide_Unbounded.Wide_Text_IO`` (:file:`a-swuwti.ads`)
 481 ==================================================================
 482
 483 .. index:: Ada.Strings.Wide_Unbounded.Wide_Text_IO (a-swuwti.ads)
 484
 485 .. index:: Unbounded_Wide_String, IO support
 486
 487 .. index:: Text_IO, extensions for unbounded wide strings
 488
 489 This package provides subprograms for Text_IO for unbounded
 490 wide strings, avoiding the necessity for an intermediate operation
 491 with ordinary wide strings.
 492
 493 .. _`Ada.Strings.Wide_Wide_Unbounded.Wide_Wide_Text_IO_(a-szuzti.ads)`:
 494
 495 ``Ada.Strings.Wide_Wide_Unbounded.Wide_Wide_Text_IO`` (:file:`a-szuzti.ads`)
 496 ============================================================================
 497
 498 .. index:: Ada.Strings.Wide_Wide_Unbounded.Wide_Wide_Text_IO (a-szuzti.ads)
 499
 500 .. index:: Unbounded_Wide_Wide_String, IO support
 501
 502 .. index:: Text_IO, extensions for unbounded wide wide strings
 503
 504 This package provides subprograms for Text_IO for unbounded
 505 wide wide strings, avoiding the necessity for an intermediate operation
 506 with ordinary wide wide strings.
 507
 508 .. _`Ada.Text_IO.C_Streams_(a-tiocst.ads)`:
 509
 510 ``Ada.Text_IO.C_Streams`` (:file:`a-tiocst.ads`)
 511 ================================================
 512
 513 .. index:: Ada.Text_IO.C_Streams (a-tiocst.ads)
 514
 515 .. index:: C Streams, Interfacing with ``Text_IO``
 516
 517 This package provides subprograms that allow interfacing between
 518 C streams and ``Text_IO``.  The stream identifier can be
 519 extracted from a file opened on the Ada side, and an Ada file
 520 can be constructed from a stream opened on the C side.
 521
 522 .. _`Ada.Text_IO.Reset_Standard_Files_(a-tirsfi.ads)`:
 523
 524 ``Ada.Text_IO.Reset_Standard_Files`` (:file:`a-tirsfi.ads`)
 525 ===========================================================
 526
 527 .. index:: Ada.Text_IO.Reset_Standard_Files (a-tirsfi.ads)
 528
 529 .. index:: Text_IO resetting standard files
 530
 531 This procedure is used to reset the status of the standard files used
 532 by Ada.Text_IO.  This is useful in a situation (such as a restart in an
 533 embedded application) where the status of the files may change during
 534 execution (for example a standard input file may be redefined to be
 535 interactive).
 536
 537 .. _`Ada.Wide_Characters.Unicode_(a-wichun.ads)`:
 538
 539 ``Ada.Wide_Characters.Unicode`` (:file:`a-wichun.ads`)
 540 ======================================================
 541
 542 .. index:: Ada.Wide_Characters.Unicode (a-wichun.ads)
 543
 544 .. index:: Unicode categorization, Wide_Character
 545
 546 This package provides subprograms that allow categorization of
 547 Wide_Character values according to Unicode categories.
 548
 549 .. _`Ada.Wide_Text_IO.C_Streams_(a-wtcstr.ads)`:
 550
 551 ``Ada.Wide_Text_IO.C_Streams`` (:file:`a-wtcstr.ads`)
 552 =====================================================
 553
 554 .. index:: Ada.Wide_Text_IO.C_Streams (a-wtcstr.ads)
 555
 556 .. index:: C Streams, Interfacing with ``Wide_Text_IO``
 557
 558 This package provides subprograms that allow interfacing between
 559 C streams and ``Wide_Text_IO``.  The stream identifier can be
 560 extracted from a file opened on the Ada side, and an Ada file
 561 can be constructed from a stream opened on the C side.
 562
 563 .. _`Ada.Wide_Text_IO.Reset_Standard_Files_(a-wrstfi.ads)`:
 564
 565 ``Ada.Wide_Text_IO.Reset_Standard_Files`` (:file:`a-wrstfi.ads`)
 566 ================================================================
 567
 568 .. index:: Ada.Wide_Text_IO.Reset_Standard_Files (a-wrstfi.ads)
 569
 570 .. index:: Wide_Text_IO resetting standard files
 571
 572 This procedure is used to reset the status of the standard files used
 573 by Ada.Wide_Text_IO.  This is useful in a situation (such as a restart in an
 574 embedded application) where the status of the files may change during
 575 execution (for example a standard input file may be redefined to be
 576 interactive).
 577
 578 .. _`Ada.Wide_Wide_Characters.Unicode_(a-zchuni.ads)`:
 579
 580 ``Ada.Wide_Wide_Characters.Unicode`` (:file:`a-zchuni.ads`)
 581 ===========================================================
 582
 583 .. index:: Ada.Wide_Wide_Characters.Unicode (a-zchuni.ads)
 584
 585 .. index:: Unicode categorization, Wide_Wide_Character
 586
 587 This package provides subprograms that allow categorization of
 588 Wide_Wide_Character values according to Unicode categories.
 589
 590 .. _`Ada.Wide_Wide_Text_IO.C_Streams_(a-ztcstr.ads)`:
 591
 592 ``Ada.Wide_Wide_Text_IO.C_Streams`` (:file:`a-ztcstr.ads`)
 593 ==========================================================
 594
 595 .. index:: Ada.Wide_Wide_Text_IO.C_Streams (a-ztcstr.ads)
 596
 597 .. index:: C Streams, Interfacing with ``Wide_Wide_Text_IO``
 598
 599 This package provides subprograms that allow interfacing between
 600 C streams and ``Wide_Wide_Text_IO``.  The stream identifier can be
 601 extracted from a file opened on the Ada side, and an Ada file
 602 can be constructed from a stream opened on the C side.
 603
 604 .. _`Ada.Wide_Wide_Text_IO.Reset_Standard_Files_(a-zrstfi.ads)`:
 605
 606 ``Ada.Wide_Wide_Text_IO.Reset_Standard_Files`` (:file:`a-zrstfi.ads`)
 607 =====================================================================
 608
 609 .. index:: Ada.Wide_Wide_Text_IO.Reset_Standard_Files (a-zrstfi.ads)
 610
 611 .. index:: Wide_Wide_Text_IO resetting standard files
 612
 613 This procedure is used to reset the status of the standard files used
 614 by Ada.Wide_Wide_Text_IO. This is useful in a situation (such as a
 615 restart in an embedded application) where the status of the files may
 616 change during execution (for example a standard input file may be
 617 redefined to be interactive).
 618
 619 .. _`GNAT.Altivec_(g-altive.ads)`:
 620
 621 ``GNAT.Altivec`` (:file:`g-altive.ads`)
 622 =======================================
 623
 624 .. index:: GNAT.Altivec (g-altive.ads)
 625
 626 .. index:: AltiVec
 627
 628 This is the root package of the GNAT AltiVec binding. It provides
 629 definitions of constants and types common to all the versions of the
 630 binding.
 631
 632 .. _`GNAT.Altivec.Conversions_(g-altcon.ads)`:
 633
 634 ``GNAT.Altivec.Conversions`` (:file:`g-altcon.ads`)
 635 ===================================================
 636
 637 .. index:: GNAT.Altivec.Conversions (g-altcon.ads)
 638
 639 .. index:: AltiVec
 640
 641 This package provides the Vector/View conversion routines.
 642
 643 .. _`GNAT.Altivec.Vector_Operations_(g-alveop.ads)`:
 644
 645 ``GNAT.Altivec.Vector_Operations`` (:file:`g-alveop.ads`)
 646 =========================================================
 647
 648 .. index:: GNAT.Altivec.Vector_Operations (g-alveop.ads)
 649
 650 .. index:: AltiVec
 651
 652 This package exposes the Ada interface to the AltiVec operations on
 653 vector objects. A soft emulation is included by default in the GNAT
 654 library. The hard binding is provided as a separate package. This unit
 655 is common to both bindings.
 656
 657 .. _`GNAT.Altivec.Vector_Types_(g-alvety.ads)`:
 658
 659 ``GNAT.Altivec.Vector_Types`` (:file:`g-alvety.ads`)
 660 ====================================================
 661
 662 .. index:: GNAT.Altivec.Vector_Types (g-alvety.ads)
 663
 664 .. index:: AltiVec
 665
 666 This package exposes the various vector types part of the Ada binding
 667 to AltiVec facilities.
 668
 669 .. _`GNAT.Altivec.Vector_Views_(g-alvevi.ads)`:
 670
 671 ``GNAT.Altivec.Vector_Views`` (:file:`g-alvevi.ads`)
 672 ====================================================
 673
 674 .. index:: GNAT.Altivec.Vector_Views (g-alvevi.ads)
 675
 676 .. index:: AltiVec
 677
 678 This package provides public 'View' data types from/to which private
 679 vector representations can be converted via
 680 GNAT.Altivec.Conversions. This allows convenient access to individual
 681 vector elements and provides a simple way to initialize vector
 682 objects.
 683
 684 .. _`GNAT.Array_Split_(g-arrspl.ads)`:
 685
 686 ``GNAT.Array_Split`` (:file:`g-arrspl.ads`)
 687 ===========================================
 688
 689 .. index:: GNAT.Array_Split (g-arrspl.ads)
 690
 691 .. index:: Array splitter
 692
 693 Useful array-manipulation routines: given a set of separators, split
 694 an array wherever the separators appear, and provide direct access
 695 to the resulting slices.
 696
 697 .. _`GNAT.AWK_(g-awk.ads)`:
 698
 699 ``GNAT.AWK`` (:file:`g-awk.ads`)
 700 ================================
 701
 702 .. index:: GNAT.AWK (g-awk.ads)
 703
 704 .. index:: Parsing
 705
 706 .. index:: AWK
 707
 708 Provides AWK-like parsing functions, with an easy interface for parsing one
 709 or more files containing formatted data.  The file is viewed as a database
 710 where each record is a line and a field is a data element in this line.
 711
 712 .. _`GNAT.Bind_Environment_(g-binenv.ads)`:
 713
 714 ``GNAT.Bind_Environment`` (:file:`g-binenv.ads`)
 715 ================================================
 716
 717 .. index:: GNAT.Bind_Environment (g-binenv.ads)
 718
 719 .. index:: Bind environment
 720
 721 Provides access to key=value associations captured at bind time.
 722 These associations can be specified using the :switch:`-V` binder command
 723 line switch.
 724
 725 .. _`GNAT.Branch_Prediction_(g-brapre.ads)`:
 726
 727 ``GNAT.Branch_Prediction`` (:file:`g-brapre.ads`)
 728 =================================================
 729
 730 .. index:: GNAT.Branch_Prediction (g-brapre.ads)
 731
 732 .. index:: Branch Prediction
 733
 734 Provides routines giving hints to the branch predictor of the code generator.
 735
 736 .. _`GNAT.Bounded_Buffers_(g-boubuf.ads)`:
 737
 738 ``GNAT.Bounded_Buffers`` (:file:`g-boubuf.ads`)
 739 ===============================================
 740
 741 .. index:: GNAT.Bounded_Buffers (g-boubuf.ads)
 742
 743 .. index:: Parsing
 744
 745 .. index:: Bounded Buffers
 746
 747 Provides a concurrent generic bounded buffer abstraction.  Instances are
 748 useful directly or as parts of the implementations of other abstractions,
 749 such as mailboxes.
 750
 751 .. _`GNAT.Bounded_Mailboxes_(g-boumai.ads)`:
 752
 753 ``GNAT.Bounded_Mailboxes`` (:file:`g-boumai.ads`)
 754 =================================================
 755
 756 .. index:: GNAT.Bounded_Mailboxes (g-boumai.ads)
 757
 758 .. index:: Parsing
 759
 760 .. index:: Mailboxes
 761
 762 Provides a thread-safe asynchronous intertask mailbox communication facility.
 763
 764 .. _`GNAT.Bubble_Sort_(g-bubsor.ads)`:
 765
 766 ``GNAT.Bubble_Sort`` (:file:`g-bubsor.ads`)
 767 ===========================================
 768
 769 .. index:: GNAT.Bubble_Sort (g-bubsor.ads)
 770
 771 .. index:: Sorting
 772
 773 .. index:: Bubble sort
 774
 775 Provides a general implementation of bubble sort usable for sorting arbitrary
 776 data items.  Exchange and comparison procedures are provided by passing
 777 access-to-procedure values.
 778
 779 .. _`GNAT.Bubble_Sort_A_(g-busora.ads)`:
 780
 781 ``GNAT.Bubble_Sort_A`` (:file:`g-busora.ads`)
 782 =============================================
 783
 784 .. index:: GNAT.Bubble_Sort_A (g-busora.ads)
 785
 786 .. index:: Sorting
 787
 788 .. index:: Bubble sort
 789
 790 Provides a general implementation of bubble sort usable for sorting arbitrary
 791 data items.  Move and comparison procedures are provided by passing
 792 access-to-procedure values. This is an older version, retained for
 793 compatibility. Usually ``GNAT.Bubble_Sort`` will be preferable.
 794
 795 .. _`GNAT.Bubble_Sort_G_(g-busorg.ads)`:
 796
 797 ``GNAT.Bubble_Sort_G`` (:file:`g-busorg.ads`)
 798 =============================================
 799
 800 .. index:: GNAT.Bubble_Sort_G (g-busorg.ads)
 801
 802 .. index:: Sorting
 803
 804 .. index:: Bubble sort
 805
 806 Similar to ``Bubble_Sort_A`` except that the move and sorting procedures
 807 are provided as generic parameters, this improves efficiency, especially
 808 if the procedures can be inlined, at the expense of duplicating code for
 809 multiple instantiations.
 810
 811 .. _`GNAT.Byte_Order_Mark_(g-byorma.ads)`:
 812
 813 ``GNAT.Byte_Order_Mark`` (:file:`g-byorma.ads`)
 814 ===============================================
 815
 816 .. index:: GNAT.Byte_Order_Mark (g-byorma.ads)
 817
 818 .. index:: UTF-8 representation
 819
 820 .. index:: Wide characte representations
 821
 822 Provides a routine which given a string, reads the start of the string to
 823 see whether it is one of the standard byte order marks (BOM's) which signal
 824 the encoding of the string. The routine includes detection of special XML
 825 sequences for various UCS input formats.
 826
 827 .. _`GNAT.Byte_Swapping_(g-bytswa.ads)`:
 828
 829 ``GNAT.Byte_Swapping`` (:file:`g-bytswa.ads`)
 830 =============================================
 831
 832 .. index:: GNAT.Byte_Swapping (g-bytswa.ads)
 833
 834 .. index:: Byte swapping
 835
 836 .. index:: Endianness
 837
 838 General routines for swapping the bytes in 2-, 4-, and 8-byte quantities.
 839 Machine-specific implementations are available in some cases.
 840
 841 .. _`GNAT.Calendar_(g-calend.ads)`:
 842
 843 ``GNAT.Calendar`` (:file:`g-calend.ads`)
 844 ========================================
 845
 846 .. index:: GNAT.Calendar (g-calend.ads)
 847
 848 .. index:: Calendar
 849
 850 Extends the facilities provided by ``Ada.Calendar`` to include handling
 851 of days of the week, an extended ``Split`` and ``Time_Of`` capability.
 852 Also provides conversion of ``Ada.Calendar.Time`` values to and from the
 853 C ``timeval`` format.
 854
 855 .. _`GNAT.Calendar.Time_IO_(g-catiio.ads)`:
 856
 857 ``GNAT.Calendar.Time_IO`` (:file:`g-catiio.ads`)
 858 ================================================
 859
 860 .. index:: Calendar
 861
 862 .. index:: Time
 863
 864 .. index:: GNAT.Calendar.Time_IO (g-catiio.ads)
 865
 866 .. _`GNAT.CRC32_(g-crc32.ads)`:
 867
 868 ``GNAT.CRC32`` (:file:`g-crc32.ads`)
 869 ====================================
 870
 871 .. index:: GNAT.CRC32 (g-crc32.ads)
 872
 873 .. index:: CRC32
 874
 875 .. index:: Cyclic Redundancy Check
 876
 877 This package implements the CRC-32 algorithm.  For a full description
 878 of this algorithm see
 879 *Computation of Cyclic Redundancy Checks via Table Look-Up*,
 880 :title:`Communications of the ACM`, Vol. 31 No. 8, pp. 1008-1013,
 881 Aug. 1988.  Sarwate, D.V.
 882
 883 .. _`GNAT.Case_Util_(g-casuti.ads)`:
 884
 885 ``GNAT.Case_Util`` (:file:`g-casuti.ads`)
 886 =========================================
 887
 888 .. index:: GNAT.Case_Util (g-casuti.ads)
 889
 890 .. index:: Casing utilities
 891
 892 .. index:: Character handling (``GNAT.Case_Util``)
 893
 894 A set of simple routines for handling upper and lower casing of strings
 895 without the overhead of the full casing tables
 896 in ``Ada.Characters.Handling``.
 897
 898 .. _`GNAT.CGI_(g-cgi.ads)`:
 899
 900 ``GNAT.CGI`` (:file:`g-cgi.ads`)
 901 ================================
 902
 903 .. index:: GNAT.CGI (g-cgi.ads)
 904
 905 .. index:: CGI (Common Gateway Interface)
 906
 907 This is a package for interfacing a GNAT program with a Web server via the
 908 Common Gateway Interface (CGI).  Basically this package parses the CGI
 909 parameters, which are a set of key/value pairs sent by the Web server.  It
 910 builds a table whose index is the key and provides some services to deal
 911 with this table.
 912
 913 .. _`GNAT.CGI.Cookie_(g-cgicoo.ads)`:
 914
 915 ``GNAT.CGI.Cookie`` (:file:`g-cgicoo.ads`)
 916 ==========================================
 917
 918 .. index:: GNAT.CGI.Cookie (g-cgicoo.ads)
 919
 920 .. index:: CGI (Common Gateway Interface) cookie support
 921
 922 .. index:: Cookie support in CGI
 923
 924 This is a package to interface a GNAT program with a Web server via the
 925 Common Gateway Interface (CGI).  It exports services to deal with Web
 926 cookies (piece of information kept in the Web client software).
 927
 928 .. _`GNAT.CGI.Debug_(g-cgideb.ads)`:
 929
 930 ``GNAT.CGI.Debug`` (:file:`g-cgideb.ads`)
 931 =========================================
 932
 933 .. index:: GNAT.CGI.Debug (g-cgideb.ads)
 934
 935 .. index:: CGI (Common Gateway Interface) debugging
 936
 937 This is a package to help debugging CGI (Common Gateway Interface)
 938 programs written in Ada.
 939
 940 .. _`GNAT.Command_Line_(g-comlin.ads)`:
 941
 942 ``GNAT.Command_Line`` (:file:`g-comlin.ads`)
 943 ============================================
 944
 945 .. index:: GNAT.Command_Line (g-comlin.ads)
 946
 947 .. index:: Command line
 948
 949 Provides a high level interface to ``Ada.Command_Line`` facilities,
 950 including the ability to scan for named switches with optional parameters
 951 and expand file names using wildcard notations.
 952
 953 .. _`GNAT.Compiler_Version_(g-comver.ads)`:
 954
 955 ``GNAT.Compiler_Version`` (:file:`g-comver.ads`)
 956 ================================================
 957
 958 .. index:: GNAT.Compiler_Version (g-comver.ads)
 959
 960 .. index:: Compiler Version
 961
 962 .. index:: Version, of compiler
 963
 964 Provides a routine for obtaining the version of the compiler used to
 965 compile the program. More accurately this is the version of the binder
 966 used to bind the program (this will normally be the same as the version
 967 of the compiler if a consistent tool set is used to compile all units
 968 of a partition).
 969
 970 .. _`GNAT.Ctrl_C_(g-ctrl_c.ads)`:
 971
 972 ``GNAT.Ctrl_C`` (:file:`g-ctrl_c.ads`)
 973 ======================================
 974
 975 .. index:: GNAT.Ctrl_C (g-ctrl_c.ads)
 976
 977 .. index:: Interrupt
 978
 979 Provides a simple interface to handle Ctrl-C keyboard events.
 980
 981 .. _`GNAT.Current_Exception_(g-curexc.ads)`:
 982
 983 ``GNAT.Current_Exception`` (:file:`g-curexc.ads`)
 984 =================================================
 985
 986 .. index:: GNAT.Current_Exception (g-curexc.ads)
 987
 988 .. index:: Current exception
 989
 990 .. index:: Exception retrieval
 991
 992 Provides access to information on the current exception that has been raised
 993 without the need for using the Ada 95 / Ada 2005 exception choice parameter
 994 specification syntax.
 995 This is particularly useful in simulating typical facilities for
 996 obtaining information about exceptions provided by Ada 83 compilers.
 997
 998 .. _`GNAT.Debug_Pools_(g-debpoo.ads)`:
 999
1000 ``GNAT.Debug_Pools`` (:file:`g-debpoo.ads`)
1001 ===========================================
1002
1003 .. index:: GNAT.Debug_Pools (g-debpoo.ads)
1004
1005 .. index:: Debugging
1006
1007 .. index:: Debug pools
1008
1009 .. index:: Memory corruption debugging
1010
1011 Provide a debugging storage pools that helps tracking memory corruption
1012 problems.
1013 See ``The GNAT Debug_Pool Facility`` section in the :title:`GNAT User's Guide`.
1014
1015 .. _`GNAT.Debug_Utilities_(g-debuti.ads)`:
1016
1017 ``GNAT.Debug_Utilities`` (:file:`g-debuti.ads`)
1018 ===============================================
1019
1020 .. index:: GNAT.Debug_Utilities (g-debuti.ads)
1021
1022 .. index:: Debugging
1023
1024 Provides a few useful utilities for debugging purposes, including conversion
1025 to and from string images of address values. Supports both C and Ada formats
1026 for hexadecimal literals.
1027
1028 .. _`GNAT.Decode_String_(g-decstr.ads)`:
1029
1030 ``GNAT.Decode_String`` (:file:`g-decstr.ads`)
1031 =============================================
1032
1033 .. index:: GNAT.Decode_String (g-decstr.ads)
1034
1035 .. index:: Decoding strings
1036
1037 .. index:: String decoding
1038
1039 .. index:: Wide character encoding
1040
1041 .. index:: UTF-8
1042
1043 .. index:: Unicode
1044
1045 A generic package providing routines for decoding wide character and wide wide
1046 character strings encoded as sequences of 8-bit characters using a specified
1047 encoding method. Includes validation routines, and also routines for stepping
1048 to next or previous encoded character in an encoded string.
1049 Useful in conjunction with Unicode character coding. Note there is a
1050 preinstantiation for UTF-8. See next entry.
1051
1052 .. _`GNAT.Decode_UTF8_String_(g-deutst.ads)`:
1053
1054 ``GNAT.Decode_UTF8_String`` (:file:`g-deutst.ads`)
1055 ==================================================
1056
1057 .. index:: GNAT.Decode_UTF8_String (g-deutst.ads)
1058
1059 .. index:: Decoding strings
1060
1061 .. index:: Decoding UTF-8 strings
1062
1063 .. index:: UTF-8 string decoding
1064
1065 .. index:: Wide character decoding
1066
1067 .. index:: UTF-8
1068
1069 .. index:: Unicode
1070
1071 A preinstantiation of GNAT.Decode_Strings for UTF-8 encoding.
1072
1073 .. _`GNAT.Directory_Operations_(g-dirope.ads)`:
1074
1075 ``GNAT.Directory_Operations`` (:file:`g-dirope.ads`)
1076 ====================================================
1077
1078 .. index:: GNAT.Directory_Operations (g-dirope.ads)
1079
1080 .. index:: Directory operations
1081
1082 Provides a set of routines for manipulating directories, including changing
1083 the current directory, making new directories, and scanning the files in a
1084 directory.
1085
1086 .. _`GNAT.Directory_Operations.Iteration_(g-diopit.ads)`:
1087
1088 ``GNAT.Directory_Operations.Iteration`` (:file:`g-diopit.ads`)
1089 ==============================================================
1090
1091 .. index:: GNAT.Directory_Operations.Iteration (g-diopit.ads)
1092
1093 .. index:: Directory operations iteration
1094
1095 A child unit of GNAT.Directory_Operations providing additional operations
1096 for iterating through directories.
1097
1098 .. _`GNAT.Dynamic_HTables_(g-dynhta.ads)`:
1099
1100 ``GNAT.Dynamic_HTables`` (:file:`g-dynhta.ads`)
1101 ===============================================
1102
1103 .. index:: GNAT.Dynamic_HTables (g-dynhta.ads)
1104
1105 .. index:: Hash tables
1106
1107 A generic implementation of hash tables that can be used to hash arbitrary
1108 data.  Provided in two forms, a simple form with built in hash functions,
1109 and a more complex form in which the hash function is supplied.
1110
1111 This package provides a facility similar to that of ``GNAT.HTable``,
1112 except that this package declares a type that can be used to define
1113 dynamic instances of the hash table, while an instantiation of
1114 ``GNAT.HTable`` creates a single instance of the hash table.
1115
1116 .. _`GNAT.Dynamic_Tables_(g-dyntab.ads)`:
1117
1118 ``GNAT.Dynamic_Tables`` (:file:`g-dyntab.ads`)
1119 ==============================================
1120
1121 .. index:: GNAT.Dynamic_Tables (g-dyntab.ads)
1122
1123 .. index:: Table implementation
1124
1125 .. index:: Arrays, extendable
1126
1127 A generic package providing a single dimension array abstraction where the
1128 length of the array can be dynamically modified.
1129
1130 This package provides a facility similar to that of ``GNAT.Table``,
1131 except that this package declares a type that can be used to define
1132 dynamic instances of the table, while an instantiation of
1133 ``GNAT.Table`` creates a single instance of the table type.
1134
1135 .. _`GNAT.Encode_String_(g-encstr.ads)`:
1136
1137 ``GNAT.Encode_String`` (:file:`g-encstr.ads`)
1138 =============================================
1139
1140 .. index:: GNAT.Encode_String (g-encstr.ads)
1141
1142 .. index:: Encoding strings
1143
1144 .. index:: String encoding
1145
1146 .. index:: Wide character encoding
1147
1148 .. index:: UTF-8
1149
1150 .. index:: Unicode
1151
1152 A generic package providing routines for encoding wide character and wide
1153 wide character strings as sequences of 8-bit characters using a specified
1154 encoding method. Useful in conjunction with Unicode character coding.
1155 Note there is a preinstantiation for UTF-8. See next entry.
1156
1157 .. _`GNAT.Encode_UTF8_String_(g-enutst.ads)`:
1158
1159 ``GNAT.Encode_UTF8_String`` (:file:`g-enutst.ads`)
1160 ==================================================
1161
1162 .. index:: GNAT.Encode_UTF8_String (g-enutst.ads)
1163
1164 .. index:: Encoding strings
1165
1166 .. index:: Encoding UTF-8 strings
1167
1168 .. index:: UTF-8 string encoding
1169
1170 .. index:: Wide character encoding
1171
1172 .. index:: UTF-8
1173
1174 .. index:: Unicode
1175
1176 A preinstantiation of GNAT.Encode_Strings for UTF-8 encoding.
1177
1178 .. _`GNAT.Exception_Actions_(g-excact.ads)`:
1179
1180 ``GNAT.Exception_Actions`` (:file:`g-excact.ads`)
1181 =================================================
1182
1183 .. index:: GNAT.Exception_Actions (g-excact.ads)
1184
1185 .. index:: Exception actions
1186
1187 Provides callbacks when an exception is raised. Callbacks can be registered
1188 for specific exceptions, or when any exception is raised. This
1189 can be used for instance to force a core dump to ease debugging.
1190
1191 .. _`GNAT.Exception_Traces_(g-exctra.ads)`:
1192
1193 ``GNAT.Exception_Traces`` (:file:`g-exctra.ads`)
1194 ================================================
1195
1196 .. index:: GNAT.Exception_Traces (g-exctra.ads)
1197
1198 .. index:: Exception traces
1199
1200 .. index:: Debugging
1201
1202 Provides an interface allowing to control automatic output upon exception
1203 occurrences.
1204
1205 .. _`GNAT.Exceptions_(g-except.ads)`:
1206
1207 ``GNAT.Exceptions`` (:file:`g-except.ads`)
1208 ==========================================
1209
1210 .. index:: GNAT.Exceptions (g-except.ads)
1211
1212 .. index:: Exceptions, Pure
1213
1214 .. index:: Pure packages, exceptions
1215
1216 Normally it is not possible to raise an exception with
1217 a message from a subprogram in a pure package, since the
1218 necessary types and subprograms are in ``Ada.Exceptions``
1219 which is not a pure unit. ``GNAT.Exceptions`` provides a
1220 facility for getting around this limitation for a few
1221 predefined exceptions, and for example allow raising
1222 ``Constraint_Error`` with a message from a pure subprogram.
1223
1224 .. _`GNAT.Expect_(g-expect.ads)`:
1225
1226 ``GNAT.Expect`` (:file:`g-expect.ads`)
1227 ======================================
1228
1229 .. index:: GNAT.Expect (g-expect.ads)
1230
1231 Provides a set of subprograms similar to what is available
1232 with the standard Tcl Expect tool.
1233 It allows you to easily spawn and communicate with an external process.
1234 You can send commands or inputs to the process, and compare the output
1235 with some expected regular expression. Currently ``GNAT.Expect``
1236 is implemented on all native GNAT ports.
1237 It is not implemented for cross ports, and in particular is not
1238 implemented for VxWorks or LynxOS.
1239
1240 .. _`GNAT.Expect.TTY_(g-exptty.ads)`:
1241
1242 ``GNAT.Expect.TTY`` (:file:`g-exptty.ads`)
1243 ==========================================
1244
1245 .. index:: GNAT.Expect.TTY (g-exptty.ads)
1246
1247 As GNAT.Expect but using pseudo-terminal.
1248 Currently ``GNAT.Expect.TTY`` is implemented on all native GNAT
1249 ports. It is not implemented for cross ports, and
1250 in particular is not implemented for VxWorks or LynxOS.
1251
1252 .. _`GNAT.Float_Control_(g-flocon.ads)`:
1253
1254 ``GNAT.Float_Control`` (:file:`g-flocon.ads`)
1255 =============================================
1256
1257 .. index:: GNAT.Float_Control (g-flocon.ads)
1258
1259 .. index:: Floating-Point Processor
1260
1261 Provides an interface for resetting the floating-point processor into the
1262 mode required for correct semantic operation in Ada.  Some third party
1263 library calls may cause this mode to be modified, and the Reset procedure
1264 in this package can be used to reestablish the required mode.
1265
1266 .. _`GNAT.Formatted_String_(g-forstr.ads)`:
1267
1268 ``GNAT.Formatted_String`` (:file:`g-forstr.ads`)
1269 ================================================
1270
1271 .. index:: GNAT.Formatted_String (g-forstr.ads)
1272
1273 .. index:: Formatted String
1274
1275 Provides support for C/C++ printf() formatted strings. The format is
1276 copied from the printf() routine and should therefore gives identical
1277 output. Some generic routines are provided to be able to use types
1278 derived from Integer, Float or enumerations as values for the
1279 formatted string.
1280
1281 .. _`GNAT.Heap_Sort_(g-heasor.ads)`:
1282
1283 ``GNAT.Heap_Sort`` (:file:`g-heasor.ads`)
1284 =========================================
1285
1286 .. index:: GNAT.Heap_Sort (g-heasor.ads)
1287
1288 .. index:: Sorting
1289
1290 Provides a general implementation of heap sort usable for sorting arbitrary
1291 data items. Exchange and comparison procedures are provided by passing
1292 access-to-procedure values.  The algorithm used is a modified heap sort
1293 that performs approximately N*log(N) comparisons in the worst case.
1294
1295 .. _`GNAT.Heap_Sort_A_(g-hesora.ads)`:
1296
1297 ``GNAT.Heap_Sort_A`` (:file:`g-hesora.ads`)
1298 ===========================================
1299
1300 .. index:: GNAT.Heap_Sort_A (g-hesora.ads)
1301
1302 .. index:: Sorting
1303
1304 Provides a general implementation of heap sort usable for sorting arbitrary
1305 data items. Move and comparison procedures are provided by passing
1306 access-to-procedure values.  The algorithm used is a modified heap sort
1307 that performs approximately N*log(N) comparisons in the worst case.
1308 This differs from ``GNAT.Heap_Sort`` in having a less convenient
1309 interface, but may be slightly more efficient.
1310
1311 .. _`GNAT.Heap_Sort_G_(g-hesorg.ads)`:
1312
1313 ``GNAT.Heap_Sort_G`` (:file:`g-hesorg.ads`)
1314 ===========================================
1315
1316 .. index:: GNAT.Heap_Sort_G (g-hesorg.ads)
1317
1318 .. index:: Sorting
1319
1320 Similar to ``Heap_Sort_A`` except that the move and sorting procedures
1321 are provided as generic parameters, this improves efficiency, especially
1322 if the procedures can be inlined, at the expense of duplicating code for
1323 multiple instantiations.
1324
1325 .. _`GNAT.HTable_(g-htable.ads)`:
1326
1327 ``GNAT.HTable`` (:file:`g-htable.ads`)
1328 ======================================
1329
1330 .. index:: GNAT.HTable (g-htable.ads)
1331
1332 .. index:: Hash tables
1333
1334 A generic implementation of hash tables that can be used to hash arbitrary
1335 data.  Provides two approaches, one a simple static approach, and the other
1336 allowing arbitrary dynamic hash tables.
1337
1338 .. _`GNAT.IO_(g-io.ads)`:
1339
1340 ``GNAT.IO`` (:file:`g-io.ads`)
1341 ==============================
1342
1343 .. index:: GNAT.IO (g-io.ads)
1344
1345 .. index:: Simple I/O
1346
1347 .. index:: Input/Output facilities
1348
1349 A simple preelaborable input-output package that provides a subset of
1350 simple Text_IO functions for reading characters and strings from
1351 Standard_Input, and writing characters, strings and integers to either
1352 Standard_Output or Standard_Error.
1353
1354 .. _`GNAT.IO_Aux_(g-io_aux.ads)`:
1355
1356 ``GNAT.IO_Aux`` (:file:`g-io_aux.ads`)
1357 ======================================
1358
1359 .. index:: GNAT.IO_Aux (g-io_aux.ads)
1360
1361 .. index:: Text_IO
1362
1363 .. index:: Input/Output facilities
1364
1365 Provides some auxiliary functions for use with Text_IO, including a test
1366 for whether a file exists, and functions for reading a line of text.
1367
1368 .. _`GNAT.Lock_Files_(g-locfil.ads)`:
1369
1370 ``GNAT.Lock_Files`` (:file:`g-locfil.ads`)
1371 ==========================================
1372
1373 .. index:: GNAT.Lock_Files (g-locfil.ads)
1374
1375 .. index:: File locking
1376
1377 .. index:: Locking using files
1378
1379 Provides a general interface for using files as locks.  Can be used for
1380 providing program level synchronization.
1381
1382 .. _`GNAT.MBBS_Discrete_Random_(g-mbdira.ads)`:
1383
1384 ``GNAT.MBBS_Discrete_Random`` (:file:`g-mbdira.ads`)
1385 ====================================================
1386
1387 .. index:: GNAT.MBBS_Discrete_Random (g-mbdira.ads)
1388
1389 .. index:: Random number generation
1390
1391 The original implementation of ``Ada.Numerics.Discrete_Random``.  Uses
1392 a modified version of the Blum-Blum-Shub generator.
1393
1394 .. _`GNAT.MBBS_Float_Random_(g-mbflra.ads)`:
1395
1396 ``GNAT.MBBS_Float_Random`` (:file:`g-mbflra.ads`)
1397 =================================================
1398
1399 .. index:: GNAT.MBBS_Float_Random (g-mbflra.ads)
1400
1401 .. index:: Random number generation
1402
1403 The original implementation of ``Ada.Numerics.Float_Random``.  Uses
1404 a modified version of the Blum-Blum-Shub generator.
1405
1406 .. _`GNAT.MD5_(g-md5.ads)`:
1407
1408 ``GNAT.MD5`` (:file:`g-md5.ads`)
1409 ================================
1410
1411 .. index:: GNAT.MD5 (g-md5.ads)
1412
1413 .. index:: Message Digest MD5
1414
1415 Implements the MD5 Message-Digest Algorithm as described in RFC 1321, and
1416 the HMAC-MD5 message authentication function as described in RFC 2104 and
1417 FIPS PUB 198.
1418
1419 .. _`GNAT.Memory_Dump_(g-memdum.ads)`:
1420
1421 ``GNAT.Memory_Dump`` (:file:`g-memdum.ads`)
1422 ===========================================
1423
1424 .. index:: GNAT.Memory_Dump (g-memdum.ads)
1425
1426 .. index:: Dump Memory
1427
1428 Provides a convenient routine for dumping raw memory to either the
1429 standard output or standard error files. Uses GNAT.IO for actual
1430 output.
1431
1432 .. _`GNAT.Most_Recent_Exception_(g-moreex.ads)`:
1433
1434 ``GNAT.Most_Recent_Exception`` (:file:`g-moreex.ads`)
1435 =====================================================
1436
1437 .. index:: GNAT.Most_Recent_Exception (g-moreex.ads)
1438
1439 .. index:: Exception, obtaining most recent
1440
1441 Provides access to the most recently raised exception.  Can be used for
1442 various logging purposes, including duplicating functionality of some
1443 Ada 83 implementation dependent extensions.
1444
1445 .. _`GNAT.OS_Lib_(g-os_lib.ads)`:
1446
1447 ``GNAT.OS_Lib`` (:file:`g-os_lib.ads`)
1448 ======================================
1449
1450 .. index:: GNAT.OS_Lib (g-os_lib.ads)
1451
1452 .. index:: Operating System interface
1453
1454 .. index:: Spawn capability
1455
1456 Provides a range of target independent operating system interface functions,
1457 including time/date management, file operations, subprocess management,
1458 including a portable spawn procedure, and access to environment variables
1459 and error return codes.
1460
1461 .. _`GNAT.Perfect_Hash_Generators_(g-pehage.ads)`:
1462
1463 ``GNAT.Perfect_Hash_Generators`` (:file:`g-pehage.ads`)
1464 =======================================================
1465
1466 .. index:: GNAT.Perfect_Hash_Generators (g-pehage.ads)
1467
1468 .. index:: Hash functions
1469
1470 Provides a generator of static minimal perfect hash functions. No
1471 collisions occur and each item can be retrieved from the table in one
1472 probe (perfect property). The hash table size corresponds to the exact
1473 size of the key set and no larger (minimal property). The key set has to
1474 be know in advance (static property). The hash functions are also order
1475 preserving. If w2 is inserted after w1 in the generator, their
1476 hashcode are in the same order. These hashing functions are very
1477 convenient for use with realtime applications.
1478
1479 .. _`GNAT.Random_Numbers_(g-rannum.ads)`:
1480
1481 ``GNAT.Random_Numbers`` (:file:`g-rannum.ads`)
1482 ==============================================
1483
1484 .. index:: GNAT.Random_Numbers (g-rannum.ads)
1485
1486 .. index:: Random number generation
1487
1488 Provides random number capabilities which extend those available in the
1489 standard Ada library and are more convenient to use.
1490
1491 .. _`GNAT.Regexp_(g-regexp.ads)`:
1492
1493 ``GNAT.Regexp`` (:file:`g-regexp.ads`)
1494 ======================================
1495
1496 .. index:: GNAT.Regexp (g-regexp.ads)
1497
1498 .. index:: Regular expressions
1499
1500 .. index:: Pattern matching
1501
1502 A simple implementation of regular expressions, using a subset of regular
1503 expression syntax copied from familiar Unix style utilities.  This is the
1504 simplest of the three pattern matching packages provided, and is particularly
1505 suitable for 'file globbing' applications.
1506
1507 .. _`GNAT.Registry_(g-regist.ads)`:
1508
1509 ``GNAT.Registry`` (:file:`g-regist.ads`)
1510 ========================================
1511
1512 .. index:: GNAT.Registry (g-regist.ads)
1513
1514 .. index:: Windows Registry
1515
1516 This is a high level binding to the Windows registry.  It is possible to
1517 do simple things like reading a key value, creating a new key.  For full
1518 registry API, but at a lower level of abstraction, refer to the Win32.Winreg
1519 package provided with the Win32Ada binding
1520
1521 .. _`GNAT.Regpat_(g-regpat.ads)`:
1522
1523 ``GNAT.Regpat`` (:file:`g-regpat.ads`)
1524 ======================================
1525
1526 .. index:: GNAT.Regpat (g-regpat.ads)
1527
1528 .. index:: Regular expressions
1529
1530 .. index:: Pattern matching
1531
1532 A complete implementation of Unix-style regular expression matching, copied
1533 from the original V7 style regular expression library written in C by
1534 Henry Spencer (and binary compatible with this C library).
1535
1536 .. _`GNAT.Rewrite_Data_(g-rewdat.ads)`:
1537
1538 ``GNAT.Rewrite_Data`` (:file:`g-rewdat.ads`)
1539 ============================================
1540
1541 .. index:: GNAT.Rewrite_Data (g-rewdat.ads)
1542
1543 .. index:: Rewrite data
1544
1545 A unit to rewrite on-the-fly string occurrences in a stream of
1546 data. The implementation has a very minimal memory footprint as the
1547 full content to be processed is not loaded into memory all at once. This makes
1548 this interface usable for large files or socket streams.
1549
1550 .. _`GNAT.Secondary_Stack_Info_(g-sestin.ads)`:
1551
1552 ``GNAT.Secondary_Stack_Info`` (:file:`g-sestin.ads`)
1553 ====================================================
1554
1555 .. index:: GNAT.Secondary_Stack_Info (g-sestin.ads)
1556
1557 .. index:: Secondary Stack Info
1558
1559 Provide the capability to query the high water mark of the current task's
1560 secondary stack.
1561
1562 .. _`GNAT.Semaphores_(g-semaph.ads)`:
1563
1564 ``GNAT.Semaphores`` (:file:`g-semaph.ads`)
1565 ==========================================
1566
1567 .. index:: GNAT.Semaphores (g-semaph.ads)
1568
1569 .. index:: Semaphores
1570
1571 Provides classic counting and binary semaphores using protected types.
1572
1573 .. _`GNAT.Serial_Communications_(g-sercom.ads)`:
1574
1575 ``GNAT.Serial_Communications`` (:file:`g-sercom.ads`)
1576 =====================================================
1577
1578 .. index:: GNAT.Serial_Communications (g-sercom.ads)
1579
1580 .. index:: Serial_Communications
1581
1582 Provides a simple interface to send and receive data over a serial
1583 port. This is only supported on GNU/Linux and Windows.
1584
1585 .. _`GNAT.SHA1_(g-sha1.ads)`:
1586
1587 ``GNAT.SHA1`` (:file:`g-sha1.ads`)
1588 ==================================
1589
1590 .. index:: GNAT.SHA1 (g-sha1.ads)
1591
1592 .. index:: Secure Hash Algorithm SHA-1
1593
1594 Implements the SHA-1 Secure Hash Algorithm as described in FIPS PUB 180-3
1595 and RFC 3174, and the HMAC-SHA1 message authentication function as described
1596 in RFC 2104 and FIPS PUB 198.
1597
1598 .. _`GNAT.SHA224_(g-sha224.ads)`:
1599
1600 ``GNAT.SHA224`` (:file:`g-sha224.ads`)
1601 ======================================
1602
1603 .. index:: GNAT.SHA224 (g-sha224.ads)
1604
1605 .. index:: Secure Hash Algorithm SHA-224
1606
1607 Implements the SHA-224 Secure Hash Algorithm as described in FIPS PUB 180-3,
1608 and the HMAC-SHA224 message authentication function as described
1609 in RFC 2104 and FIPS PUB 198.
1610
1611 .. _`GNAT.SHA256_(g-sha256.ads)`:
1612
1613 ``GNAT.SHA256`` (:file:`g-sha256.ads`)
1614 ======================================
1615
1616 .. index:: GNAT.SHA256 (g-sha256.ads)
1617
1618 .. index:: Secure Hash Algorithm SHA-256
1619
1620 Implements the SHA-256 Secure Hash Algorithm as described in FIPS PUB 180-3,
1621 and the HMAC-SHA256 message authentication function as described
1622 in RFC 2104 and FIPS PUB 198.
1623
1624 .. _`GNAT.SHA384_(g-sha384.ads)`:
1625
1626 ``GNAT.SHA384`` (:file:`g-sha384.ads`)
1627 ======================================
1628
1629 .. index:: GNAT.SHA384 (g-sha384.ads)
1630
1631 .. index:: Secure Hash Algorithm SHA-384
1632
1633 Implements the SHA-384 Secure Hash Algorithm as described in FIPS PUB 180-3,
1634 and the HMAC-SHA384 message authentication function as described
1635 in RFC 2104 and FIPS PUB 198.
1636
1637 .. _`GNAT.SHA512_(g-sha512.ads)`:
1638
1639 ``GNAT.SHA512`` (:file:`g-sha512.ads`)
1640 ======================================
1641
1642 .. index:: GNAT.SHA512 (g-sha512.ads)
1643
1644 .. index:: Secure Hash Algorithm SHA-512
1645
1646 Implements the SHA-512 Secure Hash Algorithm as described in FIPS PUB 180-3,
1647 and the HMAC-SHA512 message authentication function as described
1648 in RFC 2104 and FIPS PUB 198.
1649
1650 .. _`GNAT.Signals_(g-signal.ads)`:
1651
1652 ``GNAT.Signals`` (:file:`g-signal.ads`)
1653 =======================================
1654
1655 .. index:: GNAT.Signals (g-signal.ads)
1656
1657 .. index:: Signals
1658
1659 Provides the ability to manipulate the blocked status of signals on supported
1660 targets.
1661
1662 .. _`GNAT.Sockets_(g-socket.ads)`:
1663
1664 ``GNAT.Sockets`` (:file:`g-socket.ads`)
1665 =======================================
1666
1667 .. index:: GNAT.Sockets (g-socket.ads)
1668
1669 .. index:: Sockets
1670
1671 A high level and portable interface to develop sockets based applications.
1672 This package is based on the sockets thin binding found in
1673 ``GNAT.Sockets.Thin``. Currently ``GNAT.Sockets`` is implemented
1674 on all native GNAT ports and on VxWorks cross prots.  It is not implemented for
1675 the LynxOS cross port.
1676
1677 .. _`GNAT.Source_Info_(g-souinf.ads)`:
1678
1679 ``GNAT.Source_Info`` (:file:`g-souinf.ads`)
1680 ===========================================
1681
1682 .. index:: GNAT.Source_Info (g-souinf.ads)
1683
1684 .. index:: Source Information
1685
1686 Provides subprograms that give access to source code information known at
1687 compile time, such as the current file name and line number. Also provides
1688 subprograms yielding the date and time of the current compilation (like the
1689 C macros ``__DATE__`` and ``__TIME__``)
1690
1691 .. _`GNAT.Spelling_Checker_(g-speche.ads)`:
1692
1693 ``GNAT.Spelling_Checker`` (:file:`g-speche.ads`)
1694 ================================================
1695
1696 .. index:: GNAT.Spelling_Checker (g-speche.ads)
1697
1698 .. index:: Spell checking
1699
1700 Provides a function for determining whether one string is a plausible
1701 near misspelling of another string.
1702
1703 .. _`GNAT.Spelling_Checker_Generic_(g-spchge.ads)`:
1704
1705 ``GNAT.Spelling_Checker_Generic`` (:file:`g-spchge.ads`)
1706 ========================================================
1707
1708 .. index:: GNAT.Spelling_Checker_Generic (g-spchge.ads)
1709
1710 .. index:: Spell checking
1711
1712 Provides a generic function that can be instantiated with a string type for
1713 determining whether one string is a plausible near misspelling of another
1714 string.
1715
1716 .. _`GNAT.Spitbol.Patterns_(g-spipat.ads)`:
1717
1718 ``GNAT.Spitbol.Patterns`` (:file:`g-spipat.ads`)
1719 ================================================
1720
1721 .. index:: GNAT.Spitbol.Patterns (g-spipat.ads)
1722
1723 .. index:: SPITBOL pattern matching
1724
1725 .. index:: Pattern matching
1726
1727 A complete implementation of SNOBOL4 style pattern matching.  This is the
1728 most elaborate of the pattern matching packages provided.  It fully duplicates
1729 the SNOBOL4 dynamic pattern construction and matching capabilities, using the
1730 efficient algorithm developed by Robert Dewar for the SPITBOL system.
1731
1732 .. _`GNAT.Spitbol_(g-spitbo.ads)`:
1733
1734 ``GNAT.Spitbol`` (:file:`g-spitbo.ads`)
1735 =======================================
1736
1737 .. index:: GNAT.Spitbol (g-spitbo.ads)
1738
1739 .. index:: SPITBOL interface
1740
1741 The top level package of the collection of SPITBOL-style functionality, this
1742 package provides basic SNOBOL4 string manipulation functions, such as
1743 Pad, Reverse, Trim, Substr capability, as well as a generic table function
1744 useful for constructing arbitrary mappings from strings in the style of
1745 the SNOBOL4 TABLE function.
1746
1747 .. _`GNAT.Spitbol.Table_Boolean_(g-sptabo.ads)`:
1748
1749 ``GNAT.Spitbol.Table_Boolean`` (:file:`g-sptabo.ads`)
1750 =====================================================
1751
1752 .. index:: GNAT.Spitbol.Table_Boolean (g-sptabo.ads)
1753
1754 .. index:: Sets of strings
1755
1756 .. index:: SPITBOL Tables
1757
1758 A library level of instantiation of ``GNAT.Spitbol.Patterns.Table``
1759 for type ``Standard.Boolean``, giving an implementation of sets of
1760 string values.
1761
1762 .. _`GNAT.Spitbol.Table_Integer_(g-sptain.ads)`:
1763
1764 ``GNAT.Spitbol.Table_Integer`` (:file:`g-sptain.ads`)
1765 =====================================================
1766
1767 .. index:: GNAT.Spitbol.Table_Integer (g-sptain.ads)
1768
1769 .. index:: Integer maps
1770
1771 .. index:: Maps
1772
1773 .. index:: SPITBOL Tables
1774
1775 A library level of instantiation of ``GNAT.Spitbol.Patterns.Table``
1776 for type ``Standard.Integer``, giving an implementation of maps
1777 from string to integer values.
1778
1779 .. _`GNAT.Spitbol.Table_VString_(g-sptavs.ads)`:
1780
1781 ``GNAT.Spitbol.Table_VString`` (:file:`g-sptavs.ads`)
1782 =====================================================
1783
1784 .. index:: GNAT.Spitbol.Table_VString (g-sptavs.ads)
1785
1786 .. index:: String maps
1787
1788 .. index:: Maps
1789
1790 .. index:: SPITBOL Tables
1791
1792 A library level of instantiation of ``GNAT.Spitbol.Patterns.Table`` for
1793 a variable length string type, giving an implementation of general
1794 maps from strings to strings.
1795
1796 .. _`GNAT.SSE_(g-sse.ads)`:
1797
1798 ``GNAT.SSE`` (:file:`g-sse.ads`)
1799 ================================
1800
1801 .. index:: GNAT.SSE (g-sse.ads)
1802
1803 Root of a set of units aimed at offering Ada bindings to a subset of
1804 the Intel(r) Streaming SIMD Extensions with GNAT on the x86 family of
1805 targets.  It exposes vector component types together with a general
1806 introduction to the binding contents and use.
1807
1808 .. _`GNAT.SSE.Vector_Types_(g-ssvety.ads)`:
1809
1810 ``GNAT.SSE.Vector_Types`` (:file:`g-ssvety.ads`)
1811 ================================================
1812
1813 .. index:: GNAT.SSE.Vector_Types (g-ssvety.ads)
1814
1815 SSE vector types for use with SSE related intrinsics.
1816
1817 .. _`GNAT.String_Hash(g-strhas.ads)`:
1818
1819 ``GNAT.String_Hash`` (:file:`g-strhas.ads`)
1820 ===========================================
1821
1822 .. index:: GNAT.String_Hash (g-strhas.ads)
1823
1824 .. index:: Hash functions
1825
1826 Provides a generic hash function working on arrays of scalars. Both the scalar
1827 type and the hash result type are parameters.
1828
1829 .. _`GNAT.Strings_(g-string.ads)`:
1830
1831 ``GNAT.Strings`` (:file:`g-string.ads`)
1832 =======================================
1833
1834 .. index:: GNAT.Strings (g-string.ads)
1835
1836 Common String access types and related subprograms. Basically it
1837 defines a string access and an array of string access types.
1838
1839 .. _`GNAT.String_Split_(g-strspl.ads)`:
1840
1841 ``GNAT.String_Split`` (:file:`g-strspl.ads`)
1842 ============================================
1843
1844 .. index:: GNAT.String_Split (g-strspl.ads)
1845
1846 .. index:: String splitter
1847
1848 Useful string manipulation routines: given a set of separators, split
1849 a string wherever the separators appear, and provide direct access
1850 to the resulting slices. This package is instantiated from
1851 ``GNAT.Array_Split``.
1852
1853 .. _`GNAT.Table_(g-table.ads)`:
1854
1855 ``GNAT.Table`` (:file:`g-table.ads`)
1856 ====================================
1857
1858 .. index:: GNAT.Table (g-table.ads)
1859
1860 .. index:: Table implementation
1861
1862 .. index:: Arrays, extendable
1863
1864 A generic package providing a single dimension array abstraction where the
1865 length of the array can be dynamically modified.
1866
1867 This package provides a facility similar to that of ``GNAT.Dynamic_Tables``,
1868 except that this package declares a single instance of the table type,
1869 while an instantiation of ``GNAT.Dynamic_Tables`` creates a type that can be
1870 used to define dynamic instances of the table.
1871
1872 .. _`GNAT.Task_Lock_(g-tasloc.ads)`:
1873
1874 ``GNAT.Task_Lock`` (:file:`g-tasloc.ads`)
1875 =========================================
1876
1877 .. index:: GNAT.Task_Lock (g-tasloc.ads)
1878
1879 .. index:: Task synchronization
1880
1881 .. index:: Task locking
1882
1883 .. index:: Locking
1884
1885 A very simple facility for locking and unlocking sections of code using a
1886 single global task lock.  Appropriate for use in situations where contention
1887 between tasks is very rarely expected.
1888
1889 .. _`GNAT.Time_Stamp_(g-timsta.ads)`:
1890
1891 ``GNAT.Time_Stamp`` (:file:`g-timsta.ads`)
1892 ==========================================
1893
1894 .. index:: GNAT.Time_Stamp (g-timsta.ads)
1895
1896 .. index:: Time stamp
1897
1898 .. index:: Current time
1899
1900 Provides a simple function that returns a string YYYY-MM-DD HH:MM:SS.SS that
1901 represents the current date and time in ISO 8601 format. This is a very simple
1902 routine with minimal code and there are no dependencies on any other unit.
1903
1904 .. _`GNAT.Threads_(g-thread.ads)`:
1905
1906 ``GNAT.Threads`` (:file:`g-thread.ads`)
1907 =======================================
1908
1909 .. index:: GNAT.Threads (g-thread.ads)
1910
1911 .. index:: Foreign threads
1912
1913 .. index:: Threads, foreign
1914
1915 Provides facilities for dealing with foreign threads which need to be known
1916 by the GNAT run-time system. Consult the documentation of this package for
1917 further details if your program has threads that are created by a non-Ada
1918 environment which then accesses Ada code.
1919
1920 .. _`GNAT.Traceback_(g-traceb.ads)`:
1921
1922 ``GNAT.Traceback`` (:file:`g-traceb.ads`)
1923 =========================================
1924
1925 .. index:: GNAT.Traceback (g-traceb.ads)
1926
1927 .. index:: Trace back facilities
1928
1929 Provides a facility for obtaining non-symbolic traceback information, useful
1930 in various debugging situations.
1931
1932 .. _`GNAT.Traceback.Symbolic_(g-trasym.ads)`:
1933
1934 ``GNAT.Traceback.Symbolic`` (:file:`g-trasym.ads`)
1935 ==================================================
1936
1937 .. index:: GNAT.Traceback.Symbolic (g-trasym.ads)
1938
1939 .. index:: Trace back facilities
1940
1941 .. _`GNAT.UTF_32_(g-table.ads)`:
1942
1943 ``GNAT.UTF_32`` (:file:`g-table.ads`)
1944 =====================================
1945
1946 .. index:: GNAT.UTF_32 (g-table.ads)
1947
1948 .. index:: Wide character codes
1949
1950 This is a package intended to be used in conjunction with the
1951 ``Wide_Character`` type in Ada 95 and the
1952 ``Wide_Wide_Character`` type in Ada 2005 (available
1953 in ``GNAT`` in Ada 2005 mode). This package contains
1954 Unicode categorization routines, as well as lexical
1955 categorization routines corresponding to the Ada 2005
1956 lexical rules for identifiers and strings, and also a
1957 lower case to upper case fold routine corresponding to
1958 the Ada 2005 rules for identifier equivalence.
1959
1960 .. _`GNAT.Wide_Spelling_Checker_(g-u3spch.ads)`:
1961
1962 ``GNAT.Wide_Spelling_Checker`` (:file:`g-u3spch.ads`)
1963 =====================================================
1964
1965 .. index:: GNAT.Wide_Spelling_Checker (g-u3spch.ads)
1966
1967 .. index:: Spell checking
1968
1969 Provides a function for determining whether one wide wide string is a plausible
1970 near misspelling of another wide wide string, where the strings are represented
1971 using the UTF_32_String type defined in System.Wch_Cnv.
1972
1973 .. _`GNAT.Wide_Spelling_Checker_(g-wispch.ads)`:
1974
1975 ``GNAT.Wide_Spelling_Checker`` (:file:`g-wispch.ads`)
1976 =====================================================
1977
1978 .. index:: GNAT.Wide_Spelling_Checker (g-wispch.ads)
1979
1980 .. index:: Spell checking
1981
1982 Provides a function for determining whether one wide string is a plausible
1983 near misspelling of another wide string.
1984
1985 .. _`GNAT.Wide_String_Split_(g-wistsp.ads)`:
1986
1987 ``GNAT.Wide_String_Split`` (:file:`g-wistsp.ads`)
1988 =================================================
1989
1990 .. index:: GNAT.Wide_String_Split (g-wistsp.ads)
1991
1992 .. index:: Wide_String splitter
1993
1994 Useful wide string manipulation routines: given a set of separators, split
1995 a wide string wherever the separators appear, and provide direct access
1996 to the resulting slices. This package is instantiated from
1997 ``GNAT.Array_Split``.
1998
1999 .. _`GNAT.Wide_Wide_Spelling_Checker_(g-zspche.ads)`:
2000
2001 ``GNAT.Wide_Wide_Spelling_Checker`` (:file:`g-zspche.ads`)
2002 ==========================================================
2003
2004 .. index:: GNAT.Wide_Wide_Spelling_Checker (g-zspche.ads)
2005
2006 .. index:: Spell checking
2007
2008 Provides a function for determining whether one wide wide string is a plausible
2009 near misspelling of another wide wide string.
2010
2011 .. _`GNAT.Wide_Wide_String_Split_(g-zistsp.ads)`:
2012
2013 ``GNAT.Wide_Wide_String_Split`` (:file:`g-zistsp.ads`)
2014 ======================================================
2015
2016 .. index:: GNAT.Wide_Wide_String_Split (g-zistsp.ads)
2017
2018 .. index:: Wide_Wide_String splitter
2019
2020 Useful wide wide string manipulation routines: given a set of separators, split
2021 a wide wide string wherever the separators appear, and provide direct access
2022 to the resulting slices. This package is instantiated from
2023 ``GNAT.Array_Split``.
2024
2025 .. _`Interfaces.C.Extensions_(i-cexten.ads)`:
2026
2027 ``Interfaces.C.Extensions`` (:file:`i-cexten.ads`)
2028 ==================================================
2029
2030 .. index:: Interfaces.C.Extensions (i-cexten.ads)
2031
2032 This package contains additional C-related definitions, intended
2033 for use with either manually or automatically generated bindings
2034 to C libraries.
2035
2036 .. _`Interfaces.C.Streams_(i-cstrea.ads)`:
2037
2038 ``Interfaces.C.Streams`` (:file:`i-cstrea.ads`)
2039 ===============================================
2040
2041 .. index:: Interfaces.C.Streams (i-cstrea.ads)
2042
2043 .. index::  C streams, interfacing
2044
2045 This package is a binding for the most commonly used operations
2046 on C streams.
2047
2048 .. _`Interfaces.Packed_Decimal_(i-pacdec.ads)`:
2049
2050 ``Interfaces.Packed_Decimal`` (:file:`i-pacdec.ads`)
2051 ====================================================
2052
2053 .. index:: Interfaces.Packed_Decimal (i-pacdec.ads)
2054
2055 .. index::  IBM Packed Format
2056
2057 .. index::  Packed Decimal
2058
2059 This package provides a set of routines for conversions to and
2060 from a packed decimal format compatible with that used on IBM
2061 mainframes.
2062
2063 .. _`Interfaces.VxWorks_(i-vxwork.ads)`:
2064
2065 ``Interfaces.VxWorks`` (:file:`i-vxwork.ads`)
2066 =============================================
2067
2068 .. index:: Interfaces.VxWorks (i-vxwork.ads)
2069
2070 .. index:: Interfacing to VxWorks
2071
2072 .. index:: VxWorks, interfacing
2073
2074 This package provides a limited binding to the VxWorks API.
2075 In particular, it interfaces with the
2076 VxWorks hardware interrupt facilities.
2077
2078 .. _`Interfaces.VxWorks.Int_Connection_(i-vxinco.ads)`:
2079
2080 ``Interfaces.VxWorks.Int_Connection`` (:file:`i-vxinco.ads`)
2081 ============================================================
2082
2083 .. index:: Interfaces.VxWorks.Int_Connection (i-vxinco.ads)
2084
2085 .. index:: Interfacing to VxWorks
2086
2087 .. index:: VxWorks, interfacing
2088
2089 This package provides a way for users to replace the use of
2090 intConnect() with a custom routine for installing interrupt
2091 handlers.
2092
2093 .. _`Interfaces.VxWorks.IO_(i-vxwoio.ads)`:
2094
2095 ``Interfaces.VxWorks.IO`` (:file:`i-vxwoio.ads`)
2096 ================================================
2097
2098 .. index:: Interfaces.VxWorks.IO (i-vxwoio.ads)
2099
2100 .. index:: Interfacing to VxWorks' I/O
2101
2102 .. index:: VxWorks, I/O interfacing
2103
2104 .. index:: VxWorks, Get_Immediate
2105
2106 .. index:: Get_Immediate, VxWorks
2107
2108 This package provides a binding to the ioctl (IO/Control)
2109 function of VxWorks, defining a set of option values and
2110 function codes. A particular use of this package is
2111 to enable the use of Get_Immediate under VxWorks.
2112
2113 .. _`System.Address_Image_(s-addima.ads)`:
2114
2115 ``System.Address_Image`` (:file:`s-addima.ads`)
2116 ===============================================
2117
2118 .. index:: System.Address_Image (s-addima.ads)
2119
2120 .. index:: Address image
2121
2122 .. index:: Image, of an address
2123
2124 This function provides a useful debugging
2125 function that gives an (implementation dependent)
2126 string which identifies an address.
2127
2128 .. _`System.Assertions_(s-assert.ads)`:
2129
2130 ``System.Assertions`` (:file:`s-assert.ads`)
2131 ============================================
2132
2133 .. index:: System.Assertions (s-assert.ads)
2134
2135 .. index:: Assertions
2136
2137 .. index:: Assert_Failure, exception
2138
2139 This package provides the declaration of the exception raised
2140 by an run-time assertion failure, as well as the routine that
2141 is used internally to raise this assertion.
2142
2143 .. _`System.Atomic_Counters_(s-atocou.ads)`:
2144
2145 ``System.Atomic_Counters`` (:file:`s-atocou.ads`)
2146 =================================================
2147
2148 .. index:: System.Atomic_Counters (s-atocou.ads)
2149
2150 This package provides the declaration of an atomic counter type,
2151 together with efficient routines (using hardware
2152 synchronization primitives) for incrementing, decrementing,
2153 and testing of these counters. This package is implemented
2154 on most targets, including all Alpha, ia64, PowerPC, SPARC V9,
2155 x86, and x86_64 platforms.
2156
2157 .. _`System.Memory_(s-memory.ads)`:
2158
2159 ``System.Memory`` (:file:`s-memory.ads`)
2160 ========================================
2161
2162 .. index:: System.Memory (s-memory.ads)
2163
2164 .. index:: Memory allocation
2165
2166 This package provides the interface to the low level routines used
2167 by the generated code for allocation and freeing storage for the
2168 default storage pool (analogous to the C routines malloc and free.
2169 It also provides a reallocation interface analogous to the C routine
2170 realloc. The body of this unit may be modified to provide alternative
2171 allocation mechanisms for the default pool, and in addition, direct
2172 calls to this unit may be made for low level allocation uses (for
2173 example see the body of ``GNAT.Tables``).
2174
2175 .. _`System.Multiprocessors_(s-multip.ads)`:
2176
2177 ``System.Multiprocessors`` (:file:`s-multip.ads`)
2178 =================================================
2179
2180 .. index:: System.Multiprocessors (s-multip.ads)
2181
2182 .. index:: Multiprocessor interface
2183
2184 This is an Ada 2012 unit defined in the Ada 2012 Reference Manual, but
2185 in GNAT we also make it available in Ada 95 and Ada 2005 (where it is
2186 technically an implementation-defined addition).
2187
2188 .. _`System.Multiprocessors.Dispatching_Domains_(s-mudido.ads)`:
2189
2190 ``System.Multiprocessors.Dispatching_Domains`` (:file:`s-mudido.ads`)
2191 =====================================================================
2192
2193 .. index:: System.Multiprocessors.Dispatching_Domains (s-mudido.ads)
2194
2195 .. index:: Multiprocessor interface
2196
2197 This is an Ada 2012 unit defined in the Ada 2012 Reference Manual, but
2198 in GNAT we also make it available in Ada 95 and Ada 2005 (where it is
2199 technically an implementation-defined addition).
2200
2201 .. _`System.Partition_Interface_(s-parint.ads)`:
2202
2203 ``System.Partition_Interface`` (:file:`s-parint.ads`)
2204 =====================================================
2205
2206 .. index:: System.Partition_Interface (s-parint.ads)
2207
2208 .. index:: Partition interfacing functions
2209
2210 This package provides facilities for partition interfacing.  It
2211 is used primarily in a distribution context when using Annex E
2212 with ``GLADE``.
2213
2214 .. _`System.Pool_Global_(s-pooglo.ads)`:
2215
2216 ``System.Pool_Global`` (:file:`s-pooglo.ads`)
2217 =============================================
2218
2219 .. index:: System.Pool_Global (s-pooglo.ads)
2220
2221 .. index:: Storage pool, global
2222
2223 .. index:: Global storage pool
2224
2225 This package provides a storage pool that is equivalent to the default
2226 storage pool used for access types for which no pool is specifically
2227 declared. It uses malloc/free to allocate/free and does not attempt to
2228 do any automatic reclamation.
2229
2230 .. _`System.Pool_Local_(s-pooloc.ads)`:
2231
2232 ``System.Pool_Local`` (:file:`s-pooloc.ads`)
2233 ============================================
2234
2235 .. index:: System.Pool_Local (s-pooloc.ads)
2236
2237 .. index:: Storage pool, local
2238
2239 .. index:: Local storage pool
2240
2241 This package provides a storage pool that is intended for use with locally
2242 defined access types. It uses malloc/free for allocate/free, and maintains
2243 a list of allocated blocks, so that all storage allocated for the pool can
2244 be freed automatically when the pool is finalized.
2245
2246 .. _`System.Restrictions_(s-restri.ads)`:
2247
2248 ``System.Restrictions`` (:file:`s-restri.ads`)
2249 ==============================================
2250
2251 .. index:: System.Restrictions (s-restri.ads)
2252
2253 .. index:: Run-time restrictions access
2254
2255 This package provides facilities for accessing at run time
2256 the status of restrictions specified at compile time for
2257 the partition. Information is available both with regard
2258 to actual restrictions specified, and with regard to
2259 compiler determined information on which restrictions
2260 are violated by one or more packages in the partition.
2261
2262 .. _`System.Rident_(s-rident.ads)`:
2263
2264 ``System.Rident`` (:file:`s-rident.ads`)
2265 ========================================
2266
2267 .. index:: System.Rident (s-rident.ads)
2268
2269 .. index:: Restrictions definitions
2270
2271 This package provides definitions of the restrictions
2272 identifiers supported by GNAT, and also the format of
2273 the restrictions provided in package System.Restrictions.
2274 It is not normally necessary to ``with`` this generic package
2275 since the necessary instantiation is included in
2276 package System.Restrictions.
2277
2278 .. _`System.Strings.Stream_Ops_(s-ststop.ads)`:
2279
2280 ``System.Strings.Stream_Ops`` (:file:`s-ststop.ads`)
2281 ====================================================
2282
2283 .. index:: System.Strings.Stream_Ops (s-ststop.ads)
2284
2285 .. index:: Stream operations
2286
2287 .. index:: String stream operations
2288
2289 This package provides a set of stream subprograms for standard string types.
2290 It is intended primarily to support implicit use of such subprograms when
2291 stream attributes are applied to string types, but the subprograms in this
2292 package can be used directly by application programs.
2293
2294 .. _`System.Unsigned_Types_(s-unstyp.ads)`:
2295
2296 ``System.Unsigned_Types`` (:file:`s-unstyp.ads`)
2297 ================================================
2298
2299 .. index:: System.Unsigned_Types (s-unstyp.ads)
2300
2301 This package contains definitions of standard unsigned types that
2302 correspond in size to the standard signed types declared in Standard,
2303 and (unlike the types in Interfaces) have corresponding names. It
2304 also contains some related definitions for other specialized types
2305 used by the compiler in connection with packed array types.
2306
2307 .. _`System.Wch_Cnv_(s-wchcnv.ads)`:
2308
2309 ``System.Wch_Cnv`` (:file:`s-wchcnv.ads`)
2310 =========================================
2311
2312 .. index:: System.Wch_Cnv (s-wchcnv.ads)
2313
2314 .. index:: Wide Character, Representation
2315
2316 .. index:: Wide String, Conversion
2317
2318 .. index:: Representation of wide characters
2319
2320 This package provides routines for converting between
2321 wide and wide wide characters and a representation as a value of type
2322 ``Standard.String``, using a specified wide character
2323 encoding method.  It uses definitions in
2324 package ``System.Wch_Con``.
2325
2326 .. _`System.Wch_Con_(s-wchcon.ads)`:
2327
2328 ``System.Wch_Con`` (:file:`s-wchcon.ads`)
2329 =========================================
2330
2331 .. index:: System.Wch_Con (s-wchcon.ads)
2332
2333 This package provides definitions and descriptions of
2334 the various methods used for encoding wide characters
2335 in ordinary strings.  These definitions are used by
2336 the package ``System.Wch_Cnv``.