tran.c (12646B)
1 /* $OpenBSD: tran.c,v 1.15 2011/09/28 19:27:18 millert Exp $ */ 2 /**************************************************************** 3 Copyright (C) Lucent Technologies 1997 4 All Rights Reserved 5 6 Permission to use, copy, modify, and distribute this software and 7 its documentation for any purpose and without fee is hereby 8 granted, provided that the above copyright notice appear in all 9 copies and that both that the copyright notice and this 10 permission notice and warranty disclaimer appear in supporting 11 documentation, and that the name Lucent Technologies or any of 12 its entities not be used in advertising or publicity pertaining 13 to distribution of the software without specific, written prior 14 permission. 15 16 LUCENT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 17 INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. 18 IN NO EVENT SHALL LUCENT OR ANY OF ITS ENTITIES BE LIABLE FOR ANY 19 SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 20 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER 21 IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, 22 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF 23 THIS SOFTWARE. 24 ****************************************************************/ 25 26 #define DEBUG 27 #include <stdio.h> 28 #include <math.h> 29 #include <ctype.h> 30 #include <string.h> 31 #include <stdlib.h> 32 #include "awk.h" 33 #include "ytab.h" 34 35 #define FULLTAB 2 /* rehash when table gets this x full */ 36 #define GROWTAB 4 /* grow table by this factor */ 37 38 Array *symtab; /* main symbol table */ 39 40 char **FS; /* initial field sep */ 41 char **RS; /* initial record sep */ 42 char **OFS; /* output field sep */ 43 char **ORS; /* output record sep */ 44 char **OFMT; /* output format for numbers */ 45 char **CONVFMT; /* format for conversions in getsval */ 46 Awkfloat *NF; /* number of fields in current record */ 47 Awkfloat *NR; /* number of current record */ 48 Awkfloat *FNR; /* number of current record in current file */ 49 char **FILENAME; /* current filename argument */ 50 Awkfloat *ARGC; /* number of arguments from command line */ 51 char **SUBSEP; /* subscript separator for a[i,j,k]; default \034 */ 52 Awkfloat *RSTART; /* start of re matched with ~; origin 1 (!) */ 53 Awkfloat *RLENGTH; /* length of same */ 54 55 Cell *fsloc; /* FS */ 56 Cell *nrloc; /* NR */ 57 Cell *nfloc; /* NF */ 58 Cell *fnrloc; /* FNR */ 59 Array *ARGVtab; /* symbol table containing ARGV[...] */ 60 Array *ENVtab; /* symbol table containing ENVIRON[...] */ 61 Cell *rstartloc; /* RSTART */ 62 Cell *rlengthloc; /* RLENGTH */ 63 Cell *symtabloc; /* SYMTAB */ 64 65 Cell *nullloc; /* a guaranteed empty cell */ 66 Node *nullnode; /* zero&null, converted into a node for comparisons */ 67 Cell *literal0; 68 69 extern Cell **fldtab; 70 71 void syminit(void) /* initialize symbol table with builtin vars */ 72 { 73 literal0 = setsymtab("0", "0", 0.0, NUM|STR|CON|DONTFREE, symtab); 74 /* this is used for if(x)... tests: */ 75 nullloc = setsymtab("$zero&null", "", 0.0, NUM|STR|CON|DONTFREE, symtab); 76 nullnode = celltonode(nullloc, CCON); 77 78 fsloc = setsymtab("FS", " ", 0.0, STR|DONTFREE, symtab); 79 FS = &fsloc->sval; 80 RS = &setsymtab("RS", "\n", 0.0, STR|DONTFREE, symtab)->sval; 81 OFS = &setsymtab("OFS", " ", 0.0, STR|DONTFREE, symtab)->sval; 82 ORS = &setsymtab("ORS", "\n", 0.0, STR|DONTFREE, symtab)->sval; 83 OFMT = &setsymtab("OFMT", "%.6g", 0.0, STR|DONTFREE, symtab)->sval; 84 CONVFMT = &setsymtab("CONVFMT", "%.6g", 0.0, STR|DONTFREE, symtab)->sval; 85 FILENAME = &setsymtab("FILENAME", "", 0.0, STR|DONTFREE, symtab)->sval; 86 nfloc = setsymtab("NF", "", 0.0, NUM, symtab); 87 NF = &nfloc->fval; 88 nrloc = setsymtab("NR", "", 0.0, NUM, symtab); 89 NR = &nrloc->fval; 90 fnrloc = setsymtab("FNR", "", 0.0, NUM, symtab); 91 FNR = &fnrloc->fval; 92 SUBSEP = &setsymtab("SUBSEP", "\034", 0.0, STR|DONTFREE, symtab)->sval; 93 rstartloc = setsymtab("RSTART", "", 0.0, NUM, symtab); 94 RSTART = &rstartloc->fval; 95 rlengthloc = setsymtab("RLENGTH", "", 0.0, NUM, symtab); 96 RLENGTH = &rlengthloc->fval; 97 symtabloc = setsymtab("SYMTAB", "", 0.0, ARR, symtab); 98 symtabloc->sval = (char *) symtab; 99 } 100 101 void arginit(int ac, char **av) /* set up ARGV and ARGC */ 102 { 103 Cell *cp; 104 int i; 105 char temp[50]; 106 107 ARGC = &setsymtab("ARGC", "", (Awkfloat) ac, NUM, symtab)->fval; 108 cp = setsymtab("ARGV", "", 0.0, ARR, symtab); 109 ARGVtab = makesymtab(NSYMTAB); /* could be (int) ARGC as well */ 110 cp->sval = (char *) ARGVtab; 111 for (i = 0; i < ac; i++) { 112 snprintf(temp, sizeof temp, "%d", i); 113 if (is_number(*av)) 114 setsymtab(temp, *av, atof(*av), STR|NUM, ARGVtab); 115 else 116 setsymtab(temp, *av, 0.0, STR, ARGVtab); 117 av++; 118 } 119 } 120 121 void envinit(char **envp) /* set up ENVIRON variable */ 122 { 123 Cell *cp; 124 char *p; 125 126 cp = setsymtab("ENVIRON", "", 0.0, ARR, symtab); 127 ENVtab = makesymtab(NSYMTAB); 128 cp->sval = (char *) ENVtab; 129 for ( ; *envp; envp++) { 130 if ((p = strchr(*envp, '=')) == NULL) 131 continue; 132 if( p == *envp ) /* no left hand side name in env string */ 133 continue; 134 *p++ = 0; /* split into two strings at = */ 135 if (is_number(p)) 136 setsymtab(*envp, p, atof(p), STR|NUM, ENVtab); 137 else 138 setsymtab(*envp, p, 0.0, STR, ENVtab); 139 p[-1] = '='; /* restore in case env is passed down to a shell */ 140 } 141 } 142 143 Array *makesymtab(int n) /* make a new symbol table */ 144 { 145 Array *ap; 146 Cell **tp; 147 148 ap = (Array *) malloc(sizeof(Array)); 149 tp = (Cell **) calloc(n, sizeof(Cell *)); 150 if (ap == NULL || tp == NULL) 151 FATAL("out of space in makesymtab"); 152 ap->nelem = 0; 153 ap->size = n; 154 ap->tab = tp; 155 return(ap); 156 } 157 158 void freesymtab(Cell *ap) /* free a symbol table */ 159 { 160 Cell *cp, *temp; 161 Array *tp; 162 int i; 163 164 if (!isarr(ap)) 165 return; 166 tp = (Array *) ap->sval; 167 if (tp == NULL) 168 return; 169 for (i = 0; i < tp->size; i++) { 170 for (cp = tp->tab[i]; cp != NULL; cp = temp) { 171 xfree(cp->nval); 172 if (freeable(cp)) 173 xfree(cp->sval); 174 temp = cp->cnext; /* avoids freeing then using */ 175 free(cp); 176 tp->nelem--; 177 } 178 tp->tab[i] = 0; 179 } 180 if (tp->nelem != 0) 181 WARNING("can't happen: inconsistent element count freeing %s", ap->nval); 182 free(tp->tab); 183 free(tp); 184 } 185 186 void freeelem(Cell *ap, const char *s) /* free elem s from ap (i.e., ap["s"] */ 187 { 188 Array *tp; 189 Cell *p, *prev = NULL; 190 int h; 191 192 tp = (Array *) ap->sval; 193 h = hash(s, tp->size); 194 for (p = tp->tab[h]; p != NULL; prev = p, p = p->cnext) 195 if (strcmp(s, p->nval) == 0) { 196 if (prev == NULL) /* 1st one */ 197 tp->tab[h] = p->cnext; 198 else /* middle somewhere */ 199 prev->cnext = p->cnext; 200 if (freeable(p)) 201 xfree(p->sval); 202 free(p->nval); 203 free(p); 204 tp->nelem--; 205 return; 206 } 207 } 208 209 Cell *setsymtab(const char *n, const char *s, Awkfloat f, unsigned t, Array *tp) 210 { 211 int h; 212 Cell *p; 213 214 if (n != NULL && (p = lookup(n, tp)) != NULL) { 215 dprintf( ("setsymtab found %p: n=%s s=\"%s\" f=%g t=%o\n", 216 (void*)p, NN(p->nval), NN(p->sval), p->fval, p->tval) ); 217 return(p); 218 } 219 p = (Cell *) malloc(sizeof(Cell)); 220 if (p == NULL) 221 FATAL("out of space for symbol table at %s", n); 222 p->nval = tostring(n); 223 p->sval = s ? tostring(s) : tostring(""); 224 p->fval = f; 225 p->tval = t; 226 p->csub = CUNK; 227 p->ctype = OCELL; 228 tp->nelem++; 229 if (tp->nelem > FULLTAB * tp->size) 230 rehash(tp); 231 h = hash(n, tp->size); 232 p->cnext = tp->tab[h]; 233 tp->tab[h] = p; 234 dprintf( ("setsymtab set %p: n=%s s=\"%s\" f=%g t=%o\n", 235 (void*)p, p->nval, p->sval, p->fval, p->tval) ); 236 return(p); 237 } 238 239 int hash(const char *s, int n) /* form hash value for string s */ 240 { 241 unsigned hashval; 242 243 for (hashval = 0; *s != '\0'; s++) 244 hashval = (*s + 31 * hashval); 245 return hashval % n; 246 } 247 248 void rehash(Array *tp) /* rehash items in small table into big one */ 249 { 250 int i, nh, nsz; 251 Cell *cp, *op, **np; 252 253 nsz = GROWTAB * tp->size; 254 np = (Cell **) calloc(nsz, sizeof(Cell *)); 255 if (np == NULL) /* can't do it, but can keep running. */ 256 return; /* someone else will run out later. */ 257 for (i = 0; i < tp->size; i++) { 258 for (cp = tp->tab[i]; cp; cp = op) { 259 op = cp->cnext; 260 nh = hash(cp->nval, nsz); 261 cp->cnext = np[nh]; 262 np[nh] = cp; 263 } 264 } 265 free(tp->tab); 266 tp->tab = np; 267 tp->size = nsz; 268 } 269 270 Cell *lookup(const char *s, Array *tp) /* look for s in tp */ 271 { 272 Cell *p; 273 int h; 274 275 h = hash(s, tp->size); 276 for (p = tp->tab[h]; p != NULL; p = p->cnext) 277 if (strcmp(s, p->nval) == 0) 278 return(p); /* found it */ 279 return(NULL); /* not found */ 280 } 281 282 Awkfloat setfval(Cell *vp, Awkfloat f) /* set float val of a Cell */ 283 { 284 int fldno; 285 286 if ((vp->tval & (NUM | STR)) == 0) 287 funnyvar(vp, "assign to"); 288 if (isfld(vp)) { 289 donerec = 0; /* mark $0 invalid */ 290 fldno = atoi(vp->nval); 291 if (fldno > *NF) 292 newfld(fldno); 293 dprintf( ("setting field %d to %g\n", fldno, f) ); 294 } else if (isrec(vp)) { 295 donefld = 0; /* mark $1... invalid */ 296 donerec = 1; 297 } 298 if (freeable(vp)) 299 xfree(vp->sval); /* free any previous string */ 300 vp->tval &= ~STR; /* mark string invalid */ 301 vp->tval |= NUM; /* mark number ok */ 302 dprintf( ("setfval %p: %s = %g, t=%o\n", (void*)vp, NN(vp->nval), f, vp->tval) ); 303 return vp->fval = f; 304 } 305 306 void funnyvar(Cell *vp, const char *rw) 307 { 308 if (isarr(vp)) 309 FATAL("can't %s %s; it's an array name.", rw, vp->nval); 310 if (vp->tval & FCN) 311 FATAL("can't %s %s; it's a function.", rw, vp->nval); 312 WARNING("funny variable %p: n=%s s=\"%s\" f=%g t=%o", 313 vp, vp->nval, vp->sval, vp->fval, vp->tval); 314 } 315 316 char *setsval(Cell *vp, const char *s) /* set string val of a Cell */ 317 { 318 char *t; 319 int fldno; 320 321 dprintf( ("starting setsval %p: %s = \"%s\", t=%o, r,f=%d,%d\n", 322 (void*)vp, NN(vp->nval), s, vp->tval, donerec, donefld) ); 323 if ((vp->tval & (NUM | STR)) == 0) 324 funnyvar(vp, "assign to"); 325 if (isfld(vp)) { 326 donerec = 0; /* mark $0 invalid */ 327 fldno = atoi(vp->nval); 328 if (fldno > *NF) 329 newfld(fldno); 330 dprintf( ("setting field %d to %s (%p)\n", fldno, s, s) ); 331 } else if (isrec(vp)) { 332 donefld = 0; /* mark $1... invalid */ 333 donerec = 1; 334 } 335 t = tostring(s); /* in case it's self-assign */ 336 if (freeable(vp)) 337 xfree(vp->sval); 338 vp->tval &= ~NUM; 339 vp->tval |= STR; 340 vp->tval &= ~DONTFREE; 341 dprintf( ("setsval %p: %s = \"%s (%p) \", t=%o r,f=%d,%d\n", 342 (void*)vp, NN(vp->nval), t,t, vp->tval, donerec, donefld) ); 343 return(vp->sval = t); 344 } 345 346 Awkfloat getfval(Cell *vp) /* get float val of a Cell */ 347 { 348 if ((vp->tval & (NUM | STR)) == 0) 349 funnyvar(vp, "read value of"); 350 if (isfld(vp) && donefld == 0) 351 fldbld(); 352 else if (isrec(vp) && donerec == 0) 353 recbld(); 354 if (!isnum(vp)) { /* not a number */ 355 vp->fval = atof(vp->sval); /* best guess */ 356 if (is_number(vp->sval) && !(vp->tval&CON)) 357 vp->tval |= NUM; /* make NUM only sparingly */ 358 } 359 dprintf( ("getfval %p: %s = %g, t=%o\n", 360 (void*)vp, NN(vp->nval), vp->fval, vp->tval) ); 361 return(vp->fval); 362 } 363 364 static char *get_str_val(Cell *vp, char **fmt) /* get string val of a Cell */ 365 { 366 int n; 367 double dtemp; 368 369 if ((vp->tval & (NUM | STR)) == 0) 370 funnyvar(vp, "read value of"); 371 if (isfld(vp) && donefld == 0) 372 fldbld(); 373 else if (isrec(vp) && donerec == 0) 374 recbld(); 375 if (isstr(vp) == 0) { 376 if (freeable(vp)) 377 xfree(vp->sval); 378 if (modf(vp->fval, &dtemp) == 0) /* it's integral */ 379 n = asprintf(&vp->sval, "%.30g", vp->fval); 380 else 381 n = asprintf(&vp->sval, *fmt, vp->fval); 382 if (n == -1) 383 FATAL("out of space in get_str_val"); 384 vp->tval &= ~DONTFREE; 385 vp->tval |= STR; 386 } 387 dprintf( ("getsval %p: %s = \"%s (%p)\", t=%o\n", 388 (void*)vp, NN(vp->nval), vp->sval, vp->sval, vp->tval) ); 389 return(vp->sval); 390 } 391 392 char *getsval(Cell *vp) /* get string val of a Cell */ 393 { 394 return get_str_val(vp, CONVFMT); 395 } 396 397 char *getpssval(Cell *vp) /* get string val of a Cell for print */ 398 { 399 return get_str_val(vp, OFMT); 400 } 401 402 403 char *tostring(const char *s) /* make a copy of string s */ 404 { 405 char *p; 406 407 p = strdup(s); 408 if (p == NULL) 409 FATAL("out of space in tostring on %s", s); 410 return p; 411 } 412 413 char *qstring(const char *is, int delim) /* collect string up to next delim */ 414 { 415 const char *os = is; 416 int c, n; 417 uschar *s = (uschar *) is; 418 uschar *buf, *bp; 419 420 if ((buf = (uschar *) malloc(strlen(is)+3)) == NULL) 421 FATAL( "out of space in qstring(%s)", s); 422 for (bp = buf; (c = *s) != delim; s++) { 423 if (c == '\n') 424 SYNTAX( "newline in string %.20s...", os ); 425 else if (c != '\\') 426 *bp++ = c; 427 else { /* \something */ 428 c = *++s; 429 if (c == 0) { /* \ at end */ 430 *bp++ = '\\'; 431 break; /* for loop */ 432 } 433 switch (c) { 434 case '\\': *bp++ = '\\'; break; 435 case 'n': *bp++ = '\n'; break; 436 case 't': *bp++ = '\t'; break; 437 case 'b': *bp++ = '\b'; break; 438 case 'f': *bp++ = '\f'; break; 439 case 'r': *bp++ = '\r'; break; 440 default: 441 if (!isdigit(c)) { 442 *bp++ = c; 443 break; 444 } 445 n = c - '0'; 446 if (isdigit(s[1])) { 447 n = 8 * n + *++s - '0'; 448 if (isdigit(s[1])) 449 n = 8 * n + *++s - '0'; 450 } 451 *bp++ = n; 452 break; 453 } 454 } 455 } 456 *bp++ = 0; 457 return (char *) buf; 458 }