Home | History | Annotate | Line # | Download | only in libedit
eln.c revision 1.16 
      1 /*	$NetBSD: eln.c,v 1.16 2014/05/20 15:05:08 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.16 2014/05/20 15:05:08 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 = (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_RESIZE: {
    122 		el_zfunc_t p = va_arg(ap, el_zfunc_t);
    123 		void *arg = va_arg(ap, void *);
    124 		ret = ch_resizefun(el, p, arg);
    125 		break;
    126 	}
    127 
    128 	case EL_PROMPT_ESC:
    129 	case EL_RPROMPT_ESC: {
    130 		el_pfunc_t p = va_arg(ap, el_pfunc_t);
    131 		int c = va_arg(ap, int);
    132 
    133 		ret = prompt_set(el, p, c, op, 0);
    134 		break;
    135 	}
    136 
    137 	case EL_TERMINAL:       /* const char * */
    138 		ret = el_wset(el, op, va_arg(ap, char *));
    139 		break;
    140 
    141 	case EL_EDITOR:		/* const wchar_t * */
    142 		ret = el_wset(el, op, ct_decode_string(va_arg(ap, char *),
    143 		    &el->el_lgcyconv));
    144 		break;
    145 
    146 	case EL_SIGNAL:         /* int */
    147 	case EL_EDITMODE:
    148 	case EL_UNBUFFERED:
    149 	case EL_PREP_TERM:
    150 		ret = el_wset(el, op, va_arg(ap, int));
    151 		break;
    152 
    153 	case EL_BIND:   /* const char * list -> const wchar_t * list */
    154 	case EL_TELLTC:
    155 	case EL_SETTC:
    156 	case EL_ECHOTC:
    157 	case EL_SETTY: {
    158 		const char *argv[20];
    159 		int i;
    160 		const wchar_t **wargv;
    161 		for (i = 1; i < (int)__arraycount(argv) - 1; ++i)
    162 			if ((argv[i] = va_arg(ap, const char *)) == NULL)
    163 			    break;
    164 		argv[0] = argv[i] = NULL;
    165 		wargv = (const wchar_t **)
    166 		    ct_decode_argv(i + 1, argv, &el->el_lgcyconv);
    167 		if (!wargv) {
    168 		    ret = -1;
    169 		    goto out;
    170 		}
    171 		/*
    172 		 * AFAIK we can't portably pass through our new wargv to
    173 		 * el_wset(), so we have to reimplement the body of
    174 		 * el_wset() for these ops.
    175 		 */
    176 		switch (op) {
    177 		case EL_BIND:
    178 			wargv[0] = STR("bind");
    179 			ret = map_bind(el, i, wargv);
    180 			break;
    181 		case EL_TELLTC:
    182 			wargv[0] = STR("telltc");
    183 			ret = terminal_telltc(el, i, wargv);
    184 			break;
    185 		case EL_SETTC:
    186 			wargv[0] = STR("settc");
    187 			ret = terminal_settc(el, i, wargv);
    188 			break;
    189 		case EL_ECHOTC:
    190 			wargv[0] = STR("echotc");
    191 			ret = terminal_echotc(el, i, wargv);
    192 			break;
    193 		case EL_SETTY:
    194 			wargv[0] = STR("setty");
    195 			ret = tty_stty(el, i, wargv);
    196 			break;
    197 		default:
    198 			ret = -1;
    199 		}
    200 		ct_free_argv(wargv);
    201 		break;
    202 	}
    203 
    204 	/* XXX: do we need to change el_func_t too? */
    205 	case EL_ADDFN: {          /* const char *, const char *, el_func_t */
    206 		const char *args[2];
    207 		el_func_t func;
    208 		wchar_t **wargv;
    209 
    210 		args[0] = va_arg(ap, const char *);
    211 		args[1] = va_arg(ap, const char *);
    212 		func = va_arg(ap, el_func_t);
    213 
    214 		wargv = ct_decode_argv(2, args, &el->el_lgcyconv);
    215 		if (!wargv) {
    216 		    ret = -1;
    217 		    goto out;
    218 		}
    219 		// XXX: The two strdup's leak
    220 		ret = map_addfunc(el, Strdup(wargv[0]), Strdup(wargv[1]),
    221 		    func);
    222 		ct_free_argv(wargv);
    223 		break;
    224 	}
    225 	case EL_HIST: {           /* hist_fun_t, const char * */
    226 		hist_fun_t fun = va_arg(ap, hist_fun_t);
    227 		void *ptr = va_arg(ap, void *);
    228 		ret = hist_set(el, fun, ptr);
    229 		el->el_flags |= NARROW_HISTORY;
    230 		break;
    231 	}
    232 
    233 	/* XXX: do we need to change el_rfunc_t? */
    234 	case EL_GETCFN:         /* el_rfunc_t */
    235 		ret = el_wset(el, op, va_arg(ap, el_rfunc_t));
    236 		el->el_flags |= NARROW_READ;
    237 		break;
    238 
    239 	case EL_CLIENTDATA:     /* void * */
    240 		ret = el_wset(el, op, va_arg(ap, void *));
    241 		break;
    242 
    243 	case EL_SETFP: {          /* int, FILE * */
    244 		int what = va_arg(ap, int);
    245 		FILE *fp = va_arg(ap, FILE *);
    246 		ret = el_wset(el, op, what, fp);
    247 		break;
    248 	}
    249 
    250 	case EL_REFRESH:
    251 		re_clear_display(el);
    252 		re_refresh(el);
    253 		terminal__flush(el);
    254 		ret = 0;
    255 		break;
    256 
    257 	default:
    258 		ret = -1;
    259 		break;
    260 	}
    261 
    262 out:
    263 	va_end(ap);
    264 	return ret;
    265 }
    266 
    267 
    268 public int
    269 el_get(EditLine *el, int op, ...)
    270 {
    271 	va_list ap;
    272 	int ret;
    273 
    274 	if (!el)
    275 		return -1;
    276 
    277 	va_start(ap, op);
    278 
    279 	switch (op) {
    280 	case EL_PROMPT:         /* el_pfunc_t * */
    281 	case EL_RPROMPT: {
    282 		el_pfunc_t *p = va_arg(ap, el_pfunc_t *);
    283 		ret = prompt_get(el, p, 0, op);
    284 		break;
    285 	}
    286 
    287 	case EL_PROMPT_ESC: /* el_pfunc_t *, char **/
    288 	case EL_RPROMPT_ESC: {
    289 		el_pfunc_t *p = va_arg(ap, el_pfunc_t *);
    290 		char *c = va_arg(ap, char *);
    291 		wchar_t wc = 0;
    292 		ret = prompt_get(el, p, &wc, op);
    293 		*c = (char)wc;
    294 		break;
    295 	}
    296 
    297 	case EL_EDITOR: {
    298 		const char **p = va_arg(ap, const char **);
    299 		const wchar_t *pw;
    300 		ret = el_wget(el, op, &pw);
    301 		*p = ct_encode_string(pw, &el->el_lgcyconv);
    302 		if (!el->el_lgcyconv.csize)
    303 			ret = -1;
    304 		break;
    305 	}
    306 
    307 	case EL_TERMINAL:       /* const char ** */
    308 		ret = el_wget(el, op, va_arg(ap, const char **));
    309 		break;
    310 
    311 	case EL_SIGNAL:         /* int * */
    312 	case EL_EDITMODE:
    313 	case EL_UNBUFFERED:
    314 	case EL_PREP_TERM:
    315 		ret = el_wget(el, op, va_arg(ap, int *));
    316 		break;
    317 
    318 	case EL_GETTC: {
    319 		char *argv[20];
    320 		static char gettc[] = "gettc";
    321 		int i;
    322 		for (i = 1; i < (int)__arraycount(argv); ++i)
    323 			if ((argv[i] = va_arg(ap, char *)) == NULL)
    324 				break;
    325 		argv[0] = gettc;
    326 		ret = terminal_gettc(el, i, argv);
    327 		break;
    328 	}
    329 
    330 	/* XXX: do we need to change el_rfunc_t? */
    331 	case EL_GETCFN:         /* el_rfunc_t */
    332 		ret = el_wget(el, op, va_arg(ap, el_rfunc_t *));
    333 		break;
    334 
    335 	case EL_CLIENTDATA:     /* void ** */
    336 		ret = el_wget(el, op, va_arg(ap, void **));
    337 		break;
    338 
    339 	case EL_GETFP: {          /* int, FILE ** */
    340 		int what = va_arg(ap, int);
    341 		FILE **fpp = va_arg(ap, FILE **);
    342 		ret = el_wget(el, op, what, fpp);
    343 		break;
    344 	}
    345 
    346 	default:
    347 		ret = -1;
    348 		break;
    349 	}
    350 
    351 	va_end(ap);
    352 	return ret;
    353 }
    354 
    355 
    356 const LineInfo *
    357 el_line(EditLine *el)
    358 {
    359 	const LineInfoW *winfo = el_wline(el);
    360 	LineInfo *info = &el->el_lgcylinfo;
    361 	size_t offset;
    362 	const Char *p;
    363 
    364 	info->buffer   = ct_encode_string(winfo->buffer, &el->el_lgcyconv);
    365 
    366 	offset = 0;
    367 	for (p = winfo->buffer; p < winfo->cursor; p++)
    368 		offset += ct_enc_width(*p);
    369 	info->cursor = info->buffer + offset;
    370 
    371 	offset = 0;
    372 	for (p = winfo->buffer; p < winfo->lastchar; p++)
    373 		offset += ct_enc_width(*p);
    374 	info->lastchar = info->buffer + offset;
    375 
    376 	return info;
    377 }
    378 
    379 
    380 int
    381 el_insertstr(EditLine *el, const char *str)
    382 {
    383 	return el_winsertstr(el, ct_decode_string(str, &el->el_lgcyconv));
    384 }
    385