2.11BSD#431 - /usr/src/new/PORT/perl.1.0.10/str.c

   1: /* $Header: str.c,v 1.0.1.1 88/01/21 21:28:39 root Exp $
   2:  *
   3:  * $Log:	str.c,v $
   4:  * Revision 1.0.1.1  88/01/21  21:28:39  root
   5:  * Suppressed warning messages on signed vs unsigned chars in str_gets().
   6:  *
   7:  * Revision 1.0  87/12/18  13:06:22  root
   8:  * Initial revision
   9:  *
  10:  */
  11: 
  12: #include "handy.h"
  13: #include "EXTERN.h"
  14: #include "search.h"
  15: #include "util.h"
  16: #include "perl.h"
  17: 
  18: str_reset(s)
  19: register char *s;
  20: {
  21:     register STAB *stab;
  22:     register STR *str;
  23:     register int i;
  24:     register int max;
  25:     register SPAT *spat;
  26: 
  27:     if (!*s) {      /* reset ?? searches */
  28:     for (spat = spat_root; spat != Nullspat; spat = spat->spat_next) {
  29:         spat->spat_flags &= ~SPAT_USED;
  30:     }
  31:     return;
  32:     }
  33: 
  34:     /* reset variables */
  35: 
  36:     while (*s) {
  37:     i = *s;
  38:     if (s[1] == '-') {
  39:         s += 2;
  40:     }
  41:     max = *s++;
  42:     for ( ; i <= max; i++) {
  43:         for (stab = stab_index[i]; stab; stab = stab->stab_next) {
  44:         str = stab->stab_val;
  45:         str->str_cur = 0;
  46:         if (str->str_ptr != Nullch)
  47:             str->str_ptr[0] = '\0';
  48:         }
  49:     }
  50:     }
  51: }
  52: 
  53: str_numset(str,num)
  54: register STR *str;
  55: double num;
  56: {
  57:     str->str_nval = num;
  58:     str->str_pok = 0;       /* invalidate pointer */
  59:     str->str_nok = 1;       /* validate number */
  60: }
  61: 
  62: char *
  63: str_2ptr(str)
  64: register STR *str;
  65: {
  66:     register char *s;
  67: 
  68:     if (!str)
  69:     return "";
  70:     GROWSTR(&(str->str_ptr), &(str->str_len), 24);
  71:     s = str->str_ptr;
  72:     if (str->str_nok) {
  73:     sprintf(s,"%.20g",str->str_nval);
  74:     while (*s) s++;
  75:     }
  76:     *s = '\0';
  77:     str->str_cur = s - str->str_ptr;
  78:     str->str_pok = 1;
  79: #ifdef DEBUGGING
  80:     if (debug & 32)
  81:     fprintf(stderr,"0x%lx ptr(%s)\n",str,str->str_ptr);
  82: #endif
  83:     return str->str_ptr;
  84: }
  85: 
  86: double
  87: str_2num(str)
  88: register STR *str;
  89: {
  90:     if (!str)
  91:     return 0.0;
  92:     if (str->str_len && str->str_pok)
  93:     str->str_nval = atof(str->str_ptr);
  94:     else
  95:     str->str_nval = 0.0;
  96:     str->str_nok = 1;
  97: #ifdef DEBUGGING
  98:     if (debug & 32)
  99:     fprintf(stderr,"0x%lx num(%g)\n",str,str->str_nval);
 100: #endif
 101:     return str->str_nval;
 102: }
 103: 
 104: str_sset(dstr,sstr)
 105: STR *dstr;
 106: register STR *sstr;
 107: {
 108:     if (!sstr)
 109:     str_nset(dstr,No,0);
 110:     else if (sstr->str_nok)
 111:     str_numset(dstr,sstr->str_nval);
 112:     else if (sstr->str_pok)
 113:     str_nset(dstr,sstr->str_ptr,sstr->str_cur);
 114:     else
 115:     str_nset(dstr,"",0);
 116: }
 117: 
 118: str_nset(str,ptr,len)
 119: register STR *str;
 120: register char *ptr;
 121: register int len;
 122: {
 123:     GROWSTR(&(str->str_ptr), &(str->str_len), len + 1);
 124:     bcopy(ptr,str->str_ptr,len);
 125:     str->str_cur = len;
 126:     *(str->str_ptr+str->str_cur) = '\0';
 127:     str->str_nok = 0;       /* invalidate number */
 128:     str->str_pok = 1;       /* validate pointer */
 129: }
 130: 
 131: str_set(str,ptr)
 132: register STR *str;
 133: register char *ptr;
 134: {
 135:     register int len;
 136: 
 137:     if (!ptr)
 138:     ptr = "";
 139:     len = strlen(ptr);
 140:     GROWSTR(&(str->str_ptr), &(str->str_len), len + 1);
 141:     bcopy(ptr,str->str_ptr,len+1);
 142:     str->str_cur = len;
 143:     str->str_nok = 0;       /* invalidate number */
 144:     str->str_pok = 1;       /* validate pointer */
 145: }
 146: 
 147: str_chop(str,ptr)   /* like set but assuming ptr is in str */
 148: register STR *str;
 149: register char *ptr;
 150: {
 151:     if (!(str->str_pok))
 152:     str_2ptr(str);
 153:     str->str_cur -= (ptr - str->str_ptr);
 154:     bcopy(ptr,str->str_ptr, str->str_cur + 1);
 155:     str->str_nok = 0;       /* invalidate number */
 156:     str->str_pok = 1;       /* validate pointer */
 157: }
 158: 
 159: str_ncat(str,ptr,len)
 160: register STR *str;
 161: register char *ptr;
 162: register int len;
 163: {
 164:     if (!(str->str_pok))
 165:     str_2ptr(str);
 166:     GROWSTR(&(str->str_ptr), &(str->str_len), str->str_cur + len + 1);
 167:     bcopy(ptr,str->str_ptr+str->str_cur,len);
 168:     str->str_cur += len;
 169:     *(str->str_ptr+str->str_cur) = '\0';
 170:     str->str_nok = 0;       /* invalidate number */
 171:     str->str_pok = 1;       /* validate pointer */
 172: }
 173: 
 174: str_scat(dstr,sstr)
 175: STR *dstr;
 176: register STR *sstr;
 177: {
 178:     if (!(sstr->str_pok))
 179:     str_2ptr(sstr);
 180:     if (sstr)
 181:     str_ncat(dstr,sstr->str_ptr,sstr->str_cur);
 182: }
 183: 
 184: str_cat(str,ptr)
 185: register STR *str;
 186: register char *ptr;
 187: {
 188:     register int len;
 189: 
 190:     if (!ptr)
 191:     return;
 192:     if (!(str->str_pok))
 193:     str_2ptr(str);
 194:     len = strlen(ptr);
 195:     GROWSTR(&(str->str_ptr), &(str->str_len), str->str_cur + len + 1);
 196:     bcopy(ptr,str->str_ptr+str->str_cur,len+1);
 197:     str->str_cur += len;
 198:     str->str_nok = 0;       /* invalidate number */
 199:     str->str_pok = 1;       /* validate pointer */
 200: }
 201: 
 202: char *
 203: str_append_till(str,from,delim,keeplist)
 204: register STR *str;
 205: register char *from;
 206: register int delim;
 207: char *keeplist;
 208: {
 209:     register char *to;
 210:     register int len;
 211: 
 212:     if (!from)
 213:     return Nullch;
 214:     len = strlen(from);
 215:     GROWSTR(&(str->str_ptr), &(str->str_len), str->str_cur + len + 1);
 216:     str->str_nok = 0;       /* invalidate number */
 217:     str->str_pok = 1;       /* validate pointer */
 218:     to = str->str_ptr+str->str_cur;
 219:     for (; *from; from++,to++) {
 220:     if (*from == '\\' && from[1] && delim != '\\') {
 221:         if (!keeplist) {
 222:         if (from[1] == delim || from[1] == '\\')
 223:             from++;
 224:         else
 225:             *to++ = *from++;
 226:         }
 227:         else if (index(keeplist,from[1]))
 228:         *to++ = *from++;
 229:         else
 230:         from++;
 231:     }
 232:     else if (*from == delim)
 233:         break;
 234:     *to = *from;
 235:     }
 236:     *to = '\0';
 237:     str->str_cur = to - str->str_ptr;
 238:     return from;
 239: }
 240: 
 241: STR *
 242: str_new(len)
 243: int len;
 244: {
 245:     register STR *str;
 246: 
 247:     if (freestrroot) {
 248:     str = freestrroot;
 249:     freestrroot = str->str_link.str_next;
 250:     str->str_link.str_magic = Nullstab;
 251:     }
 252:     else {
 253:     str = (STR *) safemalloc(sizeof(STR));
 254:     bzero((char*)str,sizeof(STR));
 255:     }
 256:     if (len)
 257:     GROWSTR(&(str->str_ptr), &(str->str_len), len + 1);
 258:     return str;
 259: }
 260: 
 261: void
 262: str_grow(str,len)
 263: register STR *str;
 264: int len;
 265: {
 266:     if (len && str)
 267:     GROWSTR(&(str->str_ptr), &(str->str_len), len + 1);
 268: }
 269: 
 270: /* make str point to what nstr did */
 271: 
 272: void
 273: str_replace(str,nstr)
 274: register STR *str;
 275: register STR *nstr;
 276: {
 277:     safefree(str->str_ptr);
 278:     str->str_ptr = nstr->str_ptr;
 279:     str->str_len = nstr->str_len;
 280:     str->str_cur = nstr->str_cur;
 281:     str->str_pok = nstr->str_pok;
 282:     if (str->str_nok = nstr->str_nok)
 283:     str->str_nval = nstr->str_nval;
 284:     safefree((char*)nstr);
 285: }
 286: 
 287: void
 288: str_free(str)
 289: register STR *str;
 290: {
 291:     if (!str)
 292:     return;
 293:     if (str->str_len)
 294:     str->str_ptr[0] = '\0';
 295:     str->str_cur = 0;
 296:     str->str_nok = 0;
 297:     str->str_pok = 0;
 298:     str->str_link.str_next = freestrroot;
 299:     freestrroot = str;
 300: }
 301: 
 302: str_len(str)
 303: register STR *str;
 304: {
 305:     if (!str)
 306:     return 0;
 307:     if (!(str->str_pok))
 308:     str_2ptr(str);
 309:     if (str->str_len)
 310:     return str->str_cur;
 311:     else
 312:     return 0;
 313: }
 314: 
 315: char *
 316: str_gets(str,fp)
 317: register STR *str;
 318: register FILE *fp;
 319: {
 320: #ifdef STDSTDIO     /* Here is some breathtakingly efficient cheating */
 321: 
 322:     register char *bp;      /* we're going to steal some values */
 323:     register int cnt;       /*  from the stdio struct and put EVERYTHING */
 324:     register STDCHAR *ptr;  /*   in the innermost loop into registers */
 325:     register char newline = record_separator;/* (assuming >= 6 registers) */
 326:     int i;
 327:     int bpx;
 328:     int obpx;
 329:     register int get_paragraph;
 330:     register char *oldbp;
 331: 
 332:     if (get_paragraph = !newline) { /* yes, that's an assignment */
 333:     newline = '\n';
 334:     oldbp = Nullch;         /* remember last \n position (none) */
 335:     }
 336:     cnt = fp->_cnt;         /* get count into register */
 337:     str->str_nok = 0;           /* invalidate number */
 338:     str->str_pok = 1;           /* validate pointer */
 339:     if (str->str_len <= cnt)        /* make sure we have the room */
 340:     GROWSTR(&(str->str_ptr), &(str->str_len), cnt+1);
 341:     bp = str->str_ptr;          /* move these two too to registers */
 342:     ptr = fp->_ptr;
 343:     for (;;) {
 344:       screamer:
 345:     while (--cnt >= 0) {            /* this */  /* eat */
 346:         if ((*bp++ = *ptr++) == newline)    /* really */    /* dust */
 347:         goto thats_all_folks;       /* screams */   /* sed :-) */
 348:     }
 349: 
 350:     fp->_cnt = cnt;         /* deregisterize cnt and ptr */
 351:     fp->_ptr = ptr;
 352:     i = _filbuf(fp);        /* get more characters */
 353:     cnt = fp->_cnt;
 354:     ptr = fp->_ptr;         /* reregisterize cnt and ptr */
 355: 
 356:     bpx = bp - str->str_ptr;    /* prepare for possible relocation */
 357:     if (get_paragraph && oldbp)
 358:         obpx = oldbp - str->str_ptr;
 359:     GROWSTR(&(str->str_ptr), &(str->str_len), str->str_cur + cnt + 1);
 360:     bp = str->str_ptr + bpx;    /* reconstitute our pointer */
 361:     if (get_paragraph && oldbp)
 362:         oldbp = str->str_ptr + obpx;
 363: 
 364:     if (i == newline) {     /* all done for now? */
 365:         *bp++ = i;
 366:         goto thats_all_folks;
 367:     }
 368:     else if (i == EOF)      /* all done for ever? */
 369:         goto thats_really_all_folks;
 370:     *bp++ = i;          /* now go back to screaming loop */
 371:     }
 372: 
 373: thats_all_folks:
 374:     if (get_paragraph && bp - 1 != oldbp) {
 375:     oldbp = bp; /* remember where this newline was */
 376:     goto screamer;  /* and go back to the fray */
 377:     }
 378: thats_really_all_folks:
 379:     fp->_cnt = cnt;         /* put these back or we're in trouble */
 380:     fp->_ptr = ptr;
 381:     *bp = '\0';
 382:     str->str_cur = bp - str->str_ptr;   /* set length */
 383: 
 384: #else /* !STDSTDIO */   /* The big, slow, and stupid way */
 385: 
 386:     static char buf[4192];
 387: 
 388:     if (fgets(buf, sizeof buf, fp) != Nullch)
 389:     str_set(str, buf);
 390:     else
 391:     str_set(str, No);
 392: 
 393: #endif /* STDSTDIO */
 394: 
 395:     return str->str_cur ? str->str_ptr : Nullch;
 396: }
 397: 
 398: 
 399: STR *
 400: interp(str,s)
 401: register STR *str;
 402: register char *s;
 403: {
 404:     register char *t = s;
 405:     char *envsave = envname;
 406:     envname = Nullch;
 407: 
 408:     str_set(str,"");
 409:     while (*s) {
 410:     if (*s == '\\' && s[1] == '$') {
 411:         str_ncat(str, t, s++ - t);
 412:         t = s++;
 413:     }
 414:     else if (*s == '$' && s[1] && s[1] != '|') {
 415:         str_ncat(str,t,s-t);
 416:         s = scanreg(s,tokenbuf);
 417:         str_cat(str,reg_get(tokenbuf));
 418:         t = s;
 419:     }
 420:     else
 421:         s++;
 422:     }
 423:     envname = envsave;
 424:     str_ncat(str,t,s-t);
 425:     return str;
 426: }
 427: 
 428: void
 429: str_inc(str)
 430: register STR *str;
 431: {
 432:     register char *d;
 433: 
 434:     if (!str)
 435:     return;
 436:     if (str->str_nok) {
 437:     str->str_nval += 1.0;
 438:     str->str_pok = 0;
 439:     return;
 440:     }
 441:     if (!str->str_pok) {
 442:     str->str_nval = 1.0;
 443:     str->str_nok = 1;
 444:     return;
 445:     }
 446:     for (d = str->str_ptr; *d && *d != '.'; d++) ;
 447:     d--;
 448:     if (!isdigit(*str->str_ptr) || !isdigit(*d) ) {
 449:         str_numset(str,atof(str->str_ptr) + 1.0);  /* punt */
 450:     return;
 451:     }
 452:     while (d >= str->str_ptr) {
 453:     if (++*d <= '9')
 454:         return;
 455:     *(d--) = '0';
 456:     }
 457:     /* oh,oh, the number grew */
 458:     GROWSTR(&(str->str_ptr), &(str->str_len), str->str_cur + 2);
 459:     str->str_cur++;
 460:     for (d = str->str_ptr + str->str_cur; d > str->str_ptr; d--)
 461:     *d = d[-1];
 462:     *d = '1';
 463: }
 464: 
 465: void
 466: str_dec(str)
 467: register STR *str;
 468: {
 469:     register char *d;
 470: 
 471:     if (!str)
 472:     return;
 473:     if (str->str_nok) {
 474:     str->str_nval -= 1.0;
 475:     str->str_pok = 0;
 476:     return;
 477:     }
 478:     if (!str->str_pok) {
 479:     str->str_nval = -1.0;
 480:     str->str_nok = 1;
 481:     return;
 482:     }
 483:     for (d = str->str_ptr; *d && *d != '.'; d++) ;
 484:     d--;
 485:     if (!isdigit(*str->str_ptr) || !isdigit(*d) || (*d == '0' && d == str->str_ptr)) {
 486:         str_numset(str,atof(str->str_ptr) - 1.0);  /* punt */
 487:     return;
 488:     }
 489:     while (d >= str->str_ptr) {
 490:     if (--*d >= '0')
 491:         return;
 492:     *(d--) = '9';
 493:     }
 494: }
 495: 
 496: /* make a string that will exist for the duration of the expression eval */
 497: 
 498: STR *
 499: str_static(oldstr)
 500: STR *oldstr;
 501: {
 502:     register STR *str = str_new(0);
 503:     static long tmps_size = -1;
 504: 
 505:     str_sset(str,oldstr);
 506:     if (++tmps_max > tmps_size) {
 507:     tmps_size = tmps_max;
 508:     if (!(tmps_size & 127)) {
 509:         if (tmps_size)
 510:         tmps_list = (STR**)saferealloc((char*)tmps_list,
 511:             (tmps_size + 128) * sizeof(STR*) );
 512:         else
 513:         tmps_list = (STR**)safemalloc(128 * sizeof(char*));
 514:     }
 515:     }
 516:     tmps_list[tmps_max] = str;
 517:     return str;
 518: }
 519: 
 520: STR *
 521: str_make(s)
 522: char *s;
 523: {
 524:     register STR *str = str_new(0);
 525: 
 526:     str_set(str,s);
 527:     return str;
 528: }
 529: 
 530: STR *
 531: str_nmake(n)
 532: double n;
 533: {
 534:     register STR *str = str_new(0);
 535: 
 536:     str_numset(str,n);
 537:     return str;
 538: }

Defined functions