home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / perl-5.003-base.tgz / perl-5.003-base.tar / fsf / perl / config_h.SH < prev    next >
Text File  |  1996-03-25  |  50KB  |  1,598 lines
  1. case $CONFIG in
  2. '')
  3.     if test -f config.sh; then TOP=.;
  4.     elif test -f ../config.sh; then TOP=..;
  5.     elif test -f ../../config.sh; then TOP=../..;
  6.     elif test -f ../../../config.sh; then TOP=../../..;
  7.     elif test -f ../../../../config.sh; then TOP=../../../..;
  8.     else
  9.         echo "Can't find config.sh."; exit 1
  10.     fi
  11.     . $TOP/config.sh
  12.     ;;
  13. esac
  14. case "$0" in
  15. */*) cd `expr X$0 : 'X\(.*\)/'` ;;
  16. esac
  17. echo "Extracting config.h (with variable substitutions)"
  18. sed <<!GROK!THIS! >config.h -e 's!^#undef!/\*#define!' -e 's!^#un-def!#undef!'
  19. /*
  20.  * This file was produced by running the config_h.SH script, which
  21.  * gets its values from config.sh, which is generally produced by
  22.  * running Configure.
  23.  *
  24.  * Feel free to modify any of this as the need arises.  Note, however,
  25.  * that running config_h.SH again will wipe out any changes you've made.
  26.  * For a more permanent change edit config.sh and rerun config_h.SH.
  27.  *
  28.  * \$Id: Config_h.U,v 3.0.1.4 1995/09/25 09:10:49 ram Exp $
  29.  */
  30.  
  31. /* Configuration time: $cf_time
  32.  * Configured by: $cf_by
  33.  * Target system: $myuname
  34.  */
  35.  
  36. #ifndef _config_h_
  37. #define _config_h_
  38.  
  39. /* MEM_ALIGNBYTES:
  40.  *    This symbol contains the number of bytes required to align a
  41.  *    double. Usual values are 2, 4 and 8.
  42.  */
  43. #define MEM_ALIGNBYTES $alignbytes    /**/
  44.  
  45. /* BIN:
  46.  *    This symbol holds the path of the bin directory where the package will
  47.  *    be installed. Program must be prepared to deal with ~name substitution.
  48.  */
  49. #define BIN "$bin"    /**/
  50.  
  51. /* CAT2:
  52.  *    This macro catenates 2 tokens together.
  53.  */
  54. #if $cpp_stuff == 1
  55. #define CAT2(a,b)a/**/b
  56. #define CAT3(a,b,c)a/**/b/**/c
  57. #define CAT4(a,b,c,d)a/**/b/**/c/**/d
  58. #define CAT5(a,b,c,d,e)a/**/b/**/c/**/d/**/e
  59. #define STRINGIFY(a)"a"
  60.         /* If you can get stringification with catify, tell me how! */
  61. #endif
  62. #if $cpp_stuff == 42
  63. #define CAT2(a,b)a ## b
  64. #define CAT3(a,b,c)a ## b ## c
  65. #define CAT4(a,b,c,d)a ## b ## c ## d
  66. #define CAT5(a,b,c,d,e)a ## b ## c ## d ## e
  67. #define StGiFy(a)# a
  68. #define STRINGIFY(a)StGiFy(a)
  69. #define SCAT2(a,b)StGiFy(a) StGiFy(b)
  70. #define SCAT3(a,b,c)StGiFy(a) StGiFy(b) StGiFy(c)
  71. #define SCAT4(a,b,c,d)StGiFy(a) StGiFy(b) StGiFy(c) StGiFy(d)
  72. #define SCAT5(a,b,c,d,e)StGiFy(a) StGiFy(b) StGiFy(c) StGiFy(d) StGiFy(e)
  73. #endif
  74. #ifndef CAT2
  75. #include "Bletch: How does this C preprocessor catenate tokens?"
  76. #endif
  77.  
  78. /* CPPSTDIN:
  79.  *    This symbol contains the first part of the string which will invoke
  80.  *    the C preprocessor on the standard input and produce to standard
  81.  *    output.     Typical value of "cc -E" or "/lib/cpp", but it can also
  82.  *    call a wrapper. See CPPRUN.
  83.  */
  84. /* CPPMINUS:
  85.  *    This symbol contains the second part of the string which will invoke
  86.  *    the C preprocessor on the standard input and produce to standard
  87.  *    output.  This symbol will have the value "-" if CPPSTDIN needs a minus
  88.  *    to specify standard input, otherwise the value is "".
  89.  */
  90. #define CPPSTDIN "$cppstdin"
  91. #define CPPMINUS "$cppminus"
  92.  
  93. /* HAS_ALARM:
  94.  *    This symbol, if defined, indicates that the alarm routine is
  95.  *    available.
  96.  */
  97. #$d_alarm HAS_ALARM        /**/
  98.  
  99. /* HASATTRIBUTE:
  100.  *    This symbol indicates the C compiler can check for function attributes,
  101.  *    such as printf formats. This is normally only supported by GNU cc.
  102.  */
  103. #$d_attribut HASATTRIBUTE     /**/
  104. #ifndef HASATTRIBUTE
  105. #define __attribute__(_arg_)
  106. #endif
  107.  
  108. /* HAS_BCMP:
  109.  *    This symbol is defined if the bcmp() routine is available to
  110.  *    compare blocks of memory.
  111.  */
  112. #$d_bcmp HAS_BCMP    /**/
  113.  
  114. /* HAS_BCOPY:
  115.  *    This symbol is defined if the bcopy() routine is available to
  116.  *    copy blocks of memory.
  117.  */
  118. #$d_bcopy HAS_BCOPY    /**/
  119.  
  120. /* HAS_BZERO:
  121.  *    This symbol is defined if the bzero() routine is available to
  122.  *    set a memory block to 0.
  123.  */
  124. #$d_bzero HAS_BZERO    /**/
  125.  
  126. /* CASTI32:
  127.  *    This symbol is defined if the C compiler can cast negative
  128.  *    or large floating point numbers to 32-bit ints.
  129.  */
  130. #$d_casti32    CASTI32        /**/
  131.  
  132. /* CASTNEGFLOAT:
  133.  *    This symbol is defined if the C compiler can cast negative
  134.  *    numbers to unsigned longs, ints and shorts.
  135.  */
  136. /* CASTFLAGS:
  137.  *    This symbol contains flags that say what difficulties the compiler
  138.  *    has casting odd floating values to unsigned long:
  139.  *        0 = ok
  140.  *        1 = couldn't cast < 0
  141.  *        2 = couldn't cast >= 0x80000000
  142.  *        4 = couldn't cast in argument expression list
  143.  */
  144. #$d_castneg    CASTNEGFLOAT        /**/
  145. #define CASTFLAGS $castflags        /**/
  146.  
  147. /* HAS_CHOWN:
  148.  *    This symbol, if defined, indicates that the chown routine is
  149.  *    available.
  150.  */
  151. #$d_chown HAS_CHOWN        /**/
  152.  
  153. /* HAS_CHROOT:
  154.  *    This symbol, if defined, indicates that the chroot routine is
  155.  *    available.
  156.  */
  157. #$d_chroot HAS_CHROOT        /**/
  158.  
  159. /* HAS_CHSIZE:
  160.  *    This symbol, if defined, indicates that the chsize routine is available
  161.  *    to truncate files.  You might need a -lx to get this routine.
  162.  */
  163. #$d_chsize    HAS_CHSIZE        /**/
  164.  
  165. /* VOID_CLOSEDIR:
  166.  *    This symbol, if defined, indicates that the closedir() routine
  167.  *    does not return a value.
  168.  */
  169. #$d_void_closedir VOID_CLOSEDIR        /**/
  170.  
  171. /* HASCONST:
  172.  *    This symbol, if defined, indicates that this C compiler knows about
  173.  *    the const type. There is no need to actually test for that symbol
  174.  *    within your programs. The mere use of the "const" keyword will
  175.  *    trigger the necessary tests.
  176.  */
  177. #$d_const HASCONST    /**/
  178. #ifndef HASCONST
  179. #define const
  180. #endif
  181.  
  182. /* HAS_CRYPT:
  183.  *    This symbol, if defined, indicates that the crypt routine is available
  184.  *    to encrypt passwords and the like.
  185.  */
  186. #$d_crypt HAS_CRYPT        /**/
  187.  
  188. /* HAS_CUSERID:
  189.  *    This symbol, if defined, indicates that the cuserid routine is
  190.  *    available to get character login names.
  191.  */
  192. #$d_cuserid HAS_CUSERID        /**/
  193.  
  194. /* HAS_DBL_DIG:
  195.  *    This symbol, if defined, indicates that this system's <float.h>
  196.  *    or <limits.h> defines the symbol DBL_DIG, which is the number
  197.  *    of significant digits in a double precision number.  If this
  198.  *    symbol is not defined, a guess of 15 is usually pretty good.
  199.  */
  200. #$d_dbl_dig HAS_DBL_DIG     /* */
  201.  
  202. /* HAS_DIFFTIME:
  203.  *    This symbol, if defined, indicates that the difftime routine is
  204.  *    available.
  205.  */
  206. #$d_difftime HAS_DIFFTIME        /**/
  207.  
  208. /* HAS_DLERROR:
  209.  *    This symbol, if defined, indicates that the dlerror routine is
  210.  *    available to return a string describing the last error that
  211.  *    occurred from a call to dlopen(), dlclose() or dlsym().
  212.  */
  213. #$d_dlerror HAS_DLERROR    /**/
  214.  
  215. /* HAS_DUP2:
  216.  *    This symbol, if defined, indicates that the dup2 routine is
  217.  *    available to duplicate file descriptors.
  218.  */
  219. #$d_dup2 HAS_DUP2    /**/
  220.  
  221. /* HAS_FCHMOD:
  222.  *    This symbol, if defined, indicates that the fchmod routine is available
  223.  *    to change mode of opened files.  If unavailable, use chmod().
  224.  */
  225. #$d_fchmod HAS_FCHMOD        /**/
  226.  
  227. /* HAS_FCHOWN:
  228.  *    This symbol, if defined, indicates that the fchown routine is available
  229.  *    to change ownership of opened files.  If unavailable, use chown().
  230.  */
  231. #$d_fchown HAS_FCHOWN        /**/
  232.  
  233. /* HAS_FCNTL:
  234.  *    This symbol, if defined, indicates to the C program that
  235.  *    the fcntl() function exists.
  236.  */
  237. #$d_fcntl HAS_FCNTL        /**/
  238.  
  239. /* HAS_FGETPOS:
  240.  *    This symbol, if defined, indicates that the fgetpos routine is
  241.  *    available to get the file position indicator, similar to ftell().
  242.  */
  243. #$d_fgetpos HAS_FGETPOS    /**/
  244.  
  245. /* FLEXFILENAMES:
  246.  *    This symbol, if defined, indicates that the system supports filenames
  247.  *    longer than 14 characters.
  248.  */
  249. #$d_flexfnam    FLEXFILENAMES        /**/
  250.  
  251. /* HAS_FLOCK:
  252.  *    This symbol, if defined, indicates that the flock routine is
  253.  *    available to do file locking.
  254.  */
  255. #$d_flock HAS_FLOCK        /**/
  256.  
  257. /* HAS_FORK:
  258.  *    This symbol, if defined, indicates that the fork routine is
  259.  *    available.
  260.  */
  261. #$d_fork HAS_FORK        /**/
  262.  
  263. /* HAS_FSETPOS:
  264.  *    This symbol, if defined, indicates that the fsetpos routine is
  265.  *    available to set the file position indicator, similar to fseek().
  266.  */
  267. #$d_fsetpos HAS_FSETPOS    /**/
  268.  
  269. /* HAS_GETGROUPS:
  270.  *    This symbol, if defined, indicates that the getgroups() routine is
  271.  *    available to get the list of process groups.  If unavailable, multiple
  272.  *    groups are probably not supported.
  273.  */
  274. #$d_getgrps HAS_GETGROUPS        /**/
  275.  
  276. /* HAS_GETHOSTENT:
  277.  *    This symbol, if defined, indicates that the gethostent routine is
  278.  *    available to lookup host names in some data base or other.
  279.  */
  280. #$d_gethent HAS_GETHOSTENT        /**/
  281.  
  282. /* HAS_UNAME:
  283.  *    This symbol, if defined, indicates that the C program may use the
  284.  *    uname() routine to derive the host name.  See also HAS_GETHOSTNAME
  285.  *    and PHOSTNAME.
  286.  */
  287. #$d_uname HAS_UNAME        /**/
  288.  
  289. /* HAS_GETLOGIN:
  290.  *    This symbol, if defined, indicates that the getlogin routine is
  291.  *    available to get the login name.
  292.  */
  293. #$d_getlogin HAS_GETLOGIN        /**/
  294.  
  295. /* HAS_GETPGRP:
  296.  *    This symbol, if defined, indicates that the getpgrp routine is
  297.  *    available to get the current process group.
  298.  */
  299. #$d_getpgrp HAS_GETPGRP        /**/
  300.  
  301. /* HAS_GETPGRP2:
  302.  *    This symbol, if defined, indicates that the getpgrp2() (as in DG/UX)
  303.  *    routine is available to get the current process group.
  304.  */
  305. #$d_getpgrp2 HAS_GETPGRP2        /**/
  306.  
  307. /* HAS_GETPPID:
  308.  *    This symbol, if defined, indicates that the getppid routine is
  309.  *    available to get the parent process ID.
  310.  */
  311. #$d_getppid HAS_GETPPID        /**/
  312.  
  313. /* HAS_GETPRIORITY:
  314.  *    This symbol, if defined, indicates that the getpriority routine is
  315.  *    available to get a process's priority.
  316.  */
  317. #$d_getprior HAS_GETPRIORITY        /**/
  318.  
  319. /* HAS_HTONL:
  320.  *    This symbol, if defined, indicates that the htonl() routine (and
  321.  *    friends htons() ntohl() ntohs()) are available to do network
  322.  *    order byte swapping.
  323.  */
  324. /* HAS_HTONS:
  325.  *    This symbol, if defined, indicates that the htons() routine (and
  326.  *    friends htonl() ntohl() ntohs()) are available to do network
  327.  *    order byte swapping.
  328.  */
  329. /* HAS_NTOHL:
  330.  *    This symbol, if defined, indicates that the ntohl() routine (and
  331.  *    friends htonl() htons() ntohs()) are available to do network
  332.  *    order byte swapping.
  333.  */
  334. /* HAS_NTOHS:
  335.  *    This symbol, if defined, indicates that the ntohs() routine (and
  336.  *    friends htonl() htons() ntohl()) are available to do network
  337.  *    order byte swapping.
  338.  */
  339. #$d_htonl HAS_HTONL        /**/
  340. #$d_htonl HAS_HTONS        /**/
  341. #$d_htonl HAS_NTOHL        /**/
  342. #$d_htonl HAS_NTOHS        /**/
  343.  
  344. /* HAS_ISASCII:
  345.  *    This manifest constant lets the C program know that isascii 
  346.  *    is available.
  347.  */
  348. #$d_isascii HAS_ISASCII        /**/
  349.  
  350. /* HAS_KILLPG:
  351.  *    This symbol, if defined, indicates that the killpg routine is available
  352.  *    to kill process groups.  If unavailable, you probably should use kill
  353.  *    with a negative process number.
  354.  */
  355. #$d_killpg HAS_KILLPG    /**/
  356.  
  357. /* HAS_LINK:
  358.  *    This symbol, if defined, indicates that the link routine is
  359.  *    available to create hard links.
  360.  */
  361. #$d_link HAS_LINK    /**/
  362.  
  363. /* HAS_LOCALECONV:
  364.  *    This symbol, if defined, indicates that the localeconv routine is
  365.  *    available for numeric and monetary formatting conventions.
  366.  */
  367. #$d_locconv HAS_LOCALECONV    /**/
  368.  
  369. /* HAS_LOCKF:
  370.  *    This symbol, if defined, indicates that the lockf routine is
  371.  *    available to do file locking.
  372.  */
  373. #$d_lockf HAS_LOCKF        /**/
  374.  
  375. /* HAS_LSTAT:
  376.  *    This symbol, if defined, indicates that the lstat routine is
  377.  *    available to do file stats on symbolic links.
  378.  */
  379. #$d_lstat HAS_LSTAT        /**/
  380.  
  381. /* HAS_MBLEN:
  382.  *    This symbol, if defined, indicates that the mblen routine is available
  383.  *    to find the number of bytes in a multibye character.
  384.  */
  385. #$d_mblen HAS_MBLEN        /**/
  386.  
  387. /* HAS_MBSTOWCS:
  388.  *    This symbol, if defined, indicates that the mbstowcs routine is
  389.  *    available to covert a multibyte string into a wide character string.
  390.  */
  391. #$d_mbstowcs    HAS_MBSTOWCS        /**/
  392.  
  393. /* HAS_MBTOWC:
  394.  *    This symbol, if defined, indicates that the mbtowc routine is available
  395.  *    to covert a multibyte to a wide character.
  396.  */
  397. #$d_mbtowc HAS_MBTOWC        /**/
  398.  
  399. /* HAS_MEMCMP:
  400.  *    This symbol, if defined, indicates that the memcmp routine is available
  401.  *    to compare blocks of memory.
  402.  */
  403. #$d_memcmp HAS_MEMCMP    /**/
  404.  
  405. /* HAS_MEMCPY:
  406.  *    This symbol, if defined, indicates that the memcpy routine is available
  407.  *    to copy blocks of memory.
  408.  */
  409. #$d_memcpy HAS_MEMCPY    /**/
  410.  
  411. /* HAS_MEMMOVE:
  412.  *    This symbol, if defined, indicates that the memmove routine is available
  413.  *    to copy potentially overlapping blocks of memory. This should be used
  414.  *    only when HAS_SAFE_BCOPY is not defined. If neither is there, roll your
  415.  *    own version.
  416.  */
  417. #$d_memmove HAS_MEMMOVE    /**/
  418.  
  419. /* HAS_MEMSET:
  420.  *    This symbol, if defined, indicates that the memset routine is available
  421.  *    to set blocks of memory.
  422.  */
  423. #$d_memset HAS_MEMSET    /**/
  424.  
  425. /* HAS_MKDIR:
  426.  *    This symbol, if defined, indicates that the mkdir routine is available
  427.  *    to create directories.  Otherwise you should fork off a new process to
  428.  *    exec /bin/mkdir.
  429.  */
  430. #$d_mkdir HAS_MKDIR        /**/
  431.  
  432. /* HAS_MKFIFO:
  433.  *    This symbol, if defined, indicates that the mkfifo routine is
  434.  *    available to create FIFOs. Otherwise, mknod should be able to
  435.  *    do it for you. However, if mkfifo is there, mknod might require
  436.  *    super-user privileges which mkfifo will not.
  437.  */
  438. #$d_mkfifo HAS_MKFIFO        /**/
  439.  
  440. /* HAS_MKTIME:
  441.  *    This symbol, if defined, indicates that the mktime routine is
  442.  *    available.
  443.  */
  444. #$d_mktime HAS_MKTIME        /**/
  445.  
  446. /* HAS_MSG:
  447.  *    This symbol, if defined, indicates that the entire msg*(2) library is
  448.  *    supported (IPC mechanism based on message queues).
  449.  */
  450. #$d_msg HAS_MSG        /**/
  451.  
  452. /* HAS_NICE:
  453.  *    This symbol, if defined, indicates that the nice routine is
  454.  *    available.
  455.  */
  456. #$d_nice HAS_NICE        /**/
  457.  
  458. /* HAS_OPEN3:
  459.  *    This manifest constant lets the C program know that the three
  460.  *    argument form of open(2) is available.
  461.  */
  462. #$d_open3 HAS_OPEN3        /**/
  463.  
  464. /* HAS_PATHCONF:
  465.  *    This symbol, if defined, indicates that pathconf() is available
  466.  *    to determine file-system related limits and options associated
  467.  *    with a given filename.
  468.  */
  469. /* HAS_FPATHCONF:
  470.  *    This symbol, if defined, indicates that pathconf() is available
  471.  *    to determine file-system related limits and options associated
  472.  *    with a given open file descriptor.
  473.  */
  474. #$d_pathconf HAS_PATHCONF        /**/
  475. #$d_fpathconf HAS_FPATHCONF        /**/
  476.  
  477. /* HAS_PAUSE:
  478.  *    This symbol, if defined, indicates that the pause routine is
  479.  *    available to suspend a process until a signal is received.
  480.  */
  481. #$d_pause HAS_PAUSE        /**/
  482.  
  483. /* HAS_PIPE:
  484.  *    This symbol, if defined, indicates that the pipe routine is
  485.  *    available to create an inter-process channel.
  486.  */
  487. #$d_pipe HAS_PIPE        /**/
  488.  
  489. /* HAS_POLL:
  490.  *    This symbol, if defined, indicates that the poll routine is
  491.  *    available to poll active file descriptors.
  492.  */
  493. #$d_poll HAS_POLL        /**/
  494.  
  495. /* HAS_READDIR:
  496.  *    This symbol, if defined, indicates that the readdir routine is
  497.  *    available to read directory entries. You may have to include
  498.  *    <dirent.h>. See I_DIRENT.
  499.  */
  500. #$d_readdir HAS_READDIR        /**/
  501.  
  502. /* HAS_SEEKDIR:
  503.  *    This symbol, if defined, indicates that the seekdir routine is
  504.  *    available. You may have to include <dirent.h>. See I_DIRENT.
  505.  */
  506. #$d_seekdir HAS_SEEKDIR        /**/
  507.  
  508. /* HAS_TELLDIR:
  509.  *    This symbol, if defined, indicates that the telldir routine is
  510.  *    available. You may have to include <dirent.h>. See I_DIRENT.
  511.  */
  512. #$d_telldir HAS_TELLDIR        /**/
  513.  
  514. /* HAS_REWINDDIR:
  515.  *    This symbol, if defined, indicates that the rewinddir routine is
  516.  *    available. You may have to include <dirent.h>. See I_DIRENT.
  517.  */
  518. #$d_rewinddir HAS_REWINDDIR        /**/
  519.  
  520. /* HAS_READLINK:
  521.  *    This symbol, if defined, indicates that the readlink routine is
  522.  *    available to read the value of a symbolic link.
  523.  */
  524. #$d_readlink HAS_READLINK        /**/
  525.  
  526. /* HAS_RENAME:
  527.  *    This symbol, if defined, indicates that the rename routine is available
  528.  *    to rename files.  Otherwise you should do the unlink(), link(), unlink()
  529.  *    trick.
  530.  */
  531. #$d_rename HAS_RENAME    /**/
  532.  
  533. /* HAS_RMDIR:
  534.  *    This symbol, if defined, indicates that the rmdir routine is
  535.  *    available to remove directories. Otherwise you should fork off a
  536.  *    new process to exec /bin/rmdir.
  537.  */
  538. #$d_rmdir HAS_RMDIR        /**/
  539.  
  540. /* HAS_SAFE_BCOPY:
  541.  *    This symbol, if defined, indicates that the bcopy routine is available
  542.  *    to copy potentially overlapping memory blocks. Otherwise you should
  543.  *    probably use memmove() or memcpy(). If neither is defined, roll your
  544.  *    own version.
  545.  */
  546. #$d_safebcpy HAS_SAFE_BCOPY    /**/
  547.  
  548. /* HAS_SAFE_MEMCPY:
  549.  *    This symbol, if defined, indicates that the memcpy routine is available
  550.  *    to copy potentially overlapping memory blocks. Otherwise you should
  551.  *    probably use memmove() or memcpy(). If neither is defined, roll your
  552.  *    own version.
  553.  */
  554. #$d_safemcpy HAS_SAFE_MEMCPY    /**/
  555.  
  556. /* HAS_SELECT:
  557.  *    This symbol, if defined, indicates that the select routine is
  558.  *    available to select active file descriptors. If the timeout field
  559.  *    is used, <sys/time.h> may need to be included.
  560.  */
  561. #$d_select HAS_SELECT    /**/
  562.  
  563. /* HAS_SEM:
  564.  *    This symbol, if defined, indicates that the entire sem*(2) library is
  565.  *    supported.
  566.  */
  567. #$d_sem HAS_SEM        /**/
  568.  
  569. /* HAS_SETEGID:
  570.  *    This symbol, if defined, indicates that the setegid routine is available
  571.  *    to change the effective gid of the current program.
  572.  */
  573. #$d_setegid HAS_SETEGID        /**/
  574.  
  575. /* HAS_SETEUID:
  576.  *    This symbol, if defined, indicates that the seteuid routine is available
  577.  *    to change the effective uid of the current program.
  578.  */
  579. #$d_seteuid HAS_SETEUID        /**/
  580.  
  581. /* HAS_SETLINEBUF:
  582.  *    This symbol, if defined, indicates that the setlinebuf routine is
  583.  *    available to change stderr or stdout from block-buffered or unbuffered
  584.  *    to a line-buffered mode.
  585.  */
  586. #$d_setlinebuf HAS_SETLINEBUF        /**/
  587.  
  588. /* HAS_SETLOCALE:
  589.  *    This symbol, if defined, indicates that the setlocale routine is
  590.  *    available to handle locale-specific ctype implementations.
  591.  */
  592. #$d_setlocale HAS_SETLOCALE    /**/
  593.  
  594. /* HAS_SETPGID:
  595.  *    This symbol, if defined, indicates that the setpgid routine is
  596.  *    available to set process group ID.
  597.  */
  598. #$d_setpgid HAS_SETPGID    /**/
  599.  
  600. /* HAS_SETPGRP:
  601.  *    This symbol, if defined, indicates that the setpgrp routine is
  602.  *    available to set the current process group.
  603.  */
  604. /* USE_BSDPGRP:
  605.  *    This symbol, if defined, indicates that the BSD notion of process
  606.  *    group is to be used. For instance, you have to say setpgrp(pid, pgrp)
  607.  *    instead of the USG setpgrp().
  608.  */
  609. #$d_setpgrp HAS_SETPGRP        /**/
  610. #$d_bsdpgrp USE_BSDPGRP        /**/
  611.  
  612. /* HAS_SETPGRP2:
  613.  *    This symbol, if defined, indicates that the setpgrp2() (as in DG/UX)
  614.  *    routine is available to set the current process group.
  615.  */
  616. #$d_setpgrp2 HAS_SETPGRP2        /**/
  617.  
  618. /* HAS_SETPRIORITY:
  619.  *    This symbol, if defined, indicates that the setpriority routine is
  620.  *    available to set a process's priority.
  621.  */
  622. #$d_setprior HAS_SETPRIORITY        /**/
  623.  
  624. /* HAS_SETREGID:
  625.  *    This symbol, if defined, indicates that the setregid routine is
  626.  *    available to change the real and effective gid of the current
  627.  *    process.
  628.  */
  629. /* HAS_SETRESGID:
  630.  *    This symbol, if defined, indicates that the setresgid routine is
  631.  *    available to change the real, effective and saved gid of the current
  632.  *    process.
  633.  */
  634. #$d_setregid HAS_SETREGID        /**/
  635. #$d_setresgid HAS_SETRESGID        /**/
  636.  
  637. /* HAS_SETREUID:
  638.  *    This symbol, if defined, indicates that the setreuid routine is
  639.  *    available to change the real and effective uid of the current
  640.  *    process.
  641.  */
  642. /* HAS_SETRESUID:
  643.  *    This symbol, if defined, indicates that the setresuid routine is
  644.  *    available to change the real, effective and saved uid of the current
  645.  *    process.
  646.  */
  647. #$d_setreuid HAS_SETREUID        /**/
  648. #$d_setresuid HAS_SETRESUID        /**/
  649.  
  650. /* HAS_SETRGID:
  651.  *    This symbol, if defined, indicates that the setrgid routine is available
  652.  *    to change the real gid of the current program.
  653.  */
  654. #$d_setrgid HAS_SETRGID        /**/
  655.  
  656. /* HAS_SETRUID:
  657.  *    This symbol, if defined, indicates that the setruid routine is available
  658.  *    to change the real uid of the current program.
  659.  */
  660. #$d_setruid HAS_SETRUID        /**/
  661.  
  662. /* HAS_SETSID:
  663.  *    This symbol, if defined, indicates that the setsid routine is
  664.  *    available to set the process group ID.
  665.  */
  666. #$d_setsid HAS_SETSID    /**/
  667.  
  668. /* HAS_SHM:
  669.  *    This symbol, if defined, indicates that the entire shm*(2) library is
  670.  *    supported.
  671.  */
  672. #$d_shm HAS_SHM        /**/
  673.  
  674. /* Shmat_t:
  675.  *    This symbol holds the return type of the shmat() system call.
  676.  *    Usually set to 'void *' or 'char *'.
  677.  */
  678. /* HAS_SHMAT_PROTOTYPE:
  679.  *    This symbol, if defined, indicates that the sys/shm.h includes
  680.  *    a prototype for shmat().  Otherwise, it is up to the program to
  681.  *    guess one.  Shmat_t shmat _((int, Shmat_t, int)) is a good guess,
  682.  *    but not always right so it should be emitted by the program only
  683.  *    when HAS_SHMAT_PROTOTYPE is not defined to avoid conflicting defs.
  684.  */
  685. #define Shmat_t $shmattype    /**/
  686. #$d_shmatprototype HAS_SHMAT_PROTOTYPE    /**/
  687.  
  688. /* HAS_SIGACTION:
  689.  *    This symbol, if defined, indicates that Vr4's sigaction() routine
  690.  *    is available.
  691.  */
  692. #$d_sigaction HAS_SIGACTION    /**/
  693.  
  694. /* HAS_SOCKET:
  695.  *    This symbol, if defined, indicates that the BSD socket interface is
  696.  *    supported.
  697.  */
  698. /* HAS_SOCKETPAIR:
  699.  *    This symbol, if defined, indicates that the BSD socketpair() call is
  700.  *    supported.
  701.  */
  702. #$d_socket HAS_SOCKET        /**/
  703. #$d_sockpair HAS_SOCKETPAIR    /**/
  704.  
  705. /* USE_STAT_BLOCKS:
  706.  *    This symbol is defined if this system has a stat structure declaring
  707.  *    st_blksize and st_blocks.
  708.  */
  709. #$d_statblks USE_STAT_BLOCKS     /**/
  710.  
  711. /* USE_STDIO_PTR:
  712.  *    This symbol is defined if the _ptr and _cnt fields (or similar)
  713.  *    of the stdio FILE structure can be used to access the stdio buffer
  714.  *    for a file handle.  If this is defined, then the FILE_ptr(fp)
  715.  *    and FILE_cnt(fp) macros will also be defined and should be used
  716.  *    to access these fields.
  717.  */
  718. /* USE_STDIO_BASE:
  719.  *    This symbol is defined if the _base field (or similar) of the
  720.  *    stdio FILE structure can be used to access the stdio buffer for
  721.  *    a file handle.  If this is defined, then the FILE_base(fp) macro
  722.  *    will also be defined and should be used to access this field.
  723.  *    Also, the FILE_bufsiz(fp) macro will be defined and should be used
  724.  *    to determine the number of bytes in the buffer.  USE_STDIO_BASE
  725.  *    will never be defined unless USE_STDIO_PTR is.
  726.  */
  727. #$d_stdstdio USE_STDIO_PTR     /**/
  728. #$d_stdiobase USE_STDIO_BASE     /**/
  729.  
  730. /* FILE_ptr:
  731.  *    This macro is used to access the _ptr field (or equivalent) of the
  732.  *    FILE structure pointed to by its argument. This macro will always be
  733.  *    defined if USE_STDIO_PTR is defined.
  734.  */
  735. /* STDIO_PTR_LVALUE:
  736.  *    This symbol is defined if the FILE_ptr macro can be used as an
  737.  *    lvalue.
  738.  */
  739. /* FILE_cnt:
  740.  *    This macro is used to access the _cnt field (or equivalent) of the
  741.  *    FILE structure pointed to by its argument. This macro will always be
  742.  *    defined if USE_STDIO_PTR is defined.
  743.  */
  744. /* STDIO_CNT_LVALUE:
  745.  *    This symbol is defined if the FILE_cnt macro can be used as an
  746.  *    lvalue.
  747.  */
  748. #ifdef USE_STDIO_PTR
  749. #define FILE_ptr(fp)    $stdio_ptr
  750. #$d_stdio_ptr_lval STDIO_PTR_LVALUE         /**/
  751. #define FILE_cnt(fp)    $stdio_cnt
  752. #$d_stdio_cnt_lval STDIO_CNT_LVALUE         /**/
  753. #endif
  754.  
  755. /* FILE_base:
  756.  *    This macro is used to access the _base field (or equivalent) of the
  757.  *    FILE structure pointed to by its argument. This macro will always be
  758.  *    defined if USE_STDIO_BASE is defined.
  759.  */
  760. /* FILE_bufsiz:
  761.  *    This macro is used to determine the number of bytes in the I/O
  762.  *    buffer pointed to by _base field (or equivalent) of the FILE
  763.  *    structure pointed to its argument. This macro will always be defined
  764.  *    if USE_STDIO_BASE is defined.
  765.  */
  766. #ifdef USE_STDIO_BASE
  767. #define FILE_base(fp)    $stdio_base
  768. #define FILE_bufsiz(fp)    $stdio_bufsiz
  769. #endif
  770.  
  771. /* HAS_STRCHR:
  772.  *    This symbol is defined to indicate that the strchr()/strrchr()
  773.  *    functions are available for string searching. If not, try the
  774.  *    index()/rindex() pair.
  775.  */
  776. /* HAS_INDEX:
  777.  *    This symbol is defined to indicate that the index()/rindex()
  778.  *    functions are available for string searching.
  779.  */
  780. #$d_strchr HAS_STRCHR    /**/
  781. #$d_index HAS_INDEX    /**/
  782.  
  783. /* HAS_STRCOLL:
  784.  *    This symbol, if defined, indicates that the strcoll routine is
  785.  *    available to compare strings using collating information.
  786.  */
  787. #$d_strcoll HAS_STRCOLL    /**/
  788.  
  789. /* USE_STRUCT_COPY:
  790.  *    This symbol, if defined, indicates that this C compiler knows how
  791.  *    to copy structures.  If undefined, you'll need to use a block copy
  792.  *    routine of some sort instead.
  793.  */
  794. #$d_strctcpy    USE_STRUCT_COPY    /**/
  795.  
  796. /* HAS_STRERROR:
  797.  *    This symbol, if defined, indicates that the strerror routine is
  798.  *    available to translate error numbers to strings. See the writeup
  799.  *    of Strerror() in this file before you try to define your own.
  800.  */
  801. /* HAS_SYS_ERRLIST:
  802.  *    This symbol, if defined, indicates that the sys_errlist array is
  803.  *    available to translate error numbers to strings. The extern int
  804.  *    sys_nerr gives the size of that table.
  805.  */
  806. /* Strerror:
  807.  *    This preprocessor symbol is defined as a macro if strerror() is
  808.  *    not available to translate error numbers to strings but sys_errlist[]
  809.  *    array is there.
  810.  */
  811. #$d_strerror HAS_STRERROR        /**/
  812. #$d_syserrlst HAS_SYS_ERRLIST    /**/
  813. #define Strerror(e) $d_strerrm
  814.  
  815. /* HAS_STRXFRM:
  816.  *    This symbol, if defined, indicates that the strxfrm() routine is
  817.  *    available to transform strings.
  818.  */
  819. #$d_strxfrm HAS_STRXFRM    /**/
  820.  
  821. /* HAS_SYMLINK:
  822.  *    This symbol, if defined, indicates that the symlink routine is available
  823.  *    to create symbolic links.
  824.  */
  825. #$d_symlink HAS_SYMLINK    /**/
  826.  
  827. /* HAS_SYSCALL:
  828.  *    This symbol, if defined, indicates that the syscall routine is
  829.  *    available to call arbitrary system calls. If undefined, that's tough.
  830.  */
  831. #$d_syscall HAS_SYSCALL    /**/
  832.  
  833. /* HAS_SYSCONF:
  834.  *    This symbol, if defined, indicates that sysconf() is available
  835.  *    to determine system related limits and options.
  836.  */
  837. #$d_sysconf HAS_SYSCONF    /**/
  838.  
  839. /* HAS_SYSTEM:
  840.  *    This symbol, if defined, indicates that the system routine is
  841.  *    available to issue a shell command.
  842.  */
  843. #$d_system HAS_SYSTEM    /**/
  844.  
  845. /* HAS_TCGETPGRP:
  846.  *    This symbol, if defined, indicates that the tcgetpgrp routine is
  847.  *    available to get foreground process group ID.
  848.  */
  849. #$d_tcgetpgrp HAS_TCGETPGRP        /**/
  850.  
  851. /* HAS_TCSETPGRP:
  852.  *    This symbol, if defined, indicates that the tcsetpgrp routine is
  853.  *    available to set foreground process group ID.
  854.  */
  855. #$d_tcsetpgrp HAS_TCSETPGRP        /**/
  856.  
  857. /* Time_t:
  858.  *    This symbol holds the type returned by time(). It can be long,
  859.  *    or time_t on BSD sites (in which case <sys/types.h> should be
  860.  *    included).
  861.  */
  862. #define Time_t $timetype        /* Time type */
  863.  
  864. /* HAS_TIMES:
  865.  *    This symbol, if defined, indicates that the times() routine exists.
  866.  *    Note that this became obsolete on some systems (SUNOS), which now
  867.  * use getrusage(). It may be necessary to include <sys/times.h>.
  868.  */
  869. #$d_times HAS_TIMES        /**/
  870.  
  871. /* HAS_TRUNCATE:
  872.  *    This symbol, if defined, indicates that the truncate routine is
  873.  *    available to truncate files.
  874.  */
  875. #$d_truncate HAS_TRUNCATE    /**/
  876.  
  877. /* HAS_TZNAME:
  878.  *    This symbol, if defined, indicates that the tzname[] array is
  879.  *    available to access timezone names.
  880.  */
  881. #$d_tzname HAS_TZNAME        /**/
  882.  
  883. /* HAS_UMASK:
  884.  *    This symbol, if defined, indicates that the umask routine is
  885.  *    available to set and get the value of the file creation mask.
  886.  */
  887. #$d_umask HAS_UMASK        /**/
  888.  
  889. /* HAS_VFORK:
  890.  *    This symbol, if defined, indicates that vfork() exists.
  891.  */
  892. #$d_vfork HAS_VFORK    /**/
  893.  
  894. /* Signal_t:
  895.  *    This symbol's value is either "void" or "int", corresponding to the
  896.  *    appropriate return type of a signal handler.  Thus, you can declare
  897.  *    a signal handler using "Signal_t (*handler)()", and define the
  898.  *    handler using "Signal_t handler(sig)".
  899.  */
  900. #define Signal_t $signal_t    /* Signal handler's return type */
  901.  
  902. /* HASVOLATILE:
  903.  *    This symbol, if defined, indicates that this C compiler knows about
  904.  *    the volatile declaration.
  905.  */
  906. #$d_volatile    HASVOLATILE    /**/
  907. #ifndef HASVOLATILE
  908. #define volatile
  909. #endif
  910.  
  911. /* HAS_VPRINTF:
  912.  *    This symbol, if defined, indicates that the vprintf routine is available
  913.  *    to printf with a pointer to an argument list.  If unavailable, you
  914.  *    may need to write your own, probably in terms of _doprnt().
  915.  */
  916. /* USE_CHAR_VSPRINTF:
  917.  *    This symbol is defined if this system has vsprintf() returning type
  918.  *    (char*).  The trend seems to be to declare it as "int vsprintf()".  It
  919.  *    is up to the package author to declare vsprintf correctly based on the
  920.  *    symbol.
  921.  */
  922. #$d_vprintf HAS_VPRINTF    /**/
  923. #$d_charvspr USE_CHAR_VSPRINTF     /**/
  924.  
  925. /* HAS_WAIT4:
  926.  *    This symbol, if defined, indicates that wait4() exists.
  927.  */
  928. #$d_wait4 HAS_WAIT4    /**/
  929.  
  930. /* HAS_WAITPID:
  931.  *    This symbol, if defined, indicates that the waitpid routine is
  932.  *    available to wait for child process.
  933.  */
  934. #$d_waitpid HAS_WAITPID    /**/
  935.  
  936. /* HAS_WCSTOMBS:
  937.  *    This symbol, if defined, indicates that the wcstombs routine is
  938.  *    available to convert wide character strings to multibyte strings.
  939.  */
  940. #$d_wcstombs HAS_WCSTOMBS    /**/
  941.  
  942. /* HAS_WCTOMB:
  943.  *    This symbol, if defined, indicates that the wctomb routine is available
  944.  *    to covert a wide character to a multibyte.
  945.  */
  946. #$d_wctomb HAS_WCTOMB        /**/
  947.  
  948. /* Fpos_t:
  949.  *    This symbol holds the type used to declare file positions in libc.
  950.  *    It can be fpos_t, long, uint, etc... It may be necessary to include
  951.  *    <sys/types.h> to get any typedef'ed information.
  952.  */
  953. #define Fpos_t $fpostype        /* File position type */
  954.  
  955. /* Gid_t:
  956.  *    This symbol holds the return type of getgid() and the type of
  957.  *    argument to setrgid() and related functions.  Typically,
  958.  *    it is the type of group ids in the kernel. It can be int, ushort,
  959.  *    uid_t, etc... It may be necessary to include <sys/types.h> to get
  960.  *    any typedef'ed information.
  961.  */
  962. #define Gid_t $gidtype        /* Type for getgid(), etc... */
  963.  
  964. /* Groups_t:
  965.  *    This symbol holds the type used for the second argument to
  966.  *    getgroups().  Usually, this is the same of gidtype, but
  967.  *    sometimes it isn't.  It can be int, ushort, uid_t, etc... 
  968.  *    It may be necessary to include <sys/types.h> to get any 
  969.  *    typedef'ed information.  This is only required if you have
  970.  *    getgroups().
  971.  */
  972. #ifdef HAS_GETGROUPS
  973. #define Groups_t $groupstype    /* Type for 2nd arg to getgroups() */
  974. #endif
  975.  
  976. /* DB_Prefix_t:
  977.  *    This symbol contains the type of the prefix structure element
  978.  *    in the <db.h> header file.  In older versions of DB, it was
  979.  *    int, while in newer ones it is u_int32_t.
  980.  */
  981. /* DB_Hash_t:
  982.  *    This symbol contains the type of the prefix structure element
  983.  *    in the <db.h> header file.  In older versions of DB, it was
  984.  *    int, while in newer ones it is size_t.
  985.  */
  986. #define DB_Hash_t    $db_hashtype        /**/
  987. #define DB_Prefix_t    $db_prefixtype      /**/
  988.  
  989. /* I_DIRENT:
  990.  *    This symbol, if defined, indicates to the C program that it should
  991.  *    include <dirent.h>. Using this symbol also triggers the definition
  992.  *    of the Direntry_t define which ends up being 'struct dirent' or
  993.  *    'struct direct' depending on the availability of <dirent.h>.
  994.  */
  995. /* DIRNAMLEN:
  996.  *    This symbol, if defined, indicates to the C program that the length
  997.  *    of directory entry names is provided by a d_namlen field.  Otherwise
  998.  *    you need to do strlen() on the d_name field.
  999.  */
  1000. /* Direntry_t:
  1001.  *    This symbol is set to 'struct direct' or 'struct dirent' depending on
  1002.  *    whether dirent is available or not. You should use this pseudo type to
  1003.  *    portably declare your directory entries.
  1004.  */
  1005. #$i_dirent I_DIRENT        /**/
  1006. #$d_dirnamlen DIRNAMLEN    /**/
  1007. #define Direntry_t $direntrytype
  1008.  
  1009. /* I_DLFCN:
  1010.  *    This symbol, if defined, indicates that <dlfcn.h> exists and should
  1011.  *    be included.
  1012.  */
  1013. #$i_dlfcn I_DLFCN        /**/
  1014.  
  1015. /* I_FCNTL:
  1016.  *    This manifest constant tells the C program to include <fcntl.h>.
  1017.  */
  1018. #$i_fcntl I_FCNTL    /**/
  1019.  
  1020. /* I_FLOAT:
  1021.  *    This symbol, if defined, indicates to the C program that it should
  1022.  *    include <float.h> to get definition of symbols like DBL_MAX or
  1023.  *    DBL_MIN, i.e. machine dependent floating point values.
  1024.  */
  1025. #$i_float I_FLOAT        /**/
  1026.  
  1027. /* I_GRP:
  1028.  *    This symbol, if defined, indicates to the C program that it should
  1029.  *    include <grp.h>.
  1030.  */
  1031. #$i_grp I_GRP        /**/
  1032.  
  1033. /* I_LIMITS:
  1034.  *    This symbol, if defined, indicates to the C program that it should
  1035.  *    include <limits.h> to get definition of symbols like WORD_BIT or
  1036.  *    LONG_MAX, i.e. machine dependant limitations.
  1037.  */
  1038. #$i_limits I_LIMITS        /**/
  1039.  
  1040. /* I_MATH:
  1041.  *    This symbol, if defined, indicates to the C program that it should
  1042.  *    include <math.h>.
  1043.  */
  1044. #$i_math I_MATH        /**/
  1045.  
  1046. /* I_MEMORY:
  1047.  *    This symbol, if defined, indicates to the C program that it should
  1048.  *    include <memory.h>.
  1049.  */
  1050. #$i_memory I_MEMORY        /**/
  1051.  
  1052. /* I_NDBM:
  1053.  *    This symbol, if defined, indicates that <ndbm.h> exists and should
  1054.  *    be included.
  1055.  */
  1056. #$i_ndbm I_NDBM    /**/
  1057.  
  1058. /* I_NET_ERRNO:
  1059.  *    This symbol, if defined, indicates that <net/errno.h> exists and 
  1060.  *    should be included.
  1061.  */
  1062. #$i_neterrno I_NET_ERRNO        /**/
  1063.  
  1064. /* I_NETINET_IN:
  1065.  *    This symbol, if defined, indicates to the C program that it should
  1066.  *    include <netinet/in.h>. Otherwise, you may try <sys/in.h>.
  1067.  */
  1068. #$i_niin I_NETINET_IN    /**/
  1069.  
  1070. /* I_PWD:
  1071.  *    This symbol, if defined, indicates to the C program that it should
  1072.  *    include <pwd.h>.
  1073.  */
  1074. /* PWQUOTA:
  1075.  *    This symbol, if defined, indicates to the C program that struct passwd
  1076.  *    contains pw_quota.
  1077.  */
  1078. /* PWAGE:
  1079.  *    This symbol, if defined, indicates to the C program that struct passwd
  1080.  *    contains pw_age.
  1081.  */
  1082. /* PWCHANGE:
  1083.  *    This symbol, if defined, indicates to the C program that struct passwd
  1084.  *    contains pw_change.
  1085.  */
  1086. /* PWCLASS:
  1087.  *    This symbol, if defined, indicates to the C program that struct passwd
  1088.  *    contains pw_class.
  1089.  */
  1090. /* PWEXPIRE:
  1091.  *    This symbol, if defined, indicates to the C program that struct passwd
  1092.  *    contains pw_expire.
  1093.  */
  1094. /* PWCOMMENT:
  1095.  *    This symbol, if defined, indicates to the C program that struct passwd
  1096.  *    contains pw_comment.
  1097.  */
  1098. #$i_pwd I_PWD        /**/
  1099. #$d_pwquota PWQUOTA    /**/
  1100. #$d_pwage PWAGE    /**/
  1101. #$d_pwchange PWCHANGE    /**/
  1102. #$d_pwclass PWCLASS    /**/
  1103. #$d_pwexpire PWEXPIRE    /**/
  1104. #$d_pwcomment PWCOMMENT    /**/
  1105.  
  1106. /* I_STDDEF:
  1107.  *    This symbol, if defined, indicates that <stddef.h> exists and should
  1108.  *    be included.
  1109.  */
  1110. #$i_stddef I_STDDEF    /**/
  1111.  
  1112. /* I_STDLIB:
  1113.  *    This symbol, if defined, indicates that <stdlib.h> exists and should
  1114.  *    be included.
  1115.  */
  1116. #$i_stdlib I_STDLIB        /**/
  1117.  
  1118. /* I_STRING:
  1119.  *    This symbol, if defined, indicates to the C program that it should
  1120.  *    include <string.h> (USG systems) instead of <strings.h> (BSD systems).
  1121.  */
  1122. #$i_string I_STRING        /**/
  1123.  
  1124. /* I_SYS_DIR:
  1125.  *    This symbol, if defined, indicates to the C program that it should
  1126.  *    include <sys/dir.h>.
  1127.  */
  1128. #$i_sysdir I_SYS_DIR        /**/
  1129.  
  1130. /* I_SYS_FILE:
  1131.  *    This symbol, if defined, indicates to the C program that it should
  1132.  *    include <sys/file.h> to get definition of R_OK and friends.
  1133.  */
  1134. #$i_sysfile I_SYS_FILE        /**/
  1135.  
  1136. /* I_SYS_IOCTL:
  1137.  *    This symbol, if defined, indicates that <sys/ioctl.h> exists and should
  1138.  *    be included. Otherwise, include <sgtty.h> or <termio.h>.
  1139.  */
  1140. #$i_sysioctl    I_SYS_IOCTL        /**/
  1141.  
  1142. /* I_SYS_NDIR:
  1143.  *    This symbol, if defined, indicates to the C program that it should
  1144.  *    include <sys/ndir.h>.
  1145.  */
  1146. #$i_sysndir I_SYS_NDIR    /**/
  1147.  
  1148. /* I_SYS_PARAM:
  1149.  *    This symbol, if defined, indicates to the C program that it should
  1150.  *    include <sys/param.h>.
  1151.  */
  1152. #$i_sysparam I_SYS_PARAM        /**/
  1153.  
  1154. /* I_SYS_SELECT:
  1155.  *    This symbol, if defined, indicates to the C program that it should
  1156.  *    include <sys/select.h> in order to get definition of struct timeval.
  1157.  */
  1158. #$i_sysselct I_SYS_SELECT    /**/
  1159.  
  1160. /* I_SYS_TIMES:
  1161.  *    This symbol, if defined, indicates to the C program that it should
  1162.  *    include <sys/times.h>.
  1163.  */
  1164. #$i_systimes    I_SYS_TIMES        /**/
  1165.  
  1166. /* I_SYS_TYPES:
  1167.  *    This symbol, if defined, indicates to the C program that it should
  1168.  *    include <sys/types.h>.
  1169.  */
  1170. #$i_systypes    I_SYS_TYPES        /**/
  1171.  
  1172. /* I_SYS_UN:
  1173.  *    This symbol, if defined, indicates to the C program that it should
  1174.  *    include <sys/un.h> to get UNIX domain socket definitions.
  1175.  */
  1176. #$i_sysun I_SYS_UN        /**/
  1177.  
  1178. /* I_TERMIO:
  1179.  *    This symbol, if defined, indicates that the program should include
  1180.  *    <termio.h> rather than <sgtty.h>.  There are also differences in
  1181.  *    the ioctl() calls that depend on the value of this symbol.
  1182.  */
  1183. /* I_TERMIOS:
  1184.  *    This symbol, if defined, indicates that the program should include
  1185.  *    the POSIX termios.h rather than sgtty.h or termio.h.
  1186.  *    There are also differences in the ioctl() calls that depend on the
  1187.  *    value of this symbol.
  1188.  */
  1189. /* I_SGTTY:
  1190.  *    This symbol, if defined, indicates that the program should include
  1191.  *    <sgtty.h> rather than <termio.h>.  There are also differences in
  1192.  *    the ioctl() calls that depend on the value of this symbol.
  1193.  */
  1194. #$i_termio I_TERMIO        /**/
  1195. #$i_termios I_TERMIOS        /**/
  1196. #$i_sgtty I_SGTTY        /**/
  1197.  
  1198. /* I_TIME:
  1199.  *    This symbol, if defined, indicates to the C program that it should
  1200.  *    include <time.h>.
  1201.  */
  1202. /* I_SYS_TIME:
  1203.  *    This symbol, if defined, indicates to the C program that it should
  1204.  *    include <sys/time.h>.
  1205.  */
  1206. /* I_SYS_TIME_KERNEL:
  1207.  *    This symbol, if defined, indicates to the C program that it should
  1208.  *    include <sys/time.h> with KERNEL defined.
  1209.  */
  1210. #$i_time I_TIME        /**/
  1211. #$i_systime I_SYS_TIME        /**/
  1212. #$i_systimek I_SYS_TIME_KERNEL        /**/
  1213.  
  1214. /* I_UNISTD:
  1215.  *    This symbol, if defined, indicates to the C program that it should
  1216.  *    include <unistd.h>.
  1217.  */
  1218. #$i_unistd I_UNISTD        /**/
  1219.  
  1220. /* I_UTIME:
  1221.  *    This symbol, if defined, indicates to the C program that it should
  1222.  *    include <utime.h>.
  1223.  */
  1224. #$i_utime I_UTIME        /**/
  1225.  
  1226. /* I_VFORK:
  1227.  *    This symbol, if defined, indicates to the C program that it should
  1228.  *    include vfork.h.
  1229.  */
  1230. #$i_vfork I_VFORK    /**/
  1231.  
  1232. /* Off_t:
  1233.  *    This symbol holds the type used to declare offsets in the kernel.
  1234.  *    It can be int, long, off_t, etc... It may be necessary to include
  1235.  *    <sys/types.h> to get any typedef'ed information.
  1236.  */
  1237. #define Off_t $lseektype        /* <offset> type */
  1238.  
  1239. /* Mode_t:
  1240.  *    This symbol holds the type used to declare file modes 
  1241.  *    for systems calls.  It is usually mode_t, but may be
  1242.  *    int or unsigned short.  It may be necessary to include <sys/types.h>
  1243.  *    to get any typedef'ed information.
  1244.  */
  1245. #define Mode_t $modetype     /* file mode parameter for system calls */
  1246.  
  1247. /* CAN_PROTOTYPE:
  1248.  *    If defined, this macro indicates that the C compiler can handle
  1249.  *    function prototypes.
  1250.  */
  1251. /* _:
  1252.  *    This macro is used to declare function parameters for folks who want
  1253.  *    to make declarations with prototypes using a different style than
  1254.  *    the above macros.  Use double parentheses.  For example:
  1255.  *
  1256.  *        int main _((int argc, char *argv[]));
  1257.  */
  1258. #$prototype    CAN_PROTOTYPE    /**/
  1259. #ifdef CAN_PROTOTYPE
  1260. #define    _(args) args
  1261. #else
  1262. #define    _(args) ()
  1263. #endif
  1264.  
  1265. /* RANDBITS:
  1266.  *    This symbol contains the number of bits of random number the rand()
  1267.  *    function produces.  Usual values are 15, 16, and 31.
  1268.  */
  1269. #define RANDBITS $randbits        /**/
  1270.  
  1271. /* SCRIPTDIR:
  1272.  *    This symbol holds the name of the directory in which the user wants
  1273.  *    to put publicly executable scripts for the package in question.  It
  1274.  *    is often a directory that is mounted across diverse architectures.
  1275.  *    Programs must be prepared to deal with ~name expansion.
  1276.  */
  1277. #define SCRIPTDIR "$scriptdir"    /**/
  1278.  
  1279. /* Select_fd_set_t:
  1280.  *    This symbol holds the type used for the 2nd, 3rd, and 4th
  1281.  *    arguments to select.  Usually, this is 'fd_set *', if HAS_FD_SET
  1282.  *    is defined, and 'int *' otherwise.  This is only useful if you 
  1283.  *    have select(), of course.
  1284.  */
  1285. #define Select_fd_set_t     $selecttype    /**/
  1286.  
  1287. /* Size_t:
  1288.  *    This symbol holds the type used to declare length parameters
  1289.  *    for string functions.  It is usually size_t, but may be
  1290.  *    unsigned long, int, etc.  It may be necessary to include
  1291.  *    <sys/types.h> to get any typedef'ed information.
  1292.  */
  1293. #define Size_t $sizetype     /* length paramater for string functions */
  1294.  
  1295. /* SSize_t:
  1296.  *    This symbol holds the type used by functions that return
  1297.  *    a count of bytes or an error condition.  It must be a signed type.
  1298.  *    It is usually ssize_t, but may be long or int, etc.
  1299.  *    It may be necessary to include <sys/types.h> or <unistd.h>
  1300.  *    to get any typedef'ed information.
  1301.  *    We will pick a type such that sizeof(SSize_t) == sizeof(Size_t).
  1302.  */
  1303. #define SSize_t $ssizetype     /* signed count of bytes */
  1304.  
  1305. /* STDCHAR:
  1306.  *    This symbol is defined to be the type of char used in stdio.h.
  1307.  *    It has the values "unsigned char" or "char".
  1308.  */
  1309. #define STDCHAR $stdchar    /**/
  1310.  
  1311. /* Uid_t:
  1312.  *    This symbol holds the type used to declare user ids in the kernel.
  1313.  *    It can be int, ushort, uid_t, etc... It may be necessary to include
  1314.  *    <sys/types.h> to get any typedef'ed information.
  1315.  */
  1316. #define Uid_t $uidtype        /* UID type */
  1317.  
  1318. /* VMS:
  1319.  *    This symbol, if defined, indicates that the program is running under
  1320.  *    VMS.  It is currently only set in conjunction with the EUNICE symbol.
  1321.  */
  1322. #$d_eunice VMS        /**/
  1323.  
  1324. /* LOC_SED:
  1325.  *    This symbol holds the complete pathname to the sed program.
  1326.  */
  1327. #define LOC_SED     "$full_sed"    /**/
  1328.  
  1329. /* ARCHLIB_EXP:
  1330.  *    This symbol contains the ~name expanded version of ARCHLIB, to be used
  1331.  *    in programs that are not prepared to deal with ~ expansion at run-time.
  1332.  */
  1333. #$d_archlib ARCHLIB_EXP "$archlibexp"        /**/
  1334.  
  1335. /* OSNAME:
  1336.  *    This symbol contains the name of the operating system, as determined
  1337.  *    by Configure.
  1338.  */
  1339. #define OSNAME "$osname"        /**/
  1340.  
  1341. /* BYTEORDER:
  1342.  *    This symbol hold the hexadecimal constant defined in byteorder,
  1343.  *    i.e. 0x1234 or 0x4321, etc...
  1344.  */
  1345. #define BYTEORDER 0x$byteorder    /* large digits for MSB */
  1346.  
  1347. /* CSH:
  1348.  *    This symbol, if defined, indicates that the C-shell exists.
  1349.  *    If defined, contains the full pathname of csh.
  1350.  */
  1351. #$d_csh CSH "$full_csh"        /**/
  1352.  
  1353. /* DLSYM_NEEDS_UNDERSCORE:
  1354.  *    This symbol, if defined, indicates that we need to prepend an
  1355.  *    underscore to the symbol name before calling dlsym().  This only
  1356.  *    makes sense if you *have* dlsym, which we will presume is the
  1357.  *    case if you're using dl_dlopen.xs.
  1358.  */
  1359. #$d_dlsymun     DLSYM_NEEDS_UNDERSCORE     /* */
  1360.  
  1361. /* SETUID_SCRIPTS_ARE_SECURE_NOW:
  1362.  *    This symbol, if defined, indicates that the bug that prevents
  1363.  *    setuid scripts from being secure is not present in this kernel.
  1364.  */
  1365. /* DOSUID:
  1366.  *    This symbol, if defined, indicates that the C program should
  1367.  *    check the script that it is executing for setuid/setgid bits, and
  1368.  *    attempt to emulate setuid/setgid on systems that have disabled
  1369.  *    setuid #! scripts because the kernel can't do it securely.
  1370.  *    It is up to the package designer to make sure that this emulation
  1371.  *    is done securely.  Among other things, it should do an fstat on
  1372.  *    the script it just opened to make sure it really is a setuid/setgid
  1373.  *    script, it should make sure the arguments passed correspond exactly
  1374.  *    to the argument on the #! line, and it should not trust any
  1375.  *    subprocesses to which it must pass the filename rather than the
  1376.  *    file descriptor of the script to be executed.
  1377.  */
  1378. #$d_suidsafe SETUID_SCRIPTS_ARE_SECURE_NOW    /**/
  1379. #$d_dosuid DOSUID        /**/
  1380.  
  1381. /* Gconvert:
  1382.  *    This preprocessor macro is defined to convert a floating point
  1383.  *    number to a string without a trailing decimal point.  This
  1384.  *    emulates the behavior of sprintf("%g"), but is sometimes much more
  1385.  *    efficient.  If gconvert() is not available, but gcvt() drops the
  1386.  *    trailing decimal point, then gcvt() is used.  If all else fails,
  1387.  *    a macro using sprintf("%g") is used. Arguments for the Gconvert
  1388.  *    macro are: value, number of digits, whether trailing zeros should
  1389.  *    be retained, and the output buffer.
  1390.  *    Possible values are:
  1391.  *        d_Gconvert='gconvert((x),(n),(t),(b))'
  1392.  *        d_Gconvert='gcvt((x),(n),(b))'
  1393.  *        d_Gconvert='sprintf((b),"%.*g",(n),(x))'
  1394.  *    The last two assume trailing zeros should not be kept.
  1395.  */
  1396. #define Gconvert(x,n,t,b) $d_Gconvert
  1397.  
  1398. /* Sigjmp_buf:
  1399.  * This is the buffer type to be used with Sigsetjmp and Siglongjmp.
  1400.  */
  1401. /* Sigsetjmp:
  1402.  * This macro is used in the same way as sigsetjmp(), but will invoke
  1403.  * traditional setjmp() if sigsetjmp isn't available.
  1404.  */
  1405. /* Siglongjmp:
  1406.  * This macro is used in the same way as siglongjmp(), but will invoke
  1407.  * traditional longjmp() if siglongjmp isn't available.
  1408.  */
  1409. #$d_sigsetjmp HAS_SIGSETJMP    /**/
  1410. #ifdef HAS_SIGSETJMP
  1411. #define Sigjmp_buf sigjmp_buf
  1412. #define Sigsetjmp(buf,save_mask) sigsetjmp(buf,save_mask)
  1413. #define Siglongjmp(buf,retval) siglongjmp(buf,retval)
  1414. #else
  1415. #define Sigjmp_buf jmp_buf
  1416. #define Sigsetjmp(buf,save_mask) setjmp(buf)
  1417. #define Siglongjmp(buf,retval) longjmp(buf,retval)
  1418. #endif
  1419.  
  1420. /* USE_DYNAMIC_LOADING:
  1421.  *    This symbol, if defined, indicates that dynamic loading of
  1422.  *    some sort is available.
  1423.  */
  1424. #$usedl USE_DYNAMIC_LOADING        /**/
  1425.  
  1426. /* I_DBM:
  1427.  *    This symbol, if defined, indicates that <dbm.h> exists and should
  1428.  *    be included.
  1429.  */
  1430. /* I_RPCSVC_DBM:
  1431.  *    This symbol, if defined, indicates that <rpcsvc/dbm.h> exists and
  1432.  *    should be included.
  1433.  */
  1434. #$i_dbm I_DBM    /**/
  1435. #$i_rpcsvcdbm I_RPCSVC_DBM    /**/
  1436.  
  1437. /* I_LOCALE:
  1438.  *    This symbol, if defined, indicates to the C program that it should
  1439.  *    include <locale.h>.
  1440.  */
  1441. #$i_locale    I_LOCALE        /**/
  1442.  
  1443. /* I_SYS_STAT:
  1444.  *    This symbol, if defined, indicates to the C program that it should
  1445.  *    include <sys/stat.h>.
  1446.  */
  1447. #$i_sysstat    I_SYS_STAT        /**/
  1448.  
  1449. /* I_STDARG:
  1450.  *    This symbol, if defined, indicates that <stdarg.h> exists and should
  1451.  *    be included.
  1452.  */
  1453. /* I_VARARGS:
  1454.  *    This symbol, if defined, indicates to the C program that it should
  1455.  *    include <varargs.h>.
  1456.  */
  1457. #$i_stdarg I_STDARG        /**/
  1458. #$i_varargs I_VARARGS    /**/
  1459.  
  1460. /* INTSIZE:
  1461.  *    This symbol contains the size of an int, so that the C preprocessor
  1462.  *    can make decisions based on it.
  1463.  */
  1464. #define INTSIZE $intsize        /**/
  1465.  
  1466. /* Free_t:
  1467.  *    This variable contains the return type of free().  It is usually
  1468.  * void, but occasionally int.
  1469.  */
  1470. /* Malloc_t:
  1471.  *    This symbol is the type of pointer returned by malloc and realloc.
  1472.  */
  1473. #define Malloc_t $malloctype            /**/
  1474. #define Free_t $freetype            /**/
  1475.  
  1476. /* MYMALLOC:
  1477.  *    This symbol, if defined, indicates that we're using our own malloc.
  1478.  */
  1479. #$d_mymalloc MYMALLOC            /**/
  1480.  
  1481. /* VAL_O_NONBLOCK:
  1482.  *    This symbol is to be used during open() or fcntl(F_SETFL) to turn on
  1483.  *    non-blocking I/O for the file descriptor. Note that there is no way
  1484.  *    back, i.e. you cannot turn it blocking again this way. If you wish to
  1485.  *    alternatively switch between blocking and non-blocking, use the
  1486.  *    ioctl(FIOSNBIO) call instead, but that is not supported by all devices.
  1487.  */
  1488. /* VAL_EAGAIN:
  1489.  *    This symbol holds the errno error code set by read() when no data was
  1490.  *    present on the non-blocking file descriptor.
  1491.  */
  1492. /* RD_NODATA:
  1493.  *    This symbol holds the return code from read() when no data is present
  1494.  *    on the non-blocking file descriptor. Be careful! If EOF_NONBLOCK is
  1495.  *    not defined, then you can't distinguish between no data and EOF by
  1496.  *    issuing a read(). You'll have to find another way to tell for sure!
  1497.  */
  1498. /* EOF_NONBLOCK:
  1499.  *    This symbol, if defined, indicates to the C program that a read() on
  1500.  *    a non-blocking file descriptor will return 0 on EOF, and not the value
  1501.  *    held in RD_NODATA (-1 usually, in that case!).
  1502.  */
  1503. #define VAL_O_NONBLOCK $o_nonblock
  1504. #define VAL_EAGAIN $eagain
  1505. #define RD_NODATA $rd_nodata
  1506. #$d_eofnblk EOF_NONBLOCK
  1507.  
  1508. /* OLDARCHLIB_EXP:
  1509.  *    This symbol contains the ~name expanded version of OLDARCHLIB, to be
  1510.  *    used in programs that are not prepared to deal with ~ expansion at 
  1511.  *    run-time.
  1512.  */
  1513. #$d_oldarchlib OLDARCHLIB_EXP "$oldarchlibexp"        /**/
  1514.  
  1515. /* PRIVLIB_EXP:
  1516.  *    This symbol contains the ~name expanded version of PRIVLIB, to be used
  1517.  *    in programs that are not prepared to deal with ~ expansion at run-time.
  1518.  */
  1519. #define PRIVLIB_EXP "$privlibexp"        /**/
  1520.  
  1521. /* SIG_NAME:
  1522.  *    This symbol contains a list of signal names in order of
  1523.  *    signal number. This is intended
  1524.  *    to be used as a static array initialization, like this:
  1525.  *        char *sig_name[] = { SIG_NAME };
  1526.  *    The signals in the list are separated with commas, and each signal
  1527.  *    is surrounded by double quotes. There is no leading SIG in the signal
  1528.  *    name, i.e. SIGQUIT is known as "QUIT".
  1529.  *    Gaps in the signal numbers (up to NSIG) are filled in with NUMnn,
  1530.  *    etc., where nn is the actual signal number (e.g. NUM37).
  1531.  *    The signal number for sig_name[i] is stored in sig_num[i].
  1532.  *    The last element is 0 to terminate the list with a NULL.  This
  1533.  *    corresponds to the 0 at the end of the sig_num list.
  1534.  */
  1535. /* SIG_NUM:
  1536.  *    This symbol contains a list of signal numbers, in the same order as the
  1537.  *    SIG_NAME list. It is suitable for static array initialization, as in:
  1538.  *        int sig_num[] = { SIG_NUM };
  1539.  *    The signals in the list are separated with commas, and the indices
  1540.  *    within that list and the SIG_NAME list match, so it's easy to compute
  1541.  *    the signal name from a number or vice versa at the price of a small
  1542.  *    dynamic linear lookup. 
  1543.  *    Duplicates are allowed, but are moved to the end of the list.
  1544.  *    The signal number corresponding to sig_name[i] is sig_number[i].
  1545.  *    if (i < NSIG) then sig_number[i] == i.  
  1546.  *    The last element is 0, corresponding to the 0 at the end of
  1547.  *    the sig_name list.
  1548.  */
  1549. #define SIG_NAME "`echo $sig_name | sed 's/ /","/g'`",0    /**/
  1550. #define SIG_NUM `echo $sig_num 0 | sed 's/ /,/g'`    /**/
  1551.  
  1552. /* SITEARCH_EXP:
  1553.  *    This symbol contains the ~name expanded version of SITEARCH, to be used
  1554.  *    in programs that are not prepared to deal with ~ expansion at run-time.
  1555.  */
  1556. #define SITEARCH_EXP "$sitearchexp"        /**/
  1557.  
  1558. /* SITELIB_EXP:
  1559.  *    This symbol contains the ~name expanded version of SITELIB, to be used
  1560.  *    in programs that are not prepared to deal with ~ expansion at run-time.
  1561.  */
  1562. #define SITELIB_EXP "$sitelibexp"        /**/
  1563.  
  1564. /* STARTPERL:
  1565.  *    This variable contains the string to put in front of a perl
  1566.  *    script to make sure (one hopes) that it runs with perl and not
  1567.  *    some shell.
  1568.  */
  1569. #define STARTPERL "$startperl"        /**/
  1570.  
  1571. /* VOIDFLAGS:
  1572.  *    This symbol indicates how much support of the void type is given by this
  1573.  *    compiler.  What various bits mean:
  1574.  *
  1575.  *        1 = supports declaration of void
  1576.  *        2 = supports arrays of pointers to functions returning void
  1577.  *        4 = supports comparisons between pointers to void functions and
  1578.  *            addresses of void functions
  1579.  *        8 = suports declaration of generic void pointers
  1580.  *
  1581.  *    The package designer should define VOIDUSED to indicate the requirements
  1582.  *    of the package.  This can be done either by #defining VOIDUSED before
  1583.  *    including config.h, or by defining defvoidused in Myinit.U.  If the
  1584.  *    latter approach is taken, only those flags will be tested.  If the
  1585.  *    level of void support necessary is not present, defines void to int.
  1586.  */
  1587. #ifndef VOIDUSED
  1588. #define VOIDUSED $defvoidused
  1589. #endif
  1590. #define VOIDFLAGS $voidflags
  1591. #if (VOIDFLAGS & VOIDUSED) != VOIDUSED
  1592. #define void int        /* is void to be avoided? */
  1593. #define M_VOID            /* Xenix strikes again */
  1594. #endif
  1595.  
  1596. #endif
  1597. !GROK!THIS!
  1598.