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
 131         free(name);
 132         free(argument);
 133         return (CMD_RETURN_NORMAL);
 134
 135 fail:
 136         free(name);
 137         free(argument);
 138         return (CMD_RETURN_ERROR);
 139 }
 140
 141 static void
 142 cmd_show_options_print(struct cmd *self, struct cmdq_item *item,
 143     struct options_entry *o, int idx, int parent)
 144 {
 145         struct args                     *args = cmd_get_args(self);
 146         struct options_array_item       *a;
 147         const char                      *name = options_name(o);
 148         char                            *value, *tmp = NULL, *escaped;
 149
 150         if (idx != -1) {
 151                 xasprintf(&tmp, "%s[%d]", name, idx);
 152                 name = tmp;
 153         } else {
 154                 if (options_is_array(o)) {
 155                         a = options_array_first(o);
 156                         if (a == NULL) {
 157                                 if (!args_has(args, 'v'))
 158                                         cmdq_print(item, "%s", name);
 159                                 return;
 160                         }
 161                         while (a != NULL) {
 162                                 idx = options_array_item_index(a);
 163                                 cmd_show_options_print(self, item, o, idx,
 164                                     parent);
 165                                 a = options_array_next(a);
 166                         }
 167                         return;
 168                 }
 169         }
 170
 171         value = options_to_string(o, idx, 0);
 172         if (args_has(args, 'v'))
 173                 cmdq_print(item, "%s", value);
 174         else if (options_is_string(o)) {
 175                 escaped = args_escape(value);
 176                 if (parent)
 177                         cmdq_print(item, "%s* %s", name, escaped);
 178                 else
 179                         cmdq_print(item, "%s %s", name, escaped);
 180                 free(escaped);
 181         } else {
 182                 if (parent)
 183                         cmdq_print(item, "%s* %s", name, value);
 184                 else
 185                         cmdq_print(item, "%s %s", name, value);
 186         }
 187         free(value);
 188
 189         free(tmp);
 190 }
 191
 192 static enum cmd_retval
 193 cmd_show_options_all(struct cmd *self, struct cmdq_item *item, int scope,
 194     struct options *oo)
 195 {
 196         struct args                             *args = cmd_get_args(self);
 197         const struct options_table_entry        *oe;
 198         struct options_entry                    *o;
 199         struct options_array_item               *a;
 200         const char                              *name;
 201         u_int                                    idx;
 202         int                                      parent;
 203
 204         if (cmd_get_entry(self) != &cmd_show_hooks_entry) {
 205                 o = options_first(oo);
 206                 while (o != NULL) {
 207                         if (options_table_entry(o) == NULL)
 208                                 cmd_show_options_print(self, item, o, -1, 0);
 209                         o = options_next(o);
 210                 }
 211         }
 212         for (oe = options_table; oe->name != NULL; oe++) {
 213                 if (~oe->scope & scope)
 214                         continue;
 215
 216                 if ((cmd_get_entry(self) != &cmd_show_hooks_entry &&
 217                     !args_has(args, 'H') &&
 218                     (oe->flags & OPTIONS_TABLE_IS_HOOK)) ||
 219                     (cmd_get_entry(self) == &cmd_show_hooks_entry &&
 220                     (~oe->flags & OPTIONS_TABLE_IS_HOOK)))
 221                         continue;
 222
 223                 o = options_get_only(oo, oe->name);
 224                 if (o == NULL) {
 225                         if (!args_has(args, 'A'))
 226                                 continue;
 227                         o = options_get(oo, oe->name);
 228                         if (o == NULL)
 229                                 continue;
 230                         parent = 1;
 231                 } else
 232                         parent = 0;
 233
 234                 if (!options_is_array(o))
 235                         cmd_show_options_print(self, item, o, -1, parent);
 236                 else if ((a = options_array_first(o)) == NULL) {
 237                         if (!args_has(args, 'v')) {
 238                                 name = options_name(o);
 239                                 if (parent)
 240                                         cmdq_print(item, "%s*", name);
 241                                 else
 242                                         cmdq_print(item, "%s", name);
 243                         }
 244                 } else {
 245                         while (a != NULL) {
 246                                 idx = options_array_item_index(a);
 247                                 cmd_show_options_print(self, item, o, idx,
 248                                     parent);
 249                                 a = options_array_next(a);
 250                         }
 251                 }
 252         }
 253         return (CMD_RETURN_NORMAL);
 254 }