bugfix: .Tg must be ignored completely in these output modes
[mandoc.git] / mdoc_term.c
index 0f885f817fb99c15780f619195ae5b0661cbe6f2..e50f5423e26c9f1f91f9d5eec8c8122a10bec711 100644 (file)
@@ -1,7 +1,7 @@
-/*     $Id: mdoc_term.c,v 1.360 2017/06/04 18:50:35 schwarze Exp $ */
+/*     $Id: mdoc_term.c,v 1.376 2020/01/20 10:37:15 schwarze Exp $ */
 /*
  * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
- * Copyright (c) 2010, 2012-2017 Ingo Schwarze <schwarze@openbsd.org>
+ * Copyright (c) 2010, 2012-2020 Ingo Schwarze <schwarze@openbsd.org>
  * Copyright (c) 2013 Franco Fichtner <franco@lastsummer.de>
  *
  * Permission to use, copy, modify, and distribute this software for any
@@ -29,7 +29,6 @@
 #include <string.h>
 
 #include "mandoc_aux.h"
-#include "mandoc.h"
 #include "roff.h"
 #include "mdoc.h"
 #include "out.h"
@@ -47,7 +46,7 @@ struct        termpair {
                  const struct roff_meta *meta, \
                  struct roff_node *n
 
-struct termact {
+struct mdoc_term_act {
        int     (*pre)(DECL_ARGS);
        void    (*post)(DECL_ARGS);
 };
@@ -84,6 +83,7 @@ static        void      termp_xx_post(DECL_ARGS);
 
 static int       termp__a_pre(DECL_ARGS);
 static int       termp__t_pre(DECL_ARGS);
+static int       termp_abort_pre(DECL_ARGS);
 static int       termp_an_pre(DECL_ARGS);
 static int       termp_ap_pre(DECL_ARGS);
 static int       termp_bd_pre(DECL_ARGS);
@@ -119,12 +119,13 @@ static    int       termp_pp_pre(DECL_ARGS);
 static int       termp_ss_pre(DECL_ARGS);
 static int       termp_sy_pre(DECL_ARGS);
 static int       termp_tag_pre(DECL_ARGS);
+static int       termp_tg_pre(DECL_ARGS);
 static int       termp_under_pre(DECL_ARGS);
 static int       termp_vt_pre(DECL_ARGS);
 static int       termp_xr_pre(DECL_ARGS);
 static int       termp_xx_pre(DECL_ARGS);
 
-static const struct termact __termacts[MDOC_MAX - MDOC_Dd] = {
+static const struct mdoc_term_act mdoc_term_acts[MDOC_MAX - MDOC_Dd] = {
        { NULL, NULL }, /* Dd */
        { NULL, NULL }, /* Dt */
        { NULL, NULL }, /* Os */
