1/*	$NetBSD: histedit.c,v 1.43 2011/06/18 21:18:46 christos Exp $	*/
2
3/*-
4 * Copyright (c) 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 * Kenneth Almquist.
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 <sys/cdefs.h>
36#ifndef lint
37#if 0
38static char sccsid[] = "@(#)histedit.c	8.2 (Berkeley) 5/4/95";
39#else
40__RCSID("$NetBSD: histedit.c,v 1.43 2011/06/18 21:18:46 christos Exp $");
41#endif
42#endif /* not lint */
43
44#include <sys/param.h>
45#include <paths.h>
46#include <stdio.h>
47#include <stdlib.h>
48#include <unistd.h>
49/*
50 * Editline and history functions (and glue).
51 */
52#include "shell.h"
53#include "parser.h"
54#include "var.h"
55#include "options.h"
56#include "builtins.h"
57#include "main.h"
58#include "output.h"
59#include "mystring.h"
60#include "myhistedit.h"
61#include "error.h"
62#ifndef SMALL
63#include "eval.h"
64#include "memalloc.h"
65
66#define MAXHISTLOOPS	4	/* max recursions through fc */
67#define DEFEDITOR	"ed"	/* default editor *should* be $EDITOR */
68
69History *hist;	/* history cookie */
70EditLine *el;	/* editline cookie */
71int displayhist;
72static FILE *el_in, *el_out;
73unsigned char _el_fn_complete(EditLine *, int);
74
75STATIC const char *fc_replace(const char *, char *, char *);
76
77#ifdef DEBUG
78extern FILE *tracefile;
79#endif
80
81/*
82 * Set history and editing status.  Called whenever the status may
83 * have changed (figures out what to do).
84 */
85void
86histedit(void)
87{
88	FILE *el_err;
89
90#define editing (Eflag || Vflag)
91
92	if (iflag == 1) {
93		if (!hist) {
94			/*
95			 * turn history on
96			 */
97			INTOFF;
98			hist = history_init();
99			INTON;
100
101			if (hist != NULL)
102				sethistsize(histsizeval());
103			else
104				out2str("sh: can't initialize history\n");
105		}
106		if (editing && !el && isatty(0)) { /* && isatty(2) ??? */
107			/*
108			 * turn editing on
109			 */
110			char *term, *shname;
111
112			INTOFF;
113			if (el_in == NULL)
114				el_in = fdopen(0, "r");
115			if (el_out == NULL)
116				el_out = fdopen(2, "w");
117			if (el_in == NULL || el_out == NULL)
118				goto bad;
119			el_err = el_out;
120#if DEBUG
121			if (tracefile)
122				el_err = tracefile;
123#endif
124			term = lookupvar("TERM");
125			if (term)
126				setenv("TERM", term, 1);
127			else
128				unsetenv("TERM");
129			shname = arg0;
130			if (shname[0] == '-')
131				shname++;
132			el = el_init(shname, el_in, el_out, el_err);
133			if (el != NULL) {
134				if (hist)
135					el_set(el, EL_HIST, history, hist);
136				el_set(el, EL_PROMPT, getprompt);
137				el_set(el, EL_SIGNAL, 1);
138				el_set(el, EL_ADDFN, "rl-complete",
139				    "ReadLine compatible completion function",
140				    _el_fn_complete);
141			} else {
142bad:
143				out2str("sh: can't initialize editing\n");
144			}
145			INTON;
146		} else if (!editing && el) {
147			INTOFF;
148			el_end(el);
149			el = NULL;
150			INTON;
151		}
152		if (el) {
153			el_source(el, NULL);
154			if (Vflag)
155				el_set(el, EL_EDITOR, "vi");
156			else if (Eflag)
157				el_set(el, EL_EDITOR, "emacs");
158			el_set(el, EL_BIND, "^I",
159			    tabcomplete ? "rl-complete" : "ed-insert", NULL);
160		}
161	} else {
162		INTOFF;
163		if (el) {	/* no editing if not interactive */
164			el_end(el);
165			el = NULL;
166		}
167		if (hist) {
168			history_end(hist);
169			hist = NULL;
170		}
171		INTON;
172	}
173}
174
175
176void
177sethistsize(const char *hs)
178{
179	int histsize;
180	HistEvent he;
181
182	if (hist != NULL) {
183		if (hs == NULL || *hs == '\0' ||
184		   (histsize = atoi(hs)) < 0)
185			histsize = 100;
186		history(hist, &he, H_SETSIZE, histsize);
187		history(hist, &he, H_SETUNIQUE, 1);
188	}
189}
190
191void
192setterm(const char *term)
193{
194	if (el != NULL && term != NULL)
195		if (el_set(el, EL_TERMINAL, term) != 0) {
196			outfmt(out2, "sh: Can't set terminal type %s\n", term);
197			outfmt(out2, "sh: Using dumb terminal settings.\n");
198		}
199}
200
201int
202inputrc(argc, argv)
203	int argc;
204	char **argv;
205{
206	if (argc != 2) {
207		out2str("usage: inputrc file\n");
208		return 1;
209	}
210	if (el != NULL) {
211		if (el_source(el, argv[1])) {
212			out2str("inputrc: failed\n");
213			return 1;
214		} else
215			return 0;
216	} else {
217		out2str("sh: inputrc ignored, not editing\n");
218		return 1;
219	}
220}
221
222/*
223 *  This command is provided since POSIX decided to standardize
224 *  the Korn shell fc command.  Oh well...
225 */
226int
227histcmd(int argc, char **argv)
228{
229	int ch;
230	const char * volatile editor = NULL;
231	HistEvent he;
232	int lflg = 0;
233	volatile int nflg = 0, rflg = 0, sflg = 0;
234	int i, retval;
235	const char *firststr, *laststr;
236	int first, last, direction;
237	char *pat = NULL, *repl;	/* ksh "fc old=new" crap */
238	static int active = 0;
239	struct jmploc jmploc;
240	struct jmploc *volatile savehandler;
241	char editfile[MAXPATHLEN + 1];
242	FILE *efp;
243#ifdef __GNUC__
244	repl = NULL;	/* XXX gcc4 */
245	efp = NULL;	/* XXX gcc4 */
246#endif
247
248	if (hist == NULL)
249		error("history not active");
250
251	if (argc == 1)
252		error("missing history argument");
253
254	optreset = 1; optind = 1; /* initialize getopt */
255	while (not_fcnumber(argv[optind]) &&
256	      (ch = getopt(argc, argv, ":e:lnrs")) != -1)
257		switch ((char)ch) {
258		case 'e':
259			editor = optionarg;
260			break;
261		case 'l':
262			lflg = 1;
263			break;
264		case 'n':
265			nflg = 1;
266			break;
267		case 'r':
268			rflg = 1;
269			break;
270		case 's':
271			sflg = 1;
272			break;
273		case ':':
274			error("option -%c expects argument", optopt);
275			/* NOTREACHED */
276		case '?':
277		default:
278			error("unknown option: -%c", optopt);
279			/* NOTREACHED */
280		}
281	argc -= optind, argv += optind;
282
283	/*
284	 * If executing...
285	 */
286	if (lflg == 0 || editor || sflg) {
287		lflg = 0;	/* ignore */
288		editfile[0] = '\0';
289		/*
290		 * Catch interrupts to reset active counter and
291		 * cleanup temp files.
292		 */
293		savehandler = handler;
294		if (setjmp(jmploc.loc)) {
295			active = 0;
296			if (*editfile)
297				unlink(editfile);
298			handler = savehandler;
299			longjmp(handler->loc, 1);
300		}
301		handler = &jmploc;
302		if (++active > MAXHISTLOOPS) {
303			active = 0;
304			displayhist = 0;
305			error("called recursively too many times");
306		}
307		/*
308		 * Set editor.
309		 */
310		if (sflg == 0) {
311			if (editor == NULL &&
312			    (editor = bltinlookup("FCEDIT", 1)) == NULL &&
313			    (editor = bltinlookup("EDITOR", 1)) == NULL)
314				editor = DEFEDITOR;
315			if (editor[0] == '-' && editor[1] == '\0') {
316				sflg = 1;	/* no edit */
317				editor = NULL;
318			}
319		}
320	}
321
322	/*
323	 * If executing, parse [old=new] now
324	 */
325	if (lflg == 0 && argc > 0 &&
326	     ((repl = strchr(argv[0], '=')) != NULL)) {
327		pat = argv[0];
328		*repl++ = '\0';
329		argc--, argv++;
330	}
331
332	/*
333	 * If -s is specified, accept only one operand
334	 */
335	if (sflg && argc >= 2)
336		error("too many args");
337
338	/*
339	 * determine [first] and [last]
340	 */
341	switch (argc) {
342	case 0:
343		firststr = lflg ? "-16" : "-1";
344		laststr = "-1";
345		break;
346	case 1:
347		firststr = argv[0];
348		laststr = lflg ? "-1" : argv[0];
349		break;
350	case 2:
351		firststr = argv[0];
352		laststr = argv[1];
353		break;
354	default:
355		error("too many args");
356		/* NOTREACHED */
357	}
358	/*
359	 * Turn into event numbers.
360	 */
361	first = str_to_event(firststr, 0);
362	last = str_to_event(laststr, 1);
363
364	if (rflg) {
365		i = last;
366		last = first;
367		first = i;
368	}
369	/*
370	 * XXX - this should not depend on the event numbers
371	 * always increasing.  Add sequence numbers or offset
372	 * to the history element in next (diskbased) release.
373	 */
374	direction = first < last ? H_PREV : H_NEXT;
375
376	/*
377	 * If editing, grab a temp file.
378	 */
379	if (editor) {
380		int fd;
381		INTOFF;		/* easier */
382		snprintf(editfile, sizeof(editfile), "%s_shXXXXXX", _PATH_TMP);
383		if ((fd = mkstemp(editfile)) < 0)
384			error("can't create temporary file %s", editfile);
385		if ((efp = fdopen(fd, "w")) == NULL) {
386			close(fd);
387			error("can't allocate stdio buffer for temp");
388		}
389	}
390
391	/*
392	 * Loop through selected history events.  If listing or executing,
393	 * do it now.  Otherwise, put into temp file and call the editor
394	 * after.
395	 *
396	 * The history interface needs rethinking, as the following
397	 * convolutions will demonstrate.
398	 */
399	history(hist, &he, H_FIRST);
400	retval = history(hist, &he, H_NEXT_EVENT, first);
401	for (;retval != -1; retval = history(hist, &he, direction)) {
402		if (lflg) {
403			if (!nflg)
404				out1fmt("%5d ", he.num);
405			out1str(he.str);
406		} else {
407			const char *s = pat ?
408			   fc_replace(he.str, pat, repl) : he.str;
409
410			if (sflg) {
411				if (displayhist) {
412					out2str(s);
413				}
414
415				evalstring(strcpy(stalloc(strlen(s) + 1), s), 0);
416				if (displayhist && hist) {
417					/*
418					 *  XXX what about recursive and
419					 *  relative histnums.
420					 */
421					history(hist, &he, H_ENTER, s);
422				}
423
424				break;
425			} else
426				fputs(s, efp);
427		}
428		/*
429		 * At end?  (if we were to lose last, we'd sure be
430		 * messed up).
431		 */
432		if (he.num == last)
433			break;
434	}
435	if (editor) {
436		char *editcmd;
437
438		fclose(efp);
439		editcmd = stalloc(strlen(editor) + strlen(editfile) + 2);
440		sprintf(editcmd, "%s %s", editor, editfile);
441		evalstring(editcmd, 0);	/* XXX - should use no JC command */
442		INTON;
443		readcmdfile(editfile);	/* XXX - should read back - quick tst */
444		unlink(editfile);
445	}
446
447	if (lflg == 0 && active > 0)
448		--active;
449	if (displayhist)
450		displayhist = 0;
451	return 0;
452}
453
454STATIC const char *
455fc_replace(const char *s, char *p, char *r)
456{
457	char *dest;
458	int plen = strlen(p);
459
460	STARTSTACKSTR(dest);
461	while (*s) {
462		if (*s == *p && strncmp(s, p, plen) == 0) {
463			while (*r)
464				STPUTC(*r++, dest);
465			s += plen;
466			*p = '\0';	/* so no more matches */
467		} else
468			STPUTC(*s++, dest);
469	}
470	STACKSTRNUL(dest);
471	dest = grabstackstr(dest);
472
473	return (dest);
474}
475
476int
477not_fcnumber(char *s)
478{
479	if (s == NULL)
480		return 0;
481        if (*s == '-')
482                s++;
483	return (!is_number(s));
484}
485
486int
487str_to_event(const char *str, int last)
488{
489	HistEvent he;
490	const char *s = str;
491	int relative = 0;
492	int i, retval;
493
494	retval = history(hist, &he, H_FIRST);
495	switch (*s) {
496	case '-':
497		relative = 1;
498		/*FALLTHROUGH*/
499	case '+':
500		s++;
501	}
502	if (is_number(s)) {
503		i = atoi(s);
504		if (relative) {
505			while (retval != -1 && i--) {
506				retval = history(hist, &he, H_NEXT);
507			}
508			if (retval == -1)
509				retval = history(hist, &he, H_LAST);
510		} else {
511			retval = history(hist, &he, H_NEXT_EVENT, i);
512			if (retval == -1) {
513				/*
514				 * the notion of first and last is
515				 * backwards to that of the history package
516				 */
517				retval = history(hist, &he,
518						last ? H_FIRST : H_LAST);
519			}
520		}
521		if (retval == -1)
522			error("history number %s not found (internal error)",
523			       str);
524	} else {
525		/*
526		 * pattern
527		 */
528		retval = history(hist, &he, H_PREV_STR, str);
529		if (retval == -1)
530			error("history pattern not found: %s", str);
531	}
532	return (he.num);
533}
534#else
535int
536histcmd(int argc, char **argv)
537{
538	error("not compiled with history support");
539	/* NOTREACHED */
540}
541int
542inputrc(int argc, char **argv)
543{
544	error("not compiled with history support");
545	/* NOTREACHED */
546}
547#endif
548