usr/src/cmd/awk/tran.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 #define DEBUG
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <ctype.h>
  36 #include <string.h>
  37 #include "awk.h"
  38 #include "y.tab.h"
  39
  40 #define FULLTAB 2       /* rehash when table gets this x full */
  41 #define GROWTAB 4       /* grow table by this factor */
  42
  43 Array   *symtab;        /* main symbol table */
  44
  45 uchar   **FS;           /* initial field sep */
  46 uchar   **RS;           /* initial record sep */
  47 uchar   **OFS;          /* output field sep */
  48 uchar   **ORS;          /* output record sep */
  49 uchar   **OFMT;         /* output format for numbers */
  50 Awkfloat *NF;           /* number of fields in current record */
  51 Awkfloat *NR;           /* number of current record */
  52 Awkfloat *FNR;          /* number of current record in current file */
  53 uchar   **FILENAME;     /* current filename argument */
  54 Awkfloat *ARGC;         /* number of arguments from command line */
  55 uchar   **SUBSEP;       /* subscript separator for a[i,j,k]; default \034 */
  56 Awkfloat *RSTART;       /* start of re matched with ~; origin 1 (!) */
  57 Awkfloat *RLENGTH;      /* length of same */
  58
  59 Cell    *recloc;        /* location of record */
  60 Cell    *nrloc;         /* NR */
  61 Cell    *nfloc;         /* NF */
  62 Cell    *fnrloc;        /* FNR */
  63 Array   *ARGVtab;       /* symbol table containing ARGV[...] */
  64 Array   *ENVtab;        /* symbol table containing ENVIRON[...] */
  65 Cell    *rstartloc;     /* RSTART */
  66 Cell    *rlengthloc;    /* RLENGTH */
  67 Cell    *symtabloc;     /* SYMTAB */
  68
  69 Cell    *nullloc;
  70 Node    *nullnode;      /* zero&null, converted into a node for comparisons */
  71
  72 static  void    rehash(Array *);
  73
  74 void
  75 syminit(void)
  76 {
  77         init_buf(&record, &record_size, LINE_INCR);
  78
  79         /* initialize $0 */
  80         recloc = getfld(0);
  81         recloc->nval = (uchar *)"$0";
  82         recloc->sval = record;
  83         recloc->tval = REC|STR|DONTFREE;
  84
  85         symtab = makesymtab(NSYMTAB);
  86         (void) setsymtab((uchar *)"0", (uchar *)"0", 0.0,
  87             NUM|STR|CON|DONTFREE, symtab);
  88         /* this is used for if(x)... tests: */
  89         nullloc = setsymtab((uchar *)"$zero&null", (uchar *)"", 0.0,
  90             NUM|STR|CON|DONTFREE, symtab);
  91         nullnode = valtonode(nullloc, CCON);
  92         FS = &setsymtab((uchar *)"FS", (uchar *)" ", 0.0,
  93             STR|DONTFREE, symtab)->sval;
  94         RS = &setsymtab((uchar *)"RS", (uchar *)"\n", 0.0,
  95             STR|DONTFREE, symtab)->sval;
  96         OFS = &setsymtab((uchar *)"OFS", (uchar *)" ", 0.0,
  97             STR|DONTFREE, symtab)->sval;
  98         ORS = &setsymtab((uchar *)"ORS", (uchar *)"\n", 0.0,
  99             STR|DONTFREE, symtab)->sval;
 100         OFMT = &setsymtab((uchar *)"OFMT", (uchar *)"%.6g", 0.0,
 101             STR|DONTFREE, symtab)->sval;
 102         FILENAME = &setsymtab((uchar *)"FILENAME", (uchar *)"-", 0.0,
 103             STR|DONTFREE, symtab)->sval;
 104         nfloc = setsymtab((uchar *)"NF", (uchar *)"", 0.0, NUM, symtab);
 105         NF = &nfloc->fval;
 106         nrloc = setsymtab((uchar *)"NR", (uchar *)"", 0.0, NUM, symtab);
 107         NR = &nrloc->fval;
 108         fnrloc = setsymtab((uchar *)"FNR", (uchar *)"", 0.0, NUM, symtab);
 109         FNR = &fnrloc->fval;
 110         SUBSEP = &setsymtab((uchar *)"SUBSEP", (uchar *)"\034", 0.0,
 111             STR|DONTFREE, symtab)->sval;
 112         rstartloc = setsymtab((uchar *)"RSTART", (uchar *)"", 0.0,
 113             NUM, symtab);
 114         RSTART = &rstartloc->fval;
 115         rlengthloc = setsymtab((uchar *)"RLENGTH", (uchar *)"", 0.0,
 116             NUM, symtab);
 117         RLENGTH = &rlengthloc->fval;
 118         symtabloc = setsymtab((uchar *)"SYMTAB", (uchar *)"", 0.0, ARR, symtab);
 119         symtabloc->sval = (uchar *)symtab;
 120 }
 121
 122 void
 123 arginit(int ac, uchar *av[])
 124 {
 125         Cell *cp;
 126         int i;
 127         uchar temp[11];
 128
 129         /* first make FILENAME first real argument */
 130         for (i = 1; i < ac; i++) {
 131                 if (!isclvar(av[i])) {
 132                         (void) setsval(lookup((uchar *)"FILENAME", symtab),
 133                             av[i]);
 134                         break;
 135                 }
 136         }
 137         ARGC = &setsymtab((uchar *)"ARGC", (uchar *)"", (Awkfloat)ac,
 138             NUM, symtab)->fval;
 139         cp = setsymtab((uchar *)"ARGV", (uchar *)"", 0.0, ARR, symtab);
 140         ARGVtab = makesymtab(NSYMTAB);  /* could be (int) ARGC as well */
 141         cp->sval = (uchar *) ARGVtab;
 142         for (i = 0; i < ac; i++) {
 143                 (void) sprintf((char *)temp, "%d", i);
 144                 if (is_number(*av)) {
 145                         (void) setsymtab(temp, *av, atof((const char *)*av),
 146                             STR|NUM, ARGVtab);
 147                 } else {
 148                         (void) setsymtab(temp, *av, 0.0, STR, ARGVtab);
 149                 }
 150                 av++;
 151         }
 152 }
 153
 154 void
 155 envinit(uchar *envp[])
 156 {
 157         Cell *cp;
 158         uchar *p;
 159
 160         cp = setsymtab((uchar *)"ENVIRON", (uchar *)"", 0.0, ARR, symtab);
 161         ENVtab = makesymtab(NSYMTAB);
 162         cp->sval = (uchar *) ENVtab;
 163         for (; *envp; envp++) {
 164                 if ((p = (uchar *)strchr((char *)*envp, '=')) == NULL)
 165                         continue;
 166                 *p++ = 0;       /* split into two strings at = */
 167                 if (is_number(p)) {
 168                         (void) setsymtab(*envp, p, atof((const char *)p),
 169                             STR|NUM, ENVtab);
 170                 } else {
 171                         (void) setsymtab(*envp, p, 0.0, STR, ENVtab);
 172                 }
 173                 /* restore in case env is passed down to a shell */
 174                 p[-1] = '=';
 175         }
 176 }
 177
 178 Array *
 179 makesymtab(int n)
 180 {
 181         Array *ap;
 182         Cell **tp;
 183
 184         ap = (Array *)malloc(sizeof (Array));
 185         tp = (Cell **)calloc(n, sizeof (Cell *));
 186         if (ap == NULL || tp == NULL)
 187                 ERROR "out of space in makesymtab" FATAL;
 188         ap->nelem = 0;
 189         ap->size = n;
 190         ap->tab = tp;
 191         return (ap);
 192 }
 193
 194 void
 195 freesymtab(Cell *ap)    /* free symbol table */
 196 {
 197         Cell *cp, *next;
 198         Array *tp;
 199         int i;
 200
 201         if (!isarr(ap))
 202                 return;
 203         /*LINTED align*/
 204         tp = (Array *)ap->sval;
 205         if (tp == NULL)
 206                 return;
 207         for (i = 0; i < tp->size; i++) {
 208                 for (cp = tp->tab[i]; cp != NULL; cp = next) {
 209                         next = cp->cnext;
 210                         xfree(cp->nval);
 211                         if (freeable(cp))
 212                                 xfree(cp->sval);
 213                         free(cp);
 214                 }
 215         }
 216         free(tp->tab);
 217         free(tp);
 218 }
 219
 220 void
 221 freeelem(Cell *ap, uchar *s)            /* free elem s from ap (i.e., ap["s"] */
 222 {
 223         Array *tp;
 224         Cell *p, *prev = NULL;
 225         int h;
 226
 227         /*LINTED align*/
 228         tp = (Array *)ap->sval;
 229         h = hash(s, tp->size);
 230         for (p = tp->tab[h]; p != NULL; prev = p, p = p->cnext)
 231                 if (strcmp((char *)s, (char *)p->nval) == 0) {
 232                         if (prev == NULL)       /* 1st one */
 233                                 tp->tab[h] = p->cnext;
 234                         else                    /* middle somewhere */
 235                                 prev->cnext = p->cnext;
 236                         if (freeable(p))
 237                                 xfree(p->sval);
 238                         free(p->nval);
 239                         free(p);
 240                         tp->nelem--;
 241                         return;
 242                 }
 243 }
 244
 245 Cell *
 246 setsymtab(uchar *n, uchar *s, Awkfloat f, unsigned int t, Array *tp)
 247 {
 248         register int h;
 249         register Cell *p;
 250
 251         if (n != NULL && (p = lookup(n, tp)) != NULL) {
 252                 dprintf(("setsymtab found %p: n=%s", (void *)p, p->nval));
 253                 dprintf((" s=\"%s\" f=%g t=%p\n",
 254                     p->sval, p->fval, (void *)p->tval));
 255                 return (p);
 256         }
 257         p = (Cell *)malloc(sizeof (Cell));
 258         if (p == NULL)
 259                 ERROR "symbol table overflow at %s", n FATAL;
 260         p->nval = tostring(n);
 261         p->sval = s ? tostring(s) : tostring((uchar *)"");
 262         p->fval = f;
 263         p->tval = t;
 264         p->csub = 0;
 265
 266         tp->nelem++;
 267         if (tp->nelem > FULLTAB * tp->size)
 268                 rehash(tp);
 269         h = hash(n, tp->size);
 270         p->cnext = tp->tab[h];
 271         tp->tab[h] = p;
 272         dprintf(("setsymtab set %p: n=%s", (void *)p, p->nval));
 273         dprintf((" s=\"%s\" f=%g t=%p\n", p->sval, p->fval, (void *)p->tval));
 274         return (p);
 275 }
 276
 277 int
 278 hash(uchar *s, int n)   /* form hash value for string s */
 279 {
 280         register unsigned hashval;
 281
 282         for (hashval = 0; *s != '\0'; s++)
 283                 hashval = (*s + 31 * hashval);
 284         return (hashval % n);
 285 }
 286
 287 static void
 288 rehash(Array *tp)       /* rehash items in small table into big one */
 289 {
 290         int i, nh, nsz;
 291         Cell *cp, *op, **np;
 292
 293         nsz = GROWTAB * tp->size;
 294         np = (Cell **)calloc(nsz, sizeof (Cell *));
 295         if (np == NULL)
 296                 ERROR "out of space in rehash" FATAL;
 297         for (i = 0; i < tp->size; i++) {
 298                 for (cp = tp->tab[i]; cp; cp = op) {
 299                         op = cp->cnext;
 300                         nh = hash(cp->nval, nsz);
 301                         cp->cnext = np[nh];
 302                         np[nh] = cp;
 303                 }
 304         }
 305         free(tp->tab);
 306         tp->tab = np;
 307         tp->size = nsz;
 308 }
 309
 310 Cell *
 311 lookup(uchar *s, Array *tp)     /* look for s in tp */
 312 {
 313         register Cell *p;
 314         int h;
 315
 316         h = hash(s, tp->size);
 317         for (p = tp->tab[h]; p != NULL; p = p->cnext) {
 318                 if (strcmp((char *)s, (char *)p->nval) == 0)
 319                         return (p);     /* found it */
 320         }
 321         return (NULL);                  /* not found */
 322 }
 323
 324 Awkfloat
 325 setfval(Cell *vp, Awkfloat f)
 326 {
 327         int     i;
 328
 329         if ((vp->tval & (NUM | STR)) == 0)
 330                 funnyvar(vp, "assign to");
 331         if (vp->tval & FLD) {
 332                 donerec = 0;    /* mark $0 invalid */
 333                 i = fldidx(vp);
 334                 if (i > *NF)
 335                         newfld(i);
 336                 dprintf(("setting field %d to %g\n", i, f));
 337         } else if (vp->tval & REC) {
 338                 donefld = 0;    /* mark $1... invalid */
 339                 donerec = 1;
 340         }
 341         vp->tval &= ~STR;       /* mark string invalid */
 342         vp->tval |= NUM;        /* mark number ok */
 343         dprintf(("setfval %p: %s = %g, t=%p\n", (void *)vp,
 344             vp->nval ? vp->nval : (unsigned char *)"NULL",
 345             f, (void *)vp->tval));
 346         return (vp->fval = f);
 347 }
 348
 349 void
 350 funnyvar(Cell *vp, char *rw)
 351 {
 352         if (vp->tval & ARR)
 353                 ERROR "can't %s %s; it's an array name.", rw, vp->nval FATAL;
 354         if (vp->tval & FCN)
 355                 ERROR "can't %s %s; it's a function.", rw, vp->nval FATAL;
 356         ERROR "funny variable %o: n=%s s=\"%s\" f=%g t=%o",
 357             vp, vp->nval, vp->sval, vp->fval, vp->tval CONT;
 358 }
 359
 360 uchar *
 361 setsval(Cell *vp, uchar *s)
 362 {
 363         int     i;
 364
 365         if ((vp->tval & (NUM | STR)) == 0)
 366                 funnyvar(vp, "assign to");
 367         if (vp->tval & FLD) {
 368                 donerec = 0;    /* mark $0 invalid */
 369                 i = fldidx(vp);
 370                 if (i > *NF)
 371                         newfld(i);
 372                 dprintf(("setting field %d to %s\n", i, s));
 373         } else if (vp->tval & REC) {
 374                 donefld = 0;    /* mark $1... invalid */
 375                 donerec = 1;
 376         }
 377         vp->tval &= ~NUM;
 378         vp->tval |= STR;
 379         if (freeable(vp))
 380                 xfree(vp->sval);
 381         vp->tval &= ~DONTFREE;
 382         dprintf(("setsval %p: %s = \"%s\", t=%p\n",
 383             (void *)vp,
 384             vp->nval ? (char *)vp->nval : "",
 385             s,
 386             (void *)(vp->tval ? (char *)vp->tval : "")));
 387         return (vp->sval = tostring(s));
 388 }
 389
 390 Awkfloat
 391 r_getfval(Cell *vp)
 392 {
 393         if ((vp->tval & (NUM | STR)) == 0)
 394                 funnyvar(vp, "read value of");
 395         if ((vp->tval & FLD) && donefld == 0)
 396                 fldbld();
 397         else if ((vp->tval & REC) && donerec == 0)
 398                 recbld();
 399         if (!isnum(vp)) {       /* not a number */
 400                 vp->fval = atof((const char *)vp->sval);        /* best guess */
 401                 if (is_number(vp->sval) && !(vp->tval&CON))
 402                         vp->tval |= NUM;        /* make NUM only sparingly */
 403         }
 404         dprintf(("getfval %p: %s = %g, t=%p\n",
 405             (void *)vp, vp->nval, vp->fval, (void *)vp->tval));
 406         return (vp->fval);
 407 }
 408
 409 uchar *
 410 r_getsval(Cell *vp)
 411 {
 412         uchar s[256];
 413
 414         if ((vp->tval & (NUM | STR)) == 0)
 415                 funnyvar(vp, "read value of");
 416         if ((vp->tval & FLD) && donefld == 0)
 417                 fldbld();
 418         else if ((vp->tval & REC) && donerec == 0)
 419                 recbld();
 420         if ((vp->tval & STR) == 0) {
 421                 if (!(vp->tval&DONTFREE))
 422                         xfree(vp->sval);
 423                 if ((long long)vp->fval == vp->fval) {
 424                         (void) snprintf((char *)s, sizeof (s),
 425                             "%.20g", vp->fval);
 426                 } else {
 427                         /*LINTED*/
 428                         (void) snprintf((char *)s, sizeof (s),
 429                             (char *)*OFMT, vp->fval);
 430                 }
 431                 vp->sval = tostring(s);
 432                 vp->tval &= ~DONTFREE;
 433                 vp->tval |= STR;
 434         }
 435         dprintf(("getsval %p: %s = \"%s\", t=%p\n",
 436             (void *)vp,
 437             vp->nval ? (char *)vp->nval : "",
 438             vp->sval ? (char *)vp->sval : "",
 439             (void *)vp->tval));
 440         return (vp->sval);
 441 }
 442
 443 uchar *
 444 tostring(uchar *s)
 445 {
 446         register uchar *p;
 447
 448         p = (uchar *)malloc(strlen((char *)s)+1);
 449         if (p == NULL)
 450                 ERROR "out of space in tostring on %s", s FATAL;
 451         (void) strcpy((char *)p, (char *)s);
 452         return (p);
 453 }
 454
 455 uchar *
 456 qstring(uchar *s, int delim)    /* collect string up to delim */
 457 {
 458         uchar *cbuf, *ret;
 459         int c, n;
 460         size_t  cbufsz, cnt;
 461
 462         init_buf(&cbuf, &cbufsz, LINE_INCR);
 463
 464         for (cnt = 0; (c = *s) != delim; s++) {
 465                 if (c == '\n') {
 466                         ERROR "newline in string %.10s...", cbuf SYNTAX;
 467                 } else if (c != '\\') {
 468                         expand_buf(&cbuf, &cbufsz, cnt);
 469                         cbuf[cnt++] = c;
 470                 } else {        /* \something */
 471                         expand_buf(&cbuf, &cbufsz, cnt);
 472                         switch (c = *++s) {
 473                         case '\\':      cbuf[cnt++] = '\\'; break;
 474                         case 'n':       cbuf[cnt++] = '\n'; break;
 475                         case 't':       cbuf[cnt++] = '\t'; break;
 476                         case 'b':       cbuf[cnt++] = '\b'; break;
 477                         case 'f':       cbuf[cnt++] = '\f'; break;
 478                         case 'r':       cbuf[cnt++] = '\r'; break;
 479                         default:
 480                                 if (!isdigit(c)) {
 481                                         cbuf[cnt++] = c;
 482                                         break;
 483                                 }
 484                                 n = c - '0';
 485                                 if (isdigit(s[1])) {
 486                                         n = 8 * n + *++s - '0';
 487                                         if (isdigit(s[1]))
 488                                                 n = 8 * n + *++s - '0';
 489                                 }
 490                                 cbuf[cnt++] = n;
 491                                 break;
 492                         }
 493                 }
 494         }
 495         cbuf[cnt] = '\0';
 496         ret = tostring(cbuf);
 497         free(cbuf);
 498         return (ret);
 499 }