circlecloud
/
tmux
mirror of https://github.com/tmux/tmux.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
tmux/format.c

4910 lines
106 KiB
C
Raw Normal View History

Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
/* $OpenBSD$ */
/*
I no longer use my SourceForge address so replace it.
2016-01-19 15:59:12 +00:00
* Copyright (c) 2011 Nicholas Marriott <nicholas.marriott@gmail.com>
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +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>
Add pane_dead_status for exit status of dead panes.
2014-12-09 19:23:35 +00:00
#include <sys/wait.h>
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
Allow any punctuation (except :) as separator in s/x/y/, not only /. From JINNOUCHI Yasushi in GitHub issue 1386.
2018-06-27 17:36:10 +00:00
#include <ctype.h>
Add length limit operator for formats.
2013-10-10 11:50:20 +00:00
#include <errno.h>
Add m: for fnmatch(3) format matching.
2017-05-29 15:43:48 +00:00
#include <fnmatch.h>
Extend the modifiers allowed before formats: as well as the existing #{=10:...} length limit, add #{t:...} to convert a time_t format to a string, #{b:...} for basename and #{d:...} for dirname. Remove all the foo_string time formats as they can now be replaced by "t:", for example #{window_activity_string} becomes #{t:window_activity}.
2015-10-25 22:29:17 +00:00
#include <libgen.h>
Add some number operators for formats, from Tyler Culp.
2020-03-11 14:17:55 +00:00
#include <math.h>
Add regular expression support for the format search, match and substitute modifiers.
2019-06-13 19:46:00 +00:00
#include <regex.h>
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
#include <stdarg.h>
xfree is not particularly helpful, remove it. From Thomas Adam.
2012-07-10 11:53:01 +00:00
#include <stdlib.h>
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
#include <string.h>
#include <time.h>
#include <unistd.h>
#include "tmux.h"
/*
* Build a list of key-value pairs and use them to expand #{key} entries in a
* string.
*/
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
struct format_expand_state;
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
static char *format_job_get(struct format_expand_state *, const char *);
static char *format_expand1(struct format_expand_state *, const char *);
static int format_replace(struct format_expand_state *, const char *,
size_t, char **, size_t *, size_t *);
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static void format_defaults_session(struct format_tree *,
struct session *);
static void format_defaults_client(struct format_tree *, struct client *);
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
static void format_defaults_winlink(struct format_tree *,
struct winlink *);
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
/* Entry in format job tree. */
struct format_job {
In order that people can use formats like #D in #() in the status line and not have to wait for an update when they change pane, we allow commands to run more than once a second if the expanded form changes. Unfortunately this can mean them being run far too often (pretty much continually) when multiple clients exist, because some formats (including #D) will always differ between clients. To avoid this, give each client its own tree of jobs which means that the same command will be different instances for each client - similar to how we have the tag to separate commands for different panes. GitHub issue 889; test case reported by Paul Johnson.
2017-05-01 12:20:55 +00:00
struct client *client;
Add a window or pane id "tag" to each format tree and use it to separate jobs, this means that if the same job is used for different windows or panes (for example in pane-border-format), it will be run separately for each pane.
2017-02-03 11:57:27 +00:00
u_int tag;
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
const char *cmd;
Key running commands for #() by the unexpanded command, and run them again if the expanded form changes (otherwise at most once per second as usual). Fixes issues reported by Gregory Pakosz.
2016-11-17 10:06:08 +00:00
const char *expanded;
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
time_t last;
char *out;
If a #() command doesn't exit, use its most recent line of output (it must be a full line). Don't let it redraw the status line more than once a second. Requested by someone about 10 years ago...
2017-04-20 09:20:22 +00:00
int updated;
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
struct job *job;
int status;
RB_ENTRY(format_job) entry;
};
/* Format job tree. */
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static int format_job_cmp(struct format_job *, struct format_job *);
Some other stuff that can be local to one file.
2016-10-11 13:45:47 +00:00
static RB_HEAD(format_job_tree, format_job) format_jobs = RB_INITIALIZER();
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
RB_GENERATE_STATIC(format_job_tree, format_job, entry, format_job_cmp);
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
/* Format job tree comparison function. */
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static int
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
format_job_cmp(struct format_job *fj1, struct format_job *fj2)
{
Add a window or pane id "tag" to each format tree and use it to separate jobs, this means that if the same job is used for different windows or panes (for example in pane-border-format), it will be run separately for each pane.
2017-02-03 11:57:27 +00:00
if (fj1->tag < fj2->tag)
return (-1);
if (fj1->tag > fj2->tag)
return (1);
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
return (strcmp(fj1->cmd, fj2->cmd));
}
Extend the modifiers allowed before formats: as well as the existing #{=10:...} length limit, add #{t:...} to convert a time_t format to a string, #{b:...} for basename and #{d:...} for dirname. Remove all the foo_string time formats as they can now be replaced by "t:", for example #{window_activity_string} becomes #{t:window_activity}.
2015-10-25 22:29:17 +00:00
/* Format modifiers. */
#define FORMAT_TIMESTRING 0x1
#define FORMAT_BASENAME 0x2
#define FORMAT_DIRNAME 0x4
Change so that window_flags escapes # automatically which means configs will not have to change. A new format window_raw_flags contains the old unescaped version.
2021-01-20 07:16:54 +00:00
#define FORMAT_QUOTE_SHELL 0x8
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
#define FORMAT_LITERAL 0x10
Add E: format to expand a format twice (useful to expand the value of an option).
2019-03-13 14:19:54 +00:00
#define FORMAT_EXPAND 0x20
Add T format modifier like E but also do strftime(3).
2019-03-14 21:31:43 +00:00
#define FORMAT_EXPANDTIME 0x40
#define FORMAT_SESSIONS 0x80
#define FORMAT_WINDOWS 0x100
#define FORMAT_PANES 0x200
Tweak the default choose modes formats: - Only show pane title if it is not default and not empty. - Add a prettier time format and use that instead of long ctime(). - Remove clutter and change the order.
2020-05-16 14:10:29 +00:00
#define FORMAT_PRETTY 0x400
Add n: modifier to get length of a format, also automatically expand variable name arguments again if they contain a #{.
2020-08-20 16:57:40 +00:00
#define FORMAT_LENGTH 0x800
Change how escaping is processed for formats so that ## and # can be used in styles. Also add a 'w' format modifier for the width. From Chas J Owens IV in GitHub issue 2389.
2020-11-09 09:10:10 +00:00
#define FORMAT_WIDTH 0x1000
Change so that window_flags escapes # automatically which means configs will not have to change. A new format window_raw_flags contains the old unescaped version.
2021-01-20 07:16:54 +00:00
#define FORMAT_QUOTE_STYLE 0x2000
Add a -S flag to new-window to make it select the existing window if one with the given name already exists rather than failing with an error. Also add a format to check if a window or session name exists which allows the same with other commands. Requested by and discussed with kn@.
2021-02-05 12:23:49 +00:00
#define FORMAT_WINDOW_NAME 0x4000
#define FORMAT_SESSION_NAME 0x8000
Permit shortcut keys in buffer, client, tree modes to be configured with a format; the default remains the line number. GitHub issue 2636.
2021-04-12 06:50:25 +00:00
#define FORMAT_CHARACTER 0x10000
Extend the modifiers allowed before formats: as well as the existing #{=10:...} length limit, add #{t:...} to convert a time_t format to a string, #{b:...} for basename and #{d:...} for dirname. Remove all the foo_string time formats as they can now be replaced by "t:", for example #{window_activity_string} becomes #{t:window_activity}.
2015-10-25 22:29:17 +00:00
Add a limit on how far format_expand can recurse.
2019-03-14 23:34:41 +00:00
/* Limit on recursion. */
Bump FORMAT_LOOOP_LIMIT and add a log message when hit, GitHub issue 2715.
2021-06-10 07:58:08 +00:00
#define FORMAT_LOOP_LIMIT 100
Add a limit on how far format_expand can recurse.
2019-03-14 23:34:41 +00:00
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
/* Format expand flags. */
#define FORMAT_EXPAND_TIME 0x1
#define FORMAT_EXPAND_NOJOBS 0x2
Permit option values to be used in formats.
2014-12-02 23:19:45 +00:00
/* Entry in format tree. */
struct format_entry {
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
char *key;
char *value;
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
time_t time;
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
format_cb cb;
RB_ENTRY(format_entry) entry;
Permit option values to be used in formats.
2014-12-02 23:19:45 +00:00
};
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
/* Format type. */
enum format_type {
FORMAT_TYPE_UNKNOWN,
FORMAT_TYPE_SESSION,
FORMAT_TYPE_WINDOW,
FORMAT_TYPE_PANE
};
Permit option values to be used in formats.
2014-12-02 23:19:45 +00:00
struct format_tree {
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
enum format_type type;
Support for windows larger than visible on the attached client. This has been a limitation for a long time. There are two new options, window-size and default-size, and a new command, resize-window. The force-width and force-height options and the session_width and session_height formats have been removed. The new window-size option tells tmux how to work out the size of windows: largest means it picks the size of the largest session, smallest the smallest session (similar to the old behaviour) and manual means that it does not automatically resize windows. The default is currently largest but this may change. aggressive-resize modifies the choice of session for largest and smallest as it did before. If a window is in a session attached to a client that is too small, only part of the window is shown. tmux attempts to keep the cursor visible, so the part of the window displayed is changed as the cursor moves (with a small delay, to try and avoid excess redrawing when applications redraw status lines or similar that are not currently visible). The offset of the visible portion of the window is shown in status-right. Drawing windows which are larger than the client is not as efficient as those which fit, particularly when the cursor moves, so it is recommended to avoid using this on slow machines or networks (set window-size to smallest or manual). The resize-window command can be used to resize a window manually. If it is used, the window-size option is automatically set to manual for the window (undo this with "setw -u window-size"). resize-window works in a similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and -A flags. -a sets the window to the size of the smallest client (what it would be if window-size was smallest) and -A the largest. For the same behaviour as force-width or force-height, use resize-window -x or -y, and "setw -u window-size" to revert to automatic sizing.. If the global window-size option is set to manual, the default-size option is used for new windows. If -x or -y is used with new-session, that sets the default-size option for the new session. The maximum size of a window is 10000x10000. But expect applications to complain and much higher memory use if making a window excessively big. The minimum size is the size required for the current layout including borders. The refresh-client command can be used to pan around a window, -U -D -L -R moves up, down, left or right and -c returns to automatic cursor tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
struct client *c;
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
struct session *s;
Support for windows larger than visible on the attached client. This has been a limitation for a long time. There are two new options, window-size and default-size, and a new command, resize-window. The force-width and force-height options and the session_width and session_height formats have been removed. The new window-size option tells tmux how to work out the size of windows: largest means it picks the size of the largest session, smallest the smallest session (similar to the old behaviour) and manual means that it does not automatically resize windows. The default is currently largest but this may change. aggressive-resize modifies the choice of session for largest and smallest as it did before. If a window is in a session attached to a client that is too small, only part of the window is shown. tmux attempts to keep the cursor visible, so the part of the window displayed is changed as the cursor moves (with a small delay, to try and avoid excess redrawing when applications redraw status lines or similar that are not currently visible). The offset of the visible portion of the window is shown in status-right. Drawing windows which are larger than the client is not as efficient as those which fit, particularly when the cursor moves, so it is recommended to avoid using this on slow machines or networks (set window-size to smallest or manual). The resize-window command can be used to resize a window manually. If it is used, the window-size option is automatically set to manual for the window (undo this with "setw -u window-size"). resize-window works in a similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and -A flags. -a sets the window to the size of the smallest client (what it would be if window-size was smallest) and -A the largest. For the same behaviour as force-width or force-height, use resize-window -x or -y, and "setw -u window-size" to revert to automatic sizing.. If the global window-size option is set to manual, the default-size option is used for new windows. If -x or -y is used with new-session, that sets the default-size option for the new session. The maximum size of a window is 10000x10000. But expect applications to complain and much higher memory use if making a window excessively big. The minimum size is the size required for the current layout including borders. The refresh-client command can be used to pan around a window, -U -D -L -R moves up, down, left or right and -c returns to automatic cursor tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
struct winlink *wl;
struct window *w;
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
struct window_pane *wp;
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
struct paste_buffer *pb;
Permit option values to be used in formats.
2014-12-02 23:19:45 +00:00
Add formats to list sessions, windows or panes.
2019-03-13 15:37:28 +00:00
struct cmdq_item *item;
In order that people can use formats like #D in #() in the status line and not have to wait for an update when they change pane, we allow commands to run more than once a second if the expanded form changes. Unfortunately this can mean them being run far too often (pretty much continually) when multiple clients exist, because some formats (including #D) will always differ between clients. To avoid this, give each client its own tree of jobs which means that the same command will be different instances for each client - similar to how we have the tag to separate commands for different panes. GitHub issue 889; test case reported by Paul Johnson.
2017-05-01 12:20:55 +00:00
struct client *client;
Make refresh-client force update of jobs, from Sina Siadat.
2015-09-14 10:25:52 +00:00
int flags;
Allow a custom time format to be given to the t format modifier.
2020-05-16 15:48:35 +00:00
u_int tag;
Permit option values to be used in formats.
2014-12-02 23:19:45 +00:00
Add formats for word and line under the mouse and use them to add some items to the pane menu.
2019-05-26 17:34:45 +00:00
struct mouse_event m;
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
RB_HEAD(format_entry_tree, format_entry) tree;
};
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static int format_entry_cmp(struct format_entry *, struct format_entry *);
RB_GENERATE_STATIC(format_entry_tree, format_entry, entry, format_entry_cmp);
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
/* Format expand state. */
struct format_expand_state {
struct format_tree *ft;
u_int loop;
time_t time;
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
struct tm tm;
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
int flags;
};
The pane and window loops need to pass the window and pane tags when they build their format.
2019-03-15 10:07:24 +00:00
/* Format modifier. */
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
struct format_modifier {
char modifier[3];
u_int size;
char **argv;
int argc;
};
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
/* Format entry tree comparison function. */
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static int
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
format_entry_cmp(struct format_entry *fe1, struct format_entry *fe2)
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
{
return (strcmp(fe1->key, fe2->key));
}
Add host_short format, from Tiago Cunha.
2013-05-31 19:46:42 +00:00
/* Single-character uppercase aliases. */
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static const char *format_upper[] = {
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
NULL, /* A */
NULL, /* B */
NULL, /* C */
"pane_id", /* D */
NULL, /* E */
"window_flags", /* F */
NULL, /* G */
"host", /* H */
"window_index", /* I */
NULL, /* J */
NULL, /* K */
NULL, /* L */
NULL, /* M */
NULL, /* N */
NULL, /* O */
"pane_index", /* P */
NULL, /* Q */
NULL, /* R */
"session_name", /* S */
"pane_title", /* T */
NULL, /* U */
NULL, /* V */
"window_name", /* W */
NULL, /* X */
NULL, /* Y */
NULL /* Z */
};
Add host_short format, from Tiago Cunha.
2013-05-31 19:46:42 +00:00
/* Single-character lowercase aliases. */
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static const char *format_lower[] = {
Add host_short format, from Tiago Cunha.
2013-05-31 19:46:42 +00:00
NULL, /* a */
NULL, /* b */
NULL, /* c */
NULL, /* d */
NULL, /* e */
NULL, /* f */
NULL, /* g */
"host_short", /* h */
NULL, /* i */
NULL, /* j */
NULL, /* k */
NULL, /* l */
NULL, /* m */
NULL, /* n */
NULL, /* o */
NULL, /* p */
NULL, /* q */
NULL, /* r */
NULL, /* s */
NULL, /* t */
NULL, /* u */
NULL, /* v */
NULL, /* w */
NULL, /* x */
NULL, /* y */
NULL /* z */
};
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
/* Is logging enabled? */
static inline int
format_logging(struct format_tree *ft)
{
return (log_get_level() != 0 || (ft->flags & FORMAT_VERBOSE));
}
/* Log a message if verbose. */
static void printflike(3, 4)
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log1(struct format_expand_state *es, const char *from, const char *fmt,
...)
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
{
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
struct format_tree *ft = es->ft;
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
va_list ap;
char *s;
static const char spaces[] = " ";
if (!format_logging(ft))
return;
va_start(ap, fmt);
Use xvasprintf not vasprintf.
2020-06-23 05:23:26 +00:00
xvasprintf(&s, fmt, ap);
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
va_end(ap);
log_debug("%s: %s", from, s);
Only print format logging when the flag is set, even if also sending to log_debug.
2019-03-15 10:22:57 +00:00
if (ft->item != NULL && (ft->flags & FORMAT_VERBOSE))
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
cmdq_print(ft->item, "#%.*s%s", es->loop, spaces, s);
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
free(s);
}
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
#define format_log(es, fmt, ...) format_log1(es, __func__, fmt, ##__VA_ARGS__)
/* Copy expand state. */
static void
format_copy_state(struct format_expand_state *to,
struct format_expand_state *from, int flags)
{
to->ft = from->ft;
to->loop = from->loop;
to->time = from->time;
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
memcpy(&to->tm, &from->tm, sizeof to->tm);
Fix a last minute change in previous.
2020-10-06 07:36:42 +00:00
to->flags = from->flags|flags;
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
}
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
If a #() command doesn't exit, use its most recent line of output (it must be a full line). Don't let it redraw the status line more than once a second. Requested by someone about 10 years ago...
2017-04-20 09:20:22 +00:00
/* Format job update callback. */
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static void
If a #() command doesn't exit, use its most recent line of output (it must be a full line). Don't let it redraw the status line more than once a second. Requested by someone about 10 years ago...
2017-04-20 09:20:22 +00:00
format_job_update(struct job *job)
{
Move job struct into job.c.
2018-08-23 15:45:05 +00:00
struct format_job *fj = job_get_data(job);
struct evbuffer *evb = job_get_event(job)->input;
Discard all but the last line when reading from a #() command - the callback is just going to be fired again straight away to go through all the lines, it is better just to use the last one straight away.
2018-01-18 14:28:11 +00:00
char *line = NULL, *next;
If a #() command doesn't exit, use its most recent line of output (it must be a full line). Don't let it redraw the status line more than once a second. Requested by someone about 10 years ago...
2017-04-20 09:20:22 +00:00
time_t t;
Discard all but the last line when reading from a #() command - the callback is just going to be fired again straight away to go through all the lines, it is better just to use the last one straight away.
2018-01-18 14:28:11 +00:00
while ((next = evbuffer_readline(evb)) != NULL) {
free(line);
line = next;
}
if (line == NULL)
If a #() command doesn't exit, use its most recent line of output (it must be a full line). Don't let it redraw the status line more than once a second. Requested by someone about 10 years ago...
2017-04-20 09:20:22 +00:00
return;
fj->updated = 1;
free(fj->out);
fj->out = line;
Only redraw single client, and tweak some logging.
2017-05-12 13:27:57 +00:00
log_debug("%s: %p %s: %s", __func__, fj, fj->cmd, fj->out);
If a #() command doesn't exit, use its most recent line of output (it must be a full line). Don't let it redraw the status line more than once a second. Requested by someone about 10 years ago...
2017-04-20 09:20:22 +00:00
Style and spacing nits.
2017-05-31 17:56:48 +00:00
t = time(NULL);
If a #() command doesn't exit, use its most recent line of output (it must be a full line). Don't let it redraw the status line more than once a second. Requested by someone about 10 years ago...
2017-04-20 09:20:22 +00:00
if (fj->status && fj->last != t) {
Only redraw single client, and tweak some logging.
2017-05-12 13:27:57 +00:00
if (fj->client != NULL)
server_status_client(fj->client);
If a #() command doesn't exit, use its most recent line of output (it must be a full line). Don't let it redraw the status line more than once a second. Requested by someone about 10 years ago...
2017-04-20 09:20:22 +00:00
fj->last = t;
}
}
/* Format job complete callback. */
static void
format_job_complete(struct job *job)
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
{
Move job struct into job.c.
2018-08-23 15:45:05 +00:00
struct format_job *fj = job_get_data(job);
struct evbuffer *evb = job_get_event(job)->input;
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
char *line, *buf;
size_t len;
fj->job = NULL;
buf = NULL;
Move job struct into job.c.
2018-08-23 15:45:05 +00:00
if ((line = evbuffer_readline(evb)) == NULL) {
len = EVBUFFER_LENGTH(evb);
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
buf = xmalloc(len + 1);
if (len != 0)
Move job struct into job.c.
2018-08-23 15:45:05 +00:00
memcpy(buf, EVBUFFER_DATA(evb), len);
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
buf[len] = '\0';
} else
buf = line;
If a #() command doesn't exit, use its most recent line of output (it must be a full line). Don't let it redraw the status line more than once a second. Requested by someone about 10 years ago...
2017-04-20 09:20:22 +00:00
Only redraw single client, and tweak some logging.
2017-05-12 13:27:57 +00:00
log_debug("%s: %p %s: %s", __func__, fj, fj->cmd, buf);
If a #() command doesn't exit, use its most recent line of output (it must be a full line). Don't let it redraw the status line more than once a second. Requested by someone about 10 years ago...
2017-04-20 09:20:22 +00:00
if (*buf != '\0' || !fj->updated) {
free(fj->out);
fj->out = buf;
} else
free(buf);
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
if (fj->status) {
In order that people can use formats like #D in #() in the status line and not have to wait for an update when they change pane, we allow commands to run more than once a second if the expanded form changes. Unfortunately this can mean them being run far too often (pretty much continually) when multiple clients exist, because some formats (including #D) will always differ between clients. To avoid this, give each client its own tree of jobs which means that the same command will be different instances for each client - similar to how we have the tag to separate commands for different panes. GitHub issue 889; test case reported by Paul Johnson.
2017-05-01 12:20:55 +00:00
if (fj->client != NULL)
server_status_client(fj->client);
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
fj->status = 0;
}
}
/* Find a job. */
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static char *
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_job_get(struct format_expand_state *es, const char *cmd)
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
{
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
struct format_tree *ft = es->ft;
struct format_job_tree *jobs;
struct format_job fj0, *fj;
time_t t;
char *expanded;
int force;
struct format_expand_state next;
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
In order that people can use formats like #D in #() in the status line and not have to wait for an update when they change pane, we allow commands to run more than once a second if the expanded form changes. Unfortunately this can mean them being run far too often (pretty much continually) when multiple clients exist, because some formats (including #D) will always differ between clients. To avoid this, give each client its own tree of jobs which means that the same command will be different instances for each client - similar to how we have the tag to separate commands for different panes. GitHub issue 889; test case reported by Paul Johnson.
2017-05-01 12:20:55 +00:00
if (ft->client == NULL)
jobs = &format_jobs;
else if (ft->client->jobs != NULL)
jobs = ft->client->jobs;
else {
jobs = ft->client->jobs = xmalloc(sizeof *ft->client->jobs);
RB_INIT(jobs);
}
Add a window or pane id "tag" to each format tree and use it to separate jobs, this means that if the same job is used for different windows or panes (for example in pane-border-format), it will be run separately for each pane.
2017-02-03 11:57:27 +00:00
fj0.tag = ft->tag;
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
fj0.cmd = cmd;
In order that people can use formats like #D in #() in the status line and not have to wait for an update when they change pane, we allow commands to run more than once a second if the expanded form changes. Unfortunately this can mean them being run far too often (pretty much continually) when multiple clients exist, because some formats (including #D) will always differ between clients. To avoid this, give each client its own tree of jobs which means that the same command will be different instances for each client - similar to how we have the tag to separate commands for different panes. GitHub issue 889; test case reported by Paul Johnson.
2017-05-01 12:20:55 +00:00
if ((fj = RB_FIND(format_job_tree, jobs, &fj0)) == NULL) {
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
fj = xcalloc(1, sizeof *fj);
In order that people can use formats like #D in #() in the status line and not have to wait for an update when they change pane, we allow commands to run more than once a second if the expanded form changes. Unfortunately this can mean them being run far too often (pretty much continually) when multiple clients exist, because some formats (including #D) will always differ between clients. To avoid this, give each client its own tree of jobs which means that the same command will be different instances for each client - similar to how we have the tag to separate commands for different panes. GitHub issue 889; test case reported by Paul Johnson.
2017-05-01 12:20:55 +00:00
fj->client = ft->client;
Add a window or pane id "tag" to each format tree and use it to separate jobs, this means that if the same job is used for different windows or panes (for example in pane-border-format), it will be run separately for each pane.
2017-02-03 11:57:27 +00:00
fj->tag = ft->tag;
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
fj->cmd = xstrdup(cmd);
In order that people can use formats like #D in #() in the status line and not have to wait for an update when they change pane, we allow commands to run more than once a second if the expanded form changes. Unfortunately this can mean them being run far too often (pretty much continually) when multiple clients exist, because some formats (including #D) will always differ between clients. To avoid this, give each client its own tree of jobs which means that the same command will be different instances for each client - similar to how we have the tag to separate commands for different panes. GitHub issue 889; test case reported by Paul Johnson.
2017-05-01 12:20:55 +00:00
RB_INSERT(format_job_tree, jobs, fj);
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
}
Do not expand times and #() inside #().
2021-02-09 14:25:40 +00:00
format_copy_state(&next, es, FORMAT_EXPAND_NOJOBS);
next.flags &= ~FORMAT_EXPAND_TIME;
expanded = format_expand1(&next, cmd);
Key running commands for #() by the unexpanded command, and run them again if the expanded form changes (otherwise at most once per second as usual). Fixes issues reported by Gregory Pakosz.
2016-11-17 10:06:08 +00:00
if (fj->expanded == NULL || strcmp(expanded, fj->expanded) != 0) {
free((void *)fj->expanded);
fj->expanded = xstrdup(expanded);
force = 1;
} else
force = (ft->flags & FORMAT_FORCE);
Make refresh-client force update of jobs, from Sina Siadat.
2015-09-14 10:25:52 +00:00
t = time(NULL);
With force, kill previous job before starting new. Fixes problem reported by Scott Mcdermott in GitHub issue 1627.
2019-03-18 09:46:42 +00:00
if (force && fj->job != NULL)
job_free(fj->job);
if (force || (fj->job == NULL && fj->last != t)) {
Drop support for popups where the content is provided directly to tmux (which does not have many practical uses) and only support running a program in the popup. display-popup is now simpler and can accept multiple arguments to avoid escaping problems (like the other commands).
2021-03-02 10:56:45 +00:00
fj->job = job_run(expanded, 0, NULL, NULL,
Use same working directory rules for jobs as new windows rather than always starting in home, GitHub issue 1488.
2018-09-27 07:43:18 +00:00
server_client_get_cwd(ft->client, NULL), format_job_update,
Add a flag to run a background process in a pty as well, not used for anything yet.
2020-03-19 13:43:18 +00:00
format_job_complete, NULL, fj, JOB_NOWAIT, -1, -1);
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
if (fj->job == NULL) {
free(fj->out);
xasprintf(&fj->out, "<'%s' didn't start>", fj->cmd);
}
Make refresh-client force update of jobs, from Sina Siadat.
2015-09-14 10:25:52 +00:00
fj->last = t;
Remove an unused variable.
2017-05-12 22:43:15 +00:00
fj->updated = 0;
Give #() commands a one second grace period where the output is empty before telling the user they aren't doing anything. GitHub issue 2774.
2021-07-13 22:09:29 +00:00
} else if (fj->job != NULL && (t - fj->last) > 1 && fj->out == NULL)
xasprintf(&fj->out, "<'%s' not ready>", fj->cmd);
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
free(expanded);
Make refresh-client force update of jobs, from Sina Siadat.
2015-09-14 10:25:52 +00:00
if (ft->flags & FORMAT_STATUS)
fj->status = 1;
Give #() commands a one second grace period where the output is empty before telling the user they aren't doing anything. GitHub issue 2774.
2021-07-13 22:09:29 +00:00
if (fj->out == NULL)
return (xstrdup(""));
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
return (format_expand1(&next, fj->out));
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
}
/* Remove old jobs. */
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static void
In order that people can use formats like #D in #() in the status line and not have to wait for an update when they change pane, we allow commands to run more than once a second if the expanded form changes. Unfortunately this can mean them being run far too often (pretty much continually) when multiple clients exist, because some formats (including #D) will always differ between clients. To avoid this, give each client its own tree of jobs which means that the same command will be different instances for each client - similar to how we have the tag to separate commands for different panes. GitHub issue 889; test case reported by Paul Johnson.
2017-05-01 12:20:55 +00:00
format_job_tidy(struct format_job_tree *jobs, int force)
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
{
struct format_job *fj, *fj1;
time_t now;
now = time(NULL);
In order that people can use formats like #D in #() in the status line and not have to wait for an update when they change pane, we allow commands to run more than once a second if the expanded form changes. Unfortunately this can mean them being run far too often (pretty much continually) when multiple clients exist, because some formats (including #D) will always differ between clients. To avoid this, give each client its own tree of jobs which means that the same command will be different instances for each client - similar to how we have the tag to separate commands for different panes. GitHub issue 889; test case reported by Paul Johnson.
2017-05-01 12:20:55 +00:00
RB_FOREACH_SAFE(fj, format_job_tree, jobs, fj1) {
if (!force && (fj->last > now || now - fj->last < 3600))
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
continue;
In order that people can use formats like #D in #() in the status line and not have to wait for an update when they change pane, we allow commands to run more than once a second if the expanded form changes. Unfortunately this can mean them being run far too often (pretty much continually) when multiple clients exist, because some formats (including #D) will always differ between clients. To avoid this, give each client its own tree of jobs which means that the same command will be different instances for each client - similar to how we have the tag to separate commands for different panes. GitHub issue 889; test case reported by Paul Johnson.
2017-05-01 12:20:55 +00:00
RB_REMOVE(format_job_tree, jobs, fj);
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
Move format job cleanup onto its own timer.
2015-08-28 11:38:27 +00:00
log_debug("%s: %s", __func__, fj->cmd);
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
if (fj->job != NULL)
job_free(fj->job);
Key running commands for #() by the unexpanded command, and run them again if the expanded form changes (otherwise at most once per second as usual). Fixes issues reported by Gregory Pakosz.
2016-11-17 10:06:08 +00:00
free((void *)fj->expanded);
Run status update on a per-client timer at status-interval.
2015-08-28 12:16:28 +00:00
free((void *)fj->cmd);
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
free(fj->out);
free(fj);
}
In order that people can use formats like #D in #() in the status line and not have to wait for an update when they change pane, we allow commands to run more than once a second if the expanded form changes. Unfortunately this can mean them being run far too often (pretty much continually) when multiple clients exist, because some formats (including #D) will always differ between clients. To avoid this, give each client its own tree of jobs which means that the same command will be different instances for each client - similar to how we have the tag to separate commands for different panes. GitHub issue 889; test case reported by Paul Johnson.
2017-05-01 12:20:55 +00:00
}
Tidy old jobs every hour instead of every 30 seconds.
2021-03-11 07:08:18 +00:00
/* Tidy old jobs for all clients. */
In order that people can use formats like #D in #() in the status line and not have to wait for an update when they change pane, we allow commands to run more than once a second if the expanded form changes. Unfortunately this can mean them being run far too often (pretty much continually) when multiple clients exist, because some formats (including #D) will always differ between clients. To avoid this, give each client its own tree of jobs which means that the same command will be different instances for each client - similar to how we have the tag to separate commands for different panes. GitHub issue 889; test case reported by Paul Johnson.
2017-05-01 12:20:55 +00:00
void
Tidy old jobs every hour instead of every 30 seconds.
2021-03-11 07:08:18 +00:00
format_tidy_jobs(void)
In order that people can use formats like #D in #() in the status line and not have to wait for an update when they change pane, we allow commands to run more than once a second if the expanded form changes. Unfortunately this can mean them being run far too often (pretty much continually) when multiple clients exist, because some formats (including #D) will always differ between clients. To avoid this, give each client its own tree of jobs which means that the same command will be different instances for each client - similar to how we have the tag to separate commands for different panes. GitHub issue 889; test case reported by Paul Johnson.
2017-05-01 12:20:55 +00:00
{
struct client *c;
format_job_tidy(&format_jobs, 0);
TAILQ_FOREACH(c, &clients, entry) {
if (c->jobs != NULL)
format_job_tidy(c->jobs, 0);
}
Tidy old jobs every hour instead of every 30 seconds.
2021-03-11 07:08:18 +00:00
}
Move format job cleanup onto its own timer.
2015-08-28 11:38:27 +00:00
Tidy old jobs every hour instead of every 30 seconds.
2021-03-11 07:08:18 +00:00
/* Remove old jobs for client. */
void
format_lost_client(struct client *c)
{
if (c->jobs != NULL)
format_job_tidy(c->jobs, 1);
free(c->jobs);
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
}
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
/* Wrapper for asprintf. */
static char * printflike(1, 2)
format_printf(const char *fmt, ...)
{
va_list ap;
char *s;
va_start(ap, fmt);
xvasprintf(&s, fmt, ap);
va_end(ap);
return (s);
}
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
/* Callback for host. */
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
static void *
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
format_cb_host(__unused struct format_tree *ft)
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
{
char host[HOST_NAME_MAX + 1];
if (gethostname(host, sizeof host) != 0)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (xstrdup(""));
return (xstrdup(host));
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
}
/* Callback for host_short. */
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
static void *
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
format_cb_host_short(__unused struct format_tree *ft)
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
{
char host[HOST_NAME_MAX + 1], *cp;
if (gethostname(host, sizeof host) != 0)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (xstrdup(""));
if ((cp = strchr(host, '.')) != NULL)
*cp = '\0';
return (xstrdup(host));
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
}
/* Callback for pid. */
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
static void *
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
format_cb_pid(__unused struct format_tree *ft)
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
{
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
char *value;
xasprintf(&value, "%ld", (long)getpid());
return (value);
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
}
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
/* Callback for session_attached_list. */
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
static void *
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
format_cb_session_attached_list(struct format_tree *ft)
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
{
struct session *s = ft->s;
struct client *loop;
struct evbuffer *buffer;
int size;
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
char *value = NULL;
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
if (s == NULL)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (NULL);
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
buffer = evbuffer_new();
if (buffer == NULL)
fatalx("out of memory");
TAILQ_FOREACH(loop, &clients, entry) {
if (loop->session == s) {
if (EVBUFFER_LENGTH(buffer) > 0)
evbuffer_add(buffer, ",", 1);
evbuffer_add_printf(buffer, "%s", loop->name);
}
}
if ((size = EVBUFFER_LENGTH(buffer)) != 0)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
xasprintf(&value, "%.*s", size, EVBUFFER_DATA(buffer));
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
evbuffer_free(buffer);
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (value);
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
}
Make a few more expensive (ish) formats functions instead of inline.
2015-08-28 17:01:42 +00:00
/* Callback for session_alerts. */
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
static void *
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
format_cb_session_alerts(struct format_tree *ft)
Make a few more expensive (ish) formats functions instead of inline.
2015-08-28 17:01:42 +00:00
{
struct session *s = ft->s;
struct winlink *wl;
Add some formats to look at the session window stack, suggested by Scott ROCHFORD.
2017-05-05 11:59:47 +00:00
char alerts[1024], tmp[16];
Make a few more expensive (ish) formats functions instead of inline.
2015-08-28 17:01:42 +00:00
if (s == NULL)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (NULL);
Make a few more expensive (ish) formats functions instead of inline.
2015-08-28 17:01:42 +00:00
*alerts = '\0';
RB_FOREACH(wl, winlinks, &s->windows) {
if ((wl->flags & WINLINK_ALERTFLAGS) == 0)
continue;
xsnprintf(tmp, sizeof tmp, "%u", wl->idx);
if (*alerts != '\0')
strlcat(alerts, ",", sizeof alerts);
strlcat(alerts, tmp, sizeof alerts);
if (wl->flags & WINLINK_ACTIVITY)
strlcat(alerts, "#", sizeof alerts);
if (wl->flags & WINLINK_BELL)
strlcat(alerts, "!", sizeof alerts);
if (wl->flags & WINLINK_SILENCE)
strlcat(alerts, "~", sizeof alerts);
}
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (xstrdup(alerts));
Make a few more expensive (ish) formats functions instead of inline.
2015-08-28 17:01:42 +00:00
}
Add some formats to look at the session window stack, suggested by Scott ROCHFORD.
2017-05-05 11:59:47 +00:00
/* Callback for session_stack. */
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
static void *
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
format_cb_session_stack(struct format_tree *ft)
Add some formats to look at the session window stack, suggested by Scott ROCHFORD.
2017-05-05 11:59:47 +00:00
{
struct session *s = ft->s;
struct winlink *wl;
char result[1024], tmp[16];
if (s == NULL)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (NULL);
Add some formats to look at the session window stack, suggested by Scott ROCHFORD.
2017-05-05 11:59:47 +00:00
xsnprintf(result, sizeof result, "%u", s->curw->idx);
TAILQ_FOREACH(wl, &s->lastw, sentry) {
xsnprintf(tmp, sizeof tmp, "%u", wl->idx);
if (*result != '\0')
strlcat(result, ",", sizeof result);
strlcat(result, tmp, sizeof result);
}
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (xstrdup(result));
Add some formats to look at the session window stack, suggested by Scott ROCHFORD.
2017-05-05 11:59:47 +00:00
}
/* Callback for window_stack_index. */
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
static void *
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
format_cb_window_stack_index(struct format_tree *ft)
Add some formats to look at the session window stack, suggested by Scott ROCHFORD.
2017-05-05 11:59:47 +00:00
{
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
struct session *s;
Add some formats to look at the session window stack, suggested by Scott ROCHFORD.
2017-05-05 11:59:47 +00:00
struct winlink *wl;
u_int idx;
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
char *value = NULL;
Add some formats to look at the session window stack, suggested by Scott ROCHFORD.
2017-05-05 11:59:47 +00:00
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
if (ft->wl == NULL)
return (NULL);
s = ft->wl->session;
Add some formats to look at the session window stack, suggested by Scott ROCHFORD.
2017-05-05 11:59:47 +00:00
idx = 0;
TAILQ_FOREACH(wl, &s->lastw, sentry) {
idx++;
if (wl == ft->wl)
break;
}
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
if (wl == NULL)
return (xstrdup("0"));
xasprintf(&value, "%u", idx);
return (value);
Add some formats to look at the session window stack, suggested by Scott ROCHFORD.
2017-05-05 11:59:47 +00:00
}
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
/* Callback for window_linked_sessions_list. */
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
static void *
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
format_cb_window_linked_sessions_list(struct format_tree *ft)
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
{
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
struct window *w;
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
struct winlink *wl;
struct evbuffer *buffer;
int size;
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
char *value = NULL;
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
if (ft->wl == NULL)
return (NULL);
w = ft->wl->window;
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
buffer = evbuffer_new();
if (buffer == NULL)
fatalx("out of memory");
TAILQ_FOREACH(wl, &w->winlinks, wentry) {
if (EVBUFFER_LENGTH(buffer) > 0)
evbuffer_add(buffer, ",", 1);
evbuffer_add_printf(buffer, "%s", wl->session->name);
}
if ((size = EVBUFFER_LENGTH(buffer)) != 0)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
xasprintf(&value, "%.*s", size, EVBUFFER_DATA(buffer));
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
evbuffer_free(buffer);
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (value);
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
}
/* Callback for window_active_sessions. */
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
static void *
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
format_cb_window_active_sessions(struct format_tree *ft)
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
{
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
struct window *w;
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
struct winlink *wl;
u_int n = 0;
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
char *value;
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
if (ft->wl == NULL)
return (NULL);
w = ft->wl->window;
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
TAILQ_FOREACH(wl, &w->winlinks, wentry) {
if (wl->session->curw == wl)
n++;
}
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
xasprintf(&value, "%u", n);
return (value);
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
}
/* Callback for window_active_sessions_list. */
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
static void *
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
format_cb_window_active_sessions_list(struct format_tree *ft)
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
{
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
struct window *w;
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
struct winlink *wl;
struct evbuffer *buffer;
int size;
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
char *value = NULL;
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
if (ft->wl == NULL)
return (NULL);
w = ft->wl->window;
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
buffer = evbuffer_new();
if (buffer == NULL)
fatalx("out of memory");
TAILQ_FOREACH(wl, &w->winlinks, wentry) {
if (wl->session->curw == wl) {
if (EVBUFFER_LENGTH(buffer) > 0)
evbuffer_add(buffer, ",", 1);
evbuffer_add_printf(buffer, "%s", wl->session->name);
}
}
if ((size = EVBUFFER_LENGTH(buffer)) != 0)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
xasprintf(&value, "%.*s", size, EVBUFFER_DATA(buffer));
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
evbuffer_free(buffer);
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (value);
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
}
/* Callback for window_active_clients. */
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
static void *
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
format_cb_window_active_clients(struct format_tree *ft)
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
{
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
struct window *w;
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
struct client *loop;
struct session *client_session;
u_int n = 0;
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
char *value;
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
if (ft->wl == NULL)
return (NULL);
w = ft->wl->window;
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
TAILQ_FOREACH(loop, &clients, entry) {
client_session = loop->session;
if (client_session == NULL)
continue;
if (w == client_session->curw->window)
n++;
}
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
xasprintf(&value, "%u", n);
return (value);
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
}
/* Callback for window_active_clients_list. */
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
static void *
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
format_cb_window_active_clients_list(struct format_tree *ft)
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
{
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
struct window *w;
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
struct client *loop;
struct session *client_session;
struct evbuffer *buffer;
int size;
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
char *value = NULL;
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
if (ft->wl == NULL)
return (NULL);
w = ft->wl->window;
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
buffer = evbuffer_new();
if (buffer == NULL)
fatalx("out of memory");
TAILQ_FOREACH(loop, &clients, entry) {
client_session = loop->session;
if (client_session == NULL)
continue;
if (w == client_session->curw->window) {
if (EVBUFFER_LENGTH(buffer) > 0)
evbuffer_add(buffer, ",", 1);
evbuffer_add_printf(buffer, "%s", loop->name);
}
}
if ((size = EVBUFFER_LENGTH(buffer)) != 0)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
xasprintf(&value, "%.*s", size, EVBUFFER_DATA(buffer));
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
evbuffer_free(buffer);
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (value);
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
}
Make a few more expensive (ish) formats functions instead of inline.
2015-08-28 17:01:42 +00:00
/* Callback for window_layout. */
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
static void *
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
format_cb_window_layout(struct format_tree *ft)
Make a few more expensive (ish) formats functions instead of inline.
2015-08-28 17:01:42 +00:00
{
struct window *w = ft->w;
if (w == NULL)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (NULL);
Make a few more expensive (ish) formats functions instead of inline.
2015-08-28 17:01:42 +00:00
if (w->saved_layout_root != NULL)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (layout_dump(w->saved_layout_root));
return (layout_dump(w->layout_root));
Make a few more expensive (ish) formats functions instead of inline.
2015-08-28 17:01:42 +00:00
}
Add window_visible_layout which ignores zoomed panes and use it for control mode (which needs to know all panes), from George Nachman.
2015-11-13 10:00:26 +00:00
/* Callback for window_visible_layout. */
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
static void *
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
format_cb_window_visible_layout(struct format_tree *ft)
Add window_visible_layout which ignores zoomed panes and use it for control mode (which needs to know all panes), from George Nachman.
2015-11-13 10:00:26 +00:00
{
struct window *w = ft->w;
if (w == NULL)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (NULL);
Add window_visible_layout which ignores zoomed panes and use it for control mode (which needs to know all panes), from George Nachman.
2015-11-13 10:00:26 +00:00
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (layout_dump(w->layout_root));
Add window_visible_layout which ignores zoomed panes and use it for control mode (which needs to know all panes), from George Nachman.
2015-11-13 10:00:26 +00:00
}
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
/* Callback for pane_start_command. */
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
static void *
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
format_cb_start_command(struct format_tree *ft)
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
{
struct window_pane *wp = ft->wp;
if (wp == NULL)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (NULL);
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (cmd_stringify_argv(wp->argc, wp->argv));
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
}
/* Callback for pane_current_command. */
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
static void *
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
format_cb_current_command(struct format_tree *ft)
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
{
struct window_pane *wp = ft->wp;
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
char *cmd, *value;
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
Do not crash with pane_current_command if the pane is newly created and has no shell set, from Thomas Adam.
2019-10-14 09:24:06 +00:00
if (wp == NULL || wp->shell == NULL)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (NULL);
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
cmd = get_proc_name(wp->fd, wp->tty);
if (cmd == NULL || *cmd == '\0') {
free(cmd);
cmd = cmd_stringify_argv(wp->argc, wp->argv);
if (cmd == NULL || *cmd == '\0') {
free(cmd);
cmd = xstrdup(wp->shell);
}
}
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
value = parse_window_name(cmd);
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
free(cmd);
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (value);
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
}
Restore pane_current_path format from portable tmux, it is no longer used by default and is very useful.
2020-04-08 11:26:07 +00:00
/* Callback for pane_current_path. */
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
static void *
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
format_cb_current_path(struct format_tree *ft)
Restore pane_current_path format from portable tmux, it is no longer used by default and is very useful.
2020-04-08 11:26:07 +00:00
{
struct window_pane *wp = ft->wp;
char *cwd;
if (wp == NULL)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (NULL);
Restore pane_current_path format from portable tmux, it is no longer used by default and is very useful.
2020-04-08 11:26:07 +00:00
cwd = get_proc_cwd(wp->fd);
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
if (cwd == NULL)
return (NULL);
return (xstrdup(cwd));
Restore pane_current_path format from portable tmux, it is no longer used by default and is very useful.
2020-04-08 11:26:07 +00:00
}
Make a few more expensive (ish) formats functions instead of inline.
2015-08-28 17:01:42 +00:00
/* Callback for history_bytes. */
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
static void *
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
format_cb_history_bytes(struct format_tree *ft)
Make a few more expensive (ish) formats functions instead of inline.
2015-08-28 17:01:42 +00:00
{
struct window_pane *wp = ft->wp;
struct grid *gd;
struct grid_line *gl;
Make some data types consistent.
2020-05-25 15:02:25 +00:00
size_t size = 0;
Make a few more expensive (ish) formats functions instead of inline.
2015-08-28 17:01:42 +00:00
u_int i;
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
char *value;
Make a few more expensive (ish) formats functions instead of inline.
2015-08-28 17:01:42 +00:00
if (wp == NULL)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (NULL);
Make a few more expensive (ish) formats functions instead of inline.
2015-08-28 17:01:42 +00:00
gd = wp->base.grid;
Make some data types consistent.
2020-05-25 15:02:25 +00:00
for (i = 0; i < gd->hsize + gd->sy; i++) {
Add accessors for grid linedata member, for some future work. From Dan Aloni.
2018-07-04 09:44:07 +00:00
gl = grid_get_line(gd, i);
Make a few more expensive (ish) formats functions instead of inline.
2015-08-28 17:01:42 +00:00
size += gl->cellsize * sizeof *gl->celldata;
Long overdue change to the way we store cells in the grid: now, instead of storing a full grid_cell with UTF-8 data and everything, store a new type grid_cell_entry. This can either be the cell itself (for ASCII cells), or an offset into an extended array (per line) for UTF-8 data. This avoid a large (8 byte) overhead on non-UTF-8 cells (by far the majority for most users) without the complexity of the shadow array we had before. Grid memory without any UTF-8 is about half. The disadvantage that cells can no longer be modified in place and need to be copied out of the grid and back but it turned out to be lot less complicated than I expected.
2015-11-13 08:09:28 +00:00
size += gl->extdsize * sizeof *gl->extddata;
Make a few more expensive (ish) formats functions instead of inline.
2015-08-28 17:01:42 +00:00
}
Make some data types consistent.
2020-05-25 15:02:25 +00:00
size += (gd->hsize + gd->sy) * sizeof *gl;
Make a few more expensive (ish) formats functions instead of inline.
2015-08-28 17:01:42 +00:00
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
xasprintf(&value, "%zu", size);
return (value);
Make some data types consistent.
2020-05-25 15:02:25 +00:00
}
/* Callback for history_all_bytes. */
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
static void *
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
format_cb_history_all_bytes(struct format_tree *ft)
Make some data types consistent.
2020-05-25 15:02:25 +00:00
{
struct window_pane *wp = ft->wp;
struct grid *gd;
struct grid_line *gl;
u_int i, lines, cells = 0, extended_cells = 0;
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
char *value;
Make some data types consistent.
2020-05-25 15:02:25 +00:00
if (wp == NULL)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (NULL);
Make some data types consistent.
2020-05-25 15:02:25 +00:00
gd = wp->base.grid;
lines = gd->hsize + gd->sy;
for (i = 0; i < lines; i++) {
gl = grid_get_line(gd, i);
cells += gl->cellsize;
extended_cells += gl->extdsize;
}
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
xasprintf(&value, "%u,%zu,%u,%zu,%u,%zu", lines,
Make some data types consistent.
2020-05-25 15:02:25 +00:00
lines * sizeof *gl, cells, cells * sizeof *gl->celldata,
extended_cells, extended_cells * sizeof *gl->extddata);
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (value);
Make a few more expensive (ish) formats functions instead of inline.
2015-08-28 17:01:42 +00:00
}
/* Callback for pane_tabs. */
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
static void *
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
format_cb_pane_tabs(struct format_tree *ft)
Make a few more expensive (ish) formats functions instead of inline.
2015-08-28 17:01:42 +00:00
{
struct window_pane *wp = ft->wp;
struct evbuffer *buffer;
u_int i;
int size;
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
char *value = NULL;
Make a few more expensive (ish) formats functions instead of inline.
2015-08-28 17:01:42 +00:00
if (wp == NULL)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (NULL);
Make a few more expensive (ish) formats functions instead of inline.
2015-08-28 17:01:42 +00:00
buffer = evbuffer_new();
evbuffer_new and bufferevent_new can both fail (when malloc fails) and return NULL. GitHub issue 1547.
2018-11-19 13:35:40 +00:00
if (buffer == NULL)
fatalx("out of memory");
Make a few more expensive (ish) formats functions instead of inline.
2015-08-28 17:01:42 +00:00
for (i = 0; i < wp->base.grid->sx; i++) {
if (!bit_test(wp->base.tabs, i))
continue;
if (EVBUFFER_LENGTH(buffer) > 0)
evbuffer_add(buffer, ",", 1);
evbuffer_add_printf(buffer, "%u", i);
}
Only show the first member of session groups in tree mode (-G flag disables).
2017-11-02 18:27:35 +00:00
if ((size = EVBUFFER_LENGTH(buffer)) != 0)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
xasprintf(&value, "%.*s", size, EVBUFFER_DATA(buffer));
Only show the first member of session groups in tree mode (-G flag disables).
2017-11-02 18:27:35 +00:00
evbuffer_free(buffer);
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (value);
Only show the first member of session groups in tree mode (-G flag disables).
2017-11-02 18:27:35 +00:00
}
Support X11 colour names and some other variations for OSC 10/11, also add OSC 110 and 111. GitHub issue 2567.
2021-02-15 09:39:37 +00:00
/* Callback for pane_fg. */
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
static void *
Support X11 colour names and some other variations for OSC 10/11, also add OSC 110 and 111. GitHub issue 2567.
2021-02-15 09:39:37 +00:00
format_cb_pane_fg(struct format_tree *ft)
{
struct window_pane *wp = ft->wp;
struct grid_cell gc;
Move hook format setup earlier and add a hook_client, GitHub issue 2809.
2021-08-12 08:05:11 +00:00
if (wp == NULL)
return (NULL);
Support X11 colour names and some other variations for OSC 10/11, also add OSC 110 and 111. GitHub issue 2567.
2021-02-15 09:39:37 +00:00
tty_default_colours(&gc, wp);
return (xstrdup(colour_tostring(gc.fg)));
}
/* Callback for pane_bg. */
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
static void *
Support X11 colour names and some other variations for OSC 10/11, also add OSC 110 and 111. GitHub issue 2567.
2021-02-15 09:39:37 +00:00
format_cb_pane_bg(struct format_tree *ft)
{
struct window_pane *wp = ft->wp;
struct grid_cell gc;
Move hook format setup earlier and add a hook_client, GitHub issue 2809.
2021-08-12 08:05:11 +00:00
if (wp == NULL)
return (NULL);
Support X11 colour names and some other variations for OSC 10/11, also add OSC 110 and 111. GitHub issue 2567.
2021-02-15 09:39:37 +00:00
tty_default_colours(&gc, wp);
return (xstrdup(colour_tostring(gc.bg)));
}
Format for group list of "other sessions" is a bit weird, just list all the sessions in the group.
2017-11-02 18:52:05 +00:00
/* Callback for session_group_list. */
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
static void *
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
format_cb_session_group_list(struct format_tree *ft)
Only show the first member of session groups in tree mode (-G flag disables).
2017-11-02 18:27:35 +00:00
{
struct session *s = ft->s;
struct session_group *sg;
struct session *loop;
struct evbuffer *buffer;
int size;
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
char *value = NULL;
Only show the first member of session groups in tree mode (-G flag disables).
2017-11-02 18:27:35 +00:00
if (s == NULL)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (NULL);
Only show the first member of session groups in tree mode (-G flag disables).
2017-11-02 18:27:35 +00:00
sg = session_group_contains(s);
if (sg == NULL)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (NULL);
Only show the first member of session groups in tree mode (-G flag disables).
2017-11-02 18:27:35 +00:00
buffer = evbuffer_new();
evbuffer_new and bufferevent_new can both fail (when malloc fails) and return NULL. GitHub issue 1547.
2018-11-19 13:35:40 +00:00
if (buffer == NULL)
fatalx("out of memory");
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
Only show the first member of session groups in tree mode (-G flag disables).
2017-11-02 18:27:35 +00:00
TAILQ_FOREACH(loop, &sg->sessions, gentry) {
if (EVBUFFER_LENGTH(buffer) > 0)
evbuffer_add(buffer, ",", 1);
evbuffer_add_printf(buffer, "%s", loop->name);
}
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
if ((size = EVBUFFER_LENGTH(buffer)) != 0)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
xasprintf(&value, "%.*s", size, EVBUFFER_DATA(buffer));
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
evbuffer_free(buffer);
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (value);
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
}
/* Callback for session_group_attached_list. */
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
static void *
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
format_cb_session_group_attached_list(struct format_tree *ft)
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
{
struct session *s = ft->s, *client_session, *session_loop;
struct session_group *sg;
struct client *loop;
struct evbuffer *buffer;
int size;
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
char *value = NULL;
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
if (s == NULL)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (NULL);
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
sg = session_group_contains(s);
if (sg == NULL)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (NULL);
Add a number of new formats to inspect what sessions and clients a window is present or active in. From Tyler Culp in GitHub issue 2034.
2019-12-26 11:04:58 +00:00
buffer = evbuffer_new();
if (buffer == NULL)
fatalx("out of memory");
TAILQ_FOREACH(loop, &clients, entry) {
client_session = loop->session;
if (client_session == NULL)
continue;
TAILQ_FOREACH(session_loop, &sg->sessions, gentry) {
if (session_loop == client_session){
if (EVBUFFER_LENGTH(buffer) > 0)
evbuffer_add(buffer, ",", 1);
evbuffer_add_printf(buffer, "%s", loop->name);
}
}
}
Only show the first member of session groups in tree mode (-G flag disables).
2017-11-02 18:27:35 +00:00
if ((size = EVBUFFER_LENGTH(buffer)) != 0)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
xasprintf(&value, "%.*s", size, EVBUFFER_DATA(buffer));
Make a few more expensive (ish) formats functions instead of inline.
2015-08-28 17:01:42 +00:00
evbuffer_free(buffer);
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (value);
Make a few more expensive (ish) formats functions instead of inline.
2015-08-28 17:01:42 +00:00
}
Allow multiple modes to be open in a pane. A stack of open modes is kept and the previous restored when the top is exited. If a mode that is already on the stack is entered, the existing instance is moved to the top as the active mode rather than being opened new.
2019-03-12 11:16:49 +00:00
/* Callback for pane_in_mode. */
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
static void *
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
format_cb_pane_in_mode(struct format_tree *ft)
Allow multiple modes to be open in a pane. A stack of open modes is kept and the previous restored when the top is exited. If a mode that is already on the stack is entered, the existing instance is moved to the top as the active mode rather than being opened new.
2019-03-12 11:16:49 +00:00
{
struct window_pane *wp = ft->wp;
u_int n = 0;
struct window_mode_entry *wme;
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
char *value;
Allow multiple modes to be open in a pane. A stack of open modes is kept and the previous restored when the top is exited. If a mode that is already on the stack is entered, the existing instance is moved to the top as the active mode rather than being opened new.
2019-03-12 11:16:49 +00:00
if (wp == NULL)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (NULL);
Allow multiple modes to be open in a pane. A stack of open modes is kept and the previous restored when the top is exited. If a mode that is already on the stack is entered, the existing instance is moved to the top as the active mode rather than being opened new.
2019-03-12 11:16:49 +00:00
TAILQ_FOREACH(wme, &wp->modes, entry)
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
n++;
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
xasprintf(&value, "%u", n);
return (value);
Allow multiple modes to be open in a pane. A stack of open modes is kept and the previous restored when the top is exited. If a mode that is already on the stack is entered, the existing instance is moved to the top as the active mode rather than being opened new.
2019-03-12 11:16:49 +00:00
}
Fix top/bottom pane calculation with pane border status enabled, reported by Stanislav Spassov.
2020-02-14 13:57:58 +00:00
/* Callback for pane_at_top. */
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
static void *
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
format_cb_pane_at_top(struct format_tree *ft)
Fix top/bottom pane calculation with pane border status enabled, reported by Stanislav Spassov.
2020-02-14 13:57:58 +00:00
{
struct window_pane *wp = ft->wp;
Some more, and use of wp->window before wp NULL check in format.c.
2020-04-09 13:53:50 +00:00
struct window *w;
Fix top/bottom pane calculation with pane border status enabled, reported by Stanislav Spassov.
2020-02-14 13:57:58 +00:00
int status, flag;
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
char *value;
Fix top/bottom pane calculation with pane border status enabled, reported by Stanislav Spassov.
2020-02-14 13:57:58 +00:00
if (wp == NULL)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (NULL);
Some more, and use of wp->window before wp NULL check in format.c.
2020-04-09 13:53:50 +00:00
w = wp->window;
Fix top/bottom pane calculation with pane border status enabled, reported by Stanislav Spassov.
2020-02-14 13:57:58 +00:00
status = options_get_number(w->options, "pane-border-status");
if (status == PANE_STATUS_TOP)
flag = (wp->yoff == 1);
else
flag = (wp->yoff == 0);
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
xasprintf(&value, "%d", flag);
return (value);
Fix top/bottom pane calculation with pane border status enabled, reported by Stanislav Spassov.
2020-02-14 13:57:58 +00:00
}
/* Callback for pane_at_bottom. */
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
static void *
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
format_cb_pane_at_bottom(struct format_tree *ft)
Fix top/bottom pane calculation with pane border status enabled, reported by Stanislav Spassov.
2020-02-14 13:57:58 +00:00
{
struct window_pane *wp = ft->wp;
Some more, and use of wp->window before wp NULL check in format.c.
2020-04-09 13:53:50 +00:00
struct window *w;
Fix top/bottom pane calculation with pane border status enabled, reported by Stanislav Spassov.
2020-02-14 13:57:58 +00:00
int status, flag;
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
char *value;
Fix top/bottom pane calculation with pane border status enabled, reported by Stanislav Spassov.
2020-02-14 13:57:58 +00:00
if (wp == NULL)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (NULL);
Some more, and use of wp->window before wp NULL check in format.c.
2020-04-09 13:53:50 +00:00
w = wp->window;
Fix top/bottom pane calculation with pane border status enabled, reported by Stanislav Spassov.
2020-02-14 13:57:58 +00:00
status = options_get_number(w->options, "pane-border-status");
if (status == PANE_STATUS_BOTTOM)
flag = (wp->yoff + wp->sy == w->sy - 1);
else
flag = (wp->yoff + wp->sy == w->sy);
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
xasprintf(&value, "%d", flag);
return (value);
Fix top/bottom pane calculation with pane border status enabled, reported by Stanislav Spassov.
2020-02-14 13:57:58 +00:00
}
Add a cursor_character format.
2019-03-19 19:01:50 +00:00
/* Callback for cursor_character. */
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
static void *
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
format_cb_cursor_character(struct format_tree *ft)
Add a cursor_character format.
2019-03-19 19:01:50 +00:00
{
struct window_pane *wp = ft->wp;
struct grid_cell gc;
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
char *value = NULL;
Add a cursor_character format.
2019-03-19 19:01:50 +00:00
if (wp == NULL)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
return (NULL);
Add a cursor_character format.
2019-03-19 19:01:50 +00:00
grid_view_get_cell(wp->base.grid, wp->base.cx, wp->base.cy, &gc);
if (~gc.flags & GRID_FLAG_PADDING)
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
xasprintf(&value, "%.*s", (int)gc.data.size, gc.data.data);
return (value);
Add a cursor_character format.
2019-03-19 19:01:50 +00:00
}
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
/* Callback for mouse_word. */
static void *
format_cb_mouse_word(struct format_tree *ft)
Add formats for word and line under the mouse and use them to add some items to the pane menu.
2019-05-26 17:34:45 +00:00
{
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
struct window_pane *wp;
struct grid *gd;
u_int x, y;
char *s;
Add formats for word and line under the mouse and use them to add some items to the pane menu.
2019-05-26 17:34:45 +00:00
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
if (!ft->m.valid)
return (NULL);
wp = cmd_mouse_pane(&ft->m, NULL, NULL);
if (wp == NULL)
return (NULL);
if (cmd_mouse_at(wp, &ft->m, &x, &y, 0) != 0)
return (NULL);
Add formats for word and line under the mouse and use them to add some items to the pane menu.
2019-05-26 17:34:45 +00:00
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
if (!TAILQ_EMPTY(&wp->modes)) {
if (TAILQ_FIRST(&wp->modes)->mode == &window_copy_mode ||
TAILQ_FIRST(&wp->modes)->mode == &window_view_mode)
return (s = window_copy_get_word(wp, x, y));
return (NULL);
}
gd = wp->base.grid;
return (format_grid_word(gd, x, gd->hsize + y));
}
Add formats for word and line under the mouse and use them to add some items to the pane menu.
2019-05-26 17:34:45 +00:00
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
/* Callback for mouse_line. */
static void *
format_cb_mouse_line(struct format_tree *ft)
{
struct window_pane *wp;
struct grid *gd;
u_int x, y;
if (!ft->m.valid)
return (NULL);
wp = cmd_mouse_pane(&ft->m, NULL, NULL);
if (wp == NULL)
return (NULL);
if (cmd_mouse_at(wp, &ft->m, &x, &y, 0) != 0)
return (NULL);
if (!TAILQ_EMPTY(&wp->modes)) {
if (TAILQ_FIRST(&wp->modes)->mode == &window_copy_mode ||
TAILQ_FIRST(&wp->modes)->mode == &window_view_mode)
return (window_copy_get_line(wp, y));
return (NULL);
Add formats for word and line under the mouse and use them to add some items to the pane menu.
2019-05-26 17:34:45 +00:00
}
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
gd = wp->base.grid;
return (format_grid_line(gd, gd->hsize + y));
}
Add formats for word and line under the mouse and use them to add some items to the pane menu.
2019-05-26 17:34:45 +00:00
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
/* Callback for alternate_on. */
static void *
format_cb_alternate_on(struct format_tree *ft)
{
if (ft->wp != NULL) {
if (ft->wp->base.saved_grid != NULL)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
Add formats for word and line under the mouse and use them to add some items to the pane menu.
2019-05-26 17:34:45 +00:00
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
/* Callback for alternate_saved_x. */
static void *
format_cb_alternate_saved_x(struct format_tree *ft)
{
if (ft->wp != NULL)
return (format_printf("%u", ft->wp->base.saved_cx));
return (NULL);
}
/* Callback for alternate_saved_y. */
static void *
format_cb_alternate_saved_y(struct format_tree *ft)
{
if (ft->wp != NULL)
return (format_printf("%u", ft->wp->base.saved_cy));
return (NULL);
}
/* Callback for buffer_name. */
static void *
format_cb_buffer_name(struct format_tree *ft)
{
if (ft->pb != NULL)
return (xstrdup(paste_buffer_name(ft->pb)));
return (NULL);
}
/* Callback for buffer_sample. */
static void *
format_cb_buffer_sample(struct format_tree *ft)
{
if (ft->pb != NULL)
return (paste_make_sample(ft->pb));
return (NULL);
}
/* Callback for buffer_size. */
static void *
format_cb_buffer_size(struct format_tree *ft)
{
size_t size;
if (ft->pb != NULL) {
paste_buffer_data(ft->pb, &size);
return (format_printf("%zu", size));
Add formats for word and line under the mouse and use them to add some items to the pane menu.
2019-05-26 17:34:45 +00:00
}
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
return (NULL);
}
/* Callback for client_cell_height. */
static void *
format_cb_client_cell_height(struct format_tree *ft)
{
if (ft->c != NULL && (ft->c->tty.flags & TTY_STARTED))
return (format_printf("%u", ft->c->tty.ypixel));
return (NULL);
}
/* Callback for client_cell_width. */
static void *
format_cb_client_cell_width(struct format_tree *ft)
{
if (ft->c != NULL && (ft->c->tty.flags & TTY_STARTED))
return (format_printf("%u", ft->c->tty.xpixel));
return (NULL);
}
/* Callback for client_control_mode. */
static void *
format_cb_client_control_mode(struct format_tree *ft)
{
if (ft->c != NULL) {
if (ft->c->flags & CLIENT_CONTROL)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for client_discarded. */
static void *
format_cb_client_discarded(struct format_tree *ft)
{
if (ft->c != NULL)
return (format_printf("%zu", ft->c->discarded));
return (NULL);
}
/* Callback for client_flags. */
static void *
format_cb_client_flags(struct format_tree *ft)
{
if (ft->c != NULL)
return (xstrdup(server_client_get_flags(ft->c)));
return (NULL);
}
/* Callback for client_height. */
static void *
format_cb_client_height(struct format_tree *ft)
{
if (ft->c != NULL && (ft->c->tty.flags & TTY_STARTED))
return (format_printf("%u", ft->c->tty.sy));
return (NULL);
}
/* Callback for client_key_table. */
static void *
format_cb_client_key_table(struct format_tree *ft)
{
if (ft->c != NULL)
return (xstrdup(ft->c->keytable->name));
return (NULL);
}
/* Callback for client_last_session. */
static void *
format_cb_client_last_session(struct format_tree *ft)
{
if (ft->c != NULL &&
ft->c->last_session != NULL &&
session_alive(ft->c->last_session))
return (xstrdup(ft->c->last_session->name));
return (NULL);
}
/* Callback for client_name. */
static void *
format_cb_client_name(struct format_tree *ft)
{
if (ft->c != NULL)
return (xstrdup(ft->c->name));
return (NULL);
}
/* Callback for client_pid. */
static void *
format_cb_client_pid(struct format_tree *ft)
{
if (ft->c != NULL)
return (format_printf("%ld", (long)ft->c->pid));
return (NULL);
}
/* Callback for client_prefix. */
static void *
format_cb_client_prefix(struct format_tree *ft)
{
const char *name;
if (ft->c != NULL) {
name = server_client_get_key_table(ft->c);
if (strcmp(ft->c->keytable->name, name) == 0)
Correct client_prefix so it returns 1 if in prefix, not 0.
2021-02-24 09:22:15 +00:00
return (xstrdup("0"));
return (xstrdup("1"));
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
}
return (NULL);
}
/* Callback for client_readonly. */
static void *
format_cb_client_readonly(struct format_tree *ft)
{
if (ft->c != NULL) {
if (ft->c->flags & CLIENT_READONLY)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for client_session. */
static void *
format_cb_client_session(struct format_tree *ft)
{
if (ft->c != NULL && ft->c->session != NULL)
return (xstrdup(ft->c->session->name));
return (NULL);
}
/* Callback for client_termfeatures. */
static void *
format_cb_client_termfeatures(struct format_tree *ft)
{
if (ft->c != NULL)
return (xstrdup(tty_get_features(ft->c->term_features)));
return (NULL);
}
/* Callback for client_termname. */
static void *
format_cb_client_termname(struct format_tree *ft)
{
if (ft->c != NULL)
return (xstrdup(ft->c->term_name));
return (NULL);
}
/* Callback for client_termtype. */
static void *
format_cb_client_termtype(struct format_tree *ft)
{
Handle NULL term_type.
2021-02-27 06:28:16 +00:00
if (ft->c != NULL) {
if (ft->c->term_type == NULL)
return (xstrdup(""));
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
return (xstrdup(ft->c->term_type));
Handle NULL term_type.
2021-02-27 06:28:16 +00:00
}
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
return (NULL);
}
/* Callback for client_tty. */
static void *
format_cb_client_tty(struct format_tree *ft)
{
if (ft->c != NULL)
return (xstrdup(ft->c->ttyname));
return (NULL);
}
/* Callback for client_utf8. */
static void *
format_cb_client_utf8(struct format_tree *ft)
{
if (ft->c != NULL) {
if (ft->c->flags & CLIENT_UTF8)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for client_width. */
static void *
format_cb_client_width(struct format_tree *ft)
{
if (ft->c != NULL)
return (format_printf("%u", ft->c->tty.sx));
return (NULL);
}
/* Callback for client_written. */
static void *
format_cb_client_written(struct format_tree *ft)
{
if (ft->c != NULL)
return (format_printf("%zu", ft->c->written));
return (NULL);
}
Move config file path expansion much earlier, keep the list of paths around rather than freeing later, and add a config_files format variable containing it. Suggested by kn@ a while back.
2021-02-22 08:18:13 +00:00
/* Callback for config_files. */
static void *
format_cb_config_files(__unused struct format_tree *ft)
{
char *s = NULL;
size_t slen = 0;
u_int i;
size_t n;
for (i = 0; i < cfg_nfiles; i++) {
n = strlen(cfg_files[i]) + 1;
s = xrealloc(s, slen + n + 1);
slen += xsnprintf(s + slen, n + 1, "%s,", cfg_files[i]);
}
if (s == NULL)
return (xstrdup(""));
s[slen - 1] = '\0';
return (s);
}
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
/* Callback for cursor_flag. */
static void *
format_cb_cursor_flag(struct format_tree *ft)
{
if (ft->wp != NULL) {
if (ft->wp->base.mode & MODE_CURSOR)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for cursor_x. */
static void *
format_cb_cursor_x(struct format_tree *ft)
{
if (ft->wp != NULL)
return (format_printf("%u", ft->wp->base.cx));
return (NULL);
}
/* Callback for cursor_y. */
static void *
format_cb_cursor_y(struct format_tree *ft)
{
if (ft->wp != NULL)
return (format_printf("%u", ft->wp->base.cy));
return (NULL);
}
/* Callback for history_limit. */
static void *
format_cb_history_limit(struct format_tree *ft)
{
if (ft->wp != NULL)
return (format_printf("%u", ft->wp->base.grid->hlimit));
return (NULL);
}
/* Callback for history_size. */
static void *
format_cb_history_size(struct format_tree *ft)
{
if (ft->wp != NULL)
return (format_printf("%u", ft->wp->base.grid->hsize));
return (NULL);
}
/* Callback for insert_flag. */
static void *
format_cb_insert_flag(struct format_tree *ft)
{
if (ft->wp != NULL) {
if (ft->wp->base.mode & MODE_INSERT)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for keypad_cursor_flag. */
static void *
format_cb_keypad_cursor_flag(struct format_tree *ft)
{
if (ft->wp != NULL) {
if (ft->wp->base.mode & MODE_KCURSOR)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for keypad_flag. */
static void *
format_cb_keypad_flag(struct format_tree *ft)
{
if (ft->wp != NULL) {
if (ft->wp->base.mode & MODE_KKEYPAD)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for mouse_all_flag. */
static void *
format_cb_mouse_all_flag(struct format_tree *ft)
{
if (ft->wp != NULL) {
if (ft->wp->base.mode & MODE_MOUSE_ALL)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for mouse_any_flag. */
static void *
format_cb_mouse_any_flag(struct format_tree *ft)
{
if (ft->wp != NULL) {
if (ft->wp->base.mode & ALL_MOUSE_MODES)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for mouse_button_flag. */
static void *
format_cb_mouse_button_flag(struct format_tree *ft)
{
if (ft->wp != NULL) {
if (ft->wp->base.mode & MODE_MOUSE_BUTTON)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for mouse_pane. */
static void *
format_cb_mouse_pane(struct format_tree *ft)
{
struct window_pane *wp;
if (ft->m.valid) {
wp = cmd_mouse_pane(&ft->m, NULL, NULL);
if (wp != NULL)
return (format_printf("%%%u", wp->id));
return (NULL);
}
return (NULL);
}
/* Callback for mouse_sgr_flag. */
static void *
format_cb_mouse_sgr_flag(struct format_tree *ft)
{
if (ft->wp != NULL) {
if (ft->wp->base.mode & MODE_MOUSE_SGR)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for mouse_standard_flag. */
static void *
format_cb_mouse_standard_flag(struct format_tree *ft)
{
if (ft->wp != NULL) {
if (ft->wp->base.mode & MODE_MOUSE_STANDARD)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for mouse_utf8_flag. */
static void *
format_cb_mouse_utf8_flag(struct format_tree *ft)
{
if (ft->wp != NULL) {
if (ft->wp->base.mode & MODE_MOUSE_UTF8)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for mouse_x. */
static void *
format_cb_mouse_x(struct format_tree *ft)
{
struct window_pane *wp;
u_int x, y;
if (ft->m.valid) {
wp = cmd_mouse_pane(&ft->m, NULL, NULL);
if (wp != NULL && cmd_mouse_at(wp, &ft->m, &x, &y, 0) == 0)
return (format_printf("%u", x));
return (NULL);
}
return (NULL);
}
/* Callback for mouse_y. */
static void *
format_cb_mouse_y(struct format_tree *ft)
{
struct window_pane *wp;
u_int x, y;
if (ft->m.valid) {
wp = cmd_mouse_pane(&ft->m, NULL, NULL);
if (wp != NULL && cmd_mouse_at(wp, &ft->m, &x, &y, 0) == 0)
return (format_printf("%u", y));
return (NULL);
}
return (NULL);
}
/* Callback for origin_flag. */
static void *
format_cb_origin_flag(struct format_tree *ft)
{
if (ft->wp != NULL) {
if (ft->wp->base.mode & MODE_ORIGIN)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for pane_active. */
static void *
format_cb_pane_active(struct format_tree *ft)
{
if (ft->wp != NULL) {
if (ft->wp == ft->wp->window->active)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for pane_at_left. */
static void *
format_cb_pane_at_left(struct format_tree *ft)
{
if (ft->wp != NULL) {
if (ft->wp->xoff == 0)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for pane_at_right. */
static void *
format_cb_pane_at_right(struct format_tree *ft)
{
if (ft->wp != NULL) {
if (ft->wp->xoff + ft->wp->sx == ft->wp->window->sx)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for pane_bottom. */
static void *
format_cb_pane_bottom(struct format_tree *ft)
{
if (ft->wp != NULL)
return (format_printf("%u", ft->wp->yoff + ft->wp->sy - 1));
return (NULL);
}
/* Callback for pane_dead. */
static void *
format_cb_pane_dead(struct format_tree *ft)
{
if (ft->wp != NULL) {
if (ft->wp->fd == -1)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for pane_dead_status. */
static void *
format_cb_pane_dead_status(struct format_tree *ft)
{
struct window_pane *wp = ft->wp;
if (wp != NULL) {
if ((wp->flags & PANE_STATUSREADY) && WIFEXITED(wp->status))
return (format_printf("%d", WEXITSTATUS(wp->status)));
return (NULL);
}
return (NULL);
}
/* Callback for pane_format. */
static void *
format_cb_pane_format(struct format_tree *ft)
{
if (ft->type == FORMAT_TYPE_PANE)
return (xstrdup("1"));
return (xstrdup("0"));
}
/* Callback for pane_height. */
static void *
format_cb_pane_height(struct format_tree *ft)
{
if (ft->wp != NULL)
return (format_printf("%u", ft->wp->sy));
return (NULL);
}
/* Callback for pane_id. */
static void *
format_cb_pane_id(struct format_tree *ft)
{
if (ft->wp != NULL)
return (format_printf("%%%u", ft->wp->id));
return (NULL);
}
/* Callback for pane_index. */
static void *
format_cb_pane_index(struct format_tree *ft)
{
u_int idx;
if (ft->wp != NULL && window_pane_index(ft->wp, &idx) == 0)
return (format_printf("%u", idx));
return (NULL);
}
/* Callback for pane_input_off. */
static void *
format_cb_pane_input_off(struct format_tree *ft)
{
if (ft->wp != NULL) {
if (ft->wp->flags & PANE_INPUTOFF)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for pane_last. */
static void *
format_cb_pane_last(struct format_tree *ft)
{
if (ft->wp != NULL) {
if (ft->wp == ft->wp->window->last)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for pane_left. */
static void *
format_cb_pane_left(struct format_tree *ft)
{
if (ft->wp != NULL)
return (format_printf("%u", ft->wp->xoff));
return (NULL);
}
/* Callback for pane_marked. */
static void *
format_cb_pane_marked(struct format_tree *ft)
{
if (ft->wp != NULL) {
if (server_check_marked() && marked_pane.wp == ft->wp)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for pane_marked_set. */
static void *
format_cb_pane_marked_set(struct format_tree *ft)
{
if (ft->wp != NULL) {
if (server_check_marked())
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for pane_mode. */
static void *
format_cb_pane_mode(struct format_tree *ft)
{
struct window_mode_entry *wme;
if (ft->wp != NULL) {
wme = TAILQ_FIRST(&ft->wp->modes);
if (wme != NULL)
return (xstrdup(wme->mode->name));
return (NULL);
}
return (NULL);
}
/* Callback for pane_path. */
static void *
format_cb_pane_path(struct format_tree *ft)
{
if (ft->wp != NULL) {
if (ft->wp->base.path == NULL)
return (xstrdup(""));
return (xstrdup(ft->wp->base.path));
}
return (NULL);
}
/* Callback for pane_pid. */
static void *
format_cb_pane_pid(struct format_tree *ft)
{
if (ft->wp != NULL)
return (format_printf("%ld", (long)ft->wp->pid));
return (NULL);
}
/* Callback for pane_pipe. */
static void *
format_cb_pane_pipe(struct format_tree *ft)
{
if (ft->wp != NULL) {
if (ft->wp->pipe_fd != -1)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for pane_right. */
static void *
format_cb_pane_right(struct format_tree *ft)
{
if (ft->wp != NULL)
return (format_printf("%u", ft->wp->xoff + ft->wp->sx - 1));
return (NULL);
}
/* Callback for pane_search_string. */
static void *
format_cb_pane_search_string(struct format_tree *ft)
{
if (ft->wp != NULL) {
if (ft->wp->searchstr == NULL)
return (xstrdup(""));
return (xstrdup(ft->wp->searchstr));
}
return (NULL);
}
/* Callback for pane_synchronized. */
static void *
format_cb_pane_synchronized(struct format_tree *ft)
{
if (ft->wp != NULL) {
if (options_get_number(ft->wp->options, "synchronize-panes"))
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for pane_title. */
static void *
format_cb_pane_title(struct format_tree *ft)
{
if (ft->wp != NULL)
return (xstrdup(ft->wp->base.title));
return (NULL);
}
/* Callback for pane_top. */
static void *
format_cb_pane_top(struct format_tree *ft)
{
if (ft->wp != NULL)
return (format_printf("%u", ft->wp->yoff));
return (NULL);
}
/* Callback for pane_tty. */
static void *
format_cb_pane_tty(struct format_tree *ft)
{
if (ft->wp != NULL)
return (xstrdup(ft->wp->tty));
return (NULL);
}
/* Callback for pane_width. */
static void *
format_cb_pane_width(struct format_tree *ft)
{
if (ft->wp != NULL)
return (format_printf("%u", ft->wp->sx));
return (NULL);
}
/* Callback for scroll_region_lower. */
static void *
format_cb_scroll_region_lower(struct format_tree *ft)
{
if (ft->wp != NULL)
return (format_printf("%u", ft->wp->base.rlower));
return (NULL);
}
/* Callback for scroll_region_upper. */
static void *
format_cb_scroll_region_upper(struct format_tree *ft)
{
if (ft->wp != NULL)
return (format_printf("%u", ft->wp->base.rupper));
return (NULL);
}
/* Callback for session_attached. */
static void *
format_cb_session_attached(struct format_tree *ft)
{
if (ft->s != NULL)
return (format_printf("%u", ft->s->attached));
return (NULL);
}
/* Callback for session_format. */
static void *
format_cb_session_format(struct format_tree *ft)
{
if (ft->type == FORMAT_TYPE_SESSION)
return (xstrdup("1"));
return (xstrdup("0"));
}
/* Callback for session_group. */
static void *
format_cb_session_group(struct format_tree *ft)
{
struct session_group *sg;
if (ft->s != NULL && (sg = session_group_contains(ft->s)) != NULL)
return (xstrdup(sg->name));
return (NULL);
}
/* Callback for session_group_attached. */
static void *
format_cb_session_group_attached(struct format_tree *ft)
{
struct session_group *sg;
if (ft->s != NULL && (sg = session_group_contains(ft->s)) != NULL)
return (format_printf("%u", session_group_attached_count (sg)));
return (NULL);
}
/* Callback for session_group_many_attached. */
static void *
format_cb_session_group_many_attached(struct format_tree *ft)
{
struct session_group *sg;
if (ft->s != NULL && (sg = session_group_contains(ft->s)) != NULL) {
if (session_group_attached_count (sg) > 1)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for session_group_size. */
static void *
format_cb_session_group_size(struct format_tree *ft)
{
struct session_group *sg;
if (ft->s != NULL && (sg = session_group_contains(ft->s)) != NULL)
return (format_printf("%u", session_group_count (sg)));
return (NULL);
}
/* Callback for session_grouped. */
static void *
format_cb_session_grouped(struct format_tree *ft)
{
if (ft->s != NULL) {
if (session_group_contains(ft->s) != NULL)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for session_id. */
static void *
format_cb_session_id(struct format_tree *ft)
{
if (ft->s != NULL)
return (format_printf("$%u", ft->s->id));
return (NULL);
}
/* Callback for session_many_attached. */
static void *
format_cb_session_many_attached(struct format_tree *ft)
{
if (ft->s != NULL) {
if (ft->s->attached > 1)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for session_marked. */
static void *
format_cb_session_marked(struct format_tree *ft)
{
if (ft->s != NULL) {
if (server_check_marked() && marked_pane.s == ft->s)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for session_name. */
static void *
format_cb_session_name(struct format_tree *ft)
{
if (ft->s != NULL)
return (xstrdup(ft->s->name));
return (NULL);
}
/* Callback for session_path. */
static void *
format_cb_session_path(struct format_tree *ft)
{
if (ft->s != NULL)
return (xstrdup(ft->s->cwd));
return (NULL);
}
/* Callback for session_windows. */
static void *
format_cb_session_windows(struct format_tree *ft)
{
if (ft->s != NULL)
return (format_printf ("%u", winlink_count(&ft->s->windows)));
return (NULL);
}
/* Callback for socket_path. */
static void *
format_cb_socket_path(__unused struct format_tree *ft)
{
return (xstrdup(socket_path));
}
/* Callback for version. */
static void *
format_cb_version(__unused struct format_tree *ft)
{
return (xstrdup(getversion()));
}
Add a couple of format variables for active and last window index.
2021-02-26 07:53:26 +00:00
/* Callback for active_window_index. */
static void *
format_cb_active_window_index(struct format_tree *ft)
{
if (ft->s != NULL)
return (format_printf("%u", ft->s->curw->idx));
return (NULL);
}
/* Callback for last_window_index. */
static void *
format_cb_last_window_index(struct format_tree *ft)
{
struct winlink *wl;
if (ft->s != NULL) {
wl = RB_MAX(winlinks, &ft->s->windows);
return (format_printf("%u", wl->idx));
}
return (NULL);
}
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
/* Callback for window_active. */
static void *
format_cb_window_active(struct format_tree *ft)
{
if (ft->wl != NULL) {
if (ft->wl == ft->wl->session->curw)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for window_activity_flag. */
static void *
format_cb_window_activity_flag(struct format_tree *ft)
{
if (ft->wl != NULL) {
if (ft->wl->flags & WINLINK_ACTIVITY)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for window_bell_flag. */
static void *
format_cb_window_bell_flag(struct format_tree *ft)
{
if (ft->wl != NULL) {
if (ft->wl->flags & WINLINK_BELL)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for window_bigger. */
static void *
format_cb_window_bigger(struct format_tree *ft)
{
u_int ox, oy, sx, sy;
if (ft->c != NULL) {
if (tty_window_offset(&ft->c->tty, &ox, &oy, &sx, &sy))
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for window_cell_height. */
static void *
format_cb_window_cell_height(struct format_tree *ft)
{
if (ft->w != NULL)
return (format_printf("%u", ft->w->ypixel));
return (NULL);
}
/* Callback for window_cell_width. */
static void *
format_cb_window_cell_width(struct format_tree *ft)
{
if (ft->w != NULL)
return (format_printf("%u", ft->w->xpixel));
return (NULL);
}
/* Callback for window_end_flag. */
static void *
format_cb_window_end_flag(struct format_tree *ft)
{
if (ft->wl != NULL) {
if (ft->wl == RB_MAX(winlinks, &ft->wl->session->windows))
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for window_flags. */
static void *
format_cb_window_flags(struct format_tree *ft)
{
if (ft->wl != NULL)
return (xstrdup(window_printable_flags(ft->wl, 1)));
return (NULL);
}
/* Callback for window_format. */
static void *
format_cb_window_format(struct format_tree *ft)
{
if (ft->type == FORMAT_TYPE_WINDOW)
return (xstrdup("1"));
return (xstrdup("0"));
}
/* Callback for window_height. */
static void *
format_cb_window_height(struct format_tree *ft)
{
if (ft->w != NULL)
return (format_printf("%u", ft->w->sy));
return (NULL);
}
/* Callback for window_id. */
static void *
format_cb_window_id(struct format_tree *ft)
{
if (ft->w != NULL)
return (format_printf("@%u", ft->w->id));
return (NULL);
}
/* Callback for window_index. */
static void *
format_cb_window_index(struct format_tree *ft)
{
if (ft->wl != NULL)
return (format_printf("%d", ft->wl->idx));
return (NULL);
}
/* Callback for window_last_flag. */
static void *
format_cb_window_last_flag(struct format_tree *ft)
{
if (ft->wl != NULL) {
if (ft->wl == TAILQ_FIRST(&ft->wl->session->lastw))
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for window_linked. */
static void *
format_cb_window_linked(struct format_tree *ft)
{
if (ft->wl != NULL) {
if (session_is_linked(ft->wl->session, ft->wl->window))
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for window_linked_sessions. */
static void *
format_cb_window_linked_sessions(struct format_tree *ft)
{
if (ft->wl != NULL)
return (format_printf("%u", ft->wl->window->references));
return (NULL);
}
/* Callback for window_marked_flag. */
static void *
format_cb_window_marked_flag(struct format_tree *ft)
{
if (ft->wl != NULL) {
if (server_check_marked() && marked_pane.wl == ft->wl)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for window_name. */
static void *
format_cb_window_name(struct format_tree *ft)
{
if (ft->w != NULL)
return (format_printf("%s", ft->w->name));
return (NULL);
}
/* Callback for window_offset_x. */
static void *
format_cb_window_offset_x(struct format_tree *ft)
{
u_int ox, oy, sx, sy;
if (ft->c != NULL) {
if (tty_window_offset(&ft->c->tty, &ox, &oy, &sx, &sy))
return (format_printf("%u", ox));
return (NULL);
}
return (NULL);
}
/* Callback for window_offset_y. */
static void *
format_cb_window_offset_y(struct format_tree *ft)
{
u_int ox, oy, sx, sy;
if (ft->c != NULL) {
if (tty_window_offset(&ft->c->tty, &ox, &oy, &sx, &sy))
return (format_printf("%u", oy));
return (NULL);
}
return (NULL);
}
/* Callback for window_panes. */
static void *
format_cb_window_panes(struct format_tree *ft)
{
if (ft->w != NULL)
return (format_printf("%u", window_count_panes(ft->w)));
return (NULL);
}
/* Callback for window_raw_flags. */
static void *
format_cb_window_raw_flags(struct format_tree *ft)
{
if (ft->wl != NULL)
return (xstrdup(window_printable_flags(ft->wl, 0)));
return (NULL);
}
/* Callback for window_silence_flag. */
static void *
format_cb_window_silence_flag(struct format_tree *ft)
{
if (ft->wl != NULL) {
if (ft->wl->flags & WINLINK_SILENCE)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for window_start_flag. */
static void *
format_cb_window_start_flag(struct format_tree *ft)
{
if (ft->wl != NULL) {
if (ft->wl == RB_MIN(winlinks, &ft->wl->session->windows))
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for window_width. */
static void *
format_cb_window_width(struct format_tree *ft)
{
if (ft->w != NULL)
return (format_printf("%u", ft->w->sx));
return (NULL);
}
/* Callback for window_zoomed_flag. */
static void *
format_cb_window_zoomed_flag(struct format_tree *ft)
{
if (ft->w != NULL) {
if (ft->w->flags & WINDOW_ZOOMED)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for wrap_flag. */
static void *
format_cb_wrap_flag(struct format_tree *ft)
{
if (ft->wp != NULL) {
if (ft->wp->base.mode & MODE_WRAP)
return (xstrdup("1"));
return (xstrdup("0"));
}
return (NULL);
}
/* Callback for buffer_created. */
static void *
format_cb_buffer_created(struct format_tree *ft)
{
static struct timeval tv;
if (ft->pb != NULL) {
timerclear(&tv);
tv.tv_sec = paste_buffer_created(ft->pb);
return (&tv);
Add formats for word and line under the mouse and use them to add some items to the pane menu.
2019-05-26 17:34:45 +00:00
}
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
return (NULL);
Add formats for word and line under the mouse and use them to add some items to the pane menu.
2019-05-26 17:34:45 +00:00
}
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
/* Callback for client_activity. */
static void *
format_cb_client_activity(struct format_tree *ft)
Add formats for word and line under the mouse and use them to add some items to the pane menu.
2019-05-26 17:34:45 +00:00
{
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
if (ft->c != NULL)
return (&ft->c->activity_time);
return (NULL);
}
Add formats for word and line under the mouse and use them to add some items to the pane menu.
2019-05-26 17:34:45 +00:00
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
/* Callback for client_created. */
static void *
format_cb_client_created(struct format_tree *ft)
{
if (ft->c != NULL)
return (&ft->c->creation_time);
return (NULL);
}
Use the existing code in format.c to add foramts for word and line at cursor position in copy mode, from Anindya Mukherjee.
2019-10-23 07:42:05 +00:00
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
/* Callback for session_activity. */
static void *
format_cb_session_activity(struct format_tree *ft)
{
if (ft->s != NULL)
return (&ft->s->activity_time);
return (NULL);
Use the existing code in format.c to add foramts for word and line at cursor position in copy mode, from Anindya Mukherjee.
2019-10-23 07:42:05 +00:00
}
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
/* Callback for session_created. */
static void *
format_cb_session_created(struct format_tree *ft)
Use the existing code in format.c to add foramts for word and line at cursor position in copy mode, from Anindya Mukherjee.
2019-10-23 07:42:05 +00:00
{
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
if (ft->s != NULL)
return (&ft->s->creation_time);
return (NULL);
}
Add formats for word and line under the mouse and use them to add some items to the pane menu.
2019-05-26 17:34:45 +00:00
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
/* Callback for session_last_attached. */
static void *
format_cb_session_last_attached(struct format_tree *ft)
{
if (ft->s != NULL)
return (&ft->s->last_attached_time);
return (NULL);
}
Add formats for word and line under the mouse and use them to add some items to the pane menu.
2019-05-26 17:34:45 +00:00
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
/* Callback for start_time. */
static void *
format_cb_start_time(__unused struct format_tree *ft)
{
return (&start_time);
Use the existing code in format.c to add foramts for word and line at cursor position in copy mode, from Anindya Mukherjee.
2019-10-23 07:42:05 +00:00
}
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
/* Callback for window_activity. */
static void *
format_cb_window_activity(struct format_tree *ft)
Use the existing code in format.c to add foramts for word and line at cursor position in copy mode, from Anindya Mukherjee.
2019-10-23 07:42:05 +00:00
{
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
if (ft->w != NULL)
return (&ft->w->activity_time);
return (NULL);
}
Use the existing code in format.c to add foramts for word and line at cursor position in copy mode, from Anindya Mukherjee.
2019-10-23 07:42:05 +00:00
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
/* Callback for buffer_mode_format, */
static void *
format_cb_buffer_mode_format(__unused struct format_tree *ft)
{
return (xstrdup(window_buffer_mode.default_format));
}
Use the existing code in format.c to add foramts for word and line at cursor position in copy mode, from Anindya Mukherjee.
2019-10-23 07:42:05 +00:00
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
/* Callback for client_mode_format, */
static void *
format_cb_client_mode_format(__unused struct format_tree *ft)
{
return (xstrdup(window_client_mode.default_format));
}
/* Callback for tree_mode_format, */
static void *
format_cb_tree_mode_format(__unused struct format_tree *ft)
{
return (xstrdup(window_tree_mode.default_format));
}
/* Format table type. */
enum format_table_type {
FORMAT_TABLE_STRING,
FORMAT_TABLE_TIME
};
/* Format table entry. */
struct format_table_entry {
const char *key;
enum format_table_type type;
format_cb cb;
};
/*
* Format table. Default format variables (that are almost always in the tree
* and where the value is expanded by a callback in this file) are listed here.
* Only variables which are added by the caller go into the tree.
*/
static const struct format_table_entry format_table[] = {
Add a couple of format variables for active and last window index.
2021-02-26 07:53:26 +00:00
{ "active_window_index", FORMAT_TABLE_STRING,
format_cb_active_window_index
},
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
{ "alternate_on", FORMAT_TABLE_STRING,
format_cb_alternate_on
},
{ "alternate_saved_x", FORMAT_TABLE_STRING,
format_cb_alternate_saved_x
},
{ "alternate_saved_y", FORMAT_TABLE_STRING,
format_cb_alternate_saved_y
},
{ "buffer_created", FORMAT_TABLE_TIME,
format_cb_buffer_created
},
{ "buffer_mode_format", FORMAT_TABLE_STRING,
format_cb_buffer_mode_format
},
{ "buffer_name", FORMAT_TABLE_STRING,
format_cb_buffer_name
},
{ "buffer_sample", FORMAT_TABLE_STRING,
format_cb_buffer_sample
},
{ "buffer_size", FORMAT_TABLE_STRING,
format_cb_buffer_size
},
{ "client_activity", FORMAT_TABLE_TIME,
format_cb_client_activity
},
{ "client_cell_height", FORMAT_TABLE_STRING,
format_cb_client_cell_height
},
{ "client_cell_width", FORMAT_TABLE_STRING,
format_cb_client_cell_width
},
{ "client_control_mode", FORMAT_TABLE_STRING,
format_cb_client_control_mode
},
{ "client_created", FORMAT_TABLE_TIME,
format_cb_client_created
},
{ "client_discarded", FORMAT_TABLE_STRING,
format_cb_client_discarded
},
{ "client_flags", FORMAT_TABLE_STRING,
format_cb_client_flags
},
{ "client_height", FORMAT_TABLE_STRING,
format_cb_client_height
},
{ "client_key_table", FORMAT_TABLE_STRING,
format_cb_client_key_table
},
{ "client_last_session", FORMAT_TABLE_STRING,
format_cb_client_last_session
},
{ "client_mode_format", FORMAT_TABLE_STRING,
format_cb_client_mode_format
},
{ "client_name", FORMAT_TABLE_STRING,
format_cb_client_name
},
{ "client_pid", FORMAT_TABLE_STRING,
format_cb_client_pid
},
{ "client_prefix", FORMAT_TABLE_STRING,
format_cb_client_prefix
},
{ "client_readonly", FORMAT_TABLE_STRING,
format_cb_client_readonly
},
{ "client_session", FORMAT_TABLE_STRING,
format_cb_client_session
},
{ "client_termfeatures", FORMAT_TABLE_STRING,
format_cb_client_termfeatures
},
{ "client_termname", FORMAT_TABLE_STRING,
format_cb_client_termname
},
{ "client_termtype", FORMAT_TABLE_STRING,
format_cb_client_termtype
},
{ "client_tty", FORMAT_TABLE_STRING,
format_cb_client_tty
},
{ "client_utf8", FORMAT_TABLE_STRING,
format_cb_client_utf8
},
{ "client_width", FORMAT_TABLE_STRING,
format_cb_client_width
},
{ "client_written", FORMAT_TABLE_STRING,
format_cb_client_written
},
Move config file path expansion much earlier, keep the list of paths around rather than freeing later, and add a config_files format variable containing it. Suggested by kn@ a while back.
2021-02-22 08:18:13 +00:00
{ "config_files", FORMAT_TABLE_STRING,
format_cb_config_files
},
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
{ "cursor_character", FORMAT_TABLE_STRING,
format_cb_cursor_character
},
{ "cursor_flag", FORMAT_TABLE_STRING,
format_cb_cursor_flag
},
{ "cursor_x", FORMAT_TABLE_STRING,
format_cb_cursor_x
},
{ "cursor_y", FORMAT_TABLE_STRING,
format_cb_cursor_y
},
{ "history_all_bytes", FORMAT_TABLE_STRING,
format_cb_history_all_bytes
},
{ "history_bytes", FORMAT_TABLE_STRING,
format_cb_history_bytes
},
{ "history_limit", FORMAT_TABLE_STRING,
format_cb_history_limit
},
{ "history_size", FORMAT_TABLE_STRING,
format_cb_history_size
},
{ "host", FORMAT_TABLE_STRING,
format_cb_host
},
{ "host_short", FORMAT_TABLE_STRING,
format_cb_host_short
},
{ "insert_flag", FORMAT_TABLE_STRING,
format_cb_insert_flag
},
{ "keypad_cursor_flag", FORMAT_TABLE_STRING,
format_cb_keypad_cursor_flag
},
{ "keypad_flag", FORMAT_TABLE_STRING,
format_cb_keypad_flag
},
Add a couple of format variables for active and last window index.
2021-02-26 07:53:26 +00:00
{ "last_window_index", FORMAT_TABLE_STRING,
format_cb_last_window_index
},
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
{ "mouse_all_flag", FORMAT_TABLE_STRING,
format_cb_mouse_all_flag
},
{ "mouse_any_flag", FORMAT_TABLE_STRING,
format_cb_mouse_any_flag
},
{ "mouse_button_flag", FORMAT_TABLE_STRING,
format_cb_mouse_button_flag
},
{ "mouse_line", FORMAT_TABLE_STRING,
format_cb_mouse_line
},
{ "mouse_pane", FORMAT_TABLE_STRING,
format_cb_mouse_pane
},
{ "mouse_sgr_flag", FORMAT_TABLE_STRING,
format_cb_mouse_sgr_flag
},
{ "mouse_standard_flag", FORMAT_TABLE_STRING,
format_cb_mouse_standard_flag
},
{ "mouse_utf8_flag", FORMAT_TABLE_STRING,
format_cb_mouse_utf8_flag
},
{ "mouse_word", FORMAT_TABLE_STRING,
format_cb_mouse_word
},
{ "mouse_x", FORMAT_TABLE_STRING,
format_cb_mouse_x
},
{ "mouse_y", FORMAT_TABLE_STRING,
format_cb_mouse_y
},
{ "origin_flag", FORMAT_TABLE_STRING,
format_cb_origin_flag
},
{ "pane_active", FORMAT_TABLE_STRING,
format_cb_pane_active
},
{ "pane_at_bottom", FORMAT_TABLE_STRING,
format_cb_pane_at_bottom
},
{ "pane_at_left", FORMAT_TABLE_STRING,
format_cb_pane_at_left
},
{ "pane_at_right", FORMAT_TABLE_STRING,
format_cb_pane_at_right
},
{ "pane_at_top", FORMAT_TABLE_STRING,
format_cb_pane_at_top
},
{ "pane_bg", FORMAT_TABLE_STRING,
format_cb_pane_bg
},
{ "pane_bottom", FORMAT_TABLE_STRING,
format_cb_pane_bottom
},
{ "pane_current_command", FORMAT_TABLE_STRING,
format_cb_current_command
},
{ "pane_current_path", FORMAT_TABLE_STRING,
format_cb_current_path
},
{ "pane_dead", FORMAT_TABLE_STRING,
format_cb_pane_dead
},
{ "pane_dead_status", FORMAT_TABLE_STRING,
format_cb_pane_dead_status
},
{ "pane_fg", FORMAT_TABLE_STRING,
format_cb_pane_fg
},
{ "pane_format", FORMAT_TABLE_STRING,
format_cb_pane_format
},
{ "pane_height", FORMAT_TABLE_STRING,
format_cb_pane_height
},
{ "pane_id", FORMAT_TABLE_STRING,
format_cb_pane_id
},
{ "pane_in_mode", FORMAT_TABLE_STRING,
format_cb_pane_in_mode
},
{ "pane_index", FORMAT_TABLE_STRING,
format_cb_pane_index
},
{ "pane_input_off", FORMAT_TABLE_STRING,
format_cb_pane_input_off
},
{ "pane_last", FORMAT_TABLE_STRING,
format_cb_pane_last
},
{ "pane_left", FORMAT_TABLE_STRING,
format_cb_pane_left
},
{ "pane_marked", FORMAT_TABLE_STRING,
format_cb_pane_marked
},
{ "pane_marked_set", FORMAT_TABLE_STRING,
format_cb_pane_marked_set
},
{ "pane_mode", FORMAT_TABLE_STRING,
format_cb_pane_mode
},
{ "pane_path", FORMAT_TABLE_STRING,
format_cb_pane_path
},
{ "pane_pid", FORMAT_TABLE_STRING,
format_cb_pane_pid
},
{ "pane_pipe", FORMAT_TABLE_STRING,
format_cb_pane_pipe
},
{ "pane_right", FORMAT_TABLE_STRING,
format_cb_pane_right
},
{ "pane_search_string", FORMAT_TABLE_STRING,
format_cb_pane_search_string
},
{ "pane_start_command", FORMAT_TABLE_STRING,
format_cb_start_command
},
{ "pane_synchronized", FORMAT_TABLE_STRING,
format_cb_pane_synchronized
},
{ "pane_tabs", FORMAT_TABLE_STRING,
format_cb_pane_tabs
},
{ "pane_title", FORMAT_TABLE_STRING,
format_cb_pane_title
},
{ "pane_top", FORMAT_TABLE_STRING,
format_cb_pane_top
},
{ "pane_tty", FORMAT_TABLE_STRING,
format_cb_pane_tty
},
{ "pane_width", FORMAT_TABLE_STRING,
format_cb_pane_width
},
{ "pid", FORMAT_TABLE_STRING,
format_cb_pid
},
{ "scroll_region_lower", FORMAT_TABLE_STRING,
format_cb_scroll_region_lower
},
{ "scroll_region_upper", FORMAT_TABLE_STRING,
format_cb_scroll_region_upper
},
{ "session_activity", FORMAT_TABLE_TIME,
format_cb_session_activity
},
{ "session_alerts", FORMAT_TABLE_STRING,
format_cb_session_alerts
},
{ "session_attached", FORMAT_TABLE_STRING,
format_cb_session_attached
},
{ "session_attached_list", FORMAT_TABLE_STRING,
format_cb_session_attached_list
},
{ "session_created", FORMAT_TABLE_TIME,
format_cb_session_created
},
{ "session_format", FORMAT_TABLE_STRING,
format_cb_session_format
},
{ "session_group", FORMAT_TABLE_STRING,
format_cb_session_group
},
{ "session_group_attached", FORMAT_TABLE_STRING,
format_cb_session_group_attached
},
{ "session_group_attached_list", FORMAT_TABLE_STRING,
format_cb_session_group_attached_list
},
{ "session_group_list", FORMAT_TABLE_STRING,
format_cb_session_group_list
},
{ "session_group_many_attached", FORMAT_TABLE_STRING,
format_cb_session_group_many_attached
},
{ "session_group_size", FORMAT_TABLE_STRING,
format_cb_session_group_size
},
{ "session_grouped", FORMAT_TABLE_STRING,
format_cb_session_grouped
},
{ "session_id", FORMAT_TABLE_STRING,
format_cb_session_id
},
{ "session_last_attached", FORMAT_TABLE_TIME,
format_cb_session_last_attached
},
{ "session_many_attached", FORMAT_TABLE_STRING,
format_cb_session_many_attached
},
{ "session_marked", FORMAT_TABLE_STRING,
format_cb_session_marked,
},
{ "session_name", FORMAT_TABLE_STRING,
format_cb_session_name
},
{ "session_path", FORMAT_TABLE_STRING,
format_cb_session_path
},
{ "session_stack", FORMAT_TABLE_STRING,
format_cb_session_stack
},
{ "session_windows", FORMAT_TABLE_STRING,
format_cb_session_windows
},
{ "socket_path", FORMAT_TABLE_STRING,
format_cb_socket_path
},
{ "start_time", FORMAT_TABLE_TIME,
format_cb_start_time
},
{ "tree_mode_format", FORMAT_TABLE_STRING,
format_cb_tree_mode_format
},
{ "version", FORMAT_TABLE_STRING,
format_cb_version
},
{ "window_active", FORMAT_TABLE_STRING,
format_cb_window_active
},
{ "window_active_clients", FORMAT_TABLE_STRING,
format_cb_window_active_clients
},
{ "window_active_clients_list", FORMAT_TABLE_STRING,
format_cb_window_active_clients_list
},
{ "window_active_sessions", FORMAT_TABLE_STRING,
format_cb_window_active_sessions
},
{ "window_active_sessions_list", FORMAT_TABLE_STRING,
format_cb_window_active_sessions_list
},
{ "window_activity", FORMAT_TABLE_TIME,
format_cb_window_activity
},
{ "window_activity_flag", FORMAT_TABLE_STRING,
format_cb_window_activity_flag
},
{ "window_bell_flag", FORMAT_TABLE_STRING,
format_cb_window_bell_flag
},
{ "window_bigger", FORMAT_TABLE_STRING,
format_cb_window_bigger
},
{ "window_cell_height", FORMAT_TABLE_STRING,
format_cb_window_cell_height
},
{ "window_cell_width", FORMAT_TABLE_STRING,
format_cb_window_cell_width
},
{ "window_end_flag", FORMAT_TABLE_STRING,
format_cb_window_end_flag
},
{ "window_flags", FORMAT_TABLE_STRING,
format_cb_window_flags
},
{ "window_format", FORMAT_TABLE_STRING,
format_cb_window_format
},
{ "window_height", FORMAT_TABLE_STRING,
format_cb_window_height
},
{ "window_id", FORMAT_TABLE_STRING,
format_cb_window_id
},
{ "window_index", FORMAT_TABLE_STRING,
format_cb_window_index
},
{ "window_last_flag", FORMAT_TABLE_STRING,
format_cb_window_last_flag
},
{ "window_layout", FORMAT_TABLE_STRING,
format_cb_window_layout
},
{ "window_linked", FORMAT_TABLE_STRING,
format_cb_window_linked
},
{ "window_linked_sessions", FORMAT_TABLE_STRING,
format_cb_window_linked_sessions
},
{ "window_linked_sessions_list", FORMAT_TABLE_STRING,
format_cb_window_linked_sessions_list
},
{ "window_marked_flag", FORMAT_TABLE_STRING,
format_cb_window_marked_flag
},
{ "window_name", FORMAT_TABLE_STRING,
format_cb_window_name
},
{ "window_offset_x", FORMAT_TABLE_STRING,
format_cb_window_offset_x
},
{ "window_offset_y", FORMAT_TABLE_STRING,
format_cb_window_offset_y
},
{ "window_panes", FORMAT_TABLE_STRING,
format_cb_window_panes
},
{ "window_raw_flags", FORMAT_TABLE_STRING,
format_cb_window_raw_flags
},
{ "window_silence_flag", FORMAT_TABLE_STRING,
format_cb_window_silence_flag
},
{ "window_stack_index", FORMAT_TABLE_STRING,
format_cb_window_stack_index
},
{ "window_start_flag", FORMAT_TABLE_STRING,
format_cb_window_start_flag
},
{ "window_visible_layout", FORMAT_TABLE_STRING,
format_cb_window_visible_layout
},
{ "window_width", FORMAT_TABLE_STRING,
format_cb_window_width
},
{ "window_zoomed_flag", FORMAT_TABLE_STRING,
format_cb_window_zoomed_flag
},
{ "wrap_flag", FORMAT_TABLE_STRING,
format_cb_wrap_flag
Make the mouse_word and mouse_line formats work in copy mode and enable the default pane menu in copy mode.
2020-03-20 17:59:39 +00:00
}
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
};
/* Compare format table entries. */
static int
format_table_compare(const void *key0, const void *entry0)
{
const char *key = key0;
const struct format_table_entry *entry = entry0;
return (strcmp(key, entry->key));
}
/* Get a format callback. */
static struct format_table_entry *
format_table_get(const char *key)
{
return (bsearch(key, format_table, nitems(format_table),
sizeof *format_table, format_table_compare));
Add formats for word and line under the mouse and use them to add some items to the pane menu.
2019-05-26 17:34:45 +00:00
}
Also move cmdq_item and cmdq_list into cmd-queue.c (this is to make its use more clearly defined and preparation for some future work).
2020-04-13 10:59:58 +00:00
/* Merge one format tree into another. */
void
Provide a way for hooks to tag formats onto the commands they fire so that the user can get at additional information - now used for the "hook" format, more to come.
2016-10-16 19:36:37 +00:00
format_merge(struct format_tree *ft, struct format_tree *from)
{
struct format_entry *fe;
RB_FOREACH(fe, format_entry_tree, &from->tree) {
if (fe->value != NULL)
format_add(ft, fe->key, "%s", fe->value);
}
}
Add some formats for search in copy mode (search_present, search_match). GitHub issue 2268.
2020-06-11 19:43:34 +00:00
/* Get format pane. */
struct window_pane *
format_get_pane(struct format_tree *ft)
{
return (ft->wp);
}
Add a way to append or prepend to a format if the length has been limited.
2019-05-26 12:02:42 +00:00
/* Add item bits to tree. */
static void
format_create_add_item(struct format_tree *ft, struct cmdq_item *item)
{
Move cmdq_state into cmd-queue.c.
2020-04-13 14:46:04 +00:00
struct key_event *event = cmdq_get_event(item);
struct mouse_event *m = &event->m;
Add formats for word and line under the mouse and use them to add some items to the pane menu.
2019-05-26 17:34:45 +00:00
Also move cmdq_item and cmdq_list into cmd-queue.c (this is to make its use more clearly defined and preparation for some future work).
2020-04-13 10:59:58 +00:00
cmdq_merge_formats(item, ft);
Add formats for word and line under the mouse and use them to add some items to the pane menu.
2019-05-26 17:34:45 +00:00
memcpy(&ft->m, m, sizeof ft->m);
Add a way to append or prepend to a format if the length has been limited.
2019-05-26 12:02:42 +00:00
}
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
/* Create a new tree. */
struct format_tree *
In order that people can use formats like #D in #() in the status line and not have to wait for an update when they change pane, we allow commands to run more than once a second if the expanded form changes. Unfortunately this can mean them being run far too often (pretty much continually) when multiple clients exist, because some formats (including #D) will always differ between clients. To avoid this, give each client its own tree of jobs which means that the same command will be different instances for each client - similar to how we have the tag to separate commands for different panes. GitHub issue 889; test case reported by Paul Johnson.
2017-05-01 12:20:55 +00:00
format_create(struct client *c, struct cmdq_item *item, int tag, int flags)
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
{
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
struct format_tree *ft;
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
Permit option values to be used in formats.
2014-12-02 23:19:45 +00:00
ft = xcalloc(1, sizeof *ft);
RB_INIT(&ft->tree);
Add a window or pane id "tag" to each format tree and use it to separate jobs, this means that if the same job is used for different windows or panes (for example in pane-border-format), it will be run separately for each pane.
2017-02-03 11:57:27 +00:00
In order that people can use formats like #D in #() in the status line and not have to wait for an update when they change pane, we allow commands to run more than once a second if the expanded form changes. Unfortunately this can mean them being run far too often (pretty much continually) when multiple clients exist, because some formats (including #D) will always differ between clients. To avoid this, give each client its own tree of jobs which means that the same command will be different instances for each client - similar to how we have the tag to separate commands for different panes. GitHub issue 889; test case reported by Paul Johnson.
2017-05-01 12:20:55 +00:00
if (c != NULL) {
ft->client = c;
ft->client->references++;
}
Add formats to list sessions, windows or panes.
2019-03-13 15:37:28 +00:00
ft->item = item;
In order that people can use formats like #D in #() in the status line and not have to wait for an update when they change pane, we allow commands to run more than once a second if the expanded form changes. Unfortunately this can mean them being run far too often (pretty much continually) when multiple clients exist, because some formats (including #D) will always differ between clients. To avoid this, give each client its own tree of jobs which means that the same command will be different instances for each client - similar to how we have the tag to separate commands for different panes. GitHub issue 889; test case reported by Paul Johnson.
2017-05-01 12:20:55 +00:00
Add a window or pane id "tag" to each format tree and use it to separate jobs, this means that if the same job is used for different windows or panes (for example in pane-border-format), it will be run separately for each pane.
2017-02-03 11:57:27 +00:00
ft->tag = tag;
Make refresh-client force update of jobs, from Sina Siadat.
2015-09-14 10:25:52 +00:00
ft->flags = flags;
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
Add a way to append or prepend to a format if the length has been limited.
2019-05-26 12:02:42 +00:00
if (item != NULL)
format_create_add_item(ft, item);
Add cmdq as an argument to format_create and add a format for the command name (will also be used for more later).
2015-12-11 12:27:36 +00:00
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
return (ft);
}
/* Free a tree. */
void
format_free(struct format_tree *ft)
{
Permit option values to be used in formats.
2014-12-02 23:19:45 +00:00
struct format_entry *fe, *fe1;
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
RB_FOREACH_SAFE(fe, format_entry_tree, &ft->tree, fe1) {
RB_REMOVE(format_entry_tree, &ft->tree, fe);
xfree is not particularly helpful, remove it. From Thomas Adam.
2012-07-10 11:53:01 +00:00
free(fe->value);
free(fe->key);
free(fe);
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
}
In order that people can use formats like #D in #() in the status line and not have to wait for an update when they change pane, we allow commands to run more than once a second if the expanded form changes. Unfortunately this can mean them being run far too often (pretty much continually) when multiple clients exist, because some formats (including #D) will always differ between clients. To avoid this, give each client its own tree of jobs which means that the same command will be different instances for each client - similar to how we have the tag to separate commands for different panes. GitHub issue 889; test case reported by Paul Johnson.
2017-05-01 12:20:55 +00:00
if (ft->client != NULL)
server_client_unref(ft->client);
Add host_short format, from Tiago Cunha.
2013-05-31 19:46:42 +00:00
free(ft);
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
}
Move hook format setup earlier and add a hook_client, GitHub issue 2809.
2021-08-12 08:05:11 +00:00
/* Log each format. */
static void
format_log_debug_cb(const char *key, const char *value, void *arg)
{
const char *prefix = arg;
log_debug("%s: %s=%s", prefix, key, value);
}
/* Log a format tree. */
void
format_log_debug(struct format_tree *ft, const char *prefix)
{
Do not dereference pane when it is NULL, fixes a crash when creating a hook from the config, GitHub issue 2820.
2021-08-12 08:10:20 +00:00
format_each(ft, format_log_debug_cb, (void *)prefix);
Move hook format setup earlier and add a hook_client, GitHub issue 2809.
2021-08-12 08:05:11 +00:00
}
Add format variables for the default formats for the various modes (tree_mode_format and so on) and add a -a flag to display-message to list variables with values.
2019-03-18 14:10:25 +00:00
/* Walk each format. */
void
format_each(struct format_tree *ft, void (*cb)(const char *, const char *,
void *), void *arg)
{
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
const struct format_table_entry *fte;
struct format_entry *fe;
u_int i;
char s[64];
void *value;
struct timeval *tv;
for (i = 0; i < nitems(format_table); i++) {
fte = &format_table[i];
Add format variables for the default formats for the various modes (tree_mode_format and so on) and add a -a flag to display-message to list variables with values.
2019-03-18 14:10:25 +00:00
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
value = fte->cb(ft);
if (value == NULL)
continue;
if (fte->type == FORMAT_TABLE_TIME) {
tv = value;
xsnprintf(s, sizeof s, "%lld", (long long)tv->tv_sec);
cb(fte->key, s, arg);
} else {
cb(fte->key, value, arg);
free(value);
}
}
Add format variables for the default formats for the various modes (tree_mode_format and so on) and add a -a flag to display-message to list variables with values.
2019-03-18 14:10:25 +00:00
RB_FOREACH(fe, format_entry_tree, &ft->tree) {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
if (fe->time != 0) {
xsnprintf(s, sizeof s, "%lld", (long long)fe->time);
Pass correct value into iterator callback for time formats.
2019-12-26 14:48:29 +00:00
cb(fe->key, s, arg);
Add format variables for the default formats for the various modes (tree_mode_format and so on) and add a -a flag to display-message to list variables with values.
2019-03-18 14:10:25 +00:00
} else {
if (fe->value == NULL && fe->cb != NULL) {
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
fe->value = fe->cb(ft);
Add format variables for the default formats for the various modes (tree_mode_format and so on) and add a -a flag to display-message to list variables with values.
2019-03-18 14:10:25 +00:00
if (fe->value == NULL)
fe->value = xstrdup("");
}
cb(fe->key, fe->value, arg);
}
}
}
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
/* Add a key-value pair. */
void
format_add(struct format_tree *ft, const char *key, const char *fmt, ...)
{
struct format_entry *fe;
Add formats for window flags.
2013-10-10 11:47:52 +00:00
struct format_entry *fe_now;
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
va_list ap;
fe = xmalloc(sizeof *fe);
fe->key = xstrdup(key);
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
fe_now = RB_INSERT(format_entry_tree, &ft->tree, fe);
if (fe_now != NULL) {
free(fe->key);
free(fe);
free(fe_now->value);
fe = fe_now;
}
fe->cb = NULL;
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
fe->time = 0;
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
va_start(ap, fmt);
xvasprintf(&fe->value, fmt, ap);
va_end(ap);
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
}
Extend the modifiers allowed before formats: as well as the existing #{=10:...} length limit, add #{t:...} to convert a time_t format to a string, #{b:...} for basename and #{d:...} for dirname. Remove all the foo_string time formats as they can now be replaced by "t:", for example #{window_activity_string} becomes #{t:window_activity}.
2015-10-25 22:29:17 +00:00
/* Add a key and time. */
Change message log to be per server rather than per client and include every command that is run.
2020-05-16 15:47:22 +00:00
void
Extend the modifiers allowed before formats: as well as the existing #{=10:...} length limit, add #{t:...} to convert a time_t format to a string, #{b:...} for basename and #{d:...} for dirname. Remove all the foo_string time formats as they can now be replaced by "t:", for example #{window_activity_string} becomes #{t:window_activity}.
2015-10-25 22:29:17 +00:00
format_add_tv(struct format_tree *ft, const char *key, struct timeval *tv)
{
Pass correct value into iterator callback for time formats.
2019-12-26 14:48:29 +00:00
struct format_entry *fe, *fe_now;
Extend the modifiers allowed before formats: as well as the existing #{=10:...} length limit, add #{t:...} to convert a time_t format to a string, #{b:...} for basename and #{d:...} for dirname. Remove all the foo_string time formats as they can now be replaced by "t:", for example #{window_activity_string} becomes #{t:window_activity}.
2015-10-25 22:29:17 +00:00
fe = xmalloc(sizeof *fe);
fe->key = xstrdup(key);
fe_now = RB_INSERT(format_entry_tree, &ft->tree, fe);
if (fe_now != NULL) {
free(fe->key);
free(fe);
free(fe_now->value);
fe = fe_now;
}
fe->cb = NULL;
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
fe->time = tv->tv_sec;
Extend the modifiers allowed before formats: as well as the existing #{=10:...} length limit, add #{t:...} to convert a time_t format to a string, #{b:...} for basename and #{d:...} for dirname. Remove all the foo_string time formats as they can now be replaced by "t:", for example #{window_activity_string} becomes #{t:window_activity}.
2015-10-25 22:29:17 +00:00
fe->value = NULL;
}
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
/* Add a key and function. */
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
void
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
format_add_cb(struct format_tree *ft, const char *key, format_cb cb)
{
struct format_entry *fe;
struct format_entry *fe_now;
fe = xmalloc(sizeof *fe);
fe->key = xstrdup(key);
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
fe_now = RB_INSERT(format_entry_tree, &ft->tree, fe);
Add formats for window flags.
2013-10-10 11:47:52 +00:00
if (fe_now != NULL) {
free(fe->key);
free(fe);
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
free(fe_now->value);
fe = fe_now;
Add formats for window flags.
2013-10-10 11:47:52 +00:00
}
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
fe->cb = cb;
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
fe->time = 0;
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
fe->value = NULL;
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
}
Change so that window_flags escapes # automatically which means configs will not have to change. A new format window_raw_flags contains the old unescaped version.
2021-01-20 07:16:54 +00:00
/* Quote shell special characters in string. */
Add q: format prefix to escape sh(1) special characters. Suggested by someone ages ago and then more recently in GitHub issue 1449.
2018-08-26 09:28:42 +00:00
static char *
Change so that window_flags escapes # automatically which means configs will not have to change. A new format window_raw_flags contains the old unescaped version.
2021-01-20 07:16:54 +00:00
format_quote_shell(const char *s)
Add q: format prefix to escape sh(1) special characters. Suggested by someone ages ago and then more recently in GitHub issue 1449.
2018-08-26 09:28:42 +00:00
{
const char *cp;
char *out, *at;
at = out = xmalloc(strlen(s) * 2 + 1);
for (cp = s; *cp != '\0'; cp++) {
if (strchr("|&;<>()$`\\\"'*?[# =%", *cp) != NULL)
*at++ = '\\';
*at++ = *cp;
}
*at = '\0';
return (out);
}
Change so that window_flags escapes # automatically which means configs will not have to change. A new format window_raw_flags contains the old unescaped version.
2021-01-20 07:16:54 +00:00
/* Quote #s in string. */
Make replacement of ##s consistent when drawing formats, whether followed by [ or not. Add a flag (e) to the q: format modifier to double up #s and use it for the window_flags format variable so it doesn't end up escaping any following text. GitHub issue 2485.
2020-12-01 08:12:58 +00:00
static char *
Change so that window_flags escapes # automatically which means configs will not have to change. A new format window_raw_flags contains the old unescaped version.
2021-01-20 07:16:54 +00:00
format_quote_style(const char *s)
Make replacement of ##s consistent when drawing formats, whether followed by [ or not. Add a flag (e) to the q: format modifier to double up #s and use it for the window_flags format variable so it doesn't end up escaping any following text. GitHub issue 2485.
2020-12-01 08:12:58 +00:00
{
const char *cp;
char *out, *at;
at = out = xmalloc(strlen(s) * 2 + 1);
for (cp = s; *cp != '\0'; cp++) {
if (*cp == '#')
*at++ = '#';
*at++ = *cp;
}
*at = '\0';
return (out);
}
Tweak the default choose modes formats: - Only show pane title if it is not default and not empty. - Add a prettier time format and use that instead of long ctime(). - Remove clutter and change the order.
2020-05-16 14:10:29 +00:00
/* Make a prettier time. */
static char *
format_pretty_time(time_t t)
{
struct tm now_tm, tm;
time_t now, age;
char s[6];
time(&now);
if (now < t)
now = t;
age = now - t;
localtime_r(&now, &now_tm);
localtime_r(&t, &tm);
/* Last 24 hours. */
if (age < 24 * 3600) {
strftime(s, sizeof s, "%H:%M", &tm);
return (xstrdup(s));
}
/* This month or last 28 days. */
if ((tm.tm_year == now_tm.tm_year && tm.tm_mon == now_tm.tm_mon) ||
age < 28 * 24 * 3600) {
strftime(s, sizeof s, "%a%d", &tm);
return (xstrdup(s));
}
/* Last 12 months. */
if ((tm.tm_year == now_tm.tm_year && tm.tm_mon < now_tm.tm_mon) ||
(tm.tm_year == now_tm.tm_year - 1 && tm.tm_mon > now_tm.tm_mon)) {
strftime(s, sizeof s, "%d%b", &tm);
return (xstrdup(s));
}
/* Older than that. */
strftime(s, sizeof s, "%h%y", &tm);
return (xstrdup(s));
}
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
/* Find a format entry. */
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static char *
Allow a custom time format to be given to the t format modifier.
2020-05-16 15:48:35 +00:00
format_find(struct format_tree *ft, const char *key, int modifiers,
const char *time_format)
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
{
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
struct format_table_entry *fte;
void *value;
struct format_entry *fe, fe_find;
struct environ_entry *envent;
struct options_entry *o;
int idx;
char *found = NULL, *saved, s[512];
const char *errstr;
time_t t = 0;
struct tm tm;
Tweak the default choose modes formats: - Only show pane title if it is not default and not empty. - Add a prettier time format and use that instead of long ctime(). - Remove clutter and change the order.
2020-05-16 14:10:29 +00:00
o = options_parse_get(global_options, key, &idx, 0);
if (o == NULL && ft->wp != NULL)
o = options_parse_get(ft->wp->options, key, &idx, 0);
if (o == NULL && ft->w != NULL)
o = options_parse_get(ft->w->options, key, &idx, 0);
if (o == NULL)
o = options_parse_get(global_w_options, key, &idx, 0);
if (o == NULL && ft->s != NULL)
o = options_parse_get(ft->s->options, key, &idx, 0);
if (o == NULL)
o = options_parse_get(global_s_options, key, &idx, 0);
if (o != NULL) {
Add a customize mode where keys and options may be browsed and changed, includes adding a brief description of each option. Bound to "C" by default.
2020-05-16 16:02:24 +00:00
found = options_to_string(o, idx, 1);
Tweak the default choose modes formats: - Only show pane title if it is not default and not empty. - Add a prettier time format and use that instead of long ctime(). - Remove clutter and change the order.
2020-05-16 14:10:29 +00:00
goto found;
Permit option values to be used in formats.
2014-12-02 23:19:45 +00:00
}
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
fte = format_table_get(key);
if (fte != NULL) {
value = fte->cb(ft);
if (fte->type == FORMAT_TABLE_TIME)
t = ((struct timeval *)value)->tv_sec;
else
found = value;
goto found;
}
Tweak the default choose modes formats: - Only show pane title if it is not default and not empty. - Add a prettier time format and use that instead of long ctime(). - Remove clutter and change the order.
2020-05-16 14:10:29 +00:00
fe_find.key = (char *)key;
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
fe = RB_FIND(format_entry_tree, &ft->tree, &fe_find);
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
if (fe != NULL) {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
if (fe->time != 0) {
t = fe->time;
Extend the modifiers allowed before formats: as well as the existing #{=10:...} length limit, add #{t:...} to convert a time_t format to a string, #{b:...} for basename and #{d:...} for dirname. Remove all the foo_string time formats as they can now be replaced by "t:", for example #{window_activity_string} becomes #{t:window_activity}.
2015-10-25 22:29:17 +00:00
goto found;
}
Change format callback to return value rather than storing it in the entry.
2020-06-01 19:39:25 +00:00
if (fe->value == NULL && fe->cb != NULL) {
fe->value = fe->cb(ft);
if (fe->value == NULL)
fe->value = xstrdup("");
}
Make options_tostring allocate its result instead of using a stack buffer (needed for something in the future).
2019-04-25 18:18:55 +00:00
found = xstrdup(fe->value);
Extend the modifiers allowed before formats: as well as the existing #{=10:...} length limit, add #{t:...} to convert a time_t format to a string, #{b:...} for basename and #{d:...} for dirname. Remove all the foo_string time formats as they can now be replaced by "t:", for example #{window_activity_string} becomes #{t:window_activity}.
2015-10-25 22:29:17 +00:00
goto found;
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
}
Allow environment variables in #{}.
2015-08-28 10:06:52 +00:00
Extend the modifiers allowed before formats: as well as the existing #{=10:...} length limit, add #{t:...} to convert a time_t format to a string, #{b:...} for basename and #{d:...} for dirname. Remove all the foo_string time formats as they can now be replaced by "t:", for example #{window_activity_string} becomes #{t:window_activity}.
2015-10-25 22:29:17 +00:00
if (~modifiers & FORMAT_TIMESTRING) {
envent = NULL;
if (ft->s != NULL)
Like options, move the environ struct into environ.c.
2015-10-28 09:51:55 +00:00
envent = environ_find(ft->s->environ, key);
Extend the modifiers allowed before formats: as well as the existing #{=10:...} length limit, add #{t:...} to convert a time_t format to a string, #{b:...} for basename and #{d:...} for dirname. Remove all the foo_string time formats as they can now be replaced by "t:", for example #{window_activity_string} becomes #{t:window_activity}.
2015-10-25 22:29:17 +00:00
if (envent == NULL)
Like options, move the environ struct into environ.c.
2015-10-28 09:51:55 +00:00
envent = environ_find(global_environ, key);
Do not crash if the environment variable is present but empty.
2019-06-13 21:24:09 +00:00
if (envent != NULL && envent->value != NULL) {
Make options_tostring allocate its result instead of using a stack buffer (needed for something in the future).
2019-04-25 18:18:55 +00:00
found = xstrdup(envent->value);
Extend the modifiers allowed before formats: as well as the existing #{=10:...} length limit, add #{t:...} to convert a time_t format to a string, #{b:...} for basename and #{d:...} for dirname. Remove all the foo_string time formats as they can now be replaced by "t:", for example #{window_activity_string} becomes #{t:window_activity}.
2015-10-25 22:29:17 +00:00
goto found;
}
}
Allow environment variables in #{}.
2015-08-28 10:06:52 +00:00
return (NULL);
Extend the modifiers allowed before formats: as well as the existing #{=10:...} length limit, add #{t:...} to convert a time_t format to a string, #{b:...} for basename and #{d:...} for dirname. Remove all the foo_string time formats as they can now be replaced by "t:", for example #{window_activity_string} becomes #{t:window_activity}.
2015-10-25 22:29:17 +00:00
found:
Tweak the default choose modes formats: - Only show pane title if it is not default and not empty. - Add a prettier time format and use that instead of long ctime(). - Remove clutter and change the order.
2020-05-16 14:10:29 +00:00
if (modifiers & FORMAT_TIMESTRING) {
if (t == 0 && found != NULL) {
t = strtonum(found, 0, INT64_MAX, &errstr);
if (errstr != NULL)
t = 0;
free(found);
}
if (t == 0)
return (NULL);
if (modifiers & FORMAT_PRETTY)
found = format_pretty_time(t);
else {
Allow a custom time format to be given to the t format modifier.
2020-05-16 15:48:35 +00:00
if (time_format != NULL) {
localtime_r(&t, &tm);
strftime(s, sizeof s, time_format, &tm);
} else {
ctime_r(&t, s);
s[strcspn(s, "\n")] = '\0';
}
Tweak the default choose modes formats: - Only show pane title if it is not default and not empty. - Add a prettier time format and use that instead of long ctime(). - Remove clutter and change the order.
2020-05-16 14:10:29 +00:00
found = xstrdup(s);
}
return (found);
}
if (t != 0)
xasprintf(&found, "%lld", (long long)t);
else if (found == NULL)
The format callback may not always succeed, so we need to check for NULL. From Patrick Palka.
2015-10-27 09:18:06 +00:00
return (NULL);
Extend the modifiers allowed before formats: as well as the existing #{=10:...} length limit, add #{t:...} to convert a time_t format to a string, #{b:...} for basename and #{d:...} for dirname. Remove all the foo_string time formats as they can now be replaced by "t:", for example #{window_activity_string} becomes #{t:window_activity}.
2015-10-25 22:29:17 +00:00
if (modifiers & FORMAT_BASENAME) {
Make options_tostring allocate its result instead of using a stack buffer (needed for something in the future).
2019-04-25 18:18:55 +00:00
saved = found;
found = xstrdup(basename(saved));
Extend the modifiers allowed before formats: as well as the existing #{=10:...} length limit, add #{t:...} to convert a time_t format to a string, #{b:...} for basename and #{d:...} for dirname. Remove all the foo_string time formats as they can now be replaced by "t:", for example #{window_activity_string} becomes #{t:window_activity}.
2015-10-25 22:29:17 +00:00
free(saved);
}
if (modifiers & FORMAT_DIRNAME) {
Make options_tostring allocate its result instead of using a stack buffer (needed for something in the future).
2019-04-25 18:18:55 +00:00
saved = found;
found = xstrdup(dirname(saved));
Extend the modifiers allowed before formats: as well as the existing #{=10:...} length limit, add #{t:...} to convert a time_t format to a string, #{b:...} for basename and #{d:...} for dirname. Remove all the foo_string time formats as they can now be replaced by "t:", for example #{window_activity_string} becomes #{t:window_activity}.
2015-10-25 22:29:17 +00:00
free(saved);
}
Change so that window_flags escapes # automatically which means configs will not have to change. A new format window_raw_flags contains the old unescaped version.
2021-01-20 07:16:54 +00:00
if (modifiers & FORMAT_QUOTE_SHELL) {
Make options_tostring allocate its result instead of using a stack buffer (needed for something in the future).
2019-04-25 18:18:55 +00:00
saved = found;
Change so that window_flags escapes # automatically which means configs will not have to change. A new format window_raw_flags contains the old unescaped version.
2021-01-20 07:16:54 +00:00
found = xstrdup(format_quote_shell(saved));
Add q: format prefix to escape sh(1) special characters. Suggested by someone ages ago and then more recently in GitHub issue 1449.
2018-08-26 09:28:42 +00:00
free(saved);
}
Change so that window_flags escapes # automatically which means configs will not have to change. A new format window_raw_flags contains the old unescaped version.
2021-01-20 07:16:54 +00:00
if (modifiers & FORMAT_QUOTE_STYLE) {
Make replacement of ##s consistent when drawing formats, whether followed by [ or not. Add a flag (e) to the q: format modifier to double up #s and use it for the window_flags format variable so it doesn't end up escaping any following text. GitHub issue 2485.
2020-12-01 08:12:58 +00:00
saved = found;
Change so that window_flags escapes # automatically which means configs will not have to change. A new format window_raw_flags contains the old unescaped version.
2021-01-20 07:16:54 +00:00
found = xstrdup(format_quote_style(saved));
Make replacement of ##s consistent when drawing formats, whether followed by [ or not. Add a flag (e) to the q: format modifier to double up #s and use it for the window_flags format variable so it doesn't end up escaping any following text. GitHub issue 2485.
2020-12-01 08:12:58 +00:00
free(saved);
}
Make options_tostring allocate its result instead of using a stack buffer (needed for something in the future).
2019-04-25 18:18:55 +00:00
return (found);
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
}
Allow a custom time format to be given to the t format modifier.
2020-05-16 15:48:35 +00:00
/* Remove escaped characters from string. */
static char *
format_strip(const char *s)
{
char *out, *cp;
int brackets = 0;
cp = out = xmalloc(strlen(s) + 1);
for (; *s != '\0'; s++) {
if (*s == '#' && s[1] == '{')
brackets++;
if (*s == '#' && strchr(",#{}:", s[1]) != NULL) {
if (brackets != 0)
*cp++ = *s;
continue;
}
if (*s == '}')
brackets--;
*cp++ = *s;
}
*cp = '\0';
return (out);
}
Allow escaping , and } with # in #{}; GitHub issue 1332.
2018-05-22 08:49:12 +00:00
/* Skip until end. */
Extend the #[] style syntax and use that together with previous format changes to allow the status line to be entirely configured with a single option. Now that it is possible to configure their content, enable the existing code that lets the status line be multiple lines in height. The status option can now take a value of 2, 3, 4 or 5 (as well as the previous on or off) to configure more than one line. The new status-format array option configures the format of each line, the default just references the existing status-* options, although some of the more obscure status options may be eliminated in time. Additions to the #[] syntax are: "align" to specify alignment (left, centre, right), "list" for the window list and "range" to configure ranges of text for the mouse bindings. The "align" keyword can also be used to specify alignment of entries in tree mode and the pane status lines.
2019-03-18 20:53:33 +00:00
const char *
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
format_skip(const char *s, const char *end)
Add simple comparisons in formats: #{==:a,b} and #{!=:a,b} ("a" and "b" are expanded so can compare formats). And expand the condition to #{?a,b,c} (the "a" part) if it doesn't work as a simple lookup. Also add FORMAT_NOJOBS flag to disable jobs in a format.
2017-01-09 21:03:25 +00:00
{
int brackets = 0;
for (; *s != '\0'; s++) {
Allow escaping , and } with # in #{}; GitHub issue 1332.
2018-05-22 08:49:12 +00:00
if (*s == '#' && s[1] == '{')
Add simple comparisons in formats: #{==:a,b} and #{!=:a,b} ("a" and "b" are expanded so can compare formats). And expand the condition to #{?a,b,c} (the "a" part) if it doesn't work as a simple lookup. Also add FORMAT_NOJOBS flag to disable jobs in a format.
2017-01-09 21:03:25 +00:00
brackets++;
Allow a custom time format to be given to the t format modifier.
2020-05-16 15:48:35 +00:00
if (*s == '#' && strchr(",#{}:", s[1]) != NULL) {
Allow escaping , and } with # in #{}; GitHub issue 1332.
2018-05-22 08:49:12 +00:00
s++;
continue;
}
Add simple comparisons in formats: #{==:a,b} and #{!=:a,b} ("a" and "b" are expanded so can compare formats). And expand the condition to #{?a,b,c} (the "a" part) if it doesn't work as a simple lookup. Also add FORMAT_NOJOBS flag to disable jobs in a format.
2017-01-09 21:03:25 +00:00
if (*s == '}')
brackets--;
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
if (strchr(end, *s) != NULL && brackets == 0)
Add simple comparisons in formats: #{==:a,b} and #{!=:a,b} ("a" and "b" are expanded so can compare formats). And expand the condition to #{?a,b,c} (the "a" part) if it doesn't work as a simple lookup. Also add FORMAT_NOJOBS flag to disable jobs in a format.
2017-01-09 21:03:25 +00:00
break;
}
if (*s == '\0')
return (NULL);
return (s);
}
/* Return left and right alternatives separated by commas. */
static int
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_choose(struct format_expand_state *es, const char *s, char **left,
char **right, int expand)
Add simple comparisons in formats: #{==:a,b} and #{!=:a,b} ("a" and "b" are expanded so can compare formats). And expand the condition to #{?a,b,c} (the "a" part) if it doesn't work as a simple lookup. Also add FORMAT_NOJOBS flag to disable jobs in a format.
2017-01-09 21:03:25 +00:00
{
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
const char *cp;
char *left0, *right0;
Add simple comparisons in formats: #{==:a,b} and #{!=:a,b} ("a" and "b" are expanded so can compare formats). And expand the condition to #{?a,b,c} (the "a" part) if it doesn't work as a simple lookup. Also add FORMAT_NOJOBS flag to disable jobs in a format.
2017-01-09 21:03:25 +00:00
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
cp = format_skip(s, ",");
Add simple comparisons in formats: #{==:a,b} and #{!=:a,b} ("a" and "b" are expanded so can compare formats). And expand the condition to #{?a,b,c} (the "a" part) if it doesn't work as a simple lookup. Also add FORMAT_NOJOBS flag to disable jobs in a format.
2017-01-09 21:03:25 +00:00
if (cp == NULL)
return (-1);
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
left0 = xstrndup(s, cp - s);
right0 = xstrdup(cp + 1);
Add simple comparisons in formats: #{==:a,b} and #{!=:a,b} ("a" and "b" are expanded so can compare formats). And expand the condition to #{?a,b,c} (the "a" part) if it doesn't work as a simple lookup. Also add FORMAT_NOJOBS flag to disable jobs in a format.
2017-01-09 21:03:25 +00:00
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
if (expand) {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
*left = format_expand1(es, left0);
Free old strings after they have been expanded in format_choose.
2019-03-29 09:33:24 +00:00
free(left0);
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
*right = format_expand1(es, right0);
Free old strings after they have been expanded in format_choose.
2019-03-29 09:33:24 +00:00
free(right0);
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
} else {
*left = left0;
*right = right0;
}
Add simple comparisons in formats: #{==:a,b} and #{!=:a,b} ("a" and "b" are expanded so can compare formats). And expand the condition to #{?a,b,c} (the "a" part) if it doesn't work as a simple lookup. Also add FORMAT_NOJOBS flag to disable jobs in a format.
2017-01-09 21:03:25 +00:00
return (0);
}
/* Is this true? */
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
int
Add simple comparisons in formats: #{==:a,b} and #{!=:a,b} ("a" and "b" are expanded so can compare formats). And expand the condition to #{?a,b,c} (the "a" part) if it doesn't work as a simple lookup. Also add FORMAT_NOJOBS flag to disable jobs in a format.
2017-01-09 21:03:25 +00:00
format_true(const char *s)
{
if (s != NULL && *s != '\0' && (s[0] != '0' || s[1] != '\0'))
return (1);
return (0);
}
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
/* Check if modifier end. */
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static int
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
format_is_end(char c)
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
{
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
return (c == ';' || c == ':');
}
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
/* Add to modifier list. */
static void
format_add_modifier(struct format_modifier **list, u_int *count,
const char *c, size_t n, char **argv, int argc)
{
struct format_modifier *fm;
*list = xreallocarray(*list, (*count) + 1, sizeof **list);
fm = &(*list)[(*count)++];
memcpy(fm->modifier, c, n);
fm->modifier[n] = '\0';
fm->size = n;
fm->argv = argv;
fm->argc = argc;
}
/* Free modifier list. */
static void
format_free_modifiers(struct format_modifier *list, u_int count)
{
u_int i;
for (i = 0; i < count; i++)
cmd_free_argv(list[i].argc, list[i].argv);
free(list);
}
/* Build modifier list. */
static struct format_modifier *
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_build_modifiers(struct format_expand_state *es, const char **s,
u_int *count)
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
{
const char *cp = *s, *end;
struct format_modifier *list = NULL;
char c, last[] = "X;:", **argv, *value;
int argc;
/*
* Modifiers are a ; separated list of the forms:
Permit shortcut keys in buffer, client, tree modes to be configured with a format; the default remains the line number. GitHub issue 2636.
2021-04-12 06:50:25 +00:00
* l,m,C,a,b,d,n,t,w,q,E,T,S,W,P,<,>
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
* =a
* =/a
* =/a/
* s/a/b/
* s/a/b
Add <, >, <=, >= for formats, GitHub issue 1747.
2019-05-25 16:51:10 +00:00
* ||,&&,!=,==,<=,>=
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
*/
*count = 0;
while (*cp != '\0' && *cp != ':') {
Allow a custom time format to be given to the t format modifier.
2020-05-16 15:48:35 +00:00
/* Skip any separator character. */
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
if (*cp == ';')
cp++;
/* Check single character modifiers with no arguments. */
Permit shortcut keys in buffer, client, tree modes to be configured with a format; the default remains the line number. GitHub issue 2636.
2021-04-12 06:50:25 +00:00
if (strchr("labdnwETSWP<>", cp[0]) != NULL &&
Add formats to list sessions, windows or panes.
2019-03-13 15:37:28 +00:00
format_is_end(cp[1])) {
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
format_add_modifier(&list, count, cp, 1, NULL, 0);
cp++;
continue;
Add simple comparisons in formats: #{==:a,b} and #{!=:a,b} ("a" and "b" are expanded so can compare formats). And expand the condition to #{?a,b,c} (the "a" part) if it doesn't work as a simple lookup. Also add FORMAT_NOJOBS flag to disable jobs in a format.
2017-01-09 21:03:25 +00:00
}
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
/* Then try double character with no arguments. */
if ((memcmp("||", cp, 2) == 0 ||
memcmp("&&", cp, 2) == 0 ||
memcmp("!=", cp, 2) == 0 ||
Add <, >, <=, >= for formats, GitHub issue 1747.
2019-05-25 16:51:10 +00:00
memcmp("==", cp, 2) == 0 ||
memcmp("<=", cp, 2) == 0 ||
memcmp(">=", cp, 2) == 0) &&
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
format_is_end(cp[2])) {
format_add_modifier(&list, count, cp, 2, NULL, 0);
cp += 2;
continue;
Add simple comparisons in formats: #{==:a,b} and #{!=:a,b} ("a" and "b" are expanded so can compare formats). And expand the condition to #{?a,b,c} (the "a" part) if it doesn't work as a simple lookup. Also add FORMAT_NOJOBS flag to disable jobs in a format.
2017-01-09 21:03:25 +00:00
}
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
/* Now try single character with arguments. */
Add a -S flag to new-window to make it select the existing window if one with the given name already exists rather than failing with an error. Also add a format to check if a window or session name exists which allows the same with other commands. Requested by and discussed with kn@.
2021-02-05 12:23:49 +00:00
if (strchr("mCNst=peq", cp[0]) == NULL)
Add s/foo/bar/: prefix for formats to substitute bar for foo.
2015-11-18 14:13:55 +00:00
break;
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
c = cp[0];
/* No arguments provided. */
if (format_is_end(cp[1])) {
format_add_modifier(&list, count, cp, 1, NULL, 0);
cp++;
continue;
Add s/foo/bar/: prefix for formats to substitute bar for foo.
2015-11-18 14:13:55 +00:00
}
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
argv = NULL;
argc = 0;
/* Single argument with no wrapper character. */
if (!ispunct(cp[1]) || cp[1] == '-') {
end = format_skip(cp + 1, ":;");
if (end == NULL)
break;
argv = xcalloc(1, sizeof *argv);
value = xstrndup(cp + 1, end - (cp + 1));
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
argv[0] = format_expand1(es, value);
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
free(value);
argc = 1;
format_add_modifier(&list, count, &c, 1, argv, argc);
cp = end;
continue;
Add s/foo/bar/: prefix for formats to substitute bar for foo.
2015-11-18 14:13:55 +00:00
}
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
/* Multiple arguments with a wrapper character. */
last[0] = cp[1];
cp++;
do {
if (cp[0] == last[0] && format_is_end(cp[1])) {
cp++;
break;
}
end = format_skip(cp + 1, last);
if (end == NULL)
break;
cp++;
argv = xreallocarray (argv, argc + 1, sizeof *argv);
value = xstrndup(cp, end - cp);
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
argv[argc++] = format_expand1(es, value);
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
free(value);
cp = end;
} while (!format_is_end(cp[0]));
format_add_modifier(&list, count, &c, 1, argv, argc);
}
if (*cp != ':') {
format_free_modifiers(list, *count);
*count = 0;
return (NULL);
}
*s = cp + 1;
More style nits.
2020-04-09 15:35:27 +00:00
return (list);
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
}
Add regular expression support for the format search, match and substitute modifiers.
2019-06-13 19:46:00 +00:00
/* Match against an fnmatch(3) pattern or regular expression. */
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
static char *
Add regular expression support for the format search, match and substitute modifiers.
2019-06-13 19:46:00 +00:00
format_match(struct format_modifier *fm, const char *pattern, const char *text)
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
{
Add regular expression support for the format search, match and substitute modifiers.
2019-06-13 19:46:00 +00:00
const char *s = "";
regex_t r;
int flags = 0;
if (fm->argc >= 1)
s = fm->argv[0];
if (strchr(s, 'r') == NULL) {
if (strchr(s, 'i') != NULL)
flags |= FNM_CASEFOLD;
if (fnmatch(pattern, text, flags) != 0)
return (xstrdup("0"));
} else {
flags = REG_EXTENDED|REG_NOSUB;
if (strchr(s, 'i') != NULL)
flags |= REG_ICASE;
if (regcomp(&r, pattern, flags) != 0)
return (xstrdup("0"));
if (regexec(&r, text, 0, NULL, 0) != 0) {
regfree(&r);
return (xstrdup("0"));
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
}
Add regular expression support for the format search, match and substitute modifiers.
2019-06-13 19:46:00 +00:00
regfree(&r);
}
return (xstrdup("1"));
}
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
Add regular expression support for the format search, match and substitute modifiers.
2019-06-13 19:46:00 +00:00
/* Perform substitution in string. */
static char *
format_sub(struct format_modifier *fm, const char *text, const char *pattern,
const char *with)
{
char *value;
int flags = REG_EXTENDED;
if (fm->argc >= 3 && strchr(fm->argv[2], 'i') != NULL)
flags |= REG_ICASE;
value = regsub(pattern, with, text, flags);
if (value == NULL)
return (xstrdup(text));
return (value);
}
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
Add regular expression support for the format search, match and substitute modifiers.
2019-06-13 19:46:00 +00:00
/* Search inside pane. */
static char *
format_search(struct format_modifier *fm, struct window_pane *wp, const char *s)
{
int ignore = 0, regex = 0;
char *value;
if (fm->argc >= 1) {
if (strchr(fm->argv[0], 'i') != NULL)
ignore = 1;
if (strchr(fm->argv[0], 'r') != NULL)
regex = 1;
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
}
Add regular expression support for the format search, match and substitute modifiers.
2019-06-13 19:46:00 +00:00
xasprintf(&value, "%u", window_pane_search(wp, s, regex, ignore));
return (value);
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
}
Add a -S flag to new-window to make it select the existing window if one with the given name already exists rather than failing with an error. Also add a format to check if a window or session name exists which allows the same with other commands. Requested by and discussed with kn@.
2021-02-05 12:23:49 +00:00
/* Does session name exist? */
static char *
format_session_name(struct format_expand_state *es, const char *fmt)
{
char *name;
struct session *s;
name = format_expand1(es, fmt);
RB_FOREACH(s, sessions, &sessions) {
if (strcmp(s->name, name) == 0) {
free(name);
return (xstrdup("1"));
}
}
free(name);
return (xstrdup("0"));
}
Add formats to list sessions, windows or panes.
2019-03-13 15:37:28 +00:00
/* Loop over sessions. */
static char *
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_loop_sessions(struct format_expand_state *es, const char *fmt)
Add formats to list sessions, windows or panes.
2019-03-13 15:37:28 +00:00
{
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
struct format_tree *ft = es->ft;
struct client *c = ft->client;
struct cmdq_item *item = ft->item;
struct format_tree *nft;
struct format_expand_state next;
char *expanded, *value;
size_t valuelen;
struct session *s;
Add formats to list sessions, windows or panes.
2019-03-13 15:37:28 +00:00
value = xcalloc(1, 1);
valuelen = 1;
RB_FOREACH(s, sessions, &sessions) {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "session loop: $%u", s->id);
The pane and window loops need to pass the window and pane tags when they build their format.
2019-03-15 10:07:24 +00:00
nft = format_create(c, item, FORMAT_NONE, ft->flags);
Use right format for session loop, GitHub issue 2519.
2020-12-30 18:29:40 +00:00
format_defaults(nft, ft->c, s, NULL, NULL);
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_copy_state(&next, es, 0);
next.ft = nft;
expanded = format_expand1(&next, fmt);
format_free(next.ft);
Add formats to list sessions, windows or panes.
2019-03-13 15:37:28 +00:00
valuelen += strlen(expanded);
value = xrealloc(value, valuelen);
strlcat(value, expanded, valuelen);
free(expanded);
}
return (value);
}
Add a -S flag to new-window to make it select the existing window if one with the given name already exists rather than failing with an error. Also add a format to check if a window or session name exists which allows the same with other commands. Requested by and discussed with kn@.
2021-02-05 12:23:49 +00:00
/* Does window name exist? */
static char *
format_window_name(struct format_expand_state *es, const char *fmt)
{
struct format_tree *ft = es->ft;
char *name;
struct winlink *wl;
if (ft->s == NULL) {
format_log(es, "window name but no session");
return (NULL);
}
name = format_expand1(es, fmt);
RB_FOREACH(wl, winlinks, &ft->s->windows) {
if (strcmp(wl->window->name, name) == 0) {
free(name);
return (xstrdup("1"));
}
}
free(name);
return (xstrdup("0"));
}
Add formats to list sessions, windows or panes.
2019-03-13 15:37:28 +00:00
/* Loop over windows. */
static char *
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_loop_windows(struct format_expand_state *es, const char *fmt)
{
struct format_tree *ft = es->ft;
struct client *c = ft->client;
struct cmdq_item *item = ft->item;
struct format_tree *nft;
struct format_expand_state next;
char *all, *active, *use, *expanded, *value;
size_t valuelen;
struct winlink *wl;
struct window *w;
Add formats to list sessions, windows or panes.
2019-03-13 15:37:28 +00:00
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
if (ft->s == NULL) {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "window loop but no session");
Add formats to list sessions, windows or panes.
2019-03-13 15:37:28 +00:00
return (NULL);
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
}
Add formats to list sessions, windows or panes.
2019-03-13 15:37:28 +00:00
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
if (format_choose(es, fmt, &all, &active, 0) != 0) {
Add formats to list sessions, windows or panes.
2019-03-13 15:37:28 +00:00
all = xstrdup(fmt);
active = NULL;
}
value = xcalloc(1, 1);
valuelen = 1;
RB_FOREACH(wl, winlinks, &ft->s->windows) {
The pane and window loops need to pass the window and pane tags when they build their format.
2019-03-15 10:07:24 +00:00
w = wl->window;
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "window loop: %u @%u", wl->idx, w->id);
Add formats to list sessions, windows or panes.
2019-03-13 15:37:28 +00:00
if (active != NULL && wl == ft->s->curw)
use = active;
else
use = all;
The pane and window loops need to pass the window and pane tags when they build their format.
2019-03-15 10:07:24 +00:00
nft = format_create(c, item, FORMAT_WINDOW|w->id, ft->flags);
format_defaults(nft, ft->c, ft->s, wl, NULL);
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_copy_state(&next, es, 0);
next.ft = nft;
expanded = format_expand1(&next, use);
The pane and window loops need to pass the window and pane tags when they build their format.
2019-03-15 10:07:24 +00:00
format_free(nft);
Add formats to list sessions, windows or panes.
2019-03-13 15:37:28 +00:00
valuelen += strlen(expanded);
value = xrealloc(value, valuelen);
strlcat(value, expanded, valuelen);
free(expanded);
}
free(active);
free(all);
return (value);
}
/* Loop over panes. */
static char *
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_loop_panes(struct format_expand_state *es, const char *fmt)
Add formats to list sessions, windows or panes.
2019-03-13 15:37:28 +00:00
{
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
struct format_tree *ft = es->ft;
struct client *c = ft->client;
struct cmdq_item *item = ft->item;
struct format_tree *nft;
struct format_expand_state next;
char *all, *active, *use, *expanded, *value;
size_t valuelen;
struct window_pane *wp;
Add formats to list sessions, windows or panes.
2019-03-13 15:37:28 +00:00
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
if (ft->w == NULL) {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "pane loop but no window");
Add formats to list sessions, windows or panes.
2019-03-13 15:37:28 +00:00
return (NULL);
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
}
Add formats to list sessions, windows or panes.
2019-03-13 15:37:28 +00:00
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
if (format_choose(es, fmt, &all, &active, 0) != 0) {
Add formats to list sessions, windows or panes.
2019-03-13 15:37:28 +00:00
all = xstrdup(fmt);
active = NULL;
}
value = xcalloc(1, 1);
valuelen = 1;
TAILQ_FOREACH(wp, &ft->w->panes, entry) {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "pane loop: %%%u", wp->id);
Add formats to list sessions, windows or panes.
2019-03-13 15:37:28 +00:00
if (active != NULL && wp == ft->w->active)
use = active;
else
use = all;
The pane and window loops need to pass the window and pane tags when they build their format.
2019-03-15 10:07:24 +00:00
nft = format_create(c, item, FORMAT_PANE|wp->id, ft->flags);
format_defaults(nft, ft->c, ft->s, ft->wl, wp);
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_copy_state(&next, es, 0);
next.ft = nft;
expanded = format_expand1(&next, use);
The pane and window loops need to pass the window and pane tags when they build their format.
2019-03-15 10:07:24 +00:00
format_free(nft);
Add formats to list sessions, windows or panes.
2019-03-13 15:37:28 +00:00
valuelen += strlen(expanded);
value = xrealloc(value, valuelen);
strlcat(value, expanded, valuelen);
free(expanded);
}
free(active);
free(all);
return (value);
}
Add some number operators for formats, from Tyler Culp.
2020-03-11 14:17:55 +00:00
static char *
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_replace_expression(struct format_modifier *mexp,
struct format_expand_state *es, const char *copy)
{
int argc = mexp->argc;
const char *errstr;
char *endch, *value, *left = NULL, *right = NULL;
int use_fp = 0;
u_int prec = 0;
double mleft, mright, result;
Add numeric comparisons for formats, from teo_paul1 at yahoo dot com in GitHub issue 2442.
2020-11-02 08:21:30 +00:00
enum { ADD,
SUBTRACT,
MULTIPLY,
DIVIDE,
MODULUS,
EQUAL,
NOT_EQUAL,
GREATER_THAN,
GREATER_THAN_EQUAL,
LESS_THAN,
LESS_THAN_EQUAL } operator;
Add some number operators for formats, from Tyler Culp.
2020-03-11 14:17:55 +00:00
if (strcmp(mexp->argv[0], "+") == 0)
operator = ADD;
else if (strcmp(mexp->argv[0], "-") == 0)
operator = SUBTRACT;
else if (strcmp(mexp->argv[0], "*") == 0)
operator = MULTIPLY;
else if (strcmp(mexp->argv[0], "/") == 0)
operator = DIVIDE;
else if (strcmp(mexp->argv[0], "%") == 0 ||
strcmp(mexp->argv[0], "m") == 0)
operator = MODULUS;
Add numeric comparisons for formats, from teo_paul1 at yahoo dot com in GitHub issue 2442.
2020-11-02 08:21:30 +00:00
else if (strcmp(mexp->argv[0], "==") == 0)
operator = EQUAL;
else if (strcmp(mexp->argv[0], "!=") == 0)
operator = NOT_EQUAL;
else if (strcmp(mexp->argv[0], ">") == 0)
operator = GREATER_THAN;
else if (strcmp(mexp->argv[0], "<") == 0)
operator = LESS_THAN;
else if (strcmp(mexp->argv[0], ">=") == 0)
operator = GREATER_THAN_EQUAL;
else if (strcmp(mexp->argv[0], "<=") == 0)
operator = LESS_THAN_EQUAL;
Add some number operators for formats, from Tyler Culp.
2020-03-11 14:17:55 +00:00
else {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "expression has no valid operator: '%s'",
Add some number operators for formats, from Tyler Culp.
2020-03-11 14:17:55 +00:00
mexp->argv[0]);
goto fail;
}
/* The second argument may be flags. */
if (argc >= 2 && strchr(mexp->argv[1], 'f') != NULL) {
use_fp = 1;
prec = 2;
}
/* The third argument may be precision. */
if (argc >= 3) {
prec = strtonum(mexp->argv[2], INT_MIN, INT_MAX, &errstr);
if (errstr != NULL) {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "expression precision %s: %s", errstr,
Add some number operators for formats, from Tyler Culp.
2020-03-11 14:17:55 +00:00
mexp->argv[2]);
goto fail;
}
}
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
if (format_choose(es, copy, &left, &right, 1) != 0) {
format_log(es, "expression syntax error");
Add some number operators for formats, from Tyler Culp.
2020-03-11 14:17:55 +00:00
goto fail;
}
mleft = strtod(left, &endch);
if (*endch != '\0') {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "expression left side is invalid: %s", left);
Add some number operators for formats, from Tyler Culp.
2020-03-11 14:17:55 +00:00
goto fail;
}
mright = strtod(right, &endch);
if (*endch != '\0') {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "expression right side is invalid: %s", right);
Add some number operators for formats, from Tyler Culp.
2020-03-11 14:17:55 +00:00
goto fail;
}
if (!use_fp) {
mleft = (long long)mleft;
mright = (long long)mright;
}
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "expression left side is: %.*f", prec, mleft);
Permit shortcut keys in buffer, client, tree modes to be configured with a format; the default remains the line number. GitHub issue 2636.
2021-04-12 06:50:25 +00:00
format_log(es, "expression right side is: %.*f", prec, mright);
Add some number operators for formats, from Tyler Culp.
2020-03-11 14:17:55 +00:00
switch (operator) {
case ADD:
result = mleft + mright;
break;
case SUBTRACT:
result = mleft - mright;
break;
case MULTIPLY:
result = mleft * mright;
break;
case DIVIDE:
result = mleft / mright;
break;
case MODULUS:
result = fmod(mleft, mright);
break;
Add numeric comparisons for formats, from teo_paul1 at yahoo dot com in GitHub issue 2442.
2020-11-02 08:21:30 +00:00
case EQUAL:
result = fabs(mleft - mright) < 1e-9;
break;
case NOT_EQUAL:
result = fabs(mleft - mright) > 1e-9;
break;
case GREATER_THAN:
result = (mleft > mright);
break;
case GREATER_THAN_EQUAL:
result = (mleft >= mright);
break;
case LESS_THAN:
result = (mleft < mright);
break;
case LESS_THAN_EQUAL:
Bump FORMAT_LOOOP_LIMIT and add a log message when hit, GitHub issue 2715.
2021-06-10 07:58:08 +00:00
result = (mleft <= mright);
Add numeric comparisons for formats, from teo_paul1 at yahoo dot com in GitHub issue 2442.
2020-11-02 08:21:30 +00:00
break;
Add some number operators for formats, from Tyler Culp.
2020-03-11 14:17:55 +00:00
}
if (use_fp)
xasprintf(&value, "%.*f", prec, result);
else
xasprintf(&value, "%.*f", prec, (double)(long long)result);
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "expression result is %s", value);
Add some number operators for formats, from Tyler Culp.
2020-03-11 14:17:55 +00:00
free(right);
free(left);
More style nits.
2020-04-09 15:35:27 +00:00
return (value);
Add some number operators for formats, from Tyler Culp.
2020-03-11 14:17:55 +00:00
fail:
free(right);
free(left);
return (NULL);
}
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
/* Replace a key. */
static int
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_replace(struct format_expand_state *es, const char *key, size_t keylen,
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
char **buf, size_t *len, size_t *off)
{
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
struct format_tree *ft = es->ft;
struct window_pane *wp = ft->wp;
Permit shortcut keys in buffer, client, tree modes to be configured with a format; the default remains the line number. GitHub issue 2636.
2021-04-12 06:50:25 +00:00
const char *errstr, *copy, *cp, *marker = NULL;
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
const char *time_format = NULL;
char *copy0, *condition, *found, *new;
Permit shortcut keys in buffer, client, tree modes to be configured with a format; the default remains the line number. GitHub issue 2636.
2021-04-12 06:50:25 +00:00
char *value, *left, *right, c;
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
size_t valuelen;
int modifiers = 0, limit = 0, width = 0;
int j;
struct format_modifier *list, *cmp = NULL, *search = NULL;
struct format_modifier **sub = NULL, *mexp = NULL, *fm;
u_int i, count, nsub = 0;
struct format_expand_state next;
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
/* Make a copy of the key. */
copy = copy0 = xstrndup(key, keylen);
/* Process modifier list. */
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
list = format_build_modifiers(es, &copy, &count);
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
for (i = 0; i < count; i++) {
fm = &list[i];
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
if (format_logging(ft)) {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "modifier %u is %s", i, fm->modifier);
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
for (j = 0; j < fm->argc; j++) {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "modifier %u argument %d: %s", i,
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
j, fm->argv[j]);
}
}
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
if (fm->size == 1) {
switch (fm->modifier[0]) {
case 'm':
Add <, >, <=, >= for formats, GitHub issue 1747.
2019-05-25 16:51:10 +00:00
case '<':
case '>':
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
cmp = fm;
break;
case 'C':
search = fm;
break;
case 's':
Add regular expression support for the format search, match and substitute modifiers.
2019-06-13 19:46:00 +00:00
if (fm->argc < 2)
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
break;
Remove stray spaces after function names.
2021-08-20 17:50:42 +00:00
sub = xreallocarray(sub, nsub + 1, sizeof *sub);
Allow multiple substitutions in a single format.
2019-11-25 15:02:48 +00:00
sub[nsub++] = fm;
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
break;
case '=':
Add regular expression support for the format search, match and substitute modifiers.
2019-06-13 19:46:00 +00:00
if (fm->argc < 1)
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
break;
limit = strtonum(fm->argv[0], INT_MIN, INT_MAX,
Permit shortcut keys in buffer, client, tree modes to be configured with a format; the default remains the line number. GitHub issue 2636.
2021-04-12 06:50:25 +00:00
&errstr);
if (errstr != NULL)
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
limit = 0;
Add regular expression support for the format search, match and substitute modifiers.
2019-06-13 19:46:00 +00:00
if (fm->argc >= 2 && fm->argv[1] != NULL)
Add a way to append or prepend to a format if the length has been limited.
2019-05-26 12:02:42 +00:00
marker = fm->argv[1];
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
break;
Add p format modifier for padding to width.
2019-11-25 15:04:15 +00:00
case 'p':
if (fm->argc < 1)
break;
width = strtonum(fm->argv[0], INT_MIN, INT_MAX,
Permit shortcut keys in buffer, client, tree modes to be configured with a format; the default remains the line number. GitHub issue 2636.
2021-04-12 06:50:25 +00:00
&errstr);
if (errstr != NULL)
Add p format modifier for padding to width.
2019-11-25 15:04:15 +00:00
width = 0;
break;
Change how escaping is processed for formats so that ## and # can be used in styles. Also add a 'w' format modifier for the width. From Chas J Owens IV in GitHub issue 2389.
2020-11-09 09:10:10 +00:00
case 'w':
modifiers |= FORMAT_WIDTH;
break;
Add some number operators for formats, from Tyler Culp.
2020-03-11 14:17:55 +00:00
case 'e':
if (fm->argc < 1 || fm->argc > 3)
break;
Tweak the default choose modes formats: - Only show pane title if it is not default and not empty. - Add a prettier time format and use that instead of long ctime(). - Remove clutter and change the order.
2020-05-16 14:10:29 +00:00
mexp = fm;
Add some number operators for formats, from Tyler Culp.
2020-03-11 14:17:55 +00:00
break;
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
case 'l':
modifiers |= FORMAT_LITERAL;
break;
Permit shortcut keys in buffer, client, tree modes to be configured with a format; the default remains the line number. GitHub issue 2636.
2021-04-12 06:50:25 +00:00
case 'a':
modifiers |= FORMAT_CHARACTER;
break;
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
case 'b':
modifiers |= FORMAT_BASENAME;
break;
case 'd':
modifiers |= FORMAT_DIRNAME;
break;
Add n: modifier to get length of a format, also automatically expand variable name arguments again if they contain a #{.
2020-08-20 16:57:40 +00:00
case 'n':
modifiers |= FORMAT_LENGTH;
break;
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
case 't':
modifiers |= FORMAT_TIMESTRING;
Tweak the default choose modes formats: - Only show pane title if it is not default and not empty. - Add a prettier time format and use that instead of long ctime(). - Remove clutter and change the order.
2020-05-16 14:10:29 +00:00
if (fm->argc < 1)
break;
if (strchr(fm->argv[0], 'p') != NULL)
modifiers |= FORMAT_PRETTY;
Allow a custom time format to be given to the t format modifier.
2020-05-16 15:48:35 +00:00
else if (fm->argc >= 2 &&
strchr(fm->argv[0], 'f') != NULL)
time_format = format_strip(fm->argv[1]);
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
break;
case 'q':
Make replacement of ##s consistent when drawing formats, whether followed by [ or not. Add a flag (e) to the q: format modifier to double up #s and use it for the window_flags format variable so it doesn't end up escaping any following text. GitHub issue 2485.
2020-12-01 08:12:58 +00:00
if (fm->argc < 1)
Change so that window_flags escapes # automatically which means configs will not have to change. A new format window_raw_flags contains the old unescaped version.
2021-01-20 07:16:54 +00:00
modifiers |= FORMAT_QUOTE_SHELL;
else if (strchr(fm->argv[0], 'e') != NULL ||
strchr(fm->argv[0], 'h') != NULL)
modifiers |= FORMAT_QUOTE_STYLE;
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
break;
Add E: format to expand a format twice (useful to expand the value of an option).
2019-03-13 14:19:54 +00:00
case 'E':
modifiers |= FORMAT_EXPAND;
break;
Add T format modifier like E but also do strftime(3).
2019-03-14 21:31:43 +00:00
case 'T':
modifiers |= FORMAT_EXPANDTIME;
break;
Add a -S flag to new-window to make it select the existing window if one with the given name already exists rather than failing with an error. Also add a format to check if a window or session name exists which allows the same with other commands. Requested by and discussed with kn@.
2021-02-05 12:23:49 +00:00
case 'N':
if (fm->argc < 1 ||
strchr(fm->argv[0], 'w') != NULL)
modifiers |= FORMAT_WINDOW_NAME;
else if (strchr(fm->argv[0], 's') != NULL)
modifiers |= FORMAT_SESSION_NAME;
break;
Add formats to list sessions, windows or panes.
2019-03-13 15:37:28 +00:00
case 'S':
modifiers |= FORMAT_SESSIONS;
break;
case 'W':
modifiers |= FORMAT_WINDOWS;
break;
case 'P':
modifiers |= FORMAT_PANES;
break;
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
}
} else if (fm->size == 2) {
if (strcmp(fm->modifier, "||") == 0 ||
strcmp(fm->modifier, "&&") == 0 ||
strcmp(fm->modifier, "==") == 0 ||
Add <, >, <=, >= for formats, GitHub issue 1747.
2019-05-25 16:51:10 +00:00
strcmp(fm->modifier, "!=") == 0 ||
strcmp(fm->modifier, ">=") == 0 ||
strcmp(fm->modifier, "<=") == 0)
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
cmp = fm;
}
Add length limit operator for formats.
2013-10-10 11:50:20 +00:00
}
Allow escaping , and } with # in #{}; GitHub issue 1332.
2018-05-22 08:49:12 +00:00
/* Is this a literal string? */
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
if (modifiers & FORMAT_LITERAL) {
Allow escaping , and } with # in #{}; GitHub issue 1332.
2018-05-22 08:49:12 +00:00
value = xstrdup(copy);
goto done;
}
Permit shortcut keys in buffer, client, tree modes to be configured with a format; the default remains the line number. GitHub issue 2636.
2021-04-12 06:50:25 +00:00
/* Is this a character? */
if (modifiers & FORMAT_CHARACTER) {
new = format_expand1(es, copy);
c = strtonum(new, 32, 126, &errstr);
if (errstr != NULL)
value = xstrdup("");
else
xasprintf(&value, "%c", c);
Remove stray spaces after function names.
2021-08-20 17:50:42 +00:00
free(new);
Permit shortcut keys in buffer, client, tree modes to be configured with a format; the default remains the line number. GitHub issue 2636.
2021-04-12 06:50:25 +00:00
goto done;
}
Add formats to list sessions, windows or panes.
2019-03-13 15:37:28 +00:00
/* Is this a loop, comparison or condition? */
if (modifiers & FORMAT_SESSIONS) {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
value = format_loop_sessions(es, copy);
Add formats to list sessions, windows or panes.
2019-03-13 15:37:28 +00:00
if (value == NULL)
goto fail;
} else if (modifiers & FORMAT_WINDOWS) {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
value = format_loop_windows(es, copy);
Add formats to list sessions, windows or panes.
2019-03-13 15:37:28 +00:00
if (value == NULL)
goto fail;
} else if (modifiers & FORMAT_PANES) {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
value = format_loop_panes(es, copy);
Add formats to list sessions, windows or panes.
2019-03-13 15:37:28 +00:00
if (value == NULL)
goto fail;
Add a -S flag to new-window to make it select the existing window if one with the given name already exists rather than failing with an error. Also add a format to check if a window or session name exists which allows the same with other commands. Requested by and discussed with kn@.
2021-02-05 12:23:49 +00:00
} else if (modifiers & FORMAT_WINDOW_NAME) {
value = format_window_name(es, copy);
if (value == NULL)
goto fail;
} else if (modifiers & FORMAT_SESSION_NAME) {
value = format_session_name(es, copy);
if (value == NULL)
goto fail;
Add formats to list sessions, windows or panes.
2019-03-13 15:37:28 +00:00
} else if (search != NULL) {
Add ||, && format operators and C: to search pane content.
2017-05-29 18:06:34 +00:00
/* Search in pane. */
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
new = format_expand1(es, copy);
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
if (wp == NULL) {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "search '%s' but no pane", new);
Add ||, && format operators and C: to search pane content.
2017-05-29 18:06:34 +00:00
value = xstrdup("0");
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
} else {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "search '%s' pane %%%u", new, wp->id);
Fix warnings, from Jan Tache in GitHub issue 2692.
2021-06-10 07:45:43 +00:00
value = format_search(search, wp, new);
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
}
Expand arguments to C and s format modifiers (matches m which already expands).
2019-06-24 10:04:29 +00:00
free(new);
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
} else if (cmp != NULL) {
/* Comparison of left and right. */
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
if (format_choose(es, copy, &left, &right, 1) != 0) {
format_log(es, "compare %s syntax error: %s",
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
cmp->modifier, copy);
Add simple comparisons in formats: #{==:a,b} and #{!=:a,b} ("a" and "b" are expanded so can compare formats). And expand the condition to #{?a,b,c} (the "a" part) if it doesn't work as a simple lookup. Also add FORMAT_NOJOBS flag to disable jobs in a format.
2017-01-09 21:03:25 +00:00
goto fail;
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
}
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "compare %s left is: %s", cmp->modifier, left);
format_log(es, "compare %s right is: %s", cmp->modifier, right);
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
if (strcmp(cmp->modifier, "||") == 0) {
if (format_true(left) || format_true(right))
value = xstrdup("1");
else
value = xstrdup("0");
} else if (strcmp(cmp->modifier, "&&") == 0) {
if (format_true(left) && format_true(right))
value = xstrdup("1");
else
value = xstrdup("0");
} else if (strcmp(cmp->modifier, "==") == 0) {
if (strcmp(left, right) == 0)
value = xstrdup("1");
else
value = xstrdup("0");
} else if (strcmp(cmp->modifier, "!=") == 0) {
if (strcmp(left, right) != 0)
value = xstrdup("1");
else
value = xstrdup("0");
Add <, >, <=, >= for formats, GitHub issue 1747.
2019-05-25 16:51:10 +00:00
} else if (strcmp(cmp->modifier, "<") == 0) {
if (strcmp(left, right) < 0)
value = xstrdup("1");
else
value = xstrdup("0");
} else if (strcmp(cmp->modifier, ">") == 0) {
if (strcmp(left, right) > 0)
value = xstrdup("1");
else
value = xstrdup("0");
} else if (strcmp(cmp->modifier, "<=") == 0) {
if (strcmp(left, right) <= 0)
value = xstrdup("1");
else
value = xstrdup("0");
} else if (strcmp(cmp->modifier, ">=") == 0) {
if (strcmp(left, right) >= 0)
value = xstrdup("1");
else
value = xstrdup("0");
Add regular expression support for the format search, match and substitute modifiers.
2019-06-13 19:46:00 +00:00
} else if (strcmp(cmp->modifier, "m") == 0)
Use the right format modifier when comparing, and remove a couple of unused variables.
2019-06-15 06:33:48 +00:00
value = format_match(cmp, left, right);
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
Add simple comparisons in formats: #{==:a,b} and #{!=:a,b} ("a" and "b" are expanded so can compare formats). And expand the condition to #{?a,b,c} (the "a" part) if it doesn't work as a simple lookup. Also add FORMAT_NOJOBS flag to disable jobs in a format.
2017-01-09 21:03:25 +00:00
free(right);
free(left);
} else if (*copy == '?') {
/* Conditional: check first and choose second or third. */
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
cp = format_skip(copy + 1, ",");
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
if (cp == NULL) {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "condition syntax error: %s", copy + 1);
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
goto fail;
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
}
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
condition = xstrndup(copy + 1, cp - (copy + 1));
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "condition is: %s", condition);
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
Allow a custom time format to be given to the t format modifier.
2020-05-16 15:48:35 +00:00
found = format_find(ft, condition, modifiers, time_format);
If foo doesn't exist and can't be expanded in #{?foo,a,b} then assume it is false.
2018-05-29 09:10:30 +00:00
if (found == NULL) {
/*
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
* If the condition not found, try to expand it. If
If foo doesn't exist and can't be expanded in #{?foo,a,b} then assume it is false.
2018-05-29 09:10:30 +00:00
* the expansion doesn't have any effect, then assume
* false.
*/
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
found = format_expand1(es, condition);
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
if (strcmp(found, condition) == 0) {
If foo doesn't exist and can't be expanded in #{?foo,a,b} then assume it is false.
2018-05-29 09:10:30 +00:00
free(found);
found = xstrdup("");
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es,
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
"condition '%s' not found; assuming false",
condition);
If foo doesn't exist and can't be expanded in #{?foo,a,b} then assume it is false.
2018-05-29 09:10:30 +00:00
}
Evaluate styles with the pane variables.
2021-08-12 19:47:05 +00:00
} else {
format_log(es, "condition '%s' found: %s", condition,
found);
}
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
if (format_choose(es, cp + 1, &left, &right, 0) != 0) {
format_log(es, "condition '%s' syntax error: %s",
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
condition, cp + 1);
Memory leaks, from Gang Fan in GitHub issue 1453.
2018-08-27 11:03:34 +00:00
free(found);
Count brackets in #{?...} so that nested conditional formats work, from Daniel De Graaf.
2015-10-27 09:28:31 +00:00
goto fail;
Memory leaks, from Gang Fan in GitHub issue 1453.
2018-08-27 11:03:34 +00:00
}
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
if (format_true(found)) {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "condition '%s' is true", condition);
value = format_expand1(es, left);
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
} else {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "condition '%s' is false", condition);
value = format_expand1(es, right);
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
}
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
free(right);
free(left);
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
free(condition);
Add s/foo/bar/: prefix for formats to substitute bar for foo.
2015-11-18 14:13:55 +00:00
free(found);
Add some number operators for formats, from Tyler Culp.
2020-03-11 14:17:55 +00:00
} else if (mexp != NULL) {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
value = format_replace_expression(mexp, es, copy);
Add some number operators for formats, from Tyler Culp.
2020-03-11 14:17:55 +00:00
if (value == NULL)
value = xstrdup("");
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
} else {
Add n: modifier to get length of a format, also automatically expand variable name arguments again if they contain a #{.
2020-08-20 16:57:40 +00:00
if (strstr(copy, "#{") != 0) {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "expanding inner format '%s'", copy);
value = format_expand1(es, copy);
Add n: modifier to get length of a format, also automatically expand variable name arguments again if they contain a #{.
2020-08-20 16:57:40 +00:00
} else {
value = format_find(ft, copy, modifiers, time_format);
if (value == NULL) {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "format '%s' not found", copy);
Add n: modifier to get length of a format, also automatically expand variable name arguments again if they contain a #{.
2020-08-20 16:57:40 +00:00
value = xstrdup("");
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
} else {
format_log(es, "format '%s' found: %s", copy,
value);
}
Add n: modifier to get length of a format, also automatically expand variable name arguments again if they contain a #{.
2020-08-20 16:57:40 +00:00
}
Add s/foo/bar/: prefix for formats to substitute bar for foo.
2015-11-18 14:13:55 +00:00
}
Apply length limits and substitution even to literal formats.
2019-03-13 14:27:17 +00:00
done:
Add E: format to expand a format twice (useful to expand the value of an option).
2019-03-13 14:19:54 +00:00
/* Expand again if required. */
if (modifiers & FORMAT_EXPAND) {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
new = format_expand1(es, value);
Add E: format to expand a format twice (useful to expand the value of an option).
2019-03-13 14:19:54 +00:00
free(value);
value = new;
Add n: modifier to get length of a format, also automatically expand variable name arguments again if they contain a #{.
2020-08-20 16:57:40 +00:00
} else if (modifiers & FORMAT_EXPANDTIME) {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_copy_state(&next, es, FORMAT_EXPAND_TIME);
new = format_expand1(&next, value);
Add T format modifier like E but also do strftime(3).
2019-03-14 21:31:43 +00:00
free(value);
value = new;
}
Add E: format to expand a format twice (useful to expand the value of an option).
2019-03-13 14:19:54 +00:00
Add s/foo/bar/: prefix for formats to substitute bar for foo.
2015-11-18 14:13:55 +00:00
/* Perform substitution if any. */
Allow multiple substitutions in a single format.
2019-11-25 15:02:48 +00:00
for (i = 0; i < nsub; i++) {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
left = format_expand1(es, sub[i]->argv[0]);
right = format_expand1(es, sub[i]->argv[1]);
Allow multiple substitutions in a single format.
2019-11-25 15:02:48 +00:00
new = format_sub(sub[i], value, left, right);
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "substitute '%s' to '%s': %s", left, right, new);
Add s/foo/bar/: prefix for formats to substitute bar for foo.
2015-11-18 14:13:55 +00:00
free(value);
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
value = new;
Expand arguments to C and s format modifiers (matches m which already expands).
2019-06-24 10:04:29 +00:00
free(right);
free(left);
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
}
Add length limit operator for formats.
2013-10-10 11:50:20 +00:00
/* Truncate the value if needed. */
Support negative trim values (#{=-10:pane_title}) to trim from the end, suggested by Kevin Brubeck Unhammer.
2016-01-31 09:54:46 +00:00
if (limit > 0) {
Extend the #[] style syntax and use that together with previous format changes to allow the status line to be entirely configured with a single option. Now that it is possible to configure their content, enable the existing code that lets the status line be multiple lines in height. The status option can now take a value of 2, 3, 4 or 5 (as well as the previous on or off) to configure more than one line. The new status-format array option configures the format of each line, the default just references the existing status-* options, although some of the more obscure status options may be eliminated in time. Additions to the #[] syntax are: "align" to specify alignment (left, centre, right), "list" for the window list and "range" to configure ranges of text for the mouse bindings. The "align" keyword can also be used to specify alignment of entries in tree mode and the pane status lines.
2019-03-18 20:53:33 +00:00
new = format_trim_left(value, limit);
Add a way to append or prepend to a format if the length has been limited.
2019-05-26 12:02:42 +00:00
if (marker != NULL && strcmp(new, value) != 0) {
free(value);
xasprintf(&value, "%s%s", new, marker);
} else {
free(value);
value = new;
}
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "applied length limit %d: %s", limit, value);
Support negative trim values (#{=-10:pane_title}) to trim from the end, suggested by Kevin Brubeck Unhammer.
2016-01-31 09:54:46 +00:00
} else if (limit < 0) {
Extend the #[] style syntax and use that together with previous format changes to allow the status line to be entirely configured with a single option. Now that it is possible to configure their content, enable the existing code that lets the status line be multiple lines in height. The status option can now take a value of 2, 3, 4 or 5 (as well as the previous on or off) to configure more than one line. The new status-format array option configures the format of each line, the default just references the existing status-* options, although some of the more obscure status options may be eliminated in time. Additions to the #[] syntax are: "align" to specify alignment (left, centre, right), "list" for the window list and "range" to configure ranges of text for the mouse bindings. The "align" keyword can also be used to specify alignment of entries in tree mode and the pane status lines.
2019-03-18 20:53:33 +00:00
new = format_trim_right(value, -limit);
Add a way to append or prepend to a format if the length has been limited.
2019-05-26 12:02:42 +00:00
if (marker != NULL && strcmp(new, value) != 0) {
free(value);
xasprintf(&value, "%s%s", marker, new);
} else {
free(value);
value = new;
}
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "applied length limit %d: %s", limit, value);
Add some UTF-8 utility functions and use them to prevent the width limit on formats from splitting UTF-8 characters improperly.
2014-04-17 15:37:55 +00:00
}
Add length limit operator for formats.
2013-10-10 11:50:20 +00:00
Add p format modifier for padding to width.
2019-11-25 15:04:15 +00:00
/* Pad the value if needed. */
if (width > 0) {
new = utf8_padcstr(value, width);
free(value);
value = new;
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "applied padding width %d: %s", width, value);
Add p format modifier for padding to width.
2019-11-25 15:04:15 +00:00
} else if (width < 0) {
new = utf8_rpadcstr(value, -width);
free(value);
value = new;
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "applied padding width %d: %s", width, value);
Add p format modifier for padding to width.
2019-11-25 15:04:15 +00:00
}
Change how escaping is processed for formats so that ## and # can be used in styles. Also add a 'w' format modifier for the width. From Chas J Owens IV in GitHub issue 2389.
2020-11-09 09:10:10 +00:00
/* Replace with the length or width if needed. */
Add n: modifier to get length of a format, also automatically expand variable name arguments again if they contain a #{.
2020-08-20 16:57:40 +00:00
if (modifiers & FORMAT_LENGTH) {
xasprintf(&new, "%zu", strlen(value));
free(value);
value = new;
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "replacing with length: %s", new);
Add n: modifier to get length of a format, also automatically expand variable name arguments again if they contain a #{.
2020-08-20 16:57:40 +00:00
}
Change how escaping is processed for formats so that ## and # can be used in styles. Also add a 'w' format modifier for the width. From Chas J Owens IV in GitHub issue 2389.
2020-11-09 09:10:10 +00:00
if (modifiers & FORMAT_WIDTH) {
xasprintf(&new, "%u", format_width(value));
free(value);
value = new;
format_log(es, "replacing with width: %s", new);
}
Add n: modifier to get length of a format, also automatically expand variable name arguments again if they contain a #{.
2020-08-20 16:57:40 +00:00
If foo doesn't exist and can't be expanded in #{?foo,a,b} then assume it is false.
2018-05-29 09:10:30 +00:00
/* Expand the buffer and copy in the value. */
Add s/foo/bar/: prefix for formats to substitute bar for foo.
2015-11-18 14:13:55 +00:00
valuelen = strlen(value);
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
while (*len - *off < valuelen + 1) {
Add xreallocarray and remove nmemb argument from xrealloc.
2014-10-08 17:35:58 +00:00
*buf = xreallocarray(*buf, 2, *len);
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
*len *= 2;
}
memcpy(*buf + *off, value, valuelen);
*off += valuelen;
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "replaced '%s' with '%s'", copy0, value);
Add s/foo/bar/: prefix for formats to substitute bar for foo.
2015-11-18 14:13:55 +00:00
free(value);
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
Allow multiple substitutions in a single format.
2019-11-25 15:02:48 +00:00
free(sub);
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
format_free_modifiers(list, count);
Add length limit operator for formats.
2013-10-10 11:50:20 +00:00
free(copy0);
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
return (0);
fail:
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "failed %s", copy0);
Allow multiple substitutions in a single format.
2019-11-25 15:02:48 +00:00
free(sub);
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
format_free_modifiers(list, count);
Add length limit operator for formats.
2013-10-10 11:50:20 +00:00
free(copy0);
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
return (-1);
}
/* Expand keys in a template. */
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
static char *
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_expand1(struct format_expand_state *es, const char *fmt)
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
{
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
struct format_tree *ft = es->ft;
char *buf, *out, *name;
const char *ptr, *s;
size_t off, len, n, outlen;
int ch, brackets;
char expanded[8192];
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
if (fmt == NULL || *fmt == '\0')
Add format_expand_time and use it instead of status_replace where command execution is not needed.
2015-02-06 17:11:39 +00:00
return (xstrdup(""));
Bump FORMAT_LOOOP_LIMIT and add a log message when hit, GitHub issue 2715.
2021-06-10 07:58:08 +00:00
if (es->loop == FORMAT_LOOP_LIMIT) {
format_log(es, "reached loop limit (%u)", FORMAT_LOOP_LIMIT);
Add a limit on how far format_expand can recurse.
2019-03-14 23:34:41 +00:00
return (xstrdup(""));
Bump FORMAT_LOOOP_LIMIT and add a log message when hit, GitHub issue 2715.
2021-06-10 07:58:08 +00:00
}
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
es->loop++;
Add a limit on how far format_expand can recurse.
2019-03-14 23:34:41 +00:00
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "expanding format: %s", fmt);
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
if ((es->flags & FORMAT_EXPAND_TIME) && strchr(fmt, '%') != NULL) {
if (es->time == 0) {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
es->time = time(NULL);
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
localtime_r(&es->time, &es->tm);
}
if (strftime(expanded, sizeof expanded, fmt, &es->tm) == 0) {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "format is too long");
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
return (xstrdup(""));
}
if (format_logging(ft) && strcmp(expanded, fmt) != 0)
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "after time expanded: %s", expanded);
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
fmt = expanded;
}
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
len = 64;
buf = xmalloc(len);
off = 0;
while (*fmt != '\0') {
if (*fmt != '#') {
while (len - off < 2) {
Add xreallocarray and remove nmemb argument from xrealloc.
2014-10-08 17:35:58 +00:00
buf = xreallocarray(buf, 2, len);
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
len *= 2;
}
buf[off++] = *fmt++;
continue;
}
fmt++;
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
ch = (u_char)*fmt++;
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
switch (ch) {
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
case '(':
brackets = 1;
for (ptr = fmt; *ptr != '\0'; ptr++) {
if (*ptr == '(')
brackets++;
if (*ptr == ')' && --brackets == 0)
break;
}
if (*ptr != ')' || brackets != 0)
break;
n = ptr - fmt;
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
name = xstrndup(fmt, n);
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "found #(): %s", name);
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
if ((ft->flags & FORMAT_NOJOBS) ||
(es->flags & FORMAT_EXPAND_NOJOBS)) {
Add simple comparisons in formats: #{==:a,b} and #{!=:a,b} ("a" and "b" are expanded so can compare formats). And expand the condition to #{?a,b,c} (the "a" part) if it doesn't work as a simple lookup. Also add FORMAT_NOJOBS flag to disable jobs in a format.
2017-01-09 21:03:25 +00:00
out = xstrdup("");
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "#() is disabled");
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
} else {
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
out = format_job_get(es, name);
format_log(es, "#() result: %s", out);
Do not leak memory when working out job name in formats.
2018-02-20 10:43:46 +00:00
}
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
free(name);
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
outlen = strlen(out);
Pass output from jobs through format_expand() so they are expanded again (this was the previous behaviour).
2015-10-25 08:59:26 +00:00
while (len - off < outlen + 1) {
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
buf = xreallocarray(buf, 2, len);
len *= 2;
}
Pass output from jobs through format_expand() so they are expanded again (this was the previous behaviour).
2015-10-25 08:59:26 +00:00
memcpy(buf + off, out, outlen);
off += outlen;
free(out);
Move the jobs output cache into the formats code so that #() work more generally (for example, again working in set-titles-string).
2015-05-27 13:28:04 +00:00
fmt += n + 1;
continue;
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
case '{':
Make format parsing build the modifiers into a list, standardize how arguments are given and allow multiple modifiers on a format (separated by ;).
2019-03-13 14:10:34 +00:00
ptr = format_skip((char *)fmt - 2, "}");
Allow escaping , and } with # in #{}; GitHub issue 1332.
2018-05-22 08:49:12 +00:00
if (ptr == NULL)
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
break;
n = ptr - fmt;
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "found #{}: %.*s", (int)n, fmt);
if (format_replace(es, fmt, n, &buf, &len, &off) != 0)
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
break;
fmt += n + 1;
continue;
Replace ## by # in format.
2013-11-24 11:29:09 +00:00
case '#':
Change how escaping is processed for formats so that ## and # can be used in styles. Also add a 'w' format modifier for the width. From Chas J Owens IV in GitHub issue 2389.
2020-11-09 09:10:10 +00:00
/*
* If ##[ (with two or more #s), then it is a style and
* can be left for format_draw to handle.
*/
ptr = fmt;
n = 2;
while (*ptr == '#') {
ptr++;
n++;
}
if (*ptr == '[') {
format_log(es, "found #*%zu[", n);
while (len - off < n + 2) {
buf = xreallocarray(buf, 2, len);
len *= 2;
}
memcpy(buf + off, fmt - 2, n + 1);
off += n + 1;
fmt = ptr + 1;
continue;
}
/* FALLTHROUGH */
case '}':
Allow escaping , and } with # in #{}; GitHub issue 1332.
2018-05-22 08:49:12 +00:00
case ',':
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "found #%c", ch);
Replace ## by # in format.
2013-11-24 11:29:09 +00:00
while (len - off < 2) {
Add xreallocarray and remove nmemb argument from xrealloc.
2014-10-08 17:35:58 +00:00
buf = xreallocarray(buf, 2, len);
Replace ## by # in format.
2013-11-24 11:29:09 +00:00
len *= 2;
}
Allow escaping , and } with # in #{}; GitHub issue 1332.
2018-05-22 08:49:12 +00:00
buf[off++] = ch;
Replace ## by # in format.
2013-11-24 11:29:09 +00:00
continue;
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
default:
Add host_short format, from Tiago Cunha.
2013-05-31 19:46:42 +00:00
s = NULL;
if (ch >= 'A' && ch <= 'Z')
s = format_upper[ch - 'A'];
else if (ch >= 'a' && ch <= 'z')
s = format_lower[ch - 'a'];
if (s == NULL) {
while (len - off < 3) {
Add xreallocarray and remove nmemb argument from xrealloc.
2014-10-08 17:35:58 +00:00
buf = xreallocarray(buf, 2, len);
Add host_short format, from Tiago Cunha.
2013-05-31 19:46:42 +00:00
len *= 2;
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
}
Add host_short format, from Tiago Cunha.
2013-05-31 19:46:42 +00:00
buf[off++] = '#';
buf[off++] = ch;
continue;
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
}
Add host_short format, from Tiago Cunha.
2013-05-31 19:46:42 +00:00
n = strlen(s);
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "found #%c: %s", ch, s);
if (format_replace(es, s, n, &buf, &len, &off) != 0)
Add host_short format, from Tiago Cunha.
2013-05-31 19:46:42 +00:00
break;
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
continue;
}
break;
}
buf[off] = '\0';
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
format_log(es, "result is: %s", buf);
es->loop--;
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
return (buf);
}
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
/* Expand keys in a template, passing through strftime first. */
char *
format_expand_time(struct format_tree *ft, const char *fmt)
{
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
struct format_expand_state es;
memset(&es, 0, sizeof es);
es.ft = ft;
es.flags = FORMAT_EXPAND_TIME;
return (format_expand1(&es, fmt));
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
}
/* Expand keys in a template. */
char *
format_expand(struct format_tree *ft, const char *fmt)
{
Add a state struct to store working state during format expansion instead of modiyfing the format tree. Use this to disable nested job expansion so that the result of #() is not expanded again. Reported by Chas J Owens IV, GitHub issue 2390.
2020-10-06 07:36:05 +00:00
struct format_expand_state es;
memset(&es, 0, sizeof es);
es.ft = ft;
es.flags = 0;
return (format_expand1(&es, fmt));
Add a -v flag to display-message to show verbose messages as the format is parsed, this gives the user a way to debug problems with formats rather than just being confronted with (for example) a blank status line.
2019-03-15 10:04:13 +00:00
}
Add a helper function for the most common format_create/defaults/expand pattern.
2017-03-08 13:36:12 +00:00
/* Expand a single string. */
char *
format_single(struct cmdq_item *item, const char *fmt, struct client *c,
struct session *s, struct winlink *wl, struct window_pane *wp)
{
struct format_tree *ft;
char *expanded;
Call format_defaults_window for panes as well.
2020-05-16 14:55:38 +00:00
ft = format_create_defaults(item, c, s, wl, wp);
Add a helper function for the most common format_create/defaults/expand pattern.
2017-03-08 13:36:12 +00:00
expanded = format_expand(ft, fmt);
format_free(ft);
return (expanded);
}
Call format_defaults_window for panes as well.
2020-05-16 14:55:38 +00:00
/* Expand a single string using state. */
char *
format_single_from_state(struct cmdq_item *item, const char *fmt,
struct client *c, struct cmd_find_state *fs)
{
return (format_single(item, fmt, c, fs->s, fs->wl, fs->wp));
}
Also move cmdq_item and cmdq_list into cmd-queue.c (this is to make its use more clearly defined and preparation for some future work).
2020-04-13 10:59:58 +00:00
/* Expand a single string using target. */
char *
Make client -c and -t handling common in cmd-queue.c and try to be clearer about whether the client is the target client (must have a session) or not.
2020-04-13 20:51:57 +00:00
format_single_from_target(struct cmdq_item *item, const char *fmt)
Also move cmdq_item and cmdq_list into cmd-queue.c (this is to make its use more clearly defined and preparation for some future work).
2020-04-13 10:59:58 +00:00
{
Call format_defaults_window for panes as well.
2020-05-16 14:55:38 +00:00
struct client *tc = cmdq_get_target_client(item);
Also move cmdq_item and cmdq_list into cmd-queue.c (this is to make its use more clearly defined and preparation for some future work).
2020-04-13 10:59:58 +00:00
Call format_defaults_window for panes as well.
2020-05-16 14:55:38 +00:00
return (format_single_from_state(item, fmt, tc, cmdq_get_target(item)));
}
/* Create and add defaults. */
struct format_tree *
format_create_defaults(struct cmdq_item *item, struct client *c,
struct session *s, struct winlink *wl, struct window_pane *wp)
{
struct format_tree *ft;
if (item != NULL)
ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0);
else
ft = format_create(NULL, item, FORMAT_NONE, 0);
format_defaults(ft, c, s, wl, wp);
return (ft);
}
/* Create and add defaults using state. */
struct format_tree *
format_create_from_state(struct cmdq_item *item, struct client *c,
struct cmd_find_state *fs)
{
return (format_create_defaults(item, c, fs->s, fs->wl, fs->wp));
}
/* Create and add defaults using target. */
struct format_tree *
format_create_from_target(struct cmdq_item *item)
{
struct client *tc = cmdq_get_target_client(item);
return (format_create_from_state(item, tc, cmdq_get_target(item)));
Also move cmdq_item and cmdq_list into cmd-queue.c (this is to make its use more clearly defined and preparation for some future work).
2020-04-13 10:59:58 +00:00
}
Wrap all the individual format_* calls in a single format_defaults functions.
2015-02-05 10:29:43 +00:00
/* Set defaults for any of arguments that are not NULL. */
void
format_defaults(struct format_tree *ft, struct client *c, struct session *s,
struct winlink *wl, struct window_pane *wp)
{
Add formats for top paste buffer by default. Also a tmux.1 fix from jmc.
2020-03-28 09:39:27 +00:00
struct paste_buffer *pb;
Expand command formats in %if and move the config file loading later (to when the first client has identified) so all the client formats are available, fixes problems reported by Thomas Sattler.
2019-06-20 06:51:36 +00:00
if (c != NULL && c->name != NULL)
Expand session and window formats for buffer filters.
2019-03-28 21:05:15 +00:00
log_debug("%s: c=%s", __func__, c->name);
else
Expand command formats in %if and move the config file loading later (to when the first client has identified) so all the client formats are available, fixes problems reported by Thomas Sattler.
2019-06-20 06:51:36 +00:00
log_debug("%s: c=none", __func__);
Expand session and window formats for buffer filters.
2019-03-28 21:05:15 +00:00
if (s != NULL)
log_debug("%s: s=$%u", __func__, s->id);
else
log_debug("%s: s=none", __func__);
if (wl != NULL)
Call format_defaults_window for panes as well.
2020-05-16 14:55:38 +00:00
log_debug("%s: wl=%u", __func__, wl->idx);
Expand session and window formats for buffer filters.
2019-03-28 21:05:15 +00:00
else
log_debug("%s: wl=none", __func__);
if (wp != NULL)
log_debug("%s: wp=%%%u", __func__, wp->id);
else
log_debug("%s: wp=none", __func__);
Change how display-message uses the client. Originally it was only intended as the target client where the message should be displayed but at some point (perhaps when -p was added), it was used for format expansion too. This means it can get a bit weird where you have client formats expanding for a client with a different current session than the target session. However, it is nice that display-message can be used to show information about a specific client. So change so that the -c client will be used if the session matches the target session (-t or default), otherwise the best client will be chosen.
2018-04-18 14:35:37 +00:00
if (c != NULL && s != NULL && c->session != s)
log_debug("%s: session does not match", __func__);
Check session, window, pane in the right order when working out format type.
2021-02-26 21:53:41 +00:00
if (wp != NULL)
ft->type = FORMAT_TYPE_PANE;
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
else if (wl != NULL)
ft->type = FORMAT_TYPE_WINDOW;
Check session, window, pane in the right order when working out format type.
2021-02-26 21:53:41 +00:00
else if (s != NULL)
ft->type = FORMAT_TYPE_SESSION;
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
else
ft->type = FORMAT_TYPE_UNKNOWN;
Add -F to choose-tree, choose-client, choose-buffer to specify the format of each line, as well as adding a couple of formats needed for the default display.
2017-08-09 11:43:45 +00:00
Wrap all the individual format_* calls in a single format_defaults functions.
2015-02-05 10:29:43 +00:00
if (s == NULL && c != NULL)
s = c->session;
if (wl == NULL && s != NULL)
wl = s->curw;
if (wp == NULL && wl != NULL)
wp = wl->window->active;
if (c != NULL)
format_defaults_client(ft, c);
if (s != NULL)
format_defaults_session(ft, s);
Now that struct winlink has a session pointer, can remove some arguments.
2017-04-20 09:43:45 +00:00
if (wl != NULL)
format_defaults_winlink(ft, wl);
Wrap all the individual format_* calls in a single format_defaults functions.
2015-02-05 10:29:43 +00:00
if (wp != NULL)
format_defaults_pane(ft, wp);
Add formats for top paste buffer by default. Also a tmux.1 fix from jmc.
2020-03-28 09:39:27 +00:00
Remove stray spaces after function names.
2021-08-20 17:50:42 +00:00
pb = paste_get_top(NULL);
Add formats for top paste buffer by default. Also a tmux.1 fix from jmc.
2020-03-28 09:39:27 +00:00
if (pb != NULL)
format_defaults_paste_buffer(ft, pb);
Wrap all the individual format_* calls in a single format_defaults functions.
2015-02-05 10:29:43 +00:00
}
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
/* Set default format keys for a session. */
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static void
Wrap all the individual format_* calls in a single format_defaults functions.
2015-02-05 10:29:43 +00:00
format_defaults_session(struct format_tree *ft, struct session *s)
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
{
Permit option values to be used in formats.
2014-12-02 23:19:45 +00:00
ft->s = s;
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
}
Add client formats, from Ben Boeckel.
2011-10-23 01:12:46 +00:00
/* Set default format keys for a client. */
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static void
Wrap all the individual format_* calls in a single format_defaults functions.
2015-02-05 10:29:43 +00:00
format_defaults_client(struct format_tree *ft, struct client *c)
Add client formats, from Ben Boeckel.
2011-10-23 01:12:46 +00:00
{
Permit option values to be used in formats.
2014-12-02 23:19:45 +00:00
if (ft->s == NULL)
ft->s = c->session;
Support for windows larger than visible on the attached client. This has been a limitation for a long time. There are two new options, window-size and default-size, and a new command, resize-window. The force-width and force-height options and the session_width and session_height formats have been removed. The new window-size option tells tmux how to work out the size of windows: largest means it picks the size of the largest session, smallest the smallest session (similar to the old behaviour) and manual means that it does not automatically resize windows. The default is currently largest but this may change. aggressive-resize modifies the choice of session for largest and smallest as it did before. If a window is in a session attached to a client that is too small, only part of the window is shown. tmux attempts to keep the cursor visible, so the part of the window displayed is changed as the cursor moves (with a small delay, to try and avoid excess redrawing when applications redraw status lines or similar that are not currently visible). The offset of the visible portion of the window is shown in status-right. Drawing windows which are larger than the client is not as efficient as those which fit, particularly when the cursor moves, so it is recommended to avoid using this on slow machines or networks (set window-size to smallest or manual). The resize-window command can be used to resize a window manually. If it is used, the window-size option is automatically set to manual for the window (undo this with "setw -u window-size"). resize-window works in a similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and -A flags. -a sets the window to the size of the smallest client (what it would be if window-size was smallest) and -A the largest. For the same behaviour as force-width or force-height, use resize-window -x or -y, and "setw -u window-size" to revert to automatic sizing.. If the global window-size option is set to manual, the default-size option is used for new windows. If -x or -y is used with new-session, that sets the default-size option for the new session. The maximum size of a window is 10000x10000. But expect applications to complain and much higher memory use if making a window excessively big. The minimum size is the size required for the current layout including borders. The refresh-client command can be used to pan around a window, -U -D -L -R moves up, down, left or right and -c returns to automatic cursor tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
ft->c = c;
Add client formats, from Ben Boeckel.
2011-10-23 01:12:46 +00:00
}
First period not last for host_short, from Michael Scholz.
2013-10-10 12:04:01 +00:00
/* Set default format keys for a window. */
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
void
Wrap all the individual format_* calls in a single format_defaults functions.
2015-02-05 10:29:43 +00:00
format_defaults_window(struct format_tree *ft, struct window *w)
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
{
Permit option values to be used in formats.
2014-12-02 23:19:45 +00:00
ft->w = w;
First period not last for host_short, from Michael Scholz.
2013-10-10 12:04:01 +00:00
}
/* Set default format keys for a winlink. */
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static void
Now that struct winlink has a session pointer, can remove some arguments.
2017-04-20 09:43:45 +00:00
format_defaults_winlink(struct format_tree *ft, struct winlink *wl)
First period not last for host_short, from Michael Scholz.
2013-10-10 12:04:01 +00:00
{
Permit option values to be used in formats.
2014-12-02 23:19:45 +00:00
if (ft->w == NULL)
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
format_defaults_window(ft, wl->window);
Add some formats to look at the session window stack, suggested by Scott ROCHFORD.
2017-05-05 11:59:47 +00:00
ft->wl = wl;
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
}
/* Set default format keys for a window pane. */
void
Wrap all the individual format_* calls in a single format_defaults functions.
2015-02-05 10:29:43 +00:00
format_defaults_pane(struct format_tree *ft, struct window_pane *wp)
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
{
Allow multiple modes to be open in a pane. A stack of open modes is kept and the previous restored when the top is exited. If a mode that is already on the stack is entered, the existing instance is moved to the top as the active mode rather than being opened new.
2019-03-12 11:16:49 +00:00
struct window_mode_entry *wme;
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
Permit option values to be used in formats.
2014-12-02 23:19:45 +00:00
if (ft->w == NULL)
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
format_defaults_window(ft, wp->window);
Allow formats to be specified as functions (in the code) so they are only evaluated on demand rather than each time a format tree is constructed. Use this for expensive formats like pane_current_command.
2015-08-28 16:46:40 +00:00
ft->wp = wp;
Permit option values to be used in formats.
2014-12-02 23:19:45 +00:00
Allow multiple modes to be open in a pane. A stack of open modes is kept and the previous restored when the top is exited. If a mode that is already on the stack is entered, the existing instance is moved to the top as the active mode rather than being opened new.
2019-03-12 11:16:49 +00:00
wme = TAILQ_FIRST(&wp->modes);
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
if (wme != NULL && wme->mode->formats != NULL)
wme->mode->formats(wme, ft);
Add initial framework for more powerful formatting of command output and use it for list-{panes,windows,sessions}. This allows more descriptive replacements (such as #{session_name}) and conditionals. Later this will be used for status_replace and list-keys and other places.
2011-08-26 10:53:16 +00:00
}
Switch all of the various choose- and list- commands over to the format infrastructure, from Thomas Adam.
2012-05-22 11:35:37 +00:00
Add pane_tabs format to format_window_pane based on code from George Nachman.
2013-03-24 09:29:40 +00:00
/* Set default format keys for paste buffer. */
Switch all of the various choose- and list- commands over to the format infrastructure, from Thomas Adam.
2012-05-22 11:35:37 +00:00
void
Nuke the utf8 and status-utf8 options and make tmux only a UTF-8 terminal. We still support non-UTF-8 terminals outside tmux, but inside it is always UTF-8 (as when the utf8 and status-utf8 options were on).
2015-11-12 11:09:11 +00:00
format_defaults_paste_buffer(struct format_tree *ft, struct paste_buffer *pb)
Switch all of the various choose- and list- commands over to the format infrastructure, from Thomas Adam.
2012-05-22 11:35:37 +00:00
{
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
ft->pb = pb;
}
/* Return word at given coordinates. Caller frees. */
char *
format_grid_word(struct grid *gd, u_int x, u_int y)
{
const struct grid_line *gl;
struct grid_cell gc;
const char *ws;
struct utf8_data *ud = NULL;
u_int end;
size_t size = 0;
int found = 0;
char *s = NULL;
Add -F to choose-tree, choose-client, choose-buffer to specify the format of each line, as well as adding a couple of formats needed for the default display.
2017-08-09 11:43:45 +00:00
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
ws = options_get_string(global_s_options, "word-separators");
Switch all of the various choose- and list- commands over to the format infrastructure, from Thomas Adam.
2012-05-22 11:35:37 +00:00
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
for (;;) {
grid_get_cell(gd, x, y, &gc);
if (gc.flags & GRID_FLAG_PADDING)
break;
Fix mouse_word format now word-separators has no space and position of menu if too close to the bottom.
2021-07-08 11:14:53 +00:00
if (utf8_cstrhas(ws, &gc.data) ||
(gc.data.size == 1 && *gc.data.data == ' ')) {
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
found = 1;
break;
}
Switch all of the various choose- and list- commands over to the format infrastructure, from Thomas Adam.
2012-05-22 11:35:37 +00:00
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
if (x == 0) {
if (y == 0)
break;
gl = grid_peek_line(gd, y - 1);
if (~gl->flags & GRID_LINE_WRAPPED)
break;
y--;
x = grid_line_length(gd, y);
if (x == 0)
break;
}
x--;
}
for (;;) {
if (found) {
end = grid_line_length(gd, y);
if (end == 0 || x == end - 1) {
if (y == gd->hsize + gd->sy - 1)
break;
gl = grid_peek_line(gd, y);
if (~gl->flags & GRID_LINE_WRAPPED)
break;
y++;
x = 0;
} else
x++;
}
found = 1;
grid_get_cell(gd, x, y, &gc);
if (gc.flags & GRID_FLAG_PADDING)
break;
Fix mouse_word format now word-separators has no space and position of menu if too close to the bottom.
2021-07-08 11:14:53 +00:00
if (utf8_cstrhas(ws, &gc.data) ||
(gc.data.size == 1 && *gc.data.data == ' '))
There are many format variables now so allocating all the default ones each time a tree is created is too expensive. Instead, convert them all into callbacks and put them in a static table so they only allocate on demand. The tree remains for the moment for extra (non-default) variables added by for example copy mode or popups. Also reduce expensive calls to localtime_r/strftime. GitHub issue 2253.
2021-02-22 07:09:06 +00:00
break;
ud = xreallocarray(ud, size + 2, sizeof *ud);
memcpy(&ud[size++], &gc.data, sizeof *ud);
}
if (size != 0) {
ud[size].size = 0;
s = utf8_tocstr(ud);
free(ud);
}
return (s);
}
/* Return line at given coordinates. Caller frees. */
char *
format_grid_line(struct grid *gd, u_int y)
{
struct grid_cell gc;
struct utf8_data *ud = NULL;
u_int x;
size_t size = 0;
char *s = NULL;
for (x = 0; x < grid_line_length(gd, y); x++) {
grid_get_cell(gd, x, y, &gc);
if (gc.flags & GRID_FLAG_PADDING)
break;
ud = xreallocarray(ud, size + 2, sizeof *ud);
memcpy(&ud[size++], &gc.data, sizeof *ud);
}
if (size != 0) {
ud[size].size = 0;
s = utf8_tocstr(ud);
free(ud);
}
return (s);
Switch all of the various choose- and list- commands over to the format infrastructure, from Thomas Adam.
2012-05-22 11:35:37 +00:00
}