[BACK]Return to cmd-list.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / tmux

Annotation of src/usr.bin/tmux/cmd-list.c, Revision 1.18

1.18    ! nicm        1: /* $OpenBSD: cmd-list.c,v 1.17 2019/05/20 11:34:37 nicm Exp $ */
1.1       nicm        2:
                      3: /*
1.16      nicm        4:  * Copyright (c) 2009 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:
1.8       nicm       21: #include <stdlib.h>
1.1       nicm       22: #include <string.h>
                     23:
                     24: #include "tmux.h"
                     25:
1.18    ! nicm       26: static u_int cmd_list_next_group = 1;
        !            27:
        !            28: struct cmd_list *
1.17      nicm       29: cmd_list_new(void)
                     30: {
                     31:        struct cmd_list *cmdlist;
                     32:
                     33:        cmdlist = xcalloc(1, sizeof *cmdlist);
                     34:        cmdlist->references = 1;
1.18    ! nicm       35:        cmdlist->group = cmd_list_next_group++;
1.17      nicm       36:        TAILQ_INIT(&cmdlist->list);
                     37:        return (cmdlist);
                     38: }
                     39:
1.18    ! nicm       40: void
        !            41: cmd_list_append(struct cmd_list *cmdlist, struct cmd *cmd)
        !            42: {
        !            43:        cmd->group = cmdlist->group;
        !            44:        TAILQ_INSERT_TAIL(&cmdlist->list, cmd, qentry);
        !            45: }
        !            46:
        !            47: void
        !            48: cmd_list_move(struct cmd_list *cmdlist, struct cmd_list *from)
        !            49: {
        !            50:        struct cmd      *cmd, *cmd1;
        !            51:
        !            52:        TAILQ_FOREACH_SAFE(cmd, &from->list, qentry, cmd1) {
        !            53:                TAILQ_REMOVE(&from->list, cmd, qentry);
        !            54:                TAILQ_INSERT_TAIL(&cmdlist->list, cmd, qentry);
        !            55:        }
        !            56:        cmdlist->group = cmd_list_next_group++;
        !            57: }
        !            58:
1.1       nicm       59: struct cmd_list *
1.14      nicm       60: cmd_list_parse(int argc, char **argv, const char *file, u_int line,
1.12      nicm       61:     char **cause)
1.1       nicm       62: {
                     63:        struct cmd_list *cmdlist;
                     64:        struct cmd      *cmd;
                     65:        int              i, lastsplit;
                     66:        size_t           arglen, new_argc;
1.6       nicm       67:        char           **copy_argv, **new_argv;
                     68:
                     69:        copy_argv = cmd_copy_argv(argc, argv);
1.1       nicm       70:
1.17      nicm       71:        cmdlist = cmd_list_new();
1.1       nicm       72:
                     73:        lastsplit = 0;
                     74:        for (i = 0; i < argc; i++) {
1.6       nicm       75:                arglen = strlen(copy_argv[i]);
                     76:                if (arglen == 0 || copy_argv[i][arglen - 1] != ';')
1.1       nicm       77:                        continue;
1.6       nicm       78:                copy_argv[i][arglen - 1] = '\0';
1.1       nicm       79:
1.6       nicm       80:                if (arglen > 1 && copy_argv[i][arglen - 2] == '\\') {
                     81:                        copy_argv[i][arglen - 2] = ';';
1.1       nicm       82:                        continue;
                     83:                }
                     84:
                     85:                new_argc = i - lastsplit;
1.6       nicm       86:                new_argv = copy_argv + lastsplit;
1.1       nicm       87:                if (arglen != 1)
                     88:                        new_argc++;
                     89:
1.12      nicm       90:                cmd = cmd_parse(new_argc, new_argv, file, line, cause);
1.1       nicm       91:                if (cmd == NULL)
                     92:                        goto bad;
1.5       nicm       93:                TAILQ_INSERT_TAIL(&cmdlist->list, cmd, qentry);
1.1       nicm       94:
                     95:                lastsplit = i + 1;
                     96:        }
                     97:
                     98:        if (lastsplit != argc) {
1.12      nicm       99:                cmd = cmd_parse(argc - lastsplit, copy_argv + lastsplit,
                    100:                    file, line, cause);
1.1       nicm      101:                if (cmd == NULL)
                    102:                        goto bad;
1.5       nicm      103:                TAILQ_INSERT_TAIL(&cmdlist->list, cmd, qentry);
1.1       nicm      104:        }
                    105:
1.6       nicm      106:        cmd_free_argv(argc, copy_argv);
1.1       nicm      107:        return (cmdlist);
                    108:
                    109: bad:
                    110:        cmd_list_free(cmdlist);
1.6       nicm      111:        cmd_free_argv(argc, copy_argv);
1.1       nicm      112:        return (NULL);
                    113: }
                    114:
                    115: void
                    116: cmd_list_free(struct cmd_list *cmdlist)
                    117: {
1.12      nicm      118:        struct cmd      *cmd, *cmd1;
1.1       nicm      119:
1.5       nicm      120:        if (--cmdlist->references != 0)
                    121:                return;
                    122:
1.12      nicm      123:        TAILQ_FOREACH_SAFE(cmd, &cmdlist->list, qentry, cmd1) {
1.5       nicm      124:                TAILQ_REMOVE(&cmdlist->list, cmd, qentry);
1.18    ! nicm      125:                cmd_free(cmd);
1.1       nicm      126:        }
1.12      nicm      127:
1.8       nicm      128:        free(cmdlist);
1.1       nicm      129: }
                    130:
1.15      nicm      131: char *
                    132: cmd_list_print(struct cmd_list *cmdlist)
1.1       nicm      133: {
                    134:        struct cmd      *cmd;
1.15      nicm      135:        char            *buf, *this;
                    136:        size_t           len;
                    137:
                    138:        len = 1;
                    139:        buf = xcalloc(1, len);
1.1       nicm      140:
1.5       nicm      141:        TAILQ_FOREACH(cmd, &cmdlist->list, qentry) {
1.15      nicm      142:                this = cmd_print(cmd);
                    143:
                    144:                len += strlen(this) + 3;
                    145:                buf = xrealloc(buf, len);
                    146:
                    147:                strlcat(buf, this, len);
                    148:                if (TAILQ_NEXT(cmd, qentry) != NULL)
                    149:                        strlcat(buf, " ; ", len);
                    150:
                    151:                free(this);
1.1       nicm      152:        }
1.15      nicm      153:
                    154:        return (buf);
1.1       nicm      155: }