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

Diff for /src/usr.bin/tmux/cmd-capture-pane.c between version 1.22 and 1.23

version 1.22, 2013/03/25 10:05:35 version 1.23, 2013/03/25 11:38:15
Line 29 
Line 29 
   
 enum cmd_retval  cmd_capture_pane_exec(struct cmd *, struct cmd_q *);  enum cmd_retval  cmd_capture_pane_exec(struct cmd *, struct cmd_q *);
   
   char            *cmd_capture_pane_append(char *, size_t *, char *, size_t);
   char            *cmd_capture_pane_pending(struct args *, struct window_pane *,
                        size_t *);
   char            *cmd_capture_pane_history(struct args *, struct cmd_q *,
                        struct window_pane *, size_t *);
   
 const struct cmd_entry cmd_capture_pane_entry = {  const struct cmd_entry cmd_capture_pane_entry = {
         "capture-pane", "capturep",          "capture-pane", "capturep",
         "ab:CeE:JpqS:t:", 0, 0,          "ab:CeE:JpPqS:t:", 0, 0,
         "[-aCeJpq] [-b buffer-index] [-E end-line] [-S start-line]"          "[-aCeJpPq] [-b buffer-index] [-E end-line] [-S start-line]"
         CMD_TARGET_PANE_USAGE,          CMD_TARGET_PANE_USAGE,
         0,          0,
         NULL,          NULL,
Line 40 
Line 46 
         cmd_capture_pane_exec          cmd_capture_pane_exec
 };  };
   
 enum cmd_retval  char *
 cmd_capture_pane_exec(struct cmd *self, struct cmd_q *cmdq)  cmd_capture_pane_append(char *buf, size_t *len, char *line, size_t linelen)
 {  {
         struct args             *args = self->args;          buf = xrealloc(buf, 1, *len + linelen + 1);
         struct client           *c;          memcpy(buf + *len, line, linelen);
         struct window_pane      *wp;          *len += linelen;
         char                    *buf, *line, *cause;          return (buf);
         struct screen           *s;  }
   
   char *
   cmd_capture_pane_pending(struct args *args, struct window_pane *wp,
       size_t *len)
   {
           char    *buf, *line, tmp[5];
           size_t   linelen;
           u_int    i;
   
           if (wp->ictx.since_ground == NULL)
                   return (xstrdup(""));
   
           line = EVBUFFER_DATA(wp->ictx.since_ground);
           linelen = EVBUFFER_LENGTH(wp->ictx.since_ground);
   
           buf = NULL;
           if (args_has(args, 'C')) {
                   for (i = 0; i < linelen; i++) {
                           if (line[i] >= ' ') {
                                   tmp[0] = line[i];
                                   tmp[1] = '\0';
                           } else
                                   xsnprintf(tmp, sizeof tmp, "\\%03o", line[i]);
                           buf = cmd_capture_pane_append(buf, len, tmp,
                               strlen(tmp));
                   }
           } else
                   buf = cmd_capture_pane_append(buf, len, line, linelen);
           return (buf);
   }
   
   char *
   cmd_capture_pane_history(struct args *args, struct cmd_q *cmdq,
       struct window_pane *wp, size_t *len)
   {
         struct grid             *gd;          struct grid             *gd;
         int                      buffer, n, with_codes, escape_c0, join_lines;  
         u_int                    i, limit, top, bottom, tmp, sx;  
         size_t                   len, linelen;  
         struct grid_cell        *gc;  
         const struct grid_line  *gl;          const struct grid_line  *gl;
           struct grid_cell        *gc = NULL;
           int                      n, with_codes, escape_c0, join_lines;
           u_int                    i, sx, top, bottom, tmp;
           char                    *cause, *buf, *line;
           size_t                   linelen;
   
         if (cmd_find_pane(cmdq, args_get(args, 't'), NULL, &wp) == NULL)          sx = screen_size_x(&wp->base);
                 return (CMD_RETURN_ERROR);  
   
         if (args_has(args, 'a')) {          if (args_has(args, 'a')) {
                 s = NULL;  
                 gd = wp->saved_grid;                  gd = wp->saved_grid;
                 sx = screen_size_x(&wp->base);                  if (gd == NULL) {
                 if (gd == NULL && !args_has(args, 'q')) {                          if (!args_has(args, 'q')) {
                         cmdq_error(cmdq, "no alternate screen");                                  cmdq_error(cmdq, "no alternate screen");
                         return (CMD_RETURN_ERROR);                                  return (NULL);
                           }
                           return (xstrdup(""));
                 }                  }
         } else {          } else
                 s = &wp->base;                  gd = wp->base.grid;
                 sx = screen_size_x(s);  
                 gd = s->grid;  
         }  
   
         buf = NULL;          n = args_strtonum(args, 'S', INT_MIN, SHRT_MAX, &cause);
         len = 0;          if (cause != NULL) {
                   top = gd->hsize;
                   free(cause);
           } else if (n < 0 && (u_int) -n > gd->hsize)
                   top = 0;
           else
                   top = gd->hsize + n;
           if (top > gd->hsize + gd->sy - 1)
                   top = gd->hsize + gd->sy - 1;
   
         if (gd != NULL) {          n = args_strtonum(args, 'E', INT_MIN, SHRT_MAX, &cause);
                 n = args_strtonum(args, 'S', INT_MIN, SHRT_MAX, &cause);          if (cause != NULL) {
                 if (cause != NULL) {                  bottom = gd->hsize + gd->sy - 1;
                         top = gd->hsize;                  free(cause);
                         free(cause);          } else if (n < 0 && (u_int) -n > gd->hsize)
                 } else if (n < 0 && (u_int) -n > gd->hsize)                  bottom = 0;
                         top = 0;          else
                 else                  bottom = gd->hsize + n;
                         top = gd->hsize + n;          if (bottom > gd->hsize + gd->sy - 1)
                 if (top > gd->hsize + gd->sy - 1)                  bottom = gd->hsize + gd->sy - 1;
                         top = gd->hsize + gd->sy - 1;  
   
                 n = args_strtonum(args, 'E', INT_MIN, SHRT_MAX, &cause);          if (bottom < top) {
                 if (cause != NULL) {                  tmp = bottom;
                         bottom = gd->hsize + gd->sy - 1;                  bottom = top;
                         free(cause);                  top = tmp;
                 } else if (n < 0 && (u_int) -n > gd->hsize)          }
                         bottom = 0;  
                 else  
                         bottom = gd->hsize + n;  
                 if (bottom > gd->hsize + gd->sy - 1)  
                         bottom = gd->hsize + gd->sy - 1;  
   
                 if (bottom < top) {          with_codes = args_has(args, 'e');
                         tmp = bottom;          escape_c0 = args_has(args, 'C');
                         bottom = top;          join_lines = args_has(args, 'J');
                         top = tmp;  
                 }  
   
                 with_codes = args_has(args, 'e');          buf = NULL;
                 escape_c0 = args_has(args, 'C');          for (i = top; i <= bottom; i++) {
                 join_lines = args_has(args, 'J');                  line = grid_string_cells(gd, 0, i, sx, &gc, with_codes,
                       escape_c0, !join_lines);
                   linelen = strlen(line);
   
                 gc = NULL;                  buf = cmd_capture_pane_append(buf, len, line, linelen);
                 for (i = top; i <= bottom; i++) {  
                         line = grid_string_cells(gd, 0, i, sx, &gc, with_codes,  
                             escape_c0, !join_lines);  
                         linelen = strlen(line);  
   
                         buf = xrealloc(buf, 1, len + linelen + 1);                  gl = grid_peek_line(gd, i);
                         memcpy(buf + len, line, linelen);                  if (!join_lines || !(gl->flags & GRID_LINE_WRAPPED))
                         len += linelen;                          buf[(*len)++] = '\n';
   
                         gl = grid_peek_line(gd, i);                  free(line);
                         if (!join_lines || !(gl->flags & GRID_LINE_WRAPPED))          }
                                 buf[len++] = '\n';          return (buf);
   }
   
                         free(line);  enum cmd_retval
                 }  cmd_capture_pane_exec(struct cmd *self, struct cmd_q *cmdq)
         } else  {
                 buf = xstrdup("");          struct args             *args = self->args;
           struct client           *c;
           struct window_pane      *wp;
           char                    *buf, *cause;
           int                      buffer;
           u_int                    limit;
           size_t                   len;
   
           if (cmd_find_pane(cmdq, args_get(args, 't'), NULL, &wp) == NULL)
                   return (CMD_RETURN_ERROR);
   
           len = 0;
           if (args_has(args, 'P'))
                   buf = cmd_capture_pane_pending(args, wp, &len);
           else
                   buf = cmd_capture_pane_history(args, cmdq, wp, &len);
           if (buf == NULL)
                   return (CMD_RETURN_ERROR);
   
         if (args_has(args, 'p')) {          if (args_has(args, 'p')) {
                 c = cmdq->client;                  c = cmdq->client;
Legend:
Removed from v.1.22  
changed lines
  Added in v.1.23