[This Glossary is automatically generated from the Unit files.  Do not edit
this file or your changes will be lost.  Edit the appropriate Unit instead.]

This file contains a listing of all the C preprocessor symbols and shell
variables whose value can be determined by a Configure script.  For the
most part, any symbol in UPPERCASE is a C preprocessor symbol, and
will be defined in config.h.  Symbols in lowercase are shell variables,
and are defined in config.sh.

If you write your shell scripts and C programs in terms of these symbols,
metaconfig can automatically build you a Configure script that will determine
the value of those symbols.  See the README file for a description of how
to use metaconfig.

In the following listing, the Unit: line indicates the name of the unit
where this symbol is defined, and the Wants: line indicates what other
symbols must be determined in order to figure out the value of this one.
If there is an "(Also defines ...)" entry, it indicates what other symbols
are defined by the Unit other than the one corresponding to the unit name.

Variable of the form d_* either have the value "define" or "/*define", and
control whether some C preprocessor symbol gets defined or not.

ABORTSIG:
	Unit: abortsig
	Wants: Myread Oldconfig Guess cat ccflags rm
	Optional: cc

	This symbol holds the signal number (symbol) used by the abort() call. To
	actually define the signal symbol, <signal.h> should be included.

ACTIVE:
	Unit: active (Also defines activeexp)
	Wants: newslib Oldconfig Getfile

	The name of the active file for the news system.  This file contains
	the list of active newsgroups.  The name may have ~ on the front.

ACTIVE_EXP:
	Unit: active (Also defines activeexp)
	Wants: newslib Oldconfig Getfile

	This is the same as ACTIVE, but is filename expanded at configuration
	time, for programs that do not want to deal with it themselves.

ALIGNBYTES:
	Obsoleted by MEM_ALIGNBYTES.

ARCHLIB:
	Unit: archlib (Also defines d_archlib archlibexp installarchlib)
	Wants: archname afs spackage cat Getfile Loc Oldconfig prefixexp
	  privlib test Prefixit Prefixup

	This variable, if defined, holds the name of the directory in
	which the user wants to put architecture-dependent public
	library files for $package.  It is most often a local directory
	such as /usr/local/lib.  Programs using this variable must be
	prepared to deal with filename expansion.  If ARCHLIB is the
	same as PRIVLIB, it is not defined, since presumably the
	program already searches PRIVLIB.

ARCHLIB_EXP:
	Unit: archlib (Also defines d_archlib archlibexp installarchlib)
	Wants: archname afs spackage cat Getfile Loc Oldconfig prefixexp
	  privlib test Prefixit Prefixup

	This symbol contains the ~name expanded version of ARCHLIB, to be used
	in programs that are not prepared to deal with ~ expansion at run-time.

ARCHNAME:
	Unit: archname (Also defines myarchname)
	Wants: sed Loc Myread Oldconfig osname test rm

	This symbol holds a string representing the architecture name.
	It may be used to construct an architecture-dependant pathname
	where library files may be held under a private library, for
	instance.

BASICSHELL:
	Unit: basicshell
	Wants: Getfile Oldconfig bash csh ksh sh

	This symbol contains the full name of the basic script shell on this
	system.  Usual values are /bin/sh, /bin/ksh, /bin/csh.

BERKNAMES:
	Unit: nametype (Also defines d_passnames d_berknames d_usgnames)
	Wants: Myread Guess Oldconfig cat

	This symbol, if defined, indicates that full names are stored in
	the /etc/passwd file in Berkeley format (name first thing, everything
	up to first comma, with & replaced by capitalized login id, yuck).

BIN:
	Unit: bin (Also defines binexp installbin)
	Wants: Prefixit Getfile Oldconfig afs cat test

	This symbol holds the path of the bin directory where the package will
	be installed. Program must be prepared to deal with ~name substitution.

BIN_EXP:
	Unit: bin (Also defines binexp installbin)
	Wants: Prefixit Getfile Oldconfig afs cat test

	This symbol is the filename expanded version of the BIN symbol, for
	programs that do not want to deal with that at run-time.

BITS_PER_BYTE:
	Unit: bitpbyte
	Wants: cat rm Myread
	Optional: cc ccflags

	This symbol contains the number of bits in a byte, so that the C
	preprocessor can make decisions based on it.

BSD:
	Unit: Guess (Also defines d_eunice d_xenix d_bsd)
	Wants: cat test echo n c contains rm Loc eunicefix

	This symbol, if defined, indicates that the program is running under
	a BSD system.

BSDJMP:
	Obsoleted by USE_BSDJMP.

BSDPGRP:
	Obsoleted by USE_BSD_SETPGRP.

BYTEORDER:
	Unit: byteorder
	Wants: cat Myread Oldconfig Loc rm
	Optional: cc ccflags

	This symbol hold the hexadecimal constant defined in byteorder,
	i.e. 0x1234 or 0x4321, etc...

CAN_KEEPALIVE:
	Unit: sockopt (Also defines d_keepalive)
	Wants: cat rm contains socketlib sockethdr d_oldsock libs Oldconfig
	  Setvar Findhdr
	Optional: cc ccflags

	This symbol if defined indicates to the C program that the SO_KEEPALIVE
	option of setsockopt() will work as advertised in the manual.

CAN_PROTOTYPE:
	Unit: prototype
	Wants: Myread Oldconfig cat rm Setvar
	Optional: cc ccflags

	If defined, this macro indicates that the C compiler can handle
	function prototypes.

CAN_VAPROTO:
	Unit: vaproto
	Wants: prototype i_stdarg Setvar

	This variable is defined on systems supporting prototype declaration
	of functions with a variable number of arguments.

CASTFLAGS:
	Unit: d_castneg (Also defines castflags)
	Wants: cat rm Setvar signal_t
	Optional: cc ccflags

	This symbol contains flags that say what difficulties the compiler
	has casting odd floating values to unsigned long:
		0 = ok
		1 = couldn't cast < 0
		2 = couldn't cast >= 0x80000000
		4 = couldn't cast in argument expression list

CASTI32:
	Unit: d_casti32
	Wants: cat rm intsize Setvar test signal_t
	Optional: cc ccflags

	This symbol is defined if the C compiler can cast negative
	or large floating point numbers to 32-bit ints.

CASTNEGFLOAT:
	Unit: d_castneg (Also defines castflags)
	Wants: cat rm Setvar signal_t
	Optional: cc ccflags

	This symbol is defined if the C compiler can cast negative
	numbers to unsigned longs, ints and shorts.

CAT2:
	Unit: cpp_stuff
	Wants: cat contains cppstdin cppflags cppminus rm

	This macro catenates 2 tokens together.

CAT3:
	Unit: cpp_stuff
	Wants: cat contains cppstdin cppflags cppminus rm

	This macro catenates 3 tokens together.

CAT4:
	Unit: cpp_stuff
	Wants: cat contains cppstdin cppflags cppminus rm

	This macro catenates 4 tokens together.

CAT5:
	Unit: cpp_stuff
	Wants: cat contains cppstdin cppflags cppminus rm

	This macro catenates 5 tokens together.

CBRT:
	Obsoleted by HAS_CBRT.

CHARSIZE:
	Unit: charsize
	Wants: cat rm Myread
	Optional: cc ccflags

	This symbol contains the size of a char, so that the C preprocessor
	can make decisions based on it.

CHARSPRINTF:
	Unit: d_charsprf
	Wants: cat rm Setvar
	Optional: cc

	This symbol is defined if this system declares "char *sprintf()" in
	stdio.h.  The trend seems to be to declare it as "int sprintf()".  It
	is up to the package author to declare sprintf correctly based on the
	symbol.

CHARVSPRINTF:
	Obsoleted by USE_CHAR_VSPRINTF.

CHAR_ORDER_INT:
	Unit: charorder (Also defines chorder_int chorder_short chorder_long)
	Wants: Myread cat rm
	Optional: cc ccflags

	Holds the byte ordering of characters in an int. It's a string
	value like "c0c1c2c3" on a Big-Endian machine.

CHAR_ORDER_LONG:
	Unit: charorder (Also defines chorder_int chorder_short chorder_long)
	Wants: Myread cat rm
	Optional: cc ccflags

	Holds the byte ordering of characters in a long. It's a string
	value like "c0c1c2c3c4c5c6c7" on a 64 bits Big-Endian machine.

CHAR_ORDER_SHORT:
	Unit: charorder (Also defines chorder_int chorder_short chorder_long)
	Wants: Myread cat rm
	Optional: cc ccflags

	Holds the byte ordering of characters in a short. It's a string
	value like "c0c1" on a Big-Endian machine.

CHSIZE:
	Obsoleted by HAS_CHSIZE.

CITYDIST:
	Unit: locdist (Also defines orgdist citydist statedist multistatedist
	  cntrydist contdist)
	Wants: test newslibexp cat Myread Oldconfig

	This symbol contains the distribution name for the news system that
	restricts article distribution to the city.

CLOCKTYPE:
	Obsoleted by Clock_t.

CNTRYDIST:
	Unit: locdist (Also defines orgdist citydist statedist multistatedist
	  cntrydist contdist)
	Wants: test newslibexp cat Myread Oldconfig

	This symbol contains the distribution name for the news system that
	restricts article distribution to the country.

CONTDIST:
	Unit: locdist (Also defines orgdist citydist statedist multistatedist
	  cntrydist contdist)
	Wants: test newslibexp cat Myread Oldconfig

	This symbol contains the distribution name for the news system that
	restricts article distribution to the continent.

CPPCANSTDIN:
	Obsoleted by CPP_CAN_STDIN.

CPPFILECOM:
	Obsoleted by CPP_FILE_COM.

CPPIGNHDRS:
	Obsoleted by CPP_IGN_HDRS.

CPPLAST:
	Unit: cppstdin (Also defines cppminus cpprun cpplast)
	Wants: contains test Myread Oldconfig Loc cpp rm
	Optional: cc

	This symbol is intended to be used along with CPPRUN in the same manner
	symbol CPPMINUS is used with CPPSTDIN. It contains either "-" or "".

CPPMINUS:
	Unit: cppstdin (Also defines cppminus cpprun cpplast)
	Wants: contains test Myread Oldconfig Loc cpp rm
	Optional: cc

	This symbol contains the second part of the string which will invoke
	the C preprocessor on the standard input and produce to standard
	output.  This symbol will have the value "-" if CPPSTDIN needs a minus
	to specify standard input, otherwise the value is "".

CPPRUN:
	Unit: cppstdin (Also defines cppminus cpprun cpplast)
	Wants: contains test Myread Oldconfig Loc cpp rm
	Optional: cc

	This symbol contains the string which will invoke a C preprocessor on
	the standard input and produce to standard output. It needs to end
	with CPPLAST, after all other preprocessor flags have been specified.
	The main difference with CPPSTDIN is that this program will never be a
	pointer to a shell wrapper, i.e. it will be empty if no preprocessor is
	available directly to the user. Note that it may well be different from
	the preprocessor used to compile the C program.

CPPSTDIN:
	Unit: cppstdin (Also defines cppminus cpprun cpplast)
	Wants: contains test Myread Oldconfig Loc cpp rm
	Optional: cc

	This symbol contains the first part of the string which will invoke
	the C preprocessor on the standard input and produce to standard
	output.	 Typical value of "cc -E" or "/lib/cpp", but it can also
	call a wrapper. See CPPRUN.

CPPSTDINFLAGS:
	Obsoleted by CPP_STDIN_FLAGS.

CPP_CAN_STDIN:
	Unit: cppfilecom (Also defines cppstdinflags d_cppignhdrs
	  d_cppcanstdin)
	Wants: contains package test Myread Oldconfig Loc Setvar cpp cc cat rm

	This symbol is defined if CPP_FILE_COM can read standard input
	directly.

CPP_FILE_COM:
	Unit: cppfilecom (Also defines cppstdinflags d_cppignhdrs
	  d_cppcanstdin)
	Wants: contains package test Myread Oldconfig Loc Setvar cpp cc cat rm

	This symbol contains the first part of the string which will invoke
	the C preprocessor a file and produce to standard output, preserving
	comments. Typical value of "cc -E -C" or "/lib/cpp -C".

CPP_IGN_HDRS:
	Unit: cppfilecom (Also defines cppstdinflags d_cppignhdrs
	  d_cppcanstdin)
	Wants: contains package test Myread Oldconfig Loc Setvar cpp cc cat rm

	This symbol is defined if CPP_FILE_COM ignores *.h files.

CPP_STDIN_FLAGS:
	Unit: cppfilecom (Also defines cppstdinflags d_cppignhdrs
	  d_cppcanstdin)
	Wants: contains package test Myread Oldconfig Loc Setvar cpp cc cat rm

	This variable contains any flags necessary to get CPP_FILE_COM to
	read from the standard input.

CRYPT:
	Obsoleted by HAS_CRYPT.

CSH:
	Unit: d_csh (Also defines full_csh)
	Wants: csh Setvar

	This symbol, if defined, indicates that the C-shell exists.
	If defined, contains the full pathname of csh.

CTERMID:
	Obsoleted by HAS_CTERMID.

Caddr_t:
	Unit: sbrktype
	Wants: Myread Oldconfig Loc contains Findhdr

	This symbol holds the type of a core address. It is inteded to be used
	to safely declare the return type of system calls like sbrk(). It might
	be necessary to include <sys/types.h> as well.

Clock_t:
	Unit: d_times (Also defines clocktype)
	Wants: Csym Myread Typedef i_systimes

	This symbol holds the type returned by times(). It can be long,
	or clock_t on BSD sites (in which case <sys/types.h> should be
	included).

DB_Hash_t:
	Unit: i_db (Also defines db_hashtype db_prefixtype)
	Wants: Inhdr rm contains cat d_const
	Optional: cc ccflags

	This symbol contains the type of the prefix structure element
	in the <db.h> header file.  In older versions of DB, it was
	int, while in newer ones it is size_t.

DB_Prefix_t:
	Unit: i_db (Also defines db_hashtype db_prefixtype)
	Wants: Inhdr rm contains cat d_const
	Optional: cc ccflags

	This symbol contains the type of the prefix structure element
	in the <db.h> header file.  In older versions of DB, it was
	int, while in newer ones it is u_int32_t.

DEFEDITOR:
	Unit: defeditor
	Wants: Getfile Oldconfig Loc vi

	This symbol contains the full pathname of the default editor.

DIRNAMLEN:
	Unit: i_dirent (Also defines d_dirnamlen direntrytype)
	Wants: test contains Setvar Myread Findhdr cppstdin cppflags cppminus
	  rm

	This symbol, if defined, indicates to the C program that the length
	of directory entry names is provided by a d_namlen field.  Otherwise
	you need to do strlen() on the d_name field.

DOSUID:
	Unit: d_dosuid (Also defines d_suidsafe)
	Wants: cat contains ls rm test Myread Setvar Oldconfig Guess package
	  hint

	This symbol, if defined, indicates that the C program should
	check the script that it is executing for setuid/setgid bits, and
	attempt to emulate setuid/setgid on systems that have disabled
	setuid #! scripts because the kernel can't do it securely.
	It is up to the package designer to make sure that this emulation
	is done securely.  Among other things, it should do an fstat on
	the script it just opened to make sure it really is a setuid/setgid
	script, it should make sure the arguments passed correspond exactly
	to the argument on the #! line, and it should not trust any
	subprocesses to which it must pass the filename rather than the
	file descriptor of the script to be executed.

DOTS:
	Unit: prototype
	Wants: Myread Oldconfig cat rm Setvar
	Optional: cc ccflags

	This macro is used to specify the ... in function prototypes which
	have arbitrary additional arguments.

DOUBLESIZE:
	Unit: doublesize
	Wants: cat rm Myread
	Optional: cc ccflags

	This symbol contains the size of a double, so that the C preprocessor
	can make decisions based on it.

DUP2:
	Obsoleted by HAS_DUP2.

Direntry_t:
	Unit: i_dirent (Also defines d_dirnamlen direntrytype)
	Wants: test contains Setvar Myread Findhdr cppstdin cppflags cppminus
	  rm

	This symbol is set to 'struct direct' or 'struct dirent' depending on
	whether dirent is available or not. You should use this pseudo type to
	portably declare your directory entries.

EMULATE_NDIR:
	Unit: d_usendir (Also defines i_ndir ndirc ndiro ndirlib)
	Wants: test Csym Findhdr _a _o

	This symbol, if defined, indicates that the program should compile
	the ndir.c code provided with the package.

EOFPIPE:
	Unit: d_eofpipe
	Wants: cat rm Oldconfig Guess echo n c
	Optional: cc ccflags libs

	This symbol, if defined, indicates that EOF condition will be detected
	by the reader of the pipe when it is closed by the writing process.
	That is, a select() call on that file descriptor will not block when
	only an EOF remains (typical behaviour for BSD systems).

EOF_NONBLOCK:
	Unit: nblock_io (Also defines o_nonblock eagain rd_nodata d_eofnblk)
	Wants: cat rm d_open3 h_sysfile h_fcntl signal_t hint Oldconfig
	  Setvar startsh
	Optional: cc ccflags ldflags

	This symbol, if defined, indicates to the C program that a read() on
	a non-blocking file descriptor will return 0 on EOF, and not the value
	held in RD_NODATA (-1 usually, in that case!).

EUNICE:
	Unit: Guess (Also defines d_eunice d_xenix d_bsd)
	Wants: cat test echo n c contains rm Loc eunicefix

	This symbol, if defined, indicates that the program is being compiled
	under the EUNICE package under VMS.  The program will need to handle
	things like files that don't go away the first time you unlink them,
	due to version numbering.  It will also need to compensate for lack
	of a respectable link() command.

FCHMOD:
	Obsoleted by HAS_FCHMOD.

FCHOWN:
	Obsoleted by HAS_FCHOWN.

FCNTL:
	Obsoleted by I_FCNTL.

FILE_base:
	Unit: d_stdstdio (Also defines d_stdiobase stdio_ptr stdio_cnt
	  stdio_base stdio_bufsiz d_stdio_cnt_lval d_stdio_ptr_lval
	  stdio_filbuf)
	Wants: cat contains rm Setvar Findhdr Oldconfig
	Optional: cc ccflags ldflags libs

	This macro is used to access the _base field (or equivalent) of the
	FILE structure pointed to by its argument. This macro will always be
	defined if USE_STDIO_BASE is defined.

FILE_bufsiz:
	Unit: d_stdstdio (Also defines d_stdiobase stdio_ptr stdio_cnt
	  stdio_base stdio_bufsiz d_stdio_cnt_lval d_stdio_ptr_lval
	  stdio_filbuf)
	Wants: cat contains rm Setvar Findhdr Oldconfig
	Optional: cc ccflags ldflags libs

	This macro is used to determine the number of bytes in the I/O
	buffer pointed to by _base field (or equivalent) of the FILE
	structure pointed to its argument. This macro will always be defined
	if USE_STDIO_BASE is defined.

FILE_cnt:
	Unit: d_stdstdio (Also defines d_stdiobase stdio_ptr stdio_cnt
	  stdio_base stdio_bufsiz d_stdio_cnt_lval d_stdio_ptr_lval
	  stdio_filbuf)
	Wants: cat contains rm Setvar Findhdr Oldconfig
	Optional: cc ccflags ldflags libs

	This macro is used to access the _cnt field (or equivalent) of the
	FILE structure pointed to by its argument. This macro will always be
	defined if USE_STDIO_PTR is defined.

FILE_filbuf:
	Unit: d_stdstdio (Also defines d_stdiobase stdio_ptr stdio_cnt
	  stdio_base stdio_bufsiz d_stdio_cnt_lval d_stdio_ptr_lval
	  stdio_filbuf)
	Wants: cat contains rm Setvar Findhdr Oldconfig
	Optional: cc ccflags ldflags libs

	This macro is used to access the internal stdio _filbuf function
	(or equivalent), if STDIO_CNT_LVALUE and STDIO_PTR_LVALUE
	are defined.  It is typically either _filbuf or __filbuf.
	This macro will only be defined if both STDIO_CNT_LVALUE and
	STDIO_PTR_LVALUE are defined.

FILE_ptr:
	Unit: d_stdstdio (Also defines d_stdiobase stdio_ptr stdio_cnt
	  stdio_base stdio_bufsiz d_stdio_cnt_lval d_stdio_ptr_lval
	  stdio_filbuf)
	Wants: cat contains rm Setvar Findhdr Oldconfig
	Optional: cc ccflags ldflags libs

	This macro is used to access the _ptr field (or equivalent) of the
	FILE structure pointed to by its argument. This macro will always be
	defined if USE_STDIO_PTR is defined.

FLEXFILENAMES:
	Unit: d_flexfnam
	Wants: cat rm test Setvar

	This symbol, if defined, indicates that the system supports filenames
	longer than 14 characters.

FLOATSIZE:
	Unit: floatsize
	Wants: cat rm Myread
	Optional: cc ccflags

	This symbol contains the size of a float, so that the C preprocessor
	can make decisions based on it.

FLOCK:
	Obsoleted by HAS_FLOCK.

FPU:
	Unit: fpu
	Wants: test cat cc Myread

	String containing the flags for the local floating point unit.

FPUNIT:
	Obsoleted by FPU.

FTIMER:
	Obsoleted by HAS_FTIME.

Fpos_t:
	Unit: fpostype
	Wants: Myread Typedef

	This symbol holds the type used to declare file positions in libc.
	It can be fpos_t, long, uint, etc... It may be necessary to include
	<sys/types.h> to get any typedef'ed information.

Free_t:
	Unit: mallocsrc (Also defines mallocobj usemymalloc malloctype
	  d_mymalloc freetype)
	Wants: Myread Oldconfig package Guess Setvar rm cat Findhdr i_malloc
	  i_stdlib sed libs _o
	Optional: cc ccflags

	This variable contains the return type of free().  It is usually
	void, but occasionally int.

GETGROUPS:
	Obsoleted by HAS_GETGROUPS.

GETHOSTBYNAME:
	Obsoleted by HAS_GETHOSTBYNAME.

GETHOSTENT:
	Obsoleted by HAS_GETHOSTENT.

GETHOSTID:
	Obsoleted by HAS_GETHOSTID.

GETHOSTNAME:
	Obsoleted by HAS_GETHOSTNAME.

GETOPT:
	Obsoleted by HAS_GETOPT.

GETPAGESIZE:
	Obsoleted by HAS_GETPAGESIZE.

GETPGRP:
	Obsoleted by HAS_GETPGRP.

GETPGRP2:
	Obsoleted by HAS_GETPGRP2.

GETPRIORITY:
	Obsoleted by HAS_GETPRIORITY.

GETPWENT:
	Obsoleted by HAS_GETPWENT.

GETRUSAGE:
	Obsoleted by HAS_GETRUSAGE.

GETTIMEOFDAY:
	Obsoleted by HAS_GETTIMEOFDAY.

GETWD:
	Obsoleted by HAS_GETWD.

GIDTYPE:
	Obsoleted by Gid_t.

GNUC_ATTRIBUTE_CHECK:
	Obsoleted by HASATTRIBUTE.

GROUPSTYPE:
	Obsoleted by Groups_t.

Gconvert:
	Unit: d_gconvert (Also defines d_Gconvert)
	Wants: cat cc ccflags ldflags libs Inlibc rm _o

	This preprocessor macro is defined to convert a floating point
	number to a string without a trailing decimal point.  This
	emulates the behavior of sprintf("%g"), but is sometimes much more
	efficient.  If gconvert() is not available, but gcvt() drops the
	trailing decimal point, then gcvt() is used.  If all else fails,
	a macro using sprintf("%g") is used. Arguments for the Gconvert
	macro are: value, number of digits, whether trailing zeros should
	be retained, and the output buffer.
	Possible values are:
		d_Gconvert='gconvert((x),(n),(t),(b))'
		d_Gconvert='gcvt((x),(n),(b))'
		d_Gconvert='sprintf((b),"%.*g",(n),(x))'
	The last two assume trailing zeros should not be kept.

Gid_t:
	Unit: gidtype
	Wants: Myread Typedef Findhdr

	This symbol holds the return type of getgid() and the type of
	argument to setrgid() and related functions.  Typically,
	it is the type of group ids in the kernel. It can be int, ushort,
	uid_t, etc... It may be necessary to include <sys/types.h> to get
	any typedef'ed information.

Groups_t:
	Unit: groupstype
	Wants: gidtype d_getgrps Myread Oldconfig Findhdr cat

	This symbol holds the type used for the second argument to
	getgroups().  Usually, this is the same of gidtype, but
	sometimes it isn't.  It can be int, ushort, uid_t, etc... 
	It may be necessary to include <sys/types.h> to get any 
	typedef'ed information.  This is only required if you have
	getgroups().

HASATTRIBUTE:
	Unit: d_attribut
	Wants: Myread Oldconfig cat cc ccflags rm Setvar contains

	This symbol indicates the C compiler can check for function attributes,
	such as printf formats. This is normally only supported by GNU cc.

HASCONST:
	Unit: d_const
	Wants: cat cc ccflags Setvar

	This symbol, if defined, indicates that this C compiler knows about
	the const type. There is no need to actually test for that symbol
	within your programs. The mere use of the "const" keyword will
	trigger the necessary tests.

HASVOLATILE:
	Unit: d_volatile
	Wants: cat rm Setvar
	Optional: cc ccflags

	This symbol, if defined, indicates that this C compiler knows about
	the volatile declaration.

HAS_ACCESS:
	Unit: d_access
	Wants: test cat h_fcntl h_sysfile rm Inlibc Findhdr
	Optional: cc cppflags

	This manifest constant lets the C program know that the access()
	system call is available to check for accessibility using real UID/GID.
	(always present on UNIX.)

HAS_ALARM:
	Unit: d_alarm
	Wants: Inlibc

	This symbol, if defined, indicates that the alarm routine is
	available.

HAS_BCMP:
	Unit: d_bcmp
	Wants: Inlibc

	This symbol is defined if the bcmp() routine is available to
	compare blocks of memory.

HAS_BCOPY:
	Unit: d_bcopy
	Wants: Inlibc

	This symbol is defined if the bcopy() routine is available to
	copy blocks of memory.

HAS_BZERO:
	Unit: d_bzero
	Wants: Inlibc

	This symbol is defined if the bzero() routine is available to
	set a memory block to 0.

HAS_CBRT:
	Unit: d_cbrt
	Wants: Inlibc

	This symbol, if defined, indicates that the cbrt() (cube root)
	function is available.

HAS_CHOWN:
	Unit: d_chown
	Wants: Inlibc

	This symbol, if defined, indicates that the chown routine is
	available.

HAS_CHROOT:
	Unit: d_chroot
	Wants: Inlibc

	This symbol, if defined, indicates that the chroot routine is
	available.

HAS_CHSIZE:
	Unit: d_chsize
	Wants: Inlibc

	This symbol, if defined, indicates that the chsize routine is available
	to truncate files.  You might need a -lx to get this routine.

HAS_CLOSEDIR:
	Unit: d_closedir (Also defines d_void_closedir)
	Wants: Inlibc i_dirent i_sysdir i_sysndir cc ccflags ldflags libs
	  Setvar rm

	This symbol, if defined, indicates that the closedir() routine is
	available.

HAS_CRYPT:
	Unit: d_crypt (Also defines cryptlib)
	Wants: Loc test xlibpth libpth Csym Setvar _a

	This symbol, if defined, indicates that the crypt routine is available
	to encrypt passwords and the like.

HAS_CTERMID:
	Unit: d_ctermid
	Wants: Inlibc

	This symbol, if defined, indicates that the ctermid routine is
	available to generate filename for terminal.

HAS_CURSES_KEYPAD:
	Unit: d_ckeypad
	Wants: cat cc termlib Setvar

	This symbol indicates the availability of the keypad() function
	of the curses library.

