util.c

   1 /* $Header: util.c,v 3.0.1.9 90/10/20 02:21:01 lwall Locked $
   2  *
   3  *    Copyright (c) 1989, Larry Wall
   4  *
   5  *    You may distribute under the terms of the GNU General Public License
   6  *    as specified in the README file that comes with the perl 3.0 kit.
   7  *
   8  * $Log:        util.c,v $
   9  * Revision 3.0.1.9  90/10/20  02:21:01  lwall
  10  * patch37: tried to take strlen of integer on systems without wait4 or waitpid
  11  * patch37: unreachable return eliminated
  12  *
  13  * Revision 3.0.1.8  90/10/16  11:26:57  lwall
  14  * patch29: added waitpid
  15  * patch29: various portability fixes
  16  * patch29: scripts now run at almost full speed under the debugger
  17  *
  18  * Revision 3.0.1.7  90/08/13  22:40:26  lwall
  19  * patch28: the NSIG hack didn't work right on Xenix
  20  * patch28: rename was busted on systems without rename system call
  21  *
  22  * Revision 3.0.1.6  90/08/09  05:44:55  lwall
  23  * patch19: fixed double include of <signal.h>
  24  * patch19: various MSDOS and OS/2 patches folded in
  25  * patch19: open(STDOUT,"|command") left wrong descriptor attached to STDOUT
  26  *
  27  * Revision 3.0.1.5  90/03/27  16:35:13  lwall
  28  * patch16: MSDOS support
  29  * patch16: support for machines that can't cast negative floats to unsigned ints
  30  * patch16: tail anchored pattern could dump if string to search was shorter
  31  *
  32  * Revision 3.0.1.4  90/03/01  10:26:48  lwall
  33  * patch9: fbminstr() called instr() rather than ninstr()
  34  * patch9: nested evals clobbered their longjmp environment
  35  * patch9: piped opens returned undefined rather than 0 in child
  36  * patch9: the x operator is now up to 10 times faster
  37  *
  38  * Revision 3.0.1.3  89/12/21  20:27:41  lwall
  39  * patch7: errno may now be a macro with an lvalue
  40  *
  41  * Revision 3.0.1.2  89/11/17  15:46:35  lwall
  42  * patch5: BZERO separate from BCOPY now
  43  * patch5: byteorder now is a hex value
  44  *
  45  * Revision 3.0.1.1  89/11/11  05:06:13  lwall
  46  * patch2: made dup2 a little better
  47  *
  48  * Revision 3.0  89/10/18  15:32:43  lwall
  49  * 3.0 baseline
  50  *
  51  */
  52
  53 #include "EXTERN.h"
  54 #include "perl.h"
  55
  56 #if !defined(NSIG) || defined(M_UNIX) || defined(M_XENIX)
  57 #include <signal.h>
  58 #endif
  59
  60 #ifdef I_VFORK
  61 #  include <vfork.h>
  62 #endif
  63
  64 #ifdef I_VARARGS
  65 #  include <varargs.h>
  66 #endif
  67
  68 #define FLUSH
  69
  70 static char nomem[] = "Out of memory!\n";
  71
  72 /* paranoid version of malloc */
  73
  74 #ifdef DEBUGGING
  75 static int an = 0;
  76 #endif
  77
  78 /* NOTE:  Do not call the next three routines directly.  Use the macros
  79  * in handy.h, so that we can easily redefine everything to do tracking of
  80  * allocated hunks back to the original New to track down any memory leaks.
  81  */
  82
  83 char *
  84 safemalloc(size)
  85 #ifdef MSDOS
  86 unsigned long size;
  87 #else
  88 MEM_SIZE size;
  89 #endif /* MSDOS */
  90 {
  91     char *ptr;
  92     char *malloc();
  93
  94 #ifdef MSDOS
  95         if (size > 0xffff) {
  96                 fprintf(stderr, "Allocation too large: %lx\n", size) FLUSH;
  97                 exit(1);
  98         }
  99 #endif /* MSDOS */
 100     ptr = malloc(size?size:1);  /* malloc(0) is NASTY on our system */
 101 #ifdef DEBUGGING
 102 #  ifndef I286
 103     if (debug & 128)
 104         fprintf(stderr,"0x%x: (%05d) malloc %d bytes\n",ptr,an++,size);
 105 #  else
 106     if (debug & 128)
 107         fprintf(stderr,"0x%lx: (%05d) malloc %d bytes\n",ptr,an++,size);
 108 #  endif
 109 #endif
 110     if (ptr != Nullch)
 111         return ptr;
 112     else {
 113         fputs(nomem,stdout) FLUSH;
 114         exit(1);
 115     }
 116     /*NOTREACHED*/
 117 #ifdef lint
 118     return ptr;
 119 #endif
 120 }
 121
 122 /* paranoid version of realloc */
 123
 124 char *
 125 saferealloc(where,size)
 126 char *where;
 127 #ifndef MSDOS
 128 MEM_SIZE size;
 129 #else
 130 unsigned long size;
 131 #endif /* MSDOS */
 132 {
 133     char *ptr;
 134     char *realloc();
 135
 136 #ifdef MSDOS
 137         if (size > 0xffff) {
 138                 fprintf(stderr, "Reallocation too large: %lx\n", size) FLUSH;
 139                 exit(1);
 140         }
 141 #endif /* MSDOS */
 142     if (!where)
 143         fatal("Null realloc");
 144     ptr = realloc(where,size?size:1);   /* realloc(0) is NASTY on our system */
 145 #ifdef DEBUGGING
 146 #  ifndef I286
 147     if (debug & 128) {
 148         fprintf(stderr,"0x%x: (%05d) rfree\n",where,an++);
 149         fprintf(stderr,"0x%x: (%05d) realloc %d bytes\n",ptr,an++,size);
 150     }
 151 #  else
 152     if (debug & 128) {
 153         fprintf(stderr,"0x%lx: (%05d) rfree\n",where,an++);
 154         fprintf(stderr,"0x%lx: (%05d) realloc %d bytes\n",ptr,an++,size);
 155     }
 156 #  endif
 157 #endif
 158     if (ptr != Nullch)
 159         return ptr;
 160     else {
 161         fputs(nomem,stdout) FLUSH;
 162         exit(1);
 163     }
 164     /*NOTREACHED*/
 165 #ifdef lint
 166     return ptr;
 167 #endif
 168 }
 169
 170 /* safe version of free */
 171
 172 void
 173 safefree(where)
 174 char *where;
 175 {
 176 #ifdef DEBUGGING
 177 #  ifndef I286
 178     if (debug & 128)
 179         fprintf(stderr,"0x%x: (%05d) free\n",where,an++);
 180 #  else
 181     if (debug & 128)
 182         fprintf(stderr,"0x%lx: (%05d) free\n",where,an++);
 183 #  endif
 184 #endif
 185     if (where) {
 186         free(where);
 187     }
 188 }
 189
 190 #ifdef LEAKTEST
 191
 192 #define ALIGN sizeof(long)
 193
 194 char *
 195 safexmalloc(x,size)
 196 int x;
 197 MEM_SIZE size;
 198 {
 199     register char *where;
 200
 201     where = safemalloc(size + ALIGN);
 202     xcount[x]++;
 203     where[0] = x % 100;
 204     where[1] = x / 100;
 205     return where + ALIGN;
 206 }
 207
 208 char *
 209 safexrealloc(where,size)
 210 char *where;
 211 MEM_SIZE size;
 212 {
 213     return saferealloc(where - ALIGN, size + ALIGN) + ALIGN;
 214 }
 215
 216 void
 217 safexfree(where)
 218 char *where;
 219 {
 220     int x;
 221
 222     if (!where)
 223         return;
 224     where -= ALIGN;
 225     x = where[0] + 100 * where[1];
 226     xcount[x]--;
 227     safefree(where);
 228 }
 229
 230 xstat()
 231 {
 232     register int i;
 233
 234     for (i = 0; i < MAXXCOUNT; i++) {
 235         if (xcount[i] != lastxcount[i]) {
 236             fprintf(stderr,"%2d %2d\t%ld\n", i / 100, i % 100, xcount[i]);
 237             lastxcount[i] = xcount[i];
 238         }
 239     }
 240 }
 241
 242 #endif /* LEAKTEST */
 243
 244 /* copy a string up to some (non-backslashed) delimiter, if any */
 245
 246 char *
 247 cpytill(to,from,fromend,delim,retlen)
 248 register char *to;
 249 register char *from;
 250 register char *fromend;
 251 register int delim;
 252 int *retlen;
 253 {
 254     char *origto = to;
 255
 256     for (; from < fromend; from++,to++) {
 257         if (*from == '\\') {
 258             if (from[1] == delim)
 259                 from++;
 260             else if (from[1] == '\\')
 261                 *to++ = *from++;
 262         }
 263         else if (*from == delim)
 264             break;
 265         *to = *from;
 266     }
 267     *to = '\0';
 268     *retlen = to - origto;
 269     return from;
 270 }
 271
 272 /* return ptr to little string in big string, NULL if not found */
 273 /* This routine was donated by Corey Satten. */
 274
 275 char *
 276 instr(big, little)
 277 register char *big;
 278 register char *little;
 279 {
 280     register char *s, *x;
 281     register int first;
 282
 283     if (!little)
 284         return big;
 285     first = *little++;
 286     if (!first)
 287         return big;
 288     while (*big) {
 289         if (*big++ != first)
 290             continue;
 291         for (x=big,s=little; *s; /**/ ) {
 292             if (!*x)
 293                 return Nullch;
 294             if (*s++ != *x++) {
 295                 s--;
 296                 break;
 297             }
 298         }
 299         if (!*s)
 300             return big-1;
 301     }
 302     return Nullch;
 303 }
 304
 305 /* same as instr but allow embedded nulls */
 306
 307 char *
 308 ninstr(big, bigend, little, lend)
 309 register char *big;
 310 register char *bigend;
 311 char *little;
 312 char *lend;
 313 {
 314     register char *s, *x;
 315     register int first = *little;
 316     register char *littleend = lend;
 317
 318     if (!first && little > littleend)
 319         return big;
 320     bigend -= littleend - little++;
 321     while (big <= bigend) {
 322         if (*big++ != first)
 323             continue;
 324         for (x=big,s=little; s < littleend; /**/ ) {
 325             if (*s++ != *x++) {
 326                 s--;
 327                 break;
 328             }
 329         }
 330         if (s >= littleend)
 331             return big-1;
 332     }
 333     return Nullch;
 334 }
 335
 336 /* reverse of the above--find last substring */
 337
 338 char *
 339 rninstr(big, bigend, little, lend)
 340 register char *big;
 341 char *bigend;
 342 char *little;
 343 char *lend;
 344 {
 345     register char *bigbeg;
 346     register char *s, *x;
 347     register int first = *little;
 348     register char *littleend = lend;
 349
 350     if (!first && little > littleend)
 351         return bigend;
 352     bigbeg = big;
 353     big = bigend - (littleend - little++);
 354     while (big >= bigbeg) {
 355         if (*big-- != first)
 356             continue;
 357         for (x=big+2,s=little; s < littleend; /**/ ) {
 358             if (*s++ != *x++) {
 359                 s--;
 360                 break;
 361             }
 362         }
 363         if (s >= littleend)
 364             return big+1;
 365     }
 366     return Nullch;
 367 }
 368
 369 unsigned char fold[] = {
 370         0,      1,      2,      3,      4,      5,      6,      7,
 371         8,      9,      10,     11,     12,     13,     14,     15,
 372         16,     17,     18,     19,     20,     21,     22,     23,
 373         24,     25,     26,     27,     28,     29,     30,     31,
 374         32,     33,     34,     35,     36,     37,     38,     39,
 375         40,     41,     42,     43,     44,     45,     46,     47,
 376         48,     49,     50,     51,     52,     53,     54,     55,
 377         56,     57,     58,     59,     60,     61,     62,     63,
 378         64,     'a',    'b',    'c',    'd',    'e',    'f',    'g',
 379         'h',    'i',    'j',    'k',    'l',    'm',    'n',    'o',
 380         'p',    'q',    'r',    's',    't',    'u',    'v',    'w',
 381         'x',    'y',    'z',    91,     92,     93,     94,     95,
 382         96,     'A',    'B',    'C',    'D',    'E',    'F',    'G',
 383         'H',    'I',    'J',    'K',    'L',    'M',    'N',    'O',
 384         'P',    'Q',    'R',    'S',    'T',    'U',    'V',    'W',
 385         'X',    'Y',    'Z',    123,    124,    125,    126,    127,
 386         128,    129,    130,    131,    132,    133,    134,    135,
 387         136,    137,    138,    139,    140,    141,    142,    143,
 388         144,    145,    146,    147,    148,    149,    150,    151,
 389         152,    153,    154,    155,    156,    157,    158,    159,
 390         160,    161,    162,    163,    164,    165,    166,    167,
 391         168,    169,    170,    171,    172,    173,    174,    175,
 392         176,    177,    178,    179,    180,    181,    182,    183,
 393         184,    185,    186,    187,    188,    189,    190,    191,
 394         192,    193,    194,    195,    196,    197,    198,    199,
 395         200,    201,    202,    203,    204,    205,    206,    207,
 396         208,    209,    210,    211,    212,    213,    214,    215,
 397         216,    217,    218,    219,    220,    221,    222,    223,
 398         224,    225,    226,    227,    228,    229,    230,    231,
 399         232,    233,    234,    235,    236,    237,    238,    239,
 400         240,    241,    242,    243,    244,    245,    246,    247,
 401         248,    249,    250,    251,    252,    253,    254,    255
 402 };
 403
 404 static unsigned char freq[] = {
 405         1,      2,      84,     151,    154,    155,    156,    157,
 406         165,    246,    250,    3,      158,    7,      18,     29,
 407         40,     51,     62,     73,     85,     96,     107,    118,
 408         129,    140,    147,    148,    149,    150,    152,    153,
 409         255,    182,    224,    205,    174,    176,    180,    217,
 410         233,    232,    236,    187,    235,    228,    234,    226,
 411         222,    219,    211,    195,    188,    193,    185,    184,
 412         191,    183,    201,    229,    181,    220,    194,    162,
 413         163,    208,    186,    202,    200,    218,    198,    179,
 414         178,    214,    166,    170,    207,    199,    209,    206,
 415         204,    160,    212,    216,    215,    192,    175,    173,
 416         243,    172,    161,    190,    203,    189,    164,    230,
 417         167,    248,    227,    244,    242,    255,    241,    231,
 418         240,    253,    169,    210,    245,    237,    249,    247,
 419         239,    168,    252,    251,    254,    238,    223,    221,
 420         213,    225,    177,    197,    171,    196,    159,    4,
 421         5,      6,      8,      9,      10,     11,     12,     13,
 422         14,     15,     16,     17,     19,     20,     21,     22,
 423         23,     24,     25,     26,     27,     28,     30,     31,
 424         32,     33,     34,     35,     36,     37,     38,     39,
 425         41,     42,     43,     44,     45,     46,     47,     48,
 426         49,     50,     52,     53,     54,     55,     56,     57,
 427         58,     59,     60,     61,     63,     64,     65,     66,
 428         67,     68,     69,     70,     71,     72,     74,     75,
 429         76,     77,     78,     79,     80,     81,     82,     83,
 430         86,     87,     88,     89,     90,     91,     92,     93,
 431         94,     95,     97,     98,     99,     100,    101,    102,
 432         103,    104,    105,    106,    108,    109,    110,    111,
 433         112,    113,    114,    115,    116,    117,    119,    120,
 434         121,    122,    123,    124,    125,    126,    127,    128,
 435         130,    131,    132,    133,    134,    135,    136,    137,
 436         138,    139,    141,    142,    143,    144,    145,    146
 437 };
 438
 439 void
 440 fbmcompile(str, iflag)
 441 STR *str;
 442 int iflag;
 443 {
 444     register unsigned char *s;
 445     register unsigned char *table;
 446     register int i;
 447     register int len = str->str_cur;
 448     int rarest = 0;
 449     unsigned int frequency = 256;
 450
 451     Str_Grow(str,len+258);
 452 #ifndef lint
 453     table = (unsigned char*)(str->str_ptr + len + 1);
 454 #else
 455     table = Null(unsigned char*);
 456 #endif
 457     s = table - 2;
 458     for (i = 0; i < 256; i++) {
 459         table[i] = len;
 460     }
 461     i = 0;
 462 #ifndef lint
 463     while (s >= (unsigned char*)(str->str_ptr))
 464 #endif
 465     {
 466         if (table[*s] == len) {
 467 #ifndef pdp11
 468             if (iflag)
 469                 table[*s] = table[fold[*s]] = i;
 470 #else
 471             if (iflag) {
 472                 int j;
 473                 j = fold[*s];
 474                 table[j] = i;
 475                 table[*s] = i;
 476             }
 477 #endif /* pdp11 */
 478             else
 479                 table[*s] = i;
 480         }
 481         s--,i++;
 482     }
 483     str->str_pok |= SP_FBM;             /* deep magic */
 484
 485 #ifndef lint
 486     s = (unsigned char*)(str->str_ptr);         /* deeper magic */
 487 #else
 488     s = Null(unsigned char*);
 489 #endif
 490     if (iflag) {
 491         register unsigned int tmp, foldtmp;
 492         str->str_pok |= SP_CASEFOLD;
 493         for (i = 0; i < len; i++) {
 494             tmp=freq[s[i]];
 495             foldtmp=freq[fold[s[i]]];
 496             if (tmp < frequency && foldtmp < frequency) {
 497                 rarest = i;
 498                 /* choose most frequent among the two */
 499                 frequency = (tmp > foldtmp) ? tmp : foldtmp;
 500             }
 501         }
 502     }
 503     else {
 504         for (i = 0; i < len; i++) {
 505             if (freq[s[i]] < frequency) {
 506                 rarest = i;
 507                 frequency = freq[s[i]];
 508             }
 509         }
 510     }
 511     str->str_rare = s[rarest];
 512     str->str_state = rarest;
 513 #ifdef DEBUGGING
 514     if (debug & 512)
 515         fprintf(stderr,"rarest char %c at %d\n",str->str_rare, str->str_state);
 516 #endif
 517 }
 518
 519 char *
 520 fbminstr(big, bigend, littlestr)
 521 unsigned char *big;
 522 register unsigned char *bigend;
 523 STR *littlestr;
 524 {
 525     register unsigned char *s;
 526     register int tmp;
 527     register int littlelen;
 528     register unsigned char *little;
 529     register unsigned char *table;
 530     register unsigned char *olds;
 531     register unsigned char *oldlittle;
 532
 533 #ifndef lint
 534     if (!(littlestr->str_pok & SP_FBM))
 535         return ninstr((char*)big,(char*)bigend,
 536                 littlestr->str_ptr, littlestr->str_ptr + littlestr->str_cur);
 537 #endif
 538
 539     littlelen = littlestr->str_cur;
 540 #ifndef lint
 541     if (littlestr->str_pok & SP_TAIL && !multiline) {   /* tail anchored? */
 542         if (littlelen > bigend - big)
 543             return Nullch;
 544         little = (unsigned char*)littlestr->str_ptr;
 545         if (littlestr->str_pok & SP_CASEFOLD) { /* oops, fake it */
 546             big = bigend - littlelen;           /* just start near end */
 547             if (bigend[-1] == '\n' && little[littlelen-1] != '\n')
 548                 big--;
 549         }
 550         else {
 551             s = bigend - littlelen;
 552             if (*s == *little && bcmp(s,little,littlelen)==0)
 553                 return (char*)s;                /* how sweet it is */
 554             else if (bigend[-1] == '\n' && little[littlelen-1] != '\n') {
 555                     s--;
 556                 if (*s == *little && bcmp(s,little,littlelen)==0)
 557                     return (char*)s;
 558             }
 559             return Nullch;
 560         }
 561     }
 562     table = (unsigned char*)(littlestr->str_ptr + littlelen + 1);
 563 #else
 564     table = Null(unsigned char*);
 565 #endif
 566     if (--littlelen >= bigend - big)
 567         return Nullch;
 568     s = big + littlelen;
 569     oldlittle = little = table - 2;
 570     if (littlestr->str_pok & SP_CASEFOLD) {     /* case insensitive? */
 571         if (s < bigend) {
 572           top1:
 573             if (tmp = table[*s]) {
 574 #ifdef POINTERRIGOR
 575                 if (bigend - s > tmp) {
 576                     s += tmp;
 577                     goto top1;
 578                 }
 579 #else
 580                 if ((s += tmp) < bigend)
 581                     goto top1;
 582 #endif
 583                 return Nullch;
 584             }
 585             else {
 586                 tmp = littlelen;        /* less expensive than calling strncmp() */
 587                 olds = s;
 588                 while (tmp--) {
 589                     if (*--s == *--little || fold[*s] == *little)
 590                         continue;
 591                     s = olds + 1;       /* here we pay the price for failure */
 592                     little = oldlittle;
 593                     if (s < bigend)     /* fake up continue to outer loop */
 594                         goto top1;
 595                     return Nullch;
 596                 }
 597 #ifndef lint
 598                 return (char *)s;
 599 #endif
 600             }
 601         }
 602     }
 603     else {
 604         if (s < bigend) {
 605           top2:
 606             if (tmp = table[*s]) {
 607 #ifdef POINTERRIGOR
 608                 if (bigend - s > tmp) {
 609                     s += tmp;
 610                     goto top2;
 611                 }
 612 #else
 613                 if ((s += tmp) < bigend)
 614                     goto top2;
 615 #endif
 616                 return Nullch;
 617             }
 618             else {
 619                 tmp = littlelen;        /* less expensive than calling strncmp() */
 620                 olds = s;
 621                 while (tmp--) {
 622                     if (*--s == *--little)
 623                         continue;
 624                     s = olds + 1;       /* here we pay the price for failure */
 625                     little = oldlittle;
 626                     if (s < bigend)     /* fake up continue to outer loop */
 627                         goto top2;
 628                     return Nullch;
 629                 }
 630 #ifndef lint
 631                 return (char *)s;
 632 #endif
 633             }
 634         }
 635     }
 636     return Nullch;
 637 }
 638
 639 char *
 640 screaminstr(bigstr, littlestr)
 641 STR *bigstr;
 642 STR *littlestr;
 643 {
 644     register unsigned char *s, *x;
 645     register unsigned char *big;
 646     register int pos;
 647     register int previous;
 648     register int first;
 649     register unsigned char *little;
 650     register unsigned char *bigend;
 651     register unsigned char *littleend;
 652
 653     if ((pos = screamfirst[littlestr->str_rare]) < 0)
 654         return Nullch;
 655 #ifndef lint
 656     little = (unsigned char *)(littlestr->str_ptr);
 657 #else
 658     little = Null(unsigned char *);
 659 #endif
 660     littleend = little + littlestr->str_cur;
 661     first = *little++;
 662     previous = littlestr->str_state;
 663 #ifndef lint
 664     big = (unsigned char *)(bigstr->str_ptr);
 665 #else
 666     big = Null(unsigned char*);
 667 #endif
 668     bigend = big + bigstr->str_cur;
 669     big -= previous;
 670     while (pos < previous) {
 671 #ifndef lint
 672         if (!(pos += screamnext[pos]))
 673 #endif
 674             return Nullch;
 675     }
 676     if (littlestr->str_pok & SP_CASEFOLD) {     /* case insignificant? */
 677         do {
 678             if (big[pos] != first && big[pos] != fold[first])
 679                 continue;
 680             for (x=big+pos+1,s=little; s < littleend; /**/ ) {
 681                 if (x >= bigend)
 682                     return Nullch;
 683                 if (*s++ != *x++ && fold[*(s-1)] != *(x-1)) {
 684                     s--;
 685                     break;
 686                 }
 687             }
 688             if (s == littleend)
 689 #ifndef lint
 690                 return (char *)(big+pos);
 691 #else
 692                 return Nullch;
 693 #endif
 694         } while (
 695 #ifndef lint
 696                 pos += screamnext[pos]  /* does this goof up anywhere? */
 697 #else
 698                 pos += screamnext[0]
 699 #endif
 700             );
 701     }
 702     else {
 703         do {
 704             if (big[pos] != first)
 705                 continue;
 706             for (x=big+pos+1,s=little; s < littleend; /**/ ) {
 707                 if (x >= bigend)
 708                     return Nullch;
 709                 if (*s++ != *x++) {
 710                     s--;
 711                     break;
 712                 }
 713             }
 714             if (s == littleend)
 715 #ifndef lint
 716                 return (char *)(big+pos);
 717 #else
 718                 return Nullch;
 719 #endif
 720         } while (
 721 #ifndef lint
 722                 pos += screamnext[pos]
 723 #else
 724                 pos += screamnext[0]
 725 #endif
 726             );
 727     }
 728     return Nullch;
 729 }
 730
 731 /* copy a string to a safe spot */
 732
 733 char *
 734 savestr(str)
 735 char *str;
 736 {
 737     register char *newaddr;
 738
 739     New(902,newaddr,strlen(str)+1,char);
 740     (void)strcpy(newaddr,str);
 741     return newaddr;
 742 }
 743
 744 /* same thing but with a known length */
 745
 746 char *
 747 nsavestr(str, len)
 748 char *str;
 749 register int len;
 750 {
 751     register char *newaddr;
 752
 753     New(903,newaddr,len+1,char);
 754     (void)bcopy(str,newaddr,len);       /* might not be null terminated */
 755     newaddr[len] = '\0';                /* is now */
 756     return newaddr;
 757 }
 758
 759 /* grow a static string to at least a certain length */
 760
 761 void
 762 growstr(strptr,curlen,newlen)
 763 char **strptr;
 764 int *curlen;
 765 int newlen;
 766 {
 767     if (newlen > *curlen) {             /* need more room? */
 768         if (*curlen)
 769             Renew(*strptr,newlen,char);
 770         else
 771             New(905,*strptr,newlen,char);
 772         *curlen = newlen;
 773     }
 774 }
 775
 776 #ifndef VARARGS
 777 /*VARARGS1*/
 778 mess(pat,a1,a2,a3,a4)
 779 char *pat;
 780 long a1, a2, a3, a4;
 781 {
 782     char *s;
 783
 784     s = buf;
 785     (void)sprintf(s,pat,a1,a2,a3,a4);
 786     s += strlen(s);
 787     if (s[-1] != '\n') {
 788         if (curcmd->c_line) {
 789             (void)sprintf(s," at %s line %ld",
 790               stab_val(curcmd->c_filestab)->str_ptr, (long)curcmd->c_line);
 791             s += strlen(s);
 792         }
 793         if (last_in_stab &&
 794             stab_io(last_in_stab) &&
 795             stab_io(last_in_stab)->lines ) {
 796             (void)sprintf(s,", <%s> line %ld",
 797               last_in_stab == argvstab ? "" : stab_name(last_in_stab),
 798               (long)stab_io(last_in_stab)->lines);
 799             s += strlen(s);
 800         }
 801         (void)strcpy(s,".\n");
 802     }
 803 }
 804
 805 /*VARARGS1*/
 806 fatal(pat,a1,a2,a3,a4)
 807 char *pat;
 808 long a1, a2, a3, a4;
 809 {
 810     extern FILE *e_fp;
 811     extern char *e_tmpname;
 812     char *tmps;
 813
 814     mess(pat,a1,a2,a3,a4);
 815     if (in_eval) {
 816         str_set(stab_val(stabent("@",TRUE)),buf);
 817         tmps = "_EVAL_";
 818         while (loop_ptr >= 0 && (!loop_stack[loop_ptr].loop_label ||
 819           strNE(tmps,loop_stack[loop_ptr].loop_label) )) {
 820 #ifdef DEBUGGING
 821             if (debug & 4) {
 822                 deb("(Skipping label #%d %s)\n",loop_ptr,
 823                     loop_stack[loop_ptr].loop_label);
 824             }
 825 #endif
 826             loop_ptr--;
 827         }
 828 #ifdef DEBUGGING
 829         if (debug & 4) {
 830             deb("(Found label #%d %s)\n",loop_ptr,
 831                 loop_stack[loop_ptr].loop_label);
 832         }
 833 #endif
 834         if (loop_ptr < 0) {
 835             in_eval = 0;
 836             fatal("Bad label: %s", tmps);
 837         }
 838         longjmp(loop_stack[loop_ptr].loop_env, 1);
 839     }
 840     fputs(buf,stderr);
 841     (void)fflush(stderr);
 842     if (e_fp)
 843         (void)UNLINK(e_tmpname);
 844     statusvalue >>= 8;
 845     exit(errno?errno:(statusvalue?statusvalue:255));
 846 }
 847
 848 /*VARARGS1*/
 849 warn(pat,a1,a2,a3,a4)
 850 char *pat;
 851 long a1, a2, a3, a4;
 852 {
 853     mess(pat,a1,a2,a3,a4);
 854     fputs(buf,stderr);
 855 #ifdef LEAKTEST
 856 #ifdef DEBUGGING
 857     if (debug & 4096)
 858         xstat();
 859 #endif
 860 #endif
 861     (void)fflush(stderr);
 862 }
 863 #else
 864 /*VARARGS0*/
 865 mess(args)
 866 va_list args;
 867 {
 868     char *pat;
 869     char *s;
 870 #ifdef CHARVSPRINTF
 871     char *vsprintf();
 872 #else
 873     int vsprintf();
 874 #endif
 875
 876     s = buf;
 877 #ifdef lint
 878     pat = Nullch;
 879 #else
 880     pat = va_arg(args, char *);
 881 #endif
 882     (void) vsprintf(s,pat,args);
 883
 884     s += strlen(s);
 885     if (s[-1] != '\n') {
 886         if (curcmd->c_line) {
 887             (void)sprintf(s," at %s line %ld",
 888               stab_val(curcmd->c_filestab)->str_ptr, (long)curcmd->c_line);
 889             s += strlen(s);
 890         }
 891         if (last_in_stab &&
 892             stab_io(last_in_stab) &&
 893             stab_io(last_in_stab)->lines ) {
 894             (void)sprintf(s,", <%s> line %ld",
 895               last_in_stab == argvstab ? "" : last_in_stab->str_magic->str_ptr,
 896               (long)stab_io(last_in_stab)->lines);
 897             s += strlen(s);
 898         }
 899         (void)strcpy(s,".\n");
 900     }
 901 }
 902
 903 /*VARARGS0*/
 904 fatal(va_alist)
 905 va_dcl
 906 {
 907     va_list args;
 908     extern FILE *e_fp;
 909     extern char *e_tmpname;
 910     char *tmps;
 911
 912 #ifndef lint
 913     va_start(args);
 914 #else
 915     args = 0;
 916 #endif
 917     mess(args);
 918     va_end(args);
 919     if (in_eval) {
 920         str_set(stab_val(stabent("@",TRUE)),buf);
 921         tmps = "_EVAL_";
 922         while (loop_ptr >= 0 && (!loop_stack[loop_ptr].loop_label ||
 923           strNE(tmps,loop_stack[loop_ptr].loop_label) )) {
 924 #ifdef DEBUGGING
 925             if (debug & 4) {
 926                 deb("(Skipping label #%d %s)\n",loop_ptr,
 927                     loop_stack[loop_ptr].loop_label);
 928             }
 929 #endif
 930             loop_ptr--;
 931         }
 932 #ifdef DEBUGGING
 933         if (debug & 4) {
 934             deb("(Found label #%d %s)\n",loop_ptr,
 935                 loop_stack[loop_ptr].loop_label);
 936         }
 937 #endif
 938         if (loop_ptr < 0) {
 939             in_eval = 0;
 940             fatal("Bad label: %s", tmps);
 941         }
 942         longjmp(loop_stack[loop_ptr].loop_env, 1);
 943     }
 944     fputs(buf,stderr);
 945     (void)fflush(stderr);
 946     if (e_fp)
 947         (void)UNLINK(e_tmpname);
 948     statusvalue >>= 8;
 949     exit((int)(errno?errno:(statusvalue?statusvalue:255)));
 950 }
 951
 952 /*VARARGS0*/
 953 warn(va_alist)
 954 va_dcl
 955 {
 956     va_list args;
 957
 958 #ifndef lint
 959     va_start(args);
 960 #else
 961     args = 0;
 962 #endif
 963     mess(args);
 964     va_end(args);
 965
 966     fputs(buf,stderr);
 967 #ifdef LEAKTEST
 968 #ifdef DEBUGGING
 969     if (debug & 4096)
 970         xstat();
 971 #endif
 972 #endif
 973     (void)fflush(stderr);
 974 }
 975 #endif
 976
 977 static bool firstsetenv = TRUE;
 978 extern char **environ;
 979
 980 void
 981 setenv(nam,val)
 982 char *nam, *val;
 983 {
 984     register int i=envix(nam);          /* where does it go? */
 985
 986     if (!val) {
 987         while (environ[i]) {
 988             environ[i] = environ[i+1];
 989             i++;
 990         }
 991         return;
 992     }
 993     if (!environ[i]) {                  /* does not exist yet */
 994         if (firstsetenv) {              /* need we copy environment? */
 995             int j;
 996             char **tmpenv;
 997
 998             New(901,tmpenv, i+2, char*);
 999             firstsetenv = FALSE;
1000             for (j=0; j<i; j++)         /* copy environment */
1001                 tmpenv[j] = environ[j];
1002             environ = tmpenv;           /* tell exec where it is now */
1003         }
1004         else
1005             Renew(environ, i+2, char*); /* just expand it a bit */
1006         environ[i+1] = Nullch;  /* make sure it's null terminated */
1007     }
1008     New(904, environ[i], strlen(nam) + strlen(val) + 2, char);
1009                                         /* this may or may not be in */
1010                                         /* the old environ structure */
1011 #ifndef MSDOS
1012     (void)sprintf(environ[i],"%s=%s",nam,val);/* all that work just for this */
1013 #else
1014     /* MS-DOS requires environment variable names to be in uppercase */
1015     strcpy(environ[i],nam); strupr(environ[i],nam);
1016     (void)sprintf(environ[i] + strlen(nam),"=%s",val);
1017 #endif /* MSDOS */
1018 }
1019
1020 int
1021 envix(nam)
1022 char *nam;
1023 {
1024     register int i, len = strlen(nam);
1025
1026     for (i = 0; environ[i]; i++) {
1027         if (strnEQ(environ[i],nam,len) && environ[i][len] == '=')
1028             break;                      /* strnEQ must come first to avoid */
1029     }                                   /* potential SEGV's */
1030     return i;
1031 }
1032
1033 #ifdef EUNICE
1034 unlnk(f)        /* unlink all versions of a file */
1035 char *f;
1036 {
1037     int i;
1038
1039     for (i = 0; unlink(f) >= 0; i++) ;
1040     return i ? 0 : -1;
1041 }
1042 #endif
1043
1044 #ifndef MEMCPY
1045 #ifndef BCOPY
1046 char *
1047 bcopy(from,to,len)
1048 register char *from;
1049 register char *to;
1050 register int len;
1051 {
1052     char *retval = to;
1053
1054     while (len--)
1055         *to++ = *from++;
1056     return retval;
1057 }
1058 #endif
1059
1060 #ifndef BZERO
1061 char *
1062 bzero(loc,len)
1063 register char *loc;
1064 register int len;
1065 {
1066     char *retval = loc;
1067
1068     while (len--)
1069         *loc++ = 0;
1070     return retval;
1071 }
1072 #endif
1073 #endif
1074
1075 #ifdef VARARGS
1076 #ifndef VPRINTF
1077
1078 #ifdef CHARVSPRINTF
1079 char *
1080 #else
1081 int
1082 #endif
1083 vsprintf(dest, pat, args)
1084 char *dest, *pat, *args;
1085 {
1086     FILE fakebuf;
1087
1088     fakebuf._ptr = dest;
1089     fakebuf._cnt = 32767;
1090     fakebuf._flag = _IOWRT|_IOSTRG;
1091     _doprnt(pat, args, &fakebuf);       /* what a kludge */
1092     (void)putc('\0', &fakebuf);
1093 #ifdef CHARVSPRINTF
1094     return(dest);
1095 #else
1096     return 0;           /* perl doesn't use return value */
1097 #endif
1098 }
1099
1100 #ifdef DEBUGGING
1101 int
1102 vfprintf(fd, pat, args)
1103 FILE *fd;
1104 char *pat, *args;
1105 {
1106     _doprnt(pat, args, fd);
1107     return 0;           /* wrong, but perl doesn't use the return value */
1108 }
1109 #endif
1110 #endif /* VPRINTF */
1111 #endif /* VARARGS */
1112
1113 #ifdef MYSWAP
1114 #if BYTEORDER != 0x4321
1115 short
1116 my_swap(s)
1117 short s;
1118 {
1119 #if (BYTEORDER & 1) == 0
1120     short result;
1121
1122     result = ((s & 255) << 8) + ((s >> 8) & 255);
1123     return result;
1124 #else
1125     return s;
1126 #endif
1127 }
1128
1129 long
1130 htonl(l)
1131 register long l;
1132 {
1133     union {
1134         long result;
1135         char c[sizeof(long)];
1136     } u;
1137
1138 #if BYTEORDER == 0x1234
1139     u.c[0] = (l >> 24) & 255;
1140     u.c[1] = (l >> 16) & 255;
1141     u.c[2] = (l >> 8) & 255;
1142     u.c[3] = l & 255;
1143     return u.result;
1144 #else
1145 #if ((BYTEORDER - 0x1111) & 0x444) || !(BYTEORDER & 0xf)
1146     fatal("Unknown BYTEORDER\n");
1147 #else
1148     register int o;
1149     register int s;
1150
1151     for (o = BYTEORDER - 0x1111, s = 0; s < (sizeof(long)*8); o >>= 4, s += 8) {
1152         u.c[o & 0xf] = (l >> s) & 255;
1153     }
1154     return u.result;
1155 #endif
1156 #endif
1157 }
1158
1159 long
1160 ntohl(l)
1161 register long l;
1162 {
1163     union {
1164         long l;
1165         char c[sizeof(long)];
1166     } u;
1167
1168 #if BYTEORDER == 0x1234
1169     u.c[0] = (l >> 24) & 255;
1170     u.c[1] = (l >> 16) & 255;
1171     u.c[2] = (l >> 8) & 255;
1172     u.c[3] = l & 255;
1173     return u.l;
1174 #else
1175 #if ((BYTEORDER - 0x1111) & 0x444) || !(BYTEORDER & 0xf)
1176     fatal("Unknown BYTEORDER\n");
1177 #else
1178     register int o;
1179     register int s;
1180
1181     u.l = l;
1182     l = 0;
1183     for (o = BYTEORDER - 0x1111, s = 0; s < (sizeof(long)*8); o >>= 4, s += 8) {
1184         l |= (u.c[o & 0xf] & 255) << s;
1185     }
1186     return l;
1187 #endif
1188 #endif
1189 }
1190
1191 #endif /* BYTEORDER != 0x4321 */
1192 #endif /* HTONS */
1193
1194 #ifndef MSDOS
1195 FILE *
1196 mypopen(cmd,mode)
1197 char    *cmd;
1198 char    *mode;
1199 {
1200     int p[2];
1201     register int this, that;
1202     register int pid;
1203     STR *str;
1204     int doexec = strNE(cmd,"-");
1205
1206     if (pipe(p) < 0)
1207         return Nullfp;
1208     this = (*mode == 'w');
1209     that = !this;
1210     while ((pid = (doexec?vfork():fork())) < 0) {
1211         if (errno != EAGAIN) {
1212             close(p[this]);
1213             if (!doexec)
1214                 fatal("Can't fork");
1215             return Nullfp;
1216         }
1217         sleep(5);
1218     }
1219     if (pid == 0) {
1220 #define THIS that
1221 #define THAT this
1222         close(p[THAT]);
1223         if (p[THIS] != (*mode == 'r')) {
1224             dup2(p[THIS], *mode == 'r');
1225             close(p[THIS]);
1226         }
1227         if (doexec) {
1228 #if !defined(FCNTL) || !defined(F_SETFD)
1229             int fd;
1230
1231 #ifndef NOFILE
1232 #define NOFILE 20
1233 #endif
1234             for (fd = 3; fd < NOFILE; fd++)
1235                 close(fd);
1236 #endif
1237             do_exec(cmd);       /* may or may not use the shell */
1238             _exit(1);
1239         }
1240         if (tmpstab = stabent("$",allstabs))
1241             str_numset(STAB_STR(tmpstab),(double)getpid());
1242         forkprocess = 0;
1243         hclear(pidstatus);      /* we have no children */
1244         return Nullfp;
1245 #undef THIS
1246 #undef THAT
1247     }
1248     do_execfree();      /* free any memory malloced by child on vfork */
1249     close(p[that]);
1250     if (p[that] < p[this]) {
1251         dup2(p[this], p[that]);
1252         close(p[this]);
1253         p[this] = p[that];
1254     }
1255     str = afetch(fdpid,p[this],TRUE);
1256     str->str_u.str_useful = pid;
1257     forkprocess = pid;
1258     return fdopen(p[this], mode);
1259 }
1260 #endif /* !MSDOS */
1261
1262 #ifdef NOTDEF
1263 dumpfds(s)
1264 char *s;
1265 {
1266     int fd;
1267     struct stat tmpstatbuf;
1268
1269     fprintf(stderr,"%s", s);
1270     for (fd = 0; fd < 32; fd++) {
1271         if (fstat(fd,&tmpstatbuf) >= 0)
1272             fprintf(stderr," %d",fd);
1273     }
1274     fprintf(stderr,"\n");
1275 }
1276 #endif
1277
1278 #ifndef DUP2
1279 dup2(oldfd,newfd)
1280 int oldfd;
1281 int newfd;
1282 {
1283 #if defined(FCNTL) && defined(F_DUPFD)
1284     close(newfd);
1285     fcntl(oldfd, F_DUPFD, newfd);
1286 #else
1287     int fdtmp[20];
1288     int fdx = 0;
1289     int fd;
1290
1291     close(newfd);
1292     while ((fd = dup(oldfd)) != newfd)  /* good enough for low fd's */
1293         fdtmp[fdx++] = fd;
1294     while (fdx > 0)
1295         close(fdtmp[--fdx]);
1296 #endif
1297 }
1298 #endif
1299
1300 #ifndef MSDOS
1301 int
1302 mypclose(ptr)
1303 FILE *ptr;
1304 {
1305 #ifdef VOIDSIG
1306     void (*hstat)(), (*istat)(), (*qstat)();
1307 #else
1308     int (*hstat)(), (*istat)(), (*qstat)();
1309 #endif
1310     int status;
1311     STR *str;
1312     int pid;
1313
1314     str = afetch(fdpid,fileno(ptr),TRUE);
1315     astore(fdpid,fileno(ptr),Nullstr);
1316     fclose(ptr);
1317     pid = (int)str->str_u.str_useful;
1318     hstat = signal(SIGHUP, SIG_IGN);
1319     istat = signal(SIGINT, SIG_IGN);
1320     qstat = signal(SIGQUIT, SIG_IGN);
1321     pid = wait4pid(pid, &status, 0);
1322     signal(SIGHUP, hstat);
1323     signal(SIGINT, istat);
1324     signal(SIGQUIT, qstat);
1325     return(pid < 0 ? pid : status);
1326 }
1327
1328 int
1329 wait4pid(pid,statusp,flags)
1330 int pid;
1331 int *statusp;
1332 int flags;
1333 {
1334     int result;
1335     STR *str;
1336     char spid[16];
1337
1338     if (!pid)
1339         return -1;
1340 #ifdef WAIT4
1341     return wait4(pid,statusp,flags,Null(struct rusage *));
1342 #else
1343 #ifdef WAITPID
1344     return waitpid(pid,statusp,flags);
1345 #else
1346     if (pid > 0) {
1347         sprintf(spid, "%d", pid);
1348         str = hfetch(pidstatus,spid,strlen(spid),FALSE);
1349         if (str != &str_undef) {
1350             *statusp = (int)str->str_u.str_useful;
1351             hdelete(pidstatus,spid,strlen(spid));
1352             return pid;
1353         }
1354     }
1355     else {
1356         HENT *entry;
1357
1358         hiterinit(pidstatus);
1359         if (entry = hiternext(pidstatus)) {
1360             pid = atoi(hiterkey(entry,statusp));
1361             str = hiterval(entry);
1362             *statusp = (int)str->str_u.str_useful;
1363             sprintf(spid, "%d", pid);
1364             hdelete(pidstatus,spid,strlen(spid));
1365             return pid;
1366         }
1367     }
1368     if (flags)
1369         fatal("Can't do waitpid with flags");
1370     else {
1371         int result;
1372         register int count;
1373         register STR *str;
1374
1375         while ((result = wait(statusp)) != pid && pid > 0 && result >= 0)
1376             pidgone(result,*statusp);
1377         if (result < 0)
1378             *statusp = -1;
1379     }
1380     return result;
1381 #endif
1382 #endif
1383 }
1384 #endif /* !MSDOS */
1385
1386 pidgone(pid,status)
1387 int pid;
1388 int status;
1389 {
1390 #if defined(WAIT4) || defined(WAITPID)
1391 #else
1392     register STR *str;
1393     char spid[16];
1394
1395     sprintf(spid, "%d", pid);
1396     str = hfetch(pidstatus,spid,strlen(spid),TRUE);
1397     str->str_u.str_useful = status;
1398 #endif
1399     return;
1400 }
1401
1402 #ifndef MEMCMP
1403 memcmp(s1,s2,len)
1404 register unsigned char *s1;
1405 register unsigned char *s2;
1406 register int len;
1407 {
1408     register int tmp;
1409
1410     while (len--) {
1411         if (tmp = *s1++ - *s2++)
1412             return tmp;
1413     }
1414     return 0;
1415 }
1416 #endif /* MEMCMP */
1417
1418 void
1419 repeatcpy(to,from,len,count)
1420 register char *to;
1421 register char *from;
1422 int len;
1423 register int count;
1424 {
1425     register int todo;
1426     register char *frombase = from;
1427
1428     if (len == 1) {
1429         todo = *from;
1430         while (count-- > 0)
1431             *to++ = todo;
1432         return;
1433     }
1434     while (count-- > 0) {
1435         for (todo = len; todo > 0; todo--) {
1436             *to++ = *from++;
1437         }
1438         from = frombase;
1439     }
1440 }
1441
1442 #ifndef CASTNEGFLOAT
1443 unsigned long
1444 castulong(f)
1445 double f;
1446 {
1447     long along;
1448
1449     if (f >= 0.0)
1450         return (unsigned long)f;
1451     along = (long)f;
1452     return (unsigned long)along;
1453 }
1454 #endif
1455
1456 #ifndef RENAME
1457 int
1458 same_dirent(a,b)
1459 char *a;
1460 char *b;
1461 {
1462     char *fa = rindex(a,'/');
1463     char *fb = rindex(b,'/');
1464     struct stat tmpstatbuf1;
1465     struct stat tmpstatbuf2;
1466 #ifndef MAXPATHLEN
1467 #define MAXPATHLEN 1024
1468 #endif
1469     char tmpbuf[MAXPATHLEN+1];
1470
1471     if (fa)
1472         fa++;
1473     else
1474         fa = a;
1475     if (fb)
1476         fb++;
1477     else
1478         fb = b;
1479     if (strNE(a,b))
1480         return FALSE;
1481     if (fa == a)
1482         strcpy(tmpbuf,".");
1483     else
1484         strncpy(tmpbuf, a, fa - a);
1485     if (stat(tmpbuf, &tmpstatbuf1) < 0)
1486         return FALSE;
1487     if (fb == b)
1488         strcpy(tmpbuf,".");
1489     else
1490         strncpy(tmpbuf, b, fb - b);
1491     if (stat(tmpbuf, &tmpstatbuf2) < 0)
1492         return FALSE;
1493     return tmpstatbuf1.st_dev == tmpstatbuf2.st_dev &&
1494            tmpstatbuf1.st_ino == tmpstatbuf2.st_ino;
1495 }
1496 #endif /* !RENAME */