root/releases/1.6/0p2/config_h.SH

case $CONFIG in
'')
    if test -f config.sh; then TOP=.;
    elif test -f ../config.sh; then TOP=..;
    elif test -f ../../config.sh; then TOP=../..;
    elif test -f ../../../config.sh; then TOP=../../..;
    elif test -f ../../../../config.sh; then TOP=../../../..;
    else
        echo "Can't find config.sh."; exit 1
    fi
    . $TOP/config.sh
    ;;
esac
case "$0" in
*/*) cd `expr X$0 : 'X\(.*\)/'` ;;
esac
echo "Extracting config.h (with variable substitutions)"
sed <<!GROK!THIS! >config.h -e 's!^#undef!/\*#define!' -e 's!^#un-def!#undef!'
/*
 * This file was produced by running the config_h.SH script, which
 * gets its values from config.sh, which is generally produced by
 * running Configure.
 *
 * Feel free to modify any of this as the need arises.  Note, however,
 * that running config_h.SH again will wipe out any changes you've made.
 * For a more permanent change edit config.sh and rerun config_h.SH.
 *
 * \$Id: Config_h.U,v 3.0.1.3 1995/01/30 14:25:39 ram Exp $
 */

/* Configuration time: $cf_time
 * Configured by: $cf_by
 * Target system: $myuname
 */

#ifndef _config_h_
#define _config_h_

/* getdtablesize:
 *  This catches use of the getdtablesize() subroutine, and remaps it
 *  to either ulimit(4,0) or NOFILE, if getdtablesize() isn't available.
 */
#$d_gettblsz getdtablesize() $tablesize /**/

/* HAS_BCOPY:
 *  This symbol is defined if the bcopy() routine is available to
 *  copy blocks of memory.
 */
#$d_bcopy HAS_BCOPY /**/

/* HAS_BZERO:
 *  This symbol is defined if the bzero() routine is available to
 *  set a memory block to 0.
 */
#$d_bzero HAS_BZERO /**/

/* HASCONST:
 *  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.
 */
#$d_const HASCONST  /**/
#ifndef HASCONST
#define const
#endif

/* HAS_MEMSET:
 *  This symbol, if defined, indicates that the memset routine is available
 *  to set blocks of memory.
 */
#$d_memset HAS_MEMSET   /**/

/* HAS_GETRUSAGE:
 *  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.
 */
#$d_rusage HAS_GETRUSAGE        /**/

/* HAS_SIGACTION:
 *  This symbol, if defined, indicates that Vr4's sigaction() routine
 *  is available.
 */
#$d_sigaction HAS_SIGACTION /**/

/* HAS_STRCASECMP:
 *  This symbol, if defined, indicates that the strcasecmp() routine is
 *  available for case-insensitive string compares.
 */
#$d_strccmp HAS_STRCASECMP  /**/

/* HAS_STRDUP:
 *  This symbol, if defined, indicates that the strdup routine is
 *  available to duplicate strings in memory. Otherwise, roll up
 *  your own...
 */
#$d_strdup HAS_STRDUP       /**/

/* HAS_SYSCONF:
 *  This symbol, if defined, indicates that sysconf() is available
 *  to determine system related limits and options.
 */
#$d_sysconf HAS_SYSCONF /**/

/* UNION_WAIT:
 *  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).
 */
#$d_uwait UNION_WAIT        /**/

/* VOIDSIG:
 *  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.
 */
/* Signal_t:
 *  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)".
 */
#$d_voidsig VOIDSIG     /**/
#define Signal_t $signal_t  /* Signal handler's return type */

/* HASVOLATILE:
 *  This symbol, if defined, indicates that this C compiler knows about
 *  the volatile declaration.
 */
#$d_volatile    HASVOLATILE /**/
#ifndef HASVOLATILE
#define volatile
#endif

/* HAS_WAITPID:
 *  This symbol, if defined, indicates that the waitpid routine is
 *  available to wait for child process.
 */
#$d_waitpid HAS_WAITPID /**/

/* I_LIMITS:
 *  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_limits I_LIMITS     /**/

/* I_MEMORY:
 *  This symbol, if defined, indicates to the C program that it should
 *  include <memory.h>.
 */
#$i_memory I_MEMORY     /**/

/* I_STDLIB:
 *  This symbol, if defined, indicates that <stdlib.h> exists and should
 *  be included.
 */
#$i_stdlib I_STDLIB     /**/

/* I_STRING:
 *  This symbol, if defined, indicates to the C program that it should
 *  include <string.h> (USG systems) instead of <strings.h> (BSD systems).
 */
#$i_string I_STRING     /**/

/* I_SYS_RESOURCE:
 *  This symbol, if defined, indicates to the C program that it should
 *  include <sys/resource.h>.
 */
#$i_sysresrc I_SYS_RESOURCE     /**/

/* I_SYS_SELECT:
 *  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_sysselct I_SYS_SELECT   /**/

/* I_SYS_TYPES:
 *  This symbol, if defined, indicates to the C program that it should
 *  include <sys/types.h>.
 */
#$i_systypes    I_SYS_TYPES     /**/

/* I_SYS_WAIT:
 *  This symbol, if defined, indicates to the C program that it should
 *  include <sys/wait.h>.
 */