HAS_CUSERID:
	Unit: d_cuserid
	Wants: Inlibc

	This symbol, if defined, indicates that the cuserid routine is
	available to get character login names.

HAS_DBL_DIG:
	Unit: d_dbl_dig
	Wants: Myread contains cat rm Setvar i_limits i_float cppstdin
	  cppflags cppminus

	This symbol, if defined, indicates that this system's <float.h>
	or <limits.h> defines the symbol DBL_DIG, which is the number
	of significant digits in a double precision number.  If this
	symbol is not defined, a guess of 15 is usually pretty good.

HAS_DIFFTIME:
	Unit: d_difftime
	Wants: Inlibc

	This symbol, if defined, indicates that the difftime routine is
	available.

HAS_DLERROR:
	Unit: d_dlerror
	Wants: Inlibc runnm

	This symbol, if defined, indicates that the dlerror routine is
	available to return a string describing the last error that
	occurred from a call to dlopen(), dlclose() or dlsym().

HAS_DLOPEN:
	Unit: d_dlopen
	Wants: Inlibc runnm

	This symbol, if defined, indicates that the dlopen routine is
	available.

HAS_DREM:
	Unit: d_drem
	Wants: Inlibc

	This symbol, if defined, indicates that the drem routine is
	available.  This routine is roughly the same as fmod, i.e. it
	computes the remainder r=x-n*y, where n=rint(x/y), whereas fmod
	uses n=trunc(x/y).

HAS_DUP2:
	Unit: d_dup2
	Wants: Inlibc

	This symbol, if defined, indicates that the dup2 routine is
	available to duplicate file descriptors.

HAS_EUC2JIS:
	Unit: d_euc2jis
	Wants: Inlibc

	This symbol, if defined, indicates that the euc2jis routine is
	available to convert EUC to JIS.

HAS_FCHMOD:
	Unit: d_fchmod
	Wants: Inlibc

	This symbol, if defined, indicates that the fchmod routine is available
	to change mode of opened files.  If unavailable, use chmod().

HAS_FCHOWN:
	Unit: d_fchown
	Wants: Inlibc

	This symbol, if defined, indicates that the fchown routine is available
	to change ownership of opened files.  If unavailable, use chown().

HAS_FCNTL:
	Unit: d_fcntl
	Wants: Inlibc

	This symbol, if defined, indicates to the C program that
	the fcntl() function exists.

HAS_FDS_BITS:
	Unit: d_fd_set (Also defines d_fd_macros d_fds_bits)
	Wants: cat rm Oldconfig d_socket i_systime i_sysselct
	Optional: cc ccflags

	This symbol, when defined, indicates presence of the fds_bits member in
	fd_set.  This knowledge is useful if fd_set is available but the macros
	aren't.

HAS_FD_MACROS:
	Unit: d_fd_set (Also defines d_fd_macros d_fds_bits)
	Wants: cat rm Oldconfig d_socket i_systime i_sysselct
	Optional: cc ccflags

	This symbol, when defined,  indicates presence of the macros used to
	manipulate an fd_set.

HAS_FD_SET:
	Unit: d_fd_set (Also defines d_fd_macros d_fds_bits)
	Wants: cat rm Oldconfig d_socket i_systime i_sysselct
	Optional: cc ccflags

	This symbol, when defined, indicates presence of the fd_set typedef
	in <sys/types.h>

HAS_FFS:
	Unit: d_ffs
	Wants: Inlibc

	This symbol, if defined, indicates that the ffs routine is available
	to find the first bit set in its argument.  If it's not available,
	roll your own.

HAS_FGETPOS:
	Unit: d_fgetpos
	Wants: Inlibc

	This symbol, if defined, indicates that the fgetpos routine is
	available to get the file position indicator, similar to ftell().

HAS_FLOCK:
	Unit: d_flock
	Wants: Inlibc

	This symbol, if defined, indicates that the flock routine is
	available to do file locking.

HAS_FMOD:
	Unit: d_fmod
	Wants: Inlibc

	This symbol, if defined, indicates that the fmod routine is
	available to compute the remainder r=x-n*y where n=trunc(x/y).

HAS_FORK:
	Unit: d_fork
	Wants: Inlibc

	This symbol, if defined, indicates that the fork routine is
	available.

HAS_FPATHCONF:
	Unit: d_pathconf (Also defines d_fpathconf)
	Wants: Inlibc

	This symbol, if defined, indicates that pathconf() is available
	to determine file-system related limits and options associated
	with a given open file descriptor.

HAS_FSETPOS:
	Unit: d_fsetpos
	Wants: Inlibc

	This symbol, if defined, indicates that the fsetpos routine is
	available to set the file position indicator, similar to fseek().

HAS_FTIME:
	Unit: d_ftime (Also defines d_gettimeod)
	Wants: Inlibc Setvar

	This symbol, if defined, indicates that the ftime() routine exists.
	It is basically a sub-second accuracy clock, but is less accurate
	than gettimeofday(2) anyway. The type "Timeval" should be used to
	refer to "struct timeb".

HAS_FTRUNCATE:
	Unit: d_ftrncate
	Wants: Inlibc

	This symbol, if defined, indicates that the ftruncate() subroutine
	exists.

HAS_GDBM:
	Obsoleted by I_GDBM.

HAS_GETGROUPS:
	Unit: d_getgrps
	Wants: Inlibc

	This symbol, if defined, indicates that the getgroups() routine is
	available to get the list of process groups.  If unavailable, multiple
	groups are probably not supported.

HAS_GETHOSTBYNAME:
	Unit: d_gethbynm
	Wants: Inlibc

	This symbol, if defined, indicates that the gethostbyname() routine is
	available to lookup host names in some data base or other.

HAS_GETHOSTENT:
	Unit: d_gethent
	Wants: Inlibc

	This symbol, if defined, indicates that the gethostent routine is
	available to lookup host names in some data base or other.

HAS_GETHOSTID:
	Unit: d_gethid
	Wants: Inlibc

	This symbol, if defined, indicates that the gethostid system call is
	available to get the host id.

HAS_GETHOSTNAME:
	Unit: d_gethname (Also defines d_uname d_phostname aphostname)
	Wants: phostname cat myhostname package d_portable Loc libc echo n c
	  Myread Guess Oldconfig Csym
	Optional: i_whoami usrinc

	This symbol, if defined, indicates that the C program may use the
	gethostname() routine to derive the host name.  See also HAS_UNAME
	and PHOSTNAME.

HAS_GETLOGIN:
	Unit: d_getlogin
	Wants: Inlibc

	This symbol, if defined, indicates that the getlogin routine is
	available to get the login name.

HAS_GETOPT:
	Unit: d_getopt
	Wants: Inlibc

	This symbol, if defined, indicates that the getopt() routine exists.

HAS_GETPAGESIZE:
	Unit: d_getpagsz (Also defines pagesize)
	Wants: Oldconfig Myread Inlibc cat contains libs rm Findhdr
	Optional: cc ccflags

	This symbol, if defined, indicates that the getpagesize system call
	is available to get system page size, which is the granularity of
	many memory management calls.

HAS_GETPGID:
	Unit: d_getpgid
	Wants: Inlibc

	This symbol, if defined, indicates to the C program that 
	the getpgid(pid) function is available to get the
	process group id.

HAS_GETPGRP:
	Unit: d_getpgrp (Also defines d_bsdgetpgrp)
	Wants: Guess Inlibc Setvar cat rm i_unistd
	Optional: cc ccflags ldflags libs

	This symbol, if defined, indicates that the getpgrp routine is
	available to get the current process group.

HAS_GETPGRP2:
	Unit: d_getpgrp2
	Wants: Inlibc

	This symbol, if defined, indicates that the getpgrp2() (as in DG/UX)
	routine is available to get the current process group.

HAS_GETPPID:
	Unit: d_getppid
	Wants: Inlibc

	This symbol, if defined, indicates that the getppid routine is
	available to get the parent process ID.

HAS_GETPRIORITY:
	Unit: d_getprior
	Wants: Inlibc

	This symbol, if defined, indicates that the getpriority routine is
	available to get a process's priority.

HAS_GETPWENT:
	Unit: d_getpwent
	Wants: Csym Setvar

	This symbol, if defined, indicates that the getpwent() routine
	should be used instead of the getpw() routine.

HAS_GETRUSAGE:
	Unit: d_rusage
	Wants: Inlibc

	This symbol, if defined, indicates that the getrusage() routine is
	available to get process statistics with a sub-second accuracy.
	Inclusion of <sys/resource.h> and <sys/time.h> may be necessary.

HAS_GETTIMEOFDAY:
	Unit: d_ftime (Also defines d_gettimeod)
	Wants: Inlibc Setvar

	This symbol, if defined, indicates that the gettimeofday() system
	call is available for a sub-second accuracy clock. Usually, the file
	<sys/resource.h> needs to be included (see I_SYS_RESOURCE).
	The type "Timeval" should be used to refer to "struct timeval".

HAS_GETWD:
	Unit: d_getwd
	Wants: Csym Setvar

	This symbol, if defined, indicates that the getwd routine is
	available to get working directory. If not, you should
	probably use getcwd().

HAS_GNULIBC:
	Unit: d_gnulibc
	Wants: Myread Oldconfig Setvar contains rm
	Optional: cc ccflags ldflags libs

	This symbol, if defined, indicates to the C program that 
	the GNU C library is being used.

HAS_HTONL:
	Unit: d_htonl
	Wants: Inlibc Setvar i_niin i_sysin cat rm contains cppstdin cppflags
	  cppminus

	This symbol, if defined, indicates that the htonl() routine (and
	friends htons() ntohl() ntohs()) are available to do network
	order byte swapping.

HAS_HTONS:
	Unit: d_htonl
	Wants: Inlibc Setvar i_niin i_sysin cat rm contains cppstdin cppflags
	  cppminus

	This symbol, if defined, indicates that the htons() routine (and
	friends htonl() ntohl() ntohs()) are available to do network
	order byte swapping.

HAS_INDEX:
	Unit: d_strchr (Also defines d_index)
	Wants: contains strings Setvar Myread Oldconfig Csym

	This symbol is defined to indicate that the index()/rindex()
	functions are available for string searching.

HAS_INET_ATON:
	Unit: d_inetaton
	Wants: Inlibc

	This symbol, if defined, indicates to the C program that the
	inet_aton() function is available to parse IP address "dotted-quad"
	strings.

HAS_ISASCII:
	Unit: d_isascii
	Wants: cc cat ccflags ldflags rm libs Setvar

	This manifest constant lets the C program know that isascii 
	is available.

HAS_ITIMER:
	Unit: d_itimer
	Wants: Inlibc

	This symbol, if defined, indicates that the setitimer() routine exists.

HAS_KILLPG:
	Unit: d_killpg
	Wants: Inlibc

	This symbol, if defined, indicates that the killpg routine is available
	to kill process groups.  If unavailable, you probably should use kill
	with a negative process number.

HAS_LINK:
	Unit: d_link
	Wants: Inlibc

	This symbol, if defined, indicates that the link routine is
	available to create hard links.

HAS_LOCALECONV:
	Unit: d_locconv
	Wants: Inlibc

	This symbol, if defined, indicates that the localeconv routine is
	available for numeric and monetary formatting conventions.

HAS_LOCKF:
	Unit: d_lockf
	Wants: Inlibc

	This symbol, if defined, indicates that the lockf routine is
	available to do file locking.

HAS_LSTAT:
	Unit: d_lstat
	Wants: Inlibc

	This symbol, if defined, indicates that the lstat routine is
	available to do file stats on symbolic links.

HAS_MBLEN:
	Unit: d_mblen
	Wants: Inlibc

	This symbol, if defined, indicates that the mblen routine is available
	to find the number of bytes in a multibye character.

HAS_MBSTOWCS:
	Unit: d_mbstowcs
	Wants: Inlibc

	This symbol, if defined, indicates that the mbstowcs routine is
	available to covert a multibyte string into a wide character string.

HAS_MBTOWC:
	Unit: d_mbtowc
	Wants: Inlibc

	This symbol, if defined, indicates that the mbtowc routine is available
	to covert a multibyte to a wide character.

HAS_MEMCCPY:
	Unit: d_memccpy
	Wants: Inlibc

	This symbol, if defined, indicates that the memccpy routine is available
	to copy a character into a block of memory.  Otherwise you should
	roll your own.

HAS_MEMCHR:
	Unit: d_memchr
	Wants: Inlibc

	This symbol, if defined, indicates that the memchr routine is available
	to scan a block of memory for a character.  If undefined, roll your own.

HAS_MEMCMP:
	Unit: d_memcmp
	Wants: Inlibc

	This symbol, if defined, indicates that the memcmp routine is available
	to compare blocks of memory.

HAS_MEMCPY:
	Unit: d_memcpy
	Wants: Inlibc

	This symbol, if defined, indicates that the memcpy routine is available
	to copy blocks of memory.

HAS_MEMMOVE:
	Unit: d_memmove
	Wants: Inlibc

	This symbol, if defined, indicates that the memmove routine is available
	to copy potentially overlapping blocks of memory. This should be used
	only when HAS_SAFE_BCOPY is not defined. If neither is there, roll your
	own version.

HAS_MEMSET:
	Unit: d_memset
	Wants: Inlibc

	This symbol, if defined, indicates that the memset routine is available
	to set blocks of memory.

HAS_MKDIR:
	Unit: d_mkdir
	Wants: Inlibc

	This symbol, if defined, indicates that the mkdir routine is available
	to create directories.  Otherwise you should fork off a new process to
	exec /bin/mkdir.

HAS_MKFIFO:
	Unit: d_mkfifo
	Wants: Inlibc

	This symbol, if defined, indicates that the mkfifo routine is
	available to create FIFOs. Otherwise, mknod should be able to
	do it for you. However, if mkfifo is there, mknod might require
	super-user privileges which mkfifo will not.

HAS_MKTIME:
	Unit: d_mktime
	Wants: Inlibc

	This symbol, if defined, indicates that the mktime routine is
	available.

HAS_MMAP:
	Unit: d_mmap
	Wants: Inlibc

	This symbol, if defined, indicates that the mmap system call is
	available to map a file into memory.

HAS_MSG:
	Unit: d_msg
	Wants: test d_msgctl d_msgget d_msgsnd d_msgrcv Setvar Findhdr

	This symbol, if defined, indicates that the entire msg*(2) library is
	supported (IPC mechanism based on message queues).

HAS_MSGCTL:
	Unit: d_msgctl
	Wants: Inlibc

	This symbol, if defined, indicates that the msgctl() routine is
	available to perform message control operations.

HAS_MSGGET:
	Unit: d_msgget
	Wants: Inlibc

	This symbol, if defined, indicates that the msgget() routine is
	available to get a new message queue.

HAS_MSGRCV:
	Unit: d_msgrcv
	Wants: Inlibc

	This symbol, if defined, indicates that the msgrcv() routine is
	available to extract a message from the message queue.

HAS_MSGSND:
	Unit: d_msgsnd
	Wants: Inlibc

	This symbol, if defined, indicates that the msgsnd() routine is
	available to send a message into the message queue.

HAS_MSYNC:
	Unit: d_msync
	Wants: Inlibc

	This symbol, if defined, indicates that the msync system call is
	available to synchronize a mapped file.

HAS_MUNMAP:
	Unit: d_munmap
	Wants: Inlibc

	This symbol, if defined, indicates that the munmap system call is
	available to unmap a region, usually mapped by mmap().

HAS_NDBM:
	Obsoleted by I_NDBM.

HAS_NEWS1_0:
	Unit: d_NeWS (Also defines d_news d_news0 d_newshome d_textcan)
	Wants: test rm Myread Getfile

	This symbol defined if running NeWS 1.0.

HAS_NEWS1_1:
	Unit: d_NeWS (Also defines d_news d_news0 d_newshome d_textcan)
	Wants: test rm Myread Getfile

	This symbol defined if running NeWS 1.1.

HAS_NICE:
	Unit: d_nice
	Wants: Inlibc

	This symbol, if defined, indicates that the nice routine is
	available.

HAS_NTOHL:
	Unit: d_htonl
	Wants: Inlibc Setvar i_niin i_sysin cat rm contains cppstdin cppflags
	  cppminus

	This symbol, if defined, indicates that the ntohl() routine (and
	friends htonl() htons() ntohs()) are available to do network
	order byte swapping.

HAS_NTOHS:
	Unit: d_htonl
	Wants: Inlibc Setvar i_niin i_sysin cat rm contains cppstdin cppflags
	  cppminus

	This symbol, if defined, indicates that the ntohs() routine (and
	friends htonl() htons() ntohl()) are available to do network
	order byte swapping.

HAS_ODBM:
	Obsoleted by I_DBM.

HAS_OPEN3:
	Unit: d_open3
	Wants: test cat h_fcntl h_sysfile rm Setvar Findhdr
	Optional: cc cppflags

	This manifest constant lets the C program know that the three
	argument form of open(2) is available.

HAS_PATHCONF:
	Unit: d_pathconf (Also defines d_fpathconf)
	Wants: Inlibc

	This symbol, if defined, indicates that pathconf() is available
	to determine file-system related limits and options associated
	with a given filename.

HAS_PAUSE:
	Unit: d_pause
	Wants: Inlibc

	This symbol, if defined, indicates that the pause routine is
	available to suspend a process until a signal is received.

HAS_PERROR:
	Unit: d_perror
	Wants: Inlibc

	This symbol, if defined, indicates that the perror() routine is
	available to print system error messages. If not defined, you should
	use your own diagnostic routine...

HAS_PIPE:
	Unit: d_pipe
	Wants: Inlibc

	This symbol, if defined, indicates that the pipe routine is
	available to create an inter-process channel.

HAS_POLL:
	Unit: d_poll
	Wants: Inlibc

	This symbol, if defined, indicates that the poll routine is
	available to poll active file descriptors. You may safely
	include <poll.h> when this symbol is defined.

HAS_POPEN:
	Unit: d_popen
	Wants: Inlibc

	This symbol, if defined, indicates that the popen routine is
	available to open a pipe from a process.

HAS_PSIGNAL:
	Unit: d_psignal
	Wants: Inlibc

	This symbol, if defined, indicates that the psignal() routine exists.

HAS_RDCHK:
	Unit: d_rdchk
	Wants: Inlibc

	This symbol, if defined, indicates that the rdchk routine is available
	to find out if there is input pending on an IO channel.  Generally
	the routine is used only if FIONREAD and O_NDELAY aren't available.

HAS_READDIR:
	Unit: d_readdir (Also defines d_seekdir d_telldir d_rewinddir)
	Wants: Inlibc

	This symbol, if defined, indicates that the readdir routine is
	available to read directory entries. You may have to include
	<dirent.h>. See I_DIRENT.

HAS_READLINK:
	Unit: d_readlink
	Wants: Inlibc

	This symbol, if defined, indicates that the readlink routine is
	available to read the value of a symbolic link.

HAS_RECOMP:
	Unit: d_regcmp (Also defines d_re_comp d_regcomp)
	Wants: Csym cat

	This symbol, if defined, indicates that the re_comp() routine is
	available to do some regular patern matching (usually on BSD). If so,
	it is likely that re_exec() be available.

HAS_REGCMP:
	Unit: d_regcmp (Also defines d_re_comp d_regcomp)
	Wants: Csym cat

	This symbol, if defined, indicates that the regcmp() routine is
	available to do some regular patern matching (usually on System V).

HAS_REGCOMP:
	Unit: d_regcmp (Also defines d_re_comp d_regcomp)
	Wants: Csym cat

	This symbol, if defined, indicates that the regcomp() routine is
	available to do some regular patern matching (usually on POSIX.2
	conforming systems).

HAS_RENAME:
	Unit: d_rename
	Wants: Inlibc

	This symbol, if defined, indicates that the rename routine is available
	to rename files.  Otherwise you should do the unlink(), link(), unlink()
	trick.

HAS_REWINDDIR:
	Unit: d_readdir (Also defines d_seekdir d_telldir d_rewinddir)
	Wants: Inlibc

	This symbol, if defined, indicates that the rewinddir routine is
	available. You may have to include <dirent.h>. See I_DIRENT.

HAS_RMDIR:
	Unit: d_rmdir
	Wants: Inlibc

	This symbol, if defined, indicates that the rmdir routine is
	available to remove directories. Otherwise you should fork off a
	new process to exec /bin/rmdir.

HAS_SAFE_BCOPY:
	Unit: d_safebcpy
	Wants: cat d_bcopy rm d_memmove i_memory i_stdlib i_string i_unistd
	  Oldconfig Setvar
	Optional: cc optimize ccflags ldflags libs

	This symbol, if defined, indicates that the bcopy routine is available
	to copy potentially overlapping memory blocks. Otherwise you should
	probably use memmove() or memcpy(). If neither is defined, roll your
	own version.

HAS_SAFE_MEMCPY:
	Unit: d_safemcpy
	Wants: cat d_memcpy rm d_memmove i_memory i_stdlib i_string i_unistd
	  Oldconfig Setvar
	Optional: cc optimize ccflags libs ldflags

	This symbol, if defined, indicates that the memcpy routine is available
	to copy potentially overlapping memory blocks. Otherwise you should
	probably use memmove() or memcpy(). If neither is defined, roll your
	own version.

HAS_SANE_MEMCMP:
	Unit: d_sanemcmp
	Wants: cat d_memcmp rm i_memory i_stdlib i_string i_unistd Oldconfig
	  Setvar
	Optional: cc optimize ccflags libs ldflags

	This symbol, if defined, indicates that the memcmp routine is available
	and can be used to compare relative magnitudes of chars with their high
	bits set.  If it is not defined, roll your own version.

HAS_SBRK:
	Unit: d_sbrk
	Wants: Inlibc

	This symbol, if defined, indicates that the sbrk system call is
	available to add/relase core. Always true on Unix.

HAS_SCANDIR:
	Unit: d_scandir
	Wants: Inlibc

	This symbol, if defined, indicates that the scandir routine is
	available to scan a directory.

HAS_SEEKDIR:
	Unit: d_readdir (Also defines d_seekdir d_telldir d_rewinddir)
	Wants: Inlibc

	This symbol, if defined, indicates that the seekdir routine is
	available. You may have to include <dirent.h>. See I_DIRENT.

HAS_SELECT:
	Unit: d_select
	Wants: Inlibc

	This symbol, if defined, indicates that the select routine is
	available to select active file descriptors. If the timeout field
	is used, <sys/time.h> may need to be included.

HAS_SEM:
	Unit: d_sem
	Wants: test d_semctl d_semget d_semop Setvar Findhdr

	This symbol, if defined, indicates that the entire sem*(2) library is
	supported.

HAS_SEMCTL:
	Unit: d_semctl
	Wants: Inlibc

	This symbol, if defined, indicates that the semctl() routine is
	available to perform semaphore control operations.

HAS_SEMGET:
	Unit: d_semget
	Wants: Inlibc

	This symbol, if defined, indicates that the semget() routine is
	available to get a set of semaphores.

HAS_SEMOP:
	Unit: d_semop
	Wants: Inlibc

	This symbol, if defined, indicates that the semop() routine is
	available to execute semaphore operations.

HAS_SETEGID:
	Unit: d_setegid
	Wants: Inlibc

	This symbol, if defined, indicates that the setegid routine is available
	to change the effective gid of the current program.

HAS_SETEUID:
	Unit: d_seteuid
	Wants: Inlibc

	This symbol, if defined, indicates that the seteuid routine is available
	to change the effective uid of the current program.

HAS_SETLINEBUF:
	Unit: d_setlnbuf (Also defines d_setlinebuf)
	Wants: Inlibc

	This symbol, if defined, indicates that the setlinebuf routine is
	available to change stderr or stdout from block-buffered or unbuffered
	to a line-buffered mode.

HAS_SETLOCALE:
	Unit: d_setlocale
	Wants: Inlibc

	This symbol, if defined, indicates that the setlocale routine is
	available to handle locale-specific ctype implementations.

HAS_SETPGID:
	Unit: d_setpgid
	Wants: Inlibc

	This symbol, if defined, indicates that the setpgid(pid, gpid)
	routine is available to set process group ID.

HAS_SETPGRP:
	Unit: d_setpgrp (Also defines d_bsdsetpgrp)
	Wants: cat rm Inlibc Guess Setvar i_unistd
	Optional: cc libs ccflags ldflags

	This symbol, if defined, indicates that the setpgrp routine is
	available to set the current process group.

HAS_SETPGRP2:
	Unit: d_setpgrp2
	Wants: Inlibc

	This symbol, if defined, indicates that the setpgrp2() (as in DG/UX)
	routine is available to set the current process group.

HAS_SETPRIORITY:
	Unit: d_setprior
	Wants: Inlibc

	This symbol, if defined, indicates that the setpriority routine is
	available to set a process's priority.

HAS_SETREGID:
	Unit: d_setregid (Also defines d_setresgid)
	Wants: Inlibc

	This symbol, if defined, indicates that the setregid routine is
	available to change the real and effective gid of the current
	process.

HAS_SETRESGID:
	Unit: d_setregid (Also defines d_setresgid)
	Wants: Inlibc

	This symbol, if defined, indicates that the setresgid routine is
	available to change the real, effective and saved gid of the current
	process.

HAS_SETRESUID:
	Unit: d_setreuid (Also defines d_setresuid)
	Wants: Inlibc

	This symbol, if defined, indicates that the setresuid routine is
	available to change the real, effective and saved uid of the current
	process.

HAS_SETREUID:
	Unit: d_setreuid (Also defines d_setresuid)
	Wants: Inlibc

	This symbol, if defined, indicates that the setreuid routine is
	available to change the real and effective uid of the current
	process.

HAS_SETRGID:
	Unit: d_setrgid
	Wants: Inlibc

	This symbol, if defined, indicates that the setrgid routine is available
	to change the real gid of the current program.

HAS_SETRUID:
	Unit: d_setruid
	Wants: Inlibc

	This symbol, if defined, indicates that the setruid routine is available
	to change the real uid of the current program.

HAS_SETSID:
	Unit: d_setsid
	Wants: Inlibc

	This symbol, if defined, indicates that the setsid routine is
	available to set the process group ID.

HAS_SHM:
	Unit: d_shm
	Wants: test d_shmctl d_shmget d_shmat d_shmdt Setvar Findhdr

	This symbol, if defined, indicates that the entire shm*(2) library is
	supported.

HAS_SHMAT:
	Unit: d_shmat (Also defines shmattype d_shmatprototype)
	Wants: Inlibc cat rm cppstdin cppflags cppminus Findhdr Setvar
	  contains
	Optional: cc ccflags

	This symbol, if defined, indicates that the shmat() routine is
	available to attach a shared memory segment to the process space.

HAS_SHMAT_PROTOTYPE:
	Unit: d_shmat (Also defines shmattype d_shmatprototype)
	Wants: Inlibc cat rm cppstdin cppflags cppminus Findhdr Setvar
	  contains
	Optional: cc ccflags

	This symbol, if defined, indicates that the sys/shm.h includes
	a prototype for shmat().  Otherwise, it is up to the program to
	guess one.  Shmat_t shmat _((int, Shmat_t, int)) is a good guess,
	but not always right so it should be emitted by the program only
	when HAS_SHMAT_PROTOTYPE is not defined to avoid conflicting defs.

HAS_SHMCTL:
	Unit: d_shmctl
	Wants: Inlibc

	This symbol, if defined, indicates that the shmctl() routine is
	available to perform shared memory control operations.

HAS_SHMDT:
	Unit: d_shmdt
	Wants: Inlibc

	This symbol, if defined, indicates that the shmdt() routine is
	available to detach a shared memory segment from the process space.

HAS_SHMGET:
	Unit: d_shmget
	Wants: Inlibc

	This symbol, if defined, indicates that the shmget() routine is
	available to request a shared memory segment from the kernel.

