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