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

Annotation of mandoc/man_term.c, Revision 1.11

1.11    ! kristaps    1: /*     $Id: man_term.c,v 1.10 2009/06/11 07:26:35 kristaps Exp $ */
1.1       kristaps    2: /*
1.9       kristaps    3:  * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>
1.1       kristaps    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;
1.11    ! kristaps  295:        /* FIXME */
        !           296:        if ((p->offset += offs) > p->rmargin)
        !           297:                errx(1, "line too long");
1.4       kristaps  298:        return(0);
                    299: }
                    300:
                    301:
                    302: /* ARGSUSED */
                    303: static int
1.1       kristaps  304: pre_TP(DECL_ARGS)
                    305: {
                    306:        const struct man_node *nn;
                    307:        size_t           offs;
                    308:
                    309:        term_vspace(p);
                    310:        p->offset = INDENT;
                    311:
                    312:        if (NULL == (nn = n->child))
                    313:                return(1);
                    314:
                    315:        if (nn->line == n->line) {
                    316:                if (MAN_TEXT != nn->type)
                    317:                        errx(1, "expected text line argument");
1.3       kristaps  318:                offs = (size_t)atoi(nn->string);
1.1       kristaps  319:                nn = nn->next;
                    320:        } else
                    321:                offs = INDENT;
                    322:
                    323:        for ( ; nn; nn = nn->next)
                    324:                print_node(p, nn, m);
                    325:
                    326:        term_flushln(p);
                    327:        p->flags |= TERMP_NOSPACE;
                    328:        p->offset += offs;
                    329:        return(0);
                    330: }
                    331:
                    332:
1.3       kristaps  333: /* ARGSUSED */
1.1       kristaps  334: static int
                    335: pre_SS(DECL_ARGS)
                    336: {
                    337:
                    338:        term_vspace(p);
                    339:        p->flags |= TERMP_BOLD;
                    340:        return(1);
                    341: }
                    342:
                    343:
1.3       kristaps  344: /* ARGSUSED */
1.1       kristaps  345: static void
                    346: post_SS(DECL_ARGS)
                    347: {
                    348:
                    349:        term_flushln(p);
                    350:        p->flags &= ~TERMP_BOLD;
                    351:        p->flags |= TERMP_NOSPACE;
                    352: }
                    353:
                    354:
1.3       kristaps  355: /* ARGSUSED */
1.1       kristaps  356: static int
                    357: pre_SH(DECL_ARGS)
                    358: {
                    359:
                    360:        term_vspace(p);
                    361:        p->offset = 0;
                    362:        p->flags |= TERMP_BOLD;
                    363:        return(1);
                    364: }
                    365:
                    366:
