tmux/format.c at master · tmux/tmux

History

5898 lines (5274 loc) · 127 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

/* $OpenBSD$ */

* Permission to use, copy, modify, and distribute this software for any

* purpose with or without fee is hereby granted, provided that the above

* copyright notice and this permission notice appear in all copies.

* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR

* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

* WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER

* IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING

* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

#include <sys/types.h>

#include <sys/wait.h>

#include <ctype.h>

#include <errno.h>

#include <fnmatch.h>

#include <libgen.h>

#include <math.h>

#include <pwd.h>

#include <regex.h>

#include <stdarg.h>

#include <stdlib.h>

#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.

struct format_expand_state;

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 *);

static void format_defaults_session(struct format_tree *,

struct session *);

static void format_defaults_client(struct format_tree *, struct client *);

static void format_defaults_winlink(struct format_tree *,

struct winlink *);

/* Entry in format job tree. */

struct format_job {

struct client *client;

u_int tag;

const char *cmd;

const char *expanded;

time_t last;

char *out;

int updated;

struct job *job;

int status;

RB_ENTRY(format_job) entry;

};

/* Format job tree. */

static int format_job_cmp(struct format_job *, struct format_job *);

static RB_HEAD(format_job_tree, format_job) format_jobs = RB_INITIALIZER();

RB_GENERATE_STATIC(format_job_tree, format_job, entry, format_job_cmp);

/* Format job tree comparison function. */

static int

format_job_cmp(struct format_job *fj1, struct format_job *fj2)

{

if (fj1->tag < fj2->tag)

return (-1);

if (fj1->tag > fj2->tag)

return (1);

return (strcmp(fj1->cmd, fj2->cmd));

}

/* Format modifiers. */

#define FORMAT_TIMESTRING 0x1

#define FORMAT_BASENAME 0x2

#define FORMAT_DIRNAME 0x4

#define FORMAT_QUOTE_SHELL 0x8

#define FORMAT_LITERAL 0x10

#define FORMAT_EXPAND 0x20

#define FORMAT_EXPANDTIME 0x40

#define FORMAT_SESSIONS 0x80

#define FORMAT_WINDOWS 0x100

#define FORMAT_PANES 0x200

#define FORMAT_PRETTY 0x400

#define FORMAT_LENGTH 0x800

#define FORMAT_WIDTH 0x1000

#define FORMAT_QUOTE_STYLE 0x2000

#define FORMAT_WINDOW_NAME 0x4000

#define FORMAT_SESSION_NAME 0x8000

#define FORMAT_CHARACTER 0x10000

#define FORMAT_COLOUR 0x20000

#define FORMAT_CLIENTS 0x40000

#define FORMAT_NOT 0x80000

#define FORMAT_NOT_NOT 0x100000

#define FORMAT_REPEAT 0x200000

/* Limit on recursion. */

#define FORMAT_LOOP_LIMIT 100

/* Format expand flags. */

#define FORMAT_EXPAND_TIME 0x1

#define FORMAT_EXPAND_NOJOBS 0x2

/* Entry in format tree. */

struct format_entry {

char *key;

char *value;

time_t time;

format_cb cb;

RB_ENTRY(format_entry) entry;

};

/* Format type. */

enum format_type {

FORMAT_TYPE_UNKNOWN,

FORMAT_TYPE_SESSION,

FORMAT_TYPE_WINDOW,

FORMAT_TYPE_PANE

};

static struct sort_criteria sort_crit;

struct format_tree {

enum format_type type;

struct client *c;

struct session *s;

struct winlink *wl;

struct window *w;

struct window_pane *wp;

struct paste_buffer *pb;

struct cmdq_item *item;

struct client *client;

int flags;

u_int tag;

struct mouse_event m;

RB_HEAD(format_entry_tree, format_entry) tree;

};

static int format_entry_cmp(struct format_entry *, struct format_entry *);