HAS_SIGACTION:
	Unit: d_sigaction
	Wants: Csym Setvar cat cc ccflags ldflags libs rm _o

	This symbol, if defined, indicates that Vr4's sigaction() routine
	is available.

HAS_SIGBLOCK:
	Unit: d_sigblock
	Wants: Inlibc

	This symbol, if defined, indicates that the sigblock routine is
	available to block signal reception.

HAS_SIGHOLD:
	Unit: d_sighold
	Wants: Inlibc

	This symbol, if defined, indicates that the sighold routine is
	available to hold signals.

HAS_SIGINTRP:
	Unit: d_sigvec (Also defines d_sigvectr d_sigintrp)
	Wants: Csym Inlibc Setvar

	This symbol, if defined, indicates that the siginterrupt() routine
	is available.

HAS_SIGSETJMP:
	Unit: d_sigsetjmp
	Wants: Setvar cat libs rm
	Optional: cc ccflags ldflags

	This variable indicates to the C program that the sigsetjmp()
	routine is available to save the calling process's registers
	and stack environment for later use by siglongjmp(), and
	to optionally save the process's signal mask.  See
	Sigjmp_buf, Sigsetjmp, and Siglongjmp.

HAS_SIGSETMASK:
	Unit: d_sigsetmk
	Wants: Csym Setvar

	This symbol, if defined, indicates that the sigsetmask() routine is
	available to set current signal mask. Otherwise, you should probably
	emulate this by using signal(), but fear race conditions...

HAS_SIGVEC:
	Unit: d_sigvec (Also defines d_sigvectr d_sigintrp)
	Wants: Csym Inlibc Setvar

	This symbol, if defined, indicates that BSD reliable signals are
	supported.

HAS_SIGVECTOR:
	Unit: d_sigvec (Also defines d_sigvectr d_sigintrp)
	Wants: Csym Inlibc Setvar

	This symbol, if defined, indicates that the sigvec() routine is called
	sigvector() instead, and that sigspace() is provided instead of
	sigstack().  This is probably only true for HP-UX.

HAS_SJIS2JIS:
	Unit: d_sjis2jis
	Wants: Inlibc

	This symbol, if defined, indicates that the sjis2jis routine is
	available to convert SJIS to JIS.

HAS_SMART_SBRK:
	Unit: sbrksmart
	Wants: cat d_sbrk rm
	Optional: cc ccflags libs

	This symbol is defined when the sbrk() system call may be used with
	a negative argument to lower the break value, therefore releasing
	core to the system. If not, you'd probably be better off using the
	mmap() system call.

HAS_SOCKET:
	Unit: d_socket (Also defines d_oldsock d_sockpair socketlib sockethdr)
	Wants: contains libc echo n c nm_opt nm_extract Inlibc Csym _a

	This symbol, if defined, indicates that the BSD socket interface is
	supported.

HAS_SOCKETPAIR:
	Unit: d_socket (Also defines d_oldsock d_sockpair socketlib sockethdr)
	Wants: contains libc echo n c nm_opt nm_extract Inlibc Csym _a

	This symbol, if defined, indicates that the BSD socketpair() call is
	supported.

HAS_STAT:
	Unit: d_stat
	Wants: Inlibc

	This symbol, if defined, indicates that the stat routine is
	available to get file status.

HAS_STRCASECMP:
	Unit: d_strccmp
	Wants: Inlibc

	This symbol, if defined, indicates that the strcasecmp() routine is
	available for case-insensitive string compares.

HAS_STRCHR:
	Unit: d_strchr (Also defines d_index)
	Wants: contains strings Setvar Myread Oldconfig Csym

	This symbol is defined to indicate that the strchr()/strrchr()
	functions are available for string searching. If not, try the
	index()/rindex() pair.

HAS_STRCOLL:
	Unit: d_strcoll
	Wants: Inlibc

	This symbol, if defined, indicates that the strcoll routine is
	available to compare strings using collating information.

HAS_STRCSPN:
	Unit: d_strcspn
	Wants: Inlibc

	This symbol, if defined, indicates that the strcspn routine is
	available to scan strings.

HAS_STRDUP:
	Unit: d_strdup
	Wants: Inlibc

	This symbol, if defined, indicates that the strdup routine is
	available to duplicate strings in memory. Otherwise, roll up
	your own...

HAS_STRERROR:
	Unit: d_strerror (Also defines d_syserrlst d_sysernlst d_strerrm)
	Wants: contains Csym Findhdr

	This symbol, if defined, indicates that the strerror routine is
	available to translate error numbers to strings. See the writeup
	of Strerror() in this file before you try to define your own.

HAS_STRFTIME:
	Unit: d_strftime
	Wants: Inlibc

	This symbol, if defined, indicates that the strftime routine is
	available to format locale-specific times.

HAS_STRSTR:
	Unit: d_strstr
	Wants: Inlibc

	This symbol, if defined, indicates that the strstr routine is
	available to find substrings.

HAS_STRTOD:
	Unit: d_strtod
	Wants: Inlibc

	This symbol, if defined, indicates that the strtod routine is
	available to provide better numeric string conversion than atof().

HAS_STRTOK:
	Unit: d_strtok
	Wants: Inlibc

	This symbol, if defined, indicates that the strtok routine is
	available to scan strings for tokens.

HAS_STRTOL:
	Unit: d_strtol
	Wants: Inlibc

	This symbol, if defined, indicates that the strtol routine is available
	to provide better numeric string conversion than atoi() and friends.

HAS_STRTOUL:
	Unit: d_strtoul
	Wants: Inlibc

	This symbol, if defined, indicates that the strtoul routine is
	available to provide conversion of strings to unsigned long.

HAS_STRXFRM:
	Unit: d_strxfrm
	Wants: Inlibc

	This symbol, if defined, indicates that the strxfrm() routine is
	available to transform strings.

HAS_SYMLINK:
	Unit: d_symlink
	Wants: Inlibc

	This symbol, if defined, indicates that the symlink routine is available
	to create symbolic links.

HAS_SYSCALL:
	Unit: d_syscall
	Wants: Inlibc

	This symbol, if defined, indicates that the syscall routine is
	available to call arbitrary system calls. If undefined, that's tough.

HAS_SYSCONF:
	Unit: d_sysconf
	Wants: Inlibc

	This symbol, if defined, indicates that sysconf() is available
	to determine system related limits and options.

HAS_SYSLOG:
	Unit: d_syslog (Also defines syslogc syslogo)
	Wants: test Csym Setvar Findhdr _o

	This symbol, if defined, indicates that the program can rely on the
	system providing syslog().  Otherwise, the syslog code provided by
	the package should be used.

HAS_SYSTEM:
	Unit: d_system
	Wants: Inlibc

	This symbol, if defined, indicates that the system routine is
	available to issue a shell command.

HAS_SYS_ERRLIST:
	Unit: d_strerror (Also defines d_syserrlst d_sysernlst d_strerrm)
	Wants: contains Csym Findhdr

	This symbol, if defined, indicates that the sys_errlist array is
	available to translate error numbers to strings. The extern int
	sys_nerr gives the size of that table.

HAS_SYS_ERRNOLIST:
	Unit: d_strerror (Also defines d_syserrlst d_sysernlst d_strerrm)
	Wants: contains Csym Findhdr

	This symbol, if defined, indicates that the sys_errnolist array is
	available to translate an errno code into its symbolic name (e.g.
	ENOENT). The extern int sys_nerrno gives the size of that table.

HAS_SYS_SIGLIST:
	Unit: d_siglist
	Wants: Csym Setvar

	This symbol, if defined, indicates that the sys_siglist array is
	available to translate signal numbers to strings.

HAS_TABLE:
	Unit: d_table
	Wants: Inlibc

	This symbol, if defined, indicates that the OSF/1 table() system
	call is available to examine/update items from a system table.

HAS_TCGETPGRP:
	Unit: d_tcgtpgrp (Also defines d_tcgetpgrp)
	Wants: Inlibc

	This symbol, if defined, indicates that the tcgetpgrp routine is
	available to get foreground process group ID.

HAS_TCSETPGRP:
	Unit: d_tcstpgrp (Also defines d_tcsetpgrp)
	Wants: Inlibc

	This symbol, if defined, indicates that the tcsetpgrp routine is
	available to set foreground process group ID.

HAS_TELLDIR:
	Unit: d_readdir (Also defines d_seekdir d_telldir d_rewinddir)
	Wants: Inlibc

	This symbol, if defined, indicates that the telldir routine is
	available. You may have to include <dirent.h>. See I_DIRENT.

HAS_TERMLIB:
	Unit: d_havetlib (Also defines termlib)
	Wants: cat contains Myread Loc Filexp Oldconfig libpth test uname _a
	  _o

	This symbol, when defined, indicates that termlib-style routines
	are available.  There is nothing to include.

HAS_TIME:
	Unit: d_time (Also defines timetype)
	Wants: Csym Setvar Findhdr Myread Typedef

	This symbol, if defined, indicates that the time() routine exists.

HAS_TIMES:
	Unit: d_times (Also defines clocktype)
	Wants: Csym Myread Typedef i_systimes

	This symbol, if defined, indicates that the times() routine exists.
	Note that this became obsolete on some systems (SUNOS), which now
	use getrusage(). It may be necessary to include <sys/times.h>.

HAS_TRUNCATE:
	Unit: d_truncate
	Wants: Inlibc

	This symbol, if defined, indicates that the truncate routine is
	available to truncate files.

HAS_TZNAME:
	Unit: d_tzname
	Wants: Csym Setvar

	This symbol, if defined, indicates that the tzname[] array is
	available to access timezone names.

HAS_ULIMIT:
	Unit: d_ulimit
	Wants: Inlibc

	This symbol, if defined, indicates that the ulimit system call is
	available to get the user limits.

HAS_UMASK:
	Unit: d_umask
	Wants: Inlibc

	This symbol, if defined, indicates that the umask routine is
	available to set and get the value of the file creation mask.

HAS_UNAME:
	Unit: d_gethname (Also defines d_uname d_phostname aphostname)
	Wants: phostname cat myhostname package d_portable Loc libc echo n c
	  Myread Guess Oldconfig Csym
	Optional: i_whoami usrinc

	This symbol, if defined, indicates that the C program may use the
	uname() routine to derive the host name.  See also HAS_GETHOSTNAME
	and PHOSTNAME.

HAS_USLEEP:
	Unit: d_usleep
	Wants: Inlibc

	This symbol, if defined, indicates that the usleep routine is
	available to let the process sleep on a sub-second accuracy.

HAS_VFORK:
	Unit: d_vfork (Also defines usevfork)
	Wants: Inlibc Myread Oldconfig Setvar

	This symbol, if defined, indicates that vfork() exists.

HAS_VPRINTF:
	Unit: d_vprintf (Also defines d_charvspr)
	Wants: Guess cat Csym Setvar
	Optional: cc ccflags

	This symbol, if defined, indicates that the vprintf routine is available
	to printf with a pointer to an argument list.  If unavailable, you
	may need to write your own, probably in terms of _doprnt().

HAS_WAIT3:
	Unit: d_wait3
	Wants: Inlibc

	This symbol, if defined, indicates that the wait3() subroutine
	exists.

HAS_WAIT4:
	Unit: d_wait4
	Wants: Inlibc

	This symbol, if defined, indicates that wait4() exists.

HAS_WAITPID:
	Unit: d_waitpid
	Wants: Inlibc

	This symbol, if defined, indicates that the waitpid routine is
	available to wait for child process.

HAS_WCSTOMBS:
	Unit: d_wcstombs
	Wants: Inlibc

	This symbol, if defined, indicates that the wcstombs routine is
	available to convert wide character strings to multibyte strings.

HAS_WCTOMB:
	Unit: d_wctomb
	Wants: Inlibc

	This symbol, if defined, indicates that the wctomb routine is available
	to covert a wide character to a multibyte.

HAS_XDRS:
	Unit: d_xdrs
	Wants: cat Csym Setvar

	This symbol if defined indicates to the C program that the XDR
	serialization routines are available to transfer data accross
	various architectures.

HAVETERMLIB:
	Obsoleted by HAS_TERMLIB.

HDR_O_STUFF:
	Obsoleted by I_FCNTL.

HIDDENNET:
	Obsoleted by HIDDEN_NET.

HIDDEN_NET:
	Unit: d_hidnet (Also defines hiddennet)
	Wants: cat sed myhostname mydomain Myread Oldconfig

	This symbol, if defined, contains the host name that you want to
	advertise to the outside world.  This name can be different from
	your actual host name, as long as the machine you specify knows
	how to forward mail to you.

HOSTNAME:
	Obsoleted by MYHOSTNAME.

HTONL:
	Obsoleted by HAS_HTONL.

HTONS:
	Obsoleted by HAS_HTONS.

INETD:
	Obsoleted by USE_INETD.

INSTALLPREFIX:
	Unit: prefix (Also defines prefixexp) (With private oldprefix)
	Wants: Getfile Loc Oldconfig cat package

	This symbol contains the name of the install prefix for this package.

INTERNET:
	Unit: d_internet
	Wants: Myread Oldconfig Setvar

	This symbol, if defined, indicates that there is a mailer available
	which supports internet-style addresses (user@site.domain).

INTSIZE:
	Unit: intsize (Also defines longsize shortsize)
	Wants: Myread cat rm
	Optional: cc optimize ccflags ldflags libs

	This symbol contains the value of sizeof(int) so that the C
	preprocessor can make decisions based on it.

ITIMER:
	Obsoleted by HAS_ITIMER.

I_ARPA_INET:
	Unit: i_arpainet
	Wants: Inhdr

	This symbol, if defined, indicates to the C program that it should
	include <arpa/inet.h> to get inet_addr and friends declarations.

I_BSDIOCTL:
	Obsoleted by I_SYS_BSDIOCTL.

I_DB:
	Unit: i_db (Also defines db_hashtype db_prefixtype)
	Wants: Inhdr rm contains cat d_const
	Optional: cc ccflags

	This symbol, if defined, indicates to the C program that it should
	include Berkeley's DB include file <db.h>.

I_DBM:
	Unit: i_dbm (Also defines i_rpcsvcdbm)
	Wants: Inhdr Inlibc Setvar

	This symbol, if defined, indicates that <dbm.h> exists and should
	be included.

I_DIRENT:
	Unit: i_dirent (Also defines d_dirnamlen direntrytype)
	Wants: test contains Setvar Myread Findhdr cppstdin cppflags cppminus
	  rm

	This symbol, if defined, indicates to the C program that it should
	include <dirent.h>. Using this symbol also triggers the definition
	of the Direntry_t define which ends up being 'struct dirent' or
	'struct direct' depending on the availability of <dirent.h>.

I_DLD:
	Unit: i_dld
	Wants: Inhdr

	This symbol, if defined, indicates that <dld.h> exists and should
	be included before using GNU dynamic loading features.

I_DLFCN:
	Unit: i_dlfcn
	Wants: Inhdr

	This symbol, if defined, indicates that <dlfcn.h> exists and should
	be included.

I_FCNTL:
	Unit: i_fcntl
	Wants: h_fcntl h_sysfile Inhdr Setvar
	Optional: i_sysfile

	This manifest constant tells the C program to include <fcntl.h>.

I_FLOAT:
	Unit: i_float
	Wants: Inhdr

	This symbol, if defined, indicates to the C program that it should
	include <float.h> to get definition of symbols like DBL_MAX or
	DBL_MIN, i.e. machine dependent floating point values.

I_GDBM:
	Unit: i_gdbm
	Wants: Inhdr Inlibc Setvar

	This symbol, if defined, indicates that <gdbm.h> exists and should
	be included.

I_GRP:
	Unit: i_grp
	Wants: Inhdr

	This symbol, if defined, indicates to the C program that it should
	include <grp.h>.

I_LIMITS:
	Unit: i_limits
	Wants: Inhdr

	This symbol, if defined, indicates to the C program that it should
	include <limits.h> to get definition of symbols like WORD_BIT or
	LONG_MAX, i.e. machine dependant limitations.

I_LOCALE:
	Unit: i_locale
	Wants: Inhdr

	This symbol, if defined, indicates to the C program that it should
	include <locale.h>.

I_MALLOC:
	Unit: i_malloc
	Wants: Inhdr

	This symbol, if defined, indicates to the C program that it should
	include <malloc.h>.

I_MATH:
	Unit: i_math
	Wants: Inhdr

	This symbol, if defined, indicates to the C program that it should
	include <math.h>.

I_MEMORY:
	Unit: i_memory
	Wants: Inhdr strings cppstdin cppflags cppminus contains rm Setvar

	This symbol, if defined, indicates to the C program that it should
	include <memory.h>.

I_NDBM:
	Unit: i_ndbm
	Wants: Inhdr Inlibc Setvar

	This symbol, if defined, indicates that <ndbm.h> exists and should
	be included.

I_NDIR:
	Unit: d_usendir (Also defines i_ndir ndirc ndiro ndirlib)
	Wants: test Csym Findhdr _a _o

	This symbol, if defined, indicates that the program should include the
	system's version of ndir.h, rather than the one with this package.

I_NETINET_IN:
	Unit: i_niin (Also defines i_sysin)
	Wants: Inhdr

	This symbol, if defined, indicates to the C program that it should
	include <netinet/in.h>. Otherwise, you may try <sys/in.h>.

I_NET_ERRNO:
	Unit: i_neterrno
	Wants: Inhdr rm Setvar
	Optional: cc ccflags

	This symbol, if defined, indicates that <net/errno.h> exists and 
	should be included.

I_PWD:
	Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass
	  d_pwexpire d_pwcomment)
	Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar

	This symbol, if defined, indicates to the C program that it should
	include <pwd.h>.

I_REGEX:
	Unit: i_regex
	Wants: Inhdr

	This symbol, if defined, indicates that <regex.h> exists and should
	be included.

I_RPCSVC_DBM:
	Unit: i_dbm (Also defines i_rpcsvcdbm)
	Wants: Inhdr Inlibc Setvar

	This symbol, if defined, indicates that <rpcsvc/dbm.h> exists and
	should be included.

I_SFIO:
	Unit: i_sfio
	Wants: Inhdr Setvar

	This symbol, if defined, indicates to the C program that it should
	include <sfio.h>.

I_SGTTY:
	Unit: i_termio (Also defines i_sgtty i_termios)
	Wants: test Inlibc Cppsym Guess Setvar Findhdr

	This symbol, if defined, indicates that the program should include
	<sgtty.h> rather than <termio.h>.  There are also differences in
	the ioctl() calls that depend on the value of this symbol.

I_STDARG:
	Unit: i_varhdr (Also defines i_stdarg i_varargs)
	Wants: cat rm test Setvar Findhdr startsh _o
	Optional: cc ccflags

	This symbol, if defined, indicates that <stdarg.h> exists and should
	be included.

I_STDDEF:
	Unit: i_stddef
	Wants: Inhdr

	This symbol, if defined, indicates that <stddef.h> exists and should
	be included.

I_STDLIB:
	Unit: i_stdlib
	Wants: Inhdr

	This symbol, if defined, indicates that <stdlib.h> exists and should
	be included.

I_STRING:
	Unit: i_string (Also defines strings)
	Wants: test Setvar Findhdr

	This symbol, if defined, indicates to the C program that it should
	include <string.h> (USG systems) instead of <strings.h> (BSD systems).

I_SYSDIR:
	Obsoleted by I_SYS_DIR.

I_SYSFILE:
	Obsoleted by I_SYS_FILE.

I_SYSIN:
	Obsoleted by I_SYS_IN.

I_SYSIOCTL:
	Obsoleted by I_SYS_IOCTL.

I_SYSNDIR:
	Obsoleted by I_SYS_NDIR.

I_SYSRESOURCE:
	Obsoleted by I_SYS_RESOURCE.

I_SYSSELECT:
	Obsoleted by I_SYS_SELECT.

I_SYSSOCKIO:
	Obsoleted by I_SYS_SOCKIO.

I_SYSSTAT:
	Obsoleted by I_SYS_STAT.

I_SYSTIME:
	Obsoleted by I_SYS_TIME.

I_SYSTIMEB:
	Obsoleted by I_SYS_TIMEB.

I_SYSTIMEKERNEL:
	Obsoleted by I_SYS_TIME_KERNEL.

I_SYSTIMES:
	Obsoleted by I_SYS_TIMES.

I_SYSTYPES:
	Obsoleted by I_SYS_TYPES.

I_SYSWAIT:
	Obsoleted by I_SYS_WAIT.

I_SYS_BSDIOCTL:
	Unit: i_sysioctl (Also defines i_bsdioctl i_sysfilio i_syssockio
	  d_voidtty)
	Wants: test contains cat i_termio i_termios i_sgtty Setvar Findhdr rm
	  Inhdr
	Optional: cc

	This symbol, if defined, indicates that <sys/bsdioctl.h> exists and should
	be included. Otherwise, try <sys/ioctl.h>. This is primarly intended for
	definitions of sockets options, like SIOCATMARK.

I_SYS_DIR:
	Unit: i_sysdir
	Wants: Inhdr

	This symbol, if defined, indicates to the C program that it should
	include <sys/dir.h>.

I_SYS_FILE:
	Unit: i_sysfile
	Wants: h_sysfile Inhdr Setvar

	This symbol, if defined, indicates to the C program that it should
	include <sys/file.h> to get definition of R_OK and friends.

I_SYS_FILIO:
	Unit: i_sysioctl (Also defines i_bsdioctl i_sysfilio i_syssockio
	  d_voidtty)
	Wants: test contains cat i_termio i_termios i_sgtty Setvar Findhdr rm
	  Inhdr
	Optional: cc

	This symbol, if defined, indicates that <sys/filio.h> exists and
	should be included instead of <sys/ioctl.h>.

I_SYS_IN:
	Unit: i_niin (Also defines i_sysin)
	Wants: Inhdr

	This symbol, if defined, indicates to the C program that it should
	include <sys/in.h> instead of <netinet/in.h>.

I_SYS_IOCTL:
	Unit: i_sysioctl (Also defines i_bsdioctl i_sysfilio i_syssockio
	  d_voidtty)
	Wants: test contains cat i_termio i_termios i_sgtty Setvar Findhdr rm
	  Inhdr
	Optional: cc

	This symbol, if defined, indicates that <sys/ioctl.h> exists and should
	be included. Otherwise, include <sgtty.h> or <termio.h>.

I_SYS_MMAN:
	Unit: i_sysmman
	Wants: Inhdr

	This symbol, if defined, indicates to the C program that it should
	include <sys/mman.h>.

I_SYS_NDIR:
	Unit: i_sysndir
	Wants: Inhdr

	This symbol, if defined, indicates to the C program that it should
	include <sys/ndir.h>.

I_SYS_PARAM:
	Unit: i_sysparam
	Wants: Inhdr

	This symbol, if defined, indicates to the C program that it should
	include <sys/param.h>.

I_SYS_RESOURCE:
	Unit: i_sysresrc
	Wants: Inhdr

	This symbol, if defined, indicates to the C program that it should
	include <sys/resource.h>.

I_SYS_SELECT:
	Unit: i_sysselct
	Wants: Inhdr

	This symbol, if defined, indicates to the C program that it should
	include <sys/select.h> in order to get definition of struct timeval.

I_SYS_SOCKET:
	Unit: i_syssock
	Wants: Inhdr

	This symbol, if defined, indicates to the C program that it should
	include <sys/socket.h> before performing socket calls.

I_SYS_SOCKIO:
	Unit: i_sysioctl (Also defines i_bsdioctl i_sysfilio i_syssockio
	  d_voidtty)
	Wants: test contains cat i_termio i_termios i_sgtty Setvar Findhdr rm
	  Inhdr
	Optional: cc

	This symbol, if defined, indicates the <sys/sockio.h> should be included
	to get socket ioctl options, like SIOCATMARK.

I_SYS_STAT:
	Unit: i_sysstat
	Wants: Inhdr

	This symbol, if defined, indicates to the C program that it should
	include <sys/stat.h>.

I_SYS_TABLE:
	Unit: i_systable
	Wants: Inhdr

	This symbol, if defined, indicates to the C program that it should
	include <sys/table.h> for the OSF/1 table() system call.

I_SYS_TIME:
	Unit: i_time (Also defines i_systime i_systimek timeincl)
	Wants: cat cc ccflags contains rm echo n c Findhdr
	Optional: i_sysselct

	This symbol, if defined, indicates to the C program that it should
	include <sys/time.h>.

I_SYS_TIMEB:
	Unit: i_systimeb
	Wants: test contains Loc Setvar Findhdr

	This symbol, if defined, indicates to the C program that it should
	include <sys/timeb.h>, in order to define struct timeb (some systems
	define this in <sys/time.h>). This is useful when using ftime().
	You should include <sys/time.h> if I_SYS_TIMEB is not defined,
	nor is I_SYS_TIME.

I_SYS_TIMES:
	Unit: i_systimes
	Wants: Inhdr

	This symbol, if defined, indicates to the C program that it should
	include <sys/times.h>.

I_SYS_TIME_KERNEL:
	Unit: i_time (Also defines i_systime i_systimek timeincl)
	Wants: cat cc ccflags contains rm echo n c Findhdr
	Optional: i_sysselct

	This symbol, if defined, indicates to the C program that it should
	include <sys/time.h> with KERNEL defined.

I_SYS_TWG_CF:
	Unit: i_systwgcf
	Wants: Inhdr

	This symbol, if defined, indicates to the C program that it should
	include sys/twg_config.h.

I_SYS_TYPES:
	Unit: i_systypes
	Wants: Inhdr

	This symbol, if defined, indicates to the C program that it should
	include <sys/types.h>.

I_SYS_UN:
	Unit: i_sysun
	Wants: Inhdr

	This symbol, if defined, indicates to the C program that it should
	include <sys/un.h> to get UNIX domain socket definitions.

I_SYS_WAIT:
	Unit: i_syswait
	Wants: Inhdr

	This symbol, if defined, indicates to the C program that it should
	include <sys/wait.h>.

I_TERMIO:
	Unit: i_termio (Also defines i_sgtty i_termios)
	Wants: test Inlibc Cppsym Guess Setvar Findhdr

	This symbol, if defined, indicates that the program should include
	<termio.h> rather than <sgtty.h>.  There are also differences in
	the ioctl() calls that depend on the value of this symbol.

I_TERMIOS:
	Unit: i_termio (Also defines i_sgtty i_termios)
	Wants: test Inlibc Cppsym Guess Setvar Findhdr

	This symbol, if defined, indicates that the program should include
	the POSIX termios.h rather than sgtty.h or termio.h.
	There are also differences in the ioctl() calls that depend on the
	value of this symbol.

I_TIME:
	Unit: i_time (Also defines i_systime i_systimek timeincl)
	Wants: cat cc ccflags contains rm echo n c Findhdr
	Optional: i_sysselct

	This symbol, if defined, indicates to the C program that it should
	include <time.h>.

I_UNISTD:
	Unit: i_unistd
	Wants: Inhdr

	This symbol, if defined, indicates to the C program that it should
	include <unistd.h>.

I_UTIME:
	Unit: i_utime
	Wants: Inhdr

	This symbol, if defined, indicates to the C program that it should
	include <utime.h>.

I_VALUES:
	Unit: i_values
	Wants: Inhdr

	This symbol, if defined, indicates to the C program that it should
	include <values.h> to get definition of symbols like MINFLOAT or
	MAXLONG, i.e. machine dependant limitations.  Probably, you
	should use <limits.h> instead, if it is available.

I_VARARGS:
	Unit: i_varhdr (Also defines i_stdarg i_varargs)
	Wants: cat rm test Setvar Findhdr startsh _o
	Optional: cc ccflags

	This symbol, if defined, indicates to the C program that it should
	include <varargs.h>.

