![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to move.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 move.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: move.c,v 2.4 85/08/22 16:05:16 timo Exp $";
3:
4: /*
5: * B editor -- Process arrow keys in four directions, plus TAB.
6: */
7:
8: #include "b.h"
9: #include "bobj.h"
10: #include "node.h"
11: #include "supr.h"
12: #include "gram.h"
13:
14: #define Left (-1)
15: #define Rite 1
16:
17:
18: /*
19: * Common code for PREVIOUS and NEXT commands.
20: */
21:
22: Hidden bool
23: prevnext(ep, direction)
24: environ *ep;
25: {
26: node n;
27: node n1;
28: int nch;
29: int i;
30: int len;
31: int sym;
32: string *rp;
33:
34: higher(ep);
35: switch (ep->mode) {
36: case VHOLE:
37: case FHOLE:
38: case ATBEGIN:
39: case ATEND:
40: if (direction == Left)
41: leftvhole(ep);
42: else
43: ritevhole(ep);
44: }
45:
46: for (;;) {
47: n = tree(ep->focus);
48: nch = nchildren(n);
49: rp = noderepr(n);
50:
51: switch (ep->mode) {
52:
53: case ATBEGIN:
54: case ATEND:
55: ep->mode = WHOLE;
56: continue;
57:
58: case VHOLE:
59: case FHOLE:
60: if (direction == Rite) {
61: if (ep->s1&1)
62: len = Fwidth(rp[ep->s1/2]);
63: else {
64: n1 = child(n, ep->s1/2);
65: len = width(n1);
66: }
67: }
68: if (direction == Rite ? ep->s2 >= len : ep->s2 <= 0) {
69: ep->mode = SUBSET;
70: ep->s2 = ep->s1;
71: return nextchar(ep, direction);
72: }
73: ep->s2 += direction;
74: return Yes;
75:
76: case SUBRANGE:
77: if (direction == Rite) {
78: if (ep->s1&1)
79: len = Fwidth(rp[ep->s1/2]);
80: else {
81: n1 = child(n, ep->s1/2);
82: len = width(n1);
83: }
84: }
85: if (direction == Left ? ep->s2 <= 0 : ep->s3 >= len-1) {
86: ep->mode = SUBSET;
87: ep->s2 = ep->s1;
88: return nextchar(ep, direction);
89: }
90: if (direction == Rite)
91: ep->s2 = ++ep->s3;
92: else
93: ep->s3 = --ep->s2;
94: return Yes;
95:
96: case SUBSET:
97: if (direction == Rite ? ep->s2 > 2*nch : ep->s1 <= 1) {
98: ep->mode = WHOLE;
99: continue;
100: }
101: if (direction == Rite)
102: ep->s1 = ++ep->s2;
103: else
104: ep->s2 = --ep->s1;
105: if (ep->s1&1) {
106: if (!Fw_positive(rp[ep->s1/2]) || allspaces(rp[ep->s1/2]))
107: continue;
108: }
109: else {
110: sym = symbol(n);
111: if (downi(&ep->focus, ep->s1/2)) {
112: n = tree(ep->focus);
113: if (((value)n)->type == Tex)
114: s_up(ep);
115: else {
116: if (ep->s1 == 2*nch && direction == Rite
117: && issublist(sym) && samelevel(sym, symbol(n))) {
118: ep->mode = SUBLIST;
119: ep->s3 = 1;
120: return Yes;
121: }
122: ep->mode = WHOLE;
123: if (width(n) == 0)
124: continue;
125: }
126: }
127: }
128: return Yes;
129:
130: case SUBLIST:
131: sym = symbol(n);
132: if (direction == Left) {
133: i = ichild(ep->focus);
134: if (!up(&ep->focus))
135: return No;
136: higher(ep);
137: n = tree(ep->focus);
138: if (i == nchildren(n) && samelevel(sym, symbol(n))) {
139: ep->s3 = 1;
140: return Yes;
141: }
142: ep->mode = SUBSET;
143: ep->s1 = ep->s2 = 2*i;
144: continue;
145: }
146: for (i = ep->s3; i > 0; --i)
147: if (!downrite(&ep->focus))
148: return No; /* Sorry... */
149: if (samelevel(sym, symbol(tree(ep->focus))))
150: ep->s3 = 1;
151: else
152: ep->mode = WHOLE;
153: return Yes;
154:
155: case WHOLE:
156: i = ichild(ep->focus);
157: if (!up(&ep->focus))
158: return No;
159: higher(ep);
160: ep->mode = SUBSET;
161: ep->s1 = ep->s2 = 2*i;
162: continue;
163:
164: default:
165: Abort();
166: }
167: }
168: /* Not reached */
169: }
170:
171: Visible bool leftarrow(ep)
172: environ *ep;
173: {
174: int w;
175: bool hole;
176:
177: if (narrow(ep)) {
178: while (narrow(ep))
179: ;
180: return Yes;
181: }
182: hole= ep->mode == WHOLE; /* Can't narrow and still WHOLE: */
183: /* a real hole which needs some hacking. */
184: if (!previous(ep))
185: return No;
186: if (hole) {
187: for (;;) {
188: w= focwidth(ep);
189: if (w >= 0 && w <= 1)
190: break;
191: if (!rnarrow(ep))
192: return No;
193: }
194: narrow(ep);
195: }
196: else {
197: while (rnarrow(ep))
198: ;
199: }
200: return Yes;
201: }
202:
203: Visible bool ritearrow(ep)
204: environ *ep;
205: {
206: while (narrow(ep))
207: ;
208: if (!next(ep))
209: return No;
210: while (narrow(ep))
211: ;
212: return Yes;
213: }
214:
215:
216: Visible bool
217: previous(ep)
218: environ *ep;
219: {
220: if (!prevnext(ep, Left))
221: return No;
222: return Yes;
223: }
224:
225:
226: Visible bool
227: next(ep)
228: environ *ep;
229: {
230: if (!prevnext(ep, Rite))
231: return No;
232: return Yes;
233: }
234:
235:
236: /*
237: * Position focus at next or previous char relative to current position.
238: * Assume current position given as SUBSET.
239: */
240:
241: Hidden bool
242: nextchar(ep, direction)
243: register environ *ep;
244: register int direction;
245: {
246: register int ich;
247: register int nch;
248: register node n;
249: node n1;
250: register int len;
251: string *rp;
252:
253: Assert(ep->mode == SUBSET);
254: for (;;) {
255: n = tree(ep->focus);
256: rp = noderepr(n);
257: nch = nchildren(n);
258: if (direction == Left)
259: ep->s2 = --ep->s1;
260: else
261: ep->s1 = ++ep->s2;
262: if (direction == Left ? ep->s1 < 1 : ep->s2 > 2*nch+1) {
263: ich = ichild(ep->focus);
264: if (!up(&ep->focus))
265: return No; /* *ep is garbage now! */
266: higher(ep);
267: ep->s1 = ep->s2 = 2*ich;
268: continue;
269: }
270: if (ep->s1&1) {
271: len = Fwidth(rp[ep->s1/2]);
272: if (len > 0) {
273: ep->mode = SUBRANGE;
274: ep->s2 = ep->s3 = direction == Left ? len-1 : 0;
275: return Yes;
276: }
277: continue;
278: }
279: n1 = child(n, ep->s1/2);
280: len = width(n1);
281: if (len == 0)
282: continue;
283: if (!downi(&ep->focus, ep->s1/2))
284: return No; /* Sorry... */
285: n = tree(ep->focus);
286: if (((value)n)->type == Tex) {
287: s_up(ep);
288: ep->mode = SUBRANGE;
289: ep->s2 = ep->s3 = direction == Left ? len-1 : 0;
290: return Yes;
291: }
292: if (direction == Left) {
293: nch = nchildren(n);
294: ep->s1 = ep->s2 = 2*(nch+1);
295: }
296: else
297: ep->s1 = ep->s2 = 0;
298: }
299: /* Not reached */
300: }
301:
302:
303: /*
304: * Up and down arrows.
305: */
306:
307: Hidden bool
308: updownarrow(ep, yincr)
309: environ *ep;
310: int yincr;
311: {
312: int y, x;
313:
314: while (narrow(ep))
315: ;
316: y= lineno(ep) + yincr;
317: x= colno(ep);
318: if (!gotoyx(ep, y, x))
319: return No;
320: gotofix(ep, y, x);
321: while (narrow(ep))
322: ;
323: return Yes;
324: }
325:
326: Visible bool
327: uparrow(ep)
328: environ *ep;
329: {
330: return updownarrow(ep, -1);
331: }
332:
333: Visible bool
334: downarrow(ep)
335: environ *ep;
336: {
337: return updownarrow(ep, 1);
338: }
339:
340: Visible bool
341: upline(ep)
342: register environ *ep;
343: {
344: register int y;
345:
346: y = lineno(ep);
347: if (y <= 0)
348: return No;
349: if (!gotoyx(ep, y-1, 0))
350: return No;
351: oneline(ep);
352: return Yes;
353: }
354:
355: Visible bool
356: downline(ep)
357: register environ *ep;
358: {
359: register int w;
360:
361: if (!parent(ep->focus) && ep->mode == ATEND)
362: return No; /* Superfluous? */
363: w = -focwidth(ep);
364: if (w <= 0)
365: w = 1;
366: if (!gotoyx(ep, lineno(ep) + w, 0))
367: return No;
368: oneline(ep);
369: return Yes;
370: }
371:
372:
373: /*
374: * ACCEPT command
375: * move to next Hole hole or to end of suggestion or to end of line.
376: */
377:
378:
379: Visible bool
380: accept(ep)
381: environ *ep;
382: {
383: int i;
384: string repr;
385:
386: shrink(ep);
387: switch (ep->mode) {
388: case ATBEGIN:
389: case ATEND:
390: case FHOLE:
391: case VHOLE:
392: ritevhole(ep);
393: }
394: if (symbol(tree(ep->focus)) == Hole)
395: ep->mode = ATEND;
396: switch (ep->mode) {
397: case ATBEGIN:
398: case SUBLIST:
399: case WHOLE:
400: i = 1;
401: break;
402: case ATEND:
403: i = 2*nchildren(tree(ep->focus)) + 2;
404: break;
405: case SUBRANGE:
406: case VHOLE:
407: case FHOLE:
408: i = ep->s1;
409: if (ep->s2 > 0 && i > 2*nchildren(tree(ep->focus)))
410: ++i; /* Kludge so after E?LSE: the focus moves to ELSE: ? */
411: break;
412: case SUBSET:
413: i = ep->s1 - 1;
414: break;
415: default:
416: Abort();
417: }
418: ep->mode = WHOLE;
419: for (;;) {
420: if (i/2 == nchildren(tree(ep->focus))) {
421: repr = noderepr(tree(ep->focus))[i/2];
422: if (Fw_positive(repr))
423: break;
424: }
425: if (tabstop(ep, i + 1))
426: return Yes;
427: i = 2*ichild(ep->focus) + 1;
428: if (!up(&ep->focus))
429: break;
430: higher(ep);
431: }
432: ep->mode = ATEND;
433: return Yes;
434: }
435:
436:
437: /*
438: * Find suitable tab stops for accept.
439: */
440:
441: Hidden bool
442: tabstop(ep, i)
443: environ *ep;
444: int i;
445: {
446: node n = tree(ep->focus);
447: int nch;
448: string repr;
449:
450: if (Type(n) == Tex)
451: return No;
452: nch = nchildren(n);
453: if (i/2 > nch)
454: return No;
455: if (symbol(n) == Hole) {
456: ep->mode = WHOLE;
457: return Yes;
458: }
459: if (i < 2) {
460: i = 2;
461: if (width(n) < 0) {
462: repr = noderepr(n)[0];
463: if (Fw_negative(repr)) {
464: ep->mode = ATBEGIN;
465: leftvhole(ep);
466: return Yes;
467: }
468: }
469: }
470: for (i /= 2; i <= nch; ++i) {
471: s_downi(ep, i);
472: if (tabstop(ep, 1))
473: return Yes;
474: s_up(ep);
475: }
476: return No;
477: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.