Return to node.c CVS log

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

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

1.1     ! root        1: /*
        !             2:  * n1/node.c
        !             3:  * Utility routines for the manipulation of expression tree nodes.
        !             4:  */
        !             5: 
        !             6: #ifdef   vax
        !             7: #include "INC$LIB:cc1.h"
        !             8: #else
        !             9: #include "cc1.h"
        !            10: #endif
        !            11: 
        !            12: /*
        !            13:  * Fabricate a node for an integer constant.
        !            14:  */
        !            15: TREE *
        !            16: ivalnode(n) ival_t n;
        !            17: {
        !            18:        register TREE *tp;
        !            19: 
        !            20:        tp = alocnode();
        !            21:        tp->t_op = ICON;
        !            22:        tp->t_type = IVAL_T;
        !            23:        tp->t_ival = n;
        !            24:        return tp;
        !            25: }
        !            26: 
        !            27: /*
        !            28:  * Fabricate a node for a long constant.
        !            29:  */
        !            30: TREE *
        !            31: lvalnode(n) lval_t n;
        !            32: {
        !            33:        register TREE *tp;
        !            34: 
        !            35:        tp = alocnode();
        !            36:        tp->t_op = LCON;
        !            37:        tp->t_type = LVAL_T;
        !            38:        tp->t_lval = n;
        !            39:        return tp;
        !            40: }
        !            41: 
        !            42: /*
        !            43:  * Fabricate a node, either a long or an integer,
        !            44:  * given the type and the long value.
        !            45:  */
        !            46: TREE *
        !            47: gvalnode(t, n) lval_t n;
        !            48: {
        !            49:        if (islong(t))
        !            50:                return lvalnode(n);
        !            51:        else
        !            52:                return ivalnode((ival_t)n);
        !            53: }
        !            54: 
        !            55: /*
        !            56:  * Copy a node.
        !            57:  */
        !            58: TREE *
        !            59: copynode(tp1) TREE *tp1;
        !            60: {
        !            61:        register TREE *tp2;
        !            62: 
        !            63:        tp2 = alocnode();
        !            64:        *tp2 = *tp1;            /* Union assign */
        !            65:        return tp2;
        !            66: }
        !            67: 
        !            68: /*
        !            69:  * Make up a node.
        !            70:  * Fill in the op and the type.
        !            71:  */
        !            72: TREE *
        !            73: makenode(op, t, s)
        !            74: {
        !            75:        register TREE *tp;
        !            76: 
        !            77:        tp = alocnode();
        !            78:        tp->t_op = op;
        !            79:        tp->t_type = t;
        !            80:        if (issized(t))
        !            81:                tp->t_size = s;
        !            82:        return tp;
        !            83: }
        !            84: 
        !            85: /*
        !            86:  * Make up a node.
        !            87:  * Fill in the op, the type and the left subtree.
        !            88:  */
        !            89: TREE *
        !            90: leftnode(op, lp, t, s)
        !            91: TREE *lp;
        !            92: {
        !            93:        register TREE *tp;
        !            94: 
        !            95:        tp = makenode(op, t, s);
        !            96:        tp->t_lp = lp;
        !            97:        return tp;
        !            98: }
        !            99: 
        !           100: /*
        !           101:  * Strip off conversions.
        !           102:  */
        !           103: TREE *
        !           104: basenode(tp)
        !           105: register TREE *tp;
        !           106: {
        !           107:        register op;
        !           108: 
        !           109:        while ((op=tp->t_op)==CONVERT || op==CAST)
        !           110:                tp = tp->t_lp;
        !           111:        return tp;
        !           112: }
        !           113: 
        !           114: /*
        !           115:  * Get a new tree node.
        !           116:  * Just abort if there is no space left; this should not happen.
        !           117:  */
        !           118: TREE *
        !           119: alocnode()
        !           120: {
        !           121:        register TREE *tp;
        !           122: 
        !           123:        tp = talloc();
        !           124:        tp->t_treg = NONE;
        !           125:        tp->t_rreg = NONE;
        !           126:        return tp;
        !           127: }
        !           128: 
        !           129: /*
        !           130:  * Check if a tree node is a fixed point constant of some type.
        !           131:  */
        !           132: isfxcon(tp) TREE *tp;
        !           133: {
        !           134:        register op;
        !           135: 
        !           136:        if ((op=tp->t_op)==ICON || op==LCON)
        !           137:                return 1;
        !           138:        return 0;
        !           139: }
        !           140: 
        !           141: /*
        !           142:  * Grab numeric value.
        !           143:  */
        !           144: lval_t
        !           145: grabnval(tp) register TREE *tp;
        !           146: {
        !           147:        register op;
        !           148: 
        !           149:        op = tp->t_op;
        !           150:        if (op == ICON) {
        !           151:                if (isuns(tp->t_type))
        !           152:                        return ((unsigned) tp->t_ival);
        !           153:                return tp->t_ival;
        !           154:        }
        !           155:        if (op == LCON)
        !           156:                return tp->t_lval;
        !           157:        cbotch("grabnval");
        !           158: }
        !           159: 
        !           160: /*
        !           161:  * Is this tree node a constant 'n'?
        !           162:  * Note that 'n' is an integer (not a long).
        !           163:  */
        !           164: isnval(tp, n) register TREE *tp;
        !           165: {
        !           166:        long v;
        !           167: 
        !           168:        if (isfxcon(tp)) {
        !           169:                v = grabnval(tp);
        !           170:                if (v == n)
        !           171:                        return 1;
        !           172:        }
        !           173:        return 0;
        !           174: }
        !           175: 
        !           176: /*
        !           177:  * Make a LEAF node.
        !           178:  */
        !           179: TREE *
        !           180: leafnode(tp) register TREE *tp;
        !           181: {
        !           182:        return leftnode(LEAF, tp, tp->t_type, tp->t_size);
        !           183: }
        !           184: 
        !           185: /* end of n1/node.c */

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