Home | History | Annotate | Line # | Download | only in libedit
chartype.c revision 1.23 
      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 
     37 #include <ctype.h>
     38 #include <stdlib.h>
     39 #include <string.h>
     40 
     41 #include "el.h"
     42 
     43 #define CT_BUFSIZ ((size_t)1024)
     44 
     45 #ifdef WIDECHAR
     46 protected int
     47 ct_conv_cbuff_resize(ct_buffer_t *conv, size_t csize)
     48 {
     49 	void *p;
     50 
     51 	if (csize <= conv->csize)
     52 		return 0;
     53 
     54 	conv->csize = csize;
     55 
     56 	p = el_realloc(conv->cbuff, conv->csize * sizeof(*conv->cbuff));
     57 	if (p == NULL) {
     58 		conv->csize = 0;
     59 		el_free(conv->cbuff);
     60 		conv->cbuff = NULL;
     61 		return -1;
     62 	}
     63 	conv->cbuff = p;
     64 	return 0;
     65 }
     66 
     67 protected int
     68 ct_conv_wbuff_resize(ct_buffer_t *conv, size_t wsize)
     69 {
     70 	void *p;
     71 
     72 	if (wsize <= conv->wsize)
     73 		return 0;
     74 
     75 	conv->wsize = wsize;
     76 
     77 	p = el_realloc(conv->wbuff, conv->wsize * sizeof(*conv->wbuff));
     78 	if (p == NULL) {
     79 		conv->wsize = 0;
     80 		el_free(conv->wbuff);
     81 		conv->wbuff = NULL;
     82 		return -1;
     83 	}
     84 	conv->wbuff = p;
     85 	return 0;
     86 }
     87 
     88 
     89 public char *
     90 ct_encode_string(const Char *s, ct_buffer_t *conv)
     91 {
     92 	char *dst;
     93 	ssize_t used;
     94 
     95 	if (!s)
     96 		return NULL;
     97 
     98 	dst = conv->cbuff;
     99 	for (;;) {
    100 		used = (ssize_t)(dst - conv->cbuff);
    101 		if ((conv->csize - (size_t)used) < 5) {
    102 			if (ct_conv_cbuff_resize(conv,
    103 			    conv->csize + CT_BUFSIZ) == -1)
    104 				return NULL;
    105 			dst = conv->cbuff + used;
    106 		}
    107 		if (!*s)
    108 			break;
    109 		used = ct_encode_char(dst, (size_t)5, *s);
    110 		if (used == -1) /* failed to encode, need more buffer space */
    111 			abort();
    112 		++s;
    113 		dst += used;
    114 	}
    115 	*dst = '\0';
    116 	return conv->cbuff;
    117 }
    118 
    119 public Char *
    120 ct_decode_string(const char *s, ct_buffer_t *conv)
    121 {
    122 	size_t len;
    123 
    124 	if (!s)
    125 		return NULL;
    126 
    127 	len = ct_mbstowcs(NULL, s, (size_t)0);
    128 	if (len == (size_t)-1)
    129 		return NULL;
    130 
    131 	if (conv->wsize < ++len)
    132 		if (ct_conv_wbuff_resize(conv, len + CT_BUFSIZ) == -1)
    133 			return NULL;
    134 
    135 	ct_mbstowcs(conv->wbuff, s, conv->wsize);
    136 	return conv->wbuff;
    137 }
    138 
    139 
    140 protected Char **
    141 ct_decode_argv(int argc, const char *argv[], ct_buffer_t *conv)
    142 {
    143 	size_t bufspace;
    144 	int i;
    145 	Char *p;
    146 	Char **wargv;
    147 	ssize_t bytes;
    148 
    149 	/* Make sure we have enough space in the conversion buffer to store all
    150 	 * the argv strings. */
    151 	for (i = 0, bufspace = 0; i < argc; ++i)
    152 		bufspace += argv[i] ? strlen(argv[i]) + 1 : 0;
    153 	if (conv->wsize < ++bufspace)
    154 		if (ct_conv_wbuff_resize(conv, bufspace + CT_BUFSIZ) == -1)
    155 			return NULL;
    156 
    157 	wargv = el_malloc((size_t)argc * sizeof(*wargv));
    158 
    159 	for (i = 0, p = conv->wbuff; i < argc; ++i) {
    160 		if (!argv[i]) {   /* don't pass null pointers to mbstowcs */
    161 			wargv[i] = NULL;
    162 			continue;
    163 		} else {
    164 			wargv[i] = p;
    165 			bytes = (ssize_t)mbstowcs(p, argv[i], bufspace);
    166 		}
    167 		if (bytes == -1) {
    168 			el_free(wargv);
    169 			return NULL;
    170 		} else
    171 			bytes++;  /* include '\0' in the count */
    172 		bufspace -= (size_t)bytes;
    173 		p += bytes;
    174 	}
    175 
    176 	return wargv;
    177 }
    178 
    179 
    180 protected size_t
    181 ct_enc_width(Char c)
    182 {
    183 	/* UTF-8 encoding specific values */
    184 	if (c < 0x80)
    185 		return 1;
    186 	else if (c < 0x0800)
    187 		return 2;
    188 	else if (c < 0x10000)
    189 		return 3;
    190 	else if (c < 0x110000)
    191 		return 4;
    192 	else
    193 		return 0; /* not a valid codepoint */
    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 	if (s == NULL)
    225 		return 0;
    226 	if (n == 0)
    227 		return (size_t)-2;
    228 	if (wc != NULL)
    229 		*wc = *s;
    230 	return *s != '\0';
    231 }
    232 #endif
    233 
    234 protected const Char *
    235 ct_visual_string(const Char *s)
    236 {
    237 	static Char *buff = NULL;
    238 	static size_t buffsize = 0;
    239 	void *p;
    240 	Char *dst;
    241 	ssize_t used = 0;
    242 
    243 	if (!s)
    244 		return NULL;
    245 	if (!buff) {
    246 	    buffsize = CT_BUFSIZ;
    247 	    buff = el_malloc(buffsize * sizeof(*buff));
    248 	}
    249 	dst = buff;
    250 	while (*s) {
    251 		used = ct_visual_char(dst, buffsize - (size_t)(dst - buff), *s);
    252 		if (used == -1) { /* failed to encode, need more buffer space */
    253 			used = dst - buff;
    254 			buffsize += CT_BUFSIZ;
    255 			p = el_realloc(buff, buffsize * sizeof(*buff));
    256 			if (p == NULL)
    257 				goto out;
    258 			buff = p;
    259 			dst = buff + used;
    260 			/* don't increment s here - we want to retry it! */
    261 		}
    262 		else
    263 		    ++s;
    264 		dst += used;
    265 	}
    266 	if (dst >= (buff + buffsize)) { /* sigh */
    267 		buffsize += 1;
    268 		p = el_realloc(buff, buffsize * sizeof(*buff));
    269 		if (p == NULL)
    270 			goto out;
    271 		buff = p;
    272 		dst = buff + buffsize - 1;
    273 	}
    274 	*dst = 0;
    275 	return buff;
    276 out:
    277 	el_free(buff);
    278 	buffsize = 0;
    279 	return NULL;
    280 }
    281 
    282 
    283 
    284 protected int
    285 ct_visual_width(Char c)
    286 {
    287 	int t = ct_chr_class(c);
    288 	switch (t) {
    289 	case CHTYPE_ASCIICTL:
    290 		return 2; /* ^@ ^? etc. */
    291 	case CHTYPE_TAB:
    292 		return 1; /* Hmm, this really need to be handled outside! */
    293 	case CHTYPE_NL:
    294 		return 0; /* Should this be 1 instead? */
    295 #ifdef WIDECHAR
    296 	case CHTYPE_PRINT:
    297 		return wcwidth(c);
    298 	case CHTYPE_NONPRINT:
    299 		if (c > 0xffff) /* prefer standard 4-byte display over 5-byte */
    300 			return 8; /* \U+12345 */
    301 		else
    302 			return 7; /* \U+1234 */
    303 #else
    304 	case CHTYPE_PRINT:
    305 		return 1;
    306 	case CHTYPE_NONPRINT:
    307 		return 4; /* \123 */
    308 #endif
    309 	default:
    310 		return 0; /* should not happen */
    311 	}
    312 }
    313 
    314 
    315 protected ssize_t
    316 ct_visual_char(Char *dst, size_t len, Char c)
    317 {
    318 	int t = ct_chr_class(c);
    319 	switch (t) {
    320 	case CHTYPE_TAB:
    321 	case CHTYPE_NL:
    322 	case CHTYPE_ASCIICTL:
    323 		if (len < 2)
    324 			return -1;   /* insufficient space */
    325 		*dst++ = '^';
    326 		if (c == '\177')
    327 			*dst = '?'; /* DEL -> ^? */
    328 		else
    329 			*dst = c | 0100;    /* uncontrolify it */
    330 		return 2;
    331 	case CHTYPE_PRINT:
    332 		if (len < 1)
    333 			return -1;  /* insufficient space */
    334 		*dst = c;
    335 		return 1;
    336 	case CHTYPE_NONPRINT:
    337 		/* we only use single-width glyphs for display,
    338 		 * so this is right */
    339 		if ((ssize_t)len < ct_visual_width(c))
    340 			return -1;   /* insufficient space */
    341 #ifdef WIDECHAR
    342 		*dst++ = '\\';
    343 		*dst++ = 'U';
    344 		*dst++ = '+';
    345 #define tohexdigit(v) "0123456789ABCDEF"[v]
    346 		if (c > 0xffff) /* prefer standard 4-byte display over 5-byte */
    347 			*dst++ = tohexdigit(((unsigned int) c >> 16) & 0xf);
    348 		*dst++ = tohexdigit(((unsigned int) c >> 12) & 0xf);
    349 		*dst++ = tohexdigit(((unsigned int) c >>  8) & 0xf);
    350 		*dst++ = tohexdigit(((unsigned int) c >>  4) & 0xf);
    351 		*dst   = tohexdigit(((unsigned int) c      ) & 0xf);
    352 		return c > 0xffff ? 8 : 7;
    353 #else
    354 		*dst++ = '\\';
    355 #define tooctaldigit(v) (Char)((v) + '0')
    356 		*dst++ = tooctaldigit(((unsigned int) c >> 6) & 0x7);
    357 		*dst++ = tooctaldigit(((unsigned int) c >> 3) & 0x7);
    358 		*dst++ = tooctaldigit(((unsigned int) c     ) & 0x7);
    359 #endif
    360 		/*FALLTHROUGH*/
    361 	/* these two should be handled outside this function */
    362 	default:            /* we should never hit the default */
    363 		return 0;
    364 	}
    365 }
    366 
    367 
    368 
    369 
    370 protected int
    371 ct_chr_class(Char c)
    372 {
    373 	if (c == '\t')
    374 		return CHTYPE_TAB;
    375 	else if (c == '\n')
    376 		return CHTYPE_NL;
    377 	else if (IsASCII(c) && Iscntrl(c))
    378 		return CHTYPE_ASCIICTL;
    379 	else if (Isprint(c))
    380 		return CHTYPE_PRINT;
    381 	else
    382 		return CHTYPE_NONPRINT;
    383 }
    384