RB_GENERATE_STATIC(format_entry_tree, format_entry, entry, format_entry_cmp);

/* Format expand state. */

struct format_expand_state {

struct format_tree *ft;

u_int loop;

time_t time;

struct tm tm;

int flags;

};

/* Format modifier. */

struct format_modifier {

char modifier[3];

u_int size;

char **argv;

int argc;

};

/* Format entry tree comparison function. */

static int

format_entry_cmp(struct format_entry *fe1, struct format_entry *fe2)

{

return (strcmp(fe1->key, fe2->key));

}

/* Single-character uppercase aliases. */

static const char *format_upper[] = {

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, 802E /* U */

NULL, /* V */

"window_name", /* W */

NULL, /* X */

NULL, /* Y */

NULL /* Z */

};

/* Single-character lowercase aliases. */

static const char *format_lower[] = {

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 */

};

/* 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)

format_log1(struct format_expand_state *es, const char *from, const char *fmt,

...)

{

struct format_tree *ft = es->ft;

va_list ap;

char *s;

static const char spaces[] = " ";

if (!format_logging(ft))

return;

va_start(ap, fmt);

xvasprintf(&s, fmt, ap);

va_end(ap);

log_debug("%s: %s", from, s);

if (ft->item != NULL && (ft->flags & FORMAT_VERBOSE))

cmdq_print(ft->item, "#%.*s%s", es->loop, spaces, s);

free(s);

}

#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;

memcpy(&to->tm, &from->tm, sizeof to->tm);

to->flags = from->flags|flags;

}

/* Format job update callback. */

static void

format_job_update(struct job *job)

{

struct format_job *fj = job_get_data(job);

struct evbuffer *evb = job_get_event(job)->input;

char *line = NULL, *next;

time_t t;

while ((next = evbuffer_readline(evb)) != NULL) {

free(line);

line = next;

}

if (line == NULL)

return;

fj->updated = 1;

free(fj->out);

fj->out = line;

log_debug("%s: %p %s: %s", __func__, fj, fj->cmd, fj->out);

t = time(NULL);

if (fj->status && fj->last != t) {

if (fj->client != NULL)

server_status_client(fj->client);

fj->last = t;

}

/* Format job complete callback. */

static void

format_job_complete(struct job *job)

{

struct format_job *fj = job_get_data(job);

struct evbuffer *evb = job_get_event(job)->input;

char *line, *buf;

size_t len;

fj->job = NULL;

buf = NULL;

if ((line = evbuffer_readline(evb)) == NULL) {

len = EVBUFFER_LENGTH(evb);

buf = xmalloc(len + 1);

if (len != 0)

memcpy(buf, EVBUFFER_DATA(evb), len);

buf[len] = '\0';

} else

buf = line;

log_debug("%s: %p %s: %s", __func__, fj, fj->cmd, buf);

if (*buf != '\0' || !fj->updated) {

free(fj->out);

fj->out = buf;

} else

free(buf);

if (fj->status) {

if (fj->client != NULL)

server_status_client(fj->client);

fj->status = 0;

}

/* Find a job. */

static char *

format_job_get(struct format_expand_state *es, const char *cmd)

{

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;

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);

}

fj0.tag = ft->tag;

fj0.cmd = cmd;

if ((fj = RB_FIND(format_job_tree, jobs, &fj0)) == NULL) {

fj = xcalloc(1, sizeof *fj);

fj->client = ft->client;

fj->tag = ft->tag;

fj->cmd = xstrdup(cmd);

RB_INSERT(format_job_tree, jobs, fj);

}

format_copy_state(&next, es, FORMAT_EXPAND_NOJOBS);

next.flags &= ~FORMAT_EXPAND_TIME;

expanded = format_expand1(&next, cmd);

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);

t = time(NULL);

if (force && fj->job != NULL)

job_free(fj->job);

