index a31d18eb23bd1213610bc94fe78f09e2836bff8d..77e1d8183372669bc1fed7fda0cbb97ada649417 100644 (file)
--- a/tig.c
+++ b/tig.c
static void foreach_ref(bool (*visitor)(void *data, const struct ref *ref), void *data);
static int load_refs(void);
static void foreach_ref(bool (*visitor)(void *data, const struct ref *ref), void *data);
static int load_refs(void);
-enum format_flags {
- FORMAT_ALL, /* Perform replacement in all arguments. */
- FORMAT_NONE /* No replacement should be performed. */
-};
-
-static bool format_argv(const char *dst[], const char *src[], enum format_flags flags);
-
enum input_status {
INPUT_OK,
INPUT_SKIP,
enum input_status {
INPUT_OK,
INPUT_SKIP,
return !env || argv_from_string(argv, &argc, env);
}
return !env || argv_from_string(argv, &argc, env);
}
+static void
+argv_free(const char *argv[])
+{
+ int argc;
+
+ for (argc = 0; argv[argc]; argc++)
+ free((void *) argv[argc]);
+ argv[0] = NULL;
+}
+
+static bool
+argv_copy(const char *dst[], const char *src[])
+{
+ int argc;
+
+ for (argc = 0; src[argc]; argc++)
+ if (!(dst[argc] = strdup(src[argc])))
+ return FALSE;
+ return TRUE;
+}
+
/*
* Executing external commands.
/*
* Executing external commands.
};
struct io {
};
struct io {
- enum io_type type; /* The requested type of pipe. */
- const char *dir; /* Directory from which to execute. */
- pid_t pid; /* PID of spawned process. */
int pipe; /* Pipe end for reading or writing. */
int pipe; /* Pipe end for reading or writing. */
+ pid_t pid; /* PID of spawned process. */
int error; /* Error status. */
int error; /* Error status. */
- const char *argv[SIZEOF_ARG]; /* Shell command arguments. */
char *buf; /* Read buffer. */
size_t bufalloc; /* Allocated buffer size. */
size_t bufsize; /* Buffer content size. */
char *buf; /* Read buffer. */
size_t bufalloc; /* Allocated buffer size. */
size_t bufsize; /* Buffer content size. */
};
static void
};
static void
-io_reset(struct io *io)
+io_init(struct io *io)
{
{
+ memset(io, 0, sizeof(*io));
io->pipe = -1;
io->pipe = -1;
- io->pid = 0;
- io->buf = io->bufpos = NULL;
- io->bufalloc = io->bufsize = 0;
- io->error = 0;
- io->eof = 0;
-}
-
-static void
-io_init(struct io *io, const char *dir, enum io_type type)
-{
- io_reset(io);
- io->type = type;
- io->dir = dir;
-}
-
-static bool
-io_format(struct io *io, const char *dir, enum io_type type,
- const char *argv[], enum format_flags flags)
-{
- io_init(io, dir, type);
- return format_argv(io->argv, argv, flags);
}
static bool
}
static bool
bool fits;
va_list args;
bool fits;
va_list args;
- io_init(io, NULL, IO_FD);
+ io_init(io);
va_start(args, fmt);
fits = vsnprintf(name, sizeof(name), fmt, args) < sizeof(name);
va_start(args, fmt);
fits = vsnprintf(name, sizeof(name), fmt, args) < sizeof(name);
if (io->pipe != -1)
close(io->pipe);
free(io->buf);
if (io->pipe != -1)
close(io->pipe);
free(io->buf);
- io_reset(io);
+ io_init(io);
while (pid > 0) {
int status;
while (pid > 0) {
int status;
}
static bool
}
static bool
-io_start(struct io *io)
+io_run(struct io *io, enum io_type type, const char *dir, const char *argv[], ...)
{
int pipefds[2] = { -1, -1 };
{
int pipefds[2] = { -1, -1 };
+ va_list args;
- if (io->type == IO_FD)
- return TRUE;
+ io_init(io);
- if ((io->type == IO_RD || io->type == IO_WR) && pipe(pipefds) < 0) {
+ if ((type == IO_RD || type == IO_WR) && pipe(pipefds) < 0) {
io->error = errno;
return FALSE;
io->error = errno;
return FALSE;
- } else if (io->type == IO_AP) {
- pipefds[1] = io->pipe;
+ } else if (type == IO_AP) {
+ va_start(args, argv);
+ pipefds[1] = va_arg(args, int);
+ va_end(args);
}
if ((io->pid = fork())) {
if (io->pid == -1)
io->error = errno;
}
if ((io->pid = fork())) {
if (io->pid == -1)
io->error = errno;
- if (pipefds[!(io->type == IO_WR)] != -1)
- close(pipefds[!(io->type == IO_WR)]);
+ if (pipefds[!(type == IO_WR)] != -1)
+ close(pipefds[!(type == IO_WR)]);
if (io->pid != -1) {
if (io->pid != -1) {
- io->pipe = pipefds[!!(io->type == IO_WR)];
+ io->pipe = pipefds[!!(type == IO_WR)];
return TRUE;
}
} else {
return TRUE;
}
} else {
- if (io->type != IO_FG) {
+ if (type != IO_FG) {
int devnull = open("/dev/null", O_RDWR);
int devnull = open("/dev/null", O_RDWR);
- int readfd = io->type == IO_WR ? pipefds[0] : devnull;
- int writefd = (io->type == IO_RD || io->type == IO_AP)
+ int readfd = type == IO_WR ? pipefds[0] : devnull;
+ int writefd = (type == IO_RD || type == IO_AP)
? pipefds[1] : devnull;
dup2(readfd, STDIN_FILENO);
? pipefds[1] : devnull;
dup2(readfd, STDIN_FILENO);
close(pipefds[1]);
}
close(pipefds[1]);
}
- if (io->dir && *io->dir && chdir(io->dir) == -1)
+ if (dir && *dir && chdir(dir) == -1)
exit(errno);
exit(errno);
- execvp(io->argv[0], (char *const*) io->argv);
+ execvp(argv[0], (char *const*) argv);
exit(errno);
}
exit(errno);
}
- if (pipefds[!!(io->type == IO_WR)] != -1)
- close(pipefds[!!(io->type == IO_WR)]);
+ if (pipefds[!!(type == IO_WR)] != -1)
+ close(pipefds[!!(type == IO_WR)]);
return FALSE;
}
static bool
return FALSE;
}
static bool
-io_run(struct io *io, const char **argv, const char *dir, enum io_type type)
+io_complete(enum io_type type, const char **argv, const char *dir, int fd)
{
{
- io_init(io, dir, type);
- if (!format_argv(io->argv, argv, FORMAT_NONE))
- return FALSE;
- return io_start(io);
-}
+ struct io io;
-static int
-io_complete(struct io *io)
-{
- return io_start(io) && io_done(io);
+ return io_run(&io, type, dir, argv, fd) && io_done(&io);
}
}
-static int
+static bool
io_run_bg(const char **argv)
{
io_run_bg(const char **argv)
{
- struct io io = {};
-
- if (!io_format(&io, NULL, IO_BG, argv, FORMAT_NONE))
- return FALSE;
- return io_complete(&io);
+ return io_complete(IO_BG, argv, NULL, -1);
}
static bool
io_run_fg(const char **argv, const char *dir)
{
}
static bool
io_run_fg(const char **argv, const char *dir)
{
- struct io io = {};
-
- if (!io_format(&io, dir, IO_FG, argv, FORMAT_NONE))
- return FALSE;
- return io_complete(&io);
+ return io_complete(IO_FG, argv, dir, -1);
}
static bool
}
static bool
-io_run_append(const char **argv, enum format_flags flags, int fd)
+io_run_append(const char **argv, int fd)
{
{
- struct io io = {};
-
- if (!io_format(&io, NULL, IO_AP, argv, flags)) {
- close(fd);
- return FALSE;
- }
-
- io.pipe = fd;
- return io_complete(&io);
-}
-
-static bool
-io_run_rd(struct io *io, const char **argv, const char *dir, enum format_flags flags)
-{
- return io_format(io, dir, IO_RD, argv, flags) && io_start(io);
+ return io_complete(IO_AP, argv, NULL, fd);
}
static bool
}
static bool
static bool
io_run_buf(const char **argv, char buf[], size_t bufsize)
{
static bool
io_run_buf(const char **argv, char buf[], size_t bufsize)
{
- struct io io = {};
+ struct io io;
- return io_run_rd(&io, argv, NULL, FORMAT_NONE)
- && io_read_buf(&io, buf, bufsize);
+ return io_run(&io, IO_RD, NULL, argv) && io_read_buf(&io, buf, bufsize);
}
static int
}
static int
char *name;
int state = OK;
char *name;
int state = OK;
- if (!io_start(io))
- return ERR;
-
while (state == OK && (name = io_get(io, '\n', TRUE))) {
char *value;
size_t namelen;
while (state == OK && (name = io_get(io, '\n', TRUE))) {
char *value;
size_t namelen;
io_run_load(const char **argv, const char *separators,
int (*read_property)(char *, size_t, char *, size_t))
{
io_run_load(const char **argv, const char *separators,
int (*read_property)(char *, size_t, char *, size_t))
{
- struct io io = {};
+ struct io io;
- return io_format(&io, NULL, IO_RD, argv, FORMAT_NONE)
- ? io_load(&io, separators, read_property) : ERR;
+ if (!io_run(&io, IO_RD, NULL, argv))
+ return ERR;
+ return io_load(&io, separators, read_property);
}
}
req->key = key;
req->argv[0] = NULL;
req->key = key;
req->argv[0] = NULL;
- if (!format_argv(req->argv, argv, FORMAT_NONE))
+ if (!argv_copy(req->argv, argv))
return REQ_NONE;
return REQ_NONE + ++run_requests;
return REQ_NONE;
return REQ_NONE + ++run_requests;
static void
load_option_file(const char *path)
{
static void
load_option_file(const char *path)
{
- struct io io = {};
+ struct io io;
/* It's OK that the file doesn't exist. */
if (!io_open(&io, "%s", path))
/* It's OK that the file doesn't exist. */
if (!io_open(&io, "%s", path))
enum keymap keymap; /* What keymap does this view have */
bool git_dir; /* Whether the view requires a git directory. */
enum keymap keymap; /* What keymap does this view have */
bool git_dir; /* Whether the view requires a git directory. */
- bool refresh; /* Whether the view supports refreshing. */
char ref[SIZEOF_REF]; /* Hovered commit reference */
char vid[SIZEOF_REF]; /* View ID. Set to id member when updating. */
char ref[SIZEOF_REF]; /* Hovered commit reference */
char vid[SIZEOF_REF]; /* View ID. Set to id member when updating. */
bool has_scrolled; /* View was scrolled. */
/* Loading */
bool has_scrolled; /* View was scrolled. */
/* Loading */
+ const char *argv[SIZEOF_ARG]; /* Shell command arguments. */
+ const char *dir; /* Directory from which to execute. */
struct io io;
struct io *pipe;
time_t start_time;
struct io io;
struct io *pipe;
time_t start_time;
static struct view_ops tree_ops;
static struct view_ops branch_ops;
static struct view_ops tree_ops;
static struct view_ops branch_ops;
-#define VIEW_STR(type, name, env, ref, ops, map, git, refresh) \
- { type, name, #env, ref, ops, map, git, refresh }
+#define VIEW_STR(type, name, env, ref, ops, map, git) \
+ { type, name, #env, ref, ops, map, git }
-#define VIEW_(id, name, ops, git, refresh, ref) \
- VIEW_STR(VIEW_##id, name, TIG_##id##_CMD, ref, ops, KEYMAP_##id, git, refresh)
+#define VIEW_(id, name, ops, git, ref) \
+ VIEW_STR(VIEW_##id, name, TIG_##id##_CMD, ref, ops, KEYMAP_##id, git)
static struct view views[] = {
static struct view views[] = {
- VIEW_(MAIN, "main", &main_ops, TRUE, TRUE, ref_head),
- VIEW_(DIFF, "diff", &diff_ops, TRUE, FALSE, ref_commit),
- VIEW_(LOG, "log", &log_ops, TRUE, TRUE, ref_head),
- VIEW_(TREE, "tree", &tree_ops, TRUE, FALSE, ref_commit),
- VIEW_(BLOB, "blob", &blob_ops, TRUE, FALSE, ref_blob),
- VIEW_(BLAME, "blame", &blame_ops, TRUE, FALSE, ref_commit),
- VIEW_(BRANCH, "branch", &branch_ops, TRUE, TRUE, ref_head),
- VIEW_(HELP, "help", &help_ops, FALSE, FALSE, ""),
- VIEW_(PAGER, "pager", &pager_ops, FALSE, FALSE, "stdin"),
- VIEW_(STATUS, "status", &status_ops, TRUE, TRUE, ""),
- VIEW_(STAGE, "stage", &stage_ops, TRUE, TRUE, ""),
+ VIEW_(MAIN, "main", &main_ops, TRUE, ref_head),
+ VIEW_(DIFF, "diff", &diff_ops, TRUE, ref_commit),
+ VIEW_(LOG, "log", &log_ops, TRUE, ref_head),
+ VIEW_(TREE, "tree", &tree_ops, TRUE, ref_commit),
+ VIEW_(BLOB, "blob", &blob_ops, TRUE, ref_blob),
+ VIEW_(BLAME, "blame", &blame_ops, TRUE, ref_commit),
+ VIEW_(BRANCH, "branch", &branch_ops, TRUE, ref_head),
+ VIEW_(HELP, "help", &help_ops, FALSE, ""),
+ VIEW_(PAGER, "pager", &pager_ops, FALSE, "stdin"),
+ VIEW_(STATUS, "status", &status_ops, TRUE, ""),
+ VIEW_(STAGE, "stage", &stage_ops, TRUE, ""),
};
#define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
};
#define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
#define view_is_displayed(view) \
(view == display[0] || view == display[1])
#define view_is_displayed(view) \
(view == display[0] || view == display[1])
+static enum request
+view_request(struct view *view, enum request request)
+{
+ if (!view || !view->lines)
+ return request;
+ return view->ops->request(view, request, &view->line[view->lineno]);
+}
+
/*
* View drawing.
/*
* View drawing.
view->update_secs = 0;
}
view->update_secs = 0;
}
-static void
-free_argv(const char *argv[])
-{
- int argc;
-
- for (argc = 0; argv[argc]; argc++)
- free((void *) argv[argc]);
-}
-
static const char *
format_arg(const char *name)
{
static const char *
format_arg(const char *name)
{
}
static bool
}
static bool
-format_argv(const char *dst_argv[], const char *src_argv[], enum format_flags flags)
+format_argv(const char *dst_argv[], const char *src_argv[], bool replace)
{
char buf[SIZEOF_STR];
int argc;
{
char buf[SIZEOF_STR];
int argc;
- bool noreplace = flags == FORMAT_NONE;
- free_argv(dst_argv);
+ argv_free(dst_argv);
for (argc = 0; src_argv[argc]; argc++) {
const char *arg = src_argv[argc];
for (argc = 0; src_argv[argc]; argc++) {
const char *arg = src_argv[argc];
@@ -3198,7 +3158,7 @@ format_argv(const char *dst_argv[], const char *src_argv[], enum format_flags fl
int len = next - arg;
const char *value;
int len = next - arg;
const char *value;
- if (!next || noreplace) {
+ if (!next || !replace) {
len = strlen(arg);
value = "";
len = strlen(arg);
value = "";
@@ -3213,7 +3173,7 @@ format_argv(const char *dst_argv[], const char *src_argv[], enum format_flags fl
if (!string_format_from(buf, &bufpos, "%.*s%s", len, arg, value))
return FALSE;
if (!string_format_from(buf, &bufpos, "%.*s%s", len, arg, value))
return FALSE;
- arg = next && !noreplace ? strchr(next, ')') + 1 : NULL;
+ arg = next && replace ? strchr(next, ')') + 1 : NULL;
}
dst_argv[argc] = strdup(buf);
}
dst_argv[argc] = strdup(buf);
view->start_time = time(NULL);
}
view->start_time = time(NULL);
}
+static bool
+prepare_io(struct view *view, const char *dir, const char *argv[], bool replace)
+{
+ view->dir = dir;
+ return format_argv(view->argv, argv, replace);
+}
+
static bool
prepare_update(struct view *view, const char *argv[], const char *dir)
{
if (view->pipe)
end_update(view, TRUE);
static bool
prepare_update(struct view *view, const char *argv[], const char *dir)
{
if (view->pipe)
end_update(view, TRUE);
- return io_format(&view->io, dir, IO_RD, argv, FORMAT_NONE);
+ return prepare_io(view, dir, argv, FALSE);
+}
+
+static bool
+start_update(struct view *view, const char **argv, const char *dir)
+{
+ if (view->pipe)
+ io_done(view->pipe);
+ return prepare_io(view, dir, argv, FALSE) &&
+ io_run(&view->io, IO_RD, dir, view->argv);
}
static bool
}
static bool
{
if (view->pipe)
end_update(view, TRUE);
{
if (view->pipe)
end_update(view, TRUE);
+ argv_free(view->argv);
return io_open(&view->io, "%s/%s", opt_cdup[0] ? opt_cdup : ".", name);
}
return io_open(&view->io, "%s/%s", opt_cdup[0] ? opt_cdup : ".", name);
}
if (view->ops->prepare) {
if (!view->ops->prepare(view))
return FALSE;
if (view->ops->prepare) {
if (!view->ops->prepare(view))
return FALSE;
- } else if (!io_format(&view->io, NULL, IO_RD, view->ops->argv, FORMAT_ALL)) {
+ } else if (!prepare_io(view, NULL, view->ops->argv, TRUE)) {
return FALSE;
}
return FALSE;
}
string_copy_rev(view->ref, view->id);
}
string_copy_rev(view->ref, view->id);
}
- if (!io_start(&view->io))
+ if (view->argv[0] && !io_run(&view->io, IO_RD, view->dir, view->argv))
return FALSE;
setup_update(view, view->id);
return FALSE;
setup_update(view, view->id);
return;
}
return;
}
- if (format_argv(argv, req->argv, FORMAT_ALL))
+ if (format_argv(argv, req->argv, TRUE))
open_external_viewer(argv, NULL);
open_external_viewer(argv, NULL);
- free_argv(argv);
+ argv_free(argv);
}
/*
}
/*
if (request > REQ_NONE) {
open_run_request(request);
if (request > REQ_NONE) {
open_run_request(request);
- /* FIXME: When all views can refresh always do this. */
- if (view->refresh)
- request = REQ_REFRESH;
- else
- return TRUE;
+ view_request(view, REQ_REFRESH);
+ return TRUE;
}
}
- if (view && view->lines) {
- request = view->ops->request(view, request, &view->line[view->lineno]);
- if (request == REQ_NONE)
- return TRUE;
- }
+ request = view_request(view, request);
+ if (request == REQ_NONE)
+ return TRUE;
switch (request) {
case REQ_MOVE_UP:
switch (request) {
case REQ_MOVE_UP:
if (view_is_displayed(view))
update_view_title(view);
if (line != view->lineno)
if (view_is_displayed(view))
update_view_title(view);
if (line != view->lineno)
- view->ops->request(view, REQ_ENTER,
- &view->line[view->lineno]);
-
+ view_request(view, REQ_ENTER);
} else {
move_view(view, request);
}
} else {
move_view(view, request);
}
"git", "log", "--no-color", "--pretty=raw",
"--cc", "--raw", view->id, "--", path, NULL
};
"git", "log", "--no-color", "--pretty=raw",
"--cc", "--raw", view->id, "--", path, NULL
};
- struct io io = {};
if (!view->lines) {
tree_entry(view, LINE_TREE_HEAD, opt_path, NULL, NULL);
if (!view->lines) {
tree_entry(view, LINE_TREE_HEAD, opt_path, NULL, NULL);
return TRUE;
}
return TRUE;
}
- if (!io_run_rd(&io, log_file, opt_cdup, FORMAT_NONE)) {
+ if (!start_update(view, log_file, opt_cdup)) {
report("Failed to load tree data");
return TRUE;
}
report("Failed to load tree data");
return TRUE;
}
- io_done(view->pipe);
- view->io = io;
*read_date = TRUE;
return FALSE;
*read_date = TRUE;
return FALSE;
}
static void
}
static void
-open_blob_editor()
+open_blob_editor(const char *id)
{
{
+ const char *blob_argv[] = { "git", "cat-file", "blob", id, NULL };
char file[SIZEOF_STR] = "/tmp/tigblob.XXXXXX";
int fd = mkstemp(file);
if (fd == -1)
report("Failed to create temporary file");
char file[SIZEOF_STR] = "/tmp/tigblob.XXXXXX";
int fd = mkstemp(file);
if (fd == -1)
report("Failed to create temporary file");
- else if (!io_run_append(blob_ops.argv, FORMAT_ALL, fd))
+ else if (!io_run_append(blob_argv, fd))
report("Failed to save blob data to file");
else
open_editor(file);
report("Failed to save blob data to file");
else
open_editor(file);
tree_request(struct view *view, enum request request, struct line *line)
{
enum open_flags flags;
tree_request(struct view *view, enum request request, struct line *line)
{
enum open_flags flags;
+ struct tree_entry *entry = line->data;
switch (request) {
case REQ_VIEW_BLAME:
switch (request) {
case REQ_VIEW_BLAME:
if (line->type != LINE_TREE_FILE) {
report("Edit only supported for files");
} else if (!is_head_commit(view->vid)) {
if (line->type != LINE_TREE_FILE) {
report("Edit only supported for files");
} else if (!is_head_commit(view->vid)) {
- open_blob_editor();
+ open_blob_editor(entry->id);
} else {
open_editor(opt_file);
}
} else {
open_editor(opt_file);
}
opt_path[0] = 0;
}
opt_path[0] = 0;
}
- return io_format(&view->io, opt_cdup, IO_RD, view->ops->argv, FORMAT_ALL);
+ return prepare_io(view, opt_cdup, view->ops->argv, TRUE);
}
static const char *tree_argv[SIZEOF_ARG] = {
}
static const char *tree_argv[SIZEOF_ARG] = {
{
switch (request) {
case REQ_EDIT:
{
switch (request) {
case REQ_EDIT:
- open_blob_editor();
+ open_blob_editor(view->vid);
return REQ_NONE;
default:
return pager_request(view, request, line);
return REQ_NONE;
default:
return pager_request(view, request, line);
* reading output from git-blame.
*/
* reading output from git-blame.
*/
-static const char *blame_head_argv[] = {
- "git", "blame", "--incremental", "--", "%(file)", NULL
-};
-
-static const char *blame_ref_argv[] = {
- "git", "blame", "--incremental", "%(ref)", "--", "%(file)", NULL
-};
-
-static const char *blame_cat_file_argv[] = {
- "git", "cat-file", "blob", "%(ref):%(file)", NULL
-};
-
struct blame_commit {
char id[SIZEOF_REV]; /* SHA1 ID. */
char title[128]; /* First line of the commit message. */
struct blame_commit {
char id[SIZEOF_REV]; /* SHA1 ID. */
char title[128]; /* First line of the commit message. */
}
if (*opt_ref || !io_open(&view->io, "%s%s", opt_cdup, opt_file)) {
}
if (*opt_ref || !io_open(&view->io, "%s%s", opt_cdup, opt_file)) {
- if (!io_run_rd(&view->io, blame_cat_file_argv, opt_cdup, FORMAT_ALL))
+ const char *blame_cat_file_argv[] = {
+ "git", "cat-file", "blob", path, NULL
+ };
+
+ if (!string_format(path, "%s:%s", opt_ref, opt_file) ||
+ !start_update(view, blame_cat_file_argv, opt_cdup))
return FALSE;
}
return FALSE;
}
blame_read_file(struct view *view, const char *line, bool *read_file)
{
if (!line) {
blame_read_file(struct view *view, const char *line, bool *read_file)
{
if (!line) {
- const char **argv = *opt_ref ? blame_ref_argv : blame_head_argv;
- struct io io = {};
+ const char *blame_argv[] = {
+ "git", "blame", "--incremental",
+ *opt_ref ? opt_ref : "--incremental", "--", opt_file, NULL
+ };
if (view->lines == 0 && !view->prev)
die("No blame exist for %s", view->vid);
if (view->lines == 0 && !view->prev)
die("No blame exist for %s", view->vid);
- if (view->lines == 0 || !io_run_rd(&io, argv, opt_cdup, FORMAT_ALL)) {
+ if (view->lines == 0 || !start_update(view, blame_argv, opt_cdup)) {
report("Failed to load blame data");
return TRUE;
}
report("Failed to load blame data");
return TRUE;
}
- io_done(view->pipe);
- view->io = io;
*read_file = FALSE;
return FALSE;
*read_file = FALSE;
return FALSE;
"git", "diff-tree", "-U0", blame->commit->id,
"--", blame->commit->filename, NULL
};
"git", "diff-tree", "-U0", blame->commit->id,
"--", blame->commit->filename, NULL
};
- struct io io = {};
+ struct io io;
int parent_lineno = -1;
int blamed_lineno = -1;
char *line;
int parent_lineno = -1;
int blamed_lineno = -1;
char *line;
- if (!io_run(&io, diff_tree_argv, NULL, IO_RD))
+ if (!io_run(&io, IO_RD, NULL, diff_tree_argv))
return;
while ((line = io_get(&io, '\n', TRUE))) {
return;
while ((line = io_get(&io, '\n', TRUE))) {
"--simplify-by-decoration", "--all", NULL
};
"--simplify-by-decoration", "--all", NULL
};
- if (!io_run_rd(&view->io, branch_log, NULL, FORMAT_NONE)) {
+ if (!start_update(view, branch_log, NULL)) {
report("Failed to load branch data");
return TRUE;
}
report("Failed to load branch data");
return TRUE;
}
@@ -5568,9 +5530,9 @@ status_run(struct view *view, const char *argv[], char status, enum line_type ty
{
struct status *unmerged = NULL;
char *buf;
{
struct status *unmerged = NULL;
char *buf;
- struct io io = {};
+ struct io io;
- if (!io_run(&io, argv, opt_cdup, IO_RD))
+ if (!io_run(&io, IO_RD, opt_cdup, argv))
return FALSE;
add_line_data(view, NULL, type);
return FALSE;
add_line_data(view, NULL, type);
continue;
if (!*opt_head) {
continue;
if (!*opt_head) {
- struct io io = {};
+ struct io io;
if (io_open(&io, "%s/rebase-merge/head-name", opt_git_dir) &&
io_read_buf(&io, buf, sizeof(buf))) {
if (io_open(&io, "%s/rebase-merge/head-name", opt_git_dir) &&
io_read_buf(&io, buf, sizeof(buf))) {
switch (type) {
case LINE_STAT_STAGED:
switch (type) {
case LINE_STAT_STAGED:
- return io_run(io, staged_argv, opt_cdup, IO_WR);
+ return io_run(io, IO_WR, opt_cdup, staged_argv);
case LINE_STAT_UNSTAGED:
case LINE_STAT_UNTRACKED:
case LINE_STAT_UNSTAGED:
case LINE_STAT_UNTRACKED:
- return io_run(io, others_argv, opt_cdup, IO_WR);
+ return io_run(io, IO_WR, opt_cdup, others_argv);
default:
die("line type %d not handled in switch", type);
default:
die("line type %d not handled in switch", type);
@@ -6008,7 +5970,7 @@ status_update_write(struct io *io, struct status *status, enum line_type type)
static bool
status_update_file(struct status *status, enum line_type type)
{
static bool
status_update_file(struct status *status, enum line_type type)
{
- struct io io = {};
+ struct io io;
bool result;
if (!status_update_prepare(&io, type))
bool result;
if (!status_update_prepare(&io, type))
status_update_files(struct view *view, struct line *line)
{
char buf[sizeof(view->ref)];
status_update_files(struct view *view, struct line *line)
{
char buf[sizeof(view->ref)];
- struct io io = {};
+ struct io io;
bool result = TRUE;
struct line *pos = view->line + view->lines;
int files = 0;
bool result = TRUE;
struct line *pos = view->line + view->lines;
int files = 0;
"git", "apply", "--whitespace=nowarn", NULL
};
struct line *diff_hdr;
"git", "apply", "--whitespace=nowarn", NULL
};
struct line *diff_hdr;
- struct io io = {};
+ struct io io;
int argc = 3;
diff_hdr = stage_diff_find(view, chunk, LINE_DIFF_HEADER);
int argc = 3;
diff_hdr = stage_diff_find(view, chunk, LINE_DIFF_HEADER);
apply_argv[argc++] = "-R";
apply_argv[argc++] = "-";
apply_argv[argc++] = NULL;
apply_argv[argc++] = "-R";
apply_argv[argc++] = "-";
apply_argv[argc++] = NULL;
- if (!io_run(&io, apply_argv, opt_cdup, IO_WR))
+ if (!io_run(&io, IO_WR, opt_cdup, apply_argv))
return FALSE;
if (!stage_diff_write(&io, diff_hdr, chunk) ||
return FALSE;
if (!stage_diff_write(&io, diff_hdr, chunk) ||