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

Annotation of mandoc/man_term.c, Revision 1.8

1.8     ! kristaps    1: /*     $Id: man_term.c,v 1.7 2009/04/05 16:34:22 kristaps Exp $ */
1.1       kristaps    2: /*
                      3:  * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@openbsd.org>
                      4:  *
                      5:  * Permission to use, copy, modify, and distribute this software for any
1.8     ! kristaps    6:  * purpose with or without fee is hereby granted, provided that the above
        !             7:  * copyright notice and this permission notice appear in all copies.
1.1       kristaps    8:  *
1.8     ! kristaps    9:  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
        !            10:  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
        !            11:  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
        !            12:  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
        !            13:  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
        !            14:  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
        !            15:  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
1.1       kristaps   16:  */
                     17: #include <assert.h>
                     18: #include <err.h>
                     19: #include <stdio.h>
                     20: #include <stdlib.h>
                     21: #include <string.h>
                     22:
                     23: #include "term.h"
                     24: #include "man.h"
                     25:
1.2       kristaps   26: #ifdef __linux__
                     27: extern size_t            strlcpy(char *, const char *, size_t);
                     28: extern size_t            strlcat(char *, const char *, size_t);
                     29: #endif
                     30:
1.1       kristaps   31: #define        DECL_ARGS         struct termp *p, \
                     32:                          const struct man_node *n, \
                     33:                          const struct man_meta *m
                     34:
                     35: struct termact {
                     36:        int             (*pre)(DECL_ARGS);
                     37:        void            (*post)(DECL_ARGS);
                     38: };
                     39:
                     40: static int               pre_B(DECL_ARGS);
1.3       kristaps   41: static int               pre_BI(DECL_ARGS);
                     42: static int               pre_BR(DECL_ARGS);
1.1       kristaps   43: static int               pre_I(DECL_ARGS);
1.3       kristaps   44: static int               pre_IB(DECL_ARGS);
1.4       kristaps   45: static int               pre_IP(DECL_ARGS);
1.3       kristaps   46: static int               pre_IR(DECL_ARGS);
1.1       kristaps   47: static int               pre_PP(DECL_ARGS);
1.3       kristaps   48: static int               pre_RB(DECL_ARGS);
                     49: static int               pre_RI(DECL_ARGS);
1.1       kristaps   50: static int               pre_SH(DECL_ARGS);
                     51: static int               pre_SS(DECL_ARGS);
                     52: static int               pre_TP(DECL_ARGS);
                     53:
                     54: static void              post_B(DECL_ARGS);
                     55: static void              post_I(DECL_ARGS);
                     56: static void              post_SH(DECL_ARGS);
                     57: static void              post_SS(DECL_ARGS);
                     58:
                     59: static const struct termact termacts[MAN_MAX] = {
                     60:        { NULL, NULL }, /* __ */
                     61:        { NULL, NULL }, /* TH */
                     62:        { pre_SH, post_SH }, /* SH */
                     63:        { pre_SS, post_SS }, /* SS */
                     64:        { pre_TP, NULL }, /* TP */
                     65:        { pre_PP, NULL }, /* LP */
                     66:        { pre_PP, NULL }, /* PP */
                     67:        { pre_PP, NULL }, /* P */
1.4       kristaps   68:        { pre_IP, NULL }, /* IP */
                     69:        { pre_PP, NULL }, /* HP */ /* FIXME */
1.1       kristaps   70:        { NULL, NULL }, /* SM */
                     71:        { pre_B, post_B }, /* SB */
1.3       kristaps   72:        { pre_BI, NULL }, /* BI */
                     73:        { pre_IB, NULL }, /* IB */
                     74:        { pre_BR, NULL }, /* BR */
                     75:        { pre_RB, NULL }, /* RB */
1.1       kristaps   76:        { NULL, NULL }, /* R */
                     77:        { pre_B, post_B }, /* B */
                     78:        { pre_I, post_I }, /* I */
1.3       kristaps   79:        { pre_IR, NULL }, /* IR */
                     80:        { pre_RI, NULL }, /* RI */
1.5       kristaps   81:        { pre_PP, NULL }, /* br */
1.6       kristaps   82:        { NULL, NULL }, /* na */
1.7       kristaps   83:        { pre_I, post_I }, /* i */
1.1       kristaps   84: };
                     85:
                     86: static void              print_head(struct termp *,
                     87:                                const struct man_meta *);
                     88: static void              print_body(DECL_ARGS);
                     89: static void              print_node(DECL_ARGS);
                     90: static void              print_foot(struct termp *,
                     91:                                const struct man_meta *);
                     92:
                     93:
                     94: int
                     95: man_run(struct termp *p, const struct man *m)
                     96: {
                     97:
                     98:        print_head(p, man_meta(m));
                     99:        p->flags |= TERMP_NOSPACE;
                    100:        print_body(p, man_node(m), man_meta(m));
                    101:        print_foot(p, man_meta(m));
                    102:
                    103:        return(1);
                    104: }
                    105:
                    106:
