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 <math.h> 28 #include <ctype.h> 29 #include <string.h> 30 #include <stdlib.h> 31 #include "awk.h" 32 33 #define FULLTAB 2 /* rehash when table gets this x full */ 34 #define GROWTAB 4 /* grow table by this factor */ 35 36 Array *symtab; /* main symbol table */ 37 38 char **FS; /* initial field sep */ 39 char **RS; /* initial record sep */ 40 char **OFS; /* output field sep */ 41 char **ORS; /* output record sep */ 42 char **OFMT; /* output format for numbers */ 43 char **CONVFMT; /* format for conversions in getsval */ 44 Awkfloat *NF; /* number of fields in current record */ 45 Awkfloat *NR; /* number of current record */ 46 Awkfloat *FNR; /* number of current record in current file */ 47 char **FILENAME; /* current filename argument */ 48 Awkfloat *ARGC; /* number of arguments from command line */ 49 char **SUBSEP; /* subscript separator for a[i,j,k]; default \034 */ 50 Awkfloat *RSTART; /* start of re matched with ~; origin 1 (!) */ 51 Awkfloat *RLENGTH; /* length of same */ 52 53 Cell *fsloc; /* FS */ 54 Cell *nrloc; /* NR */ 55 Cell *nfloc; /* NF */ 56 Cell *fnrloc; /* FNR */ 57 Cell *ofsloc; /* OFS */ 58 Cell *orsloc; /* ORS */ 59 Cell *rsloc; /* RS */ 60 Array *ARGVtab; /* symbol table containing ARGV[...] */ 61 Array *ENVtab; /* symbol table containing ENVIRON[...] */ 62 Cell *rstartloc; /* RSTART */ 63 Cell *rlengthloc; /* RLENGTH */ 64 Cell *subseploc; /* SUBSEP */ 65 Cell *symtabloc; /* SYMTAB */ 66 67 Cell *nullloc; /* a guaranteed empty cell */ 68 Node *nullnode; /* zero&null, converted into a node for comparisons */ 69 Cell *literal0; 70 71 extern Cell **fldtab; 72 73 void syminit(void) /* initialize symbol table with builtin vars */ 74 { 75 literal0 = setsymtab("0", "0", 0.0, NUM|STR|CON|DONTFREE, symtab); 76 /* this is used for if(x)... tests: */ 77 nullloc = setsymtab("$zero&null", "", 0.0, NUM|STR|CON|DONTFREE, symtab); 78 nullnode = celltonode(nullloc, CCON); 79 80 fsloc = setsymtab("FS", " ", 0.0, STR|DONTFREE, symtab); 81 FS = &fsloc->sval; 82 rsloc = setsymtab("RS", "\n", 0.0, STR|DONTFREE, symtab); 83 RS = &rsloc->sval; 84 ofsloc = setsymtab("OFS", " ", 0.0, STR|DONTFREE, symtab); 85 OFS = &ofsloc->sval; 86 orsloc = setsymtab("ORS", "\n", 0.0, STR|DONTFREE, symtab); 87 ORS = &orsloc->sval; 88 OFMT = &setsymtab("OFMT", "%.6g", 0.0, STR|DONTFREE, symtab)->sval; 89 CONVFMT = &setsymtab("CONVFMT", "%.6g", 0.0, STR|DONTFREE, symtab)->sval; 90 FILENAME = &setsymtab("FILENAME", "", 0.0, STR|DONTFREE, symtab)->sval; 91 nfloc = setsymtab("NF", "", 0.0, NUM, symtab); 92 NF = &nfloc->fval; 93 nrloc = setsymtab("NR", "", 0.0, NUM, symtab); 94 NR = &nrloc->fval; 95 fnrloc = setsymtab("FNR", "", 0.0, NUM, symtab); 96 FNR = &fnrloc->fval; 97 subseploc = setsymtab("SUBSEP", "\034", 0.0, STR|DONTFREE, symtab); 98 SUBSEP = &subseploc->sval; 99 rstartloc = setsymtab("RSTART", "", 0.0, NUM, symtab); 100 RSTART = &rstartloc->fval; 101 rlengthloc = setsymtab("RLENGTH", "", 0.0, NUM, symtab); 102 RLENGTH = &rlengthloc->fval; 103 symtabloc = setsymtab("SYMTAB", "", 0.0, ARR, symtab); 104 free(symtabloc->sval); 105 symtabloc->sval = (char *) symtab; 106 } 107 108 void arginit(int ac, char **av) /* set up ARGV and ARGC */ 109 { 110 Cell *cp; 111 int i; 112 char temp[50]; 113 114 ARGC = &setsymtab("ARGC", "", (Awkfloat) ac, NUM, symtab)->fval; 115 cp = setsymtab("ARGV", "", 0.0, ARR, symtab); 116 ARGVtab = makesymtab(NSYMTAB); /* could be (int) ARGC as well */ 117 free(cp->sval); 118 cp->sval = (char *) ARGVtab; 119 for (i = 0; i < ac; i++) { 120 double result; 121 122 sprintf(temp, "%d", i); 123 if (is_number(*av, & result)) 124 setsymtab(temp, *av, result, STR|NUM, ARGVtab); 125 else 126 setsymtab(temp, *av, 0.0, STR, ARGVtab); 127 av++; 128 } 129 } 130 131 void envinit(char **envp) /* set up ENVIRON variable */ 132 { 133 Cell *cp; 134 char *p; 135 136 cp = setsymtab("ENVIRON", "", 0.0, ARR, symtab); 137 ENVtab = makesymtab(NSYMTAB); 138 free(cp->sval); 139 cp->sval = (char *) ENVtab; 140 for ( ; *envp; envp++) { 141 double result; 142 143 if ((p = strchr(*envp, '=')) == NULL) 144 continue; 145 if( p == *envp ) /* no left hand side name in env string */ 146 continue; 147 *p++ = 0; /* split into two strings at = */ 148 if (is_number(p, & result)) 149 setsymtab(*envp, p, result, STR|NUM, ENVtab); 150 else 151 setsymtab(*envp, p, 0.0, STR, ENVtab); 152 p[-1] = '='; /* restore in case env is passed down to a shell */ 153 } 154 } 155 156 Array *makesymtab(int n) /* make a new symbol table */ 157 { 158 Array *ap; 159 Cell **tp; 160 161 ap = (Array *) malloc(sizeof(*ap)); 162 tp = (Cell **) calloc(n, sizeof(*tp)); 163 if (ap == NULL || tp == NULL) 164 FATAL("out of space in makesymtab"); 165 ap->nelem = 0; 166 ap->size = n; 167 ap->tab = tp; 168 return(ap); 169 } 170 171 void freesymtab(Cell *ap) /* free a symbol table */ 172 { 173 Cell *cp, *temp; 174 Array *tp; 175 int i; 176 177 if (!isarr(ap)) 178 return; 179 tp = (Array *) ap->sval; 180 if (tp == NULL) 181 return; 182 for (i = 0; i < tp->size; i++) { 183 for (cp = tp->tab[i]; cp != NULL; cp = temp) { 184 xfree(cp->nval); 185 if (freeable(cp)) 186 xfree(cp->sval); 187 temp = cp->cnext; /* avoids freeing then using */ 188 free(cp); 189 tp->nelem--; 190 } 191 tp->tab[i] = NULL; 192 } 193 if (tp->nelem != 0) 194 WARNING("can't happen: inconsistent element count freeing %s", ap->nval); 195 free(tp->tab); 196 free(tp); 197 } 198 199 void freeelem(Cell *ap, const char *s) /* free elem s from ap (i.e., ap["s"] */ 200 { 201 Array *tp; 202 Cell *p, *prev = NULL; 203 int h; 204 205 tp = (Array *) ap->sval; 206 h = hash(s, tp->size); 207 for (p = tp->tab[h]; p != NULL; prev = p, p = p->cnext) 208 if (strcmp(s, p->nval) == 0) { 209 if (prev == NULL) /* 1st one */ 210 tp->tab[h] = p->cnext; 211 else /* middle somewhere */ 212 prev->cnext = p->cnext; 213 if (freeable(p)) 214 xfree(p->sval); 215 free(p->nval); 216 free(p); 217 tp->nelem--; 218 return; 219 } 220 } 221 222 Cell *setsymtab(const char *n, const char *s, Awkfloat f, unsigned t, Array *tp) 223 { 224 int h; 225 Cell *p; 226 227 if (n != NULL && (p = lookup(n, tp)) != NULL) { 228 DPRINTF("setsymtab found %p: n=%s s=\"%s\" f=%g t=%o\n", 229 (void*)p, NN(p->nval), NN(p->sval), p->fval, p->tval); 230 return(p); 231 } 232 p = (Cell *) malloc(sizeof(*p)); 233 if (p == NULL) 234 FATAL("out of space for symbol table at %s", n); 235 p->nval = tostring(n); 236 p->sval = s ? tostring(s) : tostring(""); 237 p->fval = f; 238 p->tval = t; 239 p->csub = CUNK; 240 p->ctype = OCELL; 241 tp->nelem++; 242 if (tp->nelem > FULLTAB * tp->size) 243 rehash(tp); 244 h = hash(n, tp->size); 245 p->cnext = tp->tab[h]; 246 tp->tab[h] = p; 247 DPRINTF("setsymtab set %p: n=%s s=\"%s\" f=%g t=%o\n", 248 (void*)p, p->nval, p->sval, p->fval, p->tval); 249 return(p); 250 } 251 252 int hash(const char *s, int n) /* form hash value for string s */ 253 { 254 unsigned hashval; 255 256 for (hashval = 0; *s != '\0'; s++) 257 hashval = (*s + 31 * hashval); 258 return hashval % n; 259 } 260 261 void rehash(Array *tp) /* rehash items in small table into big one */ 262 { 263 int i, nh, nsz; 264 Cell *cp, *op, **np; 265 266 nsz = GROWTAB * tp->size; 267 np = (Cell **) calloc(nsz, sizeof(*np)); 268 if (np == NULL) /* can't do it, but can keep running. */ 269 return; /* someone else will run out later. */ 270 for (i = 0; i < tp->size; i++) { 271 for (cp = tp->tab[i]; cp; cp = op) { 272 op = cp->cnext; 273 nh = hash(cp->nval, nsz); 274 cp->cnext = np[nh]; 275 np[nh] = cp; 276 } 277 } 278 free(tp->tab); 279 tp->tab = np; 280 tp->size = nsz; 281 } 282 283 Cell *lookup(const char *s, Array *tp) /* look for s in tp */ 284 { 285 Cell *p; 286 int h; 287 288 h = hash(s, tp->size); 289 for (p = tp->tab[h]; p != NULL; p = p->cnext) 290 if (strcmp(s, p->nval) == 0) 291 return(p); /* found it */ 292 return(NULL); /* not found */ 293 } 294 295 Awkfloat setfval(Cell *vp, Awkfloat f) /* set float val of a Cell */ 296 { 297 int fldno; 298 299 f += 0.0; /* normalise negative zero to positive zero */ 300 if ((vp->tval & (NUM | STR)) == 0) 301 funnyvar(vp, "assign to"); 302 if (isfld(vp)) { 303 donerec = false; /* mark $0 invalid */ 304 fldno = atoi(vp->nval); 305 if (fldno > *NF) 306 newfld(fldno); 307 DPRINTF("setting field %d to %g\n", fldno, f); 308 } else if (&vp->fval == NF) { 309 donerec = false; /* mark $0 invalid */ 310 setlastfld(f); 311 DPRINTF("setting NF to %g\n", f); 312 } else if (isrec(vp)) { 313 donefld = false; /* mark $1... invalid */ 314 donerec = true; 315 savefs(); 316 } else if (vp == ofsloc) { 317 if (!donerec) 318 recbld(); 319 } 320 if (freeable(vp)) 321 xfree(vp->sval); /* free any previous string */ 322 vp->tval &= ~(STR|CONVC|CONVO); /* mark string invalid */ 323 vp->fmt = NULL; 324 vp->tval |= NUM; /* mark number ok */ 325 if (f == -0) /* who would have thought this possible? */ 326 f = 0; 327 DPRINTF("setfval %p: %s = %g, t=%o\n", (void*)vp, NN(vp->nval), f, vp->tval); 328 return vp->fval = f; 329 } 330 331 void funnyvar(Cell *vp, const char *rw) 332 { 333 if (isarr(vp)) 334 FATAL("can't %s %s; it's an array name.", rw, vp->nval); 335 if (vp->tval & FCN) 336 FATAL("can't %s %s; it's a function.", rw, vp->nval); 337 WARNING("funny variable %p: n=%s s=\"%s\" f=%g t=%o", 338 (void *)vp, vp->nval, vp->sval, vp->fval, vp->tval); 339 } 340 341 char *setsval(Cell *vp, const char *s) /* set string val of a Cell */ 342 { 343 char *t; 344 int fldno; 345 Awkfloat f; 346 347 DPRINTF("starting setsval %p: %s = \"%s\", t=%o, r,f=%d,%d\n", 348 (void*)vp, NN(vp->nval), s, vp->tval, donerec, donefld); 349 if ((vp->tval & (NUM | STR)) == 0) 350 funnyvar(vp, "assign to"); 351 if (isfld(vp)) { 352 donerec = false; /* mark $0 invalid */ 353 fldno = atoi(vp->nval); 354 if (fldno > *NF) 355 newfld(fldno); 356 DPRINTF("setting field %d to %s (%p)\n", fldno, s, (const void*)s); 357 } else if (isrec(vp)) { 358 donefld = false; /* mark $1... invalid */ 359 donerec = true; 360 savefs(); 361 } else if (vp == ofsloc) { 362 if (!donerec) 363 recbld(); 364 } 365 t = s ? tostring(s) : tostring(""); /* in case it's self-assign */ 366 if (freeable(vp)) 367 xfree(vp->sval); 368 vp->tval &= ~(NUM|DONTFREE|CONVC|CONVO); 369 vp->tval |= STR; 370 vp->fmt = NULL; 371 DPRINTF("setsval %p: %s = \"%s (%p) \", t=%o r,f=%d,%d\n", 372 (void*)vp, NN(vp->nval), t, (void*)t, vp->tval, donerec, donefld); 373 vp->sval = t; 374 if (&vp->fval == NF) { 375 donerec = false; /* mark $0 invalid */ 376 f = getfval(vp); 377 setlastfld(f); 378 DPRINTF("setting NF to %g\n", f); 379 } 380 381 return(vp->sval); 382 } 383 384 Awkfloat getfval(Cell *vp) /* get float val of a Cell */ 385 { 386 if ((vp->tval & (NUM | STR)) == 0) 387 funnyvar(vp, "read value of"); 388 if (isfld(vp) && !donefld) 389 fldbld(); 390 else if (isrec(vp) && !donerec) 391 recbld(); 392 if (!isnum(vp)) { /* not a number */ 393 double fval; 394 bool no_trailing; 395 396 if (is_valid_number(vp->sval, true, & no_trailing, & fval)) { 397 vp->fval = fval; 398 if (no_trailing && !(vp->tval&CON)) 399 vp->tval |= NUM; /* make NUM only sparingly */ 400 } else 401 vp->fval = 0.0; 402 } 403 DPRINTF("getfval %p: %s = %g, t=%o\n", 404 (void*)vp, NN(vp->nval), vp->fval, vp->tval); 405 return(vp->fval); 406 } 407 408 static const char *get_inf_nan(double d) 409 { 410 if (isinf(d)) { 411 return (d < 0 ? "-inf" : "+inf"); 412 } else if (isnan(d)) { 413 return (signbit(d) != 0 ? "-nan" : "+nan"); 414 } else 415 return NULL; 416 } 417 418 static char *get_str_val(Cell *vp, char **fmt) /* get string val of a Cell */ 419 { 420 char s[256]; 421 double dtemp; 422 const char *p; 423 424 if ((vp->tval & (NUM | STR)) == 0) 425 funnyvar(vp, "read value of"); 426 if (isfld(vp) && ! donefld) 427 fldbld(); 428 else if (isrec(vp) && ! donerec) 429 recbld(); 430 431 /* 432 * ADR: This is complicated and more fragile than is desirable. 433 * Retrieving a string value for a number associates the string 434 * value with the scalar. Previously, the string value was 435 * sticky, meaning if converted via OFMT that became the value 436 * (even though POSIX wants it to be via CONVFMT). Or if CONVFMT 437 * changed after a string value was retrieved, the original value 438 * was maintained and used. Also not per POSIX. 439 * 440 * We work around this design by adding two additional flags, 441 * CONVC and CONVO, indicating how the string value was 442 * obtained (via CONVFMT or OFMT) and _also_ maintaining a copy 443 * of the pointer to the xFMT format string used for the 444 * conversion. This pointer is only read, **never** dereferenced. 445 * The next time we do a conversion, if it's coming from the same 446 * xFMT as last time, and the pointer value is different, we 447 * know that the xFMT format string changed, and we need to 448 * redo the conversion. If it's the same, we don't have to. 449 * 450 * There are also several cases where we don't do a conversion, 451 * such as for a field (see the checks below). 452 */ 453 454 /* Don't duplicate the code for actually updating the value */ 455 #define update_str_val(vp) \ 456 { \ 457 if (freeable(vp)) \ 458 xfree(vp->sval); \ 459 if ((p = get_inf_nan(vp->fval)) != NULL) \ 460 strcpy(s, p); \ 461 else if (modf(vp->fval, &dtemp) == 0) /* it's integral */ \ 462 snprintf(s, sizeof (s), "%.30g", vp->fval); \ 463 else \ 464 snprintf(s, sizeof (s), *fmt, vp->fval); \ 465 vp->sval = tostring(s); \ 466 vp->tval &= ~DONTFREE; \ 467 vp->tval |= STR; \ 468 } 469 470 if (isstr(vp) == 0) { 471 update_str_val(vp); 472 if (fmt == OFMT) { 473 vp->tval &= ~CONVC; 474 vp->tval |= CONVO; 475 } else { 476 /* CONVFMT */ 477 vp->tval &= ~CONVO; 478 vp->tval |= CONVC; 479 } 480 vp->fmt = *fmt; 481 } else if ((vp->tval & DONTFREE) != 0 || ! isnum(vp) || isfld(vp)) { 482 goto done; 483 } else if (isstr(vp)) { 484 if (fmt == OFMT) { 485 if ((vp->tval & CONVC) != 0 486 || ((vp->tval & CONVO) != 0 && vp->fmt != *fmt)) { 487 update_str_val(vp); 488 vp->tval &= ~CONVC; 489 vp->tval |= CONVO; 490 vp->fmt = *fmt; 491 } 492 } else { 493 /* CONVFMT */ 494 if ((vp->tval & CONVO) != 0 495 || ((vp->tval & CONVC) != 0 && vp->fmt != *fmt)) { 496 update_str_val(vp); 497 vp->tval &= ~CONVO; 498 vp->tval |= CONVC; 499 vp->fmt = *fmt; 500 } 501 } 502 } 503 done: 504 DPRINTF("getsval %p: %s = \"%s (%p)\", t=%o\n", 505 (void*)vp, NN(vp->nval), vp->sval, (void*)vp->sval, vp->tval); 506 return(vp->sval); 507 } 508 509 char *getsval(Cell *vp) /* get string val of a Cell */ 510 { 511 return get_str_val(vp, CONVFMT); 512 } 513 514 char *getpssval(Cell *vp) /* get string val of a Cell for print */ 515 { 516 return get_str_val(vp, OFMT); 517 } 518 519 520 char *tostring(const char *s) /* make a copy of string s */ 521 { 522 char *p = strdup(s); 523 if (p == NULL) 524 FATAL("out of space in tostring on %s", s); 525 return(p); 526 } 527 528 char *tostringN(const char *s, size_t n) /* make a copy of string s */ 529 { 530 char *p; 531 532 p = (char *) malloc(n); 533 if (p == NULL) 534 FATAL("out of space in tostring on %s", s); 535 strcpy(p, s); 536 return(p); 537 } 538 539 Cell *catstr(Cell *a, Cell *b) /* concatenate a and b */ 540 { 541 Cell *c; 542 char *p; 543 char *sa = getsval(a); 544 char *sb = getsval(b); 545 size_t l = strlen(sa) + strlen(sb) + 1; 546 p = (char *) malloc(l); 547 if (p == NULL) 548 FATAL("out of space concatenating %s and %s", sa, sb); 549 snprintf(p, l, "%s%s", sa, sb); 550 551 l++; // add room for ' ' 552 char *newbuf = (char *) malloc(l); 553 if (newbuf == NULL) 554 FATAL("out of space concatenating %s and %s", sa, sb); 555 // See string() in lex.c; a string "xx" is stored in the symbol 556 // table as "xx ". 557 snprintf(newbuf, l, "%s ", p); 558 c = setsymtab(newbuf, p, 0.0, CON|STR|DONTFREE, symtab); 559 free(p); 560 free(newbuf); 561 return c; 562 } 563 564 char *qstring(const char *is, int delim) /* collect string up to next delim */ 565 { 566 int c, n; 567 const uschar *s = (const uschar *) is; 568 uschar *buf, *bp; 569 570 if ((buf = (uschar *) malloc(strlen(is)+3)) == NULL) 571 FATAL( "out of space in qstring(%s)", s); 572 for (bp = buf; (c = *s) != delim; s++) { 573 if (c == '\n') 574 SYNTAX( "newline in string %.20s...", is ); 575 else if (c != '\\') 576 *bp++ = c; 577 else { /* \something */ 578 c = *++s; 579 if (c == 0) { /* \ at end */ 580 *bp++ = '\\'; 581 break; /* for loop */ 582 } 583 switch (c) { 584 case '\\': *bp++ = '\\'; break; 585 case 'n': *bp++ = '\n'; break; 586 case 't': *bp++ = '\t'; break; 587 case 'b': *bp++ = '\b'; break; 588 case 'f': *bp++ = '\f'; break; 589 case 'r': *bp++ = '\r'; break; 590 case 'v': *bp++ = '\v'; break; 591 case 'a': *bp++ = '\a'; break; 592 default: 593 if (!isdigit(c)) { 594 *bp++ = c; 595 break; 596 } 597 n = c - '0'; 598 if (isdigit(s[1])) { 599 n = 8 * n + *++s - '0'; 600 if (isdigit(s[1])) 601 n = 8 * n + *++s - '0'; 602 } 603 *bp++ = n; 604 break; 605 } 606 } 607 } 608 *bp++ = 0; 609 return (char *) buf; 610 } 611 612 const char *flags2str(int flags) 613 { 614 static const struct ftab { 615 const char *name; 616 int value; 617 } flagtab[] = { 618 { "NUM", NUM }, 619 { "STR", STR }, 620 { "DONTFREE", DONTFREE }, 621 { "CON", CON }, 622 { "ARR", ARR }, 623 { "FCN", FCN }, 624 { "FLD", FLD }, 625 { "REC", REC }, 626 { "CONVC", CONVC }, 627 { "CONVO", CONVO }, 628 { NULL, 0 } 629 }; 630 static char buf[100]; 631 int i; 632 char *cp = buf; 633 634 for (i = 0; flagtab[i].name != NULL; i++) { 635 if ((flags & flagtab[i].value) != 0) { 636 if (cp > buf) 637 *cp++ = '|'; 638 strcpy(cp, flagtab[i].name); 639 cp += strlen(cp); 640 } 641 } 642 643 return buf; 644 } 645