static enum request
open_run_request(struct view *view, enum request request)
{
struct run_request *req = get_run_request(request);
const char **argv = NULL;
bool confirmed = FALSE;
request = REQ_NONE;
if (!req) {
report("Unknown run request");
return request;
}
if (!argv_format(view->env, &argv, req->argv, FALSE, TRUE)) {
report("Failed to format arguments");
return REQ_NONE;
}
if (req->flags.internal) {
request = run_prompt_command(view, argv);
} else {
confirmed = !req->flags.confirm;
if (req->flags.confirm) {
char cmd[SIZEOF_STR], prompt[SIZEOF_STR];
const char *and_exit = req->flags.exit ? " and exit" : "";
if (argv_to_string(argv, cmd, sizeof(cmd), " ") &&
string_format(prompt, "Run `%s`%s?", cmd, and_exit) &&
prompt_yesno(prompt)) {
confirmed = TRUE;
}
}
if (confirmed && argv_remove_quotes(argv))
open_external_viewer(argv, NULL, req->flags.silent,
!req->flags.exit, FALSE, "");
}
if (argv)
argv_free(argv);
free(argv);
if (request == REQ_NONE) {
if (req->flags.confirm && !confirmed)
request = REQ_NONE;
else if (req->flags.exit)
request = REQ_QUIT;
else if (!req->flags.internal && watch_dirty(&view->watch))
request = REQ_REFRESH;
}
return request;
}
char *
argv_to_string_alloc(const char *argv[], const char *sep)
{
size_t i, size = 0;
char *buf;
for (i = 0; argv[i]; i++)
size += strlen(argv[i]);
buf = malloc(size + 1);
if (buf && argv_to_string(argv, buf, size + 1, sep))
return buf;
free(buf);
return NULL;
}
/**
* @brief parses command line inputs and packages into a commotion message
* @param argv[] commands input by the user
* @param argc number of commands and flags input
*/
static co_msg_t *cli_parse_argv(char *argv[], const int argc) {
CHECK(argv != NULL, "No input.");
char payload[MSG_MAX_PAYLOAD];
memset(payload, '\0', sizeof(payload));
co_msg_t *message;
if(argc > 0) {
char **args = argv + 1;
CHECK(argv_to_string(args, argc, payload, MSG_MAX_PAYLOAD), "Failed to parse argv.");
message = co_msg_create(argv[0], payload);
} else {
message = co_msg_create(argv[0], NULL);
}
CHECK(message != NULL, "Invalid message.");
return message;
error:
free(message);
return NULL;
}
ACE_BEGIN_VERSIONED_NAMESPACE_DECL
int
ACE_OS::argv_to_string (ACE_TCHAR **argv,
ACE_TCHAR *&buf,
bool substitute_env_args,
bool quote_args)
{
if (argv == 0 || argv[0] == 0)
return 0;
int argc;
for (argc = 0; argv[argc] != 0; ++argc)
continue;
return argv_to_string (argc,
argv,
buf,
substitute_env_args,
quote_args);
}
static void
help_open_keymap_run_requests(struct help_request_iterator *iterator)
{
struct view *view = iterator->view;
struct keymap *keymap = iterator->keymap;
char buf[SIZEOF_STR];
const char *group = "External commands:";
int i;
for (i = 0; TRUE; i++) {
struct run_request *req = get_run_request(REQ_NONE + i + 1);
const char *key;
if (!req)
break;
if (req->keymap != keymap)
continue;
key = get_key_name(req->key);
if (!*key)
key = "(no key defined)";
if (iterator->add_title && help_open_keymap_title(view, keymap))
return;
iterator->add_title = FALSE;
if (group) {
add_line_text(view, group, LINE_HELP_GROUP);
group = NULL;
}
if (!argv_to_string(req->argv, buf, sizeof(buf), " "))
return;
add_line_format(view, LINE_DEFAULT, " %-25s `%s`", key, buf);
}
}
static enum request
open_run_request(struct view *view, enum request request)
{
struct run_request *req = get_run_request(request);
const char **argv = NULL;
bool confirmed = FALSE;
request = REQ_NONE;
if (!req) {
report("Unknown run request");
return request;
}
if (argv_format(view->env, &argv, req->argv, FALSE, TRUE)) {
if (req->internal) {
char cmd[SIZEOF_STR];
if (argv_to_string(argv, cmd, sizeof(cmd), " ")) {
request = run_prompt_command(view, cmd);
}
}
else {
confirmed = !req->confirm;
if (req->confirm) {
char cmd[SIZEOF_STR], prompt[SIZEOF_STR];
const char *and_exit = req->exit ? " and exit" : "";
if (argv_to_string(argv, cmd, sizeof(cmd), " ") &&
string_format(prompt, "Run `%s`%s?", cmd, and_exit) &&
prompt_yesno(prompt)) {
confirmed = TRUE;
}
}
if (confirmed && argv_remove_quotes(argv)) {
if (req->silent)
io_run_bg(argv);
else
open_external_viewer(argv, NULL, !req->exit, "");
}
}
}
if (argv)
argv_free(argv);
free(argv);
if (request == REQ_NONE) {
if (req->confirm && !confirmed)
request = REQ_NONE;
else if (req->exit)
request = REQ_QUIT;
else if (view_has_flags(view, VIEW_REFRESH) && !view->unrefreshable)
request = REQ_REFRESH;
}
return request;
}
enum request
run_prompt_command(struct view *view, const char *argv[])
{
enum request request;
const char *cmd = argv[0];
size_t cmdlen = cmd ? strlen(cmd) : 0;
if (!cmd)
return REQ_NONE;
if (string_isnumber(cmd)) {
int lineno = view->pos.lineno + 1;
if (parse_int(&lineno, cmd, 0, view->lines + 1) == SUCCESS) {
if (!lineno)
lineno = 1;
select_view_line(view, lineno - 1);
report_clear();
} else {
report("Unable to parse '%s' as a line number", cmd);
}
} else if (iscommit(cmd)) {
int lineno;
if (!(view->ops->column_bits & view_column_bit(ID))) {
report("Jumping to commits is not supported by the %s view", view->name);
return REQ_NONE;
}
for (lineno = 0; lineno < view->lines; lineno++) {
struct view_column_data column_data = {};
struct line *line = &view->line[lineno];
if (view->ops->get_column_data(view, line, &column_data) &&
column_data.id &&
!strncasecmp(column_data.id, cmd, cmdlen)) {
string_ncopy(view->env->search, cmd, cmdlen);
select_view_line(view, lineno);
report_clear();
return REQ_NONE;
}
}
report("Unable to find commit '%s'", view->env->search);
return REQ_NONE;
} else if (cmdlen > 1 && (cmd[0] == '/' || cmd[0] == '?')) {
char search[SIZEOF_STR];
if (!argv_to_string(argv, search, sizeof(search), " ")) {
report("Failed to copy search string");
return REQ_NONE;
}
if (!strcmp(search + 1, view->env->search))
return cmd[0] == '/' ? REQ_FIND_NEXT : REQ_FIND_PREV;
string_ncopy(view->env->search, search + 1, strlen(search + 1));
return cmd[0] == '/' ? REQ_SEARCH : REQ_SEARCH_BACK;
} else if (cmdlen > 1 && cmd[0] == '!') {
struct view *next = &pager_view;
bool copied;
/* Trim the leading '!'. */
argv[0] = cmd + 1;
copied = argv_format(view->env, &next->argv, argv, FALSE, TRUE);
argv[0] = cmd;
if (!copied) {
report("Argument formatting failed");
} else {
/* When running random commands, initially show the
* command in the title. However, it maybe later be
* overwritten if a commit line is selected. */
argv_to_string(next->argv, next->ref, sizeof(next->ref), " ");
next->dir = NULL;
open_pager_view(view, OPEN_PREPARED | OPEN_WITH_STDERR);
}
} else if (!strcmp(cmd, "save-display")) {
const char *path = argv[1] ? argv[1] : "tig-display.txt";
if (!save_display(path))
report("Failed to save screen to %s", path);
else
report("Saved screen to %s", path);
} else if (!strcmp(cmd, "exec")) {
struct run_request req = { view->keymap, {}, argv + 1 };
enum status_code code = parse_run_request_flags(&req.flags, argv + 1);
if (code != SUCCESS) {
report("Failed to execute command: %s", get_status_message(code));
} else {
return exec_run_request(view, &req);
}
} else if (!strcmp(cmd, "toggle")) {
enum view_flag flags = VIEW_NO_FLAGS;
enum status_code code = prompt_toggle(view, argv, &flags);
const char *action = get_status_message(code);
if (code != SUCCESS) {
report("%s", action);
return REQ_NONE;
}
prompt_update_display(flags);
if (*action)
report("%s", action);
} else if (!strcmp(cmd, "script")) {
if (is_script_executing()) {
report("Scripts cannot be run from scripts");
} else if (!open_script(argv[1])) {
report("Failed to open %s", argv[1]);
}
} else {
struct key key = {};
enum status_code code;
enum view_flag flags = VIEW_NO_FLAGS;
/* Try :<key> */
key.modifiers.multibytes = 1;
string_ncopy(key.data.bytes, cmd, cmdlen);
request = get_keybinding(view->keymap, &key, 1);
if (request != REQ_NONE)
return request;
/* Try :<command> */
request = get_request(cmd);
if (request != REQ_UNKNOWN)
return request;
code = set_option(argv[0], argv_size(argv + 1), &argv[1]);
if (code != SUCCESS) {
report("%s", get_status_message(code));
return REQ_NONE;
}
if (!strcmp(cmd, "set")) {
struct prompt_toggle *toggle;
toggle = find_prompt_toggle(option_toggles, ARRAY_SIZE(option_toggles),
"", argv[1], strlen(argv[1]));
if (toggle)
flags = toggle->flags;
}
if (flags) {
prompt_update_display(flags);
} else {
request = view_can_refresh(view) ? REQ_REFRESH : REQ_SCREEN_REDRAW;
if (!strcmp(cmd, "color"))
init_colors();
resize_display();
redraw_display(TRUE);
}
}
return REQ_NONE;
}
/**
* Run a command without using the shell.
*
* return 0 if the command run and exited with 0 status; Otherwise
* return -1
*
*/
int run_program(struct netcf *ncf, const char *const *argv, char **output)
{
pid_t childpid = -1;
int exitstatus, waitret;
char *argv_str;
int ret = -1;
char errbuf[128];
char *outtext = NULL;
int outfd = -1;
FILE *outfile = NULL;
size_t outlen;
if (!output)
output = &outtext;
argv_str = argv_to_string(argv);
ERR_NOMEM(argv_str == NULL, ncf);
exec_program(ncf, argv, argv_str, &childpid, &outfd);
ERR_BAIL(ncf);
printf("Attempting to execute %s\n", argv_str);
outfile = fdopen(outfd, "r");
ERR_THROW_STRERROR(outfile == NULL,ncf, EEXEC,
"Failed to create file stream for output while executing '%s': %s",
argv_str, errbuf);
*output = fread_file(outfile, &outlen);
ERR_THROW_STRERROR(*output == NULL, ncf, EEXEC,
"Error while reading output from execution of '%s': %s",
argv_str, errbuf);
/* finished with the stream. Close it so the child can exit. */
fclose(outfile);
outfile = NULL;
while ((waitret = waitpid(childpid, &exitstatus, 0) == -1) &&
errno == EINTR) {
/* empty loop */
}
ERR_THROW_STRERROR(waitret == -1, ncf, EEXEC,
"Failed waiting for completion of '%s': %s",
argv_str, errbuf);
ERR_THROW(!WIFEXITED(exitstatus) && WIFSIGNALED(exitstatus), ncf, EEXEC,
"'%s' terminated by signal: %d",
argv_str, WTERMSIG(exitstatus));
ERR_THROW(!WIFEXITED(exitstatus), ncf, EEXEC,
"'%s' terminated improperly", argv_str);
ERR_THROW(WEXITSTATUS(exitstatus) == EXIT_ENOENT, ncf, EEXEC,
"Running '%s' program not found", argv_str);
ERR_THROW(WEXITSTATUS(exitstatus) == EXIT_CANNOT_INVOKE, ncf, EEXEC,
"Running '%s' program located but not usable", argv_str);
ERR_THROW(WEXITSTATUS(exitstatus) == EXIT_SIGMASK, ncf, EEXEC,
"Running '%s' failed to reset child process signal mask",
argv_str);
ERR_THROW(WEXITSTATUS(exitstatus) == EXIT_DUP2, ncf, EEXEC,
"Running '%s' failed to dup2 child process stdout/stderr",
argv_str);
ERR_THROW(WEXITSTATUS(exitstatus) == EXIT_INVALID_IN_THIS_STATE, ncf, EINVALIDOP,
"Running '%s' operation is invalid in this state",
argv_str);
ERR_THROW(WEXITSTATUS(exitstatus) != 0, ncf, EEXEC,
"Running '%s' failed with exit code %d: %s",
argv_str, WEXITSTATUS(exitstatus), *output);
ret = 0;
error:
if (outfile)
fclose(outfile);
else if (outfd >= 0)
close(outfd);
FREE(outtext);
FREE(argv_str);
return ret;
}
enum request
run_prompt_command(struct view *view, const char *argv[])
{
enum request request;
const char *cmd = argv[0];
size_t cmdlen = cmd ? strlen(cmd) : 0;
if (!cmd)
return REQ_NONE;
if (string_isnumber(cmd)) {
int lineno = view->pos.lineno + 1;
if (parse_int(&lineno, cmd, 1, view->lines + 1) == SUCCESS) {
select_view_line(view, lineno - 1);
report_clear();
} else {
report("Unable to parse '%s' as a line number", cmd);
}
} else if (iscommit(cmd)) {
string_ncopy(view->env->search, cmd, cmdlen);
return REQ_JUMP_COMMIT;
} else if (cmdlen > 1 && (cmd[0] == '/' || cmd[0] == '?')) {
char search[SIZEOF_STR];
if (!argv_to_string(argv, search, sizeof(search), " ")) {
report("Failed to copy search string");
return REQ_NONE;
}
if (!strcmp(search + 1, view->env->search))
return cmd[0] == '/' ? REQ_FIND_NEXT : REQ_FIND_PREV;
string_ncopy(view->env->search, search + 1, strlen(search + 1));
return cmd[0] == '/' ? REQ_SEARCH : REQ_SEARCH_BACK;
} else if (cmdlen > 1 && cmd[0] == '!') {
struct view *next = &pager_view;
bool copied;
/* Trim the leading '!'. */
argv[0] = cmd + 1;
copied = argv_format(view->env, &next->argv, argv, FALSE, TRUE);
argv[0] = cmd;
if (!copied) {
report("Argument formatting failed");
} else {
/* When running random commands, initially show the
* command in the title. However, it maybe later be
* overwritten if a commit line is selected. */
argv_to_string(next->argv, next->ref, sizeof(next->ref), " ");
next->dir = NULL;
open_pager_view(view, OPEN_PREPARED | OPEN_WITH_STDERR);
}
} else if (!strcmp(cmd, "toggle")) {
char action[SIZEOF_STR] = "";
enum view_flag flags = prompt_toggle(view, argv, action);
int i;
if (flags & VIEW_RESET_DISPLAY) {
resize_display();
redraw_display(TRUE);
}
foreach_displayed_view(view, i) {
if (view_has_flags(view, flags) && !view->unrefreshable)
reload_view(view);
else
redraw_view(view);
}
if (*action)
report("%s", action);
} else {
