want to get rid of the last style= attributes, suggested by bentley@

[mandoc.git] / man_term.c

diff --git a/man_term.c b/man_term.c
index 99c2b79487f3bf06232ca6b5c8451f64d123d41c..d9ee14ad22ba433ad172f8abd8a385f9bdaadda7 100644 (file)
--- a/man_term.c
+++ b/man_term.c
@@ -1,7 +1,7 @@
-/*     $Id: man_term.c,v 1.223 2018/12/30 00:49:55 schwarze Exp $ */
+/*     $Id: man_term.c,v 1.232 2019/07/23 17:53:35 schwarze Exp $ */

 /*
  * Copyright (c) 2008-2012 Kristaps Dzonsons <kristaps@bsd.lv>
 /*
  * Copyright (c) 2008-2012 Kristaps Dzonsons <kristaps@bsd.lv>

- * Copyright (c) 2010-2015, 2017, 2018 Ingo Schwarze <schwarze@openbsd.org>
+ * Copyright (c) 2010-2015, 2017-2019 Ingo Schwarze <schwarze@openbsd.org>

  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above


@@ -27,17 +27,17 @@
 #include <string.h>
 
 #include "mandoc_aux.h"
 #include <string.h>
 
 #include "mandoc_aux.h"

+#include "mandoc.h"

 #include "roff.h"
 #include "man.h"
 #include "out.h"
 #include "term.h"
 #include "roff.h"
 #include "man.h"
 #include "out.h"
 #include "term.h"

+#include "tag.h"

 #include "main.h"
 
 #define        MAXMARGINS        64 /* maximum number of indented scopes */
 
 struct mtermp {
 #include "main.h"
 
 #define        MAXMARGINS        64 /* maximum number of indented scopes */
 
 struct mtermp {

-       int               fl;
-#define        MANT_LITERAL     (1 << 0)

        int               lmargin[MAXMARGINS]; /* margins (incl. vis. page) */
        int               lmargincur; /* index of current margin */
        int               lmarginsz; /* actual number of nested margins */
        int               lmargin[MAXMARGINS]; /* margins (incl. vis. page) */
        int               lmargincur; /* index of current margin */
        int               lmarginsz; /* actual number of nested margins */


@@ -90,15 +90,16 @@ static      void              post_IP(DECL_ARGS);
 static void              post_HP(DECL_ARGS);
 static void              post_RS(DECL_ARGS);
 static void              post_SH(DECL_ARGS);
 static void              post_HP(DECL_ARGS);
 static void              post_RS(DECL_ARGS);
 static void              post_SH(DECL_ARGS);

-static void              post_SS(DECL_ARGS);

 static void              post_SY(DECL_ARGS);
 static void              post_TP(DECL_ARGS);
 static void              post_UR(DECL_ARGS);
 
 static void              post_SY(DECL_ARGS);
 static void              post_TP(DECL_ARGS);
 static void              post_UR(DECL_ARGS);
 

+static void              tag_man(struct termp *, struct roff_node *);
+

 static const struct man_term_act man_term_acts[MAN_MAX - MAN_TH] = {
        { NULL, NULL, 0 }, /* TH */
        { pre_SH, post_SH, 0 }, /* SH */
 static const struct man_term_act man_term_acts[MAN_MAX - MAN_TH] = {
        { NULL, NULL, 0 }, /* TH */
        { pre_SH, post_SH, 0 }, /* SH */

-       { pre_SS, post_SS, 0 }, /* SS */
+       { pre_SS, post_SH, 0 }, /* SS */

        { pre_TP, post_TP, 0 }, /* TP */
        { pre_TP, post_TP, 0 }, /* TQ */
        { pre_abort, NULL, 0 }, /* LP */
        { pre_TP, post_TP, 0 }, /* TP */
        { pre_TP, post_TP, 0 }, /* TQ */
        { pre_abort, NULL, 0 }, /* LP */


@@ -117,8 +118,6 @@ static const struct man_term_act man_term_acts[MAN_MAX - MAN_TH] = {
        { pre_I, NULL, 0 }, /* I */
        { pre_alternate, NULL, 0 }, /* IR */
        { pre_alternate, NULL, 0 }, /* RI */
        { pre_I, NULL, 0 }, /* I */
        { pre_alternate, NULL, 0 }, /* IR */
        { pre_alternate, NULL, 0 }, /* RI */

-       { pre_literal, NULL, MAN_NOTEXT }, /* nf */
-       { pre_literal, NULL, MAN_NOTEXT }, /* fi */

        { NULL, NULL, 0 }, /* RE */
        { pre_RS, post_RS, 0 }, /* RS */
        { pre_DT, NULL, 0 }, /* DT */
        { NULL, NULL, 0 }, /* RE */
        { pre_RS, post_RS, 0 }, /* RS */
        { pre_DT, NULL, 0 }, /* DT */


@@ -149,9 +148,9 @@ man_term_act(enum roff_tok tok)
 void
 terminal_man(void *arg, const struct roff_meta *man)
 {
 void
 terminal_man(void *arg, const struct roff_meta *man)
 {

-       struct termp            *p;
-       struct roff_node        *n;

        struct mtermp            mt;
        struct mtermp            mt;

+       struct termp            *p;
+       struct roff_node        *n, *nc, *nn;

        size_t                   save_defindent;
 
        p = (struct termp *)arg;
        size_t                   save_defindent;
 
        p = (struct termp *)arg;


@@ -163,25 +162,30 @@ terminal_man(void *arg, const struct roff_meta *man)
        term_tab_set(p, "T");
        term_tab_set(p, ".5i");
 
        term_tab_set(p, "T");
        term_tab_set(p, ".5i");
 

-       memset(&mt, 0, sizeof(struct mtermp));
+       memset(&mt, 0, sizeof(mt));

        mt.lmargin[mt.lmargincur] = term_len(p, p->defindent);
        mt.offset = term_len(p, p->defindent);
        mt.pardist = 1;
 
        n = man->first->child;
        if (p->synopsisonly) {
        mt.lmargin[mt.lmargincur] = term_len(p, p->defindent);
        mt.offset = term_len(p, p->defindent);
        mt.pardist = 1;
 
        n = man->first->child;
        if (p->synopsisonly) {

-               while (n != NULL) {
-                       if (n->tok == MAN_SH &&
-                           n->child->child->type == ROFFT_TEXT &&
-                           !strcmp(n->child->child->string, "SYNOPSIS")) {
-                               if (n->child->next->child != NULL)
-                                       print_man_nodelist(p, &mt,
-                                           n->child->next->child, man);
-                               term_newln(p);
+               for (nn = NULL; n != NULL; n = n->next) {
+                       if (n->tok != MAN_SH)
+                               continue;
+                       nc = n->child->child;
+                       if (nc->type != ROFFT_TEXT)
+                               continue;
+                       if (strcmp(nc->string, "SYNOPSIS") == 0)

                                break;
                                break;

-                       }
-                       n = n->next;
+                       if (nn == NULL && strcmp(nc->string, "NAME") == 0)
+                               nn = n;

                }
                }

+               if (n == NULL)
+                       n = nn;
+               p->flags |= TERMP_NOSPACE;
+               if (n != NULL && (n = n->child->next->child) != NULL)
+                       print_man_nodelist(p, &mt, n, man);
+               term_newln(p);

        } else {
                term_begin(p, print_man_head, print_man_foot, man);
                p->flags |= TERMP_NOSPACE;
        } else {
                term_begin(p, print_man_head, print_man_foot, man);
                p->flags |= TERMP_NOSPACE;


@@ -207,12 +211,12 @@ print_bvspace(struct termp *p, const struct roff_node *n, int pardist)
 
        term_newln(p);
 
 
        term_newln(p);
 

-       if (n->body && n->body->child)
+       if (n->body != NULL && n->body->child != NULL)

                if (n->body->child->type == ROFFT_TBL)
                        return;
 
        if (n->parent->type == ROFFT_ROOT || n->parent->tok != MAN_RS)
                if (n->body->child->type == ROFFT_TBL)
                        return;
 
        if (n->parent->type == ROFFT_ROOT || n->parent->tok != MAN_RS)

-               if (NULL == n->prev)
+               if (n->prev == NULL)

                        return;
 
        for (i = 0; i < pardist; i++)
                        return;
 
        for (i = 0; i < pardist; i++)


@@ -229,14 +233,12 @@ pre_abort(DECL_ARGS)
 static int
 pre_ign(DECL_ARGS)
 {
 static int
 pre_ign(DECL_ARGS)
 {

-

        return 0;
 }
 
 static int
 pre_I(DECL_ARGS)
 {
        return 0;
 }
 
 static int
 pre_I(DECL_ARGS)
 {

-

        term_fontrepl(p, TERMFONT_UNDER);
        return 1;
 }
        term_fontrepl(p, TERMFONT_UNDER);
        return 1;
 }


@@ -244,14 +246,8 @@ pre_I(DECL_ARGS)
 static int
 pre_literal(DECL_ARGS)
 {
 static int
 pre_literal(DECL_ARGS)
 {

-

        term_newln(p);
 
        term_newln(p);
 

-       if (n->tok == MAN_nf || n->tok == MAN_EX)
-               mt->fl |= MANT_LITERAL;
-       else
-               mt->fl &= ~MANT_LITERAL;
-

        /*
         * Unlike .IP and .TP, .HP does not have a HEAD.
         * So in case a second call to term_flushln() is needed,
        /*
         * Unlike .IP and .TP, .HP does not have a HEAD.
         * So in case a second call to term_flushln() is needed,


@@ -264,7 +260,6 @@ pre_literal(DECL_ARGS)
                p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND);
                p->flags |= TERMP_NOSPACE;
        }
                p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND);
                p->flags |= TERMP_NOSPACE;
        }

-

        return 0;
 }
 
        return 0;
 }
 


@@ -289,7 +284,7 @@ pre_alternate(DECL_ARGS)
 {
        enum termfont            font[2];
        struct roff_node        *nn;
 {
        enum termfont            font[2];
        struct roff_node        *nn;

-       int                      savelit, i;
+       int                      i;

 
        switch (n->tok) {
        case MAN_RB:
 
        switch (n->tok) {
        case MAN_RB:


@@ -319,29 +314,21 @@ pre_alternate(DECL_ARGS)
        default:
                abort();
        }
        default:
                abort();
        }

-
-       savelit = MANT_LITERAL & mt->fl;
-       mt->fl &= ~MANT_LITERAL;
-
-       for (i = 0, nn = n->child; nn; nn = nn->next, i = 1 - i) {
+       for (i = 0, nn = n->child; nn != NULL; nn = nn->next, i = 1 - i) {

                term_fontrepl(p, font[i]);
                term_fontrepl(p, font[i]);

-               if (savelit && NULL == nn->next)
-                       mt->fl |= MANT_LITERAL;

                assert(nn->type == ROFFT_TEXT);
                term_word(p, nn->string);
                if (nn->flags & NODE_EOS)
                assert(nn->type == ROFFT_TEXT);
                term_word(p, nn->string);
                if (nn->flags & NODE_EOS)

-                       p->flags |= TERMP_SENTENCE;
-               if (nn->next)
+                       p->flags |= TERMP_SENTENCE;
+               if (nn->next != NULL)

                        p->flags |= TERMP_NOSPACE;
        }
                        p->flags |= TERMP_NOSPACE;
        }

-

        return 0;
 }
 
 static int
 pre_B(DECL_ARGS)
 {
        return 0;
 }
 
 static int
 pre_B(DECL_ARGS)
 {

-

        term_fontrepl(p, TERMFONT_BOLD);
        return 1;
 }
        term_fontrepl(p, TERMFONT_BOLD);
        return 1;
 }


@@ -349,19 +336,17 @@ pre_B(DECL_ARGS)
 static int
 pre_OP(DECL_ARGS)
 {
 static int
 pre_OP(DECL_ARGS)
 {

-

        term_word(p, "[");
        p->flags |= TERMP_KEEP | TERMP_NOSPACE;
 
        term_word(p, "[");
        p->flags |= TERMP_KEEP | TERMP_NOSPACE;
 

-       if (NULL != (n = n->child)) {
+       if ((n = n->child) != NULL) {

                term_fontrepl(p, TERMFONT_BOLD);
                term_word(p, n->string);
        }
                term_fontrepl(p, TERMFONT_BOLD);
                term_word(p, n->string);
        }

-       if (NULL != n && NULL != n->next) {
+       if (n != NULL && n->next != NULL) {

                term_fontrepl(p, TERMFONT_UNDER);
                term_word(p, n->next->string);
        }
                term_fontrepl(p, TERMFONT_UNDER);
                term_word(p, n->next->string);
        }

-

        term_fontrepl(p, TERMFONT_NONE);
        p->flags &= ~TERMP_KEEP;
        p->flags |= TERMP_NOSPACE;
        term_fontrepl(p, TERMFONT_NONE);
        p->flags &= ~TERMP_KEEP;
        p->flags |= TERMP_NOSPACE;


@@ -387,9 +372,9 @@ pre_in(DECL_ARGS)
        cp = n->child->string;
        less = 0;
 
        cp = n->child->string;
        less = 0;
 

-       if ('-' == *cp)
+       if (*cp == '-')

                less = -1;
                less = -1;

-       else if ('+' == *cp)
+       else if (*cp == '+')

                less = 1;
        else
                cp--;
                less = 1;
        else
                cp--;


@@ -431,13 +416,18 @@ pre_HP(DECL_ARGS)
        case ROFFT_BLOCK:
                print_bvspace(p, n, mt->pardist);
                return 1;
        case ROFFT_BLOCK:
                print_bvspace(p, n, mt->pardist);
                return 1;

+       case ROFFT_HEAD:
+               return 0;

        case ROFFT_BODY:
                break;
        default:
        case ROFFT_BODY:
                break;
        default:

-               return 0;
+               abort();

        }
 
        }
 

-       if ( ! (MANT_LITERAL & mt->fl)) {
+       if (n->child == NULL)
+               return 0;
+
+       if ((n->child->flags & NODE_NOFILL) == 0) {

                p->flags |= TERMP_NOBREAK | TERMP_BRIND;
                p->trailspace = 2;
        }
                p->flags |= TERMP_NOBREAK | TERMP_BRIND;
                p->trailspace = 2;
        }


@@ -463,8 +453,10 @@ pre_HP(DECL_ARGS)
 static void
 post_HP(DECL_ARGS)
 {
 static void
 post_HP(DECL_ARGS)
 {

-

        switch (n->type) {
        switch (n->type) {

+       case ROFFT_BLOCK:
+       case ROFFT_HEAD:
+               break;

        case ROFFT_BODY:
                term_newln(p);
 
        case ROFFT_BODY:
                term_newln(p);
 


@@ -484,25 +476,27 @@ post_HP(DECL_ARGS)
                p->tcol->rmargin = p->maxrmargin;
                break;
        default:
                p->tcol->rmargin = p->maxrmargin;
                break;
        default:

-               break;
+               abort();

        }
 }
 
 static int
 pre_PP(DECL_ARGS)
 {
        }
 }
 
 static int
 pre_PP(DECL_ARGS)
 {

-

        switch (n->type) {
        case ROFFT_BLOCK:
                mt->lmargin[mt->lmargincur] = term_len(p, p->defindent);
                print_bvspace(p, n, mt->pardist);
                break;
        switch (n->type) {
        case ROFFT_BLOCK:
                mt->lmargin[mt->lmargincur] = term_len(p, p->defindent);
                print_bvspace(p, n, mt->pardist);
                break;

-       default:
+       case ROFFT_HEAD:
+               return 0;
+       case ROFFT_BODY:

                p->tcol->offset = mt->offset;
                break;
                p->tcol->offset = mt->offset;
                break;

+       default:
+               abort();

        }
        }

-
-       return n->type != ROFFT_HEAD;
+       return 1;

 }
 
 static int
 }
 
 static int


@@ -510,21 +504,21 @@ pre_IP(DECL_ARGS)
 {
        struct roffsu            su;
        const struct roff_node  *nn;
 {
        struct roffsu            su;
        const struct roff_node  *nn;

-       int                      len, savelit;
+       int                      len;

 
        switch (n->type) {
 
        switch (n->type) {

-       case ROFFT_BODY:
-               p->flags |= TERMP_NOSPACE;
-               break;
+       case ROFFT_BLOCK:
+               print_bvspace(p, n, mt->pardist);
+               return 1;

        case ROFFT_HEAD:
                p->flags |= TERMP_NOBREAK;
                p->trailspace = 1;
                break;
        case ROFFT_HEAD:
                p->flags |= TERMP_NOBREAK;
                p->trailspace = 1;
                break;

-       case ROFFT_BLOCK:
-               print_bvspace(p, n, mt->pardist);
-               /* FALLTHROUGH */
+       case ROFFT_BODY:
+               p->flags |= TERMP_NOSPACE;
+               break;

        default:
        default:

-               return 1;
+               abort();

        }
 
        /* Calculate the offset from the optional second argument. */
        }
 
        /* Calculate the offset from the optional second argument. */


@@ -544,33 +538,27 @@ pre_IP(DECL_ARGS)
        case ROFFT_HEAD:
                p->tcol->offset = mt->offset;
                p->tcol->rmargin = mt->offset + len;
        case ROFFT_HEAD:
                p->tcol->offset = mt->offset;
                p->tcol->rmargin = mt->offset + len;

-
-               savelit = MANT_LITERAL & mt->fl;
-               mt->fl &= ~MANT_LITERAL;
-
-               if (n->child)
+               if (n->child != NULL) {

                        print_man_node(p, mt, n->child, meta);
                        print_man_node(p, mt, n->child, meta);

-
-               if (savelit)
-                       mt->fl |= MANT_LITERAL;
-
+                       tag_man(p, n->child);
+               }

                return 0;
        case ROFFT_BODY:
                p->tcol->offset = mt->offset + len;
                p->tcol->rmargin = p->maxrmargin;
                break;
        default:
                return 0;
        case ROFFT_BODY:
                p->tcol->offset = mt->offset + len;
                p->tcol->rmargin = p->maxrmargin;
                break;
        default:

-               break;
+               abort();

        }
        }

-

        return 1;
 }
 
 static void
 post_IP(DECL_ARGS)
 {
        return 1;
 }
 
 static void
 post_IP(DECL_ARGS)
 {

-

        switch (n->type) {
        switch (n->type) {

+       case ROFFT_BLOCK:
+               break;

        case ROFFT_HEAD:
                term_flushln(p);
                p->flags &= ~TERMP_NOBREAK;
        case ROFFT_HEAD:
                term_flushln(p);
                p->flags &= ~TERMP_NOBREAK;


@@ -582,7 +570,7 @@ post_IP(DECL_ARGS)
                p->tcol->offset = mt->offset;
                break;
        default:
                p->tcol->offset = mt->offset;
                break;
        default:

-               break;
+               abort();

        }
 }
 
        }
 }
 


@@ -591,9 +579,13 @@ pre_TP(DECL_ARGS)
 {
        struct roffsu            su;
        struct roff_node        *nn;
 {
        struct roffsu            su;
        struct roff_node        *nn;

-       int                      len, savelit;
+       int                      len;

 
        switch (n->type) {
 
        switch (n->type) {

+       case ROFFT_BLOCK:
+               if (n->tok == MAN_TP)
+                       print_bvspace(p, n, mt->pardist);
+               return 1;

        case ROFFT_HEAD:
                p->flags |= TERMP_NOBREAK | TERMP_BRTRSP;
                p->trailspace = 1;
        case ROFFT_HEAD:
                p->flags |= TERMP_NOBREAK | TERMP_BRTRSP;
                p->trailspace = 1;


@@ -601,12 +593,8 @@ pre_TP(DECL_ARGS)
        case ROFFT_BODY:
                p->flags |= TERMP_NOSPACE;
                break;
        case ROFFT_BODY:
                p->flags |= TERMP_NOSPACE;
                break;

-       case ROFFT_BLOCK:
-               if (n->tok == MAN_TP)
-                       print_bvspace(p, n, mt->pardist);
-               /* FALLTHROUGH */

        default:
        default:

-               return 1;
+               abort();

        }
 
        /* Calculate offset. */
        }
 
        /* Calculate offset. */


@@ -628,21 +616,27 @@ pre_TP(DECL_ARGS)
                p->tcol->offset = mt->offset;
                p->tcol->rmargin = mt->offset + len;
 
                p->tcol->offset = mt->offset;
                p->tcol->rmargin = mt->offset + len;
 

-               savelit = MANT_LITERAL & mt->fl;
-               mt->fl &= ~MANT_LITERAL;
-

                /* Don't print same-line elements. */
                nn = n->child;
                /* Don't print same-line elements. */
                nn = n->child;

-               while (NULL != nn && 0 == (NODE_LINE & nn->flags))
+               while (nn != NULL && (nn->flags & NODE_LINE) == 0)

                        nn = nn->next;
 
                        nn = nn->next;
 

-               while (NULL != nn) {
+               if (nn == NULL)
+                       return 0;
+
+               if (nn->type == ROFFT_TEXT)
+                       tag_man(p, nn);
+               else if (nn->child != NULL &&
+                   nn->child->type == ROFFT_TEXT &&
+                   (nn->tok == MAN_B || nn->tok == MAN_BI ||
+                    nn->tok == MAN_BR || nn->tok == MAN_I ||
+                    nn->tok == MAN_IB || nn->tok == MAN_IR))
+                       tag_man(p, nn->child);
+
+               while (nn != NULL) {

                        print_man_node(p, mt, nn, meta);
                        nn = nn->next;
                }
                        print_man_node(p, mt, nn, meta);
                        nn = nn->next;
                }

-
-               if (savelit)
-                       mt->fl |= MANT_LITERAL;

                return 0;
        case ROFFT_BODY:
                p->tcol->offset = mt->offset + len;
                return 0;
        case ROFFT_BODY:
                p->tcol->offset = mt->offset + len;


@@ -651,17 +645,17 @@ pre_TP(DECL_ARGS)
                p->flags &= ~(TERMP_NOBREAK | TERMP_BRTRSP);
                break;
        default:
                p->flags &= ~(TERMP_NOBREAK | TERMP_BRTRSP);
                break;
        default:

-               break;
+               abort();

        }
        }

-

        return 1;
 }
 
 static void
 post_TP(DECL_ARGS)
 {
        return 1;
 }
 
 static void
 post_TP(DECL_ARGS)
 {

-

        switch (n->type) {
        switch (n->type) {

+       case ROFFT_BLOCK:
+               break;

        case ROFFT_HEAD:
                term_flushln(p);
                break;
        case ROFFT_HEAD:
                term_flushln(p);
                break;


@@ -670,7 +664,7 @@ post_TP(DECL_ARGS)
                p->tcol->offset = mt->offset;
                break;
        default:
                p->tcol->offset = mt->offset;
                break;
        default:

-               break;
+               abort();

        }
 }
 
        }
 }
 


@@ -681,7 +675,6 @@ pre_SS(DECL_ARGS)
 
        switch (n->type) {
        case ROFFT_BLOCK:
 
        switch (n->type) {
        case ROFFT_BLOCK:

-               mt->fl &= ~MANT_LITERAL;

                mt->lmargin[mt->lmargincur] = term_len(p, p->defindent);
                mt->offset = term_len(p, p->defindent);
 
                mt->lmargin[mt->lmargincur] = term_len(p, p->defindent);
                mt->offset = term_len(p, p->defindent);
 


@@ -717,26 +710,9 @@ pre_SS(DECL_ARGS)
        default:
                break;
        }
        default:
                break;
        }

-

        return 1;
 }
 
        return 1;
 }
 

-static void
-post_SS(DECL_ARGS)
-{
-
-       switch (n->type) {
-       case ROFFT_HEAD:
-               term_newln(p);
-               break;
-       case ROFFT_BODY:
-               term_newln(p);
-               break;
-       default:
-               break;
-       }
-}
-

 static int
 pre_SH(DECL_ARGS)
 {
 static int
 pre_SH(DECL_ARGS)
 {


@@ -744,7 +720,6 @@ pre_SH(DECL_ARGS)
 
        switch (n->type) {
        case ROFFT_BLOCK:
 
        switch (n->type) {
        case ROFFT_BLOCK:

-               mt->fl &= ~MANT_LITERAL;

                mt->lmargin[mt->lmargincur] = term_len(p, p->defindent);
                mt->offset = term_len(p, p->defindent);
 
                mt->lmargin[mt->lmargincur] = term_len(p, p->defindent);
                mt->offset = term_len(p, p->defindent);
 


@@ -778,25 +753,23 @@ pre_SH(DECL_ARGS)
                p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND);
                break;
        default:
                p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND);
                break;
        default:

-               break;
+               abort();

        }
        }

-

        return 1;
 }
 
 static void
 post_SH(DECL_ARGS)
 {
        return 1;
 }
 
 static void
 post_SH(DECL_ARGS)
 {

-

        switch (n->type) {
        switch (n->type) {

-       case ROFFT_HEAD:
-               term_newln(p);
+       case ROFFT_BLOCK:

                break;
                break;

+       case ROFFT_HEAD:

        case ROFFT_BODY:
                term_newln(p);
                break;
        default:
        case ROFFT_BODY:
                term_newln(p);
                break;
        default:

-               break;
+               abort();

        }
 }
 
        }
 }
 


