]> git.cameronkatri.com Git - mandoc.git/blob - man_term.c
git.ckatri.com / mandoc.git / blob
? search:


7bff354251a247bb50db0fa5df51d03138e1e09f
[mandoc.git] / man_term.c
1 /* $Id: man_term.c,v 1.112 2011/06/29 15:38:09 kristaps Exp $ */
2 /*
3 * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
4 * Copyright (c) 2010, 2011 Ingo Schwarze <schwarze@openbsd.org>
5 *
6 * Permission to use, copy, modify, and distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18 #ifdef HAVE_CONFIG_H
19 #include "config.h"
20 #endif
21
22 #include <sys/types.h>
23
24 #include <assert.h>
25 #include <ctype.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29
30 #include "mandoc.h"
31 #include "out.h"
32 #include "man.h"
33 #include "term.h"
34 #include "main.h"
35
36 #define INDENT 7
37 #define HALFINDENT 3
38
39 /* FIXME: have PD set the default vspace width. */
40
41 struct mtermp {
42 int fl;
43 #define MANT_LITERAL (1 << 0)
44 /*
45 * Default amount to indent the left margin after leading text
46 * has been printed (e.g., `HP' left-indent, `TP' and `IP' body
47 * indent). This needs to be saved because `HP' and so on, if
48 * not having a specified value, must default.
49 *
50 * Note that this is the indentation AFTER the left offset, so
51 * the total offset is usually offset + lmargin.
52 */
53 size_t lmargin;
54 /*
55 * The default offset, i.e., the amount between any text and the
56 * page boundary.
57 */
58 size_t offset;
59 };
60
61 #define DECL_ARGS struct termp *p, \
62 struct mtermp *mt, \
63 const struct man_node *n, \
64 const struct man_meta *m
65
66 struct termact {
67 int (*pre)(DECL_ARGS);
68 void (*post)(DECL_ARGS);
69 int flags;
70 #define MAN_NOTEXT (1 << 0) /* Never has text children. */
71 };
72
73 static int a2width(const struct termp *, const char *);
74 static size_t a2height(const struct termp *, const char *);
75
76 static void print_man_nodelist(DECL_ARGS);
77 static void print_man_node(DECL_ARGS);
78 static void print_man_head(struct termp *, const void *);
79 static void print_man_foot(struct termp *, const void *);
80 static void print_bvspace(struct termp *,
81 const struct man_node *);
82
83 static int pre_alternate(DECL_ARGS);
84 static int pre_B(DECL_ARGS);
85 static int pre_HP(DECL_ARGS);
86 static int pre_I(DECL_ARGS);
87 static int pre_IP(DECL_ARGS);
88 static int pre_PP(DECL_ARGS);
89 static int pre_RS(DECL_ARGS);
90 static int pre_SH(DECL_ARGS);
91 static int pre_SS(DECL_ARGS);
92 static int pre_TP(DECL_ARGS);
93 static int pre_ign(DECL_ARGS);
94 static int pre_in(DECL_ARGS);
95 static int pre_literal(DECL_ARGS);
96 static int pre_sp(DECL_ARGS);
97 static int pre_ft(DECL_ARGS);
98
99 static void post_IP(DECL_ARGS);
100 static void post_HP(DECL_ARGS);
101 static void post_RS(DECL_ARGS);
102 static void post_SH(DECL_ARGS);
103 static void post_SS(DECL_ARGS);
104 static void post_TP(DECL_ARGS);
105
106 static const struct termact termacts[MAN_MAX] = {
107 { pre_sp, NULL, MAN_NOTEXT }, /* br */
108 { NULL, NULL, 0 }, /* TH */
109 { pre_SH, post_SH, 0 }, /* SH */
110 { pre_SS, post_SS, 0 }, /* SS */
111 { pre_TP, post_TP, 0 }, /* TP */
112 { pre_PP, NULL, 0 }, /* LP */
113 { pre_PP, NULL, 0 }, /* PP */
114 { pre_PP, NULL, 0 }, /* P */
115 { pre_IP, post_IP, 0 }, /* IP */
116 { pre_HP, post_HP, 0 }, /* HP */
117 { NULL, NULL, 0 }, /* SM */
118 { pre_B, NULL, 0 }, /* SB */
119 { pre_alternate, NULL, 0 }, /* BI */
120 { pre_alternate, NULL, 0 }, /* IB */
121 { pre_alternate, NULL, 0 }, /* BR */
122 { pre_alternate, NULL, 0 }, /* RB */
123 { NULL, NULL, 0 }, /* R */
124 { pre_B, NULL, 0 }, /* B */
125 { pre_I, NULL, 0 }, /* I */
126 { pre_alternate, NULL, 0 }, /* IR */
127 { pre_alternate, NULL, 0 }, /* RI */
128 { pre_ign, NULL, MAN_NOTEXT }, /* na */
129 { pre_sp, NULL, MAN_NOTEXT }, /* sp */
130 { pre_literal, NULL, 0 }, /* nf */
131 { pre_literal, NULL, 0 }, /* fi */
132 { NULL, NULL, 0 }, /* RE */
133 { pre_RS, post_RS, 0 }, /* RS */
134 { pre_ign, NULL, 0 }, /* DT */
135 { pre_ign, NULL, 0 }, /* UC */
136 { pre_ign, NULL, 0 }, /* PD */
137 { pre_ign, NULL, 0 }, /* AT */
138 { pre_in, NULL, MAN_NOTEXT }, /* in */
139 { pre_ft, NULL, MAN_NOTEXT }, /* ft */
140 };
141
142
143
144 void
145 terminal_man(void *arg, const struct man *man)
146 {
147 struct termp *p;
148 const struct man_node *n;
149 const struct man_meta *m;
150 struct mtermp mt;
151
152 p = (struct termp *)arg;
153
154 p->overstep = 0;
155 p->maxrmargin = p->defrmargin;
156 p->tabwidth = term_len(p, 5);
157
158 if (NULL == p->symtab)
159 p->symtab = mchars_alloc();
160
161 n = man_node(man);
162 m = man_meta(man);
163
164 term_begin(p, print_man_head, print_man_foot, m);
165 p->flags |= TERMP_NOSPACE;
166
167 mt.fl = 0;
168 mt.lmargin = term_len(p, INDENT);
169 mt.offset = term_len(p, INDENT);
170
171 if (n->child)
172 print_man_nodelist(p, &mt, n->child, m);
173
174 term_end(p);
175 }
176
177
178 static size_t
179 a2height(const struct termp *p, const char *cp)
180 {
181 struct roffsu su;
182
183 if ( ! a2roffsu(cp, &su, SCALE_VS))
184 SCALE_VS_INIT(&su, atoi(cp));
185
186 return(term_vspan(p, &su));
187 }
188
189
190 static int
191 a2width(const struct termp *p, const char *cp)
192 {
193 struct roffsu su;
194
195 if ( ! a2roffsu(cp, &su, SCALE_BU))
196 return(-1);
197
198 return((int)term_hspan(p, &su));
199 }
200
201 /*
202 * Printing leading vertical space before a block.
203 * This is used for the paragraph macros.
204 * The rules are pretty simple, since there's very little nesting going
205 * on here. Basically, if we're the first within another block (SS/SH),
206 * then don't emit vertical space. If we are (RS), then do. If not the
207 * first, print it.
208 */
209 static void
210 print_bvspace(struct termp *p, const struct man_node *n)
211 {
212
213 term_newln(p);
214
215 if (n->body && n->body->child)
216 if (MAN_TBL == n->body->child->type)
217 return;
218
219 if (MAN_ROOT == n->parent->type || MAN_RS != n->parent->tok)
220 if (NULL == n->prev)
221 return;
222
223 term_vspace(p);
224 }
225
226 /* ARGSUSED */
227 static int
228 pre_ign(DECL_ARGS)
229 {
230
231 return(0);
232 }
233
234
235 /* ARGSUSED */
236 static int
237 pre_I(DECL_ARGS)
238 {
239
240 term_fontrepl(p, TERMFONT_UNDER);
241 return(1);
242 }
243
244
245 /* ARGSUSED */
246 static int
247 pre_literal(DECL_ARGS)
248 {
249
250 term_newln(p);
251
252 if (MAN_nf == n->tok)
253 mt->fl |= MANT_LITERAL;
254 else
255 mt->fl &= ~MANT_LITERAL;
256
257 return(0);
258 }
259
260 /* ARGSUSED */
261 static int
262 pre_alternate(DECL_ARGS)
263 {
264 enum termfont font[2];
265 const struct man_node *nn;
266 int savelit, i;
267
268 switch (n->tok) {
269 case (MAN_RB):
270 font[0] = TERMFONT_NONE;
271 font[1] = TERMFONT_BOLD;
272 break;
273 case (MAN_RI):
274 font[0] = TERMFONT_NONE;
275 font[1] = TERMFONT_UNDER;
276 break;
277 case (MAN_BR):
278 font[0] = TERMFONT_BOLD;
279 font[1] = TERMFONT_NONE;
280 break;
281 case (MAN_BI):
282 font[0] = TERMFONT_BOLD;
283 font[1] = TERMFONT_UNDER;
284 break;
285 case (MAN_IR):
286 font[0] = TERMFONT_UNDER;
287 font[1] = TERMFONT_NONE;
288 break;
289 case (MAN_IB):
290 font[0] = TERMFONT_UNDER;
291 font[1] = TERMFONT_BOLD;
292 break;
293 default:
294 abort();
295 }
296
297 savelit = MANT_LITERAL & mt->fl;
298 mt->fl &= ~MANT_LITERAL;
299
300 for (i = 0, nn = n->child; nn; nn = nn->next, i = 1 - i) {
301 term_fontrepl(p, font[i]);
302 if (savelit && NULL == nn->next)
303 mt->fl |= MANT_LITERAL;
304 print_man_node(p, mt, nn, m);
305 if (nn->next)
306 p->flags |= TERMP_NOSPACE;
307 }
308
309 return(0);
310 }
311
312 /* ARGSUSED */
313 static int
314 pre_B(DECL_ARGS)
315 {
316
317 term_fontrepl(p, TERMFONT_BOLD);
318 return(1);
319 }
320
321 /* ARGSUSED */
322 static int
323 pre_ft(DECL_ARGS)
324 {
325 const char *cp;
326
327 if (NULL == n->child) {
328 term_fontlast(p);
329 return(0);
330 }
331
332 cp = n->child->string;
333 switch (*cp) {
334 case ('4'):
335 /* FALLTHROUGH */
336 case ('3'):
337 /* FALLTHROUGH */
338 case ('B'):
339 term_fontrepl(p, TERMFONT_BOLD);
340 break;
341 case ('2'):
342 /* FALLTHROUGH */
343 case ('I'):
344 term_fontrepl(p, TERMFONT_UNDER);
345 break;
346 case ('P'):
347 term_fontlast(p);
348 break;
349 case ('1'):
350 /* FALLTHROUGH */
351 case ('C'):
352 /* FALLTHROUGH */
353 case ('R'):
354 term_fontrepl(p, TERMFONT_NONE);
355 break;
356 default:
357 break;
358 }
359 return(0);
360 }
361
362 /* ARGSUSED */
363 static int
364 pre_in(DECL_ARGS)
365 {
366 int len, less;
367 size_t v;
368 const char *cp;
369
370 term_newln(p);
371
372 if (NULL == n->child) {
373 p->offset = mt->offset;
374 return(0);
375 }
376
377 cp = n->child->string;
378 less = 0;
379
380 if ('-' == *cp)
381 less = -1;
382 else if ('+' == *cp)
383 less = 1;
384 else
385 cp--;
386
387 if ((len = a2width(p, ++cp)) < 0)
388 return(0);
389
390 v = (size_t)len;
391
392 if (less < 0)
393 p->offset -= p->offset > v ? v : p->offset;
394 else if (less > 0)
395 p->offset += v;
396 else
397 p->offset = v;
398
399 /* Don't let this creep beyond the right margin. */
400
401 if (p->offset > p->rmargin)
402 p->offset = p->rmargin;
403
404 return(0);
405 }
406
407
408 /* ARGSUSED */
409 static int
410 pre_sp(DECL_ARGS)
411 {
412 size_t i, len;
413
414 if ((NULL == n->prev && n->parent)) {
415 if (MAN_SS == n->parent->tok)
416 return(0);
417 if (MAN_SH == n->parent->tok)
418 return(0);
419 }
420
421 switch (n->tok) {
422 case (MAN_br):
423 len = 0;
424 break;
425 default:
426 len = n->child ? a2height(p, n->child->string) : 1;
427 break;
428 }
429
430 if (0 == len)
431 term_newln(p);
432 for (i = 0; i < len; i++)
433 term_vspace(p);
434
435 return(0);
436 }
437
438
439 /* ARGSUSED */
440 static int
441 pre_HP(DECL_ARGS)
442 {
443 size_t len;
444 int ival;
445 const struct man_node *nn;
446
447 switch (n->type) {
448 case (MAN_BLOCK):
449 print_bvspace(p, n);
450 return(1);
451 case (MAN_BODY):
452 p->flags |= TERMP_NOBREAK;
453 p->flags |= TERMP_TWOSPACE;
454 break;
455 default:
456 return(0);
457 }
458
459 len = mt->lmargin;
460 ival = -1;
461
462 /* Calculate offset. */
463
464 if (NULL != (nn = n->parent->head->child))
465 if ((ival = a2width(p, nn->string)) >= 0)
466 len = (size_t)ival;
467
468 if (0 == len)
469 len = term_len(p, 1);
470
471 p->offset = mt->offset;
472 p->rmargin = mt->offset + len;
473
474 if (ival >= 0)
475 mt->lmargin = (size_t)ival;
476
477 return(1);
478 }
479
480
481 /* ARGSUSED */
482 static void
483 post_HP(DECL_ARGS)
484 {
485
486 switch (n->type) {
487 case (MAN_BLOCK):
488 term_flushln(p);
489 break;
490 case (MAN_BODY):
491 term_flushln(p);
492 p->flags &= ~TERMP_NOBREAK;
493 p->flags &= ~TERMP_TWOSPACE;
494 p->offset = mt->offset;
495 p->rmargin = p->maxrmargin;
496 break;
497 default:
498 break;
499 }
500 }
501
502
503 /* ARGSUSED */
504 static int
505 pre_PP(DECL_ARGS)
506 {
507
508 switch (n->type) {
509 case (MAN_BLOCK):
510 mt->lmargin = term_len(p, INDENT);
511 print_bvspace(p, n);
512 break;
513 default:
514 p->offset = mt->offset;
515 break;
516 }
517
518 return(MAN_HEAD != n->type);
519 }
520
521
522 /* ARGSUSED */
523 static int
524 pre_IP(DECL_ARGS)
525 {
526 const struct man_node *nn;
527 size_t len;
528 int savelit, ival;
529
530 switch (n->type) {
531 case (MAN_BODY):
532 p->flags |= TERMP_NOLPAD;
533 p->flags |= TERMP_NOSPACE;
534 break;
535 case (MAN_HEAD):
536 p->flags |= TERMP_NOBREAK;
537 break;
538 case (MAN_BLOCK):
539 print_bvspace(p, n);
540 /* FALLTHROUGH */
541 default:
542 return(1);
543 }
544
545 len = mt->lmargin;
546 ival = -1;
547
548 /* Calculate the offset from the optional second argument. */
549 if (NULL != (nn = n->parent->head->child))
550 if (NULL != (nn = nn->next))
551 if ((ival = a2width(p, nn->string)) >= 0)
552 len = (size_t)ival;
553
554 switch (n->type) {
555 case (MAN_HEAD):
556 /* Handle zero-width lengths. */
557 if (0 == len)
558 len = term_len(p, 1);
559
560 p->offset = mt->offset;
561 p->rmargin = mt->offset + len;
562 if (ival < 0)
563 break;
564
565 /* Set the saved left-margin. */
566 mt->lmargin = (size_t)ival;
567
568 savelit = MANT_LITERAL & mt->fl;
569 mt->fl &= ~MANT_LITERAL;
570
571 if (n->child)
572 print_man_node(p, mt, n->child, m);
573
574 if (savelit)
575 mt->fl |= MANT_LITERAL;
576
577 return(0);
578 case (MAN_BODY):
579 p->offset = mt->offset + len;
580 p->rmargin = p->maxrmargin;
581 break;
582 default:
583 break;
584 }
585
586 return(1);
587 }
588
589
590 /* ARGSUSED */
591 static void
592 post_IP(DECL_ARGS)
593 {
594
595 switch (n->type) {
596 case (MAN_HEAD):
597 term_flushln(p);
598 p->flags &= ~TERMP_NOBREAK;
599 p->rmargin = p->maxrmargin;
600 break;
601 case (MAN_BODY):
602 term_newln(p);
603 p->flags &= ~TERMP_NOLPAD;
604 break;
605 default:
606 break;
607 }
608 }
609
610
611 /* ARGSUSED */
612 static int
613 pre_TP(DECL_ARGS)
614 {
615 const struct man_node *nn;
616 size_t len;
617 int savelit, ival;
618
619 switch (n->type) {
620 case (MAN_HEAD):
621 p->flags |= TERMP_NOBREAK;
622 break;
623 case (MAN_BODY):
624 p->flags |= TERMP_NOLPAD;
625 p->flags |= TERMP_NOSPACE;
626 break;
627 case (MAN_BLOCK):
628 print_bvspace(p, n);
629 /* FALLTHROUGH */
630 default:
631 return(1);
632 }
633
634 len = (size_t)mt->lmargin;
635 ival = -1;
636
637 /* Calculate offset. */
638
639 if (NULL != (nn = n->parent->head->child)) {
640 while (nn && MAN_TEXT != nn->type)
641 nn = nn->next;
642 if (nn && nn->next)
643 if ((ival = a2width(p, nn->string)) >= 0)
644 len = (size_t)ival;
645 }
646
647 switch (n->type) {
648 case (MAN_HEAD):
649 /* Handle zero-length properly. */
650 if (0 == len)
651 len = term_len(p, 1);
652
653 p->offset = mt->offset;
654 p->rmargin = mt->offset + len;
655
656 savelit = MANT_LITERAL & mt->fl;
657 mt->fl &= ~MANT_LITERAL;
658
659 /* Don't print same-line elements. */
660 for (nn = n->child; nn; nn = nn->next)
661 if (nn->line > n->line)
662 print_man_node(p, mt, nn, m);
663
664 if (savelit)
665 mt->fl |= MANT_LITERAL;
666
667 if (ival >= 0)
668 mt->lmargin = (size_t)ival;
669
670 return(0);
671 case (MAN_BODY):
672 p->offset = mt->offset + len;
673 p->rmargin = p->maxrmargin;
674 break;
675 default:
676 break;
677 }
678
679 return(1);
680 }
681
682
683 /* ARGSUSED */
684 static void
685 post_TP(DECL_ARGS)
686 {
687
688 switch (n->type) {
689 case (MAN_HEAD):
690 term_flushln(p);
691 p->flags &= ~TERMP_NOBREAK;
692 p->flags &= ~TERMP_TWOSPACE;
693 p->rmargin = p->maxrmargin;
694 break;
695 case (MAN_BODY):
696 term_newln(p);
697 p->flags &= ~TERMP_NOLPAD;
698 break;
699 default:
700 break;
701 }
702 }
703
704
705 /* ARGSUSED */
706 static int
707 pre_SS(DECL_ARGS)
708 {
709
710 switch (n->type) {
711 case (MAN_BLOCK):
712 mt->lmargin = term_len(p, INDENT);
713 mt->offset = term_len(p, INDENT);
714 /* If following a prior empty `SS', no vspace. */
715 if (n->prev && MAN_SS == n->prev->tok)
716 if (NULL == n->prev->body->child)
717 break;
718 if (NULL == n->prev)
719 break;
720 term_vspace(p);
721 break;
722 case (MAN_HEAD):
723 term_fontrepl(p, TERMFONT_BOLD);
724 p->offset = term_len(p, HALFINDENT);
725 break;
726 case (MAN_BODY):
727 p->offset = mt->offset;
728 break;
729 default:
730 break;
731 }
732
733 return(1);
734 }
735
736
737 /* ARGSUSED */
738 static void
739 post_SS(DECL_ARGS)
740 {
741
742 switch (n->type) {
743 case (MAN_HEAD):
744 term_newln(p);
745 break;
746 case (MAN_BODY):
747 term_newln(p);
748 break;
749 default:
750 break;
751 }
752 }
753
754
755 /* ARGSUSED */
756 static int
757 pre_SH(DECL_ARGS)
758 {
759
760 switch (n->type) {
761 case (MAN_BLOCK):
762 mt->lmargin = term_len(p, INDENT);
763 mt->offset = term_len(p, INDENT);
764 /* If following a prior empty `SH', no vspace. */
765 if (n->prev && MAN_SH == n->prev->tok)
766 if (NULL == n->prev->body->child)
767 break;
768 /* If the first macro, no vspae. */
769 if (NULL == n->prev)
770 break;
771 term_vspace(p);
772 break;
773 case (MAN_HEAD):
774 term_fontrepl(p, TERMFONT_BOLD);
775 p->offset = 0;
776 break;
777 case (MAN_BODY):
778 p->offset = mt->offset;
779 break;
780 default:
781 break;
782 }
783
784 return(1);
785 }
786
787
788 /* ARGSUSED */
789 static void
790 post_SH(DECL_ARGS)
791 {
792
793 switch (n->type) {
794 case (MAN_HEAD):
795 term_newln(p);
796 break;
797 case (MAN_BODY):
798 term_newln(p);
799 break;
800 default:
801 break;
802 }
803 }
804
805 /* ARGSUSED */
806 static int
807 pre_RS(DECL_ARGS)
808 {
809 int ival;
810 size_t sz;
811
812 switch (n->type) {
813 case (MAN_BLOCK):
814 term_newln(p);
815 return(1);
816 case (MAN_HEAD):
817 return(0);
818 default:
819 break;
820 }
821
822 sz = term_len(p, INDENT);
823
824 if (NULL != (n = n->parent->head->child))
825 if ((ival = a2width(p, n->string)) >= 0)
826 sz = (size_t)ival;
827
828 mt->offset += sz;
829 p->offset = mt->offset;
830
831 return(1);
832 }
833
834 /* ARGSUSED */
835 static void
836 post_RS(DECL_ARGS)
837 {
838 int ival;
839 size_t sz;
840
841 switch (n->type) {
842 case (MAN_BLOCK):
843 return;
844 case (MAN_HEAD):
845 return;
846 default:
847 term_newln(p);
848 break;
849 }
850
851 sz = term_len(p, INDENT);
852
853 if (NULL != (n = n->parent->head->child))
854 if ((ival = a2width(p, n->string)) >= 0)
855 sz = (size_t)ival;
856
857 mt->offset = mt->offset < sz ? 0 : mt->offset - sz;
858 p->offset = mt->offset;
859 }
860
861 static void
862 print_man_node(DECL_ARGS)
863 {
864 size_t rm, rmax;
865 int c;
866
867 switch (n->type) {
868 case(MAN_TEXT):
869 /*
870 * If we have a blank line, output a vertical space.
871 * If we have a space as the first character, break
872 * before printing the line's data.
873 */
874 if ('\0' == *n->string) {
875 term_vspace(p);
876 return;
877 } else if (' ' == *n->string && MAN_LINE & n->flags)
878 term_newln(p);
879
880 term_word(p, n->string);
881
882 /*
883 * If we're in a literal context, make sure that words
884 * togehter on the same line stay together. This is a
885 * POST-printing call, so we check the NEXT word. Since
886 * -man doesn't have nested macros, we don't need to be
887 * more specific than this.
888 */
889 if (MANT_LITERAL & mt->fl &&
890 (NULL == n->next ||
891 n->next->line > n->line)) {
892 rm = p->rmargin;
893 rmax = p->maxrmargin;
894 p->rmargin = p->maxrmargin = TERM_MAXMARGIN;
895 p->flags |= TERMP_NOSPACE;
896 term_flushln(p);
897 p->flags &= ~TERMP_NOLPAD;
898 p->rmargin = rm;
899 p->maxrmargin = rmax;
900 }
901
902 if (MAN_EOS & n->flags)
903 p->flags |= TERMP_SENTENCE;
904 return;
905 case (MAN_EQN):
906 term_word(p, n->eqn->data);
907 return;
908 case (MAN_TBL):
909 /*
910 * Tables are preceded by a newline. Then process a
911 * table line, which will cause line termination,
912 */
913 if (TBL_SPAN_FIRST & n->span->flags)
914 term_newln(p);
915 term_tbl(p, n->span);
916 return;
917 default:
918 break;
919 }
920
921 if ( ! (MAN_NOTEXT & termacts[n->tok].flags))
922 term_fontrepl(p, TERMFONT_NONE);
923
924 c = 1;
925 if (termacts[n->tok].pre)
926 c = (*termacts[n->tok].pre)(p, mt, n, m);
927
928 if (c && n->child)
929 print_man_nodelist(p, mt, n->child, m);
930
931 if (termacts[n->tok].post)
932 (*termacts[n->tok].post)(p, mt, n, m);
933 if ( ! (MAN_NOTEXT & termacts[n->tok].flags))
934 term_fontrepl(p, TERMFONT_NONE);
935
936 if (MAN_EOS & n->flags)
937 p->flags |= TERMP_SENTENCE;
938 }
939
940
941 static void
942 print_man_nodelist(DECL_ARGS)
943 {
944
945 print_man_node(p, mt, n, m);
946 if ( ! n->next)
947 return;
948 print_man_nodelist(p, mt, n->next, m);
949 }
950
951
952 static void
953 print_man_foot(struct termp *p, const void *arg)
954 {
955 const struct man_meta *meta;
956
957 meta = (const struct man_meta *)arg;
958
959 term_fontrepl(p, TERMFONT_NONE);
960
961 term_vspace(p);
962 term_vspace(p);
963 term_vspace(p);
964
965 p->flags |= TERMP_NOSPACE | TERMP_NOBREAK;
966 p->rmargin = p->maxrmargin - term_strlen(p, meta->date);
967 p->offset = 0;
968
969 /* term_strlen() can return zero. */
970 if (p->rmargin == p->maxrmargin)
971 p->rmargin--;
972
973 if (meta->source)
974 term_word(p, meta->source);
975 if (meta->source)
976 term_word(p, "");
977 term_flushln(p);
978
979 p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
980 p->offset = p->rmargin;
981 p->rmargin = p->maxrmargin;
982 p->flags &= ~TERMP_NOBREAK;
983
984 term_word(p, meta->date);
985 term_flushln(p);
986 }
987
988
989 static void
990 print_man_head(struct termp *p, const void *arg)
991 {
992 char buf[BUFSIZ], title[BUFSIZ];
993 size_t buflen, titlen;
994 const struct man_meta *m;
995
996 m = (const struct man_meta *)arg;
997
998 /*
999 * Note that old groff would spit out some spaces before the
1000 * header. We discontinue this strange behaviour, but at one
1001 * point we did so here.
1002 */
1003
1004 p->rmargin = p->maxrmargin;
1005
1006 p->offset = 0;
1007 buf[0] = title[0] = '\0';
1008
1009 if (m->vol)
1010 strlcpy(buf, m->vol, BUFSIZ);
1011 buflen = term_strlen(p, buf);
1012
1013 snprintf(title, BUFSIZ, "%s(%s)", m->title, m->msec);
1014 titlen = term_strlen(p, title);
1015
1016 p->offset = 0;
1017 p->rmargin = 2 * (titlen+1) + buflen < p->maxrmargin ?
1018 (p->maxrmargin -
1019 term_strlen(p, buf) + term_len(p, 1)) / 2 :
1020 p->maxrmargin - buflen;
1021 p->flags |= TERMP_NOBREAK | TERMP_NOSPACE;
1022
1023 term_word(p, title);
1024 term_flushln(p);
1025
1026 p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
1027 p->offset = p->rmargin;
1028 p->rmargin = p->offset + buflen + titlen < p->maxrmargin ?
1029 p->maxrmargin - titlen : p->maxrmargin;
1030
1031 term_word(p, buf);
1032 term_flushln(p);
1033
1034 p->flags &= ~TERMP_NOBREAK;
1035 if (p->rmargin + titlen <= p->maxrmargin) {
1036 p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
1037 p->offset = p->rmargin;
1038 p->rmargin = p->maxrmargin;
1039 term_word(p, title);
1040 term_flushln(p);
1041 }
1042
1043 p->rmargin = p->maxrmargin;
1044 p->offset = 0;
1045 p->flags &= ~TERMP_NOSPACE;
1046
1047 /*
1048 * Groff likes to have some leading spaces before content. Well
1049 * that's fine by me.
1050 */
1051
1052 term_vspace(p);
1053 term_vspace(p);
1054 term_vspace(p);
1055 }
A git conversion mirror of mandoc.bsd.lv