circlecloud/tmux
1
0
Fork 0
mirror of https://github.com/tmux/tmux.git synced 2024-11-16 09:28:51 +00:00
Code Issues Projects Releases Wiki Activity
88ee5a1a00
tmux/arguments.c

332 lines
7.1 KiB
C
Raw Normal View History

No need for $Id$ now.
2014-11-08 12:27:43 +00:00
/* $OpenBSD$ */
Sync OpenBSD patchset 829: Clean up and simplify tmux command argument parsing. Originally, tmux commands were parsed in the client process into a struct with the command data which was then serialised and sent to the server to be executed. The parsing was later moved into the server (an argv was sent from the client), but the parse step and intermediate struct was kept. This change removes that struct and the separate parse step. Argument parsing and printing is now common to all commands (in arguments.c) with each command left with just an optional check function (to validate the arguments at parse time), the exec function and a function to set up any key bindings (renamed from the old init function). This is overall more simple and consistent. There should be no changes to any commands behaviour or syntax although as this touches every command please watch for any unexpected changes.
2011-01-07 14:45:34 +00:00
/*
I no longer use my SourceForge address so replace it.
2016-01-19 15:59:12 +00:00
* Copyright (c) 2010 Nicholas Marriott <nicholas.marriott@gmail.com>
Sync OpenBSD patchset 829: Clean up and simplify tmux command argument parsing. Originally, tmux commands were parsed in the client process into a struct with the command data which was then serialised and sent to the server to be executed. The parsing was later moved into the server (an argv was sent from the client), but the parse step and intermediate struct was kept. This change removes that struct and the separate parse step. Argument parsing and printing is now common to all commands (in arguments.c) with each command left with just an optional check function (to validate the arguments at parse time), the exec function and a function to set up any key bindings (renamed from the old init function). This is overall more simple and consistent. There should be no changes to any commands behaviour or syntax although as this touches every command please watch for any unexpected changes.
2011-01-07 14:45:34 +00:00
*
* 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 <stdlib.h>
#include <string.h>
Include unistd.h as it is the standard location for getopt(). OK millert@
2013-11-17 20:19:36 +00:00
#include <unistd.h>
Sync OpenBSD patchset 829: Clean up and simplify tmux command argument parsing. Originally, tmux commands were parsed in the client process into a struct with the command data which was then serialised and sent to the server to be executed. The parsing was later moved into the server (an argv was sent from the client), but the parse step and intermediate struct was kept. This change removes that struct and the separate parse step. Argument parsing and printing is now common to all commands (in arguments.c) with each command left with just an optional check function (to validate the arguments at parse time), the exec function and a function to set up any key bindings (renamed from the old init function). This is overall more simple and consistent. There should be no changes to any commands behaviour or syntax although as this touches every command please watch for any unexpected changes.
2011-01-07 14:45:34 +00:00
#include "tmux.h"
Instead of eating 1024 bytes or so for the arguments of each command, save memory by using an RB tree. From Tiago Cunha.
2013-05-31 12:19:34 +00:00
/*
* Manipulate command arguments.
*/
Support multiple occurances of the same argument. Use this for a new flag -e to new-window, split-window, respawn-window, respawn-pane to pass environment variables into the newly created process. From Steffen Christgau in GitHub issue 1697.
2019-04-28 20:05:50 +00:00
struct args_value {
char *value;
TAILQ_ENTRY(args_value) entry;
};
TAILQ_HEAD(args_values, args_value);
struct args_entry can go into arguments.c.
2015-08-29 23:19:52 +00:00
struct args_entry {
u_char flag;
Support multiple occurances of the same argument. Use this for a new flag -e to new-window, split-window, respawn-window, respawn-pane to pass environment variables into the newly created process. From Steffen Christgau in GitHub issue 1697.
2019-04-28 20:05:50 +00:00
struct args_values values;
struct args_entry can go into arguments.c.
2015-08-29 23:19:52 +00:00
RB_ENTRY(args_entry) entry;
};
Some more static.
2016-10-10 13:54:47 +00:00
static struct args_entry *args_find(struct args *, u_char);
Instead of eating 1024 bytes or so for the arguments of each command, save memory by using an RB tree. From Tiago Cunha.
2013-05-31 12:19:34 +00:00
Some more static.
2016-10-10 13:54:47 +00:00
static int args_cmp(struct args_entry *, struct args_entry *);
RB_GENERATE_STATIC(args_tree, args_entry, entry, args_cmp);
Instead of eating 1024 bytes or so for the arguments of each command, save memory by using an RB tree. From Tiago Cunha.
2013-05-31 12:19:34 +00:00
/* Arguments tree comparison function. */
Some more static.
2016-10-10 13:54:47 +00:00
static int
Instead of eating 1024 bytes or so for the arguments of each command, save memory by using an RB tree. From Tiago Cunha.
2013-05-31 12:19:34 +00:00
args_cmp(struct args_entry *a1, struct args_entry *a2)
{
return (a1->flag - a2->flag);
}
/* Find a flag in the arguments tree. */
Some more static.
2016-10-10 13:54:47 +00:00
static struct args_entry *
Instead of eating 1024 bytes or so for the arguments of each command, save memory by using an RB tree. From Tiago Cunha.
2013-05-31 12:19:34 +00:00
args_find(struct args *args, u_char ch)
{
struct args_entry entry;
entry.flag = ch;
return (RB_FIND(args_tree, &args->tree, &entry));
}
Sync OpenBSD patchset 829: Clean up and simplify tmux command argument parsing. Originally, tmux commands were parsed in the client process into a struct with the command data which was then serialised and sent to the server to be executed. The parsing was later moved into the server (an argv was sent from the client), but the parse step and intermediate struct was kept. This change removes that struct and the separate parse step. Argument parsing and printing is now common to all commands (in arguments.c) with each command left with just an optional check function (to validate the arguments at parse time), the exec function and a function to set up any key bindings (renamed from the old init function). This is overall more simple and consistent. There should be no changes to any commands behaviour or syntax although as this touches every command please watch for any unexpected changes.
2011-01-07 14:45:34 +00:00
/* Parse an argv and argc into a new argument set. */
struct args *
args_parse(const char *template, int argc, char **argv)
{
struct args *args;
int opt;
args = xcalloc(1, sizeof *args);
optreset = 1;
optind = 1;
while ((opt = getopt(argc, argv, template)) != -1) {
Instead of eating 1024 bytes or so for the arguments of each command, save memory by using an RB tree. From Tiago Cunha.
2013-05-31 12:19:34 +00:00
if (opt < 0)
Sync OpenBSD patchset 829: Clean up and simplify tmux command argument parsing. Originally, tmux commands were parsed in the client process into a struct with the command data which was then serialised and sent to the server to be executed. The parsing was later moved into the server (an argv was sent from the client), but the parse step and intermediate struct was kept. This change removes that struct and the separate parse step. Argument parsing and printing is now common to all commands (in arguments.c) with each command left with just an optional check function (to validate the arguments at parse time), the exec function and a function to set up any key bindings (renamed from the old init function). This is overall more simple and consistent. There should be no changes to any commands behaviour or syntax although as this touches every command please watch for any unexpected changes.
2011-01-07 14:45:34 +00:00
continue;
Couple of fixes from cppcheck via Tiago Cunha.
2014-01-15 11:44:18 +00:00
if (opt == '?' || strchr(template, opt) == NULL) {
Instead of eating 1024 bytes or so for the arguments of each command, save memory by using an RB tree. From Tiago Cunha.
2013-05-31 12:19:34 +00:00
args_free(args);
Sync OpenBSD patchset 829: Clean up and simplify tmux command argument parsing. Originally, tmux commands were parsed in the client process into a struct with the command data which was then serialised and sent to the server to be executed. The parsing was later moved into the server (an argv was sent from the client), but the parse step and intermediate struct was kept. This change removes that struct and the separate parse step. Argument parsing and printing is now common to all commands (in arguments.c) with each command left with just an optional check function (to validate the arguments at parse time), the exec function and a function to set up any key bindings (renamed from the old init function). This is overall more simple and consistent. There should be no changes to any commands behaviour or syntax although as this touches every command please watch for any unexpected changes.
2011-01-07 14:45:34 +00:00
return (NULL);
}
Instead of eating 1024 bytes or so for the arguments of each command, save memory by using an RB tree. From Tiago Cunha.
2013-05-31 12:19:34 +00:00
args_set(args, opt, optarg);
Sync OpenBSD patchset 829: Clean up and simplify tmux command argument parsing. Originally, tmux commands were parsed in the client process into a struct with the command data which was then serialised and sent to the server to be executed. The parsing was later moved into the server (an argv was sent from the client), but the parse step and intermediate struct was kept. This change removes that struct and the separate parse step. Argument parsing and printing is now common to all commands (in arguments.c) with each command left with just an optional check function (to validate the arguments at parse time), the exec function and a function to set up any key bindings (renamed from the old init function). This is overall more simple and consistent. There should be no changes to any commands behaviour or syntax although as this touches every command please watch for any unexpected changes.
2011-01-07 14:45:34 +00:00
}
argc -= optind;
argv += optind;
args->argc = argc;
args->argv = cmd_copy_argv(argc, argv);
return (args);
}
/* Free an arguments set. */
void
args_free(struct args *args)
{
Instead of eating 1024 bytes or so for the arguments of each command, save memory by using an RB tree. From Tiago Cunha.
2013-05-31 12:19:34 +00:00
struct args_entry *entry;
struct args_entry *entry1;
Support multiple occurances of the same argument. Use this for a new flag -e to new-window, split-window, respawn-window, respawn-pane to pass environment variables into the newly created process. From Steffen Christgau in GitHub issue 1697.
2019-04-28 20:05:50 +00:00
struct args_value *value;
struct args_value *value1;
Sync OpenBSD patchset 829: Clean up and simplify tmux command argument parsing. Originally, tmux commands were parsed in the client process into a struct with the command data which was then serialised and sent to the server to be executed. The parsing was later moved into the server (an argv was sent from the client), but the parse step and intermediate struct was kept. This change removes that struct and the separate parse step. Argument parsing and printing is now common to all commands (in arguments.c) with each command left with just an optional check function (to validate the arguments at parse time), the exec function and a function to set up any key bindings (renamed from the old init function). This is overall more simple and consistent. There should be no changes to any commands behaviour or syntax although as this touches every command please watch for any unexpected changes.
2011-01-07 14:45:34 +00:00
cmd_free_argv(args->argc, args->argv);
Instead of eating 1024 bytes or so for the arguments of each command, save memory by using an RB tree. From Tiago Cunha.
2013-05-31 12:19:34 +00:00
RB_FOREACH_SAFE(entry, args_tree, &args->tree, entry1) {
RB_REMOVE(args_tree, &args->tree, entry);
Support multiple occurances of the same argument. Use this for a new flag -e to new-window, split-window, respawn-window, respawn-pane to pass environment variables into the newly created process. From Steffen Christgau in GitHub issue 1697.
2019-04-28 20:05:50 +00:00
TAILQ_FOREACH_SAFE(value, &entry->values, entry, value1) {
TAILQ_REMOVE(&entry->values, value, entry);
free(value->value);
free(value);
}
Instead of eating 1024 bytes or so for the arguments of each command, save memory by using an RB tree. From Tiago Cunha.
2013-05-31 12:19:34 +00:00
free(entry);
}
Sync OpenBSD patchset 829: Clean up and simplify tmux command argument parsing. Originally, tmux commands were parsed in the client process into a struct with the command data which was then serialised and sent to the server to be executed. The parsing was later moved into the server (an argv was sent from the client), but the parse step and intermediate struct was kept. This change removes that struct and the separate parse step. Argument parsing and printing is now common to all commands (in arguments.c) with each command left with just an optional check function (to validate the arguments at parse time), the exec function and a function to set up any key bindings (renamed from the old init function). This is overall more simple and consistent. There should be no changes to any commands behaviour or syntax although as this touches every command please watch for any unexpected changes.
2011-01-07 14:45:34 +00:00
Sync OpenBSD patchset 1150: xfree is not particularly helpful, remove it. From Thomas Adam.
2012-07-11 19:34:16 +00:00
free(args);
Sync OpenBSD patchset 829: Clean up and simplify tmux command argument parsing. Originally, tmux commands were parsed in the client process into a struct with the command data which was then serialised and sent to the server to be executed. The parsing was later moved into the server (an argv was sent from the client), but the parse step and intermediate struct was kept. This change removes that struct and the separate parse step. Argument parsing and printing is now common to all commands (in arguments.c) with each command left with just an optional check function (to validate the arguments at parse time), the exec function and a function to set up any key bindings (renamed from the old init function). This is overall more simple and consistent. There should be no changes to any commands behaviour or syntax although as this touches every command please watch for any unexpected changes.
2011-01-07 14:45:34 +00:00
}
Do not set a limit on the length of commands when printing them.
2015-11-27 15:06:43 +00:00
/* 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);
}
Support multiple occurances of the same argument. Use this for a new flag -e to new-window, split-window, respawn-window, respawn-pane to pass environment variables into the newly created process. From Steffen Christgau in GitHub issue 1697.
2019-04-28 20:05:50 +00:00
/* Add value to string. */
static void
args_print_add_value(char **buf, size_t *len, struct args_entry *entry,
struct args_value *value)
{
Break the argument escaping code into a separate function and use it to escape key bindings in list-keys. Also escape ~ and ; and $ properly.
2019-05-23 14:03:44 +00:00
char *escaped;
Support multiple occurances of the same argument. Use this for a new flag -e to new-window, split-window, respawn-window, respawn-pane to pass environment variables into the newly created process. From Steffen Christgau in GitHub issue 1697.
2019-04-28 20:05:50 +00:00
if (**buf != '\0')
args_print_add(buf, len, " -%c ", entry->flag);
else
args_print_add(buf, len, "-%c ", entry->flag);
Break the argument escaping code into a separate function and use it to escape key bindings in list-keys. Also escape ~ and ; and $ properly.
2019-05-23 14:03:44 +00:00
escaped = args_escape(value->value);
args_print_add(buf, len, "%s", escaped);
Support multiple occurances of the same argument. Use this for a new flag -e to new-window, split-window, respawn-window, respawn-pane to pass environment variables into the newly created process. From Steffen Christgau in GitHub issue 1697.
2019-04-28 20:05:50 +00:00
free(escaped);
}
/* Add argument to string. */
static void
args_print_add_argument(char **buf, size_t *len, const char *argument)
{
Break the argument escaping code into a separate function and use it to escape key bindings in list-keys. Also escape ~ and ; and $ properly.
2019-05-23 14:03:44 +00:00
char *escaped;
Support multiple occurances of the same argument. Use this for a new flag -e to new-window, split-window, respawn-window, respawn-pane to pass environment variables into the newly created process. From Steffen Christgau in GitHub issue 1697.
2019-04-28 20:05:50 +00:00
if (**buf != '\0')
args_print_add(buf, len, " ");
Break the argument escaping code into a separate function and use it to escape key bindings in list-keys. Also escape ~ and ; and $ properly.
2019-05-23 14:03:44 +00:00
escaped = args_escape(argument);
args_print_add(buf, len, "%s", escaped);
Support multiple occurances of the same argument. Use this for a new flag -e to new-window, split-window, respawn-window, respawn-pane to pass environment variables into the newly created process. From Steffen Christgau in GitHub issue 1697.
2019-04-28 20:05:50 +00:00
free(escaped);
}
Sync OpenBSD patchset 829: Clean up and simplify tmux command argument parsing. Originally, tmux commands were parsed in the client process into a struct with the command data which was then serialised and sent to the server to be executed. The parsing was later moved into the server (an argv was sent from the client), but the parse step and intermediate struct was kept. This change removes that struct and the separate parse step. Argument parsing and printing is now common to all commands (in arguments.c) with each command left with just an optional check function (to validate the arguments at parse time), the exec function and a function to set up any key bindings (renamed from the old init function). This is overall more simple and consistent. There should be no changes to any commands behaviour or syntax although as this touches every command please watch for any unexpected changes.
2011-01-07 14:45:34 +00:00
/* Print a set of arguments. */
Do not set a limit on the length of commands when printing them.
2015-11-27 15:06:43 +00:00
char *
args_print(struct args *args)
Sync OpenBSD patchset 829: Clean up and simplify tmux command argument parsing. Originally, tmux commands were parsed in the client process into a struct with the command data which was then serialised and sent to the server to be executed. The parsing was later moved into the server (an argv was sent from the client), but the parse step and intermediate struct was kept. This change removes that struct and the separate parse step. Argument parsing and printing is now common to all commands (in arguments.c) with each command left with just an optional check function (to validate the arguments at parse time), the exec function and a function to set up any key bindings (renamed from the old init function). This is overall more simple and consistent. There should be no changes to any commands behaviour or syntax although as this touches every command please watch for any unexpected changes.
2011-01-07 14:45:34 +00:00
{
Do not set a limit on the length of commands when printing them.
2015-11-27 15:06:43 +00:00
size_t len;
Support multiple occurances of the same argument. Use this for a new flag -e to new-window, split-window, respawn-window, respawn-pane to pass environment variables into the newly created process. From Steffen Christgau in GitHub issue 1697.
2019-04-28 20:05:50 +00:00
char *buf;
int i;
Instead of eating 1024 bytes or so for the arguments of each command, save memory by using an RB tree. From Tiago Cunha.
2013-05-31 12:19:34 +00:00
struct args_entry *entry;
Support multiple occurances of the same argument. Use this for a new flag -e to new-window, split-window, respawn-window, respawn-pane to pass environment variables into the newly created process. From Steffen Christgau in GitHub issue 1697.
2019-04-28 20:05:50 +00:00
struct args_value *value;
Sync OpenBSD patchset 829: Clean up and simplify tmux command argument parsing. Originally, tmux commands were parsed in the client process into a struct with the command data which was then serialised and sent to the server to be executed. The parsing was later moved into the server (an argv was sent from the client), but the parse step and intermediate struct was kept. This change removes that struct and the separate parse step. Argument parsing and printing is now common to all commands (in arguments.c) with each command left with just an optional check function (to validate the arguments at parse time), the exec function and a function to set up any key bindings (renamed from the old init function). This is overall more simple and consistent. There should be no changes to any commands behaviour or syntax although as this touches every command please watch for any unexpected changes.
2011-01-07 14:45:34 +00:00
Do not set a limit on the length of commands when printing them.
2015-11-27 15:06:43 +00:00
len = 1;
buf = xcalloc(1, len);
Sync OpenBSD patchset 829: Clean up and simplify tmux command argument parsing. Originally, tmux commands were parsed in the client process into a struct with the command data which was then serialised and sent to the server to be executed. The parsing was later moved into the server (an argv was sent from the client), but the parse step and intermediate struct was kept. This change removes that struct and the separate parse step. Argument parsing and printing is now common to all commands (in arguments.c) with each command left with just an optional check function (to validate the arguments at parse time), the exec function and a function to set up any key bindings (renamed from the old init function). This is overall more simple and consistent. There should be no changes to any commands behaviour or syntax although as this touches every command please watch for any unexpected changes.
2011-01-07 14:45:34 +00:00
/* Process the flags first. */
Instead of eating 1024 bytes or so for the arguments of each command, save memory by using an RB tree. From Tiago Cunha.
2013-05-31 12:19:34 +00:00
RB_FOREACH(entry, args_tree, &args->tree) {
Support multiple occurances of the same argument. Use this for a new flag -e to new-window, split-window, respawn-window, respawn-pane to pass environment variables into the newly created process. From Steffen Christgau in GitHub issue 1697.
2019-04-28 20:05:50 +00:00
if (!TAILQ_EMPTY(&entry->values))
Sync OpenBSD patchset 829: Clean up and simplify tmux command argument parsing. Originally, tmux commands were parsed in the client process into a struct with the command data which was then serialised and sent to the server to be executed. The parsing was later moved into the server (an argv was sent from the client), but the parse step and intermediate struct was kept. This change removes that struct and the separate parse step. Argument parsing and printing is now common to all commands (in arguments.c) with each command left with just an optional check function (to validate the arguments at parse time), the exec function and a function to set up any key bindings (renamed from the old init function). This is overall more simple and consistent. There should be no changes to any commands behaviour or syntax although as this touches every command please watch for any unexpected changes.
2011-01-07 14:45:34 +00:00
continue;
Do not set a limit on the length of commands when printing them.
2015-11-27 15:06:43 +00:00
if (*buf == '\0')
args_print_add(&buf, &len, "-");
args_print_add(&buf, &len, "%c", entry->flag);
Sync OpenBSD patchset 829: Clean up and simplify tmux command argument parsing. Originally, tmux commands were parsed in the client process into a struct with the command data which was then serialised and sent to the server to be executed. The parsing was later moved into the server (an argv was sent from the client), but the parse step and intermediate struct was kept. This change removes that struct and the separate parse step. Argument parsing and printing is now common to all commands (in arguments.c) with each command left with just an optional check function (to validate the arguments at parse time), the exec function and a function to set up any key bindings (renamed from the old init function). This is overall more simple and consistent. There should be no changes to any commands behaviour or syntax although as this touches every command please watch for any unexpected changes.
2011-01-07 14:45:34 +00:00
}
/* Then the flags with arguments. */
Instead of eating 1024 bytes or so for the arguments of each command, save memory by using an RB tree. From Tiago Cunha.
2013-05-31 12:19:34 +00:00
RB_FOREACH(entry, args_tree, &args->tree) {
Support multiple occurances of the same argument. Use this for a new flag -e to new-window, split-window, respawn-window, respawn-pane to pass environment variables into the newly created process. From Steffen Christgau in GitHub issue 1697.
2019-04-28 20:05:50 +00:00
TAILQ_FOREACH(value, &entry->values, entry)
args_print_add_value(&buf, &len, entry, value);
Sync OpenBSD patchset 829: Clean up and simplify tmux command argument parsing. Originally, tmux commands were parsed in the client process into a struct with the command data which was then serialised and sent to the server to be executed. The parsing was later moved into the server (an argv was sent from the client), but the parse step and intermediate struct was kept. This change removes that struct and the separate parse step. Argument parsing and printing is now common to all commands (in arguments.c) with each command left with just an optional check function (to validate the arguments at parse time), the exec function and a function to set up any key bindings (renamed from the old init function). This is overall more simple and consistent. There should be no changes to any commands behaviour or syntax although as this touches every command please watch for any unexpected changes.
2011-01-07 14:45:34 +00:00
}
/* And finally the argument vector. */
Support multiple occurances of the same argument. Use this for a new flag -e to new-window, split-window, respawn-window, respawn-pane to pass environment variables into the newly created process. From Steffen Christgau in GitHub issue 1697.
2019-04-28 20:05:50 +00:00
for (i = 0; i < args->argc; i++)
args_print_add_argument(&buf, &len, args->argv[i]);
Sync OpenBSD patchset 829: Clean up and simplify tmux command argument parsing. Originally, tmux commands were parsed in the client process into a struct with the command data which was then serialised and sent to the server to be executed. The parsing was later moved into the server (an argv was sent from the client), but the parse step and intermediate struct was kept. This change removes that struct and the separate parse step. Argument parsing and printing is now common to all commands (in arguments.c) with each command left with just an optional check function (to validate the arguments at parse time), the exec function and a function to set up any key bindings (renamed from the old init function). This is overall more simple and consistent. There should be no changes to any commands behaviour or syntax although as this touches every command please watch for any unexpected changes.
2011-01-07 14:45:34 +00:00
Do not set a limit on the length of commands when printing them.
2015-11-27 15:06:43 +00:00
return (buf);
Sync OpenBSD patchset 829: Clean up and simplify tmux command argument parsing. Originally, tmux commands were parsed in the client process into a struct with the command data which was then serialised and sent to the server to be executed. The parsing was later moved into the server (an argv was sent from the client), but the parse step and intermediate struct was kept. This change removes that struct and the separate parse step. Argument parsing and printing is now common to all commands (in arguments.c) with each command left with just an optional check function (to validate the arguments at parse time), the exec function and a function to set up any key bindings (renamed from the old init function). This is overall more simple and consistent. There should be no changes to any commands behaviour or syntax although as this touches every command please watch for any unexpected changes.
2011-01-07 14:45:34 +00:00
}
Break the argument escaping code into a separate function and use it to escape key bindings in list-keys. Also escape ~ and ; and $ properly.
2019-05-23 14:03:44 +00:00
/* Escape an argument. */
char *
args_escape(const char *s)
{
Add an additional {} syntax for defining strings in the configuration file, making it much tidier to define commands that contain other tmux or shell commands (like if-shell). Also tweak bind-key to expect a string if it is only given one argument, so {} can be used with it as well. From Avi Halachmi.
2019-05-27 12:16:27 +00:00
static const char quoted[] = " #\"';${}";
Break the argument escaping code into a separate function and use it to escape key bindings in list-keys. Also escape ~ and ; and $ properly.
2019-05-23 14:03:44 +00:00
char *escaped, *result;
int flags;
Do not read past the end of the argument string if it is empty.
2019-05-28 18:30:30 +00:00
if (*s == '\0')
return (xstrdup(s));
Break the argument escaping code into a separate function and use it to escape key bindings in list-keys. Also escape ~ and ; and $ properly.
2019-05-23 14:03:44 +00:00
if ((strchr(quoted, s[0]) != NULL || s[0] == '~') && s[1] == '\0') {
xasprintf(&escaped, "\\%c", s[0]);
return (escaped);
}
Use VIS_CSTYLE for the arguments and add the missing escapes it can generate to the parser.
2019-05-29 20:05:14 +00:00
flags = VIS_OCTAL|VIS_CSTYLE|VIS_TAB|VIS_NL;
Break the argument escaping code into a separate function and use it to escape key bindings in list-keys. Also escape ~ and ; and $ properly.
2019-05-23 14:03:44 +00:00
if (s[strcspn(s, quoted)] != '\0')
flags |= VIS_DQ;
utf8_stravis(&escaped, s, flags);
if (flags & VIS_DQ) {
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);
}
Sync OpenBSD patchset 829: Clean up and simplify tmux command argument parsing. Originally, tmux commands were parsed in the client process into a struct with the command data which was then serialised and sent to the server to be executed. The parsing was later moved into the server (an argv was sent from the client), but the parse step and intermediate struct was kept. This change removes that struct and the separate parse step. Argument parsing and printing is now common to all commands (in arguments.c) with each command left with just an optional check function (to validate the arguments at parse time), the exec function and a function to set up any key bindings (renamed from the old init function). This is overall more simple and consistent. There should be no changes to any commands behaviour or syntax although as this touches every command please watch for any unexpected changes.
2011-01-07 14:45:34 +00:00
/* Return if an argument is present. */
int
args_has(struct args *args, u_char ch)
{
Run alert hooks based on the options rather than unconditionally, from Brad Town.
2017-08-23 09:14:21 +00:00
return (args_find(args, ch) != NULL);
Sync OpenBSD patchset 829: Clean up and simplify tmux command argument parsing. Originally, tmux commands were parsed in the client process into a struct with the command data which was then serialised and sent to the server to be executed. The parsing was later moved into the server (an argv was sent from the client), but the parse step and intermediate struct was kept. This change removes that struct and the separate parse step. Argument parsing and printing is now common to all commands (in arguments.c) with each command left with just an optional check function (to validate the arguments at parse time), the exec function and a function to set up any key bindings (renamed from the old init function). This is overall more simple and consistent. There should be no changes to any commands behaviour or syntax although as this touches every command please watch for any unexpected changes.
2011-01-07 14:45:34 +00:00
}
Instead of eating 1024 bytes or so for the arguments of each command, save memory by using an RB tree. From Tiago Cunha.
2013-05-31 12:19:34 +00:00
/* Set argument value in the arguments tree. */
Rewrite of choose mode, both to simplify and tidy the code and to add some modern features. Now the common code is in mode-tree.c, which provides an API used by the three modes now separated into window-{buffer,client,tree}.c. Buffer mode shows buffers, client mode clients and tree mode a tree of sessions, windows and panes. Each mode has a common set of key bindings plus a few that are specific to the mode. Other changes are: - each mode has a preview pane: for buffers this is the buffer content (very useful), for others it is a preview of the pane; - items may be sorted in different ways ('O' key); - multiple items may be tagged and an operation applied to all of them (for example, to delete multiple buffers at once); - in tree mode a command may be run on the selected item (session, window, pane) or on tagged items (key ':'); - displayed items may be filtered in tree mode by using a format (this is used to implement find-window) (key 'f'); - the custom format (-F) for the display is no longer available; - shortcut keys change from 0-9, a-z, A-Z which was always a bit weird with keys used for other uses to 0-9, M-a to M-z. Now that the code is simpler, other improvements will come later. Primary key bindings for each mode are documented under the commands in the man page (choose-buffer, choose-client, choose-tree). Parts written by Thomas Adam.
2017-05-30 21:44:59 +00:00
void
Support multiple occurances of the same argument. Use this for a new flag -e to new-window, split-window, respawn-window, respawn-pane to pass environment variables into the newly created process. From Steffen Christgau in GitHub issue 1697.
2019-04-28 20:05:50 +00:00
args_set(struct args *args, u_char ch, const char *s)
Sync OpenBSD patchset 829: Clean up and simplify tmux command argument parsing. Originally, tmux commands were parsed in the client process into a struct with the command data which was then serialised and sent to the server to be executed. The parsing was later moved into the server (an argv was sent from the client), but the parse step and intermediate struct was kept. This change removes that struct and the separate parse step. Argument parsing and printing is now common to all commands (in arguments.c) with each command left with just an optional check function (to validate the arguments at parse time), the exec function and a function to set up any key bindings (renamed from the old init function). This is overall more simple and consistent. There should be no changes to any commands behaviour or syntax although as this touches every command please watch for any unexpected changes.
2011-01-07 14:45:34 +00:00
{
Instead of eating 1024 bytes or so for the arguments of each command, save memory by using an RB tree. From Tiago Cunha.
2013-05-31 12:19:34 +00:00
struct args_entry *entry;
Support multiple occurances of the same argument. Use this for a new flag -e to new-window, split-window, respawn-window, respawn-pane to pass environment variables into the newly created process. From Steffen Christgau in GitHub issue 1697.
2019-04-28 20:05:50 +00:00
struct args_value *value;
Instead of eating 1024 bytes or so for the arguments of each command, save memory by using an RB tree. From Tiago Cunha.
2013-05-31 12:19:34 +00:00
Support multiple occurances of the same argument. Use this for a new flag -e to new-window, split-window, respawn-window, respawn-pane to pass environment variables into the newly created process. From Steffen Christgau in GitHub issue 1697.
2019-04-28 20:05:50 +00:00
entry = args_find(args, ch);
if (entry == NULL) {
Simplify args_set, from Tiago Cunha.
2014-01-09 13:51:57 +00:00
entry = xcalloc(1, sizeof *entry);
entry->flag = ch;
Support multiple occurances of the same argument. Use this for a new flag -e to new-window, split-window, respawn-window, respawn-pane to pass environment variables into the newly created process. From Steffen Christgau in GitHub issue 1697.
2019-04-28 20:05:50 +00:00
TAILQ_INIT(&entry->values);
Simplify args_set, from Tiago Cunha.
2014-01-09 13:51:57 +00:00
RB_INSERT(args_tree, &args->tree, entry);
Instead of eating 1024 bytes or so for the arguments of each command, save memory by using an RB tree. From Tiago Cunha.
2013-05-31 12:19:34 +00:00
}
Support multiple occurances of the same argument. Use this for a new flag -e to new-window, split-window, respawn-window, respawn-pane to pass environment variables into the newly created process. From Steffen Christgau in GitHub issue 1697.
2019-04-28 20:05:50 +00:00
if (s != NULL) {
value = xcalloc(1, sizeof *value);
value->value = xstrdup(s);
TAILQ_INSERT_TAIL(&entry->values, value, entry);
}
Sync OpenBSD patchset 829: Clean up and simplify tmux command argument parsing. Originally, tmux commands were parsed in the client process into a struct with the command data which was then serialised and sent to the server to be executed. The parsing was later moved into the server (an argv was sent from the client), but the parse step and intermediate struct was kept. This change removes that struct and the separate parse step. Argument parsing and printing is now common to all commands (in arguments.c) with each command left with just an optional check function (to validate the arguments at parse time), the exec function and a function to set up any key bindings (renamed from the old init function). This is overall more simple and consistent. There should be no changes to any commands behaviour or syntax although as this touches every command please watch for any unexpected changes.
2011-01-07 14:45:34 +00:00
}
/* Get argument value. Will be NULL if it isn't present. */
const char *
args_get(struct args *args, u_char ch)
{
Instead of eating 1024 bytes or so for the arguments of each command, save memory by using an RB tree. From Tiago Cunha.
2013-05-31 12:19:34 +00:00
struct args_entry *entry;
if ((entry = args_find(args, ch)) == NULL)
return (NULL);
Support multiple occurances of the same argument. Use this for a new flag -e to new-window, split-window, respawn-window, respawn-pane to pass environment variables into the newly created process. From Steffen Christgau in GitHub issue 1697.
2019-04-28 20:05:50 +00:00
return (TAILQ_LAST(&entry->values, args_values)->value);
}
/* Get first value in argument. */
const char *
args_first_value(struct args *args, u_char ch, struct args_value **value)
{
struct args_entry *entry;
if ((entry = args_find(args, ch)) == NULL)
return (NULL);
*value = TAILQ_FIRST(&entry->values);
if (*value == NULL)
return (NULL);
return ((*value)->value);
}
/* Get next value in argument. */
const char *
args_next_value(struct args_value **value)
{
if (*value == NULL)
return (NULL);
*value = TAILQ_NEXT(*value, entry);
if (*value == NULL)
return (NULL);
return ((*value)->value);
Sync OpenBSD patchset 829: Clean up and simplify tmux command argument parsing. Originally, tmux commands were parsed in the client process into a struct with the command data which was then serialised and sent to the server to be executed. The parsing was later moved into the server (an argv was sent from the client), but the parse step and intermediate struct was kept. This change removes that struct and the separate parse step. Argument parsing and printing is now common to all commands (in arguments.c) with each command left with just an optional check function (to validate the arguments at parse time), the exec function and a function to set up any key bindings (renamed from the old init function). This is overall more simple and consistent. There should be no changes to any commands behaviour or syntax although as this touches every command please watch for any unexpected changes.
2011-01-07 14:45:34 +00:00
}
/* Convert an argument value to a number. */
long long
Instead of eating 1024 bytes or so for the arguments of each command, save memory by using an RB tree. From Tiago Cunha.
2013-05-31 12:19:34 +00:00
args_strtonum(struct args *args, u_char ch, long long minval, long long maxval,
char **cause)
Sync OpenBSD patchset 829: Clean up and simplify tmux command argument parsing. Originally, tmux commands were parsed in the client process into a struct with the command data which was then serialised and sent to the server to be executed. The parsing was later moved into the server (an argv was sent from the client), but the parse step and intermediate struct was kept. This change removes that struct and the separate parse step. Argument parsing and printing is now common to all commands (in arguments.c) with each command left with just an optional check function (to validate the arguments at parse time), the exec function and a function to set up any key bindings (renamed from the old init function). This is overall more simple and consistent. There should be no changes to any commands behaviour or syntax although as this touches every command please watch for any unexpected changes.
2011-01-07 14:45:34 +00:00
{
Instead of eating 1024 bytes or so for the arguments of each command, save memory by using an RB tree. From Tiago Cunha.
2013-05-31 12:19:34 +00:00
const char *errstr;
long long ll;
struct args_entry *entry;
Support multiple occurances of the same argument. Use this for a new flag -e to new-window, split-window, respawn-window, respawn-pane to pass environment variables into the newly created process. From Steffen Christgau in GitHub issue 1697.
2019-04-28 20:05:50 +00:00
struct args_value *value;
Sync OpenBSD patchset 829: Clean up and simplify tmux command argument parsing. Originally, tmux commands were parsed in the client process into a struct with the command data which was then serialised and sent to the server to be executed. The parsing was later moved into the server (an argv was sent from the client), but the parse step and intermediate struct was kept. This change removes that struct and the separate parse step. Argument parsing and printing is now common to all commands (in arguments.c) with each command left with just an optional check function (to validate the arguments at parse time), the exec function and a function to set up any key bindings (renamed from the old init function). This is overall more simple and consistent. There should be no changes to any commands behaviour or syntax although as this touches every command please watch for any unexpected changes.
2011-01-07 14:45:34 +00:00
Instead of eating 1024 bytes or so for the arguments of each command, save memory by using an RB tree. From Tiago Cunha.
2013-05-31 12:19:34 +00:00
if ((entry = args_find(args, ch)) == NULL) {
Sync OpenBSD patchset 829: Clean up and simplify tmux command argument parsing. Originally, tmux commands were parsed in the client process into a struct with the command data which was then serialised and sent to the server to be executed. The parsing was later moved into the server (an argv was sent from the client), but the parse step and intermediate struct was kept. This change removes that struct and the separate parse step. Argument parsing and printing is now common to all commands (in arguments.c) with each command left with just an optional check function (to validate the arguments at parse time), the exec function and a function to set up any key bindings (renamed from the old init function). This is overall more simple and consistent. There should be no changes to any commands behaviour or syntax although as this touches every command please watch for any unexpected changes.
2011-01-07 14:45:34 +00:00
*cause = xstrdup("missing");
return (0);
}
Support multiple occurances of the same argument. Use this for a new flag -e to new-window, split-window, respawn-window, respawn-pane to pass environment variables into the newly created process. From Steffen Christgau in GitHub issue 1697.
2019-04-28 20:05:50 +00:00
value = TAILQ_LAST(&entry->values, args_values);
Sync OpenBSD patchset 829: Clean up and simplify tmux command argument parsing. Originally, tmux commands were parsed in the client process into a struct with the command data which was then serialised and sent to the server to be executed. The parsing was later moved into the server (an argv was sent from the client), but the parse step and intermediate struct was kept. This change removes that struct and the separate parse step. Argument parsing and printing is now common to all commands (in arguments.c) with each command left with just an optional check function (to validate the arguments at parse time), the exec function and a function to set up any key bindings (renamed from the old init function). This is overall more simple and consistent. There should be no changes to any commands behaviour or syntax although as this touches every command please watch for any unexpected changes.
2011-01-07 14:45:34 +00:00
Support multiple occurances of the same argument. Use this for a new flag -e to new-window, split-window, respawn-window, respawn-pane to pass environment variables into the newly created process. From Steffen Christgau in GitHub issue 1697.
2019-04-28 20:05:50 +00:00
ll = strtonum(value->value, minval, maxval, &errstr);
Sync OpenBSD patchset 829: Clean up and simplify tmux command argument parsing. Originally, tmux commands were parsed in the client process into a struct with the command data which was then serialised and sent to the server to be executed. The parsing was later moved into the server (an argv was sent from the client), but the parse step and intermediate struct was kept. This change removes that struct and the separate parse step. Argument parsing and printing is now common to all commands (in arguments.c) with each command left with just an optional check function (to validate the arguments at parse time), the exec function and a function to set up any key bindings (renamed from the old init function). This is overall more simple and consistent. There should be no changes to any commands behaviour or syntax although as this touches every command please watch for any unexpected changes.
2011-01-07 14:45:34 +00:00
if (errstr != NULL) {
*cause = xstrdup(errstr);
return (0);
}
*cause = NULL;
return (ll);
}
Reference in New Issue Copy Permalink