1.3       kristaps  107: /* ARGSUSED */
1.1       kristaps  108: static int
                    109: pre_I(DECL_ARGS)
                    110: {
                    111:
                    112:        p->flags |= TERMP_UNDER;
                    113:        return(1);
                    114: }
                    115:
                    116:
1.3       kristaps  117: /* ARGSUSED */
1.1       kristaps  118: static void
                    119: post_I(DECL_ARGS)
                    120: {
                    121:
                    122:        p->flags &= ~TERMP_UNDER;
                    123: }
                    124:
                    125:
1.3       kristaps  126: /* ARGSUSED */
                    127: static int
                    128: pre_IR(DECL_ARGS)
                    129: {
                    130:        const struct man_node *nn;
                    131:        int              i;
                    132:
                    133:        for (i = 0, nn = n->child; nn; nn = nn->next, i++) {
                    134:                if ( ! (i % 2))
                    135:                        p->flags |= TERMP_UNDER;
1.4       kristaps  136:                if (i > 0)
                    137:                        p->flags |= TERMP_NOSPACE;
1.3       kristaps  138:                print_node(p, nn, m);
                    139:                if ( ! (i % 2))
                    140:                        p->flags &= ~TERMP_UNDER;
                    141:        }
                    142:        return(0);
                    143: }
                    144:
                    145:
                    146: /* ARGSUSED */
                    147: static int
                    148: pre_IB(DECL_ARGS)
                    149: {
                    150:        const struct man_node *nn;
                    151:        int              i;
                    152:
                    153:        for (i = 0, nn = n->child; nn; nn = nn->next, i++) {
                    154:                p->flags |= i % 2 ? TERMP_BOLD : TERMP_UNDER;
1.4       kristaps  155:                if (i > 0)
                    156:                        p->flags |= TERMP_NOSPACE;
1.3       kristaps  157:                print_node(p, nn, m);
                    158:                p->flags &= i % 2 ? ~TERMP_BOLD : ~TERMP_UNDER;
                    159:        }
                    160:        return(0);
                    161: }
                    162:
                    163:
                    164: /* ARGSUSED */
                    165: static int
                    166: pre_RB(DECL_ARGS)
                    167: {
                    168:        const struct man_node *nn;
                    169:        int              i;
                    170:
                    171:        for (i = 0, nn = n->child; nn; nn = nn->next, i++) {
                    172:                if (i % 2)
                    173:                        p->flags |= TERMP_BOLD;
1.4       kristaps  174:                if (i > 0)
                    175:                        p->flags |= TERMP_NOSPACE;
1.3       kristaps  176:                print_node(p, nn, m);
                    177:                if (i % 2)
                    178:                        p->flags &= ~TERMP_BOLD;
                    179:        }
                    180:        return(0);
                    181: }
                    182:
                    183:
                    184: /* ARGSUSED */
                    185: static int
                    186: pre_RI(DECL_ARGS)
                    187: {
                    188:        const struct man_node *nn;
                    189:        int              i;
                    190:
                    191:        for (i = 0, nn = n->child; nn; nn = nn->next, i++) {
                    192:                if ( ! (i % 2))
                    193:                        p->flags |= TERMP_UNDER;
1.4       kristaps  194:                if (i > 0)
                    195:                        p->flags |= TERMP_NOSPACE;
1.3       kristaps  196:                print_node(p, nn, m);
                    197:                if ( ! (i % 2))
                    198:                        p->flags &= ~TERMP_UNDER;
                    199:        }
                    200:        return(0);
                    201: }
                    202:
                    203:
                    204: /* ARGSUSED */
                    205: static int
                    206: pre_BR(DECL_ARGS)
                    207: {
                    208:        const struct man_node *nn;
                    209:        int              i;
                    210:
                    211:        for (i = 0, nn = n->child; nn; nn = nn->next, i++) {
                    212:                if ( ! (i % 2))
                    213:                        p->flags |= TERMP_BOLD;
1.4       kristaps  214:                if (i > 0)
                    215:                        p->flags |= TERMP_NOSPACE;
1.3       kristaps  216:                print_node(p, nn, m);
                    217:                if ( ! (i % 2))
                    218:                        p->flags &= ~TERMP_BOLD;
                    219:        }
                    220:        return(0);
                    221: }
                    222:
                    223:
                    224: /* ARGSUSED */
                    225: static int
                    226: pre_BI(DECL_ARGS)
                    227: {
                    228:        const struct man_node *nn;
                    229:        int              i;
                    230:
                    231:        for (i = 0, nn = n->child; nn; nn = nn->next, i++) {
                    232:                p->flags |= i % 2 ? TERMP_UNDER : TERMP_BOLD;
1.4       kristaps  233:                if (i > 0)
                    234:                        p->flags |= TERMP_NOSPACE;
1.3       kristaps  235:                print_node(p, nn, m);
                    236:                p->flags &= i % 2 ? ~TERMP_UNDER : ~TERMP_BOLD;
                    237:        }
                    238:        return(0);
                    239: }
                    240:
                    241:
                    242: /* ARGSUSED */
