/* $OpenBSD$ */

/*

* Copyright (c) 2011 Nicholas Marriott <nicholas.marriott@gmail.com>

*

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

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

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

*

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

* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

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

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

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

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

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

*/

#include <sys/types.h>

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

}

/* Maimum pad and trim width. */

#define FORMAT_MAX_WIDTH 10000

/* Maimum repeat size. */

#define FORMAT_MAX_REPEAT 10000

/* Maimum precision. */

#define FORMAT_MAX_PRECISION 100

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

return (layout_dump(w, 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, 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);

}