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

Annotation of mandoc/term.c, Revision 1.29

1.29    ! kristaps    1: /* $Id: term.c,v 1.28 2009/02/28 19:15:28 kristaps Exp $ */
1.1       kristaps    2: /*
1.10      kristaps    3:  * Copyright (c) 2009 Kristaps Dzonsons <kristaps@kth.se>
1.1       kristaps    4:  *
                      5:  * Permission to use, copy, modify, and distribute this software for any
                      6:  * purpose with or without fee is hereby granted, provided that the
                      7:  * above copyright notice and this permission notice appear in all
                      8:  * copies.
                      9:  *
                     10:  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
                     11:  * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
                     12:  * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
                     13:  * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
                     14:  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
                     15:  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
                     16:  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
                     17:  * PERFORMANCE OF THIS SOFTWARE.
                     18:  */
                     19: #include <assert.h>
1.25      kristaps   20: #include <ctype.h>
1.23      kristaps   21: #include <err.h>
1.22      kristaps   22: #include <stdio.h>
1.1       kristaps   23: #include <stdlib.h>
                     24: #include <string.h>
                     25:
1.10      kristaps   26: #include "term.h"
                     27:
1.29    ! kristaps   28: #define        INDENT            6
1.10      kristaps   29:
                     30: /*
                     31:  * Performs actions on nodes of the abstract syntax tree.  Both pre- and
                     32:  * post-fix operations are defined here.
                     33:  */
                     34:
                     35: /* FIXME: indent/tab. */
1.21      kristaps   36: /* FIXME: macro arguments can be escaped. */
1.10      kristaps   37:
                     38: #define        TTYPE_PROG        0
                     39: #define        TTYPE_CMD_FLAG    1
                     40: #define        TTYPE_CMD_ARG     2
                     41: #define        TTYPE_SECTION     3
                     42: #define        TTYPE_FUNC_DECL   4
                     43: #define        TTYPE_VAR_DECL    5
                     44: #define        TTYPE_FUNC_TYPE   6
                     45: #define        TTYPE_FUNC_NAME   7
                     46: #define        TTYPE_FUNC_ARG    8
                     47: #define        TTYPE_LINK        9
                     48: #define        TTYPE_SSECTION    10
                     49: #define        TTYPE_FILE        11
1.11      kristaps   50: #define        TTYPE_EMPH        12
1.14      kristaps   51: #define        TTYPE_CONFIG      13
                     52: #define        TTYPE_CMD         14
                     53: #define        TTYPE_INCLUDE     15
1.17      kristaps   54: #define        TTYPE_SYMB        16
                     55: #define        TTYPE_SYMBOL      17
                     56: #define        TTYPE_NMAX        18
1.10      kristaps   57:
                     58: /*
                     59:  * These define "styles" for element types, like command arguments or
                     60:  * executable names.  This is useful when multiple macros must decorate
                     61:  * the same thing (like .Ex -std cmd and .Nm cmd).
                     62:  */
                     63:
                     64: const  int ttypes[TTYPE_NMAX] = {
                     65:        TERMP_BOLD,             /* TTYPE_PROG */
                     66:        TERMP_BOLD,             /* TTYPE_CMD_FLAG */
                     67:        TERMP_UNDERLINE,        /* TTYPE_CMD_ARG */
                     68:        TERMP_BOLD,             /* TTYPE_SECTION */
                     69:        TERMP_BOLD,             /* TTYPE_FUNC_DECL */
                     70:        TERMP_UNDERLINE,        /* TTYPE_VAR_DECL */
                     71:        TERMP_UNDERLINE,        /* TTYPE_FUNC_TYPE */
                     72:        TERMP_BOLD,             /* TTYPE_FUNC_NAME */
                     73:        TERMP_UNDERLINE,        /* TTYPE_FUNC_ARG */
                     74:        TERMP_UNDERLINE,        /* TTYPE_LINK */
                     75:        TERMP_BOLD,             /* TTYPE_SSECTION */
1.11      kristaps   76:        TERMP_UNDERLINE,        /* TTYPE_FILE */
1.14      kristaps   77:        TERMP_UNDERLINE,        /* TTYPE_EMPH */
                     78:        TERMP_BOLD,             /* TTYPE_CONFIG */
                     79:        TERMP_BOLD,             /* TTYPE_CMD */
1.17      kristaps   80:        TERMP_BOLD,             /* TTYPE_INCLUDE */
                     81:        TERMP_BOLD,             /* TTYPE_SYMB */
                     82:        TERMP_BOLD              /* TTYPE_SYMBOL */
1.10      kristaps   83: };
1.7       kristaps   84:
1.10      kristaps   85: static int               arg_hasattr(int, size_t,
                     86:                                const struct mdoc_arg *);
                     87: static int               arg_getattr(int, size_t,
                     88:                                const struct mdoc_arg *);
1.12      kristaps   89: static size_t            arg_offset(const struct mdoc_arg *);
                     90: static size_t            arg_width(const struct mdoc_arg *);
1.10      kristaps   91:
                     92: /*
                     93:  * What follows describes prefix and postfix operations for the abstract
                     94:  * syntax tree descent.
                     95:  */
1.1       kristaps   96:
1.10      kristaps   97: #define        DECL_ARGS \
                     98:        struct termp *p, \
1.18      kristaps   99:        struct termpair *pair, \
1.10      kristaps  100:        const struct mdoc_meta *meta, \
                    101:        const struct mdoc_node *node
                    102:
                    103: #define        DECL_PRE(name) \
                    104: static int               name##_pre(DECL_ARGS)
                    105: #define        DECL_POST(name) \
                    106: static void              name##_post(DECL_ARGS)
                    107: #define        DECL_PREPOST(name) \
                    108: DECL_PRE(name); \
                    109: DECL_POST(name);
                    110:
1.28      kristaps  111: DECL_PREPOST(termp__t);
1.10      kristaps  112: DECL_PREPOST(termp_aq);
1.12      kristaps  113: DECL_PREPOST(termp_bd);
1.15      kristaps  114: DECL_PREPOST(termp_bq);
1.10      kristaps  115: DECL_PREPOST(termp_d1);
                    116: DECL_PREPOST(termp_dq);
                    117: DECL_PREPOST(termp_fd);
                    118: DECL_PREPOST(termp_fn);
1.16      kristaps  119: DECL_PREPOST(termp_fo);
1.10      kristaps  120: DECL_PREPOST(termp_ft);
                    121: DECL_PREPOST(termp_it);
                    122: DECL_PREPOST(termp_op);
                    123: DECL_PREPOST(termp_pf);
1.15      kristaps  124: DECL_PREPOST(termp_pq);
1.10      kristaps  125: DECL_PREPOST(termp_qq);
                    126: DECL_PREPOST(termp_sh);
                    127: DECL_PREPOST(termp_ss);
                    128: DECL_PREPOST(termp_sq);
                    129: DECL_PREPOST(termp_vt);
                    130:
1.18      kristaps  131: DECL_PRE(termp_ar);
1.14      kristaps  132: DECL_PRE(termp_at);
1.18      kristaps  133: DECL_PRE(termp_bf);
1.15      kristaps  134: DECL_PRE(termp_bsx);
1.17      kristaps  135: DECL_PRE(termp_bt);
1.10      kristaps  136: DECL_PRE(termp_bx);
1.18      kristaps  137: DECL_PRE(termp_cd);
                    138: DECL_PRE(termp_cm);
                    139: DECL_PRE(termp_em);
1.10      kristaps  140: DECL_PRE(termp_ex);
1.18      kristaps  141: DECL_PRE(termp_fa);
                    142: DECL_PRE(termp_fl);
1.16      kristaps  143: DECL_PRE(termp_fx);
1.18      kristaps  144: DECL_PRE(termp_ic);
                    145: DECL_PRE(termp_in);
                    146: DECL_PRE(termp_ms);
