lib/libedit/chartype.c

   1 /*      $NetBSD: chartype.c,v 1.23 2016/02/28 23:02:24 christos Exp $   */
   2
   3 /*-
   4  * Copyright (c) 2009 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  17  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  18  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  19  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  20  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  26  * POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 /*
  30  * chartype.c: character classification and meta information
  31  */
  32 #include "config.h"
  33 #if !defined(lint) && !defined(SCCSID)
  34 __RCSID("$NetBSD: chartype.c,v 1.23 2016/02/28 23:02:24 christos Exp $");
  35 #endif /* not lint && not SCCSID */
  36 #include <sys/cdefs.h>
  37 __FBSDID("$FreeBSD$");
  38
  39 #include <ctype.h>
  40 #include <limits.h>
  41 #include <stdlib.h>
  42 #include <string.h>
  43
  44 #include "el.h"
  45
  46 #define CT_BUFSIZ ((size_t)1024)
  47
  48 #ifdef WIDECHAR
  49 protected int
  50 ct_conv_cbuff_resize(ct_buffer_t *conv, size_t csize)
  51 {
  52         void *p;
  53
  54         if (csize <= conv->csize)
  55                 return 0;
  56
  57         conv->csize = csize;
  58
  59         p = el_realloc(conv->cbuff, conv->csize * sizeof(*conv->cbuff));
  60         if (p == NULL) {
  61                 conv->csize = 0;
  62                 el_free(conv->cbuff);
  63                 conv->cbuff = NULL;
  64                 return -1;
  65         }
  66         conv->cbuff = p;
  67         return 0;
  68 }
  69
  70 protected int
  71 ct_conv_wbuff_resize(ct_buffer_t *conv, size_t wsize)
  72 {
  73         void *p;
  74
  75         if (wsize <= conv->wsize)
  76                 return 0;
  77
  78         conv->wsize = wsize;
  79
  80         p = el_realloc(conv->wbuff, conv->wsize * sizeof(*conv->wbuff));
  81         if (p == NULL) {
  82                 conv->wsize = 0;
  83                 el_free(conv->wbuff);
  84                 conv->wbuff = NULL;
  85                 return -1;
  86         }
  87         conv->wbuff = p;
  88         return 0;
  89 }
  90
  91
  92 public char *
  93 ct_encode_string(const Char *s, ct_buffer_t *conv)
  94 {
  95         char *dst;
  96         ssize_t used;
  97
  98         if (!s)
  99                 return NULL;
 100
 101         dst = conv->cbuff;
 102         for (;;) {
 103                 used = (ssize_t)(dst - conv->cbuff);
 104                 if ((conv->csize - (size_t)used) < 5) {
 105                         if (ct_conv_cbuff_resize(conv,
 106                             conv->csize + CT_BUFSIZ) == -1)
 107                                 return NULL;
 108                         dst = conv->cbuff + used;
 109                 }
 110                 if (!*s)
 111                         break;
 112                 used = ct_encode_char(dst, (size_t)5, *s);
 113                 if (used == -1) /* failed to encode, need more buffer space */
 114                         abort();
 115                 ++s;
 116                 dst += used;
 117         }
 118         *dst = '\0';
 119         return conv->cbuff;
 120 }
 121
 122 public Char *
 123 ct_decode_string(const char *s, ct_buffer_t *conv)
 124 {
 125         size_t len;
 126
 127         if (!s)
 128                 return NULL;
 129
 130         len = ct_mbstowcs(NULL, s, (size_t)0);
 131         if (len == (size_t)-1)
 132                 return NULL;
 133
 134         if (conv->wsize < ++len)
 135                 if (ct_conv_wbuff_resize(conv, len + CT_BUFSIZ) == -1)
 136                         return NULL;
 137
 138         ct_mbstowcs(conv->wbuff, s, conv->wsize);
 139         return conv->wbuff;
 140 }
 141
 142
 143 protected Char **
 144 ct_decode_argv(int argc, const char *argv[], ct_buffer_t *conv)
 145 {
 146         size_t bufspace;
 147         int i;
 148         Char *p;
 149         Char **wargv;
 150         ssize_t bytes;
 151
 152         /* Make sure we have enough space in the conversion buffer to store all
 153          * the argv strings. */
 154         for (i = 0, bufspace = 0; i < argc; ++i)
 155                 bufspace += argv[i] ? strlen(argv[i]) + 1 : 0;
 156         if (conv->wsize < ++bufspace)
 157                 if (ct_conv_wbuff_resize(conv, bufspace + CT_BUFSIZ) == -1)
 158                         return NULL;
 159
 160         wargv = el_malloc((size_t)(argc + 1) * sizeof(*wargv));
 161
 162         for (i = 0, p = conv->wbuff; i < argc; ++i) {
 163                 if (!argv[i]) {   /* don't pass null pointers to mbstowcs */
 164                         wargv[i] = NULL;
 165                         continue;
 166                 } else {
 167                         wargv[i] = p;
 168                         bytes = (ssize_t)mbstowcs(p, argv[i], bufspace);
 169                 }
 170                 if (bytes == -1) {
 171                         el_free(wargv);
 172                         return NULL;
 173                 } else
 174                         bytes++;  /* include '\0' in the count */
 175                 bufspace -= (size_t)bytes;
 176                 p += bytes;
 177         }
 178         wargv[i] = NULL;
 179
 180         return wargv;
 181 }
 182
 183
 184 protected size_t
 185 ct_enc_width(Char c)
 186 {
 187         mbstate_t ps = (mbstate_t){{0}};
 188         size_t len;
 189         char cbuf[MB_LEN_MAX];
 190         len = ct_wcrtomb(cbuf, c, &ps);
 191         if (len == (size_t)-1)
 192                 return (0);
 193         return (len);
 194 }
 195
 196 protected ssize_t
 197 ct_encode_char(char *dst, size_t len, Char c)
 198 {
 199         ssize_t l = 0;
 200         if (len < ct_enc_width(c))
 201                 return -1;
 202         l = ct_wctomb(dst, c);
 203
 204         if (l < 0) {
 205                 ct_wctomb_reset;
 206                 l = 0;
 207         }
 208         return l;
 209 }
 210
 211 size_t
 212 ct_mbrtowc(wchar_t *wc, const char *s, size_t n)
 213 {
 214         mbstate_t mbs;
 215         /* This only works because UTF-8 is stateless */
 216         memset(&mbs, 0, sizeof(mbs));
 217         return mbrtowc(wc, s, n, &mbs);
 218 }
 219
 220 #else
 221
 222 size_t
 223 ct_mbrtowc(wchar_t *wc, const char *s, size_t n)
 224 {
 225         if (s == NULL)
 226                 return 0;
 227         if (n == 0)
 228                 return (size_t)-2;
 229         if (wc != NULL)
 230                 *wc = *s;
 231         return *s != '\0';
 232 }
 233 #endif
 234
 235 protected const Char *
 236 ct_visual_string(const Char *s)
 237 {
 238         static Char *buff = NULL;
 239         static size_t buffsize = 0;
 240         void *p;
 241         Char *dst;
 242         ssize_t used = 0;
 243
 244         if (!s)
 245                 return NULL;
 246         if (!buff) {
 247             buffsize = CT_BUFSIZ;
 248             buff = el_malloc(buffsize * sizeof(*buff));
 249         }
 250         dst = buff;
 251         while (*s) {
 252                 used = ct_visual_char(dst, buffsize - (size_t)(dst - buff), *s);
 253                 if (used == -1) { /* failed to encode, need more buffer space */
 254                         used = dst - buff;
 255                         buffsize += CT_BUFSIZ;
 256                         p = el_realloc(buff, buffsize * sizeof(*buff));
 257                         if (p == NULL)
 258                                 goto out;
 259                         buff = p;
 260                         dst = buff + used;
 261                         /* don't increment s here - we want to retry it! */
 262                 }
 263                 else
 264                     ++s;
 265                 dst += used;
 266         }
 267         if (dst >= (buff + buffsize)) { /* sigh */
 268                 buffsize += 1;
 269                 p = el_realloc(buff, buffsize * sizeof(*buff));
 270                 if (p == NULL)
 271                         goto out;
 272                 buff = p;
 273                 dst = buff + buffsize - 1;
 274         }
 275         *dst = 0;
 276         return buff;
 277 out:
 278         el_free(buff);
 279         buffsize = 0;
 280         return NULL;
 281 }
 282
 283
 284
 285 protected int
 286 ct_visual_width(Char c)
 287 {
 288         int t = ct_chr_class(c);
 289         switch (t) {
 290         case CHTYPE_ASCIICTL:
 291                 return 2; /* ^@ ^? etc. */
 292         case CHTYPE_TAB:
 293                 return 1; /* Hmm, this really need to be handled outside! */
 294         case CHTYPE_NL:
 295                 return 0; /* Should this be 1 instead? */
 296 #ifdef WIDECHAR
 297         case CHTYPE_PRINT:
 298                 return wcwidth(c);
 299         case CHTYPE_NONPRINT:
 300                 if (c > 0xffff) /* prefer standard 4-byte display over 5-byte */
 301                         return 8; /* \U+12345 */
 302                 else
 303                         return 7; /* \U+1234 */
 304 #else
 305         case CHTYPE_PRINT:
 306                 return 1;
 307         case CHTYPE_NONPRINT:
 308                 return 4; /* \123 */
 309 #endif
 310         default:
 311                 return 0; /* should not happen */
 312         }
 313 }
 314
 315
 316 protected ssize_t
 317 ct_visual_char(Char *dst, size_t len, Char c)
 318 {
 319         int t = ct_chr_class(c);
 320         switch (t) {
 321         case CHTYPE_TAB:
 322         case CHTYPE_NL:
 323         case CHTYPE_ASCIICTL:
 324                 if (len < 2)
 325                         return -1;   /* insufficient space */
 326                 *dst++ = '^';
 327                 if (c == '\177')
 328                         *dst = '?'; /* DEL -> ^? */
 329                 else
 330                         *dst = c | 0100;    /* uncontrolify it */
 331                 return 2;
 332         case CHTYPE_PRINT:
 333                 if (len < 1)
 334                         return -1;  /* insufficient space */
 335                 *dst = c;
 336                 return 1;
 337         case CHTYPE_NONPRINT:
 338                 /* we only use single-width glyphs for display,
 339                  * so this is right */
 340                 if ((ssize_t)len < ct_visual_width(c))
 341                         return -1;   /* insufficient space */
 342 #ifdef WIDECHAR
 343                 *dst++ = '\\';
 344                 *dst++ = 'U';
 345                 *dst++ = '+';
 346 #define tohexdigit(v) "0123456789ABCDEF"[v]
 347                 if (c > 0xffff) /* prefer standard 4-byte display over 5-byte */
 348                         *dst++ = tohexdigit(((unsigned int) c >> 16) & 0xf);
 349                 *dst++ = tohexdigit(((unsigned int) c >> 12) & 0xf);
 350                 *dst++ = tohexdigit(((unsigned int) c >>  8) & 0xf);
 351                 *dst++ = tohexdigit(((unsigned int) c >>  4) & 0xf);
 352                 *dst   = tohexdigit(((unsigned int) c      ) & 0xf);
 353                 return c > 0xffff ? 8 : 7;
 354 #else
 355                 *dst++ = '\\';
 356 #define tooctaldigit(v) (Char)((v) + '0')
 357                 *dst++ = tooctaldigit(((unsigned int) c >> 6) & 0x7);
 358                 *dst++ = tooctaldigit(((unsigned int) c >> 3) & 0x7);
 359                 *dst++ = tooctaldigit(((unsigned int) c     ) & 0x7);
 360 #endif
 361                 /*FALLTHROUGH*/
 362         /* these two should be handled outside this function */
 363         default:            /* we should never hit the default */
 364                 return 0;
 365         }
 366 }
 367
 368
 369
 370
 371 protected int
 372 ct_chr_class(Char c)
 373 {
 374         if (c == '\t')
 375                 return CHTYPE_TAB;
 376         else if (c == '\n')
 377                 return CHTYPE_NL;
 378         else if (IsASCII(c) && Iscntrl(c))
 379                 return CHTYPE_ASCIICTL;
 380         else if (Isprint(c))
 381                 return CHTYPE_PRINT;
 382         else
 383                 return CHTYPE_NONPRINT;
 384 }