2000-08-06 21:13:45 +00:00
|
|
|
/* $Id$ */
|
2000-06-19 04:22:15 +00:00
|
|
|
/**************************************************************************
|
|
|
|
* files.c *
|
|
|
|
* *
|
2003-01-15 19:33:27 +00:00
|
|
|
* Copyright (C) 1999-2003 Chris Allegretta *
|
2000-06-19 04:22:15 +00:00
|
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
|
|
* it under the terms of the GNU General Public License as published by *
|
2001-10-24 11:33:54 +00:00
|
|
|
* the Free Software Foundation; either version 2, or (at your option) *
|
2000-06-19 04:22:15 +00:00
|
|
|
* any later version. *
|
|
|
|
* *
|
|
|
|
* This program is distributed in the hope that it will be useful, *
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
|
|
* GNU General Public License for more details. *
|
|
|
|
* *
|
|
|
|
* You should have received a copy of the GNU General Public License *
|
|
|
|
* along with this program; if not, write to the Free Software *
|
|
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. *
|
|
|
|
* *
|
|
|
|
**************************************************************************/
|
|
|
|
|
2001-04-28 18:03:52 +00:00
|
|
|
#include "config.h"
|
|
|
|
|
2000-06-19 04:22:15 +00:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <sys/types.h>
|
2002-03-25 13:40:39 +00:00
|
|
|
#include <sys/wait.h>
|
2000-06-19 04:22:15 +00:00
|
|
|
#include <sys/stat.h>
|
2002-06-28 22:45:14 +00:00
|
|
|
#include <utime.h>
|
2000-06-19 04:22:15 +00:00
|
|
|
#include <fcntl.h>
|
|
|
|
#include <errno.h>
|
2000-11-05 17:54:41 +00:00
|
|
|
#include <ctype.h>
|
|
|
|
#include <dirent.h>
|
2001-01-22 22:17:08 +00:00
|
|
|
#include <pwd.h>
|
2003-01-13 01:35:15 +00:00
|
|
|
#include <assert.h>
|
2000-06-19 04:22:15 +00:00
|
|
|
#include "proto.h"
|
|
|
|
#include "nano.h"
|
2000-06-21 03:00:43 +00:00
|
|
|
|
2003-01-30 00:53:32 +00:00
|
|
|
/* Set a default value for PATH_MAX, so we can use it below in lines like
|
|
|
|
path = getcwd(NULL, PATH_MAX + 1); */
|
|
|
|
#ifndef PATH_MAX
|
|
|
|
#define PATH_MAX -1
|
|
|
|
#endif
|
|
|
|
|
2001-10-14 19:05:10 +00:00
|
|
|
#ifndef NANO_SMALL
|
|
|
|
static int fileformat = 0; /* 0 = *nix, 1 = DOS, 2 = Mac */
|
|
|
|
#endif
|
|
|
|
|
2003-01-13 01:35:15 +00:00
|
|
|
/* Load file into edit buffer - takes data from file struct. */
|
2002-05-11 03:04:44 +00:00
|
|
|
void load_file(int update)
|
2000-06-19 04:22:15 +00:00
|
|
|
{
|
|
|
|
current = fileage;
|
2001-07-11 02:08:33 +00:00
|
|
|
|
2001-07-14 19:32:47 +00:00
|
|
|
#ifdef ENABLE_MULTIBUFFER
|
2002-05-11 03:04:44 +00:00
|
|
|
/* if update is zero, add a new entry to the open_files structure;
|
2002-02-22 04:30:50 +00:00
|
|
|
otherwise, update the current entry (the latter is needed in the
|
|
|
|
case of the alternate spell checker) */
|
2002-05-11 03:04:44 +00:00
|
|
|
add_open_file(update);
|
2001-07-11 02:08:33 +00:00
|
|
|
#endif
|
|
|
|
|
2002-05-04 03:47:33 +00:00
|
|
|
#ifdef ENABLE_COLOR
|
|
|
|
update_color();
|
2003-01-13 01:35:15 +00:00
|
|
|
edit_refresh();
|
2002-05-04 03:47:33 +00:00
|
|
|
#endif
|
2000-06-19 04:22:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* What happens when there is no file to open? aiee! */
|
|
|
|
void new_file(void)
|
|
|
|
{
|
2002-07-24 01:02:26 +00:00
|
|
|
fileage = make_new_node(NULL);
|
2001-05-17 11:35:43 +00:00
|
|
|
fileage->data = charalloc(1);
|
2002-05-11 03:04:44 +00:00
|
|
|
fileage->data[0] = '\0';
|
2000-06-19 04:22:15 +00:00
|
|
|
filebot = fileage;
|
|
|
|
edittop = fileage;
|
|
|
|
editbot = fileage;
|
|
|
|
current = fileage;
|
2002-07-24 01:02:26 +00:00
|
|
|
current_x = 0;
|
2000-06-19 04:22:15 +00:00
|
|
|
totlines = 1;
|
2001-09-28 21:59:01 +00:00
|
|
|
totsize = 0;
|
2001-07-18 01:03:36 +00:00
|
|
|
|
|
|
|
#ifdef ENABLE_MULTIBUFFER
|
|
|
|
/* if there aren't any entries in open_files, create the entry for
|
2002-02-22 04:30:50 +00:00
|
|
|
this new file; without this, if nano is started without a filename
|
|
|
|
on the command line, a new file will be created, but it will be
|
2002-05-11 03:04:44 +00:00
|
|
|
given no open_files entry */
|
2002-12-22 16:30:00 +00:00
|
|
|
if (open_files == NULL) {
|
2002-02-22 04:30:50 +00:00
|
|
|
add_open_file(0);
|
2002-01-02 15:12:21 +00:00
|
|
|
/* turn off view mode in this case; this is for consistency
|
|
|
|
whether multibuffers are compiled in or not */
|
|
|
|
UNSET(VIEW_MODE);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
/* if multibuffers haven't been compiled in, turn off view mode
|
|
|
|
unconditionally; otherwise, don't turn them off (except in the
|
|
|
|
above case), so that we can view multiple files properly */
|
|
|
|
UNSET(VIEW_MODE);
|
2001-07-18 01:03:36 +00:00
|
|
|
#endif
|
|
|
|
|
2002-05-05 23:03:54 +00:00
|
|
|
#ifdef ENABLE_COLOR
|
|
|
|
update_color();
|
2003-01-13 01:35:15 +00:00
|
|
|
edit_refresh();
|
2002-05-05 23:03:54 +00:00
|
|
|
#endif
|
2000-06-19 04:22:15 +00:00
|
|
|
}
|
|
|
|
|
2002-06-13 00:40:19 +00:00
|
|
|
filestruct *read_line(char *buf, filestruct *prev, int *line1ins, int len)
|
2000-06-19 04:22:15 +00:00
|
|
|
{
|
2002-12-22 16:30:00 +00:00
|
|
|
filestruct *fileptr = (filestruct *)nmalloc(sizeof(filestruct));
|
2002-06-13 00:40:19 +00:00
|
|
|
|
|
|
|
/* nulls to newlines; len is the string's real length here */
|
|
|
|
unsunder(buf, len);
|
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
assert(strlen(buf) == len);
|
|
|
|
|
|
|
|
fileptr->data = mallocstrcpy(NULL, buf);
|
2000-06-19 04:22:15 +00:00
|
|
|
|
2001-09-21 02:37:01 +00:00
|
|
|
#ifndef NANO_SMALL
|
2002-02-15 19:17:02 +00:00
|
|
|
/* If it's a DOS file (CRLF), and file conversion isn't disabled,
|
|
|
|
strip out the CR part */
|
2002-12-22 16:30:00 +00:00
|
|
|
if (!ISSET(NO_CONVERT) && len > 0 && buf[len - 1] == '\r') {
|
|
|
|
fileptr->data[len - 1] = '\0';
|
2001-09-22 00:42:10 +00:00
|
|
|
totsize--;
|
2001-10-14 19:05:10 +00:00
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
if (fileformat == 0)
|
2001-10-14 19:05:10 +00:00
|
|
|
fileformat = 1;
|
2001-09-21 02:37:01 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
if (*line1ins != 0 || fileage == NULL) {
|
2000-06-19 04:22:15 +00:00
|
|
|
/* Special case, insert with cursor on 1st line. */
|
|
|
|
fileptr->prev = NULL;
|
|
|
|
fileptr->next = fileage;
|
|
|
|
fileptr->lineno = 1;
|
2002-12-22 16:30:00 +00:00
|
|
|
if (*line1ins != 0) {
|
|
|
|
*line1ins = 0;
|
|
|
|
/* If we're inserting into the first line of the file, then
|
|
|
|
we want to make sure that our edit buffer stays on the
|
|
|
|
first line (and that fileage stays up to date!) */
|
|
|
|
edittop = fileptr;
|
|
|
|
} else
|
|
|
|
filebot = fileptr;
|
2000-06-19 04:22:15 +00:00
|
|
|
fileage = fileptr;
|
2002-12-22 16:30:00 +00:00
|
|
|
} else {
|
|
|
|
assert(prev != NULL);
|
2000-06-19 04:22:15 +00:00
|
|
|
fileptr->prev = prev;
|
|
|
|
fileptr->next = NULL;
|
|
|
|
fileptr->lineno = prev->lineno + 1;
|
|
|
|
prev->next = fileptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
return fileptr;
|
|
|
|
}
|
|
|
|
|
2002-05-11 03:04:44 +00:00
|
|
|
int read_file(FILE *f, const char *filename, int quiet)
|
2000-06-19 04:22:15 +00:00
|
|
|
{
|
2002-06-13 00:40:19 +00:00
|
|
|
int num_lines = 0, len = 0;
|
2003-01-13 01:35:15 +00:00
|
|
|
char input = '\0'; /* current input character */
|
2000-06-19 04:22:15 +00:00
|
|
|
char *buf;
|
|
|
|
long i = 0, bufx = 128;
|
|
|
|
filestruct *fileptr = current, *tmp = NULL;
|
2002-12-22 16:30:00 +00:00
|
|
|
#ifndef NANO_SMALL
|
|
|
|
int old_no_convert = ISSET(NO_CONVERT);
|
|
|
|
#endif
|
2000-06-19 04:22:15 +00:00
|
|
|
int line1ins = 0;
|
2002-04-22 23:52:34 +00:00
|
|
|
int input_int;
|
2000-06-19 04:22:15 +00:00
|
|
|
|
2001-05-17 11:35:43 +00:00
|
|
|
buf = charalloc(bufx);
|
2000-07-19 01:16:18 +00:00
|
|
|
buf[0] = '\0';
|
2000-06-19 04:22:15 +00:00
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
if (current != NULL) {
|
|
|
|
if (current == fileage)
|
|
|
|
line1ins = 1;
|
|
|
|
else
|
|
|
|
fileptr = current->prev;
|
2000-06-19 04:22:15 +00:00
|
|
|
tmp = fileptr;
|
|
|
|
}
|
2002-12-22 16:30:00 +00:00
|
|
|
|
|
|
|
/* For the assertion in read_line(), it must be true that if current is
|
2003-01-13 01:35:15 +00:00
|
|
|
* NULL then so is fileage. */
|
2002-12-22 16:30:00 +00:00
|
|
|
assert(current != NULL || fileage == NULL);
|
|
|
|
|
2003-01-13 01:35:15 +00:00
|
|
|
/* Read the entire file into file struct. */
|
2002-04-22 23:52:34 +00:00
|
|
|
while ((input_int = getc(f)) != EOF) {
|
2002-07-20 13:57:41 +00:00
|
|
|
input = (char)input_int;
|
2002-03-28 01:59:34 +00:00
|
|
|
#ifndef NANO_SMALL
|
2002-12-22 16:30:00 +00:00
|
|
|
/* If the file has binary chars in it, don't stupidly
|
2003-02-16 03:13:47 +00:00
|
|
|
assume it's a DOS or Mac formatted file if it hasn't been
|
|
|
|
detected as one already! */
|
|
|
|
if (fileformat == 0 && !ISSET(NO_CONVERT)
|
|
|
|
&& is_cntrl_char((int)input) != 0 && input != '\t'
|
|
|
|
&& input != '\r' && input != '\n')
|
2002-06-13 00:40:19 +00:00
|
|
|
SET(NO_CONVERT);
|
2002-03-28 01:59:34 +00:00
|
|
|
#endif
|
|
|
|
|
2002-03-26 13:05:54 +00:00
|
|
|
if (input == '\n') {
|
2002-06-13 00:40:19 +00:00
|
|
|
|
|
|
|
/* read in the line properly */
|
|
|
|
fileptr = read_line(buf, fileptr, &line1ins, len);
|
|
|
|
|
|
|
|
/* reset the line length, in preparation for the next line */
|
|
|
|
len = 0;
|
|
|
|
|
2000-07-08 03:57:16 +00:00
|
|
|
num_lines++;
|
2002-06-13 00:40:19 +00:00
|
|
|
buf[0] = '\0';
|
2000-06-19 04:22:15 +00:00
|
|
|
i = 0;
|
2001-09-22 06:38:38 +00:00
|
|
|
#ifndef NANO_SMALL
|
2002-02-15 19:17:02 +00:00
|
|
|
/* If it's a Mac file (no LF just a CR), and file conversion
|
|
|
|
isn't disabled, handle it! */
|
2002-06-13 00:40:19 +00:00
|
|
|
} else if (!ISSET(NO_CONVERT) && i > 0 && buf[i - 1] == '\r') {
|
2001-10-14 19:05:10 +00:00
|
|
|
fileformat = 2;
|
2002-06-13 00:40:19 +00:00
|
|
|
|
|
|
|
/* read in the line properly */
|
|
|
|
fileptr = read_line(buf, fileptr, &line1ins, len);
|
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
/* reset the line length, in preparation for the next line;
|
|
|
|
since we've already read in the next character, reset it
|
|
|
|
to 1 instead of 0 */
|
|
|
|
len = 1;
|
2002-06-13 00:40:19 +00:00
|
|
|
|
2001-09-22 06:38:38 +00:00
|
|
|
num_lines++;
|
2002-06-13 00:40:19 +00:00
|
|
|
totsize++;
|
2002-03-26 13:05:54 +00:00
|
|
|
buf[0] = input;
|
2002-06-13 00:40:19 +00:00
|
|
|
buf[1] = '\0';
|
2001-09-22 06:38:38 +00:00
|
|
|
i = 1;
|
|
|
|
#endif
|
2000-06-19 04:22:15 +00:00
|
|
|
} else {
|
2002-12-22 16:30:00 +00:00
|
|
|
|
|
|
|
/* Calculate the total length of the line; it might have
|
|
|
|
nulls in it, so we can't just use strlen(). */
|
|
|
|
len++;
|
|
|
|
|
2000-06-19 04:22:15 +00:00
|
|
|
/* Now we allocate a bigger buffer 128 characters at a time.
|
2002-12-22 16:30:00 +00:00
|
|
|
If we allocate a lot of space for one line, we may indeed
|
2000-06-19 04:22:15 +00:00
|
|
|
have to use a buffer this big later on, so we don't
|
2001-05-05 17:45:54 +00:00
|
|
|
decrease it at all. We do free it at the end, though. */
|
2000-06-19 04:22:15 +00:00
|
|
|
if (i >= bufx - 1) {
|
|
|
|
bufx += 128;
|
2002-12-22 16:30:00 +00:00
|
|
|
buf = nrealloc(buf, bufx);
|
2000-06-19 04:22:15 +00:00
|
|
|
}
|
2002-03-26 13:05:54 +00:00
|
|
|
buf[i] = input;
|
2002-06-13 00:40:19 +00:00
|
|
|
buf[i + 1] = '\0';
|
2000-06-19 04:22:15 +00:00
|
|
|
i++;
|
|
|
|
}
|
2002-04-22 23:52:34 +00:00
|
|
|
totsize++;
|
|
|
|
}
|
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
/* This conditional duplicates previous read_byte() behavior;
|
|
|
|
perhaps this could use some better handling. */
|
|
|
|
if (ferror(f))
|
|
|
|
nperror(filename);
|
|
|
|
fclose(f);
|
2000-06-19 04:22:15 +00:00
|
|
|
|
|
|
|
/* Did we not get a newline but still have stuff to do? */
|
2002-06-13 00:40:19 +00:00
|
|
|
if (len > 0) {
|
2002-07-21 15:44:13 +00:00
|
|
|
#ifndef NANO_SMALL
|
|
|
|
/* If file conversion isn't disabled, the last character in
|
|
|
|
this file is a CR and fileformat isn't set yet, make sure
|
|
|
|
it's set to Mac format */
|
2002-12-22 16:30:00 +00:00
|
|
|
if (!ISSET(NO_CONVERT) && buf[len - 1] == '\r' && fileformat == 0)
|
2002-07-21 15:44:13 +00:00
|
|
|
fileformat = 2;
|
|
|
|
#endif
|
|
|
|
|
2002-06-13 00:40:19 +00:00
|
|
|
/* read in the LAST line properly */
|
|
|
|
fileptr = read_line(buf, fileptr, &line1ins, len);
|
|
|
|
|
2000-07-08 03:57:16 +00:00
|
|
|
num_lines++;
|
2002-06-13 00:40:19 +00:00
|
|
|
totsize++;
|
|
|
|
buf[0] = '\0';
|
2000-06-19 04:22:15 +00:00
|
|
|
}
|
2002-07-21 15:44:13 +00:00
|
|
|
#ifndef NANO_SMALL
|
2002-12-22 16:30:00 +00:00
|
|
|
else if (!ISSET(NO_CONVERT) && input == '\r') {
|
2002-07-21 15:44:13 +00:00
|
|
|
/* If file conversion isn't disabled and the last character in
|
|
|
|
this file is a CR, read it in properly as a (Mac format)
|
|
|
|
line */
|
2002-12-22 16:30:00 +00:00
|
|
|
buf[0] = input;
|
|
|
|
buf[1] = '\0';
|
|
|
|
len = 1;
|
|
|
|
fileptr = read_line(buf, fileptr, &line1ins, len);
|
|
|
|
num_lines++;
|
|
|
|
totsize++;
|
|
|
|
buf[0] = '\0';
|
2002-07-21 15:44:13 +00:00
|
|
|
}
|
|
|
|
#endif
|
2002-03-21 05:07:28 +00:00
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
free(buf);
|
|
|
|
|
|
|
|
#ifndef NANO_SMALL
|
|
|
|
/* If NO_CONVERT wasn't set before we read the file, but it is now,
|
|
|
|
unset it again. */
|
|
|
|
if (!old_no_convert && ISSET(NO_CONVERT))
|
|
|
|
UNSET(NO_CONVERT);
|
|
|
|
#endif
|
|
|
|
|
2002-03-21 05:07:28 +00:00
|
|
|
/* Did we even GET a file if we don't already have one? */
|
2002-10-17 02:19:31 +00:00
|
|
|
if (totsize == 0 || fileptr == NULL)
|
2000-06-19 04:22:15 +00:00
|
|
|
new_file();
|
2000-07-04 22:15:39 +00:00
|
|
|
|
2002-03-26 13:05:54 +00:00
|
|
|
/* Did we try to insert a file of 0 bytes? */
|
2002-10-17 02:19:31 +00:00
|
|
|
if (num_lines != 0) {
|
|
|
|
if (current != NULL) {
|
|
|
|
fileptr->next = current;
|
|
|
|
current->prev = fileptr;
|
|
|
|
renumber(current);
|
|
|
|
current_x = 0;
|
|
|
|
placewewant = 0;
|
|
|
|
} else if (fileptr->next == NULL) {
|
|
|
|
filebot = fileptr;
|
|
|
|
new_magicline();
|
|
|
|
totsize--;
|
|
|
|
load_file(quiet);
|
|
|
|
}
|
2000-06-19 04:22:15 +00:00
|
|
|
}
|
2001-10-14 19:05:10 +00:00
|
|
|
|
|
|
|
#ifndef NANO_SMALL
|
|
|
|
if (fileformat == 2)
|
2003-02-10 11:30:11 +00:00
|
|
|
statusbar(P_("Read %d line (Converted from Mac format)",
|
2002-10-17 02:19:31 +00:00
|
|
|
"Read %d lines (Converted from Mac format)",
|
|
|
|
num_lines), num_lines);
|
2001-10-14 19:05:10 +00:00
|
|
|
else if (fileformat == 1)
|
2003-02-10 11:30:11 +00:00
|
|
|
statusbar(P_("Read %d line (Converted from DOS format)",
|
2002-10-17 02:19:31 +00:00
|
|
|
"Read %d lines (Converted from DOS format)",
|
|
|
|
num_lines), num_lines);
|
2001-10-14 19:05:10 +00:00
|
|
|
else
|
|
|
|
#endif
|
2003-02-10 11:30:11 +00:00
|
|
|
statusbar(P_("Read %d line", "Read %d lines", num_lines),
|
2002-10-17 02:19:31 +00:00
|
|
|
num_lines);
|
2001-10-14 19:05:10 +00:00
|
|
|
|
2000-07-08 03:57:16 +00:00
|
|
|
totlines += num_lines;
|
2000-06-19 04:22:15 +00:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2003-01-13 01:35:15 +00:00
|
|
|
/* Open the file (and decide if it exists). */
|
2002-05-11 03:04:44 +00:00
|
|
|
int open_file(const char *filename, int insert, int quiet)
|
2000-06-19 04:22:15 +00:00
|
|
|
{
|
|
|
|
int fd;
|
2002-04-22 23:52:34 +00:00
|
|
|
FILE *f;
|
2000-06-19 04:22:15 +00:00
|
|
|
struct stat fileinfo;
|
|
|
|
|
2002-05-11 03:04:44 +00:00
|
|
|
if (filename[0] == '\0' || stat(filename, &fileinfo) == -1) {
|
2002-02-22 04:30:50 +00:00
|
|
|
if (insert && !quiet) {
|
|
|
|
statusbar(_("\"%s\" not found"), filename);
|
2000-06-19 04:22:15 +00:00
|
|
|
return -1;
|
|
|
|
} else {
|
|
|
|
/* We have a new file */
|
|
|
|
statusbar(_("New File"));
|
|
|
|
new_file();
|
|
|
|
}
|
2003-01-26 04:11:09 +00:00
|
|
|
} else if (S_ISDIR(fileinfo.st_mode) || S_ISCHR(fileinfo.st_mode) ||
|
|
|
|
S_ISBLK(fileinfo.st_mode)) {
|
|
|
|
/* Don't open character or block files. Sorry, /dev/sndstat! */
|
|
|
|
statusbar(S_ISDIR(fileinfo.st_mode) ? _("\"%s\" is a directory") :
|
|
|
|
_("File \"%s\" is a device file"), filename);
|
|
|
|
if (!insert)
|
|
|
|
new_file();
|
|
|
|
return -1;
|
2000-06-19 04:22:15 +00:00
|
|
|
} else if ((fd = open(filename, O_RDONLY)) == -1) {
|
2003-01-13 01:35:15 +00:00
|
|
|
/* If we're in multibuffer mode, don't be quiet when an error
|
|
|
|
occurs while opening a file */
|
|
|
|
if (!quiet
|
|
|
|
#ifdef ENABLE_MULTIBUFFER
|
|
|
|
|| ISSET(MULTIBUFFER)
|
|
|
|
#endif
|
|
|
|
)
|
2000-06-19 04:22:15 +00:00
|
|
|
statusbar("%s: %s", strerror(errno), filename);
|
2000-12-18 01:09:07 +00:00
|
|
|
if (!insert)
|
|
|
|
new_file();
|
2000-06-19 04:22:15 +00:00
|
|
|
return -1;
|
|
|
|
} else { /* File is A-OK */
|
|
|
|
if (!quiet)
|
|
|
|
statusbar(_("Reading File"));
|
2002-04-22 23:52:34 +00:00
|
|
|
f = fdopen(fd, "rb"); /* Binary for our own line-end munging */
|
2002-12-22 16:30:00 +00:00
|
|
|
if (f == NULL) {
|
2002-04-22 23:52:34 +00:00
|
|
|
nperror("fdopen");
|
2003-01-26 04:11:09 +00:00
|
|
|
close(fd);
|
2002-04-22 23:52:34 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
read_file(f, filename, quiet);
|
2002-06-28 22:45:14 +00:00
|
|
|
#ifndef NANO_SMALL
|
|
|
|
stat(filename, &originalfilestat);
|
|
|
|
#endif
|
2000-06-19 04:22:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2002-02-22 04:30:50 +00:00
|
|
|
/* This function will return the name of the first available extension
|
2003-01-13 01:35:15 +00:00
|
|
|
* of a filename (starting with the filename, then filename.1, etc).
|
|
|
|
* Memory is allocated for the return value. If no writable extension
|
|
|
|
* exists, we return "". */
|
2002-04-06 05:02:14 +00:00
|
|
|
char *get_next_filename(const char *name)
|
2002-02-22 04:30:50 +00:00
|
|
|
{
|
|
|
|
int i = 0;
|
|
|
|
char *buf = NULL;
|
|
|
|
struct stat fs;
|
|
|
|
|
|
|
|
buf = charalloc(strlen(name) + num_of_digits(INT_MAX) + 2);
|
|
|
|
strcpy(buf, name);
|
|
|
|
|
2002-04-06 05:02:14 +00:00
|
|
|
while (1) {
|
2002-02-22 04:30:50 +00:00
|
|
|
|
|
|
|
if (stat(buf, &fs) == -1)
|
2002-04-06 05:02:14 +00:00
|
|
|
return buf;
|
2002-02-22 04:30:50 +00:00
|
|
|
if (i == INT_MAX)
|
|
|
|
break;
|
|
|
|
|
|
|
|
i++;
|
|
|
|
strcpy(buf, name);
|
|
|
|
sprintf(&buf[strlen(name)], ".%d", i);
|
|
|
|
}
|
|
|
|
|
2002-04-06 05:02:14 +00:00
|
|
|
/* We get here only if there is no possible save file. */
|
|
|
|
buf[0] = '\0';
|
2002-02-22 04:30:50 +00:00
|
|
|
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
2001-07-11 02:08:33 +00:00
|
|
|
int do_insertfile(int loading_file)
|
2000-06-19 04:22:15 +00:00
|
|
|
{
|
2002-05-11 03:04:44 +00:00
|
|
|
int i, old_current_x = current_x;
|
2000-11-25 05:03:20 +00:00
|
|
|
char *realname = NULL;
|
2002-09-03 22:58:40 +00:00
|
|
|
static char *inspath = NULL;
|
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
if (inspath == NULL) {
|
|
|
|
inspath = charalloc(1);
|
|
|
|
inspath[0] = '\0';
|
|
|
|
}
|
2000-06-19 04:22:15 +00:00
|
|
|
|
|
|
|
wrap_reset();
|
2001-05-21 12:56:25 +00:00
|
|
|
|
2003-02-03 04:55:17 +00:00
|
|
|
#if !defined(DISABLE_BROWSER) || !defined(NANO_SMALL) && defined(ENABLE_MULTIBUFFER)
|
|
|
|
start_again: /* Goto here when the user cancels the file browser. */
|
|
|
|
#endif
|
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
#if !defined(DISABLE_BROWSER) || (!defined(DISABLE_MOUSE) && defined(NCURSES_MOUSE_VERSION))
|
2001-05-29 04:21:44 +00:00
|
|
|
currshortcut = insertfile_list;
|
2001-05-21 12:56:25 +00:00
|
|
|
#endif
|
|
|
|
|
2002-02-27 04:14:16 +00:00
|
|
|
#ifndef DISABLE_OPERATINGDIR
|
2002-12-22 16:30:00 +00:00
|
|
|
if (operating_dir != NULL && strcmp(operating_dir, ".") != 0)
|
2002-09-03 22:58:40 +00:00
|
|
|
#ifdef ENABLE_MULTIBUFFER
|
|
|
|
if (ISSET(MULTIBUFFER))
|
2003-01-13 01:35:15 +00:00
|
|
|
i = statusq(1, insertfile_list, inspath,
|
|
|
|
#ifndef NANO_SMALL
|
|
|
|
0,
|
|
|
|
#endif
|
|
|
|
_("File to insert into new buffer [from %s] "),
|
2002-09-03 22:58:40 +00:00
|
|
|
operating_dir);
|
|
|
|
else
|
|
|
|
#endif
|
2003-01-13 01:35:15 +00:00
|
|
|
i = statusq(1, insertfile_list, inspath,
|
|
|
|
#ifndef NANO_SMALL
|
|
|
|
0,
|
|
|
|
#endif
|
|
|
|
_("File to insert [from %s] "),
|
2002-02-27 04:14:16 +00:00
|
|
|
operating_dir);
|
2002-09-03 22:58:40 +00:00
|
|
|
|
2002-07-24 01:02:26 +00:00
|
|
|
else
|
2002-02-27 04:14:16 +00:00
|
|
|
#endif
|
2002-09-03 22:58:40 +00:00
|
|
|
#ifdef ENABLE_MULTIBUFFER
|
|
|
|
if (ISSET(MULTIBUFFER))
|
2003-01-13 01:35:15 +00:00
|
|
|
i = statusq(1, insertfile_list, inspath,
|
|
|
|
#ifndef NANO_SMALL
|
|
|
|
0,
|
|
|
|
#endif
|
|
|
|
_("File to insert into new buffer [from ./] "));
|
2002-09-03 22:58:40 +00:00
|
|
|
else
|
2003-01-13 01:35:15 +00:00
|
|
|
#endif /* ENABLE_MULTIBUFFER */
|
|
|
|
i = statusq(1, insertfile_list, inspath,
|
|
|
|
#ifndef NANO_SMALL
|
|
|
|
0,
|
2002-09-03 22:58:40 +00:00
|
|
|
#endif
|
2003-01-13 01:35:15 +00:00
|
|
|
_("File to insert [from ./] "));
|
2002-02-27 04:14:16 +00:00
|
|
|
|
2000-06-19 04:22:15 +00:00
|
|
|
if (i != -1) {
|
2002-09-03 22:58:40 +00:00
|
|
|
inspath = mallocstrcpy(inspath, answer);
|
2000-06-19 04:22:15 +00:00
|
|
|
#ifdef DEBUG
|
2002-06-28 22:45:14 +00:00
|
|
|
fprintf(stderr, _("filename is %s\n"), answer);
|
2000-06-19 04:22:15 +00:00
|
|
|
#endif
|
|
|
|
|
2002-09-13 18:14:04 +00:00
|
|
|
#ifndef NANO_SMALL
|
2002-09-03 22:58:40 +00:00
|
|
|
#ifdef ENABLE_MULTIBUFFER
|
2002-09-13 18:14:04 +00:00
|
|
|
if (i == TOGGLE_LOAD_KEY) {
|
2003-02-03 04:55:17 +00:00
|
|
|
/* Don't allow toggling if we're in view mode. */
|
|
|
|
if (!ISSET(VIEW_MODE))
|
2002-09-06 20:35:28 +00:00
|
|
|
TOGGLE(MULTIBUFFER);
|
2003-02-03 04:55:17 +00:00
|
|
|
loading_file = ISSET(MULTIBUFFER);
|
|
|
|
goto start_again;
|
2002-09-03 22:58:40 +00:00
|
|
|
}
|
2002-09-13 18:14:04 +00:00
|
|
|
#endif /* ENABLE_MULTIBUFFER */
|
2003-02-03 04:55:17 +00:00
|
|
|
|
2002-03-29 15:06:05 +00:00
|
|
|
if (i == NANO_EXTCMD_KEY) {
|
2003-02-03 04:55:17 +00:00
|
|
|
int ts = statusq(TRUE, extcmd_list, "", NULL,
|
|
|
|
_("Command to execute"));
|
|
|
|
if (ts == -1 || answer == NULL || answer[0] == '\0') {
|
2003-02-03 07:26:38 +00:00
|
|
|
statusbar(_("Cancelled"));
|
2002-03-29 15:06:05 +00:00
|
|
|
display_main_list();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
2002-09-13 18:14:04 +00:00
|
|
|
#endif /* !NANO_SMALL */
|
2003-02-03 04:55:17 +00:00
|
|
|
#ifndef DISABLE_BROWSER
|
|
|
|
if (i == NANO_TOFILES_KEY) {
|
|
|
|
char *tmp = do_browse_from(answer);
|
|
|
|
|
2003-02-12 02:52:04 +00:00
|
|
|
if (tmp != NULL) {
|
|
|
|
free(answer);
|
2003-02-03 04:55:17 +00:00
|
|
|
answer = tmp;
|
2003-02-13 03:03:49 +00:00
|
|
|
resetstatuspos = 1;
|
2003-02-12 02:52:04 +00:00
|
|
|
} else
|
2003-02-03 04:55:17 +00:00
|
|
|
goto start_again;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef DISABLE_OPERATINGDIR
|
|
|
|
if (i != NANO_EXTCMD_KEY && check_operating_dir(answer, FALSE)) {
|
|
|
|
statusbar(_("Can't insert file from outside of %s"),
|
|
|
|
operating_dir);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
2002-03-29 15:06:05 +00:00
|
|
|
|
2001-07-14 19:32:47 +00:00
|
|
|
#ifdef ENABLE_MULTIBUFFER
|
2001-07-11 02:08:33 +00:00
|
|
|
if (loading_file) {
|
2002-02-22 04:30:50 +00:00
|
|
|
/* update the current entry in the open_files structure */
|
|
|
|
add_open_file(1);
|
2001-07-11 02:08:33 +00:00
|
|
|
new_file();
|
|
|
|
UNSET(MODIFIED);
|
2002-05-11 03:04:44 +00:00
|
|
|
#ifndef NANO_SMALL
|
|
|
|
UNSET(MARK_ISSET);
|
|
|
|
#endif
|
2001-01-03 07:11:47 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2002-03-21 05:07:28 +00:00
|
|
|
#ifndef NANO_SMALL
|
2003-02-03 04:55:17 +00:00
|
|
|
if (i == NANO_EXTCMD_KEY) {
|
|
|
|
realname = mallocstrcpy(realname, "");
|
2002-03-29 15:06:05 +00:00
|
|
|
i = open_pipe(answer);
|
2003-02-03 04:55:17 +00:00
|
|
|
} else
|
2002-03-21 05:07:28 +00:00
|
|
|
#endif /* NANO_SMALL */
|
2003-02-03 04:55:17 +00:00
|
|
|
{
|
|
|
|
realname = real_dir_from_tilde(answer);
|
2002-03-21 05:07:28 +00:00
|
|
|
i = open_file(realname, 1, loading_file);
|
2003-02-03 04:55:17 +00:00
|
|
|
}
|
2001-07-11 02:08:33 +00:00
|
|
|
|
2001-07-14 19:32:47 +00:00
|
|
|
#ifdef ENABLE_MULTIBUFFER
|
2003-01-13 01:35:15 +00:00
|
|
|
if (loading_file) {
|
|
|
|
/* if there was an error opening the file, free() realname,
|
|
|
|
free() fileage (which now points to the new buffer we
|
|
|
|
created to hold the file), reload the buffer we had open
|
|
|
|
before, and skip the insertion; otherwise, save realname
|
|
|
|
in filename and continue the insertion */
|
|
|
|
if (i == -1) {
|
|
|
|
free(realname);
|
|
|
|
free(fileage);
|
|
|
|
load_open_file();
|
|
|
|
goto skip_insert;
|
|
|
|
} else
|
|
|
|
filename = mallocstrcpy(filename, realname);
|
|
|
|
}
|
2001-07-11 02:08:33 +00:00
|
|
|
#endif
|
|
|
|
|
2000-11-25 05:03:20 +00:00
|
|
|
free(realname);
|
2000-06-19 04:22:15 +00:00
|
|
|
|
2002-07-19 01:08:59 +00:00
|
|
|
#ifdef DEBUG
|
2000-06-19 04:22:15 +00:00
|
|
|
dump_buffer(fileage);
|
2002-07-19 01:08:59 +00:00
|
|
|
#endif
|
2001-07-11 02:08:33 +00:00
|
|
|
|
2001-07-14 19:32:47 +00:00
|
|
|
#ifdef ENABLE_MULTIBUFFER
|
2001-07-11 02:08:33 +00:00
|
|
|
if (loading_file)
|
2001-09-19 03:19:43 +00:00
|
|
|
load_file(0);
|
2001-07-11 02:08:33 +00:00
|
|
|
else
|
|
|
|
#endif
|
|
|
|
set_modified();
|
2000-06-19 04:22:15 +00:00
|
|
|
|
|
|
|
/* Here we want to rebuild the edit window */
|
2000-07-04 02:35:19 +00:00
|
|
|
fix_editbot();
|
2000-06-19 04:22:15 +00:00
|
|
|
|
2001-07-14 19:32:47 +00:00
|
|
|
#ifdef ENABLE_MULTIBUFFER
|
2001-07-11 02:08:33 +00:00
|
|
|
/* If we've loaded another file, update the titlebar's contents */
|
|
|
|
if (loading_file) {
|
|
|
|
clearok(topwin, FALSE);
|
|
|
|
titlebar(NULL);
|
|
|
|
|
|
|
|
/* And re-init the shortcut list */
|
|
|
|
shortcut_init(0);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2002-05-11 03:04:44 +00:00
|
|
|
#ifdef ENABLE_MULTIBUFFER
|
|
|
|
if (!loading_file) {
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Restore the old x-coordinate position */
|
|
|
|
current_x = old_current_x;
|
|
|
|
|
|
|
|
#ifdef ENABLE_MULTIBUFFER
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2001-05-05 17:45:54 +00:00
|
|
|
/* If we've gone off the bottom, recenter; otherwise, just redraw */
|
2000-06-21 03:00:43 +00:00
|
|
|
if (current->lineno > editbot->lineno)
|
2000-07-29 04:33:38 +00:00
|
|
|
edit_update(current, CENTER);
|
2000-06-19 04:22:15 +00:00
|
|
|
else
|
|
|
|
edit_refresh();
|
|
|
|
|
|
|
|
} else {
|
|
|
|
statusbar(_("Cancelled"));
|
2002-09-03 22:58:40 +00:00
|
|
|
i = 0;
|
2000-06-19 04:22:15 +00:00
|
|
|
}
|
2002-09-03 22:58:40 +00:00
|
|
|
|
2003-01-13 01:35:15 +00:00
|
|
|
#ifdef ENABLE_MULTIBUFFER
|
|
|
|
skip_insert:
|
|
|
|
#endif
|
|
|
|
|
2002-09-03 22:58:40 +00:00
|
|
|
free(inspath);
|
|
|
|
inspath = NULL;
|
|
|
|
|
|
|
|
display_main_list();
|
|
|
|
return i;
|
2000-06-19 04:22:15 +00:00
|
|
|
}
|
|
|
|
|
2001-07-11 02:08:33 +00:00
|
|
|
int do_insertfile_void(void)
|
|
|
|
{
|
|
|
|
int result = 0;
|
2001-07-14 19:32:47 +00:00
|
|
|
#ifdef ENABLE_MULTIBUFFER
|
2002-01-02 15:12:21 +00:00
|
|
|
if (ISSET(VIEW_MODE)) {
|
|
|
|
if (ISSET(MULTIBUFFER))
|
|
|
|
result = do_insertfile(1);
|
|
|
|
else
|
|
|
|
statusbar(_("Key illegal in non-multibuffer mode"));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
result = do_insertfile(ISSET(MULTIBUFFER));
|
2001-07-11 02:08:33 +00:00
|
|
|
#else
|
|
|
|
result = do_insertfile(0);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
display_main_list();
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2001-07-14 19:32:47 +00:00
|
|
|
#ifdef ENABLE_MULTIBUFFER
|
2002-07-19 01:08:59 +00:00
|
|
|
/* Create a new openfilestruct node. */
|
|
|
|
openfilestruct *make_new_opennode(openfilestruct *prevnode)
|
|
|
|
{
|
|
|
|
openfilestruct *newnode = nmalloc(sizeof(openfilestruct));
|
|
|
|
|
|
|
|
newnode->filename = NULL;
|
|
|
|
newnode->fileage = NULL;
|
|
|
|
newnode->filebot = NULL;
|
|
|
|
|
|
|
|
newnode->prev = prevnode;
|
|
|
|
newnode->next = NULL;
|
|
|
|
|
|
|
|
return newnode;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Splice a node into an existing openfilestruct. */
|
|
|
|
void splice_opennode(openfilestruct *begin, openfilestruct *newnode,
|
|
|
|
openfilestruct *end)
|
|
|
|
{
|
|
|
|
newnode->next = end;
|
|
|
|
newnode->prev = begin;
|
|
|
|
begin->next = newnode;
|
|
|
|
if (end != NULL)
|
|
|
|
end->prev = newnode;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Unlink a node from the rest of the openfilestruct. */
|
|
|
|
void unlink_opennode(const openfilestruct *fileptr)
|
|
|
|
{
|
|
|
|
assert(fileptr != NULL);
|
|
|
|
|
|
|
|
if (fileptr->prev != NULL)
|
|
|
|
fileptr->prev->next = fileptr->next;
|
|
|
|
|
|
|
|
if (fileptr->next != NULL)
|
|
|
|
fileptr->next->prev = fileptr->prev;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Delete a node from the openfilestruct. */
|
|
|
|
void delete_opennode(openfilestruct *fileptr)
|
|
|
|
{
|
|
|
|
if (fileptr != NULL) {
|
|
|
|
if (fileptr->filename != NULL)
|
|
|
|
free(fileptr->filename);
|
|
|
|
if (fileptr->fileage != NULL)
|
|
|
|
free_filestruct(fileptr->fileage);
|
|
|
|
free(fileptr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Deallocate all memory associated with this and later files,
|
|
|
|
* including the lines of text. */
|
|
|
|
void free_openfilestruct(openfilestruct *src)
|
|
|
|
{
|
|
|
|
if (src != NULL) {
|
|
|
|
while (src->next != NULL) {
|
|
|
|
src = src->next;
|
|
|
|
delete_opennode(src->prev);
|
|
|
|
#ifdef DEBUG
|
2003-01-23 04:27:23 +00:00
|
|
|
fprintf(stderr, _("%s: free'd a node, YAY!\n"), "delete_opennode()");
|
2002-07-19 01:08:59 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
delete_opennode(src);
|
|
|
|
#ifdef DEBUG
|
2003-01-23 04:27:23 +00:00
|
|
|
fprintf(stderr, _("%s: free'd last node.\n"), "delete_opennode()");
|
2002-07-19 01:08:59 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-07-11 02:08:33 +00:00
|
|
|
/*
|
2002-04-10 02:31:20 +00:00
|
|
|
* Add/update an entry to the open_files openfilestruct. If update is
|
2001-07-11 02:08:33 +00:00
|
|
|
* zero, a new entry is created; otherwise, the current entry is updated.
|
2002-02-22 04:30:50 +00:00
|
|
|
* Return 0 on success or 1 on error.
|
2001-07-11 02:08:33 +00:00
|
|
|
*/
|
2002-02-22 04:30:50 +00:00
|
|
|
int add_open_file(int update)
|
2001-07-11 02:08:33 +00:00
|
|
|
{
|
2002-04-10 02:31:20 +00:00
|
|
|
openfilestruct *tmp;
|
2001-07-11 02:08:33 +00:00
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
if (fileage == NULL || current == NULL || filename == NULL)
|
2001-07-11 02:08:33 +00:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
/* if no entries, make the first one */
|
2002-12-22 16:30:00 +00:00
|
|
|
if (open_files == NULL)
|
2002-04-10 02:31:20 +00:00
|
|
|
open_files = make_new_opennode(NULL);
|
2001-07-11 02:08:33 +00:00
|
|
|
|
|
|
|
else if (!update) {
|
|
|
|
|
|
|
|
/* otherwise, if we're not updating, make a new entry for
|
|
|
|
open_files and splice it in after the current one */
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
2002-06-28 22:45:14 +00:00
|
|
|
fprintf(stderr, _("filename is %s\n"), open_files->filename);
|
2001-07-11 02:08:33 +00:00
|
|
|
#endif
|
|
|
|
|
2002-04-10 02:31:20 +00:00
|
|
|
tmp = make_new_opennode(NULL);
|
|
|
|
splice_opennode(open_files, tmp, open_files->next);
|
2001-07-11 02:08:33 +00:00
|
|
|
open_files = open_files->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* save current filename */
|
2002-04-10 02:31:20 +00:00
|
|
|
open_files->filename = mallocstrcpy(open_files->filename, filename);
|
2001-07-11 02:08:33 +00:00
|
|
|
|
2002-06-28 22:45:14 +00:00
|
|
|
#ifndef NANO_SMALL
|
|
|
|
/* save the file's stat */
|
|
|
|
open_files->originalfilestat = originalfilestat;
|
|
|
|
#endif
|
|
|
|
|
2001-07-11 02:08:33 +00:00
|
|
|
/* save current total number of lines */
|
|
|
|
open_files->file_totlines = totlines;
|
|
|
|
|
|
|
|
/* save current total size */
|
|
|
|
open_files->file_totsize = totsize;
|
|
|
|
|
|
|
|
/* save current x-coordinate position */
|
|
|
|
open_files->file_current_x = current_x;
|
|
|
|
|
|
|
|
/* save current y-coordinate position */
|
|
|
|
open_files->file_current_y = current_y;
|
|
|
|
|
|
|
|
/* save current place we want */
|
|
|
|
open_files->file_placewewant = placewewant;
|
|
|
|
|
|
|
|
/* save current line number */
|
2002-04-10 02:31:20 +00:00
|
|
|
open_files->file_lineno = current->lineno;
|
2001-07-11 02:08:33 +00:00
|
|
|
|
2002-05-11 03:04:44 +00:00
|
|
|
/* if we're updating, save current modification status (and marking
|
|
|
|
status, if available) */
|
|
|
|
if (update) {
|
|
|
|
#ifndef NANO_SMALL
|
|
|
|
open_files->file_flags = (MODIFIED & ISSET(MODIFIED)) | (MARK_ISSET & ISSET(MARK_ISSET));
|
|
|
|
if (ISSET(MARK_ISSET)) {
|
|
|
|
open_files->file_mark_beginbuf = mark_beginbuf;
|
|
|
|
open_files->file_mark_beginx = mark_beginx;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
open_files->file_flags = (MODIFIED & ISSET(MODIFIED));
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2003-02-02 04:26:54 +00:00
|
|
|
/* if we're not in view mode and not updating, the file contents
|
|
|
|
might have changed, so save the filestruct; otherwise, don't */
|
|
|
|
if (!(ISSET(VIEW_MODE) && !update)) {
|
2002-05-11 03:04:44 +00:00
|
|
|
/* save current file buffer */
|
|
|
|
open_files->fileage = fileage;
|
|
|
|
open_files->filebot = filebot;
|
2002-01-02 15:12:21 +00:00
|
|
|
}
|
2001-07-11 02:08:33 +00:00
|
|
|
|
|
|
|
#ifdef DEBUG
|
2002-06-28 22:45:14 +00:00
|
|
|
fprintf(stderr, _("filename is %s\n"), open_files->filename);
|
2001-07-11 02:08:33 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read the current entry in the open_files structure and set up the
|
|
|
|
* currently open file using that entry's information. Return 0 on
|
|
|
|
* success or 1 on error.
|
|
|
|
*/
|
|
|
|
int load_open_file(void)
|
|
|
|
{
|
2002-12-22 16:30:00 +00:00
|
|
|
if (open_files == NULL)
|
2001-07-11 02:08:33 +00:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
/* set up the filename, the file buffer, the total number of lines in
|
|
|
|
the file, and the total file size */
|
2002-04-10 02:31:20 +00:00
|
|
|
filename = mallocstrcpy(filename, open_files->filename);
|
2002-06-28 22:45:14 +00:00
|
|
|
#ifndef NANO_SMALL
|
|
|
|
originalfilestat = open_files->originalfilestat;
|
|
|
|
#endif
|
2002-04-10 02:31:20 +00:00
|
|
|
fileage = open_files->fileage;
|
2001-07-11 02:08:33 +00:00
|
|
|
current = fileage;
|
2002-05-11 03:04:44 +00:00
|
|
|
filebot = open_files->filebot;
|
2001-07-11 02:08:33 +00:00
|
|
|
totlines = open_files->file_totlines;
|
|
|
|
totsize = open_files->file_totsize;
|
|
|
|
|
2002-05-11 03:04:44 +00:00
|
|
|
/* restore modification status */
|
|
|
|
if (open_files->file_flags & MODIFIED)
|
|
|
|
SET(MODIFIED);
|
|
|
|
else
|
|
|
|
UNSET(MODIFIED);
|
|
|
|
|
|
|
|
#ifndef NANO_SMALL
|
|
|
|
/* restore marking status */
|
|
|
|
if (open_files->file_flags & MARK_ISSET) {
|
|
|
|
mark_beginbuf = open_files->file_mark_beginbuf;
|
|
|
|
mark_beginx = open_files->file_mark_beginx;
|
|
|
|
SET(MARK_ISSET);
|
|
|
|
} else
|
|
|
|
UNSET(MARK_ISSET);
|
|
|
|
#endif
|
2001-10-22 03:15:31 +00:00
|
|
|
|
2003-01-13 01:35:15 +00:00
|
|
|
#ifdef ENABLE_COLOR
|
|
|
|
update_color();
|
|
|
|
#endif
|
|
|
|
|
2001-09-19 03:19:43 +00:00
|
|
|
/* restore full file position: line number, x-coordinate, y-
|
|
|
|
coordinate, place we want */
|
2002-04-10 02:31:20 +00:00
|
|
|
do_gotopos(open_files->file_lineno, open_files->file_current_x, open_files->file_current_y, open_files->file_placewewant);
|
2001-07-11 02:08:33 +00:00
|
|
|
|
2002-05-11 03:04:44 +00:00
|
|
|
/* update the titlebar */
|
2001-07-11 02:08:33 +00:00
|
|
|
clearok(topwin, FALSE);
|
|
|
|
titlebar(NULL);
|
|
|
|
|
|
|
|
/* now we're done */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Open the previous entry in the open_files structure. If closing_file
|
|
|
|
* is zero, update the current entry before switching from it.
|
|
|
|
* Otherwise, we are about to close that entry, so don't bother doing so.
|
|
|
|
* Return 0 on success and 1 on error.
|
|
|
|
*/
|
|
|
|
int open_prevfile(int closing_file)
|
|
|
|
{
|
2002-12-22 16:30:00 +00:00
|
|
|
if (open_files == NULL)
|
2001-07-11 02:08:33 +00:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
/* if we're not about to close the current entry, update it before
|
2002-02-22 04:30:50 +00:00
|
|
|
doing anything */
|
2001-07-11 02:08:33 +00:00
|
|
|
if (!closing_file)
|
2002-02-22 04:30:50 +00:00
|
|
|
add_open_file(1);
|
2001-07-11 02:08:33 +00:00
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
if (open_files->prev == NULL && open_files->next == NULL) {
|
2001-07-11 02:08:33 +00:00
|
|
|
|
|
|
|
/* only one file open */
|
|
|
|
if (!closing_file)
|
|
|
|
statusbar(_("No more open files"));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
if (open_files->prev != NULL) {
|
2001-07-11 02:08:33 +00:00
|
|
|
open_files = open_files->prev;
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
2002-06-28 22:45:14 +00:00
|
|
|
fprintf(stderr, _("filename is %s\n"), open_files->filename);
|
2001-07-11 02:08:33 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
else if (open_files->next != NULL) {
|
2001-07-11 02:08:33 +00:00
|
|
|
|
|
|
|
/* if we're at the beginning, wrap around to the end */
|
2002-12-22 16:30:00 +00:00
|
|
|
while (open_files->next != NULL)
|
2001-07-11 02:08:33 +00:00
|
|
|
open_files = open_files->next;
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
2002-06-28 22:45:14 +00:00
|
|
|
fprintf(stderr, _("filename is %s\n"), open_files->filename);
|
2001-07-11 02:08:33 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
load_open_file();
|
|
|
|
|
2002-02-27 04:14:16 +00:00
|
|
|
statusbar(_("Switched to %s"),
|
2002-12-22 16:30:00 +00:00
|
|
|
((open_files->filename[0] == '\0') ? "New Buffer" : open_files->filename));
|
2002-02-27 04:14:16 +00:00
|
|
|
|
2001-07-11 02:08:33 +00:00
|
|
|
#ifdef DEBUG
|
|
|
|
dump_buffer(current);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2002-02-15 19:17:02 +00:00
|
|
|
/* This function is used by the shortcut list. */
|
|
|
|
int open_prevfile_void(void)
|
|
|
|
{
|
2002-08-21 16:10:37 +00:00
|
|
|
return open_prevfile(0);
|
2002-02-15 19:17:02 +00:00
|
|
|
}
|
|
|
|
|
2001-07-11 02:08:33 +00:00
|
|
|
/*
|
|
|
|
* Open the next entry in the open_files structure. If closing_file is
|
|
|
|
* zero, update the current entry before switching from it. Otherwise, we
|
|
|
|
* are about to close that entry, so don't bother doing so. Return 0 on
|
|
|
|
* success and 1 on error.
|
|
|
|
*/
|
|
|
|
int open_nextfile(int closing_file)
|
|
|
|
{
|
2002-12-22 16:30:00 +00:00
|
|
|
if (open_files == NULL)
|
2001-07-11 02:08:33 +00:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
/* if we're not about to close the current entry, update it before
|
2002-02-22 04:30:50 +00:00
|
|
|
doing anything */
|
2001-07-11 02:08:33 +00:00
|
|
|
if (!closing_file)
|
2002-02-22 04:30:50 +00:00
|
|
|
add_open_file(1);
|
2001-07-11 02:08:33 +00:00
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
if (open_files->prev == NULL && open_files->next == NULL) {
|
2001-07-11 02:08:33 +00:00
|
|
|
|
|
|
|
/* only one file open */
|
|
|
|
if (!closing_file)
|
|
|
|
statusbar(_("No more open files"));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
if (open_files->next != NULL) {
|
2001-07-11 02:08:33 +00:00
|
|
|
open_files = open_files->next;
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
2002-06-28 22:45:14 +00:00
|
|
|
fprintf(stderr, _("filename is %s\n"), open_files->filename);
|
2001-07-11 02:08:33 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
}
|
2002-12-22 16:30:00 +00:00
|
|
|
else if (open_files->prev != NULL) {
|
2001-07-11 02:08:33 +00:00
|
|
|
|
|
|
|
/* if we're at the end, wrap around to the beginning */
|
2002-12-22 16:30:00 +00:00
|
|
|
while (open_files->prev != NULL) {
|
2001-07-11 02:08:33 +00:00
|
|
|
open_files = open_files->prev;
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
2002-06-28 22:45:14 +00:00
|
|
|
fprintf(stderr, _("filename is %s\n"), open_files->filename);
|
2001-07-11 02:08:33 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
load_open_file();
|
|
|
|
|
2002-02-27 04:14:16 +00:00
|
|
|
statusbar(_("Switched to %s"),
|
2002-12-22 16:30:00 +00:00
|
|
|
((open_files->filename[0] == '\0') ? "New Buffer" : open_files->filename));
|
2002-02-27 04:14:16 +00:00
|
|
|
|
2001-07-11 02:08:33 +00:00
|
|
|
#ifdef DEBUG
|
|
|
|
dump_buffer(current);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2002-02-15 19:17:02 +00:00
|
|
|
/* This function is used by the shortcut list. */
|
|
|
|
int open_nextfile_void(void)
|
|
|
|
{
|
2002-08-21 16:10:37 +00:00
|
|
|
return open_nextfile(0);
|
2002-02-15 19:17:02 +00:00
|
|
|
}
|
|
|
|
|
2001-07-11 02:08:33 +00:00
|
|
|
/*
|
|
|
|
* Delete an entry from the open_files filestruct. After deletion of an
|
2001-07-18 01:03:36 +00:00
|
|
|
* entry, the next or previous entry is opened, whichever is found first.
|
2001-07-11 02:08:33 +00:00
|
|
|
* Return 0 on success or 1 on error.
|
|
|
|
*/
|
|
|
|
int close_open_file(void)
|
|
|
|
{
|
2002-04-10 02:31:20 +00:00
|
|
|
openfilestruct *tmp;
|
2001-07-11 02:08:33 +00:00
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
if (open_files == NULL)
|
2001-07-11 02:08:33 +00:00
|
|
|
return 1;
|
|
|
|
|
2002-05-11 03:04:44 +00:00
|
|
|
/* make sure open_files->fileage and fileage, and open_files->filebot
|
|
|
|
and filebot, are in sync; they might not be if lines have been cut
|
|
|
|
from the top or bottom of the file */
|
2002-04-10 02:31:20 +00:00
|
|
|
open_files->fileage = fileage;
|
2002-05-11 03:04:44 +00:00
|
|
|
open_files->filebot = filebot;
|
2002-04-06 05:02:14 +00:00
|
|
|
|
2001-07-11 02:08:33 +00:00
|
|
|
tmp = open_files;
|
2001-07-18 01:03:36 +00:00
|
|
|
if (open_nextfile(1)) {
|
|
|
|
if (open_prevfile(1))
|
2001-07-11 02:08:33 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2002-04-10 02:31:20 +00:00
|
|
|
unlink_opennode(tmp);
|
|
|
|
delete_opennode(tmp);
|
2001-07-11 02:08:33 +00:00
|
|
|
|
|
|
|
shortcut_init(0);
|
|
|
|
display_main_list();
|
|
|
|
return 0;
|
|
|
|
}
|
2002-02-15 19:17:02 +00:00
|
|
|
#endif /* MULTIBUFFER */
|
2001-07-11 02:08:33 +00:00
|
|
|
|
2002-06-28 22:45:14 +00:00
|
|
|
#if !defined(DISABLE_SPELLER) || !defined(DISABLE_OPERATINGDIR)
|
2001-07-11 02:08:33 +00:00
|
|
|
/*
|
2001-09-19 03:19:43 +00:00
|
|
|
* When passed "[relative path]" or "[relative path][filename]" in
|
|
|
|
* origpath, return "[full path]" or "[full path][filename]" on success,
|
|
|
|
* or NULL on error. This is still done if the file doesn't exist but
|
|
|
|
* the relative path does (since the file could exist in memory but not
|
|
|
|
* yet on disk); it is not done if the relative path doesn't exist (since
|
|
|
|
* the first call to chdir() will fail then).
|
2001-07-11 02:08:33 +00:00
|
|
|
*/
|
2002-09-13 18:14:04 +00:00
|
|
|
char *get_full_path(const char *origpath)
|
2001-07-11 02:08:33 +00:00
|
|
|
{
|
2001-09-19 03:19:43 +00:00
|
|
|
char *newpath = NULL, *last_slash, *d_here, *d_there, *d_there_file, tmp;
|
|
|
|
int path_only, last_slash_index;
|
|
|
|
struct stat fileinfo;
|
2002-07-24 01:02:26 +00:00
|
|
|
char *expanded_origpath;
|
2001-07-11 02:08:33 +00:00
|
|
|
|
2001-09-19 03:19:43 +00:00
|
|
|
/* first, get the current directory, and tack a slash onto the end of
|
2001-09-23 01:18:03 +00:00
|
|
|
it, unless it turns out to be "/", in which case leave it alone */
|
2001-07-11 02:08:33 +00:00
|
|
|
|
|
|
|
#ifdef PATH_MAX
|
|
|
|
d_here = getcwd(NULL, PATH_MAX + 1);
|
|
|
|
#else
|
|
|
|
d_here = getcwd(NULL, 0);
|
|
|
|
#endif
|
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
if (d_here != NULL) {
|
2001-07-11 02:08:33 +00:00
|
|
|
|
|
|
|
align(&d_here);
|
2001-09-23 01:18:03 +00:00
|
|
|
if (strcmp(d_here, "/")) {
|
|
|
|
d_here = nrealloc(d_here, strlen(d_here) + 2);
|
|
|
|
strcat(d_here, "/");
|
|
|
|
}
|
2001-09-19 03:19:43 +00:00
|
|
|
|
|
|
|
/* stat origpath; if stat() fails, assume that origpath refers to
|
|
|
|
a new file that hasn't been saved to disk yet (i. e. set
|
|
|
|
path_only to 0); if stat() succeeds, set path_only to 0 if
|
|
|
|
origpath doesn't refer to a directory, or to 1 if it does */
|
2002-07-24 01:02:26 +00:00
|
|
|
path_only = !stat(origpath, &fileinfo) && S_ISDIR(fileinfo.st_mode);
|
2001-07-11 02:08:33 +00:00
|
|
|
|
2002-07-24 01:02:26 +00:00
|
|
|
expanded_origpath = real_dir_from_tilde(origpath);
|
2001-09-19 03:19:43 +00:00
|
|
|
/* save the value of origpath in both d_there and d_there_file */
|
2002-07-24 01:02:26 +00:00
|
|
|
d_there = mallocstrcpy(NULL, expanded_origpath);
|
|
|
|
d_there_file = mallocstrcpy(NULL, expanded_origpath);
|
|
|
|
free(expanded_origpath);
|
2001-07-11 02:08:33 +00:00
|
|
|
|
2001-09-19 03:19:43 +00:00
|
|
|
/* if we have a path but no filename, tack slashes onto the ends
|
|
|
|
of both d_there and d_there_file, if they don't end in slashes
|
|
|
|
already */
|
|
|
|
if (path_only) {
|
|
|
|
tmp = d_there[strlen(d_there) - 1];
|
|
|
|
if (tmp != '/') {
|
|
|
|
d_there = nrealloc(d_there, strlen(d_there) + 2);
|
|
|
|
strcat(d_there, "/");
|
|
|
|
d_there_file = nrealloc(d_there_file, strlen(d_there_file) + 2);
|
|
|
|
strcat(d_there_file, "/");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-07-11 02:08:33 +00:00
|
|
|
/* search for the last slash in d_there */
|
|
|
|
last_slash = strrchr(d_there, '/');
|
|
|
|
|
|
|
|
/* if we didn't find one, copy d_here into d_there; all data is
|
|
|
|
then set up */
|
2002-12-22 16:30:00 +00:00
|
|
|
if (last_slash == NULL)
|
2002-07-24 01:02:26 +00:00
|
|
|
d_there = mallocstrcpy(d_there, d_here);
|
2001-07-11 02:08:33 +00:00
|
|
|
else {
|
2001-09-19 03:19:43 +00:00
|
|
|
/* otherwise, remove all non-path elements from d_there
|
|
|
|
(i. e. everything after the last slash) */
|
2001-07-11 02:08:33 +00:00
|
|
|
last_slash_index = strlen(d_there) - strlen(last_slash);
|
2001-10-22 23:22:19 +00:00
|
|
|
null_at(&d_there, last_slash_index + 1);
|
2001-09-19 03:19:43 +00:00
|
|
|
|
|
|
|
/* and remove all non-file elements from d_there_file (i. e.
|
|
|
|
everything before and including the last slash); if we
|
2002-12-22 16:30:00 +00:00
|
|
|
have a path but no filename, don't do anything */
|
2001-09-19 03:19:43 +00:00
|
|
|
if (!path_only) {
|
|
|
|
last_slash = strrchr(d_there_file, '/');
|
|
|
|
last_slash++;
|
|
|
|
strcpy(d_there_file, last_slash);
|
|
|
|
align(&d_there_file);
|
|
|
|
}
|
2001-07-11 02:08:33 +00:00
|
|
|
|
|
|
|
/* now go to the path specified in d_there */
|
|
|
|
if (chdir(d_there) != -1) {
|
2001-09-19 03:19:43 +00:00
|
|
|
/* get the full pathname, and save it back in d_there,
|
|
|
|
tacking a slash on the end if we have a path but no
|
|
|
|
filename; if the saving fails, get out */
|
2001-07-11 02:08:33 +00:00
|
|
|
|
|
|
|
free(d_there);
|
|
|
|
|
|
|
|
#ifdef PATH_MAX
|
|
|
|
d_there = getcwd(NULL, PATH_MAX + 1);
|
|
|
|
#else
|
|
|
|
d_there = getcwd(NULL, 0);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
align(&d_there);
|
2002-12-22 16:30:00 +00:00
|
|
|
if (d_there != NULL) {
|
2001-09-23 01:18:03 +00:00
|
|
|
|
|
|
|
/* add a slash to d_there, unless it's "/", in which
|
|
|
|
case we don't need it */
|
|
|
|
if (strcmp(d_there, "/")) {
|
|
|
|
d_there = nrealloc(d_there, strlen(d_there) + 2);
|
|
|
|
strcat(d_there, "/");
|
|
|
|
}
|
2001-09-19 03:19:43 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
return NULL;
|
2001-07-11 02:08:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* finally, go back to where we were before, d_here (no error
|
|
|
|
checking is done on this chdir(), because we can do
|
|
|
|
nothing if it fails) */
|
|
|
|
chdir(d_here);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* all data is set up; fill in newpath */
|
|
|
|
|
2001-09-19 03:19:43 +00:00
|
|
|
/* if we have a path and a filename, newpath = d_there +
|
|
|
|
d_there_file; otherwise, newpath = d_there */
|
|
|
|
if (!path_only) {
|
|
|
|
newpath = charalloc(strlen(d_there) + strlen(d_there_file) + 1);
|
|
|
|
strcpy(newpath, d_there);
|
|
|
|
strcat(newpath, d_there_file);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
newpath = charalloc(strlen(d_there) + 1);
|
|
|
|
strcpy(newpath, d_there);
|
|
|
|
}
|
2001-07-11 02:08:33 +00:00
|
|
|
|
|
|
|
/* finally, clean up */
|
|
|
|
free(d_there_file);
|
|
|
|
free(d_there);
|
|
|
|
free(d_here);
|
|
|
|
}
|
|
|
|
|
|
|
|
return newpath;
|
|
|
|
}
|
2002-02-22 04:30:50 +00:00
|
|
|
#endif /* !DISABLE_SPELLER || !DISABLE_OPERATINGDIR */
|
2002-02-15 19:17:02 +00:00
|
|
|
|
|
|
|
#ifndef DISABLE_SPELLER
|
|
|
|
/*
|
2002-02-16 20:03:44 +00:00
|
|
|
* This function accepts a path and returns the full path (via
|
|
|
|
* get_full_path()). On error, if the path doesn't reference a
|
|
|
|
* directory, or if the directory isn't writable, it returns NULL.
|
2002-02-15 19:17:02 +00:00
|
|
|
*/
|
2002-09-13 18:14:04 +00:00
|
|
|
char *check_writable_directory(const char *path)
|
2002-09-06 20:35:28 +00:00
|
|
|
{
|
2002-02-15 19:17:02 +00:00
|
|
|
char *full_path = get_full_path(path);
|
2002-02-16 20:03:44 +00:00
|
|
|
int writable;
|
2002-02-15 19:17:02 +00:00
|
|
|
struct stat fileinfo;
|
|
|
|
|
2002-02-16 20:03:44 +00:00
|
|
|
/* if get_full_path() failed, return NULL */
|
2002-12-22 16:30:00 +00:00
|
|
|
if (full_path == NULL)
|
2002-02-15 19:17:02 +00:00
|
|
|
return NULL;
|
2002-02-16 20:03:44 +00:00
|
|
|
|
|
|
|
/* otherwise, stat() the full path to see if it's writable by the
|
|
|
|
user; set writable to 1 if it is, or 0 if it isn't */
|
2002-07-24 01:02:26 +00:00
|
|
|
writable = !stat(full_path, &fileinfo) && (fileinfo.st_mode & S_IWUSR);
|
2002-02-15 19:17:02 +00:00
|
|
|
|
|
|
|
/* if the full path doesn't end in a slash (meaning get_full_path()
|
2002-02-16 20:03:44 +00:00
|
|
|
found that it isn't a directory) or isn't writable, free full_path
|
|
|
|
and return NULL */
|
|
|
|
if (full_path[strlen(full_path) - 1] != '/' || writable == 0) {
|
|
|
|
free(full_path);
|
2002-02-15 19:17:02 +00:00
|
|
|
return NULL;
|
2002-02-16 20:03:44 +00:00
|
|
|
}
|
2002-02-15 19:17:02 +00:00
|
|
|
|
|
|
|
/* otherwise, return the full path */
|
|
|
|
return full_path;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This function accepts a directory name and filename prefix the same
|
|
|
|
* way that tempnam() does, determines the location for its temporary
|
|
|
|
* file the same way that tempnam() does, safely creates the temporary
|
|
|
|
* file there via mkstemp(), and returns the name of the temporary file
|
2002-02-16 20:03:44 +00:00
|
|
|
* the same way that tempnam() does. It does not reference the value of
|
|
|
|
* TMP_MAX because the total number of random filenames that it can
|
|
|
|
* generate using one prefix is equal to 256**6, which is a sufficiently
|
|
|
|
* large number to handle most cases. Since the behavior after tempnam()
|
|
|
|
* generates TMP_MAX random filenames is implementation-defined, my
|
|
|
|
* implementation is to go on generating random filenames regardless of
|
|
|
|
* it.
|
2002-02-15 19:17:02 +00:00
|
|
|
*/
|
2002-09-06 20:35:28 +00:00
|
|
|
char *safe_tempnam(const char *dirname, const char *filename_prefix)
|
|
|
|
{
|
2002-09-13 18:14:04 +00:00
|
|
|
char *full_tempdir = NULL;
|
|
|
|
const char *TMPDIR_env;
|
2002-02-16 20:03:44 +00:00
|
|
|
int filedesc;
|
2002-02-15 19:17:02 +00:00
|
|
|
|
2002-09-13 18:14:04 +00:00
|
|
|
/* if $TMPDIR is set and non-empty, set tempdir to it, run it through
|
|
|
|
get_full_path(), and save the result in full_tempdir; otherwise,
|
2002-12-22 16:30:00 +00:00
|
|
|
leave full_tempdir set to NULL */
|
2002-09-13 18:14:04 +00:00
|
|
|
TMPDIR_env = getenv("TMPDIR");
|
2002-12-22 16:30:00 +00:00
|
|
|
if (TMPDIR_env != NULL && TMPDIR_env[0] != '\0')
|
2002-09-13 18:14:04 +00:00
|
|
|
full_tempdir = check_writable_directory(TMPDIR_env);
|
2002-02-15 19:17:02 +00:00
|
|
|
|
2002-09-13 18:14:04 +00:00
|
|
|
/* if $TMPDIR is blank or isn't set, or isn't a writable
|
|
|
|
directory, and dirname isn't NULL, try it; otherwise, leave
|
|
|
|
full_tempdir set to NULL */
|
2002-12-22 16:30:00 +00:00
|
|
|
if (full_tempdir == NULL && dirname != NULL)
|
2002-09-13 18:14:04 +00:00
|
|
|
full_tempdir = check_writable_directory(dirname);
|
2002-02-15 19:17:02 +00:00
|
|
|
|
|
|
|
/* if $TMPDIR is blank or isn't set, or if it isn't a writable
|
|
|
|
directory, and dirname is NULL, try P_tmpdir instead */
|
2002-12-22 16:30:00 +00:00
|
|
|
if (full_tempdir == NULL)
|
2002-09-13 18:14:04 +00:00
|
|
|
full_tempdir = check_writable_directory(P_tmpdir);
|
2002-02-15 19:17:02 +00:00
|
|
|
|
|
|
|
/* if P_tmpdir didn't work, use /tmp instead */
|
2002-12-22 16:30:00 +00:00
|
|
|
if (full_tempdir == NULL) {
|
2002-02-15 19:17:02 +00:00
|
|
|
full_tempdir = charalloc(6);
|
|
|
|
strcpy(full_tempdir, "/tmp/");
|
|
|
|
}
|
|
|
|
|
2002-09-13 18:14:04 +00:00
|
|
|
full_tempdir = nrealloc(full_tempdir, strlen(full_tempdir) + 12);
|
2002-02-15 19:17:02 +00:00
|
|
|
|
|
|
|
/* like tempnam(), use only the first 5 characters of the prefix */
|
2002-09-13 18:14:04 +00:00
|
|
|
strncat(full_tempdir, filename_prefix, 5);
|
|
|
|
strcat(full_tempdir, "XXXXXX");
|
|
|
|
filedesc = mkstemp(full_tempdir);
|
|
|
|
|
|
|
|
/* if mkstemp succeeded, close the resulting file; afterwards, it'll be
|
|
|
|
0 bytes long, so delete it; finally, return the filename (all that's
|
|
|
|
left of it) */
|
|
|
|
if (filedesc != -1) {
|
2002-02-15 19:17:02 +00:00
|
|
|
close(filedesc);
|
2002-09-13 18:14:04 +00:00
|
|
|
unlink(full_tempdir);
|
|
|
|
return full_tempdir;
|
2002-02-15 19:17:02 +00:00
|
|
|
}
|
2002-09-13 18:14:04 +00:00
|
|
|
|
|
|
|
free(full_tempdir);
|
|
|
|
return NULL;
|
2002-02-15 19:17:02 +00:00
|
|
|
}
|
|
|
|
#endif /* !DISABLE_SPELLER */
|
2001-09-19 03:19:43 +00:00
|
|
|
|
|
|
|
#ifndef DISABLE_OPERATINGDIR
|
2002-09-13 18:14:04 +00:00
|
|
|
/* Initialize full_operating_dir based on operating_dir. */
|
|
|
|
void init_operating_dir(void)
|
|
|
|
{
|
|
|
|
assert(full_operating_dir == NULL);
|
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
if (operating_dir == NULL)
|
2002-09-13 18:14:04 +00:00
|
|
|
return;
|
|
|
|
full_operating_dir = get_full_path(operating_dir);
|
|
|
|
|
|
|
|
/* If get_full_path() failed or the operating directory is
|
|
|
|
inaccessible, unset operating_dir. */
|
2002-12-22 16:30:00 +00:00
|
|
|
if (full_operating_dir == NULL || chdir(full_operating_dir) == -1) {
|
2002-09-13 18:14:04 +00:00
|
|
|
free(full_operating_dir);
|
|
|
|
full_operating_dir = NULL;
|
|
|
|
free(operating_dir);
|
|
|
|
operating_dir = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-09-19 03:19:43 +00:00
|
|
|
/*
|
|
|
|
* Check to see if we're inside the operating directory. Return 0 if we
|
|
|
|
* are, or 1 otherwise. If allow_tabcomp is nonzero, allow incomplete
|
|
|
|
* names that would be matches for the operating directory, so that tab
|
|
|
|
* completion will work.
|
|
|
|
*/
|
2002-09-13 18:14:04 +00:00
|
|
|
int check_operating_dir(const char *currpath, int allow_tabcomp)
|
2001-09-19 03:19:43 +00:00
|
|
|
{
|
2002-02-27 04:14:16 +00:00
|
|
|
/* The char *full_operating_dir is global for mem cleanup, and
|
|
|
|
therefore we only need to get it the first time this function
|
|
|
|
is called; also, a relative operating directory path will
|
2001-09-19 03:19:43 +00:00
|
|
|
only be handled properly if this is done */
|
|
|
|
|
2002-09-13 18:14:04 +00:00
|
|
|
char *fullpath;
|
|
|
|
int retval = 0;
|
|
|
|
const char *whereami1, *whereami2 = NULL;
|
2001-09-19 03:19:43 +00:00
|
|
|
|
|
|
|
/* if no operating directory is set, don't bother doing anything */
|
2002-12-22 16:30:00 +00:00
|
|
|
if (operating_dir == NULL)
|
2001-09-19 03:19:43 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
fullpath = get_full_path(currpath);
|
2002-12-22 16:30:00 +00:00
|
|
|
if (fullpath == NULL)
|
2001-09-19 03:19:43 +00:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
whereami1 = strstr(fullpath, full_operating_dir);
|
|
|
|
if (allow_tabcomp)
|
|
|
|
whereami2 = strstr(full_operating_dir, fullpath);
|
|
|
|
|
|
|
|
/* if both searches failed, we're outside the operating directory */
|
2002-09-13 18:14:04 +00:00
|
|
|
/* otherwise */
|
2001-09-19 03:19:43 +00:00
|
|
|
/* check the search results; if the full operating directory path is
|
|
|
|
not at the beginning of the full current path (for normal usage)
|
|
|
|
and vice versa (for tab completion, if we're allowing it), we're
|
|
|
|
outside the operating directory */
|
|
|
|
if (whereami1 != fullpath && whereami2 != full_operating_dir)
|
2002-09-13 18:14:04 +00:00
|
|
|
retval = 1;
|
|
|
|
free(fullpath);
|
2001-09-19 03:19:43 +00:00
|
|
|
/* otherwise, we're still inside it */
|
2002-09-13 18:14:04 +00:00
|
|
|
return retval;
|
2001-09-19 03:19:43 +00:00
|
|
|
}
|
2001-07-11 02:08:33 +00:00
|
|
|
#endif
|
|
|
|
|
2000-06-19 04:22:15 +00:00
|
|
|
/*
|
|
|
|
* Write a file out. If tmp is nonzero, we set the umask to 0600,
|
2001-05-05 17:45:54 +00:00
|
|
|
* we don't set the global variable filename to its name, and don't
|
2000-06-19 04:22:15 +00:00
|
|
|
* print out how many lines we wrote on the statusbar.
|
2003-01-13 01:35:15 +00:00
|
|
|
*
|
2001-03-28 02:14:28 +00:00
|
|
|
* tmp means we are writing a tmp file in a secure fashion. We use
|
2000-12-02 04:36:50 +00:00
|
|
|
* it when spell checking or dumping the file on an error.
|
2001-05-29 04:21:44 +00:00
|
|
|
*
|
2002-04-16 03:15:47 +00:00
|
|
|
* append == 1 means we are appending instead of overwriting.
|
|
|
|
* append == 2 means we are prepending instead of overwriting.
|
2001-06-05 23:24:55 +00:00
|
|
|
*
|
|
|
|
* nonamechange means don't change the current filename, it is ignored
|
2002-12-22 16:30:00 +00:00
|
|
|
* if tmp is nonzero or if we're appending/prepending.
|
2000-06-19 04:22:15 +00:00
|
|
|
*/
|
2002-09-13 18:14:04 +00:00
|
|
|
int write_file(const char *name, int tmp, int append, int nonamechange)
|
2000-06-19 04:22:15 +00:00
|
|
|
{
|
2002-09-13 18:14:04 +00:00
|
|
|
int retval = -1;
|
|
|
|
/* Instead of returning in this function, you should always
|
|
|
|
* merely set retval then goto cleanup_and_exit. */
|
2002-12-22 16:30:00 +00:00
|
|
|
long size;
|
|
|
|
int lineswritten = 0;
|
2002-04-22 23:52:34 +00:00
|
|
|
char *buf = NULL;
|
2002-09-13 18:14:04 +00:00
|
|
|
const filestruct *fileptr;
|
2002-04-22 23:52:34 +00:00
|
|
|
FILE *f;
|
|
|
|
int fd;
|
|
|
|
int mask = 0, realexists, anyexists;
|
2000-12-13 15:01:29 +00:00
|
|
|
struct stat st, lst;
|
2002-02-27 04:14:16 +00:00
|
|
|
char *realname = NULL;
|
2000-06-19 04:22:15 +00:00
|
|
|
|
2002-05-11 03:04:44 +00:00
|
|
|
if (name[0] == '\0') {
|
2000-06-19 04:22:15 +00:00
|
|
|
statusbar(_("Cancelled"));
|
|
|
|
return -1;
|
|
|
|
}
|
2003-02-03 03:32:08 +00:00
|
|
|
if (!tmp)
|
|
|
|
titlebar(NULL);
|
2000-06-19 04:22:15 +00:00
|
|
|
fileptr = fileage;
|
2000-11-24 14:02:57 +00:00
|
|
|
|
2000-11-24 14:00:16 +00:00
|
|
|
realname = real_dir_from_tilde(name);
|
2000-06-19 04:22:15 +00:00
|
|
|
|
2001-09-19 03:19:43 +00:00
|
|
|
#ifndef DISABLE_OPERATINGDIR
|
2002-09-13 18:14:04 +00:00
|
|
|
/* If we're writing a temporary file, we're probably going outside
|
|
|
|
the operating directory, so skip the operating directory test. */
|
2002-12-22 16:30:00 +00:00
|
|
|
if (!tmp && operating_dir != NULL && check_operating_dir(realname, 0)) {
|
2002-09-13 18:14:04 +00:00
|
|
|
statusbar(_("Can't write outside of %s"), operating_dir);
|
|
|
|
goto cleanup_and_exit;
|
2001-09-19 03:19:43 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2002-09-13 18:14:04 +00:00
|
|
|
/* Save the state of file at the end of the symlink (if there is
|
|
|
|
one). */
|
2000-12-02 21:13:50 +00:00
|
|
|
realexists = stat(realname, &st);
|
|
|
|
|
2002-06-28 22:45:14 +00:00
|
|
|
#ifndef NANO_SMALL
|
|
|
|
/* We backup only if the backup toggle is set, the file isn't
|
|
|
|
temporary, and the file already exists. Furthermore, if we aren't
|
2002-11-04 16:05:42 +00:00
|
|
|
appending, prepending, or writing a selection, we backup only if
|
2002-06-28 22:45:14 +00:00
|
|
|
the file has not been modified by someone else since nano opened
|
|
|
|
it. */
|
|
|
|
if (ISSET(BACKUP_FILE) && !tmp && realexists == 0 &&
|
2002-12-22 16:30:00 +00:00
|
|
|
(append != 0 || ISSET(MARK_ISSET) ||
|
2002-06-28 22:45:14 +00:00
|
|
|
originalfilestat.st_mtime == st.st_mtime)) {
|
|
|
|
FILE *backup_file;
|
|
|
|
char *backupname = NULL;
|
|
|
|
char backupbuf[COPYFILEBLOCKSIZE];
|
|
|
|
size_t bytesread;
|
|
|
|
struct utimbuf filetime;
|
|
|
|
|
|
|
|
/* save the original file's access and modification times */
|
|
|
|
filetime.actime = originalfilestat.st_atime;
|
|
|
|
filetime.modtime = originalfilestat.st_mtime;
|
|
|
|
|
|
|
|
/* open the original file to copy to the backup */
|
|
|
|
f = fopen(realname, "rb");
|
2002-12-22 16:30:00 +00:00
|
|
|
if (f == NULL) {
|
2002-06-28 22:45:14 +00:00
|
|
|
statusbar(_("Could not read %s for backup: %s"), realname,
|
|
|
|
strerror(errno));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
backupname = charalloc(strlen(realname) + 2);
|
|
|
|
sprintf(backupname, "%s~", realname);
|
|
|
|
|
|
|
|
/* get a file descriptor for the destination backup file */
|
|
|
|
backup_file = fopen(backupname, "wb");
|
2002-12-22 16:30:00 +00:00
|
|
|
if (backup_file == NULL) {
|
2002-06-28 22:45:14 +00:00
|
|
|
statusbar(_("Couldn't write backup: %s"), strerror(errno));
|
|
|
|
free(backupname);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
fprintf(stderr, _("Backing up %s to %s\n"), realname, backupname);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* copy the file */
|
|
|
|
while ((bytesread = fread(backupbuf, sizeof(char),
|
|
|
|
COPYFILEBLOCKSIZE, f)) > 0)
|
|
|
|
if (fwrite(backupbuf, sizeof(char), bytesread, backup_file) <= 0)
|
|
|
|
break;
|
|
|
|
fclose(backup_file);
|
|
|
|
fclose(f);
|
|
|
|
|
|
|
|
if (chmod(backupname, originalfilestat.st_mode) == -1)
|
2002-11-04 16:05:42 +00:00
|
|
|
statusbar(_("Could not set permissions %o on backup %s: %s"),
|
2002-06-28 22:45:14 +00:00
|
|
|
originalfilestat.st_mode, backupname,
|
|
|
|
strerror(errno));
|
|
|
|
|
|
|
|
if (chown(backupname, originalfilestat.st_uid,
|
|
|
|
originalfilestat.st_gid) == -1)
|
|
|
|
statusbar(_("Could not set owner %d/group %d on backup %s: %s"),
|
|
|
|
originalfilestat.st_uid, originalfilestat.st_gid,
|
|
|
|
backupname, strerror(errno));
|
|
|
|
|
|
|
|
if (utime(backupname, &filetime) == -1)
|
|
|
|
statusbar(_("Could not set access/modification time on backup %s: %s"),
|
|
|
|
backupname, strerror(errno));
|
|
|
|
|
|
|
|
free(backupname);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2000-12-06 05:56:08 +00:00
|
|
|
/* Stat the link itself for the check... */
|
|
|
|
anyexists = lstat(realname, &lst);
|
2000-07-21 22:42:46 +00:00
|
|
|
|
2000-12-04 05:15:39 +00:00
|
|
|
/* New case: if the file exists, just give up */
|
|
|
|
if (tmp && anyexists != -1)
|
2002-09-13 18:14:04 +00:00
|
|
|
goto cleanup_and_exit;
|
2000-12-06 00:57:54 +00:00
|
|
|
/* NOTE: If you change this statement, you MUST CHANGE the if
|
2000-12-11 02:47:13 +00:00
|
|
|
statement below (that says:
|
2002-12-22 16:30:00 +00:00
|
|
|
if (realexists == -1 || tmp || (ISSET(NOFOLLOW_SYMLINKS) &&
|
2000-12-11 02:47:13 +00:00
|
|
|
S_ISLNK(lst.st_mode))) {
|
2000-12-06 05:56:08 +00:00
|
|
|
to reflect whether or not to link/unlink/rename the file */
|
2002-12-22 16:30:00 +00:00
|
|
|
else if (append != 2 && (!ISSET(NOFOLLOW_SYMLINKS) || !S_ISLNK(lst.st_mode)
|
2002-04-16 03:15:47 +00:00
|
|
|
|| tmp)) {
|
2002-12-22 16:30:00 +00:00
|
|
|
/* Use O_EXCL if tmp is nonzero. This is now copied from joe,
|
|
|
|
because wiggy says so *shrug*. */
|
|
|
|
if (append != 0)
|
2003-01-13 01:35:15 +00:00
|
|
|
fd = open(realname, O_WRONLY | O_CREAT | O_APPEND, (S_IRUSR | S_IWUSR));
|
2001-05-29 04:21:44 +00:00
|
|
|
else if (tmp)
|
2003-01-13 01:35:15 +00:00
|
|
|
fd = open(realname, O_WRONLY | O_CREAT | O_EXCL, (S_IRUSR | S_IWUSR));
|
2000-12-09 23:58:41 +00:00
|
|
|
else
|
2003-01-13 01:35:15 +00:00
|
|
|
fd = open(realname, O_WRONLY | O_CREAT | O_TRUNC, (S_IRUSR | S_IWUSR));
|
2000-12-04 05:15:39 +00:00
|
|
|
|
|
|
|
/* First, just give up if we couldn't even open the file */
|
2000-12-04 03:31:39 +00:00
|
|
|
if (fd == -1) {
|
2000-12-04 04:20:09 +00:00
|
|
|
if (!tmp && ISSET(TEMP_OPT)) {
|
2000-07-14 02:44:02 +00:00
|
|
|
UNSET(TEMP_OPT);
|
2002-09-13 18:14:04 +00:00
|
|
|
retval = do_writeout(filename, 1, 0);
|
|
|
|
} else
|
|
|
|
statusbar(_("Could not open file for writing: %s"),
|
|
|
|
strerror(errno));
|
|
|
|
goto cleanup_and_exit;
|
2000-06-19 04:22:15 +00:00
|
|
|
}
|
2000-12-04 05:15:39 +00:00
|
|
|
|
2000-06-19 04:22:15 +00:00
|
|
|
}
|
|
|
|
/* Don't follow symlink. Create new file. */
|
|
|
|
else {
|
2001-05-17 11:35:43 +00:00
|
|
|
buf = charalloc(strlen(realname) + 8);
|
2002-04-23 10:22:33 +00:00
|
|
|
strcpy(buf, realname);
|
2000-06-19 04:22:15 +00:00
|
|
|
strcat(buf, ".XXXXXX");
|
|
|
|
if ((fd = mkstemp(buf)) == -1) {
|
2000-07-14 02:44:02 +00:00
|
|
|
if (ISSET(TEMP_OPT)) {
|
|
|
|
UNSET(TEMP_OPT);
|
2002-09-13 18:14:04 +00:00
|
|
|
retval = do_writeout(filename, 1, 0);
|
|
|
|
} else
|
|
|
|
statusbar(_("Could not open file for writing: %s"),
|
|
|
|
strerror(errno));
|
|
|
|
goto cleanup_and_exit;
|
2000-06-19 04:22:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-07-19 01:08:59 +00:00
|
|
|
#ifdef DEBUG
|
2000-06-19 04:22:15 +00:00
|
|
|
dump_buffer(fileage);
|
2002-07-19 01:08:59 +00:00
|
|
|
#endif
|
2002-04-22 23:52:34 +00:00
|
|
|
|
2002-06-13 00:40:19 +00:00
|
|
|
f = fdopen(fd, append == 1 ? "ab" : "wb");
|
2002-12-22 16:30:00 +00:00
|
|
|
if (f == NULL) {
|
2002-09-13 18:14:04 +00:00
|
|
|
statusbar(_("Could not open file for writing: %s"), strerror(errno));
|
|
|
|
goto cleanup_and_exit;
|
2002-04-22 23:52:34 +00:00
|
|
|
}
|
|
|
|
|
2000-06-19 04:22:15 +00:00
|
|
|
while (fileptr != NULL && fileptr->next != NULL) {
|
2002-04-22 23:52:34 +00:00
|
|
|
int data_len;
|
2002-09-13 18:14:04 +00:00
|
|
|
|
2000-07-04 22:15:39 +00:00
|
|
|
/* Next line is so we discount the "magic line" */
|
2000-10-26 01:44:42 +00:00
|
|
|
if (filebot == fileptr && fileptr->data[0] == '\0')
|
|
|
|
break;
|
2000-07-04 22:15:39 +00:00
|
|
|
|
2002-04-22 23:52:34 +00:00
|
|
|
data_len = strlen(fileptr->data);
|
2002-06-13 00:40:19 +00:00
|
|
|
|
|
|
|
/* newlines to nulls, just before we write to disk */
|
|
|
|
sunder(fileptr->data);
|
|
|
|
|
2002-04-22 23:52:34 +00:00
|
|
|
size = fwrite(fileptr->data, 1, data_len, f);
|
2002-06-13 00:40:19 +00:00
|
|
|
|
|
|
|
/* nulls to newlines; data_len is the string's real length here */
|
|
|
|
unsunder(fileptr->data, data_len);
|
|
|
|
|
2002-04-22 23:52:34 +00:00
|
|
|
if (size < data_len) {
|
2000-06-19 04:22:15 +00:00
|
|
|
statusbar(_("Could not open file for writing: %s"),
|
|
|
|
strerror(errno));
|
2002-04-23 10:22:33 +00:00
|
|
|
fclose(f);
|
2002-09-13 18:14:04 +00:00
|
|
|
goto cleanup_and_exit;
|
2002-04-23 10:22:33 +00:00
|
|
|
}
|
2000-06-19 04:22:15 +00:00
|
|
|
#ifdef DEBUG
|
2002-04-23 10:22:33 +00:00
|
|
|
else
|
2000-06-19 04:22:15 +00:00
|
|
|
fprintf(stderr, _("Wrote >%s\n"), fileptr->data);
|
|
|
|
#endif
|
2001-09-21 02:37:01 +00:00
|
|
|
#ifndef NANO_SMALL
|
2001-09-22 04:20:25 +00:00
|
|
|
if (ISSET(DOS_FILE) || ISSET(MAC_FILE))
|
2002-04-22 23:52:34 +00:00
|
|
|
putc('\r', f);
|
2001-09-22 04:20:25 +00:00
|
|
|
|
|
|
|
if (!ISSET(MAC_FILE))
|
2001-09-21 02:37:01 +00:00
|
|
|
#endif
|
2002-04-22 23:52:34 +00:00
|
|
|
putc('\n', f);
|
2000-06-19 04:22:15 +00:00
|
|
|
|
|
|
|
fileptr = fileptr->next;
|
|
|
|
lineswritten++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fileptr != NULL) {
|
2002-09-13 18:14:04 +00:00
|
|
|
int data_len = strlen(fileptr->data);
|
2002-06-13 00:40:19 +00:00
|
|
|
|
|
|
|
/* newlines to nulls, just before we write to disk */
|
|
|
|
sunder(fileptr->data);
|
|
|
|
|
2002-04-22 23:52:34 +00:00
|
|
|
size = fwrite(fileptr->data, 1, data_len, f);
|
2002-06-13 00:40:19 +00:00
|
|
|
|
|
|
|
/* nulls to newlines; data_len is the string's real length here */
|
|
|
|
unsunder(fileptr->data, data_len);
|
|
|
|
|
2002-04-22 23:52:34 +00:00
|
|
|
if (size < data_len) {
|
2000-06-19 04:22:15 +00:00
|
|
|
statusbar(_("Could not open file for writing: %s"),
|
|
|
|
strerror(errno));
|
2002-09-13 18:14:04 +00:00
|
|
|
goto cleanup_and_exit;
|
2002-04-22 23:52:34 +00:00
|
|
|
} else if (data_len > 0) {
|
2001-09-21 02:37:01 +00:00
|
|
|
#ifndef NANO_SMALL
|
2001-09-22 05:08:12 +00:00
|
|
|
if (ISSET(DOS_FILE) || ISSET(MAC_FILE)) {
|
2002-04-22 23:52:34 +00:00
|
|
|
if (putc('\r', f) == EOF) {
|
2001-09-21 02:37:01 +00:00
|
|
|
statusbar(_("Could not open file for writing: %s"),
|
|
|
|
strerror(errno));
|
2002-04-22 23:52:34 +00:00
|
|
|
fclose(f);
|
2002-09-13 18:14:04 +00:00
|
|
|
goto cleanup_and_exit;
|
2001-09-21 02:37:01 +00:00
|
|
|
}
|
2002-04-22 23:52:34 +00:00
|
|
|
lineswritten++;
|
2001-09-21 02:37:01 +00:00
|
|
|
}
|
2001-09-22 04:20:25 +00:00
|
|
|
|
|
|
|
if (!ISSET(MAC_FILE))
|
2001-09-21 02:37:01 +00:00
|
|
|
#endif
|
2001-09-22 04:20:25 +00:00
|
|
|
{
|
2002-04-22 23:52:34 +00:00
|
|
|
if (putc('\n', f) == EOF) {
|
2001-09-22 04:20:25 +00:00
|
|
|
statusbar(_("Could not open file for writing: %s"),
|
2000-06-19 04:22:15 +00:00
|
|
|
strerror(errno));
|
2002-04-22 23:52:34 +00:00
|
|
|
fclose(f);
|
2002-09-13 18:14:04 +00:00
|
|
|
goto cleanup_and_exit;
|
2001-09-22 04:20:25 +00:00
|
|
|
}
|
2002-04-22 23:52:34 +00:00
|
|
|
lineswritten++;
|
2000-06-19 04:22:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
if (fclose(f) != 0) {
|
2000-11-24 14:00:16 +00:00
|
|
|
statusbar(_("Could not close %s: %s"), realname, strerror(errno));
|
2000-06-19 04:22:15 +00:00
|
|
|
unlink(buf);
|
2002-09-13 18:14:04 +00:00
|
|
|
goto cleanup_and_exit;
|
2000-06-19 04:22:15 +00:00
|
|
|
}
|
|
|
|
|
2002-04-16 03:15:47 +00:00
|
|
|
/* if we're prepending, open the real file, and append it here */
|
|
|
|
if (append == 2) {
|
2002-04-23 10:22:33 +00:00
|
|
|
int fd_source, fd_dest;
|
|
|
|
FILE *f_source, *f_dest;
|
|
|
|
int prechar;
|
2002-04-22 23:52:34 +00:00
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
if ((fd_dest = open(buf, O_WRONLY | O_APPEND, (S_IRUSR | S_IWUSR))) == -1) {
|
2002-04-16 03:15:47 +00:00
|
|
|
statusbar(_("Could not reopen %s: %s"), buf, strerror(errno));
|
2002-09-13 18:14:04 +00:00
|
|
|
goto cleanup_and_exit;
|
2002-04-16 03:15:47 +00:00
|
|
|
}
|
2002-04-22 23:52:34 +00:00
|
|
|
f_dest = fdopen(fd_dest, "wb");
|
2002-12-22 16:30:00 +00:00
|
|
|
if (f_dest == NULL) {
|
2002-04-22 23:52:34 +00:00
|
|
|
statusbar(_("Could not reopen %s: %s"), buf, strerror(errno));
|
2002-04-23 10:22:33 +00:00
|
|
|
close(fd_dest);
|
2002-09-13 18:14:04 +00:00
|
|
|
goto cleanup_and_exit;
|
2002-04-22 23:52:34 +00:00
|
|
|
}
|
2002-04-23 10:22:33 +00:00
|
|
|
if ((fd_source = open(realname, O_RDONLY | O_CREAT)) == -1) {
|
2002-04-22 23:52:34 +00:00
|
|
|
statusbar(_("Could not open %s for prepend: %s"), realname, strerror(errno));
|
2002-04-23 10:22:33 +00:00
|
|
|
fclose(f_dest);
|
2002-09-13 18:14:04 +00:00
|
|
|
goto cleanup_and_exit;
|
2002-04-22 23:52:34 +00:00
|
|
|
}
|
|
|
|
f_source = fdopen(fd_source, "rb");
|
2002-12-22 16:30:00 +00:00
|
|
|
if (f_source == NULL) {
|
2002-04-22 23:52:34 +00:00
|
|
|
statusbar(_("Could not open %s for prepend: %s"), realname, strerror(errno));
|
|
|
|
fclose(f_dest);
|
|
|
|
close(fd_source);
|
2002-09-13 18:14:04 +00:00
|
|
|
goto cleanup_and_exit;
|
2002-04-16 03:15:47 +00:00
|
|
|
}
|
|
|
|
|
2002-04-22 23:52:34 +00:00
|
|
|
/* Doing this in blocks is an exercise left to some other reader. */
|
|
|
|
while ((prechar = getc(f_source)) != EOF) {
|
|
|
|
if (putc(prechar, f_dest) == EOF) {
|
|
|
|
statusbar(_("Could not open %s for prepend: %s"), realname, strerror(errno));
|
|
|
|
fclose(f_source);
|
|
|
|
fclose(f_dest);
|
2002-09-13 18:14:04 +00:00
|
|
|
goto cleanup_and_exit;
|
2002-04-22 23:52:34 +00:00
|
|
|
}
|
|
|
|
}
|
2002-04-16 03:15:47 +00:00
|
|
|
|
2002-04-22 23:52:34 +00:00
|
|
|
if (ferror(f_source)) {
|
|
|
|
statusbar(_("Could not reopen %s: %s"), buf, strerror(errno));
|
|
|
|
fclose(f_source);
|
|
|
|
fclose(f_dest);
|
2002-09-13 18:14:04 +00:00
|
|
|
goto cleanup_and_exit;
|
2002-04-22 23:52:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fclose(f_source);
|
|
|
|
fclose(f_dest);
|
2002-04-16 03:15:47 +00:00
|
|
|
}
|
|
|
|
|
2000-12-06 05:56:08 +00:00
|
|
|
if (realexists == -1 || tmp ||
|
2002-12-22 16:30:00 +00:00
|
|
|
(ISSET(NOFOLLOW_SYMLINKS) && S_ISLNK(lst.st_mode))) {
|
2000-06-19 04:22:15 +00:00
|
|
|
|
2001-05-05 17:45:54 +00:00
|
|
|
/* Use default umask as file permissions if file is a new file. */
|
2000-12-06 05:56:08 +00:00
|
|
|
mask = umask(0);
|
|
|
|
umask(mask);
|
2000-06-19 04:22:15 +00:00
|
|
|
|
2002-06-28 22:45:14 +00:00
|
|
|
if (tmp) /* We don't want anyone reading our temporary file! */
|
2003-01-13 01:35:15 +00:00
|
|
|
mask = S_IRUSR | S_IWUSR;
|
2000-12-06 05:56:08 +00:00
|
|
|
else
|
2003-01-13 01:35:15 +00:00
|
|
|
mask = (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH |
|
|
|
|
S_IWOTH) & ~mask;
|
2000-12-06 05:56:08 +00:00
|
|
|
} else
|
2000-12-06 05:59:31 +00:00
|
|
|
/* Use permissions from file we are overwriting. */
|
2000-12-06 05:56:08 +00:00
|
|
|
mask = st.st_mode;
|
|
|
|
|
2002-04-16 03:15:47 +00:00
|
|
|
if (append == 2 ||
|
2002-12-22 16:30:00 +00:00
|
|
|
(!tmp && (ISSET(NOFOLLOW_SYMLINKS) && S_ISLNK(lst.st_mode)))) {
|
2000-12-06 05:56:08 +00:00
|
|
|
if (unlink(realname) == -1) {
|
|
|
|
if (errno != ENOENT) {
|
2000-12-02 21:13:50 +00:00
|
|
|
statusbar(_("Could not open %s for writing: %s"),
|
2000-12-06 05:56:08 +00:00
|
|
|
realname, strerror(errno));
|
2000-12-02 21:13:50 +00:00
|
|
|
unlink(buf);
|
2002-09-13 18:14:04 +00:00
|
|
|
goto cleanup_and_exit;
|
2000-12-02 21:13:50 +00:00
|
|
|
}
|
2000-06-19 04:22:15 +00:00
|
|
|
}
|
2000-12-06 05:56:08 +00:00
|
|
|
if (link(buf, realname) != -1)
|
|
|
|
unlink(buf);
|
|
|
|
else if (errno != EPERM) {
|
|
|
|
statusbar(_("Could not open %s for writing: %s"),
|
|
|
|
name, strerror(errno));
|
|
|
|
unlink(buf);
|
2002-09-13 18:14:04 +00:00
|
|
|
goto cleanup_and_exit;
|
2000-12-06 05:56:08 +00:00
|
|
|
} else if (rename(buf, realname) == -1) { /* Try a rename?? */
|
|
|
|
statusbar(_("Could not open %s for writing: %s"),
|
|
|
|
realname, strerror(errno));
|
|
|
|
unlink(buf);
|
2002-09-13 18:14:04 +00:00
|
|
|
goto cleanup_and_exit;
|
2000-12-06 05:56:08 +00:00
|
|
|
}
|
2000-06-19 04:22:15 +00:00
|
|
|
}
|
2000-12-06 05:56:08 +00:00
|
|
|
if (chmod(realname, mask) == -1)
|
|
|
|
statusbar(_("Could not set permissions %o on %s: %s"),
|
|
|
|
mask, realname, strerror(errno));
|
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
if (!tmp && append == 0) {
|
2003-01-13 01:35:15 +00:00
|
|
|
if (!nonamechange) {
|
2001-06-05 23:24:55 +00:00
|
|
|
filename = mallocstrcpy(filename, realname);
|
2003-01-13 01:35:15 +00:00
|
|
|
#ifdef ENABLE_COLOR
|
|
|
|
update_color();
|
|
|
|
edit_refresh();
|
|
|
|
#endif
|
|
|
|
}
|
2001-06-05 23:24:55 +00:00
|
|
|
|
2002-06-28 22:45:14 +00:00
|
|
|
#ifndef NANO_SMALL
|
|
|
|
/* Update originalfilestat to reference the file as it is now. */
|
|
|
|
stat(filename, &originalfilestat);
|
|
|
|
#endif
|
2003-02-10 11:30:11 +00:00
|
|
|
statusbar(P_("Wrote %d line", "Wrote %d lines", lineswritten),
|
2002-10-17 02:19:31 +00:00
|
|
|
lineswritten);
|
2000-12-06 05:56:08 +00:00
|
|
|
UNSET(MODIFIED);
|
2001-01-03 07:11:47 +00:00
|
|
|
titlebar(NULL);
|
2000-06-19 04:22:15 +00:00
|
|
|
}
|
2002-09-13 18:14:04 +00:00
|
|
|
|
|
|
|
retval = 1;
|
|
|
|
|
|
|
|
cleanup_and_exit:
|
|
|
|
free(realname);
|
|
|
|
free(buf);
|
|
|
|
return retval;
|
2000-06-19 04:22:15 +00:00
|
|
|
}
|
|
|
|
|
2002-09-13 18:14:04 +00:00
|
|
|
int do_writeout(const char *path, int exiting, int append)
|
2000-06-19 04:22:15 +00:00
|
|
|
{
|
|
|
|
int i = 0;
|
2000-11-24 20:45:14 +00:00
|
|
|
#ifdef NANO_EXTRA
|
|
|
|
static int did_cred = 0;
|
|
|
|
#endif
|
2000-06-19 04:22:15 +00:00
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
#if !defined(DISABLE_BROWSER) || (!defined(DISABLE_MOUSE) && defined(NCURSES_MOUSE_VERSION))
|
2001-04-12 03:01:53 +00:00
|
|
|
currshortcut = writefile_list;
|
2001-05-21 12:56:25 +00:00
|
|
|
#endif
|
|
|
|
|
2001-01-07 05:50:36 +00:00
|
|
|
answer = mallocstrcpy(answer, path);
|
2000-06-19 04:22:15 +00:00
|
|
|
|
2002-09-13 18:14:04 +00:00
|
|
|
if (exiting && ISSET(TEMP_OPT)) {
|
2002-12-22 16:30:00 +00:00
|
|
|
if (filename[0] != '\0') {
|
2001-06-05 23:24:55 +00:00
|
|
|
i = write_file(answer, 0, 0, 0);
|
2000-07-24 21:52:17 +00:00
|
|
|
display_main_list();
|
|
|
|
return i;
|
2000-10-26 01:44:42 +00:00
|
|
|
} else {
|
2000-07-24 22:05:18 +00:00
|
|
|
UNSET(TEMP_OPT);
|
|
|
|
do_exit();
|
|
|
|
|
|
|
|
/* They cancelled, abort quit */
|
|
|
|
return -1;
|
2000-07-24 21:52:17 +00:00
|
|
|
}
|
2000-06-19 04:22:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
while (1) {
|
2001-06-21 23:58:47 +00:00
|
|
|
#ifndef NANO_SMALL
|
2002-09-13 18:14:04 +00:00
|
|
|
const char *formatstr, *backupstr;
|
|
|
|
|
2002-02-15 19:17:02 +00:00
|
|
|
if (ISSET(MAC_FILE))
|
|
|
|
formatstr = _(" [Mac Format]");
|
|
|
|
else if (ISSET(DOS_FILE))
|
|
|
|
formatstr = _(" [DOS Format]");
|
|
|
|
else
|
|
|
|
formatstr = "";
|
|
|
|
|
2002-06-28 22:45:14 +00:00
|
|
|
if (ISSET(BACKUP_FILE))
|
|
|
|
backupstr = _(" [Backup]");
|
|
|
|
else
|
|
|
|
backupstr = "";
|
|
|
|
|
2002-02-15 19:17:02 +00:00
|
|
|
/* Be nice to the translation folks */
|
2001-09-27 20:46:25 +00:00
|
|
|
if (ISSET(MARK_ISSET) && !exiting) {
|
2002-04-16 03:15:47 +00:00
|
|
|
if (append == 2)
|
2003-01-05 20:41:21 +00:00
|
|
|
i = statusq(1, writefile_list, "", 0,
|
2002-06-28 22:45:14 +00:00
|
|
|
"%s%s%s", _("Prepend Selection to File"), formatstr, backupstr);
|
2003-01-13 01:35:15 +00:00
|
|
|
else if (append == 1)
|
2003-01-05 20:41:21 +00:00
|
|
|
i = statusq(1, writefile_list, "", 0,
|
2002-06-28 22:45:14 +00:00
|
|
|
"%s%s%s", _("Append Selection to File"), formatstr, backupstr);
|
2001-09-27 20:46:25 +00:00
|
|
|
else
|
2003-01-05 20:41:21 +00:00
|
|
|
i = statusq(1, writefile_list, "", 0,
|
2002-06-28 22:45:14 +00:00
|
|
|
"%s%s%s", _("Write Selection to File"), formatstr, backupstr);
|
|
|
|
} else {
|
2002-04-16 03:15:47 +00:00
|
|
|
if (append == 2)
|
2003-01-05 20:41:21 +00:00
|
|
|
i = statusq(1, writefile_list, answer, 0,
|
2002-06-28 22:45:14 +00:00
|
|
|
"%s%s%s", _("File Name to Prepend to"), formatstr, backupstr);
|
2003-01-13 01:35:15 +00:00
|
|
|
else if (append == 1)
|
2003-01-05 20:41:21 +00:00
|
|
|
i = statusq(1, writefile_list, answer, 0,
|
2002-06-28 22:45:14 +00:00
|
|
|
"%s%s%s", _("File Name to Append to"), formatstr, backupstr);
|
2001-09-27 20:46:25 +00:00
|
|
|
else
|
2003-01-05 20:41:21 +00:00
|
|
|
i = statusq(1, writefile_list, answer, 0,
|
2002-06-28 22:45:14 +00:00
|
|
|
"%s%s%s", _("File Name to Write"), formatstr, backupstr);
|
2001-09-27 20:46:25 +00:00
|
|
|
}
|
2002-06-28 22:45:14 +00:00
|
|
|
#else
|
|
|
|
if (append == 2)
|
2003-01-13 01:35:15 +00:00
|
|
|
i = statusq(1, writefile_list, answer,
|
2002-06-28 22:45:14 +00:00
|
|
|
"%s", _("File Name to Prepend to"));
|
2003-01-13 01:35:15 +00:00
|
|
|
else if (append == 1)
|
|
|
|
i = statusq(1, writefile_list, answer,
|
2002-06-28 22:45:14 +00:00
|
|
|
"%s", _("File Name to Append to"));
|
|
|
|
else
|
2003-01-13 01:35:15 +00:00
|
|
|
i = statusq(1, writefile_list, answer,
|
2002-06-28 22:45:14 +00:00
|
|
|
"%s", _("File Name to Write"));
|
|
|
|
#endif /* !NANO_SMALL */
|
2000-06-19 04:22:15 +00:00
|
|
|
|
2002-09-13 18:14:04 +00:00
|
|
|
if (i == -1) {
|
|
|
|
statusbar(_("Cancelled"));
|
|
|
|
display_main_list();
|
|
|
|
return 0;
|
|
|
|
}
|
2000-06-19 04:22:15 +00:00
|
|
|
|
2001-01-12 07:51:05 +00:00
|
|
|
#ifndef DISABLE_BROWSER
|
2001-01-03 07:11:47 +00:00
|
|
|
if (i == NANO_TOFILES_KEY) {
|
2001-01-05 21:13:14 +00:00
|
|
|
char *tmp = do_browse_from(answer);
|
2001-05-21 12:56:25 +00:00
|
|
|
|
2001-04-12 03:01:53 +00:00
|
|
|
currshortcut = writefile_list;
|
2002-09-13 18:14:04 +00:00
|
|
|
if (tmp == NULL)
|
|
|
|
continue;
|
|
|
|
free(answer);
|
|
|
|
answer = tmp;
|
2001-05-29 04:21:44 +00:00
|
|
|
} else
|
2002-09-13 18:14:04 +00:00
|
|
|
#endif /* !DISABLE_BROWSER */
|
2002-07-20 13:57:41 +00:00
|
|
|
#ifndef NANO_SMALL
|
2002-02-15 19:17:02 +00:00
|
|
|
if (i == TOGGLE_DOS_KEY) {
|
|
|
|
UNSET(MAC_FILE);
|
|
|
|
TOGGLE(DOS_FILE);
|
2002-09-13 18:14:04 +00:00
|
|
|
continue;
|
2002-02-15 19:17:02 +00:00
|
|
|
} else if (i == TOGGLE_MAC_KEY) {
|
|
|
|
UNSET(DOS_FILE);
|
|
|
|
TOGGLE(MAC_FILE);
|
2002-09-13 18:14:04 +00:00
|
|
|
continue;
|
2002-06-28 22:45:14 +00:00
|
|
|
} else if (i == TOGGLE_BACKUP_KEY) {
|
|
|
|
TOGGLE(BACKUP_FILE);
|
2002-09-13 18:14:04 +00:00
|
|
|
continue;
|
|
|
|
} else
|
2002-12-22 16:30:00 +00:00
|
|
|
#endif /* !NANO_SMALL */
|
2002-09-13 18:14:04 +00:00
|
|
|
if (i == NANO_PREPEND_KEY) {
|
|
|
|
append = append == 2 ? 0 : 2;
|
|
|
|
continue;
|
|
|
|
} else if (i == NANO_APPEND_KEY) {
|
|
|
|
append = append == 1 ? 0 : 1;
|
|
|
|
continue;
|
|
|
|
}
|
2001-01-03 07:11:47 +00:00
|
|
|
|
2000-06-19 04:22:15 +00:00
|
|
|
#ifdef DEBUG
|
2002-09-13 18:14:04 +00:00
|
|
|
fprintf(stderr, _("filename is %s\n"), answer);
|
2000-06-19 04:22:15 +00:00
|
|
|
#endif
|
2000-11-24 20:45:14 +00:00
|
|
|
|
|
|
|
#ifdef NANO_EXTRA
|
2002-09-13 18:14:04 +00:00
|
|
|
if (exiting && !ISSET(TEMP_OPT) && !strcasecmp(answer, "zzy")
|
2000-12-06 05:56:08 +00:00
|
|
|
&& !did_cred) {
|
2002-09-13 18:14:04 +00:00
|
|
|
do_credits();
|
|
|
|
did_cred = 1;
|
|
|
|
return -1;
|
|
|
|
}
|
2000-11-24 20:45:14 +00:00
|
|
|
#endif
|
2002-12-22 16:30:00 +00:00
|
|
|
if (append == 0 && strcmp(answer, filename) != 0) {
|
2002-09-13 18:14:04 +00:00
|
|
|
struct stat st;
|
2000-06-19 04:22:15 +00:00
|
|
|
|
2002-09-13 18:14:04 +00:00
|
|
|
if (!stat(answer, &st)) {
|
|
|
|
i = do_yesno(0, 0, _("File exists, OVERWRITE ?"));
|
|
|
|
|
|
|
|
if (i == 0 || i == -1)
|
|
|
|
continue;
|
2000-06-21 03:00:43 +00:00
|
|
|
}
|
2002-09-13 18:14:04 +00:00
|
|
|
}
|
2000-06-19 04:22:15 +00:00
|
|
|
|
2002-06-28 22:45:14 +00:00
|
|
|
#ifndef NANO_SMALL
|
2001-05-29 04:21:44 +00:00
|
|
|
/* Here's where we allow the selected text to be written to
|
|
|
|
a separate file. */
|
|
|
|
if (ISSET(MARK_ISSET) && !exiting) {
|
2002-11-04 16:05:42 +00:00
|
|
|
filestruct *fileagebak = fileage;
|
2001-05-29 04:21:44 +00:00
|
|
|
filestruct *filebotbak = filebot;
|
|
|
|
filestruct *cutback = cutbuffer;
|
2002-09-13 18:14:04 +00:00
|
|
|
int oldmod = ISSET(MODIFIED);
|
|
|
|
/* write_file() unsets the MODIFIED flag. */
|
2001-05-29 04:21:44 +00:00
|
|
|
|
2002-09-13 18:14:04 +00:00
|
|
|
cutbuffer = NULL;
|
2001-05-29 04:21:44 +00:00
|
|
|
|
2002-09-13 18:14:04 +00:00
|
|
|
/* Put the marked text in the cutbuffer without changing
|
|
|
|
the open file. */
|
|
|
|
cut_marked_segment(current, current_x, mark_beginbuf,
|
2001-05-29 04:21:44 +00:00
|
|
|
mark_beginx, 0);
|
|
|
|
|
|
|
|
fileage = cutbuffer;
|
2002-09-13 18:14:04 +00:00
|
|
|
filebot = get_cutbottom();
|
2001-06-05 23:24:55 +00:00
|
|
|
i = write_file(answer, 0, append, 1);
|
2001-05-29 04:21:44 +00:00
|
|
|
|
|
|
|
/* Now restore everything */
|
2002-09-13 18:14:04 +00:00
|
|
|
free_filestruct(cutbuffer);
|
2001-05-29 04:21:44 +00:00
|
|
|
fileage = fileagebak;
|
|
|
|
filebot = filebotbak;
|
|
|
|
cutbuffer = cutback;
|
|
|
|
if (oldmod)
|
|
|
|
set_modified();
|
|
|
|
} else
|
2002-06-28 22:45:14 +00:00
|
|
|
#endif /* !NANO_SMALL */
|
2001-06-05 23:24:55 +00:00
|
|
|
i = write_file(answer, 0, append, 0);
|
2001-07-11 02:08:33 +00:00
|
|
|
|
2001-07-14 19:32:47 +00:00
|
|
|
#ifdef ENABLE_MULTIBUFFER
|
2002-09-13 18:14:04 +00:00
|
|
|
/* If we're not about to exit, update the current entry in
|
|
|
|
the open_files structure. */
|
|
|
|
if (!exiting)
|
|
|
|
add_open_file(1);
|
2001-07-11 02:08:33 +00:00
|
|
|
#endif
|
2002-09-13 18:14:04 +00:00
|
|
|
display_main_list();
|
|
|
|
return i;
|
|
|
|
} /* while (1) */
|
2000-06-19 04:22:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int do_writeout_void(void)
|
|
|
|
{
|
2001-05-29 04:21:44 +00:00
|
|
|
return do_writeout(filename, 0, 0);
|
2000-06-19 04:22:15 +00:00
|
|
|
}
|
2000-11-05 17:54:41 +00:00
|
|
|
|
2000-11-24 14:00:16 +00:00
|
|
|
/* Return a malloc()ed string containing the actual directory, used
|
2002-09-13 18:14:04 +00:00
|
|
|
* to convert ~user and ~/ notation... */
|
|
|
|
char *real_dir_from_tilde(const char *buf)
|
2000-11-24 14:00:16 +00:00
|
|
|
{
|
2002-07-29 23:46:38 +00:00
|
|
|
char *dirtmp = NULL;
|
2001-01-23 03:09:15 +00:00
|
|
|
|
2000-11-24 14:00:16 +00:00
|
|
|
if (buf[0] == '~') {
|
2002-09-13 18:14:04 +00:00
|
|
|
size_t i;
|
|
|
|
const struct passwd *userdata;
|
|
|
|
|
|
|
|
/* Figure how how much of the str we need to compare */
|
|
|
|
for (i = 1; buf[i] != '/' && buf[i] != '\0'; i++)
|
|
|
|
;
|
|
|
|
|
2003-03-11 03:50:40 +00:00
|
|
|
/* Determine home directory using getpwuid() or getpwent(),
|
|
|
|
don't rely on $HOME */
|
2003-02-13 22:00:19 +00:00
|
|
|
if (i == 1)
|
|
|
|
userdata = getpwuid(geteuid());
|
|
|
|
else {
|
2002-09-13 18:14:04 +00:00
|
|
|
do {
|
|
|
|
userdata = getpwent();
|
|
|
|
} while (userdata != NULL &&
|
|
|
|
strncmp(userdata->pw_name, buf + 1, i - 1));
|
2002-07-29 23:46:38 +00:00
|
|
|
}
|
|
|
|
endpwent();
|
2001-01-23 03:09:15 +00:00
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
if (userdata != NULL) { /* User found */
|
2002-09-13 18:14:04 +00:00
|
|
|
dirtmp = charalloc(strlen(userdata->pw_dir) + strlen(buf + i) + 1);
|
2002-07-29 23:46:38 +00:00
|
|
|
sprintf(dirtmp, "%s%s", userdata->pw_dir, &buf[i]);
|
2000-11-24 14:00:16 +00:00
|
|
|
}
|
2001-01-23 03:09:15 +00:00
|
|
|
}
|
2000-11-25 04:43:43 +00:00
|
|
|
|
2002-09-13 18:14:04 +00:00
|
|
|
if (dirtmp == NULL)
|
|
|
|
dirtmp = mallocstrcpy(dirtmp, buf);
|
|
|
|
|
2000-11-25 04:43:43 +00:00
|
|
|
return dirtmp;
|
2000-11-24 14:00:16 +00:00
|
|
|
}
|
|
|
|
|
2003-01-13 01:35:15 +00:00
|
|
|
#ifndef DISABLE_TABCOMP
|
2002-09-13 18:14:04 +00:00
|
|
|
/* Tack a slash onto the string we're completing if it's a directory. We
|
|
|
|
* assume there is room for one more character on the end of buf. The
|
|
|
|
* return value says whether buf is a directory. */
|
2002-06-13 00:40:19 +00:00
|
|
|
int append_slash_if_dir(char *buf, int *lastwastab, int *place)
|
2000-11-24 14:00:16 +00:00
|
|
|
{
|
2002-09-13 18:14:04 +00:00
|
|
|
char *dirptr = real_dir_from_tilde(buf);
|
2000-11-24 14:00:16 +00:00
|
|
|
struct stat fileinfo;
|
2000-11-25 04:43:43 +00:00
|
|
|
int ret = 0;
|
2000-11-24 14:00:16 +00:00
|
|
|
|
2002-09-13 18:14:04 +00:00
|
|
|
assert(dirptr != buf);
|
2000-11-24 14:00:16 +00:00
|
|
|
|
2002-09-13 18:14:04 +00:00
|
|
|
if (stat(dirptr, &fileinfo) != -1 && S_ISDIR(fileinfo.st_mode)) {
|
2000-11-24 14:00:16 +00:00
|
|
|
strncat(buf, "/", 1);
|
2002-09-13 18:14:04 +00:00
|
|
|
(*place)++;
|
2000-11-24 14:00:16 +00:00
|
|
|
/* now we start over again with # of tabs so far */
|
2002-06-13 00:40:19 +00:00
|
|
|
*lastwastab = 0;
|
2000-11-25 04:43:43 +00:00
|
|
|
ret = 1;
|
2000-11-24 14:00:16 +00:00
|
|
|
}
|
|
|
|
|
2002-09-13 18:14:04 +00:00
|
|
|
free(dirptr);
|
2000-11-25 04:43:43 +00:00
|
|
|
return ret;
|
2000-11-24 14:00:16 +00:00
|
|
|
}
|
2000-11-05 17:54:41 +00:00
|
|
|
|
|
|
|
/*
|
2003-01-13 01:35:15 +00:00
|
|
|
* These functions (username_tab_completion(), cwd_tab_completion(), and
|
|
|
|
* input_tab()) were taken from busybox 0.46 (cmdedit.c). Here is the
|
2002-12-22 16:30:00 +00:00
|
|
|
* notice from that file:
|
2000-11-05 17:54:41 +00:00
|
|
|
*
|
|
|
|
* Termios command line History and Editting, originally
|
|
|
|
* intended for NetBSD sh (ash)
|
|
|
|
* Copyright (c) 1999
|
|
|
|
* Main code: Adam Rogoyski <rogoyski@cs.utexas.edu>
|
|
|
|
* Etc: Dave Cinege <dcinege@psychosis.com>
|
|
|
|
* Majorly adjusted/re-written for busybox:
|
|
|
|
* Erik Andersen <andersee@debian.org>
|
|
|
|
*
|
|
|
|
* You may use this code as you wish, so long as the original author(s)
|
|
|
|
* are attributed in any redistributions of the source code.
|
|
|
|
* This code is 'as is' with no warranty.
|
|
|
|
* This code may safely be consumed by a BSD or GPL license.
|
|
|
|
*/
|
|
|
|
|
|
|
|
char **username_tab_completion(char *buf, int *num_matches)
|
|
|
|
{
|
2002-12-22 16:30:00 +00:00
|
|
|
char **matches = (char **)NULL;
|
2001-01-19 04:17:24 +00:00
|
|
|
char *matchline = NULL;
|
2001-01-23 03:27:31 +00:00
|
|
|
struct passwd *userdata;
|
2000-11-24 14:00:16 +00:00
|
|
|
|
2001-01-19 04:17:24 +00:00
|
|
|
*num_matches = 0;
|
2001-01-02 06:21:07 +00:00
|
|
|
matches = nmalloc(BUFSIZ * sizeof(char *));
|
2001-01-19 04:17:24 +00:00
|
|
|
|
2000-11-24 14:00:16 +00:00
|
|
|
strcat(buf, "*");
|
2001-01-19 04:17:24 +00:00
|
|
|
|
2001-01-23 03:27:31 +00:00
|
|
|
while ((userdata = getpwent()) != NULL) {
|
2000-11-24 14:00:16 +00:00
|
|
|
|
2001-01-23 03:27:31 +00:00
|
|
|
if (check_wildcard_match(userdata->pw_name, &buf[1]) == TRUE) {
|
2000-11-24 14:00:16 +00:00
|
|
|
|
|
|
|
/* Cool, found a match. Add it to the list
|
|
|
|
* This makes a lot more sense to me (Chris) this way...
|
|
|
|
*/
|
2001-01-19 04:17:24 +00:00
|
|
|
|
2001-09-19 03:19:43 +00:00
|
|
|
#ifndef DISABLE_OPERATINGDIR
|
|
|
|
/* ...unless the match exists outside the operating
|
|
|
|
directory, in which case just go to the next match */
|
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
if (operating_dir != NULL) {
|
|
|
|
if (check_operating_dir(userdata->pw_dir, 1) != 0)
|
2001-09-19 03:19:43 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2001-05-17 11:35:43 +00:00
|
|
|
matchline = charalloc(strlen(userdata->pw_name) + 2);
|
2001-01-23 03:27:31 +00:00
|
|
|
sprintf(matchline, "~%s", userdata->pw_name);
|
|
|
|
matches[*num_matches] = matchline;
|
|
|
|
++*num_matches;
|
2000-11-24 14:00:16 +00:00
|
|
|
|
2001-01-23 03:27:31 +00:00
|
|
|
/* If there's no more room, bail out */
|
|
|
|
if (*num_matches == BUFSIZ)
|
|
|
|
break;
|
2000-11-24 14:00:16 +00:00
|
|
|
}
|
2001-01-23 03:27:31 +00:00
|
|
|
}
|
|
|
|
endpwent();
|
2001-01-19 04:17:24 +00:00
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
return matches;
|
2000-11-05 17:54:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* This was originally called exe_n_cwd_tab_completion, but we're not
|
|
|
|
worried about executables, only filenames :> */
|
|
|
|
|
|
|
|
char **cwd_tab_completion(char *buf, int *num_matches)
|
|
|
|
{
|
2002-07-20 13:57:41 +00:00
|
|
|
char *dirname, *dirtmp = NULL, *tmp = NULL, *tmp2 = NULL;
|
2002-12-22 16:30:00 +00:00
|
|
|
char **matches = (char **)NULL;
|
2000-11-05 17:54:41 +00:00
|
|
|
DIR *dir;
|
|
|
|
struct dirent *next;
|
|
|
|
|
2001-01-02 06:21:07 +00:00
|
|
|
matches = nmalloc(BUFSIZ * sizeof(char *));
|
2000-11-05 17:54:41 +00:00
|
|
|
|
|
|
|
/* Stick a wildcard onto the buf, for later use */
|
|
|
|
strcat(buf, "*");
|
|
|
|
|
2000-11-15 01:25:42 +00:00
|
|
|
/* Okie, if there's a / in the buffer, strip out the directory part */
|
2002-12-22 16:30:00 +00:00
|
|
|
if (buf[0] != '\0' && strstr(buf, "/") != NULL) {
|
2002-07-20 13:57:41 +00:00
|
|
|
dirname = charalloc(strlen(buf) + 1);
|
2000-11-05 17:54:41 +00:00
|
|
|
tmp = buf + strlen(buf);
|
|
|
|
while (*tmp != '/' && tmp != buf)
|
2000-11-14 18:25:26 +00:00
|
|
|
tmp--;
|
2000-11-14 17:46:06 +00:00
|
|
|
|
2000-11-05 17:54:41 +00:00
|
|
|
tmp++;
|
|
|
|
|
2002-07-20 13:57:41 +00:00
|
|
|
strncpy(dirname, buf, tmp - buf + 1);
|
|
|
|
dirname[tmp - buf] = '\0';
|
2000-11-14 17:46:06 +00:00
|
|
|
|
2000-11-05 17:54:41 +00:00
|
|
|
} else {
|
2001-04-03 01:02:38 +00:00
|
|
|
|
|
|
|
#ifdef PATH_MAX
|
2002-07-20 13:57:41 +00:00
|
|
|
if ((dirname = getcwd(NULL, PATH_MAX + 1)) == NULL)
|
2001-04-03 01:02:38 +00:00
|
|
|
#else
|
2001-05-05 17:45:54 +00:00
|
|
|
/* The better, but apparently segfault-causing way */
|
2002-07-20 13:57:41 +00:00
|
|
|
if ((dirname = getcwd(NULL, 0)) == NULL)
|
2001-04-03 01:02:38 +00:00
|
|
|
#endif /* PATH_MAX */
|
2000-11-05 17:54:41 +00:00
|
|
|
return matches;
|
|
|
|
else
|
|
|
|
tmp = buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
2002-07-20 13:57:41 +00:00
|
|
|
fprintf(stderr, "\nDir = %s\n", dirname);
|
2000-11-05 17:54:41 +00:00
|
|
|
fprintf(stderr, "\nbuf = %s\n", buf);
|
|
|
|
fprintf(stderr, "\ntmp = %s\n", tmp);
|
|
|
|
#endif
|
2000-11-14 18:25:26 +00:00
|
|
|
|
2002-07-20 13:57:41 +00:00
|
|
|
dirtmp = real_dir_from_tilde(dirname);
|
|
|
|
free(dirname);
|
|
|
|
dirname = dirtmp;
|
2000-11-24 14:00:16 +00:00
|
|
|
|
|
|
|
#ifdef DEBUG
|
2002-07-20 13:57:41 +00:00
|
|
|
fprintf(stderr, "\nDir = %s\n", dirname);
|
2000-11-24 14:00:16 +00:00
|
|
|
fprintf(stderr, "\nbuf = %s\n", buf);
|
|
|
|
fprintf(stderr, "\ntmp = %s\n", tmp);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2002-07-20 13:57:41 +00:00
|
|
|
dir = opendir(dirname);
|
2002-12-22 16:30:00 +00:00
|
|
|
if (dir == NULL) {
|
2000-11-05 17:54:41 +00:00
|
|
|
/* Don't print an error, just shut up and return */
|
|
|
|
*num_matches = 0;
|
|
|
|
beep();
|
2002-12-22 16:30:00 +00:00
|
|
|
return matches;
|
2000-11-05 17:54:41 +00:00
|
|
|
}
|
|
|
|
while ((next = readdir(dir)) != NULL) {
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
2000-11-15 01:25:42 +00:00
|
|
|
fprintf(stderr, "Comparing \'%s\'\n", next->d_name);
|
2000-11-05 17:54:41 +00:00
|
|
|
#endif
|
|
|
|
/* See if this matches */
|
|
|
|
if (check_wildcard_match(next->d_name, tmp) == TRUE) {
|
2000-11-06 04:04:15 +00:00
|
|
|
|
|
|
|
/* Cool, found a match. Add it to the list
|
|
|
|
* This makes a lot more sense to me (Chris) this way...
|
|
|
|
*/
|
2001-09-19 03:19:43 +00:00
|
|
|
|
|
|
|
#ifndef DISABLE_OPERATINGDIR
|
|
|
|
/* ...unless the match exists outside the operating
|
|
|
|
directory, in which case just go to the next match; to
|
|
|
|
properly do operating directory checking, we have to add the
|
|
|
|
directory name to the beginning of the proposed match
|
|
|
|
before we check it */
|
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
if (operating_dir != NULL) {
|
2002-07-20 13:57:41 +00:00
|
|
|
tmp2 = charalloc(strlen(dirname) + strlen(next->d_name) + 2);
|
|
|
|
strcpy(tmp2, dirname);
|
2001-09-19 03:19:43 +00:00
|
|
|
strcat(tmp2, "/");
|
|
|
|
strcat(tmp2, next->d_name);
|
|
|
|
if (check_operating_dir(tmp2, 1)) {
|
|
|
|
free(tmp2);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
free(tmp2);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2000-11-06 04:04:15 +00:00
|
|
|
tmp2 = NULL;
|
2001-05-17 11:35:43 +00:00
|
|
|
tmp2 = charalloc(strlen(next->d_name) + 1);
|
2000-11-06 04:04:15 +00:00
|
|
|
strcpy(tmp2, next->d_name);
|
|
|
|
matches[*num_matches] = tmp2;
|
2000-11-05 17:54:41 +00:00
|
|
|
++*num_matches;
|
2000-11-15 01:25:42 +00:00
|
|
|
|
|
|
|
/* If there's no more room, bail out */
|
|
|
|
if (*num_matches == BUFSIZ)
|
|
|
|
break;
|
2000-11-05 17:54:41 +00:00
|
|
|
}
|
|
|
|
}
|
2003-02-08 02:02:02 +00:00
|
|
|
closedir(dir);
|
|
|
|
free(dirname);
|
2000-11-05 17:54:41 +00:00
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
return matches;
|
2000-11-05 17:54:41 +00:00
|
|
|
}
|
|
|
|
|
2003-01-13 01:35:15 +00:00
|
|
|
/* This function now has an arg which refers to how much the statusbar
|
|
|
|
* (place) should be advanced, i.e. the new cursor pos. */
|
2002-06-13 00:40:19 +00:00
|
|
|
char *input_tab(char *buf, int place, int *lastwastab, int *newplace, int *list)
|
2000-11-05 17:54:41 +00:00
|
|
|
{
|
|
|
|
/* Do TAB completion */
|
2000-11-05 21:54:23 +00:00
|
|
|
static int num_matches = 0, match_matches = 0;
|
2002-12-22 16:30:00 +00:00
|
|
|
static char **matches = (char **)NULL;
|
2000-11-14 17:46:06 +00:00
|
|
|
int pos = place, i = 0, col = 0, editline = 0;
|
2000-11-25 04:43:43 +00:00
|
|
|
int longestname = 0, is_dir = 0;
|
2000-11-05 21:56:54 +00:00
|
|
|
char *foo;
|
2000-11-05 17:54:41 +00:00
|
|
|
|
2001-11-29 03:43:08 +00:00
|
|
|
*list = 0;
|
|
|
|
|
2002-06-13 00:40:19 +00:00
|
|
|
if (*lastwastab == FALSE) {
|
2002-12-22 16:30:00 +00:00
|
|
|
char *tmp, *copyto, *matchbuf;
|
2000-11-05 17:54:41 +00:00
|
|
|
|
2002-06-13 00:40:19 +00:00
|
|
|
*lastwastab = 1;
|
2000-11-14 18:25:26 +00:00
|
|
|
|
2000-11-05 17:54:41 +00:00
|
|
|
/* Make a local copy of the string -- up to the position of the
|
|
|
|
cursor */
|
2002-12-22 16:30:00 +00:00
|
|
|
matchbuf = (char *)nmalloc((strlen(buf) + 2) * sizeof(char));
|
|
|
|
memset(matchbuf, '\0', (strlen(buf) + 2));
|
2000-11-06 05:40:03 +00:00
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
strncpy(matchbuf, buf, place);
|
|
|
|
tmp = matchbuf;
|
2000-11-05 17:54:41 +00:00
|
|
|
|
|
|
|
/* skip any leading white space */
|
2002-12-22 16:30:00 +00:00
|
|
|
while (*tmp && isspace((int)*tmp))
|
2000-11-05 17:54:41 +00:00
|
|
|
++tmp;
|
|
|
|
|
|
|
|
/* Free up any memory already allocated */
|
|
|
|
if (matches != NULL) {
|
2000-11-14 17:46:06 +00:00
|
|
|
for (i = i; i < num_matches; i++)
|
|
|
|
free(matches[i]);
|
2000-11-05 17:54:41 +00:00
|
|
|
free(matches);
|
2002-12-22 16:30:00 +00:00
|
|
|
matches = (char **)NULL;
|
2000-11-06 04:04:15 +00:00
|
|
|
num_matches = 0;
|
2000-11-05 17:54:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* If the word starts with `~' and there is no slash in the word,
|
|
|
|
* then try completing this word as a username. */
|
|
|
|
|
2002-07-29 23:46:38 +00:00
|
|
|
/* If the original string begins with a tilde, and the part
|
|
|
|
we're trying to tab-complete doesn't contain a slash, copy
|
|
|
|
the part we're tab-completing into buf, so tab completion
|
|
|
|
will result in buf's containing only the tab-completed
|
|
|
|
username. */
|
2002-12-22 16:30:00 +00:00
|
|
|
if (buf[0] == '~' && strchr(tmp, '/') == NULL) {
|
2002-07-29 23:46:38 +00:00
|
|
|
buf = mallocstrcpy(buf, tmp);
|
2000-12-06 05:56:08 +00:00
|
|
|
matches = username_tab_completion(tmp, &num_matches);
|
2002-07-29 23:46:38 +00:00
|
|
|
}
|
2002-09-06 20:35:28 +00:00
|
|
|
/* If we're in the middle of the original line, copy the string
|
|
|
|
only up to the cursor position into buf, so tab completion
|
|
|
|
will result in buf's containing only the tab-completed
|
|
|
|
path/filename. */
|
|
|
|
else if (strlen(buf) > strlen(tmp))
|
|
|
|
buf = mallocstrcpy(buf, tmp);
|
2000-11-05 17:54:41 +00:00
|
|
|
|
|
|
|
/* Try to match everything in the current working directory that
|
|
|
|
* matches. */
|
2002-12-22 16:30:00 +00:00
|
|
|
if (matches == NULL)
|
2000-11-05 17:54:41 +00:00
|
|
|
matches = cwd_tab_completion(tmp, &num_matches);
|
|
|
|
|
|
|
|
/* Don't leak memory */
|
2002-12-22 16:30:00 +00:00
|
|
|
free(matchbuf);
|
2000-11-05 17:54:41 +00:00
|
|
|
|
2000-11-14 17:46:06 +00:00
|
|
|
#ifdef DEBUG
|
|
|
|
fprintf(stderr, "%d matches found...\n", num_matches);
|
|
|
|
#endif
|
2000-11-05 17:54:41 +00:00
|
|
|
/* Did we find exactly one match? */
|
2000-11-14 18:25:26 +00:00
|
|
|
switch (num_matches) {
|
2000-11-06 05:40:03 +00:00
|
|
|
case 0:
|
2000-11-06 05:41:20 +00:00
|
|
|
blank_edit();
|
2000-11-15 01:25:42 +00:00
|
|
|
wrefresh(edit);
|
2000-11-06 05:40:03 +00:00
|
|
|
break;
|
|
|
|
case 1:
|
2000-11-14 17:46:06 +00:00
|
|
|
|
|
|
|
buf = nrealloc(buf, strlen(buf) + strlen(matches[0]) + 1);
|
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
if (buf[0] != '\0' && strstr(buf, "/") != NULL) {
|
2000-11-14 18:25:26 +00:00
|
|
|
for (tmp = buf + strlen(buf); *tmp != '/' && tmp != buf;
|
|
|
|
tmp--);
|
2000-11-14 17:46:06 +00:00
|
|
|
tmp++;
|
2000-11-14 18:25:26 +00:00
|
|
|
} else
|
2000-11-14 17:46:06 +00:00
|
|
|
tmp = buf;
|
|
|
|
|
2000-11-25 04:43:43 +00:00
|
|
|
if (!strcmp(tmp, matches[0]))
|
2002-06-13 00:40:19 +00:00
|
|
|
is_dir = append_slash_if_dir(buf, lastwastab, newplace);
|
2000-11-25 04:43:43 +00:00
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
if (is_dir != 0)
|
2000-11-25 04:43:43 +00:00
|
|
|
break;
|
2000-11-14 17:46:06 +00:00
|
|
|
|
|
|
|
copyto = tmp;
|
2000-11-14 18:25:26 +00:00
|
|
|
for (pos = 0; *tmp == matches[0][pos] &&
|
|
|
|
pos <= strlen(matches[0]); pos++)
|
2000-11-14 17:46:06 +00:00
|
|
|
tmp++;
|
|
|
|
|
2000-11-15 01:25:42 +00:00
|
|
|
/* write out the matched name */
|
2000-11-14 18:25:26 +00:00
|
|
|
strncpy(copyto, matches[0], strlen(matches[0]) + 1);
|
2000-11-14 17:46:06 +00:00
|
|
|
*newplace += strlen(matches[0]) - pos;
|
|
|
|
|
2001-09-19 03:19:43 +00:00
|
|
|
/* if an exact match is typed in and Tab is pressed,
|
|
|
|
*newplace will now be negative; in that case, make it
|
|
|
|
zero, so that the cursor will stay where it is instead of
|
|
|
|
moving backward */
|
|
|
|
if (*newplace < 0)
|
|
|
|
*newplace = 0;
|
|
|
|
|
2000-11-24 14:00:16 +00:00
|
|
|
/* Is it a directory? */
|
2002-06-13 00:40:19 +00:00
|
|
|
append_slash_if_dir(buf, lastwastab, newplace);
|
2000-11-24 14:00:16 +00:00
|
|
|
|
2000-11-06 05:40:03 +00:00
|
|
|
break;
|
|
|
|
default:
|
2001-05-05 17:45:54 +00:00
|
|
|
/* Check to see if all matches share a beginning, and, if so,
|
2000-11-14 18:25:26 +00:00
|
|
|
tack it onto buf and then beep */
|
2000-11-05 21:54:23 +00:00
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
if (buf[0] != '\0' && strstr(buf, "/") != NULL) {
|
2000-11-14 18:25:26 +00:00
|
|
|
for (tmp = buf + strlen(buf); *tmp != '/' && tmp != buf;
|
|
|
|
tmp--);
|
2000-11-14 17:46:06 +00:00
|
|
|
tmp++;
|
2000-11-14 18:25:26 +00:00
|
|
|
} else
|
2000-11-14 17:46:06 +00:00
|
|
|
tmp = buf;
|
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
for (pos = 0; *tmp == matches[0][pos] && *tmp != '\0' &&
|
2000-11-14 18:25:26 +00:00
|
|
|
pos <= strlen(matches[0]); pos++)
|
2000-11-14 17:46:06 +00:00
|
|
|
tmp++;
|
|
|
|
|
2000-11-05 21:54:23 +00:00
|
|
|
while (1) {
|
|
|
|
match_matches = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < num_matches; i++) {
|
|
|
|
if (matches[i][pos] == 0)
|
|
|
|
break;
|
|
|
|
else if (matches[i][pos] == matches[0][pos])
|
|
|
|
match_matches++;
|
|
|
|
}
|
2000-11-14 18:25:26 +00:00
|
|
|
if (match_matches == num_matches &&
|
|
|
|
(i == num_matches || matches[i] != 0)) {
|
2000-11-05 21:54:23 +00:00
|
|
|
/* All the matches have the same character at pos+1,
|
2000-11-14 18:25:26 +00:00
|
|
|
so paste it into buf... */
|
2000-11-05 22:48:35 +00:00
|
|
|
buf = nrealloc(buf, strlen(buf) + 2);
|
2000-11-14 17:46:06 +00:00
|
|
|
strncat(buf, matches[0] + pos, 1);
|
2000-11-14 18:25:26 +00:00
|
|
|
*newplace += 1;
|
2000-11-05 21:54:23 +00:00
|
|
|
pos++;
|
2000-11-05 22:48:35 +00:00
|
|
|
} else {
|
2000-11-05 21:54:23 +00:00
|
|
|
beep();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2000-11-06 05:40:03 +00:00
|
|
|
break;
|
2000-11-05 21:54:23 +00:00
|
|
|
}
|
2000-11-05 17:54:41 +00:00
|
|
|
} else {
|
|
|
|
/* Ok -- the last char was a TAB. Since they
|
|
|
|
* just hit TAB again, print a list of all the
|
|
|
|
* available choices... */
|
2002-12-22 16:30:00 +00:00
|
|
|
if (matches != NULL && num_matches > 1) {
|
2000-11-05 17:54:41 +00:00
|
|
|
|
|
|
|
/* Blank the edit window, and print the matches out there */
|
|
|
|
blank_edit();
|
|
|
|
wmove(edit, 0, 0);
|
|
|
|
|
2000-11-05 21:54:23 +00:00
|
|
|
editline = 0;
|
2000-11-15 01:25:42 +00:00
|
|
|
|
2000-11-05 21:54:23 +00:00
|
|
|
/* Figure out the length of the longest filename */
|
|
|
|
for (i = 0; i < num_matches; i++)
|
|
|
|
if (strlen(matches[i]) > longestname)
|
|
|
|
longestname = strlen(matches[i]);
|
|
|
|
|
|
|
|
if (longestname > COLS - 1)
|
|
|
|
longestname = COLS - 1;
|
|
|
|
|
2001-05-17 11:35:43 +00:00
|
|
|
foo = charalloc(longestname + 5);
|
2000-11-05 21:56:54 +00:00
|
|
|
|
2000-11-05 17:54:41 +00:00
|
|
|
/* Print the list of matches */
|
|
|
|
for (i = 0, col = 0; i < num_matches; i++) {
|
2000-11-14 18:25:26 +00:00
|
|
|
|
2000-11-05 21:54:23 +00:00
|
|
|
/* make each filename shown be the same length as the longest
|
2000-11-14 18:25:26 +00:00
|
|
|
filename, with two spaces at the end */
|
2000-11-05 21:54:23 +00:00
|
|
|
snprintf(foo, longestname + 1, matches[i]);
|
|
|
|
while (strlen(foo) < longestname)
|
|
|
|
strcat(foo, " ");
|
|
|
|
|
|
|
|
strcat(foo, " ");
|
|
|
|
|
2000-11-14 17:46:06 +00:00
|
|
|
/* Disable el cursor */
|
|
|
|
curs_set(0);
|
2000-11-05 22:48:35 +00:00
|
|
|
/* now, put the match on the screen */
|
|
|
|
waddnstr(edit, foo, strlen(foo));
|
|
|
|
col += strlen(foo);
|
|
|
|
|
|
|
|
/* And if the next match isn't going to fit on the
|
|
|
|
line, move to the next one */
|
2003-02-08 02:02:02 +00:00
|
|
|
if (col > COLS - longestname && i + 1 < num_matches) {
|
2000-11-05 21:54:23 +00:00
|
|
|
editline++;
|
|
|
|
wmove(edit, editline, 0);
|
2000-11-14 18:25:26 +00:00
|
|
|
if (editline == editwinrows - 1) {
|
|
|
|
waddstr(edit, _("(more)"));
|
|
|
|
break;
|
|
|
|
}
|
2000-11-05 17:54:41 +00:00
|
|
|
col = 0;
|
|
|
|
}
|
|
|
|
}
|
2000-11-05 21:56:54 +00:00
|
|
|
free(foo);
|
2000-11-05 17:54:41 +00:00
|
|
|
wrefresh(edit);
|
2001-11-29 03:43:08 +00:00
|
|
|
*list = 1;
|
2000-11-06 05:45:48 +00:00
|
|
|
} else
|
|
|
|
beep();
|
2000-11-05 17:54:41 +00:00
|
|
|
}
|
|
|
|
|
2001-11-29 03:43:08 +00:00
|
|
|
/* Only refresh the edit window if we don't have a list of filename
|
|
|
|
matches on it */
|
|
|
|
if (*list == 0)
|
|
|
|
edit_refresh();
|
2000-11-14 17:46:06 +00:00
|
|
|
curs_set(1);
|
|
|
|
return buf;
|
2000-11-05 17:54:41 +00:00
|
|
|
}
|
2002-09-13 18:14:04 +00:00
|
|
|
#endif /* !DISABLE_TABCOMP */
|
2001-01-03 07:11:47 +00:00
|
|
|
|
2001-01-12 07:51:05 +00:00
|
|
|
#ifndef DISABLE_BROWSER
|
2001-01-03 07:11:47 +00:00
|
|
|
/* Return the stat of the file pointed to by path */
|
2002-07-20 13:57:41 +00:00
|
|
|
struct stat filestat(const char *path)
|
|
|
|
{
|
2001-01-03 07:11:47 +00:00
|
|
|
struct stat st;
|
|
|
|
|
2001-03-28 13:04:08 +00:00
|
|
|
stat(path, &st);
|
2001-01-03 07:11:47 +00:00
|
|
|
return st;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Our sort routine for file listings - sort directories before
|
2002-09-13 18:14:04 +00:00
|
|
|
* files, and then alphabetically. */
|
2002-07-20 13:57:41 +00:00
|
|
|
int diralphasort(const void *va, const void *vb)
|
|
|
|
{
|
2002-09-13 18:14:04 +00:00
|
|
|
struct stat fileinfo;
|
|
|
|
const char *a = *(char *const *)va, *b = *(char *const *)vb;
|
|
|
|
int aisdir = stat(a, &fileinfo) != -1 && S_ISDIR(fileinfo.st_mode);
|
|
|
|
int bisdir = stat(b, &fileinfo) != -1 && S_ISDIR(fileinfo.st_mode);
|
2001-01-03 07:11:47 +00:00
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
if (aisdir != 0 && bisdir == 0)
|
2002-09-13 18:14:04 +00:00
|
|
|
return -1;
|
2002-12-22 16:30:00 +00:00
|
|
|
if (aisdir == 0 && bisdir != 0)
|
2002-09-13 18:14:04 +00:00
|
|
|
return 1;
|
2001-04-03 01:02:38 +00:00
|
|
|
|
2002-09-13 18:14:04 +00:00
|
|
|
return strcasecmp(a, b);
|
2001-01-03 07:11:47 +00:00
|
|
|
}
|
|
|
|
|
2001-05-05 17:45:54 +00:00
|
|
|
/* Free our malloc()ed memory */
|
2001-01-03 07:11:47 +00:00
|
|
|
void free_charptrarray(char **array, int len)
|
|
|
|
{
|
2002-09-13 18:14:04 +00:00
|
|
|
for (; len > 0; len--)
|
|
|
|
free(array[len - 1]);
|
2001-01-03 07:11:47 +00:00
|
|
|
free(array);
|
|
|
|
}
|
|
|
|
|
2002-09-13 18:14:04 +00:00
|
|
|
/* Only print the last part of a path; isn't there a shell
|
|
|
|
* command for this? */
|
|
|
|
const char *tail(const char *foo)
|
2001-01-03 07:11:47 +00:00
|
|
|
{
|
2002-09-13 18:14:04 +00:00
|
|
|
const char *tmp = foo + strlen(foo);
|
2001-01-03 07:11:47 +00:00
|
|
|
|
|
|
|
while (*tmp != '/' && tmp != foo)
|
|
|
|
tmp--;
|
|
|
|
|
2002-09-13 18:14:04 +00:00
|
|
|
if (*tmp == '/')
|
|
|
|
tmp++;
|
2001-01-03 07:11:47 +00:00
|
|
|
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
2002-09-13 18:14:04 +00:00
|
|
|
/* Strip one dir from the end of a string. */
|
2001-01-03 07:11:47 +00:00
|
|
|
void striponedir(char *foo)
|
|
|
|
{
|
2002-09-13 18:14:04 +00:00
|
|
|
char *tmp;
|
2001-01-03 07:11:47 +00:00
|
|
|
|
2003-02-12 23:49:56 +00:00
|
|
|
assert(foo != NULL);
|
2001-01-03 07:11:47 +00:00
|
|
|
/* Don't strip the root dir */
|
2003-02-12 23:49:56 +00:00
|
|
|
if (*foo == '\0' || strcmp(foo, "/") == 0)
|
2001-01-03 07:11:47 +00:00
|
|
|
return;
|
|
|
|
|
2003-02-12 23:49:56 +00:00
|
|
|
tmp = foo + strlen(foo) - 1;
|
|
|
|
assert(tmp >= foo);
|
2001-01-03 07:11:47 +00:00
|
|
|
if (*tmp == '/')
|
2003-02-12 23:49:56 +00:00
|
|
|
*tmp = '\0';
|
2001-01-03 07:11:47 +00:00
|
|
|
|
|
|
|
while (*tmp != '/' && tmp != foo)
|
|
|
|
tmp--;
|
|
|
|
|
|
|
|
if (tmp != foo)
|
2002-09-13 18:14:04 +00:00
|
|
|
*tmp = '\0';
|
|
|
|
else { /* SPK may need to make a 'default' path here */
|
|
|
|
if (*tmp != '/')
|
|
|
|
*tmp = '.';
|
|
|
|
*(tmp + 1) = '\0';
|
2002-02-27 04:14:16 +00:00
|
|
|
}
|
2001-01-03 07:11:47 +00:00
|
|
|
}
|
|
|
|
|
2003-01-30 00:53:32 +00:00
|
|
|
int readable_dir(const char *path)
|
|
|
|
{
|
|
|
|
DIR *dir = opendir(path);
|
|
|
|
|
|
|
|
/* If dir is NULL, don't do closedir(), since that changes errno. */
|
|
|
|
if (dir != NULL)
|
|
|
|
closedir(dir);
|
|
|
|
return dir != NULL;
|
|
|
|
}
|
|
|
|
|
2002-09-06 20:35:28 +00:00
|
|
|
/* Initialize the browser code, including the list of files in *path */
|
2002-09-13 18:14:04 +00:00
|
|
|
char **browser_init(const char *path, int *longest, int *numents)
|
2002-09-06 20:35:28 +00:00
|
|
|
{
|
|
|
|
DIR *dir;
|
|
|
|
struct dirent *next;
|
2002-09-13 18:14:04 +00:00
|
|
|
char **filelist;
|
2002-09-06 20:35:28 +00:00
|
|
|
int i = 0;
|
2002-09-13 18:14:04 +00:00
|
|
|
size_t path_len;
|
2002-09-06 20:35:28 +00:00
|
|
|
|
|
|
|
dir = opendir(path);
|
2002-12-22 16:30:00 +00:00
|
|
|
if (dir == NULL)
|
2002-09-06 20:35:28 +00:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
*numents = 0;
|
|
|
|
while ((next = readdir(dir)) != NULL) {
|
|
|
|
if (!strcmp(next->d_name, "."))
|
|
|
|
continue;
|
|
|
|
(*numents)++;
|
|
|
|
if (strlen(next->d_name) > *longest)
|
|
|
|
*longest = strlen(next->d_name);
|
|
|
|
}
|
|
|
|
rewinddir(dir);
|
|
|
|
*longest += 10;
|
|
|
|
|
|
|
|
filelist = nmalloc(*numents * sizeof (char *));
|
|
|
|
|
2002-09-13 18:14:04 +00:00
|
|
|
if (!strcmp(path, "/"))
|
|
|
|
path = "";
|
|
|
|
path_len = strlen(path);
|
|
|
|
|
2002-09-06 20:35:28 +00:00
|
|
|
while ((next = readdir(dir)) != NULL) {
|
|
|
|
if (!strcmp(next->d_name, "."))
|
|
|
|
continue;
|
|
|
|
|
2002-09-13 18:14:04 +00:00
|
|
|
filelist[i] = charalloc(strlen(next->d_name) + path_len + 2);
|
|
|
|
sprintf(filelist[i], "%s/%s", path, next->d_name);
|
2002-09-06 20:35:28 +00:00
|
|
|
i++;
|
|
|
|
}
|
2003-02-12 23:49:56 +00:00
|
|
|
closedir(dir);
|
2002-09-06 20:35:28 +00:00
|
|
|
|
|
|
|
if (*longest > COLS - 1)
|
|
|
|
*longest = COLS - 1;
|
|
|
|
|
|
|
|
return filelist;
|
|
|
|
}
|
|
|
|
|
2001-01-04 04:59:17 +00:00
|
|
|
/* Our browser function. inpath is the path to start browsing from */
|
2002-09-13 18:14:04 +00:00
|
|
|
char *do_browser(const char *inpath)
|
2001-01-03 07:11:47 +00:00
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
char *foo, *retval = NULL;
|
|
|
|
static char *path = NULL;
|
|
|
|
int numents = 0, i = 0, j = 0, kbinput = 0, longest = 0, abort = 0;
|
|
|
|
int col = 0, selected = 0, editline = 0, width = 0, filecols = 0;
|
2001-01-06 18:12:43 +00:00
|
|
|
int lineno = 0, kb;
|
2002-12-22 16:30:00 +00:00
|
|
|
char **filelist = (char **)NULL;
|
|
|
|
#if !defined(DISABLE_MOUSE) && defined(NCURSES_MOUSE_VERSION)
|
2001-05-05 23:17:36 +00:00
|
|
|
MEVENT mevent;
|
|
|
|
#endif
|
2001-01-03 07:11:47 +00:00
|
|
|
|
2002-09-13 18:14:04 +00:00
|
|
|
assert(inpath != NULL);
|
|
|
|
|
2001-01-04 04:59:17 +00:00
|
|
|
/* If path isn't the same as inpath, we are being passed a new
|
|
|
|
dir as an arg. We free it here so it will be copied from
|
|
|
|
inpath below */
|
2001-01-03 07:11:47 +00:00
|
|
|
if (path != NULL && strcmp(path, inpath)) {
|
|
|
|
free(path);
|
|
|
|
path = NULL;
|
|
|
|
}
|
|
|
|
|
2001-01-04 04:59:17 +00:00
|
|
|
/* if path doesn't exist, make it so */
|
2001-01-03 07:11:47 +00:00
|
|
|
if (path == NULL)
|
2002-09-13 18:14:04 +00:00
|
|
|
path = mallocstrcpy(NULL, inpath);
|
2001-01-03 07:11:47 +00:00
|
|
|
|
|
|
|
filelist = browser_init(path, &longest, &numents);
|
2001-05-17 11:35:43 +00:00
|
|
|
foo = charalloc(longest + 8);
|
2001-01-04 04:59:17 +00:00
|
|
|
|
2001-05-05 17:45:54 +00:00
|
|
|
/* Sort the list by directory first, then alphabetically */
|
2001-01-03 07:11:47 +00:00
|
|
|
qsort(filelist, numents, sizeof(char *), diralphasort);
|
|
|
|
|
2001-01-06 18:12:43 +00:00
|
|
|
kb = keypad_on(edit, 1);
|
2001-01-03 07:11:47 +00:00
|
|
|
titlebar(path);
|
2002-02-15 19:17:02 +00:00
|
|
|
bottombars(browser_list);
|
2001-01-03 07:11:47 +00:00
|
|
|
curs_set(0);
|
|
|
|
wmove(edit, 0, 0);
|
|
|
|
i = 0;
|
|
|
|
width = 0;
|
|
|
|
filecols = 0;
|
2001-01-04 04:59:17 +00:00
|
|
|
|
|
|
|
/* Loop invariant: Microsoft sucks. */
|
2001-01-03 07:11:47 +00:00
|
|
|
do {
|
2003-01-30 00:57:33 +00:00
|
|
|
char *new_path;
|
|
|
|
/* Used by the Go To Directory prompt. */
|
2001-04-14 06:50:24 +00:00
|
|
|
|
|
|
|
blank_statusbar_refresh();
|
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
#if !defined(DISABLE_HELP) || (!defined(DISABLE_MOUSE) && defined(NCURSES_MOUSE_VERSION))
|
2001-05-07 12:08:37 +00:00
|
|
|
currshortcut = browser_list;
|
2001-05-21 12:56:25 +00:00
|
|
|
#endif
|
|
|
|
|
2001-01-03 07:11:47 +00:00
|
|
|
editline = 0;
|
|
|
|
col = 0;
|
2001-01-04 05:20:23 +00:00
|
|
|
|
2001-05-05 17:45:54 +00:00
|
|
|
/* Compute line number we're on now, so we don't divide by zero later */
|
2002-07-24 01:02:26 +00:00
|
|
|
lineno = selected;
|
|
|
|
if (width != 0)
|
|
|
|
lineno /= width;
|
2001-01-03 07:11:47 +00:00
|
|
|
|
|
|
|
switch (kbinput) {
|
2001-04-12 03:01:53 +00:00
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
#if !defined(DISABLE_MOUSE) && defined(NCURSES_MOUSE_VERSION)
|
2002-07-24 01:02:26 +00:00
|
|
|
case KEY_MOUSE:
|
2001-05-05 23:17:36 +00:00
|
|
|
if (getmouse(&mevent) == ERR)
|
2002-07-24 01:02:26 +00:00
|
|
|
return retval;
|
2001-05-05 23:17:36 +00:00
|
|
|
|
|
|
|
/* If they clicked in the edit window, they probably clicked
|
|
|
|
on a file */
|
2002-07-24 01:02:26 +00:00
|
|
|
if (wenclose(edit, mevent.y, mevent.x)) {
|
2001-05-05 23:17:36 +00:00
|
|
|
int selectedbackup = selected;
|
|
|
|
|
|
|
|
mevent.y -= 2;
|
|
|
|
|
2002-07-24 01:02:26 +00:00
|
|
|
/* Longest is the width of each column. There are two
|
|
|
|
* spaces between each column. */
|
2002-12-22 16:30:00 +00:00
|
|
|
selected = (lineno / editwinrows) * editwinrows * width
|
2002-07-24 01:02:26 +00:00
|
|
|
+ mevent.y * width + mevent.x / (longest + 2);
|
|
|
|
|
|
|
|
/* If they clicked beyond the end of a row, select the
|
|
|
|
* end of that row. */
|
|
|
|
if (mevent.x > width * (longest + 2))
|
|
|
|
selected--;
|
2001-05-05 23:17:36 +00:00
|
|
|
|
|
|
|
/* If we're off the screen, reset to the last item.
|
|
|
|
If we clicked where we did last time, select this name! */
|
2001-05-06 03:02:21 +00:00
|
|
|
if (selected > numents - 1)
|
2001-05-05 23:17:36 +00:00
|
|
|
selected = numents - 1;
|
2002-07-24 01:02:26 +00:00
|
|
|
else if (selectedbackup == selected)
|
2001-05-05 23:17:36 +00:00
|
|
|
ungetch('s'); /* Unget the 'select' key */
|
|
|
|
} else /* Must be clicking a shortcut */
|
|
|
|
do_mouse();
|
|
|
|
|
2001-04-12 03:01:53 +00:00
|
|
|
break;
|
|
|
|
#endif
|
2001-07-02 01:31:44 +00:00
|
|
|
case NANO_UP_KEY:
|
2001-01-03 07:11:47 +00:00
|
|
|
case KEY_UP:
|
|
|
|
case 'u':
|
|
|
|
if (selected - width >= 0)
|
|
|
|
selected -= width;
|
|
|
|
break;
|
2001-07-02 01:31:44 +00:00
|
|
|
case NANO_BACK_KEY:
|
2001-01-03 07:11:47 +00:00
|
|
|
case KEY_LEFT:
|
2001-07-02 01:31:44 +00:00
|
|
|
case NANO_BACKSPACE_KEY:
|
|
|
|
case 127:
|
2001-01-03 07:11:47 +00:00
|
|
|
case 'l':
|
|
|
|
if (selected > 0)
|
|
|
|
selected--;
|
|
|
|
break;
|
|
|
|
case KEY_DOWN:
|
2001-07-02 01:31:44 +00:00
|
|
|
case NANO_DOWN_KEY:
|
2001-01-03 07:11:47 +00:00
|
|
|
case 'd':
|
|
|
|
if (selected + width <= numents - 1)
|
|
|
|
selected += width;
|
|
|
|
break;
|
|
|
|
case KEY_RIGHT:
|
2001-07-02 01:31:44 +00:00
|
|
|
case NANO_FORWARD_KEY:
|
2001-01-03 07:11:47 +00:00
|
|
|
case 'r':
|
|
|
|
if (selected < numents - 1)
|
|
|
|
selected++;
|
|
|
|
break;
|
|
|
|
case NANO_PREVPAGE_KEY:
|
2001-01-04 04:41:08 +00:00
|
|
|
case NANO_PREVPAGE_FKEY:
|
2001-01-03 07:11:47 +00:00
|
|
|
case KEY_PPAGE:
|
2001-01-08 21:14:04 +00:00
|
|
|
case '-':
|
2002-07-24 01:02:26 +00:00
|
|
|
if (selected >= (editwinrows + lineno % editwinrows) * width)
|
2001-01-04 05:20:23 +00:00
|
|
|
selected -= (editwinrows + lineno % editwinrows) * width;
|
2001-01-03 07:11:47 +00:00
|
|
|
else
|
|
|
|
selected = 0;
|
|
|
|
break;
|
|
|
|
case NANO_NEXTPAGE_KEY:
|
2001-01-04 04:41:08 +00:00
|
|
|
case NANO_NEXTPAGE_FKEY:
|
2001-01-03 07:11:47 +00:00
|
|
|
case KEY_NPAGE:
|
2001-01-08 21:14:04 +00:00
|
|
|
case ' ':
|
2002-07-24 01:02:26 +00:00
|
|
|
selected += (editwinrows - lineno % editwinrows) * width;
|
|
|
|
if (selected >= numents)
|
2001-01-03 07:11:47 +00:00
|
|
|
selected = numents - 1;
|
|
|
|
break;
|
2001-10-22 03:15:31 +00:00
|
|
|
case NANO_HELP_KEY:
|
|
|
|
case NANO_HELP_FKEY:
|
|
|
|
do_help();
|
|
|
|
break;
|
2001-01-03 07:11:47 +00:00
|
|
|
case KEY_ENTER:
|
2001-07-02 01:31:44 +00:00
|
|
|
case NANO_ENTER_KEY:
|
2001-01-04 05:22:46 +00:00
|
|
|
case 's': /* More Pico compatibility */
|
|
|
|
case 'S':
|
2001-01-04 04:59:17 +00:00
|
|
|
/* You can't cd up from / */
|
2001-04-14 06:50:24 +00:00
|
|
|
if (!strcmp(filelist[selected], "/..") && !strcmp(path, "/")) {
|
2001-01-03 07:11:47 +00:00
|
|
|
statusbar(_("Can't move up a directory"));
|
2003-02-03 03:39:05 +00:00
|
|
|
beep();
|
2001-04-14 06:50:24 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2001-09-19 03:19:43 +00:00
|
|
|
#ifndef DISABLE_OPERATINGDIR
|
2003-02-03 03:39:05 +00:00
|
|
|
/*
|
|
|
|
* Note: the selected file can be outside the operating
|
|
|
|
* directory if it is .. or if it is a symlink to a directory
|
|
|
|
* outside the opdir. */
|
|
|
|
if (check_operating_dir(filelist[selected], FALSE)) {
|
|
|
|
statusbar(_("Can't go outside of %s in restricted mode"), operating_dir);
|
|
|
|
beep();
|
|
|
|
break;
|
2001-09-19 03:19:43 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2003-02-03 03:39:05 +00:00
|
|
|
if (stat(filelist[selected], &st) == -1) {
|
|
|
|
statusbar(_("Can't open \"%s\": %s"), filelist[selected], strerror(errno));
|
|
|
|
beep();
|
|
|
|
break;
|
|
|
|
}
|
2003-01-26 22:05:07 +00:00
|
|
|
|
2003-02-03 03:39:05 +00:00
|
|
|
if (!S_ISDIR(st.st_mode)) {
|
|
|
|
retval = mallocstrcpy(retval, filelist[selected]);
|
|
|
|
abort = 1;
|
|
|
|
break;
|
2002-02-27 04:14:16 +00:00
|
|
|
}
|
|
|
|
|
2003-02-03 03:39:05 +00:00
|
|
|
new_path = mallocstrcpy(NULL, filelist[selected]);
|
|
|
|
|
|
|
|
if (strcmp("..", tail(new_path)) == 0) {
|
|
|
|
/* They want to go up a level, so strip off .. and the
|
|
|
|
current dir */
|
|
|
|
striponedir(new_path);
|
|
|
|
/* SPK for '.' path, get the current path via getcwd */
|
|
|
|
if (strcmp(new_path, ".") == 0) {
|
|
|
|
free(new_path);
|
|
|
|
new_path = getcwd(NULL, PATH_MAX + 1);
|
2001-01-03 07:11:47 +00:00
|
|
|
}
|
2003-02-03 03:39:05 +00:00
|
|
|
striponedir(new_path);
|
|
|
|
}
|
2001-01-04 04:59:17 +00:00
|
|
|
|
2003-02-03 03:39:05 +00:00
|
|
|
if (!readable_dir(new_path)) {
|
|
|
|
/* We can't open this dir for some reason. Complain */
|
|
|
|
statusbar(_("Can't open \"%s\": %s"), new_path, strerror(errno));
|
|
|
|
free(new_path);
|
|
|
|
break;
|
2001-01-03 07:11:47 +00:00
|
|
|
}
|
2003-02-03 03:39:05 +00:00
|
|
|
|
|
|
|
free_charptrarray(filelist, numents);
|
|
|
|
free(foo);
|
|
|
|
free(path);
|
|
|
|
path = new_path;
|
|
|
|
return do_browser(path);
|
|
|
|
|
2001-04-14 06:50:24 +00:00
|
|
|
/* Goto a specific directory */
|
|
|
|
case 'g': /* Pico compatibility */
|
|
|
|
case 'G':
|
|
|
|
case NANO_GOTO_KEY:
|
|
|
|
|
|
|
|
curs_set(1);
|
2003-01-13 01:35:15 +00:00
|
|
|
j = statusq(0, gotodir_list, "",
|
|
|
|
#ifndef NANO_SMALL
|
|
|
|
0,
|
|
|
|
#endif
|
|
|
|
_("Goto Directory"));
|
2002-02-15 19:17:02 +00:00
|
|
|
bottombars(browser_list);
|
2001-04-14 06:50:24 +00:00
|
|
|
curs_set(0);
|
|
|
|
|
|
|
|
if (j < 0) {
|
|
|
|
statusbar(_("Goto Cancelled"));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2003-01-30 00:57:33 +00:00
|
|
|
new_path = real_dir_from_tilde(answer);
|
2001-04-14 06:50:24 +00:00
|
|
|
|
2003-01-30 00:57:33 +00:00
|
|
|
if (new_path[0] != '/') {
|
|
|
|
new_path = charealloc(new_path, strlen(path) + strlen(answer) + 2);
|
|
|
|
sprintf(new_path, "%s/%s", path, answer);
|
2001-04-14 06:50:24 +00:00
|
|
|
}
|
|
|
|
|
2003-01-30 00:57:33 +00:00
|
|
|
#ifndef DISABLE_OPERATINGDIR
|
|
|
|
if (check_operating_dir(new_path, FALSE)) {
|
|
|
|
statusbar(_("Can't go outside of %s in restricted mode"), operating_dir);
|
|
|
|
free(new_path);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (!readable_dir(new_path)) {
|
2001-04-14 06:50:24 +00:00
|
|
|
/* We can't open this dir for some reason. Complain */
|
|
|
|
statusbar(_("Can't open \"%s\": %s"), answer, strerror(errno));
|
2003-01-30 00:57:33 +00:00
|
|
|
free(new_path);
|
2001-04-14 06:50:24 +00:00
|
|
|
break;
|
2003-01-30 00:57:33 +00:00
|
|
|
}
|
2001-04-14 06:50:24 +00:00
|
|
|
|
|
|
|
/* Start over again with the new path value */
|
2003-02-12 02:52:04 +00:00
|
|
|
free_charptrarray(filelist, numents);
|
|
|
|
free(foo);
|
2003-01-30 00:57:33 +00:00
|
|
|
free(path);
|
|
|
|
path = new_path;
|
2001-04-14 06:50:24 +00:00
|
|
|
return do_browser(path);
|
|
|
|
|
2001-01-03 07:11:47 +00:00
|
|
|
/* Stuff we want to abort the browser */
|
|
|
|
case 'q':
|
|
|
|
case 'Q':
|
|
|
|
case 'e': /* Pico compatibility, yeech */
|
|
|
|
case 'E':
|
2001-07-02 01:31:44 +00:00
|
|
|
case NANO_CANCEL_KEY:
|
2001-01-04 04:41:08 +00:00
|
|
|
case NANO_EXIT_FKEY:
|
2002-07-24 01:02:26 +00:00
|
|
|
abort = 1;
|
|
|
|
break;
|
2001-01-03 07:11:47 +00:00
|
|
|
}
|
|
|
|
if (abort)
|
|
|
|
break;
|
|
|
|
|
2001-04-14 06:50:24 +00:00
|
|
|
blank_edit();
|
|
|
|
|
2002-12-22 16:30:00 +00:00
|
|
|
if (width != 0)
|
2001-01-03 07:11:47 +00:00
|
|
|
i = width * editwinrows * ((selected / width) / editwinrows);
|
|
|
|
else
|
|
|
|
i = 0;
|
|
|
|
|
|
|
|
wmove(edit, 0, 0);
|
|
|
|
for (j = i; j < numents && editline <= editwinrows - 1; j++) {
|
|
|
|
filecols++;
|
|
|
|
|
|
|
|
strncpy(foo, tail(filelist[j]), strlen(tail(filelist[j])) + 1);
|
|
|
|
while (strlen(foo) < longest)
|
|
|
|
strcat(foo, " ");
|
|
|
|
col += strlen(foo);
|
|
|
|
|
|
|
|
/* Put file info in the string also */
|
2001-05-05 17:45:54 +00:00
|
|
|
/* We use lstat here to detect links; then, if we find a
|
|
|
|
symlink, we examine it via stat() to see if it is a
|
2001-03-28 13:04:08 +00:00
|
|
|
directory or just a file symlink */
|
|
|
|
lstat(filelist[j], &st);
|
2001-01-03 07:11:47 +00:00
|
|
|
if (S_ISDIR(st.st_mode))
|
|
|
|
strcpy(foo + longest - 5, "(dir)");
|
|
|
|
else {
|
2001-03-28 13:04:08 +00:00
|
|
|
if (S_ISLNK(st.st_mode)) {
|
|
|
|
/* Aha! It's a symlink! Now, is it a dir? If so,
|
|
|
|
mark it as such */
|
|
|
|
st = filestat(filelist[j]);
|
|
|
|
if (S_ISDIR(st.st_mode))
|
|
|
|
strcpy(foo + longest - 5, "(dir)");
|
|
|
|
else
|
|
|
|
strcpy(foo + longest - 2, "--");
|
2001-04-03 01:02:38 +00:00
|
|
|
} else if (st.st_size < (1 << 10)) /* less than 1 K */
|
|
|
|
sprintf(foo + longest - 7, "%4d B",
|
2001-05-23 21:54:47 +00:00
|
|
|
(int) st.st_size);
|
2001-04-03 01:02:38 +00:00
|
|
|
else if (st.st_size >= (1 << 30)) /* at least 1 gig */
|
|
|
|
sprintf(foo + longest - 7, "%4d GB",
|
|
|
|
(int) st.st_size >> 30);
|
|
|
|
else if (st.st_size >= (1 << 20)) /* at least 1 meg */
|
|
|
|
sprintf(foo + longest - 7, "%4d MB",
|
|
|
|
(int) st.st_size >> 20);
|
2002-12-22 16:30:00 +00:00
|
|
|
else /* It's more than 1 k and less than a meg */
|
2001-04-03 01:02:38 +00:00
|
|
|
sprintf(foo + longest - 7, "%4d KB",
|
|
|
|
(int) st.st_size >> 10);
|
2001-01-03 07:11:47 +00:00
|
|
|
}
|
|
|
|
|
2002-11-04 16:05:42 +00:00
|
|
|
/* Highlight the currently selected file/dir */
|
2002-07-24 01:02:26 +00:00
|
|
|
if (j == selected)
|
2001-01-03 07:11:47 +00:00
|
|
|
wattron(edit, A_REVERSE);
|
2002-07-24 01:02:26 +00:00
|
|
|
waddstr(edit, foo);
|
|
|
|
if (j == selected)
|
2001-01-03 07:11:47 +00:00
|
|
|
wattroff(edit, A_REVERSE);
|
|
|
|
|
2001-01-04 04:59:17 +00:00
|
|
|
/* And add some space between the cols */
|
2001-01-03 07:11:47 +00:00
|
|
|
waddstr(edit, " ");
|
|
|
|
col += 2;
|
|
|
|
|
|
|
|
/* And if the next entry isn't going to fit on the
|
|
|
|
line, move to the next one */
|
2002-07-24 01:02:26 +00:00
|
|
|
if (col > COLS - longest) {
|
2001-01-03 07:11:47 +00:00
|
|
|
editline++;
|
|
|
|
wmove(edit, editline, 0);
|
|
|
|
col = 0;
|
|
|
|
if (width == 0)
|
|
|
|
width = filecols;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
wrefresh(edit);
|
|
|
|
} while ((kbinput = wgetch(edit)) != NANO_EXIT_KEY);
|
|
|
|
curs_set(1);
|
|
|
|
blank_edit();
|
2002-05-11 03:04:44 +00:00
|
|
|
titlebar(NULL);
|
2001-01-03 07:11:47 +00:00
|
|
|
edit_refresh();
|
2001-01-06 18:12:43 +00:00
|
|
|
kb = keypad_on(edit, kb);
|
2001-01-03 07:11:47 +00:00
|
|
|
|
2001-01-04 04:59:17 +00:00
|
|
|
/* cleanup */
|
2001-01-03 07:11:47 +00:00
|
|
|
free_charptrarray(filelist, numents);
|
|
|
|
free(foo);
|
|
|
|
return retval;
|
|
|
|
}
|
2001-01-05 21:13:14 +00:00
|
|
|
|
2001-05-05 17:45:54 +00:00
|
|
|
/* Browser front end, checks to see if inpath has a dir in it and, if so,
|
2001-01-05 21:13:14 +00:00
|
|
|
starts do_browser from there, else from the current dir */
|
2002-09-13 18:14:04 +00:00
|
|
|
char *do_browse_from(const char *inpath)
|
2001-01-05 21:13:14 +00:00
|
|
|
{
|
|
|
|
struct stat st;
|
2002-09-13 18:14:04 +00:00
|
|
|
char *bob;
|
2003-01-30 00:53:32 +00:00
|
|
|
/* The result of do_browser; the selected file name. */
|
|
|
|
char *path;
|
|
|
|
/* inpath, tilde expanded. */
|
2001-04-03 01:02:38 +00:00
|
|
|
|
2003-01-30 00:53:32 +00:00
|
|
|
assert(inpath != NULL);
|
|
|
|
|
|
|
|
path = real_dir_from_tilde(inpath);
|
2002-09-13 18:14:04 +00:00
|
|
|
|
2003-01-30 00:53:32 +00:00
|
|
|
/*
|
|
|
|
* Perhaps path is a directory. If so, we will pass that to
|
|
|
|
* do_browser. Otherwise, perhaps path is a directory / a file. So
|
|
|
|
* we try stripping off the last path element. If it still isn't a
|
|
|
|
* directory, just use the current directory. */
|
|
|
|
|
|
|
|
if (stat(path, &st) == -1 || !S_ISDIR(st.st_mode)) {
|
|
|
|
striponedir(path);
|
2003-02-12 23:49:56 +00:00
|
|
|
if (stat(path, &st) == -1 || !S_ISDIR(st.st_mode)) {
|
|
|
|
free(path);
|
2003-01-30 00:53:32 +00:00
|
|
|
path = getcwd(NULL, PATH_MAX + 1);
|
2003-02-12 23:49:56 +00:00
|
|
|
}
|
2001-04-03 01:02:38 +00:00
|
|
|
}
|
2001-01-05 21:13:14 +00:00
|
|
|
|
2003-01-30 00:53:32 +00:00
|
|
|
#ifndef DISABLE_OPERATINGDIR
|
|
|
|
/* If the resulting path isn't in the operating directory, use that. */
|
|
|
|
if (check_operating_dir(path, FALSE))
|
|
|
|
path = mallocstrcpy(path, operating_dir);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (!readable_dir(path)) {
|
|
|
|
beep();
|
|
|
|
bob = NULL;
|
|
|
|
} else
|
|
|
|
bob = do_browser(path);
|
|
|
|
free(path);
|
2002-09-13 18:14:04 +00:00
|
|
|
return bob;
|
2001-01-05 21:13:14 +00:00
|
|
|
}
|
2002-07-20 13:57:41 +00:00
|
|
|
#endif /* !DISABLE_BROWSER */
|
2003-01-16 23:44:46 +00:00
|
|
|
|
|
|
|
#ifndef NANO_SMALL
|
|
|
|
#ifdef ENABLE_NANORC
|
|
|
|
void load_history(void)
|
|
|
|
{
|
|
|
|
FILE *hist;
|
2003-02-13 22:00:19 +00:00
|
|
|
const struct passwd *userage = NULL;
|
2003-01-16 23:44:46 +00:00
|
|
|
static char *nanohist;
|
|
|
|
char *buf, *ptr;
|
2003-02-13 22:00:19 +00:00
|
|
|
char *homenv = getenv("HOME");
|
2003-01-16 23:44:46 +00:00
|
|
|
historyheadtype *history = &search_history;
|
|
|
|
|
|
|
|
|
2003-02-13 22:00:19 +00:00
|
|
|
if (homenv != NULL) {
|
|
|
|
nanohist = nrealloc(nanohist, strlen(homenv) + 15);
|
|
|
|
sprintf(nanohist, "%s/.nano_history", homenv);
|
|
|
|
} else {
|
|
|
|
userage = getpwuid(geteuid());
|
|
|
|
endpwent();
|
2003-01-16 23:44:46 +00:00
|
|
|
nanohist = nrealloc(nanohist, strlen(userage->pw_dir) + 15);
|
|
|
|
sprintf(nanohist, "%s/.nano_history", userage->pw_dir);
|
2003-02-13 22:00:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* assume do_rcfile has reported missing home dir */
|
|
|
|
|
|
|
|
if (homenv != NULL || userage != NULL) {
|
2003-01-16 23:44:46 +00:00
|
|
|
hist = fopen(nanohist, "r");
|
|
|
|
if (!hist) {
|
2003-03-11 03:50:40 +00:00
|
|
|
if (errno != ENOENT) {
|
|
|
|
/* Don't save history when we quit. */
|
|
|
|
UNSET(HISTORYLOG);
|
2003-01-16 23:44:46 +00:00
|
|
|
rcfile_error(_("Unable to open ~/.nano_history file, %s"), strerror(errno));
|
2003-03-11 03:50:40 +00:00
|
|
|
}
|
2003-01-16 23:44:46 +00:00
|
|
|
free(nanohist);
|
|
|
|
} else {
|
|
|
|
buf = charalloc(1024);
|
|
|
|
while (fgets(buf, 1023, hist) != 0) {
|
|
|
|
ptr = buf;
|
2003-02-12 23:58:01 +00:00
|
|
|
while (*ptr != '\n' && *ptr != '\0' && ptr < buf + 1023)
|
2003-01-16 23:44:46 +00:00
|
|
|
ptr++;
|
|
|
|
*ptr = '\0';
|
|
|
|
if (strlen(buf))
|
|
|
|
update_history(history, buf);
|
|
|
|
else
|
|
|
|
history = &replace_history;
|
|
|
|
}
|
|
|
|
fclose(hist);
|
|
|
|
free(buf);
|
|
|
|
free(nanohist);
|
|
|
|
UNSET(HISTORY_CHANGED);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* save histories to ~/.nano_history */
|
|
|
|
void save_history(void)
|
|
|
|
{
|
|
|
|
FILE *hist;
|
2003-02-13 22:00:19 +00:00
|
|
|
const struct passwd *userage = NULL;
|
2003-01-16 23:44:46 +00:00
|
|
|
char *nanohist = NULL;
|
2003-02-13 22:00:19 +00:00
|
|
|
char *homenv = getenv("HOME");
|
2003-01-16 23:44:46 +00:00
|
|
|
historytype *h;
|
|
|
|
|
|
|
|
/* don't save unchanged or empty histories */
|
|
|
|
if (!((search_history.count || replace_history.count) &&
|
|
|
|
ISSET(HISTORY_CHANGED) && !ISSET(VIEW_MODE)))
|
|
|
|
return;
|
|
|
|
|
2003-02-13 22:00:19 +00:00
|
|
|
if (homenv != NULL) {
|
|
|
|
nanohist = nrealloc(nanohist, strlen(homenv) + 15);
|
|
|
|
sprintf(nanohist, "%s/.nano_history", homenv);
|
|
|
|
} else {
|
|
|
|
userage = getpwuid(geteuid());
|
|
|
|
endpwent();
|
2003-01-16 23:44:46 +00:00
|
|
|
nanohist = nrealloc(nanohist, strlen(userage->pw_dir) + 15);
|
|
|
|
sprintf(nanohist, "%s/.nano_history", userage->pw_dir);
|
2003-02-13 22:00:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (homenv != NULL || userage != NULL) {
|
2003-01-16 23:44:46 +00:00
|
|
|
hist = fopen(nanohist, "wb");
|
|
|
|
if (!hist) {
|
|
|
|
rcfile_msg(_("Unable to write ~/.nano_history file, %s"), strerror(errno));
|
|
|
|
} else {
|
|
|
|
/* set rw only by owner for security ?? */
|
|
|
|
chmod(nanohist, S_IRUSR | S_IWUSR);
|
|
|
|
/* write oldest first */
|
|
|
|
for (h = search_history.tail ; h->prev ; h = h->prev) {
|
2003-02-03 05:04:09 +00:00
|
|
|
h->data = nrealloc(h->data, strlen(h->data) + 2);
|
2003-01-16 23:44:46 +00:00
|
|
|
strcat(h->data, "\n");
|
|
|
|
if (fputs(h->data, hist) == EOF) {
|
|
|
|
rcfile_msg(_("Unable to write ~/.nano_history file, %s"), strerror(errno));
|
|
|
|
goto come_from;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (fputs("\n", hist) == EOF) {
|
|
|
|
rcfile_msg(_("Unable to write ~/.nano_history file, %s"), strerror(errno));
|
|
|
|
goto come_from;
|
|
|
|
}
|
|
|
|
for (h = replace_history.tail ; h->prev ; h = h->prev) {
|
2003-02-03 05:04:09 +00:00
|
|
|
h->data = nrealloc(h->data, strlen(h->data) + 2);
|
2003-01-16 23:44:46 +00:00
|
|
|
strcat(h->data, "\n");
|
|
|
|
if (fputs(h->data, hist) == EOF) {
|
|
|
|
rcfile_msg(_("Unable to write ~/.nano_history file, %s"), strerror(errno));
|
|
|
|
goto come_from;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
come_from:
|
|
|
|
fclose(hist);
|
|
|
|
}
|
|
|
|
free(nanohist);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* ENABLE_NANORC */
|
2003-01-17 21:07:38 +00:00
|
|
|
#endif /* !NANO_SMALL */
|