1.10      kristaps  147: DECL_PRE(termp_nd);
1.18      kristaps  148: DECL_PRE(termp_nm);
1.10      kristaps  149: DECL_PRE(termp_ns);
                    150: DECL_PRE(termp_nx);
                    151: DECL_PRE(termp_ox);
1.18      kristaps  152: DECL_PRE(termp_pa);
1.10      kristaps  153: DECL_PRE(termp_pp);
1.28      kristaps  154: DECL_PRE(termp_rs);
1.14      kristaps  155: DECL_PRE(termp_rv);
1.22      kristaps  156: DECL_PRE(termp_sm);
1.14      kristaps  157: DECL_PRE(termp_st);
1.18      kristaps  158: DECL_PRE(termp_sx);
                    159: DECL_PRE(termp_sy);
1.10      kristaps  160: DECL_PRE(termp_ud);
1.16      kristaps  161: DECL_PRE(termp_ux);
1.18      kristaps  162: DECL_PRE(termp_va);
1.10      kristaps  163: DECL_PRE(termp_xr);
                    164:
1.28      kristaps  165: DECL_POST(termp___);
1.10      kristaps  166: DECL_POST(termp_bl);
                    167:
                    168: const  struct termact __termacts[MDOC_MAX] = {
                    169:        { NULL, NULL }, /* \" */
                    170:        { NULL, NULL }, /* Dd */
                    171:        { NULL, NULL }, /* Dt */
                    172:        { NULL, NULL }, /* Os */
                    173:        { termp_sh_pre, termp_sh_post }, /* Sh */
                    174:        { termp_ss_pre, termp_ss_post }, /* Ss */
                    175:        { termp_pp_pre, NULL }, /* Pp */
                    176:        { termp_d1_pre, termp_d1_post }, /* D1 */
1.29    ! kristaps  177:        { termp_d1_pre, termp_d1_post }, /* Dl */
1.12      kristaps  178:        { termp_bd_pre, termp_bd_post }, /* Bd */
1.10      kristaps  179:        { NULL, NULL }, /* Ed */
                    180:        { NULL, termp_bl_post }, /* Bl */
                    181:        { NULL, NULL }, /* El */
                    182:        { termp_it_pre, termp_it_post }, /* It */
                    183:        { NULL, NULL }, /* Ad */
                    184:        { NULL, NULL }, /* An */
1.18      kristaps  185:        { termp_ar_pre, NULL }, /* Ar */
                    186:        { termp_cd_pre, NULL }, /* Cd */
                    187:        { termp_cm_pre, NULL }, /* Cm */
1.10      kristaps  188:        { NULL, NULL }, /* Dv */
                    189:        { NULL, NULL }, /* Er */
                    190:        { NULL, NULL }, /* Ev */
                    191:        { termp_ex_pre, NULL }, /* Ex */
1.18      kristaps  192:        { termp_fa_pre, NULL }, /* Fa */
1.10      kristaps  193:        { termp_fd_pre, termp_fd_post }, /* Fd */
1.18      kristaps  194:        { termp_fl_pre, NULL }, /* Fl */
1.10      kristaps  195:        { termp_fn_pre, termp_fn_post }, /* Fn */
                    196:        { termp_ft_pre, termp_ft_post }, /* Ft */
1.18      kristaps  197:        { termp_ic_pre, NULL }, /* Ic */
                    198:        { termp_in_pre, NULL }, /* In */
1.10      kristaps  199:        { NULL, NULL }, /* Li */
                    200:        { termp_nd_pre, NULL }, /* Nd */
1.18      kristaps  201:        { termp_nm_pre, NULL }, /* Nm */
1.10      kristaps  202:        { termp_op_pre, termp_op_post }, /* Op */
                    203:        { NULL, NULL }, /* Ot */
1.18      kristaps  204:        { termp_pa_pre, NULL }, /* Pa */
1.14      kristaps  205:        { termp_rv_pre, NULL }, /* Rv */
                    206:        { termp_st_pre, NULL }, /* St */
1.18      kristaps  207:        { termp_va_pre, NULL }, /* Va */
1.10      kristaps  208:        { termp_vt_pre, termp_vt_post }, /* Vt */
                    209:        { termp_xr_pre, NULL }, /* Xr */
1.28      kristaps  210:        { NULL, termp____post }, /* %A */
1.29    ! kristaps  211:        { NULL, termp____post }, /* %B */
1.28      kristaps  212:        { NULL, termp____post }, /* %D */
1.29    ! kristaps  213:        { NULL, termp____post }, /* %I */
1.28      kristaps  214:        { NULL, termp____post }, /* %J */
1.29    ! kristaps  215:        { NULL, termp____post }, /* %N */
        !           216:        { NULL, termp____post }, /* %O */
        !           217:        { NULL, termp____post }, /* %P */
        !           218:        { NULL, termp____post }, /* %R */
1.28      kristaps  219:        { termp__t_pre, termp__t_post }, /* %T */
1.29    ! kristaps  220:        { NULL, termp____post }, /* %V */
1.10      kristaps  221:        { NULL, NULL }, /* Ac */
1.14      kristaps  222:        { termp_aq_pre, termp_aq_post }, /* Ao */
1.10      kristaps  223:        { termp_aq_pre, termp_aq_post }, /* Aq */
1.14      kristaps  224:        { termp_at_pre, NULL }, /* At */
1.10      kristaps  225:        { NULL, NULL }, /* Bc */
1.18      kristaps  226:        { termp_bf_pre, NULL }, /* Bf */
1.15      kristaps  227:        { termp_bq_pre, termp_bq_post }, /* Bo */
                    228:        { termp_bq_pre, termp_bq_post }, /* Bq */
                    229:        { termp_bsx_pre, NULL }, /* Bsx */
1.10      kristaps  230:        { termp_bx_pre, NULL }, /* Bx */
                    231:        { NULL, NULL }, /* Db */
                    232:        { NULL, NULL }, /* Dc */
1.15      kristaps  233:        { termp_dq_pre, termp_dq_post }, /* Do */
1.10      kristaps  234:        { termp_dq_pre, termp_dq_post }, /* Dq */
                    235:        { NULL, NULL }, /* Ec */
                    236:        { NULL, NULL }, /* Ef */
1.18      kristaps  237:        { termp_em_pre, NULL }, /* Em */
1.10      kristaps  238:        { NULL, NULL }, /* Eo */
1.16      kristaps  239:        { termp_fx_pre, NULL }, /* Fx */
1.18      kristaps  240:        { termp_ms_pre, NULL }, /* Ms */
1.10      kristaps  241:        { NULL, NULL }, /* No */
                    242:        { termp_ns_pre, NULL }, /* Ns */
                    243:        { termp_nx_pre, NULL }, /* Nx */
                    244:        { termp_ox_pre, NULL }, /* Ox */
                    245:        { NULL, NULL }, /* Pc */
                    246:        { termp_pf_pre, termp_pf_post }, /* Pf */
1.15      kristaps  247:        { termp_pq_pre, termp_pq_post }, /* Po */
                    248:        { termp_pq_pre, termp_pq_post }, /* Pq */
1.10      kristaps  249:        { NULL, NULL }, /* Qc */
1.16      kristaps  250:        { termp_sq_pre, termp_sq_post }, /* Ql */
1.15      kristaps  251:        { termp_qq_pre, termp_qq_post }, /* Qo */
1.10      kristaps  252:        { termp_qq_pre, termp_qq_post }, /* Qq */
                    253:        { NULL, NULL }, /* Re */
1.28      kristaps  254:        { termp_rs_pre, NULL }, /* Rs */
1.10      kristaps  255:        { NULL, NULL }, /* Sc */
1.15      kristaps  256:        { termp_sq_pre, termp_sq_post }, /* So */
1.10      kristaps  257:        { termp_sq_pre, termp_sq_post }, /* Sq */
1.22      kristaps  258:        { termp_sm_pre, NULL }, /* Sm */
1.18      kristaps  259:        { termp_sx_pre, NULL }, /* Sx */
                    260:        { termp_sy_pre, NULL }, /* Sy */
1.10      kristaps  261:        { NULL, NULL }, /* Tn */
1.16      kristaps  262:        { termp_ux_pre, NULL }, /* Ux */
1.10      kristaps  263:        { NULL, NULL }, /* Xc */
                    264:        { NULL, NULL }, /* Xo */
1.16      kristaps  265:        { termp_fo_pre, termp_fo_post }, /* Fo */
1.10      kristaps  266:        { NULL, NULL }, /* Fc */
1.16      kristaps  267:        { termp_op_pre, termp_op_post }, /* Oo */
1.10      kristaps  268:        { NULL, NULL }, /* Oc */
                    269:        { NULL, NULL }, /* Bk */
                    270:        { NULL, NULL }, /* Ek */
1.17      kristaps  271:        { termp_bt_pre, NULL }, /* Bt */
1.10      kristaps  272:        { NULL, NULL }, /* Hf */
                    273:        { NULL, NULL }, /* Fr */
                    274:        { termp_ud_pre, NULL }, /* Ud */
1.2       kristaps  275: };
                    276:
