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