@@ -159,7 +160,7 @@ static      const struct termact __termacts[MDOC_MAX - MDOC_Dd] = {
        { termp_nd_pre, NULL }, /* Nd */
        { termp_nm_pre, termp_nm_post }, /* Nm */
        { termp_quote_pre, termp_quote_post }, /* Op */
-       { termp_ft_pre, NULL }, /* Ot */
+       { termp_abort_pre, NULL }, /* Ot */
        { termp_under_pre, NULL }, /* Pa */
        { termp_ex_pre, NULL }, /* Rv */
        { NULL, NULL }, /* St */
@@ -232,7 +233,7 @@ static      const struct termact __termacts[MDOC_MAX - MDOC_Dd] = {
        { termp_under_pre, NULL }, /* Fr */
        { NULL, NULL }, /* Ud */
        { NULL, termp_lb_post }, /* Lb */
-       { termp_pp_pre, NULL }, /* Lp */
+       { termp_abort_pre, NULL }, /* Lp */
        { termp_lk_pre, NULL }, /* Lk */
        { termp_under_pre, NULL }, /* Mt */
        { termp_quote_pre, termp_quote_post }, /* Brq */
@@ -245,50 +246,54 @@ static    const struct termact __termacts[MDOC_MAX - MDOC_Dd] = {
        { NULL, termp____post }, /* %Q */
        { NULL, termp____post }, /* %U */
        { NULL, NULL }, /* Ta */
+       { termp_tg_pre, NULL }, /* Tg */
 };
-static const struct termact *const termacts = __termacts - MDOC_Dd;
 
-static int      fn_prio;
+static int      fn_prio = TAG_STRONG;
 
 
 void
-terminal_mdoc(void *arg, const struct roff_man *mdoc)
+terminal_mdoc(void *arg, const struct roff_meta *mdoc)
 {
-       struct roff_node        *n;
+       struct roff_node        *n, *nn;
        struct termp            *p;
        size_t                   save_defindent;
 
        p = (struct termp *)arg;
-       p->rmargin = p->maxrmargin = p->defrmargin;
+       p->tcol->rmargin = p->maxrmargin = p->defrmargin;
        term_tab_set(p, NULL);
        term_tab_set(p, "T");
        term_tab_set(p, ".5i");
 
        n = mdoc->first->child;
        if (p->synopsisonly) {
-               while (n != NULL) {
-                       if (n->tok == MDOC_Sh && n->sec == SEC_SYNOPSIS) {
-                               if (n->child->next->child != NULL)
-                                       print_mdoc_nodelist(p, NULL,
-                                           &mdoc->meta,
-                                           n->child->next->child);
-                               term_newln(p);
+               for (nn = NULL; n != NULL; n = n->next) {
+                       if (n->tok != MDOC_Sh)
+                               continue;
+                       if (n->sec == SEC_SYNOPSIS)
                                break;
-                       }
-                       n = n->next;
+                       if (nn == NULL && n->sec == SEC_NAME)
+                               nn = n;
                }
+               if (n == NULL)
+                       n = nn;
+               p->flags |= TERMP_NOSPACE;
+               if (n != NULL && (n = n->child->next->child) != NULL)
+                       print_mdoc_nodelist(p, NULL, mdoc, n);
+               term_newln(p);
        } else {
                save_defindent = p->defindent;
                if (p->defindent == 0)
                        p->defindent = 5;
-               term_begin(p, print_mdoc_head, print_mdoc_foot,
-                   &mdoc->meta);
-               while (n != NULL && n->flags & NODE_NOPRT)
+               term_begin(p, print_mdoc_head, print_mdoc_foot, mdoc);
+               while (n != NULL &&
+                   (n->type == ROFFT_COMMENT ||
+                    n->flags & NODE_NOPRT))
                        n = n->next;
                if (n != NULL) {
                        if (n->tok != MDOC_Sh)
                                term_vspace(p);
-                       print_mdoc_nodelist(p, NULL, &mdoc->meta, n);
+                       print_mdoc_nodelist(p, NULL, mdoc, n);
                }
                term_end(p);
                p->defindent = save_defindent;
@@ -308,16 +313,30 @@ print_mdoc_nodelist(DECL_ARGS)
 static void
 print_mdoc_node(DECL_ARGS)
 {
-       int              chld;
+       const struct mdoc_term_act *act;
        struct termpair  npair;
        size_t           offset, rmargin;
+       int              chld;
+
+       /*
+        * In no-fill mode, break the output line at the beginning
+        * of new input lines except after \c, and nowhere else.
+        */
+
+       if (n->flags & NODE_NOFILL) {
+               if (n->flags & NODE_LINE &&
+                   (p->flags & TERMP_NONEWLINE) == 0)
+                       term_newln(p);
+               p->flags |= TERMP_BRNEVER;
+       } else
+               p->flags &= ~TERMP_BRNEVER;
 
-       if (n->flags & NODE_NOPRT)
+       if (n->type == ROFFT_COMMENT || n->flags & NODE_NOPRT)
                return;
 
        chld = 1;
-       offset = p->offset;
-       rmargin = p->rmargin;
+       offset = p->tcol->offset;
+       rmargin = p->tcol->rmargin;
        n->flags &= ~NODE_ENDED;
        n->prev_font = p->fonti;
 
@@ -339,11 +358,25 @@ print_mdoc_node(DECL_ARGS)
         * produce output.  Note that some pre-handlers do so.
         */
 
+       act = NULL;
        switch (n->type) {
        case ROFFT_TEXT:
-               if (*n->string == ' ' && n->flags & NODE_LINE &&
-                   (p->flags & TERMP_NONEWLINE) == 0)
-                       term_newln(p);
+               if (n->flags & NODE_LINE) {
+                       switch (*n->string) {
+                       case '\0':
+                               if (p->flags & TERMP_NONEWLINE)
+                                       term_newln(p);
+                               else
+                                       term_vspace(p);
+                               return;
+                       case ' ':
+                               if ((p->flags & TERMP_NONEWLINE) == 0)
+                                       term_newln(p);
+                               break;
+                       default:
+                               break;
+                       }
+               }
                if (NODE_DELIMC & n->flags)
                        p->flags |= TERMP_NOSPACE;
                term_word(p, n->string);
@@ -368,10 +401,10 @@ print_mdoc_node(DECL_ARGS)
                        return;
                }
                assert(n->tok >= MDOC_Dd && n->tok < MDOC_MAX);
-               if (termacts[n->tok].pre != NULL &&
+               act = mdoc_term_acts + (n->tok - MDOC_Dd);
+               if (act->pre != NULL &&
                    (n->end == ENDBODY_NOT || n->child != NULL))
-                       chld = (*termacts[n->tok].pre)
-                               (p, &npair, meta, n);
+                       chld = (*act->pre)(p, &npair, meta, n);
                break;
        }
 
@@ -389,9 +422,9 @@ print_mdoc_node(DECL_ARGS)
        case ROFFT_EQN:
                break;
        default:
-               if (termacts[n->tok].post == NULL || n->flags & NODE_ENDED)
+               if (act->post == NULL || n->flags & NODE_ENDED)
                        break;
-               (void)(*termacts[n->tok].post)(p, &npair, meta, n);
+               (void)(*act->post)(p, &npair, meta, n);
 
                /*
                 * Explicit end tokens not only call the post
@@ -407,8 +440,8 @@ print_mdoc_node(DECL_ARGS)
                p->flags |= TERMP_SENTENCE;
 
        if (n->type != ROFFT_TEXT)
-               p->offset = offset;
-       p->rmargin = rmargin;
+               p->tcol->offset = offset;
+       p->tcol->rmargin = rmargin;
 }
 
 static void
@@ -428,9 +461,9 @@ print_mdoc_foot(struct termp *p, const struct roff_meta *meta)
 
        term_vspace(p);
 
-       p->offset = 0;
+       p->tcol->offset = 0;
        sz = term_strlen(p, meta->date);
-       p->rmargin = p->maxrmargin > sz ?
+       p->tcol->rmargin = p->maxrmargin > sz ?
            (p->maxrmargin + term_len(p, 1) - sz) / 2 : 0;
        p->trailspace = 1;
        p->flags |= TERMP_NOSPACE | TERMP_NOBREAK;
@@ -438,16 +471,16 @@ print_mdoc_foot(struct termp *p, const struct roff_meta *meta)
        term_word(p, meta->os);
        term_flushln(p);
 
-       p->offset = p->rmargin;
+       p->tcol->offset = p->tcol->rmargin;
        sz = term_strlen(p, meta->os);
-       p->rmargin = p->maxrmargin > sz ? p->maxrmargin - sz : 0;
+       p->tcol->rmargin = p->maxrmargin > sz ? p->maxrmargin - sz : 0;
        p->flags |= TERMP_NOSPACE;
 
        term_word(p, meta->date);
        term_flushln(p);
 
-       p->offset = p->rmargin;
-       p->rmargin = p->maxrmargin;
+       p->tcol->offset = p->tcol->rmargin;
+       p->tcol->rmargin = p->maxrmargin;
        p->trailspace = 0;
        p->flags &= ~TERMP_NOBREAK;
        p->flags |= TERMP_NOSPACE;
@@ -455,8 +488,8 @@ print_mdoc_foot(struct termp *p, const struct roff_meta *meta)
        term_word(p, meta->os);
        term_flushln(p);
 
-       p->offset = 0;
-       p->rmargin = p->maxrmargin;
+       p->tcol->offset = 0;
+       p->tcol->rmargin = p->maxrmargin;
        p->flags = 0;
 }
 
@@ -496,8 +529,8 @@ print_mdoc_head(struct termp *p, const struct roff_meta *meta)
 
        p->flags |= TERMP_NOBREAK | TERMP_NOSPACE;
        p->trailspace = 1;
-       p->offset = 0;
-       p->rmargin = 2 * (titlen+1) + vollen < p->maxrmargin ?
+       p->tcol->offset = 0;
+       p->tcol->rmargin = 2 * (titlen+1) + vollen < p->maxrmargin ?
            (p->maxrmargin - vollen + term_len(p, 1)) / 2 :
            vollen < p->maxrmargin ?  p->maxrmargin - vollen : 0;
 
@@ -505,26 +538,26 @@ print_mdoc_head(struct termp *p, const struct roff_meta *meta)
        term_flushln(p);
 
        p->flags |= TERMP_NOSPACE;
-       p->offset = p->rmargin;
-       p->rmargin = p->offset + vollen + titlen < p->maxrmargin ?
-           p->maxrmargin - titlen : p->maxrmargin;
+       p->tcol->offset = p->tcol->rmargin;
+       p->tcol->rmargin = p->tcol->offset + vollen + titlen <
+           p->maxrmargin ? p->maxrmargin - titlen : p->maxrmargin;
 
        term_word(p, volume);
        term_flushln(p);
 
        p->flags &= ~TERMP_NOBREAK;
        p->trailspace = 0;
-       if (p->rmargin + titlen <= p->maxrmargin) {
+       if (p->tcol->rmargin + titlen <= p->maxrmargin) {
                p->flags |= TERMP_NOSPACE;
-               p->offset = p->rmargin;
-               p->rmargin = p->maxrmargin;
+               p->tcol->offset = p->tcol->rmargin;
+               p->tcol->rmargin = p->maxrmargin;
                term_word(p, title);
                term_flushln(p);
        }
 
        p->flags &= ~TERMP_NOSPACE;
-       p->offset = 0;
-       p->rmargin = p->maxrmargin;
+       p->tcol->offset = 0;
+       p->tcol->rmargin = p->maxrmargin;
        free(title);
        free(volume);
 }
@@ -533,12 +566,14 @@ static int
 a2width(const struct termp *p, const char *v)
 {
        struct roffsu    su;
+       const char      *end;
 
-       if (a2roffsu(v, &su, SCALE_MAX) < 2) {
+       end = a2roffsu(v, &su, SCALE_MAX);
+       if (end == NULL || *end != '\0') {
                SCALE_HS_INIT(&su, term_strlen(p, v));
                su.scale /= term_strlen(p, "0");
        }
-       return term_hspan(p, &su) / 24;
+       return term_hen(p, &su);
 }
 
 /*
@@ -565,7 +600,9 @@ print_bvspace(struct termp *p,
        /* Do not vspace directly after Ss/Sh. */
 
        nn = n;
-       while (nn->prev != NULL && nn->prev->flags & NODE_NOPRT)
+       while (nn->prev != NULL &&
+           (nn->prev->type == ROFFT_COMMENT ||
+            nn->prev->flags & NODE_NOPRT))
                nn = nn->prev;
        while (nn->prev == NULL) {
                do {
@@ -649,8 +686,8 @@ termp_it_pre(DECL_ARGS)
 
        if (bl->norm->Bl.offs != NULL) {
                offset = a2width(p, bl->norm->Bl.offs);
-               if (offset < 0 && (size_t)(-offset) > p->offset)
-                       offset = -p->offset;
+               if (offset < 0 && (size_t)(-offset) > p->tcol->offset)
+                       offset = -p->tcol->offset;
                else if (offset > SHRT_MAX)
                        offset = 0;
        }
@@ -684,7 +721,7 @@ termp_it_pre(DECL_ARGS)
                        SCALE_HS_INIT(&su,
                            term_strlen(p, bl->norm->Bl.cols[i]));
                        su.scale /= term_strlen(p, "0");
-                       offset += term_hspan(p, &su) / 24 + dcol;
+                       offset += term_hen(p, &su) + dcol;
                }
 
                /*
@@ -702,7 +739,7 @@ termp_it_pre(DECL_ARGS)
                 */
                SCALE_HS_INIT(&su, term_strlen(p, bl->norm->Bl.cols[i]));
                su.scale /= term_strlen(p, "0");
-               width = term_hspan(p, &su) / 24 + dcol;
+               width = term_hen(p, &su) + dcol;
                break;
        default:
                if (NULL == bl->norm->Bl.width)
@@ -714,8 +751,8 @@ termp_it_pre(DECL_ARGS)
                 * handling for column for how this changes.
                 */
                width = a2width(p, bl->norm->Bl.width) + term_len(p, 2);
-               if (width < 0 && (size_t)(-width) > p->offset)
-                       width = -p->offset;
+               if (width < 0 && (size_t)(-width) > p->tcol->offset)
+                       width = -p->tcol->offset;
                else if (width > SHRT_MAX)
                        width = 0;
                break;
@@ -815,7 +852,7 @@ termp_it_pre(DECL_ARGS)
         * necessarily lengthened.  Everybody gets the offset.
         */
 
-       p->offset += offset;
+       p->tcol->offset += offset;
 
        switch (type) {
        case LIST_bullet:
@@ -825,21 +862,21 @@ termp_it_pre(DECL_ARGS)
        case LIST_hang:
        case LIST_tag:
                if (n->type == ROFFT_HEAD)
-                       p->rmargin = p->offset + width;
+                       p->tcol->rmargin = p->tcol->offset + width;
                else
-                       p->offset += width;
+                       p->tcol->offset += width;
                break;
        case LIST_column:
                assert(width);
-               p->rmargin = p->offset + width;
+               p->tcol->rmargin = p->tcol->offset + width;
                /*
                 * XXX - this behaviour is not documented: the
                 * right-most column is filled to the right margin.
                 */
                if (n->type == ROFFT_HEAD)
                        break;
-               if (NULL == n->next && p->rmargin < p->maxrmargin)
-                       p->rmargin = p->maxrmargin;
+               if (n->next == NULL && p->tcol->rmargin < p->maxrmargin)
+                       p->tcol->rmargin = p->maxrmargin;
                break;
        default:
                break;
@@ -945,7 +982,7 @@ termp_nm_pre(DECL_ARGS)
        }
 
        if (n->type == ROFFT_BODY) {
-               if (NULL == n->child)
+               if (n->child == NULL)
                        return 0;
                p->flags |= TERMP_NOSPACE;
                cp = NULL;
@@ -954,9 +991,10 @@ termp_nm_pre(DECL_ARGS)
                if (cp == NULL)
                        cp = meta->name;
                if (cp == NULL)
-                       p->offset += term_len(p, 6);
+                       p->tcol->offset += term_len(p, 6);
                else
-                       p->offset += term_len(p, 1) + term_strlen(p, cp);
+                       p->tcol->offset += term_len(p, 1) +
+                           term_strlen(p, cp);
                return 1;
        }
 
@@ -967,18 +1005,18 @@ termp_nm_pre(DECL_ARGS)
                synopsis_pre(p, n->parent);
 
        if (n->type == ROFFT_HEAD &&
-           NULL != n->next && NULL != n->next->child) {
+           n->next != NULL && n->next->child != NULL) {
                p->flags |= TERMP_NOSPACE | TERMP_NOBREAK | TERMP_BRIND;
                p->trailspace = 1;
-               p->rmargin = p->offset + term_len(p, 1);
-               if (NULL == n->child) {
-                       p->rmargin += term_strlen(p, meta->name);
-               else if (n->child->type == ROFFT_TEXT) {
-                       p->rmargin += term_strlen(p, n->child->string);
-                       if (n->child->next)
+               p->tcol->rmargin = p->tcol->offset + term_len(p, 1);
+               if (n->child == NULL)
+                       p->tcol->rmargin += term_strlen(p, meta->name);
+               else if (n->child->type == ROFFT_TEXT) {
+                       p->tcol->rmargin += term_strlen(p, n->child->string);
+                       if (n->child->next != NULL)
                                p->flags |= TERMP_HANG;
                } else {
-                       p->rmargin += term_len(p, 5);
+                       p->tcol->rmargin += term_len(p, 5);
                        p->flags |= TERMP_HANG;
                }
        }
@@ -1250,13 +1288,13 @@ termp_sh_pre(DECL_ARGS)
                term_fontpush(p, TERMFONT_BOLD);
                break;
        case ROFFT_BODY:
-               p->offset = term_len(p, p->defindent);
+               p->tcol->offset = term_len(p, p->defindent);
                term_tab_set(p, NULL);
                term_tab_set(p, "T");
                term_tab_set(p, ".5i");
                switch (n->sec) {
                case SEC_DESCRIPTION:
-                       fn_prio = 0;
+                       fn_prio = TAG_STRONG;
                        break;
                case SEC_AUTHORS:
                        p->flags &= ~(TERMP_SPLIT|TERMP_NOSPLIT);
@@ -1281,7 +1319,7 @@ termp_sh_post(DECL_ARGS)
                break;
        case ROFFT_BODY:
                term_newln(p);
-               p->offset = 0;
+               p->tcol->offset = 0;
                break;
        default:
                break;
@@ -1303,7 +1341,7 @@ termp_d1_pre(DECL_ARGS)
        if (n->type != ROFFT_BLOCK)
                return 1;
        term_newln(p);
-       p->offset += term_len(p, p->defindent + 1);
+       p->tcol->offset += term_len(p, p->defindent + 1);
        term_tab_set(p, NULL);
        term_tab_set(p, "T");
        term_tab_set(p, ".5i");
@@ -1334,8 +1372,8 @@ termp_fn_pre(DECL_ARGS)
                return 0;
 
        if (pretty) {
-               rmargin = p->rmargin;
-               p->rmargin = p->offset + term_len(p, 4);
+               rmargin = p->tcol->rmargin;
+               p->tcol->rmargin = p->tcol->offset + term_len(p, 4);
                p->flags |= TERMP_NOBREAK | TERMP_BRIND | TERMP_HANG;
        }
 
@@ -1345,14 +1383,14 @@ termp_fn_pre(DECL_ARGS)
        term_fontpop(p);
 
        if (n->sec == SEC_DESCRIPTION || n->sec == SEC_CUSTOM)
-               tag_put(n->string, ++fn_prio, p->line);
+               tag_put(n->string, fn_prio++, p->line);
 
        if (pretty) {
                term_flushln(p);
                p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND | TERMP_HANG);
                p->flags |= TERMP_NOPAD;
-               p->offset = p->rmargin;
-               p->rmargin = rmargin;
+               p->tcol->offset = p->tcol->rmargin;
+               p->tcol->rmargin = rmargin;
        }
 
        p->flags |= TERMP_NOSPACE;
@@ -1413,8 +1451,6 @@ termp_fa_pre(DECL_ARGS)
 static int
 termp_bd_pre(DECL_ARGS)
 {
-       size_t                   lm, len, rm, rmax;
-       struct roff_node        *nn;
        int                      offset;
 
        if (n->type == ROFFT_BLOCK) {
@@ -1429,103 +1465,45 @@ termp_bd_pre(DECL_ARGS)
            ! strcmp(n->norm->Bd.offs, "left"))
                /* nothing */;
        else if ( ! strcmp(n->norm->Bd.offs, "indent"))
-               p->offset += term_len(p, p->defindent + 1);
+               p->tcol->offset += term_len(p, p->defindent + 1);
        else if ( ! strcmp(n->norm->Bd.offs, "indent-two"))
-               p->offset += term_len(p, (p->defindent + 1) * 2);
+               p->tcol->offset += term_len(p, (p->defindent + 1) * 2);
        else {
                offset = a2width(p, n->norm->Bd.offs);
-               if (offset < 0 && (size_t)(-offset) > p->offset)
-                       p->offset = 0;
+               if (offset < 0 && (size_t)(-offset) > p->tcol->offset)
+                       p->tcol->offset = 0;
                else if (offset < SHRT_MAX)
-                       p->offset += offset;
+                       p->tcol->offset += offset;
        }
 
-       /*
-        * If -ragged or -filled are specified, the block does nothing
-        * but change the indentation.  If -unfilled or -literal are
-        * specified, text is printed exactly as entered in the display:
-        * for macro lines, a newline is appended to the line.  Blank
-        * lines are allowed.
-        */
-
-       if (DISP_literal != n->norm->Bd.type &&
-           DISP_unfilled != n->norm->Bd.type &&
-           DISP_centered != n->norm->Bd.type)
-               return 1;
-
-       if (n->norm->Bd.type == DISP_literal) {
+       switch (n->norm->Bd.type) {
+       case DISP_literal:
                term_tab_set(p, NULL);
                term_tab_set(p, "T");
                term_tab_set(p, "8n");
+               break;
+       case DISP_centered:
+               p->flags |= TERMP_CENTER;
+               break;
+       default:
+               break;
        }
-
-       lm = p->offset;
-       rm = p->rmargin;
-       rmax = p->maxrmargin;
-       p->rmargin = p->maxrmargin = TERM_MAXMARGIN;
-
-       for (nn = n->child; nn; nn = nn->next) {
-               if (DISP_centered == n->norm->Bd.type) {
-                       if (nn->type == ROFFT_TEXT) {
-                               len = term_strlen(p, nn->string);
-                               p->offset = len >= rm ? 0 :
-                                   lm + len >= rm ? rm - len :
-                                   (lm + rm - len) / 2;
-                       } else
-                               p->offset = lm;
-               }
-               print_mdoc_node(p, pair, meta, nn);
-               /*
-                * If the printed node flushes its own line, then we
-                * needn't do it here as well.  This is hacky, but the
-                * notion of selective eoln whitespace is pretty dumb
-                * anyway, so don't sweat it.
-                */
-               if (nn->tok < ROFF_MAX)
-                       continue;
-               switch (nn->tok) {
-               case MDOC_Sm:
-               case MDOC_Bl:
-               case MDOC_D1:
-               case MDOC_Dl:
-               case MDOC_Lp:
-               case MDOC_Pp:
-                       continue;
-               default:
-                       break;
-               }
-               if (p->flags & TERMP_NONEWLINE ||
-                   (nn->next && ! (nn->next->flags & NODE_LINE)))
-                       continue;
-               term_flushln(p);
-               p->flags |= TERMP_NOSPACE;
-       }
-
-       p->rmargin = rm;
-       p->maxrmargin = rmax;
-       return 0;
+       return 1;
 }
 
 static void
 termp_bd_post(DECL_ARGS)
 {
-       size_t           rm, rmax;
-
        if (n->type != ROFFT_BODY)
                return;
-
-       rm = p->rmargin;
-       rmax = p->maxrmargin;
-
-       if (DISP_literal == n->norm->Bd.type ||
-           DISP_unfilled == n->norm->Bd.type)
-               p->rmargin = p->maxrmargin = TERM_MAXMARGIN;
-
+       if (n->norm->Bd.type == DISP_unfilled ||
+           n->norm->Bd.type == DISP_literal)
+               p->flags |= TERMP_BRNEVER;
        p->flags |= TERMP_NOSPACE;
        term_newln(p);
-
-       p->rmargin = rm;
-       p->maxrmargin = rmax;
+       p->flags &= ~TERMP_BRNEVER;
+       if (n->norm->Bd.type == DISP_centered)
+               p->flags &= ~TERMP_CENTER;
 }
 
 static int
@@ -1560,17 +1538,18 @@ termp_ss_pre(DECL_ARGS)
        case ROFFT_BLOCK:
                term_newln(p);
                for (nn = n->prev; nn != NULL; nn = nn->prev)
-                       if ((nn->flags & NODE_NOPRT) == 0)
+                       if (nn->type != ROFFT_COMMENT &&
+                           (nn->flags & NODE_NOPRT) == 0)
                                break;
                if (nn != NULL)
                        term_vspace(p);
                break;
        case ROFFT_HEAD:
                term_fontpush(p, TERMFONT_BOLD);
-               p->offset = term_len(p, (p->defindent+1)/2);
+               p->tcol->offset = term_len(p, (p->defindent+1)/2);
                break;
        case ROFFT_BODY:
-               p->offset = term_len(p, p->defindent);
+               p->tcol->offset = term_len(p, p->defindent);
                term_tab_set(p, NULL);
                term_tab_set(p, "T");
                term_tab_set(p, ".5i");
@@ -1635,7 +1614,7 @@ termp_in_post(DECL_ARGS)
 static int
 termp_pp_pre(DECL_ARGS)
 {
-       fn_prio = 0;
+       fn_prio = TAG_STRONG;
        term_vspace(p);
        return 0;
 }
@@ -1674,7 +1653,7 @@ termp_quote_pre(DECL_ARGS)
                /* FALLTHROUGH */
        case MDOC_Do:
        case MDOC_Dq:
-               term_word(p, "\\(Lq");
+               term_word(p, "\\(lq");
                break;
        case MDOC_En:
                if (NULL == n->norm->Es ||
@@ -1732,7 +1711,7 @@ termp_quote_post(DECL_ARGS)
                /* FALLTHROUGH */
        case MDOC_Do:
        case MDOC_Dq:
-               term_word(p, "\\(Rq");
+               term_word(p, "\\(rq");
                break;
        case MDOC_En:
                if (n->norm->Es == NULL ||
@@ -1817,8 +1796,8 @@ termp_fo_pre(DECL_ARGS)
                return 1;
        } else if (n->type == ROFFT_BODY) {
                if (pretty) {
-                       rmargin = p->rmargin;
-                       p->rmargin = p->offset + term_len(p, 4);
+                       rmargin = p->tcol->rmargin;
+                       p->tcol->rmargin = p->tcol->offset + term_len(p, 4);
                        p->flags |= TERMP_NOBREAK | TERMP_BRIND |
                                        TERMP_HANG;
                }
@@ -1830,8 +1809,8 @@ termp_fo_pre(DECL_ARGS)
                        p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND |
                                        TERMP_HANG);
                        p->flags |= TERMP_NOPAD;
-                       p->offset = p->rmargin;
-                       p->rmargin = rmargin;
+                       p->tcol->offset = p->tcol->rmargin;
+                       p->tcol->rmargin = rmargin;
                }
                return 1;
        }
@@ -1950,7 +1929,6 @@ static int
 termp_lk_pre(DECL_ARGS)
 {
        const struct roff_node *link, *descr, *punct;
-       int display;
 
        if ((link = n->child) == NULL)
                return 0;
@@ -1976,11 +1954,6 @@ termp_lk_pre(DECL_ARGS)
        }
 
        /* Link target. */
-       display = term_strlen(p, link->string) >= 26;
-       if (display) {
-               term_newln(p);
-               p->offset += term_len(p, p->defindent + 1);
-       }
        term_fontpush(p, TERMFONT_BOLD);
        term_word(p, link->string);
        term_fontpop(p);
@@ -1991,8 +1964,6 @@ termp_lk_pre(DECL_ARGS)
                term_word(p, punct->string);
                punct = punct->next;
        }
-       if (display)
-               term_newln(p);
        return 0;
 }
 
@@ -2068,7 +2039,7 @@ termp_em_pre(DECL_ARGS)
 {
        if (n->child != NULL &&
            n->child->type == ROFFT_TEXT)
-               tag_put(n->child->string, 0, p->line);
+               tag_put(n->child->string, TAG_FALLBACK, p->line);
        term_fontpush(p, TERMFONT_UNDER);
        return 1;
 }
@@ -2078,7 +2049,7 @@ termp_sy_pre(DECL_ARGS)
 {
        if (n->child != NULL &&
            n->child->type == ROFFT_TEXT)
-               tag_put(n->child->string, 0, p->line);
+               tag_put(n->child->string, TAG_FALLBACK, p->line);
        term_fontpush(p, TERMFONT_BOLD);
        return 1;
 }
@@ -2091,7 +2062,7 @@ termp_er_pre(DECL_ARGS)
            (n->parent->tok == MDOC_It ||
             (n->parent->tok == MDOC_Bq &&
              n->parent->parent->parent->tok == MDOC_It)))
-               tag_put(n->child->string, 1, p->line);
+               tag_put(n->child->string, TAG_STRONG, p->line);
        return 1;
 }
 
@@ -2108,6 +2079,19 @@ termp_tag_pre(DECL_ARGS)
             (n->parent->tok == MDOC_Xo &&
              n->parent->parent->prev == NULL &&
              n->parent->parent->parent->tok == MDOC_It)))
-               tag_put(n->child->string, 1, p->line);
+               tag_put(n->child->string, TAG_STRONG, p->line);
        return 1;
 }
+
+static int
+termp_tg_pre(DECL_ARGS)
+{
+       tag_put(n->child->string, TAG_MANUAL, p->line);
+       return 0;
+}
+
+static int
+termp_abort_pre(DECL_ARGS)
+{
+       abort();
+}