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