home *** CD-ROM | disk | FTP | other *** search
/ Netrunner 2004 October / NETRUNNER0410.ISO / regular / ActivePerl-5.8.4.810-MSWin32-x86.msi / _c904cc06bfbc60338dc3391a48435c8d < prev    next >
Text File  |  2004-06-01  |  137KB  |  4,264 lines
  1. /*
  2.  * This file was produced by running the config_h.SH script, which
  3.  * gets its values from uconfig.sh, which is generally produced by
  4.  * running Configure.
  5.  *
  6.  * Feel free to modify any of this as the need arises.  Note, however,
  7.  * that running config_h.SH again will wipe out any changes you've made.
  8.  * For a more permanent change edit uconfig.sh and rerun config_h.SH.
  9.  *
  10.  * $Id: Config_h.U,v 3.0.1.5 1997/02/28 14:57:43 ram Exp $
  11.  */
  12.  
  13. /*
  14.  * Package name      : 
  15.  * Source directory  : 
  16.  * Configuration time: 
  17.  * Configured by     : 
  18.  * Target system     : unknown
  19.  */
  20.  
  21. #ifndef _config_h_
  22. #define _config_h_
  23.  
  24. /* LOC_SED:
  25.  *    This symbol holds the complete pathname to the sed program.
  26.  */
  27. #define LOC_SED     ""    /**/
  28.  
  29. /* HAS_ALARM:
  30.  *    This symbol, if defined, indicates that the alarm routine is
  31.  *    available.
  32.  */
  33. /*#define HAS_ALARM        / **/
  34.  
  35. /* HAS_BCMP:
  36.  *    This symbol is defined if the bcmp() routine is available to
  37.  *    compare blocks of memory.
  38.  */
  39. /*#define HAS_BCMP    / **/
  40.  
  41. /* HAS_BCOPY:
  42.  *    This symbol is defined if the bcopy() routine is available to
  43.  *    copy blocks of memory.
  44.  */
  45. /*#define HAS_BCOPY    / **/
  46.  
  47. /* HAS_BZERO:
  48.  *    This symbol is defined if the bzero() routine is available to
  49.  *    set a memory block to 0.
  50.  */
  51. /*#define HAS_BZERO    / **/
  52.  
  53. /* HAS_CHOWN:
  54.  *    This symbol, if defined, indicates that the chown routine is
  55.  *    available.
  56.  */
  57. /*#define HAS_CHOWN        / **/
  58.  
  59. /* HAS_CHROOT:
  60.  *    This symbol, if defined, indicates that the chroot routine is
  61.  *    available.
  62.  */
  63. /*#define HAS_CHROOT        / **/
  64.  
  65. /* HAS_CHSIZE:
  66.  *    This symbol, if defined, indicates that the chsize routine is available
  67.  *    to truncate files.  You might need a -lx to get this routine.
  68.  */
  69. /*#define    HAS_CHSIZE        / **/
  70.  
  71. /* HASCONST:
  72.  *    This symbol, if defined, indicates that this C compiler knows about
  73.  *    the const type. There is no need to actually test for that symbol
  74.  *    within your programs. The mere use of the "const" keyword will
  75.  *    trigger the necessary tests.
  76.  */
  77. /*#define HASCONST    / **/
  78. #ifndef HASCONST
  79. #define const
  80. #endif
  81.  
  82. /* HAS_CUSERID:
  83.  *    This symbol, if defined, indicates that the cuserid routine is
  84.  *    available to get character login names.
  85.  */
  86. /*#define HAS_CUSERID        / **/
  87.  
  88. /* HAS_DBL_DIG:
  89.  *    This symbol, if defined, indicates that this system's <float.h>
  90.  *    or <limits.h> defines the symbol DBL_DIG, which is the number
  91.  *    of significant digits in a double precision number.  If this
  92.  *    symbol is not defined, a guess of 15 is usually pretty good.
  93.  */
  94. /*#define HAS_DBL_DIG     / * */
  95.  
  96. /* HAS_DIFFTIME:
  97.  *    This symbol, if defined, indicates that the difftime routine is
  98.  *    available.
  99.  */
  100. /*#define HAS_DIFFTIME        / **/
  101.  
  102. /* HAS_DLERROR:
  103.  *    This symbol, if defined, indicates that the dlerror routine is
  104.  *    available to return a string describing the last error that
  105.  *    occurred from a call to dlopen(), dlclose() or dlsym().
  106.  */
  107. /*#define HAS_DLERROR    / **/
  108.  
  109. /* HAS_DUP2:
  110.  *    This symbol, if defined, indicates that the dup2 routine is
  111.  *    available to duplicate file descriptors.
  112.  */
  113. /*#define HAS_DUP2    / **/
  114.  
  115. /* HAS_FCHMOD:
  116.  *    This symbol, if defined, indicates that the fchmod routine is available
  117.  *    to change mode of opened files.  If unavailable, use chmod().
  118.  */
  119. /*#define HAS_FCHMOD        / **/
  120.  
  121. /* HAS_FCHOWN:
  122.  *    This symbol, if defined, indicates that the fchown routine is available
  123.  *    to change ownership of opened files.  If unavailable, use chown().
  124.  */
  125. /*#define HAS_FCHOWN        / **/
  126.  
  127. /* HAS_FCNTL:
  128.  *    This symbol, if defined, indicates to the C program that
  129.  *    the fcntl() function exists.
  130.  */
  131. /*#define HAS_FCNTL        / **/
  132.  
  133. /* HAS_FGETPOS:
  134.  *    This symbol, if defined, indicates that the fgetpos routine is
  135.  *    available to get the file position indicator, similar to ftell().
  136.  */
  137. /*#define HAS_FGETPOS    / **/
  138.  
  139. /* HAS_FLOCK:
  140.  *    This symbol, if defined, indicates that the flock routine is
  141.  *    available to do file locking.
  142.  */
  143. /*#define HAS_FLOCK        / **/
  144.  
  145. /* HAS_FORK:
  146.  *    This symbol, if defined, indicates that the fork routine is
  147.  *    available.
  148.  */
  149. #define HAS_FORK        /**/
  150.  
  151. /* HAS_FSETPOS:
  152.  *    This symbol, if defined, indicates that the fsetpos routine is
  153.  *    available to set the file position indicator, similar to fseek().
  154.  */
  155. /*#define HAS_FSETPOS    / **/
  156.  
  157. /* HAS_GETTIMEOFDAY:
  158.  *    This symbol, if defined, indicates that the gettimeofday() system
  159.  *    call is available for a sub-second accuracy clock. Usually, the file
  160.  *    <sys/resource.h> needs to be included (see I_SYS_RESOURCE).
  161.  *    The type "Timeval" should be used to refer to "struct timeval".
  162.  */
  163. /*#define HAS_GETTIMEOFDAY    / **/
  164. #ifdef HAS_GETTIMEOFDAY
  165. #define Timeval struct timeval    /* Structure used by gettimeofday() */
  166. #endif
  167.  
  168. /* HAS_GETGROUPS:
  169.  *    This symbol, if defined, indicates that the getgroups() routine is
  170.  *    available to get the list of process groups.  If unavailable, multiple
  171.  *    groups are probably not supported.
  172.  */
  173. /*#define HAS_GETGROUPS        / **/
  174.  
  175. /* HAS_GETLOGIN:
  176.  *    This symbol, if defined, indicates that the getlogin routine is
  177.  *    available to get the login name.
  178.  */
  179. /*#define HAS_GETLOGIN        / **/
  180.  
  181. /* HAS_GETPGID:
  182.  *    This symbol, if defined, indicates to the C program that 
  183.  *    the getpgid(pid) function is available to get the
  184.  *    process group id.
  185.  */
  186. /*#define HAS_GETPGID        / **/
  187.  
  188. /* HAS_GETPGRP2:
  189.  *    This symbol, if defined, indicates that the getpgrp2() (as in DG/UX)
  190.  *    routine is available to get the current process group.
  191.  */
  192. /*#define HAS_GETPGRP2        / **/
  193.  
  194. /* HAS_GETPPID:
  195.  *    This symbol, if defined, indicates that the getppid routine is
  196.  *    available to get the parent process ID.
  197.  */
  198. /*#define HAS_GETPPID        / **/
  199.  
  200. /* HAS_GETPRIORITY:
  201.  *    This symbol, if defined, indicates that the getpriority routine is
  202.  *    available to get a process's priority.
  203.  */
  204. /*#define HAS_GETPRIORITY        / **/
  205.  
  206. /* HAS_INET_ATON:
  207.  *    This symbol, if defined, indicates to the C program that the
  208.  *    inet_aton() function is available to parse IP address "dotted-quad"
  209.  *    strings.
  210.  */
  211. /*#define HAS_INET_ATON        / **/
  212.  
  213. /* HAS_KILLPG:
  214.  *    This symbol, if defined, indicates that the killpg routine is available
  215.  *    to kill process groups.  If unavailable, you probably should use kill
  216.  *    with a negative process number.
  217.  */
  218. /*#define HAS_KILLPG    / **/
  219.  
  220. /* HAS_LINK:
  221.  *    This symbol, if defined, indicates that the link routine is
  222.  *    available to create hard links.
  223.  */
  224. /*#define HAS_LINK    / **/
  225.  
  226. /* HAS_LOCALECONV:
  227.  *    This symbol, if defined, indicates that the localeconv routine is
  228.  *    available for numeric and monetary formatting conventions.
  229.  */
  230. /*#define HAS_LOCALECONV    / **/
  231.  
  232. /* HAS_LOCKF:
  233.  *    This symbol, if defined, indicates that the lockf routine is
  234.  *    available to do file locking.
  235.  */
  236. /*#define HAS_LOCKF        / **/
  237.  
  238. /* HAS_LSTAT:
  239.  *    This symbol, if defined, indicates that the lstat routine is
  240.  *    available to do file stats on symbolic links.
  241.  */
  242. /*#define HAS_LSTAT        / **/
  243.  
  244. /* HAS_MBLEN:
  245.  *    This symbol, if defined, indicates that the mblen routine is available
  246.  *    to find the number of bytes in a multibye character.
  247.  */
  248. /*#define HAS_MBLEN        / **/
  249.  
  250. /* HAS_MBSTOWCS:
  251.  *    This symbol, if defined, indicates that the mbstowcs routine is
  252.  *    available to covert a multibyte string into a wide character string.
  253.  */
  254. /*#define    HAS_MBSTOWCS        / **/
  255.  
  256. /* HAS_MBTOWC:
  257.  *    This symbol, if defined, indicates that the mbtowc routine is available
  258.  *    to covert a multibyte to a wide character.
  259.  */
  260. /*#define HAS_MBTOWC        / **/
  261.  
  262. /* HAS_MEMCMP:
  263.  *    This symbol, if defined, indicates that the memcmp routine is available
  264.  *    to compare blocks of memory.
  265.  */
  266. /*#define HAS_MEMCMP    / **/
  267.  
  268. /* HAS_MEMCPY:
  269.  *    This symbol, if defined, indicates that the memcpy routine is available
  270.  *    to copy blocks of memory.
  271.  */
  272. /*#define HAS_MEMCPY    / **/
  273.  
  274. /* HAS_MEMMOVE:
  275.  *    This symbol, if defined, indicates that the memmove routine is available
  276.  *    to copy potentially overlapping blocks of memory. This should be used
  277.  *    only when HAS_SAFE_BCOPY is not defined. If neither is there, roll your
  278.  *    own version.
  279.  */
  280. /*#define HAS_MEMMOVE    / **/
  281.  
  282. /* HAS_MEMSET:
  283.  *    This symbol, if defined, indicates that the memset routine is available
  284.  *    to set blocks of memory.
  285.  */
  286. /*#define HAS_MEMSET    / **/
  287.  
  288. /* HAS_MKDIR:
  289.  *    This symbol, if defined, indicates that the mkdir routine is available
  290.  *    to create directories.  Otherwise you should fork off a new process to
  291.  *    exec /bin/mkdir.
  292.  */
  293. /*#define HAS_MKDIR        / **/
  294.  
  295. /* HAS_MKFIFO:
  296.  *    This symbol, if defined, indicates that the mkfifo routine is
  297.  *    available to create FIFOs. Otherwise, mknod should be able to
  298.  *    do it for you. However, if mkfifo is there, mknod might require
  299.  *    super-user privileges which mkfifo will not.
  300.  */
  301. /*#define HAS_MKFIFO        / **/
  302.  
  303. /* HAS_MKTIME:
  304.  *    This symbol, if defined, indicates that the mktime routine is
  305.  *    available.
  306.  */
  307. /*#define HAS_MKTIME        / **/
  308.  
  309. /* HAS_MSYNC:
  310.  *    This symbol, if defined, indicates that the msync system call is
  311.  *    available to synchronize a mapped file.
  312.  */
  313. /*#define HAS_MSYNC        / **/
  314.  
  315. /* HAS_MUNMAP:
  316.  *    This symbol, if defined, indicates that the munmap system call is
  317.  *    available to unmap a region, usually mapped by mmap().
  318.  */
  319. /*#define HAS_MUNMAP        / **/
  320.  
  321. /* HAS_NICE:
  322.  *    This symbol, if defined, indicates that the nice routine is
  323.  *    available.
  324.  */
  325. /*#define HAS_NICE        / **/
  326.  
  327. /* HAS_PATHCONF:
  328.  *    This symbol, if defined, indicates that pathconf() is available
  329.  *    to determine file-system related limits and options associated
  330.  *    with a given filename.
  331.  */
  332. /* HAS_FPATHCONF:
  333.  *    This symbol, if defined, indicates that pathconf() is available
  334.  *    to determine file-system related limits and options associated
  335.  *    with a given open file descriptor.
  336.  */
  337. /*#define HAS_PATHCONF        / **/
  338. /*#define HAS_FPATHCONF        / **/
  339.  
  340. /* HAS_PAUSE:
  341.  *    This symbol, if defined, indicates that the pause routine is
  342.  *    available to suspend a process until a signal is received.
  343.  */
  344. /*#define HAS_PAUSE        / **/
  345.  
  346. /* HAS_PIPE:
  347.  *    This symbol, if defined, indicates that the pipe routine is
  348.  *    available to create an inter-process channel.
  349.  */
  350. /*#define HAS_PIPE        / **/
  351.  
  352. /* HAS_POLL:
  353.  *    This symbol, if defined, indicates that the poll routine is
  354.  *    available to poll active file descriptors. You may safely
  355.  *    include <poll.h> when this symbol is defined.
  356.  */
  357. /*#define HAS_POLL        / **/
  358.  
  359. /* HAS_READDIR:
  360.  *    This symbol, if defined, indicates that the readdir routine is
  361.  *    available to read directory entries. You may have to include
  362.  *    <dirent.h>. See I_DIRENT.
  363.  */
  364. #define HAS_READDIR        /**/
  365.  
  366. /* HAS_SEEKDIR:
  367.  *    This symbol, if defined, indicates that the seekdir routine is
  368.  *    available. You may have to include <dirent.h>. See I_DIRENT.
  369.  */
  370. /*#define HAS_SEEKDIR        / **/
  371.  
  372. /* HAS_TELLDIR:
  373.  *    This symbol, if defined, indicates that the telldir routine is
  374.  *    available. You may have to include <dirent.h>. See I_DIRENT.
  375.  */
  376. /*#define HAS_TELLDIR        / **/
  377.  
  378. /* HAS_REWINDDIR:
  379.  *    This symbol, if defined, indicates that the rewinddir routine is
  380.  *    available. You may have to include <dirent.h>. See I_DIRENT.
  381.  */
  382. /*#define HAS_REWINDDIR        / **/
  383.  
  384. /* HAS_READLINK:
  385.  *    This symbol, if defined, indicates that the readlink routine is
  386.  *    available to read the value of a symbolic link.
  387.  */
  388. /*#define HAS_READLINK        / **/
  389.  
  390. /* HAS_RENAME:
  391.  *    This symbol, if defined, indicates that the rename routine is available
  392.  *    to rename files.  Otherwise you should do the unlink(), link(), unlink()
  393.  *    trick.
  394.  */
  395. #define HAS_RENAME    /**/
  396.  
  397. /* HAS_RMDIR:
  398.  *    This symbol, if defined, indicates that the rmdir routine is
  399.  *    available to remove directories. Otherwise you should fork off a
  400.  *    new process to exec /bin/rmdir.
  401.  */
  402. /*#define HAS_RMDIR        / **/
  403.  
  404. /* HAS_SELECT:
  405.  *    This symbol, if defined, indicates that the select routine is
  406.  *    available to select active file descriptors. If the timeout field
  407.  *    is used, <sys/time.h> may need to be included.
  408.  */
  409. /*#define HAS_SELECT    / **/
  410.  
  411. /* HAS_SETEGID:
  412.  *    This symbol, if defined, indicates that the setegid routine is available
  413.  *    to change the effective gid of the current program.
  414.  */
  415. /*#define HAS_SETEGID        / **/
  416.  
  417. /* HAS_SETEUID:
  418.  *    This symbol, if defined, indicates that the seteuid routine is available
  419.  *    to change the effective uid of the current program.
  420.  */
  421. /*#define HAS_SETEUID        / **/
  422.  
  423. /* HAS_SETLINEBUF:
  424.  *    This symbol, if defined, indicates that the setlinebuf routine is
  425.  *    available to change stderr or stdout from block-buffered or unbuffered
  426.  *    to a line-buffered mode.
  427.  */
  428. /*#define HAS_SETLINEBUF        / **/
  429.  
  430. /* HAS_SETLOCALE:
  431.  *    This symbol, if defined, indicates that the setlocale routine is
  432.  *    available to handle locale-specific ctype implementations.
  433.  */
  434. /*#define HAS_SETLOCALE    / **/
  435.  
  436. /* HAS_SETPGID:
  437.  *    This symbol, if defined, indicates that the setpgid(pid, gpid)
  438.  *    routine is available to set process group ID.
  439.  */
  440. /*#define HAS_SETPGID    / **/
  441.  
  442. /* HAS_SETPGRP2:
  443.  *    This symbol, if defined, indicates that the setpgrp2() (as in DG/UX)
  444.  *    routine is available to set the current process group.
  445.  */
  446. /*#define HAS_SETPGRP2        / **/
  447.  
  448. /* HAS_SETPRIORITY:
  449.  *    This symbol, if defined, indicates that the setpriority routine is
  450.  *    available to set a process's priority.
  451.  */
  452. /*#define HAS_SETPRIORITY        / **/
  453.  
  454. /* HAS_SETREGID:
  455.  *    This symbol, if defined, indicates that the setregid routine is
  456.  *    available to change the real and effective gid of the current
  457.  *    process.
  458.  */
  459. /* HAS_SETRESGID:
  460.  *    This symbol, if defined, indicates that the setresgid routine is
  461.  *    available to change the real, effective and saved gid of the current
  462.  *    process.
  463.  */
  464. /*#define HAS_SETREGID        / **/
  465. /*#define HAS_SETRESGID        / **/
  466.  
  467. /* HAS_SETREUID:
  468.  *    This symbol, if defined, indicates that the setreuid routine is
  469.  *    available to change the real and effective uid of the current
  470.  *    process.
  471.  */
  472. /* HAS_SETRESUID:
  473.  *    This symbol, if defined, indicates that the setresuid routine is
  474.  *    available to change the real, effective and saved uid of the current
  475.  *    process.
  476.  */
  477. /*#define HAS_SETREUID        / **/
  478. /*#define HAS_SETRESUID        / **/
  479.  
  480. /* HAS_SETRGID:
  481.  *    This symbol, if defined, indicates that the setrgid routine is available
  482.  *    to change the real gid of the current program.
  483.  */
  484. /*#define HAS_SETRGID        / **/
  485.  
  486. /* HAS_SETRUID:
  487.  *    This symbol, if defined, indicates that the setruid routine is available
  488.  *    to change the real uid of the current program.
  489.  */
  490. /*#define HAS_SETRUID        / **/
  491.  
  492. /* HAS_SETSID:
  493.  *    This symbol, if defined, indicates that the setsid routine is
  494.  *    available to set the process group ID.
  495.  */
  496. /*#define HAS_SETSID    / **/
  497.  
  498. /* HAS_STRCHR:
  499.  *    This symbol is defined to indicate that the strchr()/strrchr()
  500.  *    functions are available for string searching. If not, try the
  501.  *    index()/rindex() pair.
  502.  */
  503. /* HAS_INDEX:
  504.  *    This symbol is defined to indicate that the index()/rindex()
  505.  *    functions are available for string searching.
  506.  */
  507. /*#define HAS_STRCHR    / **/
  508. /*#define HAS_INDEX    / **/
  509.  
  510. /* HAS_STRCOLL:
  511.  *    This symbol, if defined, indicates that the strcoll routine is
  512.  *    available to compare strings using collating information.
  513.  */
  514. /*#define HAS_STRCOLL    / **/
  515.  
  516. /* USE_STRUCT_COPY:
  517.  *    This symbol, if defined, indicates that this C compiler knows how
  518.  *    to copy structures.  If undefined, you'll need to use a block copy
  519.  *    routine of some sort instead.
  520.  */
  521. /*#define    USE_STRUCT_COPY    / **/
  522.  
  523. /* HAS_STRTOD:
  524.  *    This symbol, if defined, indicates that the strtod routine is
  525.  *    available to provide better numeric string conversion than atof().
  526.  */
  527. /*#define HAS_STRTOD    / **/
  528.  
  529. /* HAS_STRTOL:
  530.  *    This symbol, if defined, indicates that the strtol routine is available
  531.  *    to provide better numeric string conversion than atoi() and friends.
  532.  */
  533. /*#define HAS_STRTOL    / **/
  534.  
  535. /* HAS_STRXFRM:
  536.  *    This symbol, if defined, indicates that the strxfrm() routine is
  537.  *    available to transform strings.
  538.  */
  539. /*#define HAS_STRXFRM    / **/
  540.  
  541. /* HAS_SYMLINK:
  542.  *    This symbol, if defined, indicates that the symlink routine is available
  543.  *    to create symbolic links.
  544.  */
  545. /*#define HAS_SYMLINK    / **/
  546.  
  547. /* HAS_SYSCALL:
  548.  *    This symbol, if defined, indicates that the syscall routine is
  549.  *    available to call arbitrary system calls. If undefined, that's tough.
  550.  */
  551. /*#define HAS_SYSCALL    / **/
  552.  
  553. /* HAS_SYSCONF:
  554.  *    This symbol, if defined, indicates that sysconf() is available
  555.  *    to determine system related limits and options.
  556.  */
  557. /*#define HAS_SYSCONF    / **/
  558.  
  559. /* HAS_SYSTEM:
  560.  *    This symbol, if defined, indicates that the system routine is
  561.  *    available to issue a shell command.
  562.  */
  563. /*#define HAS_SYSTEM    / **/
  564.  
  565. /* HAS_TCGETPGRP:
  566.  *    This symbol, if defined, indicates that the tcgetpgrp routine is
  567.  *    available to get foreground process group ID.
  568.  */
  569. /*#define HAS_TCGETPGRP        / **/
  570.  
  571. /* HAS_TCSETPGRP:
  572.  *    This symbol, if defined, indicates that the tcsetpgrp routine is
  573.  *    available to set foreground process group ID.
  574.  */
  575. /*#define HAS_TCSETPGRP        / **/
  576.  
  577. /* HAS_TRUNCATE:
  578.  *    This symbol, if defined, indicates that the truncate routine is
  579.  *    available to truncate files.
  580.  */
  581. /*#define HAS_TRUNCATE    / **/
  582.  
  583. /* HAS_TZNAME:
  584.  *    This symbol, if defined, indicates that the tzname[] array is
  585.  *    available to access timezone names.
  586.  */
  587. /*#define HAS_TZNAME        / **/
  588.  
  589. /* HAS_UMASK:
  590.  *    This symbol, if defined, indicates that the umask routine is
  591.  *    available to set and get the value of the file creation mask.
  592.  */
  593. /*#define HAS_UMASK        / **/
  594.  
  595. /* HAS_USLEEP:
  596.  *    This symbol, if defined, indicates that the usleep routine is
  597.  *    available to let the process sleep on a sub-second accuracy.
  598.  */
  599. /*#define HAS_USLEEP        / **/
  600.  
  601. /* HASVOLATILE:
  602.  *    This symbol, if defined, indicates that this C compiler knows about
  603.  *    the volatile declaration.
  604.  */
  605. /*#define    HASVOLATILE    / **/
  606. #ifndef HASVOLATILE
  607. #define volatile
  608. #endif
  609.  
  610. /* HAS_WAIT4:
  611.  *    This symbol, if defined, indicates that wait4() exists.
  612.  */
  613. /*#define HAS_WAIT4    / **/
  614.  
  615. /* HAS_WAITPID:
  616.  *    This symbol, if defined, indicates that the waitpid routine is
  617.  *    available to wait for child process.
  618.  */
  619. /*#define HAS_WAITPID    / **/
  620.  
  621. /* HAS_WCSTOMBS:
  622.  *    This symbol, if defined, indicates that the wcstombs routine is
  623.  *    available to convert wide character strings to multibyte strings.
  624.  */
  625. /*#define HAS_WCSTOMBS    / **/
  626.  
  627. /* HAS_WCTOMB:
  628.  *    This symbol, if defined, indicates that the wctomb routine is available
  629.  *    to covert a wide character to a multibyte.
  630.  */
  631. /*#define HAS_WCTOMB        / **/
  632.  
  633. /* I_ARPA_INET:
  634.  *    This symbol, if defined, indicates to the C program that it should
  635.  *    include <arpa/inet.h> to get inet_addr and friends declarations.
  636.  */
  637. /*#define    I_ARPA_INET        / **/
  638.  
  639. /* I_DBM:
  640.  *    This symbol, if defined, indicates that <dbm.h> exists and should
  641.  *    be included.
  642.  */
  643. /* I_RPCSVC_DBM:
  644.  *    This symbol, if defined, indicates that <rpcsvc/dbm.h> exists and
  645.  *    should be included.
  646.  */
  647. /*#define I_DBM    / **/
  648. /*#define I_RPCSVC_DBM    / **/
  649.  
  650. /* I_DIRENT:
  651.  *    This symbol, if defined, indicates to the C program that it should
  652.  *    include <dirent.h>. Using this symbol also triggers the definition
  653.  *    of the Direntry_t define which ends up being 'struct dirent' or
  654.  *    'struct direct' depending on the availability of <dirent.h>.
  655.  */
  656. /* DIRNAMLEN:
  657.  *    This symbol, if defined, indicates to the C program that the length
  658.  *    of directory entry names is provided by a d_namlen field.  Otherwise
  659.  *    you need to do strlen() on the d_name field.
  660.  */
  661. /* Direntry_t:
  662.  *    This symbol is set to 'struct direct' or 'struct dirent' depending on
  663.  *    whether dirent is available or not. You should use this pseudo type to
  664.  *    portably declare your directory entries.
  665.  */
  666. #define I_DIRENT        /**/
  667. /*#define DIRNAMLEN    / **/
  668. #define Direntry_t struct dirent
  669.  
  670. /* I_DLFCN:
  671.  *    This symbol, if defined, indicates that <dlfcn.h> exists and should
  672.  *    be included.
  673.  */
  674. /*#define I_DLFCN        / **/
  675.  
  676. /* I_FCNTL:
  677.  *    This manifest constant tells the C program to include <fcntl.h>.
  678.  */
  679. /*#define I_FCNTL    / **/
  680.  
  681. /* I_FLOAT:
  682.  *    This symbol, if defined, indicates to the C program that it should
  683.  *    include <float.h> to get definition of symbols like DBL_MAX or
  684.  *    DBL_MIN, i.e. machine dependent floating point values.
  685.  */
  686. /*#define I_FLOAT        / **/
  687.  
  688. /* I_LIMITS:
  689.  *    This symbol, if defined, indicates to the C program that it should
  690.  *    include <limits.h> to get definition of symbols like WORD_BIT or
  691.  *    LONG_MAX, i.e. machine dependant limitations.
  692.  */
  693. /*#define I_LIMITS        / **/
  694.  
  695. /* I_LOCALE:
  696.  *    This symbol, if defined, indicates to the C program that it should
  697.  *    include <locale.h>.
  698.  */
  699. /*#define    I_LOCALE        / **/
  700.  
  701. /* I_MATH:
  702.  *    This symbol, if defined, indicates to the C program that it should
  703.  *    include <math.h>.
  704.  */
  705. #define I_MATH        /**/
  706.  
  707. /* I_MEMORY:
  708.  *    This symbol, if defined, indicates to the C program that it should
  709.  *    include <memory.h>.
  710.  */
  711. /*#define I_MEMORY        / **/
  712.  
  713. /* I_NET_ERRNO:
  714.  *    This symbol, if defined, indicates that <net/errno.h> exists and 
  715.  *    should be included.
  716.  */
  717. /*#define I_NET_ERRNO        / **/
  718.  
  719. /* I_NETINET_IN:
  720.  *    This symbol, if defined, indicates to the C program that it should
  721.  *    include <netinet/in.h>. Otherwise, you may try <sys/in.h>.
  722.  */
  723. /*#define I_NETINET_IN    / **/
  724.  
  725. /* I_SFIO:
  726.  *    This symbol, if defined, indicates to the C program that it should
  727.  *    include <sfio.h>.
  728.  */
  729. /*#define    I_SFIO        / **/
  730.  
  731. /* I_STDDEF:
  732.  *    This symbol, if defined, indicates that <stddef.h> exists and should
  733.  *    be included.
  734.  */
  735. /*#define I_STDDEF    / **/
  736.  
  737. /* I_STDLIB:
  738.  *    This symbol, if defined, indicates that <stdlib.h> exists and should
  739.  *    be included.
  740.  */
  741. #define I_STDLIB        /**/
  742.  
  743. /* I_STRING:
  744.  *    This symbol, if defined, indicates to the C program that it should
  745.  *    include <string.h> (USG systems) instead of <strings.h> (BSD systems).
  746.  */
  747. #define I_STRING        /**/
  748.  
  749. /* I_SYS_DIR:
  750.  *    This symbol, if defined, indicates to the C program that it should
  751.  *    include <sys/dir.h>.
  752.  */
  753. /*#define I_SYS_DIR        / **/
  754.  
  755. /* I_SYS_FILE:
  756.  *    This symbol, if defined, indicates to the C program that it should
  757.  *    include <sys/file.h> to get definition of R_OK and friends.
  758.  */
  759. /*#define I_SYS_FILE        / **/
  760.  
  761. /* I_SYS_IOCTL:
  762.  *    This symbol, if defined, indicates that <sys/ioctl.h> exists and should
  763.  *    be included. Otherwise, include <sgtty.h> or <termio.h>.
  764.  */
  765. /* I_SYS_SOCKIO:
  766.  *    This symbol, if defined, indicates the <sys/sockio.h> should be included
  767.  *    to get socket ioctl options, like SIOCATMARK.
  768.  */
  769. /*#define    I_SYS_IOCTL        / **/
  770. /*#define I_SYS_SOCKIO    / **/
  771.  
  772. /* I_SYS_NDIR:
  773.  *    This symbol, if defined, indicates to the C program that it should
  774.  *    include <sys/ndir.h>.
  775.  */
  776. /*#define I_SYS_NDIR    / **/
  777.  
  778. /* I_SYS_PARAM:
  779.  *    This symbol, if defined, indicates to the C program that it should
  780.  *    include <sys/param.h>.
  781.  */
  782. /*#define I_SYS_PARAM        / **/
  783.  
  784. /* I_SYS_RESOURCE:
  785.  *    This symbol, if defined, indicates to the C program that it should
  786.  *    include <sys/resource.h>.
  787.  */
  788. /*#define I_SYS_RESOURCE        / **/
  789.  
  790. /* I_SYS_SELECT:
  791.  *    This symbol, if defined, indicates to the C program that it should
  792.  *    include <sys/select.h> in order to get definition of struct timeval.
  793.  */
  794. /*#define I_SYS_SELECT    / **/
  795.  
  796. /* I_SYS_STAT:
  797.  *    This symbol, if defined, indicates to the C program that it should
  798.  *    include <sys/stat.h>.
  799.  */
  800. #define    I_SYS_STAT        /**/
  801.  
  802. /* I_SYS_TIMES:
  803.  *    This symbol, if defined, indicates to the C program that it should
  804.  *    include <sys/times.h>.
  805.  */
  806. /*#define    I_SYS_TIMES        / **/
  807.  
  808. /* I_SYS_TYPES:
  809.  *    This symbol, if defined, indicates to the C program that it should
  810.  *    include <sys/types.h>.
  811.  */
  812. /*#define    I_SYS_TYPES        / **/
  813.  
  814. /* I_SYS_UN:
  815.  *    This symbol, if defined, indicates to the C program that it should
  816.  *    include <sys/un.h> to get UNIX domain socket definitions.
  817.  */
  818. /*#define I_SYS_UN        / **/
  819.  
  820. /* I_SYS_WAIT:
  821.  *    This symbol, if defined, indicates to the C program that it should
  822.  *    include <sys/wait.h>.
  823.  */
  824. /*#define I_SYS_WAIT    / **/
  825.  
  826. /* I_TERMIO:
  827.  *    This symbol, if defined, indicates that the program should include
  828.  *    <termio.h> rather than <sgtty.h>.  There are also differences in
  829.  *    the ioctl() calls that depend on the value of this symbol.
  830.  */
  831. /* I_TERMIOS:
  832.  *    This symbol, if defined, indicates that the program should include
  833.  *    the POSIX termios.h rather than sgtty.h or termio.h.
  834.  *    There are also differences in the ioctl() calls that depend on the
  835.  *    value of this symbol.
  836.  */
  837. /* I_SGTTY:
  838.  *    This symbol, if defined, indicates that the program should include
  839.  *    <sgtty.h> rather than <termio.h>.  There are also differences in
  840.  *    the ioctl() calls that depend on the value of this symbol.
  841.  */
  842. /*#define I_TERMIO        / **/
  843. /*#define I_TERMIOS        / **/
  844. /*#define I_SGTTY        / **/
  845.  
  846. /* I_UNISTD:
  847.  *    This symbol, if defined, indicates to the C program that it should
  848.  *    include <unistd.h>.
  849.  */
  850. /*#define I_UNISTD        / **/
  851.  
  852. /* I_UTIME:
  853.  *    This symbol, if defined, indicates to the C program that it should
  854.  *    include <utime.h>.
  855.  */
  856. /*#define I_UTIME        / **/
  857.  
  858. /* I_VALUES:
  859.  *    This symbol, if defined, indicates to the C program that it should
  860.  *    include <values.h> to get definition of symbols like MINFLOAT or
  861.  *    MAXLONG, i.e. machine dependant limitations.  Probably, you
  862.  *    should use <limits.h> instead, if it is available.
  863.  */
  864. /*#define I_VALUES        / **/
  865.  
  866. /* I_VFORK:
  867.  *    This symbol, if defined, indicates to the C program that it should
  868.  *    include vfork.h.
  869.  */
  870. /*#define I_VFORK    / **/
  871.  
  872. /* INTSIZE:
  873.  *    This symbol contains the value of sizeof(int) so that the C
  874.  *    preprocessor can make decisions based on it.
  875.  */
  876. /* LONGSIZE:
  877.  *    This symbol contains the value of sizeof(long) so that the C
  878.  *    preprocessor can make decisions based on it.
  879.  */
  880. /* SHORTSIZE:
  881.  *    This symbol contains the value of sizeof(short) so that the C
  882.  *    preprocessor can make decisions based on it.
  883.  */
  884. #define INTSIZE 4        /**/
  885. #define LONGSIZE 4        /**/
  886. #define SHORTSIZE 2        /**/
  887.  
  888. /* MULTIARCH:
  889.  *    This symbol, if defined, signifies that the build
  890.  *    process will produce some binary files that are going to be
  891.  *    used in a cross-platform environment.  This is the case for
  892.  *    example with the NeXT "fat" binaries that contain executables
  893.  *    for several CPUs.
  894.  */
  895. /*#define MULTIARCH        / **/
  896.  
  897. /* HAS_QUAD:
  898.  *    This symbol, if defined, tells that there's a 64-bit integer type,
  899.  *    Quad_t, and its unsigned counterpar, Uquad_t. QUADKIND will be one
  900.  *    of QUAD_IS_INT, QUAD_IS_LONG, QUAD_IS_LONG_LONG, or QUAD_IS_INT64_T.
  901.  */
  902. /*#define HAS_QUAD    / **/
  903. #ifdef HAS_QUAD
  904. #   define Quad_t int64_t    /**/
  905. #   define Uquad_t uint64_t    /**/
  906. #   define QUADKIND 4    /**/
  907. #   define QUAD_IS_INT    1
  908. #   define QUAD_IS_LONG    2
  909. #   define QUAD_IS_LONG_LONG    3
  910. #   define QUAD_IS_INT64_T    4
  911. #endif
  912.  
  913. /* HAS_ACCESSX:
  914.  *    This symbol, if defined, indicates that the accessx routine is
  915.  *    available to do extended access checks.
  916.  */
  917. /*#define HAS_ACCESSX        / **/
  918.  
  919. /* HAS_EACCESS:
  920.  *    This symbol, if defined, indicates that the eaccess routine is
  921.  *    available to do extended access checks.
  922.  */
  923. /*#define HAS_EACCESS        / **/
  924.  
  925. /* I_SYS_ACCESS:
  926.  *     This symbol, if defined, indicates to the C program that it should
  927.  *     include <sys/access.h>.
  928.  */
  929. /*#define   I_SYS_ACCESS                / **/
  930.  
  931. /* I_SYS_SECURITY:
  932.  *     This symbol, if defined, indicates to the C program that it should
  933.  *     include <sys/security.h>.
  934.  */
  935. /*#define   I_SYS_SECURITY    / **/
  936.  
  937. /* MEM_ALIGNBYTES:
  938.  *    This symbol contains the number of bytes required to align a
  939.  *    double, or a long double when applicable. Usual values are 2,
  940.  *    4 and 8. The default is eight, for safety.
  941.  */
  942. #if defined(USE_CROSS_COMPILE) || defined(MULTIARCH)
  943. #  define MEM_ALIGNBYTES 8
  944. #else
  945. #define MEM_ALIGNBYTES 4
  946. #endif
  947.  
  948. /* BYTEORDER:
  949.  *    This symbol holds the hexadecimal constant defined in byteorder,
  950.  *    in a UV, i.e. 0x1234 or 0x4321 or 0x12345678, etc...
  951.  *    If the compiler supports cross-compiling or multiple-architecture
  952.  *    binaries (eg. on NeXT systems), use compiler-defined macros to
  953.  *    determine the byte order.
  954.  *    On NeXT 3.2 (and greater), you can build "Fat" Multiple Architecture
  955.  *    Binaries (MAB) on either big endian or little endian machines.
  956.  *    The endian-ness is available at compile-time.  This only matters
  957.  *    for perl, where the config.h can be generated and installed on 
  958.  *    one system, and used by a different architecture to build an
  959.  *    extension.  Older versions of NeXT that might not have
  960.  *    defined either *_ENDIAN__ were all on Motorola 680x0 series,
  961.  *    so the default case (for NeXT) is big endian to catch them. 
  962.  *    This might matter for NeXT 3.0.
  963.  */
  964. #if defined(USE_CROSS_COMPILE) || defined(MULTIARCH)
  965. #  ifdef __LITTLE_ENDIAN__
  966. #    if LONGSIZE == 4
  967. #      define BYTEORDER 0x1234
  968. #    else
  969. #      if LONGSIZE == 8
  970. #        define BYTEORDER 0x12345678
  971. #      endif
  972. #    endif
  973. #  else
  974. #    ifdef __BIG_ENDIAN__
  975. #      if LONGSIZE == 4
  976. #        define BYTEORDER 0x4321
  977. #      else
  978. #        if LONGSIZE == 8
  979. #          define BYTEORDER 0x87654321
  980. #        endif
  981. #      endif
  982. #    endif
  983. #  endif
  984. #  if !defined(BYTEORDER) && (defined(NeXT) || defined(__NeXT__))
  985. #    define BYTEORDER 0x4321
  986. #  endif
  987. #else
  988. #define BYTEORDER 0x1234    /* large digits for MSB */
  989. #endif /* NeXT */
  990.  
  991. /* CASTI32:
  992.  *    This symbol is defined if the C compiler can cast negative
  993.  *    or large floating point numbers to 32-bit ints.
  994.  */
  995. /*#define    CASTI32        / **/
  996.  
  997. /* CASTNEGFLOAT:
  998.  *    This symbol is defined if the C compiler can cast negative
  999.  *    numbers to unsigned longs, ints and shorts.
  1000.  */
  1001. /* CASTFLAGS:
  1002.  *    This symbol contains flags that say what difficulties the compiler
  1003.  *    has casting odd floating values to unsigned long:
  1004.  *        0 = ok
  1005.  *        1 = couldn't cast < 0
  1006.  *        2 = couldn't cast >= 0x80000000
  1007.  *        4 = couldn't cast in argument expression list
  1008.  */
  1009. /*#define    CASTNEGFLOAT        / **/
  1010. #define CASTFLAGS 0        /**/
  1011.  
  1012. /* VOID_CLOSEDIR:
  1013.  *    This symbol, if defined, indicates that the closedir() routine
  1014.  *    does not return a value.
  1015.  */
  1016. /*#define VOID_CLOSEDIR        / **/
  1017.  
  1018. /* HAS_FD_SET:
  1019.  *    This symbol, when defined, indicates presence of the fd_set typedef
  1020.  *    in <sys/types.h>
  1021.  */
  1022. /*#define HAS_FD_SET    / **/
  1023.  
  1024. /* Gconvert:
  1025.  *    This preprocessor macro is defined to convert a floating point
  1026.  *    number to a string without a trailing decimal point.  This
  1027.  *    emulates the behavior of sprintf("%g"), but is sometimes much more
  1028.  *    efficient.  If gconvert() is not available, but gcvt() drops the
  1029.  *    trailing decimal point, then gcvt() is used.  If all else fails,
  1030.  *    a macro using sprintf("%g") is used. Arguments for the Gconvert
  1031.  *    macro are: value, number of digits, whether trailing zeros should
  1032.  *    be retained, and the output buffer.
  1033.  *    The usual values are:
  1034.  *        d_Gconvert='gconvert((x),(n),(t),(b))'
  1035.  *        d_Gconvert='gcvt((x),(n),(b))'
  1036.  *        d_Gconvert='sprintf((b),"%.*g",(n),(x))'
  1037.  *    The last two assume trailing zeros should not be kept.
  1038.  */
  1039. #define Gconvert(x,n,t,b) sprintf((b),"%.*g",(n),(x))
  1040.  
  1041. /* HAS_GETPAGESIZE:
  1042.  *    This symbol, if defined, indicates that the getpagesize system call
  1043.  *    is available to get system page size, which is the granularity of
  1044.  *    many memory management calls.
  1045.  */
  1046. /*#define HAS_GETPAGESIZE        / **/
  1047.  
  1048. /* HAS_GNULIBC:
  1049.  *    This symbol, if defined, indicates to the C program that 
  1050.  *    the GNU C library is being used.  A better check is to use
  1051.  *    the __GLIBC__ and __GLIBC_MINOR__ symbols supplied with glibc.
  1052.  */
  1053. /*#define HAS_GNULIBC      / **/
  1054. #if defined(HAS_GNULIBC) && !defined(_GNU_SOURCE)
  1055. #   define _GNU_SOURCE
  1056. #endif
  1057. /* HAS_ISASCII:
  1058.  *    This manifest constant lets the C program know that isascii 
  1059.  *    is available.
  1060.  */
  1061. /*#define HAS_ISASCII        / **/
  1062.  
  1063. /* HAS_LCHOWN:
  1064.  *    This symbol, if defined, indicates that the lchown routine is
  1065.  *    available to operate on a symbolic link (instead of following the
  1066.  *    link).
  1067.  */
  1068. /*#define HAS_LCHOWN        / **/
  1069.  
  1070. /* HAS_OPEN3:
  1071.  *    This manifest constant lets the C program know that the three
  1072.  *    argument form of open(2) is available.
  1073.  */
  1074. /*#define HAS_OPEN3        / **/
  1075.  
  1076. /* HAS_SAFE_BCOPY:
  1077.  *    This symbol, if defined, indicates that the bcopy routine is available
  1078.  *    to copy potentially overlapping memory blocks. Normally, you should
  1079.  *    probably use memmove() or memcpy(). If neither is defined, roll your
  1080.  *    own version.
  1081.  */
  1082. /*#define HAS_SAFE_BCOPY    / **/
  1083.  
  1084. /* HAS_SAFE_MEMCPY:
  1085.  *    This symbol, if defined, indicates that the memcpy routine is available
  1086.  *    to copy potentially overlapping memory blocks.  If you need to
  1087.  *    copy overlapping memory blocks, you should check HAS_MEMMOVE and
  1088.  *    use memmove() instead, if available.
  1089.  */
  1090. /*#define HAS_SAFE_MEMCPY    / **/
  1091.  
  1092. /* HAS_SANE_MEMCMP:
  1093.  *    This symbol, if defined, indicates that the memcmp routine is available
  1094.  *    and can be used to compare relative magnitudes of chars with their high
  1095.  *    bits set.  If it is not defined, roll your own version.
  1096.  */
  1097. /*#define HAS_SANE_MEMCMP    / **/
  1098.  
  1099. /* HAS_SIGACTION:
  1100.  *    This symbol, if defined, indicates that Vr4's sigaction() routine
  1101.  *    is available.
  1102.  */
  1103. /*#define HAS_SIGACTION    / **/
  1104.  
  1105. /* HAS_SIGSETJMP:
  1106.  *    This variable indicates to the C program that the sigsetjmp()
  1107.  *    routine is available to save the calling process's registers
  1108.  *    and stack environment for later use by siglongjmp(), and
  1109.  *    to optionally save the process's signal mask.  See
  1110.  *    Sigjmp_buf, Sigsetjmp, and Siglongjmp.
  1111.  */
  1112. /* Sigjmp_buf:
  1113.  *    This is the buffer type to be used with Sigsetjmp and Siglongjmp.
  1114.  */
  1115. /* Sigsetjmp:
  1116.  *    This macro is used in the same way as sigsetjmp(), but will invoke
  1117.  *    traditional setjmp() if sigsetjmp isn't available.
  1118.  *    See HAS_SIGSETJMP.
  1119.  */
  1120. /* Siglongjmp:
  1121.  *    This macro is used in the same way as siglongjmp(), but will invoke
  1122.  *    traditional longjmp() if siglongjmp isn't available.
  1123.  *    See HAS_SIGSETJMP.
  1124.  */
  1125. /*#define HAS_SIGSETJMP    / **/
  1126. #ifdef HAS_SIGSETJMP
  1127. #define Sigjmp_buf sigjmp_buf
  1128. #define Sigsetjmp(buf,save_mask) sigsetjmp((buf),(save_mask))
  1129. #define Siglongjmp(buf,retval) siglongjmp((buf),(retval))
  1130. #else
  1131. #define Sigjmp_buf jmp_buf
  1132. #define Sigsetjmp(buf,save_mask) setjmp((buf))
  1133. #define Siglongjmp(buf,retval) longjmp((buf),(retval))
  1134. #endif
  1135.  
  1136. /* USE_STDIO_PTR:
  1137.  *    This symbol is defined if the _ptr and _cnt fields (or similar)
  1138.  *    of the stdio FILE structure can be used to access the stdio buffer
  1139.  *    for a file handle.  If this is defined, then the FILE_ptr(fp)
  1140.  *    and FILE_cnt(fp) macros will also be defined and should be used
  1141.  *    to access these fields.
  1142.  */
  1143. /* FILE_ptr:
  1144.  *    This macro is used to access the _ptr field (or equivalent) of the
  1145.  *    FILE structure pointed to by its argument. This macro will always be
  1146.  *    defined if USE_STDIO_PTR is defined.
  1147.  */
  1148. /* STDIO_PTR_LVALUE:
  1149.  *    This symbol is defined if the FILE_ptr macro can be used as an
  1150.  *    lvalue.
  1151.  */
  1152. /* FILE_cnt:
  1153.  *    This macro is used to access the _cnt field (or equivalent) of the
  1154.  *    FILE structure pointed to by its argument. This macro will always be
  1155.  *    defined if USE_STDIO_PTR is defined.
  1156.  */
  1157. /* STDIO_CNT_LVALUE:
  1158.  *    This symbol is defined if the FILE_cnt macro can be used as an
  1159.  *    lvalue.
  1160.  */
  1161. /* STDIO_PTR_LVAL_SETS_CNT:
  1162.  *    This symbol is defined if using the FILE_ptr macro as an lvalue
  1163.  *    to increase the pointer by n has the side effect of decreasing the
  1164.  *    value of File_cnt(fp) by n.
  1165.  */
  1166. /* STDIO_PTR_LVAL_NOCHANGE_CNT:
  1167.  *    This symbol is defined if using the FILE_ptr macro as an lvalue
  1168.  *    to increase the pointer by n leaves File_cnt(fp) unchanged.
  1169.  */
  1170. /*#define USE_STDIO_PTR     / **/
  1171. #ifdef USE_STDIO_PTR
  1172. #define FILE_ptr(fp)    ((fp)->_IO_read_ptr)
  1173. /*#define STDIO_PTR_LVALUE         / **/
  1174. #define FILE_cnt(fp)    ((fp)->_IO_read_end - (fp)->_IO_read_ptr)
  1175. /*#define STDIO_CNT_LVALUE         / **/
  1176. /*#define STDIO_PTR_LVAL_SETS_CNT    / **/
  1177. /*#define STDIO_PTR_LVAL_NOCHANGE_CNT    / **/
  1178. #endif
  1179.  
  1180. /* USE_STDIO_BASE:
  1181.  *    This symbol is defined if the _base field (or similar) of the
  1182.  *    stdio FILE structure can be used to access the stdio buffer for
  1183.  *    a file handle.  If this is defined, then the FILE_base(fp) macro
  1184.  *    will also be defined and should be used to access this field.
  1185.  *    Also, the FILE_bufsiz(fp) macro will be defined and should be used
  1186.  *    to determine the number of bytes in the buffer.  USE_STDIO_BASE
  1187.  *    will never be defined unless USE_STDIO_PTR is.
  1188.  */
  1189. /* FILE_base:
  1190.  *    This macro is used to access the _base field (or equivalent) of the
  1191.  *    FILE structure pointed to by its argument. This macro will always be
  1192.  *    defined if USE_STDIO_BASE is defined.
  1193.  */
  1194. /* FILE_bufsiz:
  1195.  *    This macro is used to determine the number of bytes in the I/O
  1196.  *    buffer pointed to by _base field (or equivalent) of the FILE
  1197.  *    structure pointed to its argument. This macro will always be defined
  1198.  *    if USE_STDIO_BASE is defined.
  1199.  */
  1200. /*#define USE_STDIO_BASE     / **/
  1201. #ifdef USE_STDIO_BASE
  1202. #define FILE_base(fp)    ((fp)->_IO_read_base)
  1203. #define FILE_bufsiz(fp)    ((fp)->_IO_read_end - (fp)->_IO_read_base)
  1204. #endif
  1205.  
  1206. /* HAS_VPRINTF:
  1207.  *    This symbol, if defined, indicates that the vprintf routine is available
  1208.  *    to printf with a pointer to an argument list.  If unavailable, you
  1209.  *    may need to write your own, probably in terms of _doprnt().
  1210.  */
  1211. /* USE_CHAR_VSPRINTF:
  1212.  *    This symbol is defined if this system has vsprintf() returning type
  1213.  *    (char*).  The trend seems to be to declare it as "int vsprintf()".  It
  1214.  *    is up to the package author to declare vsprintf correctly based on the
  1215.  *    symbol.
  1216.  */
  1217. #define HAS_VPRINTF    /**/
  1218. /*#define USE_CHAR_VSPRINTF     / **/
  1219.  
  1220. /* DOUBLESIZE:
  1221.  *    This symbol contains the size of a double, so that the C preprocessor
  1222.  *    can make decisions based on it.
  1223.  */
  1224. #define DOUBLESIZE 8        /**/
  1225.  
  1226. /* I_TIME:
  1227.  *    This symbol, if defined, indicates to the C program that it should
  1228.  *    include <time.h>.
  1229.  */
  1230. /* I_SYS_TIME:
  1231.  *    This symbol, if defined, indicates to the C program that it should
  1232.  *    include <sys/time.h>.
  1233.  */
  1234. /* I_SYS_TIME_KERNEL:
  1235.  *    This symbol, if defined, indicates to the C program that it should
  1236.  *    include <sys/time.h> with KERNEL defined.
  1237.  */
  1238. /* HAS_TM_TM_ZONE:
  1239.  *    This symbol, if defined, indicates to the C program that
  1240.  *    the struct tm has a tm_zone field.
  1241.  */
  1242. /* HAS_TM_TM_GMTOFF:
  1243.  *    This symbol, if defined, indicates to the C program that
  1244.  *    the struct tm has a tm_gmtoff field.
  1245.  */
  1246. #define I_TIME        /**/
  1247. /*#define I_SYS_TIME        / **/
  1248. /*#define I_SYS_TIME_KERNEL        / **/
  1249. /*#define HAS_TM_TM_ZONE        / **/
  1250. /*#define HAS_TM_TM_GMTOFF        / **/
  1251.  
  1252. /* VAL_O_NONBLOCK:
  1253.  *    This symbol is to be used during open() or fcntl(F_SETFL) to turn on
  1254.  *    non-blocking I/O for the file descriptor. Note that there is no way
  1255.  *    back, i.e. you cannot turn it blocking again this way. If you wish to
  1256.  *    alternatively switch between blocking and non-blocking, use the
  1257.  *    ioctl(FIOSNBIO) call instead, but that is not supported by all devices.
  1258.  */
  1259. /* VAL_EAGAIN:
  1260.  *    This symbol holds the errno error code set by read() when no data was
  1261.  *    present on the non-blocking file descriptor.
  1262.  */
  1263. /* RD_NODATA:
  1264.  *    This symbol holds the return code from read() when no data is present
  1265.  *    on the non-blocking file descriptor. Be careful! If EOF_NONBLOCK is
  1266.  *    not defined, then you can't distinguish between no data and EOF by
  1267.  *    issuing a read(). You'll have to find another way to tell for sure!
  1268.  */
  1269. /* EOF_NONBLOCK:
  1270.  *    This symbol, if defined, indicates to the C program that a read() on
  1271.  *    a non-blocking file descriptor will return 0 on EOF, and not the value
  1272.  *    held in RD_NODATA (-1 usually, in that case!).
  1273.  */
  1274. #define VAL_O_NONBLOCK O_NONBLOCK
  1275. #define VAL_EAGAIN EAGAIN
  1276. #define RD_NODATA -1
  1277. #undef EOF_NONBLOCK
  1278.  
  1279. /* PTRSIZE:
  1280.  *    This symbol contains the size of a pointer, so that the C preprocessor
  1281.  *    can make decisions based on it.  It will be sizeof(void *) if
  1282.  *    the compiler supports (void *); otherwise it will be
  1283.  *    sizeof(char *).
  1284.  */
  1285. #define PTRSIZE 4        /**/
  1286.  
  1287. /* Drand01:
  1288.  *    This macro is to be used to generate uniformly distributed
  1289.  *    random numbers over the range [0., 1.[.  You may have to supply
  1290.  *    an 'extern double drand48();' in your program since SunOS 4.1.3
  1291.  *    doesn't provide you with anything relevant in its headers.
  1292.  *    See HAS_DRAND48_PROTO.
  1293.  */
  1294. /* Rand_seed_t:
  1295.  *    This symbol defines the type of the argument of the
  1296.  *    random seed function.
  1297.  */
  1298. /* seedDrand01:
  1299.  *    This symbol defines the macro to be used in seeding the
  1300.  *    random number generator (see Drand01).
  1301.  */
  1302. /* RANDBITS:
  1303.  *    This symbol indicates how many bits are produced by the
  1304.  *    function used to generate normalized random numbers.
  1305.  *    Values include 15, 16, 31, and 48.
  1306.  */
  1307. #define Drand01()        ((rand() & 0x7FFF) / (double) ((unsigned long)1 << 15))        /**/
  1308. #define Rand_seed_t        int        /**/
  1309. #define seedDrand01(x)    srand((Rand_seed_t)x)    /**/
  1310. #define RANDBITS        48        /**/
  1311.  
  1312. /* SSize_t:
  1313.  *    This symbol holds the type used by functions that return
  1314.  *    a count of bytes or an error condition.  It must be a signed type.
  1315.  *    It is usually ssize_t, but may be long or int, etc.
  1316.  *    It may be necessary to include <sys/types.h> or <unistd.h>
  1317.  *    to get any typedef'ed information.
  1318.  *    We will pick a type such that sizeof(SSize_t) == sizeof(Size_t).
  1319.  */
  1320. #define SSize_t int     /* signed count of bytes */
  1321.  
  1322. /* EBCDIC:
  1323.  *     This symbol, if defined, indicates that this system uses
  1324.  *    EBCDIC encoding.
  1325.  */
  1326. /*#define    EBCDIC         / **/
  1327.  
  1328. /* ARCHLIB:
  1329.  *    This variable, if defined, holds the name of the directory in
  1330.  *    which the user wants to put architecture-dependent public
  1331.  *    library files for .  It is most often a local directory
  1332.  *    such as /usr/local/lib.  Programs using this variable must be
  1333.  *    prepared to deal with filename expansion.  If ARCHLIB is the
  1334.  *    same as PRIVLIB, it is not defined, since presumably the
  1335.  *    program already searches PRIVLIB.
  1336.  */
  1337. /* ARCHLIB_EXP:
  1338.  *    This symbol contains the ~name expanded version of ARCHLIB, to be used
  1339.  *    in programs that are not prepared to deal with ~ expansion at run-time.
  1340.  */
  1341. /*#define ARCHLIB "/usr/local/lib/perl5/5.7/unknown"        / **/
  1342. /*#define ARCHLIB_EXP "/usr/local/lib/perl5/5.7/unknown"        / **/
  1343.  
  1344. /* BIN:
  1345.  *    This symbol holds the path of the bin directory where the package will
  1346.  *    be installed. Program must be prepared to deal with ~name substitution.
  1347.  */
  1348. /* BIN_EXP:
  1349.  *    This symbol is the filename expanded version of the BIN symbol, for
  1350.  *    programs that do not want to deal with that at run-time.
  1351.  */
  1352. #define BIN "/usr/local/bin"    /**/
  1353. #define BIN_EXP ""    /**/
  1354.  
  1355. /* PERL_INC_VERSION_LIST:
  1356.  *    This variable specifies the list of subdirectories in over
  1357.  *    which perl.c:incpush() and lib/lib.pm will automatically
  1358.  *    search when adding directories to @INC, in a format suitable
  1359.  *    for a C initialization string.  See the inc_version_list entry
  1360.  *    in Porting/Glossary for more details.
  1361.  */
  1362. #define PERL_INC_VERSION_LIST NULL        /**/
  1363.  
  1364. /* INSTALL_USR_BIN_PERL:
  1365.  *    This symbol, if defined, indicates that Perl is to be installed
  1366.  *     also as /usr/bin/perl.
  1367.  */
  1368. /*#define INSTALL_USR_BIN_PERL    / **/
  1369.  
  1370. /* PERL_OTHERLIBDIRS:
  1371.  *    This variable contains a colon-separated set of paths for the perl
  1372.  *    binary to search for additional library files or modules.
  1373.  *    These directories will be tacked to the end of @INC.
  1374.  *    Perl will automatically search below each path for version-
  1375.  *    and architecture-specific directories.  See PERL_INC_VERSION_LIST
  1376.  *    for more details.
  1377.  */
  1378. /*#define PERL_OTHERLIBDIRS ""        / **/
  1379.  
  1380. /* PRIVLIB:
  1381.  *    This symbol contains the name of the private library for this package.
  1382.  *    The library is private in the sense that it needn't be in anyone's
  1383.  *    execution path, but it should be accessible by the world.  The program
  1384.  *    should be prepared to do ~ expansion.
  1385.  */
  1386. /* PRIVLIB_EXP:
  1387.  *    This symbol contains the ~name expanded version of PRIVLIB, to be used
  1388.  *    in programs that are not prepared to deal with ~ expansion at run-time.
  1389.  */
  1390. #define PRIVLIB "/usr/local/lib/perl5/5.7"        /**/
  1391. #define PRIVLIB_EXP "/usr/local/lib/perl5/5.7"        /**/
  1392.  
  1393. /* SITEARCH:
  1394.  *    This symbol contains the name of the private library for this package.
  1395.  *    The library is private in the sense that it needn't be in anyone's
  1396.  *    execution path, but it should be accessible by the world.  The program
  1397.  *    should be prepared to do ~ expansion.
  1398.  *    The standard distribution will put nothing in this directory.
  1399.  *    After perl has been installed, users may install their own local
  1400.  *    architecture-dependent modules in this directory with
  1401.  *        MakeMaker Makefile.PL
  1402.  *    or equivalent.  See INSTALL for details.
  1403.  */
  1404. /* SITEARCH_EXP:
  1405.  *    This symbol contains the ~name expanded version of SITEARCH, to be used
  1406.  *    in programs that are not prepared to deal with ~ expansion at run-time.
  1407.  */
  1408. #define SITEARCH ""        /**/
  1409. #define SITEARCH_EXP ""        /**/
  1410.  
  1411. /* SITELIB:
  1412.  *    This symbol contains the name of the private library for this package.
  1413.  *    The library is private in the sense that it needn't be in anyone's
  1414.  *    execution path, but it should be accessible by the world.  The program
  1415.  *    should be prepared to do ~ expansion.
  1416.  *    The standard distribution will put nothing in this directory.
  1417.  *    After perl has been installed, users may install their own local
  1418.  *    architecture-independent modules in this directory with
  1419.  *        MakeMaker Makefile.PL
  1420.  *    or equivalent.  See INSTALL for details.
  1421.  */
  1422. /* SITELIB_EXP:
  1423.  *    This symbol contains the ~name expanded version of SITELIB, to be used
  1424.  *    in programs that are not prepared to deal with ~ expansion at run-time.
  1425.  */
  1426. /* SITELIB_STEM:
  1427.  *    This define is SITELIB_EXP with any trailing version-specific component
  1428.  *    removed.  The elements in inc_version_list (inc_version_list.U) can
  1429.  *    be tacked onto this variable to generate a list of directories to search.
  1430.  */
  1431. #define SITELIB ""        /**/
  1432. #define SITELIB_EXP ""        /**/
  1433. #define SITELIB_STEM ""        /**/
  1434.  
  1435. /* PERL_VENDORARCH:
  1436.  *    If defined, this symbol contains the name of a private library.
  1437.  *    The library is private in the sense that it needn't be in anyone's
  1438.  *    execution path, but it should be accessible by the world.
  1439.  *    It may have a ~ on the front. 
  1440.  *    The standard distribution will put nothing in this directory.
  1441.  *    Vendors who distribute perl may wish to place their own
  1442.  *    architecture-dependent modules and extensions in this directory with
  1443.  *        MakeMaker Makefile.PL INSTALLDIRS=vendor 
  1444.  *    or equivalent.  See INSTALL for details.
  1445.  */
  1446. /* PERL_VENDORARCH_EXP:
  1447.  *    This symbol contains the ~name expanded version of PERL_VENDORARCH, to be used
  1448.  *    in programs that are not prepared to deal with ~ expansion at run-time.
  1449.  */
  1450. /*#define PERL_VENDORARCH ""        / **/
  1451. /*#define PERL_VENDORARCH_EXP ""        / **/
  1452.  
  1453. /* PERL_VENDORLIB_EXP:
  1454.  *    This symbol contains the ~name expanded version of VENDORLIB, to be used
  1455.  *    in programs that are not prepared to deal with ~ expansion at run-time.
  1456.  */
  1457. /* PERL_VENDORLIB_STEM:
  1458.  *    This define is PERL_VENDORLIB_EXP with any trailing version-specific component
  1459.  *    removed.  The elements in inc_version_list (inc_version_list.U) can
  1460.  *    be tacked onto this variable to generate a list of directories to search.
  1461.  */
  1462. /*#define PERL_VENDORLIB_EXP ""        / **/
  1463. /*#define PERL_VENDORLIB_STEM ""        / **/
  1464.  
  1465. /* OSNAME:
  1466.  *    This symbol contains the name of the operating system, as determined
  1467.  *    by Configure.  You shouldn't rely on it too much; the specific
  1468.  *    feature tests from Configure are generally more reliable.
  1469.  */
  1470. /* OSVERS:
  1471.  *    This symbol contains the version of the operating system, as determined
  1472.  *    by Configure.  You shouldn't rely on it too much; the specific
  1473.  *    feature tests from Configure are generally more reliable.
  1474.  */
  1475. #define OSNAME "unknown"        /**/
  1476. #define OSVERS ""        /**/
  1477.  
  1478. /* CAT2:
  1479.  *    This macro concatenates 2 tokens together.
  1480.  */
  1481. /* STRINGIFY:
  1482.  *    This macro surrounds its token with double quotes.
  1483.  */
  1484. #if 42 == 1
  1485. #define CAT2(a,b)    a/**/b
  1486. #define STRINGIFY(a)    "a"
  1487.         /* If you can get stringification with catify, tell me how! */
  1488. #endif
  1489. #if 42 == 42
  1490. #define PeRl_CaTiFy(a, b)    a ## b    
  1491. #define PeRl_StGiFy(a)    #a
  1492. /* the additional level of indirection enables these macros to be
  1493.  * used as arguments to other macros.  See K&R 2nd ed., page 231. */
  1494. #define CAT2(a,b)    PeRl_CaTiFy(a,b)
  1495. #define StGiFy(a)    PeRl_StGiFy(a)
  1496. #define STRINGIFY(a)    PeRl_StGiFy(a)
  1497. #endif
  1498. #if 42 != 1 && 42 != 42
  1499. #   include "Bletch: How does this C preprocessor concatenate tokens?"
  1500. #endif
  1501.  
  1502. /* CPPSTDIN:
  1503.  *    This symbol contains the first part of the string which will invoke
  1504.  *    the C preprocessor on the standard input and produce to standard
  1505.  *    output.     Typical value of "cc -E" or "/lib/cpp", but it can also
  1506.  *    call a wrapper. See CPPRUN.
  1507.  */
  1508. /* CPPMINUS:
  1509.  *    This symbol contains the second part of the string which will invoke
  1510.  *    the C preprocessor on the standard input and produce to standard
  1511.  *    output.  This symbol will have the value "-" if CPPSTDIN needs a minus
  1512.  *    to specify standard input, otherwise the value is "".
  1513.  */
  1514. /* CPPRUN:
  1515.  *    This symbol contains the string which will invoke a C preprocessor on
  1516.  *    the standard input and produce to standard output. It needs to end
  1517.  *    with CPPLAST, after all other preprocessor flags have been specified.
  1518.  *    The main difference with CPPSTDIN is that this program will never be a
  1519.  *    pointer to a shell wrapper, i.e. it will be empty if no preprocessor is
  1520.  *    available directly to the user. Note that it may well be different from
  1521.  *    the preprocessor used to compile the C program.
  1522.  */
  1523. /* CPPLAST:
  1524.  *    This symbol is intended to be used along with CPPRUN in the same manner
  1525.  *    symbol CPPMINUS is used with CPPSTDIN. It contains either "-" or "".
  1526.  */
  1527. #define CPPSTDIN ""
  1528. #define CPPMINUS ""
  1529. #define CPPRUN ""
  1530. #define CPPLAST ""
  1531.  
  1532. /* HAS_ACCESS:
  1533.  *    This manifest constant lets the C program know that the access()
  1534.  *    system call is available to check for accessibility using real UID/GID.
  1535.  *    (always present on UNIX.)
  1536.  */
  1537. /*#define HAS_ACCESS        / **/
  1538.  
  1539. /* HASATTRIBUTE:
  1540.  *    This symbol indicates the C compiler can check for function attributes,
  1541.  *    such as printf formats. This is normally only supported by GNU cc.
  1542.  */
  1543. /*#define HASATTRIBUTE     / **/
  1544. #ifndef HASATTRIBUTE
  1545. #ifdef __attribute__
  1546. #undef __attribute__
  1547. #endif
  1548. #define __attribute__(_arg_)
  1549. #endif
  1550.  
  1551. /* HAS_CRYPT:
  1552.  *    This symbol, if defined, indicates that the crypt routine is available
  1553.  *    to encrypt passwords and the like.
  1554.  */
  1555. /*#define HAS_CRYPT        / **/
  1556.  
  1557. /* HAS_CSH:
  1558.  *    This symbol, if defined, indicates that the C-shell exists.
  1559.  */
  1560. /* CSH:
  1561.  *    This symbol, if defined, contains the full pathname of csh.
  1562.  */
  1563. /*#define HAS_CSH        / **/
  1564. #ifdef HAS_CSH
  1565. #define CSH ""    /**/
  1566. #endif
  1567.  
  1568. /* SETUID_SCRIPTS_ARE_SECURE_NOW:
  1569.  *    This symbol, if defined, indicates that the bug that prevents
  1570.  *    setuid scripts from being secure is not present in this kernel.
  1571.  */
  1572. /* DOSUID:
  1573.  *    This symbol, if defined, indicates that the C program should
  1574.  *    check the script that it is executing for setuid/setgid bits, and
  1575.  *    attempt to emulate setuid/setgid on systems that have disabled
  1576.  *    setuid #! scripts because the kernel can't do it securely.
  1577.  *    It is up to the package designer to make sure that this emulation
  1578.  *    is done securely.  Among other things, it should do an fstat on
  1579.  *    the script it just opened to make sure it really is a setuid/setgid
  1580.  *    script, it should make sure the arguments passed correspond exactly
  1581.  *    to the argument on the #! line, and it should not trust any
  1582.  *    subprocesses to which it must pass the filename rather than the
  1583.  *    file descriptor of the script to be executed.
  1584.  */
  1585. /*#define SETUID_SCRIPTS_ARE_SECURE_NOW    / **/
  1586. /*#define DOSUID        / **/
  1587.  
  1588. /* HAS_ENDGRENT:
  1589.  *    This symbol, if defined, indicates that the getgrent routine is
  1590.  *    available for finalizing sequential access of the group database.
  1591.  */
  1592. /*#define HAS_ENDGRENT        / **/
  1593.  
  1594. /* HAS_ENDHOSTENT:
  1595.  *    This symbol, if defined, indicates that the endhostent() routine is
  1596.  *    available to close whatever was being used for host queries.
  1597.  */
  1598. /*#define HAS_ENDHOSTENT        / **/
  1599.  
  1600. /* HAS_ENDNETENT:
  1601.  *    This symbol, if defined, indicates that the endnetent() routine is
  1602.  *    available to close whatever was being used for network queries.
  1603.  */
  1604. /*#define HAS_ENDNETENT        / **/
  1605.  
  1606. /* HAS_ENDPROTOENT:
  1607.  *    This symbol, if defined, indicates that the endprotoent() routine is
  1608.  *    available to close whatever was being used for protocol queries.
  1609.  */
  1610. /*#define HAS_ENDPROTOENT        / **/
  1611.  
  1612. /* HAS_ENDPWENT:
  1613.  *    This symbol, if defined, indicates that the getgrent routine is
  1614.  *    available for finalizing sequential access of the passwd database.
  1615.  */
  1616. /*#define HAS_ENDPWENT        / **/
  1617.  
  1618. /* HAS_ENDSERVENT:
  1619.  *    This symbol, if defined, indicates that the endservent() routine is
  1620.  *    available to close whatever was being used for service queries.
  1621.  */
  1622. /*#define HAS_ENDSERVENT        / **/
  1623.  
  1624. /* FLEXFILENAMES:
  1625.  *    This symbol, if defined, indicates that the system supports filenames
  1626.  *    longer than 14 characters.
  1627.  */
  1628. /*#define    FLEXFILENAMES        / **/
  1629.  
  1630. /* HAS_GETGRENT:
  1631.  *    This symbol, if defined, indicates that the getgrent routine is
  1632.  *    available for sequential access of the group database.
  1633.  */
  1634. /*#define HAS_GETGRENT        / **/
  1635.  
  1636. /* HAS_GETHOSTBYADDR:
  1637.  *    This symbol, if defined, indicates that the gethostbyaddr() routine is
  1638.  *    available to look up hosts by their IP addresses.
  1639.  */
  1640. /*#define HAS_GETHOSTBYADDR        / **/
  1641.  
  1642. /* HAS_GETHOSTBYNAME:
  1643.  *    This symbol, if defined, indicates that the gethostbyname() routine is
  1644.  *    available to look up host names in some data base or other.
  1645.  */
  1646. /*#define HAS_GETHOSTBYNAME        / **/
  1647.  
  1648. /* HAS_GETHOSTENT:
  1649.  *    This symbol, if defined, indicates that the gethostent() routine is
  1650.  *    available to look up host names in some data base or another.
  1651.  */
  1652. /*#define HAS_GETHOSTENT        / **/
  1653.  
  1654. /* HAS_GETHOSTNAME:
  1655.  *    This symbol, if defined, indicates that the C program may use the
  1656.  *    gethostname() routine to derive the host name.  See also HAS_UNAME
  1657.  *    and PHOSTNAME.
  1658.  */
  1659. /* HAS_UNAME:
  1660.  *    This symbol, if defined, indicates that the C program may use the
  1661.  *    uname() routine to derive the host name.  See also HAS_GETHOSTNAME
  1662.  *    and PHOSTNAME.
  1663.  */
  1664. /* PHOSTNAME:
  1665.  *    This symbol, if defined, indicates the command to feed to the
  1666.  *    popen() routine to derive the host name.  See also HAS_GETHOSTNAME
  1667.  *    and HAS_UNAME.    Note that the command uses a fully qualified path,
  1668.  *    so that it is safe even if used by a process with super-user
  1669.  *    privileges.
  1670.  */
  1671. /* HAS_PHOSTNAME:
  1672.  *    This symbol, if defined, indicates that the C program may use the
  1673.  *    contents of PHOSTNAME as a command to feed to the popen() routine
  1674.  *    to derive the host name.
  1675.  */
  1676. /*#define HAS_GETHOSTNAME    / **/
  1677. /*#define HAS_UNAME        / **/
  1678. /*#define HAS_PHOSTNAME    / **/
  1679. #ifdef HAS_PHOSTNAME
  1680. #define PHOSTNAME ""    /* How to get the host name */
  1681. #endif
  1682.  
  1683. /* HAS_GETNETBYADDR:
  1684.  *    This symbol, if defined, indicates that the getnetbyaddr() routine is
  1685.  *    available to look up networks by their IP addresses.
  1686.  */
  1687. /*#define HAS_GETNETBYADDR        / **/
  1688.  
  1689. /* HAS_GETNETBYNAME:
  1690.  *    This symbol, if defined, indicates that the getnetbyname() routine is
  1691.  *    available to look up networks by their names.
  1692.  */
  1693. /*#define HAS_GETNETBYNAME        / **/
  1694.  
  1695. /* HAS_GETNETENT:
  1696.  *    This symbol, if defined, indicates that the getnetent() routine is
  1697.  *    available to look up network names in some data base or another.
  1698.  */
  1699. /*#define HAS_GETNETENT        / **/
  1700.  
  1701. /* HAS_GETPROTOENT:
  1702.  *    This symbol, if defined, indicates that the getprotoent() routine is
  1703.  *    available to look up protocols in some data base or another.
  1704.  */
  1705. /*#define HAS_GETPROTOENT        / **/
  1706.  
  1707. /* HAS_GETPGRP:
  1708.  *    This symbol, if defined, indicates that the getpgrp routine is
  1709.  *    available to get the current process group.
  1710.  */
  1711. /* USE_BSD_GETPGRP:
  1712.  *    This symbol, if defined, indicates that getpgrp needs one
  1713.  *    arguments whereas USG one needs none.
  1714.  */
  1715. /*#define HAS_GETPGRP        / **/
  1716. /*#define USE_BSD_GETPGRP    / **/
  1717.  
  1718. /* HAS_GETPROTOBYNAME:
  1719.  *    This symbol, if defined, indicates that the getprotobyname()
  1720.  *    routine is available to look up protocols by their name.
  1721.  */
  1722. /* HAS_GETPROTOBYNUMBER:
  1723.  *    This symbol, if defined, indicates that the getprotobynumber()
  1724.  *    routine is available to look up protocols by their number.
  1725.  */
  1726. /*#define HAS_GETPROTOBYNAME        / **/
  1727. /*#define HAS_GETPROTOBYNUMBER        / **/
  1728.  
  1729. /* HAS_GETPWENT:
  1730.  *    This symbol, if defined, indicates that the getpwent routine is
  1731.  *    available for sequential access of the passwd database.
  1732.  *    If this is not available, the older getpw() function may be available.
  1733.  */
  1734. /*#define HAS_GETPWENT        / **/
  1735.  
  1736. /* HAS_GETSERVENT:
  1737.  *    This symbol, if defined, indicates that the getservent() routine is
  1738.  *    available to look up network services in some data base or another.
  1739.  */
  1740. /*#define HAS_GETSERVENT        / **/
  1741.  
  1742. /* HAS_GETSERVBYNAME:
  1743.  *    This symbol, if defined, indicates that the getservbyname()
  1744.  *    routine is available to look up services by their name.
  1745.  */
  1746. /* HAS_GETSERVBYPORT:
  1747.  *    This symbol, if defined, indicates that the getservbyport()
  1748.  *    routine is available to look up services by their port.
  1749.  */
  1750. /*#define HAS_GETSERVBYNAME        / **/
  1751. /*#define HAS_GETSERVBYPORT        / **/
  1752.  
  1753. /* HAS_HTONL:
  1754.  *    This symbol, if defined, indicates that the htonl() routine (and
  1755.  *    friends htons() ntohl() ntohs()) are available to do network
  1756.  *    order byte swapping.
  1757.  */
  1758. /* HAS_HTONS:
  1759.  *    This symbol, if defined, indicates that the htons() routine (and
  1760.  *    friends htonl() ntohl() ntohs()) are available to do network
  1761.  *    order byte swapping.
  1762.  */
  1763. /* HAS_NTOHL:
  1764.  *    This symbol, if defined, indicates that the ntohl() routine (and
  1765.  *    friends htonl() htons() ntohs()) are available to do network
  1766.  *    order byte swapping.
  1767.  */
  1768. /* HAS_NTOHS:
  1769.  *    This symbol, if defined, indicates that the ntohs() routine (and
  1770.  *    friends htonl() htons() ntohl()) are available to do network
  1771.  *    order byte swapping.
  1772.  */
  1773. /*#define HAS_HTONL        / **/
  1774. /*#define HAS_HTONS        / **/
  1775. /*#define HAS_NTOHL        / **/
  1776. /*#define HAS_NTOHS        / **/
  1777.  
  1778. /* HAS_LONG_DOUBLE:
  1779.  *    This symbol will be defined if the C compiler supports long
  1780.  *    doubles.
  1781.  */
  1782. /* LONG_DOUBLESIZE:
  1783.  *    This symbol contains the size of a long double, so that the 
  1784.  *    C preprocessor can make decisions based on it.  It is only
  1785.  *    defined if the system supports long doubles.
  1786.  */
  1787. /*#define HAS_LONG_DOUBLE        / **/
  1788. #ifdef HAS_LONG_DOUBLE
  1789. #define LONG_DOUBLESIZE 8        /**/
  1790. #endif
  1791.  
  1792. /* HAS_LONG_LONG:
  1793.  *    This symbol will be defined if the C compiler supports long long.
  1794.  */
  1795. /* LONGLONGSIZE:
  1796.  *    This symbol contains the size of a long long, so that the 
  1797.  *    C preprocessor can make decisions based on it.  It is only
  1798.  *    defined if the system supports long long.
  1799.  */
  1800. /*#define HAS_LONG_LONG        / **/
  1801. #ifdef HAS_LONG_LONG
  1802. #define LONGLONGSIZE 8        /**/
  1803. #endif
  1804.  
  1805. /* HAS_MEMCHR:
  1806.  *    This symbol, if defined, indicates that the memchr routine is available
  1807.  *    to locate characters within a C string.
  1808.  */
  1809. /*#define HAS_MEMCHR    / **/
  1810.  
  1811. /* HAS_MKSTEMP:
  1812.  *    This symbol, if defined, indicates that the mkstemp routine is
  1813.  *    available to exclusively create and open a uniquely named
  1814.  *    temporary file.
  1815.  */
  1816. /*#define HAS_MKSTEMP        / **/
  1817.  
  1818. /* HAS_MMAP:
  1819.  *    This symbol, if defined, indicates that the mmap system call is
  1820.  *    available to map a file into memory.
  1821.  */
  1822. /* Mmap_t:
  1823.  *    This symbol holds the return type of the mmap() system call
  1824.  *    (and simultaneously the type of the first argument).
  1825.  *    Usually set to 'void *' or 'cadd_t'.
  1826.  */
  1827. /*#define HAS_MMAP        / **/
  1828. #define Mmap_t     /**/
  1829.  
  1830. /* HAS_MSG:
  1831.  *    This symbol, if defined, indicates that the entire msg*(2) library is
  1832.  *    supported (IPC mechanism based on message queues).
  1833.  */
  1834. /*#define HAS_MSG        / **/
  1835.  
  1836. /* HAS_SEM:
  1837.  *    This symbol, if defined, indicates that the entire sem*(2) library is
  1838.  *    supported.
  1839.  */
  1840. /*#define HAS_SEM        / **/
  1841.  
  1842. /* HAS_SETGRENT:
  1843.  *    This symbol, if defined, indicates that the setgrent routine is
  1844.  *    available for initializing sequential access of the group database.
  1845.  */
  1846. /*#define HAS_SETGRENT        / **/
  1847.  
  1848. /* HAS_SETGROUPS:
  1849.  *    This symbol, if defined, indicates that the setgroups() routine is
  1850.  *    available to set the list of process groups.  If unavailable, multiple
  1851.  *    groups are probably not supported.
  1852.  */
  1853. /*#define HAS_SETGROUPS        / **/
  1854.  
  1855. /* HAS_SETHOSTENT:
  1856.  *    This symbol, if defined, indicates that the sethostent() routine is
  1857.  *    available.
  1858.  */
  1859. /*#define HAS_SETHOSTENT        / **/
  1860.  
  1861. /* HAS_SETNETENT:
  1862.  *    This symbol, if defined, indicates that the setnetent() routine is
  1863.  *    available.
  1864.  */
  1865. /*#define HAS_SETNETENT        / **/
  1866.  
  1867. /* HAS_SETPROTOENT:
  1868.  *    This symbol, if defined, indicates that the setprotoent() routine is
  1869.  *    available.
  1870.  */
  1871. /*#define HAS_SETPROTOENT        / **/
  1872.  
  1873. /* HAS_SETPGRP:
  1874.  *    This symbol, if defined, indicates that the setpgrp routine is
  1875.  *    available to set the current process group.
  1876.  */
  1877. /* USE_BSD_SETPGRP:
  1878.  *    This symbol, if defined, indicates that setpgrp needs two
  1879.  *    arguments whereas USG one needs none.  See also HAS_SETPGID
  1880.  *    for a POSIX interface.
  1881.  */
  1882. /*#define HAS_SETPGRP        / **/
  1883. /*#define USE_BSD_SETPGRP    / **/
  1884.  
  1885. /* HAS_SETPWENT:
  1886.  *    This symbol, if defined, indicates that the setpwent routine is
  1887.  *    available for initializing sequential access of the passwd database.
  1888.  */
  1889. /*#define HAS_SETPWENT        / **/
  1890.  
  1891. /* HAS_SETSERVENT:
  1892.  *    This symbol, if defined, indicates that the setservent() routine is
  1893.  *    available.
  1894.  */
  1895. /*#define HAS_SETSERVENT        / **/
  1896.  
  1897. /* HAS_SETVBUF:
  1898.  *    This symbol, if defined, indicates that the setvbuf routine is
  1899.  *    available to change buffering on an open stdio stream.
  1900.  *    to a line-buffered mode.
  1901.  */
  1902. /*#define HAS_SETVBUF        / **/
  1903.  
  1904. /* HAS_SHM:
  1905.  *    This symbol, if defined, indicates that the entire shm*(2) library is
  1906.  *    supported.
  1907.  */
  1908. /*#define HAS_SHM        / **/
  1909.  
  1910. /* Shmat_t:
  1911.  *    This symbol holds the return type of the shmat() system call.
  1912.  *    Usually set to 'void *' or 'char *'.
  1913.  */
  1914. /* HAS_SHMAT_PROTOTYPE:
  1915.  *    This symbol, if defined, indicates that the sys/shm.h includes
  1916.  *    a prototype for shmat().  Otherwise, it is up to the program to
  1917.  *    guess one.  Shmat_t shmat(int, Shmat_t, int) is a good guess,
  1918.  *    but not always right so it should be emitted by the program only
  1919.  *    when HAS_SHMAT_PROTOTYPE is not defined to avoid conflicting defs.
  1920.  */
  1921. #define Shmat_t void *    /**/
  1922. /*#define HAS_SHMAT_PROTOTYPE    / **/
  1923.  
  1924. /* HAS_SOCKET:
  1925.  *    This symbol, if defined, indicates that the BSD socket interface is
  1926.  *    supported.
  1927.  */
  1928. /* HAS_SOCKETPAIR:
  1929.  *    This symbol, if defined, indicates that the BSD socketpair() call is
  1930.  *    supported.
  1931.  */
  1932. /* HAS_MSG_CTRUNC:
  1933.  *    This symbol, if defined, indicates that the MSG_CTRUNC is supported.
  1934.  *    Checking just with #ifdef might not be enough because this symbol
  1935.  *    has been known to be an enum.
  1936.  */
  1937. /* HAS_MSG_DONTROUTE:
  1938.  *    This symbol, if defined, indicates that the MSG_DONTROUTE is supported.
  1939.  *    Checking just with #ifdef might not be enough because this symbol
  1940.  *    has been known to be an enum.
  1941.  */
  1942. /* HAS_MSG_OOB:
  1943.  *    This symbol, if defined, indicates that the MSG_OOB is supported.
  1944.  *    Checking just with #ifdef might not be enough because this symbol
  1945.  *    has been known to be an enum.
  1946.  */
  1947. /* HAS_MSG_PEEK:
  1948.  *    This symbol, if defined, indicates that the MSG_PEEK is supported.
  1949.  *    Checking just with #ifdef might not be enough because this symbol
  1950.  *    has been known to be an enum.
  1951.  */
  1952. /* HAS_MSG_PROXY:
  1953.  *    This symbol, if defined, indicates that the MSG_PROXY is supported.
  1954.  *    Checking just with #ifdef might not be enough because this symbol
  1955.  *    has been known to be an enum.
  1956.  */
  1957. /* HAS_SCM_RIGHTS:
  1958.  *    This symbol, if defined, indicates that the SCM_RIGHTS is supported.
  1959.  *    Checking just with #ifdef might not be enough because this symbol
  1960.  *    has been known to be an enum.
  1961.  */
  1962. /*#define    HAS_SOCKET        / **/
  1963. /*#define    HAS_SOCKETPAIR    / **/
  1964. /*#define    HAS_MSG_CTRUNC    / **/
  1965. /*#define    HAS_MSG_DONTROUTE    / **/
  1966. /*#define    HAS_MSG_OOB    / **/
  1967. /*#define    HAS_MSG_PEEK    / **/
  1968. /*#define    HAS_MSG_PROXY    / **/
  1969. /*#define    HAS_SCM_RIGHTS    / **/
  1970.  
  1971. /* USE_STAT_BLOCKS:
  1972.  *    This symbol is defined if this system has a stat structure declaring
  1973.  *    st_blksize and st_blocks.
  1974.  */
  1975. #ifndef USE_STAT_BLOCKS
  1976. /*#define USE_STAT_BLOCKS     / **/
  1977. #endif
  1978.  
  1979. /* HAS_STRERROR:
  1980.  *    This symbol, if defined, indicates that the strerror routine is
  1981.  *    available to translate error numbers to strings. See the writeup
  1982.  *    of Strerror() in this file before you try to define your own.
  1983.  */
  1984. /* HAS_SYS_ERRLIST:
  1985.  *    This symbol, if defined, indicates that the sys_errlist array is
  1986.  *    available to translate error numbers to strings. The extern int
  1987.  *    sys_nerr gives the size of that table.
  1988.  */
  1989. /* Strerror:
  1990.  *    This preprocessor symbol is defined as a macro if strerror() is
  1991.  *    not available to translate error numbers to strings but sys_errlist[]
  1992.  *    array is there.
  1993.  */
  1994. /*#define HAS_STRERROR        / **/
  1995. /*#define HAS_SYS_ERRLIST    / **/
  1996. #define Strerror(e) strerror(e)
  1997.  
  1998. /* HAS_STRTOUL:
  1999.  *    This symbol, if defined, indicates that the strtoul routine is
  2000.  *    available to provide conversion of strings to unsigned long.
  2001.  */
  2002. #define HAS_STRTOUL    /**/
  2003.  
  2004. /* HAS_UNION_SEMUN:
  2005.  *    This symbol, if defined, indicates that the union semun is
  2006.  *    defined by including <sys/sem.h>.  If not, the user code
  2007.  *    probably needs to define it as:
  2008.  *    union semun {
  2009.  *        int val;
  2010.  *        struct semid_ds *buf;
  2011.  *        unsigned short *array;
  2012.  *    }
  2013.  */
  2014. /* USE_SEMCTL_SEMUN:
  2015.  *    This symbol, if defined, indicates that union semun is
  2016.  *    used for semctl IPC_STAT.
  2017.  */
  2018. /* USE_SEMCTL_SEMID_DS:
  2019.  *    This symbol, if defined, indicates that struct semid_ds * is
  2020.  *    used for semctl IPC_STAT.
  2021.  */
  2022. /*#define HAS_UNION_SEMUN    / **/
  2023. /*#define USE_SEMCTL_SEMUN    / **/
  2024. /*#define USE_SEMCTL_SEMID_DS    / **/
  2025.  
  2026. /* HAS_VFORK:
  2027.  *    This symbol, if defined, indicates that vfork() exists.
  2028.  */
  2029. /*#define HAS_VFORK    / **/
  2030.  
  2031. /* Signal_t:
  2032.  *    This symbol's value is either "void" or "int", corresponding to the
  2033.  *    appropriate return type of a signal handler.  Thus, you can declare
  2034.  *    a signal handler using "Signal_t (*handler)()", and define the
  2035.  *    handler using "Signal_t handler(sig)".
  2036.  */
  2037. #define Signal_t int    /* Signal handler's return type */
  2038.  
  2039. /* Groups_t:
  2040.  *    This symbol holds the type used for the second argument to
  2041.  *    getgroups() and setgroups().  Usually, this is the same as
  2042.  *    gidtype (gid_t) , but sometimes it isn't.
  2043.  *    It can be int, ushort, gid_t, etc... 
  2044.  *    It may be necessary to include <sys/types.h> to get any 
  2045.  *    typedef'ed information.  This is only required if you have
  2046.  *    getgroups() or setgroups()..
  2047.  */
  2048. #if defined(HAS_GETGROUPS) || defined(HAS_SETGROUPS)
  2049. #define Groups_t int    /* Type for 2nd arg to [sg]etgroups() */
  2050. #endif
  2051.  
  2052. /* I_GRP:
  2053.  *    This symbol, if defined, indicates to the C program that it should
  2054.  *    include <grp.h>.
  2055.  */
  2056. /* GRPASSWD:
  2057.  *    This symbol, if defined, indicates to the C program that struct group
  2058.  *    in <grp.h> contains gr_passwd.
  2059.  */
  2060. /*#define I_GRP        / **/
  2061. /*#define GRPASSWD    / **/
  2062.  
  2063. /* I_NDBM:
  2064.  *    This symbol, if defined, indicates that <ndbm.h> exists and should
  2065.  *    be included.
  2066.  */
  2067. /*#define I_NDBM    / **/
  2068.  
  2069. /* I_NETDB:
  2070.  *    This symbol, if defined, indicates that <netdb.h> exists and
  2071.  *    should be included.
  2072.  */
  2073. /*#define I_NETDB        / **/
  2074.  
  2075. /* I_PWD:
  2076.  *    This symbol, if defined, indicates to the C program that it should
  2077.  *    include <pwd.h>.
  2078.  */
  2079. /* PWQUOTA:
  2080.  *    This symbol, if defined, indicates to the C program that struct passwd
  2081.  *    contains pw_quota.
  2082.  */
  2083. /* PWAGE:
  2084.  *    This symbol, if defined, indicates to the C program that struct passwd
  2085.  *    contains pw_age.
  2086.  */
  2087. /* PWCHANGE:
  2088.  *    This symbol, if defined, indicates to the C program that struct passwd
  2089.  *    contains pw_change.
  2090.  */
  2091. /* PWCLASS:
  2092.  *    This symbol, if defined, indicates to the C program that struct passwd
  2093.  *    contains pw_class.
  2094.  */
  2095. /* PWEXPIRE:
  2096.  *    This symbol, if defined, indicates to the C program that struct passwd
  2097.  *    contains pw_expire.
  2098.  */
  2099. /* PWCOMMENT:
  2100.  *    This symbol, if defined, indicates to the C program that struct passwd
  2101.  *    contains pw_comment.
  2102.  */
  2103. /* PWGECOS:
  2104.  *    This symbol, if defined, indicates to the C program that struct passwd
  2105.  *    contains pw_gecos.
  2106.  */
  2107. /* PWPASSWD:
  2108.  *    This symbol, if defined, indicates to the C program that struct passwd
  2109.  *    contains pw_passwd.
  2110.  */
  2111. /*#define I_PWD        / **/
  2112. /*#define PWQUOTA    / **/
  2113. /*#define PWAGE    / **/
  2114. /*#define PWCHANGE    / **/
  2115. /*#define PWCLASS    / **/
  2116. /*#define PWEXPIRE    / **/
  2117. /*#define PWCOMMENT    / **/
  2118. /*#define PWGECOS    / **/
  2119. /*#define PWPASSWD    / **/
  2120.  
  2121. /* I_SYSUIO:
  2122.  *    This symbol, if defined, indicates that <sys/uio.h> exists and
  2123.  *    should be included.
  2124.  */
  2125. /*#define    I_SYSUIO        / **/
  2126.  
  2127. /* I_STDARG:
  2128.  *    This symbol, if defined, indicates that <stdarg.h> exists and should
  2129.  *    be included.
  2130.  */
  2131. /* I_VARARGS:
  2132.  *    This symbol, if defined, indicates to the C program that it should
  2133.  *    include <varargs.h>.
  2134.  */
  2135. #define I_STDARG        /**/
  2136. /*#define I_VARARGS    / **/
  2137.  
  2138. /* Free_t:
  2139.  *    This variable contains the return type of free().  It is usually
  2140.  * void, but occasionally int.
  2141.  */
  2142. /* Malloc_t:
  2143.  *    This symbol is the type of pointer returned by malloc and realloc.
  2144.  */
  2145. #define Malloc_t void *            /**/
  2146. #define Free_t int            /**/
  2147.  
  2148. /* MYMALLOC:
  2149.  *    This symbol, if defined, indicates that we're using our own malloc.
  2150.  */
  2151. /*#define MYMALLOC            / **/
  2152.  
  2153. /* CAN_PROTOTYPE:
  2154.  *    If defined, this macro indicates that the C compiler can handle
  2155.  *    function prototypes.
  2156.  */
  2157. /* _:
  2158.  *    This macro is used to declare function parameters for folks who want
  2159.  *    to make declarations with prototypes using a different style than
  2160.  *    the above macros.  Use double parentheses.  For example:
  2161.  *
  2162.  *        int main _((int argc, char *argv[]));
  2163.  */
  2164. /*#define    CAN_PROTOTYPE    / **/
  2165. #ifdef CAN_PROTOTYPE
  2166. #define    _(args) args
  2167. #else
  2168. #define    _(args) ()
  2169. #endif
  2170.  
  2171. /* SH_PATH:
  2172.  *    This symbol contains the full pathname to the shell used on this
  2173.  *    on this system to execute Bourne shell scripts.  Usually, this will be
  2174.  *    /bin/sh, though it's possible that some systems will have /bin/ksh,
  2175.  *    /bin/pdksh, /bin/ash, /bin/bash, or even something such as
  2176.  *    D:/bin/sh.exe.
  2177.  */
  2178. #define SH_PATH ""  /**/
  2179.  
  2180. /* SIG_NAME:
  2181.  *    This symbol contains a list of signal names in order of
  2182.  *    signal number. This is intended
  2183.  *    to be used as a static array initialization, like this:
  2184.  *        char *sig_name[] = { SIG_NAME };
  2185.  *    The signals in the list are separated with commas, and each signal
  2186.  *    is surrounded by double quotes. There is no leading SIG in the signal
  2187.  *    name, i.e. SIGQUIT is known as "QUIT".
  2188.  *    Gaps in the signal numbers (up to NSIG) are filled in with NUMnn,
  2189.  *    etc., where nn is the actual signal number (e.g. NUM37).
  2190.  *    The signal number for sig_name[i] is stored in sig_num[i].
  2191.  *    The last element is 0 to terminate the list with a NULL.  This
  2192.  *    corresponds to the 0 at the end of the sig_name_init list.
  2193.  *    Note that this variable is initialized from the sig_name_init,
  2194.  *    not from sig_name (which is unused).
  2195.  */
  2196. /* SIG_NUM:
  2197.  *    This symbol contains a list of signal numbers, in the same order as the
  2198.  *    SIG_NAME list. It is suitable for static array initialization, as in:
  2199.  *        int sig_num[] = { SIG_NUM };
  2200.  *    The signals in the list are separated with commas, and the indices
  2201.  *    within that list and the SIG_NAME list match, so it's easy to compute
  2202.  *    the signal name from a number or vice versa at the price of a small
  2203.  *    dynamic linear lookup. 
  2204.  *    Duplicates are allowed, but are moved to the end of the list.
  2205.  *    The signal number corresponding to sig_name[i] is sig_number[i].
  2206.  *    if (i < NSIG) then sig_number[i] == i.  
  2207.  *    The last element is 0, corresponding to the 0 at the end of
  2208.  *    the sig_name_init list.
  2209.  *    Note that this variable is initialized from the sig_num_init,
  2210.  *    not from sig_num (which is unused).
  2211.  */
  2212. /* SIG_SIZE:
  2213.  *    This variable contains the number of elements of the SIG_NAME
  2214.  *    and SIG_NUM arrays, excluding the final NULL entry.
  2215.  */
  2216. #define SIG_NAME 0        /**/
  2217. #define SIG_NUM  0        /**/
  2218. #define SIG_SIZE 1            /**/
  2219.  
  2220. /* STDCHAR:
  2221.  *    This symbol is defined to be the type of char used in stdio.h.
  2222.  *    It has the values "unsigned char" or "char".
  2223.  */
  2224. #define STDCHAR char    /**/
  2225.  
  2226. /* VOIDFLAGS:
  2227.  *    This symbol indicates how much support of the void type is given by this
  2228.  *    compiler.  What various bits mean:
  2229.  *
  2230.  *        1 = supports declaration of void
  2231.  *        2 = supports arrays of pointers to functions returning void
  2232.  *        4 = supports comparisons between pointers to void functions and
  2233.  *            addresses of void functions
  2234.  *        8 = suports declaration of generic void pointers
  2235.  *
  2236.  *    The package designer should define VOIDUSED to indicate the requirements
  2237.  *    of the package.  This can be done either by #defining VOIDUSED before
  2238.  *    including config.h, or by defining defvoidused in Myinit.U.  If the
  2239.  *    latter approach is taken, only those flags will be tested.  If the
  2240.  *    level of void support necessary is not present, defines void to int.
  2241.  */
  2242. #ifndef VOIDUSED
  2243. #define VOIDUSED 1
  2244. #endif
  2245. #define VOIDFLAGS 1
  2246. #if (VOIDFLAGS & VOIDUSED) != VOIDUSED
  2247. #define void int        /* is void to be avoided? */
  2248. #define M_VOID            /* Xenix strikes again */
  2249. #endif
  2250.  
  2251. /* USE_CROSS_COMPILE:
  2252.  *    This symbol, if defined, indicates that Perl is being cross-compiled.
  2253.  */
  2254. /* PERL_TARGETARCH:
  2255.  *    This symbol, if defined, indicates the target architecture
  2256.  *    Perl has been cross-compiled to.  Undefined if not a cross-compile.
  2257.  */
  2258. #ifndef USE_CROSS_COMPILE
  2259. /*#define    USE_CROSS_COMPILE    / **/
  2260. #define    PERL_TARGETARCH    ""    /**/
  2261. #endif
  2262.  
  2263. /* HAS_ATOLF:
  2264.  *    This symbol, if defined, indicates that the atolf routine is
  2265.  *    available to convert strings into long doubles.
  2266.  */
  2267. /*#define HAS_ATOLF        / **/
  2268.  
  2269. /* HAS_ATOLL:
  2270.  *    This symbol, if defined, indicates that the atoll routine is
  2271.  *    available to convert strings into long longs.
  2272.  */
  2273. /*#define HAS_ATOLL        / **/
  2274.  
  2275. /* HAS__FWALK:
  2276.  *    This symbol, if defined, indicates that the _fwalk system call is
  2277.  *    available to apply a function to all the file handles.
  2278.  */
  2279. /*#define HAS__FWALK        / **/
  2280.  
  2281. /* HAS_AINTL:
  2282.  *    This symbol, if defined, indicates that the aintl routine is
  2283.  *    available.  If copysignl is also present we can emulate modfl.
  2284.  */
  2285. /*#define HAS_AINTL        / **/
  2286.  
  2287. /* HAS_CLASS:
  2288.  *    This symbol, if defined, indicates that the class routine is
  2289.  *    available to classify doubles.  Available for example in AIX.
  2290.  *    The returned values are defined in <float.h> and are:
  2291.  *
  2292.  *    FP_PLUS_NORM    Positive normalized, nonzero
  2293.  *    FP_MINUS_NORM    Negative normalized, nonzero
  2294.  *    FP_PLUS_DENORM    Positive denormalized, nonzero
  2295.  *    FP_MINUS_DENORM    Negative denormalized, nonzero
  2296.  *    FP_PLUS_ZERO    +0.0
  2297.  *    FP_MINUS_ZERO    -0.0
  2298.  *    FP_PLUS_INF    +INF
  2299.  *    FP_MINUS_INF    -INF
  2300.  *    FP_NANS        Signaling Not a Number (NaNS)
  2301.  *    FP_NANQ        Quiet Not a Number (NaNQ)
  2302.  */
  2303. /*#define HAS_CLASS        / **/
  2304.  
  2305. /* HAS_STRUCT_CMSGHDR:
  2306.  *    This symbol, if defined, indicates that the struct cmsghdr
  2307.  *    is supported.
  2308.  */
  2309. /*#define HAS_STRUCT_CMSGHDR    / **/
  2310.  
  2311. /* HAS_COPYSIGNL:
  2312.  *    This symbol, if defined, indicates that the copysignl routine is
  2313.  *    available.  If aintl is also present we can emulate modfl.
  2314.  */
  2315. /*#define HAS_COPYSIGNL        / **/
  2316.  
  2317. /* HAS_DBMINIT_PROTO:
  2318.  *    This symbol, if defined, indicates that the system provides
  2319.  *    a prototype for the dbminit() function.  Otherwise, it is up
  2320.  *    to the program to supply one.  A good guess is
  2321.  *        extern int dbminit(char *);
  2322.  */
  2323. /*#define    HAS_DBMINIT_PROTO    / **/
  2324.  
  2325. /* HAS_DIRFD:
  2326.  *    This manifest constant lets the C program know that dirfd
  2327.  *    is available.
  2328.  */
  2329. /*#define HAS_DIRFD        / **/
  2330.  
  2331. /* DLSYM_NEEDS_UNDERSCORE:
  2332.  *    This symbol, if defined, indicates that we need to prepend an
  2333.  *    underscore to the symbol name before calling dlsym().  This only
  2334.  *    makes sense if you *have* dlsym, which we will presume is the
  2335.  *    case if you're using dl_dlopen.xs.
  2336.  */
  2337. /*#define     DLSYM_NEEDS_UNDERSCORE     / **/
  2338.  
  2339. /* HAS_FAST_STDIO:
  2340.  *    This symbol, if defined, indicates that the "fast stdio"
  2341.  *    is available to manipulate the stdio buffers directly.
  2342.  */
  2343. /*#define HAS_FAST_STDIO        / **/
  2344.  
  2345. /* HAS_FCHDIR:
  2346.  *    This symbol, if defined, indicates that the fchdir routine is
  2347.  *    available to change directory using a file descriptor.
  2348.  */
  2349. /*#define HAS_FCHDIR        / **/
  2350.  
  2351. /* FCNTL_CAN_LOCK:
  2352.  *    This symbol, if defined, indicates that fcntl() can be used
  2353.  *    for file locking.  Normally on Unix systems this is defined.
  2354.  *    It may be undefined on VMS.
  2355.  */
  2356. /*#define FCNTL_CAN_LOCK        / **/
  2357.  
  2358. /* HAS_FINITE:
  2359.  *    This symbol, if defined, indicates that the finite routine is
  2360.  *    available to check whether a double is finite (non-infinity non-NaN).
  2361.  */
  2362. /*#define HAS_FINITE        / **/
  2363.  
  2364. /* HAS_FINITEL:
  2365.  *    This symbol, if defined, indicates that the finitel routine is
  2366.  *    available to check whether a long double is finite
  2367.  *    (non-infinity non-NaN).
  2368.  */
  2369. /*#define HAS_FINITEL        / **/
  2370.  
  2371. /* HAS_FLOCK_PROTO:
  2372.  *    This symbol, if defined, indicates that the system provides
  2373.  *    a prototype for the flock() function.  Otherwise, it is up
  2374.  *    to the program to supply one.  A good guess is
  2375.  *        extern int flock(int, int);
  2376.  */
  2377. /*#define    HAS_FLOCK_PROTO    / **/
  2378.  
  2379. /* HAS_FP_CLASS:
  2380.  *    This symbol, if defined, indicates that the fp_class routine is
  2381.  *    available to classify doubles.  Available for example in Digital UNIX.
  2382.  *    The returned values are defined in <math.h> and are:
  2383.  *
  2384.  *    FP_SNAN           Signaling NaN (Not-a-Number)
  2385.  *    FP_QNAN           Quiet NaN (Not-a-Number)
  2386.  *    FP_POS_INF        +infinity
  2387.  *    FP_NEG_INF        -infinity
  2388.  *    FP_POS_NORM       Positive normalized
  2389.  *    FP_NEG_NORM       Negative normalized
  2390.  *    FP_POS_DENORM     Positive denormalized
  2391.  *    FP_NEG_DENORM     Negative denormalized
  2392.  *    FP_POS_ZERO       +0.0 (positive zero)
  2393.  *    FP_NEG_ZERO       -0.0 (negative zero)
  2394.  */
  2395. /*#define HAS_FP_CLASS        / **/
  2396.  
  2397. /* HAS_FPCLASS:
  2398.  *    This symbol, if defined, indicates that the fpclass routine is
  2399.  *    available to classify doubles.  Available for example in Solaris/SVR4.
  2400.  *    The returned values are defined in <ieeefp.h> and are:
  2401.  *
  2402.  *    FP_SNAN        signaling NaN
  2403.  *    FP_QNAN        quiet NaN
  2404.  *    FP_NINF        negative infinity
  2405.  *    FP_PINF        positive infinity
  2406.  *    FP_NDENORM    negative denormalized non-zero
  2407.  *    FP_PDENORM    positive denormalized non-zero
  2408.  *    FP_NZERO    negative zero
  2409.  *    FP_PZERO    positive zero
  2410.  *    FP_NNORM    negative normalized non-zero
  2411.  *    FP_PNORM    positive normalized non-zero
  2412.  */
  2413. /*#define HAS_FPCLASS        / **/
  2414.  
  2415. /* HAS_FPCLASSIFY:
  2416.  *    This symbol, if defined, indicates that the fpclassify routine is
  2417.  *    available to classify doubles.  Available for example in HP-UX.
  2418.  *    The returned values are defined in <math.h> and are
  2419.  *
  2420.  *           FP_NORMAL     Normalized
  2421.  *           FP_ZERO       Zero
  2422.  *           FP_INFINITE   Infinity
  2423.  *           FP_SUBNORMAL  Denormalized
  2424.  *           FP_NAN        NaN
  2425.  *
  2426.  */
  2427. /*#define HAS_FPCLASSIFY        / **/
  2428.  
  2429. /* HAS_FPCLASSL:
  2430.  *    This symbol, if defined, indicates that the fpclassl routine is
  2431.  *    available to classify long doubles.  Available for example in IRIX.
  2432.  *    The returned values are defined in <ieeefp.h> and are:
  2433.  *
  2434.  *    FP_SNAN        signaling NaN
  2435.  *    FP_QNAN        quiet NaN
  2436.  *    FP_NINF        negative infinity
  2437.  *    FP_PINF        positive infinity
  2438.  *    FP_NDENORM    negative denormalized non-zero
  2439.  *    FP_PDENORM    positive denormalized non-zero
  2440.  *    FP_NZERO    negative zero
  2441.  *    FP_PZERO    positive zero
  2442.  *    FP_NNORM    negative normalized non-zero
  2443.  *    FP_PNORM    positive normalized non-zero
  2444.  */
  2445. /*#define HAS_FPCLASSL        / **/
  2446.  
  2447. /* HAS_FPOS64_T:
  2448.  *    This symbol will be defined if the C compiler supports fpos64_t.
  2449.  */
  2450. /*#define    HAS_FPOS64_T        / **/
  2451.  
  2452. /* HAS_FREXPL:
  2453.  *    This symbol, if defined, indicates that the frexpl routine is
  2454.  *    available to break a long double floating-point number into
  2455.  *    a normalized fraction and an integral power of 2.
  2456.  */
  2457. /*#define HAS_FREXPL        / **/
  2458.  
  2459. /* HAS_STRUCT_FS_DATA:
  2460.  *    This symbol, if defined, indicates that the struct fs_data
  2461.  *    to do statfs() is supported.
  2462.  */
  2463. /*#define HAS_STRUCT_FS_DATA    / **/
  2464.  
  2465. /* HAS_FSEEKO:
  2466.  *    This symbol, if defined, indicates that the fseeko routine is
  2467.  *    available to fseek beyond 32 bits (useful for ILP32 hosts).
  2468.  */
  2469. /*#define HAS_FSEEKO        / **/
  2470.  
  2471. /* HAS_FSTATFS:
  2472.  *    This symbol, if defined, indicates that the fstatfs routine is
  2473.  *    available to stat filesystems by file descriptors.
  2474.  */
  2475. /*#define HAS_FSTATFS        / **/
  2476.  
  2477. /* HAS_FSYNC:
  2478.  *    This symbol, if defined, indicates that the fsync routine is
  2479.  *    available to write a file's modified data and attributes to
  2480.  *    permanent storage.
  2481.  */
  2482. /*#define HAS_FSYNC        / **/
  2483.  
  2484. /* HAS_FTELLO:
  2485.  *    This symbol, if defined, indicates that the ftello routine is
  2486.  *    available to ftell beyond 32 bits (useful for ILP32 hosts).
  2487.  */
  2488. /*#define HAS_FTELLO        / **/
  2489.  
  2490. /* HAS_GETCWD:
  2491.  *    This symbol, if defined, indicates that the getcwd routine is
  2492.  *    available to get the current working directory.
  2493.  */
  2494. /*#define HAS_GETCWD        / **/
  2495.  
  2496. /* HAS_GETESPWNAM:
  2497.  *    This symbol, if defined, indicates that the getespwnam system call is
  2498.  *    available to retrieve enchanced (shadow) password entries by name.
  2499.  */
  2500. /*#define HAS_GETESPWNAM        / **/
  2501.  
  2502. /* HAS_GETFSSTAT:
  2503.  *    This symbol, if defined, indicates that the getfsstat routine is
  2504.  *    available to stat filesystems in bulk.
  2505.  */
  2506. /*#define HAS_GETFSSTAT        / **/
  2507.  
  2508. /* HAS_GETITIMER:
  2509.  *    This symbol, if defined, indicates that the getitimer routine is
  2510.  *    available to return interval timers.
  2511.  */
  2512. /*#define HAS_GETITIMER        / **/
  2513.  
  2514. /* HAS_GETMNT:
  2515.  *    This symbol, if defined, indicates that the getmnt routine is
  2516.  *    available to get filesystem mount info by filename.
  2517.  */
  2518. /*#define HAS_GETMNT        / **/
  2519.  
  2520. /* HAS_GETMNTENT:
  2521.  *    This symbol, if defined, indicates that the getmntent routine is
  2522.  *    available to iterate through mounted file systems to get their info.
  2523.  */
  2524. /*#define HAS_GETMNTENT        / **/
  2525.  
  2526. /* HAS_GETPRPWNAM:
  2527.  *    This symbol, if defined, indicates that the getprpwnam system call is
  2528.  *    available to retrieve protected (shadow) password entries by name.
  2529.  */
  2530. /*#define HAS_GETPRPWNAM        / **/
  2531.  
  2532. /* HAS_GETSPNAM:
  2533.  *    This symbol, if defined, indicates that the getspnam system call is
  2534.  *    available to retrieve SysV shadow password entries by name.
  2535.  */
  2536. /*#define HAS_GETSPNAM        / **/
  2537.  
  2538. /* HAS_HASMNTOPT:
  2539.  *    This symbol, if defined, indicates that the hasmntopt routine is
  2540.  *    available to query the mount options of file systems.
  2541.  */
  2542. /*#define HAS_HASMNTOPT        / **/
  2543.  
  2544. /* HAS_ILOGBL:
  2545.  *    This symbol, if defined, indicates that the ilogbl routine is
  2546.  *    available.  If scalbnl is also present we can emulate frexpl.
  2547.  */
  2548. /*#define HAS_ILOGBL        / **/
  2549.  
  2550. /* HAS_INT64_T:
  2551.  *     This symbol will defined if the C compiler supports int64_t.
  2552.  *     Usually the <inttypes.h> needs to be included, but sometimes
  2553.  *    <sys/types.h> is enough.
  2554.  */
  2555. /*#define     HAS_INT64_T               / **/
  2556.  
  2557. /* HAS_ISFINITE:
  2558.  *    This symbol, if defined, indicates that the isfinite routine is
  2559.  *    available to check whether a double is finite (non-infinity non-NaN).
  2560.  */
  2561. /*#define HAS_ISFINITE        / **/
  2562.  
  2563. /* HAS_ISINF:
  2564.  *    This symbol, if defined, indicates that the isinf routine is
  2565.  *    available to check whether a double is an infinity.
  2566.  */
  2567. /*#define HAS_ISINF        / **/
  2568.  
  2569. /* HAS_ISNAN:
  2570.  *    This symbol, if defined, indicates that the isnan routine is
  2571.  *    available to check whether a double is a NaN.
  2572.  */
  2573. /*#define HAS_ISNAN        / **/
  2574.  
  2575. /* HAS_ISNANL:
  2576.  *    This symbol, if defined, indicates that the isnanl routine is
  2577.  *    available to check whether a long double is a NaN.
  2578.  */
  2579. /*#define HAS_ISNANL        / **/
  2580.  
  2581. /* HAS_LDBL_DIG:
  2582.  *    This symbol, if defined, indicates that this system's <float.h>
  2583.  *    or <limits.h> defines the symbol LDBL_DIG, which is the number
  2584.  *    of significant digits in a long double precision number. Unlike
  2585.  *    for DBL_DIG, there's no good guess for LDBL_DIG if it is undefined.
  2586.  */
  2587. /*#define HAS_LDBL_DIG     / * */
  2588.  
  2589. /* HAS_MADVISE:
  2590.  *    This symbol, if defined, indicates that the madvise system call is
  2591.  *    available to map a file into memory.
  2592.  */
  2593. /*#define HAS_MADVISE        / **/
  2594.  
  2595. /* HAS_MKDTEMP:
  2596.  *    This symbol, if defined, indicates that the mkdtemp routine is
  2597.  *    available to exclusively create a uniquely named temporary directory.
  2598.  */
  2599. /*#define HAS_MKDTEMP        / **/
  2600.  
  2601. /* HAS_MKSTEMPS:
  2602.  *    This symbol, if defined, indicates that the mkstemps routine is
  2603.  *    available to excluslvely create and open a uniquely named
  2604.  *    (with a suffix) temporary file.
  2605.  */
  2606. /*#define HAS_MKSTEMPS        / **/
  2607.  
  2608. /* HAS_MODFL:
  2609.  *    This symbol, if defined, indicates that the modfl routine is
  2610.  *    available to split a long double x into a fractional part f and
  2611.  *    an integer part i such that |f| < 1.0 and (f + i) = x.
  2612.  */
  2613. /* HAS_MODFL_PROTO:
  2614.  *    This symbol, if defined, indicates that the system provides
  2615.  *    a prototype for the modfl() function.  Otherwise, it is up
  2616.  *    to the program to supply one.
  2617.  */
  2618. /* HAS_MODFL_POW32_BUG:
  2619.  *    This symbol, if defined, indicates that the modfl routine is
  2620.  *    broken for long doubles >= pow(2, 32).
  2621.  *    For example from 4294967303.150000 one would get 4294967302.000000
  2622.  *    and 1.150000.  The bug has been seen in certain versions of glibc,
  2623.  *    release 2.2.2 is known to be okay.
  2624.  */
  2625. /*#define HAS_MODFL        / **/
  2626. /*#define HAS_MODFL_PROTO        / **/
  2627. /*#define HAS_MODFL_POW32_BUG        / **/
  2628.  
  2629. /* HAS_MPROTECT:
  2630.  *    This symbol, if defined, indicates that the mprotect system call is
  2631.  *    available to modify the access protection of a memory mapped file.
  2632.  */
  2633. /*#define HAS_MPROTECT        / **/
  2634.  
  2635. /* HAS_STRUCT_MSGHDR:
  2636.  *    This symbol, if defined, indicates that the struct msghdr
  2637.  *    is supported.
  2638.  */
  2639. /*#define HAS_STRUCT_MSGHDR    / **/
  2640.  
  2641. /* HAS_NL_LANGINFO:
  2642.  *    This symbol, if defined, indicates that the nl_langinfo routine is
  2643.  *    available to return local data.  You will also need <langinfo.h>
  2644.  *    and therefore I_LANGINFO.
  2645.  */
  2646. /*#define HAS_NL_LANGINFO        / **/
  2647.  
  2648. /* HAS_OFF64_T:
  2649.  *    This symbol will be defined if the C compiler supports off64_t.
  2650.  */
  2651. /*#define    HAS_OFF64_T            / **/
  2652.  
  2653. /* HAS_PROCSELFEXE:
  2654.  *    This symbol is defined if PROCSELFEXE_PATH is a symlink
  2655.  *    to the absolute pathname of the executing program.
  2656.  */
  2657. /* PROCSELFEXE_PATH:
  2658.  *    If HAS_PROCSELFEXE is defined this symbol is the filename
  2659.  *    of the symbolic link pointing to the absolute pathname of
  2660.  *    the executing program.
  2661.  */
  2662. /*#define HAS_PROCSELFEXE    / **/
  2663. #if defined(HAS_PROCSELFEXE) && !defined(PROCSELFEXE_PATH)
  2664. #define PROCSELFEXE_PATH        /**/
  2665. #endif
  2666.  
  2667. /* HAS_PTHREAD_ATTR_SETSCOPE:
  2668.  *    This symbol, if defined, indicates that the pthread_attr_setscope
  2669.  *    system call is available to set the contention scope attribute of
  2670.  *    a thread attribute object.
  2671.  */
  2672. /*#define HAS_PTHREAD_ATTR_SETSCOPE        / **/
  2673.  
  2674. /* HAS_READV:
  2675.  *    This symbol, if defined, indicates that the readv routine is
  2676.  *    available to do gather reads.  You will also need <sys/uio.h>
  2677.  *    and there I_SYSUIO.
  2678.  */
  2679. /*#define HAS_READV        / **/
  2680.  
  2681. /* HAS_RECVMSG:
  2682.  *    This symbol, if defined, indicates that the recvmsg routine is
  2683.  *    available to send structured socket messages.
  2684.  */
  2685. /*#define HAS_RECVMSG        / **/
  2686.  
  2687. /* HAS_SBRK_PROTO:
  2688.  *    This symbol, if defined, indicates that the system provides
  2689.  *    a prototype for the sbrk() function.  Otherwise, it is up
  2690.  *    to the program to supply one.  Good guesses are
  2691.  *        extern void* sbrk(int);
  2692.  *        extern void* sbrk(size_t);
  2693.  */
  2694. /*#define    HAS_SBRK_PROTO    / **/
  2695.  
  2696. /* HAS_SCALBNL:
  2697.  *    This symbol, if defined, indicates that the scalbnl routine is
  2698.  *    available.  If ilogbl is also present we can emulate frexpl.
  2699.  */
  2700. /*#define HAS_SCALBNL        / **/
  2701.  
  2702. /* HAS_SENDMSG:
  2703.  *    This symbol, if defined, indicates that the sendmsg routine is
  2704.  *    available to send structured socket messages.
  2705.  */
  2706. /*#define HAS_SENDMSG        / **/
  2707.  
  2708. /* HAS_SETITIMER:
  2709.  *    This symbol, if defined, indicates that the setitimer routine is
  2710.  *    available to set interval timers.
  2711.  */
  2712. /*#define HAS_SETITIMER        / **/
  2713.  
  2714. /* HAS_SETPROCTITLE:
  2715.  *    This symbol, if defined, indicates that the setproctitle routine is
  2716.  *    available to set process title.
  2717.  */
  2718. /*#define HAS_SETPROCTITLE        / **/
  2719.  
  2720. /* USE_SFIO:
  2721.  *    This symbol, if defined, indicates that sfio should
  2722.  *    be used.
  2723.  */
  2724. /*#define    USE_SFIO        / **/
  2725.  
  2726. /* HAS_SIGPROCMASK:
  2727.  *    This symbol, if defined, indicates that the sigprocmask
  2728.  *    system call is available to examine or change the signal mask
  2729.  *    of the calling process.
  2730.  */
  2731. /*#define HAS_SIGPROCMASK        / **/
  2732.  
  2733. /* HAS_SOCKATMARK:
  2734.  *    This symbol, if defined, indicates that the sockatmark routine is
  2735.  *    available to test whether a socket is at the out-of-band mark.
  2736.  */
  2737. /*#define HAS_SOCKATMARK        / **/
  2738.  
  2739. /* HAS_SOCKATMARK_PROTO:
  2740.  *    This symbol, if defined, indicates that the system provides
  2741.  *    a prototype for the sockatmark() function.  Otherwise, it is up
  2742.  *    to the program to supply one.  A good guess is
  2743.  *        extern int sockatmark(int);
  2744.  */
  2745. /*#define    HAS_SOCKATMARK_PROTO    / **/
  2746.  
  2747. /* HAS_SOCKS5_INIT:
  2748.  *    This symbol, if defined, indicates that the socks5_init routine is
  2749.  *    available to initialize SOCKS 5.
  2750.  */
  2751. /*#define HAS_SOCKS5_INIT        / **/
  2752.  
  2753. /* HAS_SQRTL:
  2754.  *    This symbol, if defined, indicates that the sqrtl routine is
  2755.  *    available to do long double square roots.
  2756.  */
  2757. /*#define HAS_SQRTL        / **/
  2758.  
  2759. /* HAS_SETRESGID_PROTO:
  2760.  *    This symbol, if defined, indicates that the system provides
  2761.  *    a prototype for the setresgid() function.  Otherwise, it is up
  2762.  *    to the program to supply one.  Good guesses are
  2763.  *        extern int setresgid(uid_t ruid, uid_t euid, uid_t suid);
  2764.  */
  2765. /*#define    HAS_SETRESGID_PROTO    / **/
  2766.  
  2767. /* HAS_SETRESUID_PROTO:
  2768.  *    This symbol, if defined, indicates that the system provides
  2769.  *    a prototype for the setresuid() function.  Otherwise, it is up
  2770.  *    to the program to supply one.  Good guesses are
  2771.  *        extern int setresuid(uid_t ruid, uid_t euid, uid_t suid);
  2772.  */
  2773. /*#define    HAS_SETRESUID_PROTO    / **/
  2774.  
  2775. /* HAS_STRUCT_STATFS_F_FLAGS:
  2776.  *    This symbol, if defined, indicates that the struct statfs
  2777.  *    does have the f_flags member containing the mount flags of
  2778.  *    the filesystem containing the file.
  2779.  *    This kind of struct statfs is coming from <sys/mount.h> (BSD 4.3),
  2780.  *    not from <sys/statfs.h> (SYSV).  Older BSDs (like Ultrix) do not
  2781.  *    have statfs() and struct statfs, they have ustat() and getmnt()
  2782.  *    with struct ustat and struct fs_data.
  2783.  */
  2784. /*#define HAS_STRUCT_STATFS_F_FLAGS        / **/
  2785.  
  2786. /* HAS_STRUCT_STATFS:
  2787.  *    This symbol, if defined, indicates that the struct statfs
  2788.  *    to do statfs() is supported.
  2789.  */
  2790. /*#define HAS_STRUCT_STATFS    / **/
  2791.  
  2792. /* HAS_FSTATVFS:
  2793.  *    This symbol, if defined, indicates that the fstatvfs routine is
  2794.  *    available to stat filesystems by file descriptors.
  2795.  */
  2796. /*#define HAS_FSTATVFS        / **/
  2797.  
  2798. /* HAS_STRFTIME:
  2799.  *    This symbol, if defined, indicates that the strftime routine is
  2800.  *    available to do time formatting.
  2801.  */
  2802. /*#define HAS_STRFTIME        / **/
  2803.  
  2804. /* HAS_STRTOLD:
  2805.  *    This symbol, if defined, indicates that the strtold routine is
  2806.  *    available to convert strings to long doubles.
  2807.  */
  2808. /*#define HAS_STRTOLD        / **/
  2809.  
  2810. /* HAS_STRTOLL:
  2811.  *    This symbol, if defined, indicates that the strtoll routine is
  2812.  *    available to convert strings to long longs.
  2813.  */
  2814. /*#define HAS_STRTOLL        / **/
  2815.  
  2816. /* HAS_STRTOQ:
  2817.  *    This symbol, if defined, indicates that the strtoq routine is
  2818.  *    available to convert strings to long longs (quads).
  2819.  */
  2820. /*#define HAS_STRTOQ        / **/
  2821.  
  2822. /* HAS_STRTOULL:
  2823.  *    This symbol, if defined, indicates that the strtoull routine is
  2824.  *    available to convert strings to unsigned long longs.
  2825.  */
  2826. /*#define HAS_STRTOULL        / **/
  2827.  
  2828. /* HAS_STRTOUQ:
  2829.  *    This symbol, if defined, indicates that the strtouq routine is
  2830.  *    available to convert strings to unsigned long longs (quads).
  2831.  */
  2832. /*#define HAS_STRTOUQ        / **/
  2833.  
  2834. /* HAS_SYSCALL_PROTO:
  2835.  *    This symbol, if defined, indicates that the system provides
  2836.  *    a prototype for the syscall() function.  Otherwise, it is up
  2837.  *    to the program to supply one.  Good guesses are
  2838.  *        extern int syscall(int,  ...);
  2839.  *        extern int syscall(long, ...);
  2840.  */
  2841. /*#define    HAS_SYSCALL_PROTO    / **/
  2842.  
  2843. /* HAS_TELLDIR_PROTO:
  2844.  *    This symbol, if defined, indicates that the system provides
  2845.  *    a prototype for the telldir() function.  Otherwise, it is up
  2846.  *    to the program to supply one.  A good guess is
  2847.  *        extern long telldir(DIR*);
  2848.  */
  2849. /*#define    HAS_TELLDIR_PROTO    / **/
  2850.  
  2851. /* U32_ALIGNMENT_REQUIRED:
  2852.  *    This symbol, if defined, indicates that you must access
  2853.  *    character data through U32-aligned pointers.
  2854.  */
  2855. #ifndef U32_ALIGNMENT_REQUIRED
  2856. #define U32_ALIGNMENT_REQUIRED    /**/
  2857. #endif
  2858.  
  2859. /* HAS_UALARM:
  2860.  *    This symbol, if defined, indicates that the ualarm routine is
  2861.  *    available to do alarms with microsecond granularity.
  2862.  */
  2863. /*#define HAS_UALARM        / **/
  2864.  
  2865. /* HAS_UNORDERED:
  2866.  *    This symbol, if defined, indicates that the unordered routine is
  2867.  *    available to check whether two doubles are unordered
  2868.  *    (effectively: whether either of them is NaN)
  2869.  */
  2870. /*#define HAS_UNORDERED        / **/
  2871.  
  2872. /* HAS_USLEEP_PROTO:
  2873.  *    This symbol, if defined, indicates that the system provides
  2874.  *    a prototype for the usleep() function.  Otherwise, it is up
  2875.  *    to the program to supply one.  A good guess is
  2876.  *        extern int usleep(useconds_t);
  2877.  */
  2878. /*#define    HAS_USLEEP_PROTO    / **/
  2879.  
  2880. /* HAS_USTAT:
  2881.  *    This symbol, if defined, indicates that the ustat system call is
  2882.  *    available to query file system statistics by dev_t.
  2883.  */
  2884. /*#define HAS_USTAT        / **/
  2885.  
  2886. /* HAS_WRITEV:
  2887.  *    This symbol, if defined, indicates that the writev routine is
  2888.  *    available to do scatter writes.
  2889.  */
  2890. /*#define HAS_WRITEV        / **/
  2891.  
  2892. /* USE_DYNAMIC_LOADING:
  2893.  *    This symbol, if defined, indicates that dynamic loading of
  2894.  *    some sort is available.
  2895.  */
  2896. /*#define USE_DYNAMIC_LOADING        / **/
  2897.  
  2898. /* FFLUSH_NULL:
  2899.  *    This symbol, if defined, tells that fflush(NULL) does flush
  2900.  *    all pending stdio output.
  2901.  */
  2902. /* FFLUSH_ALL:
  2903.  *    This symbol, if defined, tells that to flush
  2904.  *    all pending stdio output one must loop through all
  2905.  *    the stdio file handles stored in an array and fflush them.
  2906.  *    Note that if fflushNULL is defined, fflushall will not
  2907.  *    even be probed for and will be left undefined.
  2908.  */
  2909. /*#define    FFLUSH_NULL         / **/
  2910. /*#define    FFLUSH_ALL         / **/
  2911.  
  2912. /* I_CRYPT:
  2913.  *    This symbol, if defined, indicates that <crypt.h> exists and
  2914.  *    should be included.
  2915.  */
  2916. /*#define    I_CRYPT        / **/
  2917.  
  2918. /* DB_Prefix_t:
  2919.  *    This symbol contains the type of the prefix structure element
  2920.  *    in the <db.h> header file.  In older versions of DB, it was
  2921.  *    int, while in newer ones it is u_int32_t.
  2922.  */
  2923. /* DB_Hash_t:
  2924.  *    This symbol contains the type of the prefix structure element
  2925.  *    in the <db.h> header file.  In older versions of DB, it was
  2926.  *    int, while in newer ones it is size_t.
  2927.  */
  2928. /* DB_VERSION_MAJOR_CFG:
  2929.  *    This symbol, if defined, defines the major version number of
  2930.  *    Berkeley DB found in the <db.h> header when Perl was configured.
  2931.  */
  2932. /* DB_VERSION_MINOR_CFG:
  2933.  *    This symbol, if defined, defines the minor version number of
  2934.  *    Berkeley DB found in the <db.h> header when Perl was configured.
  2935.  *    For DB version 1 this is always 0.
  2936.  */
  2937. /* DB_VERSION_PATCH_CFG:
  2938.  *    This symbol, if defined, defines the patch version number of
  2939.  *    Berkeley DB found in the <db.h> header when Perl was configured.
  2940.  *    For DB version 1 this is always 0.
  2941.  */
  2942. #define DB_Hash_t    u_int32_t        /**/
  2943. #define DB_Prefix_t    size_t      /**/
  2944. #define DB_VERSION_MAJOR_CFG          /**/
  2945. #define DB_VERSION_MINOR_CFG          /**/
  2946. #define DB_VERSION_PATCH_CFG          /**/
  2947.  
  2948. /* I_FP:
  2949.  *    This symbol, if defined, indicates that <fp.h> exists and
  2950.  *    should be included.
  2951.  */
  2952. /*#define    I_FP        / **/
  2953.  
  2954. /* I_FP_CLASS:
  2955.  *    This symbol, if defined, indicates that <fp_class.h> exists and
  2956.  *    should be included.
  2957.  */
  2958. /*#define    I_FP_CLASS        / **/
  2959.  
  2960. /* I_IEEEFP:
  2961.  *    This symbol, if defined, indicates that <ieeefp.h> exists and
  2962.  *    should be included.
  2963.  */
  2964. /*#define    I_IEEEFP        / **/
  2965.  
  2966. /* I_INTTYPES:
  2967.  *     This symbol, if defined, indicates to the C program that it should
  2968.  *     include <inttypes.h>.
  2969.  */
  2970. /*#define   I_INTTYPES                / **/
  2971.  
  2972. /* I_LANGINFO:
  2973.  *    This symbol, if defined, indicates that <langinfo.h> exists and
  2974.  *    should be included.
  2975.  */
  2976. /*#define    I_LANGINFO        / **/
  2977.  
  2978. /* I_LIBUTIL:
  2979.  *    This symbol, if defined, indicates that <libutil.h> exists and
  2980.  *    should be included.
  2981.  */
  2982. /*#define    I_LIBUTIL        / **/
  2983.  
  2984. /* I_MNTENT:
  2985.  *    This symbol, if defined, indicates that <mntent.h> exists and
  2986.  *    should be included.
  2987.  */
  2988. /*#define    I_MNTENT        / **/
  2989.  
  2990. /* I_NETINET_TCP:
  2991.  *     This symbol, if defined, indicates to the C program that it should
  2992.  *     include <netinet/tcp.h>.
  2993.  */
  2994. /*#define   I_NETINET_TCP                / **/
  2995.  
  2996. /* I_POLL:
  2997.  *    This symbol, if defined, indicates that <poll.h> exists and
  2998.  *    should be included.
  2999.  */
  3000. /*#define    I_POLL        / **/
  3001.  
  3002. /* I_PROT:
  3003.  *    This symbol, if defined, indicates that <prot.h> exists and
  3004.  *    should be included.
  3005.  */
  3006. /*#define    I_PROT        / **/
  3007.  
  3008. /* I_SHADOW:
  3009.  *    This symbol, if defined, indicates that <shadow.h> exists and
  3010.  *    should be included.
  3011.  */
  3012. /*#define    I_SHADOW        / **/
  3013.  
  3014. /* I_SOCKS:
  3015.  *    This symbol, if defined, indicates that <socks.h> exists and
  3016.  *    should be included.
  3017.  */
  3018. /*#define    I_SOCKS        / **/
  3019.  
  3020. /* I_SUNMATH:
  3021.  *    This symbol, if defined, indicates that <sunmath.h> exists and
  3022.  *    should be included.
  3023.  */
  3024. /*#define    I_SUNMATH        / **/
  3025.  
  3026. /* I_SYSLOG:
  3027.  *    This symbol, if defined, indicates that <syslog.h> exists and
  3028.  *    should be included.
  3029.  */
  3030. /*#define    I_SYSLOG        / **/
  3031.  
  3032. /* I_SYSMODE:
  3033.  *    This symbol, if defined, indicates that <sys/mode.h> exists and
  3034.  *    should be included.
  3035.  */
  3036. /*#define    I_SYSMODE        / **/
  3037.  
  3038. /* I_SYS_MOUNT:
  3039.  *    This symbol, if defined, indicates that <sys/mount.h> exists and
  3040.  *    should be included.
  3041.  */
  3042. /*#define    I_SYS_MOUNT        / **/
  3043.  
  3044. /* I_SYS_STATFS:
  3045.  *    This symbol, if defined, indicates that <sys/statfs.h> exists.
  3046.  */
  3047. /*#define    I_SYS_STATFS        / **/
  3048.  
  3049. /* I_SYS_STATVFS:
  3050.  *    This symbol, if defined, indicates that <sys/statvfs.h> exists and
  3051.  *    should be included.
  3052.  */
  3053. /*#define    I_SYS_STATVFS        / **/
  3054.  
  3055. /* I_SYSUTSNAME:
  3056.  *    This symbol, if defined, indicates that <sys/utsname.h> exists and
  3057.  *    should be included.
  3058.  */
  3059. /*#define    I_SYSUTSNAME        / **/
  3060.  
  3061. /* I_SYS_VFS:
  3062.  *    This symbol, if defined, indicates that <sys/vfs.h> exists and
  3063.  *    should be included.
  3064.  */
  3065. /*#define    I_SYS_VFS        / **/
  3066.  
  3067. /* I_USTAT:
  3068.  *    This symbol, if defined, indicates that <ustat.h> exists and
  3069.  *    should be included.
  3070.  */
  3071. /*#define    I_USTAT        / **/
  3072.  
  3073. /* PERL_PRIfldbl:
  3074.  *    This symbol, if defined, contains the string used by stdio to
  3075.  *    format long doubles (format 'f') for output.
  3076.  */
  3077. /* PERL_PRIgldbl:
  3078.  *    This symbol, if defined, contains the string used by stdio to
  3079.  *    format long doubles (format 'g') for output.
  3080.  */
  3081. /* PERL_PRIeldbl:
  3082.  *    This symbol, if defined, contains the string used by stdio to
  3083.  *    format long doubles (format 'e') for output.
  3084.  */
  3085. /* PERL_SCNfldbl:
  3086.  *    This symbol, if defined, contains the string used by stdio to
  3087.  *    format long doubles (format 'f') for input.
  3088.  */
  3089. /*#define PERL_PRIfldbl    "llf"    / **/
  3090. /*#define PERL_PRIgldbl    "llg"    / **/
  3091. /*#define PERL_PRIeldbl    "lle"    / **/
  3092. /*#define PERL_SCNfldbl    "llf"    / **/
  3093.  
  3094. /* NEED_VA_COPY:
  3095.  *    This symbol, if defined, indicates that the system stores
  3096.  *    the variable argument list datatype, va_list, in a format
  3097.  *    that cannot be copied by simple assignment, so that some
  3098.  *    other means must be used when copying is required.
  3099.  *    As such systems vary in their provision (or non-provision)
  3100.  *    of copying mechanisms, handy.h defines a platform-
  3101.  *    independent macro, Perl_va_copy(src, dst), to do the job.
  3102.  */
  3103. /*#define    NEED_VA_COPY        / **/
  3104.  
  3105. /* IVTYPE:
  3106.  *    This symbol defines the C type used for Perl's IV.
  3107.  */
  3108. /* UVTYPE:
  3109.  *    This symbol defines the C type used for Perl's UV.
  3110.  */
  3111. /* I8TYPE:
  3112.  *    This symbol defines the C type used for Perl's I8.
  3113.  */
  3114. /* U8TYPE:
  3115.  *    This symbol defines the C type used for Perl's U8.
  3116.  */
  3117. /* I16TYPE:
  3118.  *    This symbol defines the C type used for Perl's I16.
  3119.  */
  3120. /* U16TYPE:
  3121.  *    This symbol defines the C type used for Perl's U16.
  3122.  */
  3123. /* I32TYPE:
  3124.  *    This symbol defines the C type used for Perl's I32.
  3125.  */
  3126. /* U32TYPE:
  3127.  *    This symbol defines the C type used for Perl's U32.
  3128.  */
  3129. /* I64TYPE:
  3130.  *    This symbol defines the C type used for Perl's I64.
  3131.  */
  3132. /* U64TYPE:
  3133.  *    This symbol defines the C type used for Perl's U64.
  3134.  */
  3135. /* NVTYPE:
  3136.  *    This symbol defines the C type used for Perl's NV.
  3137.  */
  3138. /* IVSIZE:
  3139.  *    This symbol contains the sizeof(IV).
  3140.  */
  3141. /* UVSIZE:
  3142.  *    This symbol contains the sizeof(UV).
  3143.  */
  3144. /* I8SIZE:
  3145.  *    This symbol contains the sizeof(I8).
  3146.  */
  3147. /* U8SIZE:
  3148.  *    This symbol contains the sizeof(U8).
  3149.  */
  3150. /* I16SIZE:
  3151.  *    This symbol contains the sizeof(I16).
  3152.  */
  3153. /* U16SIZE:
  3154.  *    This symbol contains the sizeof(U16).
  3155.  */
  3156. /* I32SIZE:
  3157.  *    This symbol contains the sizeof(I32).
  3158.  */
  3159. /* U32SIZE:
  3160.  *    This symbol contains the sizeof(U32).
  3161.  */
  3162. /* I64SIZE:
  3163.  *    This symbol contains the sizeof(I64).
  3164.  */
  3165. /* U64SIZE:
  3166.  *    This symbol contains the sizeof(U64).
  3167.  */
  3168. /* NVSIZE:
  3169.  *    This symbol contains the sizeof(NV).
  3170.  */
  3171. /* NV_PRESERVES_UV:
  3172.  *    This symbol, if defined, indicates that a variable of type NVTYPE
  3173.  *    can preserve all the bits of a variable of type UVTYPE.
  3174.  */
  3175. /* NV_PRESERVES_UV_BITS:
  3176.  *    This symbol contains the number of bits a variable of type NVTYPE
  3177.  *    can preserve of a variable of type UVTYPE.
  3178.  */
  3179. #define    IVTYPE        long        /**/
  3180. #define    UVTYPE        unsigned long        /**/
  3181. #define    I8TYPE        char        /**/
  3182. #define    U8TYPE        unsigned char        /**/
  3183. #define    I16TYPE        short    /**/
  3184. #define    U16TYPE        unsigned short    /**/
  3185. #define    I32TYPE        long    /**/
  3186. #define    U32TYPE        unsigned long    /**/
  3187. #ifdef HAS_QUAD
  3188. #define    I64TYPE        int64_t    /**/
  3189. #define    U64TYPE        uint64_t    /**/
  3190. #endif
  3191. #define    NVTYPE        double        /**/
  3192. #define    IVSIZE        4        /**/
  3193. #define    UVSIZE        4        /**/
  3194. #define    I8SIZE        1        /**/
  3195. #define    U8SIZE        1        /**/
  3196. #define    I16SIZE        2    /**/
  3197. #define    U16SIZE        2    /**/
  3198. #define    I32SIZE        4    /**/
  3199. #define    U32SIZE        4    /**/
  3200. #ifdef HAS_QUAD
  3201. #define    I64SIZE        8    /**/
  3202. #define    U64SIZE        8    /**/
  3203. #endif
  3204. #define    NVSIZE        8        /**/
  3205. #undef    NV_PRESERVES_UV
  3206. #define    NV_PRESERVES_UV_BITS    0
  3207.  
  3208. /* IVdf:
  3209.  *    This symbol defines the format string used for printing a Perl IV
  3210.  *    as a signed decimal integer.
  3211.  */
  3212. /* UVuf:
  3213.  *    This symbol defines the format string used for printing a Perl UV
  3214.  *    as an unsigned decimal integer.
  3215.  */
  3216. /* UVof:
  3217.  *    This symbol defines the format string used for printing a Perl UV
  3218.  *    as an unsigned octal integer.
  3219.  */
  3220. /* UVxf:
  3221.  *    This symbol defines the format string used for printing a Perl UV
  3222.  *    as an unsigned hexadecimal integer in lowercase abcdef.
  3223.  */
  3224. /* UVXf:
  3225.  *    This symbol defines the format string used for printing a Perl UV
  3226.  *    as an unsigned hexadecimal integer in uppercase ABCDEF.
  3227.  */
  3228. /* NVef:
  3229.  *    This symbol defines the format string used for printing a Perl NV
  3230.  *    using %e-ish floating point format.
  3231.  */
  3232. /* NVff:
  3233.  *    This symbol defines the format string used for printing a Perl NV
  3234.  *    using %f-ish floating point format.
  3235.  */
  3236. /* NVgf:
  3237.  *    This symbol defines the format string used for printing a Perl NV
  3238.  *    using %g-ish floating point format.
  3239.  */
  3240. #define    IVdf        "ld"        /**/
  3241. #define    UVuf        "lu"        /**/
  3242. #define    UVof        "lo"        /**/
  3243. #define    UVxf        "lx"        /**/
  3244. #define    UVXf        "lX"        /**/
  3245. #define    NVef        "e"        /**/
  3246. #define    NVff        "f"        /**/
  3247. #define    NVgf        "g"        /**/
  3248.  
  3249. /* SELECT_MIN_BITS:
  3250.  *    This symbol holds the minimum number of bits operated by select.
  3251.  *    That is, if you do select(n, ...), how many bits at least will be
  3252.  *    cleared in the masks if some activity is detected.  Usually this
  3253.  *    is either n or 32*ceil(n/32), especially many little-endians do
  3254.  *    the latter.  This is only useful if you have select(), naturally.
  3255.  */
  3256. #define SELECT_MIN_BITS     32    /**/
  3257.  
  3258. /* STARTPERL:
  3259.  *    This variable contains the string to put in front of a perl
  3260.  *    script to make sure (one hopes) that it runs with perl and not
  3261.  *    some shell.
  3262.  */
  3263. #define STARTPERL ""        /**/
  3264.  
  3265. /* HAS_STDIO_STREAM_ARRAY:
  3266.  *    This symbol, if defined, tells that there is an array
  3267.  *    holding the stdio streams.
  3268.  */
  3269. /* STDIO_STREAM_ARRAY:
  3270.  *    This symbol tells the name of the array holding the stdio streams.
  3271.  *    Usual values include _iob, __iob, and __sF.
  3272.  */
  3273. /*#define    HAS_STDIO_STREAM_ARRAY    / **/
  3274. #define STDIO_STREAM_ARRAY    
  3275.  
  3276. /* USE_64_BIT_INT:
  3277.  *    This symbol, if defined, indicates that 64-bit integers should
  3278.  *    be used when available.  If not defined, the native integers
  3279.  *    will be employed (be they 32 or 64 bits).  The minimal possible
  3280.  *    64-bitness is used, just enough to get 64-bit integers into Perl.
  3281.  *    This may mean using for example "long longs", while your memory
  3282.  *    may still be limited to 2 gigabytes.
  3283.  */
  3284. /* USE_64_BIT_ALL:
  3285.  *    This symbol, if defined, indicates that 64-bit integers should
  3286.  *    be used when available.  If not defined, the native integers
  3287.  *    will be used (be they 32 or 64 bits).  The maximal possible
  3288.  *    64-bitness is employed: LP64 or ILP64, meaning that you will
  3289.  *    be able to use more than 2 gigabytes of memory.  This mode is
  3290.  *    even more binary incompatible than USE_64_BIT_INT. You may not
  3291.  *    be able to run the resulting executable in a 32-bit CPU at all or
  3292.  *    you may need at least to reboot your OS to 64-bit mode.
  3293.  */
  3294. #ifndef USE_64_BIT_INT
  3295. /*#define    USE_64_BIT_INT        / **/
  3296. #endif
  3297.  
  3298. #ifndef USE_64_BIT_ALL
  3299. /*#define    USE_64_BIT_ALL        / **/
  3300. #endif
  3301.  
  3302. /* USE_FAST_STDIO:
  3303.  *    This symbol, if defined, indicates that Perl should
  3304.  *    be built to use 'fast stdio'.
  3305.  *    Defaults to define in Perls 5.8 and earlier, to undef later.
  3306.  */
  3307. #ifndef USE_FAST_STDIO
  3308. /*#define    USE_FAST_STDIO        / **/
  3309. #endif
  3310.  
  3311. /* USE_LARGE_FILES:
  3312.  *    This symbol, if defined, indicates that large file support
  3313.  *    should be used when available.
  3314.  */
  3315. #ifndef USE_LARGE_FILES
  3316. /*#define    USE_LARGE_FILES        / **/
  3317. #endif
  3318.  
  3319. /* USE_LONG_DOUBLE:
  3320.  *    This symbol, if defined, indicates that long doubles should
  3321.  *    be used when available.
  3322.  */
  3323. #ifndef USE_LONG_DOUBLE
  3324. /*#define    USE_LONG_DOUBLE        / **/
  3325. #endif
  3326.  
  3327. /* USE_MORE_BITS:
  3328.  *    This symbol, if defined, indicates that 64-bit interfaces and
  3329.  *    long doubles should be used when available.
  3330.  */
  3331. #ifndef USE_MORE_BITS
  3332. /*#define    USE_MORE_BITS        / **/
  3333. #endif
  3334.  
  3335. /* MULTIPLICITY:
  3336.  *    This symbol, if defined, indicates that Perl should
  3337.  *    be built to use multiplicity.
  3338.  */
  3339. #ifndef MULTIPLICITY
  3340. /*#define    MULTIPLICITY        / **/
  3341. #endif
  3342.  
  3343. /* USE_PERLIO:
  3344.  *    This symbol, if defined, indicates that the PerlIO abstraction should
  3345.  *    be used throughout.  If not defined, stdio should be
  3346.  *    used in a fully backward compatible manner.
  3347.  */
  3348. #ifndef USE_PERLIO
  3349. /*#define    USE_PERLIO        / **/
  3350. #endif
  3351.  
  3352. /* USE_SOCKS:
  3353.  *    This symbol, if defined, indicates that Perl should
  3354.  *    be built to use socks.
  3355.  */
  3356. #ifndef USE_SOCKS
  3357. /*#define    USE_SOCKS        / **/
  3358. #endif
  3359.  
  3360. /* HAS_DRAND48_PROTO:
  3361.  *    This symbol, if defined, indicates that the system provides
  3362.  *    a prototype for the drand48() function.  Otherwise, it is up
  3363.  *    to the program to supply one.  A good guess is
  3364.  *        extern double drand48(void);
  3365.  */
  3366. /*#define    HAS_DRAND48_PROTO    / **/
  3367.  
  3368. /* HAS_GETHOST_PROTOS:
  3369.  *    This symbol, if defined, indicates that <netdb.h> includes
  3370.  *    prototypes for gethostent(), gethostbyname(), and
  3371.  *    gethostbyaddr().  Otherwise, it is up to the program to guess
  3372.  *    them.  See netdbtype.U for probing for various Netdb_xxx_t types.
  3373.  */
  3374. /*#define    HAS_GETHOST_PROTOS    / **/
  3375.  
  3376. /* HAS_GETNET_PROTOS:
  3377.  *    This symbol, if defined, indicates that <netdb.h> includes
  3378.  *    prototypes for getnetent(), getnetbyname(), and
  3379.  *    getnetbyaddr().  Otherwise, it is up to the program to guess
  3380.  *    them.  See netdbtype.U for probing for various Netdb_xxx_t types.
  3381.  */
  3382. /*#define    HAS_GETNET_PROTOS    / **/
  3383.  
  3384. /* HAS_GETPROTO_PROTOS:
  3385.  *    This symbol, if defined, indicates that <netdb.h> includes
  3386.  *    prototypes for getprotoent(), getprotobyname(), and
  3387.  *    getprotobyaddr().  Otherwise, it is up to the program to guess
  3388.  *    them.  See netdbtype.U for probing for various Netdb_xxx_t types.
  3389.  */
  3390. /*#define    HAS_GETPROTO_PROTOS    / **/
  3391.  
  3392. /* HAS_GETSERV_PROTOS:
  3393.  *    This symbol, if defined, indicates that <netdb.h> includes
  3394.  *    prototypes for getservent(), getservbyname(), and
  3395.  *    getservbyaddr().  Otherwise, it is up to the program to guess
  3396.  *    them.  See netdbtype.U for probing for various Netdb_xxx_t types.
  3397.  */
  3398. /*#define    HAS_GETSERV_PROTOS    / **/
  3399.  
  3400. /* HAS_LSEEK_PROTO:
  3401.  *    This symbol, if defined, indicates that the system provides
  3402.  *    a prototype for the lseek() function.  Otherwise, it is up
  3403.  *    to the program to supply one.  A good guess is
  3404.  *        extern off_t lseek(int, off_t, int);
  3405.  */
  3406. /*#define    HAS_LSEEK_PROTO    / **/
  3407.  
  3408. /* Netdb_host_t:
  3409.  *    This symbol holds the type used for the 1st argument
  3410.  *    to gethostbyaddr().
  3411.  */
  3412. /* Netdb_hlen_t:
  3413.  *    This symbol holds the type used for the 2nd argument
  3414.  *    to gethostbyaddr().
  3415.  */
  3416. /* Netdb_name_t:
  3417.  *    This symbol holds the type used for the argument to
  3418.  *    gethostbyname().
  3419.  */
  3420. /* Netdb_net_t:
  3421.  *    This symbol holds the type used for the 1st argument to
  3422.  *    getnetbyaddr().
  3423.  */
  3424. #define Netdb_host_t        const char * /**/
  3425. #define Netdb_hlen_t        int /**/
  3426. #define Netdb_name_t        const char * /**/
  3427. #define Netdb_net_t        unsigned long /**/
  3428.  
  3429. /* Select_fd_set_t:
  3430.  *    This symbol holds the type used for the 2nd, 3rd, and 4th
  3431.  *    arguments to select.  Usually, this is 'fd_set *', if HAS_FD_SET
  3432.  *    is defined, and 'int *' otherwise.  This is only useful if you 
  3433.  *    have select(), of course.
  3434.  */
  3435. #define Select_fd_set_t     int    /**/
  3436.  
  3437. /* Sock_size_t:
  3438.  *    This symbol holds the type used for the size argument of
  3439.  *    various socket calls (just the base type, not the pointer-to).
  3440.  */
  3441. #define Sock_size_t        int /**/
  3442.  
  3443. /* ARCHNAME:
  3444.  *    This symbol holds a string representing the architecture name.
  3445.  *    It may be used to construct an architecture-dependant pathname
  3446.  *    where library files may be held under a private library, for
  3447.  *    instance.
  3448.  */
  3449. #define ARCHNAME "unknown"        /**/
  3450.  
  3451. /* HAS_ASCTIME_R:
  3452.  *    This symbol, if defined, indicates that the asctime_r routine
  3453.  *    is available to asctime re-entrantly.
  3454.  */
  3455. /* ASCTIME_R_PROTO:
  3456.  *    This symbol encodes the prototype of asctime_r.
  3457.  *    It is zero if d_asctime_r is undef, and one of the
  3458.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_asctime_r
  3459.  *    is defined.
  3460.  */
  3461. /*#define HAS_ASCTIME_R       / **/
  3462. #define ASCTIME_R_PROTO 0       /**/
  3463.  
  3464. /* HAS_CRYPT_R:
  3465.  *    This symbol, if defined, indicates that the crypt_r routine
  3466.  *    is available to crypt re-entrantly.
  3467.  */
  3468. /* CRYPT_R_PROTO:
  3469.  *    This symbol encodes the prototype of crypt_r.
  3470.  *    It is zero if d_crypt_r is undef, and one of the
  3471.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_crypt_r
  3472.  *    is defined.
  3473.  */
  3474. /*#define HAS_CRYPT_R       / **/
  3475. #define CRYPT_R_PROTO 0       /**/
  3476.  
  3477. /* HAS_CTERMID_R:
  3478.  *    This symbol, if defined, indicates that the ctermid_r routine
  3479.  *    is available to ctermid re-entrantly.
  3480.  */
  3481. /* CTERMID_R_PROTO:
  3482.  *    This symbol encodes the prototype of ctermid_r.
  3483.  *    It is zero if d_ctermid_r is undef, and one of the
  3484.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_ctermid_r
  3485.  *    is defined.
  3486.  */
  3487. /*#define HAS_CTERMID_R       / **/
  3488. #define CTERMID_R_PROTO 0       /**/
  3489.  
  3490. /* HAS_CTIME_R:
  3491.  *    This symbol, if defined, indicates that the ctime_r routine
  3492.  *    is available to ctime re-entrantly.
  3493.  */
  3494. /* CTIME_R_PROTO:
  3495.  *    This symbol encodes the prototype of ctime_r.
  3496.  *    It is zero if d_ctime_r is undef, and one of the
  3497.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_ctime_r
  3498.  *    is defined.
  3499.  */
  3500. /*#define HAS_CTIME_R       / **/
  3501. #define CTIME_R_PROTO 0       /**/
  3502.  
  3503. /* HAS_DRAND48_R:
  3504.  *    This symbol, if defined, indicates that the drand48_r routine
  3505.  *    is available to drand48 re-entrantly.
  3506.  */
  3507. /* DRAND48_R_PROTO:
  3508.  *    This symbol encodes the prototype of drand48_r.
  3509.  *    It is zero if d_drand48_r is undef, and one of the
  3510.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_drand48_r
  3511.  *    is defined.
  3512.  */
  3513. /*#define HAS_DRAND48_R       / **/
  3514. #define DRAND48_R_PROTO 0       /**/
  3515.  
  3516. /* HAS_ENDGRENT_R:
  3517.  *    This symbol, if defined, indicates that the endgrent_r routine
  3518.  *    is available to endgrent re-entrantly.
  3519.  */
  3520. /* ENDGRENT_R_PROTO:
  3521.  *    This symbol encodes the prototype of endgrent_r.
  3522.  *    It is zero if d_endgrent_r is undef, and one of the
  3523.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_endgrent_r
  3524.  *    is defined.
  3525.  */
  3526. /*#define HAS_ENDGRENT_R       / **/
  3527. #define ENDGRENT_R_PROTO 0       /**/
  3528.  
  3529. /* HAS_ENDHOSTENT_R:
  3530.  *    This symbol, if defined, indicates that the endhostent_r routine
  3531.  *    is available to endhostent re-entrantly.
  3532.  */
  3533. /* ENDHOSTENT_R_PROTO:
  3534.  *    This symbol encodes the prototype of endhostent_r.
  3535.  *    It is zero if d_endhostent_r is undef, and one of the
  3536.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_endhostent_r
  3537.  *    is defined.
  3538.  */
  3539. /*#define HAS_ENDHOSTENT_R       / **/
  3540. #define ENDHOSTENT_R_PROTO 0       /**/
  3541.  
  3542. /* HAS_ENDNETENT_R:
  3543.  *    This symbol, if defined, indicates that the endnetent_r routine
  3544.  *    is available to endnetent re-entrantly.
  3545.  */
  3546. /* ENDNETENT_R_PROTO:
  3547.  *    This symbol encodes the prototype of endnetent_r.
  3548.  *    It is zero if d_endnetent_r is undef, and one of the
  3549.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_endnetent_r
  3550.  *    is defined.
  3551.  */
  3552. /*#define HAS_ENDNETENT_R       / **/
  3553. #define ENDNETENT_R_PROTO 0       /**/
  3554.  
  3555. /* HAS_ENDPROTOENT_R:
  3556.  *    This symbol, if defined, indicates that the endprotoent_r routine
  3557.  *    is available to endprotoent re-entrantly.
  3558.  */
  3559. /* ENDPROTOENT_R_PROTO:
  3560.  *    This symbol encodes the prototype of endprotoent_r.
  3561.  *    It is zero if d_endprotoent_r is undef, and one of the
  3562.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_endprotoent_r
  3563.  *    is defined.
  3564.  */
  3565. /*#define HAS_ENDPROTOENT_R       / **/
  3566. #define ENDPROTOENT_R_PROTO 0       /**/
  3567.  
  3568. /* HAS_ENDPWENT_R:
  3569.  *    This symbol, if defined, indicates that the endpwent_r routine
  3570.  *    is available to endpwent re-entrantly.
  3571.  */
  3572. /* ENDPWENT_R_PROTO:
  3573.  *    This symbol encodes the prototype of endpwent_r.
  3574.  *    It is zero if d_endpwent_r is undef, and one of the
  3575.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_endpwent_r
  3576.  *    is defined.
  3577.  */
  3578. /*#define HAS_ENDPWENT_R       / **/
  3579. #define ENDPWENT_R_PROTO 0       /**/
  3580.  
  3581. /* HAS_ENDSERVENT_R:
  3582.  *    This symbol, if defined, indicates that the endservent_r routine
  3583.  *    is available to endservent re-entrantly.
  3584.  */
  3585. /* ENDSERVENT_R_PROTO:
  3586.  *    This symbol encodes the prototype of endservent_r.
  3587.  *    It is zero if d_endservent_r is undef, and one of the
  3588.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_endservent_r
  3589.  *    is defined.
  3590.  */
  3591. /*#define HAS_ENDSERVENT_R       / **/
  3592. #define ENDSERVENT_R_PROTO 0       /**/
  3593.  
  3594. /* HAS_GETGRENT_R:
  3595.  *    This symbol, if defined, indicates that the getgrent_r routine
  3596.  *    is available to getgrent re-entrantly.
  3597.  */
  3598. /* GETGRENT_R_PROTO:
  3599.  *    This symbol encodes the prototype of getgrent_r.
  3600.  *    It is zero if d_getgrent_r is undef, and one of the
  3601.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_getgrent_r
  3602.  *    is defined.
  3603.  */
  3604. /*#define HAS_GETGRENT_R       / **/
  3605. #define GETGRENT_R_PROTO 0       /**/
  3606.  
  3607. /* HAS_GETGRGID_R:
  3608.  *    This symbol, if defined, indicates that the getgrgid_r routine
  3609.  *    is available to getgrgid re-entrantly.
  3610.  */
  3611. /* GETGRGID_R_PROTO:
  3612.  *    This symbol encodes the prototype of getgrgid_r.
  3613.  *    It is zero if d_getgrgid_r is undef, and one of the
  3614.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_getgrgid_r
  3615.  *    is defined.
  3616.  */
  3617. /*#define HAS_GETGRGID_R       / **/
  3618. #define GETGRGID_R_PROTO 0       /**/
  3619.  
  3620. /* HAS_GETGRNAM_R:
  3621.  *    This symbol, if defined, indicates that the getgrnam_r routine
  3622.  *    is available to getgrnam re-entrantly.
  3623.  */
  3624. /* GETGRNAM_R_PROTO:
  3625.  *    This symbol encodes the prototype of getgrnam_r.
  3626.  *    It is zero if d_getgrnam_r is undef, and one of the
  3627.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_getgrnam_r
  3628.  *    is defined.
  3629.  */
  3630. /*#define HAS_GETGRNAM_R       / **/
  3631. #define GETGRNAM_R_PROTO 0       /**/
  3632.  
  3633. /* HAS_GETHOSTBYADDR_R:
  3634.  *    This symbol, if defined, indicates that the gethostbyaddr_r routine
  3635.  *    is available to gethostbyaddr re-entrantly.
  3636.  */
  3637. /* GETHOSTBYADDR_R_PROTO:
  3638.  *    This symbol encodes the prototype of gethostbyaddr_r.
  3639.  *    It is zero if d_gethostbyaddr_r is undef, and one of the
  3640.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_gethostbyaddr_r
  3641.  *    is defined.
  3642.  */
  3643. /*#define HAS_GETHOSTBYADDR_R       / **/
  3644. #define GETHOSTBYADDR_R_PROTO 0       /**/
  3645.  
  3646. /* HAS_GETHOSTBYNAME_R:
  3647.  *    This symbol, if defined, indicates that the gethostbyname_r routine
  3648.  *    is available to gethostbyname re-entrantly.
  3649.  */
  3650. /* GETHOSTBYNAME_R_PROTO:
  3651.  *    This symbol encodes the prototype of gethostbyname_r.
  3652.  *    It is zero if d_gethostbyname_r is undef, and one of the
  3653.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_gethostbyname_r
  3654.  *    is defined.
  3655.  */
  3656. /*#define HAS_GETHOSTBYNAME_R       / **/
  3657. #define GETHOSTBYNAME_R_PROTO 0       /**/
  3658.  
  3659. /* HAS_GETHOSTENT_R:
  3660.  *    This symbol, if defined, indicates that the gethostent_r routine
  3661.  *    is available to gethostent re-entrantly.
  3662.  */
  3663. /* GETHOSTENT_R_PROTO:
  3664.  *    This symbol encodes the prototype of gethostent_r.
  3665.  *    It is zero if d_gethostent_r is undef, and one of the
  3666.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_gethostent_r
  3667.  *    is defined.
  3668.  */
  3669. /*#define HAS_GETHOSTENT_R       / **/
  3670. #define GETHOSTENT_R_PROTO 0       /**/
  3671.  
  3672. /* HAS_GETLOGIN_R:
  3673.  *    This symbol, if defined, indicates that the getlogin_r routine
  3674.  *    is available to getlogin re-entrantly.
  3675.  */
  3676. /* GETLOGIN_R_PROTO:
  3677.  *    This symbol encodes the prototype of getlogin_r.
  3678.  *    It is zero if d_getlogin_r is undef, and one of the
  3679.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_getlogin_r
  3680.  *    is defined.
  3681.  */
  3682. /*#define HAS_GETLOGIN_R       / **/
  3683. #define GETLOGIN_R_PROTO 0       /**/
  3684.  
  3685. /* HAS_GETNETBYADDR_R:
  3686.  *    This symbol, if defined, indicates that the getnetbyaddr_r routine
  3687.  *    is available to getnetbyaddr re-entrantly.
  3688.  */
  3689. /* GETNETBYADDR_R_PROTO:
  3690.  *    This symbol encodes the prototype of getnetbyaddr_r.
  3691.  *    It is zero if d_getnetbyaddr_r is undef, and one of the
  3692.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_getnetbyaddr_r
  3693.  *    is defined.
  3694.  */
  3695. /*#define HAS_GETNETBYADDR_R       / **/
  3696. #define GETNETBYADDR_R_PROTO 0       /**/
  3697.  
  3698. /* HAS_GETNETBYNAME_R:
  3699.  *    This symbol, if defined, indicates that the getnetbyname_r routine
  3700.  *    is available to getnetbyname re-entrantly.
  3701.  */
  3702. /* GETNETBYNAME_R_PROTO:
  3703.  *    This symbol encodes the prototype of getnetbyname_r.
  3704.  *    It is zero if d_getnetbyname_r is undef, and one of the
  3705.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_getnetbyname_r
  3706.  *    is defined.
  3707.  */
  3708. /*#define HAS_GETNETBYNAME_R       / **/
  3709. #define GETNETBYNAME_R_PROTO 0       /**/
  3710.  
  3711. /* HAS_GETNETENT_R:
  3712.  *    This symbol, if defined, indicates that the getnetent_r routine
  3713.  *    is available to getnetent re-entrantly.
  3714.  */
  3715. /* GETNETENT_R_PROTO:
  3716.  *    This symbol encodes the prototype of getnetent_r.
  3717.  *    It is zero if d_getnetent_r is undef, and one of the
  3718.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_getnetent_r
  3719.  *    is defined.
  3720.  */
  3721. /*#define HAS_GETNETENT_R       / **/
  3722. #define GETNETENT_R_PROTO 0       /**/
  3723.  
  3724. /* HAS_GETPROTOBYNAME_R:
  3725.  *    This symbol, if defined, indicates that the getprotobyname_r routine
  3726.  *    is available to getprotobyname re-entrantly.
  3727.  */
  3728. /* GETPROTOBYNAME_R_PROTO:
  3729.  *    This symbol encodes the prototype of getprotobyname_r.
  3730.  *    It is zero if d_getprotobyname_r is undef, and one of the
  3731.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_getprotobyname_r
  3732.  *    is defined.
  3733.  */
  3734. /*#define HAS_GETPROTOBYNAME_R       / **/
  3735. #define GETPROTOBYNAME_R_PROTO 0       /**/
  3736.  
  3737. /* HAS_GETPROTOBYNUMBER_R:
  3738.  *    This symbol, if defined, indicates that the getprotobynumber_r routine
  3739.  *    is available to getprotobynumber re-entrantly.
  3740.  */
  3741. /* GETPROTOBYNUMBER_R_PROTO:
  3742.  *    This symbol encodes the prototype of getprotobynumber_r.
  3743.  *    It is zero if d_getprotobynumber_r is undef, and one of the
  3744.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_getprotobynumber_r
  3745.  *    is defined.
  3746.  */
  3747. /*#define HAS_GETPROTOBYNUMBER_R       / **/
  3748. #define GETPROTOBYNUMBER_R_PROTO 0       /**/
  3749.  
  3750. /* HAS_GETPROTOENT_R:
  3751.  *    This symbol, if defined, indicates that the getprotoent_r routine
  3752.  *    is available to getprotoent re-entrantly.
  3753.  */
  3754. /* GETPROTOENT_R_PROTO:
  3755.  *    This symbol encodes the prototype of getprotoent_r.
  3756.  *    It is zero if d_getprotoent_r is undef, and one of the
  3757.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_getprotoent_r
  3758.  *    is defined.
  3759.  */
  3760. /*#define HAS_GETPROTOENT_R       / **/
  3761. #define GETPROTOENT_R_PROTO 0       /**/
  3762.  
  3763. /* HAS_GETPWENT_R:
  3764.  *    This symbol, if defined, indicates that the getpwent_r routine
  3765.  *    is available to getpwent re-entrantly.
  3766.  */
  3767. /* GETPWENT_R_PROTO:
  3768.  *    This symbol encodes the prototype of getpwent_r.
  3769.  *    It is zero if d_getpwent_r is undef, and one of the
  3770.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_getpwent_r
  3771.  *    is defined.
  3772.  */
  3773. /*#define HAS_GETPWENT_R       / **/
  3774. #define GETPWENT_R_PROTO 0       /**/
  3775.  
  3776. /* HAS_GETPWNAM_R:
  3777.  *    This symbol, if defined, indicates that the getpwnam_r routine
  3778.  *    is available to getpwnam re-entrantly.
  3779.  */
  3780. /* GETPWNAM_R_PROTO:
  3781.  *    This symbol encodes the prototype of getpwnam_r.
  3782.  *    It is zero if d_getpwnam_r is undef, and one of the
  3783.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_getpwnam_r
  3784.  *    is defined.
  3785.  */
  3786. /*#define HAS_GETPWNAM_R       / **/
  3787. #define GETPWNAM_R_PROTO 0       /**/
  3788.  
  3789. /* HAS_GETPWUID_R:
  3790.  *    This symbol, if defined, indicates that the getpwuid_r routine
  3791.  *    is available to getpwuid re-entrantly.
  3792.  */
  3793. /* GETPWUID_R_PROTO:
  3794.  *    This symbol encodes the prototype of getpwuid_r.
  3795.  *    It is zero if d_getpwuid_r is undef, and one of the
  3796.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_getpwuid_r
  3797.  *    is defined.
  3798.  */
  3799. /*#define HAS_GETPWUID_R       / **/
  3800. #define GETPWUID_R_PROTO 0       /**/
  3801.  
  3802. /* HAS_GETSERVBYNAME_R:
  3803.  *    This symbol, if defined, indicates that the getservbyname_r routine
  3804.  *    is available to getservbyname re-entrantly.
  3805.  */
  3806. /* GETSERVBYNAME_R_PROTO:
  3807.  *    This symbol encodes the prototype of getservbyname_r.
  3808.  *    It is zero if d_getservbyname_r is undef, and one of the
  3809.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_getservbyname_r
  3810.  *    is defined.
  3811.  */
  3812. /*#define HAS_GETSERVBYNAME_R       / **/
  3813. #define GETSERVBYNAME_R_PROTO 0       /**/
  3814.  
  3815. /* HAS_GETSERVBYPORT_R:
  3816.  *    This symbol, if defined, indicates that the getservbyport_r routine
  3817.  *    is available to getservbyport re-entrantly.
  3818.  */
  3819. /* GETSERVBYPORT_R_PROTO:
  3820.  *    This symbol encodes the prototype of getservbyport_r.
  3821.  *    It is zero if d_getservbyport_r is undef, and one of the
  3822.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_getservbyport_r
  3823.  *    is defined.
  3824.  */
  3825. /*#define HAS_GETSERVBYPORT_R       / **/
  3826. #define GETSERVBYPORT_R_PROTO 0       /**/
  3827.  
  3828. /* HAS_GETSERVENT_R:
  3829.  *    This symbol, if defined, indicates that the getservent_r routine
  3830.  *    is available to getservent re-entrantly.
  3831.  */
  3832. /* GETSERVENT_R_PROTO:
  3833.  *    This symbol encodes the prototype of getservent_r.
  3834.  *    It is zero if d_getservent_r is undef, and one of the
  3835.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_getservent_r
  3836.  *    is defined.
  3837.  */
  3838. /*#define HAS_GETSERVENT_R       / **/
  3839. #define GETSERVENT_R_PROTO 0       /**/
  3840.  
  3841. /* HAS_GETSPNAM_R:
  3842.  *    This symbol, if defined, indicates that the getspnam_r routine
  3843.  *    is available to getspnam re-entrantly.
  3844.  */
  3845. /* GETSPNAM_R_PROTO:
  3846.  *    This symbol encodes the prototype of getspnam_r.
  3847.  *    It is zero if d_getspnam_r is undef, and one of the
  3848.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_getspnam_r
  3849.  *    is defined.
  3850.  */
  3851. /*#define HAS_GETSPNAM_R       / **/
  3852. #define GETSPNAM_R_PROTO 0       /**/
  3853.  
  3854. /* HAS_GMTIME_R:
  3855.  *    This symbol, if defined, indicates that the gmtime_r routine
  3856.  *    is available to gmtime re-entrantly.
  3857.  */
  3858. /* GMTIME_R_PROTO:
  3859.  *    This symbol encodes the prototype of gmtime_r.
  3860.  *    It is zero if d_gmtime_r is undef, and one of the
  3861.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_gmtime_r
  3862.  *    is defined.
  3863.  */
  3864. /*#define HAS_GMTIME_R       / **/
  3865. #define GMTIME_R_PROTO 0       /**/
  3866.  
  3867. /* HAS_LOCALTIME_R:
  3868.  *    This symbol, if defined, indicates that the localtime_r routine
  3869.  *    is available to localtime re-entrantly.
  3870.  */
  3871. /* LOCALTIME_R_PROTO:
  3872.  *    This symbol encodes the prototype of localtime_r.
  3873.  *    It is zero if d_localtime_r is undef, and one of the
  3874.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_localtime_r
  3875.  *    is defined.
  3876.  */
  3877. /*#define HAS_LOCALTIME_R       / **/
  3878. #define LOCALTIME_R_PROTO 0       /**/
  3879.  
  3880. /* OLD_PTHREAD_CREATE_JOINABLE:
  3881.  *    This symbol, if defined, indicates how to create pthread
  3882.  *    in joinable (aka undetached) state.  NOTE: not defined
  3883.  *    if pthread.h already has defined PTHREAD_CREATE_JOINABLE
  3884.  *    (the new version of the constant).
  3885.  *    If defined, known values are PTHREAD_CREATE_UNDETACHED
  3886.  *    and __UNDETACHED.
  3887.  */
  3888. /*#define OLD_PTHREAD_CREATE_JOINABLE  / **/
  3889.  
  3890. /* HAS_PTHREAD_ATFORK:
  3891.  *    This symbol, if defined, indicates that the pthread_atfork routine
  3892.  *    is available to setup fork handlers.
  3893.  */
  3894. /*#define HAS_PTHREAD_ATFORK        / **/
  3895.  
  3896. /* HAS_PTHREAD_YIELD:
  3897.  *    This symbol, if defined, indicates that the pthread_yield 
  3898.  *    routine is available to yield the execution of the current
  3899.  *    thread.     sched_yield is preferable to pthread_yield.
  3900.  */
  3901. /* SCHED_YIELD:
  3902.  *    This symbol defines the way to yield the execution of
  3903.  *    the current thread.  Known ways are sched_yield,
  3904.  *    pthread_yield, and pthread_yield with NULL.
  3905.  */
  3906. /* HAS_SCHED_YIELD:
  3907.  *    This symbol, if defined, indicates that the sched_yield
  3908.  *    routine is available to yield the execution of the current
  3909.  *    thread.     sched_yield is preferable to pthread_yield.
  3910.  */
  3911. /*#define HAS_PTHREAD_YIELD    / **/
  3912. #define SCHED_YIELD    sched_yield()    /**/
  3913. /*#define HAS_SCHED_YIELD    / **/
  3914.  
  3915. /* HAS_RANDOM_R:
  3916.  *    This symbol, if defined, indicates that the random_r routine
  3917.  *    is available to random re-entrantly.
  3918.  */
  3919. /* RANDOM_R_PROTO:
  3920.  *    This symbol encodes the prototype of random_r.
  3921.  *    It is zero if d_random_r is undef, and one of the
  3922.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_random_r
  3923.  *    is defined.
  3924.  */
  3925. /*#define HAS_RANDOM_R       / **/
  3926. #define RANDOM_R_PROTO 0       /**/
  3927.  
  3928. /* HAS_READDIR64_R:
  3929.  *    This symbol, if defined, indicates that the readdir64_r routine
  3930.  *    is available to readdir64 re-entrantly.
  3931.  */
  3932. /* READDIR64_R_PROTO:
  3933.  *    This symbol encodes the prototype of readdir64_r.
  3934.  *    It is zero if d_readdir64_r is undef, and one of the
  3935.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_readdir64_r
  3936.  *    is defined.
  3937.  */
  3938. /*#define HAS_READDIR64_R       / **/
  3939. #define READDIR64_R_PROTO 0       /**/
  3940.  
  3941. /* HAS_READDIR_R:
  3942.  *    This symbol, if defined, indicates that the readdir_r routine
  3943.  *    is available to readdir re-entrantly.
  3944.  */
  3945. /* READDIR_R_PROTO:
  3946.  *    This symbol encodes the prototype of readdir_r.
  3947.  *    It is zero if d_readdir_r is undef, and one of the
  3948.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_readdir_r
  3949.  *    is defined.
  3950.  */
  3951. /*#define HAS_READDIR_R       / **/
  3952. #define READDIR_R_PROTO 0       /**/
  3953.  
  3954. /* HAS_SETGRENT_R:
  3955.  *    This symbol, if defined, indicates that the setgrent_r routine
  3956.  *    is available to setgrent re-entrantly.
  3957.  */
  3958. /* SETGRENT_R_PROTO:
  3959.  *    This symbol encodes the prototype of setgrent_r.
  3960.  *    It is zero if d_setgrent_r is undef, and one of the
  3961.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_setgrent_r
  3962.  *    is defined.
  3963.  */
  3964. /*#define HAS_SETGRENT_R       / **/
  3965. #define SETGRENT_R_PROTO 0       /**/
  3966.  
  3967. /* HAS_SETHOSTENT_R:
  3968.  *    This symbol, if defined, indicates that the sethostent_r routine
  3969.  *    is available to sethostent re-entrantly.
  3970.  */
  3971. /* SETHOSTENT_R_PROTO:
  3972.  *    This symbol encodes the prototype of sethostent_r.
  3973.  *    It is zero if d_sethostent_r is undef, and one of the
  3974.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_sethostent_r
  3975.  *    is defined.
  3976.  */
  3977. /*#define HAS_SETHOSTENT_R       / **/
  3978. #define SETHOSTENT_R_PROTO 0       /**/
  3979.  
  3980. /* HAS_SETLOCALE_R:
  3981.  *    This symbol, if defined, indicates that the setlocale_r routine
  3982.  *    is available to setlocale re-entrantly.
  3983.  */
  3984. /* SETLOCALE_R_PROTO:
  3985.  *    This symbol encodes the prototype of setlocale_r.
  3986.  *    It is zero if d_setlocale_r is undef, and one of the
  3987.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_setlocale_r
  3988.  *    is defined.
  3989.  */
  3990. /*#define HAS_SETLOCALE_R       / **/
  3991. #define SETLOCALE_R_PROTO 0       /**/
  3992.  
  3993. /* HAS_SETNETENT_R:
  3994.  *    This symbol, if defined, indicates that the setnetent_r routine
  3995.  *    is available to setnetent re-entrantly.
  3996.  */
  3997. /* SETNETENT_R_PROTO:
  3998.  *    This symbol encodes the prototype of setnetent_r.
  3999.  *    It is zero if d_setnetent_r is undef, and one of the
  4000.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_setnetent_r
  4001.  *    is defined.
  4002.  */
  4003. /*#define HAS_SETNETENT_R       / **/
  4004. #define SETNETENT_R_PROTO 0       /**/
  4005.  
  4006. /* HAS_SETPROTOENT_R:
  4007.  *    This symbol, if defined, indicates that the setprotoent_r routine
  4008.  *    is available to setprotoent re-entrantly.
  4009.  */
  4010. /* SETPROTOENT_R_PROTO:
  4011.  *    This symbol encodes the prototype of setprotoent_r.
  4012.  *    It is zero if d_setprotoent_r is undef, and one of the
  4013.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_setprotoent_r
  4014.  *    is defined.
  4015.  */
  4016. /*#define HAS_SETPROTOENT_R       / **/
  4017. #define SETPROTOENT_R_PROTO 0       /**/
  4018.  
  4019. /* HAS_SETPWENT_R:
  4020.  *    This symbol, if defined, indicates that the setpwent_r routine
  4021.  *    is available to setpwent re-entrantly.
  4022.  */
  4023. /* SETPWENT_R_PROTO:
  4024.  *    This symbol encodes the prototype of setpwent_r.
  4025.  *    It is zero if d_setpwent_r is undef, and one of the
  4026.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_setpwent_r
  4027.  *    is defined.
  4028.  */
  4029. /*#define HAS_SETPWENT_R       / **/
  4030. #define SETPWENT_R_PROTO 0       /**/
  4031.  
  4032. /* HAS_SETSERVENT_R:
  4033.  *    This symbol, if defined, indicates that the setservent_r routine
  4034.  *    is available to setservent re-entrantly.
  4035.  */
  4036. /* SETSERVENT_R_PROTO:
  4037.  *    This symbol encodes the prototype of setservent_r.
  4038.  *    It is zero if d_setservent_r is undef, and one of the
  4039.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_setservent_r
  4040.  *    is defined.
  4041.  */
  4042. /*#define HAS_SETSERVENT_R       / **/
  4043. #define SETSERVENT_R_PROTO 0       /**/
  4044.  
  4045. /* HAS_SRAND48_R:
  4046.  *    This symbol, if defined, indicates that the srand48_r routine
  4047.  *    is available to srand48 re-entrantly.
  4048.  */
  4049. /* SRAND48_R_PROTO:
  4050.  *    This symbol encodes the prototype of srand48_r.
  4051.  *    It is zero if d_srand48_r is undef, and one of the
  4052.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_srand48_r
  4053.  *    is defined.
  4054.  */
  4055. /*#define HAS_SRAND48_R       / **/
  4056. #define SRAND48_R_PROTO 0       /**/
  4057.  
  4058. /* HAS_SRANDOM_R:
  4059.  *    This symbol, if defined, indicates that the srandom_r routine
  4060.  *    is available to srandom re-entrantly.
  4061.  */
  4062. /* SRANDOM_R_PROTO:
  4063.  *    This symbol encodes the prototype of srandom_r.
  4064.  *    It is zero if d_srandom_r is undef, and one of the
  4065.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_srandom_r
  4066.  *    is defined.
  4067.  */
  4068. /*#define HAS_SRANDOM_R       / **/
  4069. #define SRANDOM_R_PROTO 0       /**/
  4070.  
  4071. /* HAS_STRERROR_R:
  4072.  *    This symbol, if defined, indicates that the strerror_r routine
  4073.  *    is available to strerror re-entrantly.
  4074.  */
  4075. /* STRERROR_R_PROTO:
  4076.  *    This symbol encodes the prototype of strerror_r.
  4077.  *    It is zero if d_strerror_r is undef, and one of the
  4078.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_strerror_r
  4079.  *    is defined.
  4080.  */
  4081. /*#define HAS_STRERROR_R       / **/
  4082. #define STRERROR_R_PROTO 0       /**/
  4083.  
  4084. /* HAS_TMPNAM_R:
  4085.  *    This symbol, if defined, indicates that the tmpnam_r routine
  4086.  *    is available to tmpnam re-entrantly.
  4087.  */
  4088. /* TMPNAM_R_PROTO:
  4089.  *    This symbol encodes the prototype of tmpnam_r.
  4090.  *    It is zero if d_tmpnam_r is undef, and one of the
  4091.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_tmpnam_r
  4092.  *    is defined.
  4093.  */
  4094. /*#define HAS_TMPNAM_R       / **/
  4095. #define TMPNAM_R_PROTO 0       /**/
  4096.  
  4097. /* HAS_TTYNAME_R:
  4098.  *    This symbol, if defined, indicates that the ttyname_r routine
  4099.  *    is available to ttyname re-entrantly.
  4100.  */
  4101. /* TTYNAME_R_PROTO:
  4102.  *    This symbol encodes the prototype of ttyname_r.
  4103.  *    It is zero if d_ttyname_r is undef, and one of the
  4104.  *    REENTRANT_PROTO_T_ABC macros of reentr.h if d_ttyname_r
  4105.  *    is defined.
  4106.  */
  4107. /*#define HAS_TTYNAME_R       / **/
  4108. #define TTYNAME_R_PROTO 0       /**/
  4109.  
  4110. /* I_MACH_CTHREADS:
  4111.  *     This symbol, if defined, indicates to the C program that it should
  4112.  *     include <mach/cthreads.h>.
  4113.  */
  4114. /*#define   I_MACH_CTHREADS    / **/
  4115.  
  4116. /* I_PTHREAD:
  4117.  *     This symbol, if defined, indicates to the C program that it should
  4118.  *     include <pthread.h>.
  4119.  */
  4120. /*#define   I_PTHREAD    / **/
  4121.  
  4122. /* USE_ITHREADS:
  4123.  *    This symbol, if defined, indicates that Perl should be built to
  4124.  *    use the interpreter-based threading implementation.
  4125.  */
  4126. /* USE_5005THREADS:
  4127.  *    This symbol, if defined, indicates that Perl should be built to
  4128.  *    use the 5.005-based threading implementation.
  4129.  */
  4130. /* OLD_PTHREADS_API:
  4131.  *    This symbol, if defined, indicates that Perl should
  4132.  *    be built to use the old draft POSIX threads API.
  4133.  */
  4134. /* USE_REENTRANT_API:
  4135.  *    This symbol, if defined, indicates that Perl should
  4136.  *    try to use the various _r versions of library functions.
  4137.  *    This is extremely experimental.
  4138.  */
  4139. /*#define    USE_5005THREADS        / **/
  4140. /*#define    USE_ITHREADS        / **/
  4141. #if defined(USE_5005THREADS) && !defined(USE_ITHREADS)
  4142. #define        USE_THREADS        /* until src is revised*/
  4143. #endif
  4144. /*#define    OLD_PTHREADS_API        / **/
  4145. /*#define    USE_REENTRANT_API    / **/
  4146.  
  4147. /* HAS_TIME:
  4148.  *    This symbol, if defined, indicates that the time() routine exists.
  4149.  */
  4150. /* Time_t:
  4151.  *    This symbol holds the type returned by time(). It can be long,
  4152.  *    or time_t on BSD sites (in which case <sys/types.h> should be
  4153.  *    included).
  4154.  */
  4155. #define HAS_TIME        /**/
  4156. #define Time_t time_t        /* Time type */
  4157.  
  4158. /* HAS_TIMES:
  4159.  *    This symbol, if defined, indicates that the times() routine exists.
  4160.  *    Note that this became obsolete on some systems (SUNOS), which now
  4161.  * use getrusage(). It may be necessary to include <sys/times.h>.
  4162.  */
  4163. /*#define HAS_TIMES        / **/
  4164.  
  4165. /* Fpos_t:
  4166.  *    This symbol holds the type used to declare file positions in libc.
  4167.  *    It can be fpos_t, long, uint, etc... It may be necessary to include
  4168.  *    <sys/types.h> to get any typedef'ed information.
  4169.  */
  4170. #define Fpos_t int        /* File position type */
  4171.  
  4172. /* Gid_t_f:
  4173.  *    This symbol defines the format string used for printing a Gid_t.
  4174.  */
  4175. #define    Gid_t_f        "lu"        /**/
  4176.  
  4177. /* Gid_t_sign:
  4178.  *    This symbol holds the signedess of a Gid_t.
  4179.  *    1 for unsigned, -1 for signed.
  4180.  */
  4181. #define Gid_t_sign    1        /* GID sign */
  4182.  
  4183. /* Gid_t_size:
  4184.  *    This symbol holds the size of a Gid_t in bytes.
  4185.  */
  4186. #define Gid_t_size 4        /* GID size */
  4187.  
  4188. /* Gid_t:
  4189.  *    This symbol holds the return type of getgid() and the type of
  4190.  *    argument to setrgid() and related functions.  Typically,
  4191.  *    it is the type of group ids in the kernel. It can be int, ushort,
  4192.  *    gid_t, etc... It may be necessary to include <sys/types.h> to get
  4193.  *    any typedef'ed information.
  4194.  */
  4195. #define Gid_t int        /* Type for getgid(), etc... */
  4196.  
  4197. /* Off_t:
  4198.  *    This symbol holds the type used to declare offsets in the kernel.
  4199.  *    It can be int, long, off_t, etc... It may be necessary to include
  4200.  *    <sys/types.h> to get any typedef'ed information.
  4201.  */
  4202. /* LSEEKSIZE:
  4203.  *    This symbol holds the number of bytes used by the Off_t.
  4204.  */
  4205. /* Off_t_size:
  4206.  *    This symbol holds the number of bytes used by the Off_t.
  4207.  */
  4208. #define Off_t int        /* <offset> type */
  4209. #define LSEEKSIZE 4        /* <offset> size */
  4210. #define Off_t_size 4    /* <offset> size */
  4211.  
  4212. /* Mode_t:
  4213.  *    This symbol holds the type used to declare file modes 
  4214.  *    for systems calls.  It is usually mode_t, but may be
  4215.  *    int or unsigned short.  It may be necessary to include <sys/types.h>
  4216.  *    to get any typedef'ed information.
  4217.  */
  4218. #define Mode_t int     /* file mode parameter for system calls */
  4219.  
  4220. /* Pid_t:
  4221.  *    This symbol holds the type used to declare process ids in the kernel.
  4222.  *    It can be int, uint, pid_t, etc... It may be necessary to include
  4223.  *    <sys/types.h> to get any typedef'ed information.
  4224.  */
  4225. #define Pid_t int        /* PID type */
  4226.  
  4227. /* Size_t_size:
  4228.  *    This symbol holds the size of a Size_t in bytes.
  4229.  */
  4230. #define Size_t_size 4        /* */
  4231.  
  4232. /* Size_t:
  4233.  *    This symbol holds the type used to declare length parameters
  4234.  *    for string functions.  It is usually size_t, but may be
  4235.  *    unsigned long, int, etc.  It may be necessary to include
  4236.  *    <sys/types.h> to get any typedef'ed information.
  4237.  */
  4238. #define Size_t int     /* length paramater for string functions */
  4239.  
  4240. /* Uid_t_f:
  4241.  *    This symbol defines the format string used for printing a Uid_t.
  4242.  */
  4243. #define    Uid_t_f        "lu"        /**/
  4244.  
  4245. /* Uid_t_sign:
  4246.  *    This symbol holds the signedess of a Uid_t.
  4247.  *    1 for unsigned, -1 for signed.
  4248.  */
  4249. #define Uid_t_sign    1        /* UID sign */
  4250.  
  4251. /* Uid_t_size:
  4252.  *    This symbol holds the size of a Uid_t in bytes.
  4253.  */
  4254. #define Uid_t_size 4        /* UID size */
  4255.  
  4256. /* Uid_t:
  4257.  *    This symbol holds the type used to declare user ids in the kernel.
  4258.  *    It can be int, ushort, uid_t, etc... It may be necessary to include
  4259.  *    <sys/types.h> to get any typedef'ed information.
  4260.  */
  4261. #define Uid_t int        /* UID type */
  4262.  
  4263. #endif
  4264.