1 /* 2 * This file was produced by running the config_h.SH script, which 3 * gets its values from config.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 config.sh and rerun config_h.SH. 9 * 10 * \$Id: config.ga.h,v 1.8 2006/03/28 19:23:14 millert Exp $ 11 */ 12 13 /* 14 * Package name : perl5 15 * Source directory : /vos_ftp_site/pub/vos/posix/(alpha|ga)/perl 16 * Configuration time: 2002-02-15 20:16 UCT 17 * Configured by : Paul.Green@stratus.com 18 * Target system : VOS 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 "/system/gnu_library/bin/sed.pm" /**/ 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 _error_ /**/ 905 # define Uquad_t _error_ /**/ 906 # define QUADKIND _error_ /**/ 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 8 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 0x4321 /* 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)->_ptr) 1173 #define STDIO_PTR_LVALUE /**/ 1174 #define FILE_cnt(fp) ((fp)->_cnt) 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)->_base) 1203 #define FILE_bufsiz(fp) ((fp)->_cnt + (fp)->_ptr - (fp)->_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 #define 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()/(RAND_MAX+1) /**/ 1308 #define Rand_seed_t unsigned int /**/ 1309 #define seedDrand01(x) srand((Rand_seed_t)x) /**/ 1310 #define RANDBITS 15 /**/ 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 ssize_t /* 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 perl5. 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 "" /**/ 1342 /*#define ARCHLIB_EXP "" /**/ 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 "/system/gnu_library/bin" /**/ 1353 #define BIN_EXP "/system/gnu_library/bin" /**/ 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 0 /**/ 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 "/system/ported/lib/perl5/5.8.8" /**/ 1391 #define PRIVLIB_EXP "/system/ported/lib/perl5/5.8.8" /**/ 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 "/system/ported/lib/perl5/site_perl/5.8.8/hppa1.1" /**/ 1409 /*#define SITEARCH_EXP "/system/ported/lib/perl5/site_perl/5.8.8/hppa1.1" /**/ 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 "/system/ported/lib/perl5/site_perl/5.8.8" /**/ 1432 #define SITELIB_EXP "/system/ported/lib/perl5/site_perl/5.8.8" /**/ 1433 #define SITELIB_STEM "/system/ported/lib/perl5/site_perl" /**/ 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 "VOS" /**/ 1476 #define OSVERS "VOS" /**/ 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 "cc -E" 1528 #define CPPMINUS "-" 1529 #define CPPRUN "cc -E -" 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 "/system/gnu_library/bin/bash.pm" /**/ 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 _error_ /**/ 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 void * /**/ 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 void /* 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 gid_t /* 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 void /**/ 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 "/system/gnu_library/bin/bash.pm" /**/ 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 "ZERO","ABRT","FPE","ILL","INT","SEGV","TERM","USR1","USR2","IO","HUP","URG","ALRM","CHLD","CONT","KILL","STOP","PIPE","QUIT","BUS","TRAP","TSTP","TTIN","TTOU","RT1","RT2","RT3","RT4","RT5","RT6","RT7","RT8",0 /**/ 2217 #define SIG_NUM 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,0 /**/ 2218 #define SIG_SIZE 32 /**/ 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 unsigned 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 15 2244 #endif 2245 #define VOIDFLAGS 15 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 "undef" /**/ 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 int /**/ 2943 #define DB_Prefix_t int /**/ 2944 #define DB_VERSION_MAJOR_CFG undef /**/ 2945 #define DB_VERSION_MINOR_CFG undef /**/ 2946 #define DB_VERSION_PATCH_CFG undef /**/ 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 "Lf" /**/ 3090 #define PERL_PRIgldbl "Lg" /**/ 3091 #define PERL_PRIeldbl "Le" /**/ 3092 #define PERL_SCNfldbl "Lf" /**/ 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 int /**/ 3180 #define UVTYPE unsigned int /**/ 3181 #define I8TYPE char /**/ 3182 #define U8TYPE unsigned char /**/ 3183 #define I16TYPE short /**/ 3184 #define U16TYPE unsigned short /**/ 3185 #define I32TYPE int /**/ 3186 #define U32TYPE unsigned int /**/ 3187 #ifdef HAS_QUAD 3188 #define I64TYPE _error_ /**/ 3189 #define U64TYPE _error_ /**/ 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 _error_ /**/ 3202 #define U64SIZE _error_ /**/ 3203 #endif 3204 #define NVSIZE 8 /**/ 3205 #define NV_PRESERVES_UV 3206 #define NV_PRESERVES_UV_BITS 32 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 "d" /**/ 3241 #define UVuf "u" /**/ 3242 #define UVof "o" /**/ 3243 #define UVxf "x" /**/ 3244 #define UVXf "X" /**/ 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 1 /**/ 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 "!perl.pm" /**/ 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 _iob 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 /* PERL_XS_APIVERSION: 3361 * This variable contains the version of the oldest perl binary 3362 * compatible with the present perl. perl.c:incpush() and 3363 * lib/lib.pm will automatically search in /system/ported/lib/perl5/site_perl/5.8.8/hppa1.1 for older 3364 * directories across major versions back to xs_apiversion. 3365 * This is only useful if you have a perl library directory tree 3366 * structured like the default one. 3367 * See INSTALL for how this works. 3368 * The versioned site_perl directory was introduced in 5.005, 3369 * so that is the lowest possible value. 3370 * Since this can depend on compile time options 3371 * it is set by Configure. Other non-default sources 3372 * of potential incompatibility, such as multiplicity, threads, 3373 * debugging, 64bits, sfio, etc., are not checked for currently, 3374 * though in principle we could go snooping around in old 3375 * Config.pm files. 3376 */ 3377 /* PERL_PM_APIVERSION: 3378 * This variable contains the version of the oldest perl 3379 * compatible with the present perl. (That is, pure perl modules 3380 * written for pm_apiversion will still work for the current 3381 * version). perl.c:incpush() and lib/lib.pm will automatically 3382 * search in /system/ported/lib/perl5/site_perl/5.8.8 for older directories across major versions 3383 * back to pm_apiversion. This is only useful if you have a perl 3384 * library directory tree structured like the default one. The 3385 * versioned site_perl library was introduced in 5.005, so that's 3386 * the default setting for this variable. It's hard to imagine 3387 * it changing before Perl6. It is included here for symmetry 3388 * with xs_apiveprsion -- the searching algorithms will 3389 * (presumably) be similar. 3390 * See the INSTALL file for how this works. 3391 */ 3392 #define PERL_XS_APIVERSION "5.00563" 3393 #define PERL_PM_APIVERSION "5.005" 3394 3395 /* HAS_DRAND48_PROTO: 3396 * This symbol, if defined, indicates that the system provides 3397 * a prototype for the drand48() function. Otherwise, it is up 3398 * to the program to supply one. A good guess is 3399 * extern double drand48(void); 3400 */ 3401 /*#define HAS_DRAND48_PROTO /**/ 3402 3403 /* HAS_GETHOST_PROTOS: 3404 * This symbol, if defined, indicates that <netdb.h> includes 3405 * prototypes for gethostent(), gethostbyname(), and 3406 * gethostbyaddr(). Otherwise, it is up to the program to guess 3407 * them. See netdbtype.U for probing for various Netdb_xxx_t types. 3408 */ 3409 #define HAS_GETHOST_PROTOS /**/ 3410 3411 /* HAS_GETNET_PROTOS: 3412 * This symbol, if defined, indicates that <netdb.h> includes 3413 * prototypes for getnetent(), getnetbyname(), and 3414 * getnetbyaddr(). Otherwise, it is up to the program to guess 3415 * them. See netdbtype.U for probing for various Netdb_xxx_t types. 3416 */ 3417 #define HAS_GETNET_PROTOS /**/ 3418 3419 /* HAS_GETPROTO_PROTOS: 3420 * This symbol, if defined, indicates that <netdb.h> includes 3421 * prototypes for getprotoent(), getprotobyname(), and 3422 * getprotobyaddr(). Otherwise, it is up to the program to guess 3423 * them. See netdbtype.U for probing for various Netdb_xxx_t types. 3424 */ 3425 #define HAS_GETPROTO_PROTOS /**/ 3426 3427 /* HAS_GETSERV_PROTOS: 3428 * This symbol, if defined, indicates that <netdb.h> includes 3429 * prototypes for getservent(), getservbyname(), and 3430 * getservbyaddr(). Otherwise, it is up to the program to guess 3431 * them. See netdbtype.U for probing for various Netdb_xxx_t types. 3432 */ 3433 #define HAS_GETSERV_PROTOS /**/ 3434 3435 /* HAS_LSEEK_PROTO: 3436 * This symbol, if defined, indicates that the system provides 3437 * a prototype for the lseek() function. Otherwise, it is up 3438 * to the program to supply one. A good guess is 3439 * extern off_t lseek(int, off_t, int); 3440 */ 3441 #define HAS_LSEEK_PROTO /**/ 3442 3443 /* Netdb_host_t: 3444 * This symbol holds the type used for the 1st argument 3445 * to gethostbyaddr(). 3446 */ 3447 /* Netdb_hlen_t: 3448 * This symbol holds the type used for the 2nd argument 3449 * to gethostbyaddr(). 3450 */ 3451 /* Netdb_name_t: 3452 * This symbol holds the type used for the argument to 3453 * gethostbyname(). 3454 */ 3455 /* Netdb_net_t: 3456 * This symbol holds the type used for the 1st argument to 3457 * getnetbyaddr(). 3458 */ 3459 #define Netdb_host_t char * /**/ 3460 #define Netdb_hlen_t int /**/ 3461 #define Netdb_name_t char * /**/ 3462 #define Netdb_net_t long /**/ 3463 3464 /* Select_fd_set_t: 3465 * This symbol holds the type used for the 2nd, 3rd, and 4th 3466 * arguments to select. Usually, this is 'fd_set *', if HAS_FD_SET 3467 * is defined, and 'int *' otherwise. This is only useful if you 3468 * have select(), of course. 3469 */ 3470 #define Select_fd_set_t fd_set * /**/ 3471 3472 /* Sock_size_t: 3473 * This symbol holds the type used for the size argument of 3474 * various socket calls (just the base type, not the pointer-to). 3475 */ 3476 #define Sock_size_t int /**/ 3477 3478 /* ARCHNAME: 3479 * This symbol holds a string representing the architecture name. 3480 * It may be used to construct an architecture-dependant pathname 3481 * where library files may be held under a private library, for 3482 * instance. 3483 */ 3484 #define ARCHNAME "" /**/ 3485 3486 /* HAS_ASCTIME_R: 3487 * This symbol, if defined, indicates that the asctime_r routine 3488 * is available to asctime re-entrantly. 3489 */ 3490 /* ASCTIME_R_PROTO: 3491 * This symbol encodes the prototype of asctime_r. 3492 * It is zero if d_asctime_r is undef, and one of the 3493 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_asctime_r 3494 * is defined. 3495 */ 3496 /*#define HAS_ASCTIME_R /**/ 3497 #define ASCTIME_R_PROTO 0 /**/ 3498 3499 /* HAS_CRYPT_R: 3500 * This symbol, if defined, indicates that the crypt_r routine 3501 * is available to crypt re-entrantly. 3502 */ 3503 /* CRYPT_R_PROTO: 3504 * This symbol encodes the prototype of crypt_r. 3505 * It is zero if d_crypt_r is undef, and one of the 3506 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_crypt_r 3507 * is defined. 3508 */ 3509 /*#define HAS_CRYPT_R /**/ 3510 #define CRYPT_R_PROTO 0 /**/ 3511 3512 /* HAS_CTERMID_R: 3513 * This symbol, if defined, indicates that the ctermid_r routine 3514 * is available to ctermid re-entrantly. 3515 */ 3516 /* CTERMID_R_PROTO: 3517 * This symbol encodes the prototype of ctermid_r. 3518 * It is zero if d_ctermid_r is undef, and one of the 3519 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_ctermid_r 3520 * is defined. 3521 */ 3522 /*#define HAS_CTERMID_R /**/ 3523 #define CTERMID_R_PROTO 0 /**/ 3524 3525 /* HAS_CTIME_R: 3526 * This symbol, if defined, indicates that the ctime_r routine 3527 * is available to ctime re-entrantly. 3528 */ 3529 /* CTIME_R_PROTO: 3530 * This symbol encodes the prototype of ctime_r. 3531 * It is zero if d_ctime_r is undef, and one of the 3532 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_ctime_r 3533 * is defined. 3534 */ 3535 /*#define HAS_CTIME_R /**/ 3536 #define CTIME_R_PROTO 0 /**/ 3537 3538 /* HAS_DRAND48_R: 3539 * This symbol, if defined, indicates that the drand48_r routine 3540 * is available to drand48 re-entrantly. 3541 */ 3542 /* DRAND48_R_PROTO: 3543 * This symbol encodes the prototype of drand48_r. 3544 * It is zero if d_drand48_r is undef, and one of the 3545 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_drand48_r 3546 * is defined. 3547 */ 3548 /*#define HAS_DRAND48_R /**/ 3549 #define DRAND48_R_PROTO 0 /**/ 3550 3551 /* HAS_ENDGRENT_R: 3552 * This symbol, if defined, indicates that the endgrent_r routine 3553 * is available to endgrent re-entrantly. 3554 */ 3555 /* ENDGRENT_R_PROTO: 3556 * This symbol encodes the prototype of endgrent_r. 3557 * It is zero if d_endgrent_r is undef, and one of the 3558 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_endgrent_r 3559 * is defined. 3560 */ 3561 /*#define HAS_ENDGRENT_R /**/ 3562 #define ENDGRENT_R_PROTO 0 /**/ 3563 3564 /* HAS_ENDHOSTENT_R: 3565 * This symbol, if defined, indicates that the endhostent_r routine 3566 * is available to endhostent re-entrantly. 3567 */ 3568 /* ENDHOSTENT_R_PROTO: 3569 * This symbol encodes the prototype of endhostent_r. 3570 * It is zero if d_endhostent_r is undef, and one of the 3571 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_endhostent_r 3572 * is defined. 3573 */ 3574 /*#define HAS_ENDHOSTENT_R /**/ 3575 #define ENDHOSTENT_R_PROTO 0 /**/ 3576 3577 /* HAS_ENDNETENT_R: 3578 * This symbol, if defined, indicates that the endnetent_r routine 3579 * is available to endnetent re-entrantly. 3580 */ 3581 /* ENDNETENT_R_PROTO: 3582 * This symbol encodes the prototype of endnetent_r. 3583 * It is zero if d_endnetent_r is undef, and one of the 3584 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_endnetent_r 3585 * is defined. 3586 */ 3587 /*#define HAS_ENDNETENT_R /**/ 3588 #define ENDNETENT_R_PROTO 0 /**/ 3589 3590 /* HAS_ENDPROTOENT_R: 3591 * This symbol, if defined, indicates that the endprotoent_r routine 3592 * is available to endprotoent re-entrantly. 3593 */ 3594 /* ENDPROTOENT_R_PROTO: 3595 * This symbol encodes the prototype of endprotoent_r. 3596 * It is zero if d_endprotoent_r is undef, and one of the 3597 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_endprotoent_r 3598 * is defined. 3599 */ 3600 /*#define HAS_ENDPROTOENT_R /**/ 3601 #define ENDPROTOENT_R_PROTO 0 /**/ 3602 3603 /* HAS_ENDPWENT_R: 3604 * This symbol, if defined, indicates that the endpwent_r routine 3605 * is available to endpwent re-entrantly. 3606 */ 3607 /* ENDPWENT_R_PROTO: 3608 * This symbol encodes the prototype of endpwent_r. 3609 * It is zero if d_endpwent_r is undef, and one of the 3610 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_endpwent_r 3611 * is defined. 3612 */ 3613 /*#define HAS_ENDPWENT_R /**/ 3614 #define ENDPWENT_R_PROTO 0 /**/ 3615 3616 /* HAS_ENDSERVENT_R: 3617 * This symbol, if defined, indicates that the endservent_r routine 3618 * is available to endservent re-entrantly. 3619 */ 3620 /* ENDSERVENT_R_PROTO: 3621 * This symbol encodes the prototype of endservent_r. 3622 * It is zero if d_endservent_r is undef, and one of the 3623 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_endservent_r 3624 * is defined. 3625 */ 3626 /*#define HAS_ENDSERVENT_R /**/ 3627 #define ENDSERVENT_R_PROTO 0 /**/ 3628 3629 /* HAS_GETGRENT_R: 3630 * This symbol, if defined, indicates that the getgrent_r routine 3631 * is available to getgrent re-entrantly. 3632 */ 3633 /* GETGRENT_R_PROTO: 3634 * This symbol encodes the prototype of getgrent_r. 3635 * It is zero if d_getgrent_r is undef, and one of the 3636 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getgrent_r 3637 * is defined. 3638 */ 3639 /*#define HAS_GETGRENT_R /**/ 3640 #define GETGRENT_R_PROTO 0 /**/ 3641 3642 /* HAS_GETGRGID_R: 3643 * This symbol, if defined, indicates that the getgrgid_r routine 3644 * is available to getgrgid re-entrantly. 3645 */ 3646 /* GETGRGID_R_PROTO: 3647 * This symbol encodes the prototype of getgrgid_r. 3648 * It is zero if d_getgrgid_r is undef, and one of the 3649 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getgrgid_r 3650 * is defined. 3651 */ 3652 /*#define HAS_GETGRGID_R /**/ 3653 #define GETGRGID_R_PROTO 0 /**/ 3654 3655 /* HAS_GETGRNAM_R: 3656 * This symbol, if defined, indicates that the getgrnam_r routine 3657 * is available to getgrnam re-entrantly. 3658 */ 3659 /* GETGRNAM_R_PROTO: 3660 * This symbol encodes the prototype of getgrnam_r. 3661 * It is zero if d_getgrnam_r is undef, and one of the 3662 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getgrnam_r 3663 * is defined. 3664 */ 3665 /*#define HAS_GETGRNAM_R /**/ 3666 #define GETGRNAM_R_PROTO 0 /**/ 3667 3668 /* HAS_GETHOSTBYADDR_R: 3669 * This symbol, if defined, indicates that the gethostbyaddr_r routine 3670 * is available to gethostbyaddr re-entrantly. 3671 */ 3672 /* GETHOSTBYADDR_R_PROTO: 3673 * This symbol encodes the prototype of gethostbyaddr_r. 3674 * It is zero if d_gethostbyaddr_r is undef, and one of the 3675 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_gethostbyaddr_r 3676 * is defined. 3677 */ 3678 /*#define HAS_GETHOSTBYADDR_R /**/ 3679 #define GETHOSTBYADDR_R_PROTO 0 /**/ 3680 3681 /* HAS_GETHOSTBYNAME_R: 3682 * This symbol, if defined, indicates that the gethostbyname_r routine 3683 * is available to gethostbyname re-entrantly. 3684 */ 3685 /* GETHOSTBYNAME_R_PROTO: 3686 * This symbol encodes the prototype of gethostbyname_r. 3687 * It is zero if d_gethostbyname_r is undef, and one of the 3688 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_gethostbyname_r 3689 * is defined. 3690 */ 3691 /*#define HAS_GETHOSTBYNAME_R /**/ 3692 #define GETHOSTBYNAME_R_PROTO 0 /**/ 3693 3694 /* HAS_GETHOSTENT_R: 3695 * This symbol, if defined, indicates that the gethostent_r routine 3696 * is available to gethostent re-entrantly. 3697 */ 3698 /* GETHOSTENT_R_PROTO: 3699 * This symbol encodes the prototype of gethostent_r. 3700 * It is zero if d_gethostent_r is undef, and one of the 3701 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_gethostent_r 3702 * is defined. 3703 */ 3704 /*#define HAS_GETHOSTENT_R /**/ 3705 #define GETHOSTENT_R_PROTO 0 /**/ 3706 3707 /* HAS_GETLOGIN_R: 3708 * This symbol, if defined, indicates that the getlogin_r routine 3709 * is available to getlogin re-entrantly. 3710 */ 3711 /* GETLOGIN_R_PROTO: 3712 * This symbol encodes the prototype of getlogin_r. 3713 * It is zero if d_getlogin_r is undef, and one of the 3714 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getlogin_r 3715 * is defined. 3716 */ 3717 /*#define HAS_GETLOGIN_R /**/ 3718 #define GETLOGIN_R_PROTO 0 /**/ 3719 3720 /* HAS_GETNETBYADDR_R: 3721 * This symbol, if defined, indicates that the getnetbyaddr_r routine 3722 * is available to getnetbyaddr re-entrantly. 3723 */ 3724 /* GETNETBYADDR_R_PROTO: 3725 * This symbol encodes the prototype of getnetbyaddr_r. 3726 * It is zero if d_getnetbyaddr_r is undef, and one of the 3727 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getnetbyaddr_r 3728 * is defined. 3729 */ 3730 /*#define HAS_GETNETBYADDR_R /**/ 3731 #define GETNETBYADDR_R_PROTO 0 /**/ 3732 3733 /* HAS_GETNETBYNAME_R: 3734 * This symbol, if defined, indicates that the getnetbyname_r routine 3735 * is available to getnetbyname re-entrantly. 3736 */ 3737 /* GETNETBYNAME_R_PROTO: 3738 * This symbol encodes the prototype of getnetbyname_r. 3739 * It is zero if d_getnetbyname_r is undef, and one of the 3740 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getnetbyname_r 3741 * is defined. 3742 */ 3743 /*#define HAS_GETNETBYNAME_R /**/ 3744 #define GETNETBYNAME_R_PROTO 0 /**/ 3745 3746 /* HAS_GETNETENT_R: 3747 * This symbol, if defined, indicates that the getnetent_r routine 3748 * is available to getnetent re-entrantly. 3749 */ 3750 /* GETNETENT_R_PROTO: 3751 * This symbol encodes the prototype of getnetent_r. 3752 * It is zero if d_getnetent_r is undef, and one of the 3753 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getnetent_r 3754 * is defined. 3755 */ 3756 /*#define HAS_GETNETENT_R /**/ 3757 #define GETNETENT_R_PROTO 0 /**/ 3758 3759 /* HAS_GETPROTOBYNAME_R: 3760 * This symbol, if defined, indicates that the getprotobyname_r routine 3761 * is available to getprotobyname re-entrantly. 3762 */ 3763 /* GETPROTOBYNAME_R_PROTO: 3764 * This symbol encodes the prototype of getprotobyname_r. 3765 * It is zero if d_getprotobyname_r is undef, and one of the 3766 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getprotobyname_r 3767 * is defined. 3768 */ 3769 /*#define HAS_GETPROTOBYNAME_R /**/ 3770 #define GETPROTOBYNAME_R_PROTO 0 /**/ 3771 3772 /* HAS_GETPROTOBYNUMBER_R: 3773 * This symbol, if defined, indicates that the getprotobynumber_r routine 3774 * is available to getprotobynumber re-entrantly. 3775 */ 3776 /* GETPROTOBYNUMBER_R_PROTO: 3777 * This symbol encodes the prototype of getprotobynumber_r. 3778 * It is zero if d_getprotobynumber_r is undef, and one of the 3779 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getprotobynumber_r 3780 * is defined. 3781 */ 3782 /*#define HAS_GETPROTOBYNUMBER_R /**/ 3783 #define GETPROTOBYNUMBER_R_PROTO 0 /**/ 3784 3785 /* HAS_GETPROTOENT_R: 3786 * This symbol, if defined, indicates that the getprotoent_r routine 3787 * is available to getprotoent re-entrantly. 3788 */ 3789 /* GETPROTOENT_R_PROTO: 3790 * This symbol encodes the prototype of getprotoent_r. 3791 * It is zero if d_getprotoent_r is undef, and one of the 3792 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getprotoent_r 3793 * is defined. 3794 */ 3795 /*#define HAS_GETPROTOENT_R /**/ 3796 #define GETPROTOENT_R_PROTO 0 /**/ 3797 3798 /* HAS_GETPWENT_R: 3799 * This symbol, if defined, indicates that the getpwent_r routine 3800 * is available to getpwent re-entrantly. 3801 */ 3802 /* GETPWENT_R_PROTO: 3803 * This symbol encodes the prototype of getpwent_r. 3804 * It is zero if d_getpwent_r is undef, and one of the 3805 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getpwent_r 3806 * is defined. 3807 */ 3808 /*#define HAS_GETPWENT_R /**/ 3809 #define GETPWENT_R_PROTO 0 /**/ 3810 3811 /* HAS_GETPWNAM_R: 3812 * This symbol, if defined, indicates that the getpwnam_r routine 3813 * is available to getpwnam re-entrantly. 3814 */ 3815 /* GETPWNAM_R_PROTO: 3816 * This symbol encodes the prototype of getpwnam_r. 3817 * It is zero if d_getpwnam_r is undef, and one of the 3818 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getpwnam_r 3819 * is defined. 3820 */ 3821 /*#define HAS_GETPWNAM_R /**/ 3822 #define GETPWNAM_R_PROTO 0 /**/ 3823 3824 /* HAS_GETPWUID_R: 3825 * This symbol, if defined, indicates that the getpwuid_r routine 3826 * is available to getpwuid re-entrantly. 3827 */ 3828 /* GETPWUID_R_PROTO: 3829 * This symbol encodes the prototype of getpwuid_r. 3830 * It is zero if d_getpwuid_r is undef, and one of the 3831 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getpwuid_r 3832 * is defined. 3833 */ 3834 /*#define HAS_GETPWUID_R /**/ 3835 #define GETPWUID_R_PROTO 0 /**/ 3836 3837 /* HAS_GETSERVBYNAME_R: 3838 * This symbol, if defined, indicates that the getservbyname_r routine 3839 * is available to getservbyname re-entrantly. 3840 */ 3841 /* GETSERVBYNAME_R_PROTO: 3842 * This symbol encodes the prototype of getservbyname_r. 3843 * It is zero if d_getservbyname_r is undef, and one of the 3844 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getservbyname_r 3845 * is defined. 3846 */ 3847 /*#define HAS_GETSERVBYNAME_R /**/ 3848 #define GETSERVBYNAME_R_PROTO 0 /**/ 3849 3850 /* HAS_GETSERVBYPORT_R: 3851 * This symbol, if defined, indicates that the getservbyport_r routine 3852 * is available to getservbyport re-entrantly. 3853 */ 3854 /* GETSERVBYPORT_R_PROTO: 3855 * This symbol encodes the prototype of getservbyport_r. 3856 * It is zero if d_getservbyport_r is undef, and one of the 3857 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getservbyport_r 3858 * is defined. 3859 */ 3860 /*#define HAS_GETSERVBYPORT_R /**/ 3861 #define GETSERVBYPORT_R_PROTO 0 /**/ 3862 3863 /* HAS_GETSERVENT_R: 3864 * This symbol, if defined, indicates that the getservent_r routine 3865 * is available to getservent re-entrantly. 3866 */ 3867 /* GETSERVENT_R_PROTO: 3868 * This symbol encodes the prototype of getservent_r. 3869 * It is zero if d_getservent_r is undef, and one of the 3870 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getservent_r 3871 * is defined. 3872 */ 3873 /*#define HAS_GETSERVENT_R /**/ 3874 #define GETSERVENT_R_PROTO 0 /**/ 3875 3876 /* HAS_GETSPNAM_R: 3877 * This symbol, if defined, indicates that the getspnam_r routine 3878 * is available to getspnam re-entrantly. 3879 */ 3880 /* GETSPNAM_R_PROTO: 3881 * This symbol encodes the prototype of getspnam_r. 3882 * It is zero if d_getspnam_r is undef, and one of the 3883 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getspnam_r 3884 * is defined. 3885 */ 3886 /*#define HAS_GETSPNAM_R /**/ 3887 #define GETSPNAM_R_PROTO 0 /**/ 3888 3889 /* HAS_GMTIME_R: 3890 * This symbol, if defined, indicates that the gmtime_r routine 3891 * is available to gmtime re-entrantly. 3892 */ 3893 /* GMTIME_R_PROTO: 3894 * This symbol encodes the prototype of gmtime_r. 3895 * It is zero if d_gmtime_r is undef, and one of the 3896 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_gmtime_r 3897 * is defined. 3898 */ 3899 /*#define HAS_GMTIME_R /**/ 3900 #define GMTIME_R_PROTO 0 /**/ 3901 3902 /* HAS_LOCALTIME_R: 3903 * This symbol, if defined, indicates that the localtime_r routine 3904 * is available to localtime re-entrantly. 3905 */ 3906 /* LOCALTIME_R_PROTO: 3907 * This symbol encodes the prototype of localtime_r. 3908 * It is zero if d_localtime_r is undef, and one of the 3909 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_localtime_r 3910 * is defined. 3911 */ 3912 /*#define HAS_LOCALTIME_R /**/ 3913 #define LOCALTIME_R_PROTO 0 /**/ 3914 3915 /* OLD_PTHREAD_CREATE_JOINABLE: 3916 * This symbol, if defined, indicates how to create pthread 3917 * in joinable (aka undetached) state. NOTE: not defined 3918 * if pthread.h already has defined PTHREAD_CREATE_JOINABLE 3919 * (the new version of the constant). 3920 * If defined, known values are PTHREAD_CREATE_UNDETACHED 3921 * and __UNDETACHED. 3922 */ 3923 /*#define OLD_PTHREAD_CREATE_JOINABLE /**/ 3924 3925 /* HAS_PTHREAD_ATFORK: 3926 * This symbol, if defined, indicates that the pthread_atfork routine 3927 * is available to setup fork handlers. 3928 */ 3929 /*#define HAS_PTHREAD_ATFORK /**/ 3930 3931 /* HAS_PTHREAD_YIELD: 3932 * This symbol, if defined, indicates that the pthread_yield 3933 * routine is available to yield the execution of the current 3934 * thread. sched_yield is preferable to pthread_yield. 3935 */ 3936 /* SCHED_YIELD: 3937 * This symbol defines the way to yield the execution of 3938 * the current thread. Known ways are sched_yield, 3939 * pthread_yield, and pthread_yield with NULL. 3940 */ 3941 /* HAS_SCHED_YIELD: 3942 * This symbol, if defined, indicates that the sched_yield 3943 * routine is available to yield the execution of the current 3944 * thread. sched_yield is preferable to pthread_yield. 3945 */ 3946 /*#define HAS_PTHREAD_YIELD /**/ 3947 #define SCHED_YIELD /**/ 3948 /*#define HAS_SCHED_YIELD /**/ 3949 3950 /* HAS_RANDOM_R: 3951 * This symbol, if defined, indicates that the random_r routine 3952 * is available to random re-entrantly. 3953 */ 3954 /* RANDOM_R_PROTO: 3955 * This symbol encodes the prototype of random_r. 3956 * It is zero if d_random_r is undef, and one of the 3957 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_random_r 3958 * is defined. 3959 */ 3960 /*#define HAS_RANDOM_R /**/ 3961 #define RANDOM_R_PROTO 0 /**/ 3962 3963 /* HAS_READDIR64_R: 3964 * This symbol, if defined, indicates that the readdir64_r routine 3965 * is available to readdir64 re-entrantly. 3966 */ 3967 /* READDIR64_R_PROTO: 3968 * This symbol encodes the prototype of readdir64_r. 3969 * It is zero if d_readdir64_r is undef, and one of the 3970 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_readdir64_r 3971 * is defined. 3972 */ 3973 /*#define HAS_READDIR64_R /**/ 3974 #define READDIR64_R_PROTO 0 /**/ 3975 3976 /* HAS_READDIR_R: 3977 * This symbol, if defined, indicates that the readdir_r routine 3978 * is available to readdir re-entrantly. 3979 */ 3980 /* READDIR_R_PROTO: 3981 * This symbol encodes the prototype of readdir_r. 3982 * It is zero if d_readdir_r is undef, and one of the 3983 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_readdir_r 3984 * is defined. 3985 */ 3986 /*#define HAS_READDIR_R /**/ 3987 #define READDIR_R_PROTO 0 /**/ 3988 3989 /* HAS_SETGRENT_R: 3990 * This symbol, if defined, indicates that the setgrent_r routine 3991 * is available to setgrent re-entrantly. 3992 */ 3993 /* SETGRENT_R_PROTO: 3994 * This symbol encodes the prototype of setgrent_r. 3995 * It is zero if d_setgrent_r is undef, and one of the 3996 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_setgrent_r 3997 * is defined. 3998 */ 3999 /*#define HAS_SETGRENT_R /**/ 4000 #define SETGRENT_R_PROTO 0 /**/ 4001 4002 /* HAS_SETHOSTENT_R: 4003 * This symbol, if defined, indicates that the sethostent_r routine 4004 * is available to sethostent re-entrantly. 4005 */ 4006 /* SETHOSTENT_R_PROTO: 4007 * This symbol encodes the prototype of sethostent_r. 4008 * It is zero if d_sethostent_r is undef, and one of the 4009 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_sethostent_r 4010 * is defined. 4011 */ 4012 /*#define HAS_SETHOSTENT_R /**/ 4013 #define SETHOSTENT_R_PROTO 0 /**/ 4014 4015 /* HAS_SETLOCALE_R: 4016 * This symbol, if defined, indicates that the setlocale_r routine 4017 * is available to setlocale re-entrantly. 4018 */ 4019 /* SETLOCALE_R_PROTO: 4020 * This symbol encodes the prototype of setlocale_r. 4021 * It is zero if d_setlocale_r is undef, and one of the 4022 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_setlocale_r 4023 * is defined. 4024 */ 4025 /*#define HAS_SETLOCALE_R /**/ 4026 #define SETLOCALE_R_PROTO 0 /**/ 4027 4028 /* HAS_SETNETENT_R: 4029 * This symbol, if defined, indicates that the setnetent_r routine 4030 * is available to setnetent re-entrantly. 4031 */ 4032 /* SETNETENT_R_PROTO: 4033 * This symbol encodes the prototype of setnetent_r. 4034 * It is zero if d_setnetent_r is undef, and one of the 4035 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_setnetent_r 4036 * is defined. 4037 */ 4038 /*#define HAS_SETNETENT_R /**/ 4039 #define SETNETENT_R_PROTO 0 /**/ 4040 4041 /* HAS_SETPROTOENT_R: 4042 * This symbol, if defined, indicates that the setprotoent_r routine 4043 * is available to setprotoent re-entrantly. 4044 */ 4045 /* SETPROTOENT_R_PROTO: 4046 * This symbol encodes the prototype of setprotoent_r. 4047 * It is zero if d_setprotoent_r is undef, and one of the 4048 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_setprotoent_r 4049 * is defined. 4050 */ 4051 /*#define HAS_SETPROTOENT_R /**/ 4052 #define SETPROTOENT_R_PROTO 0 /**/ 4053 4054 /* HAS_SETPWENT_R: 4055 * This symbol, if defined, indicates that the setpwent_r routine 4056 * is available to setpwent re-entrantly. 4057 */ 4058 /* SETPWENT_R_PROTO: 4059 * This symbol encodes the prototype of setpwent_r. 4060 * It is zero if d_setpwent_r is undef, and one of the 4061 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_setpwent_r 4062 * is defined. 4063 */ 4064 /*#define HAS_SETPWENT_R /**/ 4065 #define SETPWENT_R_PROTO 0 /**/ 4066 4067 /* HAS_SETSERVENT_R: 4068 * This symbol, if defined, indicates that the setservent_r routine 4069 * is available to setservent re-entrantly. 4070 */ 4071 /* SETSERVENT_R_PROTO: 4072 * This symbol encodes the prototype of setservent_r. 4073 * It is zero if d_setservent_r is undef, and one of the 4074 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_setservent_r 4075 * is defined. 4076 */ 4077 /*#define HAS_SETSERVENT_R /**/ 4078 #define SETSERVENT_R_PROTO 0 /**/ 4079 4080 /* HAS_SRAND48_R: 4081 * This symbol, if defined, indicates that the srand48_r routine 4082 * is available to srand48 re-entrantly. 4083 */ 4084 /* SRAND48_R_PROTO: 4085 * This symbol encodes the prototype of srand48_r. 4086 * It is zero if d_srand48_r is undef, and one of the 4087 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_srand48_r 4088 * is defined. 4089 */ 4090 /*#define HAS_SRAND48_R /**/ 4091 #define SRAND48_R_PROTO 0 /**/ 4092 4093 /* HAS_SRANDOM_R: 4094 * This symbol, if defined, indicates that the srandom_r routine 4095 * is available to srandom re-entrantly. 4096 */ 4097 /* SRANDOM_R_PROTO: 4098 * This symbol encodes the prototype of srandom_r. 4099 * It is zero if d_srandom_r is undef, and one of the 4100 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_srandom_r 4101 * is defined. 4102 */ 4103 /*#define HAS_SRANDOM_R /**/ 4104 #define SRANDOM_R_PROTO 0 /**/ 4105 4106 /* HAS_STRERROR_R: 4107 * This symbol, if defined, indicates that the strerror_r routine 4108 * is available to strerror re-entrantly. 4109 */ 4110 /* STRERROR_R_PROTO: 4111 * This symbol encodes the prototype of strerror_r. 4112 * It is zero if d_strerror_r is undef, and one of the 4113 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_strerror_r 4114 * is defined. 4115 */ 4116 /*#define HAS_STRERROR_R /**/ 4117 #define STRERROR_R_PROTO 0 /**/ 4118 4119 /* HAS_TMPNAM_R: 4120 * This symbol, if defined, indicates that the tmpnam_r routine 4121 * is available to tmpnam re-entrantly. 4122 */ 4123 /* TMPNAM_R_PROTO: 4124 * This symbol encodes the prototype of tmpnam_r. 4125 * It is zero if d_tmpnam_r is undef, and one of the 4126 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_tmpnam_r 4127 * is defined. 4128 */ 4129 /*#define HAS_TMPNAM_R /**/ 4130 #define TMPNAM_R_PROTO 0 /**/ 4131 4132 /* HAS_TTYNAME_R: 4133 * This symbol, if defined, indicates that the ttyname_r routine 4134 * is available to ttyname re-entrantly. 4135 */ 4136 /* TTYNAME_R_PROTO: 4137 * This symbol encodes the prototype of ttyname_r. 4138 * It is zero if d_ttyname_r is undef, and one of the 4139 * REENTRANT_PROTO_T_ABC macros of reentr.h if d_ttyname_r 4140 * is defined. 4141 */ 4142 /*#define HAS_TTYNAME_R /**/ 4143 #define TTYNAME_R_PROTO 0 /**/ 4144 4145 /* I_MACH_CTHREADS: 4146 * This symbol, if defined, indicates to the C program that it should 4147 * include <mach/cthreads.h>. 4148 */ 4149 /*#define I_MACH_CTHREADS /**/ 4150 4151 /* I_PTHREAD: 4152 * This symbol, if defined, indicates to the C program that it should 4153 * include <pthread.h>. 4154 */ 4155 /*#define I_PTHREAD /**/ 4156 4157 /* USE_ITHREADS: 4158 * This symbol, if defined, indicates that Perl should be built to 4159 * use the interpreter-based threading implementation. 4160 */ 4161 /* USE_5005THREADS: 4162 * This symbol, if defined, indicates that Perl should be built to 4163 * use the 5.005-based threading implementation. 4164 */ 4165 /* OLD_PTHREADS_API: 4166 * This symbol, if defined, indicates that Perl should 4167 * be built to use the old draft POSIX threads API. 4168 */ 4169 /* USE_REENTRANT_API: 4170 * This symbol, if defined, indicates that Perl should 4171 * try to use the various _r versions of library functions. 4172 * This is extremely experimental. 4173 */ 4174 /*#define USE_5005THREADS /**/ 4175 /*#define USE_ITHREADS /**/ 4176 #if defined(USE_5005THREADS) && !defined(USE_ITHREADS) 4177 #define USE_THREADS /* until src is revised*/ 4178 #endif 4179 /*#define OLD_PTHREADS_API /**/ 4180 /*#define USE_REENTRANT_API /**/ 4181 4182 /* HAS_TIME: 4183 * This symbol, if defined, indicates that the time() routine exists. 4184 */ 4185 /* Time_t: 4186 * This symbol holds the type returned by time(). It can be long, 4187 * or time_t on BSD sites (in which case <sys/types.h> should be 4188 * included). 4189 */ 4190 #define HAS_TIME /**/ 4191 #define Time_t time_t /* Time type */ 4192 4193 /* HAS_TIMES: 4194 * This symbol, if defined, indicates that the times() routine exists. 4195 * Note that this became obsolete on some systems (SUNOS), which now 4196 * use getrusage(). It may be necessary to include <sys/times.h>. 4197 */ 4198 #define HAS_TIMES /**/ 4199 4200 /* Fpos_t: 4201 * This symbol holds the type used to declare file positions in libc. 4202 * It can be fpos_t, long, uint, etc... It may be necessary to include 4203 * <sys/types.h> to get any typedef'ed information. 4204 */ 4205 #define Fpos_t fpos_t /* File position type */ 4206 4207 /* Gid_t_f: 4208 * This symbol defines the format string used for printing a Gid_t. 4209 */ 4210 #define Gid_t_f "d" /**/ 4211 4212 /* Gid_t_sign: 4213 * This symbol holds the signedess of a Gid_t. 4214 * 1 for unsigned, -1 for signed. 4215 */ 4216 #define Gid_t_sign -1 /* GID sign */ 4217 4218 /* Gid_t_size: 4219 * This symbol holds the size of a Gid_t in bytes. 4220 */ 4221 #define Gid_t_size 4 /* GID size */ 4222 4223 /* Gid_t: 4224 * This symbol holds the return type of getgid() and the type of 4225 * argument to setrgid() and related functions. Typically, 4226 * it is the type of group ids in the kernel. It can be int, ushort, 4227 * gid_t, etc... It may be necessary to include <sys/types.h> to get 4228 * any typedef'ed information. 4229 */ 4230 #define Gid_t gid_t /* Type for getgid(), etc... */ 4231 4232 /* Off_t: 4233 * This symbol holds the type used to declare offsets in the kernel. 4234 * It can be int, long, off_t, etc... It may be necessary to include 4235 * <sys/types.h> to get any typedef'ed information. 4236 */ 4237 /* LSEEKSIZE: 4238 * This symbol holds the number of bytes used by the Off_t. 4239 */ 4240 /* Off_t_size: 4241 * This symbol holds the number of bytes used by the Off_t. 4242 */ 4243 #define Off_t off_t /* <offset> type */ 4244 #define LSEEKSIZE 4 /* <offset> size */ 4245 #define Off_t_size 4 /* <offset> size */ 4246 4247 /* Mode_t: 4248 * This symbol holds the type used to declare file modes 4249 * for systems calls. It is usually mode_t, but may be 4250 * int or unsigned short. It may be necessary to include <sys/types.h> 4251 * to get any typedef'ed information. 4252 */ 4253 #define Mode_t mode_t /* file mode parameter for system calls */ 4254 4255 /* Pid_t: 4256 * This symbol holds the type used to declare process ids in the kernel. 4257 * It can be int, uint, pid_t, etc... It may be necessary to include 4258 * <sys/types.h> to get any typedef'ed information. 4259 */ 4260 #define Pid_t pid_t /* PID type */ 4261 4262 /* Size_t_size: 4263 * This symbol holds the size of a Size_t in bytes. 4264 */ 4265 #define Size_t_size 4 /* */ 4266 4267 /* Size_t: 4268 * This symbol holds the type used to declare length parameters 4269 * for string functions. It is usually size_t, but may be 4270 * unsigned long, int, etc. It may be necessary to include 4271 * <sys/types.h> to get any typedef'ed information. 4272 */ 4273 #define Size_t size_t /* length paramater for string functions */ 4274 4275 /* Uid_t_f: 4276 * This symbol defines the format string used for printing a Uid_t. 4277 */ 4278 #define Uid_t_f "d" /**/ 4279 4280 /* Uid_t_sign: 4281 * This symbol holds the signedess of a Uid_t. 4282 * 1 for unsigned, -1 for signed. 4283 */ 4284 #define Uid_t_sign -1 /* UID sign */ 4285 4286 /* Uid_t_size: 4287 * This symbol holds the size of a Uid_t in bytes. 4288 */ 4289 #define Uid_t_size 4 /* UID size */ 4290 4291 /* Uid_t: 4292 * This symbol holds the type used to declare user ids in the kernel. 4293 * It can be int, ushort, uid_t, etc... It may be necessary to include 4294 * <sys/types.h> to get any typedef'ed information. 4295 */ 4296 #define Uid_t uid_t /* UID type */ 4297 4298 #endif 4299