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

Diff for /src/usr.bin/tmux/cmd.c between version 1.157 and 1.158

version 1.157, 2020/03/24 08:09:43 version 1.158, 2020/04/13 08:26:27
Line 207 
Line 207 
         NULL          NULL
 };  };
   
   /* Instance of a command. */
   struct cmd {
           const struct cmd_entry   *entry;
           struct args              *args;
           u_int                     group;
   
           char                     *file;
           u_int                     line;
   
           char                     *alias;
           int                       argc;
           char                    **argv;
   
           TAILQ_ENTRY(cmd)          qentry;
   };
   TAILQ_HEAD(cmds, cmd);
   
   /* Next group number for new command list. */
 static u_int cmd_list_next_group = 1;  static u_int cmd_list_next_group = 1;
   
   /* Log an argument vector. */
 void printflike(3, 4)  void printflike(3, 4)
 cmd_log_argv(int argc, char **argv, const char *fmt, ...)  cmd_log_argv(int argc, char **argv, const char *fmt, ...)
 {  {
Line 225 
Line 244 
         free(prefix);          free(prefix);
 }  }
   
   /* Prepend to an argument vector. */
 void  void
 cmd_prepend_argv(int *argc, char ***argv, char *arg)  cmd_prepend_argv(int *argc, char ***argv, char *arg)
 {  {
Line 241 
Line 261 
         (*argc)++;          (*argc)++;
 }  }
   
   /* Append to an argument vector. */
 void  void
 cmd_append_argv(int *argc, char ***argv, char *arg)  cmd_append_argv(int *argc, char ***argv, char *arg)
 {  {
Line 248 
Line 269 
         (*argv)[(*argc)++] = xstrdup(arg);          (*argv)[(*argc)++] = xstrdup(arg);
 }  }
   
   /* Pack an argument vector up into a buffer. */
 int  int
 cmd_pack_argv(int argc, char **argv, char *buf, size_t len)  cmd_pack_argv(int argc, char **argv, char *buf, size_t len)
 {  {
Line 270 
Line 292 
         return (0);          return (0);
 }  }
   
   /* Unpack an argument vector from a packed buffer. */
 int  int
 cmd_unpack_argv(char *buf, size_t len, int argc, char ***argv)  cmd_unpack_argv(char *buf, size_t len, int argc, char ***argv)
 {  {
Line 298 
Line 321 
         return (0);          return (0);
 }  }
   
   /* Copy an argument vector, ensuring it is terminated by NULL. */
 char **  char **
 cmd_copy_argv(int argc, char **argv)  cmd_copy_argv(int argc, char **argv)
 {  {
Line 314 
Line 338 
         return (new_argv);          return (new_argv);
 }  }
   
   /* Free an argument vector. */
 void  void
 cmd_free_argv(int argc, char **argv)  cmd_free_argv(int argc, char **argv)
 {  {
Line 326 
Line 351 
         free(argv);          free(argv);
 }  }
   
   /* Convert argument vector to a string. */
 char *  char *
 cmd_stringify_argv(int argc, char **argv)  cmd_stringify_argv(int argc, char **argv)
 {  {
Line 352 
Line 378 
         return (buf);          return (buf);
 }  }
   
   /* Get entry for command. */
   const struct cmd_entry *
   cmd_get_entry(struct cmd *cmd)
   {
           return (cmd->entry);
   }
   
   /* Get arguments for command. */
   struct args *
   cmd_get_args(struct cmd *cmd)
   {
           return (cmd->args);
   }
   
   /* Get file and line for command. */
   void
   cmd_get_source(struct cmd *cmd, const char **file, u_int *line)
   {
           if (file != NULL)
                   *file = cmd->file;
           if (line != NULL)
                   *line = cmd->line;
   }
   
   /* Look for an alias for a command. */
 char *  char *
 cmd_get_alias(const char *name)  cmd_get_alias(const char *name)
 {  {
Line 382 
Line 433 
         return (NULL);          return (NULL);
 }  }
   
   /* Look up a command entry by name. */
 static const struct cmd_entry *  static const struct cmd_entry *
 cmd_find(const char *name, char **cause)  cmd_find(const char *name, char **cause)
 {  {
Line 431 
Line 483 
         return (NULL);          return (NULL);
 }  }
   
   /* Parse a single command from an argument vector. */
 struct cmd *  struct cmd *
 cmd_parse(int argc, char **argv, const char *file, u_int line, char **cause)  cmd_parse(int argc, char **argv, const char *file, u_int line, char **cause)
 {  {
Line 479 
Line 532 
         return (NULL);          return (NULL);
 }  }
   
   /* Free a command. */
 void  void
 cmd_free(struct cmd *cmd)  cmd_free(struct cmd *cmd)
 {  {
Line 491 
Line 545 
         free(cmd);          free(cmd);
 }  }
   
   /* Get a command as a string. */
 char *  char *
 cmd_print(struct cmd *cmd)  cmd_print(struct cmd *cmd)
 {  {
Line 506 
Line 561 
         return (out);          return (out);
 }  }
   
   /* Create a new command list. */
 struct cmd_list *  struct cmd_list *
 cmd_list_new(void)  cmd_list_new(void)
 {  {
Line 514 
Line 570 
         cmdlist = xcalloc(1, sizeof *cmdlist);          cmdlist = xcalloc(1, sizeof *cmdlist);
         cmdlist->references = 1;          cmdlist->references = 1;
         cmdlist->group = cmd_list_next_group++;          cmdlist->group = cmd_list_next_group++;
         TAILQ_INIT(&cmdlist->list);          cmdlist->list = xcalloc(1, sizeof *cmdlist->list);
           TAILQ_INIT(cmdlist->list);
         return (cmdlist);          return (cmdlist);
 }  }
   
   /* Append a command to a command list. */
 void  void
 cmd_list_append(struct cmd_list *cmdlist, struct cmd *cmd)  cmd_list_append(struct cmd_list *cmdlist, struct cmd *cmd)
 {  {
         cmd->group = cmdlist->group;          cmd->group = cmdlist->group;
         TAILQ_INSERT_TAIL(&cmdlist->list, cmd, qentry);          TAILQ_INSERT_TAIL(cmdlist->list, cmd, qentry);
 }  }
   
   /* Move all commands from one command list to another */
 void  void
 cmd_list_move(struct cmd_list *cmdlist, struct cmd_list *from)  cmd_list_move(struct cmd_list *cmdlist, struct cmd_list *from)
 {  {
         struct cmd      *cmd, *cmd1;          struct cmd      *cmd, *cmd1;
   
         TAILQ_FOREACH_SAFE(cmd, &from->list, qentry, cmd1) {          TAILQ_FOREACH_SAFE(cmd, from->list, qentry, cmd1) {
                 TAILQ_REMOVE(&from->list, cmd, qentry);                  TAILQ_REMOVE(from->list, cmd, qentry);
                 TAILQ_INSERT_TAIL(&cmdlist->list, cmd, qentry);                  TAILQ_INSERT_TAIL(cmdlist->list, cmd, qentry);
         }          }
         cmdlist->group = cmd_list_next_group++;          cmdlist->group = cmd_list_next_group++;
 }  }
   
   /* Free a command list. */
 void  void
 cmd_list_free(struct cmd_list *cmdlist)  cmd_list_free(struct cmd_list *cmdlist)
 {  {
Line 545 
Line 605 
         if (--cmdlist->references != 0)          if (--cmdlist->references != 0)
                 return;                  return;
   
         TAILQ_FOREACH_SAFE(cmd, &cmdlist->list, qentry, cmd1) {          TAILQ_FOREACH_SAFE(cmd, cmdlist->list, qentry, cmd1) {
                 TAILQ_REMOVE(&cmdlist->list, cmd, qentry);                  TAILQ_REMOVE(cmdlist->list, cmd, qentry);
                 cmd_free(cmd);                  cmd_free(cmd);
         }          }
           free(cmdlist->list);
         free(cmdlist);          free(cmdlist);
 }  }
   
   /* Get a command list as a string. */
 char *  char *
 cmd_list_print(struct cmd_list *cmdlist, int escaped)  cmd_list_print(struct cmd_list *cmdlist, int escaped)
 {  {
Line 563 
Line 624 
         len = 1;          len = 1;
         buf = xcalloc(1, len);          buf = xcalloc(1, len);
   
         TAILQ_FOREACH(cmd, &cmdlist->list, qentry) {          TAILQ_FOREACH(cmd, cmdlist->list, qentry) {
                 this = cmd_print(cmd);                  this = cmd_print(cmd);
   
                 len += strlen(this) + 4;                  len += strlen(this) + 4;
Line 581 
Line 642 
         }          }
   
         return (buf);          return (buf);
   }
   
   /* Get first command in list. */
   struct cmd *
   cmd_list_first(struct cmd_list *cmdlist, u_int *group)
   {
           struct cmd      *cmd;
   
           cmd = TAILQ_FIRST(cmdlist->list);
           if (cmd != NULL && group != NULL)
                   *group = cmd->group;
           return (cmd);
   }
   
   /* Get next command in list. */
   struct cmd *
   cmd_list_next(struct cmd *cmd, u_int *group)
   {
           cmd = TAILQ_NEXT(cmd, qentry);
           if (cmd != NULL && group != NULL)
                   *group = cmd->group;
           return (cmd);
   }
   
   /* Do all of the commands in this command list have this flag? */
   int
   cmd_list_all_have(struct cmd_list *cmdlist, int flag)
   {
           struct cmd      *cmd;
   
           TAILQ_FOREACH(cmd, cmdlist->list, qentry) {
                   if (~cmd->entry->flags & flag)
                           return (0);
           }
           return (1);
   }
   
   /* Do any of the commands in this command list have this flag? */
   int
   cmd_list_any_have(struct cmd_list *cmdlist, int flag)
   {
           struct cmd      *cmd;
   
           TAILQ_FOREACH(cmd, cmdlist->list, qentry) {
                   if (cmd->entry->flags & flag)
                           return (1);
           }
           return (0);
 }  }
   
 /* Adjust current mouse position for a pane. */  /* Adjust current mouse position for a pane. */
Legend:
Removed from v.1.157  
changed lines
  Added in v.1.158