1.10      kristaps  277: const struct termact *termacts = __termacts;
                    278:
                    279:
                    280: static size_t
1.12      kristaps  281: arg_width(const struct mdoc_arg *arg)
1.10      kristaps  282: {
1.27      kristaps  283:        size_t           v;
                    284:        int              i, len;
1.12      kristaps  285:
                    286:        assert(*arg->value);
1.25      kristaps  287:        if (0 == strcmp(*arg->value, "indent"))
                    288:                return(INDENT);
                    289:        if (0 == strcmp(*arg->value, "indent-two"))
                    290:                return(INDENT * 2);
                    291:
1.27      kristaps  292:        len = (int)strlen(*arg->value);
1.25      kristaps  293:        assert(len > 0);
                    294:
                    295:        for (i = 0; i < len - 1; i++)
                    296:                if ( ! isdigit((int)(*arg->value)[i]))
                    297:                        break;
                    298:
                    299:        if (i == len - 1) {
                    300:                if ('n' == (*arg->value)[len - 1]) {
                    301:                        v = (size_t)atoi(*arg->value);
                    302:                        return(v);
                    303:                }
                    304:
                    305:        }
1.29    ! kristaps  306:        return(strlen(*arg->value) + 2);
1.12      kristaps  307: }
                    308:
                    309:
                    310: static size_t
                    311: arg_offset(const struct mdoc_arg *arg)
                    312: {
                    313:
                    314:        /* TODO */
                    315:        assert(*arg->value);
                    316:        if (0 == strcmp(*arg->value, "indent"))
1.10      kristaps  317:                return(INDENT);
1.12      kristaps  318:        if (0 == strcmp(*arg->value, "indent-two"))
1.10      kristaps  319:                return(INDENT * 2);
1.12      kristaps  320:        return(strlen(*arg->value));
1.10      kristaps  321: }
                    322:
1.3       kristaps  323:
1.10      kristaps  324: static int
                    325: arg_hasattr(int arg, size_t argc, const struct mdoc_arg *argv)
1.2       kristaps  326: {
                    327:
1.10      kristaps  328:        return(-1 != arg_getattr(arg, argc, argv));
                    329: }
                    330:
                    331:
                    332: static int
                    333: arg_getattr(int arg, size_t argc, const struct mdoc_arg *argv)
                    334: {
                    335:        int              i;
                    336:
                    337:        for (i = 0; i < (int)argc; i++)
                    338:                if (argv[i].arg == arg)
                    339:                        return(i);
                    340:        return(-1);
                    341: }
                    342:
                    343:
                    344: /* ARGSUSED */
                    345: static int
                    346: termp_dq_pre(DECL_ARGS)
                    347: {
                    348:
                    349:        if (MDOC_BODY != node->type)
                    350:                return(1);
                    351:
                    352:        word(p, "``");
                    353:        p->flags |= TERMP_NOSPACE;
                    354:        return(1);
                    355: }
                    356:
                    357:
                    358: /* ARGSUSED */
                    359: static void
                    360: termp_dq_post(DECL_ARGS)
                    361: {
                    362:
                    363:        if (MDOC_BODY != node->type)
                    364:                return;
1.3       kristaps  365:
1.10      kristaps  366:        p->flags |= TERMP_NOSPACE;
                    367:        word(p, "''");
                    368: }
1.2       kristaps  369:
1.3       kristaps  370:
1.10      kristaps  371: /* ARGSUSED */
1.20      kristaps  372: static int
                    373: termp_it_pre(DECL_ARGS)
