![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to node.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n1|
Return to node.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n1 |
1.1 root 1: /*
2: * Utility routines for the
3: * manipulation of expression tree
4: * nodes.
5: */
6: #ifdef vax
7: #include "INC$LIB:cc1.h"
8: #else
9: #include "cc1.h"
10: #endif
11:
12:
13: /*
14: * Fabricate a node for an
15: * integer constant.
16: */
17: TREE *
18: ivalnode(n)
19: ival_t n;
20: {
21: register TREE *tp;
22:
23: tp = alocnode();
24: tp->t_op = ICON;
25: tp->t_type = IVAL_T;
26: tp->t_ival = n;
27: return (tp);
28: }
29:
30: /*
31: * Fabricate a node for a
32: * long constant.
33: */
34: TREE *
35: lvalnode(n)
36: lval_t n;
37: {
38: register TREE *tp;
39:
40: tp = alocnode();
41: tp->t_op = LCON;
42: tp->t_type = LVAL_T;
43: tp->t_lval = n;
44: return (tp);
45: }
46:
47: /*
48: * Fabricate a node, either a
49: * long or an integer, given the
50: * type and the long value.
51: */
52: TREE *
53: gvalnode(t, n)
54: lval_t n;
55: {
56: if (islong(t))
57: return (lvalnode(n));
58: else
59: return (ivalnode((ival_t)n));
60: }
61:
62: /*
63: * Copy a node.
64: */
65: TREE *
66: copynode(tp1)
67: TREE *tp1;
68: {
69: register TREE *tp2;
70:
71: tp2 = alocnode();
72: *tp2 = *tp1; /* Union assign */
73: return (tp2);
74: }
75:
76: /*
77: * Make up a node.
78: * Fill in the op and the type.
79: */
80: TREE *
81: makenode(op, t, s)
82: {
83: register TREE *tp;
84:
85: tp = alocnode();
86: tp->t_op = op;
87: tp->t_type = t;
88: if (issized(t))
89: tp->t_size = s;
90: return (tp);
91: }
92:
93: /*
94: * Make up a node.
95: * Fill in the op, the type and
96: * the left subtree.
97: */
98: TREE *
99: leftnode(op, lp, t, s)
100: TREE *lp;
101: {
102: register TREE *tp;
103:
104: tp = makenode(op, t, s);
105: tp->t_lp = lp;
106: return (tp);
107: }
108:
109: /*
110: * Strip off conversions.
111: */
112: TREE *
113: basenode(tp)
114: register TREE *tp;
115: {
116: register op;
117:
118: while ((op=tp->t_op)==CONVERT || op==CAST)
119: tp = tp->t_lp;
120: return (tp);
121: }
122:
123: /*
124: * Get a new tree node.
125: * Just abort if there is no space
126: * left. This should not happen.
127: */
128: TREE *
129: alocnode()
130: {
131: register TREE *tp;
132:
133: tp = talloc();
134: tp->t_treg = NONE;
135: tp->t_rreg = NONE;
136: return (tp);
137: }
138:
139: /*
140: * Check if a tree node is a
141: * fixed point constant of some type.
142: */
143: isfxcon(tp)
144: TREE *tp;
145: {
146: register op;
147:
148: if ((op=tp->t_op)==ICON || op==LCON)
149: return (1);
150: return (0);
151: }
152:
153: /*
154: * Grab numeric value.
155: */
156: lval_t
157: grabnval(tp)
158: register TREE *tp;
159: {
160: register op;
161:
162: op = tp->t_op;
163: if (op == ICON) {
164: if (isuns(tp->t_type))
165: return ((unsigned) tp->t_ival);
166: return (tp->t_ival);
167: }
168: if (op == LCON)
169: return (tp->t_lval);
170: cbotch("grabnval");
171: }
172:
173: /*
174: * Is this tree node a constant `n'.
175: * Note that `n' is an integer.
176: * (Not a long).
177: */
178: isnval(tp, n)
179: register TREE *tp;
180: {
181: long v;
182:
183: if (isfxcon(tp)) {
184: v = grabnval(tp);
185: if (v == n)
186: return (1);
187: }
188: return (0);
189: }
190:
191: /*
192: * Make a LEAF node.
193: */
194: TREE *
195: leafnode(tp)
196: register TREE *tp;
197: {
198: return (leftnode(LEAF, tp, tp->t_type, tp->t_size));
199: }
200:
201: #if OVERLAID
202: /*
203: * Free all of the tree nodes.
204: */
205: freenode()
206: {
207: if (tbot != NULL) {
208: free((char *) tbot);
209: tbot = NULL;
210: }
211: }
212: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.