7c9f05ff287299473bacf645f06e8f43b8810770
[dragonfly.git] / usr.bin / mandoc / man_term.c
1 /*      $Id: man_term.c,v 1.19 2009/10/27 21:40:07 schwarze Exp $ */
2 /*
3  * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>
4  *
5  * Permission to use, copy, modify, and distribute this software for any
6  * purpose with or without fee is hereby granted, provided that the above
7  * copyright notice and this permission notice appear in all copies.
8  *
9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16  */
17 #include <sys/types.h>
18
19 #include <assert.h>
20 #include <ctype.h>
21 #include <err.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25
26 #include "out.h"
27 #include "man.h"
28 #include "term.h"
29 #include "chars.h"
30 #include "main.h"
31
32 #define INDENT            7
33 #define HALFINDENT        3
34
35 /* FIXME: have PD set the default vspace width. */
36
37 struct  mtermp {
38         int               fl;
39 #define MANT_LITERAL     (1 << 0)
40         /*
41          * Default amount to indent the left margin after leading text
42          * has been printed (e.g., `HP' left-indent, `TP' and `IP' body
43          * indent).  This needs to be saved because `HP' and so on, if
44          * not having a specified value, must default.
45          *
46          * Note that this is the indentation AFTER the left offset, so
47          * the total offset is usually offset + lmargin.
48          */
49         size_t            lmargin;
50         /*
51          * The default offset, i.e., the amount between any text and the
52          * page boundary.
53          */
54         size_t            offset;
55 };
56
57 #define DECL_ARGS         struct termp *p, \
58                           struct mtermp *mt, \
59                           const struct man_node *n, \
60                           const struct man_meta *m
61
62 struct  termact {
63         int             (*pre)(DECL_ARGS);
64         void            (*post)(DECL_ARGS);
65 };
66
67 static  int               a2width(const struct man_node *);
68 static  int               a2height(const struct man_node *);
69
70 static  void              print_man_head(struct termp *,
71                                 const struct man_meta *);
72 static  void              print_man_body(DECL_ARGS);
73 static  void              print_man_node(DECL_ARGS);
74 static  void              print_man_foot(struct termp *,
75                                 const struct man_meta *);
76 static  void              print_bvspace(struct termp *,
77                                 const struct man_node *);
78
79 static  int               pre_B(DECL_ARGS);
80 static  int               pre_BI(DECL_ARGS);
81 static  int               pre_HP(DECL_ARGS);
82 static  int               pre_I(DECL_ARGS);
83 static  int               pre_IP(DECL_ARGS);
84 static  int               pre_IR(DECL_ARGS);
85 static  int               pre_PP(DECL_ARGS);
86 static  int               pre_RB(DECL_ARGS);
87 static  int               pre_RI(DECL_ARGS);
88 static  int               pre_RS(DECL_ARGS);
89 static  int               pre_SH(DECL_ARGS);
90 static  int               pre_SS(DECL_ARGS);
91 static  int               pre_TP(DECL_ARGS);
92 static  int               pre_br(DECL_ARGS);
93 static  int               pre_fi(DECL_ARGS);
94 static  int               pre_ign(DECL_ARGS);
95 static  int               pre_nf(DECL_ARGS);
96 static  int               pre_r(DECL_ARGS);
97 static  int               pre_sp(DECL_ARGS);
98
99 static  void              post_B(DECL_ARGS);
100 static  void              post_I(DECL_ARGS);
101 static  void              post_IP(DECL_ARGS);
102 static  void              post_HP(DECL_ARGS);
103 static  void              post_RS(DECL_ARGS);
104 static  void              post_SH(DECL_ARGS);
105 static  void              post_SS(DECL_ARGS);
106 static  void              post_TP(DECL_ARGS);
107 static  void              post_i(DECL_ARGS);
108
109 static  const struct termact termacts[MAN_MAX] = {
110         { pre_br, NULL }, /* br */
111         { NULL, NULL }, /* TH */
112         { pre_SH, post_SH }, /* SH */
113         { pre_SS, post_SS }, /* SS */
114         { pre_TP, post_TP }, /* TP */
115         { pre_PP, NULL }, /* LP */
116         { pre_PP, NULL }, /* PP */
117         { pre_PP, NULL }, /* P */
118         { pre_IP, post_IP }, /* IP */
119         { pre_HP, post_HP }, /* HP */
120         { NULL, NULL }, /* SM */
121         { pre_B, post_B }, /* SB */
122         { pre_BI, NULL }, /* BI */
123         { pre_BI, NULL }, /* IB */
124         { pre_RB, NULL }, /* BR */
125         { pre_RB, NULL }, /* RB */
126         { NULL, NULL }, /* R */
127         { pre_B, post_B }, /* B */
128         { pre_I, post_I }, /* I */
129         { pre_IR, NULL }, /* IR */
130         { pre_RI, NULL }, /* RI */
131         { NULL, NULL }, /* na */
132         { pre_I, post_i }, /* i */
133         { pre_sp, NULL }, /* sp */
134         { pre_nf, NULL }, /* nf */
135         { pre_fi, NULL }, /* fi */
136         { pre_r, NULL }, /* r */
137         { NULL, NULL }, /* RE */
138         { pre_RS, post_RS }, /* RS */
139         { pre_ign, NULL }, /* DT */
140         { pre_ign, NULL }, /* UC */
141         { pre_ign, NULL }, /* PD */
142 };
143
144
145
146 void
147 terminal_man(void *arg, const struct man *man)
148 {
149         struct termp            *p;
150         const struct man_node   *n;
151         const struct man_meta   *m;
152         struct mtermp            mt;
153
154         p = (struct termp *)arg;
155
156         if (NULL == p->symtab)
157                 switch (p->enc) {
158                 case (TERMENC_ASCII):
159                         p->symtab = chars_init(CHARS_ASCII);
160                         break;
161                 default:
162                         abort();
163                         /* NOTREACHED */
164                 }
165
166         n = man_node(man);
167         m = man_meta(man);
168
169         print_man_head(p, m);
170         p->flags |= TERMP_NOSPACE;
171
172         mt.fl = 0;
173         mt.lmargin = INDENT;
174         mt.offset = INDENT;
175
176         if (n->child)
177                 print_man_body(p, &mt, n->child, m);
178         print_man_foot(p, m);
179 }
180
181
182 static int
183 a2height(const struct man_node *n)
184 {
185         struct roffsu    su;
186
187         assert(MAN_TEXT == n->type);
188         assert(n->string);
189         if ( ! a2roffsu(n->string, &su, SCALE_VS))
190                 SCALE_VS_INIT(&su, strlen(n->string));
191
192         return((int)term_vspan(&su));
193 }
194
195
196 static int
197 a2width(const struct man_node *n)
198 {
199         struct roffsu    su;
200
201         assert(MAN_TEXT == n->type);
202         assert(n->string);
203         if ( ! a2roffsu(n->string, &su, SCALE_BU))
204                 return(-1);
205
206         return((int)term_hspan(&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         p->under++;
242         return(1);
243 }
244
245
246 /* ARGSUSED */
247 static int
248 pre_r(DECL_ARGS)
249 {
250
251         p->bold = p->under = 0;
252         return(1);
253 }
254
255
256 /* ARGSUSED */
257 static void
258 post_i(DECL_ARGS)
259 {
260
261         if (n->nchild)
262                 p->under--;
263 }
264
265
266 /* ARGSUSED */
267 static void
268 post_I(DECL_ARGS)
269 {
270
271         p->under--;
272 }
273
274
275 /* ARGSUSED */
276 static int
277 pre_fi(DECL_ARGS)
278 {
279
280         mt->fl &= ~MANT_LITERAL;
281         return(1);
282 }
283
284
285 /* ARGSUSED */
286 static int
287 pre_nf(DECL_ARGS)
288 {
289
290         term_newln(p);
291         mt->fl |= MANT_LITERAL;
292         return(1);
293 }
294
295
296 /* ARGSUSED */
297 static int
298 pre_IR(DECL_ARGS)
299 {
300         const struct man_node *nn;
301         int              i;
302
303         for (i = 0, nn = n->child; nn; nn = nn->next, i++) {
304                 if ( ! (i % 2))
305                         p->under++;
306                 if (i > 0)
307                         p->flags |= TERMP_NOSPACE;
308                 print_man_node(p, mt, nn, m);
309                 if ( ! (i % 2))
310                         p->under--;
311         }
312         return(0);
313 }
314
315
316 /* ARGSUSED */
317 static int
318 pre_RB(DECL_ARGS)
319 {
320         const struct man_node *nn;
321         int              i;
322
323         for (i = 0, nn = n->child; nn; nn = nn->next, i++) {
324                 if (i % 2 && MAN_RB == n->tok)
325                         p->bold++;
326                 else if ( ! (i % 2) && MAN_RB != n->tok)
327                         p->bold++;
328
329                 if (i > 0)
330                         p->flags |= TERMP_NOSPACE;
331
332                 print_man_node(p, mt, nn, m);
333
334                 if (i % 2 && MAN_RB == n->tok)
335                         p->bold--;
336                 else if ( ! (i % 2) && MAN_RB != n->tok)
337                         p->bold--;
338         }
339         return(0);
340 }
341
342
343 /* ARGSUSED */
344 static int
345 pre_RI(DECL_ARGS)
346 {
347         const struct man_node *nn;
348         int              i;
349
350         for (i = 0, nn = n->child; nn; nn = nn->next, i++) {
351                 if ( ! (i % 2))
352                         p->under++;
353                 if (i > 0)
354                         p->flags |= TERMP_NOSPACE;
355                 print_man_node(p, mt, nn, m);
356                 if ( ! (i % 2))
357                         p->under--;
358         }
359         return(0);
360 }
361
362
363 /* ARGSUSED */
364 static int
365 pre_BI(DECL_ARGS)
366 {
367         const struct man_node   *nn;
368         int                      i;
369
370         for (i = 0, nn = n->child; nn; nn = nn->next, i++) {
371                 if (i % 2 && MAN_BI == n->tok)
372                         p->under++;
373                 else if (i % 2)
374                         p->bold++;
375                 else if (MAN_BI == n->tok)
376                         p->bold++;
377                 else
378                         p->under++;
379
380                 if (i)
381                         p->flags |= TERMP_NOSPACE;
382                 print_man_node(p, mt, nn, m);
383
384                 if (i % 2 && MAN_BI == n->tok)
385                         p->under--;
386                 else if (i % 2)
387                         p->bold--;
388                 else if (MAN_BI == n->tok)
389                         p->bold--;
390                 else
391                         p->under--;
392         }
393         return(0);
394 }
395
396
397 /* ARGSUSED */
398 static int
399 pre_B(DECL_ARGS)
400 {
401
402         p->bold++;
403         return(1);
404 }
405
406
407 /* ARGSUSED */
408 static void
409 post_B(DECL_ARGS)
410 {
411
412         p->bold--;
413 }
414
415
416 /* ARGSUSED */
417 static int
418 pre_sp(DECL_ARGS)
419 {
420         int              i, len;
421
422         len = n->child ? a2height(n->child) : 1;
423
424         if (0 == len)
425                 term_newln(p);
426         for (i = 0; i < len; i++)
427                 term_vspace(p);
428
429         return(0);
430 }
431
432
433 /* ARGSUSED */
434 static int
435 pre_br(DECL_ARGS)
436 {
437
438         term_newln(p);
439         return(0);
440 }
441
442
443 /* ARGSUSED */
444 static int
445 pre_HP(DECL_ARGS)
446 {
447         size_t                   len;
448         int                      ival;
449         const struct man_node   *nn;
450
451         switch (n->type) {
452         case (MAN_BLOCK):
453                 print_bvspace(p, n);
454                 return(1);
455         case (MAN_BODY):
456                 p->flags |= TERMP_NOBREAK;
457                 p->flags |= TERMP_TWOSPACE;
458                 break;
459         default:
460                 return(0);
461         }
462
463         len = mt->lmargin;
464         ival = -1;
465
466         /* Calculate offset. */
467
468         if (NULL != (nn = n->parent->head->child))
469                 if ((ival = a2width(nn)) >= 0)
470                         len = (size_t)ival;
471
472         if (0 == len)
473                 len = 1;
474
475         p->offset = mt->offset;
476         p->rmargin = mt->offset + len;
477
478         if (ival >= 0)
479                 mt->lmargin = (size_t)ival;
480
481         return(1);
482 }
483
484
485 /* ARGSUSED */
486 static void
487 post_HP(DECL_ARGS)
488 {
489
490         switch (n->type) {
491         case (MAN_BLOCK):
492                 term_flushln(p);
493                 break;
494         case (MAN_BODY):
495                 term_flushln(p);
496                 p->flags &= ~TERMP_NOBREAK;
497                 p->flags &= ~TERMP_TWOSPACE;
498                 p->offset = mt->offset;
499                 p->rmargin = p->maxrmargin;
500                 break;
501         default:
502                 break;
503         }
504 }
505
506
507 /* ARGSUSED */
508 static int
509 pre_PP(DECL_ARGS)
510 {
511
512         switch (n->type) {
513         case (MAN_BLOCK):
514                 mt->lmargin = INDENT;
515                 print_bvspace(p, n);
516                 break;
517         default:
518                 p->offset = mt->offset;
519                 break;
520         }
521
522         return(1);
523 }
524
525
526 /* ARGSUSED */
527 static int
528 pre_IP(DECL_ARGS)
529 {
530         const struct man_node   *nn;
531         size_t                   len;
532         int                      ival;
533
534         switch (n->type) {
535         case (MAN_BODY):
536                 p->flags |= TERMP_NOLPAD;
537                 p->flags |= TERMP_NOSPACE;
538                 break;
539         case (MAN_HEAD):
540                 p->flags |= TERMP_NOBREAK;
541                 p->flags |= TERMP_TWOSPACE;
542                 break;
543         case (MAN_BLOCK):
544                 print_bvspace(p, n);
545                 /* FALLTHROUGH */
546         default:
547                 return(1);
548         }
549
550         len = mt->lmargin;
551         ival = -1;
552
553         /* Calculate offset. */
554
555         if (NULL != (nn = n->parent->head->child))
556                 if (NULL != (nn = nn->next)) {
557                         for ( ; nn->next; nn = nn->next)
558                                 /* Do nothing. */ ;
559                         if ((ival = a2width(nn)) >= 0)
560                                 len = (size_t)ival;
561                 }
562
563         switch (n->type) {
564         case (MAN_HEAD):
565                 /* Handle zero-width lengths. */
566                 if (0 == len)
567                         len = 1;
568
569                 p->offset = mt->offset;
570                 p->rmargin = mt->offset + len;
571                 if (ival < 0)
572                         break;
573
574                 /* Set the saved left-margin. */
575                 mt->lmargin = (size_t)ival;
576
577                 /* Don't print the length value. */
578                 for (nn = n->child; nn->next; nn = nn->next)
579                         print_man_node(p, mt, nn, m);
580                 return(0);
581         case (MAN_BODY):
582                 p->offset = mt->offset + len;
583                 p->rmargin = p->maxrmargin;
584                 break;
585         default:
586                 break;
587         }
588
589         return(1);
590 }
591
592
593 /* ARGSUSED */
594 static void
595 post_IP(DECL_ARGS)
596 {
597
598         switch (n->type) {
599         case (MAN_HEAD):
600                 term_flushln(p);
601                 p->flags &= ~TERMP_NOBREAK;
602                 p->flags &= ~TERMP_TWOSPACE;
603                 p->rmargin = p->maxrmargin;
604                 break;
605         case (MAN_BODY):
606                 term_flushln(p);
607                 p->flags &= ~TERMP_NOLPAD;
608                 break;
609         default:
610                 break;
611         }
612 }
613
614
615 /* ARGSUSED */
616 static int
617 pre_TP(DECL_ARGS)
618 {
619         const struct man_node   *nn;
620         size_t                   len;
621         int                      ival;
622
623         switch (n->type) {
624         case (MAN_HEAD):
625                 p->flags |= TERMP_NOBREAK;
626                 p->flags |= TERMP_TWOSPACE;
627                 break;
628         case (MAN_BODY):
629                 p->flags |= TERMP_NOLPAD;
630                 p->flags |= TERMP_NOSPACE;
631                 break;
632         case (MAN_BLOCK):
633                 print_bvspace(p, n);
634                 /* FALLTHROUGH */
635         default:
636                 return(1);
637         }
638
639         len = (size_t)mt->lmargin;
640         ival = -1;
641
642         /* Calculate offset. */
643
644         if (NULL != (nn = n->parent->head->child))
645                 if (NULL != nn->next)
646                         if ((ival = a2width(nn)) >= 0)
647                                 len = (size_t)ival;
648
649         switch (n->type) {
650         case (MAN_HEAD):
651                 /* Handle zero-length properly. */
652                 if (0 == len)
653                         len = 1;
654
655                 p->offset = mt->offset;
656                 p->rmargin = mt->offset + len;
657
658                 /* Don't print same-line elements. */
659                 for (nn = n->child; nn; nn = nn->next)
660                         if (nn->line > n->line)
661                                 print_man_node(p, mt, nn, m);
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 */
680 static void
681 post_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_flushln(p);
693                 p->flags &= ~TERMP_NOLPAD;
694                 break;
695         default:
696                 break;
697         }
698 }
699
700
701 /* ARGSUSED */
702 static int
703 pre_SS(DECL_ARGS)
704 {
705
706         switch (n->type) {
707         case (MAN_BLOCK):
708                 mt->lmargin = INDENT;
709                 mt->offset = 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                 p->bold++;
720                 p->offset = 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 */
734 static void
735 post_SS(DECL_ARGS)
736 {
737
738         switch (n->type) {
739         case (MAN_HEAD):
740                 term_newln(p);
741                 p->bold--;
742                 break;
743         case (MAN_BODY):
744                 term_newln(p);
745                 break;
746         default:
747                 break;
748         }
749 }
750
751
752 /* ARGSUSED */
753 static int
754 pre_SH(DECL_ARGS)
755 {
756
757         switch (n->type) {
758         case (MAN_BLOCK):
759                 mt->lmargin = INDENT;
760                 mt->offset = INDENT;
761                 /* If following a prior empty `SH', no vspace. */
762                 if (n->prev && MAN_SH == n->prev->tok)
763                         if (NULL == n->prev->body->child)
764                                 break;
765                 term_vspace(p);
766                 break;
767         case (MAN_HEAD):
768                 p->bold++;
769                 p->offset = 0;
770                 break;
771         case (MAN_BODY):
772                 p->offset = mt->offset;
773                 break;
774         default:
775                 break;
776         }
777
778         return(1);
779 }
780
781
782 /* ARGSUSED */
783 static void
784 post_SH(DECL_ARGS)
785 {
786
787         switch (n->type) {
788         case (MAN_HEAD):
789                 term_newln(p);
790                 p->bold--;
791                 break;
792         case (MAN_BODY):
793                 term_newln(p);
794                 break;
795         default:
796                 break;
797         }
798 }
799
800
801 /* ARGSUSED */
802 static int
803 pre_RS(DECL_ARGS)
804 {
805         const struct man_node   *nn;
806         int                      ival;
807
808         switch (n->type) {
809         case (MAN_BLOCK):
810                 term_newln(p);
811                 return(1);
812         case (MAN_HEAD):
813                 return(0);
814         default:
815                 break;
816         }
817
818         if (NULL == (nn = n->parent->head->child)) {
819                 mt->offset = mt->lmargin + INDENT;
820                 p->offset = mt->offset;
821                 return(1);
822         }
823
824         if ((ival = a2width(nn)) < 0)
825                 return(1);
826
827         mt->offset = INDENT + (size_t)ival;
828         p->offset = mt->offset;
829
830         return(1);
831 }
832
833
834 /* ARGSUSED */
835 static void
836 post_RS(DECL_ARGS)
837 {
838
839         switch (n->type) {
840         case (MAN_BLOCK):
841                 mt->offset = mt->lmargin = INDENT;
842                 break;
843         default:
844                 term_newln(p);
845                 p->offset = INDENT;
846                 break;
847         }
848 }
849
850
851 static void
852 print_man_node(DECL_ARGS)
853 {
854         int              c, sz;
855
856         c = 1;
857
858         switch (n->type) {
859         case(MAN_TEXT):
860                 if (0 == *n->string) {
861                         term_vspace(p);
862                         break;
863                 }
864                 /*
865                  * Note!  This is hacky.  Here, we recognise the `\c'
866                  * escape embedded in so many -man pages.  It's supposed
867                  * to remove the subsequent space, so we mark NOSPACE if
868                  * it's encountered in the string.
869                  */
870                 sz = (int)strlen(n->string);
871                 term_word(p, n->string);
872                 if (sz >= 2 && n->string[sz - 1] == 'c' &&
873                                 n->string[sz - 2] == '\\')
874                         p->flags |= TERMP_NOSPACE;
875                 /* FIXME: this means that macro lines are munged!  */
876                 if (MANT_LITERAL & mt->fl) {
877                         p->flags |= TERMP_NOSPACE;
878                         term_flushln(p);
879                 }
880                 break;
881         default:
882                 if (termacts[n->tok].pre)
883                         c = (*termacts[n->tok].pre)(p, mt, n, m);
884                 break;
885         }
886
887         if (c && n->child)
888                 print_man_body(p, mt, n->child, m);
889
890         if (MAN_TEXT != n->type)
891                 if (termacts[n->tok].post)
892                         (*termacts[n->tok].post)(p, mt, n, m);
893 }
894
895
896 static void
897 print_man_body(DECL_ARGS)
898 {
899
900         print_man_node(p, mt, n, m);
901         if ( ! n->next)
902                 return;
903         print_man_body(p, mt, n->next, m);
904 }
905
906
907 static void
908 print_man_foot(struct termp *p, const struct man_meta *meta)
909 {
910         char            buf[DATESIZ];
911
912         time2a(meta->date, buf, DATESIZ);
913
914         term_vspace(p);
915
916         p->flags |= TERMP_NOSPACE | TERMP_NOBREAK;
917         p->rmargin = p->maxrmargin - strlen(buf);
918         p->offset = 0;
919
920         if (meta->source)
921                 term_word(p, meta->source);
922         if (meta->source)
923                 term_word(p, "");
924         term_flushln(p);
925
926         p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
927         p->offset = p->rmargin;
928         p->rmargin = p->maxrmargin;
929         p->flags &= ~TERMP_NOBREAK;
930
931         term_word(p, buf);
932         term_flushln(p);
933 }
934
935
936 static void
937 print_man_head(struct termp *p, const struct man_meta *meta)
938 {
939         char            *buf, *title;
940
941         p->rmargin = p->maxrmargin;
942         p->offset = 0;
943
944         if (NULL == (buf = malloc(p->rmargin)))
945                 err(EXIT_FAILURE, "malloc");
946         if (NULL == (title = malloc(p->rmargin)))
947                 err(EXIT_FAILURE, "malloc");
948
949         if (meta->vol)
950                 (void)strlcpy(buf, meta->vol, p->rmargin);
951         else
952                 *buf = 0;
953
954         (void)snprintf(title, p->rmargin, "%s(%d)",
955                         meta->title, meta->msec);
956
957         p->offset = 0;
958         p->rmargin = (p->maxrmargin - strlen(buf) + 1) / 2;
959         p->flags |= TERMP_NOBREAK | TERMP_NOSPACE;
960
961         term_word(p, title);
962         term_flushln(p);
963
964         p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
965         p->offset = p->rmargin;
966         p->rmargin = p->maxrmargin - strlen(title);
967
968         term_word(p, buf);
969         term_flushln(p);
970
971         p->offset = p->rmargin;
972         p->rmargin = p->maxrmargin;
973         p->flags &= ~TERMP_NOBREAK;
974         p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
975
976         term_word(p, title);
977         term_flushln(p);
978
979         p->rmargin = p->maxrmargin;
980         p->offset = 0;
981         p->flags &= ~TERMP_NOSPACE;
982
983         free(title);
984         free(buf);
985 }