1 This file is fc.def, from which is created fc.c.
2 It implements the builtin "fc" in Bash.
4 Copyright (C) 1987-2009 Free Software Foundation, Inc.
6 This file is part of GNU Bash, the Bourne Again SHell.
8 Bash is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 Bash is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with Bash. If not, see <http://www.gnu.org/licenses/>.
26 $SHORT_DOC fc [-e ename] [-lnr] [first] [last] or fc -s [pat=rep] [command]
27 Display or execute commands from the history list.
29 fc is used to list or edit and re-execute commands from the history list.
30 FIRST and LAST can be numbers specifying the range, or FIRST can be a
31 string, which means the most recent command beginning with that
35 -e ENAME select which editor to use. Default is FCEDIT, then EDITOR,
37 -l list lines instead of editing
38 -n omit line numbers when listing
39 -r reverse the order of the lines (newest listed first)
41 With the `fc -s [pat=rep ...] [command]' format, COMMAND is
42 re-executed after the substitution OLD=NEW is performed.
44 A useful alias to use with this is r='fc -s', so that typing `r cc'
45 runs the last command beginning with `cc' and typing `r' re-executes
49 Returns success or status of executed command; non-zero if an error occurs.
56 # include <sys/param.h>
58 #include "../bashtypes.h"
59 #include "posixstat.h"
60 #if ! defined(_MINIX) && defined (HAVE_SYS_FILE_H)
61 # include <sys/file.h>
64 #if defined (HAVE_UNISTD_H)
69 #include <chartypes.h>
71 #include "../bashansi.h"
72 #include "../bashintl.h"
76 #include "../builtins.h"
78 #include "../bashhist.h"
80 #include <readline/history.h>
81 #include "bashgetopt.h"
88 extern int current_command_line_count;
89 extern int literal_history;
90 extern int posixly_correct;
91 extern int subshell_environment, interactive_shell;
93 extern int unlink __P((const char *));
95 extern FILE *sh_mktmpfp __P((char *, int, char **));
97 /* **************************************************************** */
99 /* The K*rn shell style fc command (Fix Command) */
101 /* **************************************************************** */
103 /* fc builtin command (fix command) for Bash for those who
104 like K*rn-style history better than csh-style.
106 fc [-e ename] [-nlr] [first] [last]
108 FIRST and LAST can be numbers specifying the range, or FIRST can be
109 a string, which means the most recent command beginning with that
112 -e ENAME selects which editor to use. Default is FCEDIT, then EDITOR,
113 then the editor which corresponds to the current readline editing
116 -l means list lines instead of editing.
117 -n means no line numbers listed.
118 -r means reverse the order of the lines (making it newest listed first).
120 fc -e - [pat=rep ...] [command]
121 fc -s [pat=rep ...] [command]
123 Equivalent to !command:sg/pat/rep execpt there can be multiple PAT=REP's.
126 /* Data structure describing a list of global replacements to perform. */
127 typedef struct repl {
133 /* Accessors for HIST_ENTRY lists that are called HLIST. */
134 #define histline(i) (hlist[(i)]->line)
135 #define histdata(i) (hlist[(i)]->data)
137 #define FREE_RLIST() \
139 for (rl = rlist; rl; ) { \
151 static char *fc_dosubs __P((char *, REPL *));
152 static char *fc_gethist __P((char *, HIST_ENTRY **));
153 static int fc_gethnum __P((char *, HIST_ENTRY **));
154 static int fc_number __P((WORD_LIST *));
155 static void fc_replhist __P((char *));
156 #ifdef INCLUDE_UNUSED
157 static char *fc_readline __P((FILE *));
158 static void fc_addhist __P((char *));
161 /* String to execute on a file that we want to edit. */
162 #define FC_EDIT_COMMAND "${FCEDIT:-${EDITOR:-vi}}"
163 #if defined (STRICT_POSIX)
164 # define POSIX_FC_EDIT_COMMAND "${FCEDIT:-ed}"
166 # define POSIX_FC_EDIT_COMMAND "${FCEDIT:-${EDITOR:-ed}}"
175 int numbering, reverse, listing, execute;
176 int histbeg, histend, last_hist, retval, opt, rh;
179 char *ename, *command, *newcom, *fcedit;
184 reverse = listing = execute = 0;
185 ename = (char *)NULL;
187 /* Parse out the options and set which of the two forms we're in. */
188 reset_internal_getopt ();
189 lcurrent = list; /* XXX */
190 while (fc_number (loptend = lcurrent) == 0 &&
191 (opt = internal_getopt (list, ":e:lnrs")) != -1)
223 if (ename && (*ename == '-') && (ename[1] == '\0'))
226 /* The "execute" form of the command (re-run, with possible string
230 rlist = (REPL *)NULL;
231 while (list && ((sep = (char *)strchr (list->word->word, '=')) != NULL))
234 rl = (REPL *)xmalloc (sizeof (REPL));
235 rl->next = (REPL *)NULL;
236 rl->pat = savestring (list->word->word);
237 rl->rep = savestring (sep);
249 /* If we have a list of substitutions to do, then reverse it
250 to get the replacements in the proper order. */
252 rlist = REVERSE_LIST (rlist, REPL *);
254 hlist = history_list ();
256 /* If we still have something in list, it is a command spec.
257 Otherwise, we use the most recent command in time. */
258 command = fc_gethist (list ? list->word->word : (char *)NULL, hlist);
262 builtin_error (_("no command found"));
266 return (EXECUTION_FAILURE);
271 newcom = fc_dosubs (command, rlist);
277 fprintf (stderr, "%s\n", command);
278 fc_replhist (command); /* replace `fc -s' with command */
279 /* Posix says that the re-executed commands should be entered into the
281 return (parse_and_execute (command, "fc", SEVAL_NOHIST));
284 /* This is the second form of the command (the list-or-edit-and-rerun
286 hlist = history_list ();
288 return (EXECUTION_SUCCESS);
289 for (i = 0; hlist[i]; i++);
291 /* With the Bash implementation of history, the current command line
292 ("fc blah..." and so on) is already part of the history list by
293 the time we get to this point. This just skips over that command
294 and makes the last command that this deals with be the last command
295 the user entered before the fc. We need to check whether the
296 line was actually added (HISTIGNORE may have caused it to not be),
297 so we check hist_last_line_added. */
299 /* Even though command substitution through parse_and_execute turns off
300 remember_on_history, command substitution in a shell when set -o history
301 has been enabled (interactive or not) should use it in the last_hist
302 calculation as if it were on. */
303 rh = remember_on_history || ((subshell_environment & SUBSHELL_COMSUB) && enable_history_list);
304 last_hist = i - rh - hist_last_line_added;
307 if (i == last_hist && hlist[last_hist] == 0)
308 while (last_hist >= 0 && hlist[last_hist] == 0)
312 sh_erange ((char *)NULL, _("history specification"));
313 return (EXECUTION_FAILURE);
318 histbeg = fc_gethnum (list->word->word, hlist);
322 histend = fc_gethnum (list->word->word, hlist);
324 histend = listing ? last_hist : histbeg;
328 /* The default for listing is the last 16 history items. */
332 histbeg = histend - 16 + 1; /* +1 because loop below uses >= */
337 /* For editing, it is the last history command. */
338 histbeg = histend = last_hist;
341 /* "When not listing, the fc command that caused the editing shall not be
342 entered into the history list." */
343 if (listing == 0 && hist_last_line_added)
345 bash_delete_last_history ();
346 /* If we're editing a single command -- the last command in the
347 history -- and we just removed the dummy command added by
348 edit_and_execute_command (), we need to check whether or not we
349 just removed the last command in the history and need to back
350 the pointer up. remember_on_history is off because we're running
351 in parse_and_execute(). */
352 if (histbeg == histend && histend == last_hist && hlist[last_hist] == 0)
353 last_hist = histbeg = --histend;
356 /* We print error messages for line specifications out of range. */
357 if ((histbeg < 0) || (histend < 0))
359 sh_erange ((char *)NULL, _("history specification"));
360 return (EXECUTION_FAILURE);
363 if (histend < histbeg)
377 stream = sh_mktmpfp ("bash-fc", MT_USERANDOM|MT_USETMPDIR, &fn);
380 builtin_error (_("%s: cannot open temp file: %s"), fn ? fn : "", strerror (errno));
382 return (EXECUTION_FAILURE);
386 for (i = reverse ? histend : histbeg; reverse ? i >= histbeg : i <= histend; reverse ? i-- : i++)
390 fprintf (stream, "%d", i + history_base);
394 fputs ("\t", stream);
396 fprintf (stream, "\t%c", histdata (i) ? '*' : ' ');
398 fprintf (stream, "%s\n", histline (i));
402 return (sh_chkwrite (EXECUTION_SUCCESS));
409 return (EXECUTION_FAILURE);
413 /* Now edit the file of commands. */
416 command = (char *)xmalloc (strlen (ename) + strlen (fn) + 2);
417 sprintf (command, "%s %s", ename, fn);
421 fcedit = posixly_correct ? POSIX_FC_EDIT_COMMAND : FC_EDIT_COMMAND;
422 command = (char *)xmalloc (3 + strlen (fcedit) + strlen (fn));
423 sprintf (command, "%s %s", fcedit, fn);
425 retval = parse_and_execute (command, "fc", SEVAL_NOHIST);
426 if (retval != EXECUTION_SUCCESS)
430 return (EXECUTION_FAILURE);
433 /* Make sure parse_and_execute doesn't turn this off, even though a
434 call to parse_and_execute farther up the function call stack (e.g.,
435 if this is called by vi_edit_and_execute_command) may have already
436 called bash_history_disable. */
437 remember_on_history = 1;
439 /* Turn on the `v' flag while fc_execute_file runs so the commands
440 will be echoed as they are read by the parser. */
441 begin_unwind_frame ("fc builtin");
442 add_unwind_protect ((Function *)xfree, fn);
443 add_unwind_protect (unlink, fn);
444 unwind_protect_int (echo_input_at_read);
445 echo_input_at_read = 1;
447 retval = fc_execute_file (fn);
449 run_unwind_frame ("fc builtin");
454 /* Return 1 if LIST->word->word is a legal number for fc's use. */
463 s = list->word->word;
466 return (legal_number (s, (intmax_t *)NULL));
469 /* Return an absolute index into HLIST which corresponds to COMMAND. If
470 COMMAND is a number, then it was specified in relative terms. If it
471 is a string, then it is the start of a command line present in HLIST. */
473 fc_gethnum (command, hlist)
477 int sign, n, clen, rh;
478 register int i, j, last_hist;
482 /* Count history elements. */
483 for (i = 0; hlist[i]; i++);
485 /* With the Bash implementation of history, the current command line
486 ("fc blah..." and so on) is already part of the history list by
487 the time we get to this point. This just skips over that command
488 and makes the last command that this deals with be the last command
489 the user entered before the fc. We need to check whether the
490 line was actually added (HISTIGNORE may have caused it to not be),
491 so we check hist_last_line_added. This needs to agree with the
492 calculation of last_hist in fc_builtin above. */
493 /* Even though command substitution through parse_and_execute turns off
494 remember_on_history, command substitution in a shell when set -o history
495 has been enabled (interactive or not) should use it in the last_hist
496 calculation as if it were on. */
497 rh = remember_on_history || ((subshell_environment & SUBSHELL_COMSUB) && enable_history_list);
498 last_hist = i - rh - hist_last_line_added;
500 if (i == last_hist && hlist[last_hist] == 0)
501 while (last_hist >= 0 && hlist[last_hist] == 0)
508 /* No specification defaults to most recent command. */
512 /* Otherwise, there is a specification. It can be a number relative to
513 the current position, or an absolute history number. */
516 /* Handle possible leading minus sign. */
517 if (s && (*s == '-'))
528 /* If the value is negative or zero, then it is an offset from
529 the current history item. */
533 return (n < 0 ? 0 : n);
540 return (i < n ? i : n);
544 clen = strlen (command);
545 for (j = i; j >= 0; j--)
547 if (STREQN (command, histline (j), clen))
553 /* Locate the most recent history line which begins with
554 COMMAND in HLIST, and return a malloc()'ed copy of it. */
556 fc_gethist (command, hlist)
563 return ((char *)NULL);
565 i = fc_gethnum (command, hlist);
568 return (savestring (histline (i)));
570 return ((char *)NULL);
573 #ifdef INCLUDE_UNUSED
574 /* Read the edited history lines from STREAM and return them
575 one at a time. This can read unlimited length lines. The
576 caller should free the storage. */
582 int line_len = 0, lindex = 0;
583 char *line = (char *)NULL;
585 while ((c = getc (stream)) != EOF)
587 if ((lindex + 2) >= line_len)
588 line = (char *)xrealloc (line, (line_len += 128));
592 line[lindex++] = '\n';
593 line[lindex++] = '\0';
605 return ((char *)NULL);
608 if (lindex + 2 >= line_len)
609 line = (char *)xrealloc (line, lindex + 3);
611 line[lindex++] = '\n'; /* Finish with newline if none in file */
612 line[lindex++] = '\0';
617 /* Perform the SUBS on COMMAND.
618 SUBS is a list of substitutions, and COMMAND is a simple string.
619 Return a pointer to a malloc'ed string which contains the substituted
622 fc_dosubs (command, subs)
626 register char *new, *t;
629 for (new = savestring (command), r = subs; r; r = r->next)
631 t = strsub (new, r->pat, r->rep, 1);
638 /* Use `command' to replace the last entry in the history list, which,
639 by this time, is `fc blah...'. The intent is that the new command
640 become the history entry, and that `fc' should never appear in the
641 history list. This way you can do `r' to your heart's content. */
643 fc_replhist (command)
648 if (command == 0 || *command == '\0')
651 n = strlen (command);
652 if (command[n - 1] == '\n')
653 command[n - 1] = '\0';
655 if (command && *command)
657 bash_delete_last_history ();
658 maybe_add_history (command); /* Obeys HISTCONTROL setting. */
662 #ifdef INCLUDE_UNUSED
663 /* Add LINE to the history, after removing a single trailing newline. */
670 if (line == 0 || *line == 0)
675 if (line[n - 1] == '\n')
679 maybe_add_history (line); /* Obeys HISTCONTROL setting. */