1 /* bashhist.c -- bash interface to the GNU history library. */
3 /* Copyright (C) 1993-2004 Free Software Foundation, Inc.
5 This file is part of GNU Bash, the Bourne Again SHell.
7 Bash is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 Bash is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License along
18 with Bash; see the file COPYING. If not, write to the Free Software
19 Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA. */
25 #if defined (HAVE_UNISTD_H)
27 # include <sys/types.h>
32 #include "bashtypes.h"
36 #include "posixstat.h"
44 #include "parser.h" /* for the struct dstack stuff. */
45 #include "pathexp.h" /* for the struct ignorevar stuff */
46 #include "bashhist.h" /* matching prototypes and declarations */
47 #include "builtins/common.h"
49 #include <readline/history.h>
50 #include <glob/glob.h>
51 #include <glob/strmatch.h>
53 #if defined (READLINE)
54 # include "bashline.h"
55 extern int rl_done, rl_dispatching; /* should really include readline.h */
62 static int histignore_item_func __P((struct ign *));
63 static int check_history_control __P((char *));
64 static void hc_erasedups __P((char *));
65 static void really_add_history __P((char *));
67 static struct ignorevar histignore =
73 (sh_iv_item_func_t *)histignore_item_func,
76 #define HIGN_EXPAND 0x01
78 /* Declarations of bash history variables. */
79 /* Non-zero means to remember lines typed to the shell on the history
80 list. This is different than the user-controlled behaviour; this
81 becomes zero when we read lines from a file, for example. */
82 int remember_on_history = 1;
84 /* The number of lines that Bash has added to this history session. The
85 difference between the number of the top element in the history list
86 (offset from history_base) and the number of lines in the history file.
87 Appending this session's history to the history file resets this to 0. */
88 int history_lines_this_session;
90 /* The number of lines that Bash has read from the history file. */
91 int history_lines_in_file;
93 #if defined (BANG_HISTORY)
94 /* Non-zero means do no history expansion on this line, regardless
95 of what history_expansion says. */
96 int history_expansion_inhibited;
99 /* With the old default, every line was saved in the history individually.
100 I.e., if the user enters:
105 Each line will be individually saved in the history.
112 If the variable command_oriented_history is set, multiple lines
113 which form one command will be saved as one history entry.
124 The user can then recall the whole command all at once instead
125 of just being able to recall one line at a time.
127 This is now enabled by default.
129 int command_oriented_history = 1;
131 /* Set to 1 if the first line of a possibly-multi-line command was saved
132 in the history list. Managed by maybe_add_history(), but global so
133 the history-manipluating builtins can see it. */
134 int current_command_first_line_saved = 0;
136 /* Non-zero means to store newlines in the history list when using
137 command_oriented_history rather than trying to use semicolons. */
140 /* Non-zero means to append the history to the history file at shell
141 exit, even if the history has been stifled. */
142 int force_append_history;
144 /* A nit for picking at history saving. Flags have the following values:
146 Value == 0 means save all lines parsed by the shell on the history.
147 Value & HC_IGNSPACE means save all lines that do not start with a space.
148 Value & HC_IGNDUPS means save all lines that do not match the last
150 Value & HC_ERASEDUPS means to remove all other matching lines from the
151 history list before saving the latest line. */
154 /* Set to 1 if the last command was added to the history list successfully
155 as a separate history entry; set to 0 if the line was ignored or added
156 to a previous entry as part of command-oriented-history processing. */
157 int hist_last_line_added;
159 /* Set to 1 if builtins/history.def:push_history added the last history
161 int hist_last_line_pushed;
163 #if defined (READLINE)
164 /* If non-zero, and readline is being used, the user is offered the
165 chance to re-edit a failed history expansion. */
166 int history_reediting;
168 /* If non-zero, and readline is being used, don't directly execute a
169 line with history substitution. Reload it into the editing buffer
170 instead and let the user further edit and confirm with a newline. */
173 #endif /* READLINE */
175 /* Non-zero means to not save function definitions in the history list. */
176 int dont_save_function_defs;
178 /* Variables declared in other files used here. */
179 extern int current_command_line_count;
181 extern struct dstack dstack;
183 static int bash_history_inhibit_expansion __P((char *, int));
184 #if defined (READLINE)
185 static void re_edit __P((char *));
187 static int history_expansion_p __P((char *));
188 static int shell_comment __P((char *));
189 static int should_expand __P((char *));
190 static HIST_ENTRY *last_history_entry __P((void));
191 static char *expand_histignore_pattern __P((char *));
192 static int history_should_ignore __P((char *));
194 /* Is the history expansion starting at string[i] one that should not
197 bash_history_inhibit_expansion (string, i)
201 /* The shell uses ! as a pattern negation character in globbing [...]
202 expressions, so let those pass without expansion. */
203 if (i > 0 && (string[i - 1] == '[') && member (']', string + i + 1))
205 /* The shell uses ! as the indirect expansion character, so let those
206 expansions pass as well. */
207 else if (i > 1 && string[i - 1] == '{' && string[i - 2] == '$' &&
208 member ('}', string + i + 1))
210 #if defined (EXTENDED_GLOB)
211 else if (extended_glob && i > 1 && string[i+1] == '(' && member (')', string + i + 2))
219 bash_initialize_history ()
221 history_quotes_inhibit_expansion = 1;
222 history_search_delimiter_chars = ";&()|<>";
223 history_inhibit_expansion_function = bash_history_inhibit_expansion;
224 #if defined (BANG_HISTORY)
225 sv_histchars ("histchars");
230 bash_history_reinit (interact)
233 #if defined (BANG_HISTORY)
234 history_expansion = interact != 0;
235 history_expansion_inhibited = 1;
237 remember_on_history = interact != 0;
238 history_inhibit_expansion_function = bash_history_inhibit_expansion;
242 bash_history_disable ()
244 remember_on_history = 0;
245 #if defined (BANG_HISTORY)
246 history_expansion_inhibited = 1;
251 bash_history_enable ()
253 remember_on_history = 1;
254 #if defined (BANG_HISTORY)
255 history_expansion_inhibited = 0;
257 history_inhibit_expansion_function = bash_history_inhibit_expansion;
258 sv_history_control ("HISTCONTROL");
259 sv_histignore ("HISTIGNORE");
262 /* Load the history list from the history file. */
269 /* Truncate history file for interactive shells which desire it.
270 Note that the history file is automatically truncated to the
271 size of HISTSIZE if the user does not explicitly set the size
273 set_if_not ("HISTSIZE", "500");
274 sv_histsize ("HISTSIZE");
276 set_if_not ("HISTFILESIZE", get_string_value ("HISTSIZE"));
277 sv_histsize ("HISTFILESIZE");
279 /* Read the history in HISTFILE into the history list. */
280 hf = get_string_value ("HISTFILE");
282 if (hf && *hf && stat (hf, &buf) == 0)
286 history_lines_in_file = where_history ();
290 #ifdef INCLUDE_UNUSED
291 /* Write the existing history out to the history file. */
298 hf = get_string_value ("HISTFILE");
299 if (hf && *hf && stat (hf, &buf) == 0)
301 /* Append only the lines that occurred this session to
305 if (history_lines_this_session < where_history () || force_append_history)
306 append_history (history_lines_this_session, hf);
310 sv_histsize ("HISTFILESIZE");
316 maybe_append_history (filename)
322 result = EXECUTION_SUCCESS;
323 if (history_lines_this_session && (history_lines_this_session < where_history ()))
325 /* If the filename was supplied, then create it if necessary. */
326 if (stat (filename, &buf) == -1 && errno == ENOENT)
328 fd = open (filename, O_WRONLY|O_CREAT, 0600);
331 builtin_error (_("%s: cannot create: %s"), filename, strerror (errno));
332 return (EXECUTION_FAILURE);
336 result = append_history (history_lines_this_session, filename);
337 history_lines_in_file += history_lines_this_session;
338 history_lines_this_session = 0;
343 /* If this is an interactive shell, then append the lines executed
344 this session to the history file. */
346 maybe_save_shell_history ()
353 if (history_lines_this_session)
355 hf = get_string_value ("HISTFILE");
359 /* If the file doesn't exist, then create it. */
360 if (stat (hf, &buf) == -1)
363 file = open (hf, O_CREAT | O_TRUNC | O_WRONLY, 0600);
368 /* Now actually append the lines if the history hasn't been
369 stifled. If the history has been stifled, rewrite the
372 if (history_lines_this_session <= where_history () || force_append_history)
374 result = append_history (history_lines_this_session, hf);
375 history_lines_in_file += history_lines_this_session;
379 result = write_history (hf);
380 history_lines_in_file = history_lines_this_session;
382 history_lines_this_session = 0;
384 sv_histsize ("HISTFILESIZE");
390 #if defined (READLINE)
391 /* Tell readline () that we have some text for it to edit. */
396 if (bash_input.type == st_stdin)
399 #endif /* READLINE */
401 /* Return 1 if this line needs history expansion. */
403 history_expansion_p (line)
408 for (s = line; *s; s++)
409 if (*s == history_expansion_char || *s == history_subst_char)
414 /* Do pre-processing on LINE. If PRINT_CHANGES is non-zero, then
415 print the results of expanding the line if there were any changes.
416 If there is an error, return NULL, otherwise the expanded line is
417 returned. If ADDIT is non-zero the line is added to the history
418 list after history expansion. ADDIT is just a suggestion;
419 REMEMBER_ON_HISTORY can veto, and does.
420 Right now this does history expansion. */
422 pre_process_line (line, print_changes, addit)
424 int print_changes, addit;
433 # if defined (BANG_HISTORY)
434 /* History expand the line. If this results in no errors, then
435 add that line to the history if ADDIT is non-zero. */
436 if (!history_expansion_inhibited && history_expansion && history_expansion_p (line))
438 expanded = history_expand (line, &history_value);
445 internal_error ("%s", history_value);
446 #if defined (READLINE)
447 else if (hist_verify == 0 || expanded == 2)
451 fprintf (stderr, "%s\n", history_value);
454 /* If there was an error, return NULL. */
455 if (expanded < 0 || expanded == 2) /* 2 == print only */
457 # if defined (READLINE)
458 if (expanded == 2 && rl_dispatching == 0 && *history_value)
460 if (expanded == 2 && *history_value)
461 # endif /* !READLINE */
462 maybe_add_history (history_value);
464 free (history_value);
466 # if defined (READLINE)
467 /* New hack. We can allow the user to edit the
468 failed history expansion. */
469 if (history_reediting && expanded < 0 && rl_done)
471 # endif /* READLINE */
472 return ((char *)NULL);
475 # if defined (READLINE)
476 if (hist_verify && expanded == 1)
478 re_edit (history_value);
479 return ((char *)NULL);
484 /* Let other expansions know that return_value can be free'ed,
485 and that a line has been added to the history list. Note
486 that we only add lines that have something in them. */
488 return_value = history_value;
490 # endif /* BANG_HISTORY */
492 if (addit && remember_on_history && *return_value)
493 maybe_add_history (return_value);
497 return_value = savestring (line);
500 return (return_value);
503 /* Return 1 if the first non-whitespace character in LINE is a `#', indicating
504 * that the line is a shell comment. */
511 for (p = line; p && *p && whitespace (*p); p++)
513 return (p && *p == '#');
516 #ifdef INCLUDE_UNUSED
517 /* Remove shell comments from LINE. A `#' and anything after it is a comment.
518 This isn't really useful yet, since it doesn't handle quoting. */
520 filter_comments (line)
525 for (p = line; p && *p && *p != '#'; p++)
533 /* Check LINE against what HISTCONTROL says to do. Returns 1 if the line
534 should be saved; 0 if it should be discarded. */
536 check_history_control (line)
542 if (history_control == 0)
545 /* ignorespace or ignoreboth */
546 if ((history_control & HC_IGNSPACE) && *line == ' ')
549 /* ignoredups or ignoreboth */
550 if (history_control & HC_IGNDUPS)
553 temp = previous_history ();
555 r = (temp == 0 || STREQ (temp->line, line) == 0);
566 /* Remove all entries matching LINE from the history list. Triggered when
567 HISTCONTROL includes `erasedups'. */
576 while (temp = previous_history ())
578 if (STREQ (temp->line, line))
580 r = where_history ();
587 /* Add LINE to the history list, handling possibly multi-line compound
588 commands. We note whether or not we save the first line of each command
589 (which is usually the entire command and history entry), and don't add
590 the second and subsequent lines of a multi-line compound command if we
591 didn't save the first line. We don't usually save shell comment lines in
592 compound commands in the history, because they could have the effect of
593 commenting out the rest of the command when the entire command is saved as
594 a single history entry (when COMMAND_ORIENTED_HISTORY is enabled). If
595 LITERAL_HISTORY is set, we're saving lines in the history with embedded
596 newlines, so it's OK to save comment lines. We also make sure to save
597 multiple-line quoted strings or other constructs. */
599 maybe_add_history (line)
602 hist_last_line_added = 0;
604 /* Don't use the value of history_control to affect the second
605 and subsequent lines of a multi-line command (old code did
606 this only when command_oriented_history is enabled). */
607 if (current_command_line_count > 1)
609 if (current_command_first_line_saved &&
610 (literal_history || dstack.delimiter_depth != 0 || shell_comment (line) == 0))
611 bash_add_history (line);
615 /* This is the first line of a (possible multi-line) command. Note whether
616 or not we should save the first line and remember it. */
617 current_command_first_line_saved = check_add_history (line, 0);
620 /* Just check LINE against HISTCONTROL and HISTIGNORE and add it to the
621 history if it's OK. Used by `history -s' as well as maybe_add_history().
622 Returns 1 if the line was saved in the history, 0 otherwise. */
624 check_add_history (line, force)
628 if (check_history_control (line) && history_should_ignore (line) == 0)
630 /* We're committed to saving the line. If the user has requested it,
631 remove other matching lines from the history. */
632 if (history_control & HC_ERASEDUPS)
637 really_add_history (line);
641 bash_add_history (line);
647 /* Add a line to the history list.
648 The variable COMMAND_ORIENTED_HISTORY controls the style of history
649 remembering; when non-zero, and LINE is not the first line of a
650 complete parser construct, append LINE to the last history line instead
651 of adding it as a new line. */
653 bash_add_history (line)
656 int add_it, offset, curlen;
657 HIST_ENTRY *current, *old;
658 char *chars_to_add, *new_line;
661 if (command_oriented_history && current_command_line_count > 1)
663 chars_to_add = literal_history ? "\n" : history_delimiting_chars ();
666 current = previous_history ();
670 /* If the previous line ended with an escaped newline (escaped
671 with backslash, but otherwise unquoted), then remove the quoted
672 newline, since that is what happens when the line is parsed. */
673 curlen = strlen (current->line);
675 if (dstack.delimiter_depth == 0 && current->line[curlen - 1] == '\\' &&
676 current->line[curlen - 2] != '\\')
678 current->line[curlen - 1] = '\0';
683 new_line = (char *)xmalloc (1
686 + strlen (chars_to_add));
687 sprintf (new_line, "%s%s%s", current->line, chars_to_add, line);
688 offset = where_history ();
689 old = replace_history_entry (offset, new_line, current->data);
693 free_history_entry (old);
700 really_add_history (line);
706 really_add_history (line)
709 hist_last_line_added = 1;
710 hist_last_line_pushed = 0;
712 history_lines_this_session++;
719 return (remember_on_history ? history_base + where_history () : 1);
728 for (p = s; p && *p; p++)
739 histignore_item_func (ign)
742 if (should_expand (ign->val))
743 ign->flags |= HIGN_EXPAND;
748 setup_history_ignore (varname)
751 setup_ignore_patterns (&histignore);
755 last_history_entry ()
760 he = previous_history ();
770 he = last_history_entry ();
772 return ((char *)NULL);
777 expand_histignore_pattern (pat)
783 phe = last_history_entry ();
785 if (phe == (HIST_ENTRY *)0)
786 return (savestring (pat));
788 ret = strcreplace (pat, '&', phe->line, 1);
793 /* Return 1 if we should not put LINE into the history according to the
794 patterns in HISTIGNORE. */
796 history_should_ignore (line)
799 register int i, match;
802 if (histignore.num_ignores == 0)
805 for (i = match = 0; i < histignore.num_ignores; i++)
807 if (histignore.ignores[i].flags & HIGN_EXPAND)
808 npat = expand_histignore_pattern (histignore.ignores[i].val);
810 npat = histignore.ignores[i].val;
812 match = strmatch (npat, line, FNMATCH_EXTFLAG) != FNM_NOMATCH;
814 if (histignore.ignores[i].flags & HIGN_EXPAND)