1.1       kristaps  243: static int
                    244: pre_B(DECL_ARGS)
                    245: {
                    246:
                    247:        p->flags |= TERMP_BOLD;
                    248:        return(1);
                    249: }
                    250:
                    251:
1.3       kristaps  252: /* ARGSUSED */
1.1       kristaps  253: static void
                    254: post_B(DECL_ARGS)
                    255: {
                    256:
                    257:        p->flags &= ~TERMP_BOLD;
                    258: }
                    259:
                    260:
1.3       kristaps  261: /* ARGSUSED */
1.1       kristaps  262: static int
                    263: pre_PP(DECL_ARGS)
                    264: {
                    265:
                    266:        term_vspace(p);
                    267:        p->offset = INDENT;
                    268:        return(0);
                    269: }
                    270:
                    271:
1.3       kristaps  272: /* ARGSUSED */
1.1       kristaps  273: static int
1.4       kristaps  274: pre_IP(DECL_ARGS)
                    275: {
                    276:        const struct man_node *nn;
                    277:        size_t           offs;
                    278:
                    279:        term_vspace(p);
                    280:        p->offset = INDENT;
                    281:
                    282:        if (NULL == (nn = n->child))
                    283:                return(1);
                    284:        if (MAN_TEXT != nn->type)
                    285:                errx(1, "expected text line argument");
                    286:
1.7       kristaps  287:        if (nn->next) {
                    288:                if (MAN_TEXT != nn->next->type)
                    289:                        errx(1, "expected text line argument");
                    290:                offs = (size_t)atoi(nn->next->string);
                    291:        } else
                    292:                offs = strlen(nn->string);
1.4       kristaps  293:
                    294:        p->flags |= TERMP_NOSPACE;
                    295:        p->offset += offs;
                    296:        return(0);
                    297: }
                    298:
                    299:
                    300: /* ARGSUSED */
                    301: static int