1.10      kristaps  374: {
                    375:        const struct mdoc_node *n, *it;
                    376:        const struct mdoc_block *bl;
1.23      kristaps  377:        char             buf[7], *tp;
                    378:        int              i, type;
1.12      kristaps  379:        size_t           width, offset;
1.2       kristaps  380:
1.10      kristaps  381:        switch (node->type) {
                    382:        case (MDOC_BODY):
                    383:                /* FALLTHROUGH */
                    384:        case (MDOC_HEAD):
1.20      kristaps  385:                it = node->parent;
                    386:                break;
                    387:        case (MDOC_BLOCK):
                    388:                it = node;
1.10      kristaps  389:                break;
                    390:        default:
1.20      kristaps  391:                return(1);
1.8       kristaps  392:        }
                    393:
1.21      kristaps  394:        n = it->parent->parent;
1.10      kristaps  395:        bl = &n->data.block;
                    396:
1.20      kristaps  397:        if (MDOC_BLOCK == node->type) {
1.29    ! kristaps  398:                newln(p);
        !           399:                if ( ! arg_hasattr(MDOC_Compact, bl->argc, bl->argv))
        !           400:                        if (node->prev || n->prev)
        !           401:                                vspace(p);
1.20      kristaps  402:                return(1);
                    403:        }
                    404:
1.23      kristaps  405:        /* Get our list type. */
                    406:
1.24      kristaps  407:        for (type = -1, i = 0; i < (int)bl->argc; i++)
1.23      kristaps  408:                switch (bl->argv[i].arg) {
                    409:                case (MDOC_Bullet):
                    410:                        /* FALLTHROUGH */
                    411:                case (MDOC_Dash):
                    412:                        /* FALLTHROUGH */
                    413:                case (MDOC_Enum):
                    414:                        /* FALLTHROUGH */
                    415:                case (MDOC_Hyphen):
                    416:                        /* FALLTHROUGH */
                    417:                case (MDOC_Tag):
                    418:                        /* FALLTHROUGH */
                    419:                case (MDOC_Ohang):
                    420:                        type = bl->argv[i].arg;
                    421:                        i = (int)bl->argc;
                    422:                        break;
1.24      kristaps  423:                default:
1.23      kristaps  424:                        errx(1, "list type not supported");
                    425:                        /* NOTREACHED */
                    426:                }
                    427:
1.24      kristaps  428:        assert(-1 != type);
                    429:
1.23      kristaps  430:        /* Save our existing (inherited) margin and offset. */
                    431:
1.20      kristaps  432:        pair->offset = p->offset;
                    433:        pair->rmargin = p->rmargin;
                    434:
1.23      kristaps  435:        /* Get list width and offset. */
                    436:
1.20      kristaps  437:        i = arg_getattr(MDOC_Width, bl->argc, bl->argv);
1.23      kristaps  438:        width = i >= 0 ? arg_width(&bl->argv[i]) : 0;
1.20      kristaps  439:
                    440:        i = arg_getattr(MDOC_Offset, bl->argc, bl->argv);
                    441:        offset = i >= 0 ? arg_offset(&bl->argv[i]) : 0;
                    442:
1.23      kristaps  443:        /* Override the width. */
1.10      kristaps  444:
1.23      kristaps  445:        switch (type) {
                    446:        case (MDOC_Bullet):
                    447:                /* FALLTHROUGH */
                    448:        case (MDOC_Dash):
                    449:                /* FALLTHROUGH */
                    450:        case (MDOC_Enum):
                    451:                /* FALLTHROUGH */
                    452:        case (MDOC_Hyphen):
                    453:                width = width > 6 ? width : 6;
                    454:                break;
                    455:        case (MDOC_Tag):
1.24      kristaps  456:                /* FIXME: auto-size. */
1.23      kristaps  457:                if (0 == width)
                    458:                        errx(1, "need non-zero -width");
                    459:                break;
                    460:        default:
                    461:                break;
                    462:        }
1.10      kristaps  463:
1.23      kristaps  464:        /* Word-wrap control. */
1.21      kristaps  465:
1.23      kristaps  466:        p->flags |= TERMP_NOSPACE;
1.21      kristaps  467:
1.23      kristaps  468:        switch (type) {
                    469:        case (MDOC_Bullet):
                    470:                /* FALLTHROUGH */
                    471:        case (MDOC_Dash):
                    472:                /* FALLTHROUGH */
                    473:        case (MDOC_Enum):
                    474:                /* FALLTHROUGH */
                    475:        case (MDOC_Hyphen):
                    476:                /* FALLTHROUGH */
                    477:        case (MDOC_Tag):
                    478:                if (MDOC_HEAD == node->type)
                    479:                        p->flags |= TERMP_NOBREAK;
                    480:                else if (MDOC_BODY == node->type)
                    481:                        p->flags |= TERMP_NOLPAD;
                    482:                break;
1.24      kristaps  483:        default:
1.23      kristaps  484:                break;
                    485:        }
1.21      kristaps  486:
1.23      kristaps  487:        /*
                    488:         * Get a token to use as the HEAD lead-in.  If NULL, we use the
                    489:         * HEAD child.
                    490:         */
1.21      kristaps  491:
1.23      kristaps  492:        tp = NULL;
1.24      kristaps  493:
1.23      kristaps  494:        if (MDOC_HEAD == node->type) {
                    495:                if (arg_hasattr(MDOC_Bullet, bl->argc, bl->argv))
                    496:                        tp = "\\[bu]";
                    497:                if (arg_hasattr(MDOC_Dash, bl->argc, bl->argv))
                    498:                        tp = "\\-";
                    499:                if (arg_hasattr(MDOC_Enum, bl->argc, bl->argv)) {
1.21      kristaps  500:                        (pair->ppair->ppair->count)++;
                    501:                        (void)snprintf(buf, sizeof(buf), "%d.",
                    502:                                        pair->ppair->ppair->count);
1.23      kristaps  503:                        tp = buf;
1.2       kristaps  504:                }
1.23      kristaps  505:                if (arg_hasattr(MDOC_Hyphen, bl->argc, bl->argv))
                    506:                        tp = "\\-";
                    507:        }
1.20      kristaps  508:
1.23      kristaps  509:        /* Margin control. */
1.2       kristaps  510:
1.21      kristaps  511:        p->offset += offset;
1.23      kristaps  512:
                    513:        switch (type) {
                    514:        case (MDOC_Bullet):
                    515:                /* FALLTHROUGH */
                    516:        case (MDOC_Dash):
                    517:                /* FALLTHROUGH */
                    518:        case (MDOC_Enum):
                    519:                /* FALLTHROUGH */
                    520:        case (MDOC_Hyphen):
                    521:                /* FALLTHROUGH */
                    522:        case (MDOC_Tag):
                    523:                if (MDOC_HEAD == node->type)
                    524:                        p->rmargin = p->offset + width;
                    525:                else if (MDOC_BODY == node->type)
                    526:                        p->offset += width;
                    527:                break;
1.24      kristaps  528:        default:
1.23      kristaps  529:                break;
                    530:        }
                    531:
                    532:        if (NULL == tp)
                    533:                return(1);
                    534:
                    535:        word(p, tp);
                    536:        return(0);
1.10      kristaps  537: }
                    538:
                    539:
                    540: /* ARGSUSED */
1.20      kristaps  541: static void
                    542: termp_it_post(DECL_ARGS)
1.10      kristaps  543: {
1.3       kristaps  544:
1.21      kristaps  545:        if (MDOC_BODY != node->type && MDOC_HEAD != node->type)
1.20      kristaps  546:                return;
1.10      kristaps  547:
1.23      kristaps  548:        flushln(p);
1.10      kristaps  549:
1.23      kristaps  550:        p->offset = pair->offset;
                    551:        p->rmargin = pair->rmargin;
1.21      kristaps  552:
1.23      kristaps  553:        if (MDOC_HEAD == node->type) {
                    554:                p->flags &= ~TERMP_NOBREAK;
                    555:                p->flags &= ~TERMP_NORPAD;
                    556:        } else if (MDOC_BODY == node->type)
                    557:                p->flags &= ~TERMP_NOLPAD;
1.2       kristaps  558: }
                    559:
                    560:
1.10      kristaps  561: /* ARGSUSED */
1.18      kristaps  562: static int
                    563: termp_nm_pre(DECL_ARGS)
1.10      kristaps  564: {
                    565:
1.29    ! kristaps  566:        if (SEC_SYNOPSIS == node->sec)
        !           567:                newln(p);
        !           568:
1.18      kristaps  569:        TERMPAIR_SETFLAG(pair, ttypes[TTYPE_PROG]);
                    570:        if (NULL == node->child)
                    571:                word(p, meta->name);
                    572:        return(1);
1.10      kristaps  573: }
                    574:
                    575:
                    576: /* ARGSUSED */
1.18      kristaps  577: static int
                    578: termp_fl_pre(DECL_ARGS)
1.10      kristaps  579: {
                    580:
1.18      kristaps  581:        TERMPAIR_SETFLAG(pair, ttypes[TTYPE_CMD_FLAG]);
                    582:        word(p, "\\-");
                    583:        p->flags |= TERMP_NOSPACE;
                    584:        return(1);
1.10      kristaps  585: }
                    586:
                    587:
                    588: /* ARGSUSED */
                    589: static int
                    590: termp_ar_pre(DECL_ARGS)
                    591: {
                    592:
1.29    ! kristaps  593:        if (node->child) {
        !           594:                TERMPAIR_SETFLAG(pair, ttypes[TTYPE_CMD_ARG]);
        !           595:                return(1);
        !           596:        }
        !           597:        p->flags |= ttypes[TTYPE_CMD_ARG];
        !           598:        word(p, "file");
        !           599:        word(p, "...");
        !           600:        p->flags &= ~ttypes[TTYPE_CMD_ARG];
1.10      kristaps  601:        return(1);
                    602: }
                    603:
                    604:
                    605: /* ARGSUSED */
                    606: static int
                    607: termp_ns_pre(DECL_ARGS)
1.2       kristaps  608: {
                    609:
                    610:        p->flags |= TERMP_NOSPACE;
1.10      kristaps  611:        return(1);
                    612: }
                    613:
                    614:
                    615: /* ARGSUSED */
                    616: static int
                    617: termp_pp_pre(DECL_ARGS)
                    618: {
                    619:
                    620:        vspace(p);
                    621:        return(1);
                    622: }
                    623:
                    624:
                    625: /* ARGSUSED */
                    626: static int
1.14      kristaps  627: termp_st_pre(DECL_ARGS)
                    628: {
                    629:        const char      *tp;
                    630:
                    631:        assert(1 == node->data.elem.argc);
                    632:
                    633:        tp = mdoc_st2a(node->data.elem.argv[0].arg);
                    634:        word(p, tp);
                    635:
                    636:        return(1);
                    637: }
                    638:
                    639:
                    640: /* ARGSUSED */
                    641: static int
1.28      kristaps  642: termp_rs_pre(DECL_ARGS)
                    643: {
                    644:
                    645:        if (MDOC_BLOCK == node->type)
                    646:                vspace(p);
                    647:        return(1);
                    648: }
                    649:
                    650:
                    651: /* ARGSUSED */
                    652: static int
