![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
index 60932d46482f8aca0468609f96f2fe47f2efa6ee..ee0d0d63eb32833202af271a8134291c9c32f738 100644 (file)
--- a/tig.c
+++ b/tig.c
#define S_ISGITLINK(mode) (((mode) & S_IFMT) == 0160000)
/* Some ASCII-shorthands fitted into the ncurses namespace. */
+#define KEY_CTL(x) ((x) & 0x1f) /* KEY_CTL(A) == ^A == \1 */
#define KEY_TAB '\t'
#define KEY_RETURN '\r'
#define KEY_ESC 27
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,
#define string_add(dst, from, src) \
string_ncopy_do(dst + (from), sizeof(dst) - (from), src, sizeof(src))
-static void
+static size_t
string_expand(char *dst, size_t dstlen, const char *src, int tabsize)
{
size_t size, pos;
}
dst[size] = 0;
+ return pos;
}
static char *
return !env || argv_from_string(argv, &argc, env);
}
+static void
+argv_free(const char *argv[])
+{
+ int argc;
+
+ if (!argv)
+ return;
+ for (argc = 0; argv[argc]; argc++)
+ free((void *) argv[argc]);
+ argv[0] = NULL;
+}
+
+static size_t
+argv_size(const char **argv)
+{
+ int argc = 0;
+
+ while (argv && argv[argc])
+ argc++;
+
+ return argc;
+}
+
+DEFINE_ALLOCATOR(argv_realloc, const char *, SIZEOF_ARG)
+
+static bool
+argv_append(const char ***argv, const char *arg)
+{
+ size_t argc = argv_size(*argv);
+
+ if (!argv_realloc(argv, argc, 2))
+ return FALSE;
+
+ (*argv)[argc++] = strdup(arg);
+ (*argv)[argc] = NULL;
+ return TRUE;
+}
+
+static bool
+argv_append_array(const char ***dst_argv, const char *src_argv[])
+{
+ int i;
+
+ for (i = 0; src_argv && src_argv[i]; i++)
+ if (!argv_append(dst_argv, src_argv[i]))
+ return FALSE;
+ return TRUE;
+}
+
+static bool
+argv_copy(const char ***dst, const char *src[])
+{
+ int argc;
+
+ for (argc = 0; src[argc]; argc++)
+ if (!argv_append(dst, src[argc]))
+ return FALSE;
+ return TRUE;
+}
+
/*
* Executing external commands.
};
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. */
+ pid_t pid; /* PID of spawned process. */
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. */
};
static void
-io_reset(struct io *io)
+io_init(struct io *io)
{
+ memset(io, 0, sizeof(*io));
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
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);
if (io->pipe != -1)
close(io->pipe);
free(io->buf);
- io_reset(io);
+ io_init(io);
while (pid > 0) {
int status;
}
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 };
+ 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;
- } 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 (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) {
- io->pipe = pipefds[!!(io->type == IO_WR)];
+ io->pipe = pipefds[!!(type == IO_WR)];
return TRUE;
}
} else {
- if (io->type != IO_FG) {
+ if (type != IO_FG) {
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);
close(pipefds[1]);
}
- if (io->dir && *io->dir && chdir(io->dir) == -1)
+ if (dir && *dir && chdir(dir) == -1)
exit(errno);
- execvp(io->argv[0], (char *const*) io->argv);
+ execvp(argv[0], (char *const*) argv);
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
-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)
{
- 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)
{
- struct io io = {};
-
- if (!io_format(&io, dir, IO_FG, argv, FORMAT_NONE))
- return FALSE;
- return io_complete(&io);
-}
-
-static bool
-io_run_append(const char **argv, enum format_flags flags, 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);
+ return io_complete(IO_FG, argv, dir, -1);
}
static bool
-io_run_rd(struct io *io, const char **argv, const char *dir, enum format_flags flags)
+io_run_append(const char **argv, int fd)
{
- return io_format(io, dir, IO_RD, argv, flags) && io_start(io);
+ return io_complete(IO_AP, argv, NULL, fd);
}
static bool
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
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;
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_(MOVE_LAST_LINE, "Move cursor to last line"), \
\
REQ_GROUP("Scrolling") \
+ REQ_(SCROLL_FIRST_COL, "Scroll to the first line columns"), \
REQ_(SCROLL_LEFT, "Scroll two columns left"), \
REQ_(SCROLL_RIGHT, "Scroll two columns right"), \
REQ_(SCROLL_LINE_UP, "Scroll one line up"), \
REQ_(OPTIONS, "Open option menu"), \
REQ_(TOGGLE_LINENO, "Toggle line numbers"), \
REQ_(TOGGLE_DATE, "Toggle date display"), \
- REQ_(TOGGLE_DATE_SHORT, "Toggle short (date-only) dates"), \
REQ_(TOGGLE_AUTHOR, "Toggle author display"), \
REQ_(TOGGLE_REV_GRAPH, "Toggle revision graph visualization"), \
REQ_(TOGGLE_REFS, "Toggle reference display (tags/branches)"), \
static bool opt_line_graphics = TRUE;
static bool opt_rev_graph = FALSE;
static bool opt_show_refs = TRUE;
+static bool opt_untracked_dirs_content = TRUE;
static int opt_num_interval = 5;
static double opt_hscroll = 0.50;
static double opt_scale_split_view = 2.0 / 3.0;
static signed char opt_is_inside_work_tree = -1; /* set to TRUE or FALSE */
static char opt_editor[SIZEOF_STR] = "";
static FILE *opt_tty = NULL;
+static const char **opt_diff_argv = NULL;
+static const char **opt_rev_argv = NULL;
+static const char **opt_file_argv = NULL;
#define is_initial_commit() (!get_ref_head())
#define is_head_commit(rev) (!strcmp((rev), "HEAD") || (get_ref_head() && !strcmp(rev, get_ref_head()->id)))
{ KEY_TAB, REQ_VIEW_NEXT },
{ KEY_RETURN, REQ_ENTER },
{ KEY_UP, REQ_PREVIOUS },
+ { KEY_CTL('P'), REQ_PREVIOUS },
{ KEY_DOWN, REQ_NEXT },
+ { KEY_CTL('N'), REQ_NEXT },
{ 'R', REQ_REFRESH },
{ KEY_F(5), REQ_REFRESH },
{ 'O', REQ_MAXIMIZE },
{ KEY_HOME, REQ_MOVE_FIRST_LINE },
{ KEY_END, REQ_MOVE_LAST_LINE },
{ KEY_NPAGE, REQ_MOVE_PAGE_DOWN },
+ { KEY_CTL('D'), REQ_MOVE_PAGE_DOWN },
{ ' ', REQ_MOVE_PAGE_DOWN },
{ KEY_PPAGE, REQ_MOVE_PAGE_UP },
+ { KEY_CTL('U'), REQ_MOVE_PAGE_UP },
{ 'b', REQ_MOVE_PAGE_UP },
{ '-', REQ_MOVE_PAGE_UP },
/* Scrolling */
+ { '|', REQ_SCROLL_FIRST_COL },
{ KEY_LEFT, REQ_SCROLL_LEFT },
{ KEY_RIGHT, REQ_SCROLL_RIGHT },
{ KEY_IC, REQ_SCROLL_LINE_UP },
+ { KEY_CTL('Y'), REQ_SCROLL_LINE_UP },
{ KEY_DC, REQ_SCROLL_LINE_DOWN },
+ { KEY_CTL('E'), REQ_SCROLL_LINE_DOWN },
{ 'w', REQ_SCROLL_PAGE_UP },
{ 's', REQ_SCROLL_PAGE_DOWN },
{ 'z', REQ_STOP_LOADING },
{ 'v', REQ_SHOW_VERSION },
{ 'r', REQ_SCREEN_REDRAW },
+ { KEY_CTL('L'), REQ_SCREEN_REDRAW },
{ 'o', REQ_OPTIONS },
{ '.', REQ_TOGGLE_LINENO },
{ 'D', REQ_TOGGLE_DATE },
if (!strcasecmp(key_table[i].name, name))
return key_table[i].value;
+ if (strlen(name) == 2 && name[0] == '^' && isprint(*name))
+ return (int)name[1] & 0x1f;
if (strlen(name) == 1 && isprint(*name))
return (int) *name;
-
return ERR;
}
static const char *
get_key_name(int key_value)
{
- static char key_char[] = "'X'";
+ static char key_char[] = "'X'\0";
const char *seq = NULL;
int key;
if (key_table[key].value == key_value)
seq = key_table[key].name;
- if (seq == NULL &&
- key_value < 127 &&
- isprint(key_value)) {
- key_char[1] = (char) key_value;
+ if (seq == NULL && key_value < 0x7f) {
+ char *s = key_char + 1;
+
+ if (key_value >= 0x20) {
+ *s++ = key_value;
+ } else {
+ *s++ = '^';
+ *s++ = 0x40 | (key_value & 0x1f);
+ }
+ *s++ = '\'';
+ *s++ = '\0';
seq = key_char;
}
struct run_request {
enum keymap keymap;
int key;
- const char *argv[SIZEOF_ARG];
+ const char **argv;
};
static struct run_request *run_request;
DEFINE_ALLOCATOR(realloc_run_requests, struct run_request, 8)
static enum request
-add_run_request(enum keymap keymap, int key, int argc, const char **argv)
+add_run_request(enum keymap keymap, int key, const char **argv)
{
struct run_request *req;
- if (argc >= ARRAY_SIZE(req->argv) - 1)
- return REQ_NONE;
-
if (!realloc_run_requests(&run_request, run_requests, 1))
return REQ_NONE;
req = &run_request[run_requests];
req->keymap = keymap;
req->key = key;
- req->argv[0] = NULL;
+ req->argv = NULL;
- if (!format_argv(req->argv, argv, FORMAT_NONE))
+ if (!argv_copy(&req->argv, argv))
return REQ_NONE;
return REQ_NONE + ++run_requests;
const char *checkout[] = { "git", "checkout", "%(branch)", NULL };
const char *commit[] = { "git", "commit", NULL };
const char *gc[] = { "git", "gc", NULL };
- struct {
- enum keymap keymap;
- int key;
- int argc;
- const char **argv;
- } reqs[] = {
- { KEYMAP_MAIN, 'C', ARRAY_SIZE(cherry_pick) - 1, cherry_pick },
- { KEYMAP_STATUS, 'C', ARRAY_SIZE(commit) - 1, commit },
- { KEYMAP_BRANCH, 'C', ARRAY_SIZE(checkout) - 1, checkout },
- { KEYMAP_GENERIC, 'G', ARRAY_SIZE(gc) - 1, gc },
+ struct run_request reqs[] = {
+ { KEYMAP_MAIN, 'C', cherry_pick },
+ { KEYMAP_STATUS, 'C', commit },
+ { KEYMAP_BRANCH, 'C', checkout },
+ { KEYMAP_GENERIC, 'G', gc },
};
int i;
if (req != reqs[i].key)
continue;
- req = add_run_request(reqs[i].keymap, reqs[i].key, reqs[i].argc, reqs[i].argv);
+ req = add_run_request(reqs[i].keymap, reqs[i].key, reqs[i].argv);
if (req != REQ_NONE)
add_keybinding(reqs[i].keymap, req, reqs[i].key);
}
if (!strcmp(argv[0], "commit-encoding"))
return parse_string(opt_encoding, argv[2], sizeof(opt_encoding));
+ if (!strcmp(argv[0], "status-untracked-dirs"))
+ return parse_bool(&opt_untracked_dirs_content, argv[2]);
+
config_msg = "Unknown variable name";
return ERR;
}
}
}
if (request == REQ_UNKNOWN && *argv[2]++ == '!')
- request = add_run_request(keymap, key, argc - 2, argv + 2);
+ request = add_run_request(keymap, key, argv + 2);
if (request == REQ_UNKNOWN) {
config_msg = "Unknown request name";
return ERR;
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))
const char *home = getenv("HOME");
const char *tigrc_user = getenv("TIGRC_USER");
const char *tigrc_system = getenv("TIGRC_SYSTEM");
+ const char *tig_diff_opts = getenv("TIG_DIFF_OPTS");
char buf[SIZEOF_STR];
if (!tigrc_system)
* that conflict with keybindings. */
add_builtin_run_requests();
+ if (!opt_diff_argv && tig_diff_opts && *tig_diff_opts) {
+ static const char *diff_opts[SIZEOF_ARG] = { NULL };
+ int argc = 0;
+
+ if (!string_format(buf, "%s", tig_diff_opts) ||
+ !argv_from_string(diff_opts, &argc, buf))
+ die("TIG_DIFF_OPTS contains too many arguments");
+ else if (!argv_copy(&opt_diff_argv, diff_opts))
+ die("Failed to format TIG_DIFF_OPTS arguments");
+ }
+
return OK;
}
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. */
bool has_scrolled; /* View was scrolled. */
/* Loading */
+ const char **argv; /* Shell command arguments. */
+ const char *dir; /* Directory from which to execute. */
struct io io;
struct io *pipe;
time_t start_time;
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[] = {
- 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, ""),
+ VIEW_(STATUS, "status", &status_ops, TRUE, ""),
+ VIEW_(STAGE, "stage", &stage_ops, TRUE, ""),
};
#define VIEW(req) (&views[(req) - REQ_OFFSET - 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.
+ */
+
static inline void
set_view_attr(struct view *view, enum line_type type)
{
}
waddnstr(view->win, string, len);
- }
- if (trimmed && use_tilde) {
- set_view_attr(view, LINE_DELIMITER);
- waddch(view->win, '~');
- col++;
+
+ if (trimmed && use_tilde) {
+ set_view_attr(view, LINE_DELIMITER);
+ waddch(view->win, '~');
+ col++;
+ }
}
return col;
static bool
draw_text(struct view *view, enum line_type type, const char *string, bool trim)
{
- view->col += draw_chars(view, type, string, view->width + view->yoffset - view->col, trim);
+ char text[SIZEOF_STR];
+
+ do {
+ size_t pos = string_expand(text, sizeof(text), string, opt_tab_size);
+
+ view->col += draw_chars(view, type, text, view->width + view->yoffset - view->col, trim);
+ string += pos;
+ } while (*string && view->width + view->yoffset > view->col);
+
return view->width + view->yoffset <= view->col;
}
}
}
+
+/*
+ * Option management
+ */
+
static void
toggle_enum_option_do(unsigned int *opt, const char *help,
const struct enum_map *map, size_t size)
assert(view_is_displayed(view));
switch (request) {
+ case REQ_SCROLL_FIRST_COL:
+ view->yoffset = 0;
+ redraw_view_from(view, 0);
+ report("");
+ return;
case REQ_SCROLL_LEFT:
if (view->yoffset == 0) {
report("Cannot scroll beyond the first column");
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 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, bool first)
{
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];
size_t bufpos = 0;
+ if (!strcmp(arg, "%(fileargs)")) {
+ if (!argv_append_array(dst_argv, opt_file_argv))
+ break;
+ continue;
+
+ } else if (!strcmp(arg, "%(diffargs)")) {
+ if (!argv_append_array(dst_argv, opt_diff_argv))
+ break;
+ continue;
+
+ } else if (!strcmp(arg, "%(revargs)") ||
+ (first && !strcmp(arg, "%(commit)"))) {
+ if (!argv_append_array(dst_argv, opt_rev_argv))
+ break;
+ continue;
+ }
+
while (arg) {
char *next = strstr(arg, "%(");
int len = next - arg;
const char *value;
- if (!next || noreplace) {
+ if (!next || !replace) {
len = strlen(arg);
value = "";
@@ -3203,16 +3272,13 @@ 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;
- arg = next && !noreplace ? strchr(next, ')') + 1 : NULL;
+ arg = next && replace ? strchr(next, ')') + 1 : NULL;
}
- dst_argv[argc] = strdup(buf);
- if (!dst_argv[argc])
+ if (!argv_append(dst_argv, buf))
break;
}
- dst_argv[argc] = NULL;
-
return src_argv[argc] == 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, !view->prev);
+}
+
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
{
if (view->pipe)
end_update(view, TRUE);
+ argv_free(view->argv);
return io_open(&view->io, "%s/%s", opt_cdup[0] ? opt_cdup : ".", name);
}
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;
}
string_copy_rev(view->ref, view->id);
}
- if (!io_start(&view->io))
+ if (view->argv && view->argv[0] &&
+ !io_run(&view->io, IO_RD, view->dir, view->argv))
return FALSE;
setup_update(view, view->id);
end_update(view, TRUE);
} else if (io_eof(view->pipe)) {
- report("");
+ if (view_is_displayed(view))
+ report("");
end_update(view, FALSE);
}
open_run_request(enum request request)
{
struct run_request *req = get_run_request(request);
- const char *argv[ARRAY_SIZE(req->argv)] = { NULL };
+ const char **argv = NULL;
if (!req) {
report("Unknown run request");
return;
}
- if (format_argv(argv, req->argv, FORMAT_ALL))
+ if (format_argv(&argv, req->argv, TRUE, FALSE))
open_external_viewer(argv, NULL);
- free_argv(argv);
+ if (argv)
+ argv_free(argv);
+ free(argv);
}
/*
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:
move_view(view, request);
break;
+ case REQ_SCROLL_FIRST_COL:
case REQ_SCROLL_LEFT:
case REQ_SCROLL_RIGHT:
case REQ_SCROLL_LINE_DOWN:
break;
case REQ_VIEW_PAGER:
+ if (view == NULL) {
+ if (!io_open(&VIEW(REQ_VIEW_PAGER)->io, ""))
+ die("Failed to open stdin");
+ open_view(view, request, OPEN_PREPARED);
+ break;
+ }
+
if (!VIEW(REQ_VIEW_PAGER)->pipe && !VIEW(REQ_VIEW_PAGER)->lines) {
report("No pager content, press %s to run command from prompt",
get_key(view->keymap, REQ_PROMPT));
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);
}
}
}
-static bool
-open_commit_parent_menu(char buf[SIZEOF_STR], int *parents)
-{
- char rev[SIZEOF_REV];
- const char *revlist_argv[] = {
- "git", "log", "--no-color", "-1", "--pretty=format:%s", rev, NULL
- };
- struct menu_item *items;
- char text[SIZEOF_STR];
- bool ok = TRUE;
- int i;
-
- items = calloc(*parents + 1, sizeof(*items));
- if (!items)
- return FALSE;
-
- for (i = 0; i < *parents; i++) {
- string_copy_rev(rev, &buf[SIZEOF_REV * i]);
- if (!io_run_buf(revlist_argv, text, sizeof(text)) ||
- !(items[i].text = strdup(text))) {
- ok = FALSE;
- break;
- }
- }
-
- if (ok) {
- *parents = 0;
- ok = prompt_menu("Select parent", items, parents);
- }
- for (i = 0; items[i].text; i++)
- free((char *) items[i].text);
- free(items);
- return ok;
-}
-
-static bool
-select_commit_parent(const char *id, char rev[SIZEOF_REV], const char *path)
-{
- char buf[SIZEOF_STR * 4];
- const char *revlist_argv[] = {
- "git", "log", "--no-color", "-1",
- "--pretty=format:%P", id, "--", path, NULL
- };
- int parents;
-
- if (!io_run_buf(revlist_argv, buf, sizeof(buf)) ||
- (parents = strlen(buf) / 40) < 0) {
- report("Failed to get parent information");
- return FALSE;
-
- } else if (parents == 0) {
- if (path)
- report("Path '%s' does not exist in the parent", path);
- else
- report("The selected commit has no parents");
- return FALSE;
- }
-
- if (parents == 1)
- parents = 0;
- else if (!open_commit_parent_menu(buf, &parents))
- return FALSE;
-
- string_copy_rev(rev, &buf[41 * parents]);
- return TRUE;
-}
-
/*
* Pager backend
*/
@@ -4028,13 +4049,10 @@ select_commit_parent(const char *id, char rev[SIZEOF_REV], const char *path)
static bool
pager_draw(struct view *view, struct line *line, unsigned int lineno)
{
- char text[SIZEOF_STR];
-
if (opt_line_number && draw_lineno(view, lineno))
return TRUE;
- string_expand(text, sizeof(text), line->data, opt_tab_size);
- draw_text(view, line->type, text, TRUE);
+ draw_text(view, line->type, line->data, TRUE);
return TRUE;
}
static const char *diff_argv[SIZEOF_ARG] = {
"git", "show", "--pretty=fuller", "--no-color", "--root",
- "--patch-with-stat", "--find-copies-harder", "-C", "%(commit)", NULL
+ "--patch-with-stat", "--find-copies-harder", "-C",
+ "%(diffargs)", "%(commit)", "--", "%(fileargs)", NULL
};
+static bool
+diff_read(struct view *view, char *data)
+{
+ if (!data) {
+ /* Fall back to retry if no diff will be shown. */
+ if (view->lines == 0 && opt_file_argv) {
+ int pos = argv_size(view->argv)
+ - argv_size(opt_file_argv) - 1;
+
+ if (pos > 0 && !strcmp(view->argv[pos], "--")) {
+ for (; view->argv[pos]; pos++) {
+ free((void *) view->argv[pos]);
+ view->argv[pos] = NULL;
+ }
+
+ if (view->pipe)
+ io_done(view->pipe);
+ if (io_run(&view->io, IO_RD, view->dir, view->argv))
+ return FALSE;
+ }
+ }
+ return TRUE;
+ }
+
+ return pager_read(view, data);
+}
+
static struct view_ops diff_ops = {
"line",
diff_argv,
NULL,
- pager_read,
+ diff_read,
pager_draw,
pager_request,
pager_grep,
"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);
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;
}
- io_done(view->pipe);
- view->io = io;
*read_date = TRUE;
return FALSE;
}
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");
- 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);
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:
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);
}
break;
case LINE_TREE_FILE:
- flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
+ flags = view_is_displayed(view) ? OPEN_SPLIT : OPEN_DEFAULT;
request = REQ_VIEW_BLOB;
break;
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] = {
{
switch (request) {
case REQ_EDIT:
- open_blob_editor();
+ open_blob_editor(view->vid);
return REQ_NONE;
default:
return pager_request(view, request, line);
* 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. */
const char *author; /* Author of the commit. */
struct time time; /* Date from the author ident. */
char filename[128]; /* Name of file. */
- bool has_previous; /* Was a "previous" line detected. */
+ char parent_id[SIZEOF_REV]; /* Parent/previous SHA1 ID. */
+ char parent_filename[128]; /* Parent/previous name of file. */
};
struct blame {
blame_open(struct view *view)
{
char path[SIZEOF_STR];
+ size_t i;
if (!view->prev && *opt_prefix) {
string_copy(path, 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;
}
+ /* First pass: remove multiple references to the same commit. */
+ for (i = 0; i < view->lines; i++) {
+ struct blame *blame = view->line[i].data;
+
+ if (blame->commit && blame->commit->id[0])
+ blame->commit->id[0] = 0;
+ else
+ blame->commit = NULL;
+ }
+
+ /* Second pass: free existing references. */
+ for (i = 0; i < view->lines; i++) {
+ struct blame *blame = view->line[i].data;
+
+ if (blame->commit)
+ free(blame->commit);
+ }
+
setup_update(view, opt_file);
string_format(view->ref, "%s ...", opt_file);
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 || !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;
}
- io_done(view->pipe);
- view->io = io;
*read_file = FALSE;
return FALSE;
string_ncopy(commit->title, line, strlen(line));
} else if (match_blame_header("previous ", &line)) {
- commit->has_previous = TRUE;
+ if (strlen(line) <= SIZEOF_REV)
+ return FALSE;
+ string_copy_rev(commit->parent_id, line);
+ line += SIZEOF_REV;
+ string_ncopy(commit->parent_filename, line, strlen(line));
} else if (match_blame_header("filename ", &line)) {
string_ncopy(commit->filename, line, strlen(line));
struct blame *blame = line->data;
struct time *time = NULL;
const char *id = NULL, *author = NULL;
- char text[SIZEOF_STR];
if (blame->commit && *blame->commit->filename) {
id = blame->commit->id;
if (draw_lineno(view, lineno))
return TRUE;
- string_expand(text, sizeof(text), blame->text, opt_tab_size);
- draw_text(view, LINE_DEFAULT, text, TRUE);
+ draw_text(view, LINE_DEFAULT, blame->text, TRUE);
return TRUE;
}
static void
setup_blame_parent_line(struct view *view, struct blame *blame)
{
+ char from[SIZEOF_REF + SIZEOF_STR];
+ char to[SIZEOF_REF + SIZEOF_STR];
const char *diff_tree_argv[] = {
- "git", "diff-tree", "-U0", blame->commit->id,
- "--", blame->commit->filename, NULL
+ "git", "diff", "--no-textconv", "--no-extdiff", "--no-color",
+ "-U0", from, to, "--", NULL
};
- struct io io = {};
+ struct io io;
int parent_lineno = -1;
int blamed_lineno = -1;
char *line;
- if (!io_run(&io, diff_tree_argv, NULL, IO_RD))
+ if (!string_format(from, "%s:%s", opt_ref, opt_file) ||
+ !string_format(to, "%s:%s", blame->commit->id, blame->commit->filename) ||
+ !io_run(&io, IO_RD, NULL, diff_tree_argv))
return;
while ((line = io_get(&io, '\n', TRUE))) {
static enum request
blame_request(struct view *view, enum request request, struct line *line)
{
- enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
+ enum open_flags flags = view_is_displayed(view) ? OPEN_SPLIT : OPEN_DEFAULT;
struct blame *blame = line->data;
switch (request) {
break;
case REQ_PARENT:
- if (check_blame_commit(blame, TRUE) &&
- select_commit_parent(blame->commit->id, opt_ref,
- blame->commit->filename)) {
- string_copy(opt_file, blame->commit->filename);
+ if (!check_blame_commit(blame, TRUE))
+ break;
+ if (!*blame->commit->parent_id) {
+ report("The selected commit has no parents");
+ } else {
+ string_copy_rev(opt_ref, blame->commit->parent_id);
+ string_copy(opt_file, blame->commit->parent_filename);
setup_blame_parent_line(view, blame);
open_view(view, REQ_VIEW_BLAME, OPEN_REFRESH);
}
"-C", "-M", "HEAD", "--", view->vid, NULL
};
- if (!blame->commit->has_previous) {
+ if (!*blame->commit->parent_id) {
diff_index_argv[1] = "diff";
diff_index_argv[2] = "--no-color";
diff_index_argv[6] = "--";
return REQ_NONE;
case REQ_ENTER:
- if (branch->ref == &branch_all) {
- const char *all_branches_argv[] = {
- "git", "log", "--no-color", "--pretty=raw", "--parents",
- "--topo-order", "--all", NULL
- };
- struct view *main_view = VIEW(REQ_VIEW_MAIN);
+ {
+ const struct ref *ref = branch->ref;
+ const char *all_branches_argv[] = {
+ "git", "log", "--no-color", "--pretty=raw", "--parents",
+ "--topo-order",
+ ref == &branch_all ? "--all" : ref->name, NULL
+ };
+ struct view *main_view = VIEW(REQ_VIEW_MAIN);
- if (!prepare_update(main_view, all_branches_argv, NULL)) {
- report("Failed to load view of all branches");
- return REQ_NONE;
- }
+ if (!prepare_update(main_view, all_branches_argv, NULL))
+ report("Failed to load view of all branches");
+ else
open_view(view, REQ_VIEW_MAIN, OPEN_PREPARED | OPEN_SPLIT);
- } else {
- open_view(view, REQ_VIEW_MAIN, OPEN_SPLIT);
- }
return REQ_NONE;
-
+ }
default:
return request;
}
"--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;
}
@@ -5557,9 +5622,9 @@ status_run(struct view *view, const char *argv[], char status, enum line_type ty
{
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);
};
static const char *status_list_other_argv[] = {
- "git", "ls-files", "-z", "--others", "--exclude-standard", opt_prefix, NULL
+ "git", "ls-files", "-z", "--others", "--exclude-standard", opt_prefix, NULL, NULL,
};
static const char *status_list_no_head_argv[] = {
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))) {
return FALSE;
}
+ if (!opt_untracked_dirs_content)
+ status_list_other_argv[ARRAY_SIZE(status_list_other_argv) - 2] = "--directory";
+
if (!status_run(view, status_diff_files_argv, 0, LINE_STAT_UNSTAGED) ||
!status_run(view, status_list_other_argv, '?', LINE_STAT_UNTRACKED))
return FALSE;
die("line type %d not handled in switch", line->type);
}
- split = view_is_displayed(view) ? OPEN_SPLIT : 0;
+ split = view_is_displayed(view) ? OPEN_SPLIT : OPEN_DEFAULT;
open_view(view, REQ_VIEW_STAGE, OPEN_PREPARED | split);
if (view_is_displayed(VIEW(REQ_VIEW_STAGE))) {
if (status) {
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:
- 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);
@@ -5997,7 +6065,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)
{
- struct io io = {};
+ struct io io;
bool result;
if (!status_update_prepare(&io, type))
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;
"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);
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) ||
static const char *main_argv[SIZEOF_ARG] = {
"git", "log", "--no-color", "--pretty=raw", "--parents",
- "--topo-order", "%(head)", NULL
+ "--topo-order", "%(diffargs)", "%(revargs)",
+ "--", "%(fileargs)", NULL
};
static bool
static enum request
main_request(struct view *view, enum request request, struct line *line)
{
- enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
+ enum open_flags flags = view_is_displayed(view) ? OPEN_SPLIT : OPEN_DEFAULT;
switch (request) {
case REQ_ENTER:
+ if (view_is_displayed(view) && display[0] != view)
+ maximize_view(view);
open_view(view, REQ_VIEW_DIFF, flags);
break;
case REQ_REFRESH:
keypad(status_win, TRUE);
wbkgdset(status_win, get_line_attr(LINE_STATUS));
+#if defined(NCURSES_VERSION_PATCH) && (NCURSES_VERSION_PATCH >= 20080119)
+ set_tabsize(opt_tab_size);
+#else
TABSIZE = opt_tab_size;
+#endif
term = getenv("XTERM_VERSION") ? NULL : getenv("COLORTERM");
if (term && !strcmp(term, "gnome-terminal")) {
{
struct view *view;
int i, key, cursor_y, cursor_x;
- bool loading = FALSE;
if (prompt_position)
input_mode = TRUE;
while (TRUE) {
+ bool loading = FALSE;
+
foreach_view (view, i) {
update_view(view);
if (view_is_displayed(view) && view->has_scrolled &&
va_end(args);
}
+static const char ***filter_args;
+
+static int
+read_filter_args(char *name, size_t namelen, char *value, size_t valuelen)
+{
+ return argv_append(filter_args, name) ? OK : ERR;
+}
+
+static void
+filter_rev_parse(const char ***args, const char *arg1, const char *arg2, const char *argv[])
+{
+ const char *rev_parse_argv[SIZEOF_ARG] = { "git", "rev-parse", arg1, arg2 };
+ const char **all_argv = NULL;
+
+ filter_args = args;
+ if (!argv_append_array(&all_argv, rev_parse_argv) ||
+ !argv_append_array(&all_argv, argv) ||
+ !io_run_load(all_argv, "\n", read_filter_args) == ERR)
+ die("Failed to split arguments");
+ argv_free(all_argv);
+ free(all_argv);
+}
+
+static void
+filter_options(const char *argv[])
+{
+ filter_rev_parse(&opt_file_argv, "--no-revs", "--no-flags", argv);
+ filter_rev_parse(&opt_diff_argv, "--no-revs", "--flags", argv);
+ filter_rev_parse(&opt_rev_argv, "--symbolic", "--revs-only", argv);
+}
+
static enum request
parse_options(int argc, const char *argv[])
{
enum request request = REQ_VIEW_MAIN;
const char *subcommand;
bool seen_dashdash = FALSE;
- /* XXX: This is vulnerable to the user overriding options
- * required for the main view parser. */
- const char *custom_argv[SIZEOF_ARG] = {
- "git", "log", "--no-color", "--pretty=raw", "--parents",
- "--topo-order", NULL
- };
- int i, j = 6;
+ const char **filter_argv = NULL;
+ int i;
- if (!isatty(STDIN_FILENO)) {
- io_open(&VIEW(REQ_VIEW_PAGER)->io, "");
+ if (!isatty(STDIN_FILENO))
return REQ_VIEW_PAGER;
- }
if (argc <= 1)
- return REQ_NONE;
+ return REQ_VIEW_MAIN;
subcommand = argv[1];
if (!strcmp(subcommand, "status")) {
subcommand = NULL;
}
- if (subcommand) {
- custom_argv[1] = subcommand;
- j = 2;
- }
-
for (i = 1 + !!subcommand; i < argc; i++) {
const char *opt = argv[i];
- if (seen_dashdash || !strcmp(opt, "--")) {
+ if (seen_dashdash) {
+ argv_append(&opt_file_argv, opt);
+ continue;
+
+ } else if (!strcmp(opt, "--")) {
seen_dashdash = TRUE;
+ continue;
} else if (!strcmp(opt, "-v") || !strcmp(opt, "--version")) {
printf("tig version %s\n", TIG_VERSION);
} else if (!strcmp(opt, "-h") || !strcmp(opt, "--help")) {
printf("%s\n", usage);
quit(0);
+
+ } else if (!strcmp(opt, "--all")) {
+ argv_append(&opt_rev_argv, opt);
+ continue;
}
- custom_argv[j++] = opt;
- if (j >= ARRAY_SIZE(custom_argv))
+ if (!argv_append(&filter_argv, opt))
die("command too long");
}
- if (!prepare_update(VIEW(request), custom_argv, NULL))
- die("Failed to format arguments");
+ if (filter_argv)
+ filter_options(filter_argv);
return request;
}
if (load_refs() == ERR)
die("Failed to load refs.");
- foreach_view (view, i)
+ foreach_view (view, i) {
+ if (getenv(view->cmd_env))
+ warn("Use of the %s environment variable is deprecated,"
+ " use options or TIG_DIFF_ARGS instead",
+ view->cmd_env);
if (!argv_from_env(view->ops->argv, view->cmd_env))
die("Too many arguments in the `%s` environment variable",
view->cmd_env);
+ }
init_display();
- if (request != REQ_NONE)
- open_view(NULL, request, OPEN_PREPARED);
- request = request == REQ_NONE ? REQ_VIEW_MAIN : REQ_NONE;
-
while (view_driver(display[current_view], request)) {
int key = get_input(0);