[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.37

1.37    ! schwarze    1: /*     $OpenBSD: chars.c,v 1.36 2015/02/17 20:33:44 schwarze Exp $ */
1.1       schwarze    2: /*
1.19      schwarze    3:  * Copyright (c) 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
1.30      schwarze    4:  * Copyright (c) 2011, 2014 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:  */
1.31      schwarze   18: #include <sys/types.h>
                     19:
1.1       schwarze   20: #include <assert.h>
1.19      schwarze   21: #include <ctype.h>
1.1       schwarze   22: #include <stdlib.h>
                     23: #include <string.h>
                     24:
1.7       schwarze   25: #include "mandoc.h"
1.27      schwarze   26: #include "mandoc_aux.h"
1.19      schwarze   27: #include "libmandoc.h"
1.1       schwarze   28:
                     29: #define        PRINT_HI         126
                     30: #define        PRINT_LO         32
                     31:
                     32: struct ln {
                     33:        struct ln        *next;
                     34:        const char       *code;
                     35:        const char       *ascii;
1.9       schwarze   36:        int               unicode;
1.1       schwarze   37: };
                     38:
1.36      schwarze   39: #define        LINES_MAX         332
1.1       schwarze   40:
1.10      schwarze   41: #define CHAR(in, ch, code) \
1.19      schwarze   42:        { NULL, (in), (ch), (code) },
1.1       schwarze   43:
1.4       schwarze   44: #define        CHAR_TBL_START    static struct ln lines[LINES_MAX] = {
                     45: #define        CHAR_TBL_END      };
                     46:
1.1       schwarze   47: #include "chars.in"
                     48:
1.19      schwarze   49: struct mchars {
1.1       schwarze   50:        struct ln       **htab;
                     51: };
                     52:
1.28      schwarze   53: static const struct ln  *find(const struct mchars *,
1.23      schwarze   54:                                const char *, size_t);
1.1       schwarze   55:
1.28      schwarze   56:
1.1       schwarze   57: void
1.19      schwarze   58: mchars_free(struct mchars *arg)
1.1       schwarze   59: {
                     60:
1.19      schwarze   61:        free(arg->htab);
                     62:        free(arg);
1.1       schwarze   63: }
                     64:
1.19      schwarze   65: struct mchars *
                     66: mchars_alloc(void)
1.1       schwarze   67: {
1.19      schwarze   68:        struct mchars    *tab;
1.1       schwarze   69:        struct ln       **htab;
                     70:        struct ln        *pp;
                     71:        int               i, hash;
                     72:
                     73:        /*
                     74:         * Constructs a very basic chaining hashtable.  The hash routine
                     75:         * is simply the integral value of the first character.
1.21      schwarze   76:         * Subsequent entries are chained in the order they're processed.
1.1       schwarze   77:         */
                     78:
1.19      schwarze   79:        tab = mandoc_malloc(sizeof(struct mchars));
1.24      schwarze   80:        htab = mandoc_calloc(PRINT_HI - PRINT_LO + 1, sizeof(struct ln *));
1.1       schwarze   81:
                     82:        for (i = 0; i < LINES_MAX; i++) {
                     83:                hash = (int)lines[i].code[0] - PRINT_LO;
                     84:
                     85:                if (NULL == (pp = htab[hash])) {
                     86:                        htab[hash] = &lines[i];
                     87:                        continue;
                     88:                }
                     89:
                     90:                for ( ; pp->next; pp = pp->next)
                     91:                        /* Scan ahead. */ ;
                     92:                pp->next = &lines[i];
                     93:        }
                     94:
                     95:        tab->htab = htab;
1.37    ! schwarze   96:        return tab;
1.1       schwarze   97: }
                     98:
1.9       schwarze   99: int
1.23      schwarze  100: mchars_spec2cp(const struct mchars *arg, const char *p, size_t sz)
1.9       schwarze  101: {
                    102:        const struct ln *ln;
                    103:
1.19      schwarze  104:        ln = find(arg, p, sz);
1.37    ! schwarze  105:        return ln != NULL ? ln->unicode : sz == 1 ? (unsigned char)*p : -1;
1.9       schwarze  106: }
                    107:
1.35      schwarze  108: int
1.19      schwarze  109: mchars_num2char(const char *p, size_t sz)
1.9       schwarze  110: {
1.28      schwarze  111:        int       i;
1.9       schwarze  112:
1.35      schwarze  113:        i = mandoc_strntoi(p, sz, 10);
1.37    ! schwarze  114:        return i >= 0 && i < 256 ? i : -1;
1.16      schwarze  115: }
                    116:
1.19      schwarze  117: int
                    118: mchars_num2uc(const char *p, size_t sz)
1.16      schwarze  119: {
1.28      schwarze  120:        int      i;
1.16      schwarze  121:
1.33      schwarze  122:        i = mandoc_strntoi(p, sz, 16);
                    123:        assert(i >= 0 && i <= 0x10FFFF);
1.37    ! schwarze  124:        return i;
1.9       schwarze  125: }
                    126:
1.1       schwarze  127: const char *
1.28      schwarze  128: mchars_spec2str(const struct mchars *arg,
1.23      schwarze  129:                const char *p, size_t sz, size_t *rsz)
1.1       schwarze  130: {
1.9       schwarze  131:        const struct ln *ln;
                    132:
1.19      schwarze  133:        ln = find(arg, p, sz);
1.30      schwarze  134:        if (ln == NULL) {
1.20      schwarze  135:                *rsz = 1;
1.37    ! schwarze  136:                return sz == 1 ? p : NULL;
1.20      schwarze  137:        }
1.1       schwarze  138:
1.10      schwarze  139:        *rsz = strlen(ln->ascii);
1.37    ! schwarze  140:        return ln->ascii;
1.31      schwarze  141: }
                    142:
                    143: const char *
                    144: mchars_uc2str(int uc)
                    145: {
                    146:        int      i;
                    147:
                    148:        for (i = 0; i < LINES_MAX; i++)
                    149:                if (uc == lines[i].unicode)
1.37    ! schwarze  150:                        return lines[i].ascii;
        !           151:        return "<?>";
1.1       schwarze  152: }
                    153:
1.9       schwarze  154: static const struct ln *
1.23      schwarze  155: find(const struct mchars *tab, const char *p, size_t sz)
1.1       schwarze  156: {
1.23      schwarze  157:        const struct ln  *pp;
1.1       schwarze  158:        int               hash;
                    159:
                    160:        assert(p);
                    161:
1.21      schwarze  162:        if (0 == sz || p[0] < PRINT_LO || p[0] > PRINT_HI)
1.37    ! schwarze  163:                return NULL;
1.1       schwarze  164:
                    165:        hash = (int)p[0] - PRINT_LO;
                    166:
1.21      schwarze  167:        for (pp = tab->htab[hash]; pp; pp = pp->next)
1.28      schwarze  168:                if (0 == strncmp(pp->code, p, sz) &&
                    169:                    '\0' == pp->code[(int)sz])
1.37    ! schwarze  170:                        return pp;
1.1       schwarze  171:
1.37    ! schwarze  172:        return NULL;
1.1       schwarze  173: }