1.14      kristaps  653: termp_rv_pre(DECL_ARGS)
                    654: {
                    655:        int              i;
                    656:
                    657:        i = arg_getattr(MDOC_Std, node->data.elem.argc,
                    658:                        node->data.elem.argv);
                    659:        assert(i >= 0);
                    660:
                    661:        newln(p);
                    662:        word(p, "The");
                    663:
                    664:        p->flags |= ttypes[TTYPE_FUNC_NAME];
                    665:        word(p, *node->data.elem.argv[i].value);
                    666:        p->flags &= ~ttypes[TTYPE_FUNC_NAME];
                    667:
                    668:                word(p, "() function returns the value 0 if successful;");
                    669:                word(p, "otherwise the value -1 is returned and the");
                    670:                word(p, "global variable");
                    671:
                    672:        p->flags |= ttypes[TTYPE_VAR_DECL];
                    673:        word(p, "errno");
                    674:        p->flags &= ~ttypes[TTYPE_VAR_DECL];
                    675:
                    676:                word(p, "is set to indicate the error.");
                    677:
                    678:        return(1);
                    679: }
                    680:
                    681:
                    682: /* ARGSUSED */
                    683: static int
1.10      kristaps  684: termp_ex_pre(DECL_ARGS)
                    685: {
                    686:        int              i;
                    687:
                    688:        i = arg_getattr(MDOC_Std, node->data.elem.argc,
                    689:                        node->data.elem.argv);
                    690:        assert(i >= 0);
                    691:
                    692:        word(p, "The");
                    693:        p->flags |= ttypes[TTYPE_PROG];
                    694:        word(p, *node->data.elem.argv[i].value);
                    695:        p->flags &= ~ttypes[TTYPE_PROG];
                    696:                word(p, "utility exits 0 on success, and >0 if an error occurs.");
                    697:
                    698:        return(1);
                    699: }
                    700:
                    701:
                    702: /* ARGSUSED */
                    703: static int
                    704: termp_nd_pre(DECL_ARGS)
                    705: {
                    706:
                    707:        word(p, "\\-");
                    708:        return(1);
                    709: }
                    710:
                    711:
                    712: /* ARGSUSED */
                    713: static void
                    714: termp_bl_post(DECL_ARGS)
                    715: {
                    716:
                    717:        if (MDOC_BLOCK == node->type)
                    718:                newln(p);
                    719: }
                    720:
                    721:
                    722: /* ARGSUSED */
                    723: static void
                    724: termp_op_post(DECL_ARGS)
                    725: {
                    726:
                    727:        if (MDOC_BODY != node->type)
1.2       kristaps  728:                return;
1.10      kristaps  729:        p->flags |= TERMP_NOSPACE;
                    730:        word(p, "\\(rB");
                    731: }
                    732:
                    733:
                    734: /* ARGSUSED */
                    735: static int
                    736: termp_xr_pre(DECL_ARGS)
                    737: {
                    738:        const struct mdoc_node *n;
                    739:
                    740:        n = node->child;
                    741:        assert(n);
                    742:
                    743:        assert(MDOC_TEXT == n->type);
                    744:        word(p, n->data.text.string);
                    745:
                    746:        if (NULL == (n = n->next))
                    747:                return(0);
                    748:
                    749:        assert(MDOC_TEXT == n->type);
                    750:        p->flags |= TERMP_NOSPACE;
                    751:        word(p, "(");
                    752:        p->flags |= TERMP_NOSPACE;
                    753:        word(p, n->data.text.string);
                    754:        p->flags |= TERMP_NOSPACE;
                    755:        word(p, ")");
                    756:
                    757:        return(0);
1.2       kristaps  758: }
                    759:
                    760:
1.10      kristaps  761: /* ARGSUSED */
                    762: static int
                    763: termp_vt_pre(DECL_ARGS)
1.2       kristaps  764: {
                    765:
1.10      kristaps  766:        /* FIXME: this can be "type name". */
1.18      kristaps  767:        TERMPAIR_SETFLAG(pair, ttypes[TTYPE_VAR_DECL]);
1.10      kristaps  768:        return(1);
1.2       kristaps  769: }
                    770:
                    771:
1.10      kristaps  772: /* ARGSUSED */
1.2       kristaps  773: static void
1.10      kristaps  774: termp_vt_post(DECL_ARGS)
                    775: {
                    776:
                    777:        if (node->sec == SEC_SYNOPSIS)
                    778:                vspace(p);
                    779: }
                    780:
                    781:
                    782: /* ARGSUSED */
                    783: static int
                    784: termp_fd_pre(DECL_ARGS)
1.2       kristaps  785: {
                    786:
1.10      kristaps  787:        /*
                    788:         * FIXME: this naming is bad.  This value is used, in general,
                    789:         * for the #include header or other preprocessor statement.
                    790:         */
1.18      kristaps  791:        TERMPAIR_SETFLAG(pair, ttypes[TTYPE_FUNC_DECL]);
1.10      kristaps  792:        return(1);
1.2       kristaps  793: }
                    794:
                    795:
1.10      kristaps  796: /* ARGSUSED */
1.2       kristaps  797: static void
1.10      kristaps  798: termp_fd_post(DECL_ARGS)
1.2       kristaps  799: {
                    800:
1.10      kristaps  801:        if (node->sec == SEC_SYNOPSIS)
                    802:                vspace(p);
                    803: }
                    804:
                    805:
                    806: /* ARGSUSED */
                    807: static int
                    808: termp_sh_pre(DECL_ARGS)
                    809: {
1.2       kristaps  810:
1.10      kristaps  811:        switch (node->type) {
                    812:        case (MDOC_HEAD):
                    813:                vspace(p);
1.18      kristaps  814:                TERMPAIR_SETFLAG(pair, ttypes[TTYPE_SECTION]);
1.2       kristaps  815:                break;
1.10      kristaps  816:        case (MDOC_BODY):
                    817:                p->offset = INDENT;
1.2       kristaps  818:                break;
1.10      kristaps  819:        default:
                    820:                break;
                    821:        }
                    822:        return(1);
                    823: }
                    824:
                    825:
                    826: /* ARGSUSED */
1.19      kristaps  827: static void
                    828: termp_sh_post(DECL_ARGS)
                    829: {
                    830:
                    831:        switch (node->type) {
                    832:        case (MDOC_HEAD):
                    833:                newln(p);
                    834:                break;
                    835:        case (MDOC_BODY):
                    836:                newln(p);
                    837:                p->offset = 0;
                    838:                break;
                    839:        default:
                    840:                break;
                    841:        }
                    842: }
                    843:
                    844:
                    845: /* ARGSUSED */
1.10      kristaps  846: static int
                    847: termp_op_pre(DECL_ARGS)
                    848: {
                    849:
                    850:        switch (node->type) {
                    851:        case (MDOC_BODY):
                    852:                word(p, "\\(lB");
                    853:                p->flags |= TERMP_NOSPACE;
1.2       kristaps  854:                break;
                    855:        default:
1.10      kristaps  856:                break;
1.2       kristaps  857:        }
1.10      kristaps  858:        return(1);
                    859: }
                    860:
                    861:
                    862: /* ARGSUSED */
                    863: static int
1.17      kristaps  864: termp_bt_pre(DECL_ARGS)
                    865: {
                    866:
                    867:        word(p, "is currently in beta test.");
                    868:        return(1);
                    869: }
                    870:
                    871:
                    872: /* ARGSUSED */
                    873: static int
1.10      kristaps  874: termp_ud_pre(DECL_ARGS)
                    875: {
                    876:
                    877:        word(p, "currently under development.");
                    878:        return(1);
                    879: }
                    880:
                    881:
                    882: /* ARGSUSED */
                    883: static int
                    884: termp_d1_pre(DECL_ARGS)
                    885: {
                    886:
                    887:        if (MDOC_BODY != node->type)
                    888:                return(1);
                    889:        newln(p);
1.19      kristaps  890:        p->offset += (pair->offset = INDENT);
1.10      kristaps  891:        return(1);
1.2       kristaps  892: }
                    893:
                    894:
