← Back to branch summary

~mysql/mysql-server/mysql-6.0

« back to all changes in this revision

Viewing changes to readline/histfile.c

  • Committer: bk at mysql
  • Date: 2000-07-31 19:29:14 UTC
  • Revision ID: sp1r-bk@work.mysql.com-20000731192914-08846
Import changeset

Show diffs side-by-side

added added

removed removed

Lines of Context:
readline/histfile.c
 
1
/* histfile.c - functions to manipulate the history file. */
 
2
 
 
3
/* Copyright (C) 1989, 1992 Free Software Foundation, Inc.
 
4
 
 
5
   This file contains the GNU History Library (the Library), a set of
 
6
   routines for managing the text of previously typed lines.
 
7
 
 
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 1, or (at your option)
 
11
   any later version.
 
12
 
 
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.
 
17
 
 
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
   675 Mass Ave, Cambridge, MA 02139, USA. */
 
22
 
 
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
 
27
 
 
28
#if defined (HAVE_CONFIG_H)
 
29
#  include <config.h>
 
30
#endif
 
31
 
 
32
#include <stdio.h>
 
33
 
 
34
#include <sys/types.h>
 
35
#ifndef _MINIX
 
36
#  include <sys/file.h>
 
37
#endif
 
38
#include <sys/stat.h>
 
39
#include <fcntl.h>
 
40
 
 
41
#if defined (HAVE_STDLIB_H)
 
42
#  include <stdlib.h>
 
43
#else
 
44
#  include "ansi_stdlib.h"
 
45
#endif /* HAVE_STDLIB_H */
 
46
 
 
47
#if defined (HAVE_UNISTD_H)
 
48
#  include <unistd.h>
 
49
#endif
 
50
 
 
51
#if defined (HAVE_STRING_H)
 
52
#  include <string.h>
 
53
#else
 
54
#  include <strings.h>
 
55
#endif /* !HAVE_STRING_H */
 
56
 
 
57
#if defined (__EMX__)
 
58
#  ifndef O_BINARY
 
59
#    define O_BINARY 0
 
60
#  endif
 
61
#else /* !__EMX__ */
 
62
   /* If we're not compiling for __EMX__, we don't want this at all.  Ever. */
 
63
#  undef O_BINARY
 
64
#  define O_BINARY 0
 
65
#endif /* !__EMX__ */
 
66
 
 
67
#include <errno.h>
 
68
#if !defined (errno)
 
69
extern int errno;
 
70
#endif /* !errno */
 
71
 
 
72
#include "history.h"
 
73
#include "histlib.h"
 
74
 
 
75
/* Functions imported from shell.c */
 
76
extern char *get_env_value ();
 
77
 
 
78
extern char *xmalloc (), *xrealloc ();
 
79
 
 
80
/* Return the string that should be used in the place of this
 
81
   filename.  This only matters when you don't specify the
 
82
   filename to read_history (), or write_history (). */
 
83
static char *
 
84
history_filename (filename)
 
85
     char *filename;
 
86
{
 
87
  char *return_val, *home;
 
88
  int home_len;
 
89
 
 
90
  return_val = filename ? savestring (filename) : (char *)NULL;
 
91
 
 
92
  if (return_val)
 
93
    return (return_val);
 
94
  
 
95
  home = get_env_value ("HOME");
 
96
 
 
97
  if (home == 0)
 
98
    {
 
99
      home = ".";
 
100
      home_len = 1;
 
101
    }
 
102
  else
 
103
    home_len = strlen (home);
 
104
 
 
105
  return_val = xmalloc (2 + home_len + 8); /* strlen(".history") == 8 */
 
106
  strcpy (return_val, home);
 
107
  return_val[home_len] = '/';
 
108
  strcpy (return_val + home_len + 1, ".history");
 
109
 
 
110
  return (return_val);
 
111
}
 
112
 
 
113
/* Add the contents of FILENAME to the history list, a line at a time.
 
114
   If FILENAME is NULL, then read from ~/.history.  Returns 0 if
 
115
   successful, or errno if not. */
 
116
int
 
117
read_history (filename)
 
118
     char *filename;
 
119
{
 
120
  return (read_history_range (filename, 0, -1));
 
121
}
 
122
 
 
123
/* Read a range of lines from FILENAME, adding them to the history list.
 
124
   Start reading at the FROM'th line and end at the TO'th.  If FROM
 
125
   is zero, start at the beginning.  If TO is less than FROM, read
 
126
   until the end of the file.  If FILENAME is NULL, then read from
 
127
   ~/.history.  Returns 0 if successful, or errno if not. */
 
