Home | History | Annotate | Line # | Download | only in libedit
el.c revision 1.57 
      1 /*	$NetBSD: el.c,v 1.57 2009/12/30 23:54:52 christos Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 1992, 1993
      5  *	The Regents of the University of California.  All rights reserved.
      6  *
      7  * This code is derived from software contributed to Berkeley by
      8  * Christos Zoulas of Cornell University.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  * 3. Neither the name of the University nor the names of its contributors
     19  *    may be used to endorse or promote products derived from this software
     20  *    without specific prior written permission.
     21  *
     22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     32  * SUCH DAMAGE.
     33  */
     34 
     35 #include "config.h"
     36 #if !defined(lint) && !defined(SCCSID)
     37 #if 0
     38 static char sccsid[] = "@(#)el.c	8.2 (Berkeley) 1/3/94";
     39 #else
     40 __RCSID("$NetBSD: el.c,v 1.57 2009/12/30 23:54:52 christos Exp $");
     41 #endif
     42 #endif /* not lint && not SCCSID */
     43 
     44 /*
     45  * el.c: EditLine interface functions
     46  */
     47 #include <sys/types.h>
     48 #include <sys/param.h>
     49 #include <string.h>
     50 #include <stdlib.h>
     51 #include <stdarg.h>
     52 #include <ctype.h>
     53 #include <locale.h>
     54 #include "el.h"
     55 
     56 /* el_init():
     57  *	Initialize editline and set default parameters.
     58  */
     59 public EditLine *
     60 el_init(const char *prog, FILE *fin, FILE *fout, FILE *ferr)
     61 {
     62 #ifdef WIDECHAR
     63 	char *locale;
     64 #endif
     65 	EditLine *el = (EditLine *) el_malloc(sizeof(EditLine));
     66 
     67 	if (el == NULL)
     68 		return (NULL);
     69 
     70 	memset(el, 0, sizeof(EditLine));
     71 
     72 	el->el_infile = fin;
     73 	el->el_outfile = fout;
     74 	el->el_errfile = ferr;
     75 
     76 	el->el_infd = fileno(fin);
     77 
     78 	el->el_prog = Strdup(ct_decode_string(prog, &el->el_scratch));
     79 	if (el->el_prog == NULL) {
     80 		el_free(el);
     81 		return NULL;
     82 	}
     83 
     84 	/*
     85          * Initialize all the modules. Order is important!!!
     86          */
     87 	el->el_flags = 0;
     88 #ifdef WIDECHAR
     89 	if ((locale = setlocale(LC_CTYPE, NULL)) != NULL){
     90 		if (strcasestr(locale, ".UTF-8") != NULL)
     91 			el->el_flags |= CHARSET_IS_UTF8;
     92 	}
     93 #endif
     94 
     95 	if (term_init(el) == -1) {
     96 		el_free(el->el_prog);
     97 		el_free(el);
     98 		return NULL;
     99 	}
    100 	(void) key_init(el);
    101 	(void) map_init(el);
    102 	if (tty_init(el) == -1)
    103 		el->el_flags |= NO_TTY;
    104 	(void) ch_init(el);
    105 	(void) search_init(el);
    106 	(void) hist_init(el);
    107 	(void) prompt_init(el);
    108 	(void) sig_init(el);
    109 	(void) read_init(el);
    110 
    111 	return (el);
    112 }
    113 
    114 
    115 /* el_end():
    116  *	Clean up.
    117  */
    118 public void
    119 el_end(EditLine *el)
    120 {
    121 
    122 	if (el == NULL)
    123 		return;
    124 
    125 	el_reset(el);
    126 
    127 	term_end(el);
    128 	key_end(el);
    129 	map_end(el);
    130 	tty_end(el);
    131 	ch_end(el);
    132 	search_end(el);
    133 	hist_end(el);
    134 	prompt_end(el);
    135 	sig_end(el);
    136 
    137 	el_free((ptr_t) el->el_prog);
    138 	el_free((ptr_t) el);
    139 #ifdef WIDECHAR
    140 	el_free((ptr_t) el->el_scratch.cbuff);
    141 	el_free((ptr_t) el->el_scratch.wbuff);
    142 	el_free((ptr_t) el->el_lgcyconv.cbuff);
    143 	el_free((ptr_t) el->el_lgcyconv.wbuff);
    144 #endif
    145 }
    146 
    147 
    148 /* el_reset():
    149  *	Reset the tty and the parser
    150  */
    151 public void
    152 el_reset(EditLine *el)
    153 {
    154 
    155 	tty_cookedmode(el);
    156 	ch_reset(el, 0);		/* XXX: Do we want that? */
    157 }
    158 
    159 
    160 /* el_set():
    161  *	set the editline parameters
    162  */
    163 public int
    164 FUN(el,set)(EditLine *el, int op, ...)
    165 {
    166 	va_list ap;
    167 	int rv = 0;
    168 
    169 	if (el == NULL)
    170 		return (-1);
    171 	va_start(ap, op);
    172 
    173 	switch (op) {
    174 	case EL_PROMPT:
    175 	case EL_RPROMPT: {
    176 		el_pfunc_t p = va_arg(ap, el_pfunc_t);
    177 
    178 		rv = prompt_set(el, p, 0, op, 1);
    179 		break;
    180 	}
    181 
    182 	case EL_PROMPT_ESC:
    183 	case EL_RPROMPT_ESC: {
    184 		el_pfunc_t p = va_arg(ap, el_pfunc_t);
    185 		int c = va_arg(ap, int);
    186 
    187 		rv = prompt_set(el, p, c, op, 1);
    188 		break;
    189 	}
    190 
    191 	case EL_TERMINAL:
    192 		rv = term_set(el, va_arg(ap, char *));
    193 		break;
    194 
    195 	case EL_EDITOR:
    196 		rv = map_set_editor(el, va_arg(ap, Char *));
    197 		break;
    198 
    199 	case EL_SIGNAL:
    200 		if (va_arg(ap, int))
    201 			el->el_flags |= HANDLE_SIGNALS;
    202 		else
    203 			el->el_flags &= ~HANDLE_SIGNALS;
    204 		break;
    205 
    206 	case EL_BIND:
    207 	case EL_TELLTC:
    208 	case EL_SETTC:
    209 	case EL_ECHOTC:
    210 	case EL_SETTY:
    211 	{
    212 		const Char *argv[20];
    213 		int i;
    214 
    215 		for (i = 1; i < 20; i++)
    216 			if ((argv[i] = va_arg(ap, Char *)) == NULL)
    217 				break;
    218 
    219 		switch (op) {
    220 		case EL_BIND:
    221 			argv[0] = STR("bind");
    222 			rv = map_bind(el, i, argv);
    223 			break;
    224 
    225 		case EL_TELLTC:
    226 			argv[0] = STR("telltc");
    227 			rv = term_telltc(el, i, argv);
    228 			break;
    229 
    230 		case EL_SETTC:
    231 			argv[0] = STR("settc");
    232 			rv = term_settc(el, i, argv);
    233 			break;
    234 
    235 		case EL_ECHOTC:
    236 			argv[0] = STR("echotc");
    237 			rv = term_echotc(el, i, argv);
    238 			break;
    239 
    240 		case EL_SETTY:
    241 			argv[0] = STR("setty");
    242 			rv = tty_stty(el, i, argv);
    243 			break;
    244 
    245 		default:
    246 			rv = -1;
    247 			EL_ABORT((el->el_errfile, "Bad op %d\n", op));
    248 			break;
    249 		}
    250 		break;
    251 	}
    252 
    253 	case EL_ADDFN:
    254 	{
    255 		Char *name = va_arg(ap, Char *);
    256 		Char *help = va_arg(ap, Char *);
    257 		el_func_t func = va_arg(ap, el_func_t);
    258 
    259 		rv = map_addfunc(el, name, help, func);
    260 		break;
    261 	}
    262 
    263 	case EL_HIST:
    264 	{
    265 		hist_fun_t func = va_arg(ap, hist_fun_t);
    266 		ptr_t ptr = va_arg(ap, ptr_t);
    267 
    268 		rv = hist_set(el, func, ptr);
    269 		el->el_flags &= ~NARROW_HISTORY;
    270 		break;
    271 	}
    272 
    273 	case EL_EDITMODE:
    274 		if (va_arg(ap, int))
    275 			el->el_flags &= ~EDIT_DISABLED;
    276 		else
    277 			el->el_flags |= EDIT_DISABLED;
    278 		rv = 0;
    279 		break;
    280 
    281 	case EL_GETCFN:
    282 	{
    283 		el_rfunc_t rc = va_arg(ap, el_rfunc_t);
    284 		rv = el_read_setfn(el, rc);
    285 		break;
    286 	}
    287 
    288 	case EL_CLIENTDATA:
    289 		el->el_data = va_arg(ap, void *);
    290 		break;
    291 
    292 	case EL_UNBUFFERED:
    293 		rv = va_arg(ap, int);
    294 		if (rv && !(el->el_flags & UNBUFFERED)) {
    295 			el->el_flags |= UNBUFFERED;
    296 			read_prepare(el);
    297 		} else if (!rv && (el->el_flags & UNBUFFERED)) {
    298 			el->el_flags &= ~UNBUFFERED;
    299 			read_finish(el);
    300 		}
    301 		rv = 0;
    302 		break;
    303 
    304 	case EL_PREP_TERM:
    305 		rv = va_arg(ap, int);
    306 		if (rv)
    307 			(void) tty_rawmode(el);
    308 		else
    309 			(void) tty_cookedmode(el);
    310 		rv = 0;
    311 		break;
    312 
    313 	case EL_SETFP:
    314 	{
    315 		FILE *fp;
    316 		int what;
    317 
    318 		what = va_arg(ap, int);
    319 		fp = va_arg(ap, FILE *);
    320 
    321 		rv = 0;
    322 		switch (what) {
    323 		case 0:
    324 			el->el_infile = fp;
    325 			el->el_infd = fileno(fp);
    326 			break;
    327 		case 1:
    328 			el->el_outfile = fp;
    329 			break;
    330 		case 2:
    331 			el->el_errfile = fp;
    332 			break;
    333 		default:
    334 			rv = -1;
    335 			break;
    336 		}
    337 		break;
    338 	}
    339 
    340 	case EL_REFRESH:
    341 		re_clear_display(el);
    342 		re_refresh(el);
    343 		term__flush(el);
    344 		break;
    345 
    346 	default:
    347 		rv = -1;
    348 		break;
    349 	}
    350 
    351 	va_end(ap);
    352 	return (rv);
    353 }
    354 
    355 
    356 /* el_get():
    357  *	retrieve the editline parameters
    358  */
    359 public int
    360 FUN(el,get)(EditLine *el, int op, ...)
    361 {
    362 	va_list ap;
    363 	int rv;
    364 
    365 	if (el == NULL)
    366 		return -1;
    367 
    368 	va_start(ap, op);
    369 
    370 	switch (op) {
    371 	case EL_PROMPT:
    372 	case EL_RPROMPT: {
    373 		el_pfunc_t *p = va_arg(ap, el_pfunc_t *);
    374 		rv = prompt_get(el, p, 0, op);
    375 		break;
    376 	}
    377 	case EL_PROMPT_ESC:
    378 	case EL_RPROMPT_ESC: {
    379 		el_pfunc_t *p = va_arg(ap, el_pfunc_t *);
    380 		Char *c = va_arg(ap, Char *);
    381 
    382 		rv = prompt_get(el, p, c, op);
    383 		break;
    384 	}
    385 
    386 	case EL_EDITOR:
    387 		rv = map_get_editor(el, va_arg(ap, const Char **));
    388 		break;
    389 
    390 	case EL_SIGNAL:
    391 		*va_arg(ap, int *) = (el->el_flags & HANDLE_SIGNALS);
    392 		rv = 0;
    393 		break;
    394 
    395 	case EL_EDITMODE:
    396 		*va_arg(ap, int *) = !(el->el_flags & EDIT_DISABLED);
    397 		rv = 0;
    398 		break;
    399 
    400 	case EL_TERMINAL:
    401 		term_get(el, va_arg(ap, const char **));
    402 		rv = 0;
    403 		break;
    404 
    405 	case EL_GETTC:
    406 	{
    407 		static char name[] = "gettc";
    408 		char *argv[20];
    409 		int i;
    410 
    411  		for (i = 1; i < (int)(sizeof(argv) / sizeof(argv[0])); i++)
    412 			if ((argv[i] = va_arg(ap, char *)) == NULL)
    413 				break;
    414 
    415 		switch (op) {
    416 		case EL_GETTC:
    417 			argv[0] = name;
    418 			rv = term_gettc(el, i, argv);
    419 			break;
    420 
    421 		default:
    422 			rv = -1;
    423 			EL_ABORT((el->el_errfile, "Bad op %d\n", op));
    424 			break;
    425 		}
    426 		break;
    427 	}
    428 
    429 	case EL_GETCFN:
    430 		*va_arg(ap, el_rfunc_t *) = el_read_getfn(el);
    431 		rv = 0;
    432 		break;
    433 
    434 	case EL_CLIENTDATA:
    435 		*va_arg(ap, void **) = el->el_data;
    436 		rv = 0;
    437 		break;
    438 
    439 	case EL_UNBUFFERED:
    440 		*va_arg(ap, int *) = (!(el->el_flags & UNBUFFERED));
    441 		rv = 0;
    442 		break;
    443 
    444 	case EL_GETFP:
    445 	{
    446 		int what;
    447 		FILE **fpp;
    448 
    449 		what = va_arg(ap, int);
    450 		fpp = va_arg(ap, FILE **);
    451 		rv = 0;
    452 		switch (what) {
    453 		case 0:
    454 			*fpp = el->el_infile;
    455 			break;
    456 		case 1:
    457 			*fpp = el->el_outfile;
    458 			break;
    459 		case 2:
    460 			*fpp = el->el_errfile;
    461 			break;
    462 		default:
    463 			rv = -1;
    464 			break;
    465 		}
    466 		break;
    467 	}
    468 	default:
    469 		rv = -1;
    470 		break;
    471 	}
    472 	va_end(ap);
    473 
    474 	return (rv);
    475 }
    476 
    477 
    478 /* el_line():
    479  *	Return editing info
    480  */
    481 public const TYPE(LineInfo) *
    482 FUN(el,line)(EditLine *el)
    483 {
    484 
    485 	return (const TYPE(LineInfo) *) (void *) &el->el_line;
    486 }
    487 
    488 
    489 /* el_source():
    490  *	Source a file
    491  */
    492 public int
    493 el_source(EditLine *el, const char *fname)
    494 {
    495 	FILE *fp;
    496 	size_t len;
    497 	char *ptr;
    498 #ifdef HAVE_ISSETUGID
    499 	char path[MAXPATHLEN];
    500 #endif
    501 	const Char *dptr;
    502 
    503 	fp = NULL;
    504 	if (fname == NULL) {
    505 #ifdef HAVE_ISSETUGID
    506 		static const char elpath[] = "/.editrc";
    507 
    508 		if (issetugid())
    509 			return (-1);
    510 		if ((ptr = getenv("HOME")) == NULL)
    511 			return (-1);
    512 		if (strlcpy(path, ptr, sizeof(path)) >= sizeof(path))
    513 			return (-1);
    514 		if (strlcat(path, elpath, sizeof(path)) >= sizeof(path))
    515 			return (-1);
    516 		fname = path;
    517 #else
    518 		/*
    519 		 * If issetugid() is missing, always return an error, in order
    520 		 * to keep from inadvertently opening up the user to a security
    521 		 * hole.
    522 		 */
    523 		return (-1);
    524 #endif
    525 	}
    526 	if (fp == NULL)
    527 		fp = fopen(fname, "r");
    528 	if (fp == NULL)
    529 		return (-1);
    530 
    531 	while ((ptr = fgetln(fp, &len)) != NULL) {
    532 		dptr = ct_decode_string(ptr, &el->el_scratch);
    533 		if (!dptr)
    534 			continue;
    535 		if (len > 0 && dptr[len - 1] == '\n')
    536 			--len;
    537 
    538 		/* loop until first non-space char or EOL */
    539 		while (*dptr != '\0' && Isspace(*dptr))
    540 			dptr++;
    541 		if (*dptr == '#')
    542 			continue;   /* ignore, this is a comment line */
    543 		if (parse_line(el, dptr) == -1) {
    544 			(void) fclose(fp);
    545 			return (-1);
    546 		}
    547 	}
    548 
    549 	(void) fclose(fp);
    550 	return (0);
    551 }
    552 
    553 
    554 /* el_resize():
    555  *	Called from program when terminal is resized
    556  */
    557 public void
    558 el_resize(EditLine *el)
    559 {
    560 	int lins, cols;
    561 	sigset_t oset, nset;
    562 
    563 	(void) sigemptyset(&nset);
    564 	(void) sigaddset(&nset, SIGWINCH);
    565 	(void) sigprocmask(SIG_BLOCK, &nset, &oset);
    566 
    567 	/* get the correct window size */
    568 	if (term_get_size(el, &lins, &cols))
    569 		term_change_size(el, lins, cols);
    570 
    571 	(void) sigprocmask(SIG_SETMASK, &oset, NULL);
    572 }
    573 
    574 
    575 /* el_beep():
    576  *	Called from the program to beep
    577  */
    578 public void
    579 el_beep(EditLine *el)
    580 {
    581 
    582 	term_beep(el);
    583 }
    584 
    585 
    586 /* el_editmode()
    587  *	Set the state of EDIT_DISABLED from the `edit' command.
    588  */
    589 protected int
    590 /*ARGSUSED*/
    591 el_editmode(EditLine *el, int argc, const Char **argv)
    592 {
    593 	const Char *how;
    594 
    595 	if (argv == NULL || argc != 2 || argv[1] == NULL)
    596 		return (-1);
    597 
    598 	how = argv[1];
    599 	if (Strcmp(how, STR("on")) == 0) {
    600 		el->el_flags &= ~EDIT_DISABLED;
    601 		tty_rawmode(el);
    602 	} else if (Strcmp(how, STR("off")) == 0) {
    603 		tty_cookedmode(el);
    604 		el->el_flags |= EDIT_DISABLED;
    605 	}
    606 	else {
    607 		(void) fprintf(el->el_errfile, "edit: Bad value `" FSTR "'.\n",
    608 		    how);
    609 		return (-1);
    610 	}
    611 	return (0);
    612 }
    613