![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to wide.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / B / src / bed|
Return to wide.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / B / src / bed |
1.1 root 1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1984. */
2: static char rcsid[] = "$Header: wide.c,v 2.3 84/07/19 12:01:37 guido Exp $";
3:
4: /*
5: * B editor -- Commands to make the focus larger and smaller in various ways.
6: */
7:
8: #include "b.h"
9: #include "bobj.h"
10: #include "node.h"
11: #include "supr.h"
12: #include "gram.h"
13:
14:
15: /*
16: * Widen -- make the focus larger.
17: */
18:
19: Visible bool
20: widen(ep)
21: register environ *ep;
22: {
23: register node n;
24: register int sym;
25: register int ich;
26:
27: higher(ep);
28: grow(ep);
29:
30: n = tree(ep->focus);
31: sym = symbol(n);
32: if (ep->mode == VHOLE && (ep->s1&1))
33: ep->mode = FHOLE;
34:
35: switch (ep->mode) {
36:
37: case ATBEGIN:
38: case ATEND:
39: /* Shouldn't occur after grow(ep) */
40: ep->mode = WHOLE;
41: return Yes;
42:
43: case VHOLE:
44: if (ep->s2 >= lenitem(ep))
45: --ep->s2;
46: ep->mode = SUBRANGE;
47: ep->s3 = ep->s2;
48: return Yes;
49:
50: case FHOLE:
51: if (ep->s2 >= lenitem(ep)) {
52: if (ep->s2 > 0)
53: --ep->s2;
54: else {
55: leftvhole(ep);
56: switch (ep->mode) {
57: case ATBEGIN:
58: case ATEND:
59: ep->mode = WHOLE;
60: return Yes;
61: case VHOLE:
62: case FHOLE:
63: if (ep->s2 >= lenitem(ep)) {
64: if (ep->s2 == 0) {
65: #ifndef NDEBUG
66: debug("[Desperate in widen]");
67: #endif NDEBUG
68: ep->mode = SUBSET;
69: ep->s2 = ep->s1;
70: return widen(ep);
71: }
72: --ep->s2;
73: }
74: ep->mode = SUBRANGE;
75: ep->s3 = ep->s2;
76: return Yes;
77: }
78: Abort();
79: }
80: }
81: ep->mode = SUBRANGE;
82: ep->s3 = ep->s2;
83: return Yes;
84:
85: case SUBRANGE:
86: ep->mode = SUBSET;
87: ep->s2 = ep->s1;
88: return Yes;
89:
90: case SUBSET:
91: if (!issublist(sym) || width(lastchild(n)) == 0) {
92: ep->mode = WHOLE;
93: return Yes;
94: }
95: if (ep->s2 < 2*nchildren(n)) {
96: ep->mode = SUBLIST;
97: ep->s3 = 1;
98: return Yes;
99: }
100: /* Fall through */
101: case SUBLIST:
102: for (;;) {
103: ich = ichild(ep->focus);
104: if (!up(&ep->focus)) {
105: ep->mode = WHOLE;
106: return Yes;
107: }
108: higher(ep);
109: n = tree(ep->focus);
110: if (ich != nchildren(n) || !samelevel(sym, symbol(n))) {
111: ep->mode = SUBSET;
112: ep->s1 = ep->s2 = 2*ich;
113: return Yes;
114: }
115: }
116: /* Not reached */
117:
118: case WHOLE:
119: ich = ichild(ep->focus);
120: if (!up(&ep->focus))
121: return No;
122: n = tree(ep->focus);
123: if (issublist(symbol(n)) && ich < nchildren(n)) {
124: ep->mode = SUBLIST;
125: ep->s3 = 1;
126: }
127: return Yes;
128:
129: default:
130: Abort();
131: /* NOTREACHED */
132: }
133: /* Not reached */
134: }
135:
136:
137: /*
138: * Narrow -- make the focus smaller.
139: */
140:
141: Visible bool
142: narrow(ep)
143: register environ *ep;
144: {
145: register node n;
146: register int sym;
147: register int nch;
148: register string repr;
149:
150: higher(ep);
151:
152: shrink(ep);
153: n = tree(ep->focus);
154: sym = symbol(n);
155:
156: switch (ep->mode) {
157:
158: case ATBEGIN:
159: case ATEND:
160: case VHOLE:
161: case FHOLE:
162: return No;
163:
164: case SUBRANGE:
165: if (ep->s3 > ep->s2)
166: ep->s3 = ep->s2;
167: else
168: ep->mode = (ep->s1&1) ? FHOLE : VHOLE;
169: return Yes;
170:
171: case SUBSET:
172: if (ep->s1 <= 2) {
173: nch = nchildren(n);
174: if (ep->s2 >= 2*nch && issublist(symbol(n))) {
175: if (ep->s1 <= 1) {
176: ep->s2 = 2*nch - 1;
177: return Yes;
178: }
179: repr = noderepr(n)[0];
180: if (!Fw_positive(repr)) {
181: ep->s2 = 2*nch - 1;
182: return Yes;
183: }
184: }
185: }
186: ep->s2 = ep->s1;
187: return Yes;
188:
189: case SUBLIST:
190: Assert(ep->s3 > 1);
191: ep->s3 = 1;
192: return Yes;
193:
194: case WHOLE:
195: Assert(sym == Hole || sym == Optional);
196: return No;
197:
198: default:
199: Abort();
200: /* NOTREACHED */
201: }
202: }
203:
204:
205: Visible bool
206: extend(ep)
207: register environ *ep;
208: {
209: register node n;
210: register int i;
211: register int len;
212: register int s1save;
213:
214: grow(ep);
215: higher(ep);
216: switch (ep->mode) {
217:
218: case VHOLE:
219: case FHOLE:
220: case ATBEGIN:
221: case ATEND:
222: return widen(ep);
223:
224: case SUBRANGE:
225: len = lenitem(ep);
226: if (ep->s3 < len-1)
227: ++ep->s3;
228: else if (ep->s2 > 0)
229: --ep->s2;
230: else {
231: ep->mode = SUBSET;
232: ep->s2 = ep->s1;
233: return extend(ep); /* Recursion! */
234: }
235: return Yes;
236:
237: case SUBSET:
238: s1save = ep->s1;
239: ep->s1 = ep->s2;
240: if (nextnnitem(ep)) {
241: ep->s2 = ep->s1;
242: ep->s1 = s1save;
243: }
244: else {
245: ep->s1 = s1save;
246: prevnnitem(ep) || Abort();
247: }
248: return Yes;
249:
250: case WHOLE:
251: return up(&ep->focus);
252:
253: case SUBLIST:
254: n = tree(ep->focus);
255: for (i = ep->s3; i > 1; --i)
256: n = lastchild(n);
257: if (samelevel(symbol(n), symbol(lastchild(n)))) {
258: ++ep->s3;
259: return Yes;
260: }
261: ep->mode = WHOLE;
262: if (symbol(lastchild(n)) != Optional)
263: return Yes;
264: return extend(ep); /* Recursion! */
265:
266: default:
267: Abort();
268: /* NOTREACHED */
269: }
270: }
271:
272:
273: /*
274: * Right-Narrow -- make the focus smaller, going to the last item of a list.
275: */
276:
277: Visible bool
278: rnarrow(ep)
279: register environ *ep;
280: {
281: register node n;
282: register int i;
283: register int sym;
284:
285: higher(ep);
286:
287: shrink(ep);
288: n = tree(ep->focus);
289: sym = symbol(n);
290: if (sym == Optional || sym == Hole)
291: return No;
292:
293: switch (ep->mode) {
294:
295: case ATBEGIN:
296: case ATEND:
297: case VHOLE:
298: case FHOLE:
299: return No;
300:
301: case SUBRANGE:
302: if (ep->s3 > ep->s2)
303: ep->s2 = ep->s3;
304: else {
305: ++ep->s2;
306: ep->mode = (ep->s1&1) ? FHOLE : VHOLE;
307: }
308: return Yes;
309:
310: case SUBSET:
311: if (issublist(sym) && ep->s2 >= 2*nchildren(n)) {
312: do {
313: sym = symbol(n);
314: s_downrite(ep);
315: n = tree(ep->focus);
316: } while (samelevel(sym, symbol(n))
317: && width(lastchild(n)) != 0);
318: ep->mode = WHOLE;
319: return Yes;
320: }
321: ep->s1 = ep->s2;
322: return Yes;
323:
324: case SUBLIST:
325: Assert(ep->s3 > 1);
326: for (i = ep->s3; i > 1; --i)
327: s_downi(ep, nchildren(tree(ep->focus)));
328: ep->s3 = 1;
329: return Yes;
330:
331: case WHOLE:
332: Assert(sym == Hole || sym == Optional);
333: return No;
334:
335: default:
336: Abort();
337: /* NOTREACHED */
338: }
339: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.