str.c.orig

   1 /* $RCSfile: str.c,v $$Revision: 4.0.1.6 $$Date: 92/06/11 21:14:21 $
   2  *
   3  *    Copyright (c) 1991, Larry Wall
   4  *
   5  *    You may distribute under the terms of either the GNU General Public
   6  *    License or the Artistic License, as specified in the README file.
   7  *
   8  * $Log:        str.c,v $
   9  * Revision 4.0.1.6  92/06/11  21:14:21  lwall
  10  * patch34: quotes containing subscripts containing variables didn't parse right
  11  *
  12  * Revision 4.0.1.5  92/06/08  15:40:43  lwall
  13  * patch20: removed implicit int declarations on functions
  14  * patch20: Perl now distinguishes overlapped copies from non-overlapped
  15  * patch20: paragraph mode now skips extra newlines automatically
  16  * patch20: fixed memory leak in doube-quote interpretation
  17  * patch20: made /\$$foo/ look for literal '$foo'
  18  * patch20: "$var{$foo'bar}" didn't scan subscript correctly
  19  * patch20: a splice on non-existent array elements could dump core
  20  * patch20: running taintperl explicitly now does checks even if $< == $>
  21  *
  22  * Revision 4.0.1.4  91/11/05  18:40:51  lwall
  23  * patch11: $foo .= <BAR> could overrun malloced memory
  24  * patch11: \$ didn't always make it through double-quoter to regexp routines
  25  * patch11: prepared for ctype implementations that don't define isascii()
  26  *
  27  * Revision 4.0.1.3  91/06/10  01:27:54  lwall
  28  * patch10: $) and $| incorrectly handled in run-time patterns
  29  *
  30  * Revision 4.0.1.2  91/06/07  11:58:13  lwall
  31  * patch4: new copyright notice
  32  * patch4: taint check on undefined string could cause core dump
  33  *
  34  * Revision 4.0.1.1  91/04/12  09:15:30  lwall
  35  * patch1: fixed undefined environ problem
  36  * patch1: substr($ENV{"PATH"},0,0) = "/foo:" didn't modify environment
  37  * patch1: $foo .= <BAR> could cause core dump for certain lengths of $foo
  38  *
  39  * Revision 4.0  91/03/20  01:39:55  lwall
  40  * 4.0 baseline.
  41  *
  42  */
  43
  44 #include "EXTERN.h"
  45 #include "perl.h"
  46 #include "perly.h"
  47
  48 static void ucase();
  49 static void lcase();
  50
  51 #ifndef str_get
  52 char *
  53 str_get(str)
  54 STR *str;
  55 {
  56 #ifdef TAINT
  57     tainted |= str->str_tainted;
  58 #endif
  59     return str->str_pok ? str->str_ptr : str_2ptr(str);
  60 }
  61 #endif
  62
  63 /* dlb ... guess we have a "crippled cc".
  64  * dlb the following functions are usually macros.
  65  */
  66 #ifndef str_true
  67 int
  68 str_true(Str)
  69 STR *Str;
  70 {
  71         if (Str->str_pok) {
  72             if (*Str->str_ptr > '0' ||
  73               Str->str_cur > 1 ||
  74               (Str->str_cur && *Str->str_ptr != '0'))
  75                 return 1;
  76             return 0;
  77         }
  78         if (Str->str_nok)
  79                 return (Str->str_u.str_nval != 0.0);
  80         return 0;
  81 }
  82 #endif /* str_true */
  83
  84 #ifndef str_gnum
  85 double str_gnum(Str)
  86 STR *Str;
  87 {
  88 #ifdef TAINT
  89         tainted |= Str->str_tainted;
  90 #endif /* TAINT*/
  91         if (Str->str_nok)
  92                 return Str->str_u.str_nval;
  93         return str_2num(Str);
  94 }
  95 #endif /* str_gnum */
  96 /* dlb ... end of crutch */
  97
  98 char *
  99 str_grow(str,newlen)
 100 register STR *str;
 101 #ifndef DOSISH
 102 register int newlen;
 103 #else
 104 unsigned long newlen;
 105 #endif
 106 {
 107     register char *s = str->str_ptr;
 108
 109 #ifdef MSDOS
 110     if (newlen >= 0x10000) {
 111         fprintf(stderr, "Allocation too large: %lx\n", newlen);
 112         exit(1);
 113     }
 114 #endif /* MSDOS */
 115     if (str->str_state == SS_INCR) {            /* data before str_ptr? */
 116         str->str_len += str->str_u.str_useful;
 117         str->str_ptr -= str->str_u.str_useful;
 118         str->str_u.str_useful = 0L;
 119         Move(s, str->str_ptr, str->str_cur+1, char);
 120         s = str->str_ptr;
 121         str->str_state = SS_NORM;                       /* normal again */
 122         if (newlen > str->str_len)
 123             newlen += 10 * (newlen - str->str_cur); /* avoid copy each time */
 124     }
 125     if (newlen > str->str_len) {                /* need more room? */
 126         if (str->str_len)
 127             Renew(s,newlen,char);
 128         else
 129             New(703,s,newlen,char);
 130         str->str_ptr = s;
 131         str->str_len = newlen;
 132     }
 133     return s;
 134 }
 135
 136 void
 137 str_numset(str,num)
 138 register STR *str;
 139 double num;
 140 {
 141     if (str->str_pok) {
 142         str->str_pok = 0;       /* invalidate pointer */
 143         if (str->str_state == SS_INCR)
 144             Str_Grow(str,0);
 145     }
 146     str->str_u.str_nval = num;
 147     str->str_state = SS_NORM;
 148     str->str_nok = 1;                   /* validate number */
 149 #ifdef TAINT
 150     str->str_tainted = tainted;
 151 #endif
 152 }
 153
 154 char *
 155 str_2ptr(str)
 156 register STR *str;
 157 {
 158     register char *s;
 159     int olderrno;
 160
 161     if (!str)
 162         return "";
 163     if (str->str_nok) {
 164         STR_GROW(str, 30);
 165         s = str->str_ptr;
 166         olderrno = errno;       /* some Xenix systems wipe out errno here */
 167 #if defined(scs) && defined(ns32000)
 168         gcvt(str->str_u.str_nval,20,s);
 169 #else
 170 #ifdef apollo
 171         if (str->str_u.str_nval == 0.0)
 172             (void)strcpy(s,"0");
 173         else
 174 #endif /*apollo*/
 175         (void)sprintf(s,"%.20g",str->str_u.str_nval);
 176 #endif /*scs*/
 177         errno = olderrno;
 178         while (*s) s++;
 179 #ifdef hcx
 180         if (s[-1] == '.')
 181             s--;
 182 #endif
 183     }
 184     else {
 185         if (str == &str_undef)
 186             return No;
 187         if (dowarn)
 188             warn("Use of uninitialized variable");
 189         STR_GROW(str, 30);
 190         s = str->str_ptr;
 191     }
 192     *s = '\0';
 193     str->str_cur = s - str->str_ptr;
 194     str->str_pok = 1;
 195 #ifdef DEBUGGING
 196     if (debug & 32)
 197         fprintf(stderr,"0x%lx ptr(%s)\n",str,str->str_ptr);
 198 #endif
 199     return str->str_ptr;
 200 }
 201
 202 double
 203 str_2num(str)
 204 register STR *str;
 205 {
 206     if (!str)
 207         return 0.0;
 208     if (str->str_state == SS_INCR)
 209         Str_Grow(str,0);       /* just force copy down */
 210     str->str_state = SS_NORM;
 211     if (str->str_len && str->str_pok)
 212         str->str_u.str_nval = atof(str->str_ptr);
 213     else  {
 214         if (str == &str_undef)
 215             return 0.0;
 216         if (dowarn)
 217             warn("Use of uninitialized variable");
 218         str->str_u.str_nval = 0.0;
 219     }
 220     str->str_nok = 1;
 221 #ifdef DEBUGGING
 222     if (debug & 32)
 223         fprintf(stderr,"0x%lx num(%g)\n",str,str->str_u.str_nval);
 224 #endif
 225     return str->str_u.str_nval;
 226 }
 227
 228 /* Note: str_sset() should not be called with a source string that needs
 229  * be reused, since it may destroy the source string if it is marked
 230  * as temporary.
 231  */
 232
 233 void
 234 str_sset(dstr,sstr)
 235 STR *dstr;
 236 register STR *sstr;
 237 {
 238 #ifdef TAINT
 239     if (sstr)
 240         tainted |= sstr->str_tainted;
 241 #endif
 242     if (sstr == dstr || dstr == &str_undef)
 243         return;
 244     if (!sstr)
 245         dstr->str_pok = dstr->str_nok = 0;
 246     else if (sstr->str_pok) {
 247
 248         /*
 249          * Check to see if we can just swipe the string.  If so, it's a
 250          * possible small lose on short strings, but a big win on long ones.
 251          * It might even be a win on short strings if dstr->str_ptr
 252          * has to be allocated and sstr->str_ptr has to be freed.
 253          */
 254
 255         if (sstr->str_pok & SP_TEMP) {          /* slated for free anyway? */
 256             if (dstr->str_ptr) {
 257                 if (dstr->str_state == SS_INCR)
 258                     dstr->str_ptr -= dstr->str_u.str_useful;
 259                 Safefree(dstr->str_ptr);
 260             }
 261             dstr->str_ptr = sstr->str_ptr;
 262             dstr->str_len = sstr->str_len;
 263             dstr->str_cur = sstr->str_cur;
 264             dstr->str_state = sstr->str_state;
 265             dstr->str_pok = sstr->str_pok & ~SP_TEMP;
 266 #ifdef TAINT
 267             dstr->str_tainted = sstr->str_tainted;
 268 #endif
 269             sstr->str_ptr = Nullch;
 270             sstr->str_len = 0;
 271             sstr->str_pok = 0;                  /* wipe out any weird flags */
 272             sstr->str_state = 0;                /* so sstr frees uneventfully */
 273         }
 274         else {                                  /* have to copy actual string */
 275             if (dstr->str_ptr) {
 276                 if (dstr->str_state == SS_INCR) {
 277                         Str_Grow(dstr,0);
 278                 }
 279             }
 280             str_nset(dstr,sstr->str_ptr,sstr->str_cur);
 281         }
 282         /*SUPPRESS 560*/
 283         if (dstr->str_nok = sstr->str_nok)
 284             dstr->str_u.str_nval = sstr->str_u.str_nval;
 285         else {
 286 #ifdef STRUCTCOPY
 287             dstr->str_u = sstr->str_u;
 288 #else
 289             dstr->str_u.str_nval = sstr->str_u.str_nval;
 290 #endif
 291             if (dstr->str_cur == sizeof(STBP)) {
 292                 char *tmps = dstr->str_ptr;
 293
 294                 if (*tmps == 'S' && bcmp(tmps,"StB",4) == 0) {
 295                     if (dstr->str_magic && dstr->str_magic->str_rare == 'X') {
 296                         str_free(dstr->str_magic);
 297                         dstr->str_magic = Nullstr;
 298                     }
 299                     if (!dstr->str_magic) {
 300                         dstr->str_magic = str_smake(sstr->str_magic);
 301                         dstr->str_magic->str_rare = 'X';
 302                     }
 303                 }
 304             }
 305         }
 306     }
 307     else if (sstr->str_nok)
 308         str_numset(dstr,sstr->str_u.str_nval);
 309     else {
 310         if (dstr->str_state == SS_INCR)
 311             Str_Grow(dstr,0);       /* just force copy down */
 312
 313 #ifdef STRUCTCOPY
 314         dstr->str_u = sstr->str_u;
 315 #else
 316         dstr->str_u.str_nval = sstr->str_u.str_nval;
 317 #endif
 318         dstr->str_pok = dstr->str_nok = 0;
 319     }
 320 }
 321
 322 void
 323 str_nset(str,ptr,len)
 324 register STR *str;
 325 register char *ptr;
 326 register STRLEN len;
 327 {
 328     if (str == &str_undef)
 329         return;
 330     STR_GROW(str, len + 1);
 331     if (ptr)
 332         Move(ptr,str->str_ptr,len,char);
 333     str->str_cur = len;
 334     *(str->str_ptr+str->str_cur) = '\0';
 335     str->str_nok = 0;           /* invalidate number */
 336     str->str_pok = 1;           /* validate pointer */
 337 #ifdef TAINT
 338     str->str_tainted = tainted;
 339 #endif
 340 }
 341
 342 void
 343 str_set(str,ptr)
 344 register STR *str;
 345 register char *ptr;
 346 {
 347     register STRLEN len;
 348
 349     if (str == &str_undef)
 350         return;
 351     if (!ptr)
 352         ptr = "";
 353     len = strlen(ptr);
 354     STR_GROW(str, len + 1);
 355     Move(ptr,str->str_ptr,len+1,char);
 356     str->str_cur = len;
 357     str->str_nok = 0;           /* invalidate number */
 358     str->str_pok = 1;           /* validate pointer */
 359 #ifdef TAINT
 360     str->str_tainted = tainted;
 361 #endif
 362 }
 363
 364 void
 365 str_chop(str,ptr)       /* like set but assuming ptr is in str */
 366 register STR *str;
 367 register char *ptr;
 368 {
 369     register STRLEN delta;
 370
 371     if (!ptr || !(str->str_pok))
 372         return;
 373     delta = ptr - str->str_ptr;
 374     str->str_len -= delta;
 375     str->str_cur -= delta;
 376     str->str_ptr += delta;
 377     if (str->str_state == SS_INCR)
 378         str->str_u.str_useful += delta;
 379     else {
 380         str->str_u.str_useful = delta;
 381         str->str_state = SS_INCR;
 382     }
 383     str->str_nok = 0;           /* invalidate number */
 384     str->str_pok = 1;           /* validate pointer (and unstudy str) */
 385 }
 386
 387 void
 388 str_ncat(str,ptr,len)
 389 register STR *str;
 390 register char *ptr;
 391 register STRLEN len;
 392 {
 393     if (str == &str_undef)
 394         return;
 395     if (!(str->str_pok))
 396         (void)str_2ptr(str);
 397     STR_GROW(str, str->str_cur + len + 1);
 398     Move(ptr,str->str_ptr+str->str_cur,len,char);
 399     str->str_cur += len;
 400     *(str->str_ptr+str->str_cur) = '\0';
 401     str->str_nok = 0;           /* invalidate number */
 402     str->str_pok = 1;           /* validate pointer */
 403 #ifdef TAINT
 404     str->str_tainted |= tainted;
 405 #endif
 406 }
 407
 408 void
 409 str_scat(dstr,sstr)
 410 STR *dstr;
 411 register STR *sstr;
 412 {
 413     if (!sstr)
 414         return;
 415 #ifdef TAINT
 416     tainted |= sstr->str_tainted;
 417 #endif
 418     if (!(sstr->str_pok))
 419         (void)str_2ptr(sstr);
 420     if (sstr)
 421         str_ncat(dstr,sstr->str_ptr,sstr->str_cur);
 422 }
 423
 424 void
 425 str_cat(str,ptr)
 426 register STR *str;
 427 register char *ptr;
 428 {
 429     register STRLEN len;
 430
 431     if (str == &str_undef)
 432         return;
 433     if (!ptr)
 434         return;
 435     if (!(str->str_pok))
 436         (void)str_2ptr(str);
 437     len = strlen(ptr);
 438     STR_GROW(str, str->str_cur + len + 1);
 439     Move(ptr,str->str_ptr+str->str_cur,len+1,char);
 440     str->str_cur += len;
 441     str->str_nok = 0;           /* invalidate number */
 442     str->str_pok = 1;           /* validate pointer */
 443 #ifdef TAINT
 444     str->str_tainted |= tainted;
 445 #endif
 446 }
 447
 448 char *
 449 str_append_till(str,from,fromend,delim,keeplist)
 450 register STR *str;
 451 register char *from;
 452 register char *fromend;
 453 register int delim;
 454 char *keeplist;
 455 {
 456     register char *to;
 457     register STRLEN len;
 458
 459     if (str == &str_undef)
 460         return Nullch;
 461     if (!from)
 462         return Nullch;
 463     len = fromend - from;
 464     STR_GROW(str, str->str_cur + len + 1);
 465     str->str_nok = 0;           /* invalidate number */
 466     str->str_pok = 1;           /* validate pointer */
 467     to = str->str_ptr+str->str_cur;
 468     for (; from < fromend; from++,to++) {
 469         if (*from == '\\' && from+1 < fromend && delim != '\\') {
 470             if (!keeplist) {
 471                 if (from[1] == delim || from[1] == '\\')
 472                     from++;
 473                 else
 474                     *to++ = *from++;
 475             }
 476             else if (from[1] && index(keeplist,from[1]))
 477                 *to++ = *from++;
 478             else
 479                 from++;
 480         }
 481         else if (*from == delim)
 482             break;
 483         *to = *from;
 484     }
 485     *to = '\0';
 486     str->str_cur = to - str->str_ptr;
 487     return from;
 488 }
 489
 490 STR *
 491 #ifdef LEAKTEST
 492 str_new(x,len)
 493 int x;
 494 #else
 495 str_new(len)
 496 #endif
 497 STRLEN len;
 498 {
 499     register STR *str;
 500
 501     if (freestrroot) {
 502         str = freestrroot;
 503         freestrroot = str->str_magic;
 504         str->str_magic = Nullstr;
 505         str->str_state = SS_NORM;
 506     }
 507     else {
 508         Newz(700+x,str,1,STR);
 509     }
 510     if (len)
 511         STR_GROW(str, len + 1);
 512     return str;
 513 }
 514
 515 void
 516 str_magic(str, stab, how, name, namlen)
 517 register STR *str;
 518 STAB *stab;
 519 int how;
 520 char *name;
 521 STRLEN namlen;
 522 {
 523     if (str == &str_undef || str->str_magic)
 524         return;
 525     str->str_magic = Str_new(75,namlen);
 526     str = str->str_magic;
 527     str->str_u.str_stab = stab;
 528     str->str_rare = how;
 529     if (name)
 530         str_nset(str,name,namlen);
 531 }
 532
 533 void
 534 str_insert(bigstr,offset,len,little,littlelen)
 535 STR *bigstr;
 536 STRLEN offset;
 537 STRLEN len;
 538 char *little;
 539 STRLEN littlelen;
 540 {
 541     register char *big;
 542     register char *mid;
 543     register char *midend;
 544     register char *bigend;
 545     register int i;
 546
 547     if (bigstr == &str_undef)
 548         return;
 549     bigstr->str_nok = 0;
 550     bigstr->str_pok = SP_VALID; /* disable possible screamer */
 551
 552     i = littlelen - len;
 553     if (i > 0) {                        /* string might grow */
 554         STR_GROW(bigstr, bigstr->str_cur + i + 1);
 555         big = bigstr->str_ptr;
 556         mid = big + offset + len;
 557         midend = bigend = big + bigstr->str_cur;
 558         bigend += i;
 559         *bigend = '\0';
 560         while (midend > mid)            /* shove everything down */
 561             *--bigend = *--midend;
 562         Move(little,big+offset,littlelen,char);
 563         bigstr->str_cur += i;
 564         STABSET(bigstr);
 565         return;
 566     }
 567     else if (i == 0) {
 568         Move(little,bigstr->str_ptr+offset,len,char);
 569         STABSET(bigstr);
 570         return;
 571     }
 572
 573     big = bigstr->str_ptr;
 574     mid = big + offset;
 575     midend = mid + len;
 576     bigend = big + bigstr->str_cur;
 577
 578     if (midend > bigend)
 579         fatal("panic: str_insert");
 580
 581     if (mid - big > bigend - midend) {  /* faster to shorten from end */
 582         if (littlelen) {
 583             Move(little, mid, littlelen,char);
 584             mid += littlelen;
 585         }
 586         i = bigend - midend;
 587         if (i > 0) {
 588             Move(midend, mid, i,char);
 589             mid += i;
 590         }
 591         *mid = '\0';
 592         bigstr->str_cur = mid - big;
 593     }
 594     /*SUPPRESS 560*/
 595     else if (i = mid - big) {   /* faster from front */
 596         midend -= littlelen;
 597         mid = midend;
 598         str_chop(bigstr,midend-i);
 599         big += i;
 600         while (i--)
 601             *--midend = *--big;
 602         if (littlelen)
 603             Move(little, mid, littlelen,char);
 604     }
 605     else if (littlelen) {
 606         midend -= littlelen;
 607         str_chop(bigstr,midend);
 608         Move(little,midend,littlelen,char);
 609     }
 610     else {
 611         str_chop(bigstr,midend);
 612     }
 613     STABSET(bigstr);
 614 }
 615
 616 /* make str point to what nstr did */
 617
 618 void
 619 str_replace(str,nstr)
 620 register STR *str;
 621 register STR *nstr;
 622 {
 623     if (str == &str_undef)
 624         return;
 625     if (str->str_state == SS_INCR)
 626         Str_Grow(str,0);        /* just force copy down */
 627     if (nstr->str_state == SS_INCR)
 628         Str_Grow(nstr,0);
 629     if (str->str_ptr)
 630         Safefree(str->str_ptr);
 631     str->str_ptr = nstr->str_ptr;
 632     str->str_len = nstr->str_len;
 633     str->str_cur = nstr->str_cur;
 634     str->str_pok = nstr->str_pok;
 635     str->str_nok = nstr->str_nok;
 636 #ifdef STRUCTCOPY
 637     str->str_u = nstr->str_u;
 638 #else
 639     str->str_u.str_nval = nstr->str_u.str_nval;
 640 #endif
 641 #ifdef TAINT
 642     str->str_tainted = nstr->str_tainted;
 643 #endif
 644     if (nstr->str_magic)
 645         str_free(nstr->str_magic);
 646     Safefree(nstr);
 647 }
 648
 649 void
 650 str_free(str)
 651 register STR *str;
 652 {
 653     if (!str || str == &str_undef)
 654         return;
 655     if (str->str_state) {
 656         if (str->str_state == SS_FREE)  /* already freed */
 657             return;
 658         if (str->str_state == SS_INCR && !(str->str_pok & 2)) {
 659             str->str_ptr -= str->str_u.str_useful;
 660             str->str_len += str->str_u.str_useful;
 661         }
 662     }
 663     if (str->str_magic)
 664         str_free(str->str_magic);
 665     str->str_magic = freestrroot;
 666 #ifdef LEAKTEST
 667     if (str->str_len) {
 668         Safefree(str->str_ptr);
 669         str->str_ptr = Nullch;
 670     }
 671     if ((str->str_pok & SP_INTRP) && str->str_u.str_args)
 672         arg_free(str->str_u.str_args);
 673     Safefree(str);
 674 #else /* LEAKTEST */
 675     if (str->str_len) {
 676         if (str->str_len > 127) {       /* next user not likely to want more */
 677             Safefree(str->str_ptr);     /* so give it back to malloc */
 678             str->str_ptr = Nullch;
 679             str->str_len = 0;
 680         }
 681         else
 682             str->str_ptr[0] = '\0';
 683     }
 684     if ((str->str_pok & SP_INTRP) && str->str_u.str_args)
 685         arg_free(str->str_u.str_args);
 686     str->str_cur = 0;
 687     str->str_nok = 0;
 688     str->str_pok = 0;
 689     str->str_state = SS_FREE;
 690 #ifdef TAINT
 691     str->str_tainted = 0;
 692 #endif
 693     freestrroot = str;
 694 #endif /* LEAKTEST */
 695 }
 696
 697 STRLEN
 698 str_len(str)
 699 register STR *str;
 700 {
 701     if (!str)
 702         return 0;
 703     if (!(str->str_pok))
 704         (void)str_2ptr(str);
 705     if (str->str_ptr)
 706         return str->str_cur;
 707     else
 708         return 0;
 709 }
 710
 711 int
 712 str_eq(str1,str2)
 713 register STR *str1;
 714 register STR *str2;
 715 {
 716     if (!str1 || str1 == &str_undef)
 717         return (str2 == Nullstr || str2 == &str_undef || !str2->str_cur);
 718     if (!str2 || str2 == &str_undef)
 719         return !str1->str_cur;
 720
 721     if (!str1->str_pok)
 722         (void)str_2ptr(str1);
 723     if (!str2->str_pok)
 724         (void)str_2ptr(str2);
 725
 726     if (str1->str_cur != str2->str_cur)
 727         return 0;
 728
 729     return !bcmp(str1->str_ptr, str2->str_ptr, str1->str_cur);
 730 }
 731
 732 int
 733 str_cmp(str1,str2)
 734 register STR *str1;
 735 register STR *str2;
 736 {
 737     int retval;
 738
 739     if (!str1 || str1 == &str_undef)
 740         return (str2 == Nullstr || str2 == &str_undef || !str2->str_cur)?0:-1;
 741     if (!str2 || str2 == &str_undef)
 742         return str1->str_cur != 0;
 743
 744     if (!str1->str_pok)
 745         (void)str_2ptr(str1);
 746     if (!str2->str_pok)
 747         (void)str_2ptr(str2);
 748
 749     if (str1->str_cur < str2->str_cur) {
 750         /*SUPPRESS 560*/
 751         if (retval = memcmp(str1->str_ptr, str2->str_ptr, str1->str_cur))
 752             return retval < 0 ? -1 : 1;
 753         else
 754             return -1;
 755     }
 756     /*SUPPRESS 560*/
 757     else if (retval = memcmp(str1->str_ptr, str2->str_ptr, str2->str_cur))
 758         return retval < 0 ? -1 : 1;
 759     else if (str1->str_cur == str2->str_cur)
 760         return 0;
 761     else
 762         return 1;
 763 }
 764
 765 char *
 766 str_gets(str,fp,append)
 767 register STR *str;
 768 register FILE *fp;
 769 int append;
 770 {
 771     register char *bp;          /* we're going to steal some values */
 772     register int cnt;           /*  from the stdio struct and put EVERYTHING */
 773     register STDCHAR *ptr;      /*   in the innermost loop into registers */
 774     register int newline = rschar;/* (assuming >= 6 registers) */
 775     int i;
 776     STRLEN bpx;
 777     int shortbuffered;
 778
 779     if (str == &str_undef)
 780         return Nullch;
 781     if (rspara) {               /* have to do this both before and after */
 782         do {                    /* to make sure file boundaries work right */
 783             i = getc(fp);
 784             if (i != '\n') {
 785                 ungetc(i,fp);
 786                 break;
 787             }
 788         } while (i != EOF);
 789     }
 790 #ifdef STDSTDIO         /* Here is some breathtakingly efficient cheating */
 791     cnt = fp->_cnt;                     /* get count into register */
 792     str->str_nok = 0;                   /* invalidate number */
 793     str->str_pok = 1;                   /* validate pointer */
 794     if (str->str_len - append <= cnt + 1) { /* make sure we have the room */
 795         if (cnt > 80 && str->str_len > append) {
 796             shortbuffered = cnt - str->str_len + append + 1;
 797             cnt -= shortbuffered;
 798         }
 799         else {
 800             shortbuffered = 0;
 801             STR_GROW(str, append+cnt+2);/* (remembering cnt can be -1) */
 802         }
 803     }
 804     else
 805         shortbuffered = 0;
 806     bp = str->str_ptr + append;         /* move these two too to registers */
 807     ptr = fp->_ptr;
 808     for (;;) {
 809       screamer:
 810         while (--cnt >= 0) {                    /* this */      /* eat */
 811             if ((*bp++ = *ptr++) == newline)    /* really */    /* dust */
 812                 goto thats_all_folks;           /* screams */   /* sed :-) */
 813         }
 814
 815         if (shortbuffered) {                    /* oh well, must extend */
 816             cnt = shortbuffered;
 817             shortbuffered = 0;
 818             bpx = bp - str->str_ptr;    /* prepare for possible relocation */
 819             str->str_cur = bpx;
 820             STR_GROW(str, str->str_len + append + cnt + 2);
 821             bp = str->str_ptr + bpx;    /* reconstitute our pointer */
 822             continue;
 823         }
 824
 825         fp->_cnt = cnt;                 /* deregisterize cnt and ptr */
 826         fp->_ptr = ptr;
 827         i = _filbuf(fp);                /* get more characters */
 828         cnt = fp->_cnt;
 829         ptr = fp->_ptr;                 /* reregisterize cnt and ptr */
 830
 831         bpx = bp - str->str_ptr;        /* prepare for possible relocation */
 832         str->str_cur = bpx;
 833         STR_GROW(str, bpx + cnt + 2);
 834         bp = str->str_ptr + bpx;        /* reconstitute our pointer */
 835
 836         if (i == newline) {             /* all done for now? */
 837             *bp++ = i;
 838             goto thats_all_folks;
 839         }
 840         else if (i == EOF)              /* all done for ever? */
 841             goto thats_really_all_folks;
 842         *bp++ = i;                      /* now go back to screaming loop */
 843     }
 844
 845 thats_all_folks:
 846     if (rslen > 1 && (bp - str->str_ptr < rslen || bcmp(bp - rslen, rs, rslen)))
 847         goto screamer;  /* go back to the fray */
 848 thats_really_all_folks:
 849     if (shortbuffered)
 850         cnt += shortbuffered;
 851     fp->_cnt = cnt;                     /* put these back or we're in trouble */
 852     fp->_ptr = ptr;
 853     *bp = '\0';
 854     str->str_cur = bp - str->str_ptr;   /* set length */
 855
 856 #else /* !STDSTDIO */   /* The big, slow, and stupid way */
 857
 858     {
 859         static char buf[8192];
 860         char * bpe = buf + sizeof(buf) - 3;
 861
 862 screamer:
 863         bp = buf;
 864         while ((i = getc(fp)) != EOF && (*bp++ = i) != newline && bp < bpe) ;
 865
 866         *bp = '\0';
 867         if (append)
 868             str_cat(str, buf);
 869         else
 870             str_set(str, buf);
 871         if (i != EOF                    /* joy */
 872             &&
 873             (i != newline
 874              ||
 875              (rslen > 1
 876               &&
 877               (str->str_cur < rslen
 878                ||
 879                bcmp(str->str_ptr + str->str_cur - rslen, rs, rslen)
 880               )
 881              )
 882             )
 883            )
 884         {
 885             append = -1;
 886             goto screamer;
 887         }
 888     }
 889
 890 #endif /* STDSTDIO */
 891
 892     if (rspara) {
 893         while (i != EOF) {
 894             i = getc(fp);
 895             if (i != '\n') {
 896                 ungetc(i,fp);
 897                 break;
 898             }
 899         }
 900     }
 901     return str->str_cur - append ? str->str_ptr : Nullch;
 902 }
 903
 904 ARG *
 905 parselist(str)
 906 STR *str;
 907 {
 908     register CMD *cmd;
 909     register ARG *arg;
 910     CMD *oldcurcmd = curcmd;
 911     int oldperldb = perldb;
 912     int retval;
 913
 914     perldb = 0;
 915     str_sset(linestr,str);
 916     in_eval++;
 917     oldoldbufptr = oldbufptr = bufptr = str_get(linestr);
 918     bufend = bufptr + linestr->str_cur;
 919     if (++loop_ptr >= loop_max) {
 920         loop_max += 128;
 921         Renew(loop_stack, loop_max, struct loop);
 922     }
 923     loop_stack[loop_ptr].loop_label = "_EVAL_";
 924     loop_stack[loop_ptr].loop_sp = 0;
 925 #ifdef DEBUGGING
 926     if (debug & 4) {
 927         deb("(Pushing label #%d _EVAL_)\n", loop_ptr);
 928     }
 929 #endif
 930     if (setjmp(loop_stack[loop_ptr].loop_env)) {
 931         in_eval--;
 932         loop_ptr--;
 933         perldb = oldperldb;
 934         fatal("%s\n",stab_val(stabent("@",TRUE))->str_ptr);
 935     }
 936 #ifdef DEBUGGING
 937     if (debug & 4) {
 938         char *tmps = loop_stack[loop_ptr].loop_label;
 939         deb("(Popping label #%d %s)\n",loop_ptr,
 940             tmps ? tmps : "" );
 941     }
 942 #endif
 943     loop_ptr--;
 944     error_count = 0;
 945     curcmd = &compiling;
 946     curcmd->c_line = oldcurcmd->c_line;
 947     retval = yyparse();
 948     curcmd = oldcurcmd;
 949     perldb = oldperldb;
 950     in_eval--;
 951     if (retval || error_count)
 952         fatal("Invalid component in string or format");
 953     cmd = eval_root;
 954     arg = cmd->c_expr;
 955     if (cmd->c_type != C_EXPR || cmd->c_next || arg->arg_type != O_LIST)
 956         fatal("panic: error in parselist %d %x %d", cmd->c_type,
 957           cmd->c_next, arg ? arg->arg_type : -1);
 958     cmd->c_expr = Nullarg;
 959     cmd_free(cmd);
 960     eval_root = Nullcmd;
 961     return arg;
 962 }
 963
 964 void
 965 intrpcompile(src)
 966 STR *src;
 967 {
 968     register char *s = str_get(src);
 969     register char *send = s + src->str_cur;
 970     register STR *str;
 971     register char *t;
 972     STR *toparse;
 973     STRLEN len;
 974     register int brackets;
 975     register char *d;
 976     STAB *stab;
 977     char *checkpoint;
 978     int sawcase = 0;
 979
 980     toparse = Str_new(76,0);
 981     str = Str_new(77,0);
 982
 983     str_nset(str,"",0);
 984     str_nset(toparse,"",0);
 985     t = s;
 986     while (s < send) {
 987         if (*s == '\\' && s[1] && index("$@[{\\]}lLuUE",s[1])) {
 988             str_ncat(str, t, s - t);
 989             ++s;
 990             if (isALPHA(*s)) {
 991                 str_ncat(str, "$c", 2);
 992                 sawcase = (*s != 'E');
 993             }
 994             else {
 995                 if (*nointrp) {         /* in a regular expression */
 996                     if (*s == '@')      /* always strip \@ */ /*SUPPRESS 530*/
 997                         ;
 998                     else                /* don't strip \\, \[, \{ etc. */
 999                         str_ncat(str,s-1,1);
1000                 }
1001                 str_ncat(str, "$b", 2);
1002             }
1003             str_ncat(str, s, 1);
1004             ++s;
1005             t = s;
1006         }
1007         else if (*s == '$' && s+1 < send && *nointrp && index(nointrp,s[1])) {
1008             str_ncat(str, t, s - t);
1009             str_ncat(str, "$b", 2);
1010             str_ncat(str, s, 2);
1011             s += 2;
1012             t = s;
1013         }
1014         else if ((*s == '@' || *s == '$') && s+1 < send) {
1015             str_ncat(str,t,s-t);
1016             t = s;
1017             if (*s == '$' && s[1] == '#' && (isALPHA(s[2]) || s[2] == '_'))
1018                 s++;
1019             s = scanident(s,send,tokenbuf);
1020             if (*t == '@' &&
1021               (!(stab = stabent(tokenbuf,FALSE)) ||
1022                  (*s == '{' ? !stab_xhash(stab) : !stab_xarray(stab)) )) {
1023                 str_ncat(str,"@",1);
1024                 s = ++t;
1025                 continue;       /* grandfather @ from old scripts */
1026             }
1027             str_ncat(str,"$a",2);
1028             str_ncat(toparse,",",1);
1029             if (t[1] != '{' && (*s == '['  || *s == '{' /* }} */ ) &&
1030               (stab = stabent(tokenbuf,FALSE)) &&
1031               ((*s == '[') ? (stab_xarray(stab) != 0) : (stab_xhash(stab) != 0)) ) {
1032                 brackets = 0;
1033                 checkpoint = s;
1034                 do {
1035                     switch (*s) {
1036                     case '[':
1037                         brackets++;
1038                         break;
1039                     case '{':
1040                         brackets++;
1041                         break;
1042                     case ']':
1043                         brackets--;
1044                         break;
1045                     case '}':
1046                         brackets--;
1047                         break;
1048                     case '$':
1049                     case '%':
1050                     case '@':
1051                     case '&':
1052                     case '*':
1053                         s = scanident(s,send,tokenbuf);
1054                         continue;
1055                     case '\'':
1056                     case '"':
1057                         /*SUPPRESS 68*/
1058                         s = cpytill(tokenbuf,s+1,send,*s,&len);
1059                         if (s >= send)
1060                             fatal("Unterminated string");
1061                         break;
1062                     }
1063                     s++;
1064                 } while (brackets > 0 && s < send);
1065                 if (s > send)
1066                     fatal("Unmatched brackets in string");
1067                 if (*nointrp) {         /* we're in a regular expression */
1068                     d = checkpoint;
1069                     if (*d == '{' && s[-1] == '}') {    /* maybe {n,m} */
1070                         ++d;
1071                         if (isDIGIT(*d)) {      /* matches /^{\d,?\d*}$/ */
1072                             if (*++d == ',')
1073                                 ++d;
1074                             while (isDIGIT(*d))
1075                                 d++;
1076                             if (d == s - 1)
1077                                 s = checkpoint;         /* Is {n,m}! Backoff! */
1078                         }
1079                     }
1080                     else if (*d == '[' && s[-1] == ']') { /* char class? */
1081                         int weight = 2;         /* let's weigh the evidence */
1082                         char seen[256];
1083                         unsigned char un_char = 0, last_un_char;
1084
1085                         Zero(seen,256,char);
1086                         *--s = '\0';
1087                         if (d[1] == '^')
1088                             weight += 150;
1089                         else if (d[1] == '$')
1090                             weight -= 3;
1091                         if (isDIGIT(d[1])) {
1092                             if (d[2]) {
1093                                 if (isDIGIT(d[2]) && !d[3])
1094                                     weight -= 10;
1095                             }
1096                             else
1097                                 weight -= 100;
1098                         }
1099                         for (d++; d < s; d++) {
1100                             last_un_char = un_char;
1101                             un_char = (unsigned char)*d;
1102                             switch (*d) {
1103                             case '&':
1104                             case '$':
1105                                 weight -= seen[un_char] * 10;
1106                                 if (isALNUM(d[1])) {
1107                                     d = scanident(d,s,tokenbuf);
1108                                     if (stabent(tokenbuf,FALSE))
1109                                         weight -= 100;
1110                                     else
1111                                         weight -= 10;
1112                                 }
1113                                 else if (*d == '$' && d[1] &&
1114                                   index("[#!%*<>()-=",d[1])) {
1115                                     if (!d[2] || /*{*/ index("])} =",d[2]))
1116                                         weight -= 10;
1117                                     else
1118                                         weight -= 1;
1119                                 }
1120                                 break;
1121                             case '\\':
1122                                 un_char = 254;
1123                                 if (d[1]) {
1124                                     if (index("wds",d[1]))
1125                                         weight += 100;
1126                                     else if (seen['\''] || seen['"'])
1127                                         weight += 1;
1128                                     else if (index("rnftb",d[1]))
1129                                         weight += 40;
1130                                     else if (isDIGIT(d[1])) {
1131                                         weight += 40;
1132                                         while (d[1] && isDIGIT(d[1]))
1133                                             d++;
1134                                     }
1135                                 }
1136                                 else
1137                                     weight += 100;
1138                                 break;
1139                             case '-':
1140                                 if (last_un_char < (unsigned char) d[1]
1141                                   || d[1] == '\\') {
1142                                     if (index("aA01! ",last_un_char))
1143                                         weight += 30;
1144                                     if (index("zZ79~",d[1]))
1145                                         weight += 30;
1146                                 }
1147                                 else
1148                                     weight -= 1;
1149                             default:
1150                                 if (isALPHA(*d) && d[1] && isALPHA(d[1])) {
1151                                     bufptr = d;
1152                                     if (yylex() != WORD)
1153                                         weight -= 150;
1154                                     d = bufptr;
1155                                 }
1156                                 if (un_char == last_un_char + 1)
1157                                     weight += 5;
1158                                 weight -= seen[un_char];
1159                                 break;
1160                             }
1161                             seen[un_char]++;
1162                         }
1163 #ifdef DEBUGGING
1164                         if (debug & 512)
1165                             fprintf(stderr,"[%s] weight %d\n",
1166                               checkpoint+1,weight);
1167 #endif
1168                         *s++ = ']';
1169                         if (weight >= 0)        /* probably a character class */
1170                             s = checkpoint;
1171                     }
1172                 }
1173             }
1174             if (*t == '@')
1175                 str_ncat(toparse, "join($\",", 8);
1176             if (t[1] == '{' && s[-1] == '}') {
1177                 str_ncat(toparse, t, 1);
1178                 str_ncat(toparse, t+2, s - t - 3);
1179             }
1180             else
1181                 str_ncat(toparse, t, s - t);
1182             if (*t == '@')
1183                 str_ncat(toparse, ")", 1);
1184             t = s;
1185         }
1186         else
1187             s++;
1188     }
1189     str_ncat(str,t,s-t);
1190     if (sawcase)
1191         str_ncat(str, "$cE", 3);
1192     if (toparse->str_ptr && *toparse->str_ptr == ',') {
1193         *toparse->str_ptr = '(';
1194         str_ncat(toparse,",$$);",5);
1195         str->str_u.str_args = parselist(toparse);
1196         str->str_u.str_args->arg_len--;         /* ignore $$ reference */
1197     }
1198     else
1199         str->str_u.str_args = Nullarg;
1200     str_free(toparse);
1201     str->str_pok |= SP_INTRP;
1202     str->str_nok = 0;
1203     str_replace(src,str);
1204 }
1205
1206 STR *
1207 interp(str,src,sp)
1208 register STR *str;
1209 STR *src;
1210 int sp;
1211 {
1212     register char *s;
1213     register char *t;
1214     register char *send;
1215     register STR **elem;
1216     int docase = 0;
1217     int l = 0;
1218     int u = 0;
1219     int L = 0;
1220     int U = 0;
1221
1222     if (str == &str_undef)
1223         return Nullstr;
1224     if (!(src->str_pok & SP_INTRP)) {
1225         int oldsave = savestack->ary_fill;
1226
1227         (void)savehptr(&curstash);
1228         curstash = curcmd->c_stash;     /* so stabent knows right package */
1229         intrpcompile(src);
1230         restorelist(oldsave);
1231     }
1232     s = src->str_ptr;           /* assumed valid since str_pok set */
1233     t = s;
1234     send = s + src->str_cur;
1235
1236     if (src->str_u.str_args) {
1237         (void)eval(src->str_u.str_args,G_ARRAY,sp);
1238         /* Assuming we have correct # of args */
1239         elem = stack->ary_array + sp;
1240     }
1241
1242     str_nset(str,"",0);
1243     while (s < send) {
1244         if (*s == '$' && s+1 < send) {
1245             if (s-t > 0)
1246                 str_ncat(str,t,s-t);
1247             switch(*++s) {
1248             default:
1249                 fatal("panic: unknown interp cookie\n");
1250                 break;
1251             case 'a':
1252                 str_scat(str,*++elem);
1253                 break;
1254             case 'b':
1255                 str_ncat(str,++s,1);
1256                 break;
1257             case 'c':
1258                 if (docase && str->str_cur >= docase) {
1259                     char *b = str->str_ptr + --docase;
1260
1261                     if (L)
1262                         lcase(b, str->str_ptr + str->str_cur);
1263                     else if (U)
1264                         ucase(b, str->str_ptr + str->str_cur);
1265
1266                     if (u)      /* note that l & u are independent of L & U */
1267                         ucase(b, b+1);
1268                     else if (l)
1269                         lcase(b, b+1);
1270                     l = u = 0;
1271                 }
1272                 docase = str->str_cur + 1;
1273                 switch (*++s) {
1274                 case 'u':
1275                     u = 1;
1276                     l = 0;
1277                     break;
1278                 case 'U':
1279                     U = 1;
1280                     L = 0;
1281                     break;
1282                 case 'l':
1283                     l = 1;
1284                     u = 0;
1285                     break;
1286                 case 'L':
1287                     L = 1;
1288                     U = 0;
1289                     break;
1290                 case 'E':
1291                     docase = L = U = l = u = 0;
1292                     break;
1293                 }
1294                 break;
1295             }
1296             t = ++s;
1297         }
1298         else
1299             s++;
1300     }
1301     if (s-t > 0)
1302         str_ncat(str,t,s-t);
1303     return str;
1304 }
1305
1306 static void
1307 ucase(s,send)
1308 register char *s;
1309 register char *send;
1310 {
1311     while (s < send) {
1312         if (isLOWER(*s))
1313             *s = toupper(*s);
1314         s++;
1315     }
1316 }
1317
1318 static void
1319 lcase(s,send)
1320 register char *s;
1321 register char *send;
1322 {
1323     while (s < send) {
1324         if (isUPPER(*s))
1325             *s = tolower(*s);
1326         s++;
1327     }
1328 }
1329
1330 void
1331 str_inc(str)
1332 register STR *str;
1333 {
1334     register char *d;
1335
1336     if (!str || str == &str_undef)
1337         return;
1338     if (str->str_nok) {
1339         str->str_u.str_nval += 1.0;
1340         str->str_pok = 0;
1341         return;
1342     }
1343     if (!str->str_pok || !*str->str_ptr) {
1344         str->str_u.str_nval = 1.0;
1345         str->str_nok = 1;
1346         str->str_pok = 0;
1347         return;
1348     }
1349     d = str->str_ptr;
1350     while (isALPHA(*d)) d++;
1351     while (isDIGIT(*d)) d++;
1352     if (*d) {
1353         str_numset(str,atof(str->str_ptr) + 1.0);  /* punt */
1354         return;
1355     }
1356     d--;
1357     while (d >= str->str_ptr) {
1358         if (isDIGIT(*d)) {
1359             if (++*d <= '9')
1360                 return;
1361             *(d--) = '0';
1362         }
1363         else {
1364             ++*d;
1365             if (isALPHA(*d))
1366                 return;
1367             *(d--) -= 'z' - 'a' + 1;
1368         }
1369     }
1370     /* oh,oh, the number grew */
1371     STR_GROW(str, str->str_cur + 2);
1372     str->str_cur++;
1373     for (d = str->str_ptr + str->str_cur; d > str->str_ptr; d--)
1374         *d = d[-1];
1375     if (isDIGIT(d[1]))
1376         *d = '1';
1377     else
1378         *d = d[1];
1379 }
1380
1381 void
1382 str_dec(str)
1383 register STR *str;
1384 {
1385     if (!str || str == &str_undef)
1386         return;
1387     if (str->str_nok) {
1388         str->str_u.str_nval -= 1.0;
1389         str->str_pok = 0;
1390         return;
1391     }
1392     if (!str->str_pok) {
1393         str->str_u.str_nval = -1.0;
1394         str->str_nok = 1;
1395         return;
1396     }
1397     str_numset(str,atof(str->str_ptr) - 1.0);
1398 }
1399
1400 /* Make a string that will exist for the duration of the expression
1401  * evaluation.  Actually, it may have to last longer than that, but
1402  * hopefully cmd_exec won't free it until it has been assigned to a
1403  * permanent location. */
1404
1405 static long tmps_size = -1;
1406
1407 STR *
1408 str_mortal(oldstr)
1409 STR *oldstr;
1410 {
1411     register STR *str = Str_new(78,0);
1412
1413     str_sset(str,oldstr);
1414     if (++tmps_max > tmps_size) {
1415         tmps_size = tmps_max;
1416         if (!(tmps_size & 127)) {
1417             if (tmps_size)
1418                 Renew(tmps_list, tmps_size + 128, STR*);
1419             else
1420                 New(702,tmps_list, 128, STR*);
1421         }
1422     }
1423     tmps_list[tmps_max] = str;
1424     if (str->str_pok)
1425         str->str_pok |= SP_TEMP;
1426     return str;
1427 }
1428
1429 /* same thing without the copying */
1430
1431 STR *
1432 str_2mortal(str)
1433 register STR *str;
1434 {
1435     if (!str || str == &str_undef)
1436         return str;
1437     if (++tmps_max > tmps_size) {
1438         tmps_size = tmps_max;
1439         if (!(tmps_size & 127)) {
1440             if (tmps_size)
1441                 Renew(tmps_list, tmps_size + 128, STR*);
1442             else
1443                 New(704,tmps_list, 128, STR*);
1444         }
1445     }
1446     tmps_list[tmps_max] = str;
1447     if (str->str_pok)
1448         str->str_pok |= SP_TEMP;
1449     return str;
1450 }
1451
1452 STR *
1453 str_make(s,len)
1454 char *s;
1455 STRLEN len;
1456 {
1457     register STR *str = Str_new(79,0);
1458
1459     if (!len)
1460         len = strlen(s);
1461     str_nset(str,s,len);
1462     return str;
1463 }
1464
1465 STR *
1466 str_nmake(n)
1467 double n;
1468 {
1469     register STR *str = Str_new(80,0);
1470
1471     str_numset(str,n);
1472     return str;
1473 }
1474
1475 /* make an exact duplicate of old */
1476
1477 STR *
1478 str_smake(old)
1479 register STR *old;
1480 {
1481     register STR *new = Str_new(81,0);
1482
1483     if (!old)
1484         return Nullstr;
1485     if (old->str_state == SS_FREE) {
1486         warn("semi-panic: attempt to dup freed string");
1487         return Nullstr;
1488     }
1489     if (old->str_state == SS_INCR && !(old->str_pok & 2))
1490         Str_Grow(old,0);
1491     if (new->str_ptr)
1492         Safefree(new->str_ptr);
1493     StructCopy(old,new,STR);
1494     if (old->str_ptr) {
1495         new->str_ptr = nsavestr(old->str_ptr,old->str_len);
1496         new->str_pok &= ~SP_TEMP;
1497     }
1498     return new;
1499 }
1500
1501 void
1502 str_reset(s,stash)
1503 register char *s;
1504 HASH *stash;
1505 {
1506     register HENT *entry;
1507     register STAB *stab;
1508     register STR *str;
1509     register int i;
1510     register SPAT *spat;
1511     register int max;
1512
1513     if (!*s) {          /* reset ?? searches */
1514         for (spat = stash->tbl_spatroot;
1515           spat != Nullspat;
1516           spat = spat->spat_next) {
1517             spat->spat_flags &= ~SPAT_USED;
1518         }
1519         return;
1520     }
1521
1522     /* reset variables */
1523
1524     if (!stash->tbl_array)
1525         return;
1526     while (*s) {
1527         i = *s;
1528         if (s[1] == '-') {
1529             s += 2;
1530         }
1531         max = *s++;
1532         for ( ; i <= max; i++) {
1533             for (entry = stash->tbl_array[i];
1534               entry;
1535               entry = entry->hent_next) {
1536                 stab = (STAB*)entry->hent_val;
1537                 str = stab_val(stab);
1538                 str->str_cur = 0;
1539                 str->str_nok = 0;
1540 #ifdef TAINT
1541                 str->str_tainted = tainted;
1542 #endif
1543                 if (str->str_ptr != Nullch)
1544                     str->str_ptr[0] = '\0';
1545                 if (stab_xarray(stab)) {
1546                     aclear(stab_xarray(stab));
1547                 }
1548                 if (stab_xhash(stab)) {
1549                     hclear(stab_xhash(stab), FALSE);
1550                     if (stab == envstab)
1551                         environ[0] = Nullch;
1552                 }
1553             }
1554         }
1555     }
1556 }
1557
1558 #ifdef TAINT
1559 void
1560 taintproper(s)
1561 char *s;
1562 {
1563 #ifdef DEBUGGING
1564     if (debug & 2048)
1565         fprintf(stderr,"%s %d %d %d\n",s,tainted,uid, euid);
1566 #endif
1567     if (tainted && (!euid || euid != uid || egid != gid || taintanyway)) {
1568         if (!unsafe)
1569             fatal("%s", s);
1570         else if (dowarn)
1571             warn("%s", s);
1572     }
1573 }
1574
1575 void
1576 taintenv()
1577 {
1578     register STR *envstr;
1579
1580     envstr = hfetch(stab_hash(envstab),"PATH",4,FALSE);
1581     if (envstr == &str_undef || envstr->str_tainted) {
1582         tainted = 1;
1583         if (envstr->str_tainted == 2)
1584             taintproper("Insecure directory in PATH");
1585         else
1586             taintproper("Insecure PATH");
1587     }
1588     envstr = hfetch(stab_hash(envstab),"IFS",3,FALSE);
1589     if (envstr != &str_undef && envstr->str_tainted) {
1590         tainted = 1;
1591         taintproper("Insecure IFS");
1592     }
1593 }
1594 #endif /* TAINT */