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

Diff for /src/usr.bin/tmux/cmd-paste-buffer.c between version 1.15 and 1.16

version 1.15, 2010/12/30 23:16:18 version 1.16, 2011/01/04 00:42:47
Line 28 
Line 28 
  * Paste paste buffer if present.   * Paste paste buffer if present.
  */   */
   
 struct cmd_paste_buffer_data {  
         char    *target;  
         int      buffer;  
   
         int      flag_delete;  
         char    *sepstr;  
 };  
   
 void    cmd_paste_buffer_init(struct cmd *, int);  
 int     cmd_paste_buffer_parse(struct cmd *, int, char **, char **);  
 int     cmd_paste_buffer_exec(struct cmd *, struct cmd_ctx *);  int     cmd_paste_buffer_exec(struct cmd *, struct cmd_ctx *);
   
 void    cmd_paste_buffer_filter(  void    cmd_paste_buffer_filter(
             struct window_pane *, const char *, size_t, char *);              struct window_pane *, const char *, size_t, const char *);
 void    cmd_paste_buffer_free(struct cmd *);  
 size_t  cmd_paste_buffer_print(struct cmd *, char *, size_t);  
   
 const struct cmd_entry cmd_paste_buffer_entry = {  const struct cmd_entry cmd_paste_buffer_entry = {
         "paste-buffer", "pasteb",          "paste-buffer", "pasteb",
           "db:rs:t:", 0, 0,
         "[-dr] [-s separator] [-b buffer-index] [-t target-pane]",          "[-dr] [-s separator] [-b buffer-index] [-t target-pane]",
         0, "",          0,
         cmd_paste_buffer_init,          NULL,
         cmd_paste_buffer_parse,          NULL,
         cmd_paste_buffer_exec,          cmd_paste_buffer_exec
         cmd_paste_buffer_free,  
         cmd_paste_buffer_print  
 };  };
   
 /* ARGSUSED */  
 void  
 cmd_paste_buffer_init(struct cmd *self, unused int arg)  
 {  
         struct cmd_paste_buffer_data    *data;  
   
         self->data = data = xmalloc(sizeof *data);  
         data->target = NULL;  
         data->buffer = -1;  
         data->flag_delete = 0;  
         data->sepstr = xstrdup("\r");  
 }  
   
 int  int
 cmd_paste_buffer_parse(struct cmd *self, int argc, char **argv, char **cause)  cmd_paste_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
 {  {
         struct cmd_paste_buffer_data    *data;          struct args             *args = self->args;
         int                      opt, n;          struct window_pane      *wp;
         const char              *errstr;          struct session          *s;
           struct paste_buffer     *pb;
           const char              *sepstr;
           char                    *cause;
           int                      buffer;
   
         cmd_paste_buffer_init(self, 0);          if (cmd_find_pane(ctx, args_get(args, 't'), &s, &wp) == NULL)
         data = self->data;                  return (-1);
   
         while ((opt = getopt(argc, argv, "b:ds:t:r")) != -1) {          if (!args_has(args, 'b'))
                 switch (opt) {                  buffer = -1;
                 case 'b':          else {
                         if (data->buffer == -1) {                  buffer = args_strtonum(args, 'b', 0, INT_MAX, &cause);
                                 n = strtonum(optarg, 0, INT_MAX, &errstr);                  if (cause != NULL) {
                                 if (errstr != NULL) {                          ctx->error(ctx, "buffer %s", cause);
                                         xasprintf(cause, "buffer %s", errstr);                          xfree(cause);
                                         goto error;                          return (-1);
                                 }  
                                 data->buffer = n;  
                         }  
                         break;  
                 case 'd':  
                         data->flag_delete = 1;  
                         break;  
                 case 's':  
                         if (data->sepstr != NULL)  
                                 xfree(data->sepstr);  
                         data->sepstr = xstrdup(optarg);  
                         break;  
                 case 't':  
                         if (data->target == NULL)  
                                 data->target = xstrdup(optarg);  
                         break;  
                 case 'r':  
                         if (data->sepstr != NULL)  
                                 xfree(data->sepstr);  
                         data->sepstr = xstrdup("\n");  
                         break;  
                 default:  
                         goto usage;  
                 }                  }
         }          }
         argc -= optind;  
         argv += optind;  
   
         return (0);          if (buffer == -1)
   
 usage:  
         xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);  
   
 error:  
         self->entry->free(self);  
         return (-1);  
 }  
   
 int  
 cmd_paste_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)  
 {  
         struct cmd_paste_buffer_data    *data = self->data;  
         struct window_pane              *wp;  
         struct session                  *s;  
         struct paste_buffer             *pb;  
   
         if (cmd_find_pane(ctx, data->target, &s, &wp) == NULL)  
                 return (-1);  
   
         if (data->buffer == -1)  
                 pb = paste_get_top(&global_buffers);                  pb = paste_get_top(&global_buffers);
         else {          else {
                 pb = paste_get_index(&global_buffers, data->buffer);                  pb = paste_get_index(&global_buffers, buffer);
                 if (pb == NULL) {                  if (pb == NULL) {
                         ctx->error(ctx, "no buffer %d", data->buffer);                          ctx->error(ctx, "no buffer %d", buffer);
                         return (-1);                          return (-1);
                 }                  }
         }          }
   
         if (pb != NULL)          if (pb != NULL) {
                 cmd_paste_buffer_filter(wp, pb->data, pb->size, data->sepstr);                  sepstr = args_get(args, 's');
                   if (sepstr == NULL) {
                           if (args_has(args, 'r'))
                                   sepstr = "\n";
                           else
                                   sepstr = "\r";
                   }
                   cmd_paste_buffer_filter(wp, pb->data, pb->size, sepstr);
           }
   
         /* Delete the buffer if -d. */          /* Delete the buffer if -d. */
         if (data->flag_delete) {          if (args_has(args, 'd')) {
                 if (data->buffer == -1)                  if (buffer == -1)
                         paste_free_top(&global_buffers);                          paste_free_top(&global_buffers);
                 else                  else
                         paste_free_index(&global_buffers, data->buffer);                          paste_free_index(&global_buffers, buffer);
         }          }
   
         return (0);          return (0);
Line 162 
Line 103 
 /* Add bytes to a buffer and filter '\n' according to separator. */  /* Add bytes to a buffer and filter '\n' according to separator. */
 void  void
 cmd_paste_buffer_filter(  cmd_paste_buffer_filter(
     struct window_pane *wp, const char *data, size_t size, char *sep)      struct window_pane *wp, const char *data, size_t size, const char *sep)
 {  {
         const char      *end = data + size;          const char      *end = data + size;
         const char      *lf;          const char      *lf;
Line 178 
Line 119 
   
         if (end != data)          if (end != data)
                 bufferevent_write(wp->event, data, end - data);                  bufferevent_write(wp->event, data, end - data);
 }  
   
 void  
 cmd_paste_buffer_free(struct cmd *self)  
 {  
         struct cmd_paste_buffer_data    *data = self->data;  
   
         if (data->target != NULL)  
                 xfree(data->target);  
         if (data->sepstr != NULL)  
                 xfree(data->sepstr);  
         xfree(data);  
 }  
   
 size_t  
 cmd_paste_buffer_print(struct cmd *self, char *buf, size_t len)  
 {  
         struct cmd_paste_buffer_data    *data = self->data;  
         size_t                           off = 0;  
         char                             tmp[BUFSIZ];  
         int                              r_flag;  
   
         r_flag = 0;  
         if (data->sepstr != NULL)  
                 r_flag = (data->sepstr[0] == '\n' && data->sepstr[1] == '\0');  
   
         off += xsnprintf(buf, len, "%s", self->entry->name);  
         if (data == NULL)  
                 return (off);  
         if (off < len && data->flag_delete)  
                 off += xsnprintf(buf + off, len - off, " -d");  
         if (off < len && r_flag)  
                 off += xsnprintf(buf + off, len - off, " -r");  
         if (off < len && data->buffer != -1)  
                 off += xsnprintf(buf + off, len - off, " -b %d", data->buffer);  
         if (off < len && data->sepstr != NULL && !r_flag) {  
                 strnvis(  
                     tmp, data->sepstr, sizeof tmp, VIS_OCTAL|VIS_TAB|VIS_NL);  
                 off += cmd_prarg(buf + off, len - off, " -s ", tmp);  
         }  
         if (off < len && data->target != NULL)  
                 off += cmd_prarg(buf + off, len - off, " -t ", data->target);  
         return (off);  
 }  }
Legend:
Removed from v.1.15  
changed lines
  Added in v.1.16