if (force || (fj->job == NULL && fj->last != t)) {

fj->job = job_run(expanded, 0, NULL, NULL, NULL,

server_client_get_cwd(ft->client, NULL), format_job_update,

format_job_complete, NULL, fj, JOB_NOWAIT, -1, -1);

if (fj->job == NULL) {

free(fj->out);

xasprintf(&fj->out, "<'%s' didn't start>", fj->cmd);

}

fj->last = t;

fj->updated = 0;

} else if (fj->job != NULL && (t - fj->last) > 1 && fj->out == NULL)

xasprintf(&fj->out, "<'%s' not ready>", fj->cmd);

free(expanded);

if (ft->flags & FORMAT_STATUS)

fj->status = 1;

if (fj->out == NULL)

return (xstrdup(""));

return (format_expand1(&next, fj->out));

}

/* Remove old jobs. */

static void

format_job_tidy(struct format_job_tree *jobs, int force)

{

struct format_job *fj, *fj1;

time_t now;

now = time(NULL);

RB_FOREACH_SAFE(fj, format_job_tree, jobs, fj1) {

if (!force && (fj->last > now || now - fj->last < 3600))

continue;

RB_REMOVE(format_job_tree, jobs, fj);

log_debug("%s: %s", __func__, fj->cmd);

if (fj->job != NULL)

job_free(fj->job);

free((void *)fj->expanded);

free((void *)fj->cmd);

free(fj->out);

free(fj);

}

/* Work around needless -Wformat-nonliteral gcc warning. */

#ifdef __GNUC__

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wformat-nonliteral"

#endif

static size_t

format_strftime(char *s, size_t max, const char *fmt, const struct tm *tm)

{

return (strftime(s, max, fmt, tm));

}

#ifdef __GNUC__

#pragma GCC diagnostic pop

#endif

/* Tidy old jobs for all clients. */

void

format_tidy_jobs(void)

{

struct client *c;

format_job_tidy(&format_jobs, 0);

TAILQ_FOREACH(c, &clients, entry) {

if (c->jobs != NULL)

format_job_tidy(c->jobs, 0);

}

/* 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);

}

/* 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);

}

/* Callback for host. */

static void *

format_cb_host(__unused struct format_tree *ft)

{

char host[HOST_NAME_MAX + 1];

if (gethostname(host, sizeof host) != 0)

return (xstrdup(""));

return (xstrdup(host));

}

/* Callback for host_short. */

static void *

format_cb_host_short(__unused struct format_tree *ft)

{

char host[HOST_NAME_MAX + 1], *cp;

if (gethostname(host, sizeof host) != 0)

return (xstrdup(""));

if ((cp = strchr(host, '.')) != NULL)

*cp = '\0';

return (xstrdup(host));

}

/* Callback for pid. */

static void *

format_cb_pid(__unused struct format_tree *ft)

{

char *value;

xasprintf(&value, "%ld", (long)getpid());

return (value);

}

/* Callback for session_attached_list. */

static void *

format_cb_session_attached_list(struct format_tree *ft)

{

struct session *s = ft->s;

struct client *loop;

struct evbuffer *buffer;

int size;

char *value = NULL;

if (s == NULL)

return (NULL);

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)

xasprintf(&value, "%.*s", size, EVBUFFER_DATA(buffer));

evbuffer_free(buffer);

return (value);

}

/* Callback for session_alert. */

static void *

format_cb_session_alert(struct format_tree *ft)

{

struct session *s = ft->s;

struct winlink *wl;

char alerts[1024];

int alerted = 0;

if (s == NULL)

return (NULL);

*alerts = '\0';

RB_FOREACH(wl, winlinks, &s->windows) {

if ((wl->flags & WINLINK_ALERTFLAGS) == 0)

continue;

if (~alerted & wl->flags & WINLINK_ACTIVITY) {

strlcat(alerts, "#", sizeof alerts);

alerted |= WINLINK_ACTIVITY;

}

if (~alerted & wl->flags & WINLINK_BELL) {

strlcat(alerts, "!", sizeof alerts);

alerted |= WINLINK_BELL;

}

if (~alerted & wl->flags & WINLINK_SILENCE) {

strlcat(alerts, "~", sizeof alerts);

alerted |= WINLINK_SILENCE;

}

return (xstrdup(alerts));

}

/* Callback for session_alerts. */

static void *

format_cb_session_alerts(struct format_tree *ft)

{

struct session *s = ft->s;

struct winlink *wl;

char alerts[1024], tmp[16];

if (s == NULL)

return (NULL);

*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);

}

return (xstrdup(alerts));

}

