contrib/awk20070501/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] = 0;
 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                         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                 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            dprintf( ("setfval %p: %s = %g, t=%o\n", vp, NN(vp->nval), f, vp->tval) );
 302         return vp->fval = f;
 303 }
 304
 305 void funnyvar(Cell *vp, const char *rw)
 306 {
 307         if (isarr(vp))
 308                 FATAL("can't %s %s; it's an array name.", rw, vp->nval);
 309         if (vp->tval & FCN)
 310                 FATAL("can't %s %s; it's a function.", rw, vp->nval);
 311         WARNING("funny variable %p: n=%s s=\"%s\" f=%g t=%o",
 312                 vp, vp->nval, vp->sval, vp->fval, vp->tval);
 313 }
 314
 315 char *setsval(Cell *vp, const char *s)  /* set string val of a Cell */
 316 {
 317         char *t;
 318         int fldno;
 319
 320            dprintf( ("starting setsval %p: %s = \"%s\", t=%o, r,f=%d,%d\n",
 321                 vp, NN(vp->nval), s, vp->tval, donerec, donefld) );
 322         if ((vp->tval & (NUM | STR)) == 0)
 323                 funnyvar(vp, "assign to");
 324         if (isfld(vp)) {
 325                 donerec = 0;    /* mark $0 invalid */
 326                 fldno = atoi(vp->nval);
 327                 if (fldno > *NF)
 328                         newfld(fldno);
 329                    dprintf( ("setting field %d to %s (%p)\n", fldno, s, s) );
 330         } else if (isrec(vp)) {
 331                 donefld = 0;    /* mark $1... invalid */
 332                 donerec = 1;
 333         }
 334         t = tostring(s);        /* in case it's self-assign */
 335         vp->tval &= ~NUM;
 336         vp->tval |= STR;
 337         if (freeable(vp))
 338                 xfree(vp->sval);
 339         vp->tval &= ~DONTFREE;
 340            dprintf( ("setsval %p: %s = \"%s (%p) \", t=%o r,f=%d,%d\n",
 341                 vp, NN(vp->nval), t,t, vp->tval, donerec, donefld) );
 342         return(vp->sval = t);
 343 }
 344
 345 Awkfloat getfval(Cell *vp)      /* get float val of a Cell */
 346 {
 347         if ((vp->tval & (NUM | STR)) == 0)
 348                 funnyvar(vp, "read value of");
 349         if (isfld(vp) && donefld == 0)
 350                 fldbld();
 351         else if (isrec(vp) && donerec == 0)
 352                 recbld();
 353         if (!isnum(vp)) {       /* not a number */
 354                 vp->fval = atof(vp->sval);      /* best guess */
 355                 if (is_number(vp->sval) && !(vp->tval&CON))
 356                         vp->tval |= NUM;        /* make NUM only sparingly */
 357         }
 358            dprintf( ("getfval %p: %s = %g, t=%o\n", vp, NN(vp->nval), vp->fval, vp->tval) );
 359         return(vp->fval);
 360 }
 361
 362 static char *get_str_val(Cell *vp, char **fmt)        /* get string val of a Cell */
 363 {
 364         char s[100];    /* BUG: unchecked */
 365         double dtemp;
 366
 367         if ((vp->tval & (NUM | STR)) == 0)
 368                 funnyvar(vp, "read value of");
 369         if (isfld(vp) && donefld == 0)
 370                 fldbld();
 371         else if (isrec(vp) && donerec == 0)
 372                 recbld();
 373         if (isstr(vp) == 0) {
 374                 if (freeable(vp))
 375                         xfree(vp->sval);
 376                 if (modf(vp->fval, &dtemp) == 0)        /* it's integral */
 377                         sprintf(s, "%.30g", vp->fval);
 378                 else
 379                         sprintf(s, *fmt, vp->fval);
 380                 vp->sval = tostring(s);
 381                 vp->tval &= ~DONTFREE;
 382                 vp->tval |= STR;
 383         }
 384            dprintf( ("getsval %p: %s = \"%s (%p)\", t=%o\n", vp, NN(vp->nval), vp->sval, vp->sval, vp->tval) );
 385         return(vp->sval);
 386 }
 387
 388 char *getsval(Cell *vp)       /* get string val of a Cell */
 389 {
 390       return get_str_val(vp, CONVFMT);
 391 }
 392
 393 char *getpssval(Cell *vp)     /* get string val of a Cell for print */
 394 {
 395       return get_str_val(vp, OFMT);
 396 }
 397
 398
 399 char *tostring(const char *s)   /* make a copy of string s */
 400 {
 401         char *p;
 402
 403         p = (char *) malloc(strlen(s)+1);
 404         if (p == NULL)
 405                 FATAL("out of space in tostring on %s", s);
 406         strcpy(p, s);
 407         return(p);
 408 }
 409
 410 char *qstring(const char *is, int delim)        /* collect string up to next delim */
 411 {
 412         const char *os = is;
 413         int c, n;
 414         uschar *s = (uschar *) is;
 415         uschar *buf, *bp;
 416
 417         if ((buf = (uschar *) malloc(strlen(is)+3)) == NULL)
 418                 FATAL( "out of space in qstring(%s)", s);
 419         for (bp = buf; (c = *s) != delim; s++) {
 420                 if (c == '\n')
 421                         SYNTAX( "newline in string %.20s...", os );
 422                 else if (c != '\\')
 423                         *bp++ = c;
 424                 else {  /* \something */
 425                         c = *++s;
 426                         if (c == 0) {   /* \ at end */
 427                                 *bp++ = '\\';
 428                                 break;  /* for loop */
 429                         }
 430                         switch (c) {
 431                         case '\\':      *bp++ = '\\'; break;
 432                         case 'n':       *bp++ = '\n'; break;
 433                         case 't':       *bp++ = '\t'; break;
 434                         case 'b':       *bp++ = '\b'; break;
 435                         case 'f':       *bp++ = '\f'; break;
 436                         case 'r':       *bp++ = '\r'; break;
 437                         default:
 438                                 if (!isdigit(c)) {
 439                                         *bp++ = c;
 440                                         break;
 441                                 }
 442                                 n = c - '0';
 443                                 if (isdigit(s[1])) {
 444                                         n = 8 * n + *++s - '0';
 445                                         if (isdigit(s[1]))
 446                                                 n = 8 * n + *++s - '0';
 447                                 }
 448                                 *bp++ = n;
 449                                 break;
 450                         }
 451                 }
 452         }
 453         *bp++ = 0;
 454         return (char *) buf;
 455 }