128
int
 
129
read_history_range (filename, from, to)
 
130
     char *filename;
 
131
     int from, to;
 
132
{
 
133
  register int line_start, line_end;
 
134
  char *input, *buffer;
 
135
  int file, current_line;
 
136
  struct stat finfo;
 
137
  size_t file_size;
 
138
 
 
139
  buffer = (char *)NULL;
 
140
  input = history_filename (filename);
 
141
  file = open (input, O_RDONLY|O_BINARY, 0666);
 
142
 
 
143
  if ((file < 0) || (fstat (file, &finfo) == -1))
 
144
    goto error_and_exit;
 
145
 
 
146
  file_size = (size_t)finfo.st_size;
 
147
 
 
148
  /* check for overflow on very large files */
 
149
  if (file_size != finfo.st_size || file_size + 1 < file_size)
 
150
    {
 
151
#if defined (EFBIG)
 
152
      errno = EFBIG;
 
153
#endif
 
154
      goto error_and_exit;
 
155
    }
 
156
 
 
157
  buffer = xmalloc (file_size + 1);
 
158
#if 0
 
159
  if (read (file, buffer, file_size) != file_size)
 
160
#else
 
161
  if (read (file, buffer, file_size) < 0)
 
162
#endif
 
163
    {
 
164
  error_and_exit:
 
165
      if (file >= 0)
 
166
        close (file);
 
167
 
 
168
      FREE (input);
 
169
      FREE (buffer);
 
170
 
 
171
      return (errno);
 
172
    }
 
173
 
 
174
  close (file);
 
175
 
 
176
  /* Set TO to larger than end of file if negative. */
 
177
  if (to < 0)
 
178
    to = file_size;
 
179
 
 
180
  /* Start at beginning of file, work to end. */
 
181
  line_start = line_end = current_line = 0;
 
182
 
 
183
  /* Skip lines until we are at FROM. */
 
184
  while (line_start < file_size && current_line < from)
 
185
    {
 
186
      for (line_end = line_start; line_end < file_size; line_end++)
 
187
        if (buffer[line_end] == '\n')
 
188
          {
 
189
            current_line++;
 
190
            line_start = line_end + 1;
 
191
            if (current_line == from)
 
192
              break;
 
193
          }
 
194
    }
 
195
 
 
196
  /* If there are lines left to gobble, then gobble them now. */
 
197
  for (line_end = line_start; line_end < file_size; line_end++)
 
198
    if (buffer[line_end] == '\n')
 
199
      {
 
200
        buffer[line_end] = '\0';
 
201
 
 
202
        if (buffer[line_start])
 
203
          add_history (buffer + line_start);
 
204
 
 
205
        current_line++;
 
206
 
 
207
        if (current_line >= to)
 
208
          break;
 
209
 
 
210
        line_start = line_end + 1;
 
211
      }
 
212
 
 
213
  FREE (input);
 
214
  FREE (buffer);
 
215
 
 
216
  return (0);
 
217
}
 
218
 
 
219
/* Truncate the history file FNAME, leaving only LINES trailing lines.
 
220
   If FNAME is NULL, then use ~/.history. */
 
221
int
 
222
history_truncate_file (fname, lines)
 
223
     char *fname;
 
224
     int lines;
 
