util.c

   1 /*    util.c
   2  *
   3  *    Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   4  *    2000, 2001, 2002, 2003, 2004, 2005, by Larry Wall and others
   5  *
   6  *    You may distribute under the terms of either the GNU General Public
   7  *    License or the Artistic License, as specified in the README file.
   8  *
   9  */
  10
  11 /*
  12  * "Very useful, no doubt, that was to Saruman; yet it seems that he was
  13  * not content."  --Gandalf
  14  */
  15
  16 /* This file contains assorted utility routines.
  17  * Which is a polite way of saying any stuff that people couldn't think of
  18  * a better place for. Amongst other things, it includes the warning and
  19  * dieing stuff, plus wrappers for malloc code.
  20  */
  21
  22 #include "EXTERN.h"
  23 #define PERL_IN_UTIL_C
  24 #include "perl.h"
  25
  26 #ifndef PERL_MICRO
  27 #include <signal.h>
  28 #ifndef SIG_ERR
  29 # define SIG_ERR ((Sighandler_t) -1)
  30 #endif
  31 #endif
  32
  33 #ifdef I_SYS_WAIT
  34 #  include <sys/wait.h>
  35 #endif
  36
  37 #ifdef HAS_SELECT
  38 # ifdef I_SYS_SELECT
  39 #  include <sys/select.h>
  40 # endif
  41 #endif
  42
  43 #define FLUSH
  44
  45 #if defined(HAS_FCNTL) && defined(F_SETFD) && !defined(FD_CLOEXEC)
  46 #  define FD_CLOEXEC 1                  /* NeXT needs this */
  47 #endif
  48
  49 /* NOTE:  Do not call the next three routines directly.  Use the macros
  50  * in handy.h, so that we can easily redefine everything to do tracking of
  51  * allocated hunks back to the original New to track down any memory leaks.
  52  * XXX This advice seems to be widely ignored :-(   --AD  August 1996.
  53  */
  54
  55 /* paranoid version of system's malloc() */
  56
  57 Malloc_t
  58 Perl_safesysmalloc(MEM_SIZE size)
  59 {
  60     dTHX;
  61     Malloc_t ptr;
  62 #ifdef HAS_64K_LIMIT
  63         if (size > 0xffff) {
  64             PerlIO_printf(Perl_error_log,
  65                           "Allocation too large: %lx\n", size) FLUSH;
  66             my_exit(1);
  67         }
  68 #endif /* HAS_64K_LIMIT */
  69 #ifdef DEBUGGING
  70     if ((long)size < 0)
  71         Perl_croak_nocontext("panic: malloc");
  72 #endif
  73     ptr = (Malloc_t)PerlMem_malloc(size?size:1);        /* malloc(0) is NASTY on our system */
  74     PERL_ALLOC_CHECK(ptr);
  75     DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) malloc %ld bytes\n",PTR2UV(ptr),(long)PL_an++,(long)size));
  76     if (ptr != Nullch)
  77         return ptr;
  78     else if (PL_nomemok)
  79         return Nullch;
  80     else {
  81         /* Can't use PerlIO to write as it allocates memory */
  82         PerlLIO_write(PerlIO_fileno(Perl_error_log),
  83                       PL_no_mem, strlen(PL_no_mem));
  84         my_exit(1);
  85         return Nullch;
  86     }
  87     /*NOTREACHED*/
  88 }
  89
  90 /* paranoid version of system's realloc() */
  91
  92 Malloc_t
  93 Perl_safesysrealloc(Malloc_t where,MEM_SIZE size)
  94 {
  95     dTHX;
  96     Malloc_t ptr;
  97 #if !defined(STANDARD_C) && !defined(HAS_REALLOC_PROTOTYPE) && !defined(PERL_MICRO)
  98     Malloc_t PerlMem_realloc();
  99 #endif /* !defined(STANDARD_C) && !defined(HAS_REALLOC_PROTOTYPE) */
 100
 101 #ifdef HAS_64K_LIMIT
 102     if (size > 0xffff) {
 103         PerlIO_printf(Perl_error_log,
 104                       "Reallocation too large: %lx\n", size) FLUSH;
 105         my_exit(1);
 106     }
 107 #endif /* HAS_64K_LIMIT */
 108     if (!size) {
 109         safesysfree(where);
 110         return NULL;
 111     }
 112
 113     if (!where)
 114         return safesysmalloc(size);
 115 #ifdef DEBUGGING
 116     if ((long)size < 0)
 117         Perl_croak_nocontext("panic: realloc");
 118 #endif
 119     ptr = (Malloc_t)PerlMem_realloc(where,size);
 120     PERL_ALLOC_CHECK(ptr);
 121
 122     DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) rfree\n",PTR2UV(where),(long)PL_an++));
 123     DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) realloc %ld bytes\n",PTR2UV(ptr),(long)PL_an++,(long)size));
 124
 125     if (ptr != Nullch)
 126         return ptr;
 127     else if (PL_nomemok)
 128         return Nullch;
 129     else {
 130         /* Can't use PerlIO to write as it allocates memory */
 131         PerlLIO_write(PerlIO_fileno(Perl_error_log),
 132                       PL_no_mem, strlen(PL_no_mem));
 133         my_exit(1);
 134         return Nullch;
 135     }
 136     /*NOTREACHED*/
 137 }
 138
 139 /* safe version of system's free() */
 140
 141 Free_t
 142 Perl_safesysfree(Malloc_t where)
 143 {
 144 #ifdef PERL_IMPLICIT_SYS
 145     dTHX;
 146 #endif
 147     DEBUG_m( PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) free\n",PTR2UV(where),(long)PL_an++));
 148     if (where) {
 149         /*SUPPRESS 701*/
 150         PerlMem_free(where);
 151     }
 152 }
 153
 154 /* safe version of system's calloc() */
 155
 156 Malloc_t
 157 Perl_safesyscalloc(MEM_SIZE count, MEM_SIZE size)
 158 {
 159     dTHX;
 160     Malloc_t ptr;
 161
 162 #ifdef HAS_64K_LIMIT
 163     if (size * count > 0xffff) {
 164         PerlIO_printf(Perl_error_log,
 165                       "Allocation too large: %lx\n", size * count) FLUSH;
 166         my_exit(1);
 167     }
 168 #endif /* HAS_64K_LIMIT */
 169 #ifdef DEBUGGING
 170     if ((long)size < 0 || (long)count < 0)
 171         Perl_croak_nocontext("panic: calloc");
 172 #endif
 173     size *= count;
 174     ptr = (Malloc_t)PerlMem_malloc(size?size:1);        /* malloc(0) is NASTY on our system */
 175     PERL_ALLOC_CHECK(ptr);
 176     DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) calloc %ld x %ld bytes\n",PTR2UV(ptr),(long)PL_an++,(long)count,(long)size));
 177     if (ptr != Nullch) {
 178         memset((void*)ptr, 0, size);
 179         return ptr;
 180     }
 181     else if (PL_nomemok)
 182         return Nullch;
 183     else {
 184         /* Can't use PerlIO to write as it allocates memory */
 185         PerlLIO_write(PerlIO_fileno(Perl_error_log),
 186                       PL_no_mem, strlen(PL_no_mem));
 187         my_exit(1);
 188         return Nullch;
 189     }
 190     /*NOTREACHED*/
 191 }
 192
 193 /* These must be defined when not using Perl's malloc for binary
 194  * compatibility */
 195
 196 #ifndef MYMALLOC
 197
 198 Malloc_t Perl_malloc (MEM_SIZE nbytes)
 199 {
 200     dTHXs;
 201     return (Malloc_t)PerlMem_malloc(nbytes);
 202 }
 203
 204 Malloc_t Perl_calloc (MEM_SIZE elements, MEM_SIZE size)
 205 {
 206     dTHXs;
 207     return (Malloc_t)PerlMem_calloc(elements, size);
 208 }
 209
 210 Malloc_t Perl_realloc (Malloc_t where, MEM_SIZE nbytes)
 211 {
 212     dTHXs;
 213     return (Malloc_t)PerlMem_realloc(where, nbytes);
 214 }
 215
 216 Free_t   Perl_mfree (Malloc_t where)
 217 {
 218     dTHXs;
 219     PerlMem_free(where);
 220 }
 221
 222 #endif
 223
 224 /* copy a string up to some (non-backslashed) delimiter, if any */
 225
 226 char *
 227 Perl_delimcpy(pTHX_ register char *to, register char *toend, register char *from, register char *fromend, register int delim, I32 *retlen)
 228 {
 229     register I32 tolen;
 230     for (tolen = 0; from < fromend; from++, tolen++) {
 231         if (*from == '\\') {
 232             if (from[1] == delim)
 233                 from++;
 234             else {
 235                 if (to < toend)
 236                     *to++ = *from;
 237                 tolen++;
 238                 from++;
 239             }
 240         }
 241         else if (*from == delim)
 242             break;
 243         if (to < toend)
 244             *to++ = *from;
 245     }
 246     if (to < toend)
 247         *to = '\0';
 248     *retlen = tolen;
 249     return from;
 250 }
 251
 252 /* return ptr to little string in big string, NULL if not found */
 253 /* This routine was donated by Corey Satten. */
 254
 255 char *
 256 Perl_instr(pTHX_ register const char *big, register const char *little)
 257 {
 258     register const char *s, *x;
 259     register I32 first;
 260
 261     if (!little)
 262         return (char*)big;
 263     first = *little++;
 264     if (!first)
 265         return (char*)big;
 266     while (*big) {
 267         if (*big++ != first)
 268             continue;
 269         for (x=big,s=little; *s; /**/ ) {
 270             if (!*x)
 271                 return Nullch;
 272             if (*s++ != *x++) {
 273                 s--;
 274                 break;
 275             }
 276         }
 277         if (!*s)
 278             return (char*)(big-1);
 279     }
 280     return Nullch;
 281 }
 282
 283 /* same as instr but allow embedded nulls */
 284
 285 char *
 286 Perl_ninstr(pTHX_ register const char *big, register const char *bigend, const char *little, const char *lend)
 287 {
 288     register const char *s, *x;
 289     register I32 first = *little;
 290     register const char *littleend = lend;
 291
 292     if (!first && little >= littleend)
 293         return (char*)big;
 294     if (bigend - big < littleend - little)
 295         return Nullch;
 296     bigend -= littleend - little++;
 297     while (big <= bigend) {
 298         if (*big++ != first)
 299             continue;
 300         for (x=big,s=little; s < littleend; /**/ ) {
 301             if (*s++ != *x++) {
 302                 s--;
 303                 break;
 304             }
 305         }
 306         if (s >= littleend)
 307             return (char*)(big-1);
 308     }
 309     return Nullch;
 310 }
 311
 312 /* reverse of the above--find last substring */
 313
 314 char *
 315 Perl_rninstr(pTHX_ register const char *big, const char *bigend, const char *little, const char *lend)
 316 {
 317     register const char *bigbeg;
 318     register const char *s, *x;
 319     register I32 first = *little;
 320     register const char *littleend = lend;
 321
 322     if (!first && little >= littleend)
 323         return (char*)bigend;
 324     bigbeg = big;
 325     big = bigend - (littleend - little++);
 326     while (big >= bigbeg) {
 327         if (*big-- != first)
 328             continue;
 329         for (x=big+2,s=little; s < littleend; /**/ ) {
 330             if (*s++ != *x++) {
 331                 s--;
 332                 break;
 333             }
 334         }
 335         if (s >= littleend)
 336             return (char*)(big+1);
 337     }
 338     return Nullch;
 339 }
 340
 341 #define FBM_TABLE_OFFSET 2      /* Number of bytes between EOS and table*/
 342
 343 /* As a space optimization, we do not compile tables for strings of length
 344    0 and 1, and for strings of length 2 unless FBMcf_TAIL.  These are
 345    special-cased in fbm_instr().
 346
 347    If FBMcf_TAIL, the table is created as if the string has a trailing \n. */
 348
 349 /*
 350 =head1 Miscellaneous Functions
 351
 352 =for apidoc fbm_compile
 353
 354 Analyses the string in order to make fast searches on it using fbm_instr()
 355 -- the Boyer-Moore algorithm.
 356
 357 =cut
 358 */
 359
 360 void
 361 Perl_fbm_compile(pTHX_ SV *sv, U32 flags)
 362 {
 363     register U8 *s;
 364     register U8 *table;
 365     register U32 i;
 366     STRLEN len;
 367     I32 rarest = 0;
 368     U32 frequency = 256;
 369
 370     if (flags & FBMcf_TAIL) {
 371         MAGIC *mg = SvUTF8(sv) && SvMAGICAL(sv) ? mg_find(sv, PERL_MAGIC_utf8) : NULL;
 372         sv_catpvn(sv, "\n", 1);         /* Taken into account in fbm_instr() */
 373         if (mg && mg->mg_len >= 0)
 374             mg->mg_len++;
 375     }
 376     s = (U8*)SvPV_force(sv, len);
 377     (void)SvUPGRADE(sv, SVt_PVBM);
 378     if (len == 0)               /* TAIL might be on a zero-length string. */
 379         return;
 380     if (len > 2) {
 381         U8 mlen;
 382         unsigned char *sb;
 383
 384         if (len > 255)
 385             mlen = 255;
 386         else
 387             mlen = (U8)len;
 388         Sv_Grow(sv, len + 256 + FBM_TABLE_OFFSET);
 389         table = (unsigned char*)(SvPVX(sv) + len + FBM_TABLE_OFFSET);
 390         s = table - 1 - FBM_TABLE_OFFSET;       /* last char */
 391         memset((void*)table, mlen, 256);
 392         table[-1] = (U8)flags;
 393         i = 0;
 394         sb = s - mlen + 1;                      /* first char (maybe) */
 395         while (s >= sb) {
 396             if (table[*s] == mlen)
 397                 table[*s] = (U8)i;
 398             s--, i++;
 399         }
 400     }
 401     sv_magic(sv, Nullsv, PERL_MAGIC_bm, Nullch, 0);     /* deep magic */
 402     SvVALID_on(sv);
 403
 404     s = (unsigned char*)(SvPVX(sv));            /* deeper magic */
 405     for (i = 0; i < len; i++) {
 406         if (PL_freq[s[i]] < frequency) {
 407             rarest = i;
 408             frequency = PL_freq[s[i]];
 409         }
 410     }
 411     BmRARE(sv) = s[rarest];
 412     BmPREVIOUS(sv) = (U16)rarest;
 413     BmUSEFUL(sv) = 100;                 /* Initial value */
 414     if (flags & FBMcf_TAIL)
 415         SvTAIL_on(sv);
 416     DEBUG_r(PerlIO_printf(Perl_debug_log, "rarest char %c at %d\n",
 417                           BmRARE(sv),BmPREVIOUS(sv)));
 418 }
 419
 420 /* If SvTAIL(littlestr), it has a fake '\n' at end. */
 421 /* If SvTAIL is actually due to \Z or \z, this gives false positives
 422    if multiline */
 423
 424 /*
 425 =for apidoc fbm_instr
 426
 427 Returns the location of the SV in the string delimited by C<str> and
 428 C<strend>.  It returns C<Nullch> if the string can't be found.  The C<sv>
 429 does not have to be fbm_compiled, but the search will not be as fast
 430 then.
 431
 432 =cut
 433 */
 434
 435 char *
 436 Perl_fbm_instr(pTHX_ unsigned char *big, register unsigned char *bigend, SV *littlestr, U32 flags)
 437 {
 438     register unsigned char *s;
 439     STRLEN l;
 440     register unsigned char *little = (unsigned char *)SvPV(littlestr,l);
 441     register STRLEN littlelen = l;
 442     register I32 multiline = flags & FBMrf_MULTILINE;
 443
 444     if ((STRLEN)(bigend - big) < littlelen) {
 445         if ( SvTAIL(littlestr)
 446              && ((STRLEN)(bigend - big) == littlelen - 1)
 447              && (littlelen == 1
 448                  || (*big == *little &&
 449                      memEQ((char *)big, (char *)little, littlelen - 1))))
 450             return (char*)big;
 451         return Nullch;
 452     }
 453
 454     if (littlelen <= 2) {               /* Special-cased */
 455
 456         if (littlelen == 1) {
 457             if (SvTAIL(littlestr) && !multiline) { /* Anchor only! */
 458                 /* Know that bigend != big.  */
 459                 if (bigend[-1] == '\n')
 460                     return (char *)(bigend - 1);
 461                 return (char *) bigend;
 462             }
 463             s = big;
 464             while (s < bigend) {
 465                 if (*s == *little)
 466                     return (char *)s;
 467                 s++;
 468             }
 469             if (SvTAIL(littlestr))
 470                 return (char *) bigend;
 471             return Nullch;
 472         }
 473         if (!littlelen)
 474             return (char*)big;          /* Cannot be SvTAIL! */
 475
 476         /* littlelen is 2 */
 477         if (SvTAIL(littlestr) && !multiline) {
 478             if (bigend[-1] == '\n' && bigend[-2] == *little)
 479                 return (char*)bigend - 2;
 480             if (bigend[-1] == *little)
 481                 return (char*)bigend - 1;
 482             return Nullch;
 483         }
 484         {
 485             /* This should be better than FBM if c1 == c2, and almost
 486                as good otherwise: maybe better since we do less indirection.
 487                And we save a lot of memory by caching no table. */
 488             register unsigned char c1 = little[0];
 489             register unsigned char c2 = little[1];
 490
 491             s = big + 1;
 492             bigend--;
 493             if (c1 != c2) {
 494                 while (s <= bigend) {
 495                     if (s[0] == c2) {
 496                         if (s[-1] == c1)
 497                             return (char*)s - 1;
 498                         s += 2;
 499                         continue;
 500                     }
 501                   next_chars:
 502                     if (s[0] == c1) {
 503                         if (s == bigend)
 504                             goto check_1char_anchor;
 505                         if (s[1] == c2)
 506                             return (char*)s;
 507                         else {
 508                             s++;
 509                             goto next_chars;
 510                         }
 511                     }
 512                     else
 513                         s += 2;
 514                 }
 515                 goto check_1char_anchor;
 516             }
 517             /* Now c1 == c2 */
 518             while (s <= bigend) {
 519                 if (s[0] == c1) {
 520                     if (s[-1] == c1)
 521                         return (char*)s - 1;
 522                     if (s == bigend)
 523                         goto check_1char_anchor;
 524                     if (s[1] == c1)
 525                         return (char*)s;
 526                     s += 3;
 527                 }
 528                 else
 529                     s += 2;
 530             }
 531         }
 532       check_1char_anchor:               /* One char and anchor! */
 533         if (SvTAIL(littlestr) && (*bigend == *little))
 534             return (char *)bigend;      /* bigend is already decremented. */
 535         return Nullch;
 536     }
 537     if (SvTAIL(littlestr) && !multiline) {      /* tail anchored? */
 538         s = bigend - littlelen;
 539         if (s >= big && bigend[-1] == '\n' && *s == *little
 540             /* Automatically of length > 2 */
 541             && memEQ((char*)s + 1, (char*)little + 1, littlelen - 2))
 542         {
 543             return (char*)s;            /* how sweet it is */
 544         }
 545         if (s[1] == *little
 546             && memEQ((char*)s + 2, (char*)little + 1, littlelen - 2))
 547         {
 548             return (char*)s + 1;        /* how sweet it is */
 549         }
 550         return Nullch;
 551     }
 552     if (SvTYPE(littlestr) != SVt_PVBM || !SvVALID(littlestr)) {
 553         char *b = ninstr((char*)big,(char*)bigend,
 554                          (char*)little, (char*)little + littlelen);
 555
 556         if (!b && SvTAIL(littlestr)) {  /* Automatically multiline!  */
 557             /* Chop \n from littlestr: */
 558             s = bigend - littlelen + 1;
 559             if (*s == *little
 560                 && memEQ((char*)s + 1, (char*)little + 1, littlelen - 2))
 561             {
 562                 return (char*)s;
 563             }
 564             return Nullch;
 565         }
 566         return b;
 567     }
 568
 569     {   /* Do actual FBM.  */
 570         register unsigned char *table = little + littlelen + FBM_TABLE_OFFSET;
 571         register unsigned char *oldlittle;
 572
 573         if (littlelen > (STRLEN)(bigend - big))
 574             return Nullch;
 575         --littlelen;                    /* Last char found by table lookup */
 576
 577         s = big + littlelen;
 578         little += littlelen;            /* last char */
 579         oldlittle = little;
 580         if (s < bigend) {
 581             register I32 tmp;
 582
 583           top2:
 584             /*SUPPRESS 560*/
 585             if ((tmp = table[*s])) {
 586                 if ((s += tmp) < bigend)
 587                     goto top2;
 588                 goto check_end;
 589             }
 590             else {              /* less expensive than calling strncmp() */
 591                 register unsigned char *olds = s;
 592
 593                 tmp = littlelen;
 594
 595                 while (tmp--) {
 596                     if (*--s == *--little)
 597                         continue;
 598                     s = olds + 1;       /* here we pay the price for failure */
 599                     little = oldlittle;
 600                     if (s < bigend)     /* fake up continue to outer loop */
 601                         goto top2;
 602                     goto check_end;
 603                 }
 604                 return (char *)s;
 605             }
 606         }
 607       check_end:
 608         if ( s == bigend && (table[-1] & FBMcf_TAIL)
 609              && memEQ((char *)(bigend - littlelen),
 610                       (char *)(oldlittle - littlelen), littlelen) )
 611             return (char*)bigend - littlelen;
 612         return Nullch;
 613     }
 614 }
 615
 616 /* start_shift, end_shift are positive quantities which give offsets
 617    of ends of some substring of bigstr.
 618    If `last' we want the last occurrence.
 619    old_posp is the way of communication between consequent calls if
 620    the next call needs to find the .
 621    The initial *old_posp should be -1.
 622
 623    Note that we take into account SvTAIL, so one can get extra
 624    optimizations if _ALL flag is set.
 625  */
 626
 627 /* If SvTAIL is actually due to \Z or \z, this gives false positives
 628    if PL_multiline.  In fact if !PL_multiline the authoritative answer
 629    is not supported yet. */
 630
 631 char *
 632 Perl_screaminstr(pTHX_ SV *bigstr, SV *littlestr, I32 start_shift, I32 end_shift, I32 *old_posp, I32 last)
 633 {
 634     register unsigned char *s, *x;
 635     register unsigned char *big;
 636     register I32 pos;
 637     register I32 previous;
 638     register I32 first;
 639     register unsigned char *little;
 640     register I32 stop_pos;
 641     register unsigned char *littleend;
 642     I32 found = 0;
 643
 644     if (*old_posp == -1
 645         ? (pos = PL_screamfirst[BmRARE(littlestr)]) < 0
 646         : (((pos = *old_posp), pos += PL_screamnext[pos]) == 0)) {
 647       cant_find:
 648         if ( BmRARE(littlestr) == '\n'
 649              && BmPREVIOUS(littlestr) == SvCUR(littlestr) - 1) {
 650             little = (unsigned char *)(SvPVX(littlestr));
 651             littleend = little + SvCUR(littlestr);
 652             first = *little++;
 653             goto check_tail;
 654         }
 655         return Nullch;
 656     }
 657
 658     little = (unsigned char *)(SvPVX(littlestr));
 659     littleend = little + SvCUR(littlestr);
 660     first = *little++;
 661     /* The value of pos we can start at: */
 662     previous = BmPREVIOUS(littlestr);
 663     big = (unsigned char *)(SvPVX(bigstr));
 664     /* The value of pos we can stop at: */
 665     stop_pos = SvCUR(bigstr) - end_shift - (SvCUR(littlestr) - 1 - previous);
 666     if (previous + start_shift > stop_pos) {
 667 /*
 668   stop_pos does not include SvTAIL in the count, so this check is incorrect
 669   (I think) - see [ID 20010618.006] and t/op/study.t. HVDS 2001/06/19
 670 */
 671 #if 0
 672         if (previous + start_shift == stop_pos + 1) /* A fake '\n'? */
 673             goto check_tail;
 674 #endif
 675         return Nullch;
 676     }
 677     while (pos < previous + start_shift) {
 678         if (!(pos += PL_screamnext[pos]))
 679             goto cant_find;
 680     }
 681     big -= previous;
 682     do {
 683         if (pos >= stop_pos) break;
 684         if (big[pos] != first)
 685             continue;
 686         for (x=big+pos+1,s=little; s < littleend; /**/ ) {
 687             if (*s++ != *x++) {
 688                 s--;
 689                 break;
 690             }
 691         }
 692         if (s == littleend) {
 693             *old_posp = pos;
 694             if (!last) return (char *)(big+pos);
 695             found = 1;
 696         }
 697     } while ( pos += PL_screamnext[pos] );
 698     if (last && found)
 699         return (char *)(big+(*old_posp));
 700   check_tail:
 701     if (!SvTAIL(littlestr) || (end_shift > 0))
 702         return Nullch;
 703     /* Ignore the trailing "\n".  This code is not microoptimized */
 704     big = (unsigned char *)(SvPVX(bigstr) + SvCUR(bigstr));
 705     stop_pos = littleend - little;      /* Actual littlestr len */
 706     if (stop_pos == 0)
 707         return (char*)big;
 708     big -= stop_pos;
 709     if (*big == first
 710         && ((stop_pos == 1) ||
 711             memEQ((char *)(big + 1), (char *)little, stop_pos - 1)))
 712         return (char*)big;
 713     return Nullch;
 714 }
 715
 716 I32
 717 Perl_ibcmp(pTHX_ const char *s1, const char *s2, register I32 len)
 718 {
 719     register U8 *a = (U8 *)s1;
 720     register U8 *b = (U8 *)s2;
 721     while (len--) {
 722         if (*a != *b && *a != PL_fold[*b])
 723             return 1;
 724         a++,b++;
 725     }
 726     return 0;
 727 }
 728
 729 I32
 730 Perl_ibcmp_locale(pTHX_ const char *s1, const char *s2, register I32 len)
 731 {
 732     register U8 *a = (U8 *)s1;
 733     register U8 *b = (U8 *)s2;
 734     while (len--) {
 735         if (*a != *b && *a != PL_fold_locale[*b])
 736             return 1;
 737         a++,b++;
 738     }
 739     return 0;
 740 }
 741
 742 /* copy a string to a safe spot */
 743
 744 /*
 745 =head1 Memory Management
 746
 747 =for apidoc savepv
 748
 749 Perl's version of C<strdup()>. Returns a pointer to a newly allocated
 750 string which is a duplicate of C<pv>. The size of the string is
 751 determined by C<strlen()>. The memory allocated for the new string can
 752 be freed with the C<Safefree()> function.
 753
 754 =cut
 755 */
 756
 757 char *
 758 Perl_savepv(pTHX_ const char *pv)
 759 {
 760     register char *newaddr;
 761     if (!pv)
 762         return Nullch;
 763
 764     New(902,newaddr,strlen(pv)+1,char);
 765     return strcpy(newaddr,pv);
 766 }
 767
 768 /* same thing but with a known length */
 769
 770 /*
 771 =for apidoc savepvn
 772
 773 Perl's version of what C<strndup()> would be if it existed. Returns a
 774 pointer to a newly allocated string which is a duplicate of the first
 775 C<len> bytes from C<pv>. The memory allocated for the new string can be
 776 freed with the C<Safefree()> function.
 777
 778 =cut
 779 */
 780
 781 char *
 782 Perl_savepvn(pTHX_ const char *pv, register I32 len)
 783 {
 784     register char *newaddr;
 785
 786     New(903,newaddr,len+1,char);
 787     /* Give a meaning to NULL pointer mainly for the use in sv_magic() */
 788     if (pv) {
 789         /* might not be null terminated */
 790         newaddr[len] = '\0';
 791         return CopyD(pv,newaddr,len,char);
 792     }
 793     else {
 794         return ZeroD(newaddr,len+1,char);
 795     }
 796 }
 797
 798 /*
 799 =for apidoc savesharedpv
 800
 801 A version of C<savepv()> which allocates the duplicate string in memory
 802 which is shared between threads.
 803
 804 =cut
 805 */
 806 char *
 807 Perl_savesharedpv(pTHX_ const char *pv)
 808 {
 809     register char *newaddr;
 810     if (!pv)
 811         return Nullch;
 812
 813     newaddr = (char*)PerlMemShared_malloc(strlen(pv)+1);
 814     if (!newaddr) {
 815         PerlLIO_write(PerlIO_fileno(Perl_error_log),
 816                       PL_no_mem, strlen(PL_no_mem));
 817         my_exit(1);
 818     }
 819     return strcpy(newaddr,pv);
 820 }
 821
 822 /*
 823 =for apidoc savesvpv
 824
 825 A version of C<savepv()>/C<savepvn()> which gets the string to duplicate from
 826 the passed in SV using C<SvPV()>
 827
 828 =cut
 829 */
 830
 831 char *
 832 Perl_savesvpv(pTHX_ SV *sv)
 833 {
 834     STRLEN len;
 835     const char *pv = SvPV(sv, len);
 836     register char *newaddr;
 837
 838     ++len;
 839     New(903,newaddr,len,char);
 840     return CopyD(pv,newaddr,len,char);
 841 }
 842
 843
 844 /* the SV for Perl_form() and mess() is not kept in an arena */
 845
 846 STATIC SV *
 847 S_mess_alloc(pTHX)
 848 {
 849     SV *sv;
 850     XPVMG *any;
 851
 852     if (!PL_dirty)
 853         return sv_2mortal(newSVpvn("",0));
 854
 855     if (PL_mess_sv)
 856         return PL_mess_sv;
 857
 858     /* Create as PVMG now, to avoid any upgrading later */
 859     New(905, sv, 1, SV);
 860     Newz(905, any, 1, XPVMG);
 861     SvFLAGS(sv) = SVt_PVMG;
 862     SvANY(sv) = (void*)any;
 863     SvREFCNT(sv) = 1 << 30; /* practically infinite */
 864     PL_mess_sv = sv;
 865     return sv;
 866 }
 867
 868 #if defined(PERL_IMPLICIT_CONTEXT)
 869 char *
 870 Perl_form_nocontext(const char* pat, ...)
 871 {
 872     dTHX;
 873     char *retval;
 874     va_list args;
 875     va_start(args, pat);
 876     retval = vform(pat, &args);
 877     va_end(args);
 878     return retval;
 879 }
 880 #endif /* PERL_IMPLICIT_CONTEXT */
 881
 882 /*
 883 =head1 Miscellaneous Functions
 884 =for apidoc form
 885
 886 Takes a sprintf-style format pattern and conventional
 887 (non-SV) arguments and returns the formatted string.
 888
 889     (char *) Perl_form(pTHX_ const char* pat, ...)
 890
 891 can be used any place a string (char *) is required:
 892
 893     char * s = Perl_form("%d.%d",major,minor);
 894
 895 Uses a single private buffer so if you want to format several strings you
 896 must explicitly copy the earlier strings away (and free the copies when you
 897 are done).
 898
 899 =cut
 900 */
 901
 902 char *
 903 Perl_form(pTHX_ const char* pat, ...)
 904 {
 905     char *retval;
 906     va_list args;
 907     va_start(args, pat);
 908     retval = vform(pat, &args);
 909     va_end(args);
 910     return retval;
 911 }
 912
 913 char *
 914 Perl_vform(pTHX_ const char *pat, va_list *args)
 915 {
 916     SV *sv = mess_alloc();
 917     sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));
 918     return SvPVX(sv);
 919 }
 920
 921 #if defined(PERL_IMPLICIT_CONTEXT)
 922 SV *
 923 Perl_mess_nocontext(const char *pat, ...)
 924 {
 925     dTHX;
 926     SV *retval;
 927     va_list args;
 928     va_start(args, pat);
 929     retval = vmess(pat, &args);
 930     va_end(args);
 931     return retval;
 932 }
 933 #endif /* PERL_IMPLICIT_CONTEXT */
 934
 935 SV *
 936 Perl_mess(pTHX_ const char *pat, ...)
 937 {
 938     SV *retval;
 939     va_list args;
 940     va_start(args, pat);
 941     retval = vmess(pat, &args);
 942     va_end(args);
 943     return retval;
 944 }
 945
 946 STATIC COP*
 947 S_closest_cop(pTHX_ COP *cop, OP *o)
 948 {
 949     /* Look for PL_op starting from o.  cop is the last COP we've seen. */
 950
 951     if (!o || o == PL_op) return cop;
 952
 953     if (o->op_flags & OPf_KIDS) {
 954         OP *kid;
 955         for (kid = cUNOPo->op_first; kid; kid = kid->op_sibling)
 956         {
 957             COP *new_cop;
 958
 959             /* If the OP_NEXTSTATE has been optimised away we can still use it
 960              * the get the file and line number. */
 961
 962             if (kid->op_type == OP_NULL && kid->op_targ == OP_NEXTSTATE)
 963                 cop = (COP *)kid;
 964
 965             /* Keep searching, and return when we've found something. */
 966
 967             new_cop = closest_cop(cop, kid);
 968             if (new_cop) return new_cop;
 969         }
 970     }
 971
 972     /* Nothing found. */
 973
 974     return 0;
 975 }
 976
 977 SV *
 978 Perl_vmess(pTHX_ const char *pat, va_list *args)
 979 {
 980     SV *sv = mess_alloc();
 981     static char dgd[] = " during global destruction.\n";
 982     COP *cop;
 983
 984     sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));
 985     if (!SvCUR(sv) || *(SvEND(sv) - 1) != '\n') {
 986
 987         /*
 988          * Try and find the file and line for PL_op.  This will usually be
 989          * PL_curcop, but it might be a cop that has been optimised away.  We
 990          * can try to find such a cop by searching through the optree starting
 991          * from the sibling of PL_curcop.
 992          */
 993
 994         cop = closest_cop(PL_curcop, PL_curcop->op_sibling);
 995         if (!cop) cop = PL_curcop;
 996
 997         if (CopLINE(cop))
 998             Perl_sv_catpvf(aTHX_ sv, " at %s line %"IVdf,
 999             OutCopFILE(cop), (IV)CopLINE(cop));
1000         if (GvIO(PL_last_in_gv) && IoLINES(GvIOp(PL_last_in_gv))) {
1001             bool line_mode = (RsSIMPLE(PL_rs) &&
1002                               SvCUR(PL_rs) == 1 && *SvPVX(PL_rs) == '\n');
1003             Perl_sv_catpvf(aTHX_ sv, ", <%s> %s %"IVdf,
1004                            PL_last_in_gv == PL_argvgv ?
1005                            "" : GvNAME(PL_last_in_gv),
1006                            line_mode ? "line" : "chunk",
1007                            (IV)IoLINES(GvIOp(PL_last_in_gv)));
1008         }
1009         sv_catpv(sv, PL_dirty ? dgd : ".\n");
1010     }
1011     return sv;
1012 }
1013
1014 void
1015 Perl_write_to_stderr(pTHX_ const char* message, int msglen)
1016 {
1017     IO *io;
1018     MAGIC *mg;
1019
1020     if (PL_stderrgv && SvREFCNT(PL_stderrgv)
1021         && (io = GvIO(PL_stderrgv))
1022         && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar)))
1023     {
1024         dSP;
1025         ENTER;
1026         SAVETMPS;
1027
1028         save_re_context();
1029         SAVESPTR(PL_stderrgv);
1030         PL_stderrgv = Nullgv;
1031
1032         PUSHSTACKi(PERLSI_MAGIC);
1033
1034         PUSHMARK(SP);
1035         EXTEND(SP,2);
1036         PUSHs(SvTIED_obj((SV*)io, mg));
1037         PUSHs(sv_2mortal(newSVpvn(message, msglen)));
1038         PUTBACK;
1039         call_method("PRINT", G_SCALAR);
1040
1041         POPSTACK;
1042         FREETMPS;
1043         LEAVE;
1044     }
1045     else {
1046 #ifdef USE_SFIO
1047         /* SFIO can really mess with your errno */
1048         int e = errno;
1049 #endif
1050         PerlIO *serr = Perl_error_log;
1051
1052         PERL_WRITE_MSG_TO_CONSOLE(serr, message, msglen);
1053         (void)PerlIO_flush(serr);
1054 #ifdef USE_SFIO
1055         errno = e;
1056 #endif
1057     }
1058 }
1059
1060 /* Common code used by vcroak, vdie and vwarner  */
1061
1062 void S_vdie_common(pTHX_ const char *message, STRLEN msglen, I32 utf8);
1063
1064 char *
1065 S_vdie_croak_common(pTHX_ const char* pat, va_list* args, STRLEN* msglen,
1066                     I32* utf8)
1067 {
1068     char *message;
1069
1070     if (pat) {
1071         SV *msv = vmess(pat, args);
1072         if (PL_errors && SvCUR(PL_errors)) {
1073             sv_catsv(PL_errors, msv);
1074             message = SvPV(PL_errors, *msglen);
1075             SvCUR_set(PL_errors, 0);
1076         }
1077         else
1078             message = SvPV(msv,*msglen);
1079         *utf8 = SvUTF8(msv);
1080     }
1081     else {
1082         message = Nullch;
1083     }
1084
1085     DEBUG_S(PerlIO_printf(Perl_debug_log,
1086                           "%p: die/croak: message = %s\ndiehook = %p\n",
1087                           thr, message, PL_diehook));
1088     if (PL_diehook) {
1089         S_vdie_common(aTHX_ message, *msglen, *utf8);
1090     }
1091     return message;
1092 }
1093
1094 void
1095 S_vdie_common(pTHX_ const char *message, STRLEN msglen, I32 utf8)
1096 {
1097     HV *stash;
1098     GV *gv;
1099     CV *cv;
1100     /* sv_2cv might call Perl_croak() */
1101     SV *olddiehook = PL_diehook;
1102
1103     assert(PL_diehook);
1104     ENTER;
1105     SAVESPTR(PL_diehook);
1106     PL_diehook = Nullsv;
1107     cv = sv_2cv(olddiehook, &stash, &gv, 0);
1108     LEAVE;
1109     if (cv && !CvDEPTH(cv) && (CvROOT(cv) || CvXSUB(cv))) {
1110         dSP;
1111         SV *msg;
1112
1113         ENTER;
1114         save_re_context();
1115         if (message) {
1116             msg = newSVpvn(message, msglen);
1117             SvFLAGS(msg) |= utf8;
1118             SvREADONLY_on(msg);
1119             SAVEFREESV(msg);
1120         }
1121         else {
1122             msg = ERRSV;
1123         }
1124
1125         PUSHSTACKi(PERLSI_DIEHOOK);
1126         PUSHMARK(SP);
1127         XPUSHs(msg);
1128         PUTBACK;
1129         call_sv((SV*)cv, G_DISCARD);
1130         POPSTACK;
1131         LEAVE;
1132     }
1133 }
1134
1135 OP *
1136 Perl_vdie(pTHX_ const char* pat, va_list *args)
1137 {
1138     char *message;
1139     int was_in_eval = PL_in_eval;
1140     STRLEN msglen;
1141     I32 utf8 = 0;
1142
1143     DEBUG_S(PerlIO_printf(Perl_debug_log,
1144                           "%p: die: curstack = %p, mainstack = %p\n",
1145                           thr, PL_curstack, PL_mainstack));
1146
1147     message = S_vdie_croak_common(aTHX_ pat, args, &msglen, &utf8);
1148
1149     PL_restartop = die_where(message, msglen);
1150     SvFLAGS(ERRSV) |= utf8;
1151     DEBUG_S(PerlIO_printf(Perl_debug_log,
1152           "%p: die: restartop = %p, was_in_eval = %d, top_env = %p\n",
1153           thr, PL_restartop, was_in_eval, PL_top_env));
1154     if ((!PL_restartop && was_in_eval) || PL_top_env->je_prev)
1155         JMPENV_JUMP(3);
1156     return PL_restartop;
1157 }
1158
1159 #if defined(PERL_IMPLICIT_CONTEXT)
1160 OP *
1161 Perl_die_nocontext(const char* pat, ...)
1162 {
1163     dTHX;
1164     OP *o;
1165     va_list args;
1166     va_start(args, pat);
1167     o = vdie(pat, &args);
1168     va_end(args);
1169     return o;
1170 }
1171 #endif /* PERL_IMPLICIT_CONTEXT */
1172
1173 OP *
1174 Perl_die(pTHX_ const char* pat, ...)
1175 {
1176     OP *o;
1177     va_list args;
1178     va_start(args, pat);
1179     o = vdie(pat, &args);
1180     va_end(args);
1181     return o;
1182 }
1183
1184 void
1185 Perl_vcroak(pTHX_ const char* pat, va_list *args)
1186 {
1187     char *message;
1188     STRLEN msglen;
1189     I32 utf8 = 0;
1190
1191     message = S_vdie_croak_common(aTHX_ pat, args, &msglen, &utf8);
1192
1193     if (PL_in_eval) {
1194         PL_restartop = die_where(message, msglen);
1195         SvFLAGS(ERRSV) |= utf8;
1196         JMPENV_JUMP(3);
1197     }
1198     else if (!message)
1199         message = SvPVx(ERRSV, msglen);
1200
1201     write_to_stderr(message, msglen);
1202     my_failure_exit();
1203 }
1204
1205 #if defined(PERL_IMPLICIT_CONTEXT)
1206 void
1207 Perl_croak_nocontext(const char *pat, ...)
1208 {
1209     dTHX;
1210     va_list args;
1211     va_start(args, pat);
1212     vcroak(pat, &args);
1213     /* NOTREACHED */
1214     va_end(args);
1215 }
1216 #endif /* PERL_IMPLICIT_CONTEXT */
1217
1218 /*
1219 =head1 Warning and Dieing
1220
1221 =for apidoc croak
1222
1223 This is the XSUB-writer's interface to Perl's C<die> function.
1224 Normally call this function the same way you call the C C<printf>
1225 function.  Calling C<croak> returns control directly to Perl,
1226 sidestepping the normal C order of execution. See C<warn>.
1227
1228 If you want to throw an exception object, assign the object to
1229 C<$@> and then pass C<Nullch> to croak():
1230
1231    errsv = get_sv("@", TRUE);
1232    sv_setsv(errsv, exception_object);
1233    croak(Nullch);
1234
1235 =cut
1236 */
1237
1238 void
1239 Perl_croak(pTHX_ const char *pat, ...)
1240 {
1241     va_list args;
1242     va_start(args, pat);
1243     vcroak(pat, &args);
1244     /* NOTREACHED */
1245     va_end(args);
1246 }
1247
1248 void
1249 Perl_vwarn(pTHX_ const char* pat, va_list *args)
1250 {
1251     char *message;
1252     HV *stash;
1253     GV *gv;
1254     CV *cv;
1255     SV *msv;
1256     STRLEN msglen;
1257     I32 utf8 = 0;
1258
1259     msv = vmess(pat, args);
1260     utf8 = SvUTF8(msv);
1261     message = SvPV(msv, msglen);
1262
1263     if (PL_warnhook) {
1264         /* sv_2cv might call Perl_warn() */
1265         SV *oldwarnhook = PL_warnhook;
1266         ENTER;
1267         SAVESPTR(PL_warnhook);
1268         PL_warnhook = Nullsv;
1269         cv = sv_2cv(oldwarnhook, &stash, &gv, 0);
1270         LEAVE;
1271         if (cv && !CvDEPTH(cv) && (CvROOT(cv) || CvXSUB(cv))) {
1272             dSP;
1273             SV *msg;
1274
1275             ENTER;
1276             save_re_context();
1277             msg = newSVpvn(message, msglen);
1278             SvFLAGS(msg) |= utf8;
1279             SvREADONLY_on(msg);
1280             SAVEFREESV(msg);
1281
1282             PUSHSTACKi(PERLSI_WARNHOOK);
1283             PUSHMARK(SP);
1284             XPUSHs(msg);
1285             PUTBACK;
1286             call_sv((SV*)cv, G_DISCARD);
1287             POPSTACK;
1288             LEAVE;
1289             return;
1290         }
1291     }
1292
1293     write_to_stderr(message, msglen);
1294 }
1295
1296 #if defined(PERL_IMPLICIT_CONTEXT)
1297 void
1298 Perl_warn_nocontext(const char *pat, ...)
1299 {
1300     dTHX;
1301     va_list args;
1302     va_start(args, pat);
1303     vwarn(pat, &args);
1304     va_end(args);
1305 }
1306 #endif /* PERL_IMPLICIT_CONTEXT */
1307
1308 /*
1309 =for apidoc warn
1310
1311 This is the XSUB-writer's interface to Perl's C<warn> function.  Call this
1312 function the same way you call the C C<printf> function.  See C<croak>.
1313
1314 =cut
1315 */
1316
1317 void
1318 Perl_warn(pTHX_ const char *pat, ...)
1319 {
1320     va_list args;
1321     va_start(args, pat);
1322     vwarn(pat, &args);
1323     va_end(args);
1324 }
1325
1326 #if defined(PERL_IMPLICIT_CONTEXT)
1327 void
1328 Perl_warner_nocontext(U32 err, const char *pat, ...)
1329 {
1330     dTHX;
1331     va_list args;
1332     va_start(args, pat);
1333     vwarner(err, pat, &args);
1334     va_end(args);
1335 }
1336 #endif /* PERL_IMPLICIT_CONTEXT */
1337
1338 void
1339 Perl_warner(pTHX_ U32  err, const char* pat,...)
1340 {
1341     va_list args;
1342     va_start(args, pat);
1343     vwarner(err, pat, &args);
1344     va_end(args);
1345 }
1346
1347 void
1348 Perl_vwarner(pTHX_ U32  err, const char* pat, va_list* args)
1349 {
1350     if (ckDEAD(err)) {
1351         SV *msv = vmess(pat, args);
1352         STRLEN msglen;
1353         char *message = SvPV(msv, msglen);
1354         I32 utf8 = SvUTF8(msv);
1355
1356         if (PL_diehook) {
1357             assert(message);
1358             S_vdie_common(aTHX_ message, msglen, utf8);
1359         }
1360         if (PL_in_eval) {
1361             PL_restartop = die_where(message, msglen);
1362             SvFLAGS(ERRSV) |= utf8;
1363             JMPENV_JUMP(3);
1364         }
1365         write_to_stderr(message, msglen);
1366         my_failure_exit();
1367     }
1368     else {
1369         Perl_vwarn(aTHX_ pat, args);
1370     }
1371 }
1372
1373 /* since we've already done strlen() for both nam and val
1374  * we can use that info to make things faster than
1375  * sprintf(s, "%s=%s", nam, val)
1376  */
1377 #define my_setenv_format(s, nam, nlen, val, vlen) \
1378    Copy(nam, s, nlen, char); \
1379    *(s+nlen) = '='; \
1380    Copy(val, s+(nlen+1), vlen, char); \
1381    *(s+(nlen+1+vlen)) = '\0'
1382
1383 #ifdef USE_ENVIRON_ARRAY
1384        /* VMS' my_setenv() is in vms.c */
1385 #if !defined(WIN32) && !defined(NETWARE)
1386 void
1387 Perl_my_setenv(pTHX_ char *nam, char *val)
1388 {
1389 #ifdef USE_ITHREADS
1390   /* only parent thread can modify process environment */
1391   if (PL_curinterp == aTHX)
1392 #endif
1393   {
1394 #ifndef PERL_USE_SAFE_PUTENV
1395     if (!PL_use_safe_putenv) {
1396     /* most putenv()s leak, so we manipulate environ directly */
1397     register I32 i=setenv_getix(nam);           /* where does it go? */
1398     int nlen, vlen;
1399
1400     if (environ == PL_origenviron) {    /* need we copy environment? */
1401         I32 j;
1402         I32 max;
1403         char **tmpenv;
1404
1405         /*SUPPRESS 530*/
1406         for (max = i; environ[max]; max++) ;
1407         tmpenv = (char**)safesysmalloc((max+2) * sizeof(char*));
1408         for (j=0; j<max; j++) {         /* copy environment */
1409             int len = strlen(environ[j]);
1410             tmpenv[j] = (char*)safesysmalloc((len+1)*sizeof(char));
1411             Copy(environ[j], tmpenv[j], len+1, char);
1412         }
1413         tmpenv[max] = Nullch;
1414         environ = tmpenv;               /* tell exec where it is now */
1415     }
1416     if (!val) {
1417         safesysfree(environ[i]);
1418         while (environ[i]) {
1419             environ[i] = environ[i+1];
1420             i++;
1421         }
1422         return;
1423     }
1424     if (!environ[i]) {                  /* does not exist yet */
1425         environ = (char**)safesysrealloc(environ, (i+2) * sizeof(char*));
1426         environ[i+1] = Nullch;  /* make sure it's null terminated */
1427     }
1428     else
1429         safesysfree(environ[i]);
1430     nlen = strlen(nam);
1431     vlen = strlen(val);
1432
1433     environ[i] = (char*)safesysmalloc((nlen+vlen+2) * sizeof(char));
1434     /* all that work just for this */
1435     my_setenv_format(environ[i], nam, nlen, val, vlen);
1436     } else {
1437 # endif
1438 #   if defined(__CYGWIN__) || defined( EPOC)
1439     setenv(nam, val, 1);
1440 #   else
1441     char *new_env;
1442     int nlen = strlen(nam), vlen;
1443     if (!val) {
1444         val = "";
1445     }
1446     vlen = strlen(val);
1447     new_env = (char*)safesysmalloc((nlen + vlen + 2) * sizeof(char));
1448     /* all that work just for this */
1449     my_setenv_format(new_env, nam, nlen, val, vlen);
1450     (void)putenv(new_env);
1451 #   endif /* __CYGWIN__ */
1452 #ifndef PERL_USE_SAFE_PUTENV
1453     }
1454 #endif
1455   }
1456 }
1457
1458 #else /* WIN32 || NETWARE */
1459
1460 void
1461 Perl_my_setenv(pTHX_ char *nam,char *val)
1462 {
1463     register char *envstr;
1464     int nlen = strlen(nam), vlen;
1465
1466     if (!val) {
1467         val = "";
1468     }
1469     vlen = strlen(val);
1470     New(904, envstr, nlen+vlen+2, char);
1471     my_setenv_format(envstr, nam, nlen, val, vlen);
1472     (void)PerlEnv_putenv(envstr);
1473     Safefree(envstr);
1474 }
1475
1476 #endif /* WIN32 || NETWARE */
1477
1478 #ifndef PERL_MICRO
1479 I32
1480 Perl_setenv_getix(pTHX_ char *nam)
1481 {
1482     register I32 i, len = strlen(nam);
1483
1484     for (i = 0; environ[i]; i++) {
1485         if (
1486 #ifdef WIN32
1487             strnicmp(environ[i],nam,len) == 0
1488 #else
1489             strnEQ(environ[i],nam,len)
1490 #endif
1491             && environ[i][len] == '=')
1492             break;                      /* strnEQ must come first to avoid */
1493     }                                   /* potential SEGV's */
1494     return i;
1495 }
1496 #endif /* !PERL_MICRO */
1497
1498 #endif /* !VMS && !EPOC*/
1499
1500 #ifdef UNLINK_ALL_VERSIONS
1501 I32
1502 Perl_unlnk(pTHX_ char *f)       /* unlink all versions of a file */
1503 {
1504     I32 i;
1505
1506     for (i = 0; PerlLIO_unlink(f) >= 0; i++) ;
1507     return i ? 0 : -1;
1508 }
1509 #endif
1510
1511 /* this is a drop-in replacement for bcopy() */
1512 #if (!defined(HAS_MEMCPY) && !defined(HAS_BCOPY)) || (!defined(HAS_MEMMOVE) && !defined(HAS_SAFE_MEMCPY) && !defined(HAS_SAFE_BCOPY))
1513 char *
1514 Perl_my_bcopy(register const char *from,register char *to,register I32 len)
1515 {
1516     char *retval = to;
1517
1518     if (from - to >= 0) {
1519         while (len--)
1520             *to++ = *from++;
1521     }
1522     else {
1523         to += len;
1524         from += len;
1525         while (len--)
1526             *(--to) = *(--from);
1527     }
1528     return retval;
1529 }
1530 #endif
1531
1532 /* this is a drop-in replacement for memset() */
1533 #ifndef HAS_MEMSET
1534 void *
1535 Perl_my_memset(register char *loc, register I32 ch, register I32 len)
1536 {
1537     char *retval = loc;
1538
1539     while (len--)
1540         *loc++ = ch;
1541     return retval;
1542 }
1543 #endif
1544
1545 /* this is a drop-in replacement for bzero() */
1546 #if !defined(HAS_BZERO) && !defined(HAS_MEMSET)
1547 char *
1548 Perl_my_bzero(register char *loc, register I32 len)
1549 {
1550     char *retval = loc;
1551
1552     while (len--)
1553         *loc++ = 0;
1554     return retval;
1555 }
1556 #endif
1557
1558 /* this is a drop-in replacement for memcmp() */
1559 #if !defined(HAS_MEMCMP) || !defined(HAS_SANE_MEMCMP)
1560 I32
1561 Perl_my_memcmp(const char *s1, const char *s2, register I32 len)
1562 {
1563     register U8 *a = (U8 *)s1;
1564     register U8 *b = (U8 *)s2;
1565     register I32 tmp;
1566
1567     while (len--) {
1568         if (tmp = *a++ - *b++)
1569             return tmp;
1570     }
1571     return 0;
1572 }
1573 #endif /* !HAS_MEMCMP || !HAS_SANE_MEMCMP */
1574
1575 #ifndef HAS_VPRINTF
1576
1577 #ifdef USE_CHAR_VSPRINTF
1578 char *
1579 #else
1580 int
1581 #endif
1582 vsprintf(char *dest, const char *pat, char *args)
1583 {
1584     FILE fakebuf;
1585
1586     fakebuf._ptr = dest;
1587     fakebuf._cnt = 32767;
1588 #ifndef _IOSTRG
1589 #define _IOSTRG 0
1590 #endif
1591     fakebuf._flag = _IOWRT|_IOSTRG;
1592     _doprnt(pat, args, &fakebuf);       /* what a kludge */
1593     (void)putc('\0', &fakebuf);
1594 #ifdef USE_CHAR_VSPRINTF
1595     return(dest);
1596 #else
1597     return 0;           /* perl doesn't use return value */
1598 #endif
1599 }
1600
1601 #endif /* HAS_VPRINTF */
1602
1603 #ifdef MYSWAP
1604 #if BYTEORDER != 0x4321
1605 short
1606 Perl_my_swap(pTHX_ short s)
1607 {
1608 #if (BYTEORDER & 1) == 0
1609     short result;
1610
1611     result = ((s & 255) << 8) + ((s >> 8) & 255);
1612     return result;
1613 #else
1614     return s;
1615 #endif
1616 }
1617
1618 long
1619 Perl_my_htonl(pTHX_ long l)
1620 {
1621     union {
1622         long result;
1623         char c[sizeof(long)];
1624     } u;
1625
1626 #if BYTEORDER == 0x1234
1627     u.c[0] = (l >> 24) & 255;
1628     u.c[1] = (l >> 16) & 255;
1629     u.c[2] = (l >> 8) & 255;
1630     u.c[3] = l & 255;
1631     return u.result;
1632 #else
1633 #if ((BYTEORDER - 0x1111) & 0x444) || !(BYTEORDER & 0xf)
1634     Perl_croak(aTHX_ "Unknown BYTEORDER\n");
1635 #else
1636     register I32 o;
1637     register I32 s;
1638
1639     for (o = BYTEORDER - 0x1111, s = 0; s < (sizeof(long)*8); o >>= 4, s += 8) {
1640         u.c[o & 0xf] = (l >> s) & 255;
1641     }
1642     return u.result;
1643 #endif
1644 #endif
1645 }
1646
1647 long
1648 Perl_my_ntohl(pTHX_ long l)
1649 {
1650     union {
1651         long l;
1652         char c[sizeof(long)];
1653     } u;
1654
1655 #if BYTEORDER == 0x1234
1656     u.c[0] = (l >> 24) & 255;
1657     u.c[1] = (l >> 16) & 255;
1658     u.c[2] = (l >> 8) & 255;
1659     u.c[3] = l & 255;
1660     return u.l;
1661 #else
1662 #if ((BYTEORDER - 0x1111) & 0x444) || !(BYTEORDER & 0xf)
1663     Perl_croak(aTHX_ "Unknown BYTEORDER\n");
1664 #else
1665     register I32 o;
1666     register I32 s;
1667
1668     u.l = l;
1669     l = 0;
1670     for (o = BYTEORDER - 0x1111, s = 0; s < (sizeof(long)*8); o >>= 4, s += 8) {
1671         l |= (u.c[o & 0xf] & 255) << s;
1672     }
1673     return l;
1674 #endif
1675 #endif
1676 }
1677
1678 #endif /* BYTEORDER != 0x4321 */
1679 #endif /* MYSWAP */
1680
1681 /*
1682  * Little-endian byte order functions - 'v' for 'VAX', or 'reVerse'.
1683  * If these functions are defined,
1684  * the BYTEORDER is neither 0x1234 nor 0x4321.
1685  * However, this is not assumed.
1686  * -DWS
1687  */
1688
1689 #define HTOLE(name,type)                                        \
1690         type                                                    \
1691         name (register type n)                                  \
1692         {                                                       \
1693             union {                                             \
1694                 type value;                                     \
1695                 char c[sizeof(type)];                           \
1696             } u;                                                \
1697             register I32 i;                                     \
1698             register I32 s = 0;                                 \
1699             for (i = 0; i < sizeof(u.c); i++, s += 8) {         \
1700                 u.c[i] = (n >> s) & 0xFF;                       \
1701             }                                                   \
1702             return u.value;                                     \
1703         }
1704
1705 #define LETOH(name,type)                                        \
1706         type                                                    \
1707         name (register type n)                                  \
1708         {                                                       \
1709             union {                                             \
1710                 type value;                                     \
1711                 char c[sizeof(type)];                           \
1712             } u;                                                \
1713             register I32 i;                                     \
1714             register I32 s = 0;                                 \
1715             u.value = n;                                        \
1716             n = 0;                                              \
1717             for (i = 0; i < sizeof(u.c); i++, s += 8) {         \
1718                 n |= ((type)(u.c[i] & 0xFF)) << s;              \
1719             }                                                   \
1720             return n;                                           \
1721         }
1722
1723 /*
1724  * Big-endian byte order functions.
1725  */
1726
1727 #define HTOBE(name,type)                                        \
1728         type                                                    \
1729         name (register type n)                                  \
1730         {                                                       \
1731             union {                                             \
1732                 type value;                                     \
1733                 char c[sizeof(type)];                           \
1734             } u;                                                \
1735             register I32 i;                                     \
1736             register I32 s = 8*(sizeof(u.c)-1);                 \
1737             for (i = 0; i < sizeof(u.c); i++, s -= 8) {         \
1738                 u.c[i] = (n >> s) & 0xFF;                       \
1739             }                                                   \
1740             return u.value;                                     \
1741         }
1742
1743 #define BETOH(name,type)                                        \
1744         type                                                    \
1745         name (register type n)                                  \
1746         {                                                       \
1747             union {                                             \
1748                 type value;                                     \
1749                 char c[sizeof(type)];                           \
1750             } u;                                                \
1751             register I32 i;                                     \
1752             register I32 s = 8*(sizeof(u.c)-1);                 \
1753             u.value = n;                                        \
1754             n = 0;                                              \
1755             for (i = 0; i < sizeof(u.c); i++, s -= 8) {         \
1756                 n |= ((type)(u.c[i] & 0xFF)) << s;              \
1757             }                                                   \
1758             return n;                                           \
1759         }
1760
1761 /*
1762  * If we just can't do it...
1763  */
1764
1765 #define NOT_AVAIL(name,type)                                    \
1766         type                                                    \
1767         name (register type n)                                  \
1768         {                                                       \
1769             Perl_croak_nocontext(#name "() not available");     \
1770             return n; /* not reached */                         \
1771         }
1772
1773
1774 #if defined(HAS_HTOVS) && !defined(htovs)
1775 HTOLE(htovs,short)
1776 #endif
1777 #if defined(HAS_HTOVL) && !defined(htovl)
1778 HTOLE(htovl,long)
1779 #endif
1780 #if defined(HAS_VTOHS) && !defined(vtohs)
1781 LETOH(vtohs,short)
1782 #endif
1783 #if defined(HAS_VTOHL) && !defined(vtohl)
1784 LETOH(vtohl,long)
1785 #endif
1786
1787 #ifdef PERL_NEED_MY_HTOLE16
1788 # if U16SIZE == 2
1789 HTOLE(Perl_my_htole16,U16)
1790 # else
1791 NOT_AVAIL(Perl_my_htole16,U16)
1792 # endif
1793 #endif
1794 #ifdef PERL_NEED_MY_LETOH16
1795 # if U16SIZE == 2
1796 LETOH(Perl_my_letoh16,U16)
1797 # else
1798 NOT_AVAIL(Perl_my_letoh16,U16)
1799 # endif
1800 #endif
1801 #ifdef PERL_NEED_MY_HTOBE16
1802 # if U16SIZE == 2
1803 HTOBE(Perl_my_htobe16,U16)
1804 # else
1805 NOT_AVAIL(Perl_my_htobe16,U16)
1806 # endif
1807 #endif
1808 #ifdef PERL_NEED_MY_BETOH16
1809 # if U16SIZE == 2
1810 BETOH(Perl_my_betoh16,U16)
1811 # else
1812 NOT_AVAIL(Perl_my_betoh16,U16)
1813 # endif
1814 #endif
1815
1816 #ifdef PERL_NEED_MY_HTOLE32
1817 # if U32SIZE == 4
1818 HTOLE(Perl_my_htole32,U32)
1819 # else
1820 NOT_AVAIL(Perl_my_htole32,U32)
1821 # endif
1822 #endif
1823 #ifdef PERL_NEED_MY_LETOH32
1824 # if U32SIZE == 4
1825 LETOH(Perl_my_letoh32,U32)
1826 # else
1827 NOT_AVAIL(Perl_my_letoh32,U32)
1828 # endif
1829 #endif
1830 #ifdef PERL_NEED_MY_HTOBE32
1831 # if U32SIZE == 4
1832 HTOBE(Perl_my_htobe32,U32)
1833 # else
1834 NOT_AVAIL(Perl_my_htobe32,U32)
1835 # endif
1836 #endif
1837 #ifdef PERL_NEED_MY_BETOH32
1838 # if U32SIZE == 4
1839 BETOH(Perl_my_betoh32,U32)
1840 # else
1841 NOT_AVAIL(Perl_my_betoh32,U32)
1842 # endif
1843 #endif
1844
1845 #ifdef PERL_NEED_MY_HTOLE64
1846 # if U64SIZE == 8
1847 HTOLE(Perl_my_htole64,U64)
1848 # else
1849 NOT_AVAIL(Perl_my_htole64,U64)
1850 # endif
1851 #endif
1852 #ifdef PERL_NEED_MY_LETOH64
1853 # if U64SIZE == 8
1854 LETOH(Perl_my_letoh64,U64)
1855 # else
1856 NOT_AVAIL(Perl_my_letoh64,U64)
1857 # endif
1858 #endif
1859 #ifdef PERL_NEED_MY_HTOBE64
1860 # if U64SIZE == 8
1861 HTOBE(Perl_my_htobe64,U64)
1862 # else
1863 NOT_AVAIL(Perl_my_htobe64,U64)
1864 # endif
1865 #endif
1866 #ifdef PERL_NEED_MY_BETOH64
1867 # if U64SIZE == 8
1868 BETOH(Perl_my_betoh64,U64)
1869 # else
1870 NOT_AVAIL(Perl_my_betoh64,U64)
1871 # endif
1872 #endif
1873
1874 #ifdef PERL_NEED_MY_HTOLES
1875 HTOLE(Perl_my_htoles,short)
1876 #endif
1877 #ifdef PERL_NEED_MY_LETOHS
1878 LETOH(Perl_my_letohs,short)
1879 #endif
1880 #ifdef PERL_NEED_MY_HTOBES
1881 HTOBE(Perl_my_htobes,short)
1882 #endif
1883 #ifdef PERL_NEED_MY_BETOHS
1884 BETOH(Perl_my_betohs,short)
1885 #endif
1886
1887 #ifdef PERL_NEED_MY_HTOLEI
1888 HTOLE(Perl_my_htolei,int)
1889 #endif
1890 #ifdef PERL_NEED_MY_LETOHI
1891 LETOH(Perl_my_letohi,int)
1892 #endif
1893 #ifdef PERL_NEED_MY_HTOBEI
1894 HTOBE(Perl_my_htobei,int)
1895 #endif
1896 #ifdef PERL_NEED_MY_BETOHI
1897 BETOH(Perl_my_betohi,int)
1898 #endif
1899
1900 #ifdef PERL_NEED_MY_HTOLEL
1901 HTOLE(Perl_my_htolel,long)
1902 #endif
1903 #ifdef PERL_NEED_MY_LETOHL
1904 LETOH(Perl_my_letohl,long)
1905 #endif
1906 #ifdef PERL_NEED_MY_HTOBEL
1907 HTOBE(Perl_my_htobel,long)
1908 #endif
1909 #ifdef PERL_NEED_MY_BETOHL
1910 BETOH(Perl_my_betohl,long)
1911 #endif
1912
1913 void
1914 Perl_my_swabn(void *ptr, int n)
1915 {
1916     register char *s = (char *)ptr;
1917     register char *e = s + (n-1);
1918     register char tc;
1919
1920     for (n /= 2; n > 0; s++, e--, n--) {
1921       tc = *s;
1922       *s = *e;
1923       *e = tc;
1924     }
1925 }
1926
1927 PerlIO *
1928 Perl_my_popen_list(pTHX_ char *mode, int n, SV **args)
1929 {
1930 #if (!defined(DOSISH) || defined(HAS_FORK) || defined(AMIGAOS)) && !defined(OS2) && !defined(VMS) && !defined(__OPEN_VM) && !defined(EPOC) && !defined(MACOS_TRADITIONAL) && !defined(NETWARE)
1931     int p[2];
1932     register I32 This, that;
1933     register Pid_t pid;
1934     SV *sv;
1935     I32 did_pipes = 0;
1936     int pp[2];
1937
1938     PERL_FLUSHALL_FOR_CHILD;
1939     This = (*mode == 'w');
1940     that = !This;
1941     if (PL_tainting) {
1942         taint_env();
1943         taint_proper("Insecure %s%s", "EXEC");
1944     }
1945     if (PerlProc_pipe(p) < 0)
1946         return Nullfp;
1947     /* Try for another pipe pair for error return */
1948     if (PerlProc_pipe(pp) >= 0)
1949         did_pipes = 1;
1950     while ((pid = PerlProc_fork()) < 0) {
1951         if (errno != EAGAIN) {
1952             PerlLIO_close(p[This]);
1953             PerlLIO_close(p[that]);
1954             if (did_pipes) {
1955                 PerlLIO_close(pp[0]);
1956                 PerlLIO_close(pp[1]);
1957             }
1958             return Nullfp;
1959         }
1960         sleep(5);
1961     }
1962     if (pid == 0) {
1963         /* Child */
1964 #undef THIS
1965 #undef THAT
1966 #define THIS that
1967 #define THAT This
1968         /* Close parent's end of error status pipe (if any) */
1969         if (did_pipes) {
1970             PerlLIO_close(pp[0]);
1971 #if defined(HAS_FCNTL) && defined(F_SETFD)
1972             /* Close error pipe automatically if exec works */
1973             fcntl(pp[1], F_SETFD, FD_CLOEXEC);
1974 #endif
1975         }
1976         /* Now dup our end of _the_ pipe to right position */
1977         if (p[THIS] != (*mode == 'r')) {
1978             PerlLIO_dup2(p[THIS], *mode == 'r');
1979             PerlLIO_close(p[THIS]);
1980             if (p[THAT] != (*mode == 'r'))      /* if dup2() didn't close it */
1981                 PerlLIO_close(p[THAT]); /* close parent's end of _the_ pipe */
1982         }
1983         else
1984             PerlLIO_close(p[THAT]);     /* close parent's end of _the_ pipe */
1985 #if !defined(HAS_FCNTL) || !defined(F_SETFD)
1986         /* No automatic close - do it by hand */
1987 #  ifndef NOFILE
1988 #  define NOFILE 20
1989 #  endif
1990         {
1991             int fd;
1992
1993             for (fd = PL_maxsysfd + 1; fd < NOFILE; fd++) {
1994                 if (fd != pp[1])
1995                     PerlLIO_close(fd);
1996             }
1997         }
1998 #endif
1999         do_aexec5(Nullsv, args-1, args-1+n, pp[1], did_pipes);
2000         PerlProc__exit(1);
2001 #undef THIS
2002 #undef THAT
2003     }
2004     /* Parent */
2005     do_execfree();      /* free any memory malloced by child on fork */
2006     if (did_pipes)
2007         PerlLIO_close(pp[1]);
2008     /* Keep the lower of the two fd numbers */
2009     if (p[that] < p[This]) {
2010         PerlLIO_dup2(p[This], p[that]);
2011         PerlLIO_close(p[This]);
2012         p[This] = p[that];
2013     }
2014     else
2015         PerlLIO_close(p[that]);         /* close child's end of pipe */
2016
2017     LOCK_FDPID_MUTEX;
2018     sv = *av_fetch(PL_fdpid,p[This],TRUE);
2019     UNLOCK_FDPID_MUTEX;
2020     (void)SvUPGRADE(sv,SVt_IV);
2021     SvIVX(sv) = pid;
2022     PL_forkprocess = pid;
2023     /* If we managed to get status pipe check for exec fail */
2024     if (did_pipes && pid > 0) {
2025         int errkid;
2026         int n = 0, n1;
2027
2028         while (n < sizeof(int)) {
2029             n1 = PerlLIO_read(pp[0],
2030                               (void*)(((char*)&errkid)+n),
2031                               (sizeof(int)) - n);
2032             if (n1 <= 0)
2033                 break;
2034             n += n1;
2035         }
2036         PerlLIO_close(pp[0]);
2037         did_pipes = 0;
2038         if (n) {                        /* Error */
2039             int pid2, status;
2040             PerlLIO_close(p[This]);
2041             if (n != sizeof(int))
2042                 Perl_croak(aTHX_ "panic: kid popen errno read");
2043             do {
2044                 pid2 = wait4pid(pid, &status, 0);
2045             } while (pid2 == -1 && errno == EINTR);
2046             errno = errkid;             /* Propagate errno from kid */
2047             return Nullfp;
2048         }
2049     }
2050     if (did_pipes)
2051          PerlLIO_close(pp[0]);
2052     return PerlIO_fdopen(p[This], mode);
2053 #else
2054     Perl_croak(aTHX_ "List form of piped open not implemented");
2055     return (PerlIO *) NULL;
2056 #endif
2057 }
2058
2059     /* VMS' my_popen() is in VMS.c, same with OS/2. */
2060 #if (!defined(DOSISH) || defined(HAS_FORK) || defined(AMIGAOS)) && !defined(VMS) && !defined(__OPEN_VM) && !defined(EPOC) && !defined(MACOS_TRADITIONAL)
2061 PerlIO *
2062 Perl_my_popen(pTHX_ char *cmd, char *mode)
2063 {
2064     int p[2];
2065     register I32 This, that;
2066     register Pid_t pid;
2067     SV *sv;
2068     I32 doexec = !(*cmd == '-' && cmd[1] == '\0');
2069     I32 did_pipes = 0;
2070     int pp[2];
2071
2072     PERL_FLUSHALL_FOR_CHILD;
2073 #ifdef OS2
2074     if (doexec) {
2075         return my_syspopen(aTHX_ cmd,mode);
2076     }
2077 #endif
2078     This = (*mode == 'w');
2079     that = !This;
2080     if (doexec && PL_tainting) {
2081         taint_env();
2082         taint_proper("Insecure %s%s", "EXEC");
2083     }
2084     if (PerlProc_pipe(p) < 0)
2085         return Nullfp;
2086     if (doexec && PerlProc_pipe(pp) >= 0)
2087         did_pipes = 1;
2088     while ((pid = PerlProc_fork()) < 0) {
2089         if (errno != EAGAIN) {
2090             PerlLIO_close(p[This]);
2091             PerlLIO_close(p[that]);
2092             if (did_pipes) {
2093                 PerlLIO_close(pp[0]);
2094                 PerlLIO_close(pp[1]);
2095             }
2096             if (!doexec)
2097                 Perl_croak(aTHX_ "Can't fork");
2098             return Nullfp;
2099         }
2100         sleep(5);
2101     }
2102     if (pid == 0) {
2103         GV* tmpgv;
2104
2105 #undef THIS
2106 #undef THAT
2107 #define THIS that
2108 #define THAT This
2109         if (did_pipes) {
2110             PerlLIO_close(pp[0]);
2111 #if defined(HAS_FCNTL) && defined(F_SETFD)
2112             fcntl(pp[1], F_SETFD, FD_CLOEXEC);
2113 #endif
2114         }
2115         if (p[THIS] != (*mode == 'r')) {
2116             PerlLIO_dup2(p[THIS], *mode == 'r');
2117             PerlLIO_close(p[THIS]);
2118             if (p[THAT] != (*mode == 'r'))      /* if dup2() didn't close it */
2119                 PerlLIO_close(p[THAT]);
2120         }
2121         else
2122             PerlLIO_close(p[THAT]);
2123 #ifndef OS2
2124         if (doexec) {
2125 #if !defined(HAS_FCNTL) || !defined(F_SETFD)
2126             int fd;
2127
2128 #ifndef NOFILE
2129 #define NOFILE 20
2130 #endif
2131             {
2132                 int fd;
2133
2134                 for (fd = PL_maxsysfd + 1; fd < NOFILE; fd++)
2135                     if (fd != pp[1])
2136                         PerlLIO_close(fd);
2137             }
2138 #endif
2139             /* may or may not use the shell */
2140             do_exec3(cmd, pp[1], did_pipes);
2141             PerlProc__exit(1);
2142         }
2143 #endif  /* defined OS2 */
2144         /*SUPPRESS 560*/
2145         if ((tmpgv = gv_fetchpv("$",TRUE, SVt_PV))) {
2146             SvREADONLY_off(GvSV(tmpgv));
2147             sv_setiv(GvSV(tmpgv), PerlProc_getpid());
2148             SvREADONLY_on(GvSV(tmpgv));
2149         }
2150 #ifdef THREADS_HAVE_PIDS
2151         PL_ppid = (IV)getppid();
2152 #endif
2153         PL_forkprocess = 0;
2154         hv_clear(PL_pidstatus); /* we have no children */
2155         return Nullfp;
2156 #undef THIS
2157 #undef THAT
2158     }
2159     do_execfree();      /* free any memory malloced by child on vfork */
2160     if (did_pipes)
2161         PerlLIO_close(pp[1]);
2162     if (p[that] < p[This]) {
2163         PerlLIO_dup2(p[This], p[that]);
2164         PerlLIO_close(p[This]);
2165         p[This] = p[that];
2166     }
2167     else
2168         PerlLIO_close(p[that]);
2169
2170     LOCK_FDPID_MUTEX;
2171     sv = *av_fetch(PL_fdpid,p[This],TRUE);
2172     UNLOCK_FDPID_MUTEX;
2173     (void)SvUPGRADE(sv,SVt_IV);
2174     SvIVX(sv) = pid;
2175     PL_forkprocess = pid;
2176     if (did_pipes && pid > 0) {
2177         int errkid;
2178         int n = 0, n1;
2179
2180         while (n < sizeof(int)) {
2181             n1 = PerlLIO_read(pp[0],
2182                               (void*)(((char*)&errkid)+n),
2183                               (sizeof(int)) - n);
2184             if (n1 <= 0)
2185                 break;
2186             n += n1;
2187         }
2188         PerlLIO_close(pp[0]);
2189         did_pipes = 0;
2190         if (n) {                        /* Error */
2191             int pid2, status;
2192             PerlLIO_close(p[This]);
2193             if (n != sizeof(int))
2194                 Perl_croak(aTHX_ "panic: kid popen errno read");
2195             do {
2196                 pid2 = wait4pid(pid, &status, 0);
2197             } while (pid2 == -1 && errno == EINTR);
2198             errno = errkid;             /* Propagate errno from kid */
2199             return Nullfp;
2200         }
2201     }
2202     if (did_pipes)
2203          PerlLIO_close(pp[0]);
2204     return PerlIO_fdopen(p[This], mode);
2205 }
2206 #else
2207 #if defined(atarist) || defined(EPOC)
2208 FILE *popen();
2209 PerlIO *
2210 Perl_my_popen(pTHX_ char *cmd, char *mode)
2211 {
2212     PERL_FLUSHALL_FOR_CHILD;
2213     /* Call system's popen() to get a FILE *, then import it.
2214        used 0 for 2nd parameter to PerlIO_importFILE;
2215        apparently not used
2216     */
2217     return PerlIO_importFILE(popen(cmd, mode), 0);
2218 }
2219 #else
2220 #if defined(DJGPP)
2221 FILE *djgpp_popen();
2222 PerlIO *
2223 Perl_my_popen(pTHX_ char *cmd, char *mode)
2224 {
2225     PERL_FLUSHALL_FOR_CHILD;
2226     /* Call system's popen() to get a FILE *, then import it.
2227        used 0 for 2nd parameter to PerlIO_importFILE;
2228        apparently not used
2229     */
2230     return PerlIO_importFILE(djgpp_popen(cmd, mode), 0);
2231 }
2232 #endif
2233 #endif
2234
2235 #endif /* !DOSISH */
2236
2237 /* this is called in parent before the fork() */
2238 void
2239 Perl_atfork_lock(void)
2240 {
2241 #if defined(USE_ITHREADS)
2242     /* locks must be held in locking order (if any) */
2243 #  ifdef MYMALLOC
2244     MUTEX_LOCK(&PL_malloc_mutex);
2245 #  endif
2246     OP_REFCNT_LOCK;
2247 #endif
2248 }
2249
2250 /* this is called in both parent and child after the fork() */
2251 void
2252 Perl_atfork_unlock(void)
2253 {
2254 #if defined(USE_ITHREADS)
2255     /* locks must be released in same order as in atfork_lock() */
2256 #  ifdef MYMALLOC
2257     MUTEX_UNLOCK(&PL_malloc_mutex);
2258 #  endif
2259     OP_REFCNT_UNLOCK;
2260 #endif
2261 }
2262
2263 Pid_t
2264 Perl_my_fork(void)
2265 {
2266 #if defined(HAS_FORK)
2267     Pid_t pid;
2268 #if defined(USE_ITHREADS) && !defined(HAS_PTHREAD_ATFORK)
2269     atfork_lock();
2270     pid = fork();
2271     atfork_unlock();
2272 #else
2273     /* atfork_lock() and atfork_unlock() are installed as pthread_atfork()
2274      * handlers elsewhere in the code */
2275     pid = fork();
2276 #endif
2277     return pid;
2278 #else
2279     /* this "canna happen" since nothing should be calling here if !HAS_FORK */
2280     Perl_croak_nocontext("fork() not available");
2281     return 0;
2282 #endif /* HAS_FORK */
2283 }
2284
2285 #ifdef DUMP_FDS
2286 void
2287 Perl_dump_fds(pTHX_ char *s)
2288 {
2289     int fd;
2290     Stat_t tmpstatbuf;
2291
2292     PerlIO_printf(Perl_debug_log,"%s", s);
2293     for (fd = 0; fd < 32; fd++) {
2294         if (PerlLIO_fstat(fd,&tmpstatbuf) >= 0)
2295             PerlIO_printf(Perl_debug_log," %d",fd);
2296     }
2297     PerlIO_printf(Perl_debug_log,"\n");
2298 }
2299 #endif  /* DUMP_FDS */
2300
2301 #ifndef HAS_DUP2
2302 int
2303 dup2(int oldfd, int newfd)
2304 {
2305 #if defined(HAS_FCNTL) && defined(F_DUPFD)
2306     if (oldfd == newfd)
2307         return oldfd;
2308     PerlLIO_close(newfd);
2309     return fcntl(oldfd, F_DUPFD, newfd);
2310 #else
2311 #define DUP2_MAX_FDS 256
2312     int fdtmp[DUP2_MAX_FDS];
2313     I32 fdx = 0;
2314     int fd;
2315
2316     if (oldfd == newfd)
2317         return oldfd;
2318     PerlLIO_close(newfd);
2319     /* good enough for low fd's... */
2320     while ((fd = PerlLIO_dup(oldfd)) != newfd && fd >= 0) {
2321         if (fdx >= DUP2_MAX_FDS) {
2322             PerlLIO_close(fd);
2323             fd = -1;
2324             break;
2325         }
2326         fdtmp[fdx++] = fd;
2327     }
2328     while (fdx > 0)
2329         PerlLIO_close(fdtmp[--fdx]);
2330     return fd;
2331 #endif
2332 }
2333 #endif
2334
2335 #ifndef PERL_MICRO
2336 #ifdef HAS_SIGACTION
2337
2338 #ifdef MACOS_TRADITIONAL
2339 /* We don't want restart behavior on MacOS */
2340 #undef SA_RESTART
2341 #endif
2342
2343 Sighandler_t
2344 Perl_rsignal(pTHX_ int signo, Sighandler_t handler)
2345 {
2346     struct sigaction act, oact;
2347
2348 #ifdef USE_ITHREADS
2349     /* only "parent" interpreter can diddle signals */
2350     if (PL_curinterp != aTHX)
2351         return SIG_ERR;
2352 #endif
2353
2354     act.sa_handler = handler;
2355     sigemptyset(&act.sa_mask);
2356     act.sa_flags = 0;
2357 #ifdef SA_RESTART
2358     if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG)
2359         act.sa_flags |= SA_RESTART;     /* SVR4, 4.3+BSD */
2360 #endif
2361 #if defined(SA_NOCLDWAIT) && !defined(BSDish) /* See [perl #18849] */
2362     if (signo == SIGCHLD && handler == (Sighandler_t)SIG_IGN)
2363         act.sa_flags |= SA_NOCLDWAIT;
2364 #endif
2365     if (sigaction(signo, &act, &oact) == -1)
2366         return SIG_ERR;
2367     else
2368         return oact.sa_handler;
2369 }
2370
2371 Sighandler_t
2372 Perl_rsignal_state(pTHX_ int signo)
2373 {
2374     struct sigaction oact;
2375
2376     if (sigaction(signo, (struct sigaction *)NULL, &oact) == -1)
2377         return SIG_ERR;
2378     else
2379         return oact.sa_handler;
2380 }
2381
2382 int
2383 Perl_rsignal_save(pTHX_ int signo, Sighandler_t handler, Sigsave_t *save)
2384 {
2385     struct sigaction act;
2386
2387 #ifdef USE_ITHREADS
2388     /* only "parent" interpreter can diddle signals */
2389     if (PL_curinterp != aTHX)
2390         return -1;
2391 #endif
2392
2393     act.sa_handler = handler;
2394     sigemptyset(&act.sa_mask);
2395     act.sa_flags = 0;
2396 #ifdef SA_RESTART
2397     if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG)
2398         act.sa_flags |= SA_RESTART;     /* SVR4, 4.3+BSD */
2399 #endif
2400 #if defined(SA_NOCLDWAIT) && !defined(BSDish) /* See [perl #18849] */
2401     if (signo == SIGCHLD && handler == (Sighandler_t)SIG_IGN)
2402         act.sa_flags |= SA_NOCLDWAIT;
2403 #endif
2404     return sigaction(signo, &act, save);
2405 }
2406
2407 int
2408 Perl_rsignal_restore(pTHX_ int signo, Sigsave_t *save)
2409 {
2410 #ifdef USE_ITHREADS
2411     /* only "parent" interpreter can diddle signals */
2412     if (PL_curinterp != aTHX)
2413         return -1;
2414 #endif
2415
2416     return sigaction(signo, save, (struct sigaction *)NULL);
2417 }
2418
2419 #else /* !HAS_SIGACTION */
2420
2421 Sighandler_t
2422 Perl_rsignal(pTHX_ int signo, Sighandler_t handler)
2423 {
2424 #if defined(USE_ITHREADS) && !defined(WIN32)
2425     /* only "parent" interpreter can diddle signals */
2426     if (PL_curinterp != aTHX)
2427         return SIG_ERR;
2428 #endif
2429
2430     return PerlProc_signal(signo, handler);
2431 }
2432
2433 static int sig_trapped; /* XXX signals are process-wide anyway, so we
2434                            ignore the implications of this for threading */
2435
2436 static
2437 Signal_t
2438 sig_trap(int signo)
2439 {
2440     sig_trapped++;
2441 }
2442
2443 Sighandler_t
2444 Perl_rsignal_state(pTHX_ int signo)
2445 {
2446     Sighandler_t oldsig;
2447
2448 #if defined(USE_ITHREADS) && !defined(WIN32)
2449     /* only "parent" interpreter can diddle signals */
2450     if (PL_curinterp != aTHX)
2451         return SIG_ERR;
2452 #endif
2453
2454     sig_trapped = 0;
2455     oldsig = PerlProc_signal(signo, sig_trap);
2456     PerlProc_signal(signo, oldsig);
2457     if (sig_trapped)
2458         PerlProc_kill(PerlProc_getpid(), signo);
2459     return oldsig;
2460 }
2461
2462 int
2463 Perl_rsignal_save(pTHX_ int signo, Sighandler_t handler, Sigsave_t *save)
2464 {
2465 #if defined(USE_ITHREADS) && !defined(WIN32)
2466     /* only "parent" interpreter can diddle signals */
2467     if (PL_curinterp != aTHX)
2468         return -1;
2469 #endif
2470     *save = PerlProc_signal(signo, handler);
2471     return (*save == SIG_ERR) ? -1 : 0;
2472 }
2473
2474 int
2475 Perl_rsignal_restore(pTHX_ int signo, Sigsave_t *save)
2476 {
2477 #if defined(USE_ITHREADS) && !defined(WIN32)
2478     /* only "parent" interpreter can diddle signals */
2479     if (PL_curinterp != aTHX)
2480         return -1;
2481 #endif
2482     return (PerlProc_signal(signo, *save) == SIG_ERR) ? -1 : 0;
2483 }
2484
2485 #endif /* !HAS_SIGACTION */
2486 #endif /* !PERL_MICRO */
2487
2488     /* VMS' my_pclose() is in VMS.c; same with OS/2 */
2489 #if (!defined(DOSISH) || defined(HAS_FORK) || defined(AMIGAOS)) && !defined(VMS) && !defined(__OPEN_VM) && !defined(EPOC) && !defined(MACOS_TRADITIONAL)
2490 I32
2491 Perl_my_pclose(pTHX_ PerlIO *ptr)
2492 {
2493     Sigsave_t hstat, istat, qstat;
2494     int status;
2495     SV **svp;
2496     Pid_t pid;
2497     Pid_t pid2;
2498     bool close_failed;
2499     int saved_errno = 0;
2500 #ifdef VMS
2501     int saved_vaxc_errno;
2502 #endif
2503 #ifdef WIN32
2504     int saved_win32_errno;
2505 #endif
2506
2507     LOCK_FDPID_MUTEX;
2508     svp = av_fetch(PL_fdpid,PerlIO_fileno(ptr),TRUE);
2509     UNLOCK_FDPID_MUTEX;
2510     pid = (SvTYPE(*svp) == SVt_IV) ? SvIVX(*svp) : -1;
2511     SvREFCNT_dec(*svp);
2512     *svp = &PL_sv_undef;
2513 #ifdef OS2
2514     if (pid == -1) {                    /* Opened by popen. */
2515         return my_syspclose(ptr);
2516     }
2517 #endif
2518     if ((close_failed = (PerlIO_close(ptr) == EOF))) {
2519         saved_errno = errno;
2520 #ifdef VMS
2521         saved_vaxc_errno = vaxc$errno;
2522 #endif
2523 #ifdef WIN32
2524         saved_win32_errno = GetLastError();
2525 #endif
2526     }
2527 #ifdef UTS
2528     if(PerlProc_kill(pid, 0) < 0) { return(pid); }   /* HOM 12/23/91 */
2529 #endif
2530 #ifndef PERL_MICRO
2531     rsignal_save(SIGHUP, SIG_IGN, &hstat);
2532     rsignal_save(SIGINT, SIG_IGN, &istat);
2533     rsignal_save(SIGQUIT, SIG_IGN, &qstat);
2534 #endif
2535     do {
2536         pid2 = wait4pid(pid, &status, 0);
2537     } while (pid2 == -1 && errno == EINTR);
2538 #ifndef PERL_MICRO
2539     rsignal_restore(SIGHUP, &hstat);
2540     rsignal_restore(SIGINT, &istat);
2541     rsignal_restore(SIGQUIT, &qstat);
2542 #endif
2543     if (close_failed) {
2544         SETERRNO(saved_errno, saved_vaxc_errno);
2545         return -1;
2546     }
2547     return(pid2 < 0 ? pid2 : status == 0 ? 0 : (errno = 0, status));
2548 }
2549 #endif /* !DOSISH */
2550
2551 #if  (!defined(DOSISH) || defined(OS2) || defined(WIN32) || defined(NETWARE)) && !defined(MACOS_TRADITIONAL)
2552 I32
2553 Perl_wait4pid(pTHX_ Pid_t pid, int *statusp, int flags)
2554 {
2555     I32 result;
2556     if (!pid)
2557         return -1;
2558 #if !defined(HAS_WAITPID) && !defined(HAS_WAIT4) || defined(HAS_WAITPID_RUNTIME)
2559     {
2560         SV *sv;
2561         SV** svp;
2562         char spid[TYPE_CHARS(IV)];
2563
2564         if (pid > 0) {
2565             sprintf(spid, "%"IVdf, (IV)pid);
2566             svp = hv_fetch(PL_pidstatus,spid,strlen(spid),FALSE);
2567             if (svp && *svp != &PL_sv_undef) {
2568                 *statusp = SvIVX(*svp);
2569                 (void)hv_delete(PL_pidstatus,spid,strlen(spid),G_DISCARD);
2570                 return pid;
2571             }
2572         }
2573         else {
2574             HE *entry;
2575
2576             hv_iterinit(PL_pidstatus);
2577             if ((entry = hv_iternext(PL_pidstatus))) {
2578                 pid = atoi(hv_iterkey(entry,(I32*)statusp));
2579                 sv = hv_iterval(PL_pidstatus,entry);
2580                 *statusp = SvIVX(sv);
2581                 sprintf(spid, "%"IVdf, (IV)pid);
2582                 (void)hv_delete(PL_pidstatus,spid,strlen(spid),G_DISCARD);
2583                 return pid;
2584             }
2585         }
2586     }
2587 #endif
2588 #ifdef HAS_WAITPID
2589 #  ifdef HAS_WAITPID_RUNTIME
2590     if (!HAS_WAITPID_RUNTIME)
2591         goto hard_way;
2592 #  endif
2593     result = PerlProc_waitpid(pid,statusp,flags);
2594     goto finish;
2595 #endif
2596 #if !defined(HAS_WAITPID) && defined(HAS_WAIT4)
2597     result = wait4((pid==-1)?0:pid,statusp,flags,Null(struct rusage *));
2598     goto finish;
2599 #endif
2600 #if !defined(HAS_WAITPID) && !defined(HAS_WAIT4) || defined(HAS_WAITPID_RUNTIME)
2601   hard_way:
2602     {
2603         if (flags)
2604             Perl_croak(aTHX_ "Can't do waitpid with flags");
2605         else {
2606             while ((result = PerlProc_wait(statusp)) != pid && pid > 0 && result >= 0)
2607                 pidgone(result,*statusp);
2608             if (result < 0)
2609                 *statusp = -1;
2610         }
2611     }
2612 #endif
2613   finish:
2614     if (result < 0 && errno == EINTR) {
2615         PERL_ASYNC_CHECK();
2616     }
2617     return result;
2618 }
2619 #endif /* !DOSISH || OS2 || WIN32 || NETWARE */
2620
2621 void
2622 /*SUPPRESS 590*/
2623 Perl_pidgone(pTHX_ Pid_t pid, int status)
2624 {
2625     register SV *sv;
2626     char spid[TYPE_CHARS(IV)];
2627
2628     sprintf(spid, "%"IVdf, (IV)pid);
2629     sv = *hv_fetch(PL_pidstatus,spid,strlen(spid),TRUE);
2630     (void)SvUPGRADE(sv,SVt_IV);
2631     SvIVX(sv) = status;
2632     return;
2633 }
2634
2635 #if defined(atarist) || defined(OS2) || defined(EPOC)
2636 int pclose();
2637 #ifdef HAS_FORK
2638 int                                     /* Cannot prototype with I32
2639                                            in os2ish.h. */
2640 my_syspclose(PerlIO *ptr)
2641 #else
2642 I32
2643 Perl_my_pclose(pTHX_ PerlIO *ptr)
2644 #endif
2645 {
2646     /* Needs work for PerlIO ! */
2647     FILE *f = PerlIO_findFILE(ptr);
2648     I32 result = pclose(f);
2649     PerlIO_releaseFILE(ptr,f);
2650     return result;
2651 }
2652 #endif
2653
2654 #if defined(DJGPP)
2655 int djgpp_pclose();
2656 I32
2657 Perl_my_pclose(pTHX_ PerlIO *ptr)
2658 {
2659     /* Needs work for PerlIO ! */
2660     FILE *f = PerlIO_findFILE(ptr);
2661     I32 result = djgpp_pclose(f);
2662     result = (result << 8) & 0xff00;
2663     PerlIO_releaseFILE(ptr,f);
2664     return result;
2665 }
2666 #endif
2667
2668 void
2669 Perl_repeatcpy(pTHX_ register char *to, register const char *from, I32 len, register I32 count)
2670 {
2671     register I32 todo;
2672     register const char *frombase = from;
2673
2674     if (len == 1) {
2675         register const char c = *from;
2676         while (count-- > 0)
2677             *to++ = c;
2678         return;
2679     }
2680     while (count-- > 0) {
2681         for (todo = len; todo > 0; todo--) {
2682             *to++ = *from++;
2683         }
2684         from = frombase;
2685     }
2686 }
2687
2688 #ifndef HAS_RENAME
2689 I32
2690 Perl_same_dirent(pTHX_ char *a, char *b)
2691 {
2692     char *fa = strrchr(a,'/');
2693     char *fb = strrchr(b,'/');
2694     Stat_t tmpstatbuf1;
2695     Stat_t tmpstatbuf2;
2696     SV *tmpsv = sv_newmortal();
2697
2698     if (fa)
2699         fa++;
2700     else
2701         fa = a;
2702     if (fb)
2703         fb++;
2704     else
2705         fb = b;
2706     if (strNE(a,b))
2707         return FALSE;
2708     if (fa == a)
2709         sv_setpv(tmpsv, ".");
2710     else
2711         sv_setpvn(tmpsv, a, fa - a);
2712     if (PerlLIO_stat(SvPVX(tmpsv), &tmpstatbuf1) < 0)
2713         return FALSE;
2714     if (fb == b)
2715         sv_setpv(tmpsv, ".");
2716     else
2717         sv_setpvn(tmpsv, b, fb - b);
2718     if (PerlLIO_stat(SvPVX(tmpsv), &tmpstatbuf2) < 0)
2719         return FALSE;
2720     return tmpstatbuf1.st_dev == tmpstatbuf2.st_dev &&
2721            tmpstatbuf1.st_ino == tmpstatbuf2.st_ino;
2722 }
2723 #endif /* !HAS_RENAME */
2724
2725 char*
2726 Perl_find_script(pTHX_ char *scriptname, bool dosearch, char **search_ext, I32 flags)
2727 {
2728     char *xfound = Nullch;
2729     char *xfailed = Nullch;
2730     char tmpbuf[MAXPATHLEN];
2731     register char *s;
2732     I32 len = 0;
2733     int retval;
2734 #if defined(DOSISH) && !defined(OS2) && !defined(atarist)
2735 #  define SEARCH_EXTS ".bat", ".cmd", NULL
2736 #  define MAX_EXT_LEN 4
2737 #endif
2738 #ifdef OS2
2739 #  define SEARCH_EXTS ".cmd", ".btm", ".bat", ".pl", NULL
2740 #  define MAX_EXT_LEN 4
2741 #endif
2742 #ifdef VMS
2743 #  define SEARCH_EXTS ".pl", ".com", NULL
2744 #  define MAX_EXT_LEN 4
2745 #endif
2746     /* additional extensions to try in each dir if scriptname not found */
2747 #ifdef SEARCH_EXTS
2748     char *exts[] = { SEARCH_EXTS };
2749     char **ext = search_ext ? search_ext : exts;
2750     int extidx = 0, i = 0;
2751     char *curext = Nullch;
2752 #else
2753 #  define MAX_EXT_LEN 0
2754 #endif
2755
2756     /*
2757      * If dosearch is true and if scriptname does not contain path
2758      * delimiters, search the PATH for scriptname.
2759      *
2760      * If SEARCH_EXTS is also defined, will look for each
2761      * scriptname{SEARCH_EXTS} whenever scriptname is not found
2762      * while searching the PATH.
2763      *
2764      * Assuming SEARCH_EXTS is C<".foo",".bar",NULL>, PATH search
2765      * proceeds as follows:
2766      *   If DOSISH or VMSISH:
2767      *     + look for ./scriptname{,.foo,.bar}
2768      *     + search the PATH for scriptname{,.foo,.bar}
2769      *
2770      *   If !DOSISH:
2771      *     + look *only* in the PATH for scriptname{,.foo,.bar} (note
2772      *       this will not look in '.' if it's not in the PATH)
2773      */
2774     tmpbuf[0] = '\0';
2775
2776 #ifdef VMS
2777 #  ifdef ALWAYS_DEFTYPES
2778     len = strlen(scriptname);
2779     if (!(len == 1 && *scriptname == '-') && scriptname[len-1] != ':') {
2780         int hasdir, idx = 0, deftypes = 1;
2781         bool seen_dot = 1;
2782
2783         hasdir = !dosearch || (strpbrk(scriptname,":[</") != Nullch) ;
2784 #  else
2785     if (dosearch) {
2786         int hasdir, idx = 0, deftypes = 1;
2787         bool seen_dot = 1;
2788
2789         hasdir = (strpbrk(scriptname,":[</") != Nullch) ;
2790 #  endif
2791         /* The first time through, just add SEARCH_EXTS to whatever we
2792          * already have, so we can check for default file types. */
2793         while (deftypes ||
2794                (!hasdir && my_trnlnm("DCL$PATH",tmpbuf,idx++)) )
2795         {
2796             if (deftypes) {
2797                 deftypes = 0;
2798                 *tmpbuf = '\0';
2799             }
2800             if ((strlen(tmpbuf) + strlen(scriptname)
2801                  + MAX_EXT_LEN) >= sizeof tmpbuf)
2802                 continue;       /* don't search dir with too-long name */
2803             strcat(tmpbuf, scriptname);
2804 #else  /* !VMS */
2805
2806 #ifdef DOSISH
2807     if (strEQ(scriptname, "-"))
2808         dosearch = 0;
2809     if (dosearch) {             /* Look in '.' first. */
2810         char *cur = scriptname;
2811 #ifdef SEARCH_EXTS
2812         if ((curext = strrchr(scriptname,'.'))) /* possible current ext */
2813             while (ext[i])
2814                 if (strEQ(ext[i++],curext)) {
2815                     extidx = -1;                /* already has an ext */
2816                     break;
2817                 }
2818         do {
2819 #endif
2820             DEBUG_p(PerlIO_printf(Perl_debug_log,
2821                                   "Looking for %s\n",cur));
2822             if (PerlLIO_stat(cur,&PL_statbuf) >= 0
2823                 && !S_ISDIR(PL_statbuf.st_mode)) {
2824                 dosearch = 0;
2825                 scriptname = cur;
2826 #ifdef SEARCH_EXTS
2827                 break;
2828 #endif
2829             }
2830 #ifdef SEARCH_EXTS
2831             if (cur == scriptname) {
2832                 len = strlen(scriptname);
2833                 if (len+MAX_EXT_LEN+1 >= sizeof(tmpbuf))
2834                     break;
2835                 cur = strcpy(tmpbuf, scriptname);
2836             }
2837         } while (extidx >= 0 && ext[extidx]     /* try an extension? */
2838                  && strcpy(tmpbuf+len, ext[extidx++]));
2839 #endif
2840     }
2841 #endif
2842
2843 #ifdef MACOS_TRADITIONAL
2844     if (dosearch && !strchr(scriptname, ':') &&
2845         (s = PerlEnv_getenv("Commands")))
2846 #else
2847     if (dosearch && !strchr(scriptname, '/')
2848 #ifdef DOSISH
2849                  && !strchr(scriptname, '\\')
2850 #endif
2851                  && (s = PerlEnv_getenv("PATH")))
2852 #endif
2853     {
2854         bool seen_dot = 0;
2855
2856         PL_bufend = s + strlen(s);
2857         while (s < PL_bufend) {
2858 #ifdef MACOS_TRADITIONAL
2859             s = delimcpy(tmpbuf, tmpbuf + sizeof tmpbuf, s, PL_bufend,
2860                         ',',
2861                         &len);
2862 #else
2863 #if defined(atarist) || defined(DOSISH)
2864             for (len = 0; *s
2865 #  ifdef atarist
2866                     && *s != ','
2867 #  endif
2868                     && *s != ';'; len++, s++) {
2869                 if (len < sizeof tmpbuf)
2870                     tmpbuf[len] = *s;
2871             }
2872             if (len < sizeof tmpbuf)
2873                 tmpbuf[len] = '\0';
2874 #else  /* ! (atarist || DOSISH) */
2875             s = delimcpy(tmpbuf, tmpbuf + sizeof tmpbuf, s, PL_bufend,
2876                         ':',
2877                         &len);
2878 #endif /* ! (atarist || DOSISH) */
2879 #endif /* MACOS_TRADITIONAL */
2880             if (s < PL_bufend)
2881                 s++;
2882             if (len + 1 + strlen(scriptname) + MAX_EXT_LEN >= sizeof tmpbuf)
2883                 continue;       /* don't search dir with too-long name */
2884 #ifdef MACOS_TRADITIONAL
2885             if (len && tmpbuf[len - 1] != ':')
2886                 tmpbuf[len++] = ':';
2887 #else
2888             if (len
2889 #if defined(atarist) || defined(__MINT__) || defined(DOSISH)
2890                 && tmpbuf[len - 1] != '/'
2891                 && tmpbuf[len - 1] != '\\'
2892 #endif
2893                )
2894                 tmpbuf[len++] = '/';
2895             if (len == 2 && tmpbuf[0] == '.')
2896                 seen_dot = 1;
2897 #endif
2898             (void)strcpy(tmpbuf + len, scriptname);
2899 #endif  /* !VMS */
2900
2901 #ifdef SEARCH_EXTS
2902             len = strlen(tmpbuf);
2903             if (extidx > 0)     /* reset after previous loop */
2904                 extidx = 0;
2905             do {
2906 #endif
2907                 DEBUG_p(PerlIO_printf(Perl_debug_log, "Looking for %s\n",tmpbuf));
2908                 retval = PerlLIO_stat(tmpbuf,&PL_statbuf);
2909                 if (S_ISDIR(PL_statbuf.st_mode)) {
2910                     retval = -1;
2911                 }
2912 #ifdef SEARCH_EXTS
2913             } while (  retval < 0               /* not there */
2914                     && extidx>=0 && ext[extidx] /* try an extension? */
2915                     && strcpy(tmpbuf+len, ext[extidx++])
2916                 );
2917 #endif
2918             if (retval < 0)
2919                 continue;
2920             if (S_ISREG(PL_statbuf.st_mode)
2921                 && cando(S_IRUSR,TRUE,&PL_statbuf)
2922 #if !defined(DOSISH) && !defined(MACOS_TRADITIONAL)
2923                 && cando(S_IXUSR,TRUE,&PL_statbuf)
2924 #endif
2925                 )
2926             {
2927                 xfound = tmpbuf;                /* bingo! */
2928                 break;
2929             }
2930             if (!xfailed)
2931                 xfailed = savepv(tmpbuf);
2932         }
2933 #ifndef DOSISH
2934         if (!xfound && !seen_dot && !xfailed &&
2935             (PerlLIO_stat(scriptname,&PL_statbuf) < 0
2936              || S_ISDIR(PL_statbuf.st_mode)))
2937 #endif
2938             seen_dot = 1;                       /* Disable message. */
2939         if (!xfound) {
2940             if (flags & 1) {                    /* do or die? */
2941                 Perl_croak(aTHX_ "Can't %s %s%s%s",
2942                       (xfailed ? "execute" : "find"),
2943                       (xfailed ? xfailed : scriptname),
2944                       (xfailed ? "" : " on PATH"),
2945                       (xfailed || seen_dot) ? "" : ", '.' not in PATH");
2946             }
2947             scriptname = Nullch;
2948         }
2949         if (xfailed)
2950             Safefree(xfailed);
2951         scriptname = xfound;
2952     }
2953     return (scriptname ? savepv(scriptname) : Nullch);
2954 }
2955
2956 #ifndef PERL_GET_CONTEXT_DEFINED
2957
2958 void *
2959 Perl_get_context(void)
2960 {
2961 #if defined(USE_ITHREADS)
2962 #  ifdef OLD_PTHREADS_API
2963     pthread_addr_t t;
2964     if (pthread_getspecific(PL_thr_key, &t))
2965         Perl_croak_nocontext("panic: pthread_getspecific");
2966     return (void*)t;
2967 #  else
2968 #    ifdef I_MACH_CTHREADS
2969     return (void*)cthread_data(cthread_self());
2970 #    else
2971     return (void*)PTHREAD_GETSPECIFIC(PL_thr_key);
2972 #    endif
2973 #  endif
2974 #else
2975     return (void*)NULL;
2976 #endif
2977 }
2978
2979 void
2980 Perl_set_context(void *t)
2981 {
2982 #if defined(USE_ITHREADS)
2983 #  ifdef I_MACH_CTHREADS
2984     cthread_set_data(cthread_self(), t);
2985 #  else
2986     if (pthread_setspecific(PL_thr_key, t))
2987         Perl_croak_nocontext("panic: pthread_setspecific");
2988 #  endif
2989 #endif
2990 }
2991
2992 #endif /* !PERL_GET_CONTEXT_DEFINED */
2993
2994 #ifdef PERL_GLOBAL_STRUCT
2995 struct perl_vars *
2996 Perl_GetVars(pTHX)
2997 {
2998  return &PL_Vars;
2999 }
3000 #endif
3001
3002 char **
3003 Perl_get_op_names(pTHX)
3004 {
3005  return PL_op_name;
3006 }
3007
3008 char **
3009 Perl_get_op_descs(pTHX)
3010 {
3011  return PL_op_desc;
3012 }
3013
3014 char *
3015 Perl_get_no_modify(pTHX)
3016 {
3017  return (char*)PL_no_modify;
3018 }
3019
3020 U32 *
3021 Perl_get_opargs(pTHX)
3022 {
3023  return PL_opargs;
3024 }
3025
3026 PPADDR_t*
3027 Perl_get_ppaddr(pTHX)
3028 {
3029  return (PPADDR_t*)PL_ppaddr;
3030 }
3031
3032 #ifndef HAS_GETENV_LEN
3033 char *
3034 Perl_getenv_len(pTHX_ const char *env_elem, unsigned long *len)
3035 {
3036     char *env_trans = PerlEnv_getenv(env_elem);
3037     if (env_trans)
3038         *len = strlen(env_trans);
3039     return env_trans;
3040 }
3041 #endif
3042
3043
3044 MGVTBL*
3045 Perl_get_vtbl(pTHX_ int vtbl_id)
3046 {
3047     MGVTBL* result = Null(MGVTBL*);
3048
3049     switch(vtbl_id) {
3050     case want_vtbl_sv:
3051         result = &PL_vtbl_sv;
3052         break;
3053     case want_vtbl_env:
3054         result = &PL_vtbl_env;
3055         break;
3056     case want_vtbl_envelem:
3057         result = &PL_vtbl_envelem;
3058         break;
3059     case want_vtbl_sig:
3060         result = &PL_vtbl_sig;
3061         break;
3062     case want_vtbl_sigelem:
3063         result = &PL_vtbl_sigelem;
3064         break;
3065     case want_vtbl_pack:
3066         result = &PL_vtbl_pack;
3067         break;
3068     case want_vtbl_packelem:
3069         result = &PL_vtbl_packelem;
3070         break;
3071     case want_vtbl_dbline:
3072         result = &PL_vtbl_dbline;
3073         break;
3074     case want_vtbl_isa:
3075         result = &PL_vtbl_isa;
3076         break;
3077     case want_vtbl_isaelem:
3078         result = &PL_vtbl_isaelem;
3079         break;
3080     case want_vtbl_arylen:
3081         result = &PL_vtbl_arylen;
3082         break;
3083     case want_vtbl_glob:
3084         result = &PL_vtbl_glob;
3085         break;
3086     case want_vtbl_mglob:
3087         result = &PL_vtbl_mglob;
3088         break;
3089     case want_vtbl_nkeys:
3090         result = &PL_vtbl_nkeys;
3091         break;
3092     case want_vtbl_taint:
3093         result = &PL_vtbl_taint;
3094         break;
3095     case want_vtbl_substr:
3096         result = &PL_vtbl_substr;
3097         break;
3098     case want_vtbl_vec:
3099         result = &PL_vtbl_vec;
3100         break;
3101     case want_vtbl_pos:
3102         result = &PL_vtbl_pos;
3103         break;
3104     case want_vtbl_bm:
3105         result = &PL_vtbl_bm;
3106         break;
3107     case want_vtbl_fm:
3108         result = &PL_vtbl_fm;
3109         break;
3110     case want_vtbl_uvar:
3111         result = &PL_vtbl_uvar;
3112         break;
3113     case want_vtbl_defelem:
3114         result = &PL_vtbl_defelem;
3115         break;
3116     case want_vtbl_regexp:
3117         result = &PL_vtbl_regexp;
3118         break;
3119     case want_vtbl_regdata:
3120         result = &PL_vtbl_regdata;
3121         break;
3122     case want_vtbl_regdatum:
3123         result = &PL_vtbl_regdatum;
3124         break;
3125 #ifdef USE_LOCALE_COLLATE
3126     case want_vtbl_collxfrm:
3127         result = &PL_vtbl_collxfrm;
3128         break;
3129 #endif
3130     case want_vtbl_amagic:
3131         result = &PL_vtbl_amagic;
3132         break;
3133     case want_vtbl_amagicelem:
3134         result = &PL_vtbl_amagicelem;
3135         break;
3136     case want_vtbl_backref:
3137         result = &PL_vtbl_backref;
3138         break;
3139     case want_vtbl_utf8:
3140         result = &PL_vtbl_utf8;
3141         break;
3142     }
3143     return result;
3144 }
3145
3146 I32
3147 Perl_my_fflush_all(pTHX)
3148 {
3149 #if defined(USE_PERLIO) || defined(FFLUSH_NULL) || defined(USE_SFIO)
3150     return PerlIO_flush(NULL);
3151 #else
3152 # if defined(HAS__FWALK)
3153     extern int fflush(FILE *);
3154     /* undocumented, unprototyped, but very useful BSDism */
3155     extern void _fwalk(int (*)(FILE *));
3156     _fwalk(&fflush);
3157     return 0;
3158 # else
3159 #  if defined(FFLUSH_ALL) && defined(HAS_STDIO_STREAM_ARRAY)
3160     long open_max = -1;
3161 #   ifdef PERL_FFLUSH_ALL_FOPEN_MAX
3162     open_max = PERL_FFLUSH_ALL_FOPEN_MAX;
3163 #   else
3164 #    if defined(HAS_SYSCONF) && defined(_SC_OPEN_MAX)
3165     open_max = sysconf(_SC_OPEN_MAX);
3166 #     else
3167 #      ifdef FOPEN_MAX
3168     open_max = FOPEN_MAX;
3169 #      else
3170 #       ifdef OPEN_MAX
3171     open_max = OPEN_MAX;
3172 #       else
3173 #        ifdef _NFILE
3174     open_max = _NFILE;
3175 #        endif
3176 #       endif
3177 #      endif
3178 #     endif
3179 #    endif
3180     if (open_max > 0) {
3181       long i;
3182       for (i = 0; i < open_max; i++)
3183             if (STDIO_STREAM_ARRAY[i]._file >= 0 &&
3184                 STDIO_STREAM_ARRAY[i]._file < open_max &&
3185                 STDIO_STREAM_ARRAY[i]._flag)
3186                 PerlIO_flush(&STDIO_STREAM_ARRAY[i]);
3187       return 0;
3188     }
3189 #  endif
3190     SETERRNO(EBADF,RMS_IFI);
3191     return EOF;
3192 # endif
3193 #endif
3194 }
3195
3196 void
3197 Perl_report_evil_fh(pTHX_ GV *gv, IO *io, I32 op)
3198 {
3199     char *func =
3200         op == OP_READLINE   ? "readline"  :     /* "<HANDLE>" not nice */
3201         op == OP_LEAVEWRITE ? "write" :         /* "write exit" not nice */
3202         PL_op_desc[op];
3203     char *pars = OP_IS_FILETEST(op) ? "" : "()";
3204     char *type = OP_IS_SOCKET(op)
3205             || (gv && io && IoTYPE(io) == IoTYPE_SOCKET)
3206                 ?  "socket" : "filehandle";
3207     char *name = NULL;
3208
3209     if (gv && isGV(gv)) {
3210         name = GvENAME(gv);
3211     }
3212
3213     if (op == OP_phoney_OUTPUT_ONLY || op == OP_phoney_INPUT_ONLY) {
3214         if (ckWARN(WARN_IO)) {
3215             const char *direction = (op == OP_phoney_INPUT_ONLY) ? "in" : "out";
3216             if (name && *name)
3217                 Perl_warner(aTHX_ packWARN(WARN_IO),
3218                             "Filehandle %s opened only for %sput",
3219                             name, direction);
3220             else
3221                 Perl_warner(aTHX_ packWARN(WARN_IO),
3222                             "Filehandle opened only for %sput", direction);
3223         }
3224     }
3225     else {
3226         char *vile;
3227         I32   warn_type;
3228
3229         if (gv && io && IoTYPE(io) == IoTYPE_CLOSED) {
3230             vile = "closed";
3231             warn_type = WARN_CLOSED;
3232         }
3233         else {
3234             vile = "unopened";
3235             warn_type = WARN_UNOPENED;
3236         }
3237
3238         if (ckWARN(warn_type)) {
3239             if (name && *name) {
3240                 Perl_warner(aTHX_ packWARN(warn_type),
3241                             "%s%s on %s %s %s", func, pars, vile, type, name);
3242                 if (io && IoDIRP(io) && !(IoFLAGS(io) & IOf_FAKE_DIRP))
3243                     Perl_warner(
3244                         aTHX_ packWARN(warn_type),
3245                         "\t(Are you trying to call %s%s on dirhandle %s?)\n",
3246                         func, pars, name
3247                     );
3248             }
3249             else {
3250                 Perl_warner(aTHX_ packWARN(warn_type),
3251                             "%s%s on %s %s", func, pars, vile, type);
3252                 if (gv && io && IoDIRP(io) && !(IoFLAGS(io) & IOf_FAKE_DIRP))
3253                     Perl_warner(
3254                         aTHX_ packWARN(warn_type),
3255                         "\t(Are you trying to call %s%s on dirhandle?)\n",
3256                         func, pars
3257                     );
3258             }
3259         }
3260     }
3261 }
3262
3263 #ifdef EBCDIC
3264 /* in ASCII order, not that it matters */
3265 static const char controllablechars[] = "?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_";
3266
3267 int
3268 Perl_ebcdic_control(pTHX_ int ch)
3269 {
3270     if (ch > 'a') {
3271         char *ctlp;
3272
3273         if (islower(ch))
3274             ch = toupper(ch);
3275
3276         if ((ctlp = strchr(controllablechars, ch)) == 0) {
3277             Perl_die(aTHX_ "unrecognised control character '%c'\n", ch);
3278         }
3279
3280         if (ctlp == controllablechars)
3281             return('\177'); /* DEL */
3282         else
3283             return((unsigned char)(ctlp - controllablechars - 1));
3284     } else { /* Want uncontrol */
3285         if (ch == '\177' || ch == -1)
3286             return('?');
3287         else if (ch == '\157')
3288             return('\177');
3289         else if (ch == '\174')
3290             return('\000');
3291         else if (ch == '^')    /* '\137' in 1047, '\260' in 819 */
3292             return('\036');
3293         else if (ch == '\155')
3294             return('\037');
3295         else if (0 < ch && ch < (sizeof(controllablechars) - 1))
3296             return(controllablechars[ch+1]);
3297         else
3298             Perl_die(aTHX_ "invalid control request: '\\%03o'\n", ch & 0xFF);
3299     }
3300 }
3301 #endif
3302
3303 /* To workaround core dumps from the uninitialised tm_zone we get the
3304  * system to give us a reasonable struct to copy.  This fix means that
3305  * strftime uses the tm_zone and tm_gmtoff values returned by
3306  * localtime(time()). That should give the desired result most of the
3307  * time. But probably not always!
3308  *
3309  * This does not address tzname aspects of NETaa14816.
3310  *
3311  */
3312
3313 #ifdef HAS_GNULIBC
3314 # ifndef STRUCT_TM_HASZONE
3315 #    define STRUCT_TM_HASZONE
3316 # endif
3317 #endif
3318
3319 #ifdef STRUCT_TM_HASZONE /* Backward compat */
3320 # ifndef HAS_TM_TM_ZONE
3321 #    define HAS_TM_TM_ZONE
3322 # endif
3323 #endif
3324
3325 void
3326 Perl_init_tm(pTHX_ struct tm *ptm)      /* see mktime, strftime and asctime */
3327 {
3328 #ifdef HAS_TM_TM_ZONE
3329     Time_t now;
3330     (void)time(&now);
3331     Copy(localtime(&now), ptm, 1, struct tm);
3332 #endif
3333 }
3334
3335 /*
3336  * mini_mktime - normalise struct tm values without the localtime()
3337  * semantics (and overhead) of mktime().
3338  */
3339 void
3340 Perl_mini_mktime(pTHX_ struct tm *ptm)
3341 {
3342     int yearday;
3343     int secs;
3344     int month, mday, year, jday;
3345     int odd_cent, odd_year;
3346
3347 #define DAYS_PER_YEAR   365
3348 #define DAYS_PER_QYEAR  (4*DAYS_PER_YEAR+1)
3349 #define DAYS_PER_CENT   (25*DAYS_PER_QYEAR-1)
3350 #define DAYS_PER_QCENT  (4*DAYS_PER_CENT+1)
3351 #define SECS_PER_HOUR   (60*60)
3352 #define SECS_PER_DAY    (24*SECS_PER_HOUR)
3353 /* parentheses deliberately absent on these two, otherwise they don't work */
3354 #define MONTH_TO_DAYS   153/5
3355 #define DAYS_TO_MONTH   5/153
3356 /* offset to bias by March (month 4) 1st between month/mday & year finding */
3357 #define YEAR_ADJUST     (4*MONTH_TO_DAYS+1)
3358 /* as used here, the algorithm leaves Sunday as day 1 unless we adjust it */
3359 #define WEEKDAY_BIAS    6       /* (1+6)%7 makes Sunday 0 again */
3360
3361 /*
3362  * Year/day algorithm notes:
3363  *
3364  * With a suitable offset for numeric value of the month, one can find
3365  * an offset into the year by considering months to have 30.6 (153/5) days,
3366  * using integer arithmetic (i.e., with truncation).  To avoid too much
3367  * messing about with leap days, we consider January and February to be
3368  * the 13th and 14th month of the previous year.  After that transformation,
3369  * we need the month index we use to be high by 1 from 'normal human' usage,
3370  * so the month index values we use run from 4 through 15.
3371  *
3372  * Given that, and the rules for the Gregorian calendar (leap years are those
3373  * divisible by 4 unless also divisible by 100, when they must be divisible
3374  * by 400 instead), we can simply calculate the number of days since some
3375  * arbitrary 'beginning of time' by futzing with the (adjusted) year number,
3376  * the days we derive from our month index, and adding in the day of the
3377  * month.  The value used here is not adjusted for the actual origin which
3378  * it normally would use (1 January A.D. 1), since we're not exposing it.
3379  * We're only building the value so we can turn around and get the
3380  * normalised values for the year, month, day-of-month, and day-of-year.
3381  *
3382  * For going backward, we need to bias the value we're using so that we find
3383  * the right year value.  (Basically, we don't want the contribution of
3384  * March 1st to the number to apply while deriving the year).  Having done
3385  * that, we 'count up' the contribution to the year number by accounting for
3386  * full quadracenturies (400-year periods) with their extra leap days, plus
3387  * the contribution from full centuries (to avoid counting in the lost leap
3388  * days), plus the contribution from full quad-years (to count in the normal
3389  * leap days), plus the leftover contribution from any non-leap years.
3390  * At this point, if we were working with an actual leap day, we'll have 0
3391  * days left over.  This is also true for March 1st, however.  So, we have
3392  * to special-case that result, and (earlier) keep track of the 'odd'
3393  * century and year contributions.  If we got 4 extra centuries in a qcent,
3394  * or 4 extra years in a qyear, then it's a leap day and we call it 29 Feb.
3395  * Otherwise, we add back in the earlier bias we removed (the 123 from
3396  * figuring in March 1st), find the month index (integer division by 30.6),
3397  * and the remainder is the day-of-month.  We then have to convert back to
3398  * 'real' months (including fixing January and February from being 14/15 in
3399  * the previous year to being in the proper year).  After that, to get
3400  * tm_yday, we work with the normalised year and get a new yearday value for
3401  * January 1st, which we subtract from the yearday value we had earlier,
3402  * representing the date we've re-built.  This is done from January 1
3403  * because tm_yday is 0-origin.
3404  *
3405  * Since POSIX time routines are only guaranteed to work for times since the
3406  * UNIX epoch (00:00:00 1 Jan 1970 UTC), the fact that this algorithm
3407  * applies Gregorian calendar rules even to dates before the 16th century
3408  * doesn't bother me.  Besides, you'd need cultural context for a given
3409  * date to know whether it was Julian or Gregorian calendar, and that's
3410  * outside the scope for this routine.  Since we convert back based on the
3411  * same rules we used to build the yearday, you'll only get strange results
3412  * for input which needed normalising, or for the 'odd' century years which
3413  * were leap years in the Julian calander but not in the Gregorian one.
3414  * I can live with that.
3415  *
3416  * This algorithm also fails to handle years before A.D. 1 gracefully, but
3417  * that's still outside the scope for POSIX time manipulation, so I don't
3418  * care.
3419  */
3420
3421     year = 1900 + ptm->tm_year;
3422     month = ptm->tm_mon;
3423     mday = ptm->tm_mday;
3424     /* allow given yday with no month & mday to dominate the result */
3425     if (ptm->tm_yday >= 0 && mday <= 0 && month <= 0) {
3426         month = 0;
3427         mday = 0;
3428         jday = 1 + ptm->tm_yday;
3429     }
3430     else {
3431         jday = 0;
3432     }
3433     if (month >= 2)
3434         month+=2;
3435     else
3436         month+=14, year--;
3437     yearday = DAYS_PER_YEAR * year + year/4 - year/100 + year/400;
3438     yearday += month*MONTH_TO_DAYS + mday + jday;
3439     /*
3440      * Note that we don't know when leap-seconds were or will be,
3441      * so we have to trust the user if we get something which looks
3442      * like a sensible leap-second.  Wild values for seconds will
3443      * be rationalised, however.
3444      */
3445     if ((unsigned) ptm->tm_sec <= 60) {
3446         secs = 0;
3447     }
3448     else {
3449         secs = ptm->tm_sec;
3450         ptm->tm_sec = 0;
3451     }
3452     secs += 60 * ptm->tm_min;
3453     secs += SECS_PER_HOUR * ptm->tm_hour;
3454     if (secs < 0) {
3455         if (secs-(secs/SECS_PER_DAY*SECS_PER_DAY) < 0) {
3456             /* got negative remainder, but need positive time */
3457             /* back off an extra day to compensate */
3458             yearday += (secs/SECS_PER_DAY)-1;
3459             secs -= SECS_PER_DAY * (secs/SECS_PER_DAY - 1);
3460         }
3461         else {
3462             yearday += (secs/SECS_PER_DAY);
3463             secs -= SECS_PER_DAY * (secs/SECS_PER_DAY);
3464         }
3465     }
3466     else if (secs >= SECS_PER_DAY) {
3467         yearday += (secs/SECS_PER_DAY);
3468         secs %= SECS_PER_DAY;
3469     }
3470     ptm->tm_hour = secs/SECS_PER_HOUR;
3471     secs %= SECS_PER_HOUR;
3472     ptm->tm_min = secs/60;
3473     secs %= 60;
3474     ptm->tm_sec += secs;
3475     /* done with time of day effects */
3476     /*
3477      * The algorithm for yearday has (so far) left it high by 428.
3478      * To avoid mistaking a legitimate Feb 29 as Mar 1, we need to
3479      * bias it by 123 while trying to figure out what year it
3480      * really represents.  Even with this tweak, the reverse
3481      * translation fails for years before A.D. 0001.
3482      * It would still fail for Feb 29, but we catch that one below.
3483      */
3484     jday = yearday;     /* save for later fixup vis-a-vis Jan 1 */
3485     yearday -= YEAR_ADJUST;
3486     year = (yearday / DAYS_PER_QCENT) * 400;
3487     yearday %= DAYS_PER_QCENT;
3488     odd_cent = yearday / DAYS_PER_CENT;
3489     year += odd_cent * 100;
3490     yearday %= DAYS_PER_CENT;
3491     year += (yearday / DAYS_PER_QYEAR) * 4;
3492     yearday %= DAYS_PER_QYEAR;
3493     odd_year = yearday / DAYS_PER_YEAR;
3494     year += odd_year;
3495     yearday %= DAYS_PER_YEAR;
3496     if (!yearday && (odd_cent==4 || odd_year==4)) { /* catch Feb 29 */
3497         month = 1;
3498         yearday = 29;
3499     }
3500     else {
3501         yearday += YEAR_ADJUST; /* recover March 1st crock */
3502         month = yearday*DAYS_TO_MONTH;
3503         yearday -= month*MONTH_TO_DAYS;
3504         /* recover other leap-year adjustment */
3505         if (month > 13) {
3506             month-=14;
3507             year++;
3508         }
3509         else {
3510             month-=2;
3511         }
3512     }
3513     ptm->tm_year = year - 1900;
3514     if (yearday) {
3515       ptm->tm_mday = yearday;
3516       ptm->tm_mon = month;
3517     }
3518     else {
3519       ptm->tm_mday = 31;
3520       ptm->tm_mon = month - 1;
3521     }
3522     /* re-build yearday based on Jan 1 to get tm_yday */
3523     year--;
3524     yearday = year*DAYS_PER_YEAR + year/4 - year/100 + year/400;
3525     yearday += 14*MONTH_TO_DAYS + 1;
3526     ptm->tm_yday = jday - yearday;
3527     /* fix tm_wday if not overridden by caller */
3528     if ((unsigned)ptm->tm_wday > 6)
3529         ptm->tm_wday = (jday + WEEKDAY_BIAS) % 7;
3530 }
3531
3532 char *
3533 Perl_my_strftime(pTHX_ char *fmt, int sec, int min, int hour, int mday, int mon, int year, int wday, int yday, int isdst)
3534 {
3535 #ifdef HAS_STRFTIME
3536   char *buf;
3537   int buflen;
3538   struct tm mytm;
3539   int len;
3540
3541   init_tm(&mytm);       /* XXX workaround - see init_tm() above */
3542   mytm.tm_sec = sec;
3543   mytm.tm_min = min;
3544   mytm.tm_hour = hour;
3545   mytm.tm_mday = mday;
3546   mytm.tm_mon = mon;
3547   mytm.tm_year = year;
3548   mytm.tm_wday = wday;
3549   mytm.tm_yday = yday;
3550   mytm.tm_isdst = isdst;
3551   mini_mktime(&mytm);
3552   /* use libc to get the values for tm_gmtoff and tm_zone [perl #18238] */
3553 #if defined(HAS_MKTIME) && (defined(HAS_TM_TM_GMTOFF) || defined(HAS_TM_TM_ZONE))
3554   STMT_START {
3555     struct tm mytm2;
3556     mytm2 = mytm;
3557     mktime(&mytm2);
3558 #ifdef HAS_TM_TM_GMTOFF
3559     mytm.tm_gmtoff = mytm2.tm_gmtoff;
3560 #endif
3561 #ifdef HAS_TM_TM_ZONE
3562     mytm.tm_zone = mytm2.tm_zone;
3563 #endif
3564   } STMT_END;
3565 #endif
3566   buflen = 64;
3567   New(0, buf, buflen, char);
3568   len = strftime(buf, buflen, fmt, &mytm);
3569   /*
3570   ** The following is needed to handle to the situation where
3571   ** tmpbuf overflows.  Basically we want to allocate a buffer
3572   ** and try repeatedly.  The reason why it is so complicated
3573   ** is that getting a return value of 0 from strftime can indicate
3574   ** one of the following:
3575   ** 1. buffer overflowed,
3576   ** 2. illegal conversion specifier, or
3577   ** 3. the format string specifies nothing to be returned(not
3578   **      an error).  This could be because format is an empty string
3579   **    or it specifies %p that yields an empty string in some locale.
3580   ** If there is a better way to make it portable, go ahead by
3581   ** all means.
3582   */
3583   if ((len > 0 && len < buflen) || (len == 0 && *fmt == '\0'))
3584     return buf;
3585   else {
3586     /* Possibly buf overflowed - try again with a bigger buf */
3587     int     fmtlen = strlen(fmt);
3588     int     bufsize = fmtlen + buflen;
3589
3590     New(0, buf, bufsize, char);
3591     while (buf) {
3592       buflen = strftime(buf, bufsize, fmt, &mytm);
3593       if (buflen > 0 && buflen < bufsize)
3594         break;
3595       /* heuristic to prevent out-of-memory errors */
3596       if (bufsize > 100*fmtlen) {
3597         Safefree(buf);
3598         buf = NULL;
3599         break;
3600       }
3601       bufsize *= 2;
3602       Renew(buf, bufsize, char);
3603     }
3604     return buf;
3605   }
3606 #else
3607   Perl_croak(aTHX_ "panic: no strftime");
3608 #endif
3609 }
3610
3611
3612 #define SV_CWD_RETURN_UNDEF \
3613 sv_setsv(sv, &PL_sv_undef); \
3614 return FALSE
3615
3616 #define SV_CWD_ISDOT(dp) \
3617     (dp->d_name[0] == '.' && (dp->d_name[1] == '\0' || \
3618         (dp->d_name[1] == '.' && dp->d_name[2] == '\0')))
3619
3620 /*
3621 =head1 Miscellaneous Functions
3622
3623 =for apidoc getcwd_sv
3624
3625 Fill the sv with current working directory
3626
3627 =cut
3628 */
3629
3630 /* Originally written in Perl by John Bazik; rewritten in C by Ben Sugars.
3631  * rewritten again by dougm, optimized for use with xs TARG, and to prefer
3632  * getcwd(3) if available
3633  * Comments from the orignal:
3634  *     This is a faster version of getcwd.  It's also more dangerous
3635  *     because you might chdir out of a directory that you can't chdir
3636  *     back into. */
3637
3638 int
3639 Perl_getcwd_sv(pTHX_ register SV *sv)
3640 {
3641 #ifndef PERL_MICRO
3642
3643 #ifndef INCOMPLETE_TAINTS
3644     SvTAINTED_on(sv);
3645 #endif
3646
3647 #ifdef HAS_GETCWD
3648     {
3649         char buf[MAXPATHLEN];
3650
3651         /* Some getcwd()s automatically allocate a buffer of the given
3652          * size from the heap if they are given a NULL buffer pointer.
3653          * The problem is that this behaviour is not portable. */
3654         if (getcwd(buf, sizeof(buf) - 1)) {
3655             STRLEN len = strlen(buf);
3656             sv_setpvn(sv, buf, len);
3657             return TRUE;
3658         }
3659         else {
3660             sv_setsv(sv, &PL_sv_undef);
3661             return FALSE;
3662         }
3663     }
3664
3665 #else
3666
3667     Stat_t statbuf;
3668     int orig_cdev, orig_cino, cdev, cino, odev, oino, tdev, tino;
3669     int namelen, pathlen=0;
3670     DIR *dir;
3671     Direntry_t *dp;
3672
3673     (void)SvUPGRADE(sv, SVt_PV);
3674
3675     if (PerlLIO_lstat(".", &statbuf) < 0) {
3676         SV_CWD_RETURN_UNDEF;
3677     }
3678
3679     orig_cdev = statbuf.st_dev;
3680     orig_cino = statbuf.st_ino;
3681     cdev = orig_cdev;
3682     cino = orig_cino;
3683
3684     for (;;) {
3685         odev = cdev;
3686         oino = cino;
3687
3688         if (PerlDir_chdir("..") < 0) {
3689             SV_CWD_RETURN_UNDEF;
3690         }
3691         if (PerlLIO_stat(".", &statbuf) < 0) {
3692             SV_CWD_RETURN_UNDEF;
3693         }
3694
3695         cdev = statbuf.st_dev;
3696         cino = statbuf.st_ino;
3697
3698         if (odev == cdev && oino == cino) {
3699             break;
3700         }
3701         if (!(dir = PerlDir_open("."))) {
3702             SV_CWD_RETURN_UNDEF;
3703         }
3704
3705         while ((dp = PerlDir_read(dir)) != NULL) {
3706 #ifdef DIRNAMLEN
3707             namelen = dp->d_namlen;
3708 #else
3709             namelen = strlen(dp->d_name);
3710 #endif
3711             /* skip . and .. */
3712             if (SV_CWD_ISDOT(dp)) {
3713                 continue;
3714             }
3715
3716             if (PerlLIO_lstat(dp->d_name, &statbuf) < 0) {
3717                 SV_CWD_RETURN_UNDEF;
3718             }
3719
3720             tdev = statbuf.st_dev;
3721             tino = statbuf.st_ino;
3722             if (tino == oino && tdev == odev) {
3723                 break;
3724             }
3725         }
3726
3727         if (!dp) {
3728             SV_CWD_RETURN_UNDEF;
3729         }
3730
3731         if (pathlen + namelen + 1 >= MAXPATHLEN) {
3732             SV_CWD_RETURN_UNDEF;
3733         }
3734
3735         SvGROW(sv, pathlen + namelen + 1);
3736
3737         if (pathlen) {
3738             /* shift down */
3739             Move(SvPVX(sv), SvPVX(sv) + namelen + 1, pathlen, char);
3740         }
3741
3742         /* prepend current directory to the front */
3743         *SvPVX(sv) = '/';
3744         Move(dp->d_name, SvPVX(sv)+1, namelen, char);
3745         pathlen += (namelen + 1);
3746
3747 #ifdef VOID_CLOSEDIR
3748         PerlDir_close(dir);
3749 #else
3750         if (PerlDir_close(dir) < 0) {
3751             SV_CWD_RETURN_UNDEF;
3752         }
3753 #endif
3754     }
3755
3756     if (pathlen) {
3757         SvCUR_set(sv, pathlen);
3758         *SvEND(sv) = '\0';
3759         SvPOK_only(sv);
3760
3761         if (PerlDir_chdir(SvPVX(sv)) < 0) {
3762             SV_CWD_RETURN_UNDEF;
3763         }
3764     }
3765     if (PerlLIO_stat(".", &statbuf) < 0) {
3766         SV_CWD_RETURN_UNDEF;
3767     }
3768
3769     cdev = statbuf.st_dev;
3770     cino = statbuf.st_ino;
3771
3772     if (cdev != orig_cdev || cino != orig_cino) {
3773         Perl_croak(aTHX_ "Unstable directory path, "
3774                    "current directory changed unexpectedly");
3775     }
3776
3777     return TRUE;
3778 #endif
3779
3780 #else
3781     return FALSE;
3782 #endif
3783 }
3784
3785 /*
3786 =for apidoc scan_version
3787
3788 Returns a pointer to the next character after the parsed
3789 version string, as well as upgrading the passed in SV to
3790 an RV.
3791
3792 Function must be called with an already existing SV like
3793
3794     sv = newSV(0);
3795     s = scan_version(s,SV *sv, bool qv);
3796
3797 Performs some preprocessing to the string to ensure that
3798 it has the correct characteristics of a version.  Flags the
3799 object if it contains an underscore (which denotes this
3800 is a alpha version).  The boolean qv denotes that the version
3801 should be interpreted as if it had multiple decimals, even if
3802 it doesn't.
3803
3804 =cut
3805 */
3806
3807 char *
3808 Perl_scan_version(pTHX_ char *s, SV *rv, bool qv)
3809 {
3810     const char *start = s;
3811     char *pos = s;
3812     I32 saw_period = 0;
3813     bool saw_under = 0;
3814     SV* sv = newSVrv(rv, "version"); /* create an SV and upgrade the RV */
3815     (void)sv_upgrade(sv, SVt_PVAV); /* needs to be an AV type */
3816     AvREAL_on((AV*)sv);
3817
3818     /* pre-scan the imput string to check for decimals */
3819     while ( *pos == '.' || *pos == '_' || isDIGIT(*pos) )
3820     {
3821         if ( *pos == '.' )
3822         {
3823             if ( saw_under )
3824                 Perl_croak(aTHX_ "Invalid version format (underscores before decimal)");
3825             saw_period++ ;
3826         }
3827         else if ( *pos == '_' )
3828         {
3829             if ( saw_under )
3830                 Perl_croak(aTHX_ "Invalid version format (multiple underscores)");
3831             saw_under = 1;
3832         }
3833         pos++;
3834     }
3835     pos = s;
3836
3837     if (*pos == 'v') {
3838         pos++;  /* get past 'v' */
3839         qv = 1; /* force quoted version processing */
3840     }
3841     while (isDIGIT(*pos))
3842         pos++;
3843     if (!isALPHA(*pos)) {
3844         I32 rev;
3845
3846         if (*s == 'v') s++;  /* get past 'v' */
3847
3848         for (;;) {
3849             rev = 0;
3850             {
3851                 /* this is atoi() that delimits on underscores */
3852                 char *end = pos;
3853                 I32 mult = 1;
3854                 I32 orev;
3855                 if ( s < pos && s > start && *(s-1) == '_' ) {
3856                         mult *= -1;     /* alpha version */
3857                 }
3858                 /* the following if() will only be true after the decimal
3859                  * point of a version originally created with a bare
3860                  * floating point number, i.e. not quoted in any way
3861                  */
3862                 if ( !qv && s > start+1 && saw_period == 1 ) {
3863                     mult *= 100;
3864                     while ( s < end ) {
3865                         orev = rev;
3866                         rev += (*s - '0') * mult;
3867                         mult /= 10;
3868                         if ( PERL_ABS(orev) > PERL_ABS(rev) )
3869                             Perl_croak(aTHX_ "Integer overflow in version");
3870                         s++;
3871                     }
3872                 }
3873                 else {
3874                     while (--end >= s) {
3875                         orev = rev;
3876                         rev += (*end - '0') * mult;
3877                         mult *= 10;
3878                         if ( PERL_ABS(orev) > PERL_ABS(rev) )
3879                             Perl_croak(aTHX_ "Integer overflow in version");
3880                     }
3881                 }
3882             }
3883
3884             /* Append revision */
3885             av_push((AV *)sv, newSViv(rev));
3886             if ( (*pos == '.' || *pos == '_') && isDIGIT(pos[1]))
3887                 s = ++pos;
3888             else if ( isDIGIT(*pos) )
3889                 s = pos;
3890             else {
3891                 s = pos;
3892                 break;
3893             }
3894             while ( isDIGIT(*pos) ) {
3895                 if ( saw_period == 1 && pos-s == 3 )
3896                     break;
3897                 pos++;
3898             }
3899         }
3900     }
3901     if ( qv ) { /* quoted versions always become full version objects */
3902         I32 len = av_len((AV *)sv);
3903         /* This for loop appears to trigger a compiler bug on OS X, as it
3904            loops infinitely. Yes, len is negative. No, it makes no sense.
3905            Compiler in question is:
3906            gcc version 3.3 20030304 (Apple Computer, Inc. build 1640)
3907            for ( len = 2 - len; len > 0; len-- )
3908            av_push((AV *)sv, newSViv(0));
3909         */
3910         len = 2 - len;
3911         while (len-- > 0)
3912             av_push((AV *)sv, newSViv(0));
3913     }
3914     return s;
3915 }
3916
3917 /*
3918 =for apidoc new_version
3919
3920 Returns a new version object based on the passed in SV:
3921
3922     SV *sv = new_version(SV *ver);
3923
3924 Does not alter the passed in ver SV.  See "upg_version" if you
3925 want to upgrade the SV.
3926
3927 =cut
3928 */
3929
3930 SV *
3931 Perl_new_version(pTHX_ SV *ver)
3932 {
3933     SV *rv = newSV(0);
3934     if ( sv_derived_from(ver,"version") ) /* can just copy directly */
3935     {
3936         I32 key;
3937         AV *av = (AV *)SvRV(ver);
3938         SV* sv = newSVrv(rv, "version"); /* create an SV and upgrade the RV */
3939         (void)sv_upgrade(sv, SVt_PVAV); /* needs to be an AV type */
3940         AvREAL_on((AV*)sv);
3941         for ( key = 0; key <= av_len(av); key++ )
3942         {
3943             I32 rev = SvIV(*av_fetch(av, key, FALSE));
3944             av_push((AV *)sv, newSViv(rev));
3945         }
3946         return rv;
3947     }
3948 #ifdef SvVOK
3949     if ( SvVOK(ver) ) { /* already a v-string */
3950         char *version;
3951         MAGIC* mg = mg_find(ver,PERL_MAGIC_vstring);
3952         version = savepvn( (const char*)mg->mg_ptr,mg->mg_len );
3953         sv_setpv(rv,version);
3954         Safefree(version);
3955     }
3956     else {
3957 #endif
3958     sv_setsv(rv,ver); /* make a duplicate */
3959 #ifdef SvVOK
3960     }
3961 #endif
3962     upg_version(rv);
3963     return rv;
3964 }
3965
3966 /*
3967 =for apidoc upg_version
3968
3969 In-place upgrade of the supplied SV to a version object.
3970
3971     SV *sv = upg_version(SV *sv);
3972
3973 Returns a pointer to the upgraded SV.
3974
3975 =cut
3976 */
3977
3978 SV *
3979 Perl_upg_version(pTHX_ SV *ver)
3980 {
3981     char *version;
3982     bool qv = 0;
3983
3984     if ( SvNOK(ver) ) /* may get too much accuracy */
3985     {
3986         char tbuf[64];
3987         sprintf(tbuf,"%.9"NVgf, SvNVX(ver));
3988         version = savepv(tbuf);
3989     }
3990 #ifdef SvVOK
3991     else if ( SvVOK(ver) ) { /* already a v-string */
3992         MAGIC* mg = mg_find(ver,PERL_MAGIC_vstring);
3993         version = savepvn( (const char*)mg->mg_ptr,mg->mg_len );
3994         qv = 1;
3995     }
3996 #endif
3997     else /* must be a string or something like a string */
3998     {
3999         version = savesvpv(ver);
4000     }
4001     (void)scan_version(version, ver, qv);
4002     Safefree(version);
4003     return ver;
4004 }
4005
4006
4007 /*
4008 =for apidoc vnumify
4009
4010 Accepts a version object and returns the normalized floating
4011 point representation.  Call like:
4012
4013     sv = vnumify(rv);
4014
4015 NOTE: you can pass either the object directly or the SV
4016 contained within the RV.
4017
4018 =cut
4019 */
4020
4021 SV *
4022 Perl_vnumify(pTHX_ SV *vs)
4023 {
4024     I32 i, len, digit;
4025     SV *sv = newSV(0);
4026     if ( SvROK(vs) )
4027         vs = SvRV(vs);
4028     len = av_len((AV *)vs);
4029     if ( len == -1 )
4030     {
4031         Perl_sv_catpv(aTHX_ sv,"0");
4032         return sv;
4033     }
4034     digit = SvIVX(*av_fetch((AV *)vs, 0, 0));
4035     Perl_sv_setpvf(aTHX_ sv,"%d.", (int)PERL_ABS(digit));
4036     for ( i = 1 ; i < len ; i++ )
4037     {
4038         digit = SvIVX(*av_fetch((AV *)vs, i, 0));
4039         Perl_sv_catpvf(aTHX_ sv,"%03d", (int)PERL_ABS(digit));
4040     }
4041
4042     if ( len > 0 )
4043     {
4044         digit = SvIVX(*av_fetch((AV *)vs, len, 0));
4045         if ( (int)PERL_ABS(digit) != 0 || len == 1 )
4046         {
4047             if ( digit < 0 ) /* alpha version */
4048                 Perl_sv_catpv(aTHX_ sv,"_");
4049             /* Don't display additional trailing zeros */
4050             Perl_sv_catpvf(aTHX_ sv,"%03d", (int)PERL_ABS(digit));
4051         }
4052     }
4053     else /* len == 0 */
4054     {
4055          Perl_sv_catpv(aTHX_ sv,"000");
4056     }
4057     return sv;
4058 }
4059
4060 /*
4061 =for apidoc vnormal
4062
4063 Accepts a version object and returns the normalized string
4064 representation.  Call like:
4065
4066     sv = vnormal(rv);
4067
4068 NOTE: you can pass either the object directly or the SV
4069 contained within the RV.
4070
4071 =cut
4072 */
4073
4074 SV *
4075 Perl_vnormal(pTHX_ SV *vs)
4076 {
4077     I32 i, len, digit;
4078     SV *sv = newSV(0);
4079     if ( SvROK(vs) )
4080         vs = SvRV(vs);
4081     len = av_len((AV *)vs);
4082     if ( len == -1 )
4083     {
4084         Perl_sv_catpv(aTHX_ sv,"");
4085         return sv;
4086     }
4087     digit = SvIVX(*av_fetch((AV *)vs, 0, 0));
4088     Perl_sv_setpvf(aTHX_ sv,"%"IVdf,(IV)digit);
4089     for ( i = 1 ; i <= len ; i++ )
4090     {
4091         digit = SvIVX(*av_fetch((AV *)vs, i, 0));
4092         if ( digit < 0 )
4093             Perl_sv_catpvf(aTHX_ sv,"_%"IVdf,(IV)-digit);
4094         else
4095             Perl_sv_catpvf(aTHX_ sv,".%"IVdf,(IV)digit);
4096     }
4097
4098     if ( len <= 2 ) { /* short version, must be at least three */
4099         for ( len = 2 - len; len != 0; len-- )
4100             Perl_sv_catpv(aTHX_ sv,".0");
4101     }
4102
4103     return sv;
4104 }
4105
4106 /*
4107 =for apidoc vstringify
4108
4109 In order to maintain maximum compatibility with earlier versions
4110 of Perl, this function will return either the floating point
4111 notation or the multiple dotted notation, depending on whether
4112 the original version contained 1 or more dots, respectively
4113
4114 =cut
4115 */
4116
4117 SV *
4118 Perl_vstringify(pTHX_ SV *vs)
4119 {
4120     I32 len, digit;
4121     if ( SvROK(vs) )
4122         vs = SvRV(vs);
4123     len = av_len((AV *)vs);
4124     digit = SvIVX(*av_fetch((AV *)vs, len, 0));
4125
4126     if ( len < 2 || ( len == 2 && digit < 0 ) )
4127         return vnumify(vs);
4128     else
4129         return vnormal(vs);
4130 }
4131
4132 /*
4133 =for apidoc vcmp
4134
4135 Version object aware cmp.  Both operands must already have been
4136 converted into version objects.
4137
4138 =cut
4139 */
4140
4141 int
4142 Perl_vcmp(pTHX_ SV *lsv, SV *rsv)
4143 {
4144     I32 i,l,m,r,retval;
4145     if ( SvROK(lsv) )
4146         lsv = SvRV(lsv);
4147     if ( SvROK(rsv) )
4148         rsv = SvRV(rsv);
4149     l = av_len((AV *)lsv);
4150     r = av_len((AV *)rsv);
4151     m = l < r ? l : r;
4152     retval = 0;
4153     i = 0;
4154     while ( i <= m && retval == 0 )
4155     {
4156         I32 left  = SvIV(*av_fetch((AV *)lsv,i,0));
4157         I32 right = SvIV(*av_fetch((AV *)rsv,i,0));
4158         bool lalpha = left  < 0 ? 1 : 0;
4159         bool ralpha = right < 0 ? 1 : 0;
4160         left  = abs(left);
4161         right = abs(right);
4162         if ( left < right || (left == right && lalpha && !ralpha) )
4163             retval = -1;
4164         if ( left > right || (left == right && ralpha && !lalpha) )
4165             retval = +1;
4166         i++;
4167     }
4168
4169     if ( l != r && retval == 0 ) /* possible match except for trailing 0's */
4170     {
4171         if ( l < r )
4172         {
4173             while ( i <= r && retval == 0 )
4174             {
4175                 if ( SvIV(*av_fetch((AV *)rsv,i,0)) != 0 )
4176                     retval = -1; /* not a match after all */
4177                 i++;
4178             }
4179         }
4180         else
4181         {
4182             while ( i <= l && retval == 0 )
4183             {
4184                 if ( SvIV(*av_fetch((AV *)lsv,i,0)) != 0 )
4185                     retval = +1; /* not a match after all */
4186                 i++;
4187             }
4188         }
4189     }
4190     return retval;
4191 }
4192
4193 #if !defined(HAS_SOCKETPAIR) && defined(HAS_SOCKET) && defined(AF_INET) && defined(PF_INET) && defined(SOCK_DGRAM) && defined(HAS_SELECT)
4194 #   define EMULATE_SOCKETPAIR_UDP
4195 #endif
4196
4197 #ifdef EMULATE_SOCKETPAIR_UDP
4198 static int
4199 S_socketpair_udp (int fd[2]) {
4200     dTHX;
4201     /* Fake a datagram socketpair using UDP to localhost.  */
4202     int sockets[2] = {-1, -1};
4203     struct sockaddr_in addresses[2];
4204     int i;
4205     Sock_size_t size = sizeof(struct sockaddr_in);
4206     unsigned short port;
4207     int got;
4208
4209     memset(&addresses, 0, sizeof(addresses));
4210     i = 1;
4211     do {
4212         sockets[i] = PerlSock_socket(AF_INET, SOCK_DGRAM, PF_INET);
4213         if (sockets[i] == -1)
4214             goto tidy_up_and_fail;
4215
4216         addresses[i].sin_family = AF_INET;
4217         addresses[i].sin_addr.s_addr = htonl(INADDR_LOOPBACK);
4218         addresses[i].sin_port = 0;      /* kernel choses port.  */
4219         if (PerlSock_bind(sockets[i], (struct sockaddr *) &addresses[i],
4220                 sizeof(struct sockaddr_in)) == -1)
4221             goto tidy_up_and_fail;
4222     } while (i--);
4223
4224     /* Now have 2 UDP sockets. Find out which port each is connected to, and
4225        for each connect the other socket to it.  */
4226     i = 1;
4227     do {
4228         if (PerlSock_getsockname(sockets[i], (struct sockaddr *) &addresses[i],
4229                 &size) == -1)
4230             goto tidy_up_and_fail;
4231         if (size != sizeof(struct sockaddr_in))
4232             goto abort_tidy_up_and_fail;
4233         /* !1 is 0, !0 is 1 */
4234         if (PerlSock_connect(sockets[!i], (struct sockaddr *) &addresses[i],
4235                 sizeof(struct sockaddr_in)) == -1)
4236             goto tidy_up_and_fail;
4237     } while (i--);
4238
4239     /* Now we have 2 sockets connected to each other. I don't trust some other
4240        process not to have already sent a packet to us (by random) so send
4241        a packet from each to the other.  */
4242     i = 1;
4243     do {
4244         /* I'm going to send my own port number.  As a short.
4245            (Who knows if someone somewhere has sin_port as a bitfield and needs
4246            this routine. (I'm assuming crays have socketpair)) */
4247         port = addresses[i].sin_port;
4248         got = PerlLIO_write(sockets[i], &port, sizeof(port));
4249         if (got != sizeof(port)) {
4250             if (got == -1)
4251                 goto tidy_up_and_fail;
4252             goto abort_tidy_up_and_fail;
4253         }
4254     } while (i--);
4255
4256     /* Packets sent. I don't trust them to have arrived though.
4257        (As I understand it Solaris TCP stack is multithreaded. Non-blocking
4258        connect to localhost will use a second kernel thread. In 2.6 the
4259        first thread running the connect() returns before the second completes,
4260        so EINPROGRESS> In 2.7 the improved stack is faster and connect()
4261        returns 0. Poor programs have tripped up. One poor program's authors'
4262        had a 50-1 reverse stock split. Not sure how connected these were.)
4263        So I don't trust someone not to have an unpredictable UDP stack.
4264     */
4265
4266     {
4267         struct timeval waitfor = {0, 100000}; /* You have 0.1 seconds */
4268         int max = sockets[1] > sockets[0] ? sockets[1] : sockets[0];
4269         fd_set rset;
4270
4271         FD_ZERO(&rset);
4272         FD_SET(sockets[0], &rset);
4273         FD_SET(sockets[1], &rset);
4274
4275         got = PerlSock_select(max + 1, &rset, NULL, NULL, &waitfor);
4276         if (got != 2 || !FD_ISSET(sockets[0], &rset)
4277                 || !FD_ISSET(sockets[1], &rset)) {
4278             /* I hope this is portable and appropriate.  */
4279             if (got == -1)
4280                 goto tidy_up_and_fail;
4281             goto abort_tidy_up_and_fail;
4282         }
4283     }
4284
4285     /* And the paranoia department even now doesn't trust it to have arrive
4286        (hence MSG_DONTWAIT). Or that what arrives was sent by us.  */
4287     {
4288         struct sockaddr_in readfrom;
4289         unsigned short buffer[2];
4290
4291         i = 1;
4292         do {
4293 #ifdef MSG_DONTWAIT
4294             got = PerlSock_recvfrom(sockets[i], (char *) &buffer,
4295                     sizeof(buffer), MSG_DONTWAIT,
4296                     (struct sockaddr *) &readfrom, &size);
4297 #else
4298             got = PerlSock_recvfrom(sockets[i], (char *) &buffer,
4299                     sizeof(buffer), 0,
4300                     (struct sockaddr *) &readfrom, &size);
4301 #endif
4302
4303             if (got == -1)
4304                 goto tidy_up_and_fail;
4305             if (got != sizeof(port)
4306                     || size != sizeof(struct sockaddr_in)
4307                     /* Check other socket sent us its port.  */
4308                     || buffer[0] != (unsigned short) addresses[!i].sin_port
4309                     /* Check kernel says we got the datagram from that socket */
4310                     || readfrom.sin_family != addresses[!i].sin_family
4311                     || readfrom.sin_addr.s_addr != addresses[!i].sin_addr.s_addr
4312                     || readfrom.sin_port != addresses[!i].sin_port)
4313                 goto abort_tidy_up_and_fail;
4314         } while (i--);
4315     }
4316     /* My caller (my_socketpair) has validated that this is non-NULL  */
4317     fd[0] = sockets[0];
4318     fd[1] = sockets[1];
4319     /* I hereby declare this connection open.  May God bless all who cross
4320        her.  */
4321     return 0;
4322
4323   abort_tidy_up_and_fail:
4324     errno = ECONNABORTED;
4325   tidy_up_and_fail:
4326     {
4327         int save_errno = errno;
4328         if (sockets[0] != -1)
4329             PerlLIO_close(sockets[0]);
4330         if (sockets[1] != -1)
4331             PerlLIO_close(sockets[1]);
4332         errno = save_errno;
4333         return -1;
4334     }
4335 }
4336 #endif /*  EMULATE_SOCKETPAIR_UDP */
4337
4338 #if !defined(HAS_SOCKETPAIR) && defined(HAS_SOCKET) && defined(AF_INET) && defined(PF_INET)
4339 int
4340 Perl_my_socketpair (int family, int type, int protocol, int fd[2]) {
4341     /* Stevens says that family must be AF_LOCAL, protocol 0.
4342        I'm going to enforce that, then ignore it, and use TCP (or UDP).  */
4343     dTHX;
4344     int listener = -1;
4345     int connector = -1;
4346     int acceptor = -1;
4347     struct sockaddr_in listen_addr;
4348     struct sockaddr_in connect_addr;
4349     Sock_size_t size;
4350
4351     if (protocol
4352 #ifdef AF_UNIX
4353         || family != AF_UNIX
4354 #endif
4355     ) {
4356         errno = EAFNOSUPPORT;
4357         return -1;
4358     }
4359     if (!fd) {
4360         errno = EINVAL;
4361         return -1;
4362     }
4363
4364 #ifdef EMULATE_SOCKETPAIR_UDP
4365     if (type == SOCK_DGRAM)
4366         return S_socketpair_udp(fd);
4367 #endif
4368
4369     listener = PerlSock_socket(AF_INET, type, 0);
4370     if (listener == -1)
4371         return -1;
4372     memset(&listen_addr, 0, sizeof(listen_addr));
4373     listen_addr.sin_family = AF_INET;
4374     listen_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
4375     listen_addr.sin_port = 0;   /* kernel choses port.  */
4376     if (PerlSock_bind(listener, (struct sockaddr *) &listen_addr,
4377             sizeof(listen_addr)) == -1)
4378         goto tidy_up_and_fail;
4379     if (PerlSock_listen(listener, 1) == -1)
4380         goto tidy_up_and_fail;
4381
4382     connector = PerlSock_socket(AF_INET, type, 0);
4383     if (connector == -1)
4384         goto tidy_up_and_fail;
4385     /* We want to find out the port number to connect to.  */
4386     size = sizeof(connect_addr);
4387     if (PerlSock_getsockname(listener, (struct sockaddr *) &connect_addr,
4388             &size) == -1)
4389         goto tidy_up_and_fail;
4390     if (size != sizeof(connect_addr))
4391         goto abort_tidy_up_and_fail;
4392     if (PerlSock_connect(connector, (struct sockaddr *) &connect_addr,
4393             sizeof(connect_addr)) == -1)
4394         goto tidy_up_and_fail;
4395
4396     size = sizeof(listen_addr);
4397     acceptor = PerlSock_accept(listener, (struct sockaddr *) &listen_addr,
4398             &size);
4399     if (acceptor == -1)
4400         goto tidy_up_and_fail;
4401     if (size != sizeof(listen_addr))
4402         goto abort_tidy_up_and_fail;
4403     PerlLIO_close(listener);
4404     /* Now check we are talking to ourself by matching port and host on the
4405        two sockets.  */
4406     if (PerlSock_getsockname(connector, (struct sockaddr *) &connect_addr,
4407             &size) == -1)
4408         goto tidy_up_and_fail;
4409     if (size != sizeof(connect_addr)
4410             || listen_addr.sin_family != connect_addr.sin_family
4411             || listen_addr.sin_addr.s_addr != connect_addr.sin_addr.s_addr
4412             || listen_addr.sin_port != connect_addr.sin_port) {
4413         goto abort_tidy_up_and_fail;
4414     }
4415     fd[0] = connector;
4416     fd[1] = acceptor;
4417     return 0;
4418
4419   abort_tidy_up_and_fail:
4420   errno = ECONNABORTED; /* I hope this is portable and appropriate.  */
4421   tidy_up_and_fail:
4422     {
4423         int save_errno = errno;
4424         if (listener != -1)
4425             PerlLIO_close(listener);
4426         if (connector != -1)
4427             PerlLIO_close(connector);
4428         if (acceptor != -1)
4429             PerlLIO_close(acceptor);
4430         errno = save_errno;
4431         return -1;
4432     }
4433 }
4434 #else
4435 /* In any case have a stub so that there's code corresponding
4436  * to the my_socketpair in global.sym. */
4437 int
4438 Perl_my_socketpair (int family, int type, int protocol, int fd[2]) {
4439 #ifdef HAS_SOCKETPAIR
4440     return socketpair(family, type, protocol, fd);
4441 #else
4442     return -1;
4443 #endif
4444 }
4445 #endif
4446
4447 /*
4448
4449 =for apidoc sv_nosharing
4450
4451 Dummy routine which "shares" an SV when there is no sharing module present.
4452 Exists to avoid test for a NULL function pointer and because it could potentially warn under
4453 some level of strict-ness.
4454
4455 =cut
4456 */
4457
4458 void
4459 Perl_sv_nosharing(pTHX_ SV *sv)
4460 {
4461 }
4462
4463 /*
4464 =for apidoc sv_nolocking
4465
4466 Dummy routine which "locks" an SV when there is no locking module present.
4467 Exists to avoid test for a NULL function pointer and because it could potentially warn under
4468 some level of strict-ness.
4469
4470 =cut
4471 */
4472
4473 void
4474 Perl_sv_nolocking(pTHX_ SV *sv)
4475 {
4476 }
4477
4478
4479 /*
4480 =for apidoc sv_nounlocking
4481
4482 Dummy routine which "unlocks" an SV when there is no locking module present.
4483 Exists to avoid test for a NULL function pointer and because it could potentially warn under
4484 some level of strict-ness.
4485
4486 =cut
4487 */
4488
4489 void
4490 Perl_sv_nounlocking(pTHX_ SV *sv)
4491 {
4492 }
4493
4494 U32
4495 Perl_parse_unicode_opts(pTHX_ char **popt)
4496 {
4497   char *p = *popt;
4498   U32 opt = 0;
4499
4500   if (*p) {
4501        if (isDIGIT(*p)) {
4502             opt = (U32) atoi(p);
4503             while (isDIGIT(*p)) p++;
4504             if (*p && *p != '\n' && *p != '\r')
4505                  Perl_croak(aTHX_ "Unknown Unicode option letter '%c'", *p);
4506        }
4507        else {
4508             for (; *p; p++) {
4509                  switch (*p) {
4510                  case PERL_UNICODE_STDIN:
4511                       opt |= PERL_UNICODE_STDIN_FLAG;   break;
4512                  case PERL_UNICODE_STDOUT:
4513                       opt |= PERL_UNICODE_STDOUT_FLAG;  break;
4514                  case PERL_UNICODE_STDERR:
4515                       opt |= PERL_UNICODE_STDERR_FLAG;  break;
4516                  case PERL_UNICODE_STD:
4517                       opt |= PERL_UNICODE_STD_FLAG;     break;
4518                  case PERL_UNICODE_IN:
4519                       opt |= PERL_UNICODE_IN_FLAG;      break;
4520                  case PERL_UNICODE_OUT:
4521                       opt |= PERL_UNICODE_OUT_FLAG;     break;
4522                  case PERL_UNICODE_INOUT:
4523                       opt |= PERL_UNICODE_INOUT_FLAG;   break;
4524                  case PERL_UNICODE_LOCALE:
4525                       opt |= PERL_UNICODE_LOCALE_FLAG;  break;
4526                  case PERL_UNICODE_ARGV:
4527                       opt |= PERL_UNICODE_ARGV_FLAG;    break;
4528                  default:
4529                       if (*p != '\n' && *p != '\r')
4530                           Perl_croak(aTHX_
4531                                      "Unknown Unicode option letter '%c'", *p);
4532                  }
4533             }
4534        }
4535   }
4536   else
4537        opt = PERL_UNICODE_DEFAULT_FLAGS;
4538
4539   if (opt & ~PERL_UNICODE_ALL_FLAGS)
4540        Perl_croak(aTHX_ "Unknown Unicode option value %"UVuf,
4541                   (UV) (opt & ~PERL_UNICODE_ALL_FLAGS));
4542
4543   *popt = p;
4544
4545   return opt;
4546 }
4547
4548 U32
4549 Perl_seed(pTHX)
4550 {
4551     /*
4552      * This is really just a quick hack which grabs various garbage
4553      * values.  It really should be a real hash algorithm which
4554      * spreads the effect of every input bit onto every output bit,
4555      * if someone who knows about such things would bother to write it.
4556      * Might be a good idea to add that function to CORE as well.
4557      * No numbers below come from careful analysis or anything here,
4558      * except they are primes and SEED_C1 > 1E6 to get a full-width
4559      * value from (tv_sec * SEED_C1 + tv_usec).  The multipliers should
4560      * probably be bigger too.
4561      */
4562 #if RANDBITS > 16
4563 #  define SEED_C1       1000003
4564 #define   SEED_C4       73819
4565 #else
4566 #  define SEED_C1       25747
4567 #define   SEED_C4       20639
4568 #endif
4569 #define   SEED_C2       3
4570 #define   SEED_C3       269
4571 #define   SEED_C5       26107
4572
4573 #ifndef PERL_NO_DEV_RANDOM
4574     int fd;
4575 #endif
4576     U32 u;
4577 #ifdef VMS
4578 #  include <starlet.h>
4579     /* when[] = (low 32 bits, high 32 bits) of time since epoch
4580      * in 100-ns units, typically incremented ever 10 ms.        */
4581     unsigned int when[2];
4582 #else
4583 #  ifdef HAS_GETTIMEOFDAY
4584     struct timeval when;
4585 #  else
4586     Time_t when;
4587 #  endif
4588 #endif
4589
4590 /* This test is an escape hatch, this symbol isn't set by Configure. */
4591 #ifndef PERL_NO_DEV_RANDOM
4592 #ifndef PERL_RANDOM_DEVICE
4593    /* /dev/random isn't used by default because reads from it will block
4594     * if there isn't enough entropy available.  You can compile with
4595     * PERL_RANDOM_DEVICE to it if you'd prefer Perl to block until there
4596     * is enough real entropy to fill the seed. */
4597 #  define PERL_RANDOM_DEVICE "/dev/urandom"
4598 #endif
4599     fd = PerlLIO_open(PERL_RANDOM_DEVICE, 0);
4600     if (fd != -1) {
4601         if (PerlLIO_read(fd, &u, sizeof u) != sizeof u)
4602             u = 0;
4603         PerlLIO_close(fd);
4604         if (u)
4605             return u;
4606     }
4607 #endif
4608
4609 #ifdef VMS
4610     _ckvmssts(sys$gettim(when));
4611     u = (U32)SEED_C1 * when[0] + (U32)SEED_C2 * when[1];
4612 #else
4613 #  ifdef HAS_GETTIMEOFDAY
4614     PerlProc_gettimeofday(&when,NULL);
4615     u = (U32)SEED_C1 * when.tv_sec + (U32)SEED_C2 * when.tv_usec;
4616 #  else
4617     (void)time(&when);
4618     u = (U32)SEED_C1 * when;
4619 #  endif
4620 #endif
4621     u += SEED_C3 * (U32)PerlProc_getpid();
4622     u += SEED_C4 * (U32)PTR2UV(PL_stack_sp);
4623 #ifndef PLAN9           /* XXX Plan9 assembler chokes on this; fix needed  */
4624     u += SEED_C5 * (U32)PTR2UV(&when);
4625 #endif
4626     return u;
4627 }
4628
4629 UV
4630 Perl_get_hash_seed(pTHX)
4631 {
4632      char *s = PerlEnv_getenv("PERL_HASH_SEED");
4633      UV myseed = 0;
4634
4635      if (s)
4636           while (isSPACE(*s)) s++;
4637      if (s && isDIGIT(*s))
4638           myseed = (UV)Atoul(s);
4639      else
4640 #ifdef USE_HASH_SEED_EXPLICIT
4641      if (s)
4642 #endif
4643      {
4644           /* Compute a random seed */
4645           (void)seedDrand01((Rand_seed_t)seed());
4646           myseed = (UV)(Drand01() * (NV)UV_MAX);
4647 #if RANDBITS < (UVSIZE * 8)
4648           /* Since there are not enough randbits to to reach all
4649            * the bits of a UV, the low bits might need extra
4650            * help.  Sum in another random number that will
4651            * fill in the low bits. */
4652           myseed +=
4653                (UV)(Drand01() * (NV)((1 << ((UVSIZE * 8 - RANDBITS))) - 1));
4654 #endif /* RANDBITS < (UVSIZE * 8) */
4655           if (myseed == 0) { /* Superparanoia. */
4656               myseed = (UV)(Drand01() * (NV)UV_MAX); /* One more chance. */
4657               if (myseed == 0)
4658                   Perl_croak(aTHX_ "Your random numbers are not that random");
4659           }
4660      }
4661      PL_rehash_seed_set = TRUE;
4662
4663      return myseed;
4664 }