1.1       kristaps  302: pre_TP(DECL_ARGS)
                    303: {
                    304:        const struct man_node *nn;
                    305:        size_t           offs;
                    306:
                    307:        term_vspace(p);
                    308:        p->offset = INDENT;
                    309:
                    310:        if (NULL == (nn = n->child))
                    311:                return(1);
                    312:
                    313:        if (nn->line == n->line) {
                    314:                if (MAN_TEXT != nn->type)
                    315:                        errx(1, "expected text line argument");
1.3       kristaps  316:                offs = (size_t)atoi(nn->string);
1.1       kristaps  317:                nn = nn->next;
                    318:        } else
                    319:                offs = INDENT;
                    320:
                    321:        for ( ; nn; nn = nn->next)
                    322:                print_node(p, nn, m);
                    323:
                    324:        term_flushln(p);
                    325:        p->flags |= TERMP_NOSPACE;
                    326:        p->offset += offs;
                    327:        return(0);
                    328: }
                    329:
                    330:
1.3       kristaps  331: /* ARGSUSED */
1.1       kristaps  332: static int
                    333: pre_SS(DECL_ARGS)
                    334: {
                    335:
                    336:        term_vspace(p);
                    337:        p->flags |= TERMP_BOLD;
                    338:        return(1);
                    339: }
                    340:
                    341:
1.3       kristaps  342: /* ARGSUSED */
1.1       kristaps  343: static void
                    344: post_SS(DECL_ARGS)
                    345: {
                    346:
                    347:        term_flushln(p);
                    348:        p->flags &= ~TERMP_BOLD;
                    349:        p->flags |= TERMP_NOSPACE;
                    350: }
                    351:
                    352:
1.3       kristaps  353: /* ARGSUSED */
1.1       kristaps  354: static int
                    355: pre_SH(DECL_ARGS)
                    356: {
                    357:
                    358:        term_vspace(p);
                    359:        p->offset = 0;
                    360:        p->flags |= TERMP_BOLD;
                    361:        return(1);
                    362: }
                    363:
                    364:
