circlecloud/tmux
1
0
Fork 0
mirror of https://github.com/tmux/tmux.git synced 2024-11-16 17:39:09 +00:00
Code Issues Projects Releases Wiki Activity
97b5962ab1
tmux/arguments.c

436 lines
9.3 KiB
C
Raw Normal View History

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-04 00:42:46 +00:00
/* $OpenBSD$ */
/*
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>
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-04 00:42:46 +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>
Run arguments through vis() as well when printing them.
2017-01-18 10:00:50 +00:00
#include <vis.h>
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-04 00:42:46 +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;
Add a -H flag to send-keys to send literal keys given as hex numbers (needed for control clients to send mouse sequences). Also add some format flags for UTF-8 and SGR mouse mode. Requested by Bradley Smith in GitHub issues 1832 and 1833.
2019-07-09 14:03:12 +00:00
u_int count;
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 *
Add formats for after hook command arguments.
2020-05-16 15:40:04 +00:00
args_find(struct args *args, u_char flag)
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;
Add formats for after hook command arguments.
2020-05-16 15:40:04 +00:00
entry.flag = flag;
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
return (RB_FIND(args_tree, &args->tree, &entry));
}
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-04 00:42:46 +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;
getopt is not required to set optarg to NULL when there is no argument and some do not, so set it explicitly each time.
2020-03-17 16:02:38 +00:00
optarg = NULL;
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-04 00:42:46 +00:00
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)
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-04 00:42:46 +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);
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-04 00:42:46 +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);
getopt is not required to set optarg to NULL when there is no argument and some do not, so set it explicitly each time.
2020-03-17 16:02:38 +00:00
optarg = NULL;
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-04 00:42:46 +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;
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-04 00:42:46 +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);
}
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-04 00:42:46 +00:00
xfree is not particularly helpful, remove it. From Thomas Adam.
2012-07-10 11:53:01 +00:00
free(args);
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-04 00:42:46 +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);
}
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-04 00:42:46 +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)
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-04 00:42:46 +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;
Add a -H flag to send-keys to send literal keys given as hex numbers (needed for control clients to send mouse sequences). Also add some format flags for UTF-8 and SGR mouse mode. Requested by Bradley Smith in GitHub issues 1832 and 1833.
2019-07-09 14:03:12 +00:00
u_int j;
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;
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-04 00:42:46 +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);
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-04 00:42:46 +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))
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-04 00:42:46 +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, "-");
Add a -H flag to send-keys to send literal keys given as hex numbers (needed for control clients to send mouse sequences). Also add some format flags for UTF-8 and SGR mouse mode. Requested by Bradley Smith in GitHub issues 1832 and 1833.
2019-07-09 14:03:12 +00:00
for (j = 0; j < entry->count; j++)
args_print_add(&buf, &len, "%c", entry->flag);
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-04 00:42:46 +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);
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-04 00:42:46 +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]);
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-04 00:42:46 +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);
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-04 00:42:46 +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)
{
Fix quoting with newlines and single quotes.
2020-06-12 07:10:43 +00:00
static const char dquoted[] = " #';${}";
static const char squoted[] = " \"";
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;
Fix quoting with newlines and single quotes.
2020-06-12 07:10:43 +00:00
int flags, quotes = 0;
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
Print empty arguments properly.
2020-04-12 20:54:28 +00:00
if (*s == '\0') {
xasprintf(&result, "''");
return (result);
}
Fix quoting with newlines and single quotes.
2020-06-12 07:10:43 +00:00
if (s[strcspn(s, dquoted)] != '\0')
quotes = '"';
else if (s[strcspn(s, squoted)] != '\0')
quotes = '\'';
Add a -A flag to show-options to show parent options as well.
2019-06-20 07:10:56 +00:00
if (s[0] != ' ' &&
Fix quoting with newlines and single quotes.
2020-06-12 07:10:43 +00:00
s[1] == '\0' &&
(quotes != 0 || s[0] == '~')) {
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
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;
Fix quoting with newlines and single quotes.
2020-06-12 07:10:43 +00:00
if (quotes == '"')
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
flags |= VIS_DQ;
utf8_stravis(&escaped, s, flags);
Fix quoting with newlines and single quotes.
2020-06-12 07:10:43 +00:00
if (quotes == '\'')
xasprintf(&result, "'%s'", escaped);
else if (quotes == '"') {
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 (*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);
}
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-04 00:42:46 +00:00
/* Return if an argument is present. */
int
Add formats for after hook command arguments.
2020-05-16 15:40:04 +00:00
args_has(struct args *args, u_char flag)
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-04 00:42:46 +00:00
{
Add a -H flag to send-keys to send literal keys given as hex numbers (needed for control clients to send mouse sequences). Also add some format flags for UTF-8 and SGR mouse mode. Requested by Bradley Smith in GitHub issues 1832 and 1833.
2019-07-09 14:03:12 +00:00
struct args_entry *entry;
Add formats for after hook command arguments.
2020-05-16 15:40:04 +00:00
entry = args_find(args, flag);
Add a -H flag to send-keys to send literal keys given as hex numbers (needed for control clients to send mouse sequences). Also add some format flags for UTF-8 and SGR mouse mode. Requested by Bradley Smith in GitHub issues 1832 and 1833.
2019-07-09 14:03:12 +00:00
if (entry == NULL)
return (0);
return (entry->count);
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-04 00:42:46 +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
Add formats for after hook command arguments.
2020-05-16 15:40:04 +00:00
args_set(struct args *args, u_char flag, const char *s)
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-04 00:42:46 +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
Add formats for after hook command arguments.
2020-05-16 15:40:04 +00:00
entry = args_find(args, 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
if (entry == NULL) {
Simplify args_set, from Tiago Cunha.
2014-01-09 13:51:57 +00:00
entry = xcalloc(1, sizeof *entry);
Add formats for after hook command arguments.
2020-05-16 15:40:04 +00:00
entry->flag = flag;
Add a -H flag to send-keys to send literal keys given as hex numbers (needed for control clients to send mouse sequences). Also add some format flags for UTF-8 and SGR mouse mode. Requested by Bradley Smith in GitHub issues 1832 and 1833.
2019-07-09 14:03:12 +00:00
entry->count = 1;
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);
Add a -H flag to send-keys to send literal keys given as hex numbers (needed for control clients to send mouse sequences). Also add some format flags for UTF-8 and SGR mouse mode. Requested by Bradley Smith in GitHub issues 1832 and 1833.
2019-07-09 14:03:12 +00:00
} else
entry->count++;
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);
}
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-04 00:42:46 +00:00
}
/* Get argument value. Will be NULL if it isn't present. */
const char *
Add formats for after hook command arguments.
2020-05-16 15:40:04 +00:00
args_get(struct args *args, u_char flag)
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-04 00:42:46 +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;
Add formats for after hook command arguments.
2020-05-16 15:40:04 +00:00
if ((entry = args_find(args, flag)) == NULL)
return (NULL);
if (TAILQ_EMPTY(&entry->values))
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
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);
}
Add formats for after hook command arguments.
2020-05-16 15:40:04 +00:00
/* 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);
}
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
/* Get first value in argument. */
const char *
Add formats for after hook command arguments.
2020-05-16 15:40:04 +00:00
args_first_value(struct args *args, u_char flag, struct args_value **value)
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_entry *entry;
Add formats for after hook command arguments.
2020-05-16 15:40:04 +00:00
if ((entry = args_find(args, flag)) == 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 (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);
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-04 00:42:46 +00:00
}
/* Convert an argument value to a number. */
long long
Add formats for after hook command arguments.
2020-05-16 15:40:04 +00:00
args_strtonum(struct args *args, u_char flag, long long minval,
long long maxval, char **cause)
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-04 00:42:46 +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;
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-04 00:42:46 +00:00
Add formats for after hook command arguments.
2020-05-16 15:40:04 +00:00
if ((entry = args_find(args, flag)) == NULL) {
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-04 00:42:46 +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);
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-04 00:42:46 +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);
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-04 00:42:46 +00:00
if (errstr != NULL) {
*cause = xstrdup(errstr);
return (0);
}
*cause = NULL;
return (ll);
}
Break code to convert an argument as a percentage into a common function.
2020-03-21 13:16:15 +00:00
/* Convert an argument to a number which may be a percentage. */
long long
Add formats for after hook command arguments.
2020-05-16 15:40:04 +00:00
args_percentage(struct args *args, u_char flag, long long minval,
Break code to convert an argument as a percentage into a common function.
2020-03-21 13:16:15 +00:00
long long maxval, long long curval, char **cause)
{
Change so main-pane-width and height can be given as a percentage.
2020-04-22 06:57:13 +00:00
const char *value;
Break code to convert an argument as a percentage into a common function.
2020-03-21 13:16:15 +00:00
struct args_entry *entry;
Add formats for after hook command arguments.
2020-05-16 15:40:04 +00:00
if ((entry = args_find(args, flag)) == NULL) {
Break code to convert an argument as a percentage into a common function.
2020-03-21 13:16:15 +00:00
*cause = xstrdup("missing");
return (0);
}
Change so main-pane-width and height can be given as a percentage.
2020-04-22 06:57:13 +00:00
value = TAILQ_LAST(&entry->values, args_values)->value;
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;
Break code to convert an argument as a percentage into a common function.
2020-03-21 13:16:15 +00:00
Change so main-pane-width and height can be given as a percentage.
2020-04-22 06:57:13 +00:00
if (value[valuelen - 1] == '%') {
copy = xstrdup(value);
Break code to convert an argument as a percentage into a common function.
2020-03-21 13:16:15 +00:00
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) {
Fix some error strings, from Kris Katterjohn.
2020-05-25 18:17:14 +00:00
*cause = xstrdup("too small");
Break code to convert an argument as a percentage into a common function.
2020-03-21 13:16:15 +00:00
return (0);
}
if (ll > maxval) {
Fix some error strings, from Kris Katterjohn.
2020-05-25 18:17:14 +00:00
*cause = xstrdup("too large");
Break code to convert an argument as a percentage into a common function.
2020-03-21 13:16:15 +00:00
return (0);
}
} else {
Change so main-pane-width and height can be given as a percentage.
2020-04-22 06:57:13 +00:00
ll = strtonum(value, minval, maxval, &errstr);
Break code to convert an argument as a percentage into a common function.
2020-03-21 13:16:15 +00:00
if (errstr != NULL) {
*cause = xstrdup(errstr);
return (0);
}
}
*cause = NULL;
return (ll);
}
Reference in New Issue Copy Permalink