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