Page MenuHomeFreeBSD
Differential D34411 Diff 103491 contrib/mg/dired.c

Changeset View

Standalone View

View Options

contrib/mg/dired.c

  • This file was added.
/* $OpenBSD: dired.c,v 1.100 2021/05/02 14:13:17 lum Exp $ */
/* This file is in the public domain. */
/* dired module for mg 2a
* by Robert A. Larson
*/
#include <sys/queue.h>
#include <sys/resource.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <ctype.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <signal.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "def.h"
#include "funmap.h"
#include "kbd.h"
void dired_init(void);
static int dired(int, int);
static int d_otherwindow(int, int);
static int d_undel(int, int);
static int d_undelbak(int, int);
static int d_findfile(int, int);
static int d_ffotherwindow(int, int);
static int d_expunge(int, int);
static int d_copy(int, int);
static int d_del(int, int);
static int d_rename(int, int);
static int d_exec(int, struct buffer *, const char *, const char *, ...);
static int d_shell_command(int, int);
static int d_create_directory(int, int);
static int d_makename(struct line *, char *, size_t);
static int d_warpdot(struct line *, int *);
static int d_forwpage(int, int);
static int d_backpage(int, int);
static int d_forwline(int, int);
static int d_backline(int, int);
static int d_killbuffer_cmd(int, int);
static int d_refreshbuffer(int, int);
static int d_filevisitalt(int, int);
static int d_gotofile(int, int);
static void reaper(int);
static int gotofile(char*);
static struct buffer *refreshbuffer(struct buffer *);
static int createlist(struct buffer *);
static void redelete(struct buffer *);
static char *findfname(struct line *, char *);
extern struct keymap_s helpmap, cXmap, metamap;
const char DDELCHAR = 'D';
/*
* Structure which holds a linked list of file names marked for
* deletion. Used to maintain dired buffer 'state' between refreshes.
*/
struct delentry {
SLIST_ENTRY(delentry) entry;
char *fn;
};
SLIST_HEAD(slisthead, delentry) delhead = SLIST_HEAD_INITIALIZER(delhead);
static PF dirednul[] = {
setmark, /* ^@ */
gotobol, /* ^A */
backchar, /* ^B */
rescan, /* ^C */
d_del, /* ^D */
gotoeol, /* ^E */
forwchar, /* ^F */
ctrlg, /* ^G */
NULL, /* ^H */
};
static PF diredcl[] = {
reposition, /* ^L */
d_findfile, /* ^M */
d_forwline, /* ^N */
rescan, /* ^O */
d_backline, /* ^P */
rescan, /* ^Q */
backisearch, /* ^R */
forwisearch, /* ^S */
rescan, /* ^T */
universal_argument, /* ^U */
d_forwpage, /* ^V */
rescan, /* ^W */
NULL /* ^X */
};
static PF diredcz[] = {
spawncli, /* ^Z */
NULL, /* esc */
rescan, /* ^\ */
rescan, /* ^] */
rescan, /* ^^ */
rescan, /* ^_ */
d_forwline, /* SP */
d_shell_command, /* ! */
rescan, /* " */
rescan, /* # */
rescan, /* $ */
rescan, /* % */
rescan, /* & */
rescan, /* ' */
rescan, /* ( */
rescan, /* ) */
rescan, /* * */
d_create_directory /* + */
};
static PF direda[] = {
d_filevisitalt, /* a */
rescan, /* b */
d_copy, /* c */
d_del, /* d */
d_findfile, /* e */
d_findfile, /* f */
d_refreshbuffer, /* g */
rescan, /* h */
rescan, /* i */
d_gotofile /* j */
};
static PF diredn[] = {
d_forwline, /* n */
d_ffotherwindow, /* o */
d_backline, /* p */
d_killbuffer_cmd, /* q */
d_rename, /* r */
rescan, /* s */
rescan, /* t */
d_undel, /* u */
rescan, /* v */
rescan, /* w */
d_expunge /* x */
};
static PF direddl[] = {
d_undelbak /* del */
};
static PF diredbp[] = {
d_backpage /* v */
};
static PF dirednull[] = {
NULL
};
static struct KEYMAPE (1) d_backpagemap = {
1,
1,
rescan,
{
{
'v', 'v', diredbp, NULL
}
}
};
static struct KEYMAPE (7) diredmap = {
7,
7,
rescan,
{
{
CCHR('@'), CCHR('H'), dirednul, (KEYMAP *) & helpmap
},
{
CCHR('L'), CCHR('X'), diredcl, (KEYMAP *) & cXmap
},
{
CCHR('['), CCHR('['), dirednull, (KEYMAP *) &
d_backpagemap
},
{
CCHR('Z'), '+', diredcz, (KEYMAP *) & metamap
},
{
'a', 'j', direda, NULL
},
{
'n', 'x', diredn, NULL
},
{
CCHR('?'), CCHR('?'), direddl, NULL
},
}
};
void
dired_init(void)
{
funmap_add(dired, "dired", 1);
funmap_add(d_create_directory, "dired-create-directory", 1);
funmap_add(d_copy, "dired-do-copy", 1);
funmap_add(d_expunge, "dired-do-flagged-delete", 0);
funmap_add(d_rename, "dired-do-rename", 1);
funmap_add(d_findfile, "dired-find-file", 1);
funmap_add(d_ffotherwindow, "dired-find-file-other-window", 1);
funmap_add(d_del, "dired-flag-file-deletion", 0);
funmap_add(d_gotofile, "dired-goto-file", 1);
funmap_add(d_forwline, "dired-next-line", 0);
funmap_add(d_otherwindow, "dired-other-window", 0);
funmap_add(d_backline, "dired-previous-line", 0);
funmap_add(d_refreshbuffer, "dired-revert", 0);
funmap_add(d_backpage, "dired-scroll-down", 0);
funmap_add(d_forwpage, "dired-scroll-up", 0);
funmap_add(d_shell_command, "dired-shell-command", 1);
funmap_add(d_undel, "dired-unmark", 0);
funmap_add(d_undelbak, "dired-unmark-backward", 0);
funmap_add(d_killbuffer_cmd, "quit-window", 0);
maps_add((KEYMAP *)&diredmap, "dired");
dobindkey(fundamental_map, "dired", "^Xd");
}
/* ARGSUSED */
int
dired(int f, int n)
{
char dname[NFILEN], *bufp, *slash;
struct buffer *bp;
if (curbp->b_fname[0] != '\0') {
(void)strlcpy(dname, curbp->b_fname, sizeof(dname));
if ((slash = strrchr(dname, '/')) != NULL) {
*(slash + 1) = '\0';
}
} else {
if (getcwd(dname, sizeof(dname)) == NULL)
dname[0] = '\0';
}
if ((bufp = eread("Dired (directory): ", dname, NFILEN,
EFDEF | EFNEW | EFCR)) == NULL)
return (ABORT);
if (bufp[0] == '\0')
return (FALSE);
if ((bp = dired_(bufp)) == NULL)
return (FALSE);
curbp = bp;
return (showbuffer(bp, curwp, WFFULL | WFMODE));
}
/* ARGSUSED */
int
d_otherwindow(int f, int n)
{
char dname[NFILEN], *bufp, *slash;
struct buffer *bp;
struct mgwin *wp;
if (curbp->b_fname[0] != '\0') {
(void)strlcpy(dname, curbp->b_fname, sizeof(dname));
if ((slash = strrchr(dname, '/')) != NULL) {
*(slash + 1) = '\0';
}
} else {
if (getcwd(dname, sizeof(dname)) == NULL)
dname[0] = '\0';
}
if ((bufp = eread("Dired other window: ", dname, NFILEN,
EFDEF | EFNEW | EFCR)) == NULL)
return (ABORT);
else if (bufp[0] == '\0')
return (FALSE);
if ((bp = dired_(bufp)) == NULL)
return (FALSE);
if ((wp = popbuf(bp, WNONE)) == NULL)
return (FALSE);
curbp = bp;
curwp = wp;
return (TRUE);
}
/* ARGSUSED */
int
d_del(int f, int n)
{
if (n < 0)
return (FALSE);
while (n--) {
if (d_warpdot(curwp->w_dotp, &curwp->w_doto) == TRUE) {
lputc(curwp->w_dotp, 0, DDELCHAR);
curbp->b_flag |= BFDIREDDEL;
}
if (lforw(curwp->w_dotp) != curbp->b_headp) {
curwp->w_dotp = lforw(curwp->w_dotp);
curwp->w_dotline++;
}
}
curwp->w_rflag |= WFEDIT | WFMOVE;
return (d_warpdot(curwp->w_dotp, &curwp->w_doto));
}
/* ARGSUSED */
int
d_undel(int f, int n)
{
if (n < 0)
return (d_undelbak(f, -n));
while (n--) {
if (llength(curwp->w_dotp) > 0)
lputc(curwp->w_dotp, 0, ' ');
if (lforw(curwp->w_dotp) != curbp->b_headp) {
curwp->w_dotp = lforw(curwp->w_dotp);
curwp->w_dotline++;
}
}
curwp->w_rflag |= WFEDIT | WFMOVE;
return (d_warpdot(curwp->w_dotp, &curwp->w_doto));
}
/* ARGSUSED */
int
d_undelbak(int f, int n)
{
if (n < 0)
return (d_undel(f, -n));
while (n--) {
if (lback(curwp->w_dotp) != curbp->b_headp) {
curwp->w_dotp = lback(curwp->w_dotp);
curwp->w_dotline--;
}
if (llength(curwp->w_dotp) > 0)
lputc(curwp->w_dotp, 0, ' ');
}
curwp->w_rflag |= WFEDIT | WFMOVE;
return (d_warpdot(curwp->w_dotp, &curwp->w_doto));
}
/* ARGSUSED */
int
d_findfile(int f, int n)
{
struct buffer *bp;
int s;
char fname[NFILEN];
if ((s = d_makename(curwp->w_dotp, fname, sizeof(fname))) == ABORT)
return (FALSE);
if (s == TRUE)
bp = dired_(fname);
else
bp = findbuffer(fname);
if (bp == NULL)
return (FALSE);
curbp = bp;
if (showbuffer(bp, curwp, WFFULL) != TRUE)
return (FALSE);
if (bp->b_fname[0] != 0)
return (TRUE);
return (readin(fname));
}
/* ARGSUSED */
int
d_ffotherwindow(int f, int n)
{
char fname[NFILEN];
int s;
struct buffer *bp;
struct mgwin *wp;
if ((s = d_makename(curwp->w_dotp, fname, sizeof(fname))) == ABORT)
return (FALSE);
if ((bp = (s ? dired_(fname) : findbuffer(fname))) == NULL)
return (FALSE);
if ((wp = popbuf(bp, WNONE)) == NULL)
return (FALSE);
curbp = bp;
curwp = wp;
if (bp->b_fname[0] != 0)
return (TRUE); /* never true for dired buffers */
return (readin(fname));
}
/* ARGSUSED */
int
d_expunge(int f, int n)
{
struct line *lp, *nlp;
char fname[NFILEN], sname[NFILEN];
int tmp;
tmp = curwp->w_dotline;
curwp->w_dotline = 0;
for (lp = bfirstlp(curbp); lp != curbp->b_headp; lp = nlp) {
curwp->w_dotline++;
nlp = lforw(lp);
if (llength(lp) && lgetc(lp, 0) == 'D') {
switch (d_makename(lp, fname, sizeof(fname))) {
case ABORT:
dobeep();
ewprintf("Bad line in dired buffer");
curwp->w_dotline = tmp;
return (FALSE);
case FALSE:
if (unlink(fname) == -1) {
(void)xbasename(sname, fname, NFILEN);
dobeep();
ewprintf("Could not delete '%s'", sname);
curwp->w_dotline = tmp;
return (FALSE);
}
break;
case TRUE:
if (rmdir(fname) == -1) {
(void)xbasename(sname, fname, NFILEN);
dobeep();
ewprintf("Could not delete directory "
"'%s'", sname);
curwp->w_dotline = tmp;
return (FALSE);
}
break;
}
lfree(lp);
curwp->w_bufp->b_lines--;
if (tmp > curwp->w_dotline)
tmp--;
curwp->w_rflag |= WFFULL;
}
}
curwp->w_dotline = tmp;
d_warpdot(curwp->w_dotp, &curwp->w_doto);
/* we have deleted all items successfully, remove del flag */
curbp->b_flag &= ~BFDIREDDEL;
return (TRUE);
}
/* ARGSUSED */
int
d_copy(int f, int n)
{
struct stat statbuf;
char frname[NFILEN], toname[NFILEN], sname[NFILEN];
char *topath, *bufp;
int ret;
size_t off;
struct buffer *bp;
if (d_makename(curwp->w_dotp, frname, sizeof(frname)) != FALSE) {
dobeep();
ewprintf("Not a file");
return (FALSE);
}
off = strlcpy(toname, curbp->b_fname, sizeof(toname));
if (off >= sizeof(toname) - 1) { /* can't happen, really */
dobeep();
ewprintf("Directory name too long");
return (FALSE);
}
(void)xbasename(sname, frname, NFILEN);
bufp = eread("Copy %s to: ", toname, sizeof(toname),
EFDEF | EFNEW | EFCR, sname);
if (bufp == NULL)
return (ABORT);
else if (bufp[0] == '\0')
return (FALSE);
topath = adjustname(toname, TRUE);
if (stat(topath, &statbuf) == 0) {
if (S_ISDIR(statbuf.st_mode)) {
ret = snprintf(toname, sizeof(toname), "%s/%s",
topath, sname);
if (ret < 0 || ret >= sizeof(toname) - 1) {
dobeep();
ewprintf("Directory name too long");
return (FALSE);
}
topath = adjustname(toname, TRUE);
}
}
if (topath == NULL)
return (FALSE);
if (strcmp(frname, topath) == 0) {
ewprintf("Cannot copy to same file: %s", frname);
return (TRUE);
}
ret = (copy(frname, topath) >= 0) ? TRUE : FALSE;
if (ret != TRUE)
return (ret);
if ((bp = refreshbuffer(curbp)) == NULL)
return (FALSE);
ewprintf("Copy: 1 file");
return (showbuffer(bp, curwp, WFFULL | WFMODE));
}
/* ARGSUSED */
int
d_rename(int f, int n)
{
struct stat statbuf;
char frname[NFILEN], toname[NFILEN];
char *topath, *bufp;
int ret;
size_t off;
struct buffer *bp;
char sname[NFILEN];
if (d_makename(curwp->w_dotp, frname, sizeof(frname)) != FALSE) {
dobeep();
ewprintf("Not a file");
return (FALSE);
}
off = strlcpy(toname, curbp->b_fname, sizeof(toname));
if (off >= sizeof(toname) - 1) { /* can't happen, really */
dobeep();
ewprintf("Name too long");
return (FALSE);
}
(void)xbasename(sname, frname, NFILEN);
bufp = eread("Rename %s to: ", toname,
sizeof(toname), EFDEF | EFNEW | EFCR, sname);
if (bufp == NULL)
return (ABORT);
else if (bufp[0] == '\0')
return (FALSE);
topath = adjustname(toname, TRUE);
if (stat(topath, &statbuf) == 0) {
if (S_ISDIR(statbuf.st_mode)) {
ret = snprintf(toname, sizeof(toname), "%s/%s",
topath, sname);
if (ret < 0 || ret >= sizeof(toname) - 1) {
dobeep();
ewprintf("Directory name too long");
return (FALSE);
}
topath = adjustname(toname, TRUE);
}
}
if (topath == NULL)
return (FALSE);
if (strcmp(frname, topath) == 0) {
ewprintf("Cannot move to same file: %s", frname);
return (TRUE);
}
ret = (rename(frname, topath) >= 0) ? TRUE : FALSE;
if (ret != TRUE)
return (ret);
if ((bp = refreshbuffer(curbp)) == NULL)
return (FALSE);
ewprintf("Move: 1 file");
return (showbuffer(bp, curwp, WFFULL | WFMODE));
}
/* ARGSUSED */
void
reaper(int signo __attribute__((unused)))
{
int save_errno = errno, status;
while (waitpid(-1, &status, WNOHANG) >= 0)
;
errno = save_errno;
}
/*
* Pipe the currently selected file through a shell command.
*/
/* ARGSUSED */
int
d_shell_command(int f, int n)
{
char command[512], fname[PATH_MAX], *bufp;
struct buffer *bp;
struct mgwin *wp;
char sname[NFILEN];
bp = bfind("*Shell Command Output*", TRUE);
if (bclear(bp) != TRUE)
return (ABORT);
if (d_makename(curwp->w_dotp, fname, sizeof(fname)) != FALSE) {
dobeep();
ewprintf("bad line");
return (ABORT);
}
command[0] = '\0';
(void)xbasename(sname, fname, NFILEN);
bufp = eread("! on %s: ", command, sizeof(command), EFNEW, sname);
if (bufp == NULL)
return (ABORT);
if (d_exec(0, bp, fname, "sh", "-c", command, NULL) != TRUE)
return (ABORT);
if ((wp = popbuf(bp, WNONE)) == NULL)
return (ABORT); /* XXX - free the buffer?? */
curwp = wp;
curbp = wp->w_bufp;
return (TRUE);
}
/*
* Pipe input file to cmd and insert the command's output in the
* given buffer. Each line will be prefixed with the given
* number of spaces.
*/
static int
d_exec(int space, struct buffer *bp, const char *input, const char *cmd, ...)
{
char buf[BUFSIZ];
va_list ap;
struct sigaction olda, newa;
char **argv = NULL, *cp;
FILE *fin;
int fds[2] = { -1, -1 };
int infd = -1;
int ret = (ABORT), n;
pid_t pid;
if (sigaction(SIGCHLD, NULL, &olda) == -1)
return (ABORT);
/* Find the number of arguments. */
va_start(ap, cmd);
for (n = 2; va_arg(ap, char *) != NULL; n++)
;
va_end(ap);
/* Allocate and build the argv. */
if ((argv = calloc(n, sizeof(*argv))) == NULL) {
dobeep();
ewprintf("Can't allocate argv : %s", strerror(errno));
goto out;
}
n = 1;
argv[0] = (char *)cmd;
va_start(ap, cmd);
while ((argv[n] = va_arg(ap, char *)) != NULL)
n++;
va_end(ap);
if (input == NULL)
input = "/dev/null";
if ((infd = open(input, O_RDONLY)) == -1) {
dobeep();
ewprintf("Can't open input file : %s", strerror(errno));
goto out;
}
if (pipe(fds) == -1) {
dobeep();
ewprintf("Can't create pipe : %s", strerror(errno));
goto out;
}
newa.sa_handler = reaper;
newa.sa_flags = 0;
if (sigaction(SIGCHLD, &newa, NULL) == -1)
goto out;
if ((pid = fork()) == -1) {
dobeep();
ewprintf("Can't fork");
goto out;
}
switch (pid) {
case 0: /* Child */
close(fds[0]);
dup2(infd, STDIN_FILENO);
dup2(fds[1], STDOUT_FILENO);
dup2(fds[1], STDERR_FILENO);
if (execvp(argv[0], argv) == -1)
ewprintf("Can't exec %s: %s", argv[0], strerror(errno));
exit(1);
break;
default: /* Parent */
close(infd);
close(fds[1]);
infd = fds[1] = -1;
if ((fin = fdopen(fds[0], "r")) == NULL)
goto out;
while (fgets(buf, sizeof(buf), fin) != NULL) {
cp = strrchr(buf, *bp->b_nlchr);
if (cp == NULL && !feof(fin)) { /* too long a line */
int c;
addlinef(bp, "%*s%s...", space, "", buf);
while ((c = getc(fin)) != EOF &&
c != *bp->b_nlchr)
;
continue;
} else if (cp)
*cp = '\0';
addlinef(bp, "%*s%s", space, "", buf);
}
fclose(fin);
break;
}
ret = (TRUE);
out:
if (sigaction(SIGCHLD, &olda, NULL) == -1)
ewprintf("Warning, couldn't reset previous signal handler");
if (fds[0] != -1)
close(fds[0]);
if (fds[1] != -1)
close(fds[1]);
if (infd != -1)
close(infd);
free(argv);
return ret;
}
/* ARGSUSED */
int
d_create_directory(int f, int n)
{
int ret;
struct buffer *bp;
ret = ask_makedir();
if (ret != TRUE)
return(ret);
if ((bp = refreshbuffer(curbp)) == NULL)
return (FALSE);
return (showbuffer(bp, curwp, WFFULL | WFMODE));
}
/* ARGSUSED */
int
d_killbuffer_cmd(int f, int n)
{
return(killbuffer_cmd(FFRAND, 0));
}
int
d_refreshbuffer(int f, int n)
{
struct buffer *bp;
if ((bp = refreshbuffer(curbp)) == NULL)
return (FALSE);
return (showbuffer(bp, curwp, WFFULL | WFMODE));
}
/*
* Kill then re-open the requested dired buffer.
* If required, take a note of any files marked for deletion. Then once
* the buffer has been re-opened, remark the same files as deleted.
*/
struct buffer *
refreshbuffer(struct buffer *bp)
{
char *tmp_b_fname;
int i, tmp_w_dotline, ddel = 0;
/* remember directory path to open later */
tmp_b_fname = strdup(bp->b_fname);
if (tmp_b_fname == NULL) {
dobeep();
ewprintf("Out of memory");
return (NULL);
}
tmp_w_dotline = curwp->w_dotline;
/* create a list of files for deletion */
if (bp->b_flag & BFDIREDDEL)
ddel = createlist(bp);
killbuffer(bp);
/* dired_() uses findbuffer() to create new buffer */
if ((bp = dired_(tmp_b_fname)) == NULL) {
free(tmp_b_fname);
return (NULL);
}
free(tmp_b_fname);
/* remark any previously deleted files with a 'D' */
if (ddel)
redelete(bp);
/* find dot line */
bp->b_dotp = bfirstlp(bp);
if (tmp_w_dotline > bp->b_lines)
tmp_w_dotline = bp->b_lines - 1;
for (i = 1; i < tmp_w_dotline; i++)
bp->b_dotp = lforw(bp->b_dotp);
bp->b_dotline = i;
bp->b_doto = 0;
d_warpdot(bp->b_dotp, &bp->b_doto);
curbp = bp;
return (bp);
}
static int
d_makename(struct line *lp, char *fn, size_t len)
{
int start, nlen, ret;
char *namep;
if (d_warpdot(lp, &start) == FALSE)
return (ABORT);
namep = &lp->l_text[start];
nlen = llength(lp) - start;
ret = snprintf(fn, len, "%s%.*s", curbp->b_fname, nlen, namep);
if (ret < 0 || ret >= (int)len)
return (ABORT); /* Name is too long. */
/* Return TRUE if the entry is a directory. */
return ((lgetc(lp, 2) == 'd') ? TRUE : FALSE);
}
#define NAME_FIELD 9
static int
d_warpdot(struct line *dotp, int *doto)
{
char *tp = dotp->l_text;
int off = 0, field = 0, len;
/*
* Find the byte offset to the (space-delimited) filename
* field in formatted ls output.
*/
len = llength(dotp);
while (off < len) {
if (tp[off++] == ' ') {
if (++field == NAME_FIELD) {
*doto = off;
return (TRUE);
}
/* Skip the space. */
while (off < len && tp[off] == ' ')
off++;
}
}
/* We didn't find the field. */
*doto = 0;
return (FALSE);
}
static int
d_forwpage(int f, int n)
{
forwpage(f | FFRAND, n);
return (d_warpdot(curwp->w_dotp, &curwp->w_doto));
}
static int
d_backpage (int f, int n)
{
backpage(f | FFRAND, n);
return (d_warpdot(curwp->w_dotp, &curwp->w_doto));
}
static int
d_forwline (int f, int n)
{
forwline(f | FFRAND, n);
return (d_warpdot(curwp->w_dotp, &curwp->w_doto));
}
static int
d_backline (int f, int n)
{
backline(f | FFRAND, n);
return (d_warpdot(curwp->w_dotp, &curwp->w_doto));
}
int
d_filevisitalt (int f, int n)
{
char fname[NFILEN];
if (d_makename(curwp->w_dotp, fname, sizeof(fname)) == ABORT)
return (FALSE);
return(do_filevisitalt(fname));
}
/*
* XXX dname needs to have enough place to store an additional '/'.
*/
struct buffer *
dired_(char *dname)
{
struct buffer *bp;
int i;
size_t len;
if ((dname = adjustname(dname, TRUE)) == NULL) {
dobeep();
ewprintf("Bad directory name");
return (NULL);
}
/* this should not be done, instead adjustname() should get a flag */
len = strlen(dname);
if (dname[len - 1] != '/') {
dname[len++] = '/';
dname[len] = '\0';
}
if ((access(dname, R_OK | X_OK)) == -1) {
if (errno == EACCES) {
dobeep();
ewprintf("Permission denied: %s", dname);
} else {
dobeep();
ewprintf("Error opening: %s", dname);
}
return (NULL);
}
for (bp = bheadp; bp != NULL; bp = bp->b_bufp) {
if (strcmp(bp->b_fname, dname) == 0) {
if (fchecktime(bp) != TRUE)
ewprintf("Directory has changed on disk;"
" type g to update Dired");
return (bp);
}
}
bp = bfind(dname, TRUE);
bp->b_flag |= BFREADONLY | BFIGNDIRTY;
if ((d_exec(2, bp, NULL, "ls", "-al", dname, NULL)) != TRUE)
return (NULL);
/* Find the line with ".." on it. */
bp->b_dotp = bfirstlp(bp);
bp->b_dotline = 1;
for (i = 0; i < bp->b_lines; i++) {
bp->b_dotp = lforw(bp->b_dotp);
bp->b_dotline++;
if (d_warpdot(bp->b_dotp, &bp->b_doto) == FALSE)
continue;
if (strcmp(ltext(bp->b_dotp) + bp->b_doto, "..") == 0)
break;
}
/* We want dot on the entry right after "..", if possible. */
if (++i < bp->b_lines - 2) {
bp->b_dotp = lforw(bp->b_dotp);
bp->b_dotline++;
}
d_warpdot(bp->b_dotp, &bp->b_doto);
(void)strlcpy(bp->b_fname, dname, sizeof(bp->b_fname));
(void)strlcpy(bp->b_cwd, dname, sizeof(bp->b_cwd));
if ((bp->b_modes[1] = name_mode("dired")) == NULL) {
bp->b_modes[0] = name_mode("fundamental");
dobeep();
ewprintf("Could not find mode dired");
return (NULL);
}
(void)fupdstat(bp);
bp->b_nmodes = 1;
return (bp);
}
/*
* Iterate through the lines of the dired buffer looking for files
* collected in the linked list made in createlist(). If a line is found
* replace 'D' as first char in a line. As lines are found, remove the
* corresponding item from the linked list. Iterate for as long as there
* are items in the linked list or until end of buffer is found.
*/
void
redelete(struct buffer *bp)
{
struct delentry *dt, *d1 = NULL;
struct line *lp, *nlp;
char fname[NFILEN];
char *p = fname;
size_t plen, fnlen;
int finished = 0;
/* reset the deleted file buffer flag until a deleted file is found */
bp->b_flag &= ~BFDIREDDEL;
for (lp = bfirstlp(bp); lp != bp->b_headp; lp = nlp) {
bp->b_dotp = lp;
if ((p = findfname(lp, p)) == NULL) {
nlp = lforw(lp);
continue;
}
plen = strlen(p);
SLIST_FOREACH_SAFE(d1, &delhead, entry, dt) {
fnlen = strlen(d1->fn);
if ((plen == fnlen) &&
(strncmp(p, d1->fn, plen) == 0)) {
lputc(bp->b_dotp, 0, DDELCHAR);
bp->b_flag |= BFDIREDDEL;
SLIST_REMOVE(&delhead, d1, delentry, entry);
if (SLIST_EMPTY(&delhead)) {
finished = 1;
break;
}
}
}
if (finished)
break;
nlp = lforw(lp);
}
while (!SLIST_EMPTY(&delhead)) {
d1 = SLIST_FIRST(&delhead);
SLIST_REMOVE_HEAD(&delhead, entry);
free(d1->fn);
free(d1);
}
return;
}
/*
* Create a list of files marked for deletion.
*/
int
createlist(struct buffer *bp)
{
struct delentry *d1 = NULL, *d2;
struct line *lp, *nlp;
char fname[NFILEN];
char *p = fname;
int ret = FALSE;
for (lp = bfirstlp(bp); lp != bp->b_headp; lp = nlp) {
/*
* Check if the line has 'D' on the first char and if a valid
* filename can be extracted from it.
*/
if (((lp->l_text[0] != DDELCHAR)) ||
((p = findfname(lp, p)) == NULL)) {
nlp = lforw(lp);
continue;
}
if (SLIST_EMPTY(&delhead)) {
if ((d1 = malloc(sizeof(struct delentry)))
== NULL)
return (ABORT);
if ((d1->fn = strdup(p)) == NULL) {
free(d1);
return (ABORT);
}
SLIST_INSERT_HEAD(&delhead, d1, entry);
} else {
if ((d2 = malloc(sizeof(struct delentry)))
== NULL) {
free(d1->fn);
free(d1);
return (ABORT);
}
if ((d2->fn = strdup(p)) == NULL) {
free(d1->fn);
free(d1);
free(d2);
return (ABORT);
}
if (!d1)
SLIST_INSERT_HEAD(&delhead, d2, entry);
else
SLIST_INSERT_AFTER(d1, d2, entry);
d1 = d2;
}
ret = TRUE;
nlp = lforw(lp);
}
return (ret);
}
int
dired_jump(int f, int n)
{
struct buffer *bp;
const char *modename;
char dname[NFILEN], *fname;
int ret, i;
/*
* We use fundamental mode in dired, so just check we aren't in
* dired mode for this specific function. Seems like a corner
* case at the moment.
*/
for (i = 0; i <= curbp->b_nmodes; i++) {
modename = curbp->b_modes[i]->p_name;
if (strncmp(modename, "dired", 5) == 0)
return (dobeep_msg("In dired mode already"));
}
if (getbufcwd(dname, sizeof(dname)) != TRUE)
return (FALSE);
fname = curbp->b_fname;
if ((bp = dired_(dname)) == NULL)
return (FALSE);
curbp = bp;
ret = showbuffer(bp, curwp, WFFULL | WFMODE);
if (ret != TRUE)
return ret;
fname = adjustname(fname, TRUE);
if (fname != NULL)
gotofile(fname);
return (TRUE);
}
int
d_gotofile(int f, int n)
{
size_t lenfpath;
char fpath[NFILEN];
char *fpth, *fnp = NULL;
if (getbufcwd(fpath, sizeof(fpath)) != TRUE)
fpath[0] = '\0';
lenfpath = strlen(fpath);
fnp = eread("Goto file: ", fpath, NFILEN,
EFNEW | EFCR | EFFILE | EFDEF);
if (fnp == NULL)
return (ABORT);
else if (fnp[0] == '\0')
return (FALSE);
fpth = adjustname(fpath, TRUE); /* Removes last '/' if dir... */
if (fpth == NULL || strlen(fpth) == lenfpath - 1) { /* ...hence -1. */
ewprintf("No file to find"); /* Current directory given so */
return (TRUE); /* return at present location. */
}
return gotofile(fpth);
}
int
gotofile(char *fpth)
{
struct line *lp, *nlp;
char fname[NFILEN];
char *p;
int tmp;
(void)xbasename(fname, fpth, NFILEN);
tmp = 0;
for (lp = bfirstlp(curbp); lp != curbp->b_headp; lp = nlp) {
tmp++;
if ((p = findfname(lp, p)) == NULL) {
nlp = lforw(lp);
continue;
}
if (strcmp(fname, p) == 0) {
curwp->w_dotp = lp;
curwp->w_dotline = tmp;
(void)d_warpdot(curwp->w_dotp, &curwp->w_doto);
tmp--;
break;
}
nlp = lforw(lp);
}
if (tmp == curbp->b_lines - 1) {
ewprintf("File not found %s", fname);
return (FALSE);
} else {
ewprintf("");
return (TRUE);
}
}
/*
* Look for and extract a file name on a dired buffer line.
*/
char *
findfname(struct line *lp, char *fn)
{
int start;
(void)d_warpdot(lp, &start);
if (start < 1)
return NULL;
fn = &lp->l_text[start];
return fn;
}