Porting/config_H

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