I_VFORK:
	Unit: i_vfork
	Wants: Inhdr d_vfork

	This symbol, if defined, indicates to the C program that it should
	include vfork.h.

I_WHOAMI:
	Unit: i_whoami
	Wants: Inhdr

	This symbol, if defined, indicates that the program may include
	<whoami.h>.

KEEPALIVE:
	Obsoleted by CAN_KEEPALIVE.

KILLPG:
	Obsoleted by HAS_KILLPG.

LIBNDIR:
	Obsoleted by I_NDIR.

LIBSYSLOG:
	Obsoleted by HAS_SYSLOG.

LOCDIST:
	Unit: locdist (Also defines orgdist citydist statedist multistatedist
	  cntrydist contdist)
	Wants: test newslibexp cat Myread Oldconfig

	This symbol contains the distribution name for the news system that
	restricts article distribution to the local organization.

LOCKF:
	Obsoleted by HAS_LOCKF.

LOC_SED:
	Unit: Loc_sed (Also defines full_sed)
	Wants: sed

	This symbol holds the complete pathname to the sed program.

LONGSIZE:
	Unit: intsize (Also defines longsize shortsize)
	Wants: Myread cat rm
	Optional: cc optimize ccflags ldflags libs

	This symbol contains the value of sizeof(long) so that the C
	preprocessor can make decisions based on it.

LSEEKTYPE:
	Obsoleted by Off_t.

LSTAT:
	Obsoleted by HAS_LSTAT.

MAILFILE:
	Unit: mailfile
	Wants: Myread Oldconfig Filexp Loc

	This symbol contains the interpretable name of the mail spool file
	for the current user.  The program must be prepared to substitute
	the HOME directory for %~, and the login id for %L.

MALLOCPTRTYPE:
	Obsoleted by Malloc_t.

MBOXCHAR:
	Unit: mboxchar
	Wants: cat package shsharp Myread Oldconfig

	This symbol contains a character which will match the beginning
	of a mailbox file.

MBSTOWCS:
	Obsoleted by HAS_MBSTOWCS.

MBTOWC:
	Obsoleted by HAS_MBTOWC.

MEMCCPY:
	Obsoleted by HAS_MEMCCPY.

MEMCMP:
	Obsoleted by HAS_MEMCMP.

MEMCPY:
	Obsoleted by HAS_MEMCPY.

MEMSET:
	Obsoleted by HAS_MEMSET.

MEM_ALIGNBYTES:
	Unit: alignbytes
	Wants: Myread cat cc ccflags rm

	This symbol contains the number of bytes required to align a
	double. Usual values are 2, 4 and 8.

MKDIR:
	Obsoleted by HAS_MKDIR.

MULTISTATEDIST:
	Unit: locdist (Also defines orgdist citydist statedist multistatedist
	  cntrydist contdist)
	Wants: test newslibexp cat Myread Oldconfig

	This symbol contains the distribution name for the news system that
	restricts article distribution to a multi-state region.

MYDOMAIN:
	Unit: myhostname (Also defines phostname mydomain)
	Wants: contains sed test Myread Oldconfig Guess Loc awk echo sort
	  uniq rm hostcat Tr
	Optional: usrinc

	This symbol contains the domain of the host the program is going to
	run on.  The domain must be appended to HOSTNAME to form a complete
	host name.  The dot comes with MYDOMAIN, and need not be supplied by
	the program.  If the host name is derived from PHOSTNAME, the domain
	may or may not already be there, and the program should check.

MYHOSTNAME:
	Unit: myhostname (Also defines phostname mydomain)
	Wants: contains sed test Myread Oldconfig Guess Loc awk echo sort
	  uniq rm hostcat Tr
	Optional: usrinc

	This symbol contains name of the host the program is going to run on.
	The domain is not kept with hostname, but must be gotten from MYDOMAIN.
	The dot comes with MYDOMAIN, and need not be supplied by the program.
	If gethostname() or uname() exist, MYHOSTNAME may be ignored. If MYDOMAIN
	is not used, MYHOSTNAME will hold the name derived from PHOSTNAME.

MYMALLOC:
	Unit: mallocsrc (Also defines mallocobj usemymalloc malloctype
	  d_mymalloc freetype)
	Wants: Myread Oldconfig package Guess Setvar rm cat Findhdr i_malloc
	  i_stdlib sed libs _o
	Optional: cc ccflags

	This symbol, if defined, indicates that we're using our own malloc.

Malloc_t:
	Unit: mallocsrc (Also defines mallocobj usemymalloc malloctype
	  d_mymalloc freetype)
	Wants: Myread Oldconfig package Guess Setvar rm cat Findhdr i_malloc
	  i_stdlib sed libs _o
	Optional: cc ccflags

	This symbol is the type of pointer returned by malloc and realloc.

Mode_t:
	Unit: modetype
	Wants: Myread Typedef

	This symbol holds the type used to declare file modes 
	for systems calls.  It is usually mode_t, but may be
	int or unsigned short.  It may be necessary to include <sys/types.h>
	to get any typedef'ed information.

NDBM:
	Obsoleted by I_NDBM.

NEWS1_0:
	Obsoleted by HAS_NEWS1_0.

NEWS1_1:
	Obsoleted by HAS_NEWS1_1.

NEWSADMIN:
	Obsoleted by NEWS_ADMIN.

NEWSLEVEL:
	Unit: newslevel
	Wants: cat contains test activeexp newslib Myread Oldconfig

	The current revision level of the Usenet news system, encoded
	as 1000 * major rev + 10 * minor rev + sub rev.  For instance,
	news 2.10.3 is encode as 2103, and 2.11 as 2110.

NEWSLIB:
	Unit: newslib (Also defines newslibexp)
	Wants: test inews Oldconfig Getfile

	This symbol contains the name of the directory serving as the news
	library.  The program must be prepared to do ~ expansion on it.

NEWSLIB_EXP:
	Unit: newslib (Also defines newslibexp)
	Wants: test inews Oldconfig Getfile

	This symbol is the ~ expanded version of NEWSLIB, for programs that
	do not wish to deal with it at run-time.

NEWSSPOOL:
	Unit: newsspool (Also defines newsspoolexp)
	Wants: Getfile Oldconfig

	This symbol contains the directory name where news articles are
	spooled.  The program must be prepared to do ~ expansion on it.

NEWSSPOOL_EXP:
	Unit: newsspool (Also defines newsspoolexp)
	Wants: Getfile Oldconfig

	This is the same as NEWSSPOOL, but is filename expanded at
	configuration time, for use in programs not willing to do so
	at run-time.

NEWS_ADMIN:
	Unit: d_newsadm (Also defines newsadmin)
	Wants: cat contains Guess Setvar Myread Oldconfig

	This symbol, if defined, contains the login name of the news
	administrator.

NLIST_FOUND:
	Unit: nlist_pfx (Also defines nlist_fnd)
	Wants: cat test Myread Oldconfig libnlist
	Optional: cc ccflags

	This manifest constant holds the member of the nlist structure which
	is nonzero if an nlist search succeeds.

NLIST_PREFIX:
	Unit: nlist_pfx (Also defines nlist_fnd)
	Wants: cat test Myread Oldconfig libnlist
	Optional: cc ccflags

	This manifest constant holds the string of characters which should
	preceed the symbol name when doing an nlist search.

NOLINEBUF:
	Unit: d_nolnbuf
	Wants: test cat rm Setvar Myread
	Optional: cc

	This symbol, if defined, indicates that stdout is not buffered, so that
	the program can call setbuf() or setlinebuf() for efficiency.

NORMSIG:
	Unit: d_normsig (Also defines jobslib)
	Wants: test Setvar Guess _a

	This symbol, if defined, indicates that normal signal handling routines
	should be used, as opposed to the ones in 4.1bsd (sigset, etc.).

NO_TIME_WITH_SYS_TIME:
	Obsoleted by I_SYS_TIME.

NTOHL:
	Obsoleted by HAS_NTOHL.

NTOHS:
	Obsoleted by HAS_NTOHS.

NXT_ARG:
	Unit: prototype
	Wants: Myread Oldconfig cat rm Setvar
	Optional: cc ccflags

	This macro is used to separate arguments in the declared argument list.

ODBM:
	Obsoleted by I_DBM.

OLDSOCKET:
	Obsoleted by USE_OLDSOCKET.

OPEN3:
	Obsoleted by HAS_OPEN3.

ORGDIST:
	Unit: locdist (Also defines orgdist citydist statedist multistatedist
	  cntrydist contdist)
	Wants: test newslibexp cat Myread Oldconfig

	This symbol contains the distribution name for the news system that
	restricts article distribution to the organization.

ORGNAME:
	Unit: orgname
	Wants: sed cat Myread Loc Oldconfig

	This symbol contains either the organizaton name or the full pathname
	of a file containing the organization name, which the program must
	be prepared to open and substitute the contents of.

OSNAME:
	Unit: Oldconfig (Also defines hint myuname osname osvers)
	Wants: Instruct Myread uname sh awk sed test cat rm lns n c contains
	  Loc Options Tr src

	This symbol contains the name of the operating system, as determined
	by Configure.  You shouldn't rely on it too much; the specific
	feature tests from Configure are generally more reliable.

Off_t:
	Unit: lseektype
	Wants: Myread Typedef

	This symbol holds the type used to declare offsets in the kernel.
	It can be int, long, off_t, etc... It may be necessary to include
	<sys/types.h> to get any typedef'ed information.

P:
	Obsoleted by _.

PAGESIZE_VALUE:
	Unit: d_getpagsz (Also defines pagesize)
	Wants: Oldconfig Myread Inlibc cat contains libs rm Findhdr
	Optional: cc ccflags

	This symbol holds the size in bytes of a system page (obtained via
	the getpagesize() system call at configuration time or asked to the
	user if the system call is not available).

PAGSIZE:
	Obsoleted by PAGESIZE_VALUE.

PASSNAMES:
	Unit: nametype (Also defines d_passnames d_berknames d_usgnames)
	Wants: Myread Guess Oldconfig cat

	This symbol, if defined, indicates that full names are stored in
	the /etc/passwd file.

PERLPATH:
	Unit: perlpath
	Wants: Getfile Oldconfig Loc perl

	This symbol contains the absolute location of the perl interpeter.

PERSISTENT_SIGNAL:
	Obsoleted by SIGNALS_KEPT.

PHOSTNAME:
	Unit: d_gethname (Also defines d_uname d_phostname aphostname)
	Wants: phostname cat myhostname package d_portable Loc libc echo n c
	  Myread Guess Oldconfig Csym
	Optional: i_whoami usrinc

	This symbol, if defined, indicates that the C program may use the
	contents of PHOSTNAME as a command to feed to the popen() routine
	to derive the host name.  See also HAS_GETHOSTNAME and HAS_UNAME.
	Note that the command uses a fully qualified path, so that it is safe
	even if used by a process with super-user privileges.

PIDCHECK:
	Unit: d_pidcheck
	Wants: cat rm _o
	Optional: cc

	This symbol, if defined, means that the kill(pid, 0) will
	check for an active pid (i.e. the kernel will run all the
	necessary pid checks, but no signal is actually sent).

PIDTYPE:
	Obsoleted by Pid_t.

POPEN:
	Obsoleted by HAS_POPEN.

PORTABLE:
	Unit: d_portable
	Wants: cat Loc Myread Oldconfig

	This symbol, if defined, indicates to the C program that it should
	not assume that it is running on the machine it was compiled on.
	The program should be prepared to look up the host name, translate
	generic filenames, use PATH, etc.

PORTAR:
	Unit: d_PORTAR
	Wants: cat rm Setvar
	Optional: cc

	This manifest constant must be defined to 1 for some implementations
	of ar.h to get the portable ar most everybody uses.

PREFSHELL:
	Unit: prefshell
	Wants: cat package Getfile Oldconfig ksh csh bash

	This symbol contains the full name of the preferred user shell on this
	system.  Usual values are /bin/csh, /bin/ksh, /bin/sh.

PRIVLIB:
	Unit: privlib (Also defines privlibexp installprivlib)
	Wants: afs package cat Getfile Oldconfig Prefixit test

	This symbol contains the name of the private library for this package.
	The library is private in the sense that it needn't be in anyone's
	execution path, but it should be accessible by the world.  The program
	should be prepared to do ~ expansion.

PRIVLIB_EXP:
	Unit: privlib (Also defines privlibexp installprivlib)
	Wants: afs package cat Getfile Oldconfig Prefixit test

	This symbol contains the ~name expanded version of PRIVLIB, to be used
	in programs that are not prepared to deal with ~ expansion at run-time.

PSIGNAL:
	Obsoleted by HAS_PSIGNAL.

PTRSIZE:
	Unit: ptrsize
	Wants: cat rm Myread
	Optional: cc ccflags

	This symbol contains the size of a pointer, so that the C preprocessor
	can make decisions based on it.

PWAGE:
	Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass
	  d_pwexpire d_pwcomment)
	Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar

	This symbol, if defined, indicates to the C program that struct passwd
	contains pw_age.

PWCHANGE:
	Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass
	  d_pwexpire d_pwcomment)
	Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar

	This symbol, if defined, indicates to the C program that struct passwd
	contains pw_change.

PWCLASS:
	Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass
	  d_pwexpire d_pwcomment)
	Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar

	This symbol, if defined, indicates to the C program that struct passwd
	contains pw_class.

PWCOMMENT:
	Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass
	  d_pwexpire d_pwcomment)
	Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar

	This symbol, if defined, indicates to the C program that struct passwd
	contains pw_comment.

PWEXPIRE:
	Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass
	  d_pwexpire d_pwcomment)
	Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar

	This symbol, if defined, indicates to the C program that struct passwd
	contains pw_expire.

PWQUOTA:
	Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass
	  d_pwexpire d_pwcomment)
	Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar

	This symbol, if defined, indicates to the C program that struct passwd
	contains pw_quota.

P_FUNC:
	Unit: prototype
	Wants: Myread Oldconfig cat rm Setvar
	Optional: cc ccflags

	This macro is used to declare "private" (static) functions.
	It takes three arguments: the function type and name, a parenthesized
	traditional (comma separated) argument list, and the declared argument
	list (in which arguments are separated with NXT_ARG, and additional
	arbitrary arguments are specified with DOTS).  For example:
	
		P_FUNC(int foo, (bar, baz), int bar NXT_ARG char *baz[])

P_FUNC_VOID:
	Unit: prototype
	Wants: Myread Oldconfig cat rm Setvar
	Optional: cc ccflags

	This macro is used to declare "private" (static) functions that have
	no arguments.  The macro takes one argument: the function type and name.
	For example:
	
		P_FUNC_VOID(int subr)

Pid_t:
	Unit: pidtype
	Wants: Myread Typedef

	This symbol holds the type used to declare process ids in the kernel.
	It can be int, uint, pid_t, etc... It may be necessary to include
	<sys/types.h> to get any typedef'ed information.

RANDBITS:
	Unit: randbits
	Wants: cat rm Myread cc i_unistd i_stdlib

	This symbol contains the number of bits of random number the rand()
	function produces.  Usual values are 15, 16, and 31.

RASTER_TEK:
	Unit: d_raster (Also defines rasterlib)
	Wants: cat test Setvar Myread Oldconfig

	Defined if this is a rastertech machine.

RDCHK:
	Obsoleted by HAS_RDCHK.

RD_NODATA:
	Unit: nblock_io (Also defines o_nonblock eagain rd_nodata d_eofnblk)
	Wants: cat rm d_open3 h_sysfile h_fcntl signal_t hint Oldconfig
	  Setvar startsh
	Optional: cc ccflags ldflags

	This symbol holds the return code from read() when no data is present
	on the non-blocking file descriptor. Be careful! If EOF_NONBLOCK is
	not defined, then you can't distinguish between no data and EOF by
	issuing a read(). You'll have to find another way to tell for sure!

READDIR:
	Obsoleted by HAS_READDIR.

RECOMP:
	Obsoleted by HAS_RECOMP.

REGCMP:
	Obsoleted by HAS_REGCMP.

REGCOMP:
	Obsoleted by HAS_REGCOMP.

RENAME:
	Obsoleted by HAS_RENAME.

RMDIR:
	Obsoleted by HAS_RMDIR.

ROOTID:
	Unit: rootid
	Wants: sed

	This symbol contains the uid of root, normally 0.

ROOT_CHOWN:
	Obsoleted by SU_CHOWN.

RUSAGE:
	Obsoleted by HAS_GETRUSAGE.

SAFE_BCOPY:
	Obsoleted by HAS_SAFE_BCOPY.

SAFE_MEMCPY:
	Obsoleted by HAS_SAFE_MEMCPY.

SBRKTYPE:
	Obsoleted by Caddr_t.

SCAN_NL:
	Unit: d_scannl
	Wants: cat rm Setvar
	Optional: cc ccflags

	This symbol is defined if the C library routines scanf() and friends
	can deal with a '\n' in the input correctly, so that you can say
	scanf("%d\n"); instead of scanf("%d"); getc(c); to handle the '\n'.

SCAT2:
	Unit: cpp_stuff
	Wants: cat contains cppstdin cppflags cppminus rm

	This macro catenates 2 tokens together and stringifies the result.

SCAT3:
	Unit: cpp_stuff
	Wants: cat contains cppstdin cppflags cppminus rm

	This macro catenates 3 tokens together and stringifies the result.

SCAT4:
	Unit: cpp_stuff
	Wants: cat contains cppstdin cppflags cppminus rm

	This macro catenates 4 tokens together and stringifies the result.

SCAT5:
	Unit: cpp_stuff
	Wants: cat contains cppstdin cppflags cppminus rm

	This macro catenates 5 tokens together and stringifies the result.

SCOREFULL:
	Unit: d_scorfl
	Wants: cat Myread Oldconfig nametype Setvar

	This symbol, if defined, indicates that any scoreboard kept by the
	program should be kept on the basis of the user's full name as opposed
	to the user's login name.  If the user can change his full name he
	can enter multiple scores if this is defined.

SCRIPTDIR:
	Unit: scriptdir (Also defines scriptdirexp installscript)
	Wants: afs cat test Getfile Loc Oldconfig Prefixit prefixexp Prefixup
	Optional: bin

	This symbol holds the name of the directory in which the user wants
	to put publicly executable scripts for the package in question.  It
	is often a directory that is mounted across diverse architectures.
	Programs must be prepared to deal with ~name expansion.

SCRIPTDIR_EXP:
	Unit: scriptdir (Also defines scriptdirexp installscript)
	Wants: afs cat test Getfile Loc Oldconfig Prefixit prefixexp Prefixup
	Optional: bin

	This is the same as SCRIPTDIR, but is filename expanded at
	configuration time, for use in programs not prepared to do
	~name substitutions at run-time.

SELECT:
	Obsoleted by HAS_SELECT.

SERVE_INET_TCP:
	Unit: ipc (Also defines serve_shm serve_msg serve_inet_udp
	  serve_inet_tcp serve_unix_udp serve_unix_tcp)
	Wants: test Myread Oldconfig d_socket d_msg d_shm d_sem

	If defined, tells the C program to enable InterNet-domain TCP
	support for IPC.

SERVE_INET_UDP:
	Unit: ipc (Also defines serve_shm serve_msg serve_inet_udp
	  serve_inet_tcp serve_unix_udp serve_unix_tcp)
	Wants: test Myread Oldconfig d_socket d_msg d_shm d_sem

	If defined, tells the C program to enable InterNet-domain UDP
	support for IPC.

SERVE_MSG:
	Unit: ipc (Also defines serve_shm serve_msg serve_inet_udp
	  serve_inet_tcp serve_unix_udp serve_unix_tcp)
	Wants: test Myread Oldconfig d_socket d_msg d_shm d_sem

	If defined, tells the C program to use USG message queues for IPC.

SERVE_SHM:
	Unit: ipc (Also defines serve_shm serve_msg serve_inet_udp
	  serve_inet_tcp serve_unix_udp serve_unix_tcp)
	Wants: test Myread Oldconfig d_socket d_msg d_shm d_sem

	If defined, tells the C program to use USG shared memory for IPC.

SERVE_UNIX_TCP:
	Unit: ipc (Also defines serve_shm serve_msg serve_inet_udp
	  serve_inet_tcp serve_unix_udp serve_unix_tcp)
	Wants: test Myread Oldconfig d_socket d_msg d_shm d_sem

	If defined, tells the C program to enable Unix-domain TCP
	support for IPC.

SERVE_UNIX_UDP:
	Unit: ipc (Also defines serve_shm serve_msg serve_inet_udp
	  serve_inet_tcp serve_unix_udp serve_unix_tcp)
	Wants: test Myread Oldconfig d_socket d_msg d_shm d_sem

	If defined, tells the C program to enable Unix-domain UDP
	support for IPC.

SETEGID:
	Obsoleted by HAS_SETEGID.

SETEUID:
	Obsoleted by HAS_SETEUID.

SETPGRP:
	Obsoleted by HAS_SETPGRP.

SETPGRP2:
	Obsoleted by HAS_SETPGRP2.

SETPRIORITY:
	Obsoleted by HAS_SETPRIORITY.

SETREGID:
	Obsoleted by HAS_SETREGID.

SETRESGID:
	Obsoleted by HAS_SETRESGID.

SETRESUID:
	Obsoleted by HAS_SETRESUID.

SETREUID:
	Obsoleted by HAS_SETREUID.

SETRGID:
	Obsoleted by HAS_SETRGID.

SETRUID:
	Obsoleted by HAS_SETRUID.

SETUID_SCRIPTS_ARE_SECURE_NOW:
	Unit: d_dosuid (Also defines d_suidsafe)
	Wants: cat contains ls rm test Myread Setvar Oldconfig Guess package
	  hint

	This symbol, if defined, indicates that the bug that prevents
	setuid scripts from being secure is not present in this kernel.

SHMLBA_WANTS_IMMU:
	Unit: d_SHM_MAC (Also defines d_SHM_PRM d_SHM_SEG d_SHM_IMMU)
	Wants: cat d_shm test rm
	Optional: cc ccflags

	This value tells us to include <sys/immu.h> because SHMLBA needs
	something from there, probably the stob() macro.  (tower_600 only?)

SHMLBA_WANTS_PARAM:
	Unit: d_SHM_MAC (Also defines d_SHM_PRM d_SHM_SEG d_SHM_IMMU)
	Wants: cat d_shm test rm
	Optional: cc ccflags

	This value tells us to include <sys/param.h> because SHMLBA needs
	something from there, probably the NBPC constant.

SHMLBA_WANTS_SEG:
	Unit: d_SHM_MAC (Also defines d_SHM_PRM d_SHM_SEG d_SHM_IMMU)
	Wants: cat d_shm test rm
	Optional: cc ccflags

	This value tells us to include <sys/seg.h> because SHMLBA needs
	something from there, probably the SNUMSHFT constant.

SHMLBA_WANTS_SYSMACROS:
	Unit: d_SHM_MAC (Also defines d_SHM_PRM d_SHM_SEG d_SHM_IMMU)
	Wants: cat d_shm test rm
	Optional: cc ccflags

	This value tells us to include <sys/sysmacros.h> because SHMLBA
	needs something from there, probably the ctob() macro.

SHORTSIZE:
	Unit: intsize (Also defines longsize shortsize)
	Wants: Myread cat rm
	Optional: cc optimize ccflags ldflags libs

	This symbol contains the value of sizeof(short) so that the C
	preprocessor can make decisions based on it.

SH_PATH:
	Unit: sh
	Wants: Head

	This symbol contains the full pathname to the shell used on this
	on this system to execute Bourne shell scripts.  Usually, this will be
	/bin/sh, though it's possible that some systems will have /bin/ksh,
	/bin/pdksh, /bin/ash, /bin/bash, or even something such as
	D:/bin/sh.exe.

SIGINTRP:
	Obsoleted by HAS_SIGINTRP.

SIGNALS_KEPT:
	Unit: d_keepsig
	Wants: cat rm Guess contains echo n c Setvar
	Optional: cc ccflags

	This symbol is defined if signal handlers needn't be reinstated after
	receipt of a signal.

SIGNAL_T:
	Obsoleted by Signal_t.

SIGNEDCHAR:
	Unit: d_sgndchr
	Wants: cat rm Setvar
	Optional: cc ccflags

	This symbol, if defined, indicates that characters are a signed type.
	If not defined, things declared as signed characters (and that make
	use of negative values) should probably be declared as shorts instead.

SIGSETMASK:
	Obsoleted by HAS_SIGSETMASK.

SIGVEC:
	Obsoleted by HAS_SIGVEC.

SIGVECTOR:
	Obsoleted by HAS_SIGVECTOR.

SIG_NAME:
	Unit: sig_name (Also defines sig_num)
	Wants: awk Signal Oldconfig rm

	This symbol contains a list of signal names in order of
	signal number. This is intended
	to be used as a static array initialization, like this:
		char *sig_name[] = { SIG_NAME };
	The signals in the list are separated with commas, and each signal
	is surrounded by double quotes. There is no leading SIG in the signal
	name, i.e. SIGQUIT is known as "QUIT".
	Gaps in the signal numbers (up to NSIG) are filled in with NUMnn,
	etc., where nn is the actual signal number (e.g. NUM37).
	The signal number for sig_name[i] is stored in sig_num[i].
	The last element is 0 to terminate the list with a NULL.  This
	corresponds to the 0 at the end of the sig_num list.

SIG_NUM:
	Unit: sig_name (Also defines sig_num)
	Wants: awk Signal Oldconfig rm

	This symbol contains a list of signal numbers, in the same order as the
	SIG_NAME list. It is suitable for static array initialization, as in:
		int sig_num[] = { SIG_NUM };
	The signals in the list are separated with commas, and the indices
	within that list and the SIG_NAME list match, so it's easy to compute
	the signal name from a number or vice versa at the price of a small
	dynamic linear lookup. 
	Duplicates are allowed, but are moved to the end of the list.
	The signal number corresponding to sig_name[i] is sig_number[i].
	if (i < NSIG) then sig_number[i] == i.  
	The last element is 0, corresponding to the 0 at the end of
	the sig_name list.

SITEARCH:
	Unit: sitearch (Also defines sitearchexp installsitearch)
	Wants: afs cat Getfile Oldconfig Prefixit prefix test archname sitelib

	This symbol contains the name of the private library for this package.
	The library is private in the sense that it needn't be in anyone's
	execution path, but it should be accessible by the world.  The program
	should be prepared to do ~ expansion.
	The standard distribution will put nothing in this directory.
	Individual sites may place their own extensions and modules in
	this directory.

SITEARCH_EXP:
	Unit: sitearch (Also defines sitearchexp installsitearch)
	Wants: afs cat Getfile Oldconfig Prefixit prefix test archname sitelib

	This symbol contains the ~name expanded version of SITEARCH, to be used
	in programs that are not prepared to deal with ~ expansion at run-time.

SITELIB:
	Unit: sitelib (Also defines sitelibexp installsitelib)
	Wants: afs cat Getfile Oldconfig Prefixit test privlib package sed

	This symbol contains the name of the private library for this package.
	The library is private in the sense that it needn't be in anyone's
	execution path, but it should be accessible by the world.  The program
	should be prepared to do ~ expansion.
	The standard distribution will put nothing in this directory.
	Individual sites may place their own extensions and modules in
	this directory.

SITELIB_EXP:
	Unit: sitelib (Also defines sitelibexp installsitelib)
	Wants: afs cat Getfile Oldconfig Prefixit test privlib package sed

	This symbol contains the ~name expanded version of SITELIB, to be used
	in programs that are not prepared to deal with ~ expansion at run-time.

SOCKET:
	Obsoleted by HAS_SOCKET.

SOCKETPAIR:
	Obsoleted by HAS_SOCKETPAIR.

SPEEDOVERMEM:
	Obsoleted by SPEED_OVER_MEM.

