This file is fc.def, from which is created fc.c.It implements the builtin "fc" in Bash.Copyright (C) 1987-2010 Free Software Foundation, Inc.This file is part of GNU Bash, the Bourne Again SHell.Bash is free software: you can redistribute it and/or modifyit under the terms of the GNU General Public License as published bythe Free Software Foundation, either version 3 of the License, or(at your option) any later version.Bash is distributed in the hope that it will be useful,but WITHOUT ANY WARRANTY; without even the implied warranty ofMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See theGNU General Public License for more details.You should have received a copy of the GNU General Public Licensealong with Bash.  If not, see <http://www.gnu.org/licenses/>.$PRODUCES fc.c$BUILTIN fc$FUNCTION fc_builtin$DEPENDS_ON HISTORY$SHORT_DOC fc [-e ename] [-lnr] [first] [last] or fc -s [pat=rep] [command]Display or execute commands from the history list.fc is used to list or edit and re-execute commands from the history list.FIRST and LAST can be numbers specifying the range, or FIRST can be astring, which means the most recent command beginning with thatstring.Options:  -e ENAME	select which editor to use.  Default is FCEDIT, then EDITOR,		then vi  -l 	list lines instead of editing  -n	omit line numbers when listing  -r	reverse the order of the lines (newest listed first)With the `fc -s [pat=rep ...] [command]' format, COMMAND isre-executed after the substitution OLD=NEW is performed.A useful alias to use with this is r='fc -s', so that typing `r cc'runs the last command beginning with `cc' and typing `r' re-executesthe last command.Exit Status:Returns success or status of executed command; non-zero if an error occurs.$END#include <config.h>#if defined (HISTORY)#ifndef _MINIX#  include <sys/param.h>#endif#include "../bashtypes.h"#include "posixstat.h"#if ! defined(_MINIX) && defined (HAVE_SYS_FILE_H)#  include <sys/file.h>#endif#if defined (HAVE_UNISTD_H)#  include <unistd.h>#endif#include <stdio.h>#include <chartypes.h>#include "../bashansi.h"#include "../bashintl.h"#include <errno.h>#include "../shell.h"#include "../builtins.h"#include "../flags.h"#include "../bashhist.h"#include "maxpath.h"#include <readline/history.h>#include "bashgetopt.h"#include "common.h"#if !defined (errno)extern int errno;#endif /* !errno */extern int current_command_line_count, saved_command_line_count;extern int literal_history;extern int posixly_correct;extern int subshell_environment, interactive_shell;extern int unlink __P((const char *));extern FILE *sh_mktmpfp __P((char *, int, char **));/* **************************************************************** *//*								    *//*	The K*rn shell style fc command (Fix Command)		    *//*								    *//* **************************************************************** *//* fc builtin command (fix command) for Bash for those who   like K*rn-style history better than csh-style.     fc [-e ename] [-nlr] [first] [last]   FIRST and LAST can be numbers specifying the range, or FIRST can be   a string, which means the most recent command beginning with that   string.   -e ENAME selects which editor to use.  Default is FCEDIT, then EDITOR,      then the editor which corresponds to the current readline editing      mode, then vi.   -l means list lines instead of editing.   -n means no line numbers listed.   -r means reverse the order of the lines (making it newest listed first).     fc -e - [pat=rep ...] [command]     fc -s [pat=rep ...] [command]   Equivalent to !command:sg/pat/rep execpt there can be multiple PAT=REP's.*//* Data structure describing a list of global replacements to perform. */typedef struct repl {  struct repl *next;  char *pat;  char *rep;} REPL;/* Accessors for HIST_ENTRY lists that are called HLIST. */#define histline(i) (hlist[(i)]->line)#define histdata(i) (hlist[(i)]->data)#define FREE_RLIST() \	do { \		for (rl = rlist; rl; ) { \			REPL *r;	\			r = rl->next; \			if (rl->pat) \				free (rl->pat); \			if (rl->rep) \				free (rl->rep); \			free (rl); \			rl = r; \		} \	} while (0)static char *fc_dosubs __P((char *, REPL *));static char *fc_gethist __P((char *, HIST_ENTRY **));static int fc_gethnum __P((char *, HIST_ENTRY **));static int fc_number __P((WORD_LIST *));static void fc_replhist __P((char *));#ifdef INCLUDE_UNUSEDstatic char *fc_readline __P((FILE *));static void fc_addhist __P((char *));#endif/* String to execute on a file that we want to edit. */#define FC_EDIT_COMMAND "${FCEDIT:-${EDITOR:-vi}}"#if defined (STRICT_POSIX)#  define POSIX_FC_EDIT_COMMAND "${FCEDIT:-ed}"#else#  define POSIX_FC_EDIT_COMMAND "${FCEDIT:-${EDITOR:-ed}}"#endifintfc_builtin (list)     WORD_LIST *list;{  register int i;  register char *sep;  int numbering, reverse, listing, execute;  int histbeg, histend, last_hist, retval, opt, rh;  FILE *stream;  REPL *rlist, *rl;  char *ename, *command, *newcom, *fcedit;  HIST_ENTRY **hlist;  char *fn;  numbering = 1;  reverse = listing = execute = 0;  ename = (char *)NULL;  /* Parse out the options and set which of the two forms we're in. */  reset_internal_getopt ();  lcurrent = list;		/* XXX */  while (fc_number (loptend = lcurrent) == 0 &&	 (opt = internal_getopt (list, ":e:lnrs")) != -1)    {      switch (opt)	{	case 'n':	  numbering = 0;	  break;	case 'l':	  listing = 1;	  break;	case 'r':	  reverse = 1;	  break;	case 's':	  execute = 1;	  break;	case 'e':	  ename = list_optarg;	  break;	default:	  builtin_usage ();	  return (EX_USAGE);	}    }  list = loptend;  if (ename && (*ename == '-') && (ename[1] == '\0'))    execute = 1;  /* The "execute" form of the command (re-run, with possible string     substitutions). */  if (execute)    {      rlist = (REPL *)NULL;      while (list && ((sep = (char *)strchr (list->word->word, '=')) != NULL))	{	  *sep++ = '\0';	  rl = (REPL *)xmalloc (sizeof (REPL));	  rl->next = (REPL *)NULL;	  rl->pat = savestring (list->word->word);	  rl->rep = savestring (sep);	  if (rlist == NULL)	    rlist = rl;	  else	    {	      rl->next = rlist;	      rlist = rl;	    }	  list = list->next;	}      /* If we have a list of substitutions to do, then reverse it	 to get the replacements in the proper order. */      rlist = REVERSE_LIST (rlist, REPL *);      hlist = history_list ();      /* If we still have something in list, it is a command spec.	 Otherwise, we use the most recent command in time. */      command = fc_gethist (list ? list->word->word : (char *)NULL, hlist);      if (command == NULL)	{	  builtin_error (_("no command found"));	  if (rlist)	    FREE_RLIST ();	  return (EXECUTION_FAILURE);	}      if (rlist)	{	  newcom = fc_dosubs (command, rlist);	  free (command);	  FREE_RLIST ();	  command = newcom;	}      fprintf (stderr, "%s\n", command);      fc_replhist (command);	/* replace `fc -s' with command */      /* Posix says that the re-executed commands should be entered into the	 history. */      return (parse_and_execute (command, "fc", SEVAL_NOHIST));    }  /* This is the second form of the command (the list-or-edit-and-rerun     form). */  hlist = history_list ();  if (hlist == 0)    return (EXECUTION_SUCCESS);  for (i = 0; hlist[i]; i++);  /* With the Bash implementation of history, the current command line     ("fc blah..." and so on) is already part of the history list by     the time we get to this point.  This just skips over that command     and makes the last command that this deals with be the last command     the user entered before the fc.  We need to check whether the     line was actually added (HISTIGNORE may have caused it to not be),     so we check hist_last_line_added. */  /* Even though command substitution through parse_and_execute turns off     remember_on_history, command substitution in a shell when set -o history     has been enabled (interactive or not) should use it in the last_hist     calculation as if it were on. */  rh = remember_on_history || ((subshell_environment & SUBSHELL_COMSUB) && enable_history_list);  last_hist = i - rh - hist_last_line_added;  /* XXX */  if (saved_command_line_count > 0 && i == last_hist && hlist[last_hist] == 0)    while (last_hist >= 0 && hlist[last_hist] == 0)      last_hist--;  if (last_hist < 0)    {      sh_erange ((char *)NULL, _("history specification"));      return (EXECUTION_FAILURE);    }  if (list)    {      histbeg = fc_gethnum (list->word->word, hlist);      list = list->next;      if (list)	histend = fc_gethnum (list->word->word, hlist);      else	histend = listing ? last_hist : histbeg;    }  else    {      /* The default for listing is the last 16 history items. */      if (listing)	{	  histend = last_hist;	  histbeg = histend - 16 + 1;	/* +1 because loop below uses >= */	  if (histbeg < 0)	    histbeg = 0;	}      else	/* For editing, it is the last history command. */	histbeg = histend = last_hist;