Return to tree0.c CVS log

Up to [MW Coherent from dump] / coherent / b / bin / c / n1

Annotation of coherent/b/bin/c/n1/tree0.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * The routines in this file
        !             3:  * read in expression trees from the intermediate
        !             4:  * file. They are used by both the modify phase and the
        !             5:  * code generation phase.
        !             6:  */
        !             7: #ifdef   vax
        !             8: #include "INC$LIB:cc1.h"
        !             9: #else
        !            10: #include "cc1.h"
        !            11: #endif
        !            12: 
        !            13: /*
        !            14:  * Read in a tree.
        !            15:  * The tree is built up in the
        !            16:  * tree buffer.
        !            17:  * Return a pointer to the top
        !            18:  * of the tree.
        !            19:  */
        !            20: TREE *
        !            21: treeget()
        !            22: {
        !            23: 
        !            24:        newtree(sizeof(TREE));
        !            25:        return (treeget1());
        !            26: }
        !            27: 
        !            28: /*
        !            29:  * This recursive routine is
        !            30:  * the real workhorse of the tree
        !            31:  * reader.
        !            32:  * It build the node and calls
        !            33:  * itself to grab the subtrees of
        !            34:  * the node.
        !            35:  */
        !            36: TREE *
        !            37: treeget1()
        !            38: {
        !            39:        register TREE *tp;
        !            40:        register op;
        !            41: 
        !            42:        if ((op=iget()) == NIL)
        !            43:                return (NULL);
        !            44:        tp = alocnode();
        !            45:        tp->t_op = op;
        !            46:        tp->t_type = bget();
        !            47:        tp->t_size = 0;
        !            48:        if (tp->t_type == BLK)
        !            49:                tp->t_size = iget();
        !            50:        switch (op) {
        !            51: 
        !            52:        case ICON:
        !            53:                tp->t_ival = iget();
        !            54:                break;
        !            55: 
        !            56:        case LCON:
        !            57:                tp->t_lval = lget();
        !            58:                break;
        !            59: 
        !            60:        case DCON:
        !            61:                dget(tp->t_dval);
        !            62:                break;
        !            63: 
        !            64:        case AID:
        !            65:        case PID:
        !            66:                tp->t_offs = zget();
        !            67:                break;
        !            68: 
        !            69:        case LID:
        !            70:                tp->t_offs = zget();
        !            71:                tp->t_seg = bget();
        !            72:                tp->t_label  = iget();
        !            73:                break;
        !            74: 
        !            75:        case GID:
        !            76:                tp->t_offs = zget();
        !            77:                tp->t_seg = bget();
        !            78:                sget(id, NCSYMB);
        !            79:                tp->t_sp = gidpool(id);
        !            80:                break;
        !            81: 
        !            82:        case REG:
        !            83:                tp->t_reg = iget();
        !            84:                break;
        !            85: 
        !            86:        case FIELD:
        !            87:                tp->t_width = bget();
        !            88:                tp->t_base  = bget();
        !            89:                tp->t_lp = treeget1();
        !            90:                break;
        !            91: 
        !            92:        default:
        !            93:                tp->t_lp = treeget1();
        !            94:                tp->t_rp = treeget1();
        !            95:        }
        !            96:        return (tp);
        !            97: }
        !            98: 
        !            99: /*
        !           100:  * Walk a tree, calling the supplied
        !           101:  * function at each node. The order of the
        !           102:  * walk is left, right, root.
        !           103:  */
        !           104: walk(tp, f)
        !           105: TREE   *tp;
        !           106: int    (*f)();
        !           107: {
        !           108:        walk1(tp, NULL, f);
        !           109: }
        !           110: 
        !           111: walk1(tp, ptp, f)
        !           112: register TREE  *tp;
        !           113: TREE           *ptp;
        !           114: int            (*f)();
        !           115: {
        !           116:        register TREE   *stp;
        !           117: 
        !           118:        if (!isleaf(tp->t_op)) {
        !           119:                walk1(tp->t_lp, tp, f);
        !           120:                if (tp->t_op!=FIELD && (stp=tp->t_rp)!=NULL)
        !           121:                        walk1(stp, tp, f);
        !           122:        }
        !           123:        (*f)(tp, ptp);
        !           124: }

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