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     ! 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.