Annotation of src/usr.bin/tmux/cmd-generic.c, Revision 1.6
1.6 ! nicm 1: /* $OpenBSD: cmd-generic.c,v 1.5 2009/07/30 13:45:56 nicm Exp $ */
1.1 nicm 2:
3: /*
4: * Copyright (c) 2008 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 <stdlib.h>
22: #include <string.h>
23:
24: #include "tmux.h"
25:
1.3 nicm 26: int cmd_getopt(int, char **, const char *, uint64_t);
27: int cmd_flags(int, uint64_t, uint64_t *);
28: size_t cmd_print_flags(char *, size_t, size_t, uint64_t);
1.6 ! nicm 29: int cmd_fill_argument(int, char **, char **, int, char **);
1.1 nicm 30:
31: size_t
32: cmd_prarg(char *buf, size_t len, const char *prefix, char *arg)
33: {
34: if (strchr(arg, ' ') != NULL)
35: return (xsnprintf(buf, len, "%s\"%s\"", prefix, arg));
36: return (xsnprintf(buf, len, "%s%s", prefix, arg));
37: }
38:
1.3 nicm 39: /* Prepend flags from chflags onto flagstr and call getopt. */
1.1 nicm 40: int
1.3 nicm 41: cmd_getopt(int argc, char **argv, const char *flagstr, uint64_t chflags)
1.1 nicm 42: {
1.3 nicm 43: u_char ch;
44: char buf[128];
45: size_t len, off;
46:
47: *buf = '\0';
48:
49: len = sizeof buf;
50: off = 0;
51:
52: for (ch = 0; ch < 26; ch++) {
53: if (chflags & CMD_CHFLAG('a' + ch))
54: off += xsnprintf(buf + off, len - off, "%c", 'a' + ch);
55: if (chflags & CMD_CHFLAG('A' + ch))
56: off += xsnprintf(buf + off, len - off, "%c", 'A' + ch);
57: }
58:
59: strlcat(buf, flagstr, sizeof buf);
60:
61: return (getopt(argc, argv, buf));
62: }
63:
64: /*
65: * If this option is expected (in ichflags), set it in ochflags, otherwise
66: * return -1.
67: */
68: int
69: cmd_flags(int opt, uint64_t ichflags, uint64_t *ochflags)
70: {
71: u_char ch;
72:
73: for (ch = 0; ch < 26; ch++) {
74: if (opt == 'a' + ch && ichflags & CMD_CHFLAG(opt)) {
75: (*ochflags) |= CMD_CHFLAG(opt);
1.1 nicm 76: return (0);
77: }
1.3 nicm 78: if (opt == 'A' + ch && ichflags & CMD_CHFLAG(opt)) {
79: (*ochflags) |= CMD_CHFLAG(opt);
1.1 nicm 80: return (0);
81: }
82: }
1.3 nicm 83: return (-1);
1.1 nicm 84: }
85:
1.3 nicm 86: /* Print the flags supported in chflags. */
1.1 nicm 87: size_t
1.3 nicm 88: cmd_print_flags(char *buf, size_t len, size_t off, uint64_t chflags)
1.1 nicm 89: {
1.3 nicm 90: u_char ch;
1.1 nicm 91: size_t boff = off;
92:
1.3 nicm 93: if (chflags == 0)
1.1 nicm 94: return (0);
95: off += xsnprintf(buf + off, len - off, " -");
1.3 nicm 96:
97: for (ch = 0; ch < 26; ch++) {
98: if (chflags & CMD_CHFLAG('a' + ch))
99: off += xsnprintf(buf + off, len - off, "%c", 'a' + ch);
100: if (chflags & CMD_CHFLAG('A' + ch))
101: off += xsnprintf(buf + off, len - off, "%c", 'A' + ch);
102: }
1.1 nicm 103: return (off - boff);
104: }
105:
106: int
1.6 ! nicm 107: cmd_fill_argument(int flags, char **arg, char **arg2, int argc, char **argv)
1.1 nicm 108: {
109: *arg = NULL;
1.6 ! nicm 110: *arg2 = NULL;
1.1 nicm 111:
112: if (flags & CMD_ARG1) {
113: if (argc != 1)
114: return (-1);
115: *arg = xstrdup(argv[0]);
116: return (0);
117: }
118:
119: if (flags & CMD_ARG01) {
120: if (argc != 0 && argc != 1)
121: return (-1);
122: if (argc == 1)
123: *arg = xstrdup(argv[0]);
124: return (0);
125: }
126:
1.6 ! nicm 127: if (flags & CMD_ARG2) {
! 128: if (argc != 2)
! 129: return (-1);
! 130: *arg = xstrdup(argv[0]);
! 131: *arg2 = xstrdup(argv[1]);
! 132: return (0);
! 133: }
! 134:
! 135: if (flags & CMD_ARG12) {
! 136: if (argc != 1 && argc != 2)
! 137: return (-1);
! 138: *arg = xstrdup(argv[0]);
! 139: if (argc == 2)
! 140: *arg2 = xstrdup(argv[1]);
! 141: return (0);
! 142: }
! 143:
1.1 nicm 144: if (argc != 0)
145: return (-1);
146: return (0);
147: }
148:
149: void
150: cmd_target_init(struct cmd *self, unused int key)
151: {
152: struct cmd_target_data *data;
153:
154: self->data = data = xmalloc(sizeof *data);
1.3 nicm 155: data->chflags = 0;
1.1 nicm 156: data->target = NULL;
157: data->arg = NULL;
158: }
159:
160: int
161: cmd_target_parse(struct cmd *self, int argc, char **argv, char **cause)
162: {
163: struct cmd_target_data *data;
1.3 nicm 164: const struct cmd_entry *entry = self->entry;
1.1 nicm 165: int opt;
166:
167: /* Don't use the entry version since it may be dependent on key. */
168: cmd_target_init(self, 0);
169: data = self->data;
170:
1.3 nicm 171: while ((opt = cmd_getopt(argc, argv, "t:", entry->chflags)) != -1) {
172: if (cmd_flags(opt, entry->chflags, &data->chflags) == 0)
1.1 nicm 173: continue;
174: switch (opt) {
175: case 't':
176: if (data->target == NULL)
177: data->target = xstrdup(optarg);
178: break;
179: default:
180: goto usage;
181: }
182: }
183: argc -= optind;
184: argv += optind;
185:
1.6 ! nicm 186: if (cmd_fill_argument(
! 187: self->entry->flags, &data->arg, &data->arg2, argc, argv) != 0)
1.1 nicm 188: goto usage;
189: return (0);
190:
191: usage:
192: xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
193:
194: self->entry->free(self);
195: return (-1);
196: }
197:
198: void
199: cmd_target_free(struct cmd *self)
200: {
201: struct cmd_target_data *data = self->data;
202:
203: if (data->target != NULL)
204: xfree(data->target);
205: if (data->arg != NULL)
206: xfree(data->arg);
207: xfree(data);
208: }
209:
210: size_t
211: cmd_target_print(struct cmd *self, char *buf, size_t len)
212: {
213: struct cmd_target_data *data = self->data;
214: size_t off = 0;
215:
216: off += xsnprintf(buf, len, "%s", self->entry->name);
217: if (data == NULL)
218: return (off);
1.3 nicm 219: off += cmd_print_flags(buf, len, off, data->chflags);
1.1 nicm 220: if (off < len && data->target != NULL)
221: off += cmd_prarg(buf + off, len - off, " -t ", data->target);
222: if (off < len && data->arg != NULL)
223: off += cmd_prarg(buf + off, len - off, " ", data->arg);
1.6 ! nicm 224: if (off < len && data->arg2 != NULL)
! 225: off += cmd_prarg(buf + off, len - off, " ", data->arg2);
1.1 nicm 226: return (off);
227: }
228:
229: void
230: cmd_srcdst_init(struct cmd *self, unused int key)
231: {
232: struct cmd_srcdst_data *data;
233:
234: self->data = data = xmalloc(sizeof *data);
1.3 nicm 235: data->chflags = 0;
1.1 nicm 236: data->src = NULL;
237: data->dst = NULL;
238: data->arg = NULL;
239: }
240:
241: int
242: cmd_srcdst_parse(struct cmd *self, int argc, char **argv, char **cause)
243: {
244: struct cmd_srcdst_data *data;
1.3 nicm 245: const struct cmd_entry *entry = self->entry;
1.1 nicm 246: int opt;
247:
248: cmd_srcdst_init(self, 0);
249: data = self->data;
250:
1.3 nicm 251: while ((opt = cmd_getopt(argc, argv, "s:t:", entry->chflags)) != -1) {
252: if (cmd_flags(opt, entry->chflags, &data->chflags) == 0)
1.1 nicm 253: continue;
254: switch (opt) {
255: case 's':
256: if (data->src == NULL)
257: data->src = xstrdup(optarg);
258: break;
259: case 't':
260: if (data->dst == NULL)
261: data->dst = xstrdup(optarg);
262: break;
263: default:
264: goto usage;
265: }
266: }
267: argc -= optind;
268: argv += optind;
269:
1.6 ! nicm 270: if (cmd_fill_argument(
! 271: self->entry->flags, &data->arg, &data->arg2, argc, argv) != 0)
1.1 nicm 272: goto usage;
273: return (0);
274:
275: usage:
276: xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
277:
278: self->entry->free(self);
279: return (-1);
280: }
281:
282: void
283: cmd_srcdst_free(struct cmd *self)
284: {
285: struct cmd_srcdst_data *data = self->data;
286:
287: if (data->src != NULL)
288: xfree(data->src);
289: if (data->dst != NULL)
290: xfree(data->dst);
291: if (data->arg != NULL)
292: xfree(data->arg);
293: xfree(data);
294: }
295:
296: size_t
297: cmd_srcdst_print(struct cmd *self, char *buf, size_t len)
298: {
299: struct cmd_srcdst_data *data = self->data;
300: size_t off = 0;
301:
302: off += xsnprintf(buf, len, "%s", self->entry->name);
303: if (data == NULL)
304: return (off);
1.3 nicm 305: off += cmd_print_flags(buf, len, off, data->chflags);
1.1 nicm 306: if (off < len && data->src != NULL)
307: off += xsnprintf(buf + off, len - off, " -s %s", data->src);
308: if (off < len && data->dst != NULL)
309: off += xsnprintf(buf + off, len - off, " -t %s", data->dst);
310: if (off < len && data->arg != NULL)
311: off += cmd_prarg(buf + off, len - off, " ", data->arg);
1.6 ! nicm 312: if (off < len && data->arg2 != NULL)
! 313: off += cmd_prarg(buf + off, len - off, " ", data->arg2);
1.1 nicm 314: return (off);
315: }
316:
317: void
318: cmd_buffer_init(struct cmd *self, unused int key)
319: {
320: struct cmd_buffer_data *data;
321:
322: self->data = data = xmalloc(sizeof *data);
1.3 nicm 323: data->chflags = 0;
1.1 nicm 324: data->target = NULL;
325: data->buffer = -1;
326: data->arg = NULL;
327: }
328:
329: int
330: cmd_buffer_parse(struct cmd *self, int argc, char **argv, char **cause)
331: {
332: struct cmd_buffer_data *data;
1.3 nicm 333: const struct cmd_entry *entry = self->entry;
1.1 nicm 334: int opt, n;
335: const char *errstr;
336:
337: cmd_buffer_init(self, 0);
338: data = self->data;
339:
1.3 nicm 340: while ((opt = cmd_getopt(argc, argv, "b:t:", entry->chflags)) != -1) {
341: if (cmd_flags(opt, entry->chflags, &data->chflags) == 0)
1.1 nicm 342: continue;
343: switch (opt) {
344: case 'b':
345: if (data->buffer == -1) {
346: n = strtonum(optarg, 0, INT_MAX, &errstr);
347: if (errstr != NULL) {
348: xasprintf(cause, "buffer %s", errstr);
349: goto error;
350: }
351: data->buffer = n;
352: }
353: break;
354: case 't':
355: if (data->target == NULL)
356: data->target = xstrdup(optarg);
357: break;
358: default:
359: goto usage;
360: }
361: }
362: argc -= optind;
363: argv += optind;
364:
1.6 ! nicm 365: if (cmd_fill_argument(
! 366: self->entry->flags, &data->arg, &data->arg2, argc, argv) != 0)
1.1 nicm 367: goto usage;
368: return (0);
369:
370: usage:
371: xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
372:
373: error:
374: self->entry->free(self);
375: return (-1);
376: }
377:
378: void
379: cmd_buffer_free(struct cmd *self)
380: {
381: struct cmd_buffer_data *data = self->data;
382:
383: if (data->target != NULL)
384: xfree(data->target);
385: if (data->arg != NULL)
386: xfree(data->arg);
387: xfree(data);
388: }
389:
390: size_t
391: cmd_buffer_print(struct cmd *self, char *buf, size_t len)
392: {
393: struct cmd_buffer_data *data = self->data;
394: size_t off = 0;
395:
396: off += xsnprintf(buf, len, "%s", self->entry->name);
397: if (data == NULL)
398: return (off);
1.3 nicm 399: off += cmd_print_flags(buf, len, off, data->chflags);
1.1 nicm 400: if (off < len && data->buffer != -1)
401: off += xsnprintf(buf + off, len - off, " -b %d", data->buffer);
402: if (off < len && data->target != NULL)
403: off += cmd_prarg(buf + off, len - off, " -t ", data->target);
404: if (off < len && data->arg != NULL)
405: off += cmd_prarg(buf + off, len - off, " ", data->arg);
1.6 ! nicm 406: if (off < len && data->arg2 != NULL)
! 407: off += cmd_prarg(buf + off, len - off, " ", data->arg2);
1.1 nicm 408: return (off);
409: }
![[BACK]](/icons/back.gif){kind=icon}
Return to cmd-generic.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / tmux