Home | History | Annotate | Line # | Download | only in libedit
      1 /*	$NetBSD: el.c,v 1.106 2026/11/14 17:50:15 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.106 2026/11/14 17:50:15 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 <ctype.h>
     50 #include <langinfo.h>
     51 #include <locale.h>
     52 #include <stdarg.h>
     53 #include <stdlib.h>
     54 #include <string.h>
     55 
     56 #include "el.h"
     57 #include "parse.h"
     58 #include "read.h"
     59 
     60 typedef char * (*func_t)(const char *);
     61 
     62 /* el_init():
     63  *	Initialize editline and set default parameters.
     64  */
     65 EditLine *
     66 el_init(const char *prog, FILE *fin, FILE *fout, FILE *ferr)
     67 {
     68     return el_init_fd(prog, fin, fout, ferr, fileno(fin), fileno(fout),
     69 	fileno(ferr));
     70 }
     71 
     72 libedit_private EditLine *
     73 el_init_internal(const char *prog, FILE *fin, FILE *fout, FILE *ferr,
     74     int fdin, int fdout, int fderr, int flags)
     75 {
     76 	EditLine *el = el_calloc(1, sizeof(*el));
     77 
     78 	if (el == NULL)
     79 		return NULL;
     80 
     81 	el->el_infile = fin;
     82 	el->el_outfile = fout;
     83 	el->el_errfile = ferr;
     84 
     85 	el->el_infd = fdin;
     86 	el->el_outfd = fdout;
     87 	el->el_errfd = fderr;
     88 
     89 	el->el_getenv = getenv;
     90 
     91 	el->el_prog = wcsdup(ct_decode_string(prog, &el->el_scratch));
     92 	if (el->el_prog == NULL) {
     93 		el_free(el);
     94 		return NULL;
     95 	}
     96 
     97 	/*
     98          * Initialize all the modules. Order is important!!!
     99          */
    100 	el->el_flags = flags;
    101 
    102 	if (terminal_init(el) == -1) {
    103 		el_free(el->el_scratch.cbuff);
    104 		el_free(el->el_scratch.wbuff);
    105 		el_free(el->el_prog);
    106 		el_free(el);
    107 		return NULL;
    108 	}
    109 	(void) keymacro_init(el);
    110 	(void) map_init(el);
    111 	if (tty_init(el) == -1)
    112 		el->el_flags |= NO_TTY;
    113 	(void) ch_init(el);
    114 	(void) search_init(el);
    115 	(void) hist_init(el);
    116 	(void) prompt_init(el);
    117 	(void) sig_init(el);
    118 	(void) literal_init(el);
    119 	if (read_init(el) == -1) {
    120 		el_end(el);
    121 		return NULL;
    122 	}
    123 	return el;
    124 }
    125 
    126 EditLine *
    127 el_init_fd(const char *prog, FILE *fin, FILE *fout, FILE *ferr,
    128     int fdin, int fdout, int fderr)
    129 {
    130 	return el_init_internal(prog, fin, fout, ferr, fdin, fdout, fderr, 0);
    131 }
    132 
    133 /* el_end():
    134  *	Clean up.
    135  */
    136 void
    137 el_end(EditLine *el)
    138 {
    139 
    140 	if (el == NULL)
    141 		return;
    142 
    143 	el_reset(el);
    144 
    145 	terminal_end(el);
    146 	keymacro_end(el);
    147 	map_end(el);
    148 	if (!(el->el_flags & NO_TTY))
    149 		tty_end(el, TCSAFLUSH);
    150 	ch_end(el);
    151 	read_end(el);
    152 	search_end(el);
    153 	hist_end(el);
    154 	prompt_end(el);
    155 	sig_end(el);
    156 	literal_end(el);
    157 
    158 	el_free(el->el_prog);
    159 	el_free(el->el_visual.cbuff);
    160 	el_free(el->el_visual.wbuff);
    161 	el_free(el->el_scratch.cbuff);
    162 	el_free(el->el_scratch.wbuff);
    163 	el_free(el->el_lgcyconv.cbuff);
    164 	el_free(el->el_lgcyconv.wbuff);
    165 	el_free(el);
    166 }
    167 
    168 
    169 /* el_reset():
    170  *	Reset the tty and the parser
    171  */
    172 void
    173 el_reset(EditLine *el)
    174 {
    175 
    176 	tty_cookedmode(el);
    177 	el->el_refresh.r_error = 0;
    178 	ch_reset(el);		/* XXX: Do we want that? */
    179 }
    180 
    181 
    182 /* el_set():
    183  *	set the editline parameters
    184  */
    185 int
    186 el_wset(EditLine *el, int op, ...)
    187 {
    188 	va_list ap;
    189 	int rv = 0;
    190 
    191 	if (el == NULL)
    192 		return -1;
    193 	va_start(ap, op);
    194 
    195 	switch (op) {
    196 	case EL_PROMPT:
    197 	case EL_RPROMPT: {
    198 		el_pfunc_t p = va_arg(ap, el_pfunc_t);
    199 
    200 		rv = prompt_set(el, p, 0, op, 1);
    201 		break;
    202 	}
    203 
    204 	case EL_RESIZE: {
    205 		el_zfunc_t p = va_arg(ap, el_zfunc_t);
    206 		void *arg = va_arg(ap, void *);
    207 		rv = ch_resizefun(el, p, arg);
    208 		break;
    209 	}
    210 
    211 	case EL_ALIAS_TEXT: {
    212 		el_afunc_t p = va_arg(ap, el_afunc_t);
    213 		void *arg = va_arg(ap, void *);
    214 		rv = ch_aliasfun(el, p, arg);
    215 		break;
    216 	}
    217 
    218 	case EL_PROMPT_ESC:
    219 	case EL_RPROMPT_ESC: {
    220 		el_pfunc_t p = va_arg(ap, el_pfunc_t);
    221 		int c = va_arg(ap, int);
    222 
    223 		rv = prompt_set(el, p, (wchar_t)c, op, 1);
    224 		break;
    225 	}
    226 
    227 	case EL_TERMINAL:
    228 		rv = terminal_set(el, va_arg(ap, char *));
    229 		break;
    230 
    231 	case EL_EDITOR:
    232 		rv = map_set_editor(el, va_arg(ap, wchar_t *));
    233 		break;
    234 
    235 	case EL_SIGNAL:
    236 		if (va_arg(ap, int))
    237 			el->el_flags |= HANDLE_SIGNALS;
    238 		else
    239 			el->el_flags &= ~HANDLE_SIGNALS;
    240 		break;
    241 
    242 	case EL_BIND:
    243 	case EL_TELLTC:
    244 	case EL_SETTC:
    245 	case EL_ECHOTC:
    246 	case EL_SETTY:
    247 	{
    248 		const wchar_t *argv[20];
    249 		int i;
    250 
    251 		for (i = 1; i < (int)__arraycount(argv); i++)
    252 			if ((argv[i] = va_arg(ap, wchar_t *)) == NULL)
    253 				break;
    254 
    255 		switch (op) {
    256 		case EL_BIND:
    257 			argv[0] = L"bind";
    258 			rv = map_bind(el, i, argv);
    259 			break;
    260 
    261 		case EL_TELLTC:
    262 			argv[0] = L"telltc";
    263 			rv = terminal_telltc(el, i, argv);
    264 			break;
    265 
    266 		case EL_SETTC:
    267 			argv[0] = L"settc";
    268 			rv = terminal_settc(el, i, argv);
    269 			break;
    270 
    271 		case EL_ECHOTC:
    272 			argv[0] = L"echotc";
    273 			rv = terminal_echotc(el, i, argv);
    274 			break;
    275 
    276 		case EL_SETTY:
    277 			argv[0] = L"setty";
    278 			rv = tty_stty(el, i, argv);
    279 			break;
    280 
    281 		default:
    282 			rv = -1;
    283 			EL_ABORT((el->el_errfile, "Bad op %d\n", op));
    284 		}
    285 		break;
    286 	}
    287 
    288 	case EL_ADDFN:
    289 	{
    290 		wchar_t *name = va_arg(ap, wchar_t *);
    291 		wchar_t *help = va_arg(ap, wchar_t *);
    292 		el_func_t func = va_arg(ap, el_func_t);
    293 
    294 		rv = map_addfunc(el, name, help, func);
    295 		break;
    296 	}
    297 
    298 	case EL_HIST:
    299 	{
    300 		hist_fun_t func = va_arg(ap, hist_fun_t);
    301 		void *ptr = va_arg(ap, void *);
    302 
    303 		rv = hist_set(el, func, ptr);
    304 		if (MB_CUR_MAX == 1)
    305 			el->el_flags &= ~NARROW_HISTORY;
    306 		break;
    307 	}
    308 
    309 	case EL_SAFEREAD:
    310 		if (va_arg(ap, int))
    311 			el->el_flags |= FIXIO;
    312 		else
    313 			el->el_flags &= ~FIXIO;
    314 		rv = 0;
    315 		break;
    316 
    317 	case EL_EDITMODE:
    318 		if (va_arg(ap, int))
    319 			el->el_flags &= ~EDIT_DISABLED;
    320 		else
    321 			el->el_flags |= EDIT_DISABLED;
    322 		rv = 0;
    323 		break;
    324 
    325 	case EL_GETCFN:
    326 	{
    327 		el_rfunc_t rc = va_arg(ap, el_rfunc_t);
    328 		rv = el_read_setfn(el->el_read, rc);
    329 		break;
    330 	}
    331 
    332 	case EL_CLIENTDATA:
    333 		el->el_data = va_arg(ap, void *);
    334 		break;
    335 
    336 	case EL_UNBUFFERED:
    337 		rv = va_arg(ap, int);
    338 		if (rv && !(el->el_flags & UNBUFFERED)) {
    339 			el->el_flags |= UNBUFFERED;
    340 			read_prepare(el);
    341 			if (el->el_refresh.r_error) {
    342 				rv = -1;
    343 				break;
    344 			}
    345 		} else if (!rv && (el->el_flags & UNBUFFERED)) {
    346 			el->el_flags &= ~UNBUFFERED;
    347 			read_finish(el);
    348 		}
    349 		rv = 0;
    350 		break;
    351 
    352 	case EL_PREP_TERM:
    353 		rv = va_arg(ap, int);
    354 		if (rv)
    355 			(void) tty_rawmode(el);
    356 		else
    357 			(void) tty_cookedmode(el);
    358 		rv = 0;
    359 		break;
    360 
    361 	case EL_SETFP:
    362 	{
    363 		FILE *fp;
    364 		int what;
    365 
    366 		what = va_arg(ap, int);
    367 		fp = va_arg(ap, FILE *);
    368 
    369 		rv = 0;
    370 		switch (what) {
    371 		case 0:
    372 			el->el_infile = fp;
    373 			el->el_infd = fileno(fp);
    374 			break;
    375 		case 1:
    376 			el->el_outfile = fp;
    377 			el->el_outfd = fileno(fp);
    378 			break;
    379 		case 2:
    380 			el->el_errfile = fp;
    381 			el->el_errfd = fileno(fp);
    382 			break;
    383 		default:
    384 			rv = -1;
    385 			break;
    386 		}
    387 		break;
    388 	}
    389 
    390 	case EL_REFRESH:
    391 		el->el_refresh.r_error = 0;
    392 		re_clear_display(el);
    393 		re_refresh(el);
    394 		terminal__flush(el);
    395 		if (el->el_refresh.r_error)
    396 			rv = -1;
    397 		break;
    398 
    399 	case EL_WORDCHARS:
    400 		rv = map_set_wordchars(el, va_arg(ap, wchar_t *));
    401 		break;
    402 
    403 	case EL_GETENV:
    404 		el->el_getenv = va_arg(ap, func_t);
    405 		break;
    406 
    407 	case EL_MATCH_HIDDEN_FILES:
    408 		if (va_arg(ap, int))
    409 			el->el_flags |= MATCH_HIDDEN_FILES;
    410 		else
    411 			el->el_flags &= ~MATCH_HIDDEN_FILES;
    412 		break;
    413 
    414 	default:
    415 		rv = -1;
    416 		break;
    417 	}
    418 
    419 	va_end(ap);
    420 	return rv;
    421 }
    422 
    423 
    424 /* el_get():
    425  *	retrieve the editline parameters
    426  */
    427 int
    428 el_wget(EditLine *el, int op, ...)
    429 {
    430 	va_list ap;
    431 	int rv;
    432 
    433 	if (el == NULL)
    434 		return -1;
    435 
    436 	va_start(ap, op);
    437 
    438 	switch (op) {
    439 	case EL_PROMPT:
    440 	case EL_RPROMPT: {
    441 		el_pfunc_t *p = va_arg(ap, el_pfunc_t *);
    442 		rv = prompt_get(el, p, 0, op);
    443 		break;
    444 	}
    445 	case EL_PROMPT_ESC:
    446 	case EL_RPROMPT_ESC: {
    447 		el_pfunc_t *p = va_arg(ap, el_pfunc_t *);
    448 		wchar_t *c = va_arg(ap, wchar_t *);
    449 
    450 		rv = prompt_get(el, p, c, op);
    451 		break;
    452 	}
    453 
    454 	case EL_EDITOR:
    455 		rv = map_get_editor(el, va_arg(ap, const wchar_t **));
    456 		break;
    457 
    458 	case EL_SIGNAL:
    459 		*va_arg(ap, int *) = (el->el_flags & HANDLE_SIGNALS);
    460 		rv = 0;
    461 		break;
    462 
    463 	case EL_EDITMODE:
    464 		*va_arg(ap, int *) = !(el->el_flags & EDIT_DISABLED);
    465 		rv = 0;
    466 		break;
    467 
    468 	case EL_SAFEREAD:
    469 		*va_arg(ap, int *) = (el->el_flags & FIXIO);
    470 		rv = 0;
    471 		break;
    472 
    473 	case EL_TERMINAL:
    474 		terminal_get(el, va_arg(ap, const char **));
    475 		rv = 0;
    476 		break;
    477 
    478 	case EL_GETTC:
    479 	{
    480 		static char name[] = "gettc";
    481 		char *argv[3];
    482 		argv[0] = name;
    483 		argv[1] = va_arg(ap, char *);
    484 		argv[2] = va_arg(ap, void *);
    485 		rv = terminal_gettc(el, 3, argv);
    486 		break;
    487 	}
    488 
    489 	case EL_GETCFN:
    490 		*va_arg(ap, el_rfunc_t *) = el_read_getfn(el->el_read);
    491 		rv = 0;
    492 		break;
    493 
    494 	case EL_CLIENTDATA:
    495 		*va_arg(ap, void **) = el->el_data;
    496 		rv = 0;
    497 		break;
    498 
    499 	case EL_UNBUFFERED:
    500 		*va_arg(ap, int *) = (el->el_flags & UNBUFFERED) != 0;
    501 		rv = 0;
    502 		break;
    503 
    504 	case EL_GETFP:
    505 	{
    506 		int what;
    507 		FILE **fpp;
    508 
    509 		what = va_arg(ap, int);
    510 		fpp = va_arg(ap, FILE **);
    511 		rv = 0;
    512 		switch (what) {
    513 		case 0:
    514 			*fpp = el->el_infile;
    515 			break;
    516 		case 1:
    517 			*fpp = el->el_outfile;
    518 			break;
    519 		case 2:
    520 			*fpp = el->el_errfile;
    521 			break;
    522 		default:
    523 			rv = -1;
    524 			break;
    525 		}
    526 		break;
    527 	}
    528 
    529 	case EL_WORDCHARS:
    530 		rv = map_get_wordchars(el, va_arg(ap, const wchar_t **));
    531 		break;
    532 
    533 	case EL_GETENV:
    534 		*va_arg(ap, func_t *) = el->el_getenv;
    535 		rv = 0;
    536 		break;
    537 
    538 	case EL_MATCH_HIDDEN_FILES:
    539 		*va_arg(ap, int *) = el->el_flags & MATCH_HIDDEN_FILES ? 1 : 0;
    540 		rv = 0;
    541 		break;
    542 
    543 	default:
    544 		rv = -1;
    545 		break;
    546 	}
    547 	va_end(ap);
    548 
    549 	return rv;
    550 }
    551 
    552 
    553 /* el_line():
    554  *	Return editing info
    555  */
    556 const LineInfoW *
    557 el_wline(EditLine *el)
    558 {
    559 
    560 	return (const LineInfoW *)(void *)&el->el_line;
    561 }
    562 
    563 
    564 /* el_source():
    565  *	Source a file
    566  */
    567 int
    568 el_source(EditLine *el, const char *fname)
    569 {
    570 	FILE *fp;
    571 	size_t len;
    572 	ssize_t slen;
    573 	char *ptr;
    574 	char *path = NULL;
    575 	const wchar_t *dptr;
    576 	int error = 0;
    577 
    578 	fp = NULL;
    579 	if (fname == NULL) {
    580 #ifdef HAVE_ISSETUGID
    581 		if (issetugid())
    582 			return -1;
    583 
    584 		if ((fname = (el->el_getenv)("EDITRC")) == NULL) {
    585 			static const char elpath[] = "/.editrc";
    586 			size_t plen = sizeof(elpath);
    587 
    588 			if ((ptr = (el->el_getenv)("HOME")) == NULL)
    589 				return -1;
    590 			plen += strlen(ptr);
    591 			if ((path = el_calloc(plen, sizeof(*path))) == NULL)
    592 				return -1;
    593 			(void)snprintf(path, plen, "%s%s", ptr,
    594 				elpath + (*ptr == '\0'));
    595 			fname = path;
    596 		}
    597 #else
    598 		/*
    599 		 * If issetugid() is missing, always return an error, in order
    600 		 * to keep from inadvertently opening up the user to a security
    601 		 * hole.
    602 		 */
    603 		return -1;
    604 #endif
    605 	}
    606 	if (fname[0] == '\0')
    607 		return -1;
    608 
    609 	if (fp == NULL)
    610 		fp = fopen(fname, "r");
    611 	if (fp == NULL) {
    612 		el_free(path);
    613 		return -1;
    614 	}
    615 
    616 	ptr = NULL;
    617 	len = 0;
    618 	while ((slen = getline(&ptr, &len, fp)) != -1) {
    619 		if (*ptr == '\n')
    620 			continue;	/* Empty line. */
    621 		if (slen > 0 && ptr[--slen] == '\n')
    622 			ptr[slen] = '\0';
    623 
    624 		dptr = ct_decode_string(ptr, &el->el_scratch);
    625 		if (!dptr)
    626 			continue;
    627 		/* loop until first non-space char or EOL */
    628 		while (*dptr != '\0' && iswspace(*dptr))
    629 			dptr++;
    630 		if (*dptr == '#')
    631 			continue;   /* ignore, this is a comment line */
    632 		if ((error = parse_line(el, dptr)) == -1)
    633 			break;
    634 	}
    635 	free(ptr);
    636 
    637 	el_free(path);
    638 	(void) fclose(fp);
    639 	return error;
    640 }
    641 
    642 
    643 /* el_resize():
    644  *	Called from program when terminal is resized
    645  */
    646 void
    647 el_resize(EditLine *el)
    648 {
    649 	int lins, cols;
    650 	sigset_t oset, nset;
    651 
    652 	(void) sigemptyset(&nset);
    653 	(void) sigaddset(&nset, SIGWINCH);
    654 	(void) sigprocmask(SIG_BLOCK, &nset, &oset);
    655 
    656 	/* get the correct window size */
    657 	if (terminal_get_size(el, &lins, &cols))
    658 		terminal_change_size(el, lins, cols);
    659 
    660 	(void) sigprocmask(SIG_SETMASK, &oset, NULL);
    661 }
    662 
    663 
    664 /* el_beep():
    665  *	Called from the program to beep
    666  */
    667 void
    668 el_beep(EditLine *el)
    669 {
    670 
    671 	terminal_beep(el);
    672 }
    673 
    674 
    675 /* el_editmode()
    676  *	Set the state of EDIT_DISABLED from the `edit' command.
    677  */
    678 libedit_private int
    679 /*ARGSUSED*/
    680 el_editmode(EditLine *el, int argc, const wchar_t **argv)
    681 {
    682 	const wchar_t *how;
    683 
    684 	if (argv == NULL || argc != 2 || argv[1] == NULL)
    685 		return -1;
    686 
    687 	how = argv[1];
    688 	if (wcscmp(how, L"on") == 0) {
    689 		el->el_flags &= ~EDIT_DISABLED;
    690 		tty_rawmode(el);
    691 	} else if (wcscmp(how, L"off") == 0) {
    692 		tty_cookedmode(el);
    693 		el->el_flags |= EDIT_DISABLED;
    694 	}
    695 	else {
    696 		(void) fprintf(el->el_errfile, "edit: Bad value `%ls'.\n",
    697 		    how);
    698 		return -1;
    699 	}
    700 	return 0;
    701 }
    702