![[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|
Return to cmd-queue.c CVS log | Up to [local] / src / usr.bin / tmux |
1.6 ! nicm 1: /* $OpenBSD: cmd-queue.c,v 1.5 2013/03/25 11:36:08 nicm Exp $ */
1.1 nicm 2:
3: /*
4: * Copyright (c) 2013 Nicholas Marriott <nicm@users.sourceforge.net>
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>
23:
24: #include "tmux.h"
25:
26: /* Create new command queue. */
27: struct cmd_q *
28: cmdq_new(struct client *c)
29: {
30: struct cmd_q *cmdq;
31:
32: cmdq = xcalloc(1, sizeof *cmdq);
33: cmdq->references = 1;
34: cmdq->dead = 0;
35:
36: cmdq->client = c;
37: cmdq->client_exit = 0;
38:
39: TAILQ_INIT(&cmdq->queue);
40: cmdq->item = NULL;
41: cmdq->cmd = NULL;
42:
43: return (cmdq);
44: }
45:
46: /* Free command queue */
47: int
48: cmdq_free(struct cmd_q *cmdq)
49: {
50: if (--cmdq->references != 0)
51: return (cmdq->dead);
52:
53: cmdq_flush(cmdq);
54: free(cmdq);
55: return (1);
56: }
57:
58: /* Show message from command. */
59: void printflike2
60: cmdq_print(struct cmd_q *cmdq, const char *fmt, ...)
61: {
62: struct client *c = cmdq->client;
63: struct window *w;
64: va_list ap;
65:
66: va_start(ap, fmt);
67:
68: if (c == NULL)
69: /* nothing */;
70: else if (c->session == NULL || (c->flags & CLIENT_CONTROL)) {
71: va_start(ap, fmt);
72: evbuffer_add_vprintf(c->stdout_data, fmt, ap);
73: va_end(ap);
74:
75: evbuffer_add(c->stdout_data, "\n", 1);
76: server_push_stdout(c);
77: } else {
78: w = c->session->curw->window;
79: if (w->active->mode != &window_copy_mode) {
80: window_pane_reset_mode(w->active);
81: window_pane_set_mode(w->active, &window_copy_mode);
82: window_copy_init_for_output(w->active);
83: }
84: window_copy_vadd(w->active, fmt, ap);
85: }
86:
87: va_end(ap);
88: }
89:
90: /* Show info from command. */
91: void printflike2
92: cmdq_info(struct cmd_q *cmdq, const char *fmt, ...)
93: {
94: struct client *c = cmdq->client;
95: va_list ap;
96: char *msg;
97:
98: if (options_get_number(&global_options, "quiet"))
99: return;
100:
101: va_start(ap, fmt);
102:
103: if (c == NULL)
104: /* nothing */;
105: else if (c->session == NULL || (c->flags & CLIENT_CONTROL)) {
106: va_start(ap, fmt);
107: evbuffer_add_vprintf(c->stdout_data, fmt, ap);
108: va_end(ap);
109:
110: evbuffer_add(c->stdout_data, "\n", 1);
111: server_push_stdout(c);
112: } else {
113: xvasprintf(&msg, fmt, ap);
114: *msg = toupper((u_char) *msg);
115: status_message_set(c, "%s", msg);
116: free(msg);
117: }
118:
119: va_end(ap);
120:
121: }
122:
123: /* Show error from command. */
124: void printflike2
125: cmdq_error(struct cmd_q *cmdq, const char *fmt, ...)
126: {
127: struct client *c = cmdq->client;
128: struct cmd *cmd = cmdq->cmd;
129: va_list ap;
130: char *msg, *cause;
131: size_t msglen;
132:
133: va_start(ap, fmt);
134: msglen = xvasprintf(&msg, fmt, ap);
135: va_end(ap);
136:
137: if (c == NULL) {
138: xasprintf(&cause, "%s:%u: %s", cmd->file, cmd->line, msg);
139: ARRAY_ADD(&cfg_causes, cause);
140: } else if (c->session == NULL || (c->flags & CLIENT_CONTROL)) {
141: evbuffer_add(c->stderr_data, msg, msglen);
142: evbuffer_add(c->stderr_data, "\n", 1);
143:
144: server_push_stderr(c);
145: c->retcode = 1;
146: } else {
147: *msg = toupper((u_char) *msg);
148: status_message_set(c, "%s", msg);
149: }
150:
151: free(msg);
152: }
153:
1.4 nicm 154: /* Print a guard line. */
1.6 ! nicm 155: int
1.4 nicm 156: cmdq_guard(struct cmd_q *cmdq, const char *guard)
157: {
158: struct client *c = cmdq->client;
159:
160: if (c == NULL || c->session == NULL)
1.6 ! nicm 161: return 0;
1.4 nicm 162: if (!(c->flags & CLIENT_CONTROL))
1.6 ! nicm 163: return 0;
1.4 nicm 164:
165: evbuffer_add_printf(c->stdout_data, "%%%s %ld %u\n", guard,
1.5 nicm 166: (long) cmdq->time, cmdq->number);
1.4 nicm 167: server_push_stdout(c);
1.6 ! nicm 168: return 1;
1.4 nicm 169: }
170:
1.1 nicm 171: /* Add command list to queue and begin processing if needed. */
172: void
173: cmdq_run(struct cmd_q *cmdq, struct cmd_list *cmdlist)
174: {
175: cmdq_append(cmdq, cmdlist);
176:
177: if (cmdq->item == NULL) {
178: cmdq->cmd = NULL;
179: cmdq_continue(cmdq);
180: }
181: }
182:
183: /* Add command list to queue. */
184: void
185: cmdq_append(struct cmd_q *cmdq, struct cmd_list *cmdlist)
186: {
187: struct cmd_q_item *item;
188:
189: item = xcalloc(1, sizeof *item);
190: item->cmdlist = cmdlist;
191: TAILQ_INSERT_TAIL(&cmdq->queue, item, qentry);
192: cmdlist->references++;
193: }
194:
195: /* Continue processing command queue. Returns 1 if finishes empty. */
196: int
197: cmdq_continue(struct cmd_q *cmdq)
198: {
199: struct cmd_q_item *next;
200: enum cmd_retval retval;
1.6 ! nicm 201: int empty, guard;
1.3 nicm 202: char s[1024];
1.1 nicm 203:
204: notify_disable();
205:
206: empty = TAILQ_EMPTY(&cmdq->queue);
207: if (empty)
208: goto empty;
209:
210: if (cmdq->item == NULL) {
211: cmdq->item = TAILQ_FIRST(&cmdq->queue);
212: cmdq->cmd = TAILQ_FIRST(&cmdq->item->cmdlist->list);
213: } else
214: cmdq->cmd = TAILQ_NEXT(cmdq->cmd, qentry);
215:
216: do {
217: next = TAILQ_NEXT(cmdq->item, qentry);
218:
219: while (cmdq->cmd != NULL) {
1.3 nicm 220: cmd_print(cmdq->cmd, s, sizeof s);
221: log_debug("cmdq %p: %s (client %d)", cmdq, s,
222: cmdq->client != NULL ? cmdq->client->ibuf.fd : -1);
223:
1.4 nicm 224: cmdq->time = time(NULL);
225: cmdq->number++;
226:
1.6 ! nicm 227: guard = cmdq_guard(cmdq, "begin");
1.1 nicm 228: retval = cmdq->cmd->entry->exec(cmdq->cmd, cmdq);
1.6 ! nicm 229: if (guard) {
! 230: if (retval == CMD_RETURN_ERROR)
! 231: cmdq_guard(cmdq, "error");
! 232: else
! 233: cmdq_guard(cmdq, "end");
! 234: }
1.1 nicm 235:
236: if (retval == CMD_RETURN_ERROR)
237: break;
238: if (retval == CMD_RETURN_WAIT)
239: goto out;
240: if (retval == CMD_RETURN_STOP) {
241: cmdq_flush(cmdq);
242: goto empty;
243: }
244:
245: cmdq->cmd = TAILQ_NEXT(cmdq->cmd, qentry);
246: }
247:
248: TAILQ_REMOVE(&cmdq->queue, cmdq->item, qentry);
249: cmd_list_free(cmdq->item->cmdlist);
250: free(cmdq->item);
251:
252: cmdq->item = next;
253: if (cmdq->item != NULL)
254: cmdq->cmd = TAILQ_FIRST(&cmdq->item->cmdlist->list);
255: } while (cmdq->item != NULL);
256:
257: empty:
258: if (cmdq->client_exit)
259: cmdq->client->flags |= CLIENT_EXIT;
260: if (cmdq->emptyfn != NULL)
261: cmdq->emptyfn(cmdq); /* may free cmdq */
262: empty = 1;
263:
264: out:
265: notify_enable();
266: return (empty);
267: }
268:
269: /* Flush command queue. */
270: void
271: cmdq_flush(struct cmd_q *cmdq)
272: {
273: struct cmd_q_item *item, *item1;
274:
275: TAILQ_FOREACH_SAFE(item, &cmdq->queue, qentry, item1) {
276: TAILQ_REMOVE(&cmdq->queue, item, qentry);
277: cmd_list_free(item->cmdlist);
278: free(item);
279: }
280: cmdq->item = NULL;
281: }