[BACK]Return to mdoc_term.c CVS log [TXT][DIR] Up to [cvsweb.bsd.lv] / mandoc

Annotation of mandoc/mdoc_term.c, Revision 1.108

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

CVSweb