@@ -811,8 +784,10 @@ pre_RS(DECL_ARGS)
                return 1;
        case ROFFT_HEAD:
                return 0;
                return 1;
        case ROFFT_HEAD:
                return 0;

-       default:
+       case ROFFT_BODY:

                break;
                break;

+       default:
+               abort();

        }
 
        n = n->parent->head;
        }
 
        n = n->parent->head;


@@ -840,20 +815,18 @@ pre_RS(DECL_ARGS)
 static void
 post_RS(DECL_ARGS)
 {
 static void
 post_RS(DECL_ARGS)
 {

-

        switch (n->type) {
        case ROFFT_BLOCK:
        switch (n->type) {
        case ROFFT_BLOCK:

-               return;

        case ROFFT_HEAD:
                return;
        case ROFFT_HEAD:
                return;

-       default:
-               term_newln(p);
+       case ROFFT_BODY:

                break;
                break;

+       default:
+               abort();

        }
        }

-
+       term_newln(p);

        mt->offset -= n->parent->head->aux;
        p->tcol->offset = mt->offset;
        mt->offset -= n->parent->head->aux;
        p->tcol->offset = mt->offset;

-

        if (--mt->lmarginsz < MAXMARGINS)
                mt->lmargincur = mt->lmarginsz;
 }
        if (--mt->lmarginsz < MAXMARGINS)
                mt->lmargincur = mt->lmarginsz;
 }


