Import mdocml-1.12.3
[dragonfly.git] / contrib / mdocml / mdoc_term.c
1 /*      $Id: mdoc_term.c,v 1.258 2013/12/25 21:24:12 schwarze Exp $ */
2 /*
3  * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
4  * Copyright (c) 2010, 2012, 2013 Ingo Schwarze <schwarze@openbsd.org>
5  * Copyright (c) 2013 Franco Fichtner <franco@lastsummer.de>
6  *
7  * Permission to use, copy, modify, and distribute this software for any
8  * purpose with or without fee is hereby granted, provided that the above
9  * copyright notice and this permission notice appear in all copies.
10  *
11  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18  */
19 #ifdef HAVE_CONFIG_H
20 #include "config.h"
21 #endif
22
23 #include <sys/types.h>
24
25 #include <assert.h>
26 #include <ctype.h>
27 #include <stdint.h>
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <string.h>
31
32 #include "mandoc.h"
33 #include "out.h"
34 #include "term.h"
35 #include "mdoc.h"
36 #include "main.h"
37
38 struct  termpair {
39         struct termpair  *ppair;
40         int               count;
41 };
42
43 #define DECL_ARGS struct termp *p, \
44                   struct termpair *pair, \
45                   const struct mdoc_meta *meta, \
46                   struct mdoc_node *n
47
48 struct  termact {
49         int     (*pre)(DECL_ARGS);
50         void    (*post)(DECL_ARGS);
51 };
52
53 static  size_t    a2width(const struct termp *, const char *);
54 static  size_t    a2height(const struct termp *, const char *);
55 static  size_t    a2offs(const struct termp *, const char *);
56
57 static  void      print_bvspace(struct termp *,
58                         const struct mdoc_node *,
59                         const struct mdoc_node *);
60 static  void      print_mdoc_node(DECL_ARGS);
61 static  void      print_mdoc_nodelist(DECL_ARGS);
62 static  void      print_mdoc_head(struct termp *, const void *);
63 static  void      print_mdoc_foot(struct termp *, const void *);
64 static  void      synopsis_pre(struct termp *, 
65                         const struct mdoc_node *);
66
67 static  void      termp____post(DECL_ARGS);
68 static  void      termp__t_post(DECL_ARGS);
69 static  void      termp_an_post(DECL_ARGS);
70 static  void      termp_bd_post(DECL_ARGS);
71 static  void      termp_bk_post(DECL_ARGS);
72 static  void      termp_bl_post(DECL_ARGS);
73 static  void      termp_fd_post(DECL_ARGS);
74 static  void      termp_fo_post(DECL_ARGS);
75 static  void      termp_in_post(DECL_ARGS);
76 static  void      termp_it_post(DECL_ARGS);
77 static  void      termp_lb_post(DECL_ARGS);
78 static  void      termp_nm_post(DECL_ARGS);
79 static  void      termp_pf_post(DECL_ARGS);
80 static  void      termp_quote_post(DECL_ARGS);
81 static  void      termp_sh_post(DECL_ARGS);
82 static  void      termp_ss_post(DECL_ARGS);
83
84 static  int       termp__a_pre(DECL_ARGS);
85 static  int       termp__t_pre(DECL_ARGS);
86 static  int       termp_an_pre(DECL_ARGS);
87 static  int       termp_ap_pre(DECL_ARGS);
88 static  int       termp_bd_pre(DECL_ARGS);
89 static  int       termp_bf_pre(DECL_ARGS);
90 static  int       termp_bk_pre(DECL_ARGS);
91 static  int       termp_bl_pre(DECL_ARGS);
92 static  int       termp_bold_pre(DECL_ARGS);
93 static  int       termp_bt_pre(DECL_ARGS);
94 static  int       termp_bx_pre(DECL_ARGS);
95 static  int       termp_cd_pre(DECL_ARGS);
96 static  int       termp_d1_pre(DECL_ARGS);
97 static  int       termp_ex_pre(DECL_ARGS);
98 static  int       termp_fa_pre(DECL_ARGS);
99 static  int       termp_fd_pre(DECL_ARGS);
100 static  int       termp_fl_pre(DECL_ARGS);
101 static  int       termp_fn_pre(DECL_ARGS);
102 static  int       termp_fo_pre(DECL_ARGS);
103 static  int       termp_ft_pre(DECL_ARGS);
104 static  int       termp_in_pre(DECL_ARGS);
105 static  int       termp_it_pre(DECL_ARGS);
106 static  int       termp_li_pre(DECL_ARGS);
107 static  int       termp_lk_pre(DECL_ARGS);
108 static  int       termp_nd_pre(DECL_ARGS);
109 static  int       termp_nm_pre(DECL_ARGS);
110 static  int       termp_ns_pre(DECL_ARGS);
111 static  int       termp_quote_pre(DECL_ARGS);
112 static  int       termp_rs_pre(DECL_ARGS);
113 static  int       termp_rv_pre(DECL_ARGS);
114 static  int       termp_sh_pre(DECL_ARGS);
115 static  int       termp_sm_pre(DECL_ARGS);
116 static  int       termp_sp_pre(DECL_ARGS);
117 static  int       termp_ss_pre(DECL_ARGS);
118 static  int       termp_under_pre(DECL_ARGS);
119 static  int       termp_ud_pre(DECL_ARGS);
120 static  int       termp_vt_pre(DECL_ARGS);
121 static  int       termp_xr_pre(DECL_ARGS);
122 static  int       termp_xx_pre(DECL_ARGS);
123
124 static  const struct termact termacts[MDOC_MAX] = {
125         { termp_ap_pre, NULL }, /* Ap */
126         { NULL, NULL }, /* Dd */
127         { NULL, NULL }, /* Dt */
128         { NULL, NULL }, /* Os */
129         { termp_sh_pre, termp_sh_post }, /* Sh */
130         { termp_ss_pre, termp_ss_post }, /* Ss */ 
131         { termp_sp_pre, NULL }, /* Pp */ 
132         { termp_d1_pre, termp_bl_post }, /* D1 */
133         { termp_d1_pre, termp_bl_post }, /* Dl */
134         { termp_bd_pre, termp_bd_post }, /* Bd */
135         { NULL, NULL }, /* Ed */
136         { termp_bl_pre, termp_bl_post }, /* Bl */
137         { NULL, NULL }, /* El */
138         { termp_it_pre, termp_it_post }, /* It */
139         { termp_under_pre, NULL }, /* Ad */ 
140         { termp_an_pre, termp_an_post }, /* An */
141         { termp_under_pre, NULL }, /* Ar */
142         { termp_cd_pre, NULL }, /* Cd */
143         { termp_bold_pre, NULL }, /* Cm */
144         { NULL, NULL }, /* Dv */ 
145         { NULL, NULL }, /* Er */ 
146         { NULL, NULL }, /* Ev */ 
147         { termp_ex_pre, NULL }, /* Ex */
148         { termp_fa_pre, NULL }, /* Fa */ 
149         { termp_fd_pre, termp_fd_post }, /* Fd */ 
150         { termp_fl_pre, NULL }, /* Fl */
151         { termp_fn_pre, NULL }, /* Fn */ 
152         { termp_ft_pre, NULL }, /* Ft */ 
153         { termp_bold_pre, NULL }, /* Ic */ 
154         { termp_in_pre, termp_in_post }, /* In */ 
155         { termp_li_pre, NULL }, /* Li */
156         { termp_nd_pre, NULL }, /* Nd */ 
157         { termp_nm_pre, termp_nm_post }, /* Nm */ 
158         { termp_quote_pre, termp_quote_post }, /* Op */
159         { NULL, NULL }, /* Ot */
160         { termp_under_pre, NULL }, /* Pa */
161         { termp_rv_pre, NULL }, /* Rv */
162         { NULL, NULL }, /* St */ 
163         { termp_under_pre, NULL }, /* Va */
164         { termp_vt_pre, NULL }, /* Vt */
165         { termp_xr_pre, NULL }, /* Xr */
166         { termp__a_pre, termp____post }, /* %A */
167         { termp_under_pre, termp____post }, /* %B */
168         { NULL, termp____post }, /* %D */
169         { termp_under_pre, termp____post }, /* %I */
170         { termp_under_pre, termp____post }, /* %J */
171         { NULL, termp____post }, /* %N */
172         { NULL, termp____post }, /* %O */
173         { NULL, termp____post }, /* %P */
174         { NULL, termp____post }, /* %R */
175         { termp__t_pre, termp__t_post }, /* %T */
176         { NULL, termp____post }, /* %V */
177         { NULL, NULL }, /* Ac */
178         { termp_quote_pre, termp_quote_post }, /* Ao */
179         { termp_quote_pre, termp_quote_post }, /* Aq */
180         { NULL, NULL }, /* At */
181         { NULL, NULL }, /* Bc */
182         { termp_bf_pre, NULL }, /* Bf */ 
183         { termp_quote_pre, termp_quote_post }, /* Bo */
184         { termp_quote_pre, termp_quote_post }, /* Bq */
185         { termp_xx_pre, NULL }, /* Bsx */
186         { termp_bx_pre, NULL }, /* Bx */
187         { NULL, NULL }, /* Db */
188         { NULL, NULL }, /* Dc */
189         { termp_quote_pre, termp_quote_post }, /* Do */
190         { termp_quote_pre, termp_quote_post }, /* Dq */
191         { NULL, NULL }, /* Ec */ /* FIXME: no space */
192         { NULL, NULL }, /* Ef */
193         { termp_under_pre, NULL }, /* Em */ 
194         { termp_quote_pre, termp_quote_post }, /* Eo */
195         { termp_xx_pre, NULL }, /* Fx */
196         { termp_bold_pre, NULL }, /* Ms */
197         { NULL, NULL }, /* No */
198         { termp_ns_pre, NULL }, /* Ns */
199         { termp_xx_pre, NULL }, /* Nx */
200         { termp_xx_pre, NULL }, /* Ox */
201         { NULL, NULL }, /* Pc */
202         { NULL, termp_pf_post }, /* Pf */
203         { termp_quote_pre, termp_quote_post }, /* Po */
204         { termp_quote_pre, termp_quote_post }, /* Pq */
205         { NULL, NULL }, /* Qc */
206         { termp_quote_pre, termp_quote_post }, /* Ql */
207         { termp_quote_pre, termp_quote_post }, /* Qo */
208         { termp_quote_pre, termp_quote_post }, /* Qq */
209         { NULL, NULL }, /* Re */
210         { termp_rs_pre, NULL }, /* Rs */
211         { NULL, NULL }, /* Sc */
212         { termp_quote_pre, termp_quote_post }, /* So */
213         { termp_quote_pre, termp_quote_post }, /* Sq */
214         { termp_sm_pre, NULL }, /* Sm */
215         { termp_under_pre, NULL }, /* Sx */
216         { termp_bold_pre, NULL }, /* Sy */
217         { NULL, NULL }, /* Tn */
218         { termp_xx_pre, NULL }, /* Ux */
219         { NULL, NULL }, /* Xc */
220         { NULL, NULL }, /* Xo */
221         { termp_fo_pre, termp_fo_post }, /* Fo */ 
222         { NULL, NULL }, /* Fc */ 
223         { termp_quote_pre, termp_quote_post }, /* Oo */
224         { NULL, NULL }, /* Oc */
225         { termp_bk_pre, termp_bk_post }, /* Bk */
226         { NULL, NULL }, /* Ek */
227         { termp_bt_pre, NULL }, /* Bt */
228         { NULL, NULL }, /* Hf */
229         { NULL, NULL }, /* Fr */
230         { termp_ud_pre, NULL }, /* Ud */
231         { NULL, termp_lb_post }, /* Lb */
232         { termp_sp_pre, NULL }, /* Lp */ 
233         { termp_lk_pre, NULL }, /* Lk */ 
234         { termp_under_pre, NULL }, /* Mt */ 
235         { termp_quote_pre, termp_quote_post }, /* Brq */ 
236         { termp_quote_pre, termp_quote_post }, /* Bro */ 
237         { NULL, NULL }, /* Brc */ 
238         { NULL, termp____post }, /* %C */ 
239         { NULL, NULL }, /* Es */ /* TODO */
240         { NULL, NULL }, /* En */ /* TODO */
241         { termp_xx_pre, NULL }, /* Dx */ 
242         { NULL, termp____post }, /* %Q */ 
243         { termp_sp_pre, NULL }, /* br */
244         { termp_sp_pre, NULL }, /* sp */ 
245         { NULL, termp____post }, /* %U */ 
246         { NULL, NULL }, /* Ta */ 
247 };
248
249
250 void
251 terminal_mdoc(void *arg, const struct mdoc *mdoc)
252 {
253         const struct mdoc_node  *n;
254         const struct mdoc_meta  *meta;
255         struct termp            *p;
256
257         p = (struct termp *)arg;
258
259         if (0 == p->defindent)
260                 p->defindent = 5;
261
262         p->overstep = 0;
263         p->maxrmargin = p->defrmargin;
264         p->tabwidth = term_len(p, 5);
265
266         if (NULL == p->symtab)
267                 p->symtab = mchars_alloc();
268
269         n = mdoc_node(mdoc);
270         meta = mdoc_meta(mdoc);
271
272         term_begin(p, print_mdoc_head, print_mdoc_foot, meta);
273
274         if (n->child)
275                 print_mdoc_nodelist(p, NULL, meta, n->child);
276
277         term_end(p);
278 }
279
280
281 static void
282 print_mdoc_nodelist(DECL_ARGS)
283 {
284
285         print_mdoc_node(p, pair, meta, n);
286         if (n->next)
287                 print_mdoc_nodelist(p, pair, meta, n->next);
288 }
289
290
291 /* ARGSUSED */
292 static void
293 print_mdoc_node(DECL_ARGS)
294 {
295         int              chld;
296         struct termpair  npair;
297         size_t           offset, rmargin;
298
299         chld = 1;
300         offset = p->offset;
301         rmargin = p->rmargin;
302         n->prev_font = term_fontq(p);
303
304         memset(&npair, 0, sizeof(struct termpair));
305         npair.ppair = pair;
306
307         /*
308          * Keeps only work until the end of a line.  If a keep was
309          * invoked in a prior line, revert it to PREKEEP.
310          */
311
312         if (TERMP_KEEP & p->flags) {
313                 if (n->prev ? (n->prev->lastline != n->line) :
314                     (n->parent && n->parent->line != n->line)) {
315                         p->flags &= ~TERMP_KEEP;
316                         p->flags |= TERMP_PREKEEP;
317                 }
318         }
319
320         /*
321          * After the keep flags have been set up, we may now
322          * produce output.  Note that some pre-handlers do so.
323          */
324
325         switch (n->type) {
326         case (MDOC_TEXT):
327                 if (' ' == *n->string && MDOC_LINE & n->flags)
328                         term_newln(p);
329                 if (MDOC_DELIMC & n->flags)
330                         p->flags |= TERMP_NOSPACE;
331                 term_word(p, n->string);
332                 if (MDOC_DELIMO & n->flags)
333                         p->flags |= TERMP_NOSPACE;
334                 break;
335         case (MDOC_EQN):
336                 term_eqn(p, n->eqn);
337                 break;
338         case (MDOC_TBL):
339                 term_tbl(p, n->span);
340                 break;
341         default:
342                 if (termacts[n->tok].pre && ENDBODY_NOT == n->end)
343                         chld = (*termacts[n->tok].pre)
344                                 (p, &npair, meta, n);
345                 break;
346         }
347
348         if (chld && n->child)
349                 print_mdoc_nodelist(p, &npair, meta, n->child);
350
351         term_fontpopq(p,
352             (ENDBODY_NOT == n->end ? n : n->pending)->prev_font);
353
354         switch (n->type) {
355         case (MDOC_TEXT):
356                 break;
357         case (MDOC_TBL):
358                 break;
359         case (MDOC_EQN):
360                 break;
361         default:
362                 if ( ! termacts[n->tok].post || MDOC_ENDED & n->flags)
363                         break;
364                 (void)(*termacts[n->tok].post)(p, &npair, meta, n);
365
366                 /*
367                  * Explicit end tokens not only call the post
368                  * handler, but also tell the respective block
369                  * that it must not call the post handler again.
370                  */
371                 if (ENDBODY_NOT != n->end)
372                         n->pending->flags |= MDOC_ENDED;
373
374                 /*
375                  * End of line terminating an implicit block
376                  * while an explicit block is still open.
377                  * Continue the explicit block without spacing.
378                  */
379                 if (ENDBODY_NOSPACE == n->end)
380                         p->flags |= TERMP_NOSPACE;
381                 break;
382         }
383
384         if (MDOC_EOS & n->flags)
385                 p->flags |= TERMP_SENTENCE;
386
387         p->offset = offset;
388         p->rmargin = rmargin;
389 }
390
391
392 static void
393 print_mdoc_foot(struct termp *p, const void *arg)
394 {
395         const struct mdoc_meta *meta;
396
397         meta = (const struct mdoc_meta *)arg;
398
399         term_fontrepl(p, TERMFONT_NONE);
400
401         /* 
402          * Output the footer in new-groff style, that is, three columns
403          * with the middle being the manual date and flanking columns
404          * being the operating system:
405          *
406          * SYSTEM                  DATE                    SYSTEM
407          */
408
409         term_vspace(p);
410
411         p->offset = 0;
412         p->rmargin = (p->maxrmargin - 
413                         term_strlen(p, meta->date) + term_len(p, 1)) / 2;
414         p->trailspace = 1;
415         p->flags |= TERMP_NOSPACE | TERMP_NOBREAK;
416
417         term_word(p, meta->os);
418         term_flushln(p);
419
420         p->offset = p->rmargin;
421         p->rmargin = p->maxrmargin - term_strlen(p, meta->os);
422         p->flags |= TERMP_NOSPACE;
423
424         term_word(p, meta->date);
425         term_flushln(p);
426
427         p->offset = p->rmargin;
428         p->rmargin = p->maxrmargin;
429         p->trailspace = 0;
430         p->flags &= ~TERMP_NOBREAK;
431         p->flags |= TERMP_NOSPACE;
432
433         term_word(p, meta->os);
434         term_flushln(p);
435
436         p->offset = 0;
437         p->rmargin = p->maxrmargin;
438         p->flags = 0;
439 }
440
441
442 static void
443 print_mdoc_head(struct termp *p, const void *arg)
444 {
445         char            buf[BUFSIZ], title[BUFSIZ];
446         size_t          buflen, titlen;
447         const struct mdoc_meta *meta;
448
449         meta = (const struct mdoc_meta *)arg;
450
451         /*
452          * The header is strange.  It has three components, which are
453          * really two with the first duplicated.  It goes like this:
454          *
455          * IDENTIFIER              TITLE                   IDENTIFIER
456          *
457          * The IDENTIFIER is NAME(SECTION), which is the command-name
458          * (if given, or "unknown" if not) followed by the manual page
459          * section.  These are given in `Dt'.  The TITLE is a free-form
460          * string depending on the manual volume.  If not specified, it
461          * switches on the manual section.
462          */
463
464         p->offset = 0;
465         p->rmargin = p->maxrmargin;
466
467         assert(meta->vol);
468         strlcpy(buf, meta->vol, BUFSIZ);
469         buflen = term_strlen(p, buf);
470
471         if (meta->arch) {
472                 strlcat(buf, " (", BUFSIZ);
473                 strlcat(buf, meta->arch, BUFSIZ);
474                 strlcat(buf, ")", BUFSIZ);
475         }
476
477         snprintf(title, BUFSIZ, "%s(%s)", meta->title, meta->msec);
478         titlen = term_strlen(p, title);
479
480         p->flags |= TERMP_NOBREAK | TERMP_NOSPACE;
481         p->trailspace = 1;
482         p->offset = 0;
483         p->rmargin = 2 * (titlen+1) + buflen < p->maxrmargin ?
484             (p->maxrmargin -
485              term_strlen(p, buf) + term_len(p, 1)) / 2 :
486             p->maxrmargin - buflen;
487
488         term_word(p, title);
489         term_flushln(p);
490
491         p->flags |= TERMP_NOSPACE;
492         p->offset = p->rmargin;
493         p->rmargin = p->offset + buflen + titlen < p->maxrmargin ?
494             p->maxrmargin - titlen : p->maxrmargin;
495
496         term_word(p, buf);
497         term_flushln(p);
498
499         p->flags &= ~TERMP_NOBREAK;
500         p->trailspace = 0;
501         if (p->rmargin + titlen <= p->maxrmargin) {
502                 p->flags |= TERMP_NOSPACE;
503                 p->offset = p->rmargin;
504                 p->rmargin = p->maxrmargin;
505                 term_word(p, title);
506                 term_flushln(p);
507         }
508
509         p->flags &= ~TERMP_NOSPACE;
510         p->offset = 0;
511         p->rmargin = p->maxrmargin;
512 }
513
514
515 static size_t
516 a2height(const struct termp *p, const char *v)
517 {
518         struct roffsu    su;
519
520
521         assert(v);
522         if ( ! a2roffsu(v, &su, SCALE_VS))
523                 SCALE_VS_INIT(&su, atoi(v));
524
525         return(term_vspan(p, &su));
526 }
527
528
529 static size_t
530 a2width(const struct termp *p, const char *v)
531 {
532         struct roffsu    su;
533
534         assert(v);
535         if ( ! a2roffsu(v, &su, SCALE_MAX))
536                 SCALE_HS_INIT(&su, term_strlen(p, v));
537
538         return(term_hspan(p, &su));
539 }
540
541
542 static size_t
543 a2offs(const struct termp *p, const char *v)
544 {
545         struct roffsu    su;
546
547         if ('\0' == *v)
548                 return(0);
549         else if (0 == strcmp(v, "left"))
550                 return(0);
551         else if (0 == strcmp(v, "indent"))
552                 return(term_len(p, p->defindent + 1));
553         else if (0 == strcmp(v, "indent-two"))
554                 return(term_len(p, (p->defindent + 1) * 2));
555         else if ( ! a2roffsu(v, &su, SCALE_MAX))
556                 SCALE_HS_INIT(&su, term_strlen(p, v));
557
558         return(term_hspan(p, &su));
559 }
560
561
562 /*
563  * Determine how much space to print out before block elements of `It'
564  * (and thus `Bl') and `Bd'.  And then go ahead and print that space,
565  * too.
566  */
567 static void
568 print_bvspace(struct termp *p, 
569                 const struct mdoc_node *bl, 
570                 const struct mdoc_node *n)
571 {
572         const struct mdoc_node  *nn;
573
574         assert(n);
575
576         term_newln(p);
577
578         if (MDOC_Bd == bl->tok && bl->norm->Bd.comp)
579                 return;
580         if (MDOC_Bl == bl->tok && bl->norm->Bl.comp)
581                 return;
582
583         /* Do not vspace directly after Ss/Sh. */
584
585         for (nn = n; nn; nn = nn->parent) {
586                 if (MDOC_BLOCK != nn->type)
587                         continue;
588                 if (MDOC_Ss == nn->tok)
589                         return;
590                 if (MDOC_Sh == nn->tok)
591                         return;
592                 if (NULL == nn->prev)
593                         continue;
594                 break;
595         }
596
597         /* A `-column' does not assert vspace within the list. */
598
599         if (MDOC_Bl == bl->tok && LIST_column == bl->norm->Bl.type)
600                 if (n->prev && MDOC_It == n->prev->tok)
601                         return;
602
603         /* A `-diag' without body does not vspace. */
604
605         if (MDOC_Bl == bl->tok && LIST_diag == bl->norm->Bl.type)
606                 if (n->prev && MDOC_It == n->prev->tok) {
607                         assert(n->prev->body);
608                         if (NULL == n->prev->body->child)
609                                 return;
610                 }
611
612         term_vspace(p);
613 }
614
615
616 /* ARGSUSED */
617 static int
618 termp_it_pre(DECL_ARGS)
619 {
620         const struct mdoc_node *bl, *nn;
621         char                    buf[7];
622         int                     i;
623         size_t                  width, offset, ncols, dcol;
624         enum mdoc_list          type;
625
626         if (MDOC_BLOCK == n->type) {
627                 print_bvspace(p, n->parent->parent, n);
628                 return(1);
629         }
630
631         bl = n->parent->parent->parent;
632         type = bl->norm->Bl.type;
633
634         /* 
635          * First calculate width and offset.  This is pretty easy unless
636          * we're a -column list, in which case all prior columns must
637          * be accounted for.
638          */
639
640         width = offset = 0;
641
642         if (bl->norm->Bl.offs)
643                 offset = a2offs(p, bl->norm->Bl.offs);
644
645         switch (type) {
646         case (LIST_column):
647                 if (MDOC_HEAD == n->type)
648                         break;
649
650                 /*
651                  * Imitate groff's column handling:
652                  * - For each earlier column, add its width.
653                  * - For less than 5 columns, add four more blanks per
654                  *   column.
655                  * - For exactly 5 columns, add three more blank per
656                  *   column.
657                  * - For more than 5 columns, add only one column.
658                  */
659                 ncols = bl->norm->Bl.ncols;
660
661                 /* LINTED */
662                 dcol = ncols < 5 ? term_len(p, 4) : 
663                         ncols == 5 ? term_len(p, 3) : term_len(p, 1);
664
665                 /*
666                  * Calculate the offset by applying all prior MDOC_BODY,
667                  * so we stop at the MDOC_HEAD (NULL == nn->prev).
668                  */
669
670                 for (i = 0, nn = n->prev; 
671                                 nn->prev && i < (int)ncols; 
672                                 nn = nn->prev, i++)
673                         offset += dcol + a2width
674                                 (p, bl->norm->Bl.cols[i]);
675
676                 /*
677                  * When exceeding the declared number of columns, leave
678                  * the remaining widths at 0.  This will later be
679                  * adjusted to the default width of 10, or, for the last
680                  * column, stretched to the right margin.
681                  */
682                 if (i >= (int)ncols)
683                         break;
684
685                 /*
686                  * Use the declared column widths, extended as explained
687                  * in the preceding paragraph.
688                  */
689                 width = a2width(p, bl->norm->Bl.cols[i]) + dcol;
690                 break;
691         default:
692                 if (NULL == bl->norm->Bl.width)
693                         break;
694
695                 /* 
696                  * Note: buffer the width by 2, which is groff's magic
697                  * number for buffering single arguments.  See the above
698                  * handling for column for how this changes.
699                  */
700                 assert(bl->norm->Bl.width);
701                 width = a2width(p, bl->norm->Bl.width) + term_len(p, 2);
702                 break;
703         }
704
705         /* 
706          * List-type can override the width in the case of fixed-head
707          * values (bullet, dash/hyphen, enum).  Tags need a non-zero
708          * offset.
709          */
710
711         switch (type) {
712         case (LIST_bullet):
713                 /* FALLTHROUGH */
714         case (LIST_dash):
715                 /* FALLTHROUGH */
716         case (LIST_hyphen):
717                 /* FALLTHROUGH */
718         case (LIST_enum):
719                 if (width < term_len(p, 2))
720                         width = term_len(p, 2);
721                 break;
722         case (LIST_hang):
723                 if (0 == width)
724                         width = term_len(p, 8);
725                 break;
726         case (LIST_column):
727                 /* FALLTHROUGH */
728         case (LIST_tag):
729                 if (0 == width)
730                         width = term_len(p, 10);
731                 break;
732         default:
733                 break;
734         }
735
736         /* 
737          * Whitespace control.  Inset bodies need an initial space,
738          * while diagonal bodies need two.
739          */
740
741         p->flags |= TERMP_NOSPACE;
742
743         switch (type) {
744         case (LIST_diag):
745                 if (MDOC_BODY == n->type)
746                         term_word(p, "\\ \\ ");
747                 break;
748         case (LIST_inset):
749                 if (MDOC_BODY == n->type) 
750                         term_word(p, "\\ ");
751                 break;
752         default:
753                 break;
754         }
755
756         p->flags |= TERMP_NOSPACE;
757
758         switch (type) {
759         case (LIST_diag):
760                 if (MDOC_HEAD == n->type)
761                         term_fontpush(p, TERMFONT_BOLD);
762                 break;
763         default:
764                 break;
765         }
766
767         /*
768          * Pad and break control.  This is the tricky part.  These flags
769          * are documented in term_flushln() in term.c.  Note that we're
770          * going to unset all of these flags in termp_it_post() when we
771          * exit.
772          */
773
774         switch (type) {
775         case (LIST_enum):
776                 /*
777                  * Weird special case.
778                  * Very narrow enum lists actually hang.
779                  */
780                 if (width == term_len(p, 2))
781                         p->flags |= TERMP_HANG;
782                 /* FALLTHROUGH */
783         case (LIST_bullet):
784                 /* FALLTHROUGH */
785         case (LIST_dash):
786                 /* FALLTHROUGH */
787         case (LIST_hyphen):
788                 if (MDOC_HEAD != n->type)
789                         break;
790                 p->flags |= TERMP_NOBREAK;
791                 p->trailspace = 1;
792                 break;
793         case (LIST_hang):
794                 if (MDOC_HEAD != n->type)
795                         break;
796
797                 /*
798                  * This is ugly.  If `-hang' is specified and the body
799                  * is a `Bl' or `Bd', then we want basically to nullify
800                  * the "overstep" effect in term_flushln() and treat
801                  * this as a `-ohang' list instead.
802                  */
803                 if (n->next->child && 
804                                 (MDOC_Bl == n->next->child->tok ||
805                                  MDOC_Bd == n->next->child->tok))
806                         break;
807
808                 p->flags |= TERMP_NOBREAK | TERMP_HANG;
809                 p->trailspace = 1;
810                 break;
811         case (LIST_tag):
812                 if (MDOC_HEAD != n->type)
813                         break;
814
815                 p->flags |= TERMP_NOBREAK;
816                 p->trailspace = 2;
817
818                 if (NULL == n->next || NULL == n->next->child)
819                         p->flags |= TERMP_DANGLE;
820                 break;
821         case (LIST_column):
822                 if (MDOC_HEAD == n->type)
823                         break;
824
825                 if (NULL == n->next) {
826                         p->flags &= ~TERMP_NOBREAK;
827                         p->trailspace = 0;
828                 } else {
829                         p->flags |= TERMP_NOBREAK;
830                         p->trailspace = 1;
831                 }
832
833                 break;
834         case (LIST_diag):
835                 if (MDOC_HEAD != n->type)
836                         break;
837                 p->flags |= TERMP_NOBREAK;
838                 p->trailspace = 1;
839                 break;
840         default:
841                 break;
842         }
843
844         /* 
845          * Margin control.  Set-head-width lists have their right
846          * margins shortened.  The body for these lists has the offset
847          * necessarily lengthened.  Everybody gets the offset.
848          */
849
850         p->offset += offset;
851
852         switch (type) {
853         case (LIST_hang):
854                 /*
855                  * Same stipulation as above, regarding `-hang'.  We
856                  * don't want to recalculate rmargin and offsets when
857                  * using `Bd' or `Bl' within `-hang' overstep lists.
858                  */
859                 if (MDOC_HEAD == n->type && n->next->child &&
860                                 (MDOC_Bl == n->next->child->tok || 
861                                  MDOC_Bd == n->next->child->tok))
862                         break;
863                 /* FALLTHROUGH */
864         case (LIST_bullet):
865                 /* FALLTHROUGH */
866         case (LIST_dash):
867                 /* FALLTHROUGH */
868         case (LIST_enum):
869                 /* FALLTHROUGH */
870         case (LIST_hyphen):
871                 /* FALLTHROUGH */
872         case (LIST_tag):
873                 assert(width);
874                 if (MDOC_HEAD == n->type)
875                         p->rmargin = p->offset + width;
876                 else 
877                         p->offset += width;
878                 break;
879         case (LIST_column):
880                 assert(width);
881                 p->rmargin = p->offset + width;
882                 /* 
883                  * XXX - this behaviour is not documented: the
884                  * right-most column is filled to the right margin.
885                  */
886                 if (MDOC_HEAD == n->type)
887                         break;
888                 if (NULL == n->next && p->rmargin < p->maxrmargin)
889                         p->rmargin = p->maxrmargin;
890                 break;
891         default:
892                 break;
893         }
894
895         /* 
896          * The dash, hyphen, bullet and enum lists all have a special
897          * HEAD character (temporarily bold, in some cases).  
898          */
899
900         if (MDOC_HEAD == n->type)
901                 switch (type) {
902                 case (LIST_bullet):
903                         term_fontpush(p, TERMFONT_BOLD);
904                         term_word(p, "\\[bu]");
905                         term_fontpop(p);
906                         break;
907                 case (LIST_dash):
908                         /* FALLTHROUGH */
909                 case (LIST_hyphen):
910                         term_fontpush(p, TERMFONT_BOLD);
911                         term_word(p, "\\(hy");
912                         term_fontpop(p);
913                         break;
914                 case (LIST_enum):
915                         (pair->ppair->ppair->count)++;
916                         snprintf(buf, sizeof(buf), "%d.", 
917                                         pair->ppair->ppair->count);
918                         term_word(p, buf);
919                         break;
920                 default:
921                         break;
922                 }
923
924         /* 
925          * If we're not going to process our children, indicate so here.
926          */
927
928         switch (type) {
929         case (LIST_bullet):
930                 /* FALLTHROUGH */
931         case (LIST_item):
932                 /* FALLTHROUGH */
933         case (LIST_dash):
934                 /* FALLTHROUGH */
935         case (LIST_hyphen):
936                 /* FALLTHROUGH */
937         case (LIST_enum):
938                 if (MDOC_HEAD == n->type)
939                         return(0);
940                 break;
941         case (LIST_column):
942                 if (MDOC_HEAD == n->type)
943                         return(0);
944                 break;
945         default:
946                 break;
947         }
948
949         return(1);
950 }
951
952
953 /* ARGSUSED */
954 static void
955 termp_it_post(DECL_ARGS)
956 {
957         enum mdoc_list     type;
958
959         if (MDOC_BLOCK == n->type)
960                 return;
961
962         type = n->parent->parent->parent->norm->Bl.type;
963
964         switch (type) {
965         case (LIST_item):
966                 /* FALLTHROUGH */
967         case (LIST_diag):
968                 /* FALLTHROUGH */
969         case (LIST_inset):
970                 if (MDOC_BODY == n->type)
971                         term_newln(p);
972                 break;
973         case (LIST_column):
974                 if (MDOC_BODY == n->type)
975                         term_flushln(p);
976                 break;
977         default:
978                 term_newln(p);
979                 break;
980         }
981
982         /* 
983          * Now that our output is flushed, we can reset our tags.  Since
984          * only `It' sets these flags, we're free to assume that nobody
985          * has munged them in the meanwhile.
986          */
987
988         p->flags &= ~TERMP_DANGLE;
989         p->flags &= ~TERMP_NOBREAK;
990         p->flags &= ~TERMP_HANG;
991         p->trailspace = 0;
992 }
993
994
995 /* ARGSUSED */
996 static int
997 termp_nm_pre(DECL_ARGS)
998 {
999
1000         if (MDOC_BLOCK == n->type) {
1001                 p->flags |= TERMP_PREKEEP;
1002                 return(1);
1003         }
1004
1005         if (MDOC_BODY == n->type) {
1006                 if (NULL == n->child)
1007                         return(0);
1008                 p->flags |= TERMP_NOSPACE;
1009                 p->offset += term_len(p, 1) +
1010                     (NULL == n->prev->child ?
1011                      term_strlen(p, meta->name) :
1012                      MDOC_TEXT == n->prev->child->type ?
1013                      term_strlen(p, n->prev->child->string) :
1014                      term_len(p, 5));
1015                 return(1);
1016         }
1017
1018         if (NULL == n->child && NULL == meta->name)
1019                 return(0);
1020
1021         if (MDOC_HEAD == n->type)
1022                 synopsis_pre(p, n->parent);
1023
1024         if (MDOC_HEAD == n->type && n->next->child) {
1025                 p->flags |= TERMP_NOSPACE | TERMP_NOBREAK;
1026                 p->trailspace = 1;
1027                 p->rmargin = p->offset + term_len(p, 1);
1028                 if (NULL == n->child) {
1029                         p->rmargin += term_strlen(p, meta->name);
1030                 } else if (MDOC_TEXT == n->child->type) {
1031                         p->rmargin += term_strlen(p, n->child->string);
1032                         if (n->child->next)
1033                                 p->flags |= TERMP_HANG;
1034                 } else {
1035                         p->rmargin += term_len(p, 5);
1036                         p->flags |= TERMP_HANG;
1037                 }
1038         }
1039
1040         term_fontpush(p, TERMFONT_BOLD);
1041         if (NULL == n->child)
1042                 term_word(p, meta->name);
1043         return(1);
1044 }
1045
1046
1047 /* ARGSUSED */
1048 static void
1049 termp_nm_post(DECL_ARGS)
1050 {
1051
1052         if (MDOC_BLOCK == n->type) {
1053                 p->flags &= ~(TERMP_KEEP | TERMP_PREKEEP);
1054         } else if (MDOC_HEAD == n->type && n->next->child) {
1055                 term_flushln(p);
1056                 p->flags &= ~(TERMP_NOBREAK | TERMP_HANG);
1057                 p->trailspace = 0;
1058         } else if (MDOC_BODY == n->type && n->child)
1059                 term_flushln(p);
1060 }
1061
1062                 
1063 /* ARGSUSED */
1064 static int
1065 termp_fl_pre(DECL_ARGS)
1066 {
1067
1068         term_fontpush(p, TERMFONT_BOLD);
1069         term_word(p, "\\-");
1070
1071         if (n->child)
1072                 p->flags |= TERMP_NOSPACE;
1073         else if (n->next && n->next->line == n->line)
1074                 p->flags |= TERMP_NOSPACE;
1075
1076         return(1);
1077 }
1078
1079
1080 /* ARGSUSED */
1081 static int
1082 termp__a_pre(DECL_ARGS)
1083 {
1084
1085         if (n->prev && MDOC__A == n->prev->tok)
1086                 if (NULL == n->next || MDOC__A != n->next->tok)
1087                         term_word(p, "and");
1088
1089         return(1);
1090 }
1091
1092
1093 /* ARGSUSED */
1094 static int
1095 termp_an_pre(DECL_ARGS)
1096 {
1097
1098         if (NULL == n->child)
1099                 return(1);
1100
1101         /*
1102          * If not in the AUTHORS section, `An -split' will cause
1103          * newlines to occur before the author name.  If in the AUTHORS
1104          * section, by default, the first `An' invocation is nosplit,
1105          * then all subsequent ones, regardless of whether interspersed
1106          * with other macros/text, are split.  -split, in this case,
1107          * will override the condition of the implied first -nosplit.
1108          */
1109         
1110         if (n->sec == SEC_AUTHORS) {
1111                 if ( ! (TERMP_ANPREC & p->flags)) {
1112                         if (TERMP_SPLIT & p->flags)
1113                                 term_newln(p);
1114                         return(1);
1115                 }
1116                 if (TERMP_NOSPLIT & p->flags)
1117                         return(1);
1118                 term_newln(p);
1119                 return(1);
1120         }
1121
1122         if (TERMP_SPLIT & p->flags)
1123                 term_newln(p);
1124
1125         return(1);
1126 }
1127
1128
1129 /* ARGSUSED */
1130 static void
1131 termp_an_post(DECL_ARGS)
1132 {
1133
1134         if (n->child) {
1135                 if (SEC_AUTHORS == n->sec)
1136                         p->flags |= TERMP_ANPREC;
1137                 return;
1138         }
1139
1140         if (AUTH_split == n->norm->An.auth) {
1141                 p->flags &= ~TERMP_NOSPLIT;
1142                 p->flags |= TERMP_SPLIT;
1143         } else if (AUTH_nosplit == n->norm->An.auth) {
1144                 p->flags &= ~TERMP_SPLIT;
1145                 p->flags |= TERMP_NOSPLIT;
1146         }
1147
1148 }
1149
1150
1151 /* ARGSUSED */
1152 static int
1153 termp_ns_pre(DECL_ARGS)
1154 {
1155
1156         if ( ! (MDOC_LINE & n->flags))
1157                 p->flags |= TERMP_NOSPACE;
1158         return(1);
1159 }
1160
1161
1162 /* ARGSUSED */
1163 static int
1164 termp_rs_pre(DECL_ARGS)
1165 {
1166
1167         if (SEC_SEE_ALSO != n->sec)
1168                 return(1);
1169         if (MDOC_BLOCK == n->type && n->prev)
1170                 term_vspace(p);
1171         return(1);
1172 }
1173
1174
1175 /* ARGSUSED */
1176 static int
1177 termp_rv_pre(DECL_ARGS)
1178 {
1179         int              nchild;
1180
1181         term_newln(p);
1182         term_word(p, "The");
1183
1184         nchild = n->nchild;
1185         for (n = n->child; n; n = n->next) {
1186                 term_fontpush(p, TERMFONT_BOLD);
1187                 term_word(p, n->string);
1188                 term_fontpop(p);
1189
1190                 p->flags |= TERMP_NOSPACE;
1191                 term_word(p, "()");
1192
1193                 if (nchild > 2 && n->next) {
1194                         p->flags |= TERMP_NOSPACE;
1195                         term_word(p, ",");
1196                 }
1197
1198                 if (n->next && NULL == n->next->next)
1199                         term_word(p, "and");
1200         }
1201
1202         if (nchild > 1)
1203                 term_word(p, "functions return");
1204         else
1205                 term_word(p, "function returns");
1206
1207         term_word(p, "the value 0 if successful; otherwise the value "
1208                         "-1 is returned and the global variable");
1209
1210         term_fontpush(p, TERMFONT_UNDER);
1211         term_word(p, "errno");
1212         term_fontpop(p);
1213
1214         term_word(p, "is set to indicate the error.");
1215         p->flags |= TERMP_SENTENCE;
1216
1217         return(0);
1218 }
1219
1220
1221 /* ARGSUSED */
1222 static int
1223 termp_ex_pre(DECL_ARGS)
1224 {
1225         int              nchild;
1226
1227         term_newln(p);
1228         term_word(p, "The");
1229
1230         nchild = n->nchild;
1231         for (n = n->child; n; n = n->next) {
1232                 term_fontpush(p, TERMFONT_BOLD);
1233                 term_word(p, n->string);
1234                 term_fontpop(p);
1235
1236                 if (nchild > 2 && n->next) {
1237                         p->flags |= TERMP_NOSPACE;
1238                         term_word(p, ",");
1239                 }
1240
1241                 if (n->next && NULL == n->next->next)
1242                         term_word(p, "and");
1243         }
1244
1245         if (nchild > 1)
1246                 term_word(p, "utilities exit");
1247         else
1248                 term_word(p, "utility exits");
1249
1250         term_word(p, "0 on success, and >0 if an error occurs.");
1251
1252         p->flags |= TERMP_SENTENCE;
1253         return(0);
1254 }
1255
1256
1257 /* ARGSUSED */
1258 static int
1259 termp_nd_pre(DECL_ARGS)
1260 {
1261
1262         if (MDOC_BODY != n->type)
1263                 return(1);
1264
1265 #if defined(__OpenBSD__) || defined(__linux__)
1266         term_word(p, "\\(en");
1267 #else
1268         term_word(p, "\\(em");
1269 #endif
1270         return(1);
1271 }
1272
1273
1274 /* ARGSUSED */
1275 static int
1276 termp_bl_pre(DECL_ARGS)
1277 {
1278
1279         return(MDOC_HEAD != n->type);
1280 }
1281
1282
1283 /* ARGSUSED */
1284 static void
1285 termp_bl_post(DECL_ARGS)
1286 {
1287
1288         if (MDOC_BLOCK == n->type)
1289                 term_newln(p);
1290 }
1291
1292 /* ARGSUSED */
1293 static int
1294 termp_xr_pre(DECL_ARGS)
1295 {
1296
1297         if (NULL == (n = n->child))
1298                 return(0);
1299
1300         assert(MDOC_TEXT == n->type);
1301         term_word(p, n->string);
1302
1303         if (NULL == (n = n->next)) 
1304                 return(0);
1305
1306         p->flags |= TERMP_NOSPACE;
1307         term_word(p, "(");
1308         p->flags |= TERMP_NOSPACE;
1309
1310         assert(MDOC_TEXT == n->type);
1311         term_word(p, n->string);
1312
1313         p->flags |= TERMP_NOSPACE;
1314         term_word(p, ")");
1315
1316         return(0);
1317 }
1318
1319 /*
1320  * This decides how to assert whitespace before any of the SYNOPSIS set
1321  * of macros (which, as in the case of Ft/Fo and Ft/Fn, may contain
1322  * macro combos).
1323  */
1324 static void
1325 synopsis_pre(struct termp *p, const struct mdoc_node *n)
1326 {
1327         /* 
1328          * Obviously, if we're not in a SYNOPSIS or no prior macros
1329          * exist, do nothing.
1330          */
1331         if (NULL == n->prev || ! (MDOC_SYNPRETTY & n->flags))
1332                 return;
1333
1334         /*
1335          * If we're the second in a pair of like elements, emit our
1336          * newline and return.  UNLESS we're `Fo', `Fn', `Fn', in which
1337          * case we soldier on.
1338          */
1339         if (n->prev->tok == n->tok && 
1340                         MDOC_Ft != n->tok && 
1341                         MDOC_Fo != n->tok && 
1342                         MDOC_Fn != n->tok) {
1343                 term_newln(p);
1344                 return;
1345         }
1346
1347         /*
1348          * If we're one of the SYNOPSIS set and non-like pair-wise after
1349          * another (or Fn/Fo, which we've let slip through) then assert
1350          * vertical space, else only newline and move on.
1351          */
1352         switch (n->prev->tok) {
1353         case (MDOC_Fd):
1354                 /* FALLTHROUGH */
1355         case (MDOC_Fn):
1356                 /* FALLTHROUGH */
1357         case (MDOC_Fo):
1358                 /* FALLTHROUGH */
1359         case (MDOC_In):
1360                 /* FALLTHROUGH */
1361         case (MDOC_Vt):
1362                 term_vspace(p);
1363                 break;
1364         case (MDOC_Ft):
1365                 if (MDOC_Fn != n->tok && MDOC_Fo != n->tok) {
1366                         term_vspace(p);
1367                         break;
1368                 }
1369                 /* FALLTHROUGH */
1370         default:
1371                 term_newln(p);
1372                 break;
1373         }
1374 }
1375
1376
1377 static int
1378 termp_vt_pre(DECL_ARGS)
1379 {
1380
1381         if (MDOC_ELEM == n->type) {
1382                 synopsis_pre(p, n);
1383                 return(termp_under_pre(p, pair, meta, n));
1384         } else if (MDOC_BLOCK == n->type) {
1385                 synopsis_pre(p, n);
1386                 return(1);
1387         } else if (MDOC_HEAD == n->type)
1388                 return(0);
1389
1390         return(termp_under_pre(p, pair, meta, n));
1391 }
1392
1393
1394 /* ARGSUSED */
1395 static int
1396 termp_bold_pre(DECL_ARGS)
1397 {
1398
1399         term_fontpush(p, TERMFONT_BOLD);
1400         return(1);
1401 }
1402
1403
1404 /* ARGSUSED */
1405 static int
1406 termp_fd_pre(DECL_ARGS)
1407 {
1408
1409         synopsis_pre(p, n);
1410         return(termp_bold_pre(p, pair, meta, n));
1411 }
1412
1413
1414 /* ARGSUSED */
1415 static void
1416 termp_fd_post(DECL_ARGS)
1417 {
1418
1419         term_newln(p);
1420 }
1421
1422
1423 /* ARGSUSED */
1424 static int
1425 termp_sh_pre(DECL_ARGS)
1426 {
1427
1428         /* No vspace between consecutive `Sh' calls. */
1429
1430         switch (n->type) {
1431         case (MDOC_BLOCK):
1432                 if (n->prev && MDOC_Sh == n->prev->tok)
1433                         if (NULL == n->prev->body->child)
1434                                 break;
1435                 term_vspace(p);
1436                 break;
1437         case (MDOC_HEAD):
1438                 term_fontpush(p, TERMFONT_BOLD);
1439                 break;
1440         case (MDOC_BODY):
1441                 p->offset = term_len(p, p->defindent);
1442                 if (SEC_AUTHORS == n->sec)
1443                         p->flags &= ~(TERMP_SPLIT|TERMP_NOSPLIT);
1444                 break;
1445         default:
1446                 break;
1447         }
1448         return(1);
1449 }
1450
1451
1452 /* ARGSUSED */
1453 static void
1454 termp_sh_post(DECL_ARGS)
1455 {
1456
1457         switch (n->type) {
1458         case (MDOC_HEAD):
1459                 term_newln(p);
1460                 break;
1461         case (MDOC_BODY):
1462                 term_newln(p);
1463                 p->offset = 0;
1464                 break;
1465         default:
1466                 break;
1467         }
1468 }
1469
1470
1471 /* ARGSUSED */
1472 static int
1473 termp_bt_pre(DECL_ARGS)
1474 {
1475
1476         term_word(p, "is currently in beta test.");
1477         p->flags |= TERMP_SENTENCE;
1478         return(0);
1479 }
1480
1481
1482 /* ARGSUSED */
1483 static void
1484 termp_lb_post(DECL_ARGS)
1485 {
1486
1487         if (SEC_LIBRARY == n->sec && MDOC_LINE & n->flags)
1488                 term_newln(p);
1489 }
1490
1491
1492 /* ARGSUSED */
1493 static int
1494 termp_ud_pre(DECL_ARGS)
1495 {
1496
1497         term_word(p, "currently under development.");
1498         p->flags |= TERMP_SENTENCE;
1499         return(0);
1500 }
1501
1502
1503 /* ARGSUSED */
1504 static int
1505 termp_d1_pre(DECL_ARGS)
1506 {
1507
1508         if (MDOC_BLOCK != n->type)
1509                 return(1);
1510         term_newln(p);
1511         p->offset += term_len(p, p->defindent + 1);
1512         return(1);
1513 }
1514
1515
1516 /* ARGSUSED */
1517 static int
1518 termp_ft_pre(DECL_ARGS)
1519 {
1520
1521         /* NB: MDOC_LINE does not effect this! */
1522         synopsis_pre(p, n);
1523         term_fontpush(p, TERMFONT_UNDER);
1524         return(1);
1525 }
1526
1527
1528 /* ARGSUSED */
1529 static int
1530 termp_fn_pre(DECL_ARGS)
1531 {
1532         size_t           rmargin = 0;
1533         int              pretty;
1534
1535         pretty = MDOC_SYNPRETTY & n->flags;
1536
1537         synopsis_pre(p, n);
1538
1539         if (NULL == (n = n->child))
1540                 return(0);
1541
1542         if (pretty) {
1543                 rmargin = p->rmargin;
1544                 p->rmargin = p->offset + term_len(p, 4);
1545                 p->flags |= TERMP_NOBREAK | TERMP_HANG;
1546         }
1547
1548         assert(MDOC_TEXT == n->type);
1549         term_fontpush(p, TERMFONT_BOLD);
1550         term_word(p, n->string);
1551         term_fontpop(p);
1552
1553         if (pretty) {
1554                 term_flushln(p);
1555                 p->flags &= ~(TERMP_NOBREAK | TERMP_HANG);
1556                 p->offset = p->rmargin;
1557                 p->rmargin = rmargin;
1558         }
1559
1560         p->flags |= TERMP_NOSPACE;
1561         term_word(p, "(");
1562         p->flags |= TERMP_NOSPACE;
1563
1564         for (n = n->next; n; n = n->next) {
1565                 assert(MDOC_TEXT == n->type);
1566                 term_fontpush(p, TERMFONT_UNDER);
1567                 if (pretty)
1568                         p->flags |= TERMP_NBRWORD;
1569                 term_word(p, n->string);
1570                 term_fontpop(p);
1571
1572                 if (n->next) {
1573                         p->flags |= TERMP_NOSPACE;
1574                         term_word(p, ",");
1575                 }
1576         }
1577
1578         p->flags |= TERMP_NOSPACE;
1579         term_word(p, ")");
1580
1581         if (pretty) {
1582                 p->flags |= TERMP_NOSPACE;
1583                 term_word(p, ";");
1584                 term_flushln(p);
1585         }
1586
1587         return(0);
1588 }
1589
1590
1591 /* ARGSUSED */
1592 static int
1593 termp_fa_pre(DECL_ARGS)
1594 {
1595         const struct mdoc_node  *nn;
1596
1597         if (n->parent->tok != MDOC_Fo) {
1598                 term_fontpush(p, TERMFONT_UNDER);
1599                 return(1);
1600         }
1601
1602         for (nn = n->child; nn; nn = nn->next) {
1603                 term_fontpush(p, TERMFONT_UNDER);
1604                 p->flags |= TERMP_NBRWORD;
1605                 term_word(p, nn->string);
1606                 term_fontpop(p);
1607
1608                 if (nn->next || (n->next && n->next->tok == MDOC_Fa)) {
1609                         p->flags |= TERMP_NOSPACE;
1610                         term_word(p, ",");
1611                 }
1612         }
1613
1614         return(0);
1615 }
1616
1617
1618 /* ARGSUSED */
1619 static int
1620 termp_bd_pre(DECL_ARGS)
1621 {
1622         size_t                   tabwidth, rm, rmax;
1623         struct mdoc_node        *nn;
1624
1625         if (MDOC_BLOCK == n->type) {
1626                 print_bvspace(p, n, n);
1627                 return(1);
1628         } else if (MDOC_HEAD == n->type)
1629                 return(0);
1630
1631         if (n->norm->Bd.offs)
1632                 p->offset += a2offs(p, n->norm->Bd.offs);
1633
1634         /*
1635          * If -ragged or -filled are specified, the block does nothing
1636          * but change the indentation.  If -unfilled or -literal are
1637          * specified, text is printed exactly as entered in the display:
1638          * for macro lines, a newline is appended to the line.  Blank
1639          * lines are allowed.
1640          */
1641         
1642         if (DISP_literal != n->norm->Bd.type && 
1643                         DISP_unfilled != n->norm->Bd.type)
1644                 return(1);
1645
1646         tabwidth = p->tabwidth;
1647         if (DISP_literal == n->norm->Bd.type)
1648                 p->tabwidth = term_len(p, 8);
1649
1650         rm = p->rmargin;
1651         rmax = p->maxrmargin;
1652         p->rmargin = p->maxrmargin = TERM_MAXMARGIN;
1653
1654         for (nn = n->child; nn; nn = nn->next) {
1655                 print_mdoc_node(p, pair, meta, nn);
1656                 /*
1657                  * If the printed node flushes its own line, then we
1658                  * needn't do it here as well.  This is hacky, but the
1659                  * notion of selective eoln whitespace is pretty dumb
1660                  * anyway, so don't sweat it.
1661                  */
1662                 switch (nn->tok) {
1663                 case (MDOC_Sm):
1664                         /* FALLTHROUGH */
1665                 case (MDOC_br):
1666                         /* FALLTHROUGH */
1667                 case (MDOC_sp):
1668                         /* FALLTHROUGH */
1669                 case (MDOC_Bl):
1670                         /* FALLTHROUGH */
1671                 case (MDOC_D1):
1672                         /* FALLTHROUGH */
1673                 case (MDOC_Dl):
1674                         /* FALLTHROUGH */
1675                 case (MDOC_Lp):
1676                         /* FALLTHROUGH */
1677                 case (MDOC_Pp):
1678                         continue;
1679                 default:
1680                         break;
1681                 }
1682                 if (nn->next && nn->next->line == nn->line)
1683                         continue;
1684                 term_flushln(p);
1685                 p->flags |= TERMP_NOSPACE;
1686         }
1687
1688         p->tabwidth = tabwidth;
1689         p->rmargin = rm;
1690         p->maxrmargin = rmax;
1691         return(0);
1692 }
1693
1694
1695 /* ARGSUSED */
1696 static void
1697 termp_bd_post(DECL_ARGS)
1698 {
1699         size_t           rm, rmax;
1700
1701         if (MDOC_BODY != n->type) 
1702                 return;
1703
1704         rm = p->rmargin;
1705         rmax = p->maxrmargin;
1706
1707         if (DISP_literal == n->norm->Bd.type || 
1708                         DISP_unfilled == n->norm->Bd.type)
1709                 p->rmargin = p->maxrmargin = TERM_MAXMARGIN;
1710
1711         p->flags |= TERMP_NOSPACE;
1712         term_newln(p);
1713
1714         p->rmargin = rm;
1715         p->maxrmargin = rmax;
1716 }
1717
1718
1719 /* ARGSUSED */
1720 static int
1721 termp_bx_pre(DECL_ARGS)
1722 {
1723
1724         if (NULL != (n = n->child)) {
1725                 term_word(p, n->string);
1726                 p->flags |= TERMP_NOSPACE;
1727                 term_word(p, "BSD");
1728         } else {
1729                 term_word(p, "BSD");
1730                 return(0);
1731         }
1732
1733         if (NULL != (n = n->next)) {
1734                 p->flags |= TERMP_NOSPACE;
1735                 term_word(p, "-");
1736                 p->flags |= TERMP_NOSPACE;
1737                 term_word(p, n->string);
1738         }
1739
1740         return(0);
1741 }
1742
1743
1744 /* ARGSUSED */
1745 static int
1746 termp_xx_pre(DECL_ARGS)
1747 {
1748         const char      *pp;
1749         int              flags;
1750
1751         pp = NULL;
1752         switch (n->tok) {
1753         case (MDOC_Bsx):
1754                 pp = "BSD/OS";
1755                 break;
1756         case (MDOC_Dx):
1757                 pp = "DragonFly";
1758                 break;
1759         case (MDOC_Fx):
1760                 pp = "FreeBSD";
1761                 break;
1762         case (MDOC_Nx):
1763                 pp = "NetBSD";
1764                 break;
1765         case (MDOC_Ox):
1766                 pp = "OpenBSD";
1767                 break;
1768         case (MDOC_Ux):
1769                 pp = "UNIX";
1770                 break;
1771         default:
1772                 abort();
1773                 /* NOTREACHED */
1774         }
1775
1776         term_word(p, pp);
1777         if (n->child) {
1778                 flags = p->flags;
1779                 p->flags |= TERMP_KEEP;
1780                 term_word(p, n->child->string);
1781                 p->flags = flags;
1782         }
1783         return(0);
1784 }
1785
1786
1787 /* ARGSUSED */
1788 static void
1789 termp_pf_post(DECL_ARGS)
1790 {
1791
1792         p->flags |= TERMP_NOSPACE;
1793 }
1794
1795
1796 /* ARGSUSED */
1797 static int
1798 termp_ss_pre(DECL_ARGS)
1799 {
1800
1801         switch (n->type) {
1802         case (MDOC_BLOCK):
1803                 term_newln(p);
1804                 if (n->prev)
1805                         term_vspace(p);
1806                 break;
1807         case (MDOC_HEAD):
1808                 term_fontpush(p, TERMFONT_BOLD);
1809                 p->offset = term_len(p, (p->defindent+1)/2);
1810                 break;
1811         default:
1812                 break;
1813         }
1814
1815         return(1);
1816 }
1817
1818
1819 /* ARGSUSED */
1820 static void
1821 termp_ss_post(DECL_ARGS)
1822 {
1823
1824         if (MDOC_HEAD == n->type)
1825                 term_newln(p);
1826 }
1827
1828
1829 /* ARGSUSED */
1830 static int
1831 termp_cd_pre(DECL_ARGS)
1832 {
1833
1834         synopsis_pre(p, n);
1835         term_fontpush(p, TERMFONT_BOLD);
1836         return(1);
1837 }
1838
1839
1840 /* ARGSUSED */
1841 static int
1842 termp_in_pre(DECL_ARGS)
1843 {
1844
1845         synopsis_pre(p, n);
1846
1847         if (MDOC_SYNPRETTY & n->flags && MDOC_LINE & n->flags) {
1848                 term_fontpush(p, TERMFONT_BOLD);
1849                 term_word(p, "#include");
1850                 term_word(p, "<");
1851         } else {
1852                 term_word(p, "<");
1853                 term_fontpush(p, TERMFONT_UNDER);
1854         }
1855
1856         p->flags |= TERMP_NOSPACE;
1857         return(1);
1858 }
1859
1860
1861 /* ARGSUSED */
1862 static void
1863 termp_in_post(DECL_ARGS)
1864 {
1865
1866         if (MDOC_SYNPRETTY & n->flags)
1867                 term_fontpush(p, TERMFONT_BOLD);
1868
1869         p->flags |= TERMP_NOSPACE;
1870         term_word(p, ">");
1871
1872         if (MDOC_SYNPRETTY & n->flags)
1873                 term_fontpop(p);
1874 }
1875
1876
1877 /* ARGSUSED */
1878 static int
1879 termp_sp_pre(DECL_ARGS)
1880 {
1881         size_t           i, len;
1882
1883         switch (n->tok) {
1884         case (MDOC_sp):
1885                 len = n->child ? a2height(p, n->child->string) : 1;
1886                 break;
1887         case (MDOC_br):
1888                 len = 0;
1889                 break;
1890         default:
1891                 len = 1;
1892                 break;
1893         }
1894
1895         if (0 == len)
1896                 term_newln(p);
1897         for (i = 0; i < len; i++)
1898                 term_vspace(p);
1899
1900         return(0);
1901 }
1902
1903
1904 /* ARGSUSED */
1905 static int
1906 termp_quote_pre(DECL_ARGS)
1907 {
1908
1909         if (MDOC_BODY != n->type && MDOC_ELEM != n->type)
1910                 return(1);
1911
1912         switch (n->tok) {
1913         case (MDOC_Ao):
1914                 /* FALLTHROUGH */
1915         case (MDOC_Aq):
1916                 term_word(p, "<");
1917                 break;
1918         case (MDOC_Bro):
1919                 /* FALLTHROUGH */
1920         case (MDOC_Brq):
1921                 term_word(p, "{");
1922                 break;
1923         case (MDOC_Oo):
1924                 /* FALLTHROUGH */
1925         case (MDOC_Op):
1926                 /* FALLTHROUGH */
1927         case (MDOC_Bo):
1928                 /* FALLTHROUGH */
1929         case (MDOC_Bq):
1930                 term_word(p, "[");
1931                 break;
1932         case (MDOC_Do):
1933                 /* FALLTHROUGH */
1934         case (MDOC_Dq):
1935                 term_word(p, "\\(lq");
1936                 break;
1937         case (MDOC_Eo):
1938                 break;
1939         case (MDOC_Po):
1940                 /* FALLTHROUGH */
1941         case (MDOC_Pq):
1942                 term_word(p, "(");
1943                 break;
1944         case (MDOC__T):
1945                 /* FALLTHROUGH */
1946         case (MDOC_Qo):
1947                 /* FALLTHROUGH */
1948         case (MDOC_Qq):
1949                 term_word(p, "\"");
1950                 break;
1951         case (MDOC_Ql):
1952                 /* FALLTHROUGH */
1953         case (MDOC_So):
1954                 /* FALLTHROUGH */
1955         case (MDOC_Sq):
1956                 term_word(p, "\\(oq");
1957                 break;
1958         default:
1959                 abort();
1960                 /* NOTREACHED */
1961         }
1962
1963         p->flags |= TERMP_NOSPACE;
1964         return(1);
1965 }
1966
1967
1968 /* ARGSUSED */
1969 static void
1970 termp_quote_post(DECL_ARGS)
1971 {
1972
1973         if (MDOC_BODY != n->type && MDOC_ELEM != n->type)
1974                 return;
1975
1976         p->flags |= TERMP_NOSPACE;
1977
1978         switch (n->tok) {
1979         case (MDOC_Ao):
1980                 /* FALLTHROUGH */
1981         case (MDOC_Aq):
1982                 term_word(p, ">");
1983                 break;
1984         case (MDOC_Bro):
1985                 /* FALLTHROUGH */
1986         case (MDOC_Brq):
1987                 term_word(p, "}");
1988                 break;
1989         case (MDOC_Oo):
1990                 /* FALLTHROUGH */
1991         case (MDOC_Op):
1992                 /* FALLTHROUGH */
1993         case (MDOC_Bo):
1994                 /* FALLTHROUGH */
1995         case (MDOC_Bq):
1996                 term_word(p, "]");
1997                 break;
1998         case (MDOC_Do):
1999                 /* FALLTHROUGH */
2000         case (MDOC_Dq):
2001                 term_word(p, "\\(rq");
2002                 break;
2003         case (MDOC_Eo):
2004                 break;
2005         case (MDOC_Po):
2006                 /* FALLTHROUGH */
2007         case (MDOC_Pq):
2008                 term_word(p, ")");
2009                 break;
2010         case (MDOC__T):
2011                 /* FALLTHROUGH */
2012         case (MDOC_Qo):
2013                 /* FALLTHROUGH */
2014         case (MDOC_Qq):
2015                 term_word(p, "\"");
2016                 break;
2017         case (MDOC_Ql):
2018                 /* FALLTHROUGH */
2019         case (MDOC_So):
2020                 /* FALLTHROUGH */
2021         case (MDOC_Sq):
2022                 term_word(p, "\\(cq");
2023                 break;
2024         default:
2025                 abort();
2026                 /* NOTREACHED */
2027         }
2028 }
2029
2030
2031 /* ARGSUSED */
2032 static int
2033 termp_fo_pre(DECL_ARGS)
2034 {
2035         size_t           rmargin = 0;
2036         int              pretty;
2037
2038         pretty = MDOC_SYNPRETTY & n->flags;
2039
2040         if (MDOC_BLOCK == n->type) {
2041                 synopsis_pre(p, n);
2042                 return(1);
2043         } else if (MDOC_BODY == n->type) {
2044                 if (pretty) {
2045                         rmargin = p->rmargin;
2046                         p->rmargin = p->offset + term_len(p, 4);
2047                         p->flags |= TERMP_NOBREAK | TERMP_HANG;
2048                 }
2049                 p->flags |= TERMP_NOSPACE;
2050                 term_word(p, "(");
2051                 p->flags |= TERMP_NOSPACE;
2052                 if (pretty) {
2053                         term_flushln(p);
2054                         p->flags &= ~(TERMP_NOBREAK | TERMP_HANG);
2055                         p->offset = p->rmargin;
2056                         p->rmargin = rmargin;
2057                 }
2058                 return(1);
2059         }
2060
2061         if (NULL == n->child)
2062                 return(0);
2063
2064         /* XXX: we drop non-initial arguments as per groff. */
2065
2066         assert(n->child->string);
2067         term_fontpush(p, TERMFONT_BOLD);
2068         term_word(p, n->child->string);
2069         return(0);
2070 }
2071
2072
2073 /* ARGSUSED */
2074 static void
2075 termp_fo_post(DECL_ARGS)
2076 {
2077
2078         if (MDOC_BODY != n->type) 
2079                 return;
2080
2081         p->flags |= TERMP_NOSPACE;
2082         term_word(p, ")");
2083
2084         if (MDOC_SYNPRETTY & n->flags) {
2085                 p->flags |= TERMP_NOSPACE;
2086                 term_word(p, ";");
2087                 term_flushln(p);
2088         }
2089 }
2090
2091
2092 /* ARGSUSED */
2093 static int
2094 termp_bf_pre(DECL_ARGS)
2095 {
2096
2097         if (MDOC_HEAD == n->type)
2098                 return(0);
2099         else if (MDOC_BODY != n->type)
2100                 return(1);
2101
2102         if (FONT_Em == n->norm->Bf.font) 
2103                 term_fontpush(p, TERMFONT_UNDER);
2104         else if (FONT_Sy == n->norm->Bf.font) 
2105                 term_fontpush(p, TERMFONT_BOLD);
2106         else 
2107                 term_fontpush(p, TERMFONT_NONE);
2108
2109         return(1);
2110 }
2111
2112
2113 /* ARGSUSED */
2114 static int
2115 termp_sm_pre(DECL_ARGS)
2116 {
2117
2118         assert(n->child && MDOC_TEXT == n->child->type);
2119         if (0 == strcmp("on", n->child->string)) {
2120                 if (p->col)
2121                         p->flags &= ~TERMP_NOSPACE;
2122                 p->flags &= ~TERMP_NONOSPACE;
2123         } else
2124                 p->flags |= TERMP_NONOSPACE;
2125
2126         return(0);
2127 }
2128
2129
2130 /* ARGSUSED */
2131 static int
2132 termp_ap_pre(DECL_ARGS)
2133 {
2134
2135         p->flags |= TERMP_NOSPACE;
2136         term_word(p, "'");
2137         p->flags |= TERMP_NOSPACE;
2138         return(1);
2139 }
2140
2141
2142 /* ARGSUSED */
2143 static void
2144 termp____post(DECL_ARGS)
2145 {
2146
2147         /*
2148          * Handle lists of authors.  In general, print each followed by
2149          * a comma.  Don't print the comma if there are only two
2150          * authors.
2151          */
2152         if (MDOC__A == n->tok && n->next && MDOC__A == n->next->tok)
2153                 if (NULL == n->next->next || MDOC__A != n->next->next->tok)
2154                         if (NULL == n->prev || MDOC__A != n->prev->tok)
2155                                 return;
2156
2157         /* TODO: %U. */
2158
2159         if (NULL == n->parent || MDOC_Rs != n->parent->tok)
2160                 return;
2161
2162         p->flags |= TERMP_NOSPACE;
2163         if (NULL == n->next) {
2164                 term_word(p, ".");
2165                 p->flags |= TERMP_SENTENCE;
2166         } else
2167                 term_word(p, ",");
2168 }
2169
2170
2171 /* ARGSUSED */
2172 static int
2173 termp_li_pre(DECL_ARGS)
2174 {
2175
2176         term_fontpush(p, TERMFONT_NONE);
2177         return(1);
2178 }
2179
2180
2181 /* ARGSUSED */
2182 static int
2183 termp_lk_pre(DECL_ARGS)
2184 {
2185         const struct mdoc_node *link, *descr;
2186
2187         if (NULL == (link = n->child))
2188                 return(0);
2189
2190         if (NULL != (descr = link->next)) {
2191                 term_fontpush(p, TERMFONT_UNDER);
2192                 while (NULL != descr) {
2193                         term_word(p, descr->string);
2194                         descr = descr->next;
2195                 }
2196                 p->flags |= TERMP_NOSPACE;
2197                 term_word(p, ":");
2198                 term_fontpop(p);
2199         }
2200
2201         term_fontpush(p, TERMFONT_BOLD);
2202         term_word(p, link->string);
2203         term_fontpop(p);
2204
2205         return(0);
2206 }
2207
2208
2209 /* ARGSUSED */
2210 static int
2211 termp_bk_pre(DECL_ARGS)
2212 {
2213
2214         switch (n->type) {
2215         case (MDOC_BLOCK):
2216                 break;
2217         case (MDOC_HEAD):
2218                 return(0);
2219         case (MDOC_BODY):
2220                 if (n->parent->args || 0 == n->prev->nchild)
2221                         p->flags |= TERMP_PREKEEP;
2222                 break;
2223         default:
2224                 abort();
2225                 /* NOTREACHED */
2226         }
2227
2228         return(1);
2229 }
2230
2231
2232 /* ARGSUSED */
2233 static void
2234 termp_bk_post(DECL_ARGS)
2235 {
2236
2237         if (MDOC_BODY == n->type)
2238                 p->flags &= ~(TERMP_KEEP | TERMP_PREKEEP);
2239 }
2240
2241 /* ARGSUSED */
2242 static void
2243 termp__t_post(DECL_ARGS)
2244 {
2245
2246         /*
2247          * If we're in an `Rs' and there's a journal present, then quote
2248          * us instead of underlining us (for disambiguation).
2249          */
2250         if (n->parent && MDOC_Rs == n->parent->tok &&
2251                         n->parent->norm->Rs.quote_T)
2252                 termp_quote_post(p, pair, meta, n);
2253
2254         termp____post(p, pair, meta, n);
2255 }
2256
2257 /* ARGSUSED */
2258 static int
2259 termp__t_pre(DECL_ARGS)
2260 {
2261
2262         /*
2263          * If we're in an `Rs' and there's a journal present, then quote
2264          * us instead of underlining us (for disambiguation).
2265          */
2266         if (n->parent && MDOC_Rs == n->parent->tok &&
2267                         n->parent->norm->Rs.quote_T)
2268                 return(termp_quote_pre(p, pair, meta, n));
2269
2270         term_fontpush(p, TERMFONT_UNDER);
2271         return(1);
2272 }
2273
2274 /* ARGSUSED */
2275 static int
2276 termp_under_pre(DECL_ARGS)
2277 {
2278
2279         term_fontpush(p, TERMFONT_UNDER);
2280         return(1);
2281 }