SPEED_OVER_MEM:
	Unit: d_speedopt
	Wants: Myread Cppsym Oldconfig cat models Setvar

	This symbol, if defined, indicates that the program can use more
	memory in order to reduce CPU time.  The symbol doesn't say whether
	we are more interested in saving text space or data space.

SSize_t:
	Unit: ssizetype
	Wants: Myread Typedef sizetype cat rm _o
	Optional: cc optimize ccflags ldflags libs

	This symbol holds the type used by functions that return
	a count of bytes or an error condition.  It must be a signed type.
	It is usually ssize_t, but may be long or int, etc.
	It may be necessary to include <sys/types.h> or <unistd.h>
	to get any typedef'ed information.
	We will pick a type such that sizeof(SSize_t) == sizeof(Size_t).

STARTPERL:
	Unit: startperl
	Wants: cat rm sharpbang perlpath d_portable Myread

	This symbol is the string that should be put on the front of a
	perl script to make sure (hopefully) that it runs with perl and
	not under some shell. That line should be followed by the classical
	invocation magic:
		eval 'exec perl -S $0 ${1+"$@"}'
			if $running_under_some_shell;
	to guarantee perl startup should the shell execute the script at first.

STAT:
	Obsoleted by HAS_STAT.

STATBLOCKS:
	Obsoleted by USE_STAT_BLOCKS.

STATEDIST:
	Unit: locdist (Also defines orgdist citydist statedist multistatedist
	  cntrydist contdist)
	Wants: test newslibexp cat Myread Oldconfig

	This symbol contains the distribution name for the news system that
	restricts article distribution to the state or province.

STAT_MACROS_BROKEN:
	Unit: d_brokstat
	Wants: cat contains cppstdin cppminus rm Setvar
	Optional: cppflags

	This symbol, if defined, indicates that the S_IS*() stat macros
	such as S_ISBLK() give false positive and are thus unusable.
	Your best bet is then to supply your own set.

STDCHAR:
	Unit: stdchar
	Wants: contains Findhdr

	This symbol is defined to be the type of char used in stdio.h.
	It has the values "unsigned char" or "char".

STDIO_CNT_LVALUE:
	Unit: d_stdstdio (Also defines d_stdiobase stdio_ptr stdio_cnt
	  stdio_base stdio_bufsiz d_stdio_cnt_lval d_stdio_ptr_lval
	  stdio_filbuf)
	Wants: cat contains rm Setvar Findhdr Oldconfig
	Optional: cc ccflags ldflags libs

	This symbol is defined if the FILE_cnt macro can be used as an
	lvalue.

STDIO_PTR_LVALUE:
	Unit: d_stdstdio (Also defines d_stdiobase stdio_ptr stdio_cnt
	  stdio_base stdio_bufsiz d_stdio_cnt_lval d_stdio_ptr_lval
	  stdio_filbuf)
	Wants: cat contains rm Setvar Findhdr Oldconfig
	Optional: cc ccflags ldflags libs

	This symbol is defined if the FILE_ptr macro can be used as an
	lvalue.

STDSTDIO:
	Obsoleted by USE_STDIO_PTR.

STRCSPN:
	Obsoleted by HAS_STRCSPN.

STRERROR:
	Obsoleted by HAS_STRERROR.

STRINGIFY:
	Unit: cpp_stuff
	Wants: cat contains cppstdin cppflags cppminus rm

	This macro surrounds its token with double quotes.

STRSTR:
	Obsoleted by HAS_STRSTR.

STRTOD:
	Obsoleted by HAS_STRTOD.

STRTOK:
	Obsoleted by HAS_STRTOK.

STRTOL:
	Obsoleted by HAS_STRTOL.

STRTOUL:
	Obsoleted by HAS_STRTOUL.

STRUCTCOPY:
	Obsoleted by USE_STRUCT_COPY.

SUNSCANF:
	Unit: sunscanf
	Wants: cat rm Myread test Setvar
	Optional: cc ccflags

	This variable is set if this system runs with the Sun version
	of scanf.

SU_CHOWN:
	Unit: d_su_chown
	Wants: Csym Setvar

	This symbol, if defined, indicates that the system allows only root
	can change the owner of a file with chown().

SYMLINK:
	Obsoleted by HAS_SYMLINK.

SYSCALL:
	Obsoleted by HAS_SYSCALL.

SYSERRLIST:
	Obsoleted by HAS_SYS_ERRLIST.

SYSERRNOLIST:
	Obsoleted by HAS_SYS_ERRNOLIST.

SYSTEM:
	Obsoleted by HAS_SYSTEM.

SYS_SIGLIST:
	Obsoleted by HAS_SYS_SIGLIST.

S_SHM_ATT:
	Unit: shm_for (Also defines shm_att shm_lim)
	Wants: Cppsym Myread ipc uname

	This symbol holds the default "place" to attach shared memory.
	Values are "HIGH", "ZERO", and "LOW".

S_SHM_FOR:
	Unit: shm_for (Also defines shm_att shm_lim)
	Wants: Cppsym Myread ipc uname

	This symbol identifies what we chose for the target system's
	default shared memory configuration parameters.

S_SHM_LIM:
	Unit: shm_for (Also defines shm_att shm_lim)
	Wants: Cppsym Myread ipc uname

	This symbol holds the default upper bound address limit if shared
	memory is attached HIGH.  If zero, there is no upper limit.

Select_fd_set_t:
	Unit: selecttype
	Wants: cat rm Oldconfig Myread d_fd_set d_select d_socket i_systime
	  i_sysselct
	Optional: cc ccflags

	This symbol holds the type used for the 2nd, 3rd, and 4th
	arguments to select.  Usually, this is 'fd_set *', if HAS_FD_SET
	is defined, and 'int *' otherwise.  This is only useful if you 
	have select(), of course.

Shmat_t:
	Unit: d_shmat (Also defines shmattype d_shmatprototype)
	Wants: Inlibc cat rm cppstdin cppflags cppminus Findhdr Setvar
	  contains
	Optional: cc ccflags

	This symbol holds the return type of the shmat() system call.
	Usually set to 'void *' or 'char *'.

Sigjmp_buf:
	Unit: d_sigsetjmp
	Wants: Setvar cat libs rm
	Optional: cc ccflags ldflags

	This is the buffer type to be used with Sigsetjmp and Siglongjmp.

Siglongjmp:
	Unit: d_sigsetjmp
	Wants: Setvar cat libs rm
	Optional: cc ccflags ldflags

	This macro is used in the same way as siglongjmp(), but will invoke
	traditional longjmp() if siglongjmp isn't available.
	See HAS_SIGSETJMP.

Signal_t:
	Unit: d_voidsig (Also defines signal_t)
	Wants: rm contains cppstdin cppminus test Myread Oldconfig Setvar
	  Findhdr
	Optional: cppflags

	This symbol's value is either "void" or "int", corresponding to the
	appropriate return type of a signal handler.  Thus, you can declare
	a signal handler using "Signal_t (*handler)()", and define the
	handler using "Signal_t handler(sig)".

Sigsetjmp:
	Unit: d_sigsetjmp
	Wants: Setvar cat libs rm
	Optional: cc ccflags ldflags

	This macro is used in the same way as sigsetjmp(), but will invoke
	traditional setjmp() if sigsetjmp isn't available.
	See HAS_SIGSETJMP.

Size_t:
	Unit: sizetype
	Wants: Myread Typedef

	This symbol holds the type used to declare length parameters
	for string functions.  It is usually size_t, but may be
	unsigned long, int, etc.  It may be necessary to include
	<sys/types.h> to get any typedef'ed information.

Strerror:
	Unit: d_strerror (Also defines d_syserrlst d_sysernlst d_strerrm)
	Wants: contains Csym Findhdr

	This preprocessor symbol is defined as a macro if strerror() is
	not available to translate error numbers to strings but sys_errlist[]
	array is there.

TEXTCAN:
	Unit: d_NeWS (Also defines d_news d_news0 d_newshome d_textcan)
	Wants: test rm Myread Getfile

	Tells path to where the textcan.ps stuff is...

TIMER:
	Obsoleted by HAS_TIME.

TIMES:
	Obsoleted by HAS_TIMES.

TIMETYPE:
	Obsoleted by Time_t.

TMINSYS:
	Obsoleted by TM_IN_SYS.

TM_IN_SYS:
	Unit: d_tminsys
	Wants: contains Setvar Findhdr

	This symbol is defined if this system declares "struct tm" in
	in <sys/time.h> rather than <time.h>.  We can't just say
	-I/usr/include/sys because some systems have both time files, and
	the -I trick gets the wrong one.

TRUNCATE:
	Obsoleted by HAS_TRUNCATE.

TZ_MINUTESWEST:
	Unit: d_tzmin
	Wants: contains cppstdin cppminus timeincl rm Setvar Guess

	This symbol is defined if this system uses tz_minuteswest
	in time header instead of timezone.
	If not defined, you may have to use struct timeb and ftime() rather
	than the new gettimeofday() system call.

Time_t:
	Unit: d_time (Also defines timetype)
	Wants: Csym Setvar Findhdr Myread Typedef

	This symbol holds the type returned by time(). It can be long,
	or time_t on BSD sites (in which case <sys/types.h> should be
	included).

UIDTYPE:
	Obsoleted by Uid_t.

ULIMIT:
	Obsoleted by HAS_ULIMIT.

UNAME:
	Obsoleted by HAS_UNAME.

UNION_WAIT:
	Unit: d_uwait (Also defines d_uwait3)
	Wants: cat contains cppstdin cppminus rm Setvar Findhdr
	Optional: cppflags

	This symbol if defined indicates to the C program that the argument
	for the wait() system call should be declared as 'union wait status'
	instead of 'int status'. You probably need to include <sys/wait.h>
	in the former case (see I_SYSWAIT).

UNION_WAIT3:
	Unit: d_uwait (Also defines d_uwait3)
	Wants: cat contains cppstdin cppminus rm Setvar Findhdr
	Optional: cppflags

	This symbol if defined indicates to the C program that the first argument
	for the wait3() system call should be declared as 'union wait status'
	instead of 'int status'. You probably need to include <sys/wait.h>
	in the former case (see I_SYSWAIT). It seems safe to assume that the
	same rule applies to the second parameter of wait4().

USENDIR:
	Obsoleted by EMULATE_NDIR.

USE_BSDJMP:
	Unit: d_bsdjmp
	Wants: Guess Setvar cat libs rm
	Optional: cc

	This symbol, if defined, indicates that the BSD _setjmp and _longjmp
	routines are available to do non-local gotos wihtout saving or restoring
	the signal mask flag.

USE_BSDPGRP:
	Obsoleted by USE_BSD_SETPGRP.

USE_BSD_GETPGRP:
	Unit: d_getpgrp (Also defines d_bsdgetpgrp)
	Wants: Guess Inlibc Setvar cat rm i_unistd
	Optional: cc ccflags ldflags libs

	This symbol, if defined, indicates that getpgrp needs one
	arguments whereas USG one needs none.

USE_BSD_SETPGRP:
	Unit: d_setpgrp (Also defines d_bsdsetpgrp)
	Wants: cat rm Inlibc Guess Setvar i_unistd
	Optional: cc libs ccflags ldflags

	This symbol, if defined, indicates that setpgrp needs two
	arguments whereas USG one needs none.  See also HAS_SETPGID
	for a POSIX interface.

USE_CHAR_VSPRINTF:
	Unit: d_vprintf (Also defines d_charvspr)
	Wants: Guess cat Csym Setvar
	Optional: cc ccflags

	This symbol is defined if this system has vsprintf() returning type
	(char*).  The trend seems to be to declare it as "int vsprintf()".  It
	is up to the package author to declare vsprintf correctly based on the
	symbol.

USE_INETD:
	Unit: d_inetd
	Wants: cat test package Myread Setvar

	This symbol if defined indicates to the C program that inetd will be
	in charge of the initial socket connection. The file descriptors 0 and
	1 have been dup()ed from the original connected socket descriptor and
	are ready for send() and recv().

USE_LINUX_STDIO:
	Unit: d_linuxstd
	Wants: d_stdstdio cppstdin cppflags cppminus contains rm Setvar
	  Findhdr

	This symbol is defined if this system has a FILE structure declaring
	_IO_read_base, _IO_read_ptr, and _IO_read_end in stdio.h.

USE_OLDSOCKET:
	Unit: d_socket (Also defines d_oldsock d_sockpair socketlib sockethdr)
	Wants: contains libc echo n c nm_opt nm_extract Inlibc Csym _a

	This symbol, if defined, indicates that the 4.1c BSD socket interface
	is supported instead of the 4.2/4.3 BSD socket interface. For instance,
	there is no setsockopt() call.

USE_STAT_BLOCKS:
	Unit: d_statblks
	Wants: contains Setvar Findhdr

	This symbol is defined if this system has a stat structure declaring
	st_blksize and st_blocks.

USE_STDIO_BASE:
	Unit: d_stdstdio (Also defines d_stdiobase stdio_ptr stdio_cnt
	  stdio_base stdio_bufsiz d_stdio_cnt_lval d_stdio_ptr_lval
	  stdio_filbuf)
	Wants: cat contains rm Setvar Findhdr Oldconfig
	Optional: cc ccflags ldflags libs

	This symbol is defined if the _base field (or similar) of the
	stdio FILE structure can be used to access the stdio buffer for
	a file handle.  If this is defined, then the FILE_base(fp) macro
	will also be defined and should be used to access this field.
	Also, the FILE_bufsiz(fp) macro will be defined and should be used
	to determine the number of bytes in the buffer.  USE_STDIO_BASE
	will never be defined unless USE_STDIO_PTR is.

USE_STDIO_PTR:
	Unit: d_stdstdio (Also defines d_stdiobase stdio_ptr stdio_cnt
	  stdio_base stdio_bufsiz d_stdio_cnt_lval d_stdio_ptr_lval
	  stdio_filbuf)
	Wants: cat contains rm Setvar Findhdr Oldconfig
	Optional: cc ccflags ldflags libs

	This symbol is defined if the _ptr and _cnt fields (or similar)
	of the stdio FILE structure can be used to access the stdio buffer
	for a file handle.  If this is defined, then the FILE_ptr(fp)
	and FILE_cnt(fp) macros will also be defined and should be used
	to access these fields.

USE_STD_STDIO:
	Obsoleted by USE_STDIO_PTR.

USE_STRUCT_COPY:
	Unit: d_strctcpy
	Wants: cat rm cc Setvar

	This symbol, if defined, indicates that this C compiler knows how
	to copy structures.  If undefined, you'll need to use a block copy
	routine of some sort instead.

USE_SYS_TIME_H:
	Obsoleted by I_SYS_TIME.

USE_TIME_H:
	Obsoleted by I_TIME.

USE_TIOCNOTTY:
	Unit: i_sysioctl (Also defines i_bsdioctl i_sysfilio i_syssockio
	  d_voidtty)
	Wants: test contains cat i_termio i_termios i_sgtty Setvar Findhdr rm
	  Inhdr
	Optional: cc

	This symbol, if defined indicate to the C program that the ioctl()
	call with TIOCNOTTY should be used to void tty association.
	Otherwise (on USG probably), it is enough to close the standard file
	decriptors and do a setpgrp().

USE_WIFSTAT:
	Unit: d_wifstat
	Wants: d_uwait Oldconfig cat rm
	Optional: cc ccflags ldflags libs

	This symbol, if defined, indicates to the C program that the argument
	for the WIFxxx set of macros such as WIFSIGNALED or WIFEXITED can
	be of the same kind as the one used to hold the wait() status. Should
	only matter on HP-UX, where the macros are incorrectly written and
	therefore cause programs using them with an 'union wait' variable
	to not compile properly. See also UNION_WAIT.