@@ -883,7 +856,9 @@ pre_SY(DECL_ARGS)
        case ROFFT_HEAD:
                p->tcol->offset = mt->offset;
                p->tcol->rmargin = mt->offset + len;
        case ROFFT_HEAD:
                p->tcol->offset = mt->offset;
                p->tcol->rmargin = mt->offset + len;

-               p->flags |= TERMP_NOBREAK;
+               if (n->next->child == NULL ||
+                   (n->next->child->flags & NODE_NOFILL) == 0)
+                       p->flags |= TERMP_NOBREAK;

                term_fontrepl(p, TERMFONT_BOLD);
                break;
        case ROFFT_BODY:
                term_fontrepl(p, TERMFONT_BOLD);
                break;
        case ROFFT_BODY:


@@ -902,6 +877,8 @@ static void
 post_SY(DECL_ARGS)
 {
        switch (n->type) {
 post_SY(DECL_ARGS)
 {
        switch (n->type) {

+       case ROFFT_BLOCK:
+               break;

        case ROFFT_HEAD:
                term_flushln(p);
                p->flags &= ~TERMP_NOBREAK;
        case ROFFT_HEAD:
                term_flushln(p);
                p->flags &= ~TERMP_NOBREAK;


@@ -911,28 +888,26 @@ post_SY(DECL_ARGS)
                p->tcol->offset = mt->offset;
                break;
        default:
                p->tcol->offset = mt->offset;
                break;
        default:

-               break;
+               abort();

        }
 }
 
 static int
 pre_UR(DECL_ARGS)
 {
        }
 }
 
 static int
 pre_UR(DECL_ARGS)
 {

-

        return n->type != ROFFT_HEAD;
 }
 
 static void
 post_UR(DECL_ARGS)
 {
        return n->type != ROFFT_HEAD;
 }
 
 static void
 post_UR(DECL_ARGS)
 {

-

        if (n->type != ROFFT_BLOCK)
                return;
 
        term_word(p, "<");
        p->flags |= TERMP_NOSPACE;
 
        if (n->type != ROFFT_BLOCK)
                return;
 
        term_word(p, "<");
        p->flags |= TERMP_NOSPACE;
 

-       if (NULL != n->child->child)
+       if (n->child->child != NULL)

                print_man_node(p, mt, n->child->child, meta);
 
        p->flags |= TERMP_NOSPACE;
                print_man_node(p, mt, n->child->child, meta);
 
        p->flags |= TERMP_NOSPACE;


@@ -997,7 +972,7 @@ print_man_node(DECL_ARGS)
        if (act->pre != NULL)
                c = (*act->pre)(p, mt, n, meta);
 
        if (act->pre != NULL)
                c = (*act->pre)(p, mt, n, meta);
 

-       if (c && n->child)
+       if (c && n->child != NULL)

                print_man_nodelist(p, mt, n->child, meta);
 
        if (act->post != NULL)
                print_man_nodelist(p, mt, n->child, meta);
 
        if (act->post != NULL)


@@ -1013,7 +988,7 @@ out:
         * -man doesn't have nested macros, we don't need to be
         * more specific than this.
         */
         * -man doesn't have nested macros, we don't need to be
         * more specific than this.
         */

-       if (mt->fl & MANT_LITERAL &&
+       if (n->flags & NODE_NOFILL &&

            ! (p->flags & (TERMP_NOBREAK | TERMP_NONEWLINE)) &&
            (n->next == NULL || n->next->flags & NODE_LINE)) {
                p->flags |= TERMP_BRNEVER | TERMP_NOSPACE;
            ! (p->flags & (TERMP_NOBREAK | TERMP_NONEWLINE)) &&
            (n->next == NULL || n->next->flags & NODE_LINE)) {
                p->flags |= TERMP_BRNEVER | TERMP_NOSPACE;


@@ -1028,15 +1003,13 @@ out:
                        p->tcol->rmargin = p->maxrmargin;
                }
        }
                        p->tcol->rmargin = p->maxrmargin;
                }
        }

