Home | History | Annotate | Line # | Download | only in libedit
el.c revision 1.31 
      1 /*	$NetBSD: el.c,v 1.31 2003/06/19 15:55:05 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. All advertising materials mentioning features or use of this software
     19  *    must display the following acknowledgement:
     20  *	This product includes software developed by the University of
     21  *	California, Berkeley and its contributors.
     22  * 4. Neither the name of the University nor the names of its contributors
     23  *    may be used to endorse or promote products derived from this software
     24  *    without specific prior written permission.
     25  *
     26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     36  * SUCH DAMAGE.
     37  */
     38 
     39 #include "config.h"
     40 #if !defined(lint) && !defined(SCCSID)
     41 #if 0
     42 static char sccsid[] = "@(#)el.c	8.2 (Berkeley) 1/3/94";
     43 #else
     44 __RCSID("$NetBSD: el.c,v 1.31 2003/06/19 15:55:05 christos Exp $");
     45 #endif
     46 #endif /* not lint && not SCCSID */
     47 
     48 /*
     49  * el.c: EditLine interface functions
     50  */
     51 #include <sys/types.h>
     52 #include <sys/param.h>
     53 #include <string.h>
     54 #include <stdlib.h>
     55 #include <stdarg.h>
     56 #include "el.h"
     57 
     58 /* el_init():
     59  *	Initialize editline and set default parameters.
     60  */
     61 public EditLine *
     62 el_init(const char *prog, FILE *fin, FILE *fout, FILE *ferr)
     63 {
     64 
     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_infd = fileno(fin);
     73 	el->el_outfile = fout;
     74 	el->el_errfile = ferr;
     75 	el->el_prog = strdup(prog);
     76 
     77 	/*
     78          * Initialize all the modules. Order is important!!!
     79          */
     80 	el->el_flags = 0;
     81 
     82 	if (term_init(el) == -1) {
     83 		free(el->el_prog);
     84 		el_free(el);
     85 		return NULL;
     86 	}
     87 	(void) key_init(el);
     88 	(void) map_init(el);
     89 	if (tty_init(el) == -1)
     90 		el->el_flags |= NO_TTY;
     91 	(void) ch_init(el);
     92 	(void) search_init(el);
     93 	(void) hist_init(el);
     94 	(void) prompt_init(el);
     95 	(void) sig_init(el);
     96 	(void) read_init(el);
     97 
     98 	return (el);
     99 }
    100 
    101 
    102 /* el_end():
    103  *	Clean up.
    104  */
    105 public void
    106 el_end(EditLine *el)
    107 {
    108 
    109 	if (el == NULL)
    110 		return;
    111 
    112 	el_reset(el);
    113 
    114 	term_end(el);
    115 	key_end(el);
    116 	map_end(el);
    117 	tty_end(el);
    118 	ch_end(el);
    119 	search_end(el);
    120 	hist_end(el);
    121 	prompt_end(el);
    122 	sig_end(el);
    123 
    124 	el_free((ptr_t) el->el_prog);
    125 	el_free((ptr_t) el);
    126 }
    127 
    128 
    129 /* el_reset():
    130  *	Reset the tty and the parser
    131  */
    132 public void
    133 el_reset(EditLine *el)
    134 {
    135 
    136 	tty_cookedmode(el);
    137 	ch_reset(el);		/* XXX: Do we want that? */
    138 }
    139 
    140 
    141 /* el_set():
    142  *	set the editline parameters
    143  */
    144 public int
    145 el_set(EditLine *el, int op, ...)
    146 {
    147 	va_list va;
    148 	int rv = 0;
    149 
    150 	if (el == NULL)
    151 		return (-1);
    152 	va_start(va, op);
    153 
    154 	switch (op) {
    155 	case EL_PROMPT:
    156 	case EL_RPROMPT:
    157 		rv = prompt_set(el, va_arg(va, el_pfunc_t), op);
    158 		break;
    159 
    160 	case EL_TERMINAL:
    161 		rv = term_set(el, va_arg(va, char *));
    162 		break;
    163 
    164 	case EL_EDITOR:
    165 		rv = map_set_editor(el, va_arg(va, char *));
    166 		break;
    167 
    168 	case EL_SIGNAL:
    169 		if (va_arg(va, int))
    170 			el->el_flags |= HANDLE_SIGNALS;
    171 		else
    172 			el->el_flags &= ~HANDLE_SIGNALS;
    173 		break;
    174 
    175 	case EL_BIND:
    176 	case EL_TELLTC:
    177 	case EL_SETTC:
    178 	case EL_ECHOTC:
    179 	case EL_SETTY:
    180 	{
    181 		const char *argv[20];
    182 		int i;
    183 
    184 		for (i = 1; i < 20; i++)
    185 			if ((argv[i] = va_arg(va, char *)) == NULL)
    186 				break;
    187 
    188 		switch (op) {
    189 		case EL_BIND:
    190 			argv[0] = "bind";
    191 			rv = map_bind(el, i, argv);
    192 			break;
    193 
    194 		case EL_TELLTC:
    195 			argv[0] = "telltc";
    196 			rv = term_telltc(el, i, argv);
    197 			break;
    198 
    199 		case EL_SETTC:
    200 			argv[0] = "settc";
    201 			rv = term_settc(el, i, argv);
    202 			break;
    203 
    204 		case EL_ECHOTC:
    205 			argv[0] = "echotc";
    206 			rv = term_echotc(el, i, argv);
    207 			break;
    208 
    209 		case EL_SETTY:
    210 			argv[0] = "setty";
    211 			rv = tty_stty(el, i, argv);
    212 			break;
    213 
    214 		default:
    215 			rv = -1;
    216 			EL_ABORT((el->el_errfile, "Bad op %d\n", op));
    217 			break;
    218 		}
    219 		break;
    220 	}
    221 
    222 	case EL_ADDFN:
    223 	{
    224 		char *name = va_arg(va, char *);
    225 		char *help = va_arg(va, char *);
    226 		el_func_t func = va_arg(va, el_func_t);
    227 
    228 		rv = map_addfunc(el, name, help, func);
    229 		break;
    230 	}
    231 
    232 	case EL_HIST:
    233 	{
    234 		hist_fun_t func = va_arg(va, hist_fun_t);
    235 		ptr_t ptr = va_arg(va, char *);
    236 
    237 		rv = hist_set(el, func, ptr);
    238 		break;
    239 	}
    240 
    241 	case EL_EDITMODE:
    242 		if (va_arg(va, int))
    243 			el->el_flags &= ~EDIT_DISABLED;
    244 		else
    245 			el->el_flags |= EDIT_DISABLED;
    246 		rv = 0;
    247 		break;
    248 
    249 	case EL_GETCFN:
    250 	{
    251 		el_rfunc_t rc = va_arg(va, el_rfunc_t);
    252 		rv = el_read_setfn(el, rc);
    253 		break;
    254 	}
    255 
    256 	case EL_CLIENTDATA:
    257 		el->el_data = va_arg(va, void *);
    258 		break;
    259 
    260 	default:
    261 		rv = -1;
    262 		break;
    263 	}
    264 
    265 	va_end(va);
    266 	return (rv);
    267 }
    268 
    269 
    270 /* el_get():
    271  *	retrieve the editline parameters
    272  */
    273 public int
    274 el_get(EditLine *el, int op, void *ret)
    275 {
    276 	int rv;
    277 
    278 	if (el == NULL || ret == NULL)
    279 		return (-1);
    280 	switch (op) {
    281 	case EL_PROMPT:
    282 	case EL_RPROMPT:
    283 		rv = prompt_get(el, (void *) &ret, op);
    284 		break;
    285 
    286 	case EL_EDITOR:
    287 		rv = map_get_editor(el, (void *) &ret);
    288 		break;
    289 
    290 	case EL_SIGNAL:
    291 		*((int *) ret) = (el->el_flags & HANDLE_SIGNALS);
    292 		rv = 0;
    293 		break;
    294 
    295 	case EL_EDITMODE:
    296 		*((int *) ret) = (!(el->el_flags & EDIT_DISABLED));
    297 		rv = 0;
    298 		break;
    299 
    300 #if 0				/* XXX */
    301 	case EL_TERMINAL:
    302 		rv = term_get(el, (const char *) &ret);
    303 		break;
    304 
    305 	case EL_BIND:
    306 	case EL_TELLTC:
    307 	case EL_SETTC:
    308 	case EL_ECHOTC:
    309 	case EL_SETTY:
    310 	{
    311 		const char *argv[20];
    312 		int i;
    313 
    314  		for (i = 1; i < sizeof(argv) / sizeof(argv[0]); i++)
    315 			if ((argv[i] = va_arg(va, char *)) == NULL)
    316 				break;
    317 
    318 		switch (op) {
    319 		case EL_BIND:
    320 			argv[0] = "bind";
    321 			rv = map_bind(el, i, argv);
    322 			break;
    323 
    324 		case EL_TELLTC:
    325 			argv[0] = "telltc";
    326 			rv = term_telltc(el, i, argv);
    327 			break;
    328 
    329 		case EL_SETTC:
    330 			argv[0] = "settc";
    331 			rv = term_settc(el, i, argv);
    332 			break;
    333 
    334 		case EL_ECHOTC:
    335 			argv[0] = "echotc";
    336 			rv = term_echotc(el, i, argv);
    337 			break;
    338 
    339 		case EL_SETTY:
    340 			argv[0] = "setty";
    341 			rv = tty_stty(el, i, argv);
    342 			break;
    343 
    344 		default:
    345 			rv = -1;
    346 			EL_ABORT((el->errfile, "Bad op %d\n", op));
    347 			break;
    348 		}
    349 		break;
    350 	}
    351 
    352 	case EL_ADDFN:
    353 	{
    354 		char *name = va_arg(va, char *);
    355 		char *help = va_arg(va, char *);
    356 		el_func_t func = va_arg(va, el_func_t);
    357 
    358 		rv = map_addfunc(el, name, help, func);
    359 		break;
    360 	}
    361 
    362 	case EL_HIST:
    363 		{
    364 			hist_fun_t func = va_arg(va, hist_fun_t);
    365 			ptr_t ptr = va_arg(va, char *);
    366 			rv = hist_set(el, func, ptr);
    367 		}
    368 		break;
    369 #endif /* XXX */
    370 
    371 	case EL_GETCFN:
    372 		*((el_rfunc_t *)ret) = el_read_getfn(el);
    373 		rv = 0;
    374 		break;
    375 
    376 	case EL_CLIENTDATA:
    377 		*((void **)ret) = el->el_data;
    378 		rv = 0;
    379 		break;
    380 
    381 	default:
    382 		rv = -1;
    383 	}
    384 
    385 	return (rv);
    386 }
    387 
    388 
    389 /* el_line():
    390  *	Return editing info
    391  */
    392 public const LineInfo *
    393 el_line(EditLine *el)
    394 {
    395 
    396 	return (const LineInfo *) (void *) &el->el_line;
    397 }
    398 
    399 
    400 /* el_source():
    401  *	Source a file
    402  */
    403 public int
    404 el_source(EditLine *el, const char *fname)
    405 {
    406 	FILE *fp;
    407 	size_t len;
    408 	char *ptr;
    409 
    410 	fp = NULL;
    411 	if (fname == NULL) {
    412 #ifdef HAVE_ISSETUGID
    413 		static const char elpath[] = "/.editrc";
    414 		char path[MAXPATHLEN];
    415 
    416 		if (issetugid())
    417 			return (-1);
    418 		if ((ptr = getenv("HOME")) == NULL)
    419 			return (-1);
    420 		if (strlcpy(path, ptr, sizeof(path)) >= sizeof(path))
    421 			return (-1);
    422 		if (strlcat(path, elpath, sizeof(path)) >= sizeof(path))
    423 			return (-1);
    424 		fname = path;
    425 #else
    426 		/*
    427 		 * If issetugid() is missing, always return an error, in order
    428 		 * to keep from inadvertently opening up the user to a security
    429 		 * hole.
    430 		 */
    431 		return (-1);
    432 #endif
    433 	}
    434 	if (fp == NULL)
    435 		fp = fopen(fname, "r");
    436 	if (fp == NULL)
    437 		return (-1);
    438 
    439 	while ((ptr = fgetln(fp, &len)) != NULL) {
    440 		if (len > 0 && ptr[len - 1] == '\n')
    441 			--len;
    442 		ptr[len] = '\0';
    443 		if (parse_line(el, ptr) == -1) {
    444 			(void) fclose(fp);
    445 			return (-1);
    446 		}
    447 	}
    448 
    449 	(void) fclose(fp);
    450 	return (0);
    451 }
    452 
    453 
    454 /* el_resize():
    455  *	Called from program when terminal is resized
    456  */
    457 public void
    458 el_resize(EditLine *el)
    459 {
    460 	int lins, cols;
    461 	sigset_t oset, nset;
    462 
    463 	(void) sigemptyset(&nset);
    464 	(void) sigaddset(&nset, SIGWINCH);
    465 	(void) sigprocmask(SIG_BLOCK, &nset, &oset);
    466 
    467 	/* get the correct window size */
    468 	if (term_get_size(el, &lins, &cols))
    469 		term_change_size(el, lins, cols);
    470 
    471 	(void) sigprocmask(SIG_SETMASK, &oset, NULL);
    472 }
    473 
    474 
    475 /* el_beep():
    476  *	Called from the program to beep
    477  */
    478 public void
    479 el_beep(EditLine *el)
    480 {
    481 
    482 	term_beep(el);
    483 }
    484 
    485 
    486 /* el_editmode()
    487  *	Set the state of EDIT_DISABLED from the `edit' command.
    488  */
    489 protected int
    490 /*ARGSUSED*/
    491 el_editmode(EditLine *el, int argc, const char **argv)
    492 {
    493 	const char *how;
    494 
    495 	if (argv == NULL || argc != 2 || argv[1] == NULL)
    496 		return (-1);
    497 
    498 	how = argv[1];
    499 	if (strcmp(how, "on") == 0)
    500 		el->el_flags &= ~EDIT_DISABLED;
    501 	else if (strcmp(how, "off") == 0)
    502 		el->el_flags |= EDIT_DISABLED;
    503 	else {
    504 		(void) fprintf(el->el_errfile, "edit: Bad value `%s'.\n", how);
    505 		return (-1);
    506 	}
    507 	return (0);
    508 }
    509