225
{
 
226
  register int i;
 
227
  int file, chars_read;
 
228
  char *buffer, *filename;
 
229
  struct stat finfo;
 
230
  size_t file_size;
 
231
 
 
232
  buffer = (char *)NULL;
 
233
  filename = history_filename (fname);
 
234
  file = open (filename, O_RDONLY|O_BINARY, 0666);
 
235
 
 
236
  if (file == -1 || fstat (file, &finfo) == -1)
 
237
    goto truncate_exit;
 
238
 
 
239
  file_size = (size_t)finfo.st_size;
 
240
 
 
241
  /* check for overflow on very large files */
 
242
  if (file_size != finfo.st_size || file_size + 1 < file_size)
 
243
    {
 
244
      close (file);
 
245
#if defined (EFBIG)
 
246
      errno = EFBIG;
 
247
#endif
 
248
      goto truncate_exit;
 
249
    }
 
250
 
 
251
  buffer = xmalloc (file_size + 1);
 
252
  chars_read = read (file, buffer, file_size);
 
253
  close (file);
 
254
 
 
255
  if (chars_read <= 0)
 
256
    goto truncate_exit;
 
257
 
 
258
  /* Count backwards from the end of buffer until we have passed
 
259
     LINES lines. */
 
260
  for (i = chars_read - 1; lines && i; i--)
 
261
    {
 
262
      if (buffer[i] == '\n')
 
263
        lines--;
 
264
    }
 
265
 
 
266
  /* If this is the first line, then the file contains exactly the
 
267
     number of lines we want to truncate to, so we don't need to do
 
268
     anything.  It's the first line if we don't find a newline between
 
269
     the current value of i and 0.  Otherwise, write from the start of
 
270
     this line until the end of the buffer. */
 
271
  for ( ; i; i--)
 
272
    if (buffer[i] == '\n')
 
273
      {
 
274
        i++;
 
275
        break;
 
276
      }
 
277
 
 
278
  /* Write only if there are more lines in the file than we want to
 
279
     truncate to. */
 
280
  if (i && ((file = open (filename, O_WRONLY|O_TRUNC|O_BINARY, 0600)) != -1))
 
281
    {
 
282
      write (file, buffer + i, file_size - i);
 
283
 
 
284
#if defined (__BEOS__)
 
285
      /* BeOS ignores O_TRUNC. */
 
286
      ftruncate (file, file_size - i);
 
287
#endif
 
288
 
 
289
      close (file);
 
290
    }
 
291
 
 
292
 truncate_exit:
 
293
 
 
294
  FREE (buffer);
 
295
 
 
296
  free (filename);
 
297
  return 0;
 
298
}
 
299
 
 
300
/* Workhorse function for writing history.  Writes NELEMENT entries
 
301
   from the history list to FILENAME.  OVERWRITE is non-zero if you
 
302
   wish to replace FILENAME with the entries. */
 
303
static int
 
304
history_do_write (filename, nelements, overwrite)
 
305
     char *filename;
 
306
     int nelements, overwrite;
 
307
{
 
308
  register int i;
 
309
  char *output;
 
310
  int file, mode;
 
311
 
 
312
  mode = overwrite ? O_WRONLY|O_CREAT|O_TRUNC|O_BINARY : O_WRONLY|O_APPEND|O_BINARY;
 
313
  output = history_filename (filename);
 
314
 
 
315
  if ((file = open (output, mode, 0600)) == -1)
 
316
    {
 
317
      FREE (output);
 
318
      return (errno);
 
319
    }
 
320
 
 
321
  if (nelements > history_length)
 
322
    nelements = history_length;
 
323
 
 
324
  /* Build a buffer of all the lines to write, and write them in one syscall.
 
325
     Suggested by Peter Ho (peter@robosts.oxford.ac.uk). */
 
326
  {
 
327
    HIST_ENTRY **the_history;   /* local */
 
328
    register int j;
 
329
    int buffer_size;
 
330
    char *buffer;
 
331
 
 
332
    the_history = history_list ();
 
333
    /* Calculate the total number of bytes to write. */
 
334
    for (buffer_size = 0, i = history_length - nelements; i < history_length; i++)
 
335
      buffer_size += 1 + strlen (the_history[i]->line);
 
336
 
 
337
    /* Allocate the buffer, and fill it. */
 
338
    buffer = xmalloc (buffer_size);
 
339
 
 
340
    for (j = 0, i = history_length - nelements; i < history_length; i++)
 
341
      {
 
342
        strcpy (buffer + j, the_history[i]->line);
 
343
        j += strlen (the_history[i]->line);
 
344
        buffer[j++] = '\n';
 
345
      }
 
346
 
 
347
    write (file, buffer, buffer_size);
 
348
    free (buffer);
 
349
  }
 
350
 
 
351
  close (file);
 
352
 
 
353
  FREE (output);
 
354
 
 
355
  return (0);
 
356
}
 
357
 
 
358
/* Append NELEMENT entries to FILENAME.  The entries appended are from
 
359
   the end of the list minus NELEMENTs up to the end of the list. */
 
360
int
 
361
append_history (nelements, filename)
 
362
     int nelements;
 
363
     char *filename;
 
364
{
 
365
  return (history_do_write (filename, nelements, HISTORY_APPEND));
 
366
}
 
367
 
 
368
/* Overwrite FILENAME with the current history.  If FILENAME is NULL,
 
369
   then write the history list to ~/.history.  Values returned
 
370
   are as in read_history ().*/
 
371
int
 
372
write_history (filename)
 
373
     char *filename;
 
374
{
 
375
  return (history_do_write (filename, history_length, HISTORY_OVERWRITE));
 
376
}