cmd-show-options.c

   1 /* $OpenBSD$ */
   2
   3 /*
   4  * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
   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 #include <vis.h>
  24
  25 #include "tmux.h"
  26
  27 /*
  28  * Show options.
  29  */
  30
  31 static enum cmd_retval  cmd_show_options_exec(struct cmd *, struct cmdq_item *);
  32
  33 static void             cmd_show_options_print(struct cmd *, struct cmdq_item *,
  34                             struct options_entry *, int, int);
  35 static enum cmd_retval  cmd_show_options_all(struct cmd *, struct cmdq_item *,
  36                             int, struct options *);
  37
  38 const struct cmd_entry cmd_show_options_entry = {
  39         .name = "show-options",
  40         .alias = "show",
  41
  42         .args = { "AgHpqst:vw", 0, 1, NULL },
  43         .usage = "[-AgHpqsvw] " CMD_TARGET_PANE_USAGE " [option]",
  44
  45         .target = { 't', CMD_FIND_PANE, CMD_FIND_CANFAIL },
  46
  47         .flags = CMD_AFTERHOOK,
  48         .exec = cmd_show_options_exec
  49 };
  50
  51 const struct cmd_entry cmd_show_window_options_entry = {
  52         .name = "show-window-options",
  53         .alias = "showw",
  54
  55         .args = { "gvt:", 0, 1, NULL },
  56         .usage = "[-gv] " CMD_TARGET_WINDOW_USAGE " [option]",
  57
  58         .target = { 't', CMD_FIND_WINDOW, CMD_FIND_CANFAIL },
  59
  60         .flags = CMD_AFTERHOOK,
  61         .exec = cmd_show_options_exec
  62 };
  63
  64 const struct cmd_entry cmd_show_hooks_entry = {
  65         .name = "show-hooks",
  66         .alias = NULL,
  67
  68         .args = { "gpt:w", 0, 1, NULL },
  69         .usage = "[-gpw] " CMD_TARGET_PANE_USAGE,
  70
  71         .target = { 't', CMD_FIND_PANE, CMD_FIND_CANFAIL },
  72
  73         .flags = CMD_AFTERHOOK,
  74         .exec = cmd_show_options_exec
  75 };
  76
  77 static enum cmd_retval
  78 cmd_show_options_exec(struct cmd *self, struct cmdq_item *item)
  79 {
  80         struct args                     *args = cmd_get_args(self);
  81         struct cmd_find_state           *target = cmdq_get_target(item);
  82         struct options                  *oo;
  83         char                            *argument, *name = NULL, *cause;
  84         int                              window, idx, ambiguous, parent, scope;
  85         struct options_entry            *o;
  86
  87         window = (cmd_get_entry(self) == &cmd_show_window_options_entry);
  88
  89         if (args_count(args) == 0) {
  90                 scope = options_scope_from_flags(args, window, target, &oo,
  91                     &cause);
  92                 if (scope == OPTIONS_TABLE_NONE) {
  93                         if (args_has(args, 'q'))
  94                                 return (CMD_RETURN_NORMAL);
  95                         cmdq_error(item, "%s", cause);
  96                         free(cause);
  97                         return (CMD_RETURN_ERROR);
  98                 }
  99                 return (cmd_show_options_all(self, item, scope, oo));
 100         }
 101         argument = format_single_from_target(item, args_string(args, 0));
 102
 103         name = options_match(argument, &idx, &ambiguous);
 104         if (name == NULL) {
 105                 if (args_has(args, 'q'))
 106                         goto fail;
 107                 if (ambiguous)
 108                         cmdq_error(item, "ambiguous option: %s", argument);
 109                 else
 110                         cmdq_error(item, "invalid option: %s", argument);
 111                 goto fail;
 112         }
 113         scope = options_scope_from_name(args, window, name, target, &oo,
 114             &cause);
 115         if (scope == OPTIONS_TABLE_NONE) {
 116                 if (args_has(args, 'q'))
 117                         goto fail;
 118                 cmdq_error(item, "%s", cause);
 119                 free(cause);
 120                 goto fail;
 121         }
 122         o = options_get_only(oo, name);
 123         if (args_has(args, 'A') && o == NULL) {
 124                 o = options_get(oo, name);
 125                 parent = 1;
 126         } else
 127                 parent = 0;
 128         if (o != NULL)
 129                 cmd_show_options_print(self, item, o, idx, parent);
 130         else if (*name == '@') {
 131                 if (args_has(args, 'q'))
 132                         goto fail;
 133                 cmdq_error(item, "invalid option: %s", argument);
 134                 goto fail;
 135         }
 136
 137         free(name);
 138         free(argument);
 139         return (CMD_RETURN_NORMAL);
 140
 141 fail:
 142         free(name);
 143         free(argument);
 144         return (CMD_RETURN_ERROR);
 145 }
 146
 147 static void
 148 cmd_show_options_print(struct cmd *self, struct cmdq_item *item,
 149     struct options_entry *o, int idx, int parent)
 150 {
 151         struct args                     *args = cmd_get_args(self);
 152         struct options_array_item       *a;
 153         const char                      *name = options_name(o);
 154         char                            *value, *tmp = NULL, *escaped;
 155
 156         if (idx != -1) {
 157                 xasprintf(&tmp, "%s[%d]", name, idx);
 158                 name = tmp;
 159         } else {
 160                 if (options_is_array(o)) {
 161                         a = options_array_first(o);
 162                         if (a == NULL) {
 163                                 if (!args_has(args, 'v'))
 164                                         cmdq_print(item, "%s", name);
 165                                 return;
 166                         }
 167                         while (a != NULL) {
 168                                 idx = options_array_item_index(a);
 169                                 cmd_show_options_print(self, item, o, idx,
 170                                     parent);
 171                                 a = options_array_next(a);
 172                         }
 173                         return;
 174                 }
 175         }
 176
 177         value = options_to_string(o, idx, 0);
 178         if (args_has(args, 'v'))
 179                 cmdq_print(item, "%s", value);
 180         else if (options_is_string(o)) {
 181                 escaped = args_escape(value);
 182                 if (parent)
 183                         cmdq_print(item, "%s* %s", name, escaped);
 184                 else
 185                         cmdq_print(item, "%s %s", name, escaped);
 186                 free(escaped);
 187         } else {
 188                 if (parent)
 189                         cmdq_print(item, "%s* %s", name, value);
 190                 else
 191                         cmdq_print(item, "%s %s", name, value);
 192         }
 193         free(value);
 194
 195         free(tmp);
 196 }
 197
 198 static enum cmd_retval
 199 cmd_show_options_all(struct cmd *self, struct cmdq_item *item, int scope,
 200     struct options *oo)
 201 {
 202         struct args                             *args = cmd_get_args(self);
 203         const struct options_table_entry        *oe;
 204         struct options_entry                    *o;
 205         struct options_array_item               *a;
 206         const char                              *name;
 207         u_int                                    idx;
 208         int                                      parent;
 209
 210         if (cmd_get_entry(self) != &cmd_show_hooks_entry) {
 211                 o = options_first(oo);
 212                 while (o != NULL) {
 213                         if (options_table_entry(o) == NULL)
 214                                 cmd_show_options_print(self, item, o, -1, 0);
 215                         o = options_next(o);
 216                 }
 217         }
 218         for (oe = options_table; oe->name != NULL; oe++) {
 219                 if (~oe->scope & scope)
 220                         continue;
 221
 222                 if ((cmd_get_entry(self) != &cmd_show_hooks_entry &&
 223                     !args_has(args, 'H') &&
 224                     (oe->flags & OPTIONS_TABLE_IS_HOOK)) ||
 225                     (cmd_get_entry(self) == &cmd_show_hooks_entry &&
 226                     (~oe->flags & OPTIONS_TABLE_IS_HOOK)))
 227                         continue;
 228
 229                 o = options_get_only(oo, oe->name);
 230                 if (o == NULL) {
 231                         if (!args_has(args, 'A'))
 232                                 continue;
 233                         o = options_get(oo, oe->name);
 234                         if (o == NULL)
 235                                 continue;
 236                         parent = 1;
 237                 } else
 238                         parent = 0;
 239
 240                 if (!options_is_array(o))
 241                         cmd_show_options_print(self, item, o, -1, parent);
 242                 else if ((a = options_array_first(o)) == NULL) {
 243                         if (!args_has(args, 'v')) {
 244                                 name = options_name(o);
 245                                 if (parent)
 246                                         cmdq_print(item, "%s*", name);
 247                                 else
 248                                         cmdq_print(item, "%s", name);
 249                         }
 250                 } else {
 251                         while (a != NULL) {
 252                                 idx = options_array_item_index(a);
 253                                 cmd_show_options_print(self, item, o, idx,
 254                                     parent);
 255                                 a = options_array_next(a);
 256                         }
 257                 }
 258         }
 259         return (CMD_RETURN_NORMAL);
 260 }