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