-       if (NODE_EOS & n->flags)
+       if (n->flags & NODE_EOS)

                p->flags |= TERMP_SENTENCE;
 }
 
                p->flags |= TERMP_SENTENCE;
 }
 

-

 static void
 print_man_nodelist(DECL_ARGS)
 {
 static void
 print_man_nodelist(DECL_ARGS)
 {

-

        while (n != NULL) {
                print_man_node(p, mt, n, meta);
                n = n->next;
        while (n != NULL) {
                print_man_node(p, mt, n, meta);
                n = n->next;


@@ -1071,7 +1044,7 @@ print_man_foot(struct termp *p, const struct roff_meta *meta)
                }
                mandoc_asprintf(&title, "%s(%s)",
                    meta->title, meta->msec);
                }
                mandoc_asprintf(&title, "%s(%s)",
                    meta->title, meta->msec);

-       } else if (meta->os) {
+       } else if (meta->os != NULL) {

                title = mandoc_strdup(meta->os);
        } else {
                title = mandoc_strdup("");
                title = mandoc_strdup(meta->os);
        } else {
                title = mandoc_strdup("");


@@ -1193,3 +1166,60 @@ print_man_head(struct termp *p, const struct roff_meta *meta)
        }
        free(title);
 }
        }
        free(title);
 }

