1 /* histfile.c - functions to manipulate the history file. */
3 /* Copyright (C) 1989, 1992 Free Software Foundation, Inc.
5 This file contains the GNU History Library (the Library), a set of
6 routines for managing the text of previously typed lines.
8 The Library 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 2, or (at your option)
13 The Library is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
18 The GNU General Public License is often shipped with GNU software, and
19 is generally kept in a file called COPYING or LICENSE. If you do not
20 have a copy of the license, write to the Free Software Foundation,
21 59 Temple Place, Suite 330, Boston, MA 02111 USA. */
23 /* The goal is to make the implementation transparent, so that you
24 don't have to know what data types are used, just what functions
25 you can call. I think I have done that. */
26 #define READLINE_LIBRARY
28 #if defined (HAVE_CONFIG_H)
34 #include <sys/types.h>
36 # include <sys/file.h>
38 #include "posixstat.h"
41 #if defined (HAVE_STDLIB_H)
44 # include "ansi_stdlib.h"
45 #endif /* HAVE_STDLIB_H */
47 #if defined (HAVE_UNISTD_H)
51 #if defined (HAVE_STRING_H)
55 #endif /* !HAVE_STRING_H */
58 /* If we're compiling for __EMX__ (OS/2) or __CYGWIN__ (cygwin32 environment
59 on win 95/98/nt), we want to open files with O_BINARY mode so that there
60 is no \n -> \r\n conversion performed. On other systems, we don't want to
61 mess around with O_BINARY at all, so we ensure that it's defined to 0. */
62 #if defined (__EMX__) || defined (__CYGWIN__)
66 #else /* !__EMX__ && !__CYGWIN__ */
69 #endif /* !__EMX__ && !__CYGWIN__ */
82 /* Return the string that should be used in the place of this
83 filename. This only matters when you don't specify the
84 filename to read_history (), or write_history (). */
86 history_filename (filename)
93 return_val = filename ? savestring (filename) : (char *)NULL;
98 home = sh_get_env_value ("HOME");
106 home_len = strlen (home);
108 return_val = xmalloc (2 + home_len + 8); /* strlen(".history") == 8 */
109 strcpy (return_val, home);
110 return_val[home_len] = '/';
111 #if defined (__MSDOS__)
112 strcpy (return_val + home_len + 1, "_history");
114 strcpy (return_val + home_len + 1, ".history");
120 /* Add the contents of FILENAME to the history list, a line at a time.
121 If FILENAME is NULL, then read from ~/.history. Returns 0 if
122 successful, or errno if not. */
124 read_history (filename)
125 const char *filename;
127 return (read_history_range (filename, 0, -1));
130 /* Read a range of lines from FILENAME, adding them to the history list.
131 Start reading at the FROM'th line and end at the TO'th. If FROM
132 is zero, start at the beginning. If TO is less than FROM, read
133 until the end of the file. If FILENAME is NULL, then read from
134 ~/.history. Returns 0 if successful, or errno if not. */
136 read_history_range (filename, from, to)
137 const char *filename;
140 register int line_start, line_end;
141 char *input, *buffer;
142 int file, current_line, chars_read;
146 buffer = (char *)NULL;
147 input = history_filename (filename);
148 file = open (input, O_RDONLY|O_BINARY, 0666);
150 if ((file < 0) || (fstat (file, &finfo) == -1))
153 file_size = (size_t)finfo.st_size;
155 /* check for overflow on very large files */
156 if (file_size != finfo.st_size || file_size + 1 < file_size)
164 buffer = xmalloc (file_size + 1);
166 chars_read = read (file, buffer, file_size);
181 /* Set TO to larger than end of file if negative. */
185 /* Start at beginning of file, work to end. */
186 line_start = line_end = current_line = 0;
188 /* Skip lines until we are at FROM. */
189 while (line_start < chars_read && current_line < from)
191 for (line_end = line_start; line_end < chars_read; line_end++)
192 if (buffer[line_end] == '\n')
195 line_start = line_end + 1;
196 if (current_line == from)
201 /* If there are lines left to gobble, then gobble them now. */
202 for (line_end = line_start; line_end < chars_read; line_end++)
203 if (buffer[line_end] == '\n')
205 buffer[line_end] = '\0';
207 if (buffer[line_start])
208 add_history (buffer + line_start);
212 if (current_line >= to)
215 line_start = line_end + 1;
224 /* Truncate the history file FNAME, leaving only LINES trailing lines.
225 If FNAME is NULL, then use ~/.history. Returns 0 on success, errno
228 history_truncate_file (fname, lines)
233 int file, chars_read, rv;
234 char *buffer, *filename;
238 buffer = (char *)NULL;
239 filename = history_filename (fname);
240 file = open (filename, O_RDONLY|O_BINARY, 0666);
243 /* Don't try to truncate non-regular files. */
244 if (file == -1 || fstat (file, &finfo) == -1)
252 if (S_ISREG (finfo.st_mode) == 0)
263 file_size = (size_t)finfo.st_size;
265 /* check for overflow on very large files */
266 if (file_size != finfo.st_size || file_size + 1 < file_size)
271 #elif defined (EOVERFLOW)
272 rv = errno = EOVERFLOW;
279 buffer = xmalloc (file_size + 1);
280 chars_read = read (file, buffer, file_size);
285 rv = (chars_read < 0) ? errno : 0;
289 /* Count backwards from the end of buffer until we have passed
291 for (i = chars_read - 1; lines && i; i--)
293 if (buffer[i] == '\n')
297 /* If this is the first line, then the file contains exactly the
298 number of lines we want to truncate to, so we don't need to do
299 anything. It's the first line if we don't find a newline between
300 the current value of i and 0. Otherwise, write from the start of
301 this line until the end of the buffer. */
303 if (buffer[i] == '\n')
309 /* Write only if there are more lines in the file than we want to
311 if (i && ((file = open (filename, O_WRONLY|O_TRUNC|O_BINARY, 0600)) != -1))
313 write (file, buffer + i, chars_read - i);
315 #if defined (__BEOS__)
316 /* BeOS ignores O_TRUNC. */
317 ftruncate (file, chars_read - i);
331 /* Workhorse function for writing history. Writes NELEMENT entries
332 from the history list to FILENAME. OVERWRITE is non-zero if you
333 wish to replace FILENAME with the entries. */
335 history_do_write (filename, nelements, overwrite)
336 const char *filename;
337 int nelements, overwrite;
343 mode = overwrite ? O_WRONLY|O_CREAT|O_TRUNC|O_BINARY : O_WRONLY|O_APPEND|O_BINARY;
344 output = history_filename (filename);
347 if ((file = open (output, mode, 0600)) == -1)
353 if (nelements > history_length)
354 nelements = history_length;
356 /* Build a buffer of all the lines to write, and write them in one syscall.
357 Suggested by Peter Ho (peter@robosts.oxford.ac.uk). */
359 HIST_ENTRY **the_history; /* local */
364 the_history = history_list ();
365 /* Calculate the total number of bytes to write. */
366 for (buffer_size = 0, i = history_length - nelements; i < history_length; i++)
367 buffer_size += 1 + strlen (the_history[i]->line);
369 /* Allocate the buffer, and fill it. */
370 buffer = xmalloc (buffer_size);
372 for (j = 0, i = history_length - nelements; i < history_length; i++)
374 strcpy (buffer + j, the_history[i]->line);
375 j += strlen (the_history[i]->line);
379 if (write (file, buffer, buffer_size) < 0)
391 /* Append NELEMENT entries to FILENAME. The entries appended are from
392 the end of the list minus NELEMENTs up to the end of the list. */
394 append_history (nelements, filename)
396 const char *filename;
398 return (history_do_write (filename, nelements, HISTORY_APPEND));
401 /* Overwrite FILENAME with the current history. If FILENAME is NULL,
402 then write the history list to ~/.history. Values returned
403 are as in read_history ().*/
405 write_history (filename)
406 const char *filename;
408 return (history_do_write (filename, history_length, HISTORY_OVERWRITE));