USGNAMES:
	Unit: nametype (Also defines d_passnames d_berknames d_usgnames)
	Wants: Myread Guess Oldconfig cat

	This symbol, if defined, indicates that full names are stored in
	the /etc/passwd file in USG format (everything after - and before ( is
	the name).

USLEEP:
	Obsoleted by HAS_USLEEP.

Uid_t:
	Unit: uidtype
	Wants: Myread Typedef Findhdr

	This symbol holds the type used to declare user ids in the kernel.
	It can be int, ushort, uid_t, etc... It may be necessary to include
	<sys/types.h> to get any typedef'ed information.

VAL_EAGAIN:
	Unit: nblock_io (Also defines o_nonblock eagain rd_nodata d_eofnblk)
	Wants: cat rm d_open3 h_sysfile h_fcntl signal_t hint Oldconfig
	  Setvar startsh
	Optional: cc ccflags ldflags

	This symbol holds the errno error code set by read() when no data was
	present on the non-blocking file descriptor.

VAL_NOFILE:
	Unit: d_NOFILE (Also defines nofile d_gettblsz tablesize)
	Wants: Myread Guess libc cat test rm Csym
	Optional: cc ccflags libs

	This symbol contains the number of file descriptors available to the
	process, as determined at configuration time. Unless a static constant
	is needed, you should rely on getdtablesize() to obtain that number.

VAL_O_NONBLOCK:
	Unit: nblock_io (Also defines o_nonblock eagain rd_nodata d_eofnblk)
	Wants: cat rm d_open3 h_sysfile h_fcntl signal_t hint Oldconfig
	  Setvar startsh
	Optional: cc ccflags ldflags

	This symbol is to be used during open() or fcntl(F_SETFL) to turn on
	non-blocking I/O for the file descriptor. Note that there is no way
	back, i.e. you cannot turn it blocking again this way. If you wish to
	alternatively switch between blocking and non-blocking, use the
	ioctl(FIOSNBIO) call instead, but that is not supported by all devices.

VFORK:
	Obsoleted by HAS_VFORK.

VMS:
	Unit: Guess (Also defines d_eunice d_xenix d_bsd)
	Wants: cat test echo n c contains rm Loc eunicefix

	This symbol, if defined, indicates that the program is running under
	VMS.  It is currently only set in conjunction with the EUNICE symbol.

VOIDFLAGS:
	Unit: voidflags (Also defines defvoidused)
	Wants: cat rm contains package Oldconfig Myread
	Optional: cc ccflags

	This symbol indicates how much support of the void type is given by this
	compiler.  What various bits mean:
	
	    1 = supports declaration of void
	    2 = supports arrays of pointers to functions returning void
	    4 = supports comparisons between pointers to void functions and
		    addresses of void functions
	    8 = suports declaration of generic void pointers
	
	The package designer should define VOIDUSED to indicate the requirements
	of the package.  This can be done either by #defining VOIDUSED before
	including config.h, or by defining defvoidused in Myinit.U.  If the
	latter approach is taken, only those flags will be tested.  If the
	level of void support necessary is not present, defines void to int.

VOIDSIG:
	Unit: d_voidsig (Also defines signal_t)
	Wants: rm contains cppstdin cppminus test Myread Oldconfig Setvar
	  Findhdr
	Optional: cppflags

	This symbol is defined if this system declares "void (*signal(...))()" in
	signal.h.  The old way was to declare it as "int (*signal(...))()".  It
	is up to the package author to declare things correctly based on the
	symbol.

VOIDTTY:
	Obsoleted by USE_TIOCNOTTY.

VOID_CLOSEDIR:
	Unit: d_closedir (Also defines d_void_closedir)
	Wants: Inlibc i_dirent i_sysdir i_sysndir cc ccflags ldflags libs
	  Setvar rm

	This symbol, if defined, indicates that the closedir() routine
	does not return a value.

VPRINTF:
	Obsoleted by HAS_VPRINTF.

V_FUNC:
	Unit: prototype
	Wants: Myread Oldconfig cat rm Setvar
	Optional: cc ccflags

	This macro is used to declare "public" (non-static) functions.
	It takes three arguments: the function type and name, a parenthesized
	traditional (comma separated) argument list, and the declared argument
	list (in which arguments are separated with NXT_ARG, and additional
	arbitrary arguments are specified with DOTS).  For example:
	
		V_FUNC(int main, (argc, argv), int argc NXT_ARG char *argv[])

V_FUNC_VOID:
	Unit: prototype
	Wants: Myread Oldconfig cat rm Setvar
	Optional: cc ccflags

	This macro is used to declare "public" (non-static) functions that have
	no arguments.  The macro takes one argument: the function type and name.
	For example:
	
		V_FUNC_VOID(int fork)

WAIT4:
	Obsoleted by HAS_WAIT4.

WAITPID:
	Obsoleted by HAS_WAITPID.

WCTOMB:
	Obsoleted by HAS_WCTOMB.

WHOAMI:
	Obsoleted by I_WHOAMI.

XDRS:
	Obsoleted by HAS_XDRS.

XENIX:
	Unit: Guess (Also defines d_eunice d_xenix d_bsd)
	Wants: cat test echo n c contains rm Loc eunicefix

	This symbol, if defined, indicates thet the program is running under
	Xenix (at least 3.0 ?).

_:
	Unit: prototype
	Wants: Myread Oldconfig cat rm Setvar
	Optional: cc ccflags

	This macro is used to declare function parameters for folks who want
	to make declarations with prototypes using a different style than
	the above macros.  Use double parentheses.  For example:
	
		int main _((int argc, char *argv[]));

_V:
	Unit: vaproto
	Wants: prototype i_stdarg Setvar

	This macro is used to declare function parameters in prototypes for
	functions with a variable number of parameters. Use double parentheses.
	For example:
	
		int printf _V((char *fmt, ...));
	
	Remember to use the plain simple _() macro when declaring a function
	with no variable number of arguments, since it might be possible to
	have a non-effect _V() macro and still get prototypes via _().

_a:
	Unit: Unix (Also defines _exe _a _o firstmakefile archobjs)
	Wants: Oldconfig

	This variable defines the extension used for ordinary libraries.
	For unix, it is '.a'.  The '.' is included.  Other possible
	values include '.lib'.

_exe:
	Unit: Unix (Also defines _exe _a _o firstmakefile archobjs)
	Wants: Oldconfig

	This variable defines the extension used for executable files.
	For unix it is empty.  Other possible values include '.exe'.

_o:
	Unit: Unix (Also defines _exe _a _o firstmakefile archobjs)
	Wants: Oldconfig

	This variable defines the extension used for object files.
	For unix, it is '.o'.  The '.' is included.  Other possible
	values include '.obj'.

abortsig:
	Unit: abortsig
	Wants: Myread Oldconfig Guess cat ccflags rm
	Optional: cc

	This variable holds the name of the signal used by the abort() call.

active:
	Unit: active (Also defines activeexp)
	Wants: newslib Oldconfig Getfile

	The name of the active file for the news system.  This file contains
	the list of active newsgroups.  The name may have ~ on the front.
	The variable myactive is the expanded form.

activeexp:
	Unit: active (Also defines activeexp)
	Wants: newslib Oldconfig Getfile

	This is the same as the active variable, but is filename expanded
	so that later Configure units can look at the active file if desired.

afs:
	Unit: afs
	Wants: Nothing

	This variable is set to 'true' if AFS (Andrew File System) is used
	on the system, 'false' otherwise.  It is possible to override this
	with a hint value or command line option, but you'd better know
	what you are doing.

alignbytes:
	Unit: alignbytes
	Wants: Myread cat cc ccflags rm

	This variable holds the number of bytes required to align a
	double. Usual values are 2, 4 and 8.

aphostname:
	Unit: d_gethname (Also defines d_uname d_phostname aphostname)
	Wants: phostname cat myhostname package d_portable Loc libc echo n c
	  Myread Guess Oldconfig Csym
	Optional: i_whoami usrinc

	Thie variable contains the command which can be used to compute the
	host name. The command is fully qualified by its absolute path, to make
	it safe when used by a process with super-user privileges.

archlib:
	Unit: archlib (Also defines d_archlib archlibexp installarchlib)
	Wants: archname afs spackage cat Getfile Loc Oldconfig prefixexp
	  privlib test Prefixit Prefixup

	This variable holds the name of the directory in which the user wants
	to put architecture-dependent public library files for $package.
	It is most often a local directory such as /usr/local/lib.
	Programs using this variable must be prepared to deal 
	with filename expansion.

archlibexp:
	Unit: archlib (Also defines d_archlib archlibexp installarchlib)
	Wants: archname afs spackage cat Getfile Loc Oldconfig prefixexp
	  privlib test Prefixit Prefixup

	This variable is the same as the archlib variable, but is 
	filename expanded at configuration time, for convenient use.

archname:
	Unit: archname (Also defines myarchname)
	Wants: sed Loc Myread Oldconfig osname test rm

	This variable is a short name to characterize the current
	architecture.  It is used mainly to construct the default archlib.

archobjs:
	Unit: Unix (Also defines _exe _a _o firstmakefile archobjs)
	Wants: Oldconfig

	This variable defines any additional objects that must be linked
	in with the program on this architecture.  On unix, it is usually
	empty.  It is typically used to include emulations of unix calls
	or other facilities.  For perl on OS/2, for example, this would
	include os2/os2.obj.

baserev:
	Unit: baserev
	Wants: Null

	The base revision level of this package, from the .package file.

basicshell:
	Unit: basicshell
	Wants: Getfile Oldconfig bash csh ksh sh

	This variable contains the eventual value of the BASICSHELL symbol,
	which contains the full name of the basic script shell on this
	system.  Usual values are /bin/sh, /bin/ksh, /bin/csh.

bcmp:
	Magic symbol, needs: HAS_BCMP
	Unit: d_bcmp
	Wants: Inlibc

	#ifndef HAS_BCMP
	#ifndef bcmp
	#define bcmp(s,d,l) memcmp((s),(d),(l))
	#endif
	#endif

bcopy:
	Magic symbol, needs: HAS_BCOPY
	Unit: d_bcopy
	Wants: Inlibc

	#ifndef HAS_BCOPY
	#ifndef bcopy
	#define bcopy(s,d,l) memcpy((d),(s),(l))
	#endif
	#endif

bin:
	Unit: bin (Also defines binexp installbin)
	Wants: Prefixit Getfile Oldconfig afs cat test

	This variable holds the name of the directory in which the user wants
	to put publicly executable images for the package in question.  It
	is most often a local directory such as /usr/local/bin. Programs using
	this variable must be prepared to deal with ~name substitution.

binexp:
	Unit: bin (Also defines binexp installbin)
	Wants: Prefixit Getfile Oldconfig afs cat test

	This is the same as the bin variable, but is filename expanded at
	configuration time, for use in your makefiles.

bitpbyte:
	Unit: bitpbyte
	Wants: cat rm Myread
	Optional: cc ccflags

	This variable contains the value of the BITS_PER_BYTE symbol, which
	indicates to the C program how many bits there are in a byte.

byteorder:
	Unit: byteorder
	Wants: cat Myread Oldconfig Loc rm
	Optional: cc ccflags

	This variable holds the byte order. In the following, larger digits
	indicate more significance.  The variable byteorder is either 4321
	on a big-endian machine, or 1234 on a little-endian, or 87654321
	on a Cray ... or 3412 with weird order !

bzero:
	Magic symbol, needs: HAS_BZERO
	Unit: d_bzero
	Wants: Inlibc

	#ifndef HAS_BZERO
	#ifndef bzero
	#define bzero(s,l) memset((s),0,(l))
	#endif
	#endif

c:
	Unit: n (Also defines c)
	Wants: contains

	This variable contains the \c string if that is what causes the echo
	command to suppress newline.  Otherwise it is null.  Correct usage is
	    $echo $n "prompt for a question: $c".

castflags:
	Unit: d_castneg (Also defines castflags)
	Wants: cat rm Setvar signal_t
	Optional: cc ccflags

	This variable contains a flag that precise difficulties the
	compiler has casting odd floating values to unsigned long:
		0 = ok
		1 = couldn't cast < 0
		2 = couldn't cast >= 0x80000000
		4 = couldn't cast in argument expression list

cc:
	Unit: cc (Also defines gccversion)
	Wants: cat contains sysman cpp rm Mcc Myread Guess Options Oldconfig
	  Loc
	Optional: large

	This variable holds the name of a command to execute a C compiler which
	can resolve multiple global references that happen to have the same
	name.  Usual values are "cc", "Mcc", "cc -M", and "gcc".

ccflags:
	Unit: ccflags (Also defines ldflags lkflags cppflags optimize
	  locincpth)
	Wants: test cat Myread Guess Options Oldconfig mips_type package
	  contains rm cppstdin cppminus cpprun cpplast libpth loclibpth hint
	Optional: gccversion usrinc cc

	This variable contains any additional C compiler flags desired by
	the user.  It is up to the Makefile to use this.

cf_by:
	Unit: cf_who (Also defines cf_time cf_by)
	Wants: date Oldconfig

	Login name of the person who ran the Configure script and answered the
	questions. This is used to tag both config.sh and config_h.SH.

cf_email:
	Unit: cf_email
	Wants: cat cf_by myhostname mydomain Oldconfig Myread

	Electronic mail address of the person who ran Configure. This can be
	used by units that require the user's e-mail, like MailList.U.

cf_name:
	Unit: cf_name (With private cf_name)
	Wants: cf_by passcat Filexp nametype cat test

	Full name of the person who ran the Configure script and answered the
	questions. This can be used by units that require the user's full name.
	This variable is for internal use only.

cf_time:
	Unit: cf_who (Also defines cf_time cf_by)
	Wants: date Oldconfig

	Holds the output of the "date" command when the configuration file was
	produced. This is used to tag both config.sh and config_h.SH.

charoder:
	Obsoleted by chorder_int.

charsize:
	Unit: charsize
	Wants: cat rm Myread
	Optional: cc ccflags

	This variable contains the value of the CHARSIZE symbol, which
	indicates to the C program how many bytes there are in a character.

chorder_int:
	Unit: charorder (Also defines chorder_int chorder_short chorder_long)
	Wants: Myread cat rm
	Optional: cc ccflags

	Holds the value describing the byte ordering of characters in an int.
	For instance, on a Big-Endian machine, this would be: "c0c1c2c3".

chorder_long:
	Unit: charorder (Also defines chorder_int chorder_short chorder_long)
	Wants: Myread cat rm
	Optional: cc ccflags

	Holds the value describing the byte ordering of characters in a long.
	On a 64 bits Big-Endian machine, that would yield: "c0c1c2c3c4c5c6c7".

chorder_short:
	Unit: charorder (Also defines chorder_int chorder_short chorder_long)
	Wants: Myread cat rm
	Optional: cc ccflags

	Holds the value describing the byte ordering of characters in a short.
	On a Big-Endian machine, that would be "c0c1".

citydist:
	Unit: locdist (Also defines orgdist citydist statedist multistatedist
	  cntrydist contdist)
	Wants: test newslibexp cat Myread Oldconfig

	This variable contains the eventual value of the CITYDIST symbol,
	which is the city's distribution name for news.

clocktype:
	Unit: d_times (Also defines clocktype)
	Wants: Csym Myread Typedef i_systimes

	This variable holds the type returned by times(). It can be long,
	or clock_t on BSD sites (in which case <sys/types.h> should be
	included).

cntrydist:
	Unit: locdist (Also defines orgdist citydist statedist multistatedist
	  cntrydist contdist)
	Wants: test newslibexp cat Myread Oldconfig

	This variable contains the eventual value of the CNTRYDIST symbol,
	which is the country's distribution name for news.

contains:
	Unit: contains
	Wants: Nothing

	This variable holds the command to do a grep with a proper return
	status.  On most sane systems it is simply "grep".  On insane systems
	it is a grep followed by a cat followed by a test.  This variable
	is primarily for the use of other Configure units.

contdist:
	Unit: locdist (Also defines orgdist citydist statedist multistatedist
	  cntrydist contdist)
	Wants: test newslibexp cat Myread Oldconfig

	This variable contains the eventual value of the CONTDIST symbol,
	which is the continent's distribution name for news.

cpp_stuff:
	Unit: cpp_stuff
	Wants: cat contains cppstdin cppflags cppminus rm

	This variable contains an identification of the catenation mechanism
	used by the C preprocessor.

cppfilecom:
	Unit: cppfilecom (Also defines cppstdinflags d_cppignhdrs
	  d_cppcanstdin)
	Wants: contains package test Myread Oldconfig Loc Setvar cpp cc cat rm

	This variable contains the first part of the string which will invoke
	the C preprocessor a file and produce to standard output, preserving
	comments. Typical value of "cc -E -C" or "/lib/cpp -C".

cppflags:
	Unit: ccflags (Also defines ldflags lkflags cppflags optimize
	  locincpth)
	Wants: test cat Myread Guess Options Oldconfig mips_type package
	  contains rm cppstdin cppminus cpprun cpplast libpth loclibpth hint
	Optional: gccversion usrinc cc

	This variable holds the flags that will be passed to the C pre-
	processor. It is up to the Makefile to use it.

cpplast:
	Unit: cppstdin (Also defines cppminus cpprun cpplast)
	Wants: contains test Myread Oldconfig Loc cpp rm
	Optional: cc

	This variable has the same functionality as cppminus, only it applies to
	cpprun and not cppstdin.

cppminus:
	Unit: cppstdin (Also defines cppminus cpprun cpplast)
	Wants: contains test Myread Oldconfig Loc cpp rm
	Optional: cc

	This variable contains the second part of the string which will invoke
	the C preprocessor on the standard input and produce to standard
	output.  This variable will have the value "-" if cppstdin needs a minus
	to specify standard input, otherwise the value is "".

cpprun:
	Unit: cppstdin (Also defines cppminus cpprun cpplast)
	Wants: contains test Myread Oldconfig Loc cpp rm
	Optional: cc

	This variable contains the command which will invoke a C preprocessor
	on standard input and put the output to stdout. It is guaranteed not
	to be a wrapper and may be a null string if no preprocessor can be
	made directly available. This preprocessor might be different from the
	one used by the C compiler. Don't forget to append cpplast after the
	preprocessor options.

cppstdin:
	Unit: cppstdin (Also defines cppminus cpprun cpplast)
	Wants: contains test Myread Oldconfig Loc cpp rm
	Optional: cc

	This variable contains the command which will invoke the C
	preprocessor on standard input and put the output to stdout.
	It is primarily used by other Configure units that ask about
	preprocessor symbols.

cppstdinflags:
	Unit: cppfilecom (Also defines cppstdinflags d_cppignhdrs
	  d_cppcanstdin)
	Wants: contains package test Myread Oldconfig Loc Setvar cpp cc cat rm

	This variable contains any flags necessary to get cppfilecom to read
	from the standard input.

cryptlib:
	Unit: d_crypt (Also defines cryptlib)
	Wants: Loc test xlibpth libpth Csym Setvar _a

	This variable holds -lcrypt or the path to a libcrypt.a archive if
	the crypt() function is not defined in the standard C library. It is
	up to the Makefile to use this.

csym:
	Unit: Csym
	Wants: Options contains libc libs runnm rm
	Optional: cc ccflags ldflags

	This shell variable is used internally by Configure to check
	wether a given C symbol is defined or not. A typical use is:
		set symbol result [-fva] [previous]
		eval $csym
	That will set result to 'true' if the function [-f], variable [-v]
	or array [-a] is defined, 'false' otherwise. If a previous value is
	given and the -r flag was provided on the command line, that value
	is reused without questioning.

d_Gconvert:
	Unit: d_gconvert (Also defines d_Gconvert)
	Wants: cat cc ccflags ldflags libs Inlibc rm _o

	This variable holds what Gconvert is defined as to convert
	floating point numbers into strings. It could be 'gconvert'
	or a more complex macro emulating gconvert with gcvt() or sprintf.

d_PORTAR:
	Unit: d_PORTAR
	Wants: cat rm Setvar
	Optional: cc

	This variable conditionally handles definition of PORTAR,
	a creation of greater minds than I can imagine.

d_SHM_IMMU:
	Unit: d_SHM_MAC (Also defines d_SHM_PRM d_SHM_SEG d_SHM_IMMU)
	Wants: cat d_shm test rm
	Optional: cc ccflags

	Sometimes, the SHMLBA manifest needs sys/immu.h, usually for the
	stob() macro.

d_SHM_MAC:
	Unit: d_SHM_MAC (Also defines d_SHM_PRM d_SHM_SEG d_SHM_IMMU)
	Wants: cat d_shm test rm
	Optional: cc ccflags

	Sometimes, the SHMLBA manifest needs sys/sysmacros.h, usually for
	the ctob() macro.

d_SHM_PRM:
	Unit: d_SHM_MAC (Also defines d_SHM_PRM d_SHM_SEG d_SHM_IMMU)
	Wants: cat d_shm test rm
	Optional: cc ccflags

	Sometimes, the SHMLBA manifest needs sys/param.h, usually for the
	NBPC constant.

d_SHM_SEG:
	Unit: d_SHM_MAC (Also defines d_SHM_PRM d_SHM_SEG d_SHM_IMMU)
	Wants: cat d_shm test rm
	Optional: cc ccflags

	Sometimes, the SHMLBA manifest needs sys/seg.h, usually for the
	SNUMSHFT constant.

d_access:
	Unit: d_access
	Wants: test cat h_fcntl h_sysfile rm Inlibc Findhdr
	Optional: cc cppflags

	This variable conditionally defines HAS_ACCESS if the access() system
	call is available to check for access permissions using real IDs.

d_alarm:
	Unit: d_alarm
	Wants: Inlibc

	This variable conditionally defines the HAS_ALARM symbol, which
	indicates to the C program that the alarm() routine is available.

d_archlib:
	Unit: archlib (Also defines d_archlib archlibexp installarchlib)
	Wants: archname afs spackage cat Getfile Loc Oldconfig prefixexp
	  privlib test Prefixit Prefixup

	This variable conditionally defines ARCHLIB to hold the pathname
	of architecture-dependent library files for $package.  If
	$archlib is the same as $privlib, then this is set to undef.

d_attrib:
	Obsoleted by d_attribut.

d_attribut:
	Unit: d_attribut
	Wants: Myread Oldconfig cat cc ccflags rm Setvar contains

	This variable conditionally defines HASATTRIBUTE, which
	indicates the C compiler can check for function attributes,
	such as printf formats.

d_bcmp:
	Unit: d_bcmp
	Wants: Inlibc

	This variable conditionally defines the HAS_BCMP symbol if
	the bcmp() routine is available to compare strings.

d_bcopy:
	Unit: d_bcopy
	Wants: Inlibc

	This variable conditionally defines the HAS_BCOPY symbol if
	the bcopy() routine is available to copy strings.

d_berknames:
	Unit: nametype (Also defines d_passnames d_berknames d_usgnames)
	Wants: Myread Guess Oldconfig cat

	This variable conditionally defines the PASSNAMES symbol,
	which indicates to the C program that full names are stored in
	the /etc/passwd file in Berkeley format.

d_bol:
	Obsoleted by chorder_long.

d_bos:
	Obsoleted by chorder_short.

d_brokstat:
	Unit: d_brokstat
	Wants: cat contains cppstdin cppminus rm Setvar
	Optional: cppflags

	This variable conditionally defines STAT_MACROS_BROKEN if some
	of the S_IS*() macros from <sys/stat.h> give false positive on
	regular files.

d_bsd:
	Unit: Guess (Also defines d_eunice d_xenix d_bsd)
	Wants: cat test echo n c contains rm Loc eunicefix

	This symbol conditionally defines the symbol BSD when running on a
	BSD system.

d_bsdgetpgrp:
	Unit: d_getpgrp (Also defines d_bsdgetpgrp)
	Wants: Guess Inlibc Setvar cat rm i_unistd
	Optional: cc ccflags ldflags libs

	This variable conditionally defines USE_BSD_GETPGRP if
	getpgrp needs one arguments whereas USG one needs none.

d_bsdjmp:
	Unit: d_bsdjmp
	Wants: Guess Setvar cat libs rm
	Optional: cc

	This variable conditionally defines USE_BSDJMP if BSD _setjmp and
	_longjmp routines are available to do non-local gotos without saving
	or restoring the signal mask flag.

d_bsdpgrp:
	Obsoleted by d_bsdsetpgrp.

d_bsdsetpgrp:
	Unit: d_setpgrp (Also defines d_bsdsetpgrp)
	Wants: cat rm Inlibc Guess Setvar i_unistd
	Optional: cc libs ccflags ldflags

	This variable conditionally defines USE_BSD_SETPGRP if
	setpgrp needs two arguments whereas USG one needs none.
	See also d_setpgid for a POSIX interface.

d_byacc:
	Unit: d_byacc
	Wants: byacc Setvar

	This variable indicates whether byacc is available.
	If the user has specified 'portability', then Makefile.SH
	sees $byacc='byacc' whether or not the user actually has
	byacc.  This variable allows us to determine in a makefile
	if we really have byacc.  

d_bzero:
	Unit: d_bzero
	Wants: Inlibc

	This variable conditionally defines the HAS_BZERO symbol if
	the bzero() routine is available to set memory to 0.

d_casti32:
	Unit: d_casti32
	Wants: cat rm intsize Setvar test signal_t
	Optional: cc ccflags

	This variable conditionally defines CASTI32, which indicates
	whether the C compiler can cast large floats to 32-bit ints.

d_castneg:
	Unit: d_castneg (Also defines castflags)
	Wants: cat rm Setvar signal_t
	Optional: cc ccflags

	This variable conditionally defines CASTNEG, which indicates
	wether the C compiler can cast negative float to unsigned.

d_cbrt:
	Unit: d_cbrt
	Wants: Inlibc

	This variable conditionally defines the CBRT symbol, which
	indicates to the C program that the cbrt() (cube root) function
	is available.

d_charsprf:
	Unit: d_charsprf
	Wants: cat rm Setvar
	Optional: cc

	This variable conditionally defines CHARSPRINTF if this system
	declares "char *sprintf()" in stdio.h.  The trend seems to be to
	declare it as "int sprintf()".

d_charvspr:
	Unit: d_vprintf (Also defines d_charvspr)
	Wants: Guess cat Csym Setvar
	Optional: cc ccflags

	This variable conditionally defines CHARVSPRINTF if this system
	has vsprintf returning type (char*).  The trend seems to be to
	declare it as "int vsprintf()".

d_chown:
	Unit: d_chown
	Wants: Inlibc

	This variable conditionally defines the HAS_CHOWN symbol, which
	indicates to the C program that the chown() routine is available.

d_chroot:
	Unit: d_chroot
	Wants: Inlibc

	This variable conditionally defines the HAS_CHROOT symbol, which
	indicates to the C program that the chroot() routine is available.

d_chsize:
	Unit: d_chsize
	Wants: Inlibc

	This variable conditionally defines the CHSIZE symbol, which
	indicates to the C program that the chsize() routine is available
	to truncate files.  You might need a -lx to get this routine.

d_ckeypad:
	Unit: d_ckeypad
	Wants: cat cc termlib Setvar

	This variable controls the definition of HAS_CURSES_KEYPAD,
	which tells the application that the keypad() curses function
	is available.

d_closedir:
	Unit: d_closedir (Also defines d_void_closedir)
	Wants: Inlibc i_dirent i_sysdir i_sysndir cc ccflags ldflags libs
	  Setvar rm

	This variable conditionally defines HAS_CLOSEDIR if closedir() is
	available.

d_col:
	Obsoleted by chorder_long.

d_const:
	Unit: d_const
	Wants: cat cc ccflags Setvar

	This variable conditionally defines the HASCONST symbol, which
	indicates to the C program that this C compiler knows about the
	const type.

d_cos:
	Obsoleted by chorder_short.

d_cppcanstdin:
	Unit: cppfilecom (Also defines cppstdinflags d_cppignhdrs
	  d_cppcanstdin)
	Wants: contains package test Myread Oldconfig Loc Setvar cpp cc cat rm

	This symbol conditionally defines CPP_CAN_STDIN if CPP_FILE_COM can
	read standard input directly.

d_cppignhdrs:
	Unit: cppfilecom (Also defines cppstdinflags d_cppignhdrs
	  d_cppcanstdin)
	Wants: contains package test Myread Oldconfig Loc Setvar cpp cc cat rm

	This symbol conditionally defines CPP_IGN_HDRS if CPP_FILE_COM ignores
	*.h files.

d_crypt:
	Unit: d_crypt (Also defines cryptlib)
	Wants: Loc test xlibpth libpth Csym Setvar _a

	This variable conditionally defines the CRYPT symbol, which
	indicates to the C program that the crypt() routine is available
	to encrypt passwords and the like.

d_csh:
	Unit: d_csh (Also defines full_csh)
	Wants: csh Setvar

	This variable conditionally defines the CSH symbol, which
	indicates to the C program that the C-shell exists.

d_ctermid:
	Unit: d_ctermid
	Wants: Inlibc

	This variable conditionally defines CTERMID if ctermid() is
	available to generate filename for terminal.

d_cuserid:
	Unit: d_cuserid
	Wants: Inlibc

	This variable conditionally defines the HAS_CUSERID symbol, which
	indicates to the C program that the cuserid() routine is available
	to get character login names.

d_dbl_dig:
	Unit: d_dbl_dig
	Wants: Myread contains cat rm Setvar i_limits i_float cppstdin
	  cppflags cppminus

	This variable conditionally defines d_dbl_dig if this system's
	header files provide DBL_DIG, which is the number of significant
	digits in a double precision number.

d_difftime:
	Unit: d_difftime
	Wants: Inlibc

	This variable conditionally defines the HAS_DIFFTIME symbol, which
	indicates to the C program that the difftime() routine is available.

d_dirnamlen:
	Unit: i_dirent (Also defines d_dirnamlen direntrytype)
	Wants: test contains Setvar Myread Findhdr cppstdin cppflags cppminus
	  rm

	This variable conditionally defines DIRNAMLEN, which indicates
	to the C program that the length of directory entry names is
	provided by a d_namelen field.

d_dlerror:
	Unit: d_dlerror
	Wants: Inlibc runnm

	This variable conditionally defines the HAS_DLERROR symbol, which
	indicates to the C program that the dlerror() routine is available.

d_dlopen:
	Unit: d_dlopen
	Wants: Inlibc runnm

	This variable conditionally defines the HAS_DLOPEN symbol, which
	indicates to the C program that the dlopen() routine is available.

d_dosuid:
	Unit: d_dosuid (Also defines d_suidsafe)
	Wants: cat contains ls rm test Myread Setvar Oldconfig Guess package
	  hint

	This variable conditionally defines the symbol DOSUID, which
	tells the C program that it should insert setuid emulation code
	on hosts which have setuid #! scripts disabled.

d_drem:
	Unit: d_drem
	Wants: Inlibc

	This variable conditionally defines the HAS_DREM symbol, which
	indicates to the C program that the drem() routine is available.

d_dup2:
	Unit: d_dup2
	Wants: Inlibc

	This variable conditionally defines HAS_DUP2 if dup2() is
	available to duplicate file descriptors.

d_eofnblk:
	Unit: nblock_io (Also defines o_nonblock eagain rd_nodata d_eofnblk)
	Wants: cat rm d_open3 h_sysfile h_fcntl signal_t hint Oldconfig
	  Setvar startsh
	Optional: cc ccflags ldflags

	This variable conditionally defines EOF_NONBLOCK if EOF can be seen
	when reading from a non-blocking I/O source.

d_eofpipe:
	Unit: d_eofpipe
	Wants: cat rm Oldconfig Guess echo n c
	Optional: cc ccflags libs

	This variable conditionally defines the EOFPIPE symbol, which
	indicates to the C program that select will correctly detect the EOF
	condition when pipe is closed from the other end.

d_euc2jis:
	Unit: d_euc2jis
	Wants: Inlibc

	This variable conditionally defines the HAS_EUC2JIS symbol, which
	indicates to the C program that the euc2jis() routine is available
	to convert EUC to JIS.

d_eunice:
	Unit: Guess (Also defines d_eunice d_xenix d_bsd)
	Wants: cat test echo n c contains rm Loc eunicefix

	This variable conditionally defines the symbols EUNICE and VAX, which
	alerts the C program that it must deal with ideosyncracies of VMS.

d_fchmod:
	Unit: d_fchmod
	Wants: Inlibc

	This variable conditionally defines the HAS_FCHMOD symbol, which
	indicates to the C program that the fchmod() routine is available
	to change mode of opened files.

d_fchown:
	Unit: d_fchown
	Wants: Inlibc

	This variable conditionally defines the HAS_FCHOWN symbol, which
	indicates to the C program that the fchown() routine is available
	to change ownership of opened files.

d_fcntl:
	Unit: d_fcntl
	Wants: Inlibc

	This variable conditionally defines the HAS_FCNTL symbol, and indicates
	whether the fcntl() function exists

d_fd_macros:
	Unit: d_fd_set (Also defines d_fd_macros d_fds_bits)
	Wants: cat rm Oldconfig d_socket i_systime i_sysselct
	Optional: cc ccflags

	This variable contains the eventual value of the HAS_FD_MACROS symbol,
	which indicates if your C compiler knows about the macros which
	manipulate an fd_set.

d_fd_set:
	Unit: d_fd_set (Also defines d_fd_macros d_fds_bits)
	Wants: cat rm Oldconfig d_socket i_systime i_sysselct
	Optional: cc ccflags

	This variable contains the eventual value of the HAS_FD_SET symbol,
	which indicates if your C compiler knows about the fd_set typedef.

d_fds_bits:
	Unit: d_fd_set (Also defines d_fd_macros d_fds_bits)
	Wants: cat rm Oldconfig d_socket i_systime i_sysselct
	Optional: cc ccflags

	This variable contains the eventual value of the HAS_FDS_BITS symbol,
	which indicates if your fd_set typedef contains the fds_bits member.
	If you have an fd_set typedef, but the dweebs who installed it did
	a half-fast job and neglected to provide the macros to manipulate
	an fd_set, HAS_FDS_BITS will let us know how to fix the gaffe.

d_ffs:
	Unit: d_ffs
	Wants: Inlibc

	This variable conditionally defines the HAS_FFS symbol, which
	indicates to the C program that the ffs() routine is available
	to find the first bit which is set in its integer argument.

d_fgetpos:
	Unit: d_fgetpos
	Wants: Inlibc

	This variable conditionally defines HAS_FGETPOS if fgetpos() is
	available to get the file position indicator.

d_flexfnam:
	Unit: d_flexfnam
	Wants: cat rm test Setvar

	This variable conditionally defines the FLEXFILENAMES symbol, which
	indicates that the system supports filenames longer than 14 characters.

d_flock:
	Unit: d_flock
	Wants: Inlibc

	This variable conditionally defines HAS_FLOCK if flock() is
	available to do file locking.

d_fmod:
	Unit: d_fmod
	Wants: Inlibc

	This variable conditionally defines the HAS_FMOD symbol, which
	indicates to the C program that the fmod() routine is available.
	See also d_drem for the drem() routine which does roughly the same.

d_fork:
	Unit: d_fork
	Wants: Inlibc

	This variable conditionally defines the HAS_FORK symbol, which
	indicates to the C program that the fork() routine is available.

d_fpathconf:
	Unit: d_pathconf (Also defines d_fpathconf)
	Wants: Inlibc

	This variable conditionally defines the HAS_FPATHCONF symbol, which
	indicates to the C program that the pathconf() routine is available
	to determine file-system related limits and options associated
	with a given open file descriptor.

d_fsetpos:
	Unit: d_fsetpos
	Wants: Inlibc

	This variable conditionally defines HAS_FSETPOS if fsetpos() is
	available to set the file position indicator.

d_ftime:
	Unit: d_ftime (Also defines d_gettimeod)
	Wants: Inlibc Setvar

	This variable conditionally defines the HAS_FTIME symbol, which indicates
	that the ftime() routine exists.  The ftime() routine is basically
	a sub-second accuracy clock.

d_ftrncate:
	Unit: d_ftrncate
	Wants: Inlibc

	This variable conditionally defines the HAS_FTRUNCATE symbol, which
	indicates to the C program that the ftruncate() subroutine exists.

d_ftruncate:
	Obsoleted by d_ftrncate.

d_gdbm:
	Obsoleted by i_gdbm.

d_getgrps:
	Unit: d_getgrps
	Wants: Inlibc

	This variable conditionally defines the HAS_GETGROUPS symbol, which
	indicates to the C program that the getgroups() routine is available
	to get the list of process groups.

d_gethbynm:
	Unit: d_gethbynm
	Wants: Inlibc

	This variable conditionally defines the HAS_GETHOSTBYNAME symbol, which
	indicates to the C program that the gethostbyname() routine is available
	to lookup host names in some data base or other.

d_gethent:
	Unit: d_gethent
	Wants: Inlibc

	This variable conditionally defines HAS_GETHOSTENT if gethostent() is
	available to dup file descriptors.

d_gethhstby:
	Obsoleted by d_gethbynm.

d_gethid:
	Unit: d_gethid
	Wants: Inlibc

	This variable conditionally defines HAS_GETHOSTID if gethostid() is
	available to get the host id.

d_gethname:
	Unit: d_gethname (Also defines d_uname d_phostname aphostname)
	Wants: phostname cat myhostname package d_portable Loc libc echo n c
	  Myread Guess Oldconfig Csym
	Optional: i_whoami usrinc

	This variable conditionally defines the HAS_GETHOSTNAME symbol, which
	indicates to the C program that the gethostname() routine may be
	used to derive the host name.

d_getlogin:
	Unit: d_getlogin
	Wants: Inlibc

	This variable conditionally defines the HAS_GETLOGIN symbol, which
	indicates to the C program that the getlogin() routine is available
	to get the login name.

d_getopt:
	Unit: d_getopt
	Wants: Inlibc

	This variable conditionally defines the HAS_GETOPT symbol, which
	indicates that the getopt() routine exists.  The getopt() routine
	parses command line options in a standard fashion.

d_getpagsz:
	Unit: d_getpagsz (Also defines pagesize)
	Wants: Oldconfig Myread Inlibc cat contains libs rm Findhdr
	Optional: cc ccflags

	This variable conditionally defines HAS_GETPAGESIZE if getpagesize()
	is available to get the system page size.

d_getpgid:
	Unit: d_getpgid
	Wants: Inlibc

	This variable conditionally defines the HAS_GETPGID symbol, which
	indicates to the C program that the getpgid(pid) function
	is available to get the process group id.

d_getpgrp:
	Unit: d_getpgrp (Also defines d_bsdgetpgrp)
	Wants: Guess Inlibc Setvar cat rm i_unistd
	Optional: cc ccflags ldflags libs

	This variable conditionally defines HAS_GETPGRP if getpgrp() is
	available to get the current process group.

d_getpgrp2:
	Unit: d_getpgrp2
	Wants: Inlibc

	This variable conditionally defines the HAS_GETPGRP2 symbol, which
	indicates to the C program that the getpgrp2() (as in DG/UX) routine
	is available to get the current process group.

d_getppid:
	Unit: d_getppid
	Wants: Inlibc

	This variable conditionally defines the HAS_GETPPID symbol, which
	indicates to the C program that the getppid() routine is available
	to get the parent process ID.

d_getprior:
	Unit: d_getprior
	Wants: Inlibc

	This variable conditionally defines HAS_GETPRIORITY if getpriority()
	is available to get a process's priority.

d_getpwent:
	Unit: d_getpwent
	Wants: Csym Setvar

	This variable conditionally defines the HAS_GETPWENT symbol, which
	indicates to the C program that it should use the getpwent()
	routine instead of the getpw() routine.

d_getrusg:
	Obsoleted by d_rusage.

d_gettblsz:
	Unit: d_NOFILE (Also defines nofile d_gettblsz tablesize)
	Wants: Myread Guess libc cat test rm Csym
	Optional: cc ccflags libs

	This variable conditionally handles remapping of the getdtablesize()
	subroutine to ulimit(4,0), or the NOFILE manifest constant.

d_gettimeod:
	Unit: d_ftime (Also defines d_gettimeod)
	Wants: Inlibc Setvar

	This variable conditionally defines the HAS_GETTIMEOFDAY symbol, which
	indicates that the gettimeofday() system call exists (to obtain a
	sub-second accuracy clock). You should probably include <sys/resource.h>.

d_getwd:
	Unit: d_getwd
	Wants: Csym Setvar

	This variable conditionally defines HAS_GETWD if getwd() is
	available to get working directory. If not, you should
	probably use getcwd().

d_gnulibc:
	Unit: d_gnulibc
	Wants: Myread Oldconfig Setvar contains rm
	Optional: cc ccflags ldflags libs

	Defined if we're dealing with the GNU C Library.

d_havetlib:
	Unit: d_havetlib (Also defines termlib)
	Wants: cat contains Myread Loc Filexp Oldconfig libpth test uname _a
	  _o

	This variable conditionally defines the HAS_TERMLIB symbol, which
	indicates to the C program that termlib-style routines are available.

d_hidnet:
	Unit: d_hidnet (Also defines hiddennet)
	Wants: cat sed myhostname mydomain Myread Oldconfig

	This variable conditionally defines the symbol HIDDEN_NET, which
	tells the C program that it should pretend it is on a different
	host for purposes of advertising a mailing address.

d_htonl:
	Unit: d_htonl
	Wants: Inlibc Setvar i_niin i_sysin cat rm contains cppstdin cppflags
	  cppminus

	This variable conditionally defines HAS_HTONL if htonl() and its
	friends are available to do network order byte swapping.

d_index:
	Unit: d_strchr (Also defines d_index)
	Wants: contains strings Setvar Myread Oldconfig Csym

	This variable conditionally defines HAS_INDEX if index() and
	rindex() are available for string searching.

d_inetaton:
	Unit: d_inetaton
	Wants: Inlibc

	This variable conditionally defines the HAS_INET_ATON symbol, which
	indicates to the C program that the inet_aton() function is available
	to parse IP address "dotted-quad" strings.

d_inetd:
	Unit: d_inetd
	Wants: cat test package Myread Setvar

	This symbol conditionally defines USE_INETD which indicates to the C
	program that the initial socket connection will be done via inetd.

d_internet:
	Unit: d_internet
	Wants: Myread Oldconfig Setvar

	This variable conditionally defines the INTERNET symbol, which
	indicates to the C program that there is a mailer available which
	supports internet-style addresses (user@site.domain).

d_isascii:
	Unit: d_isascii
	Wants: cc cat ccflags ldflags rm libs Setvar

	This variable conditionally defines the HAS_ISASCII constant,
	which indicates to the C program that isascii() is available.

d_itimer:
	Unit: d_itimer
	Wants: Inlibc

	This variable conditionally defines the HAS_ITIMER symbol, which
	indicates that the setitimer() routine exists.  The setitimer()
	routine supports sub-second accuracy for one real-time and two
	cpu clocks.

d_keepalive:
	Unit: sockopt (Also defines d_keepalive)
	Wants: cat rm contains socketlib sockethdr d_oldsock libs Oldconfig
	  Setvar Findhdr
	Optional: cc ccflags

	This symbol conditionally defines CAN_KEEPALIVE which indicates to the C
	program that setsockopt SO_KEEPALIVE will work properly.

d_keepsig:
	Unit: d_keepsig
	Wants: cat rm Guess contains echo n c Setvar
	Optional: cc ccflags

	This variable contains the eventual value of the SIGNALS_KEPT symbol,
	which indicates to the C program if signal handlers need not reinstated
	after receipt of a signal.

d_killpg:
	Unit: d_killpg
	Wants: Inlibc

	This variable conditionally defines the HAS_KILLPG symbol, which
	indicates to the C program that the killpg() routine is available
	to kill process groups.

d_libndir:
	Obsoleted by i_ndir.

d_link:
	Unit: d_link
	Wants: Inlibc

	This variable conditionally defines HAS_LINK if link() is
	available to create hard links.

d_linuxstd:
	Unit: d_linuxstd
	Wants: d_stdstdio cppstdin cppflags cppminus contains rm Setvar
	  Findhdr

	This variable conditionally defines USE_LINUX_STDIO if this system
	has a FILE structure declaring _IO_read_base, _IO_read_ptr,
	and _IO_read_end in stdio.h.

d_locconv:
	Unit: d_locconv
	Wants: Inlibc

	This variable conditionally defines HAS_LOCALECONV if localeconv() is
	available for numeric and monetary formatting conventions.

d_lockf:
	Unit: d_lockf
	Wants: Inlibc

	This variable conditionally defines HAS_LOCKF if lockf() is
	available to do file locking.

d_lstat:
	Unit: d_lstat
	Wants: Inlibc

	This variable conditionally defines HAS_LSTAT if lstat() is
	available to do file stats on symbolic links.

d_mblen:
	Unit: d_mblen
	Wants: Inlibc

	This variable conditionally defines the HAS_MBLEN symbol, which
	indicates to the C program that the mblen() routine is available
	to find the number of bytes in a multibye character.

d_mbstowcs:
	Unit: d_mbstowcs
	Wants: Inlibc

	This variable conditionally defines the HAS_MBSTOWCS symbol, which
	indicates to the C program that the mbstowcs() routine is available
	to convert a multibyte string into a wide character string.

d_mbtowc:
	Unit: d_mbtowc
	Wants: Inlibc

	This variable conditionally defines the HAS_MBTOWC symbol, which
	indicates to the C program that the mbtowc() routine is available
	to convert multibyte to a wide character.

d_memccpy:
	Unit: d_memccpy
	Wants: Inlibc

	This variable conditionally defines the HAS_MEMCCPY symbol, which
	indicates to the C program that the memccpy() routine is available
	to copy a character into a block of memory.

d_memchr:
	Unit: d_memchr
	Wants: Inlibc

	This variable conditionally defines the HAS_MEMCHR symbol, which
	indicates to the C program that the memchr() routine is available
	to scan a block of memory for a character.

d_memcmp:
	Unit: d_memcmp
	Wants: Inlibc

	This variable conditionally defines the HAS_MEMCMP symbol, which
	indicates to the C program that the memcmp() routine is available
	to compare blocks of memory.

d_memcpy:
	Unit: d_memcpy
	Wants: Inlibc

	This variable conditionally defines the HAS_MEMCPY symbol, which
	indicates to the C program that the memcpy() routine is available
	to copy blocks of memory.

d_memmove:
	Unit: d_memmove
	Wants: Inlibc

	This variable conditionally defines the HAS_MEMMOVE symbol, which
	indicates to the C program that the memmove() routine is available
	to copy potentatially overlapping blocks of memory.

d_memset:
	Unit: d_memset
	Wants: Inlibc

	This variable conditionally defines the HAS_MEMSET symbol, which
	indicates to the C program that the memset() routine is available
	to set blocks of memory.

d_mkdir:
	Unit: d_mkdir
	Wants: Inlibc

	This variable conditionally defines the HAS_MKDIR symbol, which
	indicates to the C program that the mkdir() routine is available
	to create directories..

d_mkfifo:
	Unit: d_mkfifo
	Wants: Inlibc

	This variable conditionally defines the HAS_MKFIFO symbol, which
	indicates to the C program that the mkfifo() routine is available.

d_mktime:
	Unit: d_mktime
	Wants: Inlibc

	This variable conditionally defines the HAS_MKTIME symbol, which
	indicates to the C program that the mktime() routine is available.

d_mmap:
	Unit: d_mmap
	Wants: Inlibc

	This variable conditionally defines HAS_MMAP if mmap() is
	available to map a file into memory.

d_msg:
	Unit: d_msg
	Wants: test d_msgctl d_msgget d_msgsnd d_msgrcv Setvar Findhdr

	This variable conditionally defines the HAS_MSG symbol, which
	indicates that the entire msg*(2) library is present.

d_msgctl:
	Unit: d_msgctl
	Wants: Inlibc

	This variable conditionally defines the HAS_MSGCTL symbol, which
	indicates to the C program that the msgctl() routine is available.

d_msgget:
	Unit: d_msgget
	Wants: Inlibc

	This variable conditionally defines the HAS_MSGGET symbol, which
	indicates to the C program that the msgget() routine is available.

d_msgrcv:
	Unit: d_msgrcv
	Wants: Inlibc

	This variable conditionally defines the HAS_MSGRCV symbol, which
	indicates to the C program that the msgrcv() routine is available.

d_msgsnd:
	Unit: d_msgsnd
	Wants: Inlibc

	This variable conditionally defines the HAS_MSGSND symbol, which
	indicates to the C program that the msgsnd() routine is available.

d_msync:
	Unit: d_msync
	Wants: Inlibc

	This variable conditionally defines HAS_MSYNC if msync() is
	available to synchronize a mapped file.

d_munmap:
	Unit: d_munmap
	Wants: Inlibc

	This variable conditionally defines HAS_MUNMAP if munmap() is
	available to unmap a region mapped by mmap().

d_mymalloc:
	Unit: mallocsrc (Also defines mallocobj usemymalloc malloctype
	  d_mymalloc freetype)
	Wants: Myread Oldconfig package Guess Setvar rm cat Findhdr i_malloc
	  i_stdlib sed libs _o
	Optional: cc ccflags

	This variable conditionally defines MYMALLOC in case other parts
	of the source want to take special action if MYMALLOC is used.
	This may include different sorts of profiling or error detection.

d_ndbm:
	Obsoleted by i_ndbm.

d_news:
	Unit: d_NeWS (Also defines d_news d_news0 d_newshome d_textcan)
	Wants: test rm Myread Getfile

	Set if running NeWS 1.1

d_news0:
	Unit: d_NeWS (Also defines d_news d_news0 d_newshome d_textcan)
	Wants: test rm Myread Getfile

	Set if running NeWS 1.0

d_newsadm:
	Unit: d_newsadm (Also defines newsadmin)
	Wants: cat contains Guess Setvar Myread Oldconfig

	This variable conditionally defines the NEWS_ADMIN symbol, which
	indicates to the C program that there is a user who is in charge
	of news administration.

d_newshome:
	Unit: d_NeWS (Also defines d_news d_news0 d_newshome d_textcan)
	Wants: test rm Myread Getfile

	Path to the top directory of the NeWS structure.

d_nice:
	Unit: d_nice
	Wants: Inlibc

	This variable conditionally defines the HAS_NICE symbol, which
	indicates to the C program that the nice() routine is available.

d_nolnbuf:
	Unit: d_nolnbuf
	Wants: test cat rm Setvar Myread
	Optional: cc

	This variable conditionally defines the NOLINEBUF symbol, which
	indicates to the C program that stdout is not buffered, so that
	the program can call setbuf() or setlinebuf() for efficiency.

d_normsig:
	Unit: d_normsig (Also defines jobslib)
	Wants: test Setvar Guess _a

	This variable conditionally defines the NORMSIG symbol, which
	indicates to the C program that the normal signal handling routines
	should be used, as opposed to the ones in 4.1bsd (sigset, etc.).

d_odbm:
	Obsoleted by i_dbm.

d_oldsock:
	Unit: d_socket (Also defines d_oldsock d_sockpair socketlib sockethdr)
	Wants: contains libc echo n c nm_opt nm_extract Inlibc Csym _a

	This variable conditionally defines the OLDSOCKET symbol, which
	indicates that the BSD socket interface is based on 4.1c and not 4.2.

d_open3:
	Unit: d_open3
	Wants: test cat h_fcntl h_sysfile rm Setvar Findhdr
	Optional: cc cppflags

	This variable conditionally defines the HAS_OPEN3 manifest constant,
	which indicates to the C program that the 3 argument version of
	the open(2) function is available.

d_passnames:
	Unit: nametype (Also defines d_passnames d_berknames d_usgnames)
	Wants: Myread Guess Oldconfig cat

	This variable conditionally defines the PASSNAMES symbol,
	which indicates to the C program that full names are stored in
	the /etc/passwd file.

d_pathconf:
	Unit: d_pathconf (Also defines d_fpathconf)
	Wants: Inlibc

	This variable conditionally defines the HAS_PATHCONF symbol, which
	indicates to the C program that the pathconf() routine is available
	to determine file-system related limits and options associated
	with a given filename.

d_pause:
	Unit: d_pause
	Wants: Inlibc

	This variable conditionally defines the HAS_PAUSE symbol, which
	indicates to the C program that the pause() routine is available
	to suspend a process until a signal is received.

d_perror:
	Unit: d_perror
	Wants: Inlibc

	This variable conditionally remaps perror to a null action and
	defines the symbol HAS_PERROR, which indicates to the C program
	that the perror() routine is not available to print system
	error messages.

d_phostname:
	Unit: d_gethname (Also defines d_uname d_phostname aphostname)
	Wants: phostname cat myhostname package d_portable Loc libc echo n c
	  Myread Guess Oldconfig Csym
	Optional: i_whoami usrinc

	This variable conditionally defines the PHOSTNAME symbol, which
	contains the shell command which, when fed to popen(), may be
	used to derive the host name.

d_pidcheck:
	Unit: d_pidcheck
	Wants: cat rm _o
	Optional: cc

	This variable conditionally defines the variable PIDCHECK
	which indicates that kill(pid, 0) will check for an active pid.

d_pipe:
	Unit: d_pipe
	Wants: Inlibc

	This variable conditionally defines the HAS_PIPE symbol, which
	indicates to the C program that the pipe() routine is available
	to create an inter-process channel.

d_poll:
	Unit: d_poll
	Wants: Inlibc

	This variable conditionally defines the HAS_POLL symbol, which
	indicates to the C program that the poll() routine is available
	to poll active file descriptors.

d_popen:
	Unit: d_popen
	Wants: Inlibc

	This variable conditionally defines HAS_POPEN if popen() is
	available to open a pipe from a process.

d_portable:
	Unit: d_portable
	Wants: cat Loc Myread Oldconfig

	This variable conditionally defines the PORTABLE symbol, which
	indicates to the C program that it should not assume that it is
	running on the machine it was compiled on.

d_psignal:
	Unit: d_psignal
	Wants: Inlibc

	This variable conditionally defines the HAS_PSIGNAL symbol, which
	indicates that the psignal() routine exists.  The psignal() routine
	prints a description of a signal on the standard error output.

d_pwage:
	Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass
	  d_pwexpire d_pwcomment)
	Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar

	This varaible conditionally defines PWAGE, which indicates
	that struct passwd contains pw_age.

