Debian Codegraph @

gcc/ada/doc/gnat_rm/the_gnat_library.rst

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