1.3       kristaps  365: /* ARGSUSED */
1.1       kristaps  366: static void
                    367: post_SH(DECL_ARGS)
                    368: {
                    369:
                    370:        term_flushln(p);
                    371:        p->offset = INDENT;
                    372:        p->flags &= ~TERMP_BOLD;
                    373:        p->flags |= TERMP_NOSPACE;
                    374: }
                    375:
                    376:
                    377: static void
                    378: print_node(DECL_ARGS)
                    379: {
1.4       kristaps  380:        int              c, sz;
1.1       kristaps  381:
                    382:        c = 1;
                    383:
                    384:        switch (n->type) {
                    385:        case(MAN_ELEM):
                    386:                if (termacts[n->tok].pre)
                    387:                        c = (*termacts[n->tok].pre)(p, n, m);
                    388:                break;
                    389:        case(MAN_TEXT):
1.4       kristaps  390:                if (0 == *n->string) {
                    391:                        term_vspace(p);
1.1       kristaps  392:                        break;
                    393:                }
1.4       kristaps  394:                /*
                    395:                 * Note!  This is hacky.  Here, we recognise the `\c'
                    396:                 * escape embedded in so many -man pages.  It's supposed
                    397:                 * to remove the subsequent space, so we mark NOSPACE if
                    398:                 * it's encountered in the string.
                    399:                 */
                    400:                sz = (int)strlen(n->string);
                    401:                term_word(p, n->string);
                    402:                if (sz >= 2 && n->string[sz - 1] == 'c' &&
                    403:                                n->string[sz - 2] == '\\')
                    404:                        p->flags |= TERMP_NOSPACE;
1.1       kristaps  405:                break;
                    406:        default:
                    407:                break;
                    408:        }
                    409:
                    410:        if (c && n->child)
                    411:                print_body(p, n->child, m);
                    412:
                    413:        switch (n->type) {
                    414:        case (MAN_ELEM):
                    415:                if (termacts[n->tok].post)
                    416:                        (*termacts[n->tok].post)(p, n, m);
                    417:                break;
                    418:        default:
                    419:                break;
                    420:        }
                    421: }
                    422:
                    423:
                    424: static void
                    425: print_body(DECL_ARGS)
                    426: {
                    427:        print_node(p, n, m);
                    428:        if ( ! n->next)
                    429:                return;
                    430:        print_body(p, n->next, m);
                    431: }
                    432:
                    433:
                    434: static void
                    435: print_foot(struct termp *p, const struct man_meta *meta)
                    436: {
                    437:        struct tm       *tm;
                    438:        char            *buf;
                    439:
                    440:        if (NULL == (buf = malloc(p->rmargin)))
                    441:                err(1, "malloc");
                    442:
                    443:        tm = localtime(&meta->date);
                    444:
                    445: #ifdef __OpenBSD__
                    446:        if (NULL == strftime(buf, p->rmargin, "%B %d, %Y", tm))
                    447: #else
                    448:        if (0 == strftime(buf, p->rmargin, "%B %d, %Y", tm))
                    449: #endif
                    450:                err(1, "strftime");
                    451:
                    452:        term_vspace(p);
                    453:
                    454:        p->flags |= TERMP_NOSPACE | TERMP_NOBREAK;
                    455:        p->rmargin = p->maxrmargin - strlen(buf);
                    456:        p->offset = 0;
                    457:
                    458:        if (meta->source)
                    459:                term_word(p, meta->source);
                    460:        if (meta->source)
                    461:                term_word(p, "");
                    462:        term_flushln(p);
                    463:
                    464:        p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
                    465:        p->offset = p->rmargin;
                    466:        p->rmargin = p->maxrmargin;
                    467:        p->flags &= ~TERMP_NOBREAK;
                    468:
                    469:        term_word(p, buf);
                    470:        term_flushln(p);
                    471:
                    472:        free(buf);
                    473: }
                    474:
                    475:
                    476: static void
                    477: print_head(struct termp *p, const struct man_meta *meta)
                    478: {
                    479:        char            *buf, *title;
                    480:
                    481:        p->rmargin = p->maxrmargin;
                    482:        p->offset = 0;
                    483:
                    484:        if (NULL == (buf = malloc(p->rmargin)))
                    485:                err(1, "malloc");
                    486:        if (NULL == (title = malloc(p->rmargin)))
                    487:                err(1, "malloc");
                    488:
                    489:        if (meta->vol)
                    490:                (void)strlcpy(buf, meta->vol, p->rmargin);
                    491:        else
                    492:                *buf = 0;
                    493:
                    494:        (void)snprintf(title, p->rmargin, "%s(%d)",
                    495:                        meta->title, meta->msec);
                    496:
                    497:        p->offset = 0;
                    498:        p->rmargin = (p->maxrmargin - strlen(buf)) / 2;
                    499:        p->flags |= TERMP_NOBREAK | TERMP_NOSPACE;
                    500:
                    501:        term_word(p, title);
                    502:        term_flushln(p);
                    503:
                    504:        p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
                    505:        p->offset = p->rmargin;
                    506:        p->rmargin = p->maxrmargin - strlen(title);
                    507:
                    508:        term_word(p, buf);
                    509:        term_flushln(p);
                    510:
                    511:        p->offset = p->rmargin;
                    512:        p->rmargin = p->maxrmargin;
                    513:        p->flags &= ~TERMP_NOBREAK;
                    514:        p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
                    515:
                    516:        term_word(p, title);
                    517:        term_flushln(p);
                    518:
                    519:        p->rmargin = p->maxrmargin;
                    520:        p->offset = 0;
                    521:        p->flags &= ~TERMP_NOSPACE;
                    522:
                    523:        free(title);
                    524:        free(buf);
                    525: }
                    526:

CVSweb