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

Annotation of mandoc/mdoc_term.c, Revision 1.277

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

CVSweb