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

Annotation of mandoc/term.c, Revision 1.22

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

CVSweb