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

Annotation of src/usr.bin/mandoc/chars.c, Revision 1.22

1.22    ! schwarze    1: /*     $Id: chars.c,v 1.21 2011/07/08 16:59:50 schwarze Exp $ */
1.1       schwarze    2: /*
1.19      schwarze    3:  * Copyright (c) 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
1.16      schwarze    4:  * Copyright (c) 2011 Ingo Schwarze <schwarze@openbsd.org>
1.1       schwarze    5:  *
                      6:  * Permission to use, copy, modify, and distribute this software for any
                      7:  * purpose with or without fee is hereby granted, provided that the above
                      8:  * copyright notice and this permission notice appear in all copies.
                      9:  *
                     10:  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
                     11:  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
                     12:  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
                     13:  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
                     14:  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
                     15:  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
                     16:  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
                     17:  */
                     18: #include <assert.h>
1.19      schwarze   19: #include <ctype.h>
1.1       schwarze   20: #include <stdlib.h>
                     21: #include <string.h>
                     22:
1.7       schwarze   23: #include "mandoc.h"
1.19      schwarze   24: #include "libmandoc.h"
1.1       schwarze   25:
                     26: #define        PRINT_HI         126
                     27: #define        PRINT_LO         32
                     28:
                     29: struct ln {
                     30:        struct ln        *next;
                     31:        const char       *code;
                     32:        const char       *ascii;
1.9       schwarze   33:        int               unicode;
1.1       schwarze   34: };
                     35:
1.22    ! schwarze   36: #define        LINES_MAX         328
1.1       schwarze   37:
1.10      schwarze   38: #define CHAR(in, ch, code) \
1.19      schwarze   39:        { NULL, (in), (ch), (code) },
1.1       schwarze   40:
1.4       schwarze   41: #define        CHAR_TBL_START    static struct ln lines[LINES_MAX] = {
                     42: #define        CHAR_TBL_END      };
                     43:
1.1       schwarze   44: #include "chars.in"
                     45:
1.19      schwarze   46: struct mchars {
1.1       schwarze   47:        struct ln       **htab;
                     48: };
                     49:
1.19      schwarze   50: static const struct ln  *find(struct mchars *, const char *, size_t);
1.1       schwarze   51:
                     52: void
1.19      schwarze   53: mchars_free(struct mchars *arg)
1.1       schwarze   54: {
                     55:
1.19      schwarze   56:        free(arg->htab);
                     57:        free(arg);
1.1       schwarze   58: }
                     59:
1.19      schwarze   60: struct mchars *
                     61: mchars_alloc(void)
1.1       schwarze   62: {
1.19      schwarze   63:        struct mchars    *tab;
1.1       schwarze   64:        struct ln       **htab;
                     65:        struct ln        *pp;
                     66:        int               i, hash;
                     67:
                     68:        /*
                     69:         * Constructs a very basic chaining hashtable.  The hash routine
                     70:         * is simply the integral value of the first character.
1.21      schwarze   71:         * Subsequent entries are chained in the order they're processed.
1.1       schwarze   72:         */
                     73:
1.19      schwarze   74:        tab = mandoc_malloc(sizeof(struct mchars));
1.17      schwarze   75:        htab = mandoc_calloc(PRINT_HI - PRINT_LO + 1, sizeof(struct ln **));
1.1       schwarze   76:
                     77:        for (i = 0; i < LINES_MAX; i++) {
                     78:                hash = (int)lines[i].code[0] - PRINT_LO;
                     79:
                     80:                if (NULL == (pp = htab[hash])) {
                     81:                        htab[hash] = &lines[i];
                     82:                        continue;
                     83:                }
                     84:
                     85:                for ( ; pp->next; pp = pp->next)
                     86:                        /* Scan ahead. */ ;
                     87:                pp->next = &lines[i];
                     88:        }
                     89:
                     90:        tab->htab = htab;
                     91:        return(tab);
                     92: }
                     93:
1.9       schwarze   94: int
1.19      schwarze   95: mchars_spec2cp(struct mchars *arg, const char *p, size_t sz)
1.9       schwarze   96: {
                     97:        const struct ln *ln;
                     98:
1.19      schwarze   99:        ln = find(arg, p, sz);
1.9       schwarze  100:        if (NULL == ln)
                    101:                return(-1);
                    102:        return(ln->unicode);
                    103: }
                    104:
1.19      schwarze  105: char
                    106: mchars_num2char(const char *p, size_t sz)
1.9       schwarze  107: {
1.19      schwarze  108:        int               i;
1.9       schwarze  109:
1.22    ! schwarze  110:        if ((i = mandoc_strntoi(p, sz, 10)) < 0)
1.19      schwarze  111:                return('\0');
1.20      schwarze  112:        return(i > 0 && i < 256 && isprint(i) ? i : '\0');
1.16      schwarze  113: }
                    114:
1.19      schwarze  115: int
                    116: mchars_num2uc(const char *p, size_t sz)
1.16      schwarze  117: {
1.19      schwarze  118:        int               i;
1.16      schwarze  119:
1.22    ! schwarze  120:        if ((i = mandoc_strntoi(p, sz, 16)) < 0)
1.19      schwarze  121:                return('\0');
                    122:        /* FIXME: make sure we're not in a bogus range. */
                    123:        return(i > 0x80 && i <= 0x10FFFF ? i : '\0');
1.9       schwarze  124: }
                    125:
1.1       schwarze  126: const char *
1.19      schwarze  127: mchars_spec2str(struct mchars *arg, const char *p, size_t sz, size_t *rsz)
1.1       schwarze  128: {
1.9       schwarze  129:        const struct ln *ln;
                    130:
1.19      schwarze  131:        ln = find(arg, p, sz);
1.20      schwarze  132:        if (NULL == ln) {
                    133:                *rsz = 1;
1.9       schwarze  134:                return(NULL);
1.20      schwarze  135:        }
1.1       schwarze  136:
1.10      schwarze  137:        *rsz = strlen(ln->ascii);
1.9       schwarze  138:        return(ln->ascii);
1.1       schwarze  139: }
                    140:
1.9       schwarze  141: static const struct ln *
1.19      schwarze  142: find(struct mchars *tab, const char *p, size_t sz)
1.1       schwarze  143: {
1.21      schwarze  144:        struct ln        *pp;
1.1       schwarze  145:        int               hash;
                    146:
                    147:        assert(p);
                    148:
1.21      schwarze  149:        if (0 == sz || p[0] < PRINT_LO || p[0] > PRINT_HI)
1.1       schwarze  150:                return(NULL);
                    151:
                    152:        hash = (int)p[0] - PRINT_LO;
                    153:
1.21      schwarze  154:        for (pp = tab->htab[hash]; pp; pp = pp->next)
                    155:                if (0 == strncmp(pp->code, p, sz) &&
                    156:                                '\0' == pp->code[(int)sz])
                    157:                        return(pp);
1.1       schwarze  158:
                    159:        return(NULL);
                    160: }