Return to for.c CVS log

Up to [Research Unix] / researchv9 / cmd / pic

Annotation of researchv9/cmd/pic/for.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: #include "pic.h"
                      3: #include "y.tab.h"
                      4: 
                      5: #define        SLOP    1.001
                      6: 
                      7: typedef struct {
                      8:        char    *var;   /* index variable */
                      9:        float   to;     /* limit */
                     10:        float   by;
                     11:        int     op;     /* operator */
                     12:        char    *str;   /* string to push back */
                     13: } For;
                     14: 
                     15: For    forstk[10];     /* stack of for loops */
                     16: For    *forp = forstk; /* pointer to current top */
                     17: 
                     18: forloop(var, from, to, op, by, str)    /* set up a for loop */
                     19:        char *var;
                     20:        double from, to, by;
                     21:        int op;
                     22:        char *str;
                     23: {
                     24:        dprintf("# for %s from %g to %g by %c %g \n",
                     25:                var, from, to, op, by);
                     26:        if (++forp >= forstk+10)
                     27:                fatal("for loop nested too deep");
                     28:        forp->var = var;
                     29:        forp->to = to;
                     30:        forp->op = op;
                     31:        forp->by = by;
                     32:        forp->str = str;
                     33:        setfval(var, from);
                     34:        nextfor();
                     35:        unput('\n');
                     36: }
                     37: 
                     38: nextfor()      /* do one iteration of a for loop */
                     39: {
                     40:        /* BUG:  this should depend on op and direction */
                     41:        if (getfval(forp->var) > SLOP * forp->to) {     /* loop is done */
                     42:                free(forp->str);
                     43:                if (--forp < forstk)
                     44:                        fatal("forstk popped too far");
                     45:        } else {                /* another iteration */
                     46:                pushsrc(String, "\nEndfor\n");
                     47:                pushsrc(String, forp->str);
                     48:        }
                     49: }
                     50: 
                     51: endfor()       /* end one iteration of for loop */
                     52: {
                     53:        struct symtab *p = lookup(forp->var);
                     54: 
                     55:        switch (forp->op) {
                     56:        case '+':
                     57:        case ' ':
                     58:                p->s_val.f += forp->by;
                     59:                break;
                     60:        case '-':
                     61:                p->s_val.f -= forp->by;
                     62:                break;
                     63:        case '*':
                     64:                p->s_val.f *= forp->by;
                     65:                break;
                     66:        case '/':
                     67:                p->s_val.f /= forp->by;
                     68:                break;
                     69:        }
                     70:        nextfor();
                     71: }
                     72: 
                     73: char *ifstat(expr, thenpart, elsepart)
                     74:        double expr;
                     75:        char *thenpart, *elsepart;
                     76: {
                     77:        dprintf("if %g then <%s> else <%s>\n", expr, thenpart, elsepart? elsepart : "");
                     78:        if (expr) {
                     79:                unput('\n');
                     80:                pushsrc(Free, thenpart);
                     81:                pushsrc(String, thenpart);
                     82:                unput('\n');
                     83:                if (elsepart)
                     84:                        free(elsepart);
                     85:                return thenpart;        /* to be freed later */
                     86:        } else {
                     87:                free(thenpart);
                     88:                if (elsepart) {
                     89:                        unput('\n');
                     90:                        pushsrc(Free, elsepart);
                     91:                        pushsrc(String, elsepart);
                     92:                        unput('\n');
                     93:                }
                     94:                return elsepart;
                     95:        }
                     96: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.