usr/src/cmd/awk/lib.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
  28 /*        All Rights Reserved   */
  29
  30 #pragma ident   "%Z%%M% %I%     %E% SMI"
  31
  32 #include <errno.h>
  33 #include "awk.h"
  34 #include "y.tab.h"
  35
  36 uchar   *record;
  37 size_t  record_size;
  38
  39 int     donefld;        /* 1 = implies rec broken into fields */
  40 int     donerec;        /* 1 = record is valid (no flds have changed) */
  41
  42 static struct fldtab_chunk {
  43         struct fldtab_chunk     *next;
  44         Cell                    fields[FLD_INCR];
  45 } *fldtab_head, *fldtab_tail;
  46
  47 static  size_t  fldtab_maxidx;
  48
  49 static FILE     *infile = NULL;
  50 static uchar    *file   = (uchar*) "";
  51 static uchar    *fields;
  52 static size_t   fields_size = LINE_INCR;
  53
  54 static int      maxfld  = 0;    /* last used field */
  55 static int      argno   = 1;    /* current input argument number */
  56
  57 static  uchar   *getargv(int);
  58 static  void    cleanfld(int, int);
  59 static  int     refldbld(uchar *, uchar *);
  60 static  void    bcheck2(int, int, int);
  61 static  void    eprint(void);
  62 static  void    bclass(int);
  63
  64 static void
  65 initgetrec(void)
  66 {
  67         int i;
  68         uchar *p;
  69
  70         for (i = 1; i < *ARGC; i++) {
  71                 if (!isclvar(p = getargv(i)))   /* find 1st real filename */
  72                         return;
  73                 setclvar(p);    /* a commandline assignment before filename */
  74                 argno++;
  75         }
  76         infile = stdin;         /* no filenames, so use stdin */
  77         /* *FILENAME = file = (uchar*) "-"; */
  78 }
  79
  80 int
  81 getrec(uchar **bufp, size_t *bufsizep)
  82 {
  83         int c;
  84         static int firsttime = 1;
  85         uchar_t *buf, *nbuf;
  86         size_t  len;
  87
  88         if (firsttime) {
  89                 firsttime = 0;
  90                 initgetrec();
  91         }
  92         dprintf(("RS=<%s>, FS=<%s>, ARGC=%f, FILENAME=%s\n",
  93             *RS, *FS, *ARGC, *FILENAME));
  94         donefld = 0;
  95         donerec = 1;
  96         while (argno < *ARGC || infile == stdin) {
  97                 dprintf(("argno=%d, file=|%s|\n", argno, file));
  98                 if (infile == NULL) {   /* have to open a new file */
  99                         file = getargv(argno);
 100                         if (*file == '\0') {    /* it's been zapped */
 101                                 argno++;
 102                                 continue;
 103                         }
 104                         if (isclvar(file)) {    /* a var=value arg */
 105                                 setclvar(file);
 106                                 argno++;
 107                                 continue;
 108                         }
 109                         *FILENAME = file;
 110                         dprintf(("opening file %s\n", file));
 111                         if (*file == '-' && *(file+1) == '\0')
 112                                 infile = stdin;
 113                         else if ((infile = fopen((char *)file, "r")) == NULL)
 114                                 ERROR "can't open file %s", file FATAL;
 115                         (void) setfval(fnrloc, 0.0);
 116                 }
 117                 c = readrec(&nbuf, &len, infile);
 118                 expand_buf(bufp, bufsizep, len);
 119                 buf = *bufp;
 120                 (void) memcpy(buf, nbuf, len);
 121                 buf[len] = '\0';
 122                 free(nbuf);
 123
 124                 if (c != 0 || buf[0] != '\0') { /* normal record */
 125                         if (bufp == &record) {
 126                                 if (!(recloc->tval & DONTFREE))
 127                                         xfree(recloc->sval);
 128                                 recloc->sval = record;
 129                                 recloc->tval = REC | STR | DONTFREE;
 130                                 if (is_number(recloc->sval)) {
 131                                         recloc->fval =
 132                                             atof((const char *)recloc->sval);
 133                                         recloc->tval |= NUM;
 134                                 }
 135                         }
 136                         (void) setfval(nrloc, nrloc->fval+1);
 137                         (void) setfval(fnrloc, fnrloc->fval+1);
 138                         return (1);
 139                 }
 140                 /* EOF arrived on this file; set up next */
 141                 if (infile != stdin)
 142                         (void) fclose(infile);
 143                 infile = NULL;
 144                 argno++;
 145         }
 146         return (0);     /* true end of file */
 147 }
 148
 149 int
 150 readrec(uchar **bufp, size_t *sizep, FILE *inf) /* read one record into buf */
 151 {
 152         int sep, c;
 153         uchar   *buf;
 154         int     count;
 155         size_t  bufsize;
 156
 157         init_buf(&buf, &bufsize, LINE_INCR);
 158         if ((sep = **RS) == 0) {
 159                 sep = '\n';
 160                 /* skip leading \n's */
 161                 while ((c = getc(inf)) == '\n' && c != EOF)
 162                         ;
 163                 if (c != EOF)
 164                         (void) ungetc(c, inf);
 165         }
 166         count = 0;
 167         for (;;) {
 168                 while ((c = getc(inf)) != sep && c != EOF) {
 169                         expand_buf(&buf, &bufsize, count);
 170                         buf[count++] = c;
 171                 }
 172                 if (**RS == sep || c == EOF)
 173                         break;
 174                 if ((c = getc(inf)) == '\n' || c == EOF) /* 2 in a row */
 175                         break;
 176                 expand_buf(&buf, &bufsize, count + 1);
 177                 buf[count++] = '\n';
 178                 buf[count++] = c;
 179         }
 180         buf[count] = '\0';
 181         dprintf(("readrec saw <%s>, returns %d\n",
 182             buf, c == EOF && count == 0 ? 0 : 1));
 183         *bufp = buf;
 184         *sizep = count;
 185         return (c == EOF && count == 0 ? 0 : 1);
 186 }
 187
 188 /* get ARGV[n] */
 189 static uchar *
 190 getargv(int n)
 191 {
 192         Cell *x;
 193         uchar *s, temp[11];
 194         extern Array *ARGVtab;
 195
 196         (void) sprintf((char *)temp, "%d", n);
 197         x = setsymtab(temp, (uchar *)"", 0.0, STR, ARGVtab);
 198         s = getsval(x);
 199         dprintf(("getargv(%d) returns |%s|\n", n, s));
 200         return (s);
 201 }
 202
 203 void
 204 setclvar(uchar *s)      /* set var=value from s */
 205 {
 206         uchar *p;
 207         Cell *q;
 208
 209         for (p = s; *p != '='; p++)
 210                 ;
 211         *p++ = 0;
 212         p = qstring(p, '\0');
 213         q = setsymtab(s, p, 0.0, STR, symtab);
 214         (void) setsval(q, p);
 215         if (is_number(q->sval)) {
 216                 q->fval = atof((const char *)q->sval);
 217                 q->tval |= NUM;
 218         }
 219         dprintf(("command line set %s to |%s|\n", s, p));
 220         free(p);
 221 }
 222
 223 void
 224 fldbld(void)
 225 {
 226         uchar *r, *fr, sep;
 227         Cell *p;
 228         int i;
 229         size_t  len;
 230
 231         if (donefld)
 232                 return;
 233         if (!(recloc->tval & STR))
 234                 (void) getsval(recloc);
 235         r = recloc->sval;       /* was record! */
 236
 237         /* make sure fields is always allocated */
 238         adjust_buf(&fields, fields_size);
 239
 240         /*
 241          * make sure fields has enough size. We don't expand the buffer
 242          * in the middle of the loop, since p->sval has already pointed
 243          * the address in the fields.
 244          */
 245         len = strlen((char *)r) + 1;
 246         expand_buf(&fields, &fields_size, len);
 247         fr = fields;
 248
 249         i = 0;  /* number of fields accumulated here */
 250         if (strlen((char *)*FS) > 1) {  /* it's a regular expression */
 251                 i = refldbld(r, *FS);
 252         } else if ((sep = **FS) == ' ') {
 253                 for (i = 0; ; ) {
 254                         while (*r == ' ' || *r == '\t' || *r == '\n')
 255                                 r++;
 256                         if (*r == 0)
 257                                 break;
 258                         i++;
 259                         p = getfld(i);
 260                         if (!(p->tval & DONTFREE))
 261                                 xfree(p->sval);
 262                         p->sval = fr;
 263                         p->tval = FLD | STR | DONTFREE;
 264                         do
 265                                 *fr++ = *r++;
 266                         while (*r != ' ' && *r != '\t' && *r != '\n' &&
 267                             *r != '\0')
 268                                 ;
 269                         *fr++ = 0;
 270                 }
 271                 *fr = 0;
 272         } else if (*r != 0) {   /* if 0, it's a null field */
 273                 for (;;) {
 274                         i++;
 275                         p = getfld(i);
 276                         if (!(p->tval & DONTFREE))
 277                                 xfree(p->sval);
 278                         p->sval = fr;
 279                         p->tval = FLD | STR | DONTFREE;
 280                         /* \n always a separator */
 281                         while (*r != sep && *r != '\n' && *r != '\0')
 282                                 *fr++ = *r++;
 283                         *fr++ = 0;
 284                         if (*r++ == 0)
 285                                 break;
 286                 }
 287                 *fr = 0;
 288         }
 289         /* clean out junk from previous record */
 290         cleanfld(i, maxfld);
 291         maxfld = i;
 292         donefld = 1;
 293         for (i = 1; i <= maxfld; i++) {
 294                 p = getfld(i);
 295                 if (is_number(p->sval)) {
 296                         p->fval = atof((const char *)p->sval);
 297                         p->tval |= NUM;
 298                 }
 299         }
 300
 301         (void) setfval(nfloc, (Awkfloat) maxfld);
 302         if (dbg) {
 303                 for (i = 0; i <= maxfld; i++) {
 304                         p = getfld(i);
 305                         (void) printf("field %d: |%s|\n", i, p->sval);
 306                 }
 307         }
 308 }
 309
 310 static void
 311 cleanfld(int n1, int n2)        /* clean out fields n1..n2 inclusive */
 312 {
 313         static uchar *nullstat = (uchar *) "";
 314         Cell *p;
 315         int     i;
 316
 317         for (i = n2; i > n1; i--) {
 318                 p = getfld(i);
 319                 if (!(p->tval & DONTFREE))
 320                         xfree(p->sval);
 321                 p->tval = FLD | STR | DONTFREE;
 322                 p->sval = nullstat;
 323         }
 324 }
 325
 326 void
 327 newfld(int n)   /* add field n (after end) */
 328 {
 329         if (n < 0)
 330                 ERROR "accessing invalid field", record FATAL;
 331         (void) getfld(n);
 332         cleanfld(maxfld, n);
 333         maxfld = n;
 334         (void) setfval(nfloc, (Awkfloat) n);
 335 }
 336
 337 /*
 338  * allocate field table. We don't reallocate the table since there
 339  * might be somewhere recording the address of the table.
 340  */
 341 static void
 342 morefld(void)
 343 {
 344         int     i;
 345         struct fldtab_chunk *fldcp;
 346         Cell    *newfld;
 347
 348         if ((fldcp = calloc(sizeof (struct fldtab_chunk), 1)) == NULL)
 349                 ERROR "out of space in morefld" FATAL;
 350
 351         newfld = &fldcp->fields[0];
 352         for (i = 0; i < FLD_INCR; i++) {
 353                 newfld[i].ctype = OCELL;
 354                 newfld[i].csub = CFLD;
 355                 newfld[i].nval = NULL;
 356                 newfld[i].sval = (uchar *)"";
 357                 newfld[i].fval = 0.0;
 358                 newfld[i].tval = FLD|STR|DONTFREE;
 359                 newfld[i].cnext = NULL;
 360         }
 361         /*
 362          * link this field chunk
 363          */
 364         if (fldtab_head == NULL)
 365                 fldtab_head = fldcp;
 366         else
 367                 fldtab_tail->next = fldcp;
 368         fldtab_tail = fldcp;
 369         fldcp->next = NULL;
 370
 371         fldtab_maxidx += FLD_INCR;
 372 }
 373
 374 Cell *
 375 getfld(int idx)
 376 {
 377         struct fldtab_chunk *fldcp;
 378         int     cbase;
 379
 380         if (idx < 0)
 381                 ERROR "trying to access field %d", idx FATAL;
 382         while (idx >= fldtab_maxidx)
 383                 morefld();
 384         cbase = 0;
 385         for (fldcp = fldtab_head; fldcp != NULL; fldcp = fldcp->next) {
 386                 if (idx < (cbase + FLD_INCR))
 387                         return (&fldcp->fields[idx - cbase]);
 388                 cbase += FLD_INCR;
 389         }
 390         /* should never happen */
 391         ERROR "trying to access invalid field %d", idx FATAL;
 392         return (NULL);
 393 }
 394
 395 int
 396 fldidx(Cell *vp)
 397 {
 398         struct fldtab_chunk *fldcp;
 399         Cell    *tbl;
 400         int     cbase;
 401
 402         cbase = 0;
 403         for (fldcp = fldtab_head; fldcp != NULL; fldcp = fldcp->next) {
 404                 tbl = &fldcp->fields[0];
 405                 if (vp >= tbl && vp < (tbl + FLD_INCR))
 406                         return (cbase + (vp - tbl));
 407                 cbase += FLD_INCR;
 408         }
 409         /* should never happen */
 410         ERROR "trying to access unknown field" FATAL;
 411         return (0);
 412 }
 413
 414 static int
 415 refldbld(uchar *rec, uchar *fs) /* build fields from reg expr in FS */
 416 {
 417         uchar *fr;
 418         int i, tempstat;
 419         fa *pfa;
 420         Cell    *p;
 421         size_t  len;
 422
 423         /* make sure fields is allocated */
 424         adjust_buf(&fields, fields_size);
 425         fr = fields;
 426         *fr = '\0';
 427         if (*rec == '\0')
 428                 return (0);
 429
 430         len = strlen((char *)rec) + 1;
 431         expand_buf(&fields, &fields_size, len);
 432         fr = fields;
 433
 434         pfa = makedfa(fs, 1);
 435         dprintf(("into refldbld, rec = <%s>, pat = <%s>\n", rec, fs));
 436         tempstat = pfa->initstat;
 437         for (i = 1; ; i++) {
 438                 p = getfld(i);
 439                 if (!(p->tval & DONTFREE))
 440                         xfree(p->sval);
 441                 p->tval = FLD | STR | DONTFREE;
 442                 p->sval = fr;
 443                 dprintf(("refldbld: i=%d\n", i));
 444                 if (nematch(pfa, rec)) {
 445                         pfa->initstat = 2;
 446                         dprintf(("match %s (%d chars)\n", patbeg, patlen));
 447                         (void) strncpy((char *)fr, (char *)rec, patbeg-rec);
 448                         fr += patbeg - rec + 1;
 449                         *(fr-1) = '\0';
 450                         rec = patbeg + patlen;
 451                 } else {
 452                         dprintf(("no match %s\n", rec));
 453                         (void) strcpy((char *)fr, (char *)rec);
 454                         pfa->initstat = tempstat;
 455                         break;
 456                 }
 457         }
 458         return (i);
 459 }
 460
 461 void
 462 recbld(void)
 463 {
 464         int i;
 465         uchar *p;
 466         size_t cnt, len, olen;
 467
 468         if (donerec == 1)
 469                 return;
 470         cnt = 0;
 471         olen = strlen((char *)*OFS);
 472         for (i = 1; i <= *NF; i++) {
 473                 p = getsval(getfld(i));
 474                 len = strlen((char *)p);
 475                 expand_buf(&record, &record_size, cnt + len + olen);
 476                 (void) memcpy(&record[cnt], p, len);
 477                 cnt += len;
 478                 if (i < *NF) {
 479                         (void) memcpy(&record[cnt], *OFS, olen);
 480                         cnt += olen;
 481                 }
 482         }
 483         record[cnt] = '\0';
 484         dprintf(("in recbld FS=%o, recloc=%p\n", **FS, (void *)recloc));
 485         if (!(recloc->tval & DONTFREE))
 486                 xfree(recloc->sval);
 487         recloc->tval = REC | STR | DONTFREE;
 488         recloc->sval = record;
 489         dprintf(("in recbld FS=%o, recloc=%p\n", **FS, (void *)recloc));
 490         dprintf(("recbld = |%s|\n", record));
 491         donerec = 1;
 492 }
 493
 494 Cell *
 495 fieldadr(int n)
 496 {
 497         if (n < 0)
 498                 ERROR "trying to access field %d", n FATAL;
 499         return (getfld(n));
 500 }
 501
 502 int     errorflag       = 0;
 503 char    errbuf[200];
 504
 505 void
 506 yyerror(char *s)
 507 {
 508         extern uchar *cmdname, *curfname;
 509         static int been_here = 0;
 510
 511         if (been_here++ > 2)
 512                 return;
 513         (void) fprintf(stderr, "%s: %s", cmdname, s);
 514         (void) fprintf(stderr, gettext(" at source line %lld"), lineno);
 515         if (curfname != NULL)
 516                 (void) fprintf(stderr, gettext(" in function %s"), curfname);
 517         (void) fprintf(stderr, "\n");
 518         errorflag = 2;
 519         eprint();
 520 }
 521
 522 /*ARGSUSED*/
 523 void
 524 fpecatch(int sig)
 525 {
 526         ERROR "floating point exception" FATAL;
 527 }
 528
 529 extern int bracecnt, brackcnt, parencnt;
 530
 531 void
 532 bracecheck(void)
 533 {
 534         int c;
 535         static int beenhere = 0;
 536
 537         if (beenhere++)
 538                 return;
 539         while ((c = input()) != EOF && c != '\0')
 540                 bclass(c);
 541         bcheck2(bracecnt, '{', '}');
 542         bcheck2(brackcnt, '[', ']');
 543         bcheck2(parencnt, '(', ')');
 544 }
 545
 546 /*ARGSUSED*/
 547 static void
 548 bcheck2(int n, int c1, int c2)
 549 {
 550         if (n == 1)
 551                 (void) fprintf(stderr, gettext("\tmissing %c\n"), c2);
 552         else if (n > 1)
 553                 (void) fprintf(stderr, gettext("\t%d missing %c's\n"), n, c2);
 554         else if (n == -1)
 555                 (void) fprintf(stderr, gettext("\textra %c\n"), c2);
 556         else if (n < -1)
 557                 (void) fprintf(stderr, gettext("\t%d extra %c's\n"), -n, c2);
 558 }
 559
 560 void
 561 error(int f, char *s)
 562 {
 563         extern Node *curnode;
 564         extern uchar *cmdname;
 565
 566         (void) fflush(stdout);
 567         (void) fprintf(stderr, "%s: ", cmdname);
 568         (void) fprintf(stderr, "%s", s);
 569         (void) fprintf(stderr, "\n");
 570         if (compile_time != 2 && NR && *NR > 0) {
 571                 (void) fprintf(stderr,
 572                     gettext(" input record number %g"), *FNR);
 573                 if (strcmp((char *)*FILENAME, "-") != 0)
 574                         (void) fprintf(stderr, gettext(", file %s"), *FILENAME);
 575                 (void) fprintf(stderr, "\n");
 576         }
 577         if (compile_time != 2 && curnode)
 578                 (void) fprintf(stderr, gettext(" source line number %lld\n"),
 579                     curnode->lineno);
 580         else if (compile_time != 2 && lineno) {
 581                 (void) fprintf(stderr,
 582                     gettext(" source line number %lld\n"), lineno);
 583         }
 584         eprint();
 585         if (f) {
 586                 if (dbg)
 587                         abort();
 588                 exit(2);
 589         }
 590 }
 591
 592 static void
 593 eprint(void)    /* try to print context around error */
 594 {
 595         uchar *p, *q;
 596         int c;
 597         static int been_here = 0;
 598         extern uchar ebuf[300], *ep;
 599
 600         if (compile_time == 2 || compile_time == 0 || been_here++ > 0)
 601                 return;
 602         p = ep - 1;
 603         if (p > ebuf && *p == '\n')
 604                 p--;
 605         for (; p > ebuf && *p != '\n' && *p != '\0'; p--)
 606                 ;
 607         while (*p == '\n')
 608                 p++;
 609         (void) fprintf(stderr, gettext(" context is\n\t"));
 610         for (q = ep-1; q >= p && *q != ' ' && *q != '\t' && *q != '\n'; q--)
 611                 ;
 612         for (; p < q; p++)
 613                 if (*p)
 614                         (void) putc(*p, stderr);
 615         (void) fprintf(stderr, " >>> ");
 616         for (; p < ep; p++)
 617                 if (*p)
 618                         (void) putc(*p, stderr);
 619         (void) fprintf(stderr, " <<< ");
 620         if (*ep)
 621                 while ((c = input()) != '\n' && c != '\0' && c != EOF) {
 622                         (void) putc(c, stderr);
 623                         bclass(c);
 624                 }
 625         (void) putc('\n', stderr);
 626         ep = ebuf;
 627 }
 628
 629 static void
 630 bclass(int c)
 631 {
 632         switch (c) {
 633         case '{': bracecnt++; break;
 634         case '}': bracecnt--; break;
 635         case '[': brackcnt++; break;
 636         case ']': brackcnt--; break;
 637         case '(': parencnt++; break;
 638         case ')': parencnt--; break;
 639         }
 640 }
 641
 642 double
 643 errcheck(double x, char *s)
 644 {
 645         extern int errno;
 646
 647         if (errno == EDOM) {
 648                 errno = 0;
 649                 ERROR "%s argument out of domain", s WARNING;
 650                 x = 1;
 651         } else if (errno == ERANGE) {
 652                 errno = 0;
 653                 ERROR "%s result out of range", s WARNING;
 654                 x = 1;
 655         }
 656         return (x);
 657 }
 658
 659 void
 660 PUTS(uchar *s)
 661 {
 662         dprintf(("%s\n", s));
 663 }
 664
 665 int
 666 isclvar(uchar *s)       /* is s of form var=something? */
 667 {
 668         if (s != NULL) {
 669
 670                 /* Must begin with an underscore or alphabetic character */
 671                 if (isalpha(*s) || (*s == '_')) {
 672
 673                         for (s++; *s; s++) {
 674                                 /*
 675                                  * followed by a sequence of underscores,
 676                                  * digits, and alphabetics
 677                                  */
 678                                 if (!(isalnum(*s) || *s == '_')) {
 679                                         break;
 680                                 }
 681                         }
 682                         return (*s == '=' && *(s + 1) != '=');
 683                 }
 684         }
 685
 686         return (0);
 687 }
 688
 689 #define MAXEXPON        38      /* maximum exponent for fp number */
 690
 691 int
 692 is_number(uchar *s)
 693 {
 694         int d1, d2;
 695         int point;
 696         uchar *es;
 697         extern char     radixpoint;
 698
 699         d1 = d2 = point = 0;
 700         while (*s == ' ' || *s == '\t' || *s == '\n')
 701                 s++;
 702         if (*s == '\0')
 703                 return (0);     /* empty stuff isn't number */
 704         if (*s == '+' || *s == '-')
 705                 s++;
 706         if (!isdigit(*s) && *s != radixpoint)
 707                 return (0);
 708         if (isdigit(*s)) {
 709                 do {
 710                         d1++;
 711                         s++;
 712                 } while (isdigit(*s));
 713         }
 714         if (d1 >= MAXEXPON)
 715                 return (0);     /* too many digits to convert */
 716         if (*s == radixpoint) {
 717                 point++;
 718                 s++;
 719         }
 720         if (isdigit(*s)) {
 721                 d2++;
 722                 do {
 723                         s++;
 724                 } while (isdigit(*s));
 725         }
 726         if (!(d1 || point && d2))
 727                 return (0);
 728         if (*s == 'e' || *s == 'E') {
 729                 s++;
 730                 if (*s == '+' || *s == '-')
 731                         s++;
 732                 if (!isdigit(*s))
 733                         return (0);
 734                 es = s;
 735                 do {
 736                         s++;
 737                 } while (isdigit(*s));
 738                 if (s - es > 2) {
 739                         return (0);
 740                 } else if (s - es == 2 &&
 741                     (int)(10 * (*es-'0') + *(es+1)-'0') >= MAXEXPON) {
 742                         return (0);
 743                 }
 744         }
 745         while (*s == ' ' || *s == '\t' || *s == '\n')
 746                 s++;
 747         if (*s == '\0')
 748                 return (1);
 749         else
 750                 return (0);
 751 }
 752
 753 void
 754 init_buf(uchar **optr, size_t *sizep, size_t amt)
 755 {
 756         uchar   *nptr = NULL;
 757
 758         if ((nptr = malloc(amt)) == NULL)
 759                 ERROR "out of space in init_buf" FATAL;
 760         /* initial buffer should have NULL terminated */
 761         *nptr = '\0';
 762         if (sizep != NULL)
 763                 *sizep = amt;
 764         *optr = nptr;
 765 }
 766
 767 void
 768 r_expand_buf(uchar **optr, size_t *sizep, size_t req)
 769 {
 770         uchar   *nptr;
 771         size_t  amt, size = *sizep;
 772
 773         if (size != 0 && req < (size - 1))
 774                 return;
 775         amt = req + 1 - size;
 776         amt = (amt / LINE_INCR + 1) * LINE_INCR;
 777
 778         if ((nptr = realloc(*optr, size + amt)) == NULL)
 779                 ERROR "out of space in expand_buf" FATAL;
 780         /* initial buffer should have NULL terminated */
 781         if (size == 0)
 782                 *nptr = '\0';
 783         *sizep += amt;
 784         *optr = nptr;
 785 }
 786
 787 void
 788 adjust_buf(uchar **optr, size_t size)
 789 {
 790         uchar   *nptr;
 791
 792         if ((nptr = realloc(*optr, size)) == NULL)
 793                 ERROR "out of space in adjust_buf" FATAL;
 794         *optr = nptr;
 795 }