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

Diff for /src/usr.bin/tmux/cmd-unbind-key.c between version 1.8 and 1.9

version 1.8, 2010/11/11 20:54:06 version 1.9, 2011/01/04 00:42:47
Line 24 
Line 24 
  * Unbind key from command.   * Unbind key from command.
  */   */
   
 int     cmd_unbind_key_parse(struct cmd *, int, char **, char **);  int     cmd_unbind_key_check(struct args *);
 int     cmd_unbind_key_exec(struct cmd *, struct cmd_ctx *);  int     cmd_unbind_key_exec(struct cmd *, struct cmd_ctx *);
 void    cmd_unbind_key_free(struct cmd *);  
   
 int     cmd_unbind_key_table(struct cmd *, struct cmd_ctx *);  int     cmd_unbind_key_table(struct cmd *, struct cmd_ctx *, int);
   
 struct cmd_unbind_key_data {  
         int     key;  
   
         int     flag_all;  
         int     command_key;  
         char   *tablename;  
 };  
   
 const struct cmd_entry cmd_unbind_key_entry = {  const struct cmd_entry cmd_unbind_key_entry = {
         "unbind-key", "unbind",          "unbind-key", "unbind",
           "acnt:", 1, 1,
         "[-acn] [-t key-table] key",          "[-acn] [-t key-table] key",
         0, "",          0,
         NULL,          NULL,
         cmd_unbind_key_parse,          cmd_unbind_key_check,
         cmd_unbind_key_exec,          cmd_unbind_key_exec
         cmd_unbind_key_free,  
         NULL  
 };  };
   
 int  int
 cmd_unbind_key_parse(struct cmd *self, int argc, char **argv, char **cause)  cmd_unbind_key_check(struct args *args)
 {  {
         struct cmd_unbind_key_data      *data;          if (args_has(args, 'a') && (args->argc != 0 || args_has(args, 't')))
         int                              opt, no_prefix = 0;                  return (-1);
   
         self->data = data = xmalloc(sizeof *data);  
         data->flag_all = 0;  
         data->command_key = 0;  
         data->tablename = NULL;  
   
         while ((opt = getopt(argc, argv, "acnt:")) != -1) {  
                 switch (opt) {  
                 case 'a':  
                         data->flag_all = 1;  
                         break;  
                 case 'c':  
                         data->command_key = 1;  
                         break;  
                 case 'n':  
                         no_prefix = 1;  
                         break;  
                 case 't':  
                         if (data->tablename == NULL)  
                                 data->tablename = xstrdup(optarg);  
                         break;  
                 default:  
                         goto usage;  
                 }  
         }  
         argc -= optind;  
         argv += optind;  
         if (data->flag_all && (argc != 0 || data->tablename))  
                 goto usage;  
         if (!data->flag_all && argc != 1)  
                 goto usage;  
   
         if (!data->flag_all) {  
                 data->key = key_string_lookup_string(argv[0]);  
                 if (data->key == KEYC_NONE) {  
                         xasprintf(cause, "unknown key: %s", argv[0]);  
                         goto error;  
                 }  
                 if (!no_prefix)  
                         data->key |= KEYC_PREFIX;  
         }  
   
         return (0);          return (0);
   
 usage:  
         xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);  
   
 error:  
         xfree(data);  
         return (-1);  
 }  }
   
 int  int
 cmd_unbind_key_exec(struct cmd *self, unused struct cmd_ctx *ctx)  cmd_unbind_key_exec(struct cmd *self, unused struct cmd_ctx *ctx)
 {  {
         struct cmd_unbind_key_data      *data = self->data;          struct args             *args = self->args;
         struct key_binding              *bd;          struct key_binding      *bd;
           int                      key;
   
         if (data == NULL)          if (args_has(args, 'a')) {
                 return (0);  
         if (data->flag_all) {  
                 while (!SPLAY_EMPTY(&key_bindings)) {                  while (!SPLAY_EMPTY(&key_bindings)) {
                         bd = SPLAY_ROOT(&key_bindings);                          bd = SPLAY_ROOT(&key_bindings);
                         SPLAY_REMOVE(key_bindings, &key_bindings, bd);                          SPLAY_REMOVE(key_bindings, &key_bindings, bd);
                         cmd_list_free(bd->cmdlist);                          cmd_list_free(bd->cmdlist);
                         xfree(bd);                          xfree(bd);
                 }                  }
         } else {                  return (0);
                 if (data->tablename != NULL)          }
                         return (cmd_unbind_key_table(self, ctx));  
   
                 key_bindings_remove(data->key);          key = key_string_lookup_string(args->argv[0]);
           if (key == KEYC_NONE) {
                   ctx->error(ctx, "unknown key: %s", args->argv[0]);
                   return (-1);
         }          }
   
           if (args_has(args, 't'))
                   return (cmd_unbind_key_table(self, ctx, key));
   
           if (!args_has(args, 'n'))
                   key |= KEYC_PREFIX;
           key_bindings_remove(key);
         return (0);          return (0);
 }  }
   
 int  int
 cmd_unbind_key_table(struct cmd *self, struct cmd_ctx *ctx)  cmd_unbind_key_table(struct cmd *self, struct cmd_ctx *ctx, int key)
 {  {
         struct cmd_unbind_key_data      *data = self->data;          struct args                     *args = self->args;
           const char                      *tablename;
         const struct mode_key_table     *mtab;          const struct mode_key_table     *mtab;
         struct mode_key_binding         *mbind, mtmp;          struct mode_key_binding         *mbind, mtmp;
   
         if ((mtab = mode_key_findtable(data->tablename)) == NULL) {          tablename = args_get(args, 't');
                 ctx->error(ctx, "unknown key table: %s", data->tablename);          if ((mtab = mode_key_findtable(tablename)) == NULL) {
                   ctx->error(ctx, "unknown key table: %s", tablename);
                 return (-1);                  return (-1);
         }          }
   
         mtmp.key = data->key & ~KEYC_PREFIX;          mtmp.key = key;
         mtmp.mode = data->command_key ? 1 : 0;          mtmp.mode = !!args_has(args, 'c');
         if ((mbind = SPLAY_FIND(mode_key_tree, mtab->tree, &mtmp)) != NULL) {          if ((mbind = SPLAY_FIND(mode_key_tree, mtab->tree, &mtmp)) != NULL) {
                 SPLAY_REMOVE(mode_key_tree, mtab->tree, mbind);                  SPLAY_REMOVE(mode_key_tree, mtab->tree, mbind);
                 xfree(mbind);                  xfree(mbind);
         }          }
         return (0);          return (0);
 }  
   
 void  
 cmd_unbind_key_free(struct cmd *self)  
 {  
         struct cmd_unbind_key_data      *data = self->data;  
   
         if (data->tablename != NULL)  
                 xfree(data->tablename);  
         xfree(data);  
 }  }
Legend:
Removed from v.1.8  
changed lines
  Added in v.1.9