#$i_syswait I_SYS_WAIT  /**/

/* I_SYS_TIME:
 *  This symbol, if defined, indicates to the C program that it should
 *  include <sys/time.h>.
 */
#$i_systime I_SYS_TIME      /**/

/* I_UNISTD:
 *  This symbol, if defined, indicates to the C program that it should
 *  include <unistd.h>.
 */
#$i_unistd I_UNISTD     /**/

/* I_STDARG:
 *  This symbol, if defined, indicates that <stdarg.h> exists and should
 *  be included.
 */
#$i_stdarg I_STDARG     /**/

/* Malloc_t:
 *  This symbol is the type of pointer returned by malloc and realloc.
 */
#define Malloc_t $malloctype            /**/

/* CAN_PROTOTYPE:
 *  If defined, this macro indicates that the C compiler can handle
 *  function prototypes.
 */
/* _:
 *  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[]));
 */
#$prototype CAN_PROTOTYPE   /**/
#ifdef CAN_PROTOTYPE
#define _(args) args
#else
#define _(args) ()
#endif

/* Size_t:
 *  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.
 */
#define Size_t $sizetype     /* length paramater for string functions */

/* VOIDFLAGS:
 *  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.
 */
#ifndef VOIDUSED
#define VOIDUSED $defvoidused
#endif
#define VOIDFLAGS $voidflags
#if (VOIDFLAGS & VOIDUSED) != VOIDUSED
#define void int        /* is void to be avoided? */
#define M_VOID          /* Xenix strikes again */
#endif

/* HAS_CRYPT:
 *  This symbol, if defined, indicates that the crypt routine is available
 *  to encrypt passwords and the like.
 */
#$d_crypt HAS_CRYPT     /**/

/* HAS_IEEE_MATH:
 *  Defined if the machine supports IEEE math - that is, can safely
 *  return NaN or Inf rather than crash on bad math.
 */
#$d_ieee HAS_IEEE_MATH /**/

/* SIGNALS_KEPT:
 *  This symbol is defined if signal handlers needn't be reinstated after
 *  receipt of a signal.
 */
#$d_keepsig SIGNALS_KEPT    /**/

/* HAS_MEMCPY:
 *  This symbol, if defined, indicates that the memcpy routine is available
 *  to copy blocks of memory. If not, it will be mapped to bcopy
 *  in confmagic.h
 */
#$d_memcpy HAS_MEMCPY   /**/

/* CAN_NEWSTYLE:
 *  Defined if new-style functions definitions are allowable.
 *  If they are, we can avoid some warnings that you get if
 *  you declare char arguments in a prototype and use old-style
 *  function definitions, which implicitly promote them to ints.
 */
#$d_newstyle CAN_NEWSTYLE /**/

/* HAS_RANDOM:
 *  Have we got random(), our first choice for number generation.
 */
/* HAS_LRAND48:
 *  Have we got lrand48(), our second choice.
 */
/* HAS_RAND:
 *  Have we got rand(), our last choice.
 */
#$d_random HAS_RANDOM   /**/
#$d_lrand48 HAS_LRAND48 /**/
#$d_rand HAS_RAND   /**/

/* HAS_GETRLIMIT:
 *  This symbol, if defined, indicates that the getrlimit() routine is
 *  available to get resource limits. Probably means setrlimit too.
 *  Inclusion of <sys/resource.h> and <sys/time.h> may be necessary.
 */
#$d_rlimit HAS_GETRLIMIT        /**/

/* HAS_STRCHR:
 *  This symbol is defined to indicate that the strchr()/strrchr()
 *  functions are available for string searching. If not, try the
 *  index()/rindex() pair.
 */
/* HAS_INDEX:
 *  This symbol is defined to indicate that the index()/rindex()
 *  functions are available for string searching.
 */
#$d_strchr HAS_STRCHR   /**/
#$d_index HAS_INDEX /**/

/* HAS_TIMELOCAL:
 *  This symbol, if defined, indicates that the timelocal() routine is
 *  available.
 */
#$d_timelocal HAS_TIMELOCAL     /**/

/* HAS_SAFE_TOUPPER:
 *  Defined if toupper() can operate safely on any ascii character.
 *  Some systems only allow toupper() on lower-case ascii chars.
 */
#$d_toupper HAS_SAFE_TOUPPER /**/

/* UPTIME_PATH:
 *  This symbol gives the full path to the uptime(1) program if
 *  it exists on the system. If not, this symbol is undefined.
 */
/* HAS_UPTIME:
 *  This symbol is defined if uptime(1) is available.
 */
#$d_uptime HAS_UPTIME   /**/
#define UPTIME_PATH "$uptime"

/* Free_t:
 *  This symbol is the type returned by free.
 */
/* INT_FREE:
 *  This symbol is defined if free(3) should return an int instead
 *  of void (like Sun's cc).
 */
#define Free_t $freetype        /**/
#$d_intfree INT_FREE            /**/

/* I_SYS_VLIMIT:
 *  This symbol, if defined, indicates to the C program that it should
 *  include <sys/vlimit.h>.
 */
#$i_sysvlimit I_SYS_VLIMIT      /**/

#endif
!GROK!THIS!