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