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