d_pwchange:
	Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass
	  d_pwexpire d_pwcomment)
	Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar

	This varaible conditionally defines PWCHANGE, which indicates
	that struct passwd contains pw_change.

d_pwclass:
	Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass
	  d_pwexpire d_pwcomment)
	Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar

	This varaible conditionally defines PWCLASS, which indicates
	that struct passwd contains pw_class.

d_pwcomment:
	Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass
	  d_pwexpire d_pwcomment)
	Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar

	This varaible conditionally defines PWCOMMENT, which indicates
	that struct passwd contains pw_comment.

d_pwexpire:
	Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass
	  d_pwexpire d_pwcomment)
	Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar

	This varaible conditionally defines PWEXPIRE, which indicates
	that struct passwd contains pw_expire.

d_pwquota:
	Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass
	  d_pwexpire d_pwcomment)
	Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar

	This varaible conditionally defines PWQUOTA, which indicates
	that struct passwd contains pw_quota.

d_raster:
	Unit: d_raster (Also defines rasterlib)
	Wants: cat test Setvar Myread Oldconfig

	Conditionally defines RASTER_TEK if this is a raster tech machine.

d_rasterlib:
	Obsoleted by rasterlib.

d_rdchk:
	Unit: d_rdchk
	Wants: Inlibc

	This variable conditionally defines the HAS_RDCHK symbol, which
	indicates to the C program that the rdchk() routine is available
	to find out if there is input pending on an IO channel.

d_re_comp:
	Unit: d_regcmp (Also defines d_re_comp d_regcomp)
	Wants: Csym cat

	This variable conditionally defines the HAS_RECOMP symbol, which
	indicates to the C program that the re_comp() routine is available
	for regular patern matching (usally on BSD). If so, it is likely that
	re_exec() exists.

d_readdir:
	Unit: d_readdir (Also defines d_seekdir d_telldir d_rewinddir)
	Wants: Inlibc

	This variable conditionally defines HAS_READDIR if readdir() is
	available to read directory entries.

d_readlink:
	Unit: d_readlink
	Wants: Inlibc

	This variable conditionally defines the HAS_READLINK symbol, which
	indicates to the C program that the readlink() routine is available
	to read the value of a symbolic link.

d_regcmp:
	Unit: d_regcmp (Also defines d_re_comp d_regcomp)
	Wants: Csym cat

	This variable conditionally defines the HAS_REGCMP symbol, which
	indicates to the C program that the regcmp() routine is available
	for regular patern matching (usally on System V).

d_regcomp:
	Unit: d_regcmp (Also defines d_re_comp d_regcomp)
	Wants: Csym cat

	This variable conditionally defines the HAS_REGCOMP symbol, which
	indicates to the C program that the regcomp() routine is available
	for regular patern matching (usally on POSIX.2 conforming systems).

d_rename:
	Unit: d_rename
	Wants: Inlibc

	This variable conditionally defines the HAS_RENAME symbol, which
	indicates to the C program that the rename() routine is available
	to rename files.

d_rewinddir:
	Unit: d_readdir (Also defines d_seekdir d_telldir d_rewinddir)
	Wants: Inlibc

	This variable conditionally defines HAS_REWINDDIR if rewinddir() is
	available.

d_rmdir:
	Unit: d_rmdir
	Wants: Inlibc

	This variable conditionally defines HAS_RMDIR if rmdir() is
	available to remove directories.

d_rootchown:
	Obsoleted by d_su_chown.

d_rusage:
	Unit: d_rusage
	Wants: Inlibc

	This variable conditionally defines the HAS_GETRUSAGE symbol, which
	indicates that the getrusage() routine exists.  The getrusage() routine
	supports sub-second accuracy for process cpu accounting. You may need
	to include <sys/resource.h> and <sys/time.h>.

d_safebcpy:
	Unit: d_safebcpy
	Wants: cat d_bcopy rm d_memmove i_memory i_stdlib i_string i_unistd
	  Oldconfig Setvar
	Optional: cc optimize ccflags ldflags libs

	This variable conditionally defines the HAS_SAFE_BCOPY symbol if
	the bcopy() routine can do overlapping copies.

d_safemcpy:
	Unit: d_safemcpy
	Wants: cat d_memcpy rm d_memmove i_memory i_stdlib i_string i_unistd
	  Oldconfig Setvar
	Optional: cc optimize ccflags libs ldflags

	This variable conditionally defines the HAS_SAFE_MEMCPY symbol if
	the memcpy() routine can do overlapping copies.

d_sanemcmp:
	Unit: d_sanemcmp
	Wants: cat d_memcmp rm i_memory i_stdlib i_string i_unistd Oldconfig
	  Setvar
	Optional: cc optimize ccflags libs ldflags

	This variable conditionally defines the HAS_SANE_MEMCMP symbol if
	the memcpy() routine is available and can be used to compare relative
	magnitudes of chars with their high bits set.

d_sbrk:
	Unit: d_sbrk
	Wants: Inlibc

	This variable conditionally defines HAS_SBRK if sbrk() is
	available to add more core to the process.

d_scandir:
	Unit: d_scandir
	Wants: Inlibc

	This variable conditionally defines HAS_SCANDIR if scandir() is
	available to scan a directory.

d_scannl:
	Unit: d_scannl
	Wants: cat rm Setvar
	Optional: cc ccflags

	This variable conditionally defines SCAN_NL, which indicates
	wether the C library routines scanf() and friends can deal with
	a '\n' in the input correctly. They do most of the time.

d_scorfl:
	Unit: d_scorfl
	Wants: cat Myread Oldconfig nametype Setvar

	This variable conditionally defines the SCOREFULL symbol, which
	indicates to the C program that any scoreboard kept by the program
	should be kept on the basis of the user's full name as opposed to
	the user's login name.

d_seekdir:
	Unit: d_readdir (Also defines d_seekdir d_telldir d_rewinddir)
	Wants: Inlibc

	This variable conditionally defines HAS_SEEKDIR if seekdir() is
	available.

d_select:
	Unit: d_select
	Wants: Inlibc

	This variable conditionally defines HAS_SELECT if select() is
	available to select active file descriptors. A <sys/time.h>
	inclusion may be necessary for the timeout field.

d_sem:
	Unit: d_sem
	Wants: test d_semctl d_semget d_semop Setvar Findhdr

	This variable conditionally defines the HAS_SEM symbol, which
	indicates that the entire sem*(2) library is present.

d_semctl:
	Unit: d_semctl
	Wants: Inlibc

	This variable conditionally defines the HAS_SEMCTL symbol, which
	indicates to the C program that the semctl() routine is available.

d_semget:
	Unit: d_semget
	Wants: Inlibc

	This variable conditionally defines the HAS_SEMGET symbol, which
	indicates to the C program that the semget() routine is available.

d_semop:
	Unit: d_semop
	Wants: Inlibc

	This variable conditionally defines the HAS_SEMOP symbol, which
	indicates to the C program that the semop() routine is available.

d_setegid:
	Unit: d_setegid
	Wants: Inlibc

	This variable conditionally defines the HAS_SETEGID symbol, which
	indicates to the C program that the setegid() routine is available
	to change the effective gid of the current program.

d_seteuid:
	Unit: d_seteuid
	Wants: Inlibc

	This variable conditionally defines the HAS_SETEUID symbol, which
	indicates to the C program that the seteuid() routine is available
	to change the effective uid of the current program.

d_setlinebuf:
	Unit: d_setlnbuf (Also defines d_setlinebuf)
	Wants: Inlibc

	This variable conditionally defines the HAS_SETLINEBUF symbol, which
	indicates to the C program that the setlinebuf() routine is available
	to change stderr or stdout from block-buffered or unbuffered to a
	line-buffered mode.

d_setlocale:
	Unit: d_setlocale
	Wants: Inlibc

	This variable conditionally defines HAS_SETLOCALE if setlocale() is
	available to handle locale-specific ctype implementations.

d_setpgid:
	Unit: d_setpgid
	Wants: Inlibc

	This variable conditionally defines the HAS_SETPGID symbol if the
	setpgid(pid, gpid) function is available to set process group ID.

d_setpgrp:
	Unit: d_setpgrp (Also defines d_bsdsetpgrp)
	Wants: cat rm Inlibc Guess Setvar i_unistd
	Optional: cc libs ccflags ldflags

	This variable conditionally defines HAS_SETPGRP if setpgrp() is
	available to set the current process group.

d_setpgrp2:
	Unit: d_setpgrp2
	Wants: Inlibc

	This variable conditionally defines the HAS_SETPGRP2 symbol, which
	indicates to the C program that the scter.

d_memcmp:
	Unit: d_memcmp
	Wants: Inlibc

is variable conditionally defines the HAS_MEMCMP symbol, which
	indicates to the C program that the memcmp() routine is available
	to compare blocks of memory.

d_memcpy:
	Unit: d_memcpy
	Wants: Inlibc

	This variable conditionally defines the HAS_MEMCPY symbol, which
	indicates to the C program that the memcpy() routine is available
	to copy blocks of memory.

d_memmove:
	Unit: d_memmove
	Wants: Inlibc

	This variable conditionally defines the HAS_MEMMOVE symbol, which
	indicates to the C program that the memmove() routine is available
	to copy potentatially overlapping blocks of memory.

d_memset:
	Unit: d_memset
	Wants: Inlibc

	This variable conditionally defines the HAS_MEMSET symbol, which
	indicates to the C program that the memset() routine is available
	to set blocks of memory.

d_mkdir:
	Unit: d_mkdir
	Wants: Inlibc

	This variable conditionally defines the HAS_MKDIR symbol, which
	indicates to the C program that the mkdir() routine is available
	to create directories..

d_mkfifo:
	Unit: d_mkfifo
	Wants: Inlibc

	This variable conditionally defines the HAS_MKFIFO symbol, which
	indicates to the C program that the mkfifo() routine is available.

d_mktime:
	Unit: d_mktime
	Wants: Inlibc

	This variable conditionally defines the HAS_MKTIME symbol, which
	indicates to the C program that the mktime() routine is available.

d_mmap:
	Unit: d_mmap
	Wants: Inlibc

	This variable conditionally defines HAS_MMAP if mmap() is
	available to map a file into memory.

d_msg:
	Unit: d_msg
	Wants: test d_msgctl d_msgget d_msgsnd d_msgrcv Setvar Findhdr

	This variable conditionally defines the HAS_MSG symbol, which
	indicates that the entire msg*(2) library is present.

d_msgctl:
	Unit: d_msgctl
	Wants: Inlibc

	This variable conditionally defines the HAS_MSGCTL symbol, which
	indicates to the C program that the msgctl() routine is available.

d_msgget:
	Unit: d_msgget
	Wants: Inlibc

	This variable conditionally defines the HAS_MSGGET symbol, which
	indicates to the C program that the msgget() routine is available.

d_msgrcv:
	Unit: d_msgrcv
	Wants: Inlibc

	This variable conditionally defines the HAS_MSGRCV symbol, which
	indicates to the C program that the msgrcv() routine is available.

d_msgsnd:
	Unit: d_msgsnd
	Wants: Inlibc

	This variable conditionally defines the HAS_MSGSND symbol, which
	indicates to the C program that the msgsnd() routine is available.

d_msync:
	Unit: d_msync
	Wants: Inlibc

	This variable conditionally defines HAS_MSYNC if msync() is
	available to synchronize a mapped file.

d_munmap:
	Unit: d_munmap
	Wants: Inlibc

	This variable conditionally defines HAS_MUNMAP if munmap() is
	available to unmap a region mapped by mmap().

d_mymalloc:
	Unit: mallocsrc (Also defines mallocobj usemymalloc malloctype
	  d_mymalloc freetype)
	Wants: Myread Oldconfig package Guess Setvar rm cat Findhdr i_malloc
	  i_stdlib sed libs _o
	Optional: cc ccflags

	This variable conditionally defines MYMALLOC in case other parts
	of the source want to take special action if MYMALLOC is used.
	This may include different sorts of profiling or error detection.

d_ndbm:
	Obsoleted by i_ndbm.

d_news:
	Unit: d_NeWS (Also defines d_news d_news0 d_newshome d_textcan)
	Wants: test rm Myread Getfile

	Set if running NeWS 1.1

d_news0:
	Unit: d_NeWS (Also defines d_news d_news0 d_newshome d_textcan)
	Wants: test rm Myread Getfile

	Set if running NeWS 1.0

d_newsadm:
	Unit: d_newsadm (Also defines newsadmin)
	Wants: cat contains Guess Setvar Myread Oldconfig

	This variable conditionally defines the NEWS_ADMIN symbol, which
	indicates to the C program that there is a user who is in charge
	of news administration.

d_newshome:
	Unit: d_NeWS (Also defines d_news d_news0 d_newshome d_textcan)
	Wants: test rm Myread Getfile

	Path to the top directory of the NeWS structure.

d_nice:
	Unit: d_nice
	Wants: Inlibc

	This variable conditionally defines the HAS_NICE symbol, which
	indicates to the C program that the nice() routine is available.

d_nolnbuf:
	Unit: d_nolnbuf
	Wants: test cat rm Setvar Myread
	Optional: cc

	This variable conditionally defines the NOLINEBUF symbol, which
	indicates to the C program that stdout is not buffered, so that
	the program can call setbuf() or setlinebuf() for efficiency.

