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

Annotation of mandoc/term.c, Revision 1.35

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

CVSweb