1.10      kristaps  895: /* ARGSUSED */
1.2       kristaps  896: static void
1.10      kristaps  897: termp_d1_post(DECL_ARGS)
                    898: {
                    899:
                    900:        if (MDOC_BODY != node->type)
                    901:                return;
                    902:        newln(p);
1.19      kristaps  903:        p->offset -= pair->offset;
1.10      kristaps  904: }
                    905:
                    906:
                    907: /* ARGSUSED */
                    908: static int
                    909: termp_aq_pre(DECL_ARGS)
1.6       kristaps  910: {
                    911:
1.10      kristaps  912:        if (MDOC_BODY != node->type)
                    913:                return(1);
                    914:        word(p, "<");
                    915:        p->flags |= TERMP_NOSPACE;
                    916:        return(1);
                    917: }
1.6       kristaps  918:
                    919:
1.10      kristaps  920: /* ARGSUSED */
                    921: static void
                    922: termp_aq_post(DECL_ARGS)
                    923: {
1.6       kristaps  924:
1.10      kristaps  925:        if (MDOC_BODY != node->type)
1.6       kristaps  926:                return;
1.10      kristaps  927:        p->flags |= TERMP_NOSPACE;
                    928:        word(p, ">");
                    929: }
1.6       kristaps  930:
1.10      kristaps  931:
                    932: /* ARGSUSED */
                    933: static int
                    934: termp_ft_pre(DECL_ARGS)
                    935: {
                    936:
1.18      kristaps  937:        TERMPAIR_SETFLAG(pair, ttypes[TTYPE_FUNC_TYPE]);
1.10      kristaps  938:        return(1);
1.6       kristaps  939: }
                    940:
                    941:
1.10      kristaps  942: /* ARGSUSED */
1.6       kristaps  943: static void
1.10      kristaps  944: termp_ft_post(DECL_ARGS)
1.2       kristaps  945: {
                    946:
1.10      kristaps  947:        if (node->sec == SEC_SYNOPSIS)
                    948:                newln(p);
                    949: }
1.2       kristaps  950:
                    951:
1.10      kristaps  952: /* ARGSUSED */
                    953: static int
                    954: termp_fn_pre(DECL_ARGS)
                    955: {
                    956:        const struct mdoc_node *n;
                    957:
                    958:        assert(node->child);
                    959:        assert(MDOC_TEXT == node->child->type);
1.2       kristaps  960:
1.10      kristaps  961:        /* FIXME: can be "type funcname" "type varname"... */
1.2       kristaps  962:
1.10      kristaps  963:        p->flags |= ttypes[TTYPE_FUNC_NAME];
                    964:        word(p, node->child->data.text.string);
                    965:        p->flags &= ~ttypes[TTYPE_FUNC_NAME];
                    966:
                    967:        word(p, "(");
                    968:
                    969:        p->flags |= TERMP_NOSPACE;
                    970:        for (n = node->child->next; n; n = n->next) {
                    971:                assert(MDOC_TEXT == n->type);
                    972:                p->flags |= ttypes[TTYPE_FUNC_ARG];
                    973:                word(p, n->data.text.string);
                    974:                p->flags &= ~ttypes[TTYPE_FUNC_ARG];
1.16      kristaps  975:                if (n->next)
1.10      kristaps  976:                        word(p, ",");
1.6       kristaps  977:        }
1.2       kristaps  978:
1.10      kristaps  979:        word(p, ")");
                    980:
                    981:        if (SEC_SYNOPSIS == node->sec)
                    982:                word(p, ";");
                    983:
                    984:        return(0);
1.2       kristaps  985: }
                    986:
                    987:
1.10      kristaps  988: /* ARGSUSED */
                    989: static void
                    990: termp_fn_post(DECL_ARGS)
1.2       kristaps  991: {
                    992:
1.10      kristaps  993:        if (node->sec == SEC_SYNOPSIS)
                    994:                vspace(p);
                    995:
                    996: }
1.2       kristaps  997:
                    998:
1.10      kristaps  999: /* ARGSUSED */
                   1000: static int
                   1001: termp_sx_pre(DECL_ARGS)
                   1002: {
1.8       kristaps 1003:
1.18      kristaps 1004:        TERMPAIR_SETFLAG(pair, ttypes[TTYPE_LINK]);
1.10      kristaps 1005:        return(1);
1.2       kristaps 1006: }
                   1007:
                   1008:
1.10      kristaps 1009: /* ARGSUSED */
                   1010: static int
                   1011: termp_fa_pre(DECL_ARGS)
                   1012: {
1.16      kristaps 1013:        struct mdoc_node *n;
                   1014:
                   1015:        if (node->parent->tok != MDOC_Fo) {
1.18      kristaps 1016:                TERMPAIR_SETFLAG(pair, ttypes[TTYPE_FUNC_ARG]);
1.16      kristaps 1017:                return(1);
                   1018:        }
                   1019:
                   1020:        for (n = node->child; n; n = n->next) {
                   1021:                assert(MDOC_TEXT == n->type);
                   1022:
                   1023:                p->flags |= ttypes[TTYPE_FUNC_ARG];
                   1024:                word(p, n->data.text.string);
                   1025:                p->flags &= ~ttypes[TTYPE_FUNC_ARG];
                   1026:
                   1027:                if (n->next)
                   1028:                        word(p, ",");
                   1029:        }
                   1030:
                   1031:        if (node->next && node->next->tok == MDOC_Fa)
                   1032:                word(p, ",");
1.2       kristaps 1033:
1.16      kristaps 1034:        return(0);
1.10      kristaps 1035: }
1.2       kristaps 1036:
                   1037:
1.10      kristaps 1038: /* ARGSUSED */
                   1039: static int
                   1040: termp_va_pre(DECL_ARGS)
                   1041: {
1.2       kristaps 1042:
1.18      kristaps 1043:        TERMPAIR_SETFLAG(pair, ttypes[TTYPE_VAR_DECL]);
1.10      kristaps 1044:        return(1);
1.2       kristaps 1045: }
                   1046:
                   1047:
1.10      kristaps 1048: /* ARGSUSED */
                   1049: static int
                   1050: termp_bd_pre(DECL_ARGS)
                   1051: {
                   1052:        const struct mdoc_block *bl;
                   1053:        const struct mdoc_node *n;
1.12      kristaps 1054:        int              i;
1.1       kristaps 1055:
1.10      kristaps 1056:        if (MDOC_BLOCK == node->type) {
                   1057:                vspace(p);
                   1058:                return(1);
                   1059:        } else if (MDOC_BODY != node->type)
                   1060:                return(1);
                   1061:
                   1062:        assert(MDOC_BLOCK == node->parent->type);
1.20      kristaps 1063:        pair->offset = p->offset;
1.10      kristaps 1064:
                   1065:        bl = &node->parent->data.block;
1.12      kristaps 1066:
1.20      kristaps 1067:
1.12      kristaps 1068:        i = arg_getattr(MDOC_Offset, bl->argc, bl->argv);
                   1069:        if (-1 != i) {
                   1070:                assert(1 == bl->argv[i].sz);
1.20      kristaps 1071:                p->offset += arg_offset(&bl->argv[i]);
1.12      kristaps 1072:        }
                   1073:
1.10      kristaps 1074:        if ( ! arg_hasattr(MDOC_Literal, bl->argc, bl->argv))
                   1075:                return(1);
                   1076:
                   1077:        p->flags |= TERMP_LITERAL;
                   1078:
                   1079:        for (n = node->child; n; n = n->next) {
                   1080:                assert(MDOC_TEXT == n->type); /* FIXME */
                   1081:                if ((*n->data.text.string)) {
                   1082:                        word(p, n->data.text.string);
                   1083:                        flushln(p);
                   1084:                } else
                   1085:                        vspace(p);
1.1       kristaps 1086:
1.10      kristaps 1087:        }
1.1       kristaps 1088:
1.10      kristaps 1089:        p->flags &= ~TERMP_LITERAL;
                   1090:        return(0);
                   1091: }
1.1       kristaps 1092:
                   1093:
