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