1.3       kristaps  367: /* ARGSUSED */
1.1       kristaps  368: static void
                    369: post_SH(DECL_ARGS)
                    370: {
                    371:
                    372:        term_flushln(p);
                    373:        p->offset = INDENT;
                    374:        p->flags &= ~TERMP_BOLD;
                    375:        p->flags |= TERMP_NOSPACE;
                    376: }
                    377:
                    378:
                    379: static void
                    380: print_node(DECL_ARGS)
                    381: {
1.4       kristaps  382:        int              c, sz;
1.1       kristaps  383:
                    384:        c = 1;
                    385:
                    386:        switch (n->type) {
                    387:        case(MAN_ELEM):
                    388:                if (termacts[n->tok].pre)
                    389:                        c = (*termacts[n->tok].pre)(p, n, m);
                    390:                break;
                    391:        case(MAN_TEXT):
1.4       kristaps  392:                if (0 == *n->string) {
                    393:                        term_vspace(p);
1.1       kristaps  394:                        break;
                    395:                }
1.4       kristaps  396:                /*
                    397:                 * Note!  This is hacky.  Here, we recognise the `\c'
                    398:                 * escape embedded in so many -man pages.  It's supposed
                    399:                 * to remove the subsequent space, so we mark NOSPACE if
                    400:                 * it's encountered in the string.
                    401:                 */
                    402:                sz = (int)strlen(n->string);
                    403:                term_word(p, n->string);
                    404:                if (sz >= 2 && n->string[sz - 1] == 'c' &&
                    405:                                n->string[sz - 2] == '\\')
                    406:                        p->flags |= TERMP_NOSPACE;
1.1       kristaps  407:                break;
                    408:        default:
                    409:                break;
                    410:        }
                    411:
                    412:        if (c && n->child)
                    413:                print_body(p, n->child, m);
                    414:
                    415:        switch (n->type) {
                    416:        case (MAN_ELEM):
                    417:                if (termacts[n->tok].post)
                    418:                        (*termacts[n->tok].post)(p, n, m);
                    419:                break;
                    420:        default:
                    421:                break;
                    422:        }
                    423: }
                    424:
                    425:
                    426: static void
                    427: print_body(DECL_ARGS)
                    428: {
                    429:        print_node(p, n, m);
                    430:        if ( ! n->next)
                    431:                return;
                    432:        print_body(p, n->next, m);
                    433: }
                    434:
                    435:
                    436: static void
                    437: print_foot(struct termp *p, const struct man_meta *meta)
                    438: {
                    439:        struct tm       *tm;
                    440:        char            *buf;
                    441:
                    442:        if (NULL == (buf = malloc(p->rmargin)))
                    443:                err(1, "malloc");
                    444:
                    445:        tm = localtime(&meta->date);
                    446:
                    447: #ifdef __OpenBSD__
                    448:        if (NULL == strftime(buf, p->rmargin, "%B %d, %Y", tm))
                    449: #else
                    450:        if (0 == strftime(buf, p->rmargin, "%B %d, %Y", tm))
                    451: #endif
                    452:                err(1, "strftime");
                    453:
                    454:        term_vspace(p);
                    455:
                    456:        p->flags |= TERMP_NOSPACE | TERMP_NOBREAK;
                    457:        p->rmargin = p->maxrmargin - strlen(buf);
                    458:        p->offset = 0;
                    459:
                    460:        if (meta->source)
                    461:                term_word(p, meta->source);
                    462:        if (meta->source)
                    463:                term_word(p, "");
                    464:        term_flushln(p);
                    465:
                    466:        p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
                    467:        p->offset = p->rmargin;
                    468:        p->rmargin = p->maxrmargin;
                    469:        p->flags &= ~TERMP_NOBREAK;
                    470:
                    471:        term_word(p, buf);
                    472:        term_flushln(p);
                    473:
                    474:        free(buf);
                    475: }
                    476:
                    477:
                    478: static void
                    479: print_head(struct termp *p, const struct man_meta *meta)
                    480: {
                    481:        char            *buf, *title;
                    482:
                    483:        p->rmargin = p->maxrmargin;
                    484:        p->offset = 0;
                    485:
                    486:        if (NULL == (buf = malloc(p->rmargin)))
                    487:                err(1, "malloc");
                    488:        if (NULL == (title = malloc(p->rmargin)))
                    489:                err(1, "malloc");
                    490:
                    491:        if (meta->vol)
                    492:                (void)strlcpy(buf, meta->vol, p->rmargin);
                    493:        else
                    494:                *buf = 0;
                    495:
                    496:        (void)snprintf(title, p->rmargin, "%s(%d)",
                    497:                        meta->title, meta->msec);
                    498:
                    499:        p->offset = 0;
1.10      kristaps  500:        p->rmargin = (p->maxrmargin - strlen(buf) + 1) / 2;
1.1       kristaps  501:        p->flags |= TERMP_NOBREAK | TERMP_NOSPACE;
                    502:
                    503:        term_word(p, title);
                    504:        term_flushln(p);
                    505:
                    506:        p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
                    507:        p->offset = p->rmargin;
                    508:        p->rmargin = p->maxrmargin - strlen(title);
                    509:
                    510:        term_word(p, buf);
                    511:        term_flushln(p);
                    512:
                    513:        p->offset = p->rmargin;
                    514:        p->rmargin = p->maxrmargin;
                    515:        p->flags &= ~TERMP_NOBREAK;
                    516:        p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
                    517:
                    518:        term_word(p, title);
                    519:        term_flushln(p);
                    520:
                    521:        p->rmargin = p->maxrmargin;
                    522:        p->offset = 0;
                    523:        p->flags &= ~TERMP_NOSPACE;
                    524:
                    525:        free(title);
                    526:        free(buf);
                    527: }
                    528:

CVSweb