Home | History | Annotate | Line # | Download | only in libedit
eln.c revision 1.7 
      1 /*	$NetBSD: eln.c,v 1.7 2010/04/15 00:52:48 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 #include "config.h"
     36 #if !defined(lint) && !defined(SCCSID)
     37 __RCSID("$NetBSD: eln.c,v 1.7 2010/04/15 00:52:48 christos Exp $");
     38 #endif /* not lint && not SCCSID */
     39 
     40 #include "histedit.h"
     41 #include "el.h"
     42 #include "read.h"
     43 #include <stdarg.h>
     44 #include <stdio.h>
     45 #include <stdlib.h>
     46 
     47 public int
     48 el_getc(EditLine *el, char *cp)
     49 {
     50 	int num_read;
     51 	wchar_t wc = 0;
     52 
     53 	if (!(el->el_flags & CHARSET_IS_UTF8))
     54 		el->el_flags |= IGNORE_EXTCHARS;
     55 	num_read = el_wgetc (el, &wc);
     56 	if (!(el->el_flags & CHARSET_IS_UTF8))
     57 		el->el_flags &= ~IGNORE_EXTCHARS;
     58 
     59 	if (num_read > 0)
     60 		*cp = (unsigned char)wc;
     61 	return num_read;
     62 }
     63 
     64 
     65 public void
     66 el_push(EditLine *el, const char *str)
     67 {
     68 	/* Using multibyte->wide string decoding works fine under single-byte
     69 	 * character sets too, and Does The Right Thing. */
     70 	el_wpush(el, ct_decode_string(str, &el->el_lgcyconv));
     71 }
     72 
     73 
     74 public const char *
     75 el_gets(EditLine *el, int *nread)
     76 {
     77 	const wchar_t *tmp;
     78 
     79 	el->el_flags |= IGNORE_EXTCHARS;
     80 	tmp = el_wgets(el, nread);
     81 	el->el_flags &= ~IGNORE_EXTCHARS;
     82 	return ct_encode_string(tmp, &el->el_lgcyconv);
     83 }
     84 
     85 
     86 public int
     87 el_parse(EditLine *el, int argc, const char *argv[])
     88 {
     89 	int ret;
     90 	const wchar_t **wargv;
     91 
     92 	wargv = (const wchar_t **)
     93 	    ct_decode_argv(argc, argv, &el->el_lgcyconv);
     94 	if (!wargv)
     95 		return -1;
     96 	ret = el_wparse(el, argc, wargv);
     97 	ct_free_argv(wargv);
     98 
     99 	return ret;
    100 }
    101 
    102 
    103 public int
    104 el_set(EditLine *el, int op, ...)
    105 {
    106 	va_list ap;
    107 	int ret;
    108 
    109 	if (!el)
    110 		return -1;
    111 	va_start(ap, op);
    112 
    113 	switch (op) {
    114 	case EL_PROMPT:         /* el_pfunc_t */
    115 	case EL_RPROMPT: {
    116 		el_pfunc_t p = va_arg(ap, el_pfunc_t);
    117 		ret = prompt_set(el, p, 0, op, 0);
    118 		break;
    119 	}
    120 
    121 	case EL_TERMINAL:       /* const char * */
    122 		ret = el_wset(el, op, va_arg(ap, char *));
    123 		break;
    124 
    125 	case EL_EDITOR:		/* const wchar_t * */
    126 		ret = el_wset(el, op, ct_decode_string(va_arg(ap, char *),
    127 		    &el->el_lgcyconv));
    128 		break;
    129 
    130 	case EL_SIGNAL:         /* int */
    131 	case EL_EDITMODE:
    132 	case EL_UNBUFFERED:
    133 	case EL_PREP_TERM:
    134 		ret = el_wset(el, op, va_arg(ap, int));
    135 		break;
    136 
    137 	case EL_BIND:   /* const char * list -> const wchar_t * list */
    138 	case EL_TELLTC:
    139 	case EL_SETTC:
    140 	case EL_ECHOTC:
    141 	case EL_SETTY: {
    142 		const char *argv[20];
    143 		int i;
    144 		const wchar_t **wargv;
    145 		for (i = 1; i < (int)__arraycount(argv); ++i)
    146 			if ((argv[i] = va_arg(ap, char *)) == NULL)
    147 			    break;
    148 		argv[0] = NULL;
    149 		wargv = (const wchar_t **)
    150 		    ct_decode_argv(i, argv, &el->el_lgcyconv);
    151 		if (!wargv) {
    152 		    ret = -1;
    153 		    goto out;
    154 		}
    155 		/*
    156 		 * AFAIK we can't portably pass through our new wargv to
    157 		 * el_wset(), so we have to reimplement the body of
    158 		 * el_wset() for these ops.
    159 		 */
    160 		switch (op) {
    161 		case EL_BIND:
    162 			wargv[0] = STR("bind");
    163 			ret = map_bind(el, i, wargv);
    164 			break;
    165 		case EL_TELLTC:
    166 			wargv[0] = STR("telltc");
    167 			ret = term_telltc(el, i, wargv);
    168 			break;
    169 		case EL_SETTC:
    170 			wargv[0] = STR("settc");
    171 			ret = term_settc(el, i, wargv);
    172 			break;
    173 		case EL_ECHOTC:
    174 			wargv[0] = STR("echotc");
    175 			ret = term_echotc(el, i, wargv);
    176 			break;
    177 		case EL_SETTY:
    178 			wargv[0] = STR("setty");
    179 			ret = tty_stty(el, i, wargv);
    180 			break;
    181 		default:
    182 			ret = -1;
    183 		}
    184 		ct_free_argv(wargv);
    185 		break;
    186 	}
    187 
    188 	/* XXX: do we need to change el_func_t too? */
    189 	case EL_ADDFN: {          /* const char *, const char *, el_func_t */
    190 		const char *args[2];
    191 		el_func_t func;
    192 		wchar_t **wargv;
    193 
    194 		args[0] = va_arg(ap, const char *);
    195 		args[1] = va_arg(ap, const char *);
    196 		func = va_arg(ap, el_func_t);
    197 
    198 		wargv = ct_decode_argv(2, args, &el->el_lgcyconv);
    199 		if (!wargv) {
    200 		    ret = -1;
    201 		    goto out;
    202 		}
    203 		// XXX: The two strdup's leak
    204 		ret = map_addfunc(el, Strdup(wargv[0]), Strdup(wargv[1]),
    205 		    func);
    206 		ct_free_argv(wargv);
    207 		break;
    208 	}
    209 	case EL_HIST: {           /* hist_fun_t, const char * */
    210 		hist_fun_t fun = va_arg(ap, hist_fun_t);
    211 		ptr_t ptr = va_arg(ap, ptr_t);
    212 		ret = hist_set(el, fun, ptr);
    213 		if (!(el->el_flags & CHARSET_IS_UTF8))
    214 			el->el_flags |= NARROW_HISTORY;
    215 		break;
    216 	}
    217 	/* XXX: do we need to change el_rfunc_t? */
    218 	case EL_GETCFN:         /* el_rfunc_t */
    219 		ret = el_wset(el, op, va_arg(ap, el_rfunc_t));
    220 		el->el_flags |= NARROW_READ;
    221 		break;
    222 	case EL_CLIENTDATA:     /* void * */
    223 		ret = el_wset(el, op, va_arg(ap, void *));
    224 		break;
    225 	case EL_SETFP: {          /* int, FILE * */
    226 		int what = va_arg(ap, int);
    227 		FILE *fp = va_arg(ap, FILE *);
    228 		ret = el_wset(el, op, what, fp);
    229 		break;
    230 	}
    231 	case EL_PROMPT_ESC: /* el_pfunc_t, char */
    232 	case EL_RPROMPT_ESC: {
    233 		el_pfunc_t p = va_arg(ap, el_pfunc_t);
    234 		char c = va_arg(ap, int);
    235 		ret = prompt_set(el, p, c, op, 0);
    236 		break;
    237 	}
    238 	default:
    239 		ret = -1;
    240 		break;
    241 	}
    242 
    243 out:
    244 	va_end(ap);
    245 	return ret;
    246 }
    247 
    248 
    249 public int
    250 el_get(EditLine *el, int op, ...)
    251 {
    252 	va_list ap;
    253 	int ret;
    254 
    255 	if (!el)
    256 		return -1;
    257 
    258 	va_start(ap, op);
    259 
    260 	switch (op) {
    261 	case EL_PROMPT:         /* el_pfunc_t * */
    262 	case EL_RPROMPT: {
    263 		el_pfunc_t *p = va_arg(ap, el_pfunc_t *);
    264 		ret = prompt_get(el, p, 0, op);
    265 		break;
    266 	}
    267 
    268 	case EL_PROMPT_ESC: /* el_pfunc_t *, char **/
    269 	case EL_RPROMPT_ESC: {
    270 		el_pfunc_t *p = va_arg(ap, el_pfunc_t *);
    271 		char *c = va_arg(ap, char *);
    272 		wchar_t wc;
    273 		ret = prompt_get(el, p, &wc, op);
    274 		*c = (unsigned char)wc;
    275 		break;
    276 	}
    277 
    278 	case EL_EDITOR: {
    279 		const char **p = va_arg(ap, const char **);
    280 		const wchar_t *pw;
    281 		ret = el_wget(el, op, &pw);
    282 		*p = ct_encode_string(pw, &el->el_lgcyconv);
    283 		if (!el->el_lgcyconv.csize)
    284 			ret = -1;
    285 		break;
    286 	}
    287 
    288 	case EL_TERMINAL:       /* const char ** */
    289 		ret = el_wget(el, op, va_arg(ap, const char **));
    290 		break;
    291 
    292 	case EL_SIGNAL:         /* int * */
    293 	case EL_EDITMODE:
    294 	case EL_UNBUFFERED:
    295 	case EL_PREP_TERM:
    296 		ret = el_wget(el, op, va_arg(ap, int *));
    297 		break;
    298 
    299 	case EL_GETTC: {
    300 		char *argv[20];
    301 		static char gettc[] = "gettc";
    302 		int i;
    303 		for (i = 1; i < (int)__arraycount(argv); ++i)
    304 			if ((argv[i] = va_arg(ap, char *)) == NULL)
    305 				break;
    306 		argv[0] = gettc;
    307 		ret = term_gettc(el, i, argv);
    308 		break;
    309 	}
    310 
    311 	/* XXX: do we need to change el_rfunc_t? */
    312 	case EL_GETCFN:         /* el_rfunc_t */
    313 		ret = el_wget(el, op, va_arg(ap, el_rfunc_t *));
    314 		break;
    315 
    316 	case EL_CLIENTDATA:     /* void ** */
    317 		ret = el_wget(el, op, va_arg(ap, void **));
    318 		break;
    319 
    320 	case EL_GETFP: {          /* int, FILE ** */
    321 		int what = va_arg(ap, int);
    322 		FILE **fpp = va_arg(ap, FILE **);
    323 		ret = el_wget(el, op, what, fpp);
    324 		break;
    325 	}
    326 
    327 	default:
    328 		ret = -1;
    329 		break;
    330 	}
    331 
    332 	va_end(ap);
    333 	return ret;
    334 }
    335 
    336 
    337 const LineInfo *
    338 el_line(EditLine *el)
    339 {
    340 	const LineInfoW *winfo = el_wline(el);
    341 	LineInfo *info = &el->el_lgcylinfo;
    342 	size_t offset;
    343 	const Char *p;
    344 
    345 	info->buffer   = ct_encode_string(winfo->buffer, &el->el_lgcyconv);
    346 
    347 	offset = 0;
    348 	for (p = winfo->buffer; p < winfo->cursor; p++)
    349 		offset += ct_enc_width(*p);
    350 	info->cursor = info->buffer + offset;
    351 
    352 	offset = 0;
    353 	for (p = winfo->buffer; p < winfo->lastchar; p++)
    354 		offset += ct_enc_width(*p);
    355 	info->lastchar = info->buffer + offset;
    356 
    357 	return info;
    358 }
    359 
    360 
    361 int
    362 el_insertstr(EditLine *el, const char *str)
    363 {
    364 	return el_winsertstr(el, ct_decode_string(str, &el->el_lgcyconv));
    365 }
    366