chars.c

   1 /*      $Id: chars.c,v 1.44 2011/05/17 11:50:20 kristaps Exp $ */
   2 /*
   3  * Copyright (c) 2009, 2010 Kristaps Dzonsons <kristaps@bsd.lv>
   4  * Copyright (c) 2011 Ingo Schwarze <schwarze@openbsd.org>
   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 #ifdef HAVE_CONFIG_H
  19 #include "config.h"
  20 #endif
  21
  22 #include <assert.h>
  23 #include <ctype.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 #include "mandoc.h"
  29 #include "libmandoc.h"
  30
  31 #define PRINT_HI         126
  32 #define PRINT_LO         32
  33
  34 struct  ln {
  35         struct ln        *next;
  36         const char       *code;
  37         const char       *ascii;
  38         int               unicode;
  39         int               type;
  40 #define CHARS_CHAR       (1 << 0)
  41 #define CHARS_STRING     (1 << 1)
  42 #define CHARS_BOTH       (CHARS_CHAR | CHARS_STRING)
  43 };
  44
  45 #define LINES_MAX         353
  46
  47 #define CHAR(in, ch, code) \
  48         { NULL, (in), (ch), (code), CHARS_CHAR },
  49 #define STRING(in, ch, code) \
  50         { NULL, (in), (ch), (code), CHARS_STRING },
  51 #define BOTH(in, ch, code) \
  52         { NULL, (in), (ch), (code), CHARS_BOTH },
  53
  54 #define CHAR_TBL_START    static struct ln lines[LINES_MAX] = {
  55 #define CHAR_TBL_END      };
  56
  57 #include "chars.in"
  58
  59 struct  mchars {
  60         struct ln       **htab;
  61 };
  62
  63 static  inline int        match(const struct ln *,
  64                                 const char *, size_t, int);
  65 static  const struct ln  *find(struct mchars *, const char *, size_t, int);
  66
  67 void
  68 mchars_free(struct mchars *arg)
  69 {
  70
  71         free(arg->htab);
  72         free(arg);
  73 }
  74
  75 struct mchars *
  76 mchars_alloc(void)
  77 {
  78         struct mchars    *tab;
  79         struct ln       **htab;
  80         struct ln        *pp;
  81         int               i, hash;
  82
  83         /*
  84          * Constructs a very basic chaining hashtable.  The hash routine
  85          * is simply the integral value of the first character.
  86          * Subsequent entries are chained in the order they're processed
  87          * (they're in-line re-ordered during lookup).
  88          */
  89
  90         tab = mandoc_malloc(sizeof(struct mchars));
  91         htab = mandoc_calloc(PRINT_HI - PRINT_LO + 1, sizeof(struct ln **));
  92
  93         for (i = 0; i < LINES_MAX; i++) {
  94                 hash = (int)lines[i].code[0] - PRINT_LO;
  95
  96                 if (NULL == (pp = htab[hash])) {
  97                         htab[hash] = &lines[i];
  98                         continue;
  99                 }
 100
 101                 for ( ; pp->next; pp = pp->next)
 102                         /* Scan ahead. */ ;
 103                 pp->next = &lines[i];
 104         }
 105
 106         tab->htab = htab;
 107         return(tab);
 108 }
 109
 110
 111 /*
 112  * Special character to Unicode codepoint.
 113  */
 114 int
 115 mchars_spec2cp(struct mchars *arg, const char *p, size_t sz)
 116 {
 117         const struct ln *ln;
 118
 119         ln = find(arg, p, sz, CHARS_CHAR);
 120         if (NULL == ln)
 121                 return(-1);
 122         return(ln->unicode);
 123 }
 124
 125
 126 /*
 127  * Reserved word to Unicode codepoint.
 128  */
 129 int
 130 mchars_res2cp(struct mchars *arg, const char *p, size_t sz)
 131 {
 132         const struct ln *ln;
 133
 134         ln = find(arg, p, sz, CHARS_STRING);
 135         if (NULL == ln)
 136                 return(-1);
 137         return(ln->unicode);
 138 }
 139
 140 /*
 141  * Numbered character string to ASCII codepoint.
 142  * This can only be a printable character (i.e., alnum, punct, space) so
 143  * prevent the character from ruining our state (backspace, newline, and
 144  * so on).
 145  * If the character is illegal, returns '\0'.
 146  */
 147 char
 148 mchars_num2char(const char *p, size_t sz)
 149 {
 150         int               i;
 151
 152         if ((i = mandoc_strntou(p, sz, 10)) < 0)
 153                 return('\0');
 154         return(isprint(i) ? i : '\0');
 155 }
 156
 157 /*
 158  * Hex character string to Unicode codepoint.
 159  * If the character is illegal, returns '\0'.
 160  */
 161 int
 162 mchars_num2uc(const char *p, size_t sz)
 163 {
 164         int               i;
 165
 166         if ((i = mandoc_strntou(p, sz, 16)) < 0)
 167                 return('\0');
 168         /* FIXME: make sure we're not in a bogus range. */
 169         return(i > 0x80 && i <= 0x10FFFF ? i : '\0');
 170 }
 171
 172 /*
 173  * Special character to string array.
 174  */
 175 const char *
 176 mchars_spec2str(struct mchars *arg, const char *p, size_t sz, size_t *rsz)
 177 {
 178         const struct ln *ln;
 179
 180         ln = find(arg, p, sz, CHARS_CHAR);
 181         if (NULL == ln)
 182                 return(NULL);
 183
 184         *rsz = strlen(ln->ascii);
 185         return(ln->ascii);
 186 }
 187
 188 /*
 189  * Reserved word to string array.
 190  */
 191 const char *
 192 mchars_res2str(struct mchars *arg, const char *p, size_t sz, size_t *rsz)
 193 {
 194         const struct ln *ln;
 195
 196         ln = find(arg, p, sz, CHARS_STRING);
 197         if (NULL == ln)
 198                 return(NULL);
 199
 200         *rsz = strlen(ln->ascii);
 201         return(ln->ascii);
 202 }
 203
 204 static const struct ln *
 205 find(struct mchars *tab, const char *p, size_t sz, int type)
 206 {
 207         struct ln        *pp, *prev;
 208         struct ln       **htab;
 209         int               hash;
 210
 211         assert(p);
 212         if (0 == sz)
 213                 return(NULL);
 214
 215         if (p[0] < PRINT_LO || p[0] > PRINT_HI)
 216                 return(NULL);
 217
 218         /*
 219          * Lookup the symbol in the symbol hash.  See ascii2htab for the
 220          * hashtable specs.  This dynamically re-orders the hash chain
 221          * to optimise for repeat hits.
 222          */
 223
 224         hash = (int)p[0] - PRINT_LO;
 225         htab = tab->htab;
 226
 227         if (NULL == (pp = htab[hash]))
 228                 return(NULL);
 229
 230         for (prev = NULL; pp; pp = pp->next) {
 231                 if ( ! match(pp, p, sz, type)) {
 232                         prev = pp;
 233                         continue;
 234                 }
 235
 236                 if (prev) {
 237                         prev->next = pp->next;
 238                         pp->next = htab[hash];
 239                         htab[hash] = pp;
 240                 }
 241
 242                 return(pp);
 243         }
 244
 245         return(NULL);
 246 }
 247
 248 static inline int
 249 match(const struct ln *ln, const char *p, size_t sz, int type)
 250 {
 251
 252         if ( ! (ln->type & type))
 253                 return(0);
 254         if (strncmp(ln->code, p, sz))
 255                 return(0);
 256         return('\0' == ln->code[(int)sz]);
 257 }