commands/awk/lib.c

   1 /****************************************************************
   2 Copyright (C) Lucent Technologies 1997
   3 All Rights Reserved
   4
   5 Permission to use, copy, modify, and distribute this software and
   6 its documentation for any purpose and without fee is hereby
   7 granted, provided that the above copyright notice appear in all
   8 copies and that both that the copyright notice and this
   9 permission notice and warranty disclaimer appear in supporting
  10 documentation, and that the name Lucent Technologies or any of
  11 its entities not be used in advertising or publicity pertaining
  12 to distribution of the software without specific, written prior
  13 permission.
  14
  15 LUCENT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  16 INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
  17 IN NO EVENT SHALL LUCENT OR ANY OF ITS ENTITIES BE LIABLE FOR ANY
  18 SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
  20 IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  21 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
  22 THIS SOFTWARE.
  23 ****************************************************************/
  24
  25 #define DEBUG
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <ctype.h>
  29 #include <errno.h>
  30 #include <stdlib.h>
  31 #include <stdarg.h>
  32 #include "awk.h"
  33 #include "ytab.h"
  34
  35 FILE    *infile = NULL;
  36 char    *file   = "";
  37 char    *record;
  38 int     recsize = RECSIZE;
  39 char    *fields;
  40 int     fieldssize = RECSIZE;
  41
  42 Cell    **fldtab;       /* pointers to Cells */
  43 char    inputFS[100] = " ";
  44
  45 #define MAXFLD  2
  46 int     nfields = MAXFLD;       /* last allocated slot for $i */
  47
  48 int     donefld;        /* 1 = implies rec broken into fields */
  49 int     donerec;        /* 1 = record is valid (no flds have changed) */
  50
  51 int     lastfld = 0;    /* last used field */
  52 int     argno   = 1;    /* current input argument number */
  53 extern  Awkfloat *ARGC;
  54
  55 static Cell dollar0 = { OCELL, CFLD, NULL, "", 0.0, REC|STR|DONTFREE };
  56 static Cell dollar1 = { OCELL, CFLD, NULL, "", 0.0, FLD|STR|DONTFREE };
  57
  58 void recinit(unsigned int n)
  59 {
  60         if ( (record = (char *) malloc(n)) == NULL
  61           || (fields = (char *) malloc(n+1)) == NULL
  62           || (fldtab = (Cell **) malloc((nfields+1) * sizeof(Cell *))) == NULL
  63           || (fldtab[0] = (Cell *) malloc(sizeof(Cell))) == NULL )
  64                 FATAL("out of space for $0 and fields");
  65         *fldtab[0] = dollar0;
  66         fldtab[0]->sval = record;
  67         fldtab[0]->nval = tostring("0");
  68         makefields(1, nfields);
  69 }
  70
  71 void makefields(int n1, int n2)         /* create $n1..$n2 inclusive */
  72 {
  73         char temp[50];
  74         int i;
  75
  76         for (i = n1; i <= n2; i++) {
  77                 fldtab[i] = (Cell *) malloc(sizeof (struct Cell));
  78                 if (fldtab[i] == NULL)
  79                         FATAL("out of space in makefields %d", i);
  80                 *fldtab[i] = dollar1;
  81                 sprintf(temp, "%d", i);
  82                 fldtab[i]->nval = tostring(temp);
  83         }
  84 }
  85
  86 void initgetrec(void)
  87 {
  88         int i;
  89         char *p;
  90
  91         for (i = 1; i < *ARGC; i++) {
  92                 if (!isclvar(p = getargv(i))) { /* find 1st real filename */
  93                         setsval(lookup("FILENAME", symtab), getargv(i));
  94                         return;
  95                 }
  96                 setclvar(p);    /* a commandline assignment before filename */
  97                 argno++;
  98         }
  99         infile = stdin;         /* no filenames, so use stdin */
 100 }
 101
 102 static int firsttime = 1;
 103
 104 int getrec(char **pbuf, int *pbufsize, int isrecord)    /* get next input record */
 105 {                       /* note: cares whether buf == record */
 106         int c;
 107         char *buf = *pbuf;
 108         uschar saveb0;
 109         int bufsize = *pbufsize, savebufsize = bufsize;
 110
 111         if (firsttime) {
 112                 firsttime = 0;
 113                 initgetrec();
 114         }
 115            dprintf( ("RS=<%s>, FS=<%s>, ARGC=%g, FILENAME=%s\n",
 116                 *RS, *FS, *ARGC, *FILENAME) );
 117         if (isrecord) {
 118                 donefld = 0;
 119                 donerec = 1;
 120         }
 121         saveb0 = buf[0];
 122         buf[0] = 0;
 123         while (argno < *ARGC || infile == stdin) {
 124                    dprintf( ("argno=%d, file=|%s|\n", argno, file) );
 125                 if (infile == NULL) {   /* have to open a new file */
 126                         file = getargv(argno);
 127                         if (*file == '\0') {    /* it's been zapped */
 128                                 argno++;
 129                                 continue;
 130                         }
 131                         if (isclvar(file)) {    /* a var=value arg */
 132                                 setclvar(file);
 133                                 argno++;
 134                                 continue;
 135                         }
 136                         *FILENAME = file;
 137                            dprintf( ("opening file %s\n", file) );
 138                         if (*file == '-' && *(file+1) == '\0')
 139                                 infile = stdin;
 140                         else if ((infile = fopen(file, "r")) == NULL)
 141                                 FATAL("can't open file %s", file);
 142                         setfval(fnrloc, 0.0);
 143                 }
 144                 c = readrec(&buf, &bufsize, infile);
 145                 if (c != 0 || buf[0] != '\0') { /* normal record */
 146                         if (isrecord) {
 147                                 if (freeable(fldtab[0]))
 148                                         xfree(fldtab[0]->sval);
 149                                 fldtab[0]->sval = buf;  /* buf == record */
 150                                 fldtab[0]->tval = REC | STR | DONTFREE;
 151                                 if (is_number(fldtab[0]->sval)) {
 152                                         fldtab[0]->fval = atof(fldtab[0]->sval);
 153                                         fldtab[0]->tval |= NUM;
 154                                 }
 155                         }
 156                         setfval(nrloc, nrloc->fval+1);
 157                         setfval(fnrloc, fnrloc->fval+1);
 158                         *pbuf = buf;
 159                         *pbufsize = bufsize;
 160                         return 1;
 161                 }
 162                 /* EOF arrived on this file; set up next */
 163                 if (infile != stdin)
 164                         fclose(infile);
 165                 infile = NULL;
 166                 argno++;
 167         }
 168         buf[0] = saveb0;
 169         *pbuf = buf;
 170         *pbufsize = savebufsize;
 171         return 0;       /* true end of file */
 172 }
 173
 174 void nextfile(void)
 175 {
 176         if (infile != NULL && infile != stdin)
 177                 fclose(infile);
 178         infile = NULL;
 179         argno++;
 180 }
 181
 182 int readrec(char **pbuf, int *pbufsize, FILE *inf)      /* read one record into buf */
 183 {
 184         int sep, c;
 185         char *rr, *buf = *pbuf;
 186         int bufsize = *pbufsize;
 187
 188         if (strlen(*FS) >= sizeof(inputFS))
 189                 FATAL("field separator %.10s... is too long", *FS);
 190         strcpy(inputFS, *FS);   /* for subsequent field splitting */
 191         if ((sep = **RS) == 0) {
 192                 sep = '\n';
 193                 while ((c=getc(inf)) == '\n' && c != EOF)       /* skip leading \n's */
 194                         ;
 195                 if (c != EOF)
 196                         ungetc(c, inf);
 197         }
 198         for (rr = buf; ; ) {
 199                 for (; (c=getc(inf)) != sep && c != EOF; ) {
 200                         if (rr-buf+1 > bufsize)
 201                                 if (!adjbuf(&buf, &bufsize, 1+rr-buf, recsize, &rr, "readrec 1"))
 202                                         FATAL("input record `%.30s...' too long", buf);
 203                         *rr++ = c;
 204                 }
 205                 if (**RS == sep || c == EOF)
 206                         break;
 207                 if ((c = getc(inf)) == '\n' || c == EOF) /* 2 in a row */
 208                         break;
 209                 if (!adjbuf(&buf, &bufsize, 2+rr-buf, recsize, &rr, "readrec 2"))
 210                         FATAL("input record `%.30s...' too long", buf);
 211                 *rr++ = '\n';
 212                 *rr++ = c;
 213         }
 214         if (!adjbuf(&buf, &bufsize, 1+rr-buf, recsize, &rr, "readrec 3"))
 215                 FATAL("input record `%.30s...' too long", buf);
 216         *rr = 0;
 217            dprintf( ("readrec saw <%s>, returns %d\n", buf, c == EOF && rr == buf ? 0 : 1) );
 218         *pbuf = buf;
 219         *pbufsize = bufsize;
 220         return c == EOF && rr == buf ? 0 : 1;
 221 }
 222
 223 char *getargv(int n)    /* get ARGV[n] */
 224 {
 225         Cell *x;
 226         char *s, temp[50];
 227         extern Array *ARGVtab;
 228
 229         sprintf(temp, "%d", n);
 230         x = setsymtab(temp, "", 0.0, STR, ARGVtab);
 231         s = getsval(x);
 232            dprintf( ("getargv(%d) returns |%s|\n", n, s) );
 233         return s;
 234 }
 235
 236 void setclvar(char *s)  /* set var=value from s */
 237 {
 238         char *p;
 239         Cell *q;
 240
 241         for (p=s; *p != '='; p++)
 242                 ;
 243         *p++ = 0;
 244         p = qstring(p, '\0');
 245         q = setsymtab(s, p, 0.0, STR, symtab);
 246         setsval(q, p);
 247         if (is_number(q->sval)) {
 248                 q->fval = atof(q->sval);
 249                 q->tval |= NUM;
 250         }
 251            dprintf( ("command line set %s to |%s|\n", s, p) );
 252 }
 253
 254
 255 void fldbld(void)       /* create fields from current record */
 256 {
 257         /* this relies on having fields[] the same length as $0 */
 258         /* the fields are all stored in this one array with \0's */
 259         char *r, *fr, sep;
 260         Cell *p;
 261         int i, j, n;
 262
 263         if (donefld)
 264                 return;
 265         if (!isstr(fldtab[0]))
 266                 getsval(fldtab[0]);
 267         r = fldtab[0]->sval;
 268         n = strlen(r);
 269         if (n > fieldssize) {
 270                 xfree(fields);
 271                 if ((fields = (char *) malloc(n+1)) == NULL)
 272                         FATAL("out of space for fields in fldbld %d", n);
 273                 fieldssize = n;
 274         }
 275         fr = fields;
 276         i = 0;  /* number of fields accumulated here */
 277         strcpy(inputFS, *FS);
 278         if (strlen(inputFS) > 1) {      /* it's a regular expression */
 279                 i = refldbld(r, inputFS);
 280         } else if ((sep = *inputFS) == ' ') {   /* default whitespace */
 281                 for (i = 0; ; ) {
 282                         while (*r == ' ' || *r == '\t' || *r == '\n')
 283                                 r++;
 284                         if (*r == 0)
 285                                 break;
 286                         i++;
 287                         if (i > nfields)
 288                                 growfldtab(i);
 289                         if (freeable(fldtab[i]))
 290                                 xfree(fldtab[i]->sval);
 291                         fldtab[i]->sval = fr;
 292                         fldtab[i]->tval = FLD | STR | DONTFREE;
 293                         do
 294                                 *fr++ = *r++;
 295                         while (*r != ' ' && *r != '\t' && *r != '\n' && *r != '\0');
 296                         *fr++ = 0;
 297                 }
 298                 *fr = 0;
 299         } else if ((sep = *inputFS) == 0) {             /* new: FS="" => 1 char/field */
 300                 for (i = 0; *r != 0; r++) {
 301                         char buf[2];
 302                         i++;
 303                         if (i > nfields)
 304                                 growfldtab(i);
 305                         if (freeable(fldtab[i]))
 306                                 xfree(fldtab[i]->sval);
 307                         buf[0] = *r;
 308                         buf[1] = 0;
 309                         fldtab[i]->sval = tostring(buf);
 310                         fldtab[i]->tval = FLD | STR;
 311                 }
 312                 *fr = 0;
 313         } else if (*r != 0) {   /* if 0, it's a null field */
 314                 /* subtlecase : if length(FS) == 1 && length(RS > 0)
 315                  * \n is NOT a field separator (cf awk book 61,84).
 316                  * this variable is tested in the inner while loop.
 317                  */
 318                 int rtest = '\n';  /* normal case */
 319                 if (strlen(*RS) > 0)
 320                         rtest = '\0';
 321                 for (;;) {
 322                         i++;
 323                         if (i > nfields)
 324                                 growfldtab(i);
 325                         if (freeable(fldtab[i]))
 326                                 xfree(fldtab[i]->sval);
 327                         fldtab[i]->sval = fr;
 328                         fldtab[i]->tval = FLD | STR | DONTFREE;
 329                         while (*r != sep && *r != rtest && *r != '\0')  /* \n is always a separator */
 330                                 *fr++ = *r++;
 331                         *fr++ = 0;
 332                         if (*r++ == 0)
 333                                 break;
 334                 }
 335                 *fr = 0;
 336         }
 337         if (i > nfields)
 338                 FATAL("record `%.30s...' has too many fields; can't happen", r);
 339         cleanfld(i+1, lastfld); /* clean out junk from previous record */
 340         lastfld = i;
 341         donefld = 1;
 342         for (j = 1; j <= lastfld; j++) {
 343                 p = fldtab[j];
 344                 if(is_number(p->sval)) {
 345                         p->fval = atof(p->sval);
 346                         p->tval |= NUM;
 347                 }
 348         }
 349         setfval(nfloc, (Awkfloat) lastfld);
 350         if (dbg) {
 351                 for (j = 0; j <= lastfld; j++) {
 352                         p = fldtab[j];
 353                         printf("field %d (%s): |%s|\n", j, p->nval, p->sval);
 354                 }
 355         }
 356 }
 357
 358 void cleanfld(int n1, int n2)   /* clean out fields n1 .. n2 inclusive */
 359 {                               /* nvals remain intact */
 360         Cell *p;
 361         int i;
 362
 363         for (i = n1; i <= n2; i++) {
 364                 p = fldtab[i];
 365                 if (freeable(p))
 366                         xfree(p->sval);
 367                 p->sval = "";
 368                 p->tval = FLD | STR | DONTFREE;
 369         }
 370 }
 371
 372 void newfld(int n)      /* add field n after end of existing lastfld */
 373 {
 374         if (n > nfields)
 375                 growfldtab(n);
 376         cleanfld(lastfld+1, n);
 377         lastfld = n;
 378         setfval(nfloc, (Awkfloat) n);
 379 }
 380
 381 Cell *fieldadr(int n)   /* get nth field */
 382 {
 383         if (n < 0)
 384                 FATAL("trying to access out of range field %d", n);
 385         if (n > nfields)        /* fields after NF are empty */
 386                 growfldtab(n);  /* but does not increase NF */
 387         return(fldtab[n]);
 388 }
 389
 390 void growfldtab(int n)  /* make new fields up to at least $n */
 391 {
 392         int nf = 2 * nfields;
 393         size_t s;
 394
 395         if (n > nf)
 396                 nf = n;
 397         s = (nf+1) * (sizeof (struct Cell *));  /* freebsd: how much do we need? */
 398         if (s / sizeof(struct Cell *) - 1 == nf) /* didn't overflow */
 399                 fldtab = (Cell **) realloc(fldtab, s);
 400         else                                    /* overflow sizeof int */
 401                 xfree(fldtab);  /* make it null */
 402         if (fldtab == NULL)
 403                 FATAL("out of space creating %d fields", nf);
 404         makefields(nfields+1, nf);
 405         nfields = nf;
 406 }
 407
 408 int refldbld(const char *rec, const char *fs)   /* build fields from reg expr in FS */
 409 {
 410         /* this relies on having fields[] the same length as $0 */
 411         /* the fields are all stored in this one array with \0's */
 412         char *fr;
 413         int i, tempstat, n;
 414         fa *pfa;
 415
 416         n = strlen(rec);
 417         if (n > fieldssize) {
 418                 xfree(fields);
 419                 if ((fields = (char *) malloc(n+1)) == NULL)
 420                         FATAL("out of space for fields in refldbld %d", n);
 421                 fieldssize = n;
 422         }
 423         fr = fields;
 424         *fr = '\0';
 425         if (*rec == '\0')
 426                 return 0;
 427         pfa = makedfa(fs, 1);
 428            dprintf( ("into refldbld, rec = <%s>, pat = <%s>\n", rec, fs) );
 429         tempstat = pfa->initstat;
 430         for (i = 1; ; i++) {
 431                 if (i > nfields)
 432                         growfldtab(i);
 433                 if (freeable(fldtab[i]))
 434                         xfree(fldtab[i]->sval);
 435                 fldtab[i]->tval = FLD | STR | DONTFREE;
 436                 fldtab[i]->sval = fr;
 437                    dprintf( ("refldbld: i=%d\n", i) );
 438                 if (nematch(pfa, rec)) {
 439                         pfa->initstat = 2;      /* horrible coupling to b.c */
 440                            dprintf( ("match %s (%d chars)\n", patbeg, patlen) );
 441                         strncpy(fr, rec, patbeg-rec);
 442                         fr += patbeg - rec + 1;
 443                         *(fr-1) = '\0';
 444                         rec = patbeg + patlen;
 445                 } else {
 446                            dprintf( ("no match %s\n", rec) );
 447                         strcpy(fr, rec);
 448                         pfa->initstat = tempstat;
 449                         break;
 450                 }
 451         }
 452         return i;
 453 }
 454
 455 void recbld(void)       /* create $0 from $1..$NF if necessary */
 456 {
 457         int i;
 458         char *r, *p;
 459
 460         if (donerec == 1)
 461                 return;
 462         r = record;
 463         for (i = 1; i <= *NF; i++) {
 464                 p = getsval(fldtab[i]);
 465                 if (!adjbuf(&record, &recsize, 1+strlen(p)+r-record, recsize, &r, "recbld 1"))
 466                         FATAL("created $0 `%.30s...' too long", record);
 467                 while ((*r = *p++) != 0)
 468                         r++;
 469                 if (i < *NF) {
 470                         if (!adjbuf(&record, &recsize, 2+strlen(*OFS)+r-record, recsize, &r, "recbld 2"))
 471                                 FATAL("created $0 `%.30s...' too long", record);
 472                         for (p = *OFS; (*r = *p++) != 0; )
 473                                 r++;
 474                 }
 475         }
 476         if (!adjbuf(&record, &recsize, 2+r-record, recsize, &r, "recbld 3"))
 477                 FATAL("built giant record `%.30s...'", record);
 478         *r = '\0';
 479            dprintf( ("in recbld inputFS=%s, fldtab[0]=%p\n", inputFS, fldtab[0]) );
 480
 481         if (freeable(fldtab[0]))
 482                 xfree(fldtab[0]->sval);
 483         fldtab[0]->tval = REC | STR | DONTFREE;
 484         fldtab[0]->sval = record;
 485
 486            dprintf( ("in recbld inputFS=%s, fldtab[0]=%p\n", inputFS, fldtab[0]) );
 487            dprintf( ("recbld = |%s|\n", record) );
 488         donerec = 1;
 489 }
 490
 491 int     errorflag       = 0;
 492
 493 void yyerror(const char *s)
 494 {
 495         SYNTAX("%s", s);
 496 }
 497
 498 void SYNTAX(const char *fmt, ...)
 499 {
 500         extern char *cmdname, *curfname;
 501         static int been_here = 0;
 502         va_list varg;
 503
 504         if (been_here++ > 2)
 505                 return;
 506         fprintf(stderr, "%s: ", cmdname);
 507         va_start(varg, fmt);
 508         vfprintf(stderr, fmt, varg);
 509         va_end(varg);
 510         fprintf(stderr, " at source line %d", lineno);
 511         if (curfname != NULL)
 512                 fprintf(stderr, " in function %s", curfname);
 513         if (compile_time == 1 && cursource() != NULL)
 514                 fprintf(stderr, " source file %s", cursource());
 515         fprintf(stderr, "\n");
 516         errorflag = 2;
 517         eprint();
 518 }
 519
 520 void fpecatch(int n)
 521 {
 522         FATAL("floating point exception %d", n);
 523 }
 524
 525 extern int bracecnt, brackcnt, parencnt;
 526
 527 void bracecheck(void)
 528 {
 529         int c;
 530         static int beenhere = 0;
 531
 532         if (beenhere++)
 533                 return;
 534         while ((c = input()) != EOF && c != '\0')
 535                 bclass(c);
 536         bcheck2(bracecnt, '{', '}');
 537         bcheck2(brackcnt, '[', ']');
 538         bcheck2(parencnt, '(', ')');
 539 }
 540
 541 void bcheck2(int n, int c1, int c2)
 542 {
 543         if (n == 1)
 544                 fprintf(stderr, "\tmissing %c\n", c2);
 545         else if (n > 1)
 546                 fprintf(stderr, "\t%d missing %c's\n", n, c2);
 547         else if (n == -1)
 548                 fprintf(stderr, "\textra %c\n", c2);
 549         else if (n < -1)
 550                 fprintf(stderr, "\t%d extra %c's\n", -n, c2);
 551 }
 552
 553 void FATAL(const char *fmt, ...)
 554 {
 555         extern char *cmdname;
 556         va_list varg;
 557
 558         fflush(stdout);
 559         fprintf(stderr, "%s: ", cmdname);
 560         va_start(varg, fmt);
 561         vfprintf(stderr, fmt, varg);
 562         va_end(varg);
 563         error();
 564         if (dbg > 1)            /* core dump if serious debugging on */
 565                 abort();
 566         exit(2);
 567 }
 568
 569 void WARNING(const char *fmt, ...)
 570 {
 571         extern char *cmdname;
 572         va_list varg;
 573
 574         fflush(stdout);
 575         fprintf(stderr, "%s: ", cmdname);
 576         va_start(varg, fmt);
 577         vfprintf(stderr, fmt, varg);
 578         va_end(varg);
 579         error();
 580 }
 581
 582 void error()
 583 {
 584         extern Node *curnode;
 585
 586         fprintf(stderr, "\n");
 587         if (compile_time != 2 && NR && *NR > 0) {
 588                 fprintf(stderr, " input record number %d", (int) (*FNR));
 589                 if (strcmp(*FILENAME, "-") != 0)
 590                         fprintf(stderr, ", file %s", *FILENAME);
 591                 fprintf(stderr, "\n");
 592         }
 593         if (compile_time != 2 && curnode)
 594                 fprintf(stderr, " source line number %d", curnode->lineno);
 595         else if (compile_time != 2 && lineno)
 596                 fprintf(stderr, " source line number %d", lineno);
 597         if (compile_time == 1 && cursource() != NULL)
 598                 fprintf(stderr, " source file %s", cursource());
 599         fprintf(stderr, "\n");
 600         eprint();
 601 }
 602
 603 void eprint(void)       /* try to print context around error */
 604 {
 605         char *p, *q;
 606         int c;
 607         static int been_here = 0;
 608         extern char ebuf[], *ep;
 609
 610         if (compile_time == 2 || compile_time == 0 || been_here++ > 0)
 611                 return;
 612         p = ep - 1;
 613         if (p > ebuf && *p == '\n')
 614                 p--;
 615         for ( ; p > ebuf && *p != '\n' && *p != '\0'; p--)
 616                 ;
 617         while (*p == '\n')
 618                 p++;
 619         fprintf(stderr, " context is\n\t");
 620         for (q=ep-1; q>=p && *q!=' ' && *q!='\t' && *q!='\n'; q--)
 621                 ;
 622         for ( ; p < q; p++)
 623                 if (*p)
 624                         putc(*p, stderr);
 625         fprintf(stderr, " >>> ");
 626         for ( ; p < ep; p++)
 627                 if (*p)
 628                         putc(*p, stderr);
 629         fprintf(stderr, " <<< ");
 630         if (*ep)
 631                 while ((c = input()) != '\n' && c != '\0' && c != EOF) {
 632                         putc(c, stderr);
 633                         bclass(c);
 634                 }
 635         putc('\n', stderr);
 636         ep = ebuf;
 637 }
 638
 639 void bclass(int c)
 640 {
 641         switch (c) {
 642         case '{': bracecnt++; break;
 643         case '}': bracecnt--; break;
 644         case '[': brackcnt++; break;
 645         case ']': brackcnt--; break;
 646         case '(': parencnt++; break;
 647         case ')': parencnt--; break;
 648         }
 649 }
 650
 651 double errcheck(double x, const char *s)
 652 {
 653
 654         if (errno == EDOM) {
 655                 errno = 0;
 656                 WARNING("%s argument out of domain", s);
 657                 x = 1;
 658         } else if (errno == ERANGE) {
 659                 errno = 0;
 660                 WARNING("%s result out of range", s);
 661                 x = 1;
 662         }
 663         return x;
 664 }
 665
 666 int isclvar(const char *s)      /* is s of form var=something ? */
 667 {
 668         const char *os = s;
 669
 670         if (!isalpha((uschar) *s) && *s != '_')
 671                 return 0;
 672         for ( ; *s; s++)
 673                 if (!(isalnum((uschar) *s) || *s == '_'))
 674                         break;
 675         return *s == '=' && s > os && *(s+1) != '=';
 676 }
 677
 678 /* strtod is supposed to be a proper test of what's a valid number */
 679 /* appears to be broken in gcc on linux: thinks 0x123 is a valid FP number */
 680 /* wrong: violates 4.10.1.4 of ansi C standard */
 681
 682 #include <math.h>
 683 int is_number(const char *s)
 684 {
 685         double r;
 686         char *ep;
 687         errno = 0;
 688         r = strtod(s, &ep);
 689         if (ep == s || r == HUGE_VAL || errno == ERANGE)
 690                 return 0;
 691         while (*ep == ' ' || *ep == '\t' || *ep == '\n')
 692                 ep++;
 693         if (*ep == '\0')
 694                 return 1;
 695         else
 696                 return 0;
 697 }