Import mdocml-1.11.1
[dragonfly.git] / contrib / mdocml / man_term.c
1 /*      $Id: man_term.c,v 1.105 2011/03/22 10:13:01 kristaps Exp $ */
2 /*
3  * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
4  * Copyright (c) 2010, 2011 Ingo Schwarze <schwarze@openbsd.org>
5  *
6  * Permission to use, copy, modify, and distribute this software for any
7  * purpose with or without fee is hereby granted, provided that the above
8  * copyright notice and this permission notice appear in all copies.
9  *
10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17  */
18 #ifdef HAVE_CONFIG_H
19 #include "config.h"
20 #endif
21
22 #include <sys/types.h>
23
24 #include <assert.h>
25 #include <ctype.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29
30 #include "mandoc.h"
31 #include "out.h"
32 #include "man.h"
33 #include "term.h"
34 #include "main.h"
35
36 #define INDENT            7
37 #define HALFINDENT        3
38
39 /* FIXME: have PD set the default vspace width. */
40
41 struct  mtermp {
42         int               fl;
43 #define MANT_LITERAL     (1 << 0)
44         /* 
45          * Default amount to indent the left margin after leading text
46          * has been printed (e.g., `HP' left-indent, `TP' and `IP' body
47          * indent).  This needs to be saved because `HP' and so on, if
48          * not having a specified value, must default.
49          *
50          * Note that this is the indentation AFTER the left offset, so
51          * the total offset is usually offset + lmargin.
52          */
53         size_t            lmargin;
54         /*
55          * The default offset, i.e., the amount between any text and the
56          * page boundary.
57          */
58         size_t            offset;
59 };
60
61 #define DECL_ARGS         struct termp *p, \
62                           struct mtermp *mt, \
63                           const struct man_node *n, \
64                           const struct man_meta *m
65
66 struct  termact {
67         int             (*pre)(DECL_ARGS);
68         void            (*post)(DECL_ARGS);
69         int               flags;
70 #define MAN_NOTEXT       (1 << 0) /* Never has text children. */
71 };
72
73 static  int               a2width(const struct termp *, const char *);
74 static  size_t            a2height(const struct termp *, const char *);
75
76 static  void              print_man_nodelist(DECL_ARGS);
77 static  void              print_man_node(DECL_ARGS);
78 static  void              print_man_head(struct termp *, const void *);
79 static  void              print_man_foot(struct termp *, const void *);
80 static  void              print_bvspace(struct termp *, 
81                                 const struct man_node *);
82
83 static  int               pre_alternate(DECL_ARGS);
84 static  int               pre_B(DECL_ARGS);
85 static  int               pre_HP(DECL_ARGS);
86 static  int               pre_I(DECL_ARGS);
87 static  int               pre_IP(DECL_ARGS);
88 static  int               pre_PP(DECL_ARGS);
89 static  int               pre_RS(DECL_ARGS);
90 static  int               pre_SH(DECL_ARGS);
91 static  int               pre_SS(DECL_ARGS);
92 static  int               pre_TP(DECL_ARGS);
93 static  int               pre_ign(DECL_ARGS);
94 static  int               pre_in(DECL_ARGS);
95 static  int               pre_literal(DECL_ARGS);
96 static  int               pre_sp(DECL_ARGS);
97 static  int               pre_ft(DECL_ARGS);
98
99 static  void              post_IP(DECL_ARGS);
100 static  void              post_HP(DECL_ARGS);
101 static  void              post_RS(DECL_ARGS);
102 static  void              post_SH(DECL_ARGS);
103 static  void              post_SS(DECL_ARGS);
104 static  void              post_TP(DECL_ARGS);
105
106 static  const struct termact termacts[MAN_MAX] = {
107         { pre_sp, NULL, MAN_NOTEXT }, /* br */
108         { NULL, NULL, 0 }, /* TH */
109         { pre_SH, post_SH, 0 }, /* SH */
110         { pre_SS, post_SS, 0 }, /* SS */
111         { pre_TP, post_TP, 0 }, /* TP */
112         { pre_PP, NULL, 0 }, /* LP */
113         { pre_PP, NULL, 0 }, /* PP */
114         { pre_PP, NULL, 0 }, /* P */
115         { pre_IP, post_IP, 0 }, /* IP */
116         { pre_HP, post_HP, 0 }, /* HP */ 
117         { NULL, NULL, 0 }, /* SM */
118         { pre_B, NULL, 0 }, /* SB */
119         { pre_alternate, NULL, 0 }, /* BI */
120         { pre_alternate, NULL, 0 }, /* IB */
121         { pre_alternate, NULL, 0 }, /* BR */
122         { pre_alternate, NULL, 0 }, /* RB */
123         { NULL, NULL, 0 }, /* R */
124         { pre_B, NULL, 0 }, /* B */
125         { pre_I, NULL, 0 }, /* I */
126         { pre_alternate, NULL, 0 }, /* IR */
127         { pre_alternate, NULL, 0 }, /* RI */
128         { pre_ign, NULL, MAN_NOTEXT }, /* na */
129         { pre_sp, NULL, MAN_NOTEXT }, /* sp */
130         { pre_literal, NULL, 0 }, /* nf */
131         { pre_literal, NULL, 0 }, /* fi */
132         { NULL, NULL, 0 }, /* RE */
133         { pre_RS, post_RS, 0 }, /* RS */
134         { pre_ign, NULL, 0 }, /* DT */
135         { pre_ign, NULL, 0 }, /* UC */
136         { pre_ign, NULL, 0 }, /* PD */
137         { pre_ign, NULL, 0 }, /* AT */
138         { pre_in, NULL, MAN_NOTEXT }, /* in */
139         { pre_ft, NULL, MAN_NOTEXT }, /* ft */
140 };
141
142
143
144 void
145 terminal_man(void *arg, const struct man *man)
146 {
147         struct termp            *p;
148         const struct man_node   *n;
149         const struct man_meta   *m;
150         struct mtermp            mt;
151
152         p = (struct termp *)arg;
153
154         p->overstep = 0;
155         p->maxrmargin = p->defrmargin;
156         p->tabwidth = term_len(p, 5);
157
158         if (NULL == p->symtab)
159                 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
185 static size_t
186 a2height(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
197 static int
198 a2width(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
209 static void
210 print_bvspace(struct termp *p, const struct man_node *n)
211 {
212         term_newln(p);
213
214         if (n->body && n->body->child && MAN_TBL == n->body->child->type)
215                 return;
216
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 */
230 static int
231 pre_ign(DECL_ARGS)
232 {
233
234         return(0);
235 }
236
237
238 /* ARGSUSED */
239 static int
240 pre_I(DECL_ARGS)
241 {
242
243         term_fontrepl(p, TERMFONT_UNDER);
244         return(1);
245 }
246
247
248 /* ARGSUSED */
249 static int
250 pre_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
260         return(0);
261 }
262
263 /* ARGSUSED */
264 static int
265 pre_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 */
316 static int
317 pre_B(DECL_ARGS)
318 {
319
320         term_fontrepl(p, TERMFONT_BOLD);
321         return(1);
322 }
323
324 /* ARGSUSED */
325 static int
326 pre_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 */
366 static int
367 pre_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
402         /* Don't let this creep beyond the right margin. */
403
404         if (p->offset > p->rmargin)
405                 p->offset = p->rmargin;
406
407         return(0);
408 }
409
410
411 /* ARGSUSED */
412 static int
413 pre_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 */
436 static int
437 pre_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 */
478 static void
479 post_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 */
500 static int
501 pre_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 */
519 static int
520 pre_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 */
587 static void
588 post_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 */
608 static int
609 pre_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 */
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_newln(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 = 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 */
734 static void
735 post_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 */
752 static int
753 pre_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 */
785 static void
786 post_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 */
803 static int
804 pre_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 */
836 static void
837 post_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
854 static void
855 print_man_node(DECL_ARGS)
856 {
857         size_t           rm, rmax;
858         int              c;
859
860         switch (n->type) {
861         case(MAN_TEXT):
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) {
868                         term_vspace(p);
869                         return;
870                 } else if (' ' == *n->string && MAN_LINE & n->flags)
871                         term_newln(p);
872
873                 term_word(p, n->string);
874
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)) {
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                 }
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;
901         case (MAN_TBL):
902                 /*
903                  * Tables are preceded by a newline.  Then process a
904                  * table line, which will cause line termination,
905                  */
906                 if (TBL_SPAN_FIRST & n->span->flags) 
907                         term_newln(p);
908                 term_tbl(p, n->span);
909                 return;
910         default:
911                 break;
912         }
913
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
921         if (c && n->child)
922                 print_man_nodelist(p, mt, n->child, m);
923
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);
928
929         if (MAN_EOS & n->flags)
930                 p->flags |= TERMP_SENTENCE;
931 }
932
933
934 static void
935 print_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
945 static void
946 print_man_foot(struct termp *p, const void *arg)
947 {
948         const struct man_meta *meta;
949
950         meta = (const struct man_meta *)arg;
951
952         term_fontrepl(p, TERMFONT_NONE);
953
954         term_vspace(p);
955         term_vspace(p);
956         term_vspace(p);
957
958         p->flags |= TERMP_NOSPACE | TERMP_NOBREAK;
959         p->rmargin = p->maxrmargin - term_strlen(p, meta->date);
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
977         term_word(p, meta->date);
978         term_flushln(p);
979 }
980
981
982 static void
983 print_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 }