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