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


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