d_normsig:
	Unit: d_normsig (Also defines jobslib)
	Wants: test Setvar Guess _a

	This variable conditionally defines the NORMSIG symbol, which
	indicates to the C program that the normal signal handling routines
	should be used, as opposed to the ones in 4.1bsd (sigset, etc.).

d_odbm:
	Obsoleted by i_dbm.

d_oldsock:
	Unit: d_socket (Also defines d_oldsock d_sockpair socketlib sockethdr)
	Wants: contains libc echo n c nm_opt nm_extract Inlibc Csym _a

	This variable conditionally defines the OLDSOCKET symbol, which
	indicates that the BSD socket interface is based on 4.1c and not 4.2.

d_open3:
	Unit: d_open3
	Wants: test cat h_fcntl h_sysfile rm Setvar Findhdr
	Optional: cc cppflags

	This variable conditionally defines the HAS_OPEN3 manifest constant,
	which indicates to the C program that the 3 argument version of
	the open(2) function is available.

d_passnames:
	Unit: nametype (Also defines d_passnames d_berknames d_usgnames)
	Wants: Myread Guess Oldconfig cat

	This variable conditionally defines the PASSNAMES symbol,
	which indicates to the C program that full names are stored in
	the /etc/passwd file.

d_pathconf:
	Unit: d_pathconf (Also defines d_fpathconf)
	Wants: Inlibc

	This variable conditionally defines the HAS_PATHCONF symbol, which
	indicates to the C program that the pathconf() routine is available
	to determine file-system related limits and options associated
	with a given filename.

d_pause:
	Unit: d_pause
	Wants: Inlibc

	This variable conditionally defines the HAS_PAUSE symbol, which
	indicates to the C program that the pause() routine is available
	to suspend a process until a signal is received.

d_perror:
	Unit: d_perror
	Wants: Inlibc

	This variable conditionally remaps perror to a null action and
	defines the symbol HAS_PERROR, which indicates to the C program
	that the perror() routine is not available to print system
	error messages.

d_phostname:
	Unit: d_gethname (Also defines d_uname d_phostname aphostname)
	Wants: phostname cat myhostname package d_portable Loc libc echo n c
	  Myread Guess Oldconfig Csym
	Optional: i_whoami usrinc

	This variable conditionally defines the PHOSTNAME symbol, which
	contains the shell command which, when fed to popen(), may be
	used to derive the host name.

d_pidcheck:
	Unit: d_pidcheck
	Wants: cat rm _o
	Optional: cc

	This variable conditionally defines the variable PIDCHECK
	which indicates that kill(pid, 0) will check for an active pid.

d_pipe:
	Unit: d_pipe
	Wants: Inlibc

	This variable conditionally defines the HAS_PIPE symbol, which
	indicates to the C program that the pipe() routine is available
	to create an inter-process channel.

d_poll:
	Unit: d_poll
	Wants: Inlibc

	This variable conditionally defines the HAS_POLL symbol, which
	indicates to the C program that the poll() routine is available
	to poll active file descriptors.

d_popen:
	Unit: d_popen
	Wants: Inlibc

	This variable conditionally defines HAS_POPEN if popen() is
	available to open a pipe from a process.

d_portable:
	Unit: d_portable
	Wants: cat Loc Myread Oldconfig

	This variable conditionally defines the PORTABLE symbol, which
	indicates to the C program that it should not assume that it is
	running on the machine it was compiled on.

d_psignal:
	Unit: d_psignal
	Wants: Inlibc

	This variable conditionally defines the HAS_PSIGNAL symbol, which
	indicates that the psignal() routine exists.  The psignal() routine
	prints a description of a signal on the standard error output.

d_pwage:
	Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass
	  d_pwexpire d_pwcomment)
	Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar

	This varaible conditionally defines PWAGE, which indicates
	that struct passwd contains pw_age.

d_pwchange:
	Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass
	  d_pwexpire d_pwcomment)
	Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar

	This varaible conditionally defines PWCHANGE, which indicates
	that struct passwd contains pw_change.

d_pwclass:
	Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass
	  d_pwexpire d_pwcomment)
	Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar

	This varaible conditionally defines PWCLASS, which indicates
	that struct passwd contains pw_class.

d_pwcomment:
	Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass
	  d_pwexpire d_pwcomment)
	Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar

	This varaible conditionally defines PWCOMMENT, which indicates
	that struct passwd contains pw_comment.

d_pwexpire:
	Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass
	  d_pwexpire d_pwcomment)
	Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar

	This varaible conditionally defines PWEXPIRE, which indicates
	that struct passwd contains pw_expire.

d_pwquota:
	Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass
	  d_pwexpire d_pwcomment)
	Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar

	This varaible conditionally defines PWQUOTA, which indicates
	that struct passwd contains pw_quota.

d_raster:
	Unit: d_raster (Also defines rasterlib)
	Wants: cat test Setvar Myread Oldconfig

	Conditionally defines RASTER_TEK if this is a raster tech machine.

d_rasterlib:
	Obsoleted by rasterlib.

d_rdchk:
	Unit: d_rdchk
	Wants: Inlibc

	This variable conditionally defines the HAS_RDCHK symbol, which
	indicates to the C program that the rdchk() routine is available
	to find out if there is input pending on an IO channel.

d_re_comp:
	Unit: d_regcmp (Also defines d_re_comp d_regcomp)
	Wants: Csym cat

	This variable conditionally defines the HAS_RECOMP symbol, which
	indicates to the C program that the re_comp() routine is available
	for regular patern matching (usally on BSD). If so, it is likely that
	re_exec() exists.

d_readdir:
	Unit: d_readdir (Also defines d_seekdir d_telldir d_rewinddir)
	Wants: Inlibc

	This variable conditionally defines HAS_READDIR if readdir() is
	available to read directory entries.

d_readlink:
	Unit: d_readlink
	Wants: Inlibc

	This variable conditionally defines the HAS_READLINK symbol, which
	indicates to the C program that the readlink() routine is available
	to read the value of a symbolic link.

d_regcmp:
	Unit: d_regcmp (Also defines d_re_comp d_regcomp)
	Wants: Csym cat

	This variable conditionally defines the HAS_REGCMP symbol, which
	indicates to the C program that the regcmp() routine is available
	for regular patern matching (usally on System V).

d_regcomp:
	Unit: d_regcmp (Also defines d_re_comp d_regcomp)
	Wants: Csym cat

	This variable conditionally defines the HAS_REGCOMP symbol, which
	indicates to the C program that the regcomp() routine is available
	for regular patern matching (usally on POSIX.2 conforming systems).

d_rename:
	Unit: d_rename
	Wants: Inlibc

	This variable conditionally defines the HAS_RENAME symbol, which
	indicates to the C program that the rename() routine is available
	to rename files.

d_rewinddir:
	Unit: d_readdir (Also defines d_seekdir d_telldir d_rewinddir)
	Wants: Inlibc

	This variable conditionally defines HAS_REWINDDIR if rewinddir() is
	available.

d_rmdir:
	Unit: d_rmdir
	Wants: Inlibc

	This variable conditionally defines HAS_RMDIR if rmdir() is
	available to remove directories.

d_rootchown:
	Obsoleted by d_su_chown.

d_rusage:
	Unit: d_rusage
	Wants: Inlibc

	This variable conditionally defines the HAS_GETRUSAGE symbol, which
	indicates that the getrusage() routine exists.  The getrusage() routine
	supports sub-second accuracy for process cpu accounting. You may need
	to include <sys/resource.h> and <sys/time.h>.

d_safebcpy:
	Unit: d_safebcpy
	Wants: cat d_bcopy rm d_memmove i_memory i_stdlib i_string i_unistd
	  Oldconfig Setvar
	Optional: cc optimize ccflags ldflags libs

	This variable conditionally defines the HAS_SAFE_BCOPY symbol if
	the bcopy() routine can do overlapping copies.

d_safemcpy:
	Unit: d_safemcpy
	Wants: cat d_memcpy rm d_memmove i_memory i_stdlib i_string i_unistd
	  Oldconfig Setvar
	Optional: cc optimize ccflags libs ldflags

	This variable conditionally defines the HAS_SAFE_MEMCPY symbol if
	the memcpy() routine can do overlapping copies.

d_sanemcmp:
	Unit: d_sanemcmp
	Wants: cat d_memcmp rm i_memory i_stdlib i_string i_unistd Oldconfig
	  Setvar
	Optional: cc optimize ccflags libs ldflags

	This variable conditionally defines the HAS_SANE_MEMCMP symbol if
	the memcpy() routine is available and can be used to compare relative
	magnitudes of chars with their high bits set.

d_sbrk:
	Unit: d_sbrk
	Wants: Inlibc

	This variable conditionally defines HAS_SBRK if sbrk() is
	available to add more core to the process.

d_scandir:
	Unit: d_scandir
	Wants: Inlibc

	This variable conditionally defines HAS_SCANDIR if scandir() is
	available to scan a directory.

d_scannl:
	Unit: d_scannl
	Wants: cat rm Setvar
	Optional: cc ccflags

	This variable conditionally defines SCAN_NL, which indicates
	wether the C library routines scanf() and friends can deal with
	a '\n' in the input correctly. They do most of the time.

d_scorfl:
	Unit: d_scorfl
	Wants: cat Myread Oldconfig nametype Setvar

	This variable conditionally defines the SCOREFULL symbol, which
	indicates to the C program that any scoreboard kept by the program
	should be kept on the basis of the user's full name as opposed to
	the user's login name.

d_seekdir:
	Unit: d_readdir (Also defines d_seekdir d_telldir d_rewinddir)
	Wants: Inlibc

	This variable conditionally defines HAS_SEEKDIR if seekdir() is
	available.

d_select:
	Unit: d_select
	Wants: Inlibc

	This variable conditionally defines HAS_SELECT if select() is
	available to select active file descriptors. A <sys/time.h>
	inclusion may be necessary for the timeout field.

d_sem:
	Unit: d_sem
	Wants: test d_semctl d_semget d_semop Setvar Findhdr

	This variable conditionally defines the HAS_SEM symbol, which
	indicates that the entire sem*(2) library is present.

d_semctl:
	Unit: d_semctl
	Wants: Inlibc

	This variable conditionally defines the HAS_SEMCTL symbol, which
	indicates to the C program that the semctl() routine is available.

d_semget:
	Unit: d_semget
	Wants: Inlibc

	This variable conditionally defines the HAS_SEMGET symbol, which
	indicates to the C program that the semget() routine is available.

d_semop:
	Unit: d_semop
	Wants: Inlibc

	This variable conditionally defines the HAS_SEMOP symbol, which
	indicates to the C program that the semop() routine is available.

d_setegid:
	Unit: d_setegid
	Wants: Inlibc

	This variable conditionally defines the HAS_SETEGID symbol, which
	indicates to the C program that the setegid() routine is available
	to change the effective gid of the current program.

d_seteuid:
	Unit: d_seteuid
	Wants: Inlibc

	This variable conditionally defines the HAS_SETEUID symbol, which
	indicates to the C program that the seteuid() routine is available
	to change the effective uid of the current program.

d_setlinebuf:
	Unit: d_setlnbuf (Also defines d_setlinebuf)
	Wants: Inlibc

	This variable conditionally defines the HAS_SETLINEBUF symbol, which
	indicates to the C program that the setlinebuf() routine is available
	to change stderr or stdout from block-buffered or unbuffered to a
	line-buffered mode.

d_setlocale:
	Unit: d_setlocale
	Wants: Inlibc

	This variable conditionally defines HAS_SETLOCALE if setlocale() is
	available to handle locale-specific ctype implementations.

d_setpgid:
	Unit: d_setpgid
	Wants: Inlibc

	This variable conditionally defines the HAS_SETPGID symbol if the
	setpgid(pid, gpid) function is available to set process group ID.

d_setpgrp:
	Unit: d_setpgrp (Also defines d_bsdsetpgrp)
	Wants: cat rm Inlibc Guess Setvar i_unistd
	Optional: cc libs ccflags ldflags

	This variable conditionally defines HAS_SETPGRP if setpgrp() is
	available to set the current process group.

d_setpgrp2:
	Unit: d_setpgrp2
	Wants: Inlibc

	This variable conditionally defines the HAS_SETPGRP2 symbol, which
	indicates to the C program that the scter.

d_memcmp:
	Unit: d_memcmp
	Wants: Inlibc

is variable conditionally defines the HAS_MEMCMP symbol, which
	indicates to the C program that the memcmp() routine is available
	to compare blocks of memory.

d_memcpy:
	Unit: d_memcpy
	Wants: Inlibc

	This variable conditionally defines the HAS_MEMCPY symbol, which
	indicates to the C program that the memcpy() routine is available
	to copy blocks of memory.

d_memmove:
	Unit: d_memmove
	Wants: Inlibc

	This variable conditionally defines the HAS_MEMMOVE symbol, which
	indicates to the C program that the memmove() routine is available
	to copy potentatially overlapping blocks of memory.

d_memset:
	Unit: d_memset
	Wants: Inlibc

	This variable conditionally defines the HAS_MEMSET symbol, which
	indicates to the C program that the memset() routine is available
	to set blocks of memory.

d_mkdir:
	Unit: d_mkdir
	Wants: Inlibc

	This variable conditionally defines the HAS_MKDIR symbol, which
	indicates to the C program that the mkdir() routine is available
	to create directories..

d_mkfifo:
	Unit: d_mkfifo
	Wants: Inlibc

	This variable conditionally defines the HAS_MKFIFO symbol, which
	indicates to the C program that the mkfifo() routine is available.

d_mktime:
	Unit: d_mktime
	Wants: Inlibc

	This variable conditionally defines the HAS_MKTIME symbol, which
	indicates to the C program that the mktime() routine is available.

d_mmap:
	Unit: d_mmap
	Wants: Inlibc

	This variable conditionally defines HAS_MMAP if mmap() is
	available to map a file into memory.

d_msg:
	Unit: d_msg
	Wants: test d_msgctl d_msgget d_msgsnd d_msgrcv Setvar Findhdr

	This variable conditionally defines the HAS_MSG symbol, which
	indicates that the entire msg*(2) library is present.

d_msgctl:
	Unit: d_msgctl
	Wants: Inlibc

	This variable conditionally defines the HAS_MSGCTL symbol, which
	indicates to the C program that the msgctl() routine is available.

d_msgget:
	Unit: d_msgget
	Wants: Inlibc

	This variable conditionally defines the HAS_MSGGET symbol, which
	indicates to the C program that the msgget() routine is available.

d_msgrcv:
	Unit: d_msgrcv
	Wants: Inlibc

	This variable conditionally defines the HAS_MSGRCV symbol, which
	indicates to the C program that the msgrcv() routine is available.

d_msgsnd:
	Unit: d_msgsnd
	Wants: Inlibc

	This variable conditionally defines the HAS_MSGSND symbol, which
	indicates to the C program that the msgsnd() routine is available.

d_msync:
	Unit: d_msync
	Wants: Inlibc

	This variable conditionally defines HAS_MSYNC if msync() is
	available to synchronize a mapped file.

d_munmap:
	Unit: d_munmap
	Wants: Inlibc

	This variable conditionally defines HAS_MUNMAP if munmap() is
	available to unmap a region mapped by mmap().

d_mymalloc:
	Unit: mallocsrc (Also defines mallocobj usemymalloc malloctype
	  d_mymalloc freetype)
	Wants: Myread Oldconfig package Guess Setvar rm cat Findhdr i_malloc
	  i_stdlib sed libs _o
	Optional: cc ccflags

	This variable conditionally defines MYMALLOC in case other parts
	of the source want to take special action if MYMALLOC is used.
	This may include different sorts of profiling or error detection.

d_ndbm:
	Obsoleted by i_ndbm.

d_news:
	Unit: d_NeWS (Also defines d_news d_news0 d_newshome d_textcan)
	Wants: test rm Myread Getfile

	Set if running NeWS 1.1

d_news0:
	Unit: d_NeWS (Also defines d_news d_news0 d_newshome d_textcan)
	Wants: test rm Myread Getfile

	Set if running NeWS 1.0

d_newsadm:
	Unit: d_newsadm (Also defines newsadmin)
	Wants: cat contains Guess Setvar Myread Oldconfig

	This variable conditionally defines the NEWS_ADMIN symbol, which
	indicates to the C program that there is a user who is in charge
	of news administration.

d_newshome:
	Unit: d_NeWS (Also defines d_news d_news0 d_newshome d_textcan)
	Wants: test rm Myread Getfile

	Path to the top directory of the NeWS structure.

d_nice:
	Unit: d_nice
	Wants: Inlibc

	This variable conditionally defines the HAS_NICE symbol, which
	indicates to the C program that the nice() routine is available.

d_nolnbuf:
	Unit: d_nolnbuf
	Wants: test cat rm Setvar Myread
	Optional: cc

	This variable conditionally defines the NOLINEBUF symbol, which
	indicates to the C program that stdout is not buffered, so that
	the program can call setbuf() or setlinebuf() for efficiency.

d_normsig:
	Unit: d_normsig (Also defines jobslib)
	Wants: test Setvar Guess _a

	This variable conditionally defines the NORMSIG symbol, which
	indicates to the C program that the normal signal handling routines
	should be used, as opposed to the ones in 4.1bsd (sigset, etc.).

d_odbm:
	Obsoleted by i_dbm.

d_oldsock:
	Unit: d_socket (Also defines d_oldsock d_sockpair socketlib sockethdr)
	Wants: contains libc echo n c nm_opt nm_extract Inlibc Csym _a

	This variable conditionally defines the OLDSOCKET symbol, which
	indicates that the BSD socket interface is based on 4.1c and not 4.2.

d_open3:
	Unit: d_open3
	Wants: test cat h_fcntl h_sysfile rm Setvar Findhdr
	Optional: cc cppflags

	This variable conditionally defines the HAS_OPEN3 manifest constant,
	which indicates to the C program that the 3 argument version of
	the open(2) function is available.

d_passnames:
	Unit: nametype (Also defines d_passnames d_berknames d_usgnames)
	Wants: Myread Guess Oldconfig cat

	This variable conditionally defines the PASSNAMES symbol,
	which indicates to the C program that full names are stored in
	the /etc/passwd file.

d_pathconf:
	Unit: d_pathconf (Also defines d_fpathconf)
	Wants: Inlibc

	This variable conditionally defines the HAS_PATHCONF symbol, which
	indicates to the C program that the pathconf() routine is available
	to determine file-system related limits and options associated
	with a given filename.

d_pause:
	Unit: d_pause
	Wants: Inlibc

	This variable conditionally defines the HAS_PAUSE symbol, which
	indicates to the C program that the pause() routine is available
	to suspend a process until a signal is received.

d_perror:
	Unit: d_perror
	Wants: Inlibc

	This variable conditionally remaps perror to a null action and
	defines the symbol HAS_PERROR, which indicates to the C program
	that the perror() routine is not available to print system
	error messages.

d_phostname:
	Unit: d_gethname (Also defines d_uname d_phostname aphostname)
	Wants: phostname cat myhostname package d_portable Loc libc echo n c
	  Myread Guess Oldconfig Csym
	Optional: i_whoami usrinc

	This variable conditionally defines the PHOSTNAME symbol, which
	contains the shell command which, when fed to popen(), may be
	used to derive the host name.

d_pidcheck:
	Unit: d_pidcheck
	Wants: cat rm _o
	Optional: cc

	This variable conditionally defines the variable PIDCHECK
	which indicates that kill(pid, 0) will check for an active pid.

d_pipe:
	Unit: d_pipe
	Wants: Inlibc

	This variable conditionally defines the HAS_PIPE symbol, which
	indicates to the C program that the pipe() routine is available
	to create an inter-process channel.

d_poll:
	Unit: d_poll
	Wants: Inlibc

	This variable conditionally defines the HAS_POLL symbol, which
	indicates to the C program that the poll() routine is available
	to poll active file descriptors.

d_popen:
	Unit: d_popen
	Wants: Inlibc

	This variable conditionally defines HAS_POPEN if popen() is
	available to open a pipe from a process.

d_portable:
	Unit: d_portable
	Wants: cat Loc Myread Oldconfig

	This variable conditionally defines the PORTABLE symbol, which
	indicates to the C program that it should not assume that it is
	running on the machine it was compiled on.

d_psignal:
	Unit: d_psignal
	Wants: Inlibc

	This variable conditionally defines the HAS_PSIGNAL symbol, which
	indicates that the psignal() routine exists.  The psignal() routine
	prints a description of a signal on the standard error output.

d_pwage:
	Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass
	  d_pwexpire d_pwcomment)
	Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar

	This varaible conditionally defines PWAGE, which indicates
	that struct passwd contains pw_age.

d_pwchange:
	Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass
	  d_pwexpire d_pwcomment)
	Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar

	This varaible conditionally defines PWCHANGE, which indicates
	that struct passwd contains pw_change.

d_pwclass:
	Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass
	  d_pwexpire d_pwcomment)
	Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar

	This varaible conditionally defines PWCLASS, which indicates
	that struct passwd contains pw_class.

d_pwcomment:
	Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass
	  d_pwexpire d_pwcomment)
	Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar

	This varaible conditionally defines PWCOMMENT, which indicates
	that struct passwd contains pw_comment.

d_pwexpire:
	Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass
	  d_pwexpire d_pwcomment)
	Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar

	This varaible conditionally defines PWEXPIRE, which indicates
	that struct passwd contains pw_expire.

d_pwquota:
	Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass
	  d_pwexpire d_pwcomment)
	Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar

	This varaible conditionally defines PWQUOTA, which indicates
	that struct passwd contains pw_quota.

d_raster:
	Unit: d_raster (Also defines rasterlib)
	Wants: cat test Setvar Myread Oldconfig

	Conditionally defines RASTER_TEK if this is a raster tech machine.

d_rasterlib:
	Obsoleted by rasterlib.

d_rdchk:
	Unit: d_rdchk
	Wants: Inlibc

	This variable conditionally defines the HAS_RDCHK symbol, which
	indicates to the C program that the rdchk() routine is available
	to find out if there is input pending on an IO channel.

d_re_comp:
	Unit: d_regcmp (Also defines d_re_comp d_regcomp)
	Wants: Csym cat

	This variable conditionally defines the HAS_RECOMP symbol, which
	indicates to the C program that the re_comp() routine is available
	for regular patern matching (usally on BSD). If so, it is likely that
	re_exec() exists.

d_readdir:
	Unit: d_readdir (Also defines d_seekdir d_telldir d_rewinddir)
	Wants: Inlibc

	This variable conditionally defines HAS_READDIR if readdir() is
	available to read directory entries.

d_readlink:
	Unit: d_readlink
	Wants: Inlibc

	This variable conditionally defines the HAS_READLINK symbol, which
	indicates to the C program that the readlink() routine is available
	to read the value of a symbolic link.

d_regcmp:
	Unit: d_regcmp (Also defines d_re_comp d_regcomp)
	Wants: Csym cat

	This variable conditionally defines the HAS_REGCMP symbol, which
	indicates to the C program that the regcmp() routine is available
	for regular patern matching (usally on System V).

d_regcomp:
	Unit: d_regcmp (Also defines d_re_comp d_regcomp)
	Wants: Csym cat

	This variable conditionally defines the HAS_REGCOMP symbol, which
	indicates to the C program that the regcomp() routine is available
	for regular patern matching (usally on POSIX.2 conforming systems).

d_rename:
	Unit: d_rename
	Wants: Inlibc

	This variable conditionally defines the HAS_RENAME symbol, which
	indicates to the C program that the rename() routine is available
	to rename files.

d_rewinddir:
	Unit: d_readdir (Also defines d_seekdir d_telldir d_rewinddir)
	Wants: Inlibc

	This variable conditionally defines HAS_REWINDDIR if rewinddir() is
	available.

d_rmdir:
	Unit: d_rmdir
	Wants: Inlibc

	This variable conditionally defines HAS_RMDIR if rmdir() is
	available to remove directories.

d_rootchown:
	Obsoleted by d_su_chown.

d_rusage:
	Unit: d_rusage
	Wants: Inlibc

	This variable conditionally defines the HAS_GETRUSAGE symbol, which
	indicates that the getrusage() routine exists.  The getrusage() routine
	supports sub-second accuracy for process cpu accounting. You may need
	to include <sys/resource.h> and <sys/time.h>.

d_safebcpy:
	Unit: d_safebcpy
	Wants: cat d_bcopy rm d_memmove i_memory i_stdlib i_string i_unistd
	  Oldconfig Setvar
	Optional: cc optimize ccflags ldflags libs

	This variable conditionally defines the HAS_SAFE_BCOPY symbol if
	the bcopy() routine can do overlapping copies.

d_safemcpy:
	Unit: d_safemcpy
	Wants: cat d_memcpy rm d_memmove i_memory i_stdlib i_string i_unistd
	  Oldconfig Setvar
	Optional: cc optimize ccflags libs ldflags

	This variable conditionally defines the HAS_SAFE_MEMCPY symbol if
	the memcpy() routine can do overlapping copies.

d_sanemcmp:
	Unit: d_sanemcmp
	Wants: cat d_memcmp rm i_memory i_stdlib i_string i_unistd Oldconfig
	  Setvar
	Optional: cc optimize ccflags libs ldflags

	This variable conditionally defines the HAS_SANE_MEMCMP symbol if
	the memcpy() routine is available and can be used to compare relative
	magnitudes of chars with their high bits set.

d_sbrk:
	Unit: d_sbrk
	Wants: Inlibc

	This variable conditionally defines HAS_SBRK if sbrk() is
	available to add more core to the process.

d_scandir:
	Unit: d_scandir
	Wants: Inlibc

	This variable conditionally defines HAS_SCANDIR if scandir() is
	available to scan a directory.

d_scannl:
	Unit: d_scannl
	Wants: cat rm Setvar
	Optional: cc ccflags

	This variable conditionally defines SCAN_NL, which indicates
	wether the C library routines scanf() and friends can deal with
	a '\n' in the input correctly. They do most of the time.

d_scorfl:
	Unit: d_scorfl
	Wants: cat Myread Oldconfig nametype Setvar

	This variable conditionally defines the SCOREFULL symbol, which
	indicates to the C program that any scoreboard kept by the program
	should be kept on the basis of the user's full name as opposed to
	the user's login name.

d_seekdir:
	Unit: d_readdir (Also defines d_seekdir d_telldir d_rewinddir)
	Wants: Inlibc

	This variable conditionally defines HAS_SEEKDIR if seekdir() is
	available.

d_select:
	Unit: d_select
	Wants: Inlibc

	This variable conditionally defines HAS_SELECT if select() is
	available to select active file descriptors. A <sys/time.h>
	inclusion may be necessary for the timeout field.

d_sem:
	Unit: d_sem
	Wants: test d_semctl d_semget d_semop Setvar Findhdr

	This variable conditionally defines the HAS_SEM symbol, which
	indicates that the entire sem*(2) library is present.

d_semctl:
	Unit: d_semctl
	Wants: Inlibc

	This variable conditionally defines the HAS_SEMCTL symbol, which
	indicates to the C program that the semctl() routine is available.

d_semget:
	Unit: d_semget
	Wants: Inlibc

	This variable conditionally defines the HAS_SEMGET symbol, which
	indicates to the C program that the semget() routine is available.

d_semop:
	Unit: d_semop
	Wants: Inlibc

	This variable conditionally defines the HAS_SEMOP symbol, which
	indicates to the C program that the semop() routine is available.

d_setegid:
	Unit: d_setegid
	Wants: Inlibc

	This variable conditionally defines the HAS_SETEGID symbol, which
	indicates to the C program that the setegid() routine is available
	to change the effective gid of the current program.

d_seteuid:
	Unit: d_seteuid
	Wants: Inlibc

	This variable conditionally defines the HAS_SETEUID symbol, which
	indicates to the C program that the seteuid() routine is available
	to change the effective uid of the c                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             