diff options
Diffstat (limited to '')
| -rw-r--r-- | arguments.c | 906 |
1 files changed, 906 insertions, 0 deletions
diff --git a/arguments.c b/arguments.c new file mode 100644 index 0000000..d0dc2d4 --- /dev/null +++ b/arguments.c @@ -0,0 +1,906 @@ +/* $OpenBSD$ */ + +/* + * Copyright (c) 2010 Nicholas Marriott <nicholas.marriott@gmail.com> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER + * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <sys/types.h> + +#include <ctype.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include "tmux.h" + +/* + * Manipulate command arguments. + */ + +/* List of argument values. */ +TAILQ_HEAD(args_values, args_value); + +/* Single arguments flag. */ +struct args_entry { + u_char flag; + struct args_values values; + u_int count; + RB_ENTRY(args_entry) entry; +}; + +/* Parsed argument flags and values. */ +struct args { + struct args_tree tree; + u_int count; + struct args_value *values; +}; + +/* Prepared command state. */ +struct args_command_state { + struct cmd_list *cmdlist; + char *cmd; + struct cmd_parse_input pi; +}; + +static struct args_entry *args_find(struct args *, u_char); + +static int args_cmp(struct args_entry *, struct args_entry *); +RB_GENERATE_STATIC(args_tree, args_entry, entry, args_cmp); + +/* Arguments tree comparison function. */ +static int +args_cmp(struct args_entry *a1, struct args_entry *a2) +{ + return (a1->flag - a2->flag); +} + +/* Find a flag in the arguments tree. */ +static struct args_entry * +args_find(struct args *args, u_char flag) +{ + struct args_entry entry; + + entry.flag = flag; + return (RB_FIND(args_tree, &args->tree, &entry)); +} + +/* Copy value. */ +static void +args_copy_value(struct args_value *to, struct args_value *from) +{ + to->type = from->type; + switch (from->type) { + case ARGS_NONE: + break; + case ARGS_COMMANDS: + to->cmdlist = from->cmdlist; + to->cmdlist->references++; + break; + case ARGS_STRING: + to->string = xstrdup(from->string); + break; + } +} + +/* Get value as string. */ +static const char * +args_value_as_string(struct args_value *value) +{ + switch (value->type) { + case ARGS_NONE: + return (""); + case ARGS_COMMANDS: + if (value->cached == NULL) + value->cached = cmd_list_print(value->cmdlist, 0); + return (value->cached); + case ARGS_STRING: + return (value->string); + } + fatalx("unexpected argument type"); +} + +/* Create an empty arguments set. */ +struct args * +args_create(void) +{ + struct args *args; + + args = xcalloc(1, sizeof *args); + RB_INIT(&args->tree); + return (args); +} + +/* Parse arguments into a new argument set. */ +struct args * +args_parse(const struct args_parse *parse, struct args_value *values, + u_int count, char **cause) +{ + struct args *args; + u_int i; + enum args_parse_type type; + struct args_value *value, *new; + u_char flag; + const char *found, *string, *s; + int optional_argument; + + if (count == 0) + return (args_create()); + + args = args_create(); + for (i = 1; i < count; /* nothing */) { + value = &values[i]; + if (value->type != ARGS_STRING) + break; + + string = value->string; + if (*string++ != '-' || *string == '\0') + break; + i++; + if (string[0] == '-' && string[1] == '\0') + break; + + for (;;) { + flag = *string++; + if (flag == '\0') + break; + if (flag == '?') { + args_free(args); + return (NULL); + } + if (!isalnum(flag)) { + xasprintf(cause, "invalid flag -%c", flag); + args_free(args); + return (NULL); + } + found = strchr(parse->template, flag); + if (found == NULL) { + xasprintf(cause, "unknown flag -%c", flag); + args_free(args); + return (NULL); + } + if (*++found != ':') { + log_debug("%s: -%c", __func__, flag); + args_set(args, flag, NULL); + continue; + } + if (*found == ':') { + optional_argument = 1; + found++; + } + new = xcalloc(1, sizeof *new); + if (*string != '\0') { + new->type = ARGS_STRING; + new->string = xstrdup(string); + } else { + if (i == count) { + if (optional_argument) { + log_debug("%s: -%c", __func__, + flag); + args_set(args, flag, NULL); + continue; + } + xasprintf(cause, + "-%c expects an argument", + flag); + args_free(args); + return (NULL); + } + if (values[i].type != ARGS_STRING) { + xasprintf(cause, + "-%c argument must be a string", + flag); + args_free(args); + return (NULL); + } + args_copy_value(new, &values[i++]); + } + s = args_value_as_string(new); + log_debug("%s: -%c = %s", __func__, flag, s); + args_set(args, flag, new); + break; + } + } + log_debug("%s: flags end at %u of %u", __func__, i, count); + if (i != count) { + for (/* nothing */; i < count; i++) { + value = &values[i]; + + s = args_value_as_string(value); + log_debug("%s: %u = %s (type %d)", __func__, i, s, + value->type); + + if (parse->cb != NULL) { + type = parse->cb(args, args->count, cause); + if (type == ARGS_PARSE_INVALID) { + args_free(args); + return (NULL); + } + } else + type = ARGS_PARSE_STRING; + + args->values = xrecallocarray(args->values, + args->count, args->count + 1, sizeof *args->values); + new = &args->values[args->count++]; + + switch (type) { + case ARGS_PARSE_INVALID: + fatalx("unexpected argument type"); + case ARGS_PARSE_STRING: + if (value->type != ARGS_STRING) { + xasprintf(cause, + "argument %u must be \"string\"", + args->count); + args_free(args); + return (NULL); + } + args_copy_value(new, value); + break; + case ARGS_PARSE_COMMANDS_OR_STRING: + args_copy_value(new, value); + break; + case ARGS_PARSE_COMMANDS: + if (value->type != ARGS_COMMANDS) { + xasprintf(cause, + "argument %u must be { commands }", + args->count); + args_free(args); + return (NULL); + } + args_copy_value(new, value); + break; + } + } + } + + if (parse->lower != -1 && args->count < (u_int)parse->lower) { + xasprintf(cause, + "too few arguments (need at least %u)", + parse->lower); + args_free(args); + return (NULL); + } + if (parse->upper != -1 && args->count > (u_int)parse->upper) { + xasprintf(cause, + "too many arguments (need at most %u)", + parse->upper); + args_free(args); + return (NULL); + } + return (args); +} + +/* Copy and expand a value. */ +static void +args_copy_copy_value(struct args_value *to, struct args_value *from, int argc, + char **argv) +{ + char *s, *expanded; + int i; + + to->type = from->type; + switch (from->type) { + case ARGS_NONE: + break; + case ARGS_STRING: + expanded = xstrdup(from->string); + for (i = 0; i < argc; i++) { + s = cmd_template_replace(expanded, argv[i], i + 1); + free(expanded); + expanded = s; + } + to->string = expanded; + break; + case ARGS_COMMANDS: + to->cmdlist = cmd_list_copy(from->cmdlist, argc, argv); + break; + } +} + +/* Copy an arguments set. */ +struct args * +args_copy(struct args *args, int argc, char **argv) +{ + struct args *new_args; + struct args_entry *entry; + struct args_value *value, *new_value; + u_int i; + + cmd_log_argv(argc, argv, "%s", __func__); + + new_args = args_create(); + RB_FOREACH(entry, args_tree, &args->tree) { + if (TAILQ_EMPTY(&entry->values)) { + for (i = 0; i < entry->count; i++) + args_set(new_args, entry->flag, NULL); + continue; + } + TAILQ_FOREACH(value, &entry->values, entry) { + new_value = xcalloc(1, sizeof *new_value); + args_copy_copy_value(new_value, value, argc, argv); + args_set(new_args, entry->flag, new_value); + } + } + if (args->count == 0) + return (new_args); + new_args->count = args->count; + new_args->values = xcalloc(args->count, sizeof *new_args->values); + for (i = 0; i < args->count; i++) { + new_value = &new_args->values[i]; + args_copy_copy_value(new_value, &args->values[i], argc, argv); + } + return (new_args); +} + +/* Free a value. */ +void +args_free_value(struct args_value *value) +{ + switch (value->type) { + case ARGS_NONE: + break; + case ARGS_STRING: + free(value->string); + break; + case ARGS_COMMANDS: + cmd_list_free(value->cmdlist); + break; + } + free(value->cached); +} + +/* Free values. */ +void +args_free_values(struct args_value *values, u_int count) +{ + u_int i; + + for (i = 0; i < count; i++) + args_free_value(&values[i]); +} + +/* Free an arguments set. */ +void +args_free(struct args *args) +{ + struct args_entry *entry; + struct args_entry *entry1; + struct args_value *value; + struct args_value *value1; + + args_free_values(args->values, args->count); + free(args->values); + + RB_FOREACH_SAFE(entry, args_tree, &args->tree, entry1) { + RB_REMOVE(args_tree, &args->tree, entry); + TAILQ_FOREACH_SAFE(value, &entry->values, entry, value1) { + TAILQ_REMOVE(&entry->values, value, entry); + args_free_value(value); + free(value); + } + free(entry); + } + + free(args); +} + +/* Convert arguments to vector. */ +void +args_to_vector(struct args *args, int *argc, char ***argv) +{ + char *s; + u_int i; + + *argc = 0; + *argv = NULL; + + for (i = 0; i < args->count; i++) { + switch (args->values[i].type) { + case ARGS_NONE: + break; + case ARGS_STRING: + cmd_append_argv(argc, argv, args->values[i].string); + break; + case ARGS_COMMANDS: + s = cmd_list_print(args->values[i].cmdlist, 0); + cmd_append_argv(argc, argv, s); + free(s); + break; + } + } +} + +/* Convert arguments from vector. */ +struct args_value * +args_from_vector(int argc, char **argv) +{ + struct args_value *values; + int i; + + values = xcalloc(argc, sizeof *values); + for (i = 0; i < argc; i++) { + values[i].type = ARGS_STRING; + values[i].string = xstrdup(argv[i]); + } + return (values); +} + +/* Add to string. */ +static void printflike(3, 4) +args_print_add(char **buf, size_t *len, const char *fmt, ...) +{ + va_list ap; + char *s; + size_t slen; + + va_start(ap, fmt); + slen = xvasprintf(&s, fmt, ap); + va_end(ap); + + *len += slen; + *buf = xrealloc(*buf, *len); + + strlcat(*buf, s, *len); + free(s); +} + +/* Add value to string. */ +static void +args_print_add_value(char **buf, size_t *len, struct args_value *value) +{ + char *expanded = NULL; + + if (**buf != '\0') + args_print_add(buf, len, " "); + + switch (value->type) { + case ARGS_NONE: + break; + case ARGS_COMMANDS: + expanded = cmd_list_print(value->cmdlist, 0); + args_print_add(buf, len, "{ %s }", expanded); + break; + case ARGS_STRING: + expanded = args_escape(value->string); + args_print_add(buf, len, "%s", expanded); + break; + } + free(expanded); +} + +/* Print a set of arguments. */ +char * +args_print(struct args *args) +{ + size_t len; + char *buf; + u_int i, j; + struct args_entry *entry; + struct args_value *value; + + len = 1; + buf = xcalloc(1, len); + + /* Process the flags first. */ + RB_FOREACH(entry, args_tree, &args->tree) { + if (!TAILQ_EMPTY(&entry->values)) + continue; + + if (*buf == '\0') + args_print_add(&buf, &len, "-"); + for (j = 0; j < entry->count; j++) + args_print_add(&buf, &len, "%c", entry->flag); + } + + /* Then the flags with arguments. */ + RB_FOREACH(entry, args_tree, &args->tree) { + TAILQ_FOREACH(value, &entry->values, entry) { + if (*buf != '\0') + args_print_add(&buf, &len, " -%c", entry->flag); + else + args_print_add(&buf, &len, "-%c", entry->flag); + args_print_add_value(&buf, &len, value); + } + } + + /* And finally the argument vector. */ + for (i = 0; i < args->count; i++) + args_print_add_value(&buf, &len, &args->values[i]); + + return (buf); +} + +/* Escape an argument. */ +char * +args_escape(const char *s) +{ + static const char dquoted[] = " #';${}%"; + static const char squoted[] = " \""; + char *escaped, *result; + int flags, quotes = 0; + + if (*s == '\0') { + xasprintf(&result, "''"); + return (result); + } + if (s[strcspn(s, dquoted)] != '\0') + quotes = '"'; + else if (s[strcspn(s, squoted)] != '\0') + quotes = '\''; + + if (s[0] != ' ' && + s[1] == '\0' && + (quotes != 0 || s[0] == '~')) { + xasprintf(&escaped, "\\%c", s[0]); + return (escaped); + } + + flags = VIS_OCTAL|VIS_CSTYLE|VIS_TAB|VIS_NL; + if (quotes == '"') + flags |= VIS_DQ; + utf8_stravis(&escaped, s, flags); + + if (quotes == '\'') + xasprintf(&result, "'%s'", escaped); + else if (quotes == '"') { + if (*escaped == '~') + xasprintf(&result, "\"\\%s\"", escaped); + else + xasprintf(&result, "\"%s\"", escaped); + } else { + if (*escaped == '~') + xasprintf(&result, "\\%s", escaped); + else + result = xstrdup(escaped); + } + free(escaped); + return (result); +} + +/* Return if an argument is present. */ +int +args_has(struct args *args, u_char flag) +{ + struct args_entry *entry; + + entry = args_find(args, flag); + if (entry == NULL) + return (0); + return (entry->count); +} + +/* Set argument value in the arguments tree. */ +void +args_set(struct args *args, u_char flag, struct args_value *value) +{ + struct args_entry *entry; + + entry = args_find(args, flag); + if (entry == NULL) { + entry = xcalloc(1, sizeof *entry); + entry->flag = flag; + entry->count = 1; + TAILQ_INIT(&entry->values); + RB_INSERT(args_tree, &args->tree, entry); + } else + entry->count++; + if (value != NULL && value->type != ARGS_NONE) + TAILQ_INSERT_TAIL(&entry->values, value, entry); +} + +/* Get argument value. Will be NULL if it isn't present. */ +const char * +args_get(struct args *args, u_char flag) +{ + struct args_entry *entry; + + if ((entry = args_find(args, flag)) == NULL) + return (NULL); + if (TAILQ_EMPTY(&entry->values)) + return (NULL); + return (TAILQ_LAST(&entry->values, args_values)->string); +} + +/* Get first argument. */ +u_char +args_first(struct args *args, struct args_entry **entry) +{ + *entry = RB_MIN(args_tree, &args->tree); + if (*entry == NULL) + return (0); + return ((*entry)->flag); +} + +/* Get next argument. */ +u_char +args_next(struct args_entry **entry) +{ + *entry = RB_NEXT(args_tree, &args->tree, *entry); + if (*entry == NULL) + return (0); + return ((*entry)->flag); +} + +/* Get argument count. */ +u_int +args_count(struct args *args) +{ + return (args->count); +} + +/* Get argument values. */ +struct args_value * +args_values(struct args *args) +{ + return (args->values); +} + +/* Get argument value. */ +struct args_value * +args_value(struct args *args, u_int idx) +{ + if (idx >= args->count) + return (NULL); + return (&args->values[idx]); +} + +/* Return argument as string. */ +const char * +args_string(struct args *args, u_int idx) +{ + if (idx >= args->count) + return (NULL); + return (args_value_as_string(&args->values[idx])); +} + +/* Make a command now. */ +struct cmd_list * +args_make_commands_now(struct cmd *self, struct cmdq_item *item, u_int idx, + int expand) +{ + struct args_command_state *state; + char *error; + struct cmd_list *cmdlist; + + state = args_make_commands_prepare(self, item, idx, NULL, 0, expand); + cmdlist = args_make_commands(state, 0, NULL, &error); + if (cmdlist == NULL) { + cmdq_error(item, "%s", error); + free(error); + } + else + cmdlist->references++; + args_make_commands_free(state); + return (cmdlist); +} + +/* Save bits to make a command later. */ +struct args_command_state * +args_make_commands_prepare(struct cmd *self, struct cmdq_item *item, u_int idx, + const char *default_command, int wait, int expand) +{ + struct args *args = cmd_get_args(self); + struct cmd_find_state *target = cmdq_get_target(item); + struct client *tc = cmdq_get_target_client(item); + struct args_value *value; + struct args_command_state *state; + const char *cmd; + + state = xcalloc(1, sizeof *state); + + if (idx < args->count) { + value = &args->values[idx]; + if (value->type == ARGS_COMMANDS) { + state->cmdlist = value->cmdlist; + state->cmdlist->references++; + return (state); + } + cmd = value->string; + } else { + if (default_command == NULL) + fatalx("argument out of range"); + cmd = default_command; + } + + + if (expand) + state->cmd = format_single_from_target(item, cmd); + else + state->cmd = xstrdup(cmd); + log_debug("%s: %s", __func__, state->cmd); + + if (wait) + state->pi.item = item; + cmd_get_source(self, &state->pi.file, &state->pi.line); + state->pi.c = tc; + if (state->pi.c != NULL) + state->pi.c->references++; + cmd_find_copy_state(&state->pi.fs, target); + + return (state); +} + +/* Return argument as command. */ +struct cmd_list * +args_make_commands(struct args_command_state *state, int argc, char **argv, + char **error) +{ + struct cmd_parse_result *pr; + char *cmd, *new_cmd; + int i; + + if (state->cmdlist != NULL) { + if (argc == 0) + return (state->cmdlist); + return (cmd_list_copy(state->cmdlist, argc, argv)); + } + + cmd = xstrdup(state->cmd); + for (i = 0; i < argc; i++) { + new_cmd = cmd_template_replace(cmd, argv[i], i + 1); + log_debug("%s: %%%u %s: %s", __func__, i + 1, argv[i], new_cmd); + free(cmd); + cmd = new_cmd; + } + log_debug("%s: %s", __func__, cmd); + + pr = cmd_parse_from_string(cmd, &state->pi); + free(cmd); + switch (pr->status) { + case CMD_PARSE_ERROR: + *error = pr->error; + return (NULL); + case CMD_PARSE_SUCCESS: + return (pr->cmdlist); + } + fatalx("invalid parse return state"); +} + +/* Free commands state. */ +void +args_make_commands_free(struct args_command_state *state) +{ + if (state->cmdlist != NULL) + cmd_list_free(state->cmdlist); + if (state->pi.c != NULL) + server_client_unref(state->pi.c); + free(state->cmd); + free(state); +} + +/* Get prepared command. */ +char * +args_make_commands_get_command(struct args_command_state *state) +{ + struct cmd *first; + int n; + char *s; + + if (state->cmdlist != NULL) { + first = cmd_list_first(state->cmdlist); + if (first == NULL) + return (xstrdup("")); + return (xstrdup(cmd_get_entry(first)->name)); + } + n = strcspn(state->cmd, " ,"); + xasprintf(&s, "%.*s", n, state->cmd); + return (s); +} + +/* Get first value in argument. */ +struct args_value * +args_first_value(struct args *args, u_char flag) +{ + struct args_entry *entry; + + if ((entry = args_find(args, flag)) == NULL) + return (NULL); + return (TAILQ_FIRST(&entry->values)); +} + +/* Get next value in argument. */ +struct args_value * +args_next_value(struct args_value *value) +{ + return (TAILQ_NEXT(value, entry)); +} + +/* Convert an argument value to a number. */ +long long +args_strtonum(struct args *args, u_char flag, long long minval, + long long maxval, char **cause) +{ + const char *errstr; + long long ll; + struct args_entry *entry; + struct args_value *value; + + if ((entry = args_find(args, flag)) == NULL) { + *cause = xstrdup("missing"); + return (0); + } + value = TAILQ_LAST(&entry->values, args_values); + if (value == NULL || + value->type != ARGS_STRING || + value->string == NULL) { + *cause = xstrdup("missing"); + return (0); + } + + ll = strtonum(value->string, minval, maxval, &errstr); + if (errstr != NULL) { + *cause = xstrdup(errstr); + return (0); + } + + *cause = NULL; + return (ll); +} + +/* Convert an argument to a number which may be a percentage. */ +long long +args_percentage(struct args *args, u_char flag, long long minval, + long long maxval, long long curval, char **cause) +{ + const char *value; + struct args_entry *entry; + + if ((entry = args_find(args, flag)) == NULL) { + *cause = xstrdup("missing"); + return (0); + } + value = TAILQ_LAST(&entry->values, args_values)->string; + return (args_string_percentage(value, minval, maxval, curval, cause)); +} + +/* Convert a string to a number which may be a percentage. */ +long long +args_string_percentage(const char *value, long long minval, long long maxval, + long long curval, char **cause) +{ + const char *errstr; + long long ll; + size_t valuelen = strlen(value); + char *copy; + + if (value[valuelen - 1] == '%') { + copy = xstrdup(value); + copy[valuelen - 1] = '\0'; + + ll = strtonum(copy, 0, 100, &errstr); + free(copy); + if (errstr != NULL) { + *cause = xstrdup(errstr); + return (0); + } + ll = (curval * ll) / 100; + if (ll < minval) { + *cause = xstrdup("too small"); + return (0); + } + if (ll > maxval) { + *cause = xstrdup("too large"); + return (0); + } + } else { + ll = strtonum(value, minval, maxval, &errstr); + if (errstr != NULL) { + *cause = xstrdup(errstr); + return (0); + } + } + + *cause = NULL; + return (ll); +} |