<html lang="en">
<head>
<title>Variable Index - The GNU C Library</title>
<meta http-equiv="Content-Type" content="text/html">
<meta name="description" content="The GNU C Library">
<meta name="generator" content="makeinfo 4.13">
<link title="Top" rel="start" href="index.html#Top">
<link rel="prev" href="Function-Index.html#Function-Index" title="Function Index">
<link rel="next" href="File-Index.html#File-Index" title="File Index">
<link href="http://www.gnu.org/software/texinfo/" rel="generator-home" title="Texinfo Homepage">
<!--
This file documents the GNU C library.

This is Edition 0.12, last updated 2007-10-27,
of `The GNU C Library Reference Manual', for version
2.8 (Sourcery G++ Lite 2011.03-41).

Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2001, 2002,
2003, 2007, 2008, 2010 Free Software Foundation, Inc.

Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.3 or
any later version published by the Free Software Foundation; with the
Invariant Sections being ``Free Software Needs Free Documentation''
and ``GNU Lesser General Public License'', the Front-Cover texts being
``A GNU Manual'', and with the Back-Cover Texts as in (a) below.  A
copy of the license is included in the section entitled "GNU Free
Documentation License".

(a) The FSF's Back-Cover Text is: ``You have the freedom to
copy and modify this GNU manual.  Buying copies from the FSF
supports it in developing GNU and promoting software freedom.''-->
<meta http-equiv="Content-Style-Type" content="text/css">
<style type="text/css"><!--
  pre.display { font-family:inherit }
  pre.format  { font-family:inherit }
  pre.smalldisplay { font-family:inherit; font-size:smaller }
  pre.smallformat  { font-family:inherit; font-size:smaller }
  pre.smallexample { font-size:smaller }
  pre.smalllisp    { font-size:smaller }
  span.sc    { font-variant:small-caps }
  span.roman { font-family:serif; font-weight:normal; } 
  span.sansserif { font-family:sans-serif; font-weight:normal; } 
--></style>
<link rel="stylesheet" type="text/css" href="../cs.css">
</head>
<body>
<div class="node">
<a name="Variable-Index"></a>
<p>
Next:&nbsp;<a rel="next" accesskey="n" href="File-Index.html#File-Index">File Index</a>,
Previous:&nbsp;<a rel="previous" accesskey="p" href="Function-Index.html#Function-Index">Function Index</a>,
Up:&nbsp;<a rel="up" accesskey="u" href="index.html#Top">Top</a>
<hr>
</div>

<h2 class="unnumbered">Variable and Constant Macro Index</h2>



<ul class="index-vr" compact>
<li><a href="Error-Messages.html#index-g_t_0028-220"><code>(</code></a>: <a href="Error-Messages.html#Error-Messages">Error Messages</a></li>
<li><a href="glibc-iconv-Implementation.html#index-g_t_0028_002a_005f_005fgconv_005fend_005ffct_0029-684"><code>(*__gconv_end_fct)</code></a>: <a href="glibc-iconv-Implementation.html#glibc-iconv-Implementation">glibc iconv Implementation</a></li>
<li><a href="glibc-iconv-Implementation.html#index-g_t_0028_002a_005f_005fgconv_005ffct_0029-685"><code>(*__gconv_fct)</code></a>: <a href="glibc-iconv-Implementation.html#glibc-iconv-Implementation">glibc iconv Implementation</a></li>
<li><a href="glibc-iconv-Implementation.html#index-g_t_0028_002a_005f_005fgconv_005finit_005ffct_0029-683"><code>(*__gconv_init_fct)</code></a>: <a href="glibc-iconv-Implementation.html#glibc-iconv-Implementation">glibc iconv Implementation</a></li>
<li><a href="Hooks-for-Malloc.html#index-g_t_005f_005ffree_005fhook-289"><code>__free_hook</code></a>: <a href="Hooks-for-Malloc.html#Hooks-for-Malloc">Hooks for Malloc</a></li>
<li><a href="Hooks-for-Malloc.html#index-g_t_005f_005fmalloc_005fhook-287"><code>__malloc_hook</code></a>: <a href="Hooks-for-Malloc.html#Hooks-for-Malloc">Hooks for Malloc</a></li>
<li><a href="Hooks-for-Malloc.html#index-g_t_005f_005fmalloc_005finitialize_005fhook-291"><code>__malloc_initialize_hook</code></a>: <a href="Hooks-for-Malloc.html#Hooks-for-Malloc">Hooks for Malloc</a></li>
<li><a href="Hooks-for-Malloc.html#index-g_t_005f_005fmemalign_005fhook-290"><code>__memalign_hook</code></a>: <a href="Hooks-for-Malloc.html#Hooks-for-Malloc">Hooks for Malloc</a></li>
<li><a href="Hooks-for-Malloc.html#index-g_t_005f_005frealloc_005fhook-288"><code>__realloc_hook</code></a>: <a href="Hooks-for-Malloc.html#Hooks-for-Malloc">Hooks for Malloc</a></li>
<li><a href="Feature-Test-Macros.html#index-g_t_005fBSD_005fSOURCE-40"><code>_BSD_SOURCE</code></a>: <a href="Feature-Test-Macros.html#Feature-Test-Macros">Feature Test Macros</a></li>
<li><a href="Complex-Numbers.html#index-g_t_005fComplex_005fI-2523"><code>_Complex_I</code></a>: <a href="Complex-Numbers.html#Complex-Numbers">Complex Numbers</a></li>
<li><a href="Feature-Test-Macros.html#index-g_t_005fFILE_005fOFFSET_005fBITS-49"><code>_FILE_OFFSET_BITS</code></a>: <a href="Feature-Test-Macros.html#Feature-Test-Macros">Feature Test Macros</a></li>
<li><a href="Feature-Test-Macros.html#index-g_t_005fGNU_005fSOURCE-51"><code>_GNU_SOURCE</code></a>: <a href="Feature-Test-Macros.html#Feature-Test-Macros">Feature Test Macros</a></li>
<li><a href="Controlling-Buffering.html#index-g_t_005fIOFBF-1144"><code>_IOFBF</code></a>: <a href="Controlling-Buffering.html#Controlling-Buffering">Controlling Buffering</a></li>
<li><a href="Controlling-Buffering.html#index-g_t_005fIOLBF-1145"><code>_IOLBF</code></a>: <a href="Controlling-Buffering.html#Controlling-Buffering">Controlling Buffering</a></li>
<li><a href="Controlling-Buffering.html#index-g_t_005fIONBF-1146"><code>_IONBF</code></a>: <a href="Controlling-Buffering.html#Controlling-Buffering">Controlling Buffering</a></li>
<li><a href="Feature-Test-Macros.html#index-g_t_005fISOC99_005fSOURCE-50"><code>_ISOC99_SOURCE</code></a>: <a href="Feature-Test-Macros.html#Feature-Test-Macros">Feature Test Macros</a></li>
<li><a href="Feature-Test-Macros.html#index-g_t_005fLARGEFILE64_005fSOURCE-48"><code>_LARGEFILE64_SOURCE</code></a>: <a href="Feature-Test-Macros.html#Feature-Test-Macros">Feature Test Macros</a></li>
<li><a href="Feature-Test-Macros.html#index-g_t_005fLARGEFILE_005fSOURCE-47"><code>_LARGEFILE_SOURCE</code></a>: <a href="Feature-Test-Macros.html#Feature-Test-Macros">Feature Test Macros</a></li>
<li><a href="Mount-Information.html#index-g_t_005fPATH_005fFSTAB-3458"><code>_PATH_FSTAB</code></a>: <a href="Mount-Information.html#Mount-Information">Mount Information</a></li>
<li><a href="Mount-Information.html#index-g_t_005fPATH_005fMNTTAB-3459"><code>_PATH_MNTTAB</code></a>: <a href="Mount-Information.html#Mount-Information">Mount Information</a></li>
<li><a href="Mount-Information.html#index-g_t_005fPATH_005fMOUNTED-3460"><code>_PATH_MOUNTED</code></a>: <a href="Mount-Information.html#Mount-Information">Mount Information</a></li>
<li><a href="Manipulating-the-Database.html#index-g_t_005fPATH_005fUTMP-3360"><code>_PATH_UTMP</code></a>: <a href="Manipulating-the-Database.html#Manipulating-the-Database">Manipulating the Database</a></li>
<li><a href="Manipulating-the-Database.html#index-g_t_005fPATH_005fWTMP-3361"><code>_PATH_WTMP</code></a>: <a href="Manipulating-the-Database.html#Manipulating-the-Database">Manipulating the Database</a></li>
<li><a href="System-Options.html#index-g_t_005fPOSIX2_005fC_005fDEV-3517"><code>_POSIX2_C_DEV</code></a>: <a href="System-Options.html#System-Options">System Options</a></li>
<li><a href="Version-Supported.html#index-g_t_005fPOSIX2_005fC_005fVERSION-3523"><code>_POSIX2_C_VERSION</code></a>: <a href="Version-Supported.html#Version-Supported">Version Supported</a></li>
<li><a href="System-Options.html#index-g_t_005fPOSIX2_005fFORT_005fDEV-3518"><code>_POSIX2_FORT_DEV</code></a>: <a href="System-Options.html#System-Options">System Options</a></li>
<li><a href="System-Options.html#index-g_t_005fPOSIX2_005fFORT_005fRUN-3519"><code>_POSIX2_FORT_RUN</code></a>: <a href="System-Options.html#System-Options">System Options</a></li>
<li><a href="System-Options.html#index-g_t_005fPOSIX2_005fLOCALEDEF-3520"><code>_POSIX2_LOCALEDEF</code></a>: <a href="System-Options.html#System-Options">System Options</a></li>
<li><a href="System-Options.html#index-g_t_005fPOSIX2_005fSW_005fDEV-3521"><code>_POSIX2_SW_DEV</code></a>: <a href="System-Options.html#System-Options">System Options</a></li>
<li><a href="Feature-Test-Macros.html#index-g_t_005fPOSIX_005fC_005fSOURCE-39"><code>_POSIX_C_SOURCE</code></a>: <a href="Feature-Test-Macros.html#Feature-Test-Macros">Feature Test Macros</a></li>
<li><a href="Options-for-Files.html#index-g_t_005fPOSIX_005fCHOWN_005fRESTRICTED-3661"><code>_POSIX_CHOWN_RESTRICTED</code></a>: <a href="Options-for-Files.html#Options-for-Files">Options for Files</a></li>
<li><a href="System-Options.html#index-g_t_005fPOSIX_005fJOB_005fCONTROL-3515"><code>_POSIX_JOB_CONTROL</code></a>: <a href="System-Options.html#System-Options">System Options</a></li>
<li><a href="Options-for-Files.html#index-g_t_005fPOSIX_005fNO_005fTRUNC-3662"><code>_POSIX_NO_TRUNC</code></a>: <a href="Options-for-Files.html#Options-for-Files">Options for Files</a></li>
<li><a href="System-Options.html#index-g_t_005fPOSIX_005fSAVED_005fIDS-3516"><code>_POSIX_SAVED_IDS</code></a>: <a href="System-Options.html#System-Options">System Options</a></li>
<li><a href="Feature-Test-Macros.html#index-g_t_005fPOSIX_005fSOURCE-38"><code>_POSIX_SOURCE</code></a>: <a href="Feature-Test-Macros.html#Feature-Test-Macros">Feature Test Macros</a></li>
<li><a href="Options-for-Files.html#index-g_t_005fPOSIX_005fVDISABLE-3663"><code>_POSIX_VDISABLE</code></a>: <a href="Options-for-Files.html#Options-for-Files">Options for Files</a></li>
<li><a href="Special-Characters.html#index-g_t_005fPOSIX_005fVDISABLE-1956"><code>_POSIX_VDISABLE</code></a>: <a href="Special-Characters.html#Special-Characters">Special Characters</a></li>
<li><a href="Version-Supported.html#index-g_t_005fPOSIX_005fVERSION-3522"><code>_POSIX_VERSION</code></a>: <a href="Version-Supported.html#Version-Supported">Version Supported</a></li>
<li><a href="Feature-Test-Macros.html#index-g_t_005fREENTRANT-52"><code>_REENTRANT</code></a>: <a href="Feature-Test-Macros.html#Feature-Test-Macros">Feature Test Macros</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005f2_005fC_005fDEV-3590"><code>_SC_2_C_DEV</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005f2_005fFORT_005fDEV-3591"><code>_SC_2_FORT_DEV</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005f2_005fFORT_005fRUN-3592"><code>_SC_2_FORT_RUN</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005f2_005fLOCALEDEF-3593"><code>_SC_2_LOCALEDEF</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005f2_005fSW_005fDEV-3594"><code>_SC_2_SW_DEV</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005f2_005fVERSION-3604"><code>_SC_2_VERSION</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fAIO_005fLISTIO_005fMAX-3550"><code>_SC_AIO_LISTIO_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fAIO_005fMAX-3551"><code>_SC_AIO_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fAIO_005fPRIO_005fDELTA_005fMAX-3552"><code>_SC_AIO_PRIO_DELTA_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fARG_005fMAX-3525"><code>_SC_ARG_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fASYNCHRONOUS_005fIO-3539"><code>_SC_ASYNCHRONOUS_IO</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fATEXIT_005fMAX-3610"><code>_SC_ATEXIT_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fAVPHYS_005fPAGES-3609"><code>_SC_AVPHYS_PAGES</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Query-Memory-Parameters.html#index-g_t_005fSC_005fAVPHYS_005fPAGES-2783"><code>_SC_AVPHYS_PAGES</code></a>: <a href="Query-Memory-Parameters.html#Query-Memory-Parameters">Query Memory Parameters</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fBC_005fBASE_005fMAX-3595"><code>_SC_BC_BASE_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fBC_005fDIM_005fMAX-3596"><code>_SC_BC_DIM_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fBC_005fSCALE_005fMAX-3597"><code>_SC_BC_SCALE_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fBC_005fSTRING_005fMAX-3598"><code>_SC_BC_STRING_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fCHAR_005fBIT-3623"><code>_SC_CHAR_BIT</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fCHAR_005fMAX-3624"><code>_SC_CHAR_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fCHAR_005fMIN-3625"><code>_SC_CHAR_MIN</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fCHARCLASS_005fNAME_005fMAX-3535"><code>_SC_CHARCLASS_NAME_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fCHILD_005fMAX-3526"><code>_SC_CHILD_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fCLK_005fTCK-3534"><code>_SC_CLK_TCK</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fCOLL_005fWEIGHTS_005fMAX-3599"><code>_SC_COLL_WEIGHTS_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fDELAYTIMER_005fMAX-3553"><code>_SC_DELAYTIMER_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fEQUIV_005fCLASS_005fMAX-3602"><code>_SC_EQUIV_CLASS_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fEXPR_005fNEST_005fMAX-3600"><code>_SC_EXPR_NEST_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fFSYNC-3542"><code>_SC_FSYNC</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fGETGR_005fR_005fSIZE_005fMAX-3576"><code>_SC_GETGR_R_SIZE_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fGETPW_005fR_005fSIZE_005fMAX-3577"><code>_SC_GETPW_R_SIZE_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fINT_005fMAX-3626"><code>_SC_INT_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fINT_005fMIN-3627"><code>_SC_INT_MIN</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fJOB_005fCONTROL-3531"><code>_SC_JOB_CONTROL</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fLINE_005fMAX-3601"><code>_SC_LINE_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fLOGIN_005fNAME_005fMAX-3578"><code>_SC_LOGIN_NAME_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fLONG_005fBIT-3628"><code>_SC_LONG_BIT</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fMAPPED_005fFILES-3543"><code>_SC_MAPPED_FILES</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fMB_005fLEN_005fMAX-3630"><code>_SC_MB_LEN_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fMEMLOCK-3544"><code>_SC_MEMLOCK</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fMEMLOCK_005fRANGE-3545"><code>_SC_MEMLOCK_RANGE</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fMEMORY_005fPROTECTION-3546"><code>_SC_MEMORY_PROTECTION</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fMESSAGE_005fPASSING-3547"><code>_SC_MESSAGE_PASSING</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fMQ_005fOPEN_005fMAX-3554"><code>_SC_MQ_OPEN_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fMQ_005fPRIO_005fMAX-3555"><code>_SC_MQ_PRIO_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fNGROUPS_005fMAX-3530"><code>_SC_NGROUPS_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fNL_005fARGMAX-3641"><code>_SC_NL_ARGMAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fNL_005fLANGMAX-3642"><code>_SC_NL_LANGMAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fNL_005fMSGMAX-3643"><code>_SC_NL_MSGMAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fNL_005fNMAX-3644"><code>_SC_NL_NMAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fNL_005fSETMAX-3645"><code>_SC_NL_SETMAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fNL_005fTEXTMAX-3646"><code>_SC_NL_TEXTMAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fNPROCESSORS_005fCONF-3606"><code>_SC_NPROCESSORS_CONF</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Processor-Resources.html#index-g_t_005fSC_005fNPROCESSORS_005fCONF-2787"><code>_SC_NPROCESSORS_CONF</code></a>: <a href="Processor-Resources.html#Processor-Resources">Processor Resources</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fNPROCESSORS_005fONLN-3607"><code>_SC_NPROCESSORS_ONLN</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Processor-Resources.html#index-g_t_005fSC_005fNPROCESSORS_005fONLN-2789"><code>_SC_NPROCESSORS_ONLN</code></a>: <a href="Processor-Resources.html#Processor-Resources">Processor Resources</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fNZERO-3631"><code>_SC_NZERO</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fOPEN_005fMAX-3527"><code>_SC_OPEN_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fPAGESIZE-3605"><code>_SC_PAGESIZE</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Query-Memory-Parameters.html#index-g_t_005fSC_005fPAGESIZE-2779"><code>_SC_PAGESIZE</code></a>: <a href="Query-Memory-Parameters.html#Query-Memory-Parameters">Query Memory Parameters</a></li>
<li><a href="Memory_002dmapped-I_002fO.html#index-g_t_005fSC_005fPAGESIZE-1254"><code>_SC_PAGESIZE</code></a>: <a href="Memory_002dmapped-I_002fO.html#Memory_002dmapped-I_002fO">Memory-mapped I/O</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fPHYS_005fPAGES-3608"><code>_SC_PHYS_PAGES</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Query-Memory-Parameters.html#index-g_t_005fSC_005fPHYS_005fPAGES-2781"><code>_SC_PHYS_PAGES</code></a>: <a href="Query-Memory-Parameters.html#Query-Memory-Parameters">Query Memory Parameters</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fPII-3561"><code>_SC_PII</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fPII_005fINTERNET-3564"><code>_SC_PII_INTERNET</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fPII_005fINTERNET_005fDGRAM-3569"><code>_SC_PII_INTERNET_DGRAM</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fPII_005fINTERNET_005fSTREAM-3568"><code>_SC_PII_INTERNET_STREAM</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fPII_005fOSI-3565"><code>_SC_PII_OSI</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fPII_005fOSI_005fCLTS-3571"><code>_SC_PII_OSI_CLTS</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fPII_005fOSI_005fCOTS-3570"><code>_SC_PII_OSI_COTS</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fPII_005fOSI_005fM-3572"><code>_SC_PII_OSI_M</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fPII_005fSOCKET-3563"><code>_SC_PII_SOCKET</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fPII_005fXTI-3562"><code>_SC_PII_XTI</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fPRIORITIZED_005fIO-3540"><code>_SC_PRIORITIZED_IO</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fPRIORITY_005fSCHEDULING-3537"><code>_SC_PRIORITY_SCHEDULING</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fREALTIME_005fSIGNALS-3536"><code>_SC_REALTIME_SIGNALS</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fRTSIG_005fMAX-3556"><code>_SC_RTSIG_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fSAVED_005fIDS-3532"><code>_SC_SAVED_IDS</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fSCHAR_005fMAX-3633"><code>_SC_SCHAR_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fSCHAR_005fMIN-3634"><code>_SC_SCHAR_MIN</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fSELECT-3566"><code>_SC_SELECT</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fSEM_005fNSEMS_005fMAX-3557"><code>_SC_SEM_NSEMS_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fSEM_005fVALUE_005fMAX-3558"><code>_SC_SEM_VALUE_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fSEMAPHORES-3548"><code>_SC_SEMAPHORES</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fSHARED_005fMEMORY_005fOBJECTS-3549"><code>_SC_SHARED_MEMORY_OBJECTS</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fSHRT_005fMAX-3635"><code>_SC_SHRT_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fSHRT_005fMIN-3636"><code>_SC_SHRT_MIN</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fSIGQUEUE_005fMAX-3559"><code>_SC_SIGQUEUE_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fSTREAM_005fMAX-3528"><code>_SC_STREAM_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fSYNCHRONIZED_005fIO-3541"><code>_SC_SYNCHRONIZED_IO</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fT_005fIOV_005fMAX-3573"><code>_SC_T_IOV_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fTHREAD_005fATTR_005fSTACKADDR-3584"><code>_SC_THREAD_ATTR_STACKADDR</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fTHREAD_005fATTR_005fSTACKSIZE-3585"><code>_SC_THREAD_ATTR_STACKSIZE</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fTHREAD_005fDESTRUCTOR_005fITERATIONS-3580"><code>_SC_THREAD_DESTRUCTOR_ITERATIONS</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fTHREAD_005fKEYS_005fMAX-3581"><code>_SC_THREAD_KEYS_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fTHREAD_005fPRIO_005fINHERIT-3587"><code>_SC_THREAD_PRIO_INHERIT</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fTHREAD_005fPRIO_005fPROTECT-3588"><code>_SC_THREAD_PRIO_PROTECT</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fTHREAD_005fPRIORITY_005fSCHEDULING-3586"><code>_SC_THREAD_PRIORITY_SCHEDULING</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fTHREAD_005fPROCESS_005fSHARED-3589"><code>_SC_THREAD_PROCESS_SHARED</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fTHREAD_005fSAFE_005fFUNCTIONS-3575"><code>_SC_THREAD_SAFE_FUNCTIONS</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fTHREAD_005fSTACK_005fMIN-3582"><code>_SC_THREAD_STACK_MIN</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fTHREAD_005fTHREADS_005fMAX-3583"><code>_SC_THREAD_THREADS_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fTHREADS-3574"><code>_SC_THREADS</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fTIMER_005fMAX-3560"><code>_SC_TIMER_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fTIMERS-3538"><code>_SC_TIMERS</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fTTY_005fNAME_005fMAX-3579"><code>_SC_TTY_NAME_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fTZNAME_005fMAX-3529"><code>_SC_TZNAME_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fUCHAR_005fMAX-3637"><code>_SC_UCHAR_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fUINT_005fMAX-3638"><code>_SC_UINT_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fUIO_005fMAXIOV-3567"><code>_SC_UIO_MAXIOV</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fULONG_005fMAX-3639"><code>_SC_ULONG_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fUSHRT_005fMAX-3640"><code>_SC_USHRT_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fVERSION-3533"><code>_SC_VERSION</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fWORD_005fBIT-3629"><code>_SC_WORD_BIT</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fXOPEN_005fCRYPT-3617"><code>_SC_XOPEN_CRYPT</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fXOPEN_005fENH_005fI18N-3618"><code>_SC_XOPEN_ENH_I18N</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fXOPEN_005fLEGACY-3616"><code>_SC_XOPEN_LEGACY</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fXOPEN_005fREALTIME-3614"><code>_SC_XOPEN_REALTIME</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fXOPEN_005fREALTIME_005fTHREADS-3615"><code>_SC_XOPEN_REALTIME_THREADS</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fXOPEN_005fSHM-3619"><code>_SC_XOPEN_SHM</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fXOPEN_005fUNIX-3613"><code>_SC_XOPEN_UNIX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fXOPEN_005fVERSION-3611"><code>_SC_XOPEN_VERSION</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fXOPEN_005fXCU_005fVERSION-3612"><code>_SC_XOPEN_XCU_VERSION</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fXOPEN_005fXPG2-3620"><code>_SC_XOPEN_XPG2</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fXOPEN_005fXPG3-3621"><code>_SC_XOPEN_XPG3</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Constants-for-Sysconf.html#index-g_t_005fSC_005fXOPEN_005fXPG4-3622"><code>_SC_XOPEN_XPG4</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Feature-Test-Macros.html#index-g_t_005fSVID_005fSOURCE-44"><code>_SVID_SOURCE</code></a>: <a href="Feature-Test-Macros.html#Feature-Test-Macros">Feature Test Macros</a></li>
<li><a href="Feature-Test-Macros.html#index-g_t_005fTHREAD_005fSAFE-53"><code>_THREAD_SAFE</code></a>: <a href="Feature-Test-Macros.html#Feature-Test-Macros">Feature Test Macros</a></li>
<li><a href="Feature-Test-Macros.html#index-g_t_005fXOPEN_005fSOURCE-45"><code>_XOPEN_SOURCE</code></a>: <a href="Feature-Test-Macros.html#Feature-Test-Macros">Feature Test Macros</a></li>
<li><a href="Feature-Test-Macros.html#index-g_t_005fXOPEN_005fSOURCE_005fEXTENDED-46"><code>_XOPEN_SOURCE_EXTENDED</code></a>: <a href="Feature-Test-Macros.html#Feature-Test-Macros">Feature Test Macros</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-ABDAY_005f1-717"><code>ABDAY_1</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-ABDAY_005f2-718"><code>ABDAY_2</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-ABDAY_005f3-719"><code>ABDAY_3</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-ABDAY_005f4-720"><code>ABDAY_4</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-ABDAY_005f5-721"><code>ABDAY_5</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-ABDAY_005f6-722"><code>ABDAY_6</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-ABDAY_005f7-723"><code>ABDAY_7</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-ABMON_005f1-731"><code>ABMON_1</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-ABMON_005f10-740"><code>ABMON_10</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-ABMON_005f11-741"><code>ABMON_11</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-ABMON_005f12-742"><code>ABMON_12</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-ABMON_005f2-732"><code>ABMON_2</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-ABMON_005f3-733"><code>ABMON_3</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-ABMON_005f4-734"><code>ABMON_4</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-ABMON_005f5-735"><code>ABMON_5</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-ABMON_005f6-736"><code>ABMON_6</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-ABMON_005f7-737"><code>ABMON_7</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-ABMON_005f8-738"><code>ABMON_8</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-ABMON_005f9-739"><code>ABMON_9</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="Manipulating-the-Database.html#index-ACCOUNTING-3349"><code>ACCOUNTING</code></a>: <a href="Manipulating-the-Database.html#Manipulating-the-Database">Manipulating the Database</a></li>
<li><a href="Address-Formats.html#index-AF_005fFILE-1659"><code>AF_FILE</code></a>: <a href="Address-Formats.html#Address-Formats">Address Formats</a></li>
<li><a href="Address-Formats.html#index-AF_005fINET-1660"><code>AF_INET</code></a>: <a href="Address-Formats.html#Address-Formats">Address Formats</a></li>
<li><a href="Address-Formats.html#index-AF_005fLOCAL-1657"><code>AF_LOCAL</code></a>: <a href="Address-Formats.html#Address-Formats">Address Formats</a></li>
<li><a href="Address-Formats.html#index-AF_005fUNIX-1658"><code>AF_UNIX</code></a>: <a href="Address-Formats.html#Address-Formats">Address Formats</a></li>
<li><a href="Address-Formats.html#index-AF_005fUNSPEC-1661"><code>AF_UNSPEC</code></a>: <a href="Address-Formats.html#Address-Formats">Address Formats</a></li>
<li><a href="NSS-Basics.html#index-aliases-3262"><code>aliases</code></a>: <a href="NSS-Basics.html#NSS-Basics">NSS Basics</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-ALT_005fDIGITS-766"><code>ALT_DIGITS</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="Local-Modes.html#index-ALTWERASE-1920"><code>ALTWERASE</code></a>: <a href="Local-Modes.html#Local-Modes">Local Modes</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-AM_005fSTR-755"><code>AM_STR</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="General-Limits.html#index-ARG_005fMAX-3500"><code>ARG_MAX</code></a>: <a href="General-Limits.html#General-Limits">General Limits</a></li>
<li><a href="Argp-Global-Variables.html#index-argp_005ferr_005fexit_005fstatus-3040"><code>argp_err_exit_status</code></a>: <a href="Argp-Global-Variables.html#Argp-Global-Variables">Argp Global Variables</a></li>
<li><a href="Argp-Parser-Functions.html#index-ARGP_005fERR_005fUNKNOWN-3049"><code>ARGP_ERR_UNKNOWN</code></a>: <a href="Argp-Parser-Functions.html#Argp-Parser-Functions">Argp Parser Functions</a></li>
<li><a href="Argp-Help-Flags.html#index-ARGP_005fHELP_005fBUG_005fADDR-3089"><code>ARGP_HELP_BUG_ADDR</code></a>: <a href="Argp-Help-Flags.html#Argp-Help-Flags">Argp Help Flags</a></li>
<li><a href="Argp-Help-Flags.html#index-ARGP_005fHELP_005fDOC-3088"><code>ARGP_HELP_DOC</code></a>: <a href="Argp-Help-Flags.html#Argp-Help-Flags">Argp Help Flags</a></li>
<li><a href="Argp-Help-Flags.html#index-ARGP_005fHELP_005fEXIT_005fERR-3091"><code>ARGP_HELP_EXIT_ERR</code></a>: <a href="Argp-Help-Flags.html#Argp-Help-Flags">Argp Help Flags</a></li>
<li><a href="Argp-Help-Flags.html#index-ARGP_005fHELP_005fEXIT_005fOK-3092"><code>ARGP_HELP_EXIT_OK</code></a>: <a href="Argp-Help-Flags.html#Argp-Help-Flags">Argp Help Flags</a></li>
<li><a href="Argp-Help-Flags.html#index-ARGP_005fHELP_005fLONG-3085"><code>ARGP_HELP_LONG</code></a>: <a href="Argp-Help-Flags.html#Argp-Help-Flags">Argp Help Flags</a></li>
<li><a href="Argp-Help-Flags.html#index-ARGP_005fHELP_005fLONG_005fONLY-3090"><code>ARGP_HELP_LONG_ONLY</code></a>: <a href="Argp-Help-Flags.html#Argp-Help-Flags">Argp Help Flags</a></li>
<li><a href="Argp-Help-Flags.html#index-ARGP_005fHELP_005fPOST_005fDOC-3087"><code>ARGP_HELP_POST_DOC</code></a>: <a href="Argp-Help-Flags.html#Argp-Help-Flags">Argp Help Flags</a></li>
<li><a href="Argp-Help-Flags.html#index-ARGP_005fHELP_005fPRE_005fDOC-3086"><code>ARGP_HELP_PRE_DOC</code></a>: <a href="Argp-Help-Flags.html#Argp-Help-Flags">Argp Help Flags</a></li>
<li><a href="Argp-Help-Flags.html#index-ARGP_005fHELP_005fSEE-3084"><code>ARGP_HELP_SEE</code></a>: <a href="Argp-Help-Flags.html#Argp-Help-Flags">Argp Help Flags</a></li>
<li><a href="Argp-Help-Flags.html#index-ARGP_005fHELP_005fSHORT_005fUSAGE-3083"><code>ARGP_HELP_SHORT_USAGE</code></a>: <a href="Argp-Help-Flags.html#Argp-Help-Flags">Argp Help Flags</a></li>
<li><a href="Argp-Help-Flags.html#index-ARGP_005fHELP_005fSTD_005fERR-3093"><code>ARGP_HELP_STD_ERR</code></a>: <a href="Argp-Help-Flags.html#Argp-Help-Flags">Argp Help Flags</a></li>
<li><a href="Argp-Help-Flags.html#index-ARGP_005fHELP_005fSTD_005fHELP-3095"><code>ARGP_HELP_STD_HELP</code></a>: <a href="Argp-Help-Flags.html#Argp-Help-Flags">Argp Help Flags</a></li>
<li><a href="Argp-Help-Flags.html#index-ARGP_005fHELP_005fSTD_005fUSAGE-3094"><code>ARGP_HELP_STD_USAGE</code></a>: <a href="Argp-Help-Flags.html#Argp-Help-Flags">Argp Help Flags</a></li>
<li><a href="Argp-Help-Flags.html#index-ARGP_005fHELP_005fUSAGE-3082"><code>ARGP_HELP_USAGE</code></a>: <a href="Argp-Help-Flags.html#Argp-Help-Flags">Argp Help Flags</a></li>
<li><a href="Argp-Flags.html#index-ARGP_005fIN_005fORDER-3070"><code>ARGP_IN_ORDER</code></a>: <a href="Argp-Flags.html#Argp-Flags">Argp Flags</a></li>
<li><a href="Argp-Special-Keys.html#index-ARGP_005fKEY_005fARG-3050"><code>ARGP_KEY_ARG</code></a>: <a href="Argp-Special-Keys.html#Argp-Special-Keys">Argp Special Keys</a></li>
<li><a href="Argp-Special-Keys.html#index-ARGP_005fKEY_005fARGS-3051"><code>ARGP_KEY_ARGS</code></a>: <a href="Argp-Special-Keys.html#Argp-Special-Keys">Argp Special Keys</a></li>
<li><a href="Argp-Special-Keys.html#index-ARGP_005fKEY_005fEND-3052"><code>ARGP_KEY_END</code></a>: <a href="Argp-Special-Keys.html#Argp-Special-Keys">Argp Special Keys</a></li>
<li><a href="Argp-Special-Keys.html#index-ARGP_005fKEY_005fERROR-3056"><code>ARGP_KEY_ERROR</code></a>: <a href="Argp-Special-Keys.html#Argp-Special-Keys">Argp Special Keys</a></li>
<li><a href="Argp-Special-Keys.html#index-ARGP_005fKEY_005fFINI-3057"><code>ARGP_KEY_FINI</code></a>: <a href="Argp-Special-Keys.html#Argp-Special-Keys">Argp Special Keys</a></li>
<li><a href="Argp-Help-Filter-Keys.html#index-ARGP_005fKEY_005fHELP_005fARGS_005fDOC-3080"><code>ARGP_KEY_HELP_ARGS_DOC</code></a>: <a href="Argp-Help-Filter-Keys.html#Argp-Help-Filter-Keys">Argp Help Filter Keys</a></li>
<li><a href="Argp-Help-Filter-Keys.html#index-ARGP_005fKEY_005fHELP_005fDUP_005fARGS_005fNOTE-3079"><code>ARGP_KEY_HELP_DUP_ARGS_NOTE</code></a>: <a href="Argp-Help-Filter-Keys.html#Argp-Help-Filter-Keys">Argp Help Filter Keys</a></li>
<li><a href="Argp-Help-Filter-Keys.html#index-ARGP_005fKEY_005fHELP_005fEXTRA-3078"><code>ARGP_KEY_HELP_EXTRA</code></a>: <a href="Argp-Help-Filter-Keys.html#Argp-Help-Filter-Keys">Argp Help Filter Keys</a></li>
<li><a href="Argp-Help-Filter-Keys.html#index-ARGP_005fKEY_005fHELP_005fHEADER-3077"><code>ARGP_KEY_HELP_HEADER</code></a>: <a href="Argp-Help-Filter-Keys.html#Argp-Help-Filter-Keys">Argp Help Filter Keys</a></li>
<li><a href="Argp-Help-Filter-Keys.html#index-ARGP_005fKEY_005fHELP_005fPOST_005fDOC-3076"><code>ARGP_KEY_HELP_POST_DOC</code></a>: <a href="Argp-Help-Filter-Keys.html#Argp-Help-Filter-Keys">Argp Help Filter Keys</a></li>
<li><a href="Argp-Help-Filter-Keys.html#index-ARGP_005fKEY_005fHELP_005fPRE_005fDOC-3075"><code>ARGP_KEY_HELP_PRE_DOC</code></a>: <a href="Argp-Help-Filter-Keys.html#Argp-Help-Filter-Keys">Argp Help Filter Keys</a></li>
<li><a href="Argp-Special-Keys.html#index-ARGP_005fKEY_005fINIT-3054"><code>ARGP_KEY_INIT</code></a>: <a href="Argp-Special-Keys.html#Argp-Special-Keys">Argp Special Keys</a></li>
<li><a href="Argp-Special-Keys.html#index-ARGP_005fKEY_005fNO_005fARGS-3053"><code>ARGP_KEY_NO_ARGS</code></a>: <a href="Argp-Special-Keys.html#Argp-Special-Keys">Argp Special Keys</a></li>
<li><a href="Argp-Special-Keys.html#index-ARGP_005fKEY_005fSUCCESS-3055"><code>ARGP_KEY_SUCCESS</code></a>: <a href="Argp-Special-Keys.html#Argp-Special-Keys">Argp Special Keys</a></li>
<li><a href="Argp-Flags.html#index-ARGP_005fLONG_005fONLY-3073"><code>ARGP_LONG_ONLY</code></a>: <a href="Argp-Flags.html#Argp-Flags">Argp Flags</a></li>
<li><a href="Argp-Flags.html#index-ARGP_005fNO_005fARGS-3069"><code>ARGP_NO_ARGS</code></a>: <a href="Argp-Flags.html#Argp-Flags">Argp Flags</a></li>
<li><a href="Argp-Flags.html#index-ARGP_005fNO_005fERRS-3068"><code>ARGP_NO_ERRS</code></a>: <a href="Argp-Flags.html#Argp-Flags">Argp Flags</a></li>
<li><a href="Argp-Flags.html#index-ARGP_005fNO_005fEXIT-3072"><code>ARGP_NO_EXIT</code></a>: <a href="Argp-Flags.html#Argp-Flags">Argp Flags</a></li>
<li><a href="Argp-Flags.html#index-ARGP_005fNO_005fHELP-3071"><code>ARGP_NO_HELP</code></a>: <a href="Argp-Flags.html#Argp-Flags">Argp Flags</a></li>
<li><a href="Argp-Flags.html#index-ARGP_005fPARSE_005fARGV0-3067"><code>ARGP_PARSE_ARGV0</code></a>: <a href="Argp-Flags.html#Argp-Flags">Argp Flags</a></li>
<li><a href="Argp-Global-Variables.html#index-argp_005fprogram_005fbug_005faddress-3038"><code>argp_program_bug_address</code></a>: <a href="Argp-Global-Variables.html#Argp-Global-Variables">Argp Global Variables</a></li>
<li><a href="Argp-Global-Variables.html#index-argp_005fprogram_005fversion-3037"><code>argp_program_version</code></a>: <a href="Argp-Global-Variables.html#Argp-Global-Variables">Argp Global Variables</a></li>
<li><a href="Argp-Global-Variables.html#index-argp_005fprogram_005fversion_005fhook-3039"><code>argp_program_version_hook</code></a>: <a href="Argp-Global-Variables.html#Argp-Global-Variables">Argp Global Variables</a></li>
<li><a href="Argp-Flags.html#index-ARGP_005fSILENT-3074"><code>ARGP_SILENT</code></a>: <a href="Argp-Flags.html#Argp-Flags">Argp Flags</a></li>
<li><a href="Line-Speed.html#index-B0-1934"><code>B0</code></a>: <a href="Line-Speed.html#Line-Speed">Line Speed</a></li>
<li><a href="Line-Speed.html#index-B110-1937"><code>B110</code></a>: <a href="Line-Speed.html#Line-Speed">Line Speed</a></li>
<li><a href="Line-Speed.html#index-B115200-1951"><code>B115200</code></a>: <a href="Line-Speed.html#Line-Speed">Line Speed</a></li>
<li><a href="Line-Speed.html#index-B1200-1943"><code>B1200</code></a>: <a href="Line-Speed.html#Line-Speed">Line Speed</a></li>
<li><a href="Line-Speed.html#index-B134-1938"><code>B134</code></a>: <a href="Line-Speed.html#Line-Speed">Line Speed</a></li>
<li><a href="Line-Speed.html#index-B150-1939"><code>B150</code></a>: <a href="Line-Speed.html#Line-Speed">Line Speed</a></li>
<li><a href="Line-Speed.html#index-B1800-1944"><code>B1800</code></a>: <a href="Line-Speed.html#Line-Speed">Line Speed</a></li>
<li><a href="Line-Speed.html#index-B19200-1948"><code>B19200</code></a>: <a href="Line-Speed.html#Line-Speed">Line Speed</a></li>
<li><a href="Line-Speed.html#index-B200-1940"><code>B200</code></a>: <a href="Line-Speed.html#Line-Speed">Line Speed</a></li>
<li><a href="Line-Speed.html#index-B230400-1952"><code>B230400</code></a>: <a href="Line-Speed.html#Line-Speed">Line Speed</a></li>
<li><a href="Line-Speed.html#index-B2400-1945"><code>B2400</code></a>: <a href="Line-Speed.html#Line-Speed">Line Speed</a></li>
<li><a href="Line-Speed.html#index-B300-1941"><code>B300</code></a>: <a href="Line-Speed.html#Line-Speed">Line Speed</a></li>
<li><a href="Line-Speed.html#index-B38400-1949"><code>B38400</code></a>: <a href="Line-Speed.html#Line-Speed">Line Speed</a></li>
<li><a href="Line-Speed.html#index-B460800-1953"><code>B460800</code></a>: <a href="Line-Speed.html#Line-Speed">Line Speed</a></li>
<li><a href="Line-Speed.html#index-B4800-1946"><code>B4800</code></a>: <a href="Line-Speed.html#Line-Speed">Line Speed</a></li>
<li><a href="Line-Speed.html#index-B50-1935"><code>B50</code></a>: <a href="Line-Speed.html#Line-Speed">Line Speed</a></li>
<li><a href="Line-Speed.html#index-B57600-1950"><code>B57600</code></a>: <a href="Line-Speed.html#Line-Speed">Line Speed</a></li>
<li><a href="Line-Speed.html#index-B600-1942"><code>B600</code></a>: <a href="Line-Speed.html#Line-Speed">Line Speed</a></li>
<li><a href="Line-Speed.html#index-B75-1936"><code>B75</code></a>: <a href="Line-Speed.html#Line-Speed">Line Speed</a></li>
<li><a href="Line-Speed.html#index-B9600-1947"><code>B9600</code></a>: <a href="Line-Speed.html#Line-Speed">Line Speed</a></li>
<li><a href="Utility-Limits.html#index-BC_005fBASE_005fMAX-3667"><code>BC_BASE_MAX</code></a>: <a href="Utility-Limits.html#Utility-Limits">Utility Limits</a></li>
<li><a href="Utility-Limits.html#index-BC_005fDIM_005fMAX-3668"><code>BC_DIM_MAX</code></a>: <a href="Utility-Limits.html#Utility-Limits">Utility Limits</a></li>
<li><a href="Utility-Limits.html#index-BC_005fSCALE_005fMAX-3669"><code>BC_SCALE_MAX</code></a>: <a href="Utility-Limits.html#Utility-Limits">Utility Limits</a></li>
<li><a href="Utility-Limits.html#index-BC_005fSTRING_005fMAX-3670"><code>BC_STRING_MAX</code></a>: <a href="Utility-Limits.html#Utility-Limits">Utility Limits</a></li>
<li><a href="XPG-Functions.html#index-BOOT_005fTIME-3367"><code>BOOT_TIME</code></a>: <a href="XPG-Functions.html#XPG-Functions">XPG Functions</a></li>
<li><a href="Manipulating-the-Database.html#index-BOOT_005fTIME-3342"><code>BOOT_TIME</code></a>: <a href="Manipulating-the-Database.html#Manipulating-the-Database">Manipulating the Database</a></li>
<li><a href="Input-Modes.html#index-BRKINT-1876"><code>BRKINT</code></a>: <a href="Input-Modes.html#Input-Modes">Input Modes</a></li>
<li><a href="Controlling-Buffering.html#index-BUFSIZ-1147"><code>BUFSIZ</code></a>: <a href="Controlling-Buffering.html#Controlling-Buffering">Controlling Buffering</a></li>
<li><a href="Control-Modes.html#index-CCTS_005fOFLOW-1902"><code>CCTS_OFLOW</code></a>: <a href="Control-Modes.html#Control-Modes">Control Modes</a></li>
<li><a href="Range-of-Type.html#index-CHAR_005fMAX-3752"><code>CHAR_MAX</code></a>: <a href="Range-of-Type.html#Range-of-Type">Range of Type</a></li>
<li><a href="Range-of-Type.html#index-CHAR_005fMIN-3751"><code>CHAR_MIN</code></a>: <a href="Range-of-Type.html#Range-of-Type">Range of Type</a></li>
<li><a href="General-Limits.html#index-CHILD_005fMAX-3502"><code>CHILD_MAX</code></a>: <a href="General-Limits.html#General-Limits">General Limits</a></li>
<li><a href="Control-Modes.html#index-CIGNORE-1905"><code>CIGNORE</code></a>: <a href="Control-Modes.html#Control-Modes">Control Modes</a></li>
<li><a href="CPU-Time.html#index-CLK_005fTCK-2608"><code>CLK_TCK</code></a>: <a href="CPU-Time.html#CPU-Time">CPU Time</a></li>
<li><a href="Control-Modes.html#index-CLOCAL-1888"><code>CLOCAL</code></a>: <a href="Control-Modes.html#Control-Modes">Control Modes</a></li>
<li><a href="CPU-Time.html#index-CLOCKS_005fPER_005fSEC-2607"><code>CLOCKS_PER_SEC</code></a>: <a href="CPU-Time.html#CPU-Time">CPU Time</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-CODESET-716"><code>CODESET</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="Utility-Limits.html#index-COLL_005fWEIGHTS_005fMAX-3671"><code>COLL_WEIGHTS_MAX</code></a>: <a href="Utility-Limits.html#Utility-Limits">Utility Limits</a></li>
<li><a href="Program-Error-Signals.html#index-COREFILE-2825"><code>COREFILE</code></a>: <a href="Program-Error-Signals.html#Program-Error-Signals">Program Error Signals</a></li>
<li><a href="CPU-Affinity.html#index-CPU_005fSETSIZE-2765"><code>CPU_SETSIZE</code></a>: <a href="CPU-Affinity.html#CPU-Affinity">CPU Affinity</a></li>
<li><a href="Control-Modes.html#index-CREAD-1893"><code>CREAD</code></a>: <a href="Control-Modes.html#Control-Modes">Control Modes</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-CRNCYSTR-769"><code>CRNCYSTR</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="Control-Modes.html#index-CRTS_005fIFLOW-1903"><code>CRTS_IFLOW</code></a>: <a href="Control-Modes.html#Control-Modes">Control Modes</a></li>
<li><a href="Control-Modes.html#index-CS5-1898"><code>CS5</code></a>: <a href="Control-Modes.html#Control-Modes">Control Modes</a></li>
<li><a href="Control-Modes.html#index-CS6-1899"><code>CS6</code></a>: <a href="Control-Modes.html#Control-Modes">Control Modes</a></li>
<li><a href="Control-Modes.html#index-CS7-1900"><code>CS7</code></a>: <a href="Control-Modes.html#Control-Modes">Control Modes</a></li>
<li><a href="Control-Modes.html#index-CS8-1901"><code>CS8</code></a>: <a href="Control-Modes.html#Control-Modes">Control Modes</a></li>
<li><a href="Control-Modes.html#index-CSIZE-1897"><code>CSIZE</code></a>: <a href="Control-Modes.html#Control-Modes">Control Modes</a></li>
<li><a href="Control-Modes.html#index-CSTOPB-1894"><code>CSTOPB</code></a>: <a href="Control-Modes.html#Control-Modes">Control Modes</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-CURRENCY_005fSYMBOL-768"><code>CURRENCY_SYMBOL</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-D_005fFMT-758"><code>D_FMT</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-D_005fT_005fFMT-757"><code>D_T_FMT</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-DAY_005f1-724"><code>DAY_1</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-DAY_005f2-725"><code>DAY_2</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-DAY_005f3-726"><code>DAY_3</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-DAY_005f4-727"><code>DAY_4</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-DAY_005f5-728"><code>DAY_5</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-DAY_005f6-729"><code>DAY_6</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-DAY_005f7-730"><code>DAY_7</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="Time-Zone-Functions.html#index-daylight-2677"><code>daylight</code></a>: <a href="Time-Zone-Functions.html#Time-Zone-Functions">Time Zone Functions</a></li>
<li><a href="Floating-Point-Parameters.html#index-DBL_005fDIG-3787"><code>DBL_DIG</code></a>: <a href="Floating-Point-Parameters.html#Floating-Point-Parameters">Floating Point Parameters</a></li>
<li><a href="Floating-Point-Parameters.html#index-DBL_005fEPSILON-3808"><code>DBL_EPSILON</code></a>: <a href="Floating-Point-Parameters.html#Floating-Point-Parameters">Floating Point Parameters</a></li>
<li><a href="Floating-Point-Parameters.html#index-DBL_005fMANT_005fDIG-3784"><code>DBL_MANT_DIG</code></a>: <a href="Floating-Point-Parameters.html#Floating-Point-Parameters">Floating Point Parameters</a></li>
<li><a href="Floating-Point-Parameters.html#index-DBL_005fMAX-3802"><code>DBL_MAX</code></a>: <a href="Floating-Point-Parameters.html#Floating-Point-Parameters">Floating Point Parameters</a></li>
<li><a href="Floating-Point-Parameters.html#index-DBL_005fMAX_005f10_005fEXP-3799"><code>DBL_MAX_10_EXP</code></a>: <a href="Floating-Point-Parameters.html#Floating-Point-Parameters">Floating Point Parameters</a></li>
<li><a href="Floating-Point-Parameters.html#index-DBL_005fMAX_005fEXP-3796"><code>DBL_MAX_EXP</code></a>: <a href="Floating-Point-Parameters.html#Floating-Point-Parameters">Floating Point Parameters</a></li>
<li><a href="Floating-Point-Parameters.html#index-DBL_005fMIN-3805"><code>DBL_MIN</code></a>: <a href="Floating-Point-Parameters.html#Floating-Point-Parameters">Floating Point Parameters</a></li>
<li><a href="Floating-Point-Parameters.html#index-DBL_005fMIN_005f10_005fEXP-3793"><code>DBL_MIN_10_EXP</code></a>: <a href="Floating-Point-Parameters.html#Floating-Point-Parameters">Floating Point Parameters</a></li>
<li><a href="Floating-Point-Parameters.html#index-DBL_005fMIN_005fEXP-3790"><code>DBL_MIN_EXP</code></a>: <a href="Floating-Point-Parameters.html#Floating-Point-Parameters">Floating Point Parameters</a></li>
<li><a href="XPG-Functions.html#index-DEAD_005fPROCESS-3373"><code>DEAD_PROCESS</code></a>: <a href="XPG-Functions.html#XPG-Functions">XPG Functions</a></li>
<li><a href="Manipulating-the-Database.html#index-DEAD_005fPROCESS-3348"><code>DEAD_PROCESS</code></a>: <a href="Manipulating-the-Database.html#Manipulating-the-Database">Manipulating the Database</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-DECIMAL_005fPOINT-789"><code>DECIMAL_POINT</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="DES-Encryption.html#index-DES_005fDECRYPT-3685"><code>DES_DECRYPT</code></a>: <a href="DES-Encryption.html#DES-Encryption">DES Encryption</a></li>
<li><a href="DES-Encryption.html#index-DES_005fENCRYPT-3684"><code>DES_ENCRYPT</code></a>: <a href="DES-Encryption.html#DES-Encryption">DES Encryption</a></li>
<li><a href="DES-Encryption.html#index-DES_005fHW-3686"><code>DES_HW</code></a>: <a href="DES-Encryption.html#DES-Encryption">DES Encryption</a></li>
<li><a href="DES-Encryption.html#index-DES_005fSW-3687"><code>DES_SW</code></a>: <a href="DES-Encryption.html#DES-Encryption">DES Encryption</a></li>
<li><a href="DES-Encryption.html#index-DESERR_005fBADPARAM-3691"><code>DESERR_BADPARAM</code></a>: <a href="DES-Encryption.html#DES-Encryption">DES Encryption</a></li>
<li><a href="DES-Encryption.html#index-DESERR_005fHWERROR-3690"><code>DESERR_HWERROR</code></a>: <a href="DES-Encryption.html#DES-Encryption">DES Encryption</a></li>
<li><a href="DES-Encryption.html#index-DESERR_005fNOHWDEVICE-3689"><code>DESERR_NOHWDEVICE</code></a>: <a href="DES-Encryption.html#DES-Encryption">DES Encryption</a></li>
<li><a href="DES-Encryption.html#index-DESERR_005fNONE-3688"><code>DESERR_NONE</code></a>: <a href="DES-Encryption.html#DES-Encryption">DES Encryption</a></li>
<li><a href="Directory-Entries.html#index-DT_005fBLK-1408"><code>DT_BLK</code></a>: <a href="Directory-Entries.html#Directory-Entries">Directory Entries</a></li>
<li><a href="Directory-Entries.html#index-DT_005fCHR-1407"><code>DT_CHR</code></a>: <a href="Directory-Entries.html#Directory-Entries">Directory Entries</a></li>
<li><a href="Directory-Entries.html#index-DT_005fDIR-1404"><code>DT_DIR</code></a>: <a href="Directory-Entries.html#Directory-Entries">Directory Entries</a></li>
<li><a href="Directory-Entries.html#index-DT_005fFIFO-1405"><code>DT_FIFO</code></a>: <a href="Directory-Entries.html#Directory-Entries">Directory Entries</a></li>
<li><a href="Directory-Entries.html#index-DT_005fREG-1403"><code>DT_REG</code></a>: <a href="Directory-Entries.html#Directory-Entries">Directory Entries</a></li>
<li><a href="Directory-Entries.html#index-DT_005fSOCK-1406"><code>DT_SOCK</code></a>: <a href="Directory-Entries.html#Directory-Entries">Directory Entries</a></li>
<li><a href="Directory-Entries.html#index-DT_005fUNKNOWN-1402"><code>DT_UNKNOWN</code></a>: <a href="Directory-Entries.html#Directory-Entries">Directory Entries</a></li>
<li><a href="Error-Codes.html#index-E2BIG-69"><code>E2BIG</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EACCES-75"><code>EACCES</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EADDRINUSE-110"><code>EADDRINUSE</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EADDRNOTAVAIL-111"><code>EADDRNOTAVAIL</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EADV-184"><code>EADV</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EAFNOSUPPORT-109"><code>EAFNOSUPPORT</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EAGAIN-97"><code>EAGAIN</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EALREADY-100"><code>EALREADY</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EAUTH-142"><code>EAUTH</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EBACKGROUND-147"><code>EBACKGROUND</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EBADE-174"><code>EBADE</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Line-Control.html#index-EBADF-2020"><code>EBADF</code></a>: <a href="Line-Control.html#Line-Control">Line Control</a></li>
<li><a href="Error-Codes.html#index-EBADF-71"><code>EBADF</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EBADFD-189"><code>EBADFD</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EBADMSG-153"><code>EBADMSG</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EBADR-175"><code>EBADR</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EBADRPC-135"><code>EBADRPC</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EBADRQC-178"><code>EBADRQC</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EBADSLT-179"><code>EBADSLT</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EBFONT-181"><code>EBFONT</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EBUSY-78"><code>EBUSY</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ECANCELED-164"><code>ECANCELED</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ECHILD-72"><code>ECHILD</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Local-Modes.html#index-ECHO-1907"><code>ECHO</code></a>: <a href="Local-Modes.html#Local-Modes">Local Modes</a></li>
<li><a href="Local-Modes.html#index-ECHOCTL-1914"><code>ECHOCTL</code></a>: <a href="Local-Modes.html#Local-Modes">Local Modes</a></li>
<li><a href="Local-Modes.html#index-ECHOE-1909"><code>ECHOE</code></a>: <a href="Local-Modes.html#Local-Modes">Local Modes</a></li>
<li><a href="Local-Modes.html#index-ECHOK-1911"><code>ECHOK</code></a>: <a href="Local-Modes.html#Local-Modes">Local Modes</a></li>
<li><a href="Local-Modes.html#index-ECHOKE-1912"><code>ECHOKE</code></a>: <a href="Local-Modes.html#Local-Modes">Local Modes</a></li>
<li><a href="Local-Modes.html#index-ECHONL-1913"><code>ECHONL</code></a>: <a href="Local-Modes.html#Local-Modes">Local Modes</a></li>
<li><a href="Local-Modes.html#index-ECHOPRT-1910"><code>ECHOPRT</code></a>: <a href="Local-Modes.html#Local-Modes">Local Modes</a></li>
<li><a href="Error-Codes.html#index-ECHRNG-166"><code>ECHRNG</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ECOMM-186"><code>ECOMM</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ECONNABORTED-115"><code>ECONNABORTED</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ECONNREFUSED-124"><code>ECONNREFUSED</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ECONNRESET-116"><code>ECONNRESET</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ED-149"><code>ED</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EDEADLK-73"><code>EDEADLK</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EDEADLOCK-180"><code>EDEADLOCK</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EDESTADDRREQ-120"><code>EDESTADDRREQ</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EDIED-148"><code>EDIED</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EDOM-95"><code>EDOM</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EDOTDOT-187"><code>EDOTDOT</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EDQUOT-132"><code>EDQUOT</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EEXIST-79"><code>EEXIST</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EFAULT-76"><code>EFAULT</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EFBIG-89"><code>EFBIG</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EFTYPE-141"><code>EFTYPE</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EGRATUITOUS-152"><code>EGRATUITOUS</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EGREGIOUS-150"><code>EGREGIOUS</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EHOSTDOWN-127"><code>EHOSTDOWN</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EHOSTUNREACH-128"><code>EHOSTUNREACH</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EIDRM-154"><code>EIDRM</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EIEIO-151"><code>EIEIO</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EILSEQ-146"><code>EILSEQ</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EINPROGRESS-99"><code>EINPROGRESS</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EINTR-66"><code>EINTR</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Line-Control.html#index-EINVAL-2022"><code>EINVAL</code></a>: <a href="Line-Control.html#Line-Control">Line Control</a></li>
<li><a href="Error-Codes.html#index-EINVAL-84"><code>EINVAL</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EIO-67"><code>EIO</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EISCONN-118"><code>EISCONN</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EISDIR-83"><code>EISDIR</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EISNAM-200"><code>EISNAM</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EKEYEXPIRED-205"><code>EKEYEXPIRED</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EKEYREJECTED-207"><code>EKEYREJECTED</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EKEYREVOKED-206"><code>EKEYREVOKED</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EL2HLT-173"><code>EL2HLT</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EL2NSYNC-167"><code>EL2NSYNC</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EL3HLT-168"><code>EL3HLT</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EL3RST-169"><code>EL3RST</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ELIBACC-191"><code>ELIBACC</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ELIBBAD-192"><code>ELIBBAD</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ELIBEXEC-195"><code>ELIBEXEC</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ELIBMAX-194"><code>ELIBMAX</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ELIBSCN-193"><code>ELIBSCN</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ELNRNG-170"><code>ELNRNG</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ELOOP-125"><code>ELOOP</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EMEDIUMTYPE-203"><code>EMEDIUMTYPE</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EMFILE-85"><code>EMFILE</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EMLINK-93"><code>EMLINK</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="XPG-Functions.html#index-EMPTY-3365"><code>EMPTY</code></a>: <a href="XPG-Functions.html#XPG-Functions">XPG Functions</a></li>
<li><a href="Manipulating-the-Database.html#index-EMPTY-3340"><code>EMPTY</code></a>: <a href="Manipulating-the-Database.html#Manipulating-the-Database">Manipulating the Database</a></li>
<li><a href="Error-Codes.html#index-EMSGSIZE-102"><code>EMSGSIZE</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EMULTIHOP-155"><code>EMULTIHOP</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENAMETOOLONG-126"><code>ENAMETOOLONG</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENAVAIL-199"><code>ENAVAIL</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENEEDAUTH-143"><code>ENEEDAUTH</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENETDOWN-112"><code>ENETDOWN</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENETRESET-114"><code>ENETRESET</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENETUNREACH-113"><code>ENETUNREACH</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENFILE-86"><code>ENFILE</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENOANO-177"><code>ENOANO</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENOBUFS-117"><code>ENOBUFS</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENOCSI-172"><code>ENOCSI</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENODATA-156"><code>ENODATA</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENODEV-81"><code>ENODEV</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENOENT-64"><code>ENOENT</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENOEXEC-70"><code>ENOEXEC</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENOKEY-204"><code>ENOKEY</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENOLCK-140"><code>ENOLCK</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENOLINK-157"><code>ENOLINK</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENOMEDIUM-202"><code>ENOMEDIUM</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENOMEM-74"><code>ENOMEM</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENOMSG-158"><code>ENOMSG</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENONET-182"><code>ENONET</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENOPKG-183"><code>ENOPKG</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENOPROTOOPT-104"><code>ENOPROTOOPT</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENOSPC-90"><code>ENOSPC</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENOSR-159"><code>ENOSR</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENOSTR-160"><code>ENOSTR</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENOSYS-144"><code>ENOSYS</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENOTBLK-77"><code>ENOTBLK</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENOTCONN-119"><code>ENOTCONN</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENOTDIR-82"><code>ENOTDIR</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENOTEMPTY-129"><code>ENOTEMPTY</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENOTNAM-198"><code>ENOTNAM</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENOTRECOVERABLE-209"><code>ENOTRECOVERABLE</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENOTSOCK-101"><code>ENOTSOCK</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENOTSUP-145"><code>ENOTSUP</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Line-Control.html#index-ENOTTY-2021"><code>ENOTTY</code></a>: <a href="Line-Control.html#Line-Control">Line Control</a></li>
<li><a href="Error-Codes.html#index-ENOTTY-87"><code>ENOTTY</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ENOTUNIQ-188"><code>ENOTUNIQ</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Environment-Access.html#index-environ-3108"><code>environ</code></a>: <a href="Environment-Access.html#Environment-Access">Environment Access</a></li>
<li><a href="Error-Codes.html#index-ENXIO-68"><code>ENXIO</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="EOF-and-Errors.html#index-EOF-1096"><code>EOF</code></a>: <a href="EOF-and-Errors.html#EOF-and-Errors">EOF and Errors</a></li>
<li><a href="Error-Codes.html#index-EOPNOTSUPP-107"><code>EOPNOTSUPP</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EOVERFLOW-161"><code>EOVERFLOW</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EOWNERDEAD-208"><code>EOWNERDEAD</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EPERM-63"><code>EPERM</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EPFNOSUPPORT-108"><code>EPFNOSUPPORT</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EPIPE-94"><code>EPIPE</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EPROCLIM-130"><code>EPROCLIM</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EPROCUNAVAIL-139"><code>EPROCUNAVAIL</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EPROGMISMATCH-138"><code>EPROGMISMATCH</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EPROGUNAVAIL-137"><code>EPROGUNAVAIL</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EPROTO-162"><code>EPROTO</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EPROTONOSUPPORT-105"><code>EPROTONOSUPPORT</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EPROTOTYPE-103"><code>EPROTOTYPE</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Utility-Limits.html#index-EQUIV_005fCLASS_005fMAX-3674"><code>EQUIV_CLASS_MAX</code></a>: <a href="Utility-Limits.html#Utility-Limits">Utility Limits</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-ERA-761"><code>ERA</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-ERA_005fD_005fFMT-764"><code>ERA_D_FMT</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-ERA_005fD_005fT_005fFMT-763"><code>ERA_D_T_FMT</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-ERA_005fT_005fFMT-765"><code>ERA_T_FMT</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-ERA_005fYEAR-762"><code>ERA_YEAR</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="Error-Codes.html#index-ERANGE-96"><code>ERANGE</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EREMCHG-190"><code>EREMCHG</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EREMOTE-134"><code>EREMOTE</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EREMOTEIO-201"><code>EREMOTEIO</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ERESTART-165"><code>ERESTART</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ERFKILL-210"><code>ERFKILL</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EROFS-92"><code>EROFS</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ERPCMISMATCH-136"><code>ERPCMISMATCH</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Checking-for-Errors.html#index-errno-60"><code>errno</code></a>: <a href="Checking-for-Errors.html#Checking-for-Errors">Checking for Errors</a></li>
<li><a href="Error-Messages.html#index-error_005fmessage_005fcount-221"><code>error_message_count</code></a>: <a href="Error-Messages.html#Error-Messages">Error Messages</a></li>
<li><a href="Error-Messages.html#index-error_005fone_005fper_005fline-222"><code>error_one_per_line</code></a>: <a href="Error-Messages.html#Error-Messages">Error Messages</a></li>
<li><a href="Error-Codes.html#index-ESHUTDOWN-121"><code>ESHUTDOWN</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ESOCKTNOSUPPORT-106"><code>ESOCKTNOSUPPORT</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ESPIPE-91"><code>ESPIPE</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ESRCH-65"><code>ESRCH</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ESRMNT-185"><code>ESRMNT</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ESTALE-133"><code>ESTALE</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ESTRPIPE-196"><code>ESTRPIPE</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="NSS-Basics.html#index-ethers-3263"><code>ethers</code></a>: <a href="NSS-Basics.html#NSS-Basics">NSS Basics</a></li>
<li><a href="Error-Codes.html#index-ETIME-163"><code>ETIME</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ETIMEDOUT-123"><code>ETIMEDOUT</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ETOOMANYREFS-122"><code>ETOOMANYREFS</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-ETXTBSY-88"><code>ETXTBSY</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EUCLEAN-197"><code>EUCLEAN</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EUNATCH-171"><code>EUNATCH</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EUSERS-131"><code>EUSERS</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EWOULDBLOCK-98"><code>EWOULDBLOCK</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EXDEV-80"><code>EXDEV</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Error-Codes.html#index-EXFULL-176"><code>EXFULL</code></a>: <a href="Error-Codes.html#Error-Codes">Error Codes</a></li>
<li><a href="Exit-Status.html#index-EXIT_005fFAILURE-3138"><code>EXIT_FAILURE</code></a>: <a href="Exit-Status.html#Exit-Status">Exit Status</a></li>
<li><a href="Exit-Status.html#index-EXIT_005fSUCCESS-3137"><code>EXIT_SUCCESS</code></a>: <a href="Exit-Status.html#Exit-Status">Exit Status</a></li>
<li><a href="Utility-Limits.html#index-EXPR_005fNEST_005fMAX-3672"><code>EXPR_NEST_MAX</code></a>: <a href="Utility-Limits.html#Utility-Limits">Utility Limits</a></li>
<li><a href="Line-Speed.html#index-EXTA-1954"><code>EXTA</code></a>: <a href="Line-Speed.html#Line-Speed">Line Speed</a></li>
<li><a href="Line-Speed.html#index-EXTB-1955"><code>EXTB</code></a>: <a href="Line-Speed.html#Line-Speed">Line Speed</a></li>
<li><a href="Duplicating-Descriptors.html#index-F_005fDUPFD-1321"><code>F_DUPFD</code></a>: <a href="Duplicating-Descriptors.html#Duplicating-Descriptors">Duplicating Descriptors</a></li>
<li><a href="Descriptor-Flags.html#index-F_005fGETFD-1324"><code>F_GETFD</code></a>: <a href="Descriptor-Flags.html#Descriptor-Flags">Descriptor Flags</a></li>
<li><a href="Getting-File-Status-Flags.html#index-F_005fGETFL-1362"><code>F_GETFL</code></a>: <a href="Getting-File-Status-Flags.html#Getting-File-Status-Flags">Getting File Status Flags</a></li>
<li><a href="File-Locks.html#index-F_005fGETLK-1372"><code>F_GETLK</code></a>: <a href="File-Locks.html#File-Locks">File Locks</a></li>
<li><a href="Interrupt-Input.html#index-F_005fGETOWN-1380"><code>F_GETOWN</code></a>: <a href="Interrupt-Input.html#Interrupt-Input">Interrupt Input</a></li>
<li><a href="Testing-File-Access.html#index-F_005fOK-1580"><code>F_OK</code></a>: <a href="Testing-File-Access.html#Testing-File-Access">Testing File Access</a></li>
<li><a href="File-Locks.html#index-F_005fRDLCK-1375"><code>F_RDLCK</code></a>: <a href="File-Locks.html#File-Locks">File Locks</a></li>
<li><a href="Descriptor-Flags.html#index-F_005fSETFD-1325"><code>F_SETFD</code></a>: <a href="Descriptor-Flags.html#Descriptor-Flags">Descriptor Flags</a></li>
<li><a href="Getting-File-Status-Flags.html#index-F_005fSETFL-1363"><code>F_SETFL</code></a>: <a href="Getting-File-Status-Flags.html#Getting-File-Status-Flags">Getting File Status Flags</a></li>
<li><a href="File-Locks.html#index-F_005fSETLK-1373"><code>F_SETLK</code></a>: <a href="File-Locks.html#File-Locks">File Locks</a></li>
<li><a href="File-Locks.html#index-F_005fSETLKW-1374"><code>F_SETLKW</code></a>: <a href="File-Locks.html#File-Locks">File Locks</a></li>
<li><a href="Interrupt-Input.html#index-F_005fSETOWN-1381"><code>F_SETOWN</code></a>: <a href="Interrupt-Input.html#Interrupt-Input">Interrupt Input</a></li>
<li><a href="File-Locks.html#index-F_005fUNLCK-1377"><code>F_UNLCK</code></a>: <a href="File-Locks.html#File-Locks">File Locks</a></li>
<li><a href="File-Locks.html#index-F_005fWRLCK-1376"><code>F_WRLCK</code></a>: <a href="File-Locks.html#File-Locks">File Locks</a></li>
<li><a href="Descriptor-Flags.html#index-FD_005fCLOEXEC-1326"><code>FD_CLOEXEC</code></a>: <a href="Descriptor-Flags.html#Descriptor-Flags">Descriptor Flags</a></li>
<li><a href="Waiting-for-I_002fO.html#index-FD_005fSETSIZE-1277"><code>FD_SETSIZE</code></a>: <a href="Waiting-for-I_002fO.html#Waiting-for-I_002fO">Waiting for I/O</a></li>
<li><a href="Control-Functions.html#index-FE_005fDFL_005fENV-2397"><code>FE_DFL_ENV</code></a>: <a href="Control-Functions.html#Control-Functions">Control Functions</a></li>
<li><a href="Status-bit-operations.html#index-FE_005fDIVBYZERO-2374"><code>FE_DIVBYZERO</code></a>: <a href="Status-bit-operations.html#Status-bit-operations">Status bit operations</a></li>
<li><a href="Rounding.html#index-FE_005fDOWNWARD-2391"><code>FE_DOWNWARD</code></a>: <a href="Rounding.html#Rounding">Rounding</a></li>
<li><a href="Status-bit-operations.html#index-FE_005fINEXACT-2373"><code>FE_INEXACT</code></a>: <a href="Status-bit-operations.html#Status-bit-operations">Status bit operations</a></li>
<li><a href="Status-bit-operations.html#index-FE_005fINVALID-2377"><code>FE_INVALID</code></a>: <a href="Status-bit-operations.html#Status-bit-operations">Status bit operations</a></li>
<li><a href="Control-Functions.html#index-FE_005fNOMASK_005fENV-2398"><code>FE_NOMASK_ENV</code></a>: <a href="Control-Functions.html#Control-Functions">Control Functions</a></li>
<li><a href="Status-bit-operations.html#index-FE_005fOVERFLOW-2376"><code>FE_OVERFLOW</code></a>: <a href="Status-bit-operations.html#Status-bit-operations">Status bit operations</a></li>
<li><a href="Rounding.html#index-FE_005fTONEAREST-2389"><code>FE_TONEAREST</code></a>: <a href="Rounding.html#Rounding">Rounding</a></li>
<li><a href="Rounding.html#index-FE_005fTOWARDZERO-2392"><code>FE_TOWARDZERO</code></a>: <a href="Rounding.html#Rounding">Rounding</a></li>
<li><a href="Status-bit-operations.html#index-FE_005fUNDERFLOW-2375"><code>FE_UNDERFLOW</code></a>: <a href="Status-bit-operations.html#Status-bit-operations">Status bit operations</a></li>
<li><a href="Rounding.html#index-FE_005fUPWARD-2390"><code>FE_UPWARD</code></a>: <a href="Rounding.html#Rounding">Rounding</a></li>
<li><a href="Limits-for-Files.html#index-FILENAME_005fMAX-3659"><code>FILENAME_MAX</code></a>: <a href="Limits-for-Files.html#Limits-for-Files">Limits for Files</a></li>
<li><a href="Floating-Point-Parameters.html#index-FLT_005fDIG-3786"><code>FLT_DIG</code></a>: <a href="Floating-Point-Parameters.html#Floating-Point-Parameters">Floating Point Parameters</a></li>
<li><a href="Floating-Point-Parameters.html#index-FLT_005fEPSILON-3807"><code>FLT_EPSILON</code></a>: <a href="Floating-Point-Parameters.html#Floating-Point-Parameters">Floating Point Parameters</a></li>
<li><a href="Floating-Point-Parameters.html#index-FLT_005fMANT_005fDIG-3783"><code>FLT_MANT_DIG</code></a>: <a href="Floating-Point-Parameters.html#Floating-Point-Parameters">Floating Point Parameters</a></li>
<li><a href="Floating-Point-Parameters.html#index-FLT_005fMAX-3801"><code>FLT_MAX</code></a>: <a href="Floating-Point-Parameters.html#Floating-Point-Parameters">Floating Point Parameters</a></li>
<li><a href="Floating-Point-Parameters.html#index-FLT_005fMAX_005f10_005fEXP-3798"><code>FLT_MAX_10_EXP</code></a>: <a href="Floating-Point-Parameters.html#Floating-Point-Parameters">Floating Point Parameters</a></li>
<li><a href="Floating-Point-Parameters.html#index-FLT_005fMAX_005fEXP-3795"><code>FLT_MAX_EXP</code></a>: <a href="Floating-Point-Parameters.html#Floating-Point-Parameters">Floating Point Parameters</a></li>
<li><a href="Floating-Point-Parameters.html#index-FLT_005fMIN-3804"><code>FLT_MIN</code></a>: <a href="Floating-Point-Parameters.html#Floating-Point-Parameters">Floating Point Parameters</a></li>
<li><a href="Floating-Point-Parameters.html#index-FLT_005fMIN_005f10_005fEXP-3792"><code>FLT_MIN_10_EXP</code></a>: <a href="Floating-Point-Parameters.html#Floating-Point-Parameters">Floating Point Parameters</a></li>
<li><a href="Floating-Point-Parameters.html#index-FLT_005fMIN_005fEXP-3789"><code>FLT_MIN_EXP</code></a>: <a href="Floating-Point-Parameters.html#Floating-Point-Parameters">Floating Point Parameters</a></li>
<li><a href="Floating-Point-Parameters.html#index-FLT_005fRADIX-3782"><code>FLT_RADIX</code></a>: <a href="Floating-Point-Parameters.html#Floating-Point-Parameters">Floating Point Parameters</a></li>
<li><a href="Floating-Point-Parameters.html#index-FLT_005fROUNDS-3781"><code>FLT_ROUNDS</code></a>: <a href="Floating-Point-Parameters.html#Floating-Point-Parameters">Floating Point Parameters</a></li>
<li><a href="Local-Modes.html#index-FLUSHO-1921"><code>FLUSHO</code></a>: <a href="Local-Modes.html#Local-Modes">Local Modes</a></li>
<li><a href="Opening-Streams.html#index-FOPEN_005fMAX-933"><code>FOPEN_MAX</code></a>: <a href="Opening-Streams.html#Opening-Streams">Opening Streams</a></li>
<li><a href="Misc-FP-Arithmetic.html#index-FP_005fFAST_005fFMA-2520"><code>FP_FAST_FMA</code></a>: <a href="Misc-FP-Arithmetic.html#Misc-FP-Arithmetic">Misc FP Arithmetic</a></li>
<li><a href="Exponents-and-Logarithms.html#index-FP_005fILOGB0-2161"><code>FP_ILOGB0</code></a>: <a href="Exponents-and-Logarithms.html#Exponents-and-Logarithms">Exponents and Logarithms</a></li>
<li><a href="Exponents-and-Logarithms.html#index-FP_005fILOGBNAN-2162"><code>FP_ILOGBNAN</code></a>: <a href="Exponents-and-Logarithms.html#Exponents-and-Logarithms">Exponents and Logarithms</a></li>
<li><a href="Floating-Point-Classes.html#index-FP_005fINFINITE-2343"><code>FP_INFINITE</code></a>: <a href="Floating-Point-Classes.html#Floating-Point-Classes">Floating Point Classes</a></li>
<li><a href="Floating-Point-Classes.html#index-FP_005fNAN-2342"><code>FP_NAN</code></a>: <a href="Floating-Point-Classes.html#Floating-Point-Classes">Floating Point Classes</a></li>
<li><a href="Floating-Point-Classes.html#index-FP_005fNORMAL-2346"><code>FP_NORMAL</code></a>: <a href="Floating-Point-Classes.html#Floating-Point-Classes">Floating Point Classes</a></li>
<li><a href="Floating-Point-Classes.html#index-FP_005fSUBNORMAL-2345"><code>FP_SUBNORMAL</code></a>: <a href="Floating-Point-Classes.html#Floating-Point-Classes">Floating Point Classes</a></li>
<li><a href="Floating-Point-Classes.html#index-FP_005fZERO-2344"><code>FP_ZERO</code></a>: <a href="Floating-Point-Classes.html#Floating-Point-Classes">Floating Point Classes</a></li>
<li><a href="Program-Error-Signals.html#index-FPE_005fDECOVF_005fTRAP-2835"><code>FPE_DECOVF_TRAP</code></a>: <a href="Program-Error-Signals.html#Program-Error-Signals">Program Error Signals</a></li>
<li><a href="Program-Error-Signals.html#index-FPE_005fFLTDIV_005fTRAP-2833"><code>FPE_FLTDIV_TRAP</code></a>: <a href="Program-Error-Signals.html#Program-Error-Signals">Program Error Signals</a></li>
<li><a href="Program-Error-Signals.html#index-FPE_005fFLTOVF_005fTRAP-2832"><code>FPE_FLTOVF_TRAP</code></a>: <a href="Program-Error-Signals.html#Program-Error-Signals">Program Error Signals</a></li>
<li><a href="Program-Error-Signals.html#index-FPE_005fFLTUND_005fTRAP-2834"><code>FPE_FLTUND_TRAP</code></a>: <a href="Program-Error-Signals.html#Program-Error-Signals">Program Error Signals</a></li>
<li><a href="Program-Error-Signals.html#index-FPE_005fINTDIV_005fTRAP-2830"><code>FPE_INTDIV_TRAP</code></a>: <a href="Program-Error-Signals.html#Program-Error-Signals">Program Error Signals</a></li>
<li><a href="Program-Error-Signals.html#index-FPE_005fINTOVF_005fTRAP-2829"><code>FPE_INTOVF_TRAP</code></a>: <a href="Program-Error-Signals.html#Program-Error-Signals">Program Error Signals</a></li>
<li><a href="Program-Error-Signals.html#index-FPE_005fSUBRNG_005fTRAP-2831"><code>FPE_SUBRNG_TRAP</code></a>: <a href="Program-Error-Signals.html#Program-Error-Signals">Program Error Signals</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-FRAC_005fDIGITS-776"><code>FRAC_DIGITS</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="Streams-and-Threads.html#index-FSETLOCKING_005fBYCALLER-950"><code>FSETLOCKING_BYCALLER</code></a>: <a href="Streams-and-Threads.html#Streams-and-Threads">Streams and Threads</a></li>
<li><a href="Streams-and-Threads.html#index-FSETLOCKING_005fINTERNAL-949"><code>FSETLOCKING_INTERNAL</code></a>: <a href="Streams-and-Threads.html#Streams-and-Threads">Streams and Threads</a></li>
<li><a href="Streams-and-Threads.html#index-FSETLOCKING_005fQUERY-951"><code>FSETLOCKING_QUERY</code></a>: <a href="Streams-and-Threads.html#Streams-and-Threads">Streams and Threads</a></li>
<li><a href="Mount-Information.html#index-FSTAB-3461"><code>FSTAB</code></a>: <a href="Mount-Information.html#Mount-Information">Mount Information</a></li>
<li><a href="fstab.html#index-FSTAB_005fRO-3467"><code>FSTAB_RO</code></a>: <a href="fstab.html#fstab">fstab</a></li>
<li><a href="fstab.html#index-FSTAB_005fRQ-3466"><code>FSTAB_RQ</code></a>: <a href="fstab.html#fstab">fstab</a></li>
<li><a href="fstab.html#index-FSTAB_005fRW-3465"><code>FSTAB_RW</code></a>: <a href="fstab.html#fstab">fstab</a></li>
<li><a href="fstab.html#index-FSTAB_005fSW-3468"><code>FSTAB_SW</code></a>: <a href="fstab.html#fstab">fstab</a></li>
<li><a href="fstab.html#index-FSTAB_005fXX-3469"><code>FSTAB_XX</code></a>: <a href="fstab.html#fstab">fstab</a></li>
<li><a href="Working-with-Directory-Trees.html#index-FTW_005fACTIONRETVAL-1454"><code>FTW_ACTIONRETVAL</code></a>: <a href="Working-with-Directory-Trees.html#Working-with-Directory-Trees">Working with Directory Trees</a></li>
<li><a href="Working-with-Directory-Trees.html#index-FTW_005fCHDIR-1452"><code>FTW_CHDIR</code></a>: <a href="Working-with-Directory-Trees.html#Working-with-Directory-Trees">Working with Directory Trees</a></li>
<li><a href="Working-with-Directory-Trees.html#index-FTW_005fD-1437"><code>FTW_D</code></a>: <a href="Working-with-Directory-Trees.html#Working-with-Directory-Trees">Working with Directory Trees</a></li>
<li><a href="Working-with-Directory-Trees.html#index-FTW_005fDEPTH-1453"><code>FTW_DEPTH</code></a>: <a href="Working-with-Directory-Trees.html#Working-with-Directory-Trees">Working with Directory Trees</a></li>
<li><a href="Working-with-Directory-Trees.html#index-FTW_005fDNR-1439"><code>FTW_DNR</code></a>: <a href="Working-with-Directory-Trees.html#Working-with-Directory-Trees">Working with Directory Trees</a></li>
<li><a href="Working-with-Directory-Trees.html#index-FTW_005fDP-1443"><code>FTW_DP</code></a>: <a href="Working-with-Directory-Trees.html#Working-with-Directory-Trees">Working with Directory Trees</a></li>
<li><a href="Working-with-Directory-Trees.html#index-FTW_005fF-1436"><code>FTW_F</code></a>: <a href="Working-with-Directory-Trees.html#Working-with-Directory-Trees">Working with Directory Trees</a></li>
<li><a href="Working-with-Directory-Trees.html#index-FTW_005fMOUNT-1451"><code>FTW_MOUNT</code></a>: <a href="Working-with-Directory-Trees.html#Working-with-Directory-Trees">Working with Directory Trees</a></li>
<li><a href="Working-with-Directory-Trees.html#index-FTW_005fNS-1438"><code>FTW_NS</code></a>: <a href="Working-with-Directory-Trees.html#Working-with-Directory-Trees">Working with Directory Trees</a></li>
<li><a href="Working-with-Directory-Trees.html#index-FTW_005fPHYS-1450"><code>FTW_PHYS</code></a>: <a href="Working-with-Directory-Trees.html#Working-with-Directory-Trees">Working with Directory Trees</a></li>
<li><a href="Working-with-Directory-Trees.html#index-FTW_005fSL-1440"><code>FTW_SL</code></a>: <a href="Working-with-Directory-Trees.html#Working-with-Directory-Trees">Working with Directory Trees</a></li>
<li><a href="Working-with-Directory-Trees.html#index-FTW_005fSLN-1444"><code>FTW_SLN</code></a>: <a href="Working-with-Directory-Trees.html#Working-with-Directory-Trees">Working with Directory Trees</a></li>
<li><a href="General-Time-String-Parsing.html#index-getdate_005ferr-2664"><code>getdate_err</code></a>: <a href="General-Time-String-Parsing.html#General-Time-String-Parsing">General Time String Parsing</a></li>
<li><a href="Calling-Glob.html#index-GLOB_005fABORTED-856"><code>GLOB_ABORTED</code></a>: <a href="Calling-Glob.html#Calling-Glob">Calling Glob</a></li>
<li><a href="More-Flags-for-Globbing.html#index-GLOB_005fALTDIRFUNC-869"><code>GLOB_ALTDIRFUNC</code></a>: <a href="More-Flags-for-Globbing.html#More-Flags-for-Globbing">More Flags for Globbing</a></li>
<li><a href="Flags-for-Globbing.html#index-GLOB_005fAPPEND-860"><code>GLOB_APPEND</code></a>: <a href="Flags-for-Globbing.html#Flags-for-Globbing">Flags for Globbing</a></li>
<li><a href="More-Flags-for-Globbing.html#index-GLOB_005fBRACE-870"><code>GLOB_BRACE</code></a>: <a href="More-Flags-for-Globbing.html#More-Flags-for-Globbing">More Flags for Globbing</a></li>
<li><a href="Flags-for-Globbing.html#index-GLOB_005fDOOFFS-861"><code>GLOB_DOOFFS</code></a>: <a href="Flags-for-Globbing.html#Flags-for-Globbing">Flags for Globbing</a></li>
<li><a href="Flags-for-Globbing.html#index-GLOB_005fERR-862"><code>GLOB_ERR</code></a>: <a href="Flags-for-Globbing.html#Flags-for-Globbing">Flags for Globbing</a></li>
<li><a href="More-Flags-for-Globbing.html#index-GLOB_005fMAGCHAR-868"><code>GLOB_MAGCHAR</code></a>: <a href="More-Flags-for-Globbing.html#More-Flags-for-Globbing">More Flags for Globbing</a></li>
<li><a href="Flags-for-Globbing.html#index-GLOB_005fMARK-863"><code>GLOB_MARK</code></a>: <a href="Flags-for-Globbing.html#Flags-for-Globbing">Flags for Globbing</a></li>
<li><a href="Flags-for-Globbing.html#index-GLOB_005fNOCHECK-864"><code>GLOB_NOCHECK</code></a>: <a href="Flags-for-Globbing.html#Flags-for-Globbing">Flags for Globbing</a></li>
<li><a href="Flags-for-Globbing.html#index-GLOB_005fNOESCAPE-866"><code>GLOB_NOESCAPE</code></a>: <a href="Flags-for-Globbing.html#Flags-for-Globbing">Flags for Globbing</a></li>
<li><a href="More-Flags-for-Globbing.html#index-GLOB_005fNOMAGIC-871"><code>GLOB_NOMAGIC</code></a>: <a href="More-Flags-for-Globbing.html#More-Flags-for-Globbing">More Flags for Globbing</a></li>
<li><a href="Calling-Glob.html#index-GLOB_005fNOMATCH-857"><code>GLOB_NOMATCH</code></a>: <a href="Calling-Glob.html#Calling-Glob">Calling Glob</a></li>
<li><a href="Flags-for-Globbing.html#index-GLOB_005fNOSORT-865"><code>GLOB_NOSORT</code></a>: <a href="Flags-for-Globbing.html#Flags-for-Globbing">Flags for Globbing</a></li>
<li><a href="Calling-Glob.html#index-GLOB_005fNOSPACE-858"><code>GLOB_NOSPACE</code></a>: <a href="Calling-Glob.html#Calling-Glob">Calling Glob</a></li>
<li><a href="More-Flags-for-Globbing.html#index-GLOB_005fONLYDIR-874"><code>GLOB_ONLYDIR</code></a>: <a href="More-Flags-for-Globbing.html#More-Flags-for-Globbing">More Flags for Globbing</a></li>
<li><a href="More-Flags-for-Globbing.html#index-GLOB_005fPERIOD-867"><code>GLOB_PERIOD</code></a>: <a href="More-Flags-for-Globbing.html#More-Flags-for-Globbing">More Flags for Globbing</a></li>
<li><a href="More-Flags-for-Globbing.html#index-GLOB_005fTILDE-872"><code>GLOB_TILDE</code></a>: <a href="More-Flags-for-Globbing.html#More-Flags-for-Globbing">More Flags for Globbing</a></li>
<li><a href="More-Flags-for-Globbing.html#index-GLOB_005fTILDE_005fCHECK-873"><code>GLOB_TILDE_CHECK</code></a>: <a href="More-Flags-for-Globbing.html#More-Flags-for-Globbing">More Flags for Globbing</a></li>
<li><a href="NSS-Basics.html#index-group-3264"><code>group</code></a>: <a href="NSS-Basics.html#NSS-Basics">NSS Basics</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-GROUPING-793"><code>GROUPING</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="Host-Names.html#index-h_005ferrno-1721"><code>h_errno</code></a>: <a href="Host-Names.html#Host-Names">Host Names</a></li>
<li><a href="Host-Names.html#index-HOST_005fNOT_005fFOUND-1722"><code>HOST_NOT_FOUND</code></a>: <a href="Host-Names.html#Host-Names">Host Names</a></li>
<li><a href="NSS-Basics.html#index-hosts-3265"><code>hosts</code></a>: <a href="NSS-Basics.html#NSS-Basics">NSS Basics</a></li>
<li><a href="Math-Error-Reporting.html#index-HUGE_005fVAL-2386"><code>HUGE_VAL</code></a>: <a href="Math-Error-Reporting.html#Math-Error-Reporting">Math Error Reporting</a></li>
<li><a href="Math-Error-Reporting.html#index-HUGE_005fVALF-2387"><code>HUGE_VALF</code></a>: <a href="Math-Error-Reporting.html#Math-Error-Reporting">Math Error Reporting</a></li>
<li><a href="Math-Error-Reporting.html#index-HUGE_005fVALL-2388"><code>HUGE_VALL</code></a>: <a href="Math-Error-Reporting.html#Math-Error-Reporting">Math Error Reporting</a></li>
<li><a href="Control-Modes.html#index-HUPCL-1892"><code>HUPCL</code></a>: <a href="Control-Modes.html#Control-Modes">Control Modes</a></li>
<li><a href="Complex-Numbers.html#index-I-2524"><code>I</code></a>: <a href="Complex-Numbers.html#Complex-Numbers">Complex Numbers</a></li>
<li><a href="Local-Modes.html#index-ICANON-1906"><code>ICANON</code></a>: <a href="Local-Modes.html#Local-Modes">Local Modes</a></li>
<li><a href="Input-Modes.html#index-ICRNL-1878"><code>ICRNL</code></a>: <a href="Input-Modes.html#Input-Modes">Input Modes</a></li>
<li><a href="Local-Modes.html#index-IEXTEN-1917"><code>IEXTEN</code></a>: <a href="Local-Modes.html#Local-Modes">Local Modes</a></li>
<li><a href="Interface-Naming.html#index-IFNAMSIZ-1666"><code>IFNAMSIZ</code></a>: <a href="Interface-Naming.html#Interface-Naming">Interface Naming</a></li>
<li><a href="Input-Modes.html#index-IGNBRK-1874"><code>IGNBRK</code></a>: <a href="Input-Modes.html#Input-Modes">Input Modes</a></li>
<li><a href="Input-Modes.html#index-IGNCR-1877"><code>IGNCR</code></a>: <a href="Input-Modes.html#Input-Modes">Input Modes</a></li>
<li><a href="Input-Modes.html#index-IGNPAR-1871"><code>IGNPAR</code></a>: <a href="Input-Modes.html#Input-Modes">Input Modes</a></li>
<li><a href="Input-Modes.html#index-IMAXBEL-1883"><code>IMAXBEL</code></a>: <a href="Input-Modes.html#Input-Modes">Input Modes</a></li>
<li><a href="Host-Address-Data-Type.html#index-in6addr_005fany-1701"><code>in6addr_any</code></a>: <a href="Host-Address-Data-Type.html#Host-Address-Data-Type">Host Address Data Type</a></li>
<li><a href="Host-Address-Data-Type.html#index-in6addr_005floopback-1700"><code>in6addr_loopback</code></a>: <a href="Host-Address-Data-Type.html#Host-Address-Data-Type">Host Address Data Type</a></li>
<li><a href="Host-Address-Data-Type.html#index-INADDR_005fANY-1696"><code>INADDR_ANY</code></a>: <a href="Host-Address-Data-Type.html#Host-Address-Data-Type">Host Address Data Type</a></li>
<li><a href="Host-Address-Data-Type.html#index-INADDR_005fBROADCAST-1697"><code>INADDR_BROADCAST</code></a>: <a href="Host-Address-Data-Type.html#Host-Address-Data-Type">Host Address Data Type</a></li>
<li><a href="Host-Address-Data-Type.html#index-INADDR_005fLOOPBACK-1695"><code>INADDR_LOOPBACK</code></a>: <a href="Host-Address-Data-Type.html#Host-Address-Data-Type">Host Address Data Type</a></li>
<li><a href="Host-Address-Data-Type.html#index-INADDR_005fNONE-1698"><code>INADDR_NONE</code></a>: <a href="Host-Address-Data-Type.html#Host-Address-Data-Type">Host Address Data Type</a></li>
<li><a href="Infinity-and-NaN.html#index-INFINITY-2371"><code>INFINITY</code></a>: <a href="Infinity-and-NaN.html#Infinity-and-NaN">Infinity and NaN</a></li>
<li><a href="XPG-Functions.html#index-INIT_005fPROCESS-3370"><code>INIT_PROCESS</code></a>: <a href="XPG-Functions.html#XPG-Functions">XPG Functions</a></li>
<li><a href="Manipulating-the-Database.html#index-INIT_005fPROCESS-3345"><code>INIT_PROCESS</code></a>: <a href="Manipulating-the-Database.html#Manipulating-the-Database">Manipulating the Database</a></li>
<li><a href="Input-Modes.html#index-INLCR-1879"><code>INLCR</code></a>: <a href="Input-Modes.html#Input-Modes">Input Modes</a></li>
<li><a href="Input-Modes.html#index-INPCK-1869"><code>INPCK</code></a>: <a href="Input-Modes.html#Input-Modes">Input Modes</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-INT_005fCURR_005fSYMBOL-767"><code>INT_CURR_SYMBOL</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-INT_005fFRAC_005fDIGITS-775"><code>INT_FRAC_DIGITS</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="Range-of-Type.html#index-INT_005fMAX-3757"><code>INT_MAX</code></a>: <a href="Range-of-Type.html#Range-of-Type">Range of Type</a></li>
<li><a href="Range-of-Type.html#index-INT_005fMIN-3756"><code>INT_MIN</code></a>: <a href="Range-of-Type.html#Range-of-Type">Range of Type</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-INT_005fN_005fCS_005fPRECEDES-785"><code>INT_N_CS_PRECEDES</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-INT_005fN_005fSEP_005fBY_005fSPACE-786"><code>INT_N_SEP_BY_SPACE</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-INT_005fN_005fSIGN_005fPOSN-788"><code>INT_N_SIGN_POSN</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-INT_005fP_005fCS_005fPRECEDES-783"><code>INT_P_CS_PRECEDES</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-INT_005fP_005fSEP_005fBY_005fSPACE-784"><code>INT_P_SEP_BY_SPACE</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-INT_005fP_005fSIGN_005fPOSN-787"><code>INT_P_SIGN_POSN</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="Ports.html#index-IPPORT_005fRESERVED-1734"><code>IPPORT_RESERVED</code></a>: <a href="Ports.html#Ports">Ports</a></li>
<li><a href="Ports.html#index-IPPORT_005fUSERRESERVED-1735"><code>IPPORT_USERRESERVED</code></a>: <a href="Ports.html#Ports">Ports</a></li>
<li><a href="Local-Modes.html#index-ISIG-1915"><code>ISIG</code></a>: <a href="Local-Modes.html#Local-Modes">Local Modes</a></li>
<li><a href="Input-Modes.html#index-ISTRIP-1873"><code>ISTRIP</code></a>: <a href="Input-Modes.html#Input-Modes">Input Modes</a></li>
<li><a href="Setting-an-Alarm.html#index-ITIMER_005fPROF-2695"><code>ITIMER_PROF</code></a>: <a href="Setting-an-Alarm.html#Setting-an-Alarm">Setting an Alarm</a></li>
<li><a href="Setting-an-Alarm.html#index-ITIMER_005fREAL-2693"><code>ITIMER_REAL</code></a>: <a href="Setting-an-Alarm.html#Setting-an-Alarm">Setting an Alarm</a></li>
<li><a href="Setting-an-Alarm.html#index-ITIMER_005fVIRTUAL-2694"><code>ITIMER_VIRTUAL</code></a>: <a href="Setting-an-Alarm.html#Setting-an-Alarm">Setting an Alarm</a></li>
<li><a href="Input-Modes.html#index-IXANY-1882"><code>IXANY</code></a>: <a href="Input-Modes.html#Input-Modes">Input Modes</a></li>
<li><a href="Input-Modes.html#index-IXOFF-1880"><code>IXOFF</code></a>: <a href="Input-Modes.html#Input-Modes">Input Modes</a></li>
<li><a href="Input-Modes.html#index-IXON-1881"><code>IXON</code></a>: <a href="Input-Modes.html#Input-Modes">Input Modes</a></li>
<li><a href="Identifying-the-Terminal.html#index-L_005fctermid-3231"><code>L_ctermid</code></a>: <a href="Identifying-the-Terminal.html#Identifying-the-Terminal">Identifying the Terminal</a></li>
<li><a href="Who-Logged-In.html#index-L_005fcuserid-3335"><code>L_cuserid</code></a>: <a href="Who-Logged-In.html#Who-Logged-In">Who Logged In</a></li>
<li><a href="File-Positioning.html#index-L_005fINCR-1122"><code>L_INCR</code></a>: <a href="File-Positioning.html#File-Positioning">File Positioning</a></li>
<li><a href="File-Positioning.html#index-L_005fSET-1121"><code>L_SET</code></a>: <a href="File-Positioning.html#File-Positioning">File Positioning</a></li>
<li><a href="Temporary-Files.html#index-L_005ftmpnam-1605"><code>L_tmpnam</code></a>: <a href="Temporary-Files.html#Temporary-Files">Temporary Files</a></li>
<li><a href="File-Positioning.html#index-L_005fXTND-1123"><code>L_XTND</code></a>: <a href="File-Positioning.html#File-Positioning">File Positioning</a></li>
<li><a href="Locale-Categories.html#index-LANG-699"><code>LANG</code></a>: <a href="Locale-Categories.html#Locale-Categories">Locale Categories</a></li>
<li><a href="Locale-Categories.html#index-LANGUAGE-700"><code>LANGUAGE</code></a>: <a href="Locale-Categories.html#Locale-Categories">Locale Categories</a></li>
<li><a href="Locale-Categories.html#index-LC_005fALL-698"><code>LC_ALL</code></a>: <a href="Locale-Categories.html#Locale-Categories">Locale Categories</a></li>
<li><a href="Locale-Categories.html#index-LC_005fCOLLATE-692"><code>LC_COLLATE</code></a>: <a href="Locale-Categories.html#Locale-Categories">Locale Categories</a></li>
<li><a href="Locale-Categories.html#index-LC_005fCTYPE-693"><code>LC_CTYPE</code></a>: <a href="Locale-Categories.html#Locale-Categories">Locale Categories</a></li>
<li><a href="Locale-Categories.html#index-LC_005fMESSAGES-697"><code>LC_MESSAGES</code></a>: <a href="Locale-Categories.html#Locale-Categories">Locale Categories</a></li>
<li><a href="Locale-Categories.html#index-LC_005fMONETARY-694"><code>LC_MONETARY</code></a>: <a href="Locale-Categories.html#Locale-Categories">Locale Categories</a></li>
<li><a href="Locale-Categories.html#index-LC_005fNUMERIC-695"><code>LC_NUMERIC</code></a>: <a href="Locale-Categories.html#Locale-Categories">Locale Categories</a></li>
<li><a href="Locale-Categories.html#index-LC_005fTIME-696"><code>LC_TIME</code></a>: <a href="Locale-Categories.html#Locale-Categories">Locale Categories</a></li>
<li><a href="Floating-Point-Parameters.html#index-LDBL_005fDIG-3788"><code>LDBL_DIG</code></a>: <a href="Floating-Point-Parameters.html#Floating-Point-Parameters">Floating Point Parameters</a></li>
<li><a href="Floating-Point-Parameters.html#index-LDBL_005fEPSILON-3809"><code>LDBL_EPSILON</code></a>: <a href="Floating-Point-Parameters.html#Floating-Point-Parameters">Floating Point Parameters</a></li>
<li><a href="Floating-Point-Parameters.html#index-LDBL_005fMANT_005fDIG-3785"><code>LDBL_MANT_DIG</code></a>: <a href="Floating-Point-Parameters.html#Floating-Point-Parameters">Floating Point Parameters</a></li>
<li><a href="Floating-Point-Parameters.html#index-LDBL_005fMAX-3803"><code>LDBL_MAX</code></a>: <a href="Floating-Point-Parameters.html#Floating-Point-Parameters">Floating Point Parameters</a></li>
<li><a href="Floating-Point-Parameters.html#index-LDBL_005fMAX_005f10_005fEXP-3800"><code>LDBL_MAX_10_EXP</code></a>: <a href="Floating-Point-Parameters.html#Floating-Point-Parameters">Floating Point Parameters</a></li>
<li><a href="Floating-Point-Parameters.html#index-LDBL_005fMAX_005fEXP-3797"><code>LDBL_MAX_EXP</code></a>: <a href="Floating-Point-Parameters.html#Floating-Point-Parameters">Floating Point Parameters</a></li>
<li><a href="Floating-Point-Parameters.html#index-LDBL_005fMIN-3806"><code>LDBL_MIN</code></a>: <a href="Floating-Point-Parameters.html#Floating-Point-Parameters">Floating Point Parameters</a></li>
<li><a href="Floating-Point-Parameters.html#index-LDBL_005fMIN_005f10_005fEXP-3794"><code>LDBL_MIN_10_EXP</code></a>: <a href="Floating-Point-Parameters.html#Floating-Point-Parameters">Floating Point Parameters</a></li>
<li><a href="Floating-Point-Parameters.html#index-LDBL_005fMIN_005fEXP-3791"><code>LDBL_MIN_EXP</code></a>: <a href="Floating-Point-Parameters.html#Floating-Point-Parameters">Floating Point Parameters</a></li>
<li><a href="Utility-Limits.html#index-LINE_005fMAX-3673"><code>LINE_MAX</code></a>: <a href="Utility-Limits.html#Utility-Limits">Utility Limits</a></li>
<li><a href="Limits-for-Files.html#index-LINK_005fMAX-3649"><code>LINK_MAX</code></a>: <a href="Limits-for-Files.html#Limits-for-Files">Limits for Files</a></li>
<li><a href="Asynchronous-I_002fO.html#index-LIO_005fNOP-1290"><code>LIO_NOP</code></a>: <a href="Asynchronous-I_002fO.html#Asynchronous-I_002fO">Asynchronous I/O</a></li>
<li><a href="Asynchronous-I_002fO.html#index-LIO_005fREAD-1288"><code>LIO_READ</code></a>: <a href="Asynchronous-I_002fO.html#Asynchronous-I_002fO">Asynchronous I/O</a></li>
<li><a href="Asynchronous-I_002fO.html#index-LIO_005fWRITE-1289"><code>LIO_WRITE</code></a>: <a href="Asynchronous-I_002fO.html#Asynchronous-I_002fO">Asynchronous I/O</a></li>
<li><a href="syslog_003b-vsyslog.html#index-LOG_005fALERT-2056"><code>LOG_ALERT</code></a>: <a href="syslog_003b-vsyslog.html#syslog_003b-vsyslog">syslog; vsyslog</a></li>
<li><a href="syslog_003b-vsyslog.html#index-LOG_005fAUTH-2039"><code>LOG_AUTH</code></a>: <a href="syslog_003b-vsyslog.html#syslog_003b-vsyslog">syslog; vsyslog</a></li>
<li><a href="syslog_003b-vsyslog.html#index-LOG_005fAUTHPRIV-2045"><code>LOG_AUTHPRIV</code></a>: <a href="syslog_003b-vsyslog.html#syslog_003b-vsyslog">syslog; vsyslog</a></li>
<li><a href="syslog_003b-vsyslog.html#index-LOG_005fCRIT-2057"><code>LOG_CRIT</code></a>: <a href="syslog_003b-vsyslog.html#syslog_003b-vsyslog">syslog; vsyslog</a></li>
<li><a href="syslog_003b-vsyslog.html#index-LOG_005fCRON-2044"><code>LOG_CRON</code></a>: <a href="syslog_003b-vsyslog.html#syslog_003b-vsyslog">syslog; vsyslog</a></li>
<li><a href="syslog_003b-vsyslog.html#index-LOG_005fDAEMON-2038"><code>LOG_DAEMON</code></a>: <a href="syslog_003b-vsyslog.html#syslog_003b-vsyslog">syslog; vsyslog</a></li>
<li><a href="syslog_003b-vsyslog.html#index-LOG_005fDEBUG-2062"><code>LOG_DEBUG</code></a>: <a href="syslog_003b-vsyslog.html#syslog_003b-vsyslog">syslog; vsyslog</a></li>
<li><a href="syslog_003b-vsyslog.html#index-LOG_005fEMERG-2055"><code>LOG_EMERG</code></a>: <a href="syslog_003b-vsyslog.html#syslog_003b-vsyslog">syslog; vsyslog</a></li>
<li><a href="syslog_003b-vsyslog.html#index-LOG_005fERR-2058"><code>LOG_ERR</code></a>: <a href="syslog_003b-vsyslog.html#syslog_003b-vsyslog">syslog; vsyslog</a></li>
<li><a href="syslog_003b-vsyslog.html#index-LOG_005fFTP-2046"><code>LOG_FTP</code></a>: <a href="syslog_003b-vsyslog.html#syslog_003b-vsyslog">syslog; vsyslog</a></li>
<li><a href="syslog_003b-vsyslog.html#index-LOG_005fINFO-2061"><code>LOG_INFO</code></a>: <a href="syslog_003b-vsyslog.html#syslog_003b-vsyslog">syslog; vsyslog</a></li>
<li><a href="syslog_003b-vsyslog.html#index-LOG_005fLOCAL0-2047"><code>LOG_LOCAL0</code></a>: <a href="syslog_003b-vsyslog.html#syslog_003b-vsyslog">syslog; vsyslog</a></li>
<li><a href="syslog_003b-vsyslog.html#index-LOG_005fLOCAL1-2048"><code>LOG_LOCAL1</code></a>: <a href="syslog_003b-vsyslog.html#syslog_003b-vsyslog">syslog; vsyslog</a></li>
<li><a href="syslog_003b-vsyslog.html#index-LOG_005fLOCAL2-2049"><code>LOG_LOCAL2</code></a>: <a href="syslog_003b-vsyslog.html#syslog_003b-vsyslog">syslog; vsyslog</a></li>
<li><a href="syslog_003b-vsyslog.html#index-LOG_005fLOCAL3-2050"><code>LOG_LOCAL3</code></a>: <a href="syslog_003b-vsyslog.html#syslog_003b-vsyslog">syslog; vsyslog</a></li>
<li><a href="syslog_003b-vsyslog.html#index-LOG_005fLOCAL4-2051"><code>LOG_LOCAL4</code></a>: <a href="syslog_003b-vsyslog.html#syslog_003b-vsyslog">syslog; vsyslog</a></li>
<li><a href="syslog_003b-vsyslog.html#index-LOG_005fLOCAL5-2052"><code>LOG_LOCAL5</code></a>: <a href="syslog_003b-vsyslog.html#syslog_003b-vsyslog">syslog; vsyslog</a></li>
<li><a href="syslog_003b-vsyslog.html#index-LOG_005fLOCAL6-2053"><code>LOG_LOCAL6</code></a>: <a href="syslog_003b-vsyslog.html#syslog_003b-vsyslog">syslog; vsyslog</a></li>
<li><a href="syslog_003b-vsyslog.html#index-LOG_005fLOCAL7-2054"><code>LOG_LOCAL7</code></a>: <a href="syslog_003b-vsyslog.html#syslog_003b-vsyslog">syslog; vsyslog</a></li>
<li><a href="syslog_003b-vsyslog.html#index-LOG_005fLPR-2041"><code>LOG_LPR</code></a>: <a href="syslog_003b-vsyslog.html#syslog_003b-vsyslog">syslog; vsyslog</a></li>
<li><a href="syslog_003b-vsyslog.html#index-LOG_005fMAIL-2037"><code>LOG_MAIL</code></a>: <a href="syslog_003b-vsyslog.html#syslog_003b-vsyslog">syslog; vsyslog</a></li>
<li><a href="syslog_003b-vsyslog.html#index-LOG_005fNEWS-2042"><code>LOG_NEWS</code></a>: <a href="syslog_003b-vsyslog.html#syslog_003b-vsyslog">syslog; vsyslog</a></li>
<li><a href="syslog_003b-vsyslog.html#index-LOG_005fNOTICE-2060"><code>LOG_NOTICE</code></a>: <a href="syslog_003b-vsyslog.html#syslog_003b-vsyslog">syslog; vsyslog</a></li>
<li><a href="syslog_003b-vsyslog.html#index-LOG_005fSYSLOG-2040"><code>LOG_SYSLOG</code></a>: <a href="syslog_003b-vsyslog.html#syslog_003b-vsyslog">syslog; vsyslog</a></li>
<li><a href="syslog_003b-vsyslog.html#index-LOG_005fUSER-2036"><code>LOG_USER</code></a>: <a href="syslog_003b-vsyslog.html#syslog_003b-vsyslog">syslog; vsyslog</a></li>
<li><a href="syslog_003b-vsyslog.html#index-LOG_005fUUCP-2043"><code>LOG_UUCP</code></a>: <a href="syslog_003b-vsyslog.html#syslog_003b-vsyslog">syslog; vsyslog</a></li>
<li><a href="syslog_003b-vsyslog.html#index-LOG_005fWARNING-2059"><code>LOG_WARNING</code></a>: <a href="syslog_003b-vsyslog.html#syslog_003b-vsyslog">syslog; vsyslog</a></li>
<li><a href="XPG-Functions.html#index-LOGIN_005fPROCESS-3371"><code>LOGIN_PROCESS</code></a>: <a href="XPG-Functions.html#XPG-Functions">XPG Functions</a></li>
<li><a href="Manipulating-the-Database.html#index-LOGIN_005fPROCESS-3346"><code>LOGIN_PROCESS</code></a>: <a href="Manipulating-the-Database.html#Manipulating-the-Database">Manipulating the Database</a></li>
<li><a href="Range-of-Type.html#index-LONG_005fLONG_005fMAX-3763"><code>LONG_LONG_MAX</code></a>: <a href="Range-of-Type.html#Range-of-Type">Range of Type</a></li>
<li><a href="Range-of-Type.html#index-LONG_005fLONG_005fMIN-3762"><code>LONG_LONG_MIN</code></a>: <a href="Range-of-Type.html#Range-of-Type">Range of Type</a></li>
<li><a href="Range-of-Type.html#index-LONG_005fMAX-3760"><code>LONG_MAX</code></a>: <a href="Range-of-Type.html#Range-of-Type">Range of Type</a></li>
<li><a href="Range-of-Type.html#index-LONG_005fMIN-3759"><code>LONG_MIN</code></a>: <a href="Range-of-Type.html#Range-of-Type">Range of Type</a></li>
<li><a href="Mathematical-Constants.html#index-M_005f1_005fPI-2078"><code>M_1_PI</code></a>: <a href="Mathematical-Constants.html#Mathematical-Constants">Mathematical Constants</a></li>
<li><a href="Mathematical-Constants.html#index-M_005f2_005fPI-2079"><code>M_2_PI</code></a>: <a href="Mathematical-Constants.html#Mathematical-Constants">Mathematical Constants</a></li>
<li><a href="Mathematical-Constants.html#index-M_005f2_005fSQRTPI-2080"><code>M_2_SQRTPI</code></a>: <a href="Mathematical-Constants.html#Mathematical-Constants">Mathematical Constants</a></li>
<li><a href="Mathematical-Constants.html#index-M_005fE-2070"><code>M_E</code></a>: <a href="Mathematical-Constants.html#Mathematical-Constants">Mathematical Constants</a></li>
<li><a href="Mathematical-Constants.html#index-M_005fLN10-2074"><code>M_LN10</code></a>: <a href="Mathematical-Constants.html#Mathematical-Constants">Mathematical Constants</a></li>
<li><a href="Mathematical-Constants.html#index-M_005fLN2-2073"><code>M_LN2</code></a>: <a href="Mathematical-Constants.html#Mathematical-Constants">Mathematical Constants</a></li>
<li><a href="Mathematical-Constants.html#index-M_005fLOG10E-2072"><code>M_LOG10E</code></a>: <a href="Mathematical-Constants.html#Mathematical-Constants">Mathematical Constants</a></li>
<li><a href="Mathematical-Constants.html#index-M_005fLOG2E-2071"><code>M_LOG2E</code></a>: <a href="Mathematical-Constants.html#Mathematical-Constants">Mathematical Constants</a></li>
<li><a href="Mathematical-Constants.html#index-M_005fPI-2075"><code>M_PI</code></a>: <a href="Mathematical-Constants.html#Mathematical-Constants">Mathematical Constants</a></li>
<li><a href="Mathematical-Constants.html#index-M_005fPI_005f2-2076"><code>M_PI_2</code></a>: <a href="Mathematical-Constants.html#Mathematical-Constants">Mathematical Constants</a></li>
<li><a href="Mathematical-Constants.html#index-M_005fPI_005f4-2077"><code>M_PI_4</code></a>: <a href="Mathematical-Constants.html#Mathematical-Constants">Mathematical Constants</a></li>
<li><a href="Mathematical-Constants.html#index-M_005fSQRT1_005f2-2082"><code>M_SQRT1_2</code></a>: <a href="Mathematical-Constants.html#Mathematical-Constants">Mathematical Constants</a></li>
<li><a href="Mathematical-Constants.html#index-M_005fSQRT2-2081"><code>M_SQRT2</code></a>: <a href="Mathematical-Constants.html#Mathematical-Constants">Mathematical Constants</a></li>
<li><a href="Memory_002dmapped-I_002fO.html#index-MAP_005fANON-1263"><code>MAP_ANON</code></a>: <a href="Memory_002dmapped-I_002fO.html#Memory_002dmapped-I_002fO">Memory-mapped I/O</a></li>
<li><a href="Memory_002dmapped-I_002fO.html#index-MAP_005fANONYMOUS-1262"><code>MAP_ANONYMOUS</code></a>: <a href="Memory_002dmapped-I_002fO.html#Memory_002dmapped-I_002fO">Memory-mapped I/O</a></li>
<li><a href="Memory_002dmapped-I_002fO.html#index-MAP_005fFIXED-1261"><code>MAP_FIXED</code></a>: <a href="Memory_002dmapped-I_002fO.html#Memory_002dmapped-I_002fO">Memory-mapped I/O</a></li>
<li><a href="Memory_002dmapped-I_002fO.html#index-MAP_005fPRIVATE-1259"><code>MAP_PRIVATE</code></a>: <a href="Memory_002dmapped-I_002fO.html#Memory_002dmapped-I_002fO">Memory-mapped I/O</a></li>
<li><a href="Memory_002dmapped-I_002fO.html#index-MAP_005fSHARED-1260"><code>MAP_SHARED</code></a>: <a href="Memory_002dmapped-I_002fO.html#Memory_002dmapped-I_002fO">Memory-mapped I/O</a></li>
<li><a href="Limits-for-Files.html#index-MAX_005fCANON-3651"><code>MAX_CANON</code></a>: <a href="Limits-for-Files.html#Limits-for-Files">Limits for Files</a></li>
<li><a href="Limits-for-Files.html#index-MAX_005fINPUT-3652"><code>MAX_INPUT</code></a>: <a href="Limits-for-Files.html#Limits-for-Files">Limits for Files</a></li>
<li><a href="Limits-for-Files.html#index-MAXNAMLEN-3658"><code>MAXNAMLEN</code></a>: <a href="Limits-for-Files.html#Limits-for-Files">Limits for Files</a></li>
<li><a href="Symbolic-Links.html#index-MAXSYMLINKS-1466"><code>MAXSYMLINKS</code></a>: <a href="Symbolic-Links.html#Symbolic-Links">Symbolic Links</a></li>
<li><a href="Selecting-the-Conversion.html#index-MB_005fCUR_005fMAX-636"><code>MB_CUR_MAX</code></a>: <a href="Selecting-the-Conversion.html#Selecting-the-Conversion">Selecting the Conversion</a></li>
<li><a href="Selecting-the-Conversion.html#index-MB_005fLEN_005fMAX-634"><code>MB_LEN_MAX</code></a>: <a href="Selecting-the-Conversion.html#Selecting-the-Conversion">Selecting the Conversion</a></li>
<li><a href="Control-Modes.html#index-MDMBUF-1904"><code>MDMBUF</code></a>: <a href="Control-Modes.html#Control-Modes">Control Modes</a></li>
<li><a href="Signal-Stack.html#index-MINSIGSTKSZ-2985"><code>MINSIGSTKSZ</code></a>: <a href="Signal-Stack.html#Signal-Stack">Signal Stack</a></li>
<li><a href="Printing-Formatted-Messages.html#index-MM_005fAPPL-1177"><code>MM_APPL</code></a>: <a href="Printing-Formatted-Messages.html#Printing-Formatted-Messages">Printing Formatted Messages</a></li>
<li><a href="Printing-Formatted-Messages.html#index-MM_005fCONSOLE-1173"><code>MM_CONSOLE</code></a>: <a href="Printing-Formatted-Messages.html#Printing-Formatted-Messages">Printing Formatted Messages</a></li>
<li><a href="Printing-Formatted-Messages.html#index-MM_005fERROR-1192"><code>MM_ERROR</code></a>: <a href="Printing-Formatted-Messages.html#Printing-Formatted-Messages">Printing Formatted Messages</a></li>
<li><a href="Printing-Formatted-Messages.html#index-MM_005fFIRM-1176"><code>MM_FIRM</code></a>: <a href="Printing-Formatted-Messages.html#Printing-Formatted-Messages">Printing Formatted Messages</a></li>
<li><a href="Printing-Formatted-Messages.html#index-MM_005fHALT-1191"><code>MM_HALT</code></a>: <a href="Printing-Formatted-Messages.html#Printing-Formatted-Messages">Printing Formatted Messages</a></li>
<li><a href="Printing-Formatted-Messages.html#index-MM_005fHARD-1174"><code>MM_HARD</code></a>: <a href="Printing-Formatted-Messages.html#Printing-Formatted-Messages">Printing Formatted Messages</a></li>
<li><a href="Printing-Formatted-Messages.html#index-MM_005fINFO-1194"><code>MM_INFO</code></a>: <a href="Printing-Formatted-Messages.html#Printing-Formatted-Messages">Printing Formatted Messages</a></li>
<li><a href="Printing-Formatted-Messages.html#index-MM_005fNOSEV-1190"><code>MM_NOSEV</code></a>: <a href="Printing-Formatted-Messages.html#Printing-Formatted-Messages">Printing Formatted Messages</a></li>
<li><a href="Printing-Formatted-Messages.html#index-MM_005fNRECOV-1181"><code>MM_NRECOV</code></a>: <a href="Printing-Formatted-Messages.html#Printing-Formatted-Messages">Printing Formatted Messages</a></li>
<li><a href="Printing-Formatted-Messages.html#index-MM_005fNULLACT-1187"><code>MM_NULLACT</code></a>: <a href="Printing-Formatted-Messages.html#Printing-Formatted-Messages">Printing Formatted Messages</a></li>
<li><a href="Printing-Formatted-Messages.html#index-MM_005fNULLLBL-1183"><code>MM_NULLLBL</code></a>: <a href="Printing-Formatted-Messages.html#Printing-Formatted-Messages">Printing Formatted Messages</a></li>
<li><a href="Printing-Formatted-Messages.html#index-MM_005fNULLMC-1185"><code>MM_NULLMC</code></a>: <a href="Printing-Formatted-Messages.html#Printing-Formatted-Messages">Printing Formatted Messages</a></li>
<li><a href="Printing-Formatted-Messages.html#index-MM_005fNULLSEV-1184"><code>MM_NULLSEV</code></a>: <a href="Printing-Formatted-Messages.html#Printing-Formatted-Messages">Printing Formatted Messages</a></li>
<li><a href="Printing-Formatted-Messages.html#index-MM_005fNULLTAG-1188"><code>MM_NULLTAG</code></a>: <a href="Printing-Formatted-Messages.html#Printing-Formatted-Messages">Printing Formatted Messages</a></li>
<li><a href="Printing-Formatted-Messages.html#index-MM_005fNULLTXT-1186"><code>MM_NULLTXT</code></a>: <a href="Printing-Formatted-Messages.html#Printing-Formatted-Messages">Printing Formatted Messages</a></li>
<li><a href="Printing-Formatted-Messages.html#index-MM_005fOPSYS-1179"><code>MM_OPSYS</code></a>: <a href="Printing-Formatted-Messages.html#Printing-Formatted-Messages">Printing Formatted Messages</a></li>
<li><a href="Printing-Formatted-Messages.html#index-MM_005fPRINT-1172"><code>MM_PRINT</code></a>: <a href="Printing-Formatted-Messages.html#Printing-Formatted-Messages">Printing Formatted Messages</a></li>
<li><a href="Printing-Formatted-Messages.html#index-MM_005fRECOVER-1180"><code>MM_RECOVER</code></a>: <a href="Printing-Formatted-Messages.html#Printing-Formatted-Messages">Printing Formatted Messages</a></li>
<li><a href="Printing-Formatted-Messages.html#index-MM_005fSOFT-1175"><code>MM_SOFT</code></a>: <a href="Printing-Formatted-Messages.html#Printing-Formatted-Messages">Printing Formatted Messages</a></li>
<li><a href="Printing-Formatted-Messages.html#index-MM_005fUTIL-1178"><code>MM_UTIL</code></a>: <a href="Printing-Formatted-Messages.html#Printing-Formatted-Messages">Printing Formatted Messages</a></li>
<li><a href="Printing-Formatted-Messages.html#index-MM_005fWARNING-1193"><code>MM_WARNING</code></a>: <a href="Printing-Formatted-Messages.html#Printing-Formatted-Messages">Printing Formatted Messages</a></li>
<li><a href="mtab.html#index-MNTOPT_005fDEFAULTS-3479"><code>MNTOPT_DEFAULTS</code></a>: <a href="mtab.html#mtab">mtab</a></li>
<li><a href="mtab.html#index-MNTOPT_005fNOAUTO-3484"><code>MNTOPT_NOAUTO</code></a>: <a href="mtab.html#mtab">mtab</a></li>
<li><a href="mtab.html#index-MNTOPT_005fNOSUID-3483"><code>MNTOPT_NOSUID</code></a>: <a href="mtab.html#mtab">mtab</a></li>
<li><a href="mtab.html#index-MNTOPT_005fRO-3480"><code>MNTOPT_RO</code></a>: <a href="mtab.html#mtab">mtab</a></li>
<li><a href="mtab.html#index-MNTOPT_005fRW-3481"><code>MNTOPT_RW</code></a>: <a href="mtab.html#mtab">mtab</a></li>
<li><a href="mtab.html#index-MNTOPT_005fSUID-3482"><code>MNTOPT_SUID</code></a>: <a href="mtab.html#mtab">mtab</a></li>
<li><a href="Mount-Information.html#index-MNTTAB-3462"><code>MNTTAB</code></a>: <a href="Mount-Information.html#Mount-Information">Mount Information</a></li>
<li><a href="mtab.html#index-MNTTYPE_005fIGNORE-3476"><code>MNTTYPE_IGNORE</code></a>: <a href="mtab.html#mtab">mtab</a></li>
<li><a href="mtab.html#index-MNTTYPE_005fNFS-3477"><code>MNTTYPE_NFS</code></a>: <a href="mtab.html#mtab">mtab</a></li>
<li><a href="mtab.html#index-MNTTYPE_005fSWAP-3478"><code>MNTTYPE_SWAP</code></a>: <a href="mtab.html#mtab">mtab</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-MON_005f1-743"><code>MON_1</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-MON_005f10-752"><code>MON_10</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-MON_005f11-753"><code>MON_11</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-MON_005f12-754"><code>MON_12</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-MON_005f2-744"><code>MON_2</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-MON_005f3-745"><code>MON_3</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-MON_005f4-746"><code>MON_4</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-MON_005f5-747"><code>MON_5</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-MON_005f6-748"><code>MON_6</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-MON_005f7-749"><code>MON_7</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-MON_005f8-750"><code>MON_8</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-MON_005f9-751"><code>MON_9</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-MON_005fDECIMAL_005fPOINT-770"><code>MON_DECIMAL_POINT</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-MON_005fGROUPING-772"><code>MON_GROUPING</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-MON_005fTHOUSANDS_005fSEP-771"><code>MON_THOUSANDS_SEP</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="Mount-Information.html#index-MOUNTED-3463"><code>MOUNTED</code></a>: <a href="Mount-Information.html#Mount-Information">Mount Information</a></li>
<li><a href="Memory_002dmapped-I_002fO.html#index-MS_005fASYNC-1268"><code>MS_ASYNC</code></a>: <a href="Memory_002dmapped-I_002fO.html#Memory_002dmapped-I_002fO">Memory-mapped I/O</a></li>
<li><a href="Memory_002dmapped-I_002fO.html#index-MS_005fSYNC-1267"><code>MS_SYNC</code></a>: <a href="Memory_002dmapped-I_002fO.html#Memory_002dmapped-I_002fO">Memory-mapped I/O</a></li>
<li><a href="Socket-Data-Options.html#index-MSG_005fDONTROUTE-1813"><code>MSG_DONTROUTE</code></a>: <a href="Socket-Data-Options.html#Socket-Data-Options">Socket Data Options</a></li>
<li><a href="Socket-Data-Options.html#index-MSG_005fOOB-1811"><code>MSG_OOB</code></a>: <a href="Socket-Data-Options.html#Socket-Data-Options">Socket Data Options</a></li>
<li><a href="Socket-Data-Options.html#index-MSG_005fPEEK-1812"><code>MSG_PEEK</code></a>: <a href="Socket-Data-Options.html#Socket-Data-Options">Socket Data Options</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-N_005fCS_005fPRECEDES-779"><code>N_CS_PRECEDES</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-N_005fSEP_005fBY_005fSPACE-780"><code>N_SEP_BY_SPACE</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-N_005fSIGN_005fPOSN-782"><code>N_SIGN_POSN</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="Limits-for-Files.html#index-NAME_005fMAX-3654"><code>NAME_MAX</code></a>: <a href="Limits-for-Files.html#Limits-for-Files">Limits for Files</a></li>
<li><a href="Infinity-and-NaN.html#index-NAN-2372"><code>NAN</code></a>: <a href="Infinity-and-NaN.html#Infinity-and-NaN">Infinity and NaN</a></li>
<li><a href="Mode-Data-Types.html#index-NCCS-1861"><code>NCCS</code></a>: <a href="Mode-Data-Types.html#Mode-Data-Types">Mode Data Types</a></li>
<li><a href="Consistency-Checking.html#index-NDEBUG-3706"><code>NDEBUG</code></a>: <a href="Consistency-Checking.html#Consistency-Checking">Consistency Checking</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-NEGATIVE_005fSIGN-774"><code>NEGATIVE_SIGN</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="NSS-Basics.html#index-netgroup-3266"><code>netgroup</code></a>: <a href="NSS-Basics.html#NSS-Basics">NSS Basics</a></li>
<li><a href="NSS-Basics.html#index-networks-3267"><code>networks</code></a>: <a href="NSS-Basics.html#NSS-Basics">NSS Basics</a></li>
<li><a href="XPG-Functions.html#index-NEW_005fTIME-3369"><code>NEW_TIME</code></a>: <a href="XPG-Functions.html#XPG-Functions">XPG Functions</a></li>
<li><a href="Manipulating-the-Database.html#index-NEW_005fTIME-3344"><code>NEW_TIME</code></a>: <a href="Manipulating-the-Database.html#Manipulating-the-Database">Manipulating the Database</a></li>
<li><a href="General-Limits.html#index-NGROUPS_005fMAX-3509"><code>NGROUPS_MAX</code></a>: <a href="General-Limits.html#General-Limits">General Limits</a></li>
<li><a href="Output-Conversion-Syntax.html#index-NL_005fARGMAX-1020"><code>NL_ARGMAX</code></a>: <a href="Output-Conversion-Syntax.html#Output-Conversion-Syntax">Output Conversion Syntax</a></li>
<li><a href="Host-Names.html#index-NO_005fADDRESS-1725"><code>NO_ADDRESS</code></a>: <a href="Host-Names.html#Host-Names">Host Names</a></li>
<li><a href="Host-Names.html#index-NO_005fRECOVERY-1724"><code>NO_RECOVERY</code></a>: <a href="Host-Names.html#Host-Names">Host Names</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-NOEXPR-795"><code>NOEXPR</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="Local-Modes.html#index-NOFLSH-1918"><code>NOFLSH</code></a>: <a href="Local-Modes.html#Local-Modes">Local Modes</a></li>
<li><a href="Local-Modes.html#index-NOKERNINFO-1922"><code>NOKERNINFO</code></a>: <a href="Local-Modes.html#Local-Modes">Local Modes</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-NOSTR-797"><code>NOSTR</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="Standard-Signals.html#index-NSIG-2823"><code>NSIG</code></a>: <a href="Standard-Signals.html#Standard-Signals">Standard Signals</a></li>
<li><a href="NSS-Modules-Interface.html#index-NSS_005fSTATUS_005fNOTFOUND-3288"><code>NSS_STATUS_NOTFOUND</code></a>: <a href="NSS-Modules-Interface.html#NSS-Modules-Interface">NSS Modules Interface</a></li>
<li><a href="NSS-Modules-Interface.html#index-NSS_005fSTATUS_005fSUCCESS-3289"><code>NSS_STATUS_SUCCESS</code></a>: <a href="NSS-Modules-Interface.html#NSS-Modules-Interface">NSS Modules Interface</a></li>
<li><a href="NSS-Modules-Interface.html#index-NSS_005fSTATUS_005fTRYAGAIN-3286"><code>NSS_STATUS_TRYAGAIN</code></a>: <a href="NSS-Modules-Interface.html#NSS-Modules-Interface">NSS Modules Interface</a></li>
<li><a href="NSS-Modules-Interface.html#index-NSS_005fSTATUS_005fUNAVAIL-3287"><code>NSS_STATUS_UNAVAIL</code></a>: <a href="NSS-Modules-Interface.html#NSS-Modules-Interface">NSS Modules Interface</a></li>
<li><a href="Null-Pointer-Constant.html#index-NULL-3737"><code>NULL</code></a>: <a href="Null-Pointer-Constant.html#Null-Pointer-Constant">Null Pointer Constant</a></li>
<li><a href="Access-Modes.html#index-O_005fACCMODE-1336"><code>O_ACCMODE</code></a>: <a href="Access-Modes.html#Access-Modes">Access Modes</a></li>
<li><a href="Operating-Modes.html#index-O_005fAPPEND-1355"><code>O_APPEND</code></a>: <a href="Operating-Modes.html#Operating-Modes">Operating Modes</a></li>
<li><a href="Operating-Modes.html#index-O_005fASYNC-1358"><code>O_ASYNC</code></a>: <a href="Operating-Modes.html#Operating-Modes">Operating Modes</a></li>
<li><a href="Open_002dtime-Flags.html#index-O_005fCREAT-1341"><code>O_CREAT</code></a>: <a href="Open_002dtime-Flags.html#Open_002dtime-Flags">Open-time Flags</a></li>
<li><a href="Open_002dtime-Flags.html#index-O_005fEXCL-1343"><code>O_EXCL</code></a>: <a href="Open_002dtime-Flags.html#Open_002dtime-Flags">Open-time Flags</a></li>
<li><a href="Access-Modes.html#index-O_005fEXEC-1335"><code>O_EXEC</code></a>: <a href="Access-Modes.html#Access-Modes">Access Modes</a></li>
<li><a href="Open_002dtime-Flags.html#index-O_005fEXLOCK-1354"><code>O_EXLOCK</code></a>: <a href="Open_002dtime-Flags.html#Open_002dtime-Flags">Open-time Flags</a></li>
<li><a href="Operating-Modes.html#index-O_005fFSYNC-1359"><code>O_FSYNC</code></a>: <a href="Operating-Modes.html#Operating-Modes">Operating Modes</a></li>
<li><a href="Open_002dtime-Flags.html#index-O_005fIGNORE_005fCTTY-1348"><code>O_IGNORE_CTTY</code></a>: <a href="Open_002dtime-Flags.html#Open_002dtime-Flags">Open-time Flags</a></li>
<li><a href="Operating-Modes.html#index-O_005fNDELAY-1357"><code>O_NDELAY</code></a>: <a href="Operating-Modes.html#Operating-Modes">Operating Modes</a></li>
<li><a href="Operating-Modes.html#index-O_005fNOATIME-1361"><code>O_NOATIME</code></a>: <a href="Operating-Modes.html#Operating-Modes">Operating Modes</a></li>
<li><a href="Open_002dtime-Flags.html#index-O_005fNOCTTY-1346"><code>O_NOCTTY</code></a>: <a href="Open_002dtime-Flags.html#Open_002dtime-Flags">Open-time Flags</a></li>
<li><a href="Open_002dtime-Flags.html#index-O_005fNOLINK-1349"><code>O_NOLINK</code></a>: <a href="Open_002dtime-Flags.html#Open_002dtime-Flags">Open-time Flags</a></li>
<li><a href="Operating-Modes.html#index-O_005fNONBLOCK-1356"><code>O_NONBLOCK</code></a>: <a href="Operating-Modes.html#Operating-Modes">Operating Modes</a></li>
<li><a href="Open_002dtime-Flags.html#index-O_005fNONBLOCK-1344"><code>O_NONBLOCK</code></a>: <a href="Open_002dtime-Flags.html#Open_002dtime-Flags">Open-time Flags</a></li>
<li><a href="Open_002dtime-Flags.html#index-O_005fNOTRANS-1351"><code>O_NOTRANS</code></a>: <a href="Open_002dtime-Flags.html#Open_002dtime-Flags">Open-time Flags</a></li>
<li><a href="Access-Modes.html#index-O_005fRDONLY-1330"><code>O_RDONLY</code></a>: <a href="Access-Modes.html#Access-Modes">Access Modes</a></li>
<li><a href="Access-Modes.html#index-O_005fRDWR-1332"><code>O_RDWR</code></a>: <a href="Access-Modes.html#Access-Modes">Access Modes</a></li>
<li><a href="Access-Modes.html#index-O_005fREAD-1333"><code>O_READ</code></a>: <a href="Access-Modes.html#Access-Modes">Access Modes</a></li>
<li><a href="Open_002dtime-Flags.html#index-O_005fSHLOCK-1353"><code>O_SHLOCK</code></a>: <a href="Open_002dtime-Flags.html#Open_002dtime-Flags">Open-time Flags</a></li>
<li><a href="Operating-Modes.html#index-O_005fSYNC-1360"><code>O_SYNC</code></a>: <a href="Operating-Modes.html#Operating-Modes">Operating Modes</a></li>
<li><a href="Open_002dtime-Flags.html#index-O_005fTRUNC-1352"><code>O_TRUNC</code></a>: <a href="Open_002dtime-Flags.html#Open_002dtime-Flags">Open-time Flags</a></li>
<li><a href="Access-Modes.html#index-O_005fWRITE-1334"><code>O_WRITE</code></a>: <a href="Access-Modes.html#Access-Modes">Access Modes</a></li>
<li><a href="Access-Modes.html#index-O_005fWRONLY-1331"><code>O_WRONLY</code></a>: <a href="Access-Modes.html#Access-Modes">Access Modes</a></li>
<li><a href="Preparing-for-Obstacks.html#index-obstack_005falloc_005ffailed_005fhandler-306"><code>obstack_alloc_failed_handler</code></a>: <a href="Preparing-for-Obstacks.html#Preparing-for-Obstacks">Preparing for Obstacks</a></li>
<li><a href="XPG-Functions.html#index-OLD_005fTIME-3368"><code>OLD_TIME</code></a>: <a href="XPG-Functions.html#XPG-Functions">XPG Functions</a></li>
<li><a href="Manipulating-the-Database.html#index-OLD_005fTIME-3343"><code>OLD_TIME</code></a>: <a href="Manipulating-the-Database.html#Manipulating-the-Database">Manipulating the Database</a></li>
<li><a href="Output-Modes.html#index-ONLCR-1885"><code>ONLCR</code></a>: <a href="Output-Modes.html#Output-Modes">Output Modes</a></li>
<li><a href="Output-Modes.html#index-ONOEOT-1887"><code>ONOEOT</code></a>: <a href="Output-Modes.html#Output-Modes">Output Modes</a></li>
<li><a href="General-Limits.html#index-OPEN_005fMAX-3504"><code>OPEN_MAX</code></a>: <a href="General-Limits.html#General-Limits">General Limits</a></li>
<li><a href="Output-Modes.html#index-OPOST-1884"><code>OPOST</code></a>: <a href="Output-Modes.html#Output-Modes">Output Modes</a></li>
<li><a href="Using-Getopt.html#index-optarg-3027"><code>optarg</code></a>: <a href="Using-Getopt.html#Using-Getopt">Using Getopt</a></li>
<li><a href="Using-Getopt.html#index-opterr-3024"><code>opterr</code></a>: <a href="Using-Getopt.html#Using-Getopt">Using Getopt</a></li>
<li><a href="Using-Getopt.html#index-optind-3026"><code>optind</code></a>: <a href="Using-Getopt.html#Using-Getopt">Using Getopt</a></li>
<li><a href="Argp-Option-Flags.html#index-OPTION_005fALIAS-3045"><code>OPTION_ALIAS</code></a>: <a href="Argp-Option-Flags.html#Argp-Option-Flags">Argp Option Flags</a></li>
<li><a href="Argp-Option-Flags.html#index-OPTION_005fARG_005fOPTIONAL-3043"><code>OPTION_ARG_OPTIONAL</code></a>: <a href="Argp-Option-Flags.html#Argp-Option-Flags">Argp Option Flags</a></li>
<li><a href="Argp-Option-Flags.html#index-OPTION_005fDOC-3046"><code>OPTION_DOC</code></a>: <a href="Argp-Option-Flags.html#Argp-Option-Flags">Argp Option Flags</a></li>
<li><a href="Argp-Option-Flags.html#index-OPTION_005fHIDDEN-3044"><code>OPTION_HIDDEN</code></a>: <a href="Argp-Option-Flags.html#Argp-Option-Flags">Argp Option Flags</a></li>
<li><a href="Argp-Option-Flags.html#index-OPTION_005fNO_005fUSAGE-3047"><code>OPTION_NO_USAGE</code></a>: <a href="Argp-Option-Flags.html#Argp-Option-Flags">Argp Option Flags</a></li>
<li><a href="Using-Getopt.html#index-optopt-3025"><code>optopt</code></a>: <a href="Using-Getopt.html#Using-Getopt">Using Getopt</a></li>
<li><a href="Output-Modes.html#index-OXTABS-1886"><code>OXTABS</code></a>: <a href="Output-Modes.html#Output-Modes">Output Modes</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-P_005fCS_005fPRECEDES-777"><code>P_CS_PRECEDES</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-P_005fSEP_005fBY_005fSPACE-778"><code>P_SEP_BY_SPACE</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-P_005fSIGN_005fPOSN-781"><code>P_SIGN_POSN</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="Temporary-Files.html#index-P_005ftmpdir-1609"><code>P_tmpdir</code></a>: <a href="Temporary-Files.html#Temporary-Files">Temporary Files</a></li>
<li><a href="Parsing-a-Template-String.html#index-PA_005fCHAR-1050"><code>PA_CHAR</code></a>: <a href="Parsing-a-Template-String.html#Parsing-a-Template-String">Parsing a Template String</a></li>
<li><a href="Parsing-a-Template-String.html#index-PA_005fDOUBLE-1054"><code>PA_DOUBLE</code></a>: <a href="Parsing-a-Template-String.html#Parsing-a-Template-String">Parsing a Template String</a></li>
<li><a href="Parsing-a-Template-String.html#index-PA_005fFLAG_005fLONG-1058"><code>PA_FLAG_LONG</code></a>: <a href="Parsing-a-Template-String.html#Parsing-a-Template-String">Parsing a Template String</a></li>
<li><a href="Parsing-a-Template-String.html#index-PA_005fFLAG_005fLONG_005fDOUBLE-1060"><code>PA_FLAG_LONG_DOUBLE</code></a>: <a href="Parsing-a-Template-String.html#Parsing-a-Template-String">Parsing a Template String</a></li>
<li><a href="Parsing-a-Template-String.html#index-PA_005fFLAG_005fLONG_005fLONG-1059"><code>PA_FLAG_LONG_LONG</code></a>: <a href="Parsing-a-Template-String.html#Parsing-a-Template-String">Parsing a Template String</a></li>
<li><a href="Parsing-a-Template-String.html#index-PA_005fFLAG_005fMASK-1048"><code>PA_FLAG_MASK</code></a>: <a href="Parsing-a-Template-String.html#Parsing-a-Template-String">Parsing a Template String</a></li>
<li><a href="Parsing-a-Template-String.html#index-PA_005fFLAG_005fPTR-1056"><code>PA_FLAG_PTR</code></a>: <a href="Parsing-a-Template-String.html#Parsing-a-Template-String">Parsing a Template String</a></li>
<li><a href="Parsing-a-Template-String.html#index-PA_005fFLAG_005fSHORT-1057"><code>PA_FLAG_SHORT</code></a>: <a href="Parsing-a-Template-String.html#Parsing-a-Template-String">Parsing a Template String</a></li>
<li><a href="Parsing-a-Template-String.html#index-PA_005fFLOAT-1053"><code>PA_FLOAT</code></a>: <a href="Parsing-a-Template-String.html#Parsing-a-Template-String">Parsing a Template String</a></li>
<li><a href="Parsing-a-Template-String.html#index-PA_005fINT-1049"><code>PA_INT</code></a>: <a href="Parsing-a-Template-String.html#Parsing-a-Template-String">Parsing a Template String</a></li>
<li><a href="Parsing-a-Template-String.html#index-PA_005fLAST-1055"><code>PA_LAST</code></a>: <a href="Parsing-a-Template-String.html#Parsing-a-Template-String">Parsing a Template String</a></li>
<li><a href="Parsing-a-Template-String.html#index-PA_005fPOINTER-1052"><code>PA_POINTER</code></a>: <a href="Parsing-a-Template-String.html#Parsing-a-Template-String">Parsing a Template String</a></li>
<li><a href="Parsing-a-Template-String.html#index-PA_005fSTRING-1051"><code>PA_STRING</code></a>: <a href="Parsing-a-Template-String.html#Parsing-a-Template-String">Parsing a Template String</a></li>
<li><a href="Control-Modes.html#index-PARENB-1895"><code>PARENB</code></a>: <a href="Control-Modes.html#Control-Modes">Control Modes</a></li>
<li><a href="Input-Modes.html#index-PARMRK-1872"><code>PARMRK</code></a>: <a href="Input-Modes.html#Input-Modes">Input Modes</a></li>
<li><a href="Control-Modes.html#index-PARODD-1896"><code>PARODD</code></a>: <a href="Control-Modes.html#Control-Modes">Control Modes</a></li>
<li><a href="NSS-Basics.html#index-passwd-3269"><code>passwd</code></a>: <a href="NSS-Basics.html#NSS-Basics">NSS Basics</a></li>
<li><a href="Limits-for-Files.html#index-PATH_005fMAX-3655"><code>PATH_MAX</code></a>: <a href="Limits-for-Files.html#Limits-for-Files">Limits for Files</a></li>
<li><a href="Local-Modes.html#index-PENDIN-1923"><code>PENDIN</code></a>: <a href="Local-Modes.html#Local-Modes">Local Modes</a></li>
<li><a href="Misc-Namespaces.html#index-PF_005fCCITT-1769"><code>PF_CCITT</code></a>: <a href="Misc-Namespaces.html#Misc-Namespaces">Misc Namespaces</a></li>
<li><a href="Local-Namespace-Details.html#index-PF_005fFILE-1676"><code>PF_FILE</code></a>: <a href="Local-Namespace-Details.html#Local-Namespace-Details">Local Namespace Details</a></li>
<li><a href="Misc-Namespaces.html#index-PF_005fIMPLINK-1770"><code>PF_IMPLINK</code></a>: <a href="Misc-Namespaces.html#Misc-Namespaces">Misc Namespaces</a></li>
<li><a href="Internet-Namespace.html#index-PF_005fINET-1682"><code>PF_INET</code></a>: <a href="Internet-Namespace.html#Internet-Namespace">Internet Namespace</a></li>
<li><a href="Internet-Namespace.html#index-PF_005fINET6-1683"><code>PF_INET6</code></a>: <a href="Internet-Namespace.html#Internet-Namespace">Internet Namespace</a></li>
<li><a href="Misc-Namespaces.html#index-PF_005fISO-1768"><code>PF_ISO</code></a>: <a href="Misc-Namespaces.html#Misc-Namespaces">Misc Namespaces</a></li>
<li><a href="Local-Namespace-Details.html#index-PF_005fLOCAL-1674"><code>PF_LOCAL</code></a>: <a href="Local-Namespace-Details.html#Local-Namespace-Details">Local Namespace Details</a></li>
<li><a href="Misc-Namespaces.html#index-PF_005fNS-1767"><code>PF_NS</code></a>: <a href="Misc-Namespaces.html#Misc-Namespaces">Misc Namespaces</a></li>
<li><a href="Misc-Namespaces.html#index-PF_005fROUTE-1771"><code>PF_ROUTE</code></a>: <a href="Misc-Namespaces.html#Misc-Namespaces">Misc Namespaces</a></li>
<li><a href="Local-Namespace-Details.html#index-PF_005fUNIX-1675"><code>PF_UNIX</code></a>: <a href="Local-Namespace-Details.html#Local-Namespace-Details">Local Namespace Details</a></li>
<li><a href="Mathematical-Constants.html#index-PI-2083"><code>PI</code></a>: <a href="Mathematical-Constants.html#Mathematical-Constants">Mathematical Constants</a></li>
<li><a href="Limits-for-Files.html#index-PIPE_005fBUF-3657"><code>PIPE_BUF</code></a>: <a href="Limits-for-Files.html#Limits-for-Files">Limits for Files</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-PM_005fSTR-756"><code>PM_STR</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-POSITIVE_005fSIGN-773"><code>POSITIVE_SIGN</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="Traditional-Scheduling-Functions.html#index-PRIO_005fMAX-2757"><code>PRIO_MAX</code></a>: <a href="Traditional-Scheduling-Functions.html#Traditional-Scheduling-Functions">Traditional Scheduling Functions</a></li>
<li><a href="Traditional-Scheduling-Functions.html#index-PRIO_005fMIN-2756"><code>PRIO_MIN</code></a>: <a href="Traditional-Scheduling-Functions.html#Traditional-Scheduling-Functions">Traditional Scheduling Functions</a></li>
<li><a href="Traditional-Scheduling-Functions.html#index-PRIO_005fPGRP-2761"><code>PRIO_PGRP</code></a>: <a href="Traditional-Scheduling-Functions.html#Traditional-Scheduling-Functions">Traditional Scheduling Functions</a></li>
<li><a href="Traditional-Scheduling-Functions.html#index-PRIO_005fPROCESS-2760"><code>PRIO_PROCESS</code></a>: <a href="Traditional-Scheduling-Functions.html#Traditional-Scheduling-Functions">Traditional Scheduling Functions</a></li>
<li><a href="Traditional-Scheduling-Functions.html#index-PRIO_005fUSER-2762"><code>PRIO_USER</code></a>: <a href="Traditional-Scheduling-Functions.html#Traditional-Scheduling-Functions">Traditional Scheduling Functions</a></li>
<li><a href="Error-Messages.html#index-program_005finvocation_005fname-216"><code>program_invocation_name</code></a>: <a href="Error-Messages.html#Error-Messages">Error Messages</a></li>
<li><a href="Error-Messages.html#index-program_005finvocation_005fshort_005fname-217"><code>program_invocation_short_name</code></a>: <a href="Error-Messages.html#Error-Messages">Error Messages</a></li>
<li><a href="Memory_002dmapped-I_002fO.html#index-PROT_005fEXEC-1258"><code>PROT_EXEC</code></a>: <a href="Memory_002dmapped-I_002fO.html#Memory_002dmapped-I_002fO">Memory-mapped I/O</a></li>
<li><a href="Memory_002dmapped-I_002fO.html#index-PROT_005fREAD-1256"><code>PROT_READ</code></a>: <a href="Memory_002dmapped-I_002fO.html#Memory_002dmapped-I_002fO">Memory-mapped I/O</a></li>
<li><a href="Memory_002dmapped-I_002fO.html#index-PROT_005fWRITE-1257"><code>PROT_WRITE</code></a>: <a href="Memory_002dmapped-I_002fO.html#Memory_002dmapped-I_002fO">Memory-mapped I/O</a></li>
<li><a href="NSS-Basics.html#index-protocols-3268"><code>protocols</code></a>: <a href="NSS-Basics.html#NSS-Basics">NSS Basics</a></li>
<li><a href="Working-Directory.html#index-PWD-1393"><code>PWD</code></a>: <a href="Working-Directory.html#Working-Directory">Working Directory</a></li>
<li><a href="Testing-File-Access.html#index-R_005fOK-1577"><code>R_OK</code></a>: <a href="Testing-File-Access.html#Testing-File-Access">Testing File Access</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-RADIXCHAR-790"><code>RADIXCHAR</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="ISO-Random.html#index-RAND_005fMAX-2286"><code>RAND_MAX</code></a>: <a href="ISO-Random.html#ISO-Random">ISO Random</a></li>
<li><a href="General-Limits.html#index-RE_005fDUP_005fMAX-3511"><code>RE_DUP_MAX</code></a>: <a href="General-Limits.html#General-Limits">General Limits</a></li>
<li><a href="Limits-on-Resources.html#index-RLIM_005fINFINITY-2730"><code>RLIM_INFINITY</code></a>: <a href="Limits-on-Resources.html#Limits-on-Resources">Limits on Resources</a></li>
<li><a href="Limits-on-Resources.html#index-RLIM_005fNLIMITS-2729"><code>RLIM_NLIMITS</code></a>: <a href="Limits-on-Resources.html#Limits-on-Resources">Limits on Resources</a></li>
<li><a href="Limits-on-Resources.html#index-RLIMIT_005fAS-2728"><code>RLIMIT_AS</code></a>: <a href="Limits-on-Resources.html#Limits-on-Resources">Limits on Resources</a></li>
<li><a href="Limits-on-Resources.html#index-RLIMIT_005fCORE-2724"><code>RLIMIT_CORE</code></a>: <a href="Limits-on-Resources.html#Limits-on-Resources">Limits on Resources</a></li>
<li><a href="Limits-on-Resources.html#index-RLIMIT_005fCPU-2720"><code>RLIMIT_CPU</code></a>: <a href="Limits-on-Resources.html#Limits-on-Resources">Limits on Resources</a></li>
<li><a href="Limits-on-Resources.html#index-RLIMIT_005fDATA-2722"><code>RLIMIT_DATA</code></a>: <a href="Limits-on-Resources.html#Limits-on-Resources">Limits on Resources</a></li>
<li><a href="Limits-on-Resources.html#index-RLIMIT_005fFSIZE-2721"><code>RLIMIT_FSIZE</code></a>: <a href="Limits-on-Resources.html#Limits-on-Resources">Limits on Resources</a></li>
<li><a href="Limits-on-Resources.html#index-RLIMIT_005fNOFILE-2726"><code>RLIMIT_NOFILE</code></a>: <a href="Limits-on-Resources.html#Limits-on-Resources">Limits on Resources</a></li>
<li><a href="Limits-on-Resources.html#index-RLIMIT_005fOFILE-2727"><code>RLIMIT_OFILE</code></a>: <a href="Limits-on-Resources.html#Limits-on-Resources">Limits on Resources</a></li>
<li><a href="Limits-on-Resources.html#index-RLIMIT_005fRSS-2725"><code>RLIMIT_RSS</code></a>: <a href="Limits-on-Resources.html#Limits-on-Resources">Limits on Resources</a></li>
<li><a href="Limits-on-Resources.html#index-RLIMIT_005fSTACK-2723"><code>RLIMIT_STACK</code></a>: <a href="Limits-on-Resources.html#Limits-on-Resources">Limits on Resources</a></li>
<li><a href="NSS-Basics.html#index-rpc-3270"><code>rpc</code></a>: <a href="NSS-Basics.html#NSS-Basics">NSS Basics</a></li>
<li><a href="XPG-Functions.html#index-RUN_005fLVL-3366"><code>RUN_LVL</code></a>: <a href="XPG-Functions.html#XPG-Functions">XPG Functions</a></li>
<li><a href="Manipulating-the-Database.html#index-RUN_005fLVL-3341"><code>RUN_LVL</code></a>: <a href="Manipulating-the-Database.html#Manipulating-the-Database">Manipulating the Database</a></li>
<li><a href="Permission-Bits.html#index-S_005fIEXEC-1545"><code>S_IEXEC</code></a>: <a href="Permission-Bits.html#Permission-Bits">Permission Bits</a></li>
<li><a href="Testing-File-Type.html#index-S_005fIFBLK-1522"><code>S_IFBLK</code></a>: <a href="Testing-File-Type.html#Testing-File-Type">Testing File Type</a></li>
<li><a href="Testing-File-Type.html#index-S_005fIFCHR-1521"><code>S_IFCHR</code></a>: <a href="Testing-File-Type.html#Testing-File-Type">Testing File Type</a></li>
<li><a href="Testing-File-Type.html#index-S_005fIFDIR-1520"><code>S_IFDIR</code></a>: <a href="Testing-File-Type.html#Testing-File-Type">Testing File Type</a></li>
<li><a href="Testing-File-Type.html#index-S_005fIFIFO-1526"><code>S_IFIFO</code></a>: <a href="Testing-File-Type.html#Testing-File-Type">Testing File Type</a></li>
<li><a href="Testing-File-Type.html#index-S_005fIFLNK-1524"><code>S_IFLNK</code></a>: <a href="Testing-File-Type.html#Testing-File-Type">Testing File Type</a></li>
<li><a href="Testing-File-Type.html#index-S_005fIFMT-1519"><code>S_IFMT</code></a>: <a href="Testing-File-Type.html#Testing-File-Type">Testing File Type</a></li>
<li><a href="Testing-File-Type.html#index-S_005fIFREG-1523"><code>S_IFREG</code></a>: <a href="Testing-File-Type.html#Testing-File-Type">Testing File Type</a></li>
<li><a href="Testing-File-Type.html#index-S_005fIFSOCK-1525"><code>S_IFSOCK</code></a>: <a href="Testing-File-Type.html#Testing-File-Type">Testing File Type</a></li>
<li><a href="Permission-Bits.html#index-S_005fIREAD-1541"><code>S_IREAD</code></a>: <a href="Permission-Bits.html#Permission-Bits">Permission Bits</a></li>
<li><a href="Permission-Bits.html#index-S_005fIRGRP-1547"><code>S_IRGRP</code></a>: <a href="Permission-Bits.html#Permission-Bits">Permission Bits</a></li>
<li><a href="Permission-Bits.html#index-S_005fIROTH-1551"><code>S_IROTH</code></a>: <a href="Permission-Bits.html#Permission-Bits">Permission Bits</a></li>
<li><a href="Permission-Bits.html#index-S_005fIRUSR-1540"><code>S_IRUSR</code></a>: <a href="Permission-Bits.html#Permission-Bits">Permission Bits</a></li>
<li><a href="Permission-Bits.html#index-S_005fIRWXG-1550"><code>S_IRWXG</code></a>: <a href="Permission-Bits.html#Permission-Bits">Permission Bits</a></li>
<li><a href="Permission-Bits.html#index-S_005fIRWXO-1554"><code>S_IRWXO</code></a>: <a href="Permission-Bits.html#Permission-Bits">Permission Bits</a></li>
<li><a href="Permission-Bits.html#index-S_005fIRWXU-1546"><code>S_IRWXU</code></a>: <a href="Permission-Bits.html#Permission-Bits">Permission Bits</a></li>
<li><a href="Permission-Bits.html#index-S_005fISGID-1556"><code>S_ISGID</code></a>: <a href="Permission-Bits.html#Permission-Bits">Permission Bits</a></li>
<li><a href="Permission-Bits.html#index-S_005fISUID-1555"><code>S_ISUID</code></a>: <a href="Permission-Bits.html#Permission-Bits">Permission Bits</a></li>
<li><a href="Permission-Bits.html#index-S_005fISVTX-1558"><code>S_ISVTX</code></a>: <a href="Permission-Bits.html#Permission-Bits">Permission Bits</a></li>
<li><a href="Permission-Bits.html#index-S_005fIWGRP-1548"><code>S_IWGRP</code></a>: <a href="Permission-Bits.html#Permission-Bits">Permission Bits</a></li>
<li><a href="Permission-Bits.html#index-S_005fIWOTH-1552"><code>S_IWOTH</code></a>: <a href="Permission-Bits.html#Permission-Bits">Permission Bits</a></li>
<li><a href="Permission-Bits.html#index-S_005fIWRITE-1543"><code>S_IWRITE</code></a>: <a href="Permission-Bits.html#Permission-Bits">Permission Bits</a></li>
<li><a href="Permission-Bits.html#index-S_005fIWUSR-1542"><code>S_IWUSR</code></a>: <a href="Permission-Bits.html#Permission-Bits">Permission Bits</a></li>
<li><a href="Permission-Bits.html#index-S_005fIXGRP-1549"><code>S_IXGRP</code></a>: <a href="Permission-Bits.html#Permission-Bits">Permission Bits</a></li>
<li><a href="Permission-Bits.html#index-S_005fIXOTH-1553"><code>S_IXOTH</code></a>: <a href="Permission-Bits.html#Permission-Bits">Permission Bits</a></li>
<li><a href="Permission-Bits.html#index-S_005fIXUSR-1544"><code>S_IXUSR</code></a>: <a href="Permission-Bits.html#Permission-Bits">Permission Bits</a></li>
<li><a href="Flags-for-Sigaction.html#index-SA_005fNOCLDSTOP-2926"><code>SA_NOCLDSTOP</code></a>: <a href="Flags-for-Sigaction.html#Flags-for-Sigaction">Flags for Sigaction</a></li>
<li><a href="Flags-for-Sigaction.html#index-SA_005fONSTACK-2927"><code>SA_ONSTACK</code></a>: <a href="Flags-for-Sigaction.html#Flags-for-Sigaction">Flags for Sigaction</a></li>
<li><a href="Flags-for-Sigaction.html#index-SA_005fRESTART-2928"><code>SA_RESTART</code></a>: <a href="Flags-for-Sigaction.html#Flags-for-Sigaction">Flags for Sigaction</a></li>
<li><a href="Constants-for-Sysconf.html#index-SC_005fSSIZE_005fMAX-3632"><code>SC_SSIZE_MAX</code></a>: <a href="Constants-for-Sysconf.html#Constants-for-Sysconf">Constants for Sysconf</a></li>
<li><a href="Range-of-Type.html#index-SCHAR_005fMAX-3749"><code>SCHAR_MAX</code></a>: <a href="Range-of-Type.html#Range-of-Type">Range of Type</a></li>
<li><a href="Range-of-Type.html#index-SCHAR_005fMIN-3748"><code>SCHAR_MIN</code></a>: <a href="Range-of-Type.html#Range-of-Type">Range of Type</a></li>
<li><a href="File-Positioning.html#index-SEEK_005fCUR-1118"><code>SEEK_CUR</code></a>: <a href="File-Positioning.html#File-Positioning">File Positioning</a></li>
<li><a href="File-Positioning.html#index-SEEK_005fEND-1119"><code>SEEK_END</code></a>: <a href="File-Positioning.html#File-Positioning">File Positioning</a></li>
<li><a href="File-Positioning.html#index-SEEK_005fSET-1117"><code>SEEK_SET</code></a>: <a href="File-Positioning.html#File-Positioning">File Positioning</a></li>
<li><a href="NSS-Basics.html#index-services-3271"><code>services</code></a>: <a href="NSS-Basics.html#NSS-Basics">NSS Basics</a></li>
<li><a href="NSS-Basics.html#index-shadow-3272"><code>shadow</code></a>: <a href="NSS-Basics.html#NSS-Basics">NSS Basics</a></li>
<li><a href="Range-of-Type.html#index-SHRT_005fMAX-3754"><code>SHRT_MAX</code></a>: <a href="Range-of-Type.html#Range-of-Type">Range of Type</a></li>
<li><a href="Range-of-Type.html#index-SHRT_005fMIN-3753"><code>SHRT_MIN</code></a>: <a href="Range-of-Type.html#Range-of-Type">Range of Type</a></li>
<li><a href="Process-Signal-Mask.html#index-SIG_005fBLOCK-2969"><code>SIG_BLOCK</code></a>: <a href="Process-Signal-Mask.html#Process-Signal-Mask">Process Signal Mask</a></li>
<li><a href="Basic-Signal-Handling.html#index-SIG_005fDFL-2911"><code>SIG_DFL</code></a>: <a href="Basic-Signal-Handling.html#Basic-Signal-Handling">Basic Signal Handling</a></li>
<li><a href="Basic-Signal-Handling.html#index-SIG_005fERR-2917"><code>SIG_ERR</code></a>: <a href="Basic-Signal-Handling.html#Basic-Signal-Handling">Basic Signal Handling</a></li>
<li><a href="Basic-Signal-Handling.html#index-SIG_005fIGN-2913"><code>SIG_IGN</code></a>: <a href="Basic-Signal-Handling.html#Basic-Signal-Handling">Basic Signal Handling</a></li>
<li><a href="Process-Signal-Mask.html#index-SIG_005fSETMASK-2971"><code>SIG_SETMASK</code></a>: <a href="Process-Signal-Mask.html#Process-Signal-Mask">Process Signal Mask</a></li>
<li><a href="Process-Signal-Mask.html#index-SIG_005fUNBLOCK-2970"><code>SIG_UNBLOCK</code></a>: <a href="Process-Signal-Mask.html#Process-Signal-Mask">Process Signal Mask</a></li>
<li><a href="Program-Error-Signals.html#index-SIGABRT-2842"><code>SIGABRT</code></a>: <a href="Program-Error-Signals.html#Program-Error-Signals">Program Error Signals</a></li>
<li><a href="Alarm-Signals.html#index-SIGALRM-2861"><code>SIGALRM</code></a>: <a href="Alarm-Signals.html#Alarm-Signals">Alarm Signals</a></li>
<li><a href="Program-Error-Signals.html#index-SIGBUS-2840"><code>SIGBUS</code></a>: <a href="Program-Error-Signals.html#Program-Error-Signals">Program Error Signals</a></li>
<li><a href="Job-Control-Signals.html#index-SIGCHLD-2874"><code>SIGCHLD</code></a>: <a href="Job-Control-Signals.html#Job-Control-Signals">Job Control Signals</a></li>
<li><a href="Job-Control-Signals.html#index-SIGCLD-2876"><code>SIGCLD</code></a>: <a href="Job-Control-Signals.html#Job-Control-Signals">Job Control Signals</a></li>
<li><a href="Job-Control-Signals.html#index-SIGCONT-2877"><code>SIGCONT</code></a>: <a href="Job-Control-Signals.html#Job-Control-Signals">Job Control Signals</a></li>
<li><a href="Program-Error-Signals.html#index-SIGEMT-2846"><code>SIGEMT</code></a>: <a href="Program-Error-Signals.html#Program-Error-Signals">Program Error Signals</a></li>
<li><a href="Program-Error-Signals.html#index-SIGFPE-2826"><code>SIGFPE</code></a>: <a href="Program-Error-Signals.html#Program-Error-Signals">Program Error Signals</a></li>
<li><a href="Termination-Signals.html#index-SIGHUP-2859"><code>SIGHUP</code></a>: <a href="Termination-Signals.html#Termination-Signals">Termination Signals</a></li>
<li><a href="Program-Error-Signals.html#index-SIGILL-2836"><code>SIGILL</code></a>: <a href="Program-Error-Signals.html#Program-Error-Signals">Program Error Signals</a></li>
<li><a href="Miscellaneous-Signals.html#index-SIGINFO-2898"><code>SIGINFO</code></a>: <a href="Miscellaneous-Signals.html#Miscellaneous-Signals">Miscellaneous Signals</a></li>
<li><a href="Termination-Signals.html#index-SIGINT-2852"><code>SIGINT</code></a>: <a href="Termination-Signals.html#Termination-Signals">Termination Signals</a></li>
<li><a href="Asynchronous-I_002fO-Signals.html#index-SIGIO-2867"><code>SIGIO</code></a>: <a href="Asynchronous-I_002fO-Signals.html#Asynchronous-I_002fO-Signals">Asynchronous I/O Signals</a></li>
<li><a href="Program-Error-Signals.html#index-SIGIOT-2844"><code>SIGIOT</code></a>: <a href="Program-Error-Signals.html#Program-Error-Signals">Program Error Signals</a></li>
<li><a href="Termination-Signals.html#index-SIGKILL-2857"><code>SIGKILL</code></a>: <a href="Termination-Signals.html#Termination-Signals">Termination Signals</a></li>
<li><a href="Operation-Error-Signals.html#index-SIGLOST-2890"><code>SIGLOST</code></a>: <a href="Operation-Error-Signals.html#Operation-Error-Signals">Operation Error Signals</a></li>
<li><a href="Special-Functions.html#index-signgam-2252"><code>signgam</code></a>: <a href="Special-Functions.html#Special-Functions">Special Functions</a></li>
<li><a href="Operation-Error-Signals.html#index-SIGPIPE-2887"><code>SIGPIPE</code></a>: <a href="Operation-Error-Signals.html#Operation-Error-Signals">Operation Error Signals</a></li>
<li><a href="Asynchronous-I_002fO-Signals.html#index-SIGPOLL-2872"><code>SIGPOLL</code></a>: <a href="Asynchronous-I_002fO-Signals.html#Asynchronous-I_002fO-Signals">Asynchronous I/O Signals</a></li>
<li><a href="Alarm-Signals.html#index-SIGPROF-2865"><code>SIGPROF</code></a>: <a href="Alarm-Signals.html#Alarm-Signals">Alarm Signals</a></li>
<li><a href="Termination-Signals.html#index-SIGQUIT-2854"><code>SIGQUIT</code></a>: <a href="Termination-Signals.html#Termination-Signals">Termination Signals</a></li>
<li><a href="Program-Error-Signals.html#index-SIGSEGV-2838"><code>SIGSEGV</code></a>: <a href="Program-Error-Signals.html#Program-Error-Signals">Program Error Signals</a></li>
<li><a href="Signal-Stack.html#index-SIGSTKSZ-2984"><code>SIGSTKSZ</code></a>: <a href="Signal-Stack.html#Signal-Stack">Signal Stack</a></li>
<li><a href="Job-Control-Signals.html#index-SIGSTOP-2879"><code>SIGSTOP</code></a>: <a href="Job-Control-Signals.html#Job-Control-Signals">Job Control Signals</a></li>
<li><a href="Program-Error-Signals.html#index-SIGSYS-2847"><code>SIGSYS</code></a>: <a href="Program-Error-Signals.html#Program-Error-Signals">Program Error Signals</a></li>
<li><a href="Termination-Signals.html#index-SIGTERM-2849"><code>SIGTERM</code></a>: <a href="Termination-Signals.html#Termination-Signals">Termination Signals</a></li>
<li><a href="Program-Error-Signals.html#index-SIGTRAP-2845"><code>SIGTRAP</code></a>: <a href="Program-Error-Signals.html#Program-Error-Signals">Program Error Signals</a></li>
<li><a href="Job-Control-Signals.html#index-SIGTSTP-2881"><code>SIGTSTP</code></a>: <a href="Job-Control-Signals.html#Job-Control-Signals">Job Control Signals</a></li>
<li><a href="Job-Control-Signals.html#index-SIGTTIN-2883"><code>SIGTTIN</code></a>: <a href="Job-Control-Signals.html#Job-Control-Signals">Job Control Signals</a></li>
<li><a href="Job-Control-Signals.html#index-SIGTTOU-2885"><code>SIGTTOU</code></a>: <a href="Job-Control-Signals.html#Job-Control-Signals">Job Control Signals</a></li>
<li><a href="Asynchronous-I_002fO-Signals.html#index-SIGURG-2870"><code>SIGURG</code></a>: <a href="Asynchronous-I_002fO-Signals.html#Asynchronous-I_002fO-Signals">Asynchronous I/O Signals</a></li>
<li><a href="Miscellaneous-Signals.html#index-SIGUSR1-2894"><code>SIGUSR1</code></a>: <a href="Miscellaneous-Signals.html#Miscellaneous-Signals">Miscellaneous Signals</a></li>
<li><a href="Miscellaneous-Signals.html#index-SIGUSR2-2895"><code>SIGUSR2</code></a>: <a href="Miscellaneous-Signals.html#Miscellaneous-Signals">Miscellaneous Signals</a></li>
<li><a href="Alarm-Signals.html#index-SIGVTALRM-2863"><code>SIGVTALRM</code></a>: <a href="Alarm-Signals.html#Alarm-Signals">Alarm Signals</a></li>
<li><a href="Miscellaneous-Signals.html#index-SIGWINCH-2897"><code>SIGWINCH</code></a>: <a href="Miscellaneous-Signals.html#Miscellaneous-Signals">Miscellaneous Signals</a></li>
<li><a href="Operation-Error-Signals.html#index-SIGXCPU-2892"><code>SIGXCPU</code></a>: <a href="Operation-Error-Signals.html#Operation-Error-Signals">Operation Error Signals</a></li>
<li><a href="Operation-Error-Signals.html#index-SIGXFSZ-2893"><code>SIGXFSZ</code></a>: <a href="Operation-Error-Signals.html#Operation-Error-Signals">Operation Error Signals</a></li>
<li><a href="Communication-Styles.html#index-SOCK_005fDGRAM-1649"><code>SOCK_DGRAM</code></a>: <a href="Communication-Styles.html#Communication-Styles">Communication Styles</a></li>
<li><a href="Communication-Styles.html#index-SOCK_005fRAW-1650"><code>SOCK_RAW</code></a>: <a href="Communication-Styles.html#Communication-Styles">Communication Styles</a></li>
<li><a href="Communication-Styles.html#index-SOCK_005fSTREAM-1648"><code>SOCK_STREAM</code></a>: <a href="Communication-Styles.html#Communication-Styles">Communication Styles</a></li>
<li><a href="Socket_002dLevel-Options.html#index-SOL_005fSOCKET-1831"><code>SOL_SOCKET</code></a>: <a href="Socket_002dLevel-Options.html#Socket_002dLevel-Options">Socket-Level Options</a></li>
<li><a href="Signal-Stack.html#index-SS_005fDISABLE-2986"><code>SS_DISABLE</code></a>: <a href="Signal-Stack.html#Signal-Stack">Signal Stack</a></li>
<li><a href="Signal-Stack.html#index-SS_005fONSTACK-2987"><code>SS_ONSTACK</code></a>: <a href="Signal-Stack.html#Signal-Stack">Signal Stack</a></li>
<li><a href="General-Limits.html#index-SSIZE_005fMAX-3510"><code>SSIZE_MAX</code></a>: <a href="General-Limits.html#General-Limits">General Limits</a></li>
<li><a href="Standard-Streams.html#index-stderr-925"><code>stderr</code></a>: <a href="Standard-Streams.html#Standard-Streams">Standard Streams</a></li>
<li><a href="Descriptors-and-Streams.html#index-STDERR_005fFILENO-1240"><code>STDERR_FILENO</code></a>: <a href="Descriptors-and-Streams.html#Descriptors-and-Streams">Descriptors and Streams</a></li>
<li><a href="Standard-Streams.html#index-stdin-921"><code>stdin</code></a>: <a href="Standard-Streams.html#Standard-Streams">Standard Streams</a></li>
<li><a href="Descriptors-and-Streams.html#index-STDIN_005fFILENO-1236"><code>STDIN_FILENO</code></a>: <a href="Descriptors-and-Streams.html#Descriptors-and-Streams">Descriptors and Streams</a></li>
<li><a href="Standard-Streams.html#index-stdout-923"><code>stdout</code></a>: <a href="Standard-Streams.html#Standard-Streams">Standard Streams</a></li>
<li><a href="Descriptors-and-Streams.html#index-STDOUT_005fFILENO-1238"><code>STDOUT_FILENO</code></a>: <a href="Descriptors-and-Streams.html#Descriptors-and-Streams">Descriptors and Streams</a></li>
<li><a href="General-Limits.html#index-STREAM_005fMAX-3505"><code>STREAM_MAX</code></a>: <a href="General-Limits.html#General-Limits">General Limits</a></li>
<li><a href="BSD-Handler.html#index-SV_005fINTERRUPT-2994"><code>SV_INTERRUPT</code></a>: <a href="BSD-Handler.html#BSD-Handler">BSD Handler</a></li>
<li><a href="BSD-Handler.html#index-SV_005fONSTACK-2993"><code>SV_ONSTACK</code></a>: <a href="BSD-Handler.html#BSD-Handler">BSD Handler</a></li>
<li><a href="BSD-Handler.html#index-SV_005fRESETHAND-2995"><code>SV_RESETHAND</code></a>: <a href="BSD-Handler.html#BSD-Handler">BSD Handler</a></li>
<li><a href="Signal-Messages.html#index-sys_005fsiglist-2904"><code>sys_siglist</code></a>: <a href="Signal-Messages.html#Signal-Messages">Signal Messages</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-T_005fFMT-759"><code>T_FMT</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-T_005fFMT_005fAMPM-760"><code>T_FMT_AMPM</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="Line-Control.html#index-TCIFLUSH-2010"><code>TCIFLUSH</code></a>: <a href="Line-Control.html#Line-Control">Line Control</a></li>
<li><a href="Line-Control.html#index-TCIOFF-2018"><code>TCIOFF</code></a>: <a href="Line-Control.html#Line-Control">Line Control</a></li>
<li><a href="Line-Control.html#index-TCIOFLUSH-2012"><code>TCIOFLUSH</code></a>: <a href="Line-Control.html#Line-Control">Line Control</a></li>
<li><a href="Line-Control.html#index-TCION-2019"><code>TCION</code></a>: <a href="Line-Control.html#Line-Control">Line Control</a></li>
<li><a href="Line-Control.html#index-TCOFLUSH-2011"><code>TCOFLUSH</code></a>: <a href="Line-Control.html#Line-Control">Line Control</a></li>
<li><a href="Line-Control.html#index-TCOOFF-2016"><code>TCOOFF</code></a>: <a href="Line-Control.html#Line-Control">Line Control</a></li>
<li><a href="Line-Control.html#index-TCOON-2017"><code>TCOON</code></a>: <a href="Line-Control.html#Line-Control">Line Control</a></li>
<li><a href="Mode-Functions.html#index-TCSADRAIN-1866"><code>TCSADRAIN</code></a>: <a href="Mode-Functions.html#Mode-Functions">Mode Functions</a></li>
<li><a href="Mode-Functions.html#index-TCSAFLUSH-1867"><code>TCSAFLUSH</code></a>: <a href="Mode-Functions.html#Mode-Functions">Mode Functions</a></li>
<li><a href="Mode-Functions.html#index-TCSANOW-1865"><code>TCSANOW</code></a>: <a href="Mode-Functions.html#Mode-Functions">Mode Functions</a></li>
<li><a href="Mode-Functions.html#index-TCSASOFT-1868"><code>TCSASOFT</code></a>: <a href="Mode-Functions.html#Mode-Functions">Mode Functions</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-THOUSANDS_005fSEP-791"><code>THOUSANDS_SEP</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-THOUSEP-792"><code>THOUSEP</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="Time-Zone-Functions.html#index-timezone-2676"><code>timezone</code></a>: <a href="Time-Zone-Functions.html#Time-Zone-Functions">Time Zone Functions</a></li>
<li><a href="Temporary-Files.html#index-TMP_005fMAX-1606"><code>TMP_MAX</code></a>: <a href="Temporary-Files.html#Temporary-Files">Temporary Files</a></li>
<li><a href="Local-Modes.html#index-TOSTOP-1919"><code>TOSTOP</code></a>: <a href="Local-Modes.html#Local-Modes">Local Modes</a></li>
<li><a href="Host-Names.html#index-TRY_005fAGAIN-1723"><code>TRY_AGAIN</code></a>: <a href="Host-Names.html#Host-Names">Host Names</a></li>
<li><a href="Time-Zone-Functions.html#index-tzname-2674"><code>tzname</code></a>: <a href="Time-Zone-Functions.html#Time-Zone-Functions">Time Zone Functions</a></li>
<li><a href="General-Limits.html#index-TZNAME_005fMAX-3507"><code>TZNAME_MAX</code></a>: <a href="General-Limits.html#General-Limits">General Limits</a></li>
<li><a href="Range-of-Type.html#index-UCHAR_005fMAX-3750"><code>UCHAR_MAX</code></a>: <a href="Range-of-Type.html#Range-of-Type">Range of Type</a></li>
<li><a href="Range-of-Type.html#index-UINT_005fMAX-3758"><code>UINT_MAX</code></a>: <a href="Range-of-Type.html#Range-of-Type">Range of Type</a></li>
<li><a href="Range-of-Type.html#index-ULONG_005fLONG_005fMAX-3764"><code>ULONG_LONG_MAX</code></a>: <a href="Range-of-Type.html#Range-of-Type">Range of Type</a></li>
<li><a href="Range-of-Type.html#index-ULONG_005fMAX-3761"><code>ULONG_MAX</code></a>: <a href="Range-of-Type.html#Range-of-Type">Range of Type</a></li>
<li><a href="XPG-Functions.html#index-USER_005fPROCESS-3372"><code>USER_PROCESS</code></a>: <a href="XPG-Functions.html#XPG-Functions">XPG Functions</a></li>
<li><a href="Manipulating-the-Database.html#index-USER_005fPROCESS-3347"><code>USER_PROCESS</code></a>: <a href="Manipulating-the-Database.html#Manipulating-the-Database">Manipulating the Database</a></li>
<li><a href="Range-of-Type.html#index-USHRT_005fMAX-3755"><code>USHRT_MAX</code></a>: <a href="Range-of-Type.html#Range-of-Type">Range of Type</a></li>
<li><a href="Other-Special.html#index-VDISCARD-1988"><code>VDISCARD</code></a>: <a href="Other-Special.html#Other-Special">Other Special</a></li>
<li><a href="Signal-Characters.html#index-VDSUSP-1979"><code>VDSUSP</code></a>: <a href="Signal-Characters.html#Signal-Characters">Signal Characters</a></li>
<li><a href="Editing-Characters.html#index-VEOF-1957"><code>VEOF</code></a>: <a href="Editing-Characters.html#Editing-Characters">Editing Characters</a></li>
<li><a href="Editing-Characters.html#index-VEOL-1959"><code>VEOL</code></a>: <a href="Editing-Characters.html#Editing-Characters">Editing Characters</a></li>
<li><a href="Editing-Characters.html#index-VEOL2-1961"><code>VEOL2</code></a>: <a href="Editing-Characters.html#Editing-Characters">Editing Characters</a></li>
<li><a href="Editing-Characters.html#index-VERASE-1963"><code>VERASE</code></a>: <a href="Editing-Characters.html#Editing-Characters">Editing Characters</a></li>
<li><a href="Signal-Characters.html#index-VINTR-1971"><code>VINTR</code></a>: <a href="Signal-Characters.html#Signal-Characters">Signal Characters</a></li>
<li><a href="Editing-Characters.html#index-VKILL-1967"><code>VKILL</code></a>: <a href="Editing-Characters.html#Editing-Characters">Editing Characters</a></li>
<li><a href="Other-Special.html#index-VLNEXT-1986"><code>VLNEXT</code></a>: <a href="Other-Special.html#Other-Special">Other Special</a></li>
<li><a href="Noncanonical-Input.html#index-VMIN-1992"><code>VMIN</code></a>: <a href="Noncanonical-Input.html#Noncanonical-Input">Noncanonical Input</a></li>
<li><a href="Signal-Characters.html#index-VQUIT-1974"><code>VQUIT</code></a>: <a href="Signal-Characters.html#Signal-Characters">Signal Characters</a></li>
<li><a href="Editing-Characters.html#index-VREPRINT-1969"><code>VREPRINT</code></a>: <a href="Editing-Characters.html#Editing-Characters">Editing Characters</a></li>
<li><a href="Start_002fStop-Characters.html#index-VSTART-1982"><code>VSTART</code></a>: <a href="Start_002fStop-Characters.html#Start_002fStop-Characters">Start/Stop Characters</a></li>
<li><a href="Other-Special.html#index-VSTATUS-1990"><code>VSTATUS</code></a>: <a href="Other-Special.html#Other-Special">Other Special</a></li>
<li><a href="Start_002fStop-Characters.html#index-VSTOP-1984"><code>VSTOP</code></a>: <a href="Start_002fStop-Characters.html#Start_002fStop-Characters">Start/Stop Characters</a></li>
<li><a href="Signal-Characters.html#index-VSUSP-1976"><code>VSUSP</code></a>: <a href="Signal-Characters.html#Signal-Characters">Signal Characters</a></li>
<li><a href="Noncanonical-Input.html#index-VTIME-1994"><code>VTIME</code></a>: <a href="Noncanonical-Input.html#Noncanonical-Input">Noncanonical Input</a></li>
<li><a href="Editing-Characters.html#index-VWERASE-1965"><code>VWERASE</code></a>: <a href="Editing-Characters.html#Editing-Characters">Editing Characters</a></li>
<li><a href="Testing-File-Access.html#index-W_005fOK-1578"><code>W_OK</code></a>: <a href="Testing-File-Access.html#Testing-File-Access">Testing File Access</a></li>
<li><a href="Range-of-Type.html#index-WCHAR_005fMAX-3765"><code>WCHAR_MAX</code></a>: <a href="Range-of-Type.html#Range-of-Type">Range of Type</a></li>
<li><a href="Extended-Char-Intro.html#index-WCHAR_005fMAX-622"><code>WCHAR_MAX</code></a>: <a href="Extended-Char-Intro.html#Extended-Char-Intro">Extended Char Intro</a></li>
<li><a href="Extended-Char-Intro.html#index-WCHAR_005fMIN-621"><code>WCHAR_MIN</code></a>: <a href="Extended-Char-Intro.html#Extended-Char-Intro">Extended Char Intro</a></li>
<li><a href="EOF-and-Errors.html#index-WEOF-1097"><code>WEOF</code></a>: <a href="EOF-and-Errors.html#EOF-and-Errors">EOF and Errors</a></li>
<li><a href="Extended-Char-Intro.html#index-WEOF-623"><code>WEOF</code></a>: <a href="Extended-Char-Intro.html#Extended-Char-Intro">Extended Char Intro</a></li>
<li><a href="Testing-File-Access.html#index-X_005fOK-1579"><code>X_OK</code></a>: <a href="Testing-File-Access.html#Testing-File-Access">Testing File Access</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-YESEXPR-794"><code>YESEXPR</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
<li><a href="The-Elegant-and-Fast-Way.html#index-YESSTR-796"><code>YESSTR</code></a>: <a href="The-Elegant-and-Fast-Way.html#The-Elegant-and-Fast-Way">The Elegant and Fast Way</a></li>
   </ul></body></html>

