e720f85ea3e0adafa7c1b1a23ea9d4aa8bc9c766
[kopensolaris-gnu/glibc.git] / manual / libc.texinfo
1 \input texinfo                  @c -*- Texinfo -*-
2 @comment %**start of header (This is for running Texinfo on a region.)
3 @setfilename libc.info
4 @settitle The GNU C Library
5 @setchapternewpage odd
6 @comment %**end of header (This is for running Texinfo on a region.)
7
8 @smallbook
9
10 @set EDITION 0.04 (Preliminary)
11 @set VERSION 1.07 Beta
12 @set UPDATED 20 June 1993
13
14 @ifinfo
15 This file documents the GNU C library.
16
17 This is Edition @value{EDITION}, last updated @value{UPDATED},
18 of @cite{The GNU C Library Reference Manual}, for Version @value{VERSION}.
19
20 Copyright (C) 1993 Free Software Foundation, Inc.
21
22 Permission is granted to make and distribute verbatim copies of
23 this manual provided the copyright notice and this permission notice
24 are preserved on all copies.
25
26 @ignore
27 Permission is granted to process this file through TeX and print the
28 results, provided the printed document carries copying permission
29 notice identical to this one except for the removal of this paragraph
30 (this paragraph not being relevant to the printed manual).
31
32 @end ignore
33 Permission is granted to copy and distribute modified versions of this
34 manual under the conditions for verbatim copying, provided also that the
35 section entitled ``GNU Library General Public License'' is included
36 exactly as in the original, and provided that the entire resulting
37 derived work is distributed under the terms of a permission notice
38 identical to this one.
39
40 Permission is granted to copy and distribute translations of this manual
41 into another language, under the above conditions for modified versions,
42 except that the text of the translations of the section entitled ``GNU
43 Library General Public License'' must be approved for accuracy by the
44 Foundation.
45 @end ifinfo
46
47 @iftex
48 @shorttitlepage The GNU C Library Reference Manual
49 @end iftex
50 @titlepage
51 @center @titlefont{The GNU C Library}
52 @sp 1
53 @center @titlefont{Reference Manual}
54 @sp 2
55 @center Sandra Loosemore
56 @center with
57 @center Roland McGrath, Andrew Oram, and Richard M. Stallman
58 @sp 3
59 @center last updated @value{UPDATED}
60 @sp 1
61 @center for version @value{VERSION}
62 @page
63 @vskip 0pt plus 1filll
64 Copyright @copyright{} 1993 Free Software Foundation, Inc.
65 @sp 2
66 Published by the Free Software Foundation @*
67 675 Massachusetts Avenue, @*
68 Cambridge, MA 02139 USA @*
69 Printed copies are available for $50 each.
70
71 Permission is granted to make and distribute verbatim copies of
72 this manual provided the copyright notice and this permission notice
73 are preserved on all copies.
74
75 Permission is granted to copy and distribute modified versions of this
76 manual under the conditions for verbatim copying, provided also that the
77 section entitled ``GNU Library General Public License'' is included
78 exactly as in the original, and provided that the entire resulting
79 derived work is distributed under the terms of a permission notice
80 identical to this one.
81
82 Permission is granted to copy and distribute translations of this manual
83 into another language, under the above conditions for modified versions,
84 except that the text of the translation of the section entitled ``GNU
85 Library General Public License'' must be approved for accuracy by the
86 Foundation.
87 @end titlepage
88 @page
89
90 @ifinfo
91 @node Top, Introduction, (dir), (dir)
92 @top Main Menu
93 This is the reference manual for version @value{VERSION} of the GNU C Library.
94 @end ifinfo
95
96
97 @menu
98 * Introduction::                Purpose of the GNU C Library.
99 * Error Reporting::             How the GNU Library functions report
100                                  error conditions.
101 * Memory Allocation::           Your program can allocate memory dynamically
102                                  and manipulate it via pointers.
103 * Character Handling::          Character testing and conversion functions.
104 * String and Array Utilities::  Utilities for copying and comparing
105                                  strings and arrays.
106 * Extended Characters::         Support for extended character sets.
107 * Locales::                     The country and language can affect
108                                  the behavior of library functions.
109 * Searching and Sorting::       General searching and sorting functions.
110 * Pattern Matching::            Matching wildcards and regular expressions,
111                                  and shell-style ``word expansion''.
112 * I/O Overview::                Introduction to the I/O facilities.
113 * Streams: I/O on Streams.      High-level, portable I/O facilities.
114 * Low-Level I/O::               Low-level, less portable I/O.
115 * File System Interface::       Functions for manipulating files.
116 * Pipes and FIFOs::             A simple interprocess communication mechanism.
117 * Sockets::                     A more complicated interprocess communication
118                                  mechanism, with support for networking.
119 * Low-Level Terminal Interface::How to change the characteristics
120                                  of a terminal device.
121 * Mathematics::                 Math functions (transcendental functions,
122                                  random numbers, absolute value, etc.).
123 * Arithmetic::                  Low-level arithmetic functions.
124 * Date and Time::               Functions for getting the date and time,
125                                  and for conversion between formats.
126 * Non-Local Exits::             The @code{setjmp} and @code{longjmp} facilities.
127 * Signal Handling::             All about signals; how to send them,
128                                  block them, and handle them.
129 * Process Startup::             Writing the beginning and end of your program.
130 * Child Processes::             How to create processes and run other programs.
131 * Job Control::                 All about process groups and sessions.
132 * Users and Groups::            How users are identified and classified.
133 * System Information::          Getting information about the
134                                  hardware and software configuration
135                                  of the machine a program runs on.
136 * System Configuration::        Parameters describing operating system limits.
137
138 Appendices
139
140 * Language Features::           C language features provided by the library. 
141
142 * Library Summary::             A summary showing the syntax, header file,
143                                  and derivation of each library feature.
144 * Maintenance::                 How to install and maintain the GNU C Library.
145 * Copying::                     The GNU Library General Public License says
146                                  how you can copy and share the GNU C Library.
147
148 Indices
149
150 * Concept Index::               Index of concepts and names.
151 * Type Index::                  Index of types and type qualifiers.
152 * Function Index::              Index of functions and function-like macros.
153 * Variable Index::              Index of variables and variable-like macros.
154 * File Index::                  Index of programs and files.
155
156  --- The Detailed Node Listing ---
157
158 Introduction
159
160 * Getting Started::             Getting Started
161 * Standards and Portability::   Standards and Portability
162 * Using the Library::           Using the Library
163 * Roadmap to the Manual::       Roadmap to the Manual
164
165 Standards and Portability
166
167 * ANSI C::                      The American National Standard for the
168                                  C programming language.  
169 * POSIX::                       The IEEE 1003 standards for operating systems.
170 * Berkeley Unix::               BSD and SunOS.
171 * SVID::                        The System V Interface Description.  
172
173 Using the Library
174
175 * Header Files::                How to use the header files in your programs.
176 * Macro Definitions::           Some functions in the library may really
177                                  be implemented as macros.
178 * Reserved Names::              The C standard reserves some names for
179                                  the library, and some for users.
180 * Feature Test Macros::         How to control what names are defined.
181
182 Error Reporting
183
184 * Checking for Errors::         How errors are reported by library functions.
185 * Error Codes::                 What all the error codes are.
186 * Error Messages::              Mapping error codes onto error messages.
187
188 Memory Allocation
189
190 * Memory Concepts::             An introduction to concepts and terminology.
191 * Dynamic Allocation and C::    How to get different kinds of allocation in C.
192 * Unconstrained Allocation::    The @code{malloc} facility allows fully general
193                                  dynamic allocation.
194 * Obstacks::                    Obstacks are less general than malloc
195                                  but more efficient and convenient.
196 * Variable Size Automatic::     Allocation of variable-sized blocks
197                                  of automatic storage that are freed when the
198                                  calling function returns.
199 * Relocating Allocator::        Waste less memory, if you can tolerate
200                                  automatic relocation of the blocks you get.
201 * Memory Warnings::             Getting warnings when memory is nearly full.
202
203 Unconstrained Allocation
204
205 * Basic Allocation::            Simple use of @code{malloc}.
206 * Malloc Examples::             Examples of @code{malloc}.  @code{xmalloc}.
207 * Freeing after Malloc::        Use @code{free} to free a block you
208                                  got with @code{malloc}.
209 * Changing Block Size::         Use @code{realloc} to make a block
210                                  bigger or smaller.
211 * Allocating Cleared Space::    Use @code{calloc} to allocate a
212                                  block and clear it.
213 * Efficiency and Malloc::       Efficiency considerations in use of
214                                  these functions.
215 * Aligned Memory Blocks::       Allocating specially aligned memory:
216                                  @code{memalign} and @code{valloc}.
217 * Heap Consistency Checking::   Automatic checking for errors.
218 * Hooks for Malloc::            You can use these hooks for debugging
219                                  programs that use @code{malloc}.
220 * Statistics of Malloc::        Getting information about how much
221                                  memory your program is using.
222 * Summary of Malloc::           Summary of @code{malloc} and related functions.
223
224 Obstacks
225
226 * Creating Obstacks::           How to declare an obstack in your program.
227 * Preparing for Obstacks::      Preparations needed before you can
228                                  use obstacks.
229 * Allocation in an Obstack::    Allocating objects in an obstack.
230 * Freeing Obstack Objects::     Freeing objects in an obstack.
231 * Obstack Functions::           The obstack functions are both
232                                  functions and macros.
233 * Growing Objects::             Making an object bigger by stages.
234 * Extra Fast Growing::          Extra-high-efficiency (though more
235                                  complicated) growing objects.
236 * Status of an Obstack::        Inquiries about the status of an obstack.
237 * Obstacks Data Alignment::     Controlling alignment of objects in obstacks.
238 * Obstack Chunks::              How obstacks obtain and release chunks. 
239                                 Efficiency considerations.
240 * Summary of Obstacks::         
241
242 Automatic Storage with Variable Size
243
244 * Alloca Example::              Example of using @code{alloca}.
245 * Advantages of Alloca::        Reasons to use @code{alloca}.
246 * Disadvantages of Alloca::     Reasons to avoid @code{alloca}.
247 * GNU C Variable-Size Arrays::  Only in GNU C, here is an alternative
248                                  method of allocating dynamically and
249                                  freeing automatically.
250 Relocating Allocator
251
252 * Relocator Concepts::          How to understand relocating allocation.
253 * Using Relocator::             Functions for relocating allocation.
254
255 Character Handling
256
257 * Classification of Characters::Testing whether characters are
258                                  letters, digits, punctuation, etc.
259 * Case Conversion::             Case mapping, and the like.
260
261 String and Array Utilities
262
263 * Representation of Strings::   Introduction to basic concepts.
264 * String/Array Conventions::    Whether to use a string function or an
265                                  arbitrary array function.
266 * String Length::               Determining the length of a string.
267 * Copying and Concatenation::   Functions to copy the contents of strings
268                                  and arrays.
269 * String/Array Comparison::     Functions for byte-wise and character-wise
270                                  comparison.
271 * Collation Functions::         Functions for collating strings.
272 * Search Functions::            Searching for a specific element or substring.
273 * Finding Tokens in a String::  Splitting a string into tokens by looking
274                                  for delimiters.
275
276 Extended Characters
277
278 * Extended Char Intro::         Multibyte codes versus wide characters.
279 * Locales and Extended Chars::  The locale selects the character codes.
280 * Multibyte Char Intro::        How multibyte codes are represented.
281 * Wide Char Intro::             How wide characters are represented.
282 * Wide String Conversion::      Converting wide strings to multibyte code
283                                    and vice versa.
284 * Length of Char::              how many bytes make up one multibyte char.
285 * Converting One Char::         Converting a string character by character.
286 * Example of Conversion::       Example showing why converting 
287                                    one character at a time may be useful.
288 * Shift State::                 Multibyte codes with "shift characters".
289
290 Locales and Internationalization
291
292 * Effects of Locale::           Actions affected by the choice of locale.
293 * Choosing Locale::             How the user specifies a locale.
294 * Locale Categories::           Different purposes for which
295                                  you can select a locale.
296 * Setting the Locale::          How a program specifies the locale.
297 * Standard Locales::            Locale names available on all systems.
298 * Numeric Formatting::          How to format numbers for the chosen locale.
299
300 Searching and Sorting 
301
302 * Comparison Functions::        Defining how to compare two objects.
303                                 Since the sort and search facilities are
304                                 general, you have to specify the ordering.
305 * Array Search Function::       The @code{bsearch} function.
306 * Array Sort Function::         The @code{qsort} function.
307 * Search/Sort Example::         An example program.
308
309 Pattern Matching
310
311 * Wildcard Matching::    Matching a wildcard pattern against a single string.
312 * Globbing::             Finding the files that match a wildcard pattern.
313 * Regular Expressions::  Matching regular expressions against strings.
314 * Word Expansion::       Expanding shell variables, nested commands,
315                           arithmetic, and wildcards.
316                           This is what the shell does with shell commands.
317
318 I/O Overview
319
320 * I/O Concepts::                Some basic information and terminology.
321 * File Names::                  How to refer to a file.
322
323 I/O Concepts
324
325 * Streams and File Descriptors:: The GNU Library provides two ways
326                                   to access the contents of files.
327 * File Position::               The number of bytes from the
328                                  beginning of the file.
329
330 File Names
331
332 * Directories::                 Directories contain entries for files.
333 * File Name Resolution::        A file name specifies how to look up a file.
334 * File Name Errors::            Error conditions relating to file names.
335 * File Name Portability::       File name portability and syntax issues.
336
337 I/O on Streams
338
339 * Streams::                     About the data type representing a stream.
340 * Standard Streams::            Streams to the standard input and output 
341                                  devices are created for you.
342 * Opening Streams::             How to create a stream to talk to a file.
343 * Closing Streams::             Close a stream when you are finished with it.
344 * Simple Output::               Unformatted output by characters and lines.
345 * Character Input::             Unformatted input by characters and words.
346 * Line Input::                  Reading a line or a record from a stream.
347 * Unreading::                   Peeking ahead/pushing back input just read.
348 * Formatted Output::            @code{printf} and related functions.
349 * Customizing Printf::          You can define new conversion specifiers for
350                                  @code{printf} and friends.
351 * Formatted Input::             @code{scanf} and related functions.
352 * Block Input/Output::          Input and output operations on blocks of data.
353 * EOF and Errors::              How you can tell if an I/O error happens.
354 * Binary Streams::              Some systems distinguish between text files
355                                  and binary files.
356 * File Positioning::            About random-access streams.
357 * Portable Positioning::        Random access on peculiar ANSI C systems.
358 * Stream Buffering::            How to control buffering of streams.
359 * Temporary Files::             How to open a temporary file.
360 * Other Kinds of Streams::      Other Kinds of Streams
361
362 Unreading
363
364 * Unreading Idea::              An explanation of unreading with pictures.
365 * How Unread::                  How to call @code{ungetc} to do unreading.
366
367 Formatted Output
368
369 * Formatted Output Basics::     Some examples to get you started.
370 * Output Conversion Syntax::    General syntax of conversion specifications.
371 * Table of Output Conversions:: Summary of output conversions, what they do.
372 * Integer Conversions::         Details of formatting integers.
373 * Floating-Point Conversions::  Details of formatting floating-point numbers.
374 * Other Output Conversions::    Details about formatting of strings,
375                                  characters, pointers, and the like.
376 * Formatted Output Functions::  Descriptions of the actual functions.
377 * Variable Arguments Output::   @code{vprintf} and friends.
378 * Parsing a Template String::   What kinds of arguments does
379                                  a given template call for?
380
381 Customizing Printf
382
383 * Registering New Conversions::  
384 * Conversion Specifier Options::  
385 * Defining the Output Handler::  
386 * Printf Extension Example::    
387
388 Formatted Input
389
390 * Formatted Input Basics::      Some basics to get you started.
391 * Input Conversion Syntax::     Syntax of conversion specifications.
392 * Table of Input Conversions::  Summary of input conversions and what they do.
393 * Numeric Input Conversions::   Details of conversions for reading numbers.
394 * String Input Conversions::    Details of conversions for reading strings.
395 * Other Input Conversions::     Details of miscellaneous other conversions.
396 * Formatted Input Functions::   Descriptions of the actual functions.
397 * Variable Arguments Input::    @code{vscanf} and friends.
398
399 Stream Buffering
400
401 * Buffering Concepts::          Terminology is defined here.
402 * Flushing Buffers::            How to ensure that output buffers are flushed.
403 * Controlling Buffering::       How to specify what kind of buffering to use.
404
405 Other Kinds of Streams
406
407 * String Streams::              
408 * Custom Streams::              
409
410 Programming Your Own Custom Streams
411
412 * Streams and Cookies::         
413 * Hook Functions::              
414
415 Low-Level I/O
416
417 * Opening and Closing Files::   How to open and close file descriptors.
418 * I/O Primitives::              Reading and writing data.
419 * File Position Primitive::     Setting a descriptor's file position.
420 * Descriptors and Streams::     Converting descriptor to stream or vice-versa.
421 * Stream/Descriptor Precautions::  Precautions needed if you use both
422                                     descriptors and streams.
423 * Waiting for I/O::             How to check for input or output
424                                  on multiple file descriptors.
425 * Control Operations::          Various other operations on file descriptors.
426 * Duplicating Descriptors::     Fcntl commands for duplicating descriptors.
427 * Descriptor Flags::            Fcntl commands for manipulating flags
428                                  associated with file descriptors.
429 * File Status Flags::           Fcntl commands for manipulating flags
430                                  associated with open files.
431 * File Locks::                  Fcntl commands for implementing file locking.
432 * Interrupt Input::             Getting a signal when input arrives.
433
434 File System Interface
435
436 * Working Directory::           This is used to resolve relative file names.
437 * Accessing Directories::       Finding out what files a directory contains.
438 * Hard Links::                  Adding alternate names to a file.
439 * Symbolic Links::              A file that ``points to'' a file name.
440 * Deleting Files::              How to delete a file, and what that means.
441 * Renaming Files::              Changing a file's name.
442 * Creating Directories::        A system call just for creating a directory.
443 * File Attributes::             Attributes of individual files.
444 * Making Special Files::        How to create special files.
445
446 Accessing Directories
447
448 * Directory Entries::           Format of one directory entry.
449 * Opening a Directory::         How to open a directory stream.
450 * Reading/Closing Directory::   How to read directory entries from the stream.
451 * Simple Directory Lister::     A very simple directory listing program.
452 * Random Access Directory::     Rereading part of the directory
453                                   already read with the same stream.
454
455 File Attributes
456
457 * Attribute Meanings::          The names of the file attributes,
458                                  and what their values mean.
459 * Reading Attributes::          How to read the attributes of a file.
460 * Testing File Type::           Distinguishing ordinary files,
461                                  directories, links...
462 * File Owner::                  How ownership for new files is determined,
463                                  and how to change it.
464 * Permission Bits::             How information about a file's access mode
465                                  is stored.
466 * Access Permission::           How the system decides who can access a file.
467 * Setting Permissions::         How permissions for new files are assigned,
468                                  and how to change them.
469 * Testing File Access::         How to find out if your process can
470                                  access a file.
471 * File Times::                  About the time attributes of a file.
472
473 Pipes and FIFOs
474
475 * Creating a Pipe::             Making a pipe with the @code{pipe} function.
476 * Pipe to a Subprocess::        Using a pipe to communicate with a child.
477 * FIFO Special Files::          Making a FIFO special file.
478
479 Sockets
480
481 * Socket Concepts::             Basic concepts you need to know about.
482 * Communication Styles::        Stream communication, datagrams, and others.
483 * Socket Addresses::            How socket names (``addresses'') work.
484 * File Namespace::              Details about the file namespace.
485 * Internet Namespace::          Details about the Internet namespace.
486 * Open/Close Sockets::          Creating sockets and destroying them.
487 * Connections::                 Operations on sockets with connection state.
488 * Datagrams::                   Operations on datagram sockets.
489 * Socket Options::              Miscellaneous low-level socket options.
490 * Networks Database::           Accessing the database of network names.
491
492 Socket Addresses
493
494 * Address Formats::             About @code{struct sockaddr}.
495 * Setting Address::             Binding an address to a socket.
496 * Reading Address::             Reading the address of a socket.
497
498 Internet Domain
499
500 * Internet Address Format::     How socket addresses are specified in the
501                                  Internet namespace.
502 * Host Addresses::              All about host addresses of Internet hosts.
503 * Protocols Database::          Referring to protocols by name.
504 * Services Database::           Ports may have symbolic names.
505 * Byte Order::                  Different hosts may use different byte
506                                  ordering conventions; you need to
507                                  canonicalize host address and port number. 
508 * Inet Example::                Putting it all together.
509
510 Host Addresses
511
512 * Abstract Host Addresses::             What a host number consists of.
513 * Data type: Host Address Data Type.    Data type for a host number.
514 * Functions: Host Address Functions.    Functions to operate on them.
515 * Names: Host Names.                    Translating host names to host numbers.
516
517 Open/Close Sockets
518
519 * Creating a Socket::           How to open a socket.
520 * Closing a Socket::            How to close a socket.
521 * Socket Pairs::                These are created like pipes.
522
523 Connections
524
525 * Connecting::                  What the client program must do.
526 * Listening::                   How a server program waits for requests.
527 * Accepting Connections::       What the server does when it gets a request.
528 * Who is Connected::            Getting the address of the
529                                  other side of a connection.
530 * Transferring Data::           How to send and receive data.
531 * Byte Stream Example::         An example client for communicating over a
532                                  byte stream socket in the Internet namespace.
533 * Server Example::              A corresponding server program.
534 * Out-of-Band Data::            This is an advanced feature.
535
536 Transferring Data
537
538 * Sending Data::                Sending data with @code{write}.
539 * Receiving Data::              Reading data with @code{read}.
540 * Socket Data Options::         Using @code{send} and @code{recv}.
541
542 Datagrams
543
544 * Sending Datagrams::           Sending packets on a datagram socket.
545 * Receiving Datagrams::         Receiving packets on a datagram socket.
546 * Datagram Example::            An example program: packets sent over a
547                                  datagram stream in the file namespace.
548 * Example Receiver::            Another program, that receives those packets.
549
550 Socket Options
551
552 * Socket Option Functions::     The basic functions for setting and getting
553                                  socket options.
554 * Socket-Level Options::        Details of the options at the socket level.
555
556 Low-Level Terminal Interface
557
558 * Is It a Terminal::            How to determine if a file is a terminal
559                                  device, and what its name is.
560 * I/O Queues::                  About flow control and typeahead.
561 * Canonical or Not::            Two basic styles of input processing.
562 * Terminal Modes::              How to examine and modify flags controlling
563                                  terminal I/O: echoing, signals, editing.
564 * Line Control::                Sending break sequences, clearing  buffers...
565 * Noncanon Example::            How to read single characters without echo.
566
567 Terminal Modes
568
569 * Mode Data Types::             The data type @code{struct termios} and related types.
570 * Mode Functions::              Functions to read and set terminal attributes.
571 * Setting Modes::               The right way to set attributes reliably.
572 * Input Modes::                 Flags controlling low-level input handling.
573 * Output Modes::                Flags controlling low-level output handling.
574 * Control Modes::               Flags controlling serial port behavior.
575 * Local Modes::                 Flags controlling high-level input handling.
576 * Line Speed::                  How to read and set the terminal line speed.
577 * Special Characters::          Characters that have special effects,
578                                  and how to change them.
579 * Noncanonical Input::          Controlling how long to wait for input.
580
581 Special Characters
582
583 * Editing Characters::          
584 * Signal Characters::           
585 * Start/Stop Characters::       
586
587 Mathematics
588
589 * Domain and Range Errors::     How overflow conditions and the
590                                  like are reported.
591 * Not a Number::                Making NANs and testing for NANs.
592 * Trig Functions::              Sine, cosine, and tangent.
593 * Inverse Trig Functions::      Arc sine, arc cosine, and arc tangent.
594 * Exponents and Logarithms::    Also includes square root.
595 * Hyperbolic Functions::        Hyperbolic sine and friends.
596 * Pseudo-Random Numbers::       Functions for generating pseudo-random numbers.
597 * Absolute Value::              Absolute value functions.
598
599 Pseudo-Random Numbers
600
601 * ANSI Random::                 @code{rand} and friends.
602 * BSD Random::                  @code{random} and friends.
603
604 Low-Level Arithmetic Functions
605
606 * Normalization Functions::     Hacks for radix-2 representations.
607 * Rounding and Remainders::     Determinining the integer and
608                                  fractional parts of a float.
609 * Integer Division::            Functions for performing integer division.
610 * Parsing of Numbers::          Functions for ``reading'' numbers from strings.
611 * Predicates on Floats::        Some miscellaneous test functions.
612
613 Parsing of Numbers
614
615 * Parsing of Integers::         Functions for conversion of integer values.
616 * Parsing of Floats::           Functions for conversion of floating-point.
617
618 Date and Time
619
620 * Processor Time::              Measures processor time used by a program.
621 * Calendar Time::               Manipulation of ``real'' dates and times.
622 * Setting an Alarm::            Sending a signal after a specified time.
623 * Sleeping::                    Waiting for a period of time.
624
625 Processor Time
626
627 * Basic CPU Time::              The @code{clock} function.
628 * Detailed CPU Time::           The @code{times} function.
629
630 Calendar Time
631
632 * Simple Calendar Time::        Facilities for manipulating calendar time.
633 * High-Resolution Calendar::    A time representation with greater precision.
634 * Broken-down Time::            Facilities for manipulating local time.
635 * Formatting Date and Time::    Converting times to strings.
636 * TZ Variable::                 How users specify the time zone.
637 * Time Zone Functions::         Functions to examine or specify the time zone.
638 * Time Functions Example::      An example program showing use of some of
639                                  the time functions.
640
641 Signal Handling
642
643 * Concepts of Signals::         Introduction to the signal facilities.
644 * Standard Signals::            Particular kinds of signals with standard
645                                  names and meanings.
646 * Signal Actions::              Specifying what happens when a particular
647                                  signal is delivered.
648 * Defining Handlers::           How to write a signal handler function.
649 * Generating Signals::          How to send a signal to a process.
650 * Blocking Signals::            Making the system hold signals temporarily.
651 * Waiting for a Signal::        Suspending your program until a signal arrives.
652 * BSD Signal Handling::         Additional functions for backward
653                                  compatibility with BSD.
654 * BSD Handler::                 BSD Function to Establish a Handler
655
656 Basic Concepts of Signals
657
658 * Kinds of Signals::            Some examples of what can cause a signal.
659 * Signal Generation::           Concepts of why and how signals occur.
660 * Delivery of Signal::          Concepts of what a signal does to the process.
661
662 Standard Signals
663
664 * Program Error Signals::       Used to report serious program errors.
665 * Termination Signals::         Used to interrupt and/or terminate the program.
666 * Alarm Signals::               Used to indicate expiration of timers.
667 * Asynchronous I/O Signals::    Used to indicate input is available.
668 * Job Control Signals::         Signals used to support job control.
669 * Miscellaneous Signals::       Miscellaneous Signals
670 * Nonstandard Signals::         Implementations can support other signals.
671 * Signal Messages::             Printing a message describing a signal.
672
673 Specifying Signal Actions
674
675 * Basic Signal Handling::       The simple @code{signal} function.
676 * Advanced Signal Handling::    The more powerful @code{sigaction} function.
677 * Signal and Sigaction::        How those two functions interact.
678 * Sigaction Function Example::  An example of using the sigaction function.
679 * Flags for Sigaction::         Specifying options for signal handling.
680 * Initial Signal Actions::      How programs inherit signal actions.
681
682 Defining Signal Handlers
683
684 * Handler Returns::             
685 * Termination in Handler::      
686 * Longjmp in Handler::          
687 * Signals in Handler::       
688 * Nonreentrancy::               
689 * Atomic Data Access::          
690
691 Generating Signals
692
693 * Signaling Yourself::          Signaling Yourself
694 * Signaling Another Process::   Send a signal to another process.
695 * Permission for kill::         Permission for using @code{kill}
696 * Kill Example::                Using @code{kill} for Communication
697
698 Blocking Signals
699
700 * Why Block::                   The purpose of blocking signals.
701 * Signal Sets::                 How to specify which signals to block.
702 * Process Signal Mask::         Blocking delivery of signals to your
703                                  process during normal execution.
704 * Testing for Delivery::        Blocking to Test for Delivery of a Signal
705 * Blocking for Handler::        Blocking additional signals while a
706                                  handler is being run.
707 * Checking for Pending Signals::Checking for Pending Signals
708 * Remembering a Signal::        How you can get almost the same effect
709                                  as blocking a signal, by handling it
710                                  and setting a flag to be tested later.
711
712 Waiting for a Signal
713
714 * Using Pause::                 The simple way, using @code{pause}.
715 * Pause Problems::              Why the simple way is often not very good.
716 * Sigsuspend::                  Reliably waiting for a specific signal.
717
718 BSD Signal Handling
719
720 * POSIX vs BSD::                Comparison of BSD and POSIX signal functions.
721
722 BSD Function to Establish a Handler
723
724 * Blocking in BSD::             BSD Functions for Blocking Signals 
725 * Signal Stack::                Using a Separate Signal Stack
726
727 Process Startup and Termination
728
729 * Program Arguments::           Parsing your program's command-line arguments.
730 * Environment Variables::       How to access parameters inherited from
731                                  a parent process.
732 * Program Termination::         How to cause a process to terminate and
733                                  return status information to its parent.
734
735 Program Arguments
736
737 * Argument Syntax::             By convention, options start with a hyphen.
738 * Parsing Options::             The @code{getopt} function.
739 * Example of Getopt::           An example of parsing options with @code{getopt}.
740 * Long Options::                GNU utilities should accept long-named options.
741                                  Here is how to do that.
742 * Long Option Example::         An example of using @code{getopt_long}.
743
744 Environment Variables
745
746 * Environment Access::          How to get and set the values of
747                                  environment variables.
748 * Standard Environment::        These environment variables have
749                                  standard interpretations.
750
751 Program Termination
752
753 * Normal Termination::          If a program calls @code{exit}, a
754                                  process terminates normally.
755 * Exit Status::                 The @code{exit status} provides information 
756                                  about why the process terminated. 
757 * Cleanups on Exit::            A process can run its own cleanup
758                                  functions upon normal termination. 
759 * Aborting a Program::          The @code{abort} function causes
760                                  abnormal program termination. 
761 * Termination Internals::       What happens when a process terminates.
762
763
764 Child Processes
765
766 * Running a Command::           The easy way to run another program.
767 * Process Creation Concepts::   An overview of the hard way to do it.
768 * Process Identification::      How to get the process ID of a process.
769 * Creating a Process::          How to fork a child process.
770 * Executing a File::            How to make a child execute another program.
771 * Process Completion::          How to tell when a child process has completed.
772 * Process Completion Status::   How to interpret the status value 
773                                  returned from a child process.
774 * BSD Wait Functions::          More functions, for backward compatibility.
775 * Process Creation Example::    A complete example program.
776
777 Job Control
778
779 * Concepts of Job Control ::    Concepts of Job Control
780 * Job Control is Optional::     Not all POSIX systems support job control.
781 * Controlling Terminal::        How a process gets its controlling terminal.
782 * Access to the Terminal::      How processes share the controlling terminal.
783 * Orphaned Process Groups::     Jobs left after the user logs out.
784 * Implementing a Shell::        What a shell must do to implement job control.
785 * Functions for Job Control::   Functions to control process groups.
786
787 Implementing a Job Control Shell
788
789 * Data Structures::             Introduction to the sample shell.
790 * Initializing the Shell::      What the shell must do to take
791                                  responsibility for job control.
792 * Launching Jobs::              Creating jobs to execute commands.
793 * Foreground and Background::   Putting a job in foreground of background.
794 * Stopped and Terminated Jobs:: Reporting job status.
795 * Continuing Stopped Jobs::     How to continue a stopped job in
796                                  the foreground or background.
797 * Missing Pieces::              Other parts of the shell.
798
799 Functions for Job Control
800
801 * Identifying the Terminal::    Determining the controlling terminal's name.
802 * Process Group Functions::     Functions for manipulating process groups.
803 * Terminal Access Functions::   Functions for controlling terminal access.
804
805 Users and Groups
806
807 * User and Group IDs::          Each user and group has a unique numeric ID.
808 * Process Persona::             The user IDs and group IDs of a process.
809 * Why Change Persona::          Why a program might need to change
810                                  its user and/or group IDs.
811 * How Change Persona::          Restrictions on changing user and group IDs.
812 * Reading Persona::             Examining the process's user and group IDs.
813 * Setting User ID::             
814 * Setting Groups::              
815 * Enable/Disable Setuid::       
816 * Setuid Program Example::      Setuid Program Example
817 * Tips for Setuid::             
818 * Who Logged In::               Getting the name of the user who logged in,
819                                  or of the real user ID of the current process.
820
821 * User Database::               Functions and data structures for
822                                  accessing the user database.
823 * Group Database::              Functions and data structures for
824                                  accessing the group database.
825 * Database Example::            Example program showing use of database
826                                  inquiry functions.
827
828 User Database
829
830 * User Data Structure::         
831 * Lookup User::                 
832 * Scanning All Users::          Scanning the List of All Users
833 * Writing a User Entry::        
834
835 Group Database
836
837 * Group Data Structure::        
838 * Lookup Group::                
839 * Scanning All Groups::         Scanning the List of All Groups
840
841 System Information
842
843 * Host Identification::         Determining the name of the machine.
844 * Hardware/Software Type ID::   Determining the hardware type and
845                                  operating system type.
846
847 System Configuration Limits
848
849 * General Limits::              Constants and functions that describe
850                                  various process-related limits that have
851                                  one uniform value for any given machine.
852 * System Options::              Optional POSIX features.
853 * Version Supported::           Version numbers of POSIX.1 and POSIX.2.
854 * Sysconf::                     Getting specific configuration values
855                                  of general limits and system options.
856 * Minimums::                    Minimum values for general limits.
857    
858 * Limits for Files::            Size limitations on individual files.
859                                  These can vary between file systems
860                                   or even from file to file.
861 * Options for Files::           Optional features that some files may support.
862 * File Minimums::               Minimum values for file limits.
863 * Pathconf::                    Getting the limit values for a particular file.
864    
865 * Utility Limits::              Capacity limits of POSIX.2 utility programs.
866 * Utility Minimums::            Minimum allowable values of those limits.
867    
868 * String Parameters::           Getting the default search path.
869
870 Library Facilities that are Part of the C Language
871
872 * Consistency Checking::        Using @code{assert} to abort
873                                  if something ``impossible'' happens.
874 * Variadic Functions::          Defining functions with varying
875                                  numbers of arguments.
876 * Null Pointer Constant::       The macro @code{NULL}.
877 * Important Data Types::        Data types for object sizes.
878 * Data Type Measurements::      Parameters of data type representations.
879
880 Variadic Functions
881
882 * Why Variadic::                Reasons for making functions take
883                                  variable arguments.
884 * How Variadic::                How to define and call variadic functions.
885 * Argument Macros::             Detailed specification of the macros
886                                  for accessing variable arguments.
887 * Variadic Example::            A complete example.
888
889 How Variadic Functions are Defined and Used
890
891 * Variadic Prototypes::         How to make a prototype for a function
892                                  with variable arguments.
893 * Receiving Arguments::         Steps you must follow to access the
894                                  optional argument values.
895 * How Many Arguments::          How to decide whether there are more arguments.
896 * Calling Variadics::           Things you need to know about calling
897                                  variable arguments functions.
898
899 Data Type Measurements
900
901 * Width of Type::               How many bits does an integer type hold?
902 * Range of Type::               What are the largest and smallest values
903                                  that an integer type can hold?
904 * Floating Type Macros::        Parameters that measure floating-point types.
905 * Structure Measurement::       Getting measurements on structure types.
906
907 Floating Type Macros
908
909 * Floating Point Concepts::     Definitions of terminology.
910 * Floating Point Parameters::   Dimensions, limits of floating point types.
911 * IEEE Floating Point::         How one common representation is described.
912
913 Library Maintenance
914
915 * Installation::                How to configure, compile and install
916                                  the GNU C library.
917 * Reporting Bugs::              How to report bugs (if you want to
918                                  get them fixed) and other troubles
919                                  you may have with the GNU C library.
920 * Porting::                     How to port the GNU C library to
921                                  a new machine or operating system.
922 @c * Traditional C Compatibility::  Using the GNU C library with non-ANSI
923 @c                                          C compilers.
924 * Contributors::                Who wrote what parts of the GNU C Library.
925
926 Porting the GNU C Library
927
928 * Hierarchy Conventions::       How the @file{sysdeps} hierarchy is
929                                  layed out.
930 * Porting to Unix::             Porting the library to an average
931                                  Unix-like system.
932 @end menu
933
934
935 @comment Includes of all the individual chapters.
936 @include intro.texi
937 @include errno.texi
938 @include memory.texi
939 @include ctype.texi
940 @include string.texi
941 @include mbyte.texi
942 @include locale.texi
943 @include search.texi
944 @include pattern.texi
945 @include io.texi
946 @include stdio.texi
947 @include llio.texi
948 @include filesys.texi
949 @include pipe.texi
950 @include socket.texi
951 @include terminal.texi
952 @include math.texi
953 @include arith.texi
954 @include time.texi
955 @include setjmp.texi
956 @include signal.texi
957 @include startup.texi
958 @include child.texi
959 @include job.texi
960 @include users.texi
961 @include sysinfo.texi
962 @include conf.texi
963
964 @comment Includes of the appendices.
965 @include lang.texi
966 @include header.texi
967 @include maint.texi
968
969
970 @set lgpl-appendix
971 @node Copying, Concept Index, Maintenance, Top
972 @include lgpl.texinfo
973
974
975 @node Concept Index, Type Index, Copying, Top
976 @unnumbered Concept Index
977
978 @printindex cp
979
980 @node Type Index, Function Index, Concept Index, Top
981 @unnumbered Type Index
982
983 @printindex tp
984
985 @node Function Index, Variable Index, Type Index, Top
986 @unnumbered Function and Macro Index
987
988 @printindex fn
989
990 @node Variable Index, File Index, Function Index, Top
991 @unnumbered Variable and Constant Macro Index
992
993 @printindex vr
994
995 @node File Index, , Variable Index, Top
996 @unnumbered Program and File Index
997
998 @printindex pg
999
1000
1001 @shortcontents
1002 @contents
1003 @bye