Annotation of src/usr.bin/tmux/cmd-queue.c, Revision 1.39
1.39 ! nicm 1: /* $OpenBSD: cmd-queue.c,v 1.38 2016/10/11 13:21:59 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.38 nicm 29: static void cmdq_flush(struct cmd_q *);
1.24 nicm 30:
1.1 nicm 31: /* Create new command queue. */
32: struct cmd_q *
33: cmdq_new(struct client *c)
34: {
35: struct cmd_q *cmdq;
36:
37: cmdq = xcalloc(1, sizeof *cmdq);
38: cmdq->references = 1;
1.25 nicm 39: cmdq->flags = 0;
1.1 nicm 40:
41: cmdq->client = c;
1.11 nicm 42: cmdq->client_exit = -1;
1.1 nicm 43:
44: TAILQ_INIT(&cmdq->queue);
45: cmdq->item = NULL;
46: cmdq->cmd = NULL;
47:
1.33 nicm 48: cmd_find_clear_state(&cmdq->current, NULL, 0);
49: cmdq->parent = NULL;
50:
1.1 nicm 51: return (cmdq);
52: }
53:
54: /* Free command queue */
55: int
56: cmdq_free(struct cmd_q *cmdq)
57: {
1.25 nicm 58: if (--cmdq->references != 0) {
59: if (cmdq->flags & CMD_Q_DEAD)
60: return (1);
61: return (0);
62: }
1.1 nicm 63:
64: cmdq_flush(cmdq);
65: free(cmdq);
66: return (1);
67: }
68:
69: /* Show message from command. */
1.18 nicm 70: void
1.1 nicm 71: cmdq_print(struct cmd_q *cmdq, const char *fmt, ...)
72: {
73: struct client *c = cmdq->client;
74: struct window *w;
75: va_list ap;
1.28 nicm 76: char *tmp, *msg;
1.1 nicm 77:
78: va_start(ap, fmt);
79:
80: if (c == NULL)
81: /* nothing */;
82: else if (c->session == NULL || (c->flags & CLIENT_CONTROL)) {
1.28 nicm 83: if (~c->flags & CLIENT_UTF8) {
1.37 nicm 84: xvasprintf(&tmp, fmt, ap);
1.28 nicm 85: msg = utf8_sanitize(tmp);
86: free(tmp);
87: evbuffer_add(c->stdout_data, msg, strlen(msg));
88: free(msg);
89: } else
90: evbuffer_add_vprintf(c->stdout_data, fmt, ap);
1.1 nicm 91: evbuffer_add(c->stdout_data, "\n", 1);
1.29 nicm 92: server_client_push_stdout(c);
1.1 nicm 93: } else {
94: w = c->session->curw->window;
95: if (w->active->mode != &window_copy_mode) {
96: window_pane_reset_mode(w->active);
97: window_pane_set_mode(w->active, &window_copy_mode);
98: window_copy_init_for_output(w->active);
99: }
100: window_copy_vadd(w->active, fmt, ap);
101: }
102:
103: va_end(ap);
104: }
105:
106: /* Show error from command. */
1.18 nicm 107: void
1.1 nicm 108: cmdq_error(struct cmd_q *cmdq, const char *fmt, ...)
109: {
110: struct client *c = cmdq->client;
111: struct cmd *cmd = cmdq->cmd;
112: va_list ap;
1.20 nicm 113: char *msg;
1.1 nicm 114: size_t msglen;
1.28 nicm 115: char *tmp;
1.1 nicm 116:
117: va_start(ap, fmt);
118: msglen = xvasprintf(&msg, fmt, ap);
119: va_end(ap);
120:
1.20 nicm 121: if (c == NULL)
122: cfg_add_cause("%s:%u: %s", cmd->file, cmd->line, msg);
123: else if (c->session == NULL || (c->flags & CLIENT_CONTROL)) {
1.28 nicm 124: if (~c->flags & CLIENT_UTF8) {
125: tmp = msg;
126: msg = utf8_sanitize(tmp);
127: free(tmp);
128: msglen = strlen(msg);
129: }
1.1 nicm 130: evbuffer_add(c->stderr_data, msg, msglen);
131: evbuffer_add(c->stderr_data, "\n", 1);
1.29 nicm 132: server_client_push_stderr(c);
1.13 nicm 133: c->retval = 1;
1.1 nicm 134: } else {
135: *msg = toupper((u_char) *msg);
136: status_message_set(c, "%s", msg);
137: }
138:
139: free(msg);
140: }
141:
1.4 nicm 142: /* Print a guard line. */
1.21 nicm 143: void
1.10 nicm 144: cmdq_guard(struct cmd_q *cmdq, const char *guard, int flags)
1.4 nicm 145: {
146: struct client *c = cmdq->client;
147:
1.21 nicm 148: if (c == NULL || !(c->flags & CLIENT_CONTROL))
149: return;
1.4 nicm 150:
1.9 nicm 151: evbuffer_add_printf(c->stdout_data, "%%%s %ld %u %d\n", guard,
152: (long) cmdq->time, cmdq->number, flags);
1.29 nicm 153: server_client_push_stdout(c);
1.4 nicm 154: }
155:
1.1 nicm 156: /* Add command list to queue and begin processing if needed. */
157: void
1.23 nicm 158: cmdq_run(struct cmd_q *cmdq, struct cmd_list *cmdlist, struct mouse_event *m)
1.1 nicm 159: {
1.23 nicm 160: cmdq_append(cmdq, cmdlist, m);
1.1 nicm 161:
162: if (cmdq->item == NULL) {
163: cmdq->cmd = NULL;
164: cmdq_continue(cmdq);
165: }
166: }
167:
168: /* Add command list to queue. */
169: void
1.23 nicm 170: cmdq_append(struct cmd_q *cmdq, struct cmd_list *cmdlist, struct mouse_event *m)
1.1 nicm 171: {
172: struct cmd_q_item *item;
173:
174: item = xcalloc(1, sizeof *item);
175: item->cmdlist = cmdlist;
176: TAILQ_INSERT_TAIL(&cmdq->queue, item, qentry);
177: cmdlist->references++;
1.23 nicm 178:
179: if (m != NULL)
180: memcpy(&item->mouse, m, sizeof item->mouse);
181: else
182: item->mouse.valid = 0;
1.1 nicm 183: }
184:
1.39 ! nicm 185: /* Find hooks list. */
! 186: static struct hooks *
! 187: cmdq_get_hooks(struct cmd_q *cmdq)
! 188: {
! 189: struct session *s;
! 190:
! 191: s = NULL;
! 192: if (cmdq->state.tflag.s != NULL)
! 193: s = cmdq->state.tflag.s;
! 194: else if (cmdq->state.sflag.s != NULL)
! 195: s = cmdq->state.sflag.s;
! 196: else if (cmdq->state.c != NULL)
! 197: s = cmdq->state.c->session;
! 198: if (s != NULL)
! 199: return (s->hooks);
! 200: return (global_hooks);
! 201: }
! 202:
1.24 nicm 203: /* Process one command. */
1.31 nicm 204: static enum cmd_retval
1.24 nicm 205: cmdq_continue_one(struct cmd_q *cmdq)
206: {
207: struct cmd *cmd = cmdq->cmd;
1.36 nicm 208: const char *name = cmd->entry->name;
209: struct hooks *hooks;
1.24 nicm 210: enum cmd_retval retval;
1.31 nicm 211: char *tmp;
1.24 nicm 212: int flags = !!(cmd->flags & CMD_CONTROL);
213:
1.31 nicm 214: tmp = cmd_print(cmd);
215: log_debug("cmdq %p: %s", cmdq, tmp);
216: free(tmp);
1.24 nicm 217:
218: cmdq->time = time(NULL);
219: cmdq->number++;
220:
1.36 nicm 221: if (~cmdq->flags & CMD_Q_REENTRY)
222: cmdq_guard(cmdq, "begin", flags);
1.24 nicm 223:
1.36 nicm 224: if (cmd_prepare_state(cmd, cmdq, cmdq->parent) != 0)
1.31 nicm 225: goto error;
1.36 nicm 226:
227: if (~cmdq->flags & CMD_Q_NOHOOKS) {
1.39 ! nicm 228: hooks = cmdq_get_hooks(cmdq);
1.36 nicm 229: if (~cmdq->flags & CMD_Q_REENTRY) {
230: cmdq->flags |= CMD_Q_REENTRY;
231: if (hooks_wait(hooks, cmdq, NULL,
232: "before-%s", name) == 0)
233: return (CMD_RETURN_WAIT);
234: if (cmd_prepare_state(cmd, cmdq, cmdq->parent) != 0)
235: goto error;
236: }
237: } else
238: hooks = NULL;
239: cmdq->flags &= ~CMD_Q_REENTRY;
240:
1.24 nicm 241: retval = cmd->entry->exec(cmd, cmdq);
1.32 nicm 242: if (retval == CMD_RETURN_ERROR)
243: goto error;
1.24 nicm 244:
1.39 ! nicm 245: if (hooks != NULL) {
! 246: if (cmd_prepare_state(cmd, cmdq, cmdq->parent) != 0)
! 247: goto error;
! 248: hooks = cmdq_get_hooks(cmdq);
! 249: if (hooks_wait(hooks, cmdq, NULL, "after-%s", name) == 0)
! 250: retval = CMD_RETURN_WAIT;
! 251: }
1.31 nicm 252: cmdq_guard(cmdq, "end", flags);
1.36 nicm 253:
1.24 nicm 254: return (retval);
1.31 nicm 255:
256: error:
257: cmdq_guard(cmdq, "error", flags);
1.36 nicm 258: cmdq->flags &= ~CMD_Q_REENTRY;
1.31 nicm 259: return (CMD_RETURN_ERROR);
1.24 nicm 260: }
261:
1.1 nicm 262: /* Continue processing command queue. Returns 1 if finishes empty. */
263: int
264: cmdq_continue(struct cmd_q *cmdq)
265: {
1.31 nicm 266: struct client *c = cmdq->client;
1.1 nicm 267: struct cmd_q_item *next;
268: enum cmd_retval retval;
1.24 nicm 269: int empty;
1.1 nicm 270:
1.22 nicm 271: cmdq->references++;
1.1 nicm 272: notify_disable();
1.39 ! nicm 273:
! 274: cmd_find_clear_state(&cmdq->current, NULL, 0);
1.26 nicm 275:
1.27 nicm 276: log_debug("continuing cmdq %p: flags %#x, client %p", cmdq, cmdq->flags,
277: c);
1.1 nicm 278:
279: empty = TAILQ_EMPTY(&cmdq->queue);
280: if (empty)
281: goto empty;
282:
1.36 nicm 283: /*
284: * If the command isn't in the middle of running hooks (due to
285: * CMD_RETURN_WAIT), move onto the next command; otherwise, leave the
286: * state of the queue as it is.
287: */
288: if (~cmdq->flags & CMD_Q_REENTRY) {
289: if (cmdq->item == NULL) {
290: cmdq->item = TAILQ_FIRST(&cmdq->queue);
291: cmdq->cmd = TAILQ_FIRST(&cmdq->item->cmdlist->list);
292: } else
293: cmdq->cmd = TAILQ_NEXT(cmdq->cmd, qentry);
294: }
1.1 nicm 295:
296: do {
297: while (cmdq->cmd != NULL) {
1.24 nicm 298: retval = cmdq_continue_one(cmdq);
1.1 nicm 299: if (retval == CMD_RETURN_ERROR)
300: break;
301: if (retval == CMD_RETURN_WAIT)
302: goto out;
303: if (retval == CMD_RETURN_STOP) {
304: cmdq_flush(cmdq);
305: goto empty;
306: }
307: cmdq->cmd = TAILQ_NEXT(cmdq->cmd, qentry);
308: }
1.19 nicm 309: next = TAILQ_NEXT(cmdq->item, qentry);
1.1 nicm 310:
311: TAILQ_REMOVE(&cmdq->queue, cmdq->item, qentry);
312: cmd_list_free(cmdq->item->cmdlist);
313: free(cmdq->item);
314:
315: cmdq->item = next;
316: if (cmdq->item != NULL)
317: cmdq->cmd = TAILQ_FIRST(&cmdq->item->cmdlist->list);
318: } while (cmdq->item != NULL);
319:
320: empty:
1.11 nicm 321: if (cmdq->client_exit > 0)
1.1 nicm 322: cmdq->client->flags |= CLIENT_EXIT;
323: if (cmdq->emptyfn != NULL)
1.22 nicm 324: cmdq->emptyfn(cmdq);
1.1 nicm 325: empty = 1;
326:
327: out:
328: notify_enable();
1.22 nicm 329: cmdq_free(cmdq);
330:
1.1 nicm 331: return (empty);
332: }
333:
334: /* Flush command queue. */
1.38 nicm 335: static void
1.1 nicm 336: cmdq_flush(struct cmd_q *cmdq)
337: {
338: struct cmd_q_item *item, *item1;
339:
340: TAILQ_FOREACH_SAFE(item, &cmdq->queue, qentry, item1) {
341: TAILQ_REMOVE(&cmdq->queue, item, qentry);
342: cmd_list_free(item->cmdlist);
343: free(item);
344: }
345: cmdq->item = NULL;
346: }
1.33 nicm 347:
![[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