1.10      kristaps 1094: /* ARGSUSED */
1.12      kristaps 1095: static void
                   1096: termp_bd_post(DECL_ARGS)
                   1097: {
                   1098:
1.20      kristaps 1099:        if (MDOC_BODY != node->type)
                   1100:                return;
                   1101:        newln(p);
                   1102:        p->offset = pair->offset;
1.12      kristaps 1103: }
                   1104:
                   1105:
                   1106: /* ARGSUSED */
1.10      kristaps 1107: static int
                   1108: termp_qq_pre(DECL_ARGS)
                   1109: {
1.1       kristaps 1110:
1.10      kristaps 1111:        if (MDOC_BODY != node->type)
                   1112:                return(1);
                   1113:        word(p, "\"");
                   1114:        p->flags |= TERMP_NOSPACE;
                   1115:        return(1);
1.1       kristaps 1116: }
                   1117:
                   1118:
1.10      kristaps 1119: /* ARGSUSED */
1.1       kristaps 1120: static void
1.10      kristaps 1121: termp_qq_post(DECL_ARGS)
1.1       kristaps 1122: {
                   1123:
1.10      kristaps 1124:        if (MDOC_BODY != node->type)
                   1125:                return;
                   1126:        p->flags |= TERMP_NOSPACE;
                   1127:        word(p, "\"");
                   1128: }
                   1129:
                   1130:
                   1131: /* ARGSUSED */
                   1132: static int
1.15      kristaps 1133: termp_bsx_pre(DECL_ARGS)
                   1134: {
                   1135:
                   1136:        word(p, "BSDI BSD/OS");
                   1137:        return(1);
                   1138: }
                   1139:
                   1140:
                   1141: /* ARGSUSED */
                   1142: static int
1.10      kristaps 1143: termp_bx_pre(DECL_ARGS)
                   1144: {
1.1       kristaps 1145:
1.10      kristaps 1146:        word(p, "BSD");
                   1147:        return(1);
                   1148: }
                   1149:
                   1150:
                   1151: /* ARGSUSED */
                   1152: static int
                   1153: termp_ox_pre(DECL_ARGS)
                   1154: {
                   1155:
                   1156:        word(p, "OpenBSD");
                   1157:        return(1);
                   1158: }
                   1159:
                   1160:
                   1161: /* ARGSUSED */
                   1162: static int
1.16      kristaps 1163: termp_ux_pre(DECL_ARGS)
                   1164: {
                   1165:
                   1166:        word(p, "UNIX");
                   1167:        return(1);
                   1168: }
                   1169:
                   1170:
                   1171: /* ARGSUSED */
                   1172: static int
                   1173: termp_fx_pre(DECL_ARGS)
                   1174: {
                   1175:
                   1176:        word(p, "FreeBSD");
                   1177:        return(1);
                   1178: }
                   1179:
                   1180:
                   1181: /* ARGSUSED */
                   1182: static int
1.10      kristaps 1183: termp_nx_pre(DECL_ARGS)
                   1184: {
                   1185:
                   1186:        word(p, "NetBSD");
                   1187:        return(1);
                   1188: }
                   1189:
                   1190:
                   1191: /* ARGSUSED */
                   1192: static int
                   1193: termp_sq_pre(DECL_ARGS)
                   1194: {
                   1195:
                   1196:        if (MDOC_BODY != node->type)
                   1197:                return(1);
1.28      kristaps 1198:        word(p, "`");
1.10      kristaps 1199:        p->flags |= TERMP_NOSPACE;
                   1200:        return(1);
                   1201: }
1.1       kristaps 1202:
                   1203:
1.10      kristaps 1204: /* ARGSUSED */
                   1205: static void
                   1206: termp_sq_post(DECL_ARGS)
                   1207: {
                   1208:
                   1209:        if (MDOC_BODY != node->type)
                   1210:                return;
                   1211:        p->flags |= TERMP_NOSPACE;
                   1212:        word(p, "\'");
                   1213: }
1.2       kristaps 1214:
                   1215:
1.10      kristaps 1216: /* ARGSUSED */
                   1217: static int
                   1218: termp_pf_pre(DECL_ARGS)
                   1219: {
1.1       kristaps 1220:
1.10      kristaps 1221:        p->flags |= TERMP_IGNDELIM;
                   1222:        return(1);
                   1223: }
1.1       kristaps 1224:
                   1225:
1.10      kristaps 1226: /* ARGSUSED */
                   1227: static void
                   1228: termp_pf_post(DECL_ARGS)
                   1229: {
1.1       kristaps 1230:
1.10      kristaps 1231:        p->flags &= ~TERMP_IGNDELIM;
                   1232:        p->flags |= TERMP_NOSPACE;
                   1233: }
1.1       kristaps 1234:
                   1235:
1.10      kristaps 1236: /* ARGSUSED */
                   1237: static int
                   1238: termp_ss_pre(DECL_ARGS)
                   1239: {
1.1       kristaps 1240:
1.10      kristaps 1241:        switch (node->type) {
                   1242:        case (MDOC_HEAD):
                   1243:                vspace(p);
1.18      kristaps 1244:                TERMPAIR_SETFLAG(pair, ttypes[TTYPE_SSECTION]);
1.10      kristaps 1245:                p->offset = INDENT / 2;
                   1246:                break;
                   1247:        default:
                   1248:                break;
                   1249:        }
1.1       kristaps 1250:
1.10      kristaps 1251:        return(1);
1.1       kristaps 1252: }
                   1253:
                   1254:
1.10      kristaps 1255: /* ARGSUSED */
                   1256: static void
                   1257: termp_ss_post(DECL_ARGS)
1.1       kristaps 1258: {
                   1259:
1.10      kristaps 1260:        switch (node->type) {
                   1261:        case (MDOC_HEAD):
                   1262:                newln(p);
                   1263:                p->offset = INDENT;
                   1264:                break;
                   1265:        default:
                   1266:                break;
                   1267:        }
                   1268: }
1.2       kristaps 1269:
                   1270:
1.10      kristaps 1271: /* ARGSUSED */
                   1272: static int
                   1273: termp_pa_pre(DECL_ARGS)
                   1274: {
1.2       kristaps 1275:
1.18      kristaps 1276:        TERMPAIR_SETFLAG(pair, ttypes[TTYPE_FILE]);
1.10      kristaps 1277:        return(1);
1.1       kristaps 1278: }
                   1279:
                   1280:
1.10      kristaps 1281: /* ARGSUSED */
1.11      kristaps 1282: static int
                   1283: termp_em_pre(DECL_ARGS)
                   1284: {
                   1285:
1.18      kristaps 1286:        TERMPAIR_SETFLAG(pair, ttypes[TTYPE_EMPH]);
1.11      kristaps 1287:        return(1);
                   1288: }
                   1289:
                   1290:
                   1291: /* ARGSUSED */
1.14      kristaps 1292: static int
                   1293: termp_cd_pre(DECL_ARGS)
                   1294: {
                   1295:
1.18      kristaps 1296:        TERMPAIR_SETFLAG(pair, ttypes[TTYPE_CONFIG]);
1.14      kristaps 1297:        return(1);
                   1298: }
                   1299:
                   1300:
                   1301: /* ARGSUSED */
                   1302: static int
                   1303: termp_cm_pre(DECL_ARGS)
                   1304: {
                   1305:
1.18      kristaps 1306:        TERMPAIR_SETFLAG(pair, ttypes[TTYPE_CMD_FLAG]);
1.14      kristaps 1307:        return(1);
                   1308: }
                   1309:
                   1310:
                   1311: /* ARGSUSED */
                   1312: static int
                   1313: termp_ic_pre(DECL_ARGS)
                   1314: {
                   1315:
1.18      kristaps 1316:        TERMPAIR_SETFLAG(pair, ttypes[TTYPE_CMD]);
1.14      kristaps 1317:        return(1);
                   1318: }
                   1319:
                   1320:
                   1321: /* ARGSUSED */
                   1322: static int
                   1323: termp_in_pre(DECL_ARGS)
                   1324: {
                   1325:
1.18      kristaps 1326:        TERMPAIR_SETFLAG(pair, ttypes[TTYPE_INCLUDE]);
1.14      kristaps 1327:        return(1);
                   1328: }
                   1329:
                   1330:
                   1331: /* ARGSUSED */
                   1332: static int
                   1333: termp_at_pre(DECL_ARGS)
                   1334: {
                   1335:        enum mdoc_att    c;
                   1336:
                   1337:        c = ATT_DEFAULT;
                   1338:        if (node->child) {
                   1339:                assert(MDOC_TEXT == node->child->type);
                   1340:                c = mdoc_atoatt(node->child->data.text.string);
                   1341:        }
                   1342:
                   1343:        word(p, mdoc_att2a(c));
                   1344:        return(0);
                   1345: }
