Return to inter.c CVS log

Up to [Research Unix] / researchv9 / jerq / sgs / optim

Annotation of researchv9/jerq/sgs/optim/inter.c, revision 1.1.1.1

1.1       root        1: /*     static char  ID[] = "@(#) inter.c: 1.3 10/5/82";        */
                      2: 
                      3: #include "optim.h"
                      4: 
                      5: NODE *lastnode;        /* reference to node being built by Saveop */
                      6: 
                      7:        NODE *
                      8: Saveop(opn, str, len, op) /* save part of inst */
                      9:        register int opn; register char *str; unsigned len; int op; {
                     10: 
                     11:        register NODE *p = lastnode;
                     12: 
                     13:        if (opn == 0) { /* make a new node and link it in */
                     14:                p = lastnode = GETSTR(NODE);
                     15:                if ((p->op = op) != GHOST) {
                     16:                        INSNODE(p, &ntail);
                     17:                        ninst++;
                     18:                }
                     19:                for (op = 0; op < MAXOPS; )
                     20:                        p->ops[++op] = NULL;
                     21: #ifdef LIVEDEAD
                     22:                p->nlive = p->ndead = 0;
                     23: #endif
                     24: #ifdef IDVAL
                     25:                p->uniqid = IDVAL;
                     26: #endif
                     27:        }
                     28:        if (opn < 0 || opn > MAXOPS)
                     29:                fatal("invalid opn field for %s\n", str);
                     30:        p->ops[opn] = COPY(str, len);
                     31:        return (p);
                     32: }
                     33: 
                     34:        void
                     35: addref(str, len) char *str; unsigned len; { /* add text ref to reference list */
                     36: 
                     37:        register REF *r = lastref = lastref->nextref = GETSTR(REF);
                     38: 
                     39:        r->lab = COPY(str, len);
                     40:        r->nextref = NULL;
                     41: }
                     42: 
                     43:        void
                     44: filter() { /* print FILTER nodes and remove from list */
                     45: 
                     46:        register NODE *p;
                     47: 
                     48:        for (ALLN(p))
                     49:                if (p->op == FILTER) {
                     50:                        (void) puts(p->ops[0]);
                     51:                        DELNODE(p);
                     52:                }
                     53: }
                     54: 
                     55:        void
                     56: prtext() { /* print text list */
                     57: 
                     58:        register NODE *p;
                     59: 
                     60:        for (ALLN(p)) {
                     61:                prinst(p);
                     62:        }
                     63: }
                     64: 
                     65:        boolean
                     66: same(p, q) NODE *p, *q; { /* return true iff nodes are the same */
                     67: 
                     68:        register char **pp, **qq;
                     69:        register int i;
                     70: 
                     71:        if (p->op != q->op)
                     72:                return (false);
                     73: 
                     74:        /* first check for equal numbers of active operands */
                     75: 
                     76:        for (pp = p->ops, qq = q->ops, i = MAXOPS + 1;
                     77:            --i >= 0 && (*pp != NULL || *qq != NULL); pp++, qq++)
                     78:                if (*pp == NULL || *qq == NULL)
                     79:                        return (false);
                     80: 
                     81:        /* then check for equality of the active operands */
                     82: 
                     83:        while (pp > p->ops)
                     84:                if (**--pp != **--qq || strcmp(*pp, *qq))
                     85:                        return (false);
                     86:        return (true);
                     87: }
                     88: 
                     89:        boolean
                     90: sameaddr(p, q) NODE *p, *q; { /* return true iff ops[1...] are the same */
                     91: 
                     92:        register char **pp, **qq;
                     93:        register int i;
                     94: 
                     95:        /* first check for equal numbers of active operands */
                     96: 
                     97:        for (pp = p->ops, qq = q->ops, i = MAXOPS + 1;
                     98:            --i >= 0 && (*pp != NULL || *qq != NULL); pp++, qq++)
                     99:                if (*pp == NULL || *qq == NULL)
                    100:                        return (false);
                    101: 
                    102:        /* then check for equality of the active operands */
                    103: 
                    104:        while (pp > p->ops + 1)
                    105:                if (**--pp != **--qq || strcmp(*pp, *qq))
                    106:                        return (false);
                    107:        return (true);
                    108: }
                    109: 
                    110:        char *
                    111: xalloc(n) register unsigned n; { /* allocate space */
                    112: 
                    113:        extern char *malloc();
                    114:        register char *p;
                    115: 
                    116:        if ((p = malloc(n)) == NULL)
                    117:                fatal("out of space\n", (char *)NULL);
                    118:        return (p);
                    119: }
                    120: 
                    121:        void
                    122: xfree(p) char *p; { /* free up space allocated by xalloc */
                    123: 
                    124:        extern void free();
                    125: 
                    126:        free(p);                        /* return space */
                    127: }
                    128: 
                    129:        void
                    130: fatal(fmt, str) char *fmt, *str; { /* report fatal error and quit */
                    131: 
                    132:        extern void exit();
                    133: 
                    134:        FPRINTF(stderr, "Optimizer: ");
                    135:        FPRINTF(stderr, fmt, str);
                    136:        exit(2);
                    137: }

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