![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to paragraph.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / jove|
Return to paragraph.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / jove |
1.1 root 1: /*************************************************************************
2: * This program is copyright (C) 1985, 1986 by Jonathan Payne. It is *
3: * provided to you without charge for use only on a licensed Unix *
4: * system. You may copy JOVE provided that this notice is included with *
5: * the copy. You may not sell copies of this program or versions *
6: * modified for use on microcomputer systems, unless the copies are *
7: * included with a Unix system distribution and the source is provided. *
8: *************************************************************************/
9:
10: #include "jove.h"
11:
12: /* Thanks to Brian Harvey for this paragraph boundery finding algorithm.
13: It's really quite hairy figuring it out. This deals with paragraphs that
14: are seperated by blank lines, lines beginning with a Period (assumed to
15: be an nroff command), lines beginning with BackSlash (assumed to be Tex
16: commands). Also handles paragraphs that are separated by lines of
17: different indent; and it deals with outdented paragraphs, too. It's
18: really quite nice. Here's Brian's algorithm.
19:
20: Definitions:
21:
22: THIS means the line containing the cursor.
23: PREV means the line above THIS.
24: NEXT means the line below THIS.
25:
26: BLANK means empty, empty except for spaces and tabs, starts with a period
27: or a backslash, or nonexistent (because the edge of the buffer is
28: reached). ((BH 12/24/85 A line starting with backslash is blank only if
29: the following line also starts with backslash. This is so that \noindent
30: is part of a paragraph, but long strings of TeX commands don't get
31: rearranged. It still isn't perfect but it's better.))
32:
33: BSBLANK means BLANK or starts with a backslash. (BH 12/24/85)
34:
35: HEAD means the first (nonblank) line of the paragraph containing THIS.
36: BODY means all other (nonblank) lines of the paragraph.
37: TAIL means the last (nb) line of the paragraph. (TAIL is part of BODY.)
38:
39: HEAD INDENT means the indentation of HEAD. M-J should preserve this.
40: BODY INDENT means the indentation of BODY. Ditto.
41:
42: Subprocedures:
43:
44: TAILRULE(BODYLINE)
45: If BODYLINE is BLANK, the paragraph has only one line, and there is no
46: BODY and therefore no TAIL. Return. Otherwise, starting from BODYLINE,
47: move down until you find a line that either is BSBLANK or has a different
48: indentation from BODYLINE. The line above that different line is TAIL.
49: Return.
50:
51: Rules:
52:
53: 1. If THIS is BLANK, which command are you doing? If M-J or M-[, then go
54: up to the first non-BLANK line and start over. (If there is no non-BLANK
55: line before THIS, ring the bell.) If M-], then the first non-BLANK line
56: below THIS is HEAD, and the second consecutive non-BSBLANK line (if any) is
57: the beginning of BODY. (If there is no non-BLANK line after THIS, ring
58: the bell.) Do TAILRULE(beginning-of-BODY). Go to rule A.
59:
60: 2. If PREV is BLANK or THIS is BSBLANK, then THIS is HEAD, and NEXT (if
61: not BSBLANK) is in BODY. Do TAILRULE(NEXT). Go to rule A.
62:
63: 3. If NEXT is BSBLANK, then THIS is TAIL, therefore part of BODY. Go to
64: rule 5 to find HEAD.
65:
66: 4. If either NEXT or PREV has the same indentation as THIS, then THIS is
67: part of BODY. Do TAILRULE(THIS). Go to rule 5 to find HEAD. Otherwise,
68: go to rule 6.
69:
70: 5. Go up until you find a line that is either BSBLANK or has a different
71: indentation from THIS. If that line is BLANK, the line below it is HEAD.
72: If that line is non-BLANK, then call that new line THIS for what follows.
73: If (the new) PREV has the same indent as THIS, then (the new) NEXT is
74: HEAD. If PREV has a different indent from THIS, then THIS is HEAD. Go to
75: rule A.
76:
77: 6. If you got here, then both NEXT and PREV are nonblank and are
78: differently indented from THIS. This is a tricky case and there is no
79: guarantee that you're going to win. The most straightforward thing to do
80: is assume that we are not using hanging indentation. In that case:
81: whichever of PREV and THIS is indented further is HEAD. Do
82: TAILRULE(HEAD+1). Go to rule A.
83:
84: 6+. A more complicated variant would be this: if THIS is indented further
85: than PREV, we are using regular indentation and rule 6 applies. If PREV
86: is indented further than THIS, look at both NEXT and the line after NEXT.
87: If those two lines are indented equally, and more than THIS, then we are
88: using hanging indent, THIS is HEAD, and NEXT is the first line of BODY.
89: Do TAILRULE(NEXT). Otherwise, rule 6 applies.
90:
91: A. You now know where HEAD and TAIL are. The indentation of HEAD is HEAD
92: INDENT; the indentation of TAIL is BODY INDENT.
93:
94: B. If you are trying to M-J, you are now ready to do it.
95:
96: C. If you are trying to M-], leave point after the newline that ends
97: TAIL. In other words, leave the cursor at the beginning of the line
98: after TAIL. It is not possible for this to leave point where it started
99: unless it was already at the end of the buffer.
100:
101: D. If you are trying to M-[, if the line before HEAD is not BLANK, then
102: leave point just before HEAD. That is, leave the cursor at the beginning
103: of HEAD. If the line before HEAD is BLANK, then leave the cursor at the
104: beginning of that line. If the cursor didn't move, go up to the first
105: earlier non-BLANK line and start over.
106:
107:
108: End of Algorithm. I implemented rule 6+ because it seemed nicer. */
109:
110: int RMargin = 78,
111: LMargin = 0;
112: Line *para_head,
113: *para_tail;
114: int head_indent,
115: body_indent;
116: static int use_lmargin;
117:
118: /* some defines for paragraph boundery checking */
119: #define I_EMPTY -1 /* line "looks" empty (spaces and tabs) */
120: #define I_PERIOD -2 /* line begins with "." or "\" */
121: #define I_BUFEDGE -3 /* line is nonexistent (edge of buffer) */
122:
123: static int bslash; /* Nonzero if get_indent finds line starting
124: with backslash */
125:
126: i_bsblank(lp)
127: Line *lp;
128: {
129: if (i_blank(lp))
130: return 1;
131: return bslash;
132: }
133:
134: i_blank(lp)
135: Line *lp;
136: {
137: return (get_indent(lp) < 0);
138: }
139:
140: static
141: get_indent(lp)
142: register Line *lp;
143: {
144: Bufpos save;
145: register int indent;
146:
147: bslash = 0;
148: if (lp == 0)
149: return I_BUFEDGE;
150: DOTsave(&save);
151: SetLine(lp);
152: if (blnkp(linebuf))
153: indent = I_EMPTY;
154: else if (linebuf[0] == '.')
155: indent = I_PERIOD;
156: else if (linebuf[0] == '\\') {
157: /* BH 12/24/85. Backslash is BLANK only if next line
158: also starts with Backslash. */
159: bslash++;
160: SetLine(lp->l_next);
161: if (linebuf[0] == '\\')
162: indent = I_PERIOD;
163: else
164: indent = 0;
165: } else {
166: ToIndent();
167: indent = calc_pos(linebuf, curchar);
168: }
169: SetDot(&save);
170:
171: return indent;
172: }
173:
174: static Line *
175: tailrule(lp)
176: register Line *lp;
177: {
178: int i;
179:
180: i = get_indent(lp);
181: if (i < 0)
182: return lp; /* one line paragraph */
183: do {
184: if ((get_indent(lp->l_next) != i) || bslash)
185: /* BH line with backslash is head of next para */
186: break;
187: } while ((lp = lp->l_next) != 0);
188: if (lp == 0)
189: complain((char *) 0);
190: return lp;
191: }
192:
193: /* Finds the beginning, end and indent of the current paragraph, and sets
194: the above global variables. HOW says how to behave when we're between
195: paragraphs. That is, it's either FORWARD or BACKWARD depending on which
196: way we're favoring. */
197:
198: find_para(how)
199: {
200: Line *this,
201: *prev,
202: *next,
203: *head = 0,
204: *body = 0,
205: *tail = 0;
206: int this_indent;
207: Bufpos orig; /* remember where we were when we started */
208:
209: exp = 1;
210: DOTsave(&orig);
211: strt:
212: this = curline;
213: prev = curline->l_prev;
214: next = curline->l_next;
215: this_indent = get_indent(this);
216:
217: if (i_blank(this)) { /* rule 1 */
218: if (how == BACKWARD) {
219: while (i_blank(curline))
220: if (firstp(curline))
221: complain((char *) 0);
222: else
223: line_move(BACKWARD, NO);
224: goto strt;
225: } else {
226: while (i_blank(curline))
227: if (lastp(curline))
228: complain((char *) 0);
229: else
230: line_move(FORWARD, NO);
231: head = curline;
232: next = curline->l_next;
233: if (!i_bsblank(next))
234: body = next;
235: else
236: body = head;
237: }
238: } else if (i_bsblank(this) || i_blank(prev)) { /* rule 2 */
239: head = this;
240: if (!i_bsblank(next))
241: body = next;
242: } else if (i_bsblank(next)) { /* rule 3 */
243: tail = this;
244: body = this;
245: } else if ((get_indent(next) == this_indent) || /* rule 4 */
246: (get_indent(prev) == this_indent))
247: body = this;
248: else { /* rule 6+ */
249: if (get_indent(prev) > this_indent) {
250: /* hanging indent maybe? */
251: if ((next != 0) &&
252: (get_indent(next) == get_indent(next->l_next))) {
253: head = this;
254: body = next;
255: }
256: }
257: /* Now we handle hanging indent else and the other
258: case of this_indent > get_indent(prev). That is,
259: if we didn't resolve HEAD in the above if, then
260: we are not a hanging indent. */
261: if (head == 0) { /* still don't know */
262: if (this_indent > get_indent(prev))
263: head = this;
264: else
265: head = prev;
266: body = head->l_next;
267: }
268: }
269: /* rule 5 -- find the missing parts */
270: if (head == 0) { /* haven't found head of paragraph so do so now */
271: Line *lp;
272: int i;
273:
274: lp = this;
275: do {
276: i = get_indent(lp->l_prev);
277: if (i < 0) /* is blank */
278: head = lp;
279: else if (i != this_indent || bslash) {
280: Line *this = lp->l_prev;
281:
282: if (get_indent(this->l_prev) == i)
283: head = this->l_next;
284: else
285: head = this;
286: }
287: } while (head == 0 && (lp = lp->l_prev) != 0);
288: if (lp == 0)
289: complain((char *) 0);
290: }
291: if (body == 0) /* this must be a one line paragraph */
292: body = head;
293: if (tail == 0)
294: tail = tailrule(body);
295: if (tail == 0 || head == 0 || body == 0)
296: complain("BUG! tail(%d),head(%d),body(%d)!", tail, head, body);
297: para_head = head;
298: para_tail = tail;
299: head_indent = get_indent(head);
300: body_indent = get_indent(body);
301:
302: SetDot(&orig);
303: }
304:
305: Justify()
306: {
307: use_lmargin = (exp_p != 0);
308: find_para(BACKWARD);
309: DoJustify(para_head, 0, para_tail, length(para_tail), NO,
310: use_lmargin ? LMargin : body_indent);
311: }
312:
313: Line *
314: max_line(l1, l2)
315: Line *l1,
316: *l2;
317: {
318: if (inorder(l1, 0, l2, 0))
319: return l2;
320: return l1;
321: }
322:
323: Line *
324: min_line(l1, l2)
325: Line *l1,
326: *l2;
327: {
328: if (inorder(l1, 0, l2, 0))
329: return l1;
330: return l2;
331: }
332:
333: RegJustify()
334: {
335: Mark *mp = CurMark(),
336: *tailmark;
337: Line *l1 = curline,
338: *l2 = mp->m_line;
339: int c1 = curchar,
340: c2 = mp->m_char;
341: Line *rl1,
342: *rl2;
343:
344: use_lmargin = (exp_p != 0);
345: (void) fixorder(&l1, &c1, &l2, &c2);
346: do {
347: DotTo(l1, c1);
348: find_para(FORWARD);
349: rl1 = max_line(l1, para_head);
350: rl2 = min_line(l2, para_tail);
351: tailmark = MakeMark(para_tail, 0, FLOATER);
352: DoJustify(rl1, (rl1 == l1) ? c1 : 0, rl2,
353: (rl2 == l2) ? c2 : length(rl2),
354: NO, use_lmargin ? LMargin : body_indent);
355: l1 = tailmark->m_line->l_next;
356: DelMark(tailmark);
357: c1 = 0;
358: } while (l1 != 0 && l2 != rl2);
359: }
360:
361: do_rfill()
362: {
363: Mark *mp = CurMark();
364: Line *l1 = curline,
365: *l2 = mp->m_line;
366: int c1 = curchar,
367: c2 = mp->m_char;
368:
369: use_lmargin = (exp_p != 0);
370: (void) fixorder(&l1, &c1, &l2, &c2);
371: DoJustify(l1, c1, l2, c2, NO, use_lmargin ? LMargin : 0);
372: }
373:
374: do_space()
375: {
376: int c1 = curchar,
377: c2 = c1,
378: diff,
379: nspace;
380: char ch;
381:
382: while (c1 > 0 && ((ch = linebuf[c1 - 1]) == ' ' || ch == '\t'))
383: c1--;
384: while ((ch = linebuf[c2]) == ' ' || ch == '\t')
385: c2++;
386: diff = (c2 - c1);
387: curchar = c2;
388:
389: if (diff == 0)
390: return;
391: if (c1 > 0) {
392: int topunct = c1 - 1;
393:
394: nspace = 1;
395: if (diff >= 2) {
396: while (index("\")]", linebuf[topunct])) {
397: if (topunct == 0)
398: break;
399: topunct--;
400: }
401: if (index("?!.:", linebuf[topunct]))
402: nspace = 2;
403: }
404: } else
405: nspace = 0;
406:
407: if (diff > nspace)
408: DoTimes(DelPChar(), (diff - nspace));
409: else if (diff < nspace)
410: DoTimes(Insert(' '), (nspace - diff));
411: }
412:
413: DoJustify(l1, c1, l2, c2, scrunch, indent)
414: Line *l1,
415: *l2;
416: {
417: int okay_char = -1;
418: char *cp;
419: Mark *savedot = MakeMark(curline, curchar, FLOATER),
420: *endmark;
421:
422: exp = 1;
423: (void) fixorder(&l1, &c1, &l2, &c2); /* l1/c1 will be before l2/c2 */
424: DotTo(l1, c1);
425: if (get_indent(l1) >= c1) {
426: if (use_lmargin) {
427: DelWtSpace();
428: n_indent(indent + (head_indent - body_indent));
429: use_lmargin = 0; /* turn this off now */
430: }
431: ToIndent();
432: }
433: endmark = MakeMark(l2, c2, FLOATER);
434:
435: for (;;) {
436: while (calc_pos(linebuf, curchar) < RMargin) {
437: if (curline == endmark->m_line && curchar >= endmark->m_char)
438: goto outahere;
439: okay_char = curchar;
440: if (eolp()) {
441: DelNChar(); /* Delete line separator. */
442: ins_str(" ", NO);
443: } else {
444: cp = StrIndex(1, linebuf, curchar + 1, ' ');
445: if (cp == 0)
446: Eol();
447: else
448: curchar = (cp - linebuf);
449: }
450: do_space();
451: }
452: if (okay_char > 0)
453: curchar = okay_char;
454: if (curline == endmark->m_line && curchar >= endmark->m_char)
455: goto outahere;
456:
457: /* Can't fit in small margin, so we do the best we can. */
458: if (eolp()) {
459: line_move(FORWARD, NO);
460: DelWtSpace();
461: n_indent(indent);
462: } else {
463: DelWtSpace();
464: LineInsert();
465: if (scrunch && TwoBlank()) {
466: Eol();
467: DelNChar();
468: }
469: n_indent(indent);
470: }
471: }
472: outahere:
473: ToMark(savedot); /* Back to where we were */
474: DelMark(endmark); /* Free up marks */
475: DelMark(savedot);
476: this_cmd = last_cmd = 0; /* So everything is under control */
477: f_mess("");
478: }
479:
480: extern Line *para_head,
481: *para_tail;
482:
483: DoPara(dir)
484: {
485: register int num = exp,
486: first_time = TRUE;
487:
488: while (--num >= 0) {
489: tryagain: find_para(dir); /* find paragraph bounderies */
490: if ((dir == BACKWARD) &&
491: ((!first_time) || ((para_head == curline) && bolp()))) {
492: if (bobp())
493: complain((char *) 0);
494: BackChar();
495: first_time = !first_time;
496: goto tryagain;
497: }
498: SetLine((dir == BACKWARD) ? para_head : para_tail);
499: if (dir == BACKWARD && !firstp(curline) &&
500: i_blank(curline->l_prev))
501: line_move(BACKWARD, NO);
502: else if (dir == FORWARD) {
503: if (lastp(curline)) {
504: Eol();
505: break;
506: }
507: /* otherwise */
508: line_move(FORWARD, NO);
509: }
510: }
511: }
512:
513: BackPara()
514: {
515: DoPara(BACKWARD);
516: }
517:
518: ForPara()
519: {
520: DoPara(FORWARD);
521: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.