1.15      kristaps 1346:
                   1347:
                   1348: /* ARGSUSED */
                   1349: static int
                   1350: termp_bq_pre(DECL_ARGS)
                   1351: {
                   1352:
                   1353:        if (MDOC_BODY != node->type)
                   1354:                return(1);
1.26      kristaps 1355:        word(p, "\\[");
1.15      kristaps 1356:        p->flags |= TERMP_NOSPACE;
                   1357:        return(1);
                   1358: }
                   1359:
                   1360:
                   1361: /* ARGSUSED */
                   1362: static void
                   1363: termp_bq_post(DECL_ARGS)
                   1364: {
                   1365:
                   1366:        if (MDOC_BODY != node->type)
                   1367:                return;
                   1368:        word(p, "]");
                   1369: }
                   1370:
                   1371:
                   1372: /* ARGSUSED */
                   1373: static int
                   1374: termp_pq_pre(DECL_ARGS)
                   1375: {
                   1376:
                   1377:        if (MDOC_BODY != node->type)
                   1378:                return(1);
1.26      kristaps 1379:        word(p, "\\&(");
1.15      kristaps 1380:        p->flags |= TERMP_NOSPACE;
                   1381:        return(1);
                   1382: }
                   1383:
                   1384:
                   1385: /* ARGSUSED */
                   1386: static void
                   1387: termp_pq_post(DECL_ARGS)
                   1388: {
                   1389:
                   1390:        if (MDOC_BODY != node->type)
                   1391:                return;
                   1392:        word(p, ")");
                   1393: }
                   1394:
                   1395:
1.16      kristaps 1396: /* ARGSUSED */
                   1397: static int
                   1398: termp_fo_pre(DECL_ARGS)
                   1399: {
                   1400:        const struct mdoc_node *n;
                   1401:
                   1402:        if (MDOC_BODY == node->type) {
                   1403:                word(p, "(");
                   1404:                p->flags |= TERMP_NOSPACE;
                   1405:                return(1);
                   1406:        } else if (MDOC_HEAD != node->type)
                   1407:                return(1);
                   1408:
1.17      kristaps 1409:        /* XXX - groff shows only first parameter */
                   1410:
1.16      kristaps 1411:        p->flags |= ttypes[TTYPE_FUNC_NAME];
                   1412:        for (n = node->child; n; n = n->next) {
                   1413:                assert(MDOC_TEXT == n->type);
                   1414:                word(p, n->data.text.string);
                   1415:        }
                   1416:        p->flags &= ~ttypes[TTYPE_FUNC_NAME];
                   1417:
                   1418:        return(0);
                   1419: }
                   1420:
                   1421:
                   1422: /* ARGSUSED */
                   1423: static void
                   1424: termp_fo_post(DECL_ARGS)
                   1425: {
                   1426:
                   1427:        if (MDOC_BODY != node->type)
                   1428:                return;
                   1429:        word(p, ")");
                   1430:        word(p, ";");
                   1431:        newln(p);
                   1432: }
                   1433:
                   1434:
1.17      kristaps 1435: /* ARGSUSED */
                   1436: static int
                   1437: termp_bf_pre(DECL_ARGS)
                   1438: {
                   1439:        const struct mdoc_node  *n;
                   1440:        const struct mdoc_block *b;
                   1441:
                   1442:        /* XXX - we skip over possible trailing HEAD tokens. */
                   1443:
                   1444:        if (MDOC_HEAD == node->type)
                   1445:                return(0);
                   1446:        else if (MDOC_BLOCK != node->type)
                   1447:                return(1);
                   1448:
                   1449:        b = &node->data.block;
                   1450:
                   1451:        if (NULL == (n = b->head->child)) {
                   1452:                if (arg_hasattr(MDOC_Emphasis, b->argc, b->argv))
1.18      kristaps 1453:                        TERMPAIR_SETFLAG(pair, ttypes[TTYPE_EMPH]);
1.17      kristaps 1454:                else if (arg_hasattr(MDOC_Symbolic, b->argc, b->argv))
1.18      kristaps 1455:                        TERMPAIR_SETFLAG(pair, ttypes[TTYPE_SYMB]);
1.17      kristaps 1456:
                   1457:                return(1);
                   1458:        }
                   1459:
                   1460:        assert(MDOC_TEXT == n->type);
                   1461:
                   1462:        if (0 == strcmp("Em", n->data.text.string))
1.18      kristaps 1463:                TERMPAIR_SETFLAG(pair, ttypes[TTYPE_EMPH]);
1.17      kristaps 1464:        else if (0 == strcmp("Sy", n->data.text.string))
1.18      kristaps 1465:                TERMPAIR_SETFLAG(pair, ttypes[TTYPE_EMPH]);
1.17      kristaps 1466:
                   1467:        return(1);
                   1468: }
                   1469:
                   1470:
                   1471: /* ARGSUSED */
                   1472: static int
                   1473: termp_sy_pre(DECL_ARGS)
                   1474: {
                   1475:
1.18      kristaps 1476:        TERMPAIR_SETFLAG(pair, ttypes[TTYPE_SYMB]);
1.17      kristaps 1477:        return(1);
                   1478: }
                   1479:
                   1480:
                   1481: /* ARGSUSED */
                   1482: static int
                   1483: termp_ms_pre(DECL_ARGS)
                   1484: {
                   1485:
1.18      kristaps 1486:        TERMPAIR_SETFLAG(pair, ttypes[TTYPE_SYMBOL]);
1.17      kristaps 1487:        return(1);
                   1488: }
                   1489:
1.22      kristaps 1490:
                   1491:
                   1492: /* ARGSUSED */
                   1493: static int
                   1494: termp_sm_pre(DECL_ARGS)
                   1495: {
                   1496:
                   1497: #if notyet
                   1498:        assert(node->child);
                   1499:        if (0 == strcmp("off", node->child->data.text.string)) {
                   1500:                p->flags &= ~TERMP_NONOSPACE;
                   1501:                p->flags &= ~TERMP_NOSPACE;
                   1502:        } else {
                   1503:                p->flags |= TERMP_NONOSPACE;
                   1504:                p->flags |= TERMP_NOSPACE;
                   1505:        }
                   1506: #endif
                   1507:
                   1508:        return(0);
                   1509: }
1.28      kristaps 1510:
                   1511:
                   1512: /* ARGSUSED */
                   1513: static int
                   1514: termp__t_pre(DECL_ARGS)
                   1515: {
                   1516:
                   1517:        word(p, "\"");
                   1518:        p->flags |= TERMP_NOSPACE;
                   1519:        return(1);
                   1520: }
                   1521:
                   1522:
                   1523: /* ARGSUSED */
                   1524: static void
                   1525: termp__t_post(DECL_ARGS)
                   1526: {
                   1527:
                   1528:        p->flags |= TERMP_NOSPACE;
                   1529:        word(p, "\"");
                   1530:        word(p, node->next ? "," : ".");
                   1531: }
                   1532:
                   1533:
                   1534: /* ARGSUSED */
                   1535: static void
                   1536: termp____post(DECL_ARGS)
                   1537: {
                   1538:
                   1539:        p->flags |= TERMP_NOSPACE;
                   1540:        word(p, node->next ? "," : ".");
                   1541: }

CVSweb