Return to mtree3.c CVS log

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

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

1.1     ! root        1: /*
        !             2:  * The routine in this file handles the insertion of LEAF nodes.
        !             3:  */
        !             4: #ifdef   vax
        !             5: #include "INC$LIB:cc1.h"
        !             6: #else
        !             7: #include "cc1.h"
        !             8: #endif
        !             9: 
        !            10: /*
        !            11:  * This function inserts LEAF tree nodes at the places
        !            12:  * where the value of a subexpression must be computed.
        !            13:  * It must be done in a pass by itself because the
        !            14:  * fancy folder rearranges expressions.
        !            15:  */
        !            16: TREE *
        !            17: modleaf(tp, ac)
        !            18: register TREE *tp;
        !            19: {
        !            20:        register ldown, rdown;
        !            21:        TREE *tp1, *tp2, *tp3;
        !            22:        int c, ldentry, op, psf;
        !            23:        FLAG flag;
        !            24: 
        !            25:        if ((c=ac)==MINIT || c==MRETURN || c==MSWITCH)
        !            26:                c = MRVALUE;
        !            27:        op = tp->t_op;
        !            28:        if ((op==EQ || op==NE) && isnval(tp->t_rp, 0)) {
        !            29:                tp1 = tp->t_lp;
        !            30:                while (tp1->t_op == LEAF)
        !            31:                        tp1 = tp1->t_lp;
        !            32:                tp->t_lp = modleaf(tp1, MFLOW);
        !            33:                return (tp);
        !            34:        }
        !            35:        if (!isleaf(op)) {
        !            36:                ldentry = ldtab[op-MIOBASE];
        !            37:                if ((ldown=getli(ldentry)) == MPASSED)
        !            38:                        ldown = c;
        !            39:                else if (ldown == MHARD)
        !            40:                        ldown = getldown(tp, c);
        !            41:                if ((rdown=getri(ldentry)) == MPASSED) {
        !            42:                        rdown = c;
        !            43:                        if ((op==QUEST || op==COMMA)
        !            44:                         && (rdown==MLADDR || rdown==MRADDR))
        !            45:                                rdown = MRVALUE;
        !            46:                } else if (rdown == MHARD)
        !            47:                        rdown = getrdown(tp, c);
        !            48:                tp1 = tp->t_lp;
        !            49:                while (tp1->t_op == LEAF)
        !            50:                        tp1 = tp1->t_lp;
        !            51:                tp->t_lp = modleaf(tp1, ldown);
        !            52:                if (op!=FIELD && (tp1=tp->t_rp)!=NULL) {
        !            53:                        while (tp1->t_op == LEAF)
        !            54:                                tp1 = tp1->t_lp;
        !            55:                        tp->t_rp = modleaf(tp1, rdown);
        !            56:                }
        !            57:        }
        !            58:        if (ac!=MINIT && tp->t_op!=LEAF) {
        !            59:                flag = tp->t_flag;
        !            60:                if ((flag&T_LEAF) != 0) {
        !            61:                        if ((flag&T_NLEAF) == 0) {
        !            62:                                tp2 = findoffs(tp);
        !            63:                                psf = 0;        /* Pointer seen flag */
        !            64:                                tp1 = tp;
        !            65:                                for (;;) {
        !            66:                                        tp3 = tp1->t_rp;
        !            67:                                        if (tp3 != NULL
        !            68:                                         && ispoint(tp3->t_type)) 
        !            69:                                                psf = 1;
        !            70:                                        tp3 = tp1->t_lp;
        !            71:                                        if (tp3 == tp2)
        !            72:                                                break;
        !            73:                                        tp1 = tp3;
        !            74:                                }
        !            75:                                flag = tp2->t_flag;
        !            76:                                if ((flag&T_LEAF)!=0 && tp2->t_op!=LEAF) {
        !            77:                                        tp2 = leafnode(tp2);
        !            78:                                        amd(tp2);
        !            79:                                        tp1->t_lp = tp2;
        !            80:                                }
        !            81:                                if ((tp2->t_op==LEAF || tp2->t_op==CONVERT
        !            82:                                ||  tp2->t_op==CAST)
        !            83:                                &&  psf == 0)
        !            84:                                        setofstype(tp2);
        !            85:                        }
        !            86:                        if (ac!=MLADDR && ac!=MRADDR && tp->t_op!=LEAF) {
        !            87:                                tp = leafnode(tp);
        !            88:                                if (ac == MFNARG)
        !            89:                                        fixtoptype(tp);
        !            90:                                amd(tp);
        !            91:                        }
        !            92:                }
        !            93:        }
        !            94:        return (tp);
        !            95: }

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