Annotation of src/usr.bin/tmux/cmd-queue.c, Revision 1.37
1.37 ! nicm 1: /* $OpenBSD: cmd-queue.c,v 1.36 2016/04/29 14:05:24 nicm Exp $ */
1.1 nicm 2:
3: /*
1.34 nicm 4: * Copyright (c) 2013 Nicholas Marriott <nicholas.marriott@gmail.com>
1.1 nicm 5: *
6: * Permission to use, copy, modify, and distribute this software for any
7: * purpose with or without fee is hereby granted, provided that the above
8: * copyright notice and this permission notice appear in all copies.
9: *
10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14: * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
15: * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
16: * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17: */
18:
19: #include <sys/types.h>
20:
21: #include <ctype.h>
22: #include <stdlib.h>
1.23 nicm 23: #include <string.h>
1.7 nicm 24: #include <time.h>
1.1 nicm 25:
26: #include "tmux.h"
27:
1.31 nicm 28: static enum cmd_retval cmdq_continue_one(struct cmd_q *);
1.24 nicm 29:
1.1 nicm 30: /* Create new command queue. */
31: struct cmd_q *
32: cmdq_new(struct client *c)
33: {
34: struct cmd_q *cmdq;
35:
36: cmdq = xcalloc(1, sizeof *cmdq);
37: cmdq->references = 1;
1.25 nicm 38: cmdq->flags = 0;
1.1 nicm 39:
40: cmdq->client = c;
1.11 nicm 41: cmdq->client_exit = -1;
1.1 nicm 42:
43: TAILQ_INIT(&cmdq->queue);
44: cmdq->item = NULL;
45: cmdq->cmd = NULL;
46:
1.33 nicm 47: cmd_find_clear_state(&cmdq->current, NULL, 0);
48: cmdq->parent = NULL;
49:
1.1 nicm 50: return (cmdq);
51: }
52:
53: /* Free command queue */
54: int
55: cmdq_free(struct cmd_q *cmdq)
56: {
1.25 nicm 57: if (--cmdq->references != 0) {
58: if (cmdq->flags & CMD_Q_DEAD)
59: return (1);
60: return (0);
61: }
1.1 nicm 62:
63: cmdq_flush(cmdq);
64: free(cmdq);
65: return (1);
66: }
67:
68: /* Show message from command. */
1.18 nicm 69: void
1.1 nicm 70: cmdq_print(struct cmd_q *cmdq, const char *fmt, ...)
71: {
72: struct client *c = cmdq->client;
73: struct window *w;
74: va_list ap;
1.28 nicm 75: char *tmp, *msg;
1.1 nicm 76:
77: va_start(ap, fmt);
78:
79: if (c == NULL)
80: /* nothing */;
81: else if (c->session == NULL || (c->flags & CLIENT_CONTROL)) {
1.28 nicm 82: if (~c->flags & CLIENT_UTF8) {
1.37 ! nicm 83: xvasprintf(&tmp, fmt, ap);
1.28 nicm 84: msg = utf8_sanitize(tmp);
85: free(tmp);
86: evbuffer_add(c->stdout_data, msg, strlen(msg));
87: free(msg);
88: } else
89: evbuffer_add_vprintf(c->stdout_data, fmt, ap);
1.1 nicm 90: evbuffer_add(c->stdout_data, "\n", 1);
1.29 nicm 91: server_client_push_stdout(c);
1.1 nicm 92: } else {
93: w = c->session->curw->window;
94: if (w->active->mode != &window_copy_mode) {
95: window_pane_reset_mode(w->active);
96: window_pane_set_mode(w->active, &window_copy_mode);
97: window_copy_init_for_output(w->active);
98: }
99: window_copy_vadd(w->active, fmt, ap);
100: }
101:
102: va_end(ap);
103: }
104:
105: /* Show error from command. */
1.18 nicm 106: void
1.1 nicm 107: cmdq_error(struct cmd_q *cmdq, const char *fmt, ...)
108: {
109: struct client *c = cmdq->client;
110: struct cmd *cmd = cmdq->cmd;
111: va_list ap;
1.20 nicm 112: char *msg;
1.1 nicm 113: size_t msglen;
1.28 nicm 114: char *tmp;
1.1 nicm 115:
116: va_start(ap, fmt);
117: msglen = xvasprintf(&msg, fmt, ap);
118: va_end(ap);
119:
1.20 nicm 120: if (c == NULL)
121: cfg_add_cause("%s:%u: %s", cmd->file, cmd->line, msg);
122: else if (c->session == NULL || (c->flags & CLIENT_CONTROL)) {
1.28 nicm 123: if (~c->flags & CLIENT_UTF8) {
124: tmp = msg;
125: msg = utf8_sanitize(tmp);
126: free(tmp);
127: msglen = strlen(msg);
128: }
1.1 nicm 129: evbuffer_add(c->stderr_data, msg, msglen);
130: evbuffer_add(c->stderr_data, "\n", 1);
1.29 nicm 131: server_client_push_stderr(c);
1.13 nicm 132: c->retval = 1;
1.1 nicm 133: } else {
134: *msg = toupper((u_char) *msg);
135: status_message_set(c, "%s", msg);
136: }
137:
138: free(msg);
139: }
140:
1.4 nicm 141: /* Print a guard line. */
1.21 nicm 142: void
1.10 nicm 143: cmdq_guard(struct cmd_q *cmdq, const char *guard, int flags)
1.4 nicm 144: {
145: struct client *c = cmdq->client;
146:
1.21 nicm 147: if (c == NULL || !(c->flags & CLIENT_CONTROL))
148: return;
1.4 nicm 149:
1.9 nicm 150: evbuffer_add_printf(c->stdout_data, "%%%s %ld %u %d\n", guard,
151: (long) cmdq->time, cmdq->number, flags);
1.29 nicm 152: server_client_push_stdout(c);
1.4 nicm 153: }
154:
1.1 nicm 155: /* Add command list to queue and begin processing if needed. */
156: void
1.23 nicm 157: cmdq_run(struct cmd_q *cmdq, struct cmd_list *cmdlist, struct mouse_event *m)
1.1 nicm 158: {
1.23 nicm 159: cmdq_append(cmdq, cmdlist, m);
1.1 nicm 160:
161: if (cmdq->item == NULL) {
162: cmdq->cmd = NULL;
163: cmdq_continue(cmdq);
164: }
165: }
166:
167: /* Add command list to queue. */
168: void
1.23 nicm 169: cmdq_append(struct cmd_q *cmdq, struct cmd_list *cmdlist, struct mouse_event *m)
1.1 nicm 170: {
171: struct cmd_q_item *item;
172:
173: item = xcalloc(1, sizeof *item);
174: item->cmdlist = cmdlist;
175: TAILQ_INSERT_TAIL(&cmdq->queue, item, qentry);
176: cmdlist->references++;
1.23 nicm 177:
178: if (m != NULL)
179: memcpy(&item->mouse, m, sizeof item->mouse);
180: else
181: item->mouse.valid = 0;
1.1 nicm 182: }
183:
1.24 nicm 184: /* Process one command. */
1.31 nicm 185: static enum cmd_retval
1.24 nicm 186: cmdq_continue_one(struct cmd_q *cmdq)
187: {
188: struct cmd *cmd = cmdq->cmd;
1.36 nicm 189: const char *name = cmd->entry->name;
190: struct session *s;
191: struct hooks *hooks;
1.24 nicm 192: enum cmd_retval retval;
1.31 nicm 193: char *tmp;
1.24 nicm 194: int flags = !!(cmd->flags & CMD_CONTROL);
195:
1.31 nicm 196: tmp = cmd_print(cmd);
197: log_debug("cmdq %p: %s", cmdq, tmp);
198: free(tmp);
1.24 nicm 199:
200: cmdq->time = time(NULL);
201: cmdq->number++;
202:
1.36 nicm 203: if (~cmdq->flags & CMD_Q_REENTRY)
204: cmdq_guard(cmdq, "begin", flags);
1.24 nicm 205:
1.36 nicm 206: if (cmd_prepare_state(cmd, cmdq, cmdq->parent) != 0)
1.31 nicm 207: goto error;
1.36 nicm 208:
209: if (~cmdq->flags & CMD_Q_NOHOOKS) {
210: s = NULL;
211: if (cmdq->state.tflag.s != NULL)
212: s = cmdq->state.tflag.s;
213: else if (cmdq->state.sflag.s != NULL)
214: s = cmdq->state.sflag.s;
215: else if (cmdq->state.c != NULL)
216: s = cmdq->state.c->session;
217: if (s != NULL)
218: hooks = s->hooks;
219: else
220: hooks = global_hooks;
221:
222: if (~cmdq->flags & CMD_Q_REENTRY) {
223: cmdq->flags |= CMD_Q_REENTRY;
224: if (hooks_wait(hooks, cmdq, NULL,
225: "before-%s", name) == 0)
226: return (CMD_RETURN_WAIT);
227: if (cmd_prepare_state(cmd, cmdq, cmdq->parent) != 0)
228: goto error;
229: }
230: } else
231: hooks = NULL;
232: cmdq->flags &= ~CMD_Q_REENTRY;
233:
1.24 nicm 234: retval = cmd->entry->exec(cmd, cmdq);
1.32 nicm 235: if (retval == CMD_RETURN_ERROR)
236: goto error;
1.24 nicm 237:
1.36 nicm 238: if (hooks != NULL && hooks_wait(hooks, cmdq, NULL,
239: "after-%s", name) == 0)
240: retval = CMD_RETURN_WAIT;
1.31 nicm 241: cmdq_guard(cmdq, "end", flags);
1.36 nicm 242:
1.24 nicm 243: return (retval);
1.31 nicm 244:
245: error:
246: cmdq_guard(cmdq, "error", flags);
1.36 nicm 247: cmdq->flags &= ~CMD_Q_REENTRY;
1.31 nicm 248: return (CMD_RETURN_ERROR);
1.24 nicm 249: }
250:
1.1 nicm 251: /* Continue processing command queue. Returns 1 if finishes empty. */
252: int
253: cmdq_continue(struct cmd_q *cmdq)
254: {
1.31 nicm 255: struct client *c = cmdq->client;
1.1 nicm 256: struct cmd_q_item *next;
257: enum cmd_retval retval;
1.24 nicm 258: int empty;
1.1 nicm 259:
1.22 nicm 260: cmdq->references++;
1.1 nicm 261: notify_disable();
1.26 nicm 262:
1.27 nicm 263: log_debug("continuing cmdq %p: flags %#x, client %p", cmdq, cmdq->flags,
264: c);
1.1 nicm 265:
266: empty = TAILQ_EMPTY(&cmdq->queue);
267: if (empty)
268: goto empty;
269:
1.36 nicm 270: /*
271: * If the command isn't in the middle of running hooks (due to
272: * CMD_RETURN_WAIT), move onto the next command; otherwise, leave the
273: * state of the queue as it is.
274: */
275: if (~cmdq->flags & CMD_Q_REENTRY) {
276: if (cmdq->item == NULL) {
277: cmdq->item = TAILQ_FIRST(&cmdq->queue);
278: cmdq->cmd = TAILQ_FIRST(&cmdq->item->cmdlist->list);
279: } else
280: cmdq->cmd = TAILQ_NEXT(cmdq->cmd, qentry);
281: }
1.1 nicm 282:
283: do {
284: while (cmdq->cmd != NULL) {
1.24 nicm 285: retval = cmdq_continue_one(cmdq);
1.1 nicm 286: if (retval == CMD_RETURN_ERROR)
287: break;
288: if (retval == CMD_RETURN_WAIT)
289: goto out;
290: if (retval == CMD_RETURN_STOP) {
291: cmdq_flush(cmdq);
292: goto empty;
293: }
294: cmdq->cmd = TAILQ_NEXT(cmdq->cmd, qentry);
295: }
1.19 nicm 296: next = TAILQ_NEXT(cmdq->item, qentry);
1.1 nicm 297:
298: TAILQ_REMOVE(&cmdq->queue, cmdq->item, qentry);
299: cmd_list_free(cmdq->item->cmdlist);
300: free(cmdq->item);
301:
302: cmdq->item = next;
303: if (cmdq->item != NULL)
304: cmdq->cmd = TAILQ_FIRST(&cmdq->item->cmdlist->list);
305: } while (cmdq->item != NULL);
306:
307: empty:
1.11 nicm 308: if (cmdq->client_exit > 0)
1.1 nicm 309: cmdq->client->flags |= CLIENT_EXIT;
310: if (cmdq->emptyfn != NULL)
1.22 nicm 311: cmdq->emptyfn(cmdq);
1.1 nicm 312: empty = 1;
313:
314: out:
315: notify_enable();
1.22 nicm 316: cmdq_free(cmdq);
317:
1.1 nicm 318: return (empty);
319: }
320:
321: /* Flush command queue. */
322: void
323: cmdq_flush(struct cmd_q *cmdq)
324: {
325: struct cmd_q_item *item, *item1;
326:
327: TAILQ_FOREACH_SAFE(item, &cmdq->queue, qentry, item1) {
328: TAILQ_REMOVE(&cmdq->queue, item, qentry);
329: cmd_list_free(item->cmdlist);
330: free(item);
331: }
332: cmdq->item = NULL;
333: }
1.33 nicm 334:
![[BACK]](/icons/back.gif){kind=icon}
Return to cmd-queue.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / tmux