/* Callback for session_stack. */

static void *

format_cb_session_stack(struct format_tree *ft)

{

struct session *s = ft->s;

struct winlink *wl;

char result[1024], tmp[16];

if (s == NULL)

return (NULL);

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);

}

return (xstrdup(result));

}

/* Callback for window_stack_index. */

static void *

format_cb_window_stack_index(struct format_tree *ft)

{

struct session *s;

struct winlink *wl;

u_int idx;

char *value = NULL;

if (ft->wl == NULL)

return (NULL);

s = ft->wl->session;

idx = 0;

TAILQ_FOREACH(wl, &s->lastw, sentry) {

idx++;

if (wl == ft->wl)

break;

}

if (wl == NULL)

return (xstrdup("0"));

xasprintf(&value, "%u", idx);

return (value);

}

/* Callback for window_linked_sessions_list. */

static void *

format_cb_window_linked_sessions_list(struct format_tree *ft)

{

struct window *w;

struct winlink *wl;

struct evbuffer *buffer;

int size;

char *value = NULL;

if (ft->wl == NULL)

return (NULL);

w = ft->wl->window;

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)

xasprintf(&value, "%.*s", size, EVBUFFER_DATA(buffer));

evbuffer_free(buffer);

return (value);

}

/* Callback for window_active_sessions. */

static void *

format_cb_window_active_sessions(struct format_tree *ft)

{

struct window *w;

struct winlink *wl;

u_int n = 0;

char *value;

if (ft->wl == NULL)

return (NULL);

w = ft->wl->window;

TAILQ_FOREACH(wl, &w->winlinks, wentry) {

if (wl->session->curw == wl)

n++;

}

xasprintf(&value, "%u", n);

return (value);

}

/* Callback for window_active_sessions_list. */

static void *

format_cb_window_active_sessions_list(struct format_tree *ft)

{

struct window *w;

struct winlink *wl;

struct evbuffer *buffer;

int size;

char *value = NULL;

if (ft->wl == NULL)

return (NULL);

w = ft->wl->window;

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)

xasprintf(&value, "%.*s", size, EVBUFFER_DATA(buffer));

evbuffer_free(buffer);

return (value);

}

/* Callback for window_active_clients. */

static void *

format_cb_window_active_clients(struct format_tree *ft)

{

struct window *w;

struct client *loop;

struct session *client_session;

u_int n = 0;

char *value;

if (ft->wl == NULL)

return (NULL);

w = ft->wl->window;

TAILQ_FOREACH(loop, &clients, entry) {

client_session = loop->session;

if (client_session == NULL)

continue;

if (w == client_session->curw->window)

n++;

}

xasprintf(&value, "%u", n);

return (value);

}

/* Callback for window_active_clients_list. */

static void *

format_cb_window_active_clients_list(struct format_tree *ft)

{

struct window *w;

struct client *loop;

struct session *client_session;

struct evbuffer *buffer;

int size;

char *value = NULL;

if (ft->wl == NULL)

return (NULL);

w = ft->wl->window;

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)

xasprintf(&value, "%.*s", size, EVBUFFER_DATA(buffer));

evbuffer_free(buffer);

return (value);

}

/* Callback for window_layout. */

static void *

format_cb_window_layout(struct format_tree *ft)

