![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ex_vops3.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / ex|
Return to ex_vops3.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / ex |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char *sccsid = "@(#)ex_vops3.c 7.4 (Berkeley) 3/9/87";
9: #endif not lint
10:
11: #include "ex.h"
12: #include "ex_tty.h"
13: #include "ex_vis.h"
14:
15: /*
16: * Routines to handle structure.
17: * Operations supported are:
18: * ( ) { } [ ]
19: *
20: * These cover: LISP TEXT
21: * ( ) s-exprs sentences
22: * { } list at same paragraphs
23: * [ ] defuns sections
24: *
25: * { and } for C used to attempt to do something with matching {}'s, but
26: * I couldn't find definitions which worked intuitively very well, so I
27: * scrapped this.
28: *
29: * The code here is very hard to understand.
30: */
31: line *llimit;
32: int (*lf)();
33:
34: #ifdef LISPCODE
35: int lindent();
36: #endif
37:
38: bool wasend;
39:
40: /*
41: * Find over structure, repeated count times.
42: * Don't go past line limit. F is the operation to
43: * be performed eventually. If pastatom then the user said {}
44: * rather than (), implying past atoms in a list (or a paragraph
45: * rather than a sentence.
46: */
47: lfind(pastatom, cnt, f, limit)
48: bool pastatom;
49: int cnt, (*f)();
50: line *limit;
51: {
52: register int c;
53: register int rc = 0;
54: char save[LBSIZE];
55:
56: /*
57: * Initialize, saving the current line buffer state
58: * and computing the limit; a 0 argument means
59: * directional end of file.
60: */
61: wasend = 0;
62: lf = f;
63: strcpy(save, linebuf);
64: if (limit == 0)
65: limit = dir < 0 ? one : dol;
66: llimit = limit;
67: wdot = dot;
68: wcursor = cursor;
69:
70: if (pastatom >= 2) {
71: while (cnt > 0 && word(f, cnt))
72: cnt--;
73: if (pastatom == 3)
74: eend(f);
75: if (dot == wdot) {
76: wdot = 0;
77: if (cursor == wcursor)
78: rc = -1;
79: }
80: }
81: #ifdef LISPCODE
82: else if (!value(LISP)) {
83: #else
84: else {
85: #endif
86: char *icurs;
87: line *idot;
88:
89: if (linebuf[0] == 0) {
90: do
91: if (!lnext())
92: goto ret;
93: while (linebuf[0] == 0);
94: if (dir > 0) {
95: wdot--;
96: linebuf[0] = 0;
97: wcursor = linebuf;
98: /*
99: * If looking for sentence, next line
100: * starts one.
101: */
102: if (!pastatom) {
103: icurs = wcursor;
104: idot = wdot;
105: goto begin;
106: }
107: }
108: }
109: icurs = wcursor;
110: idot = wdot;
111:
112: /*
113: * Advance so as to not find same thing again.
114: */
115: if (dir > 0) {
116: if (!lnext()) {
117: rc = -1;
118: goto ret;
119: }
120: } else
121: ignore(lskipa1(""));
122:
123: /*
124: * Count times find end of sentence/paragraph.
125: */
126: begin:
127: for (;;) {
128: while (!endsent(pastatom))
129: if (!lnext())
130: goto ret;
131: if (!pastatom || wcursor == linebuf && endPS())
132: if (--cnt <= 0)
133: break;
134: if (linebuf[0] == 0) {
135: do
136: if (!lnext())
137: goto ret;
138: while (linebuf[0] == 0);
139: } else
140: if (!lnext())
141: goto ret;
142: }
143:
144: /*
145: * If going backwards, and didn't hit the end of the buffer,
146: * then reverse direction.
147: */
148: if (dir < 0 && (wdot != llimit || wcursor != linebuf)) {
149: dir = 1;
150: llimit = dot;
151: /*
152: * Empty line needs special treatement.
153: * If moved to it from other than begining of next line,
154: * then a sentence starts on next line.
155: */
156: if (linebuf[0] == 0 && !pastatom &&
157: (wdot != dot - 1 || cursor != linebuf)) {
158: ignore(lnext());
159: goto ret;
160: }
161: }
162:
163: /*
164: * If we are not at a section/paragraph division,
165: * advance to next.
166: */
167: if (wcursor == icurs && wdot == idot || wcursor != linebuf || !endPS())
168: ignore(lskipa1(""));
169: }
170: #ifdef LISPCODE
171: else {
172: c = *wcursor;
173: /*
174: * Startup by skipping if at a ( going left or a ) going
175: * right to keep from getting stuck immediately.
176: */
177: if (dir < 0 && c == '(' || dir > 0 && c == ')') {
178: if (!lnext()) {
179: rc = -1;
180: goto ret;
181: }
182: }
183: /*
184: * Now chew up repitition count. Each time around
185: * if at the beginning of an s-exp (going forwards)
186: * or the end of an s-exp (going backwards)
187: * skip the s-exp. If not at beg/end resp, then stop
188: * if we hit a higher level paren, else skip an atom,
189: * counting it unless pastatom.
190: */
191: while (cnt > 0) {
192: c = *wcursor;
193: if (dir < 0 && c == ')' || dir > 0 && c == '(') {
194: if (!lskipbal("()"))
195: goto ret;
196: /*
197: * Unless this is the last time going
198: * backwards, skip past the matching paren
199: * so we don't think it is a higher level paren.
200: */
201: if (dir < 0 && cnt == 1)
202: goto ret;
203: if (!lnext() || !ltosolid())
204: goto ret;
205: --cnt;
206: } else if (dir < 0 && c == '(' || dir > 0 && c == ')')
207: /* Found a higher level paren */
208: goto ret;
209: else {
210: if (!lskipatom())
211: goto ret;
212: if (!pastatom)
213: --cnt;
214: }
215: }
216: }
217: #endif
218: ret:
219: strcLIN(save);
220: return (rc);
221: }
222:
223: /*
224: * Is this the end of a sentence?
225: */
226: /* ARGSUSED */
227: endsent(pastatom)
228: bool pastatom;
229: {
230: register char *cp = wcursor;
231: register int d;
232:
233: /*
234: * If this is the beginning of a line, then
235: * check for the end of a paragraph or section.
236: */
237: if (cp == linebuf)
238: return (endPS());
239:
240: /*
241: * Sentences end with . ! ? not at the beginning
242: * of the line, and must be either at the end of the line,
243: * or followed by 2 spaces. Any number of intervening ) ] ' "
244: * characters are allowed.
245: */
246: if (!any(*cp, ".!?"))
247: goto tryps;
248: do
249: if ((d = *++cp) == 0)
250: return (1);
251: while (any(d, ")]'"));
252: if (*cp == 0 || *cp++ == ' ' && *cp == ' ')
253: return (1);
254: tryps:
255: if (cp[1] == 0)
256: return (endPS());
257: return (0);
258: }
259:
260: /*
261: * End of paragraphs/sections are respective
262: * macros as well as blank lines and form feeds.
263: */
264: endPS()
265: {
266:
267: return (linebuf[0] == 0 ||
268: isa(svalue(PARAGRAPHS)) || isa(svalue(SECTIONS)));
269:
270: }
271:
272: #ifdef LISPCODE
273: lindent(addr)
274: line *addr;
275: {
276: register int i;
277: char *swcurs = wcursor;
278: line *swdot = wdot;
279:
280: again:
281: if (addr > one) {
282: register char *cp;
283: register int cnt = 0;
284:
285: addr--;
286: getline(*addr);
287: for (cp = linebuf; *cp; cp++)
288: if (*cp == '(')
289: cnt++;
290: else if (*cp == ')')
291: cnt--;
292: cp = vpastwh(linebuf);
293: if (*cp == 0)
294: goto again;
295: if (cnt == 0)
296: return (whitecnt(linebuf));
297: addr++;
298: }
299: wcursor = linebuf;
300: linebuf[0] = 0;
301: wdot = addr;
302: dir = -1;
303: llimit = one;
304: lf = lindent;
305: if (!lskipbal("()"))
306: i = 0;
307: else if (wcursor == linebuf)
308: i = 2;
309: else {
310: register char *wp = wcursor;
311:
312: dir = 1;
313: llimit = wdot;
314: if (!lnext() || !ltosolid() || !lskipatom()) {
315: wcursor = wp;
316: i = 1;
317: } else
318: i = 0;
319: i += column(wcursor) - 1;
320: if (!inopen)
321: i--;
322: }
323: wdot = swdot;
324: wcursor = swcurs;
325: return (i);
326: }
327: #endif
328:
329: lmatchp(addr)
330: line *addr;
331: {
332: register int i;
333: register char *parens, *cp;
334:
335: for (cp = cursor; !any(*cp, "({[)}]");)
336: if (*cp++ == 0)
337: return (0);
338: lf = 0;
339: parens = any(*cp, "()") ? "()" : any(*cp, "[]") ? "[]" : "{}";
340: if (*cp == parens[1]) {
341: dir = -1;
342: llimit = one;
343: } else {
344: dir = 1;
345: llimit = dol;
346: }
347: if (addr)
348: llimit = addr;
349: if (splitw)
350: llimit = dot;
351: wcursor = cp;
352: wdot = dot;
353: i = lskipbal(parens);
354: return (i);
355: }
356:
357: lsmatch(cp)
358: char *cp;
359: {
360: char save[LBSIZE];
361: register char *sp = save;
362: register char *scurs = cursor;
363:
364: wcursor = cp;
365: strcpy(sp, linebuf);
366: *wcursor = 0;
367: strcpy(cursor, genbuf);
368: cursor = strend(linebuf) - 1;
369: if (lmatchp(dot - vcline)) {
370: register int i = insmode;
371: register int c = outcol;
372: register int l = outline;
373:
374: if (!MI)
375: endim();
376: vgoto(splitw ? WECHO : LINE(wdot - llimit), column(wcursor) - 1);
377: flush();
378: sleep(1);
379: vgoto(l, c);
380: if (i)
381: goim();
382: }
383: else {
384: strcLIN(sp);
385: strcpy(scurs, genbuf);
386: if (!lmatchp((line *) 0))
387: beep();
388: }
389: strcLIN(sp);
390: wdot = 0;
391: wcursor = 0;
392: cursor = scurs;
393: }
394:
395: ltosolid()
396: {
397:
398: return (ltosol1("()"));
399: }
400:
401: ltosol1(parens)
402: register char *parens;
403: {
404: register char *cp;
405:
406: if (*parens && !*wcursor && !lnext())
407: return (0);
408: while (isspace(*wcursor) || (*wcursor == 0 && *parens))
409: if (!lnext())
410: return (0);
411: if (any(*wcursor, parens) || dir > 0)
412: return (1);
413: for (cp = wcursor; cp > linebuf; cp--)
414: if (isspace(cp[-1]) || any(cp[-1], parens))
415: break;
416: wcursor = cp;
417: return (1);
418: }
419:
420: lskipbal(parens)
421: register char *parens;
422: {
423: register int level = dir;
424: register int c;
425:
426: do {
427: if (!lnext()) {
428: wdot = NOLINE;
429: return (0);
430: }
431: c = *wcursor;
432: if (c == parens[1])
433: level--;
434: else if (c == parens[0])
435: level++;
436: } while (level);
437: return (1);
438: }
439:
440: lskipatom()
441: {
442:
443: return (lskipa1("()"));
444: }
445:
446: lskipa1(parens)
447: register char *parens;
448: {
449: register int c;
450:
451: for (;;) {
452: if (dir < 0 && wcursor == linebuf) {
453: if (!lnext())
454: return (0);
455: break;
456: }
457: c = *wcursor;
458: if (c && (isspace(c) || any(c, parens)))
459: break;
460: if (!lnext())
461: return (0);
462: if (dir > 0 && wcursor == linebuf)
463: break;
464: }
465: return (ltosol1(parens));
466: }
467:
468: lnext()
469: {
470:
471: if (dir > 0) {
472: if (*wcursor)
473: wcursor++;
474: if (*wcursor)
475: return (1);
476: if (wdot >= llimit) {
477: if (lf == vmove && wcursor > linebuf)
478: wcursor--;
479: return (0);
480: }
481: wdot++;
482: getline(*wdot);
483: wcursor = linebuf;
484: return (1);
485: } else {
486: --wcursor;
487: if (wcursor >= linebuf)
488: return (1);
489: #ifdef LISPCODE
490: if (lf == lindent && linebuf[0] == '(')
491: llimit = wdot;
492: #endif
493: if (wdot <= llimit) {
494: wcursor = linebuf;
495: return (0);
496: }
497: wdot--;
498: getline(*wdot);
499: wcursor = linebuf[0] == 0 ? linebuf : strend(linebuf) - 1;
500: return (1);
501: }
502: }
503:
504: lbrack(c, f)
505: register int c;
506: int (*f)();
507: {
508: register line *addr;
509:
510: addr = dot;
511: for (;;) {
512: addr += dir;
513: if (addr < one || addr > dol) {
514: addr -= dir;
515: break;
516: }
517: getline(*addr);
518: if (linebuf[0] == '{' ||
519: #ifdef LISPCODE
520: value(LISP) && linebuf[0] == '(' ||
521: #endif
522: isa(svalue(SECTIONS))) {
523: if (c == ']' && f != vmove) {
524: addr--;
525: getline(*addr);
526: }
527: break;
528: }
529: if (c == ']' && f != vmove && linebuf[0] == '}')
530: break;
531: }
532: if (addr == dot)
533: return (0);
534: if (f != vmove)
535: wcursor = c == ']' ? strend(linebuf) : linebuf;
536: else
537: wcursor = 0;
538: wdot = addr;
539: vmoving = 0;
540: return (1);
541: }
542:
543: isa(cp)
544: register char *cp;
545: {
546:
547: if (linebuf[0] != '.')
548: return (0);
549: for (; cp[0] && cp[1]; cp += 2)
550: if (linebuf[1] == cp[0]) {
551: if (linebuf[2] == cp[1])
552: return (1);
553: if (linebuf[2] == 0 && cp[1] == ' ')
554: return (1);
555: }
556: return (0);
557: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.