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