{

struct window *w = ft->w;

if (w == NULL)

return (NULL);

if (w->saved_layout_root != NULL)

return (layout_dump(w->saved_layout_root));

return (layout_dump(w->layout_root));

}

/* Callback for window_visible_layout. */

static void *

format_cb_window_visible_layout(struct format_tree *ft)

{

struct window *w = ft->w;

if (w == NULL)

return (NULL);

return (layout_dump(w->layout_root));

}

/* Callback for pane_start_command. */

static void *

format_cb_start_command(struct format_tree *ft)

{

struct window_pane *wp = ft->wp;

if (wp == NULL)

return (NULL);

return (cmd_stringify_argv(wp->argc, wp->argv));

}

/* Callback for pane_start_path. */

static void *

format_cb_start_path(struct format_tree *ft)

{

struct window_pane *wp = ft->wp;

if (wp == NULL)

return (NULL);

if (wp->cwd == NULL)

return (xstrdup(""));

return (xstrdup(wp->cwd));

}

/* Callback for pane_current_command. */

static void *

format_cb_current_command(struct format_tree *ft)

{

struct window_pane *wp = ft->wp;

char *cmd, *value;

if (wp == NULL || wp->shell == NULL)

return (NULL);

cmd = osdep_get_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);

}

value = parse_window_name(cmd);

free(cmd);

return (value);

}

/* Callback for pane_current_path. */

static void *

format_cb_current_path(struct format_tree *ft)

{

struct window_pane *wp = ft->wp;

char *cwd;

if (wp == NULL)

return (NULL);

cwd = osdep_get_cwd(wp->fd);

if (cwd == NULL)

return (NULL);

return (xstrdup(cwd));

}

/* Callback for history_bytes. */

static void *

format_cb_history_bytes(struct format_tree *ft)

{

struct window_pane *wp = ft->wp;

struct grid *gd;

struct grid_line *gl;

size_t size = 0;

u_int i;

char *value;

if (wp == NULL)

return (NULL);

gd = wp->base.grid;

for (i = 0; i < gd->hsize + gd->sy; i++) {

gl = grid_get_line(gd, i);

size += gl->cellsize * sizeof *gl->celldata;

size += gl->extdsize * sizeof *gl->extddata;

}

size += (gd->hsize + gd->sy) * sizeof *gl;

xasprintf(&value, "%zu", size);

return (value);

}

/* Callback for history_all_bytes. */

static void *

format_cb_history_all_bytes(struct format_tree *ft)

{

struct window_pane *wp = ft->wp;

struct grid *gd;

struct grid_line *gl;

u_int i, lines, cells = 0, extended_cells = 0;

char *value;

if (wp == NULL)

return (NULL);

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;

}

xasprintf(&value, "%u,%zu,%u,%zu,%u,%zu", lines,

lines * sizeof *gl, cells, cells * sizeof *gl->celldata,

extended_cells, extended_cells * sizeof *gl->extddata);

return (value);

}

/* Callback for pane_tabs. */

static void *

format_cb_pane_tabs(struct format_tree *ft)

{

struct window_pane *wp = ft->wp;

struct evbuffer *buffer;

u_int i;

int size;

char *value = NULL;

if (wp == NULL)

return (NULL);

buffer = evbuffer_new();

if (buffer == NULL)

fatalx("out of memory");

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);

}

if ((size = EVBUFFER_LENGTH(buffer)) != 0)

xasprintf(&value, "%.*s", size, EVBUFFER_DATA(buffer));

evbuffer_free(buffer);

return (value);

}

/* Callback for pane_fg. */

static void *

format_cb_pane_fg(struct format_tree *ft)

{

struct window_pane *wp = ft->wp;

struct grid_cell gc;

if (wp == NULL)

View remainder of file in raw view

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Uh oh!

FilesExpand file tree

format.c

Latest commit

History

format.c

File metadata and controls