update from main archive 961207
[kopensolaris-gnu/glibc.git] / manual / intro.texi
1 @node Introduction, Error Reporting, Top, Top
2 @chapter Introduction
3
4 The C language provides no built-in facilities for performing such
5 common operations as input/output, memory management, string
6 manipulation, and the like.  Instead, these facilities are defined
7 in a standard @dfn{library}, which you compile and link with your
8 programs.
9 @cindex library
10
11 The GNU C library, described in this document, defines all of the
12 library functions that are specified by the @w{ISO C} standard, as well as
13 additional features specific to POSIX and other derivatives of the Unix
14 operating system, and extensions specific to the GNU system.
15
16 The purpose of this manual is to tell you how to use the facilities
17 of the GNU library.  We have mentioned which features belong to which
18 standards to help you identify things that are potentially nonportable
19 to other systems.  But the emphasis in this manual is not on strict
20 portability.
21
22 @menu
23 * Getting Started::             What this manual is for and how to use it.
24 * Standards and Portability::   Standards and sources upon which the GNU
25                                  C library is based.
26 * Using the Library::           Some practical uses for the library.
27 * Roadmap to the Manual::       Overview of the remaining chapters in
28                                  this manual.
29 @end menu
30
31 @node Getting Started, Standards and Portability,  , Introduction
32 @section Getting Started
33
34 This manual is written with the assumption that you are at least
35 somewhat familiar with the C programming language and basic programming
36 concepts.  Specifically, familiarity with ISO standard C
37 (@pxref{ISO C}), rather than ``traditional'' pre-ISO C dialects, is
38 assumed.
39
40 The GNU C library includes several @dfn{header files}, each of which
41 provides definitions and declarations for a group of related facilities;
42 this information is used by the C compiler when processing your program.
43 For example, the header file @file{stdio.h} declares facilities for
44 performing input and output, and the header file @file{string.h}
45 declares string processing utilities.  The organization of this manual
46 generally follows the same division as the header files.
47
48 If you are reading this manual for the first time, you should read all
49 of the introductory material and skim the remaining chapters.  There are
50 a @emph{lot} of functions in the GNU C library and it's not realistic to
51 expect that you will be able to remember exactly @emph{how} to use each
52 and every one of them.  It's more important to become generally familiar
53 with the kinds of facilities that the library provides, so that when you
54 are writing your programs you can recognize @emph{when} to make use of
55 library functions, and @emph{where} in this manual you can find more
56 specific information about them.
57
58
59 @node Standards and Portability, Using the Library, Getting Started, Introduction
60 @section Standards and Portability
61 @cindex standards
62
63 This section discusses the various standards and other sources that the
64 GNU C library is based upon.  These sources include the @w{ISO C} and
65 POSIX standards, and the System V and Berkeley Unix implementations.
66
67 The primary focus of this manual is to tell you how to make effective
68 use of the GNU library facilities.  But if you are concerned about
69 making your programs compatible with these standards, or portable to
70 operating systems other than GNU, this can affect how you use the
71 library.  This section gives you an overview of these standards, so that
72 you will know what they are when they are mentioned in other parts of
73 the manual.
74
75 @xref{Library Summary}, for an alphabetical list of the functions and
76 other symbols provided by the library.  This list also states which
77 standards each function or symbol comes from.
78
79 @menu
80 * ISO C::                      The international standard for the C
81                                  programming language.
82 * POSIX::                       The ISO/IEC 9945 (aka IEEE 1003) standards
83                                  for operating systems.
84 * Berkeley Unix::               BSD and SunOS.
85 * SVID::                        The System V Interface Description.
86 @end menu
87
88 @node ISO C, POSIX,  , Standards and Portability
89 @subsection ISO C
90 @cindex ISO C
91
92 The GNU C library is compatible with the C standard adopted by the
93 American National Standards Institute (ANSI):
94 @cite{American National Standard X3.159-1989---``ANSI C''} and later
95 by the International Standardization Organizaion (ISO):
96 @cite{ISO/IEC 9899:1990, ``Programming languages---C''}.
97 We here refer to the standard as @w{ISO C} since this is the more
98 general standard in respect of ratification.
99 The header files and library facilities that make up the GNU library are
100 a superset of those specified by the @w{ISO C} standard.@refill
101
102 @pindex gcc
103 If you are concerned about strict adherence to the @w{ISO C} standard, you
104 should use the @samp{-ansi} option when you compile your programs with
105 the GNU C compiler.  This tells the compiler to define @emph{only} ISO
106 standard features from the library header files, unless you explicitly
107 ask for additional features.  @xref{Feature Test Macros}, for
108 information on how to do this.
109
110 Being able to restrict the library to include only @w{ISO C} features is
111 important because @w{ISO C} puts limitations on what names can be defined
112 by the library implementation, and the GNU extensions don't fit these
113 limitations.  @xref{Reserved Names}, for more information about these
114 restrictions.
115
116 This manual does not attempt to give you complete details on the
117 differences between @w{ISO C} and older dialects.  It gives advice on how
118 to write programs to work portably under multiple C dialects, but does
119 not aim for completeness.
120
121 @node POSIX, Berkeley Unix, ISO C, Standards and Portability
122 @subsection POSIX (The Portable Operating System Interface)
123 @cindex POSIX
124 @cindex POSIX.1
125 @cindex IEEE Std 1003.1
126 @cindex POSIX.2
127 @cindex IEEE Std 1003.2
128
129 The GNU library is also compatible with the IEEE @dfn{POSIX} family of
130 standards, known more formally as the @dfn{Portable Operating System
131 Interface for Computer Environments}.  POSIX is derived mostly from
132 various versions of the Unix operating system.
133
134 The library facilities specified by the POSIX standards are a superset
135 of those required by @w{ISO C}; POSIX specifies additional features for
136 @w{ISO C} functions, as well as specifying new additional functions.  In
137 general, the additional requirements and functionality defined by the
138 POSIX standards are aimed at providing lower-level support for a
139 particular kind of operating system environment, rather than general
140 programming language support which can run in many diverse operating
141 system environments.@refill
142
143 The GNU C library implements all of the functions specified in
144 @cite{IEEE Std 1003.1-1990, the POSIX System Application Program
145 Interface}, commonly referred to as POSIX.1.  The primary extensions to
146 the @w{ISO C} facilities specified by this standard include file system
147 interface primitives (@pxref{File System Interface}), device-specific
148 terminal control functions (@pxref{Low-Level Terminal Interface}), and
149 process control functions (@pxref{Processes}).
150
151 Some facilities from @cite{IEEE Std 1003.2-1992, the POSIX Shell and
152 Utilities standard} (POSIX.2) are also implemented in the GNU library.
153 These include utilities for dealing with regular expressions and other
154 pattern matching facilities (@pxref{Pattern Matching}).
155
156 @comment Roland sez:
157 @comment The GNU C library as it stands conforms to 1003.2 draft 11, which
158 @comment specifies:
159 @comment
160 @comment Several new macros in <limits.h>.
161 @comment popen, pclose
162 @comment <regex.h> (which is not yet fully implemented--wait on this)
163 @comment fnmatch
164 @comment getopt
165 @comment <glob.h>
166 @comment <wordexp.h> (not yet implemented)
167 @comment confstr
168
169
170 @node Berkeley Unix, SVID, POSIX, Standards and Portability
171 @subsection Berkeley Unix
172 @cindex BSD Unix
173 @cindex 4.@var{n} BSD Unix
174 @cindex Berkeley Unix
175 @cindex SunOS
176 @cindex Unix, Berkeley
177
178 The GNU C library defines facilities from some versions of Unix which
179 are not formally standardized, specifically from the 4.2 BSD, 4.3 BSD,
180 and 4.4 BSD Unix systems (also known as @dfn{Berkeley Unix}) and from
181 @dfn{SunOS} (a popular 4.2 BSD derivative that includes some Unix System
182 V functionality).  These systems support most of the @w{ISO C} and POSIX
183 facilities, and 4.4 BSD and newer releases of SunOS in fact support them all.
184
185 The BSD facilities include symbolic links (@pxref{Symbolic Links}), the
186 @code{select} function (@pxref{Waiting for I/O}), the BSD signal
187 functions (@pxref{BSD Signal Handling}), and sockets (@pxref{Sockets}).
188
189 @node SVID,  , Berkeley Unix, Standards and Portability
190 @subsection SVID (The System V Interface Description)
191 @cindex SVID
192 @cindex System V Unix
193 @cindex Unix, System V
194
195 The @dfn{System V Interface Description} (SVID) is a document describing
196 the AT&T Unix System V operating system.  It is to some extent a
197 superset of the POSIX standard (@pxref{POSIX}).
198
199 The GNU C library defines some of the facilities required by the SVID
200 that are not also required by the @w{ISO C} or POSIX standards, for
201 compatibility with  System V Unix and other Unix systems (such as
202 SunOS) which include these facilities.  However, many of the more
203 obscure and less generally useful facilities required by the SVID are
204 not included.  (In fact, Unix System V itself does not provide them all.)
205
206 @c !!! mention sysv ipc/shmem when it is there.
207
208
209 @node Using the Library, Roadmap to the Manual, Standards and Portability, Introduction
210 @section Using the Library
211
212 This section describes some of the practical issues involved in using
213 the GNU C library.
214
215 @menu
216 * Header Files::                How to include the header files in your
217                                  programs.
218 * Macro Definitions::           Some functions in the library may really
219                                  be implemented as macros.
220 * Reserved Names::              The C standard reserves some names for
221                                  the library, and some for users.
222 * Feature Test Macros::         How to control what names are defined.
223 @end menu
224
225 @node Header Files, Macro Definitions,  , Using the Library
226 @subsection Header Files
227 @cindex header files
228
229 Libraries for use by C programs really consist of two parts: @dfn{header
230 files} that define types and macros and declare variables and
231 functions; and the actual library or @dfn{archive} that contains the
232 definitions of the variables and functions.
233
234 (Recall that in C, a @dfn{declaration} merely provides information that
235 a function or variable exists and gives its type.  For a function
236 declaration, information about the types of its arguments might be
237 provided as well.  The purpose of declarations is to allow the compiler
238 to correctly process references to the declared variables and functions.
239 A @dfn{definition}, on the other hand, actually allocates storage for a
240 variable or says what a function does.)
241 @cindex definition (compared to declaration)
242 @cindex declaration (compared to definition)
243
244 In order to use the facilities in the GNU C library, you should be sure
245 that your program source files include the appropriate header files.
246 This is so that the compiler has declarations of these facilities
247 available and can correctly process references to them.  Once your
248 program has been compiled, the linker resolves these references to
249 the actual definitions provided in the archive file.
250
251 Header files are included into a program source file by the
252 @samp{#include} preprocessor directive.  The C language supports two
253 forms of this directive; the first,
254
255 @smallexample
256 #include "@var{header}"
257 @end smallexample
258
259 @noindent
260 is typically used to include a header file @var{header} that you write
261 yourself; this would contain definitions and declarations describing the
262 interfaces between the different parts of your particular application.
263 By contrast,
264
265 @smallexample
266 #include <file.h>
267 @end smallexample
268
269 @noindent
270 is typically used to include a header file @file{file.h} that contains
271 definitions and declarations for a standard library.  This file would
272 normally be installed in a standard place by your system administrator.
273 You should use this second form for the C library header files.
274
275 Typically, @samp{#include} directives are placed at the top of the C
276 source file, before any other code.  If you begin your source files with
277 some comments explaining what the code in the file does (a good idea),
278 put the @samp{#include} directives immediately afterwards, following the
279 feature test macro definition (@pxref{Feature Test Macros}).
280
281 For more information about the use of header files and @samp{#include}
282 directives, @pxref{Header Files,,, cpp.info, The GNU C Preprocessor
283 Manual}.@refill
284
285 The GNU C library provides several header files, each of which contains
286 the type and macro definitions and variable and function declarations
287 for a group of related facilities.  This means that your programs may
288 need to include several header files, depending on exactly which
289 facilities you are using.
290
291 Some library header files include other library header files
292 automatically.  However, as a matter of programming style, you should
293 not rely on this; it is better to explicitly include all the header
294 files required for the library facilities you are using.  The GNU C
295 library header files have been written in such a way that it doesn't
296 matter if a header file is accidentally included more than once;
297 including a header file a second time has no effect.  Likewise, if your
298 program needs to include multiple header files, the order in which they
299 are included doesn't matter.
300
301 @strong{Compatibility Note:} Inclusion of standard header files in any
302 order and any number of times works in any @w{ISO C} implementation.
303 However, this has traditionally not been the case in many older C
304 implementations.
305
306 Strictly speaking, you don't @emph{have to} include a header file to use
307 a function it declares; you could declare the function explicitly
308 yourself, according to the specifications in this manual.  But it is
309 usually better to include the header file because it may define types
310 and macros that are not otherwise available and because it may define
311 more efficient macro replacements for some functions.  It is also a sure
312 way to have the correct declaration.
313
314 @node Macro Definitions, Reserved Names, Header Files, Using the Library
315 @subsection Macro Definitions of Functions
316 @cindex shadowing functions with macros
317 @cindex removing macros that shadow functions
318 @cindex undefining macros that shadow functions
319
320 If we describe something as a function in this manual, it may have a
321 macro definition as well.  This normally has no effect on how your
322 program runs---the macro definition does the same thing as the function
323 would.  In particular, macro equivalents for library functions evaluate
324 arguments exactly once, in the same way that a function call would.  The
325 main reason for these macro definitions is that sometimes they can
326 produce an inline expansion that is considerably faster than an actual
327 function call.
328
329 Taking the address of a library function works even if it is also
330 defined as a macro.  This is because, in this context, the name of the
331 function isn't followed by the left parenthesis that is syntactically
332 necessary to recognize a macro call.
333
334 You might occasionally want to avoid using the macro definition of a
335 function---perhaps to make your program easier to debug.  There are
336 two ways you can do this:
337
338 @itemize @bullet
339 @item
340 You can avoid a macro definition in a specific use by enclosing the name
341 of the function in parentheses.  This works because the name of the
342 function doesn't appear in a syntactic context where it is recognizable
343 as a macro call.
344
345 @item
346 You can suppress any macro definition for a whole source file by using
347 the @samp{#undef} preprocessor directive, unless otherwise stated
348 explicitly in the description of that facility.
349 @end itemize
350
351 For example, suppose the header file @file{stdlib.h} declares a function
352 named @code{abs} with
353
354 @smallexample
355 extern int abs (int);
356 @end smallexample
357
358 @noindent
359 and also provides a macro definition for @code{abs}.  Then, in:
360
361 @smallexample
362 #include <stdlib.h>
363 int f (int *i) @{ return (abs (++*i)); @}
364 @end smallexample
365
366 @noindent
367 the reference to @code{abs} might refer to either a macro or a function.
368 On the other hand, in each of the following examples the reference is
369 to a function and not a macro.
370
371 @smallexample
372 #include <stdlib.h>
373 int g (int *i) @{ return ((abs)(++*i)); @}
374
375 #undef abs
376 int h (int *i) @{ return (abs (++*i)); @}
377 @end smallexample
378
379 Since macro definitions that double for a function behave in
380 exactly the same way as the actual function version, there is usually no
381 need for any of these methods.  In fact, removing macro definitions usually
382 just makes your program slower.
383
384
385 @node Reserved Names, Feature Test Macros, Macro Definitions, Using the Library
386 @subsection Reserved Names
387 @cindex reserved names
388 @cindex name space
389
390 The names of all library types, macros, variables and functions that
391 come from the @w{ISO C} standard are reserved unconditionally; your program
392 @strong{may not} redefine these names.  All other library names are
393 reserved if your program explicitly includes the header file that
394 defines or declares them.  There are several reasons for these
395 restrictions:
396
397 @itemize @bullet
398 @item
399 Other people reading your code could get very confused if you were using
400 a function named @code{exit} to do something completely different from
401 what the standard @code{exit} function does, for example.  Preventing
402 this situation helps to make your programs easier to understand and
403 contributes to modularity and maintainability.
404
405 @item
406 It avoids the possibility of a user accidentally redefining a library
407 function that is called by other library functions.  If redefinition
408 were allowed, those other functions would not work properly.
409
410 @item
411 It allows the compiler to do whatever special optimizations it pleases
412 on calls to these functions, without the possibility that they may have
413 been redefined by the user.  Some library facilities, such as those for
414 dealing with variadic arguments (@pxref{Variadic Functions})
415 and non-local exits (@pxref{Non-Local Exits}), actually require a
416 considerable amount of cooperation on the part of the C compiler, and
417 implementationally it might be easier for the compiler to treat these as
418 built-in parts of the language.
419 @end itemize
420
421 In addition to the names documented in this manual, reserved names
422 include all external identifiers (global functions and variables) that
423 begin with an underscore (@samp{_}) and all identifiers regardless of
424 use that begin with either two underscores or an underscore followed by
425 a capital letter are reserved names.  This is so that the library and
426 header files can define functions, variables, and macros for internal
427 purposes without risk of conflict with names in user programs.
428
429 Some additional classes of identifier names are reserved for future
430 extensions to the C language or the POSIX.1 environment.  While using these
431 names for your own purposes right now might not cause a problem, they do
432 raise the possibility of conflict with future versions of the C
433 or POSIX standards, so you should avoid these names.
434
435 @itemize @bullet
436 @item
437 Names beginning with a capital @samp{E} followed a digit or uppercase
438 letter may be used for additional error code names.  @xref{Error
439 Reporting}.
440
441 @item
442 Names that begin with either @samp{is} or @samp{to} followed by a
443 lowercase letter may be used for additional character testing and
444 conversion functions.  @xref{Character Handling}.
445
446 @item
447 Names that begin with @samp{LC_} followed by an uppercase letter may be
448 used for additional macros specifying locale attributes.
449 @xref{Locales}.
450
451 @item
452 Names of all existing mathematics functions (@pxref{Mathematics})
453 suffixed with @samp{f} or @samp{l} are reserved for corresponding
454 functions that operate on @code{float} and @code{long double} arguments,
455 respectively.
456
457 @item
458 Names that begin with @samp{SIG} followed by an uppercase letter are
459 reserved for additional signal names.  @xref{Standard Signals}.
460
461 @item
462 Names that begin with @samp{SIG_} followed by an uppercase letter are
463 reserved for additional signal actions.  @xref{Basic Signal Handling}.
464
465 @item
466 Names beginning with @samp{str}, @samp{mem}, or @samp{wcs} followed by a
467 lowercase letter are reserved for additional string and array functions.
468 @xref{String and Array Utilities}.
469
470 @item
471 Names that end with @samp{_t} are reserved for additional type names.
472 @end itemize
473
474 In addition, some individual header files reserve names beyond
475 those that they actually define.  You only need to worry about these
476 restrictions if your program includes that particular header file.
477
478 @itemize @bullet
479 @item
480 The header file @file{dirent.h} reserves names prefixed with
481 @samp{d_}.
482 @pindex dirent.h
483
484 @item
485 The header file @file{fcntl.h} reserves names prefixed with
486 @samp{l_}, @samp{F_}, @samp{O_}, and @samp{S_}.
487 @pindex fcntl.h
488
489 @item
490 The header file @file{grp.h} reserves names prefixed with @samp{gr_}.
491 @pindex grp.h
492
493 @item
494 The header file @file{limits.h} reserves names suffixed with @samp{_MAX}.
495 @pindex limits.h
496
497 @item
498 The header file @file{pwd.h} reserves names prefixed with @samp{pw_}.
499 @pindex pwd.h
500
501 @item
502 The header file @file{signal.h} reserves names prefixed with @samp{sa_}
503 and @samp{SA_}.
504 @pindex signal.h
505
506 @item
507 The header file @file{sys/stat.h} reserves names prefixed with @samp{st_}
508 and @samp{S_}.
509 @pindex sys/stat.h
510
511 @item
512 The header file @file{sys/times.h} reserves names prefixed with @samp{tms_}.
513 @pindex sys/times.h
514
515 @item
516 The header file @file{termios.h} reserves names prefixed with @samp{c_},
517 @samp{V}, @samp{I}, @samp{O}, and @samp{TC}; and names prefixed with
518 @samp{B} followed by a digit.
519 @pindex termios.h
520 @end itemize
521
522 @comment Include the section on Creature Nest Macros.
523 @comment It is in a separate file so it can be formatted into ../NOTES.
524 @include creature.texi
525
526 @node Roadmap to the Manual,  , Using the Library, Introduction
527 @section Roadmap to the Manual
528
529 Here is an overview of the contents of the remaining chapters of
530 this manual.
531
532 @itemize @bullet
533 @item
534 @ref{Error Reporting}, describes how errors detected by the library
535 are reported.
536
537 @item
538 @ref{Language Features}, contains information about library support for
539 standard parts of the C language, including things like the @code{sizeof}
540 operator and the symbolic constant @code{NULL}, how to write functions
541 accepting variable numbers of arguments, and constants describing the
542 ranges and other properties of the numerical types.  There is also a simple
543 debugging mechanism which allows you to put assertions in your code, and
544 have diagnostic messages printed if the tests fail.
545
546 @item
547 @ref{Memory Allocation}, describes the GNU library's facilities for
548 dynamic allocation of storage.  If you do not know in advance how much
549 storage your program needs, you can allocate it dynamically instead,
550 and manipulate it via pointers.
551
552 @item
553 @ref{Character Handling}, contains information about character
554 classification functions (such as @code{isspace}) and functions for
555 performing case conversion.
556
557 @item
558 @ref{String and Array Utilities}, has descriptions of functions for
559 manipulating strings (null-terminated character arrays) and general
560 byte arrays, including operations such as copying and comparison.
561
562 @item
563 @ref{I/O Overview}, gives an overall look at the input and output
564 facilities in the library, and contains information about basic concepts
565 such as file names.
566
567 @item
568 @ref{I/O on Streams}, describes I/O operations involving streams (or
569 @w{@code{FILE *}} objects).  These are the normal C library functions
570 from @file{stdio.h}.
571
572 @item
573 @ref{Low-Level I/O}, contains information about I/O operations
574 on file descriptors.  File descriptors are a lower-level mechanism
575 specific to the Unix family of operating systems.
576
577 @item
578 @ref{File System Interface}, has descriptions of operations on entire
579 files, such as functions for deleting and renaming them and for creating
580 new directories.  This chapter also contains information about how you
581 can access the attributes of a file, such as its owner and file protection
582 modes.
583
584 @item
585 @ref{Pipes and FIFOs}, contains information about simple interprocess
586 communication mechanisms.  Pipes allow communication between two related
587 processes (such as between a parent and child), while FIFOs allow
588 communication between processes sharing a common file system on the same
589 machine.
590
591 @item
592 @ref{Sockets}, describes a more complicated interprocess communication
593 mechanism that allows processes running on different machines to
594 communicate over a network.  This chapter also contains information about
595 Internet host addressing and how to use the system network databases.
596
597 @item
598 @ref{Low-Level Terminal Interface}, describes how you can change the
599 attributes of a terminal device.  If you want to disable echo of
600 characters typed by the user, for example, read this chapter.
601
602 @item
603 @ref{Mathematics}, contains information about the math library
604 functions.  These include things like random-number generators and
605 remainder functions on integers as well as the usual trigonometric and
606 exponential functions on floating-point numbers.
607
608 @item
609 @ref{Arithmetic,, Low-Level Arithmetic Functions}, describes functions
610 for simple arithmetic, analysis of floating-point values, and reading
611 numbers from strings.
612
613 @item
614 @ref{Searching and Sorting}, contains information about functions
615 for searching and sorting arrays.  You can use these functions on any
616 kind of array by providing an appropriate comparison function.
617
618 @item
619 @ref{Pattern Matching}, presents functions for matching regular expressions
620 and shell file name patterns, and for expanding words as the shell does.
621
622 @item
623 @ref{Date and Time}, describes functions for measuring both calendar time
624 and CPU time, as well as functions for setting alarms and timers.
625
626 @item
627 @ref{Extended Characters}, contains information about manipulating
628 characters and strings using character sets larger than will fit in
629 the usual @code{char} data type.
630
631 @item
632 @ref{Locales}, describes how selecting a particular country
633 or language affects the behavior of the library.  For example, the locale
634 affects collation sequences for strings and how monetary values are
635 formatted.
636
637 @item
638 @ref{Non-Local Exits}, contains descriptions of the @code{setjmp} and
639 @code{longjmp} functions.  These functions provide a facility for
640 @code{goto}-like jumps which can jump from one function to another.
641
642 @item
643 @ref{Signal Handling}, tells you all about signals---what they are,
644 how to establish a handler that is called when a particular kind of
645 signal is delivered, and how to prevent signals from arriving during
646 critical sections of your program.
647
648 @item
649 @ref{Process Startup}, tells how your programs can access their
650 command-line arguments and environment variables.
651
652 @item
653 @ref{Processes}, contains information about how to start new processes
654 and run programs.
655
656 @item
657 @ref{Job Control}, describes functions for manipulating process groups
658 and the controlling terminal.  This material is probably only of
659 interest if you are writing a shell or other program which handles job
660 control specially.
661
662 @item
663 @ref{Name Service Switch}, describes the services which are available
664 for looking up names in the system databases, how to determine which
665 service is used for which database, and how these services are
666 implemented so that contributors can design their own services.
667
668 @item
669 @ref{User Database}, and @ref{Group Database}, tell you how to access
670 the system user and group databases.
671
672 @item
673 @ref{System Information}, describes functions for getting information
674 about the hardware and software configuration your program is executing
675 under.
676
677 @item
678 @ref{System Configuration}, tells you how you can get information about
679 various operating system limits.  Most of these parameters are provided for
680 compatibility with POSIX.
681
682 @item
683 @ref{Library Summary}, gives a summary of all the functions, variables, and
684 macros in the library, with complete data types and function prototypes,
685 and says what standard or system each is derived from.
686
687 @item
688 @ref{Maintenance}, explains how to build and install the GNU C library on
689 your system, how to report any bugs you might find, and how to add new
690 functions or port the library to a new system.
691 @end itemize
692
693 If you already know the name of the facility you are interested in, you
694 can look it up in @ref{Library Summary}.  This gives you a summary of
695 its syntax and a pointer to where you can find a more detailed
696 description.  This appendix is particularly useful if you just want to
697 verify the order and type of arguments to a function, for example.  It
698 also tells you what standard or system each function, variable, or macro
699 is derived from.