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

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

Defined functions