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