[BACK]Return to mdoc_strings.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / mandoc

Annotation of src/usr.bin/mandoc/mdoc_strings.c, Revision 1.4

1.4     ! schwarze    1: /*     $Id: mdoc_strings.c,v 1.3 2009/06/15 01:36:23 schwarze Exp $ */
1.1       kristaps    2: /*
                      3:  * Copyright (c) 2008 Kristaps Dzonsons <kristaps@kth.se>
                      4:  *
                      5:  * Permission to use, copy, modify, and distribute this software for any
1.2       schwarze    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.2       schwarze    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 <sys/types.h>
                     18:
                     19: #include <assert.h>
                     20: #include <ctype.h>
                     21: #include <stdlib.h>
                     22: #include <stdio.h>
                     23: #include <string.h>
                     24:
                     25: #include "libmdoc.h"
                     26:
                     27: /*
                     28:  * Various string-literal operations:  converting scalars to and from
                     29:  * strings, etc.
                     30:  */
                     31:
                     32: struct mdoc_secname {
                     33:        const char      *name;
                     34:        int              flag;
                     35: #define        MSECNAME_META   (1 << 0)
                     36: };
                     37:
                     38: /* Section names corresponding to mdoc_sec. */
                     39:
                     40: static const struct mdoc_secname secnames[] = {
                     41:        { "PROLOGUE", MSECNAME_META },
                     42:        { "BODY", MSECNAME_META },
                     43:        { "NAME", 0 },
                     44:        { "LIBRARY", 0 },
                     45:        { "SYNOPSIS", 0 },
                     46:        { "DESCRIPTION", 0 },
                     47:        { "IMPLEMENTATION NOTES", 0 },
                     48:        { "RETURN VALUES", 0 },
                     49:        { "ENVIRONMENT", 0 },
                     50:        { "FILES", 0 },
                     51:        { "EXAMPLES", 0 },
                     52:        { "DIAGNOSTICS", 0 },
                     53:        { "COMPATIBILITY", 0 },
                     54:        { "ERRORS", 0 },
                     55:        { "SEE ALSO", 0 },
                     56:        { "STANDARDS", 0 },
                     57:        { "HISTORY", 0 },
                     58:        { "AUTHORS", 0 },
                     59:        { "CAVEATS", 0 },
                     60:        { "BUGS", 0 },
                     61:        { NULL, 0 }
                     62: };
                     63:
                     64:
                     65: size_t
                     66: mdoc_isescape(const char *p)
                     67: {
                     68:        size_t           c;
                     69:
                     70:        if ('\\' != *p++)
                     71:                return(0);
                     72:
                     73:        switch (*p) {
                     74:        case ('\\'):
                     75:                /* FALLTHROUGH */
                     76:        case ('\''):
                     77:                /* FALLTHROUGH */
                     78:        case ('`'):
                     79:                /* FALLTHROUGH */
                     80:        case ('q'):
                     81:                /* FALLTHROUGH */
                     82:        case ('-'):
                     83:                /* FALLTHROUGH */
1.3       schwarze   84:        case ('~'):
                     85:                /* FALLTHROUGH */
                     86:        case ('^'):
                     87:                /* FALLTHROUGH */
1.1       kristaps   88:        case ('%'):
                     89:                /* FALLTHROUGH */
                     90:        case ('0'):
                     91:                /* FALLTHROUGH */
                     92:        case (' '):
                     93:                /* FALLTHROUGH */
                     94:        case ('|'):
                     95:                /* FALLTHROUGH */
                     96:        case ('&'):
                     97:                /* FALLTHROUGH */
                     98:        case ('.'):
                     99:                /* FALLTHROUGH */
                    100:        case (':'):
                    101:                /* FALLTHROUGH */
                    102:        case ('e'):
                    103:                return(2);
                    104:        case ('*'):
                    105:                if (0 == *++p || ! isgraph((u_char)*p))
                    106:                        return(0);
                    107:                switch (*p) {
                    108:                case ('('):
                    109:                        if (0 == *++p || ! isgraph((u_char)*p))
                    110:                                return(0);
                    111:                        return(4);
                    112:                case ('['):
                    113:                        for (c = 3, p++; *p && ']' != *p; p++, c++)
                    114:                                if ( ! isgraph((u_char)*p))
                    115:                                        break;
                    116:                        return(*p == ']' ? c : 0);
                    117:                default:
                    118:                        break;
                    119:                }
                    120:                return(3);
                    121:        case ('('):
                    122:                if (0 == *++p || ! isgraph((u_char)*p))
                    123:                        return(0);
                    124:                if (0 == *++p || ! isgraph((u_char)*p))
                    125:                        return(0);
                    126:                return(4);
                    127:        case ('['):
                    128:                break;
                    129:        default:
                    130:                return(0);
                    131:        }
                    132:
                    133:        for (c = 3, p++; *p && ']' != *p; p++, c++)
                    134:                if ( ! isgraph((u_char)*p))
                    135:                        break;
                    136:
                    137:        return(*p == ']' ? c : 0);
                    138: }
                    139:
                    140:
                    141: int
                    142: mdoc_iscdelim(char p)
                    143: {
                    144:
                    145:        switch (p) {
                    146:        case('.'):
                    147:                /* FALLTHROUGH */
                    148:        case(','):
                    149:                /* FALLTHROUGH */
                    150:        case(';'):
                    151:                /* FALLTHROUGH */
                    152:        case(':'):
                    153:                /* FALLTHROUGH */
                    154:        case('?'):
                    155:                /* FALLTHROUGH */
                    156:        case('!'):
                    157:                /* FALLTHROUGH */
                    158:        case('('):
                    159:                /* FALLTHROUGH */
                    160:        case(')'):
                    161:                /* FALLTHROUGH */
                    162:        case('['):
                    163:                /* FALLTHROUGH */
                    164:        case(']'):
                    165:                /* FALLTHROUGH */
                    166:        case('{'):
                    167:                /* FALLTHROUGH */
                    168:        case('}'):
                    169:                return(1);
                    170:        default:
                    171:                break;
                    172:        }
                    173:
                    174:        return(0);
                    175: }
                    176:
                    177:
                    178: int
                    179: mdoc_isdelim(const char *p)
                    180: {
                    181:
                    182:        if (0 == *p)
                    183:                return(0);
                    184:        if (0 != *(p + 1))
                    185:                return(0);
                    186:        return(mdoc_iscdelim(*p));
                    187: }
                    188:
                    189:
                    190: enum mdoc_sec
                    191: mdoc_atosec(const char *p)
                    192: {
                    193:        const struct mdoc_secname *n;
                    194:        int                        i;
                    195:
                    196:        for (i = 0, n = secnames; n->name; n++, i++)
                    197:                if ( ! (n->flag & MSECNAME_META))
                    198:                        if (0 == strcmp(p, n->name))
                    199:                                return((enum mdoc_sec)i);
                    200:
                    201:        return(SEC_CUSTOM);
                    202: }
                    203:
                    204:
                    205: time_t
                    206: mdoc_atotime(const char *p)
                    207: {
                    208:        struct tm        tm;
                    209:        char            *pp;
                    210:
                    211:        (void)memset(&tm, 0, sizeof(struct tm));
                    212:
1.4     ! schwarze  213:        if (0 == strcmp(p, "$" "Mdocdate$"))
1.1       kristaps  214:                return(time(NULL));
1.4     ! schwarze  215:        if ((pp = strptime(p, "$" "Mdocdate: %b %d %Y $", &tm)) && 0 == *pp)
1.1       kristaps  216:                return(mktime(&tm));
                    217:        /* XXX - this matches "June 1999", which is wrong. */
                    218:        if ((pp = strptime(p, "%b %d %Y", &tm)) && 0 == *pp)
                    219:                return(mktime(&tm));
                    220:        if ((pp = strptime(p, "%b %d, %Y", &tm)) && 0 == *pp)
                    221:                return(mktime(&tm));
                    222:
                    223:        return(0);
                    224: }
                    225:
                    226:
                    227: size_t
                    228: mdoc_macro2len(int macro)
                    229: {
                    230:
                    231:        switch (macro) {
                    232:        case(MDOC_Ad):
                    233:                return(12);
                    234:        case(MDOC_Ao):
                    235:                return(12);
                    236:        case(MDOC_An):
                    237:                return(12);
                    238:        case(MDOC_Aq):
                    239:                return(12);
                    240:        case(MDOC_Ar):
                    241:                return(12);
                    242:        case(MDOC_Bo):
                    243:                return(12);
                    244:        case(MDOC_Bq):
                    245:                return(12);
                    246:        case(MDOC_Cd):
                    247:                return(12);
                    248:        case(MDOC_Cm):
                    249:                return(10);
                    250:        case(MDOC_Do):
                    251:                return(10);
                    252:        case(MDOC_Dq):
                    253:                return(12);
                    254:        case(MDOC_Dv):
                    255:                return(12);
                    256:        case(MDOC_Eo):
                    257:                return(12);
                    258:        case(MDOC_Em):
                    259:                return(10);
                    260:        case(MDOC_Er):
                    261:                return(12);
                    262:        case(MDOC_Ev):
                    263:                return(15);
                    264:        case(MDOC_Fa):
                    265:                return(12);
                    266:        case(MDOC_Fl):
                    267:                return(10);
                    268:        case(MDOC_Fo):
                    269:                return(16);
                    270:        case(MDOC_Fn):
                    271:                return(16);
                    272:        case(MDOC_Ic):
                    273:                return(10);
                    274:        case(MDOC_Li):
                    275:                return(16);
                    276:        case(MDOC_Ms):
                    277:                return(6);
                    278:        case(MDOC_Nm):
                    279:                return(10);
                    280:        case(MDOC_No):
                    281:                return(12);
                    282:        case(MDOC_Oo):
                    283:                return(10);
                    284:        case(MDOC_Op):
                    285:                return(14);
                    286:        case(MDOC_Pa):
                    287:                return(32);
                    288:        case(MDOC_Pf):
                    289:                return(12);
                    290:        case(MDOC_Po):
                    291:                return(12);
                    292:        case(MDOC_Pq):
                    293:                return(12);
                    294:        case(MDOC_Ql):
                    295:                return(16);
                    296:        case(MDOC_Qo):
                    297:                return(12);
                    298:        case(MDOC_So):
                    299:                return(12);
                    300:        case(MDOC_Sq):
                    301:                return(12);
                    302:        case(MDOC_Sy):
                    303:                return(6);
                    304:        case(MDOC_Sx):
                    305:                return(16);
                    306:        case(MDOC_Tn):
                    307:                return(10);
                    308:        case(MDOC_Va):
                    309:                return(12);
                    310:        case(MDOC_Vt):
                    311:                return(12);
                    312:        case(MDOC_Xr):
                    313:                return(10);
                    314:        default:
                    315:                break;
                    316:        };
                    317:        return(0);
                    318: }