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

Annotation of mandoc/term.c, Revision 1.42

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

CVSweb