+
+/*
+ * Skip leading whitespace, dashes, backslashes, and font escapes,
+ * then create a tag if the first following byte is a letter.
+ * Priority is high unless whitespace is present.
+ */
+static void
+tag_man(struct termp *p, struct roff_node *n)
+{
+       const char      *cp, *arg;
+       int              prio, sz;
+
+       assert(n->type == ROFFT_TEXT);
+       cp = n->string;
+       prio = 1;
+       for (;;) {
+               switch (*cp) {
+               case ' ':
+               case '\t':
+                       prio = INT_MAX;
+                       /* FALLTHROUGH */
+               case '-':
+                       cp++;
+                       break;
+               case '\\':
+                       cp++;
+                       switch (mandoc_escape(&cp, &arg, &sz)) {
+                       case ESCAPE_FONT:
+                       case ESCAPE_FONTROMAN:
+                       case ESCAPE_FONTITALIC:
+                       case ESCAPE_FONTBOLD:
+                       case ESCAPE_FONTPREV:
+                       case ESCAPE_FONTBI:
+                               break;
+                       case ESCAPE_SPECIAL:
+                               if (sz != 1)
+                                       return;
+                               switch (*arg) {
+                               case '&':
+                               case '-':
+                               case 'e':
+                                       break;
+                               default:
+                                       return;
+                               }
+                               break;
+                       default:
+                               return;
+                       }
+                       break;
+               default:
+                       if (isalpha((unsigned char)*cp))
+                               tag_put(cp, prio, p->line);
+                       return;
+               }
+       }
+}