Return to tran.c CVS log

Up to [local] / rpl / rplawk

Quelques patches pour rplawk et ncurses.

    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:             (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: }