git.oblomov.eu Git - git/blob - add-patch.c

   1 #include "cache.h"
   2 #include "add-interactive.h"
   3 #include "strbuf.h"
   4 #include "run-command.h"
   5 #include "strvec.h"
   6 #include "pathspec.h"
   7 #include "color.h"
   8 #include "diff.h"
   9 #include "compat/terminal.h"
  10 #include "prompt.h"
  11
  12 enum prompt_mode_type {
  13         PROMPT_MODE_CHANGE = 0, PROMPT_DELETION, PROMPT_ADDITION, PROMPT_HUNK,
  14         PROMPT_MODE_MAX, /* must be last */
  15 };
  16
  17 struct patch_mode {
  18         /*
  19          * The magic constant 4 is chosen such that all patch modes
  20          * provide enough space for three command-line arguments followed by a
  21          * trailing `NULL`.
  22          */
  23         const char *diff_cmd[4], *apply_args[4], *apply_check_args[4];
  24         unsigned is_reverse:1, index_only:1, apply_for_checkout:1;
  25         const char *prompt_mode[PROMPT_MODE_MAX];
  26         const char *edit_hunk_hint, *help_patch_text;
  27 };
  28
  29 static struct patch_mode patch_mode_add = {
  30         .diff_cmd = { "diff-files", NULL },
  31         .apply_args = { "--cached", NULL },
  32         .apply_check_args = { "--cached", NULL },
  33         .prompt_mode = {
  34                 N_("Stage mode change [y,n,q,a,d%s,?]? "),
  35                 N_("Stage deletion [y,n,q,a,d%s,?]? "),
  36                 N_("Stage addition [y,n,q,a,d%s,?]? "),
  37                 N_("Stage this hunk [y,n,q,a,d%s,?]? ")
  38         },
  39         .edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "
  40                              "will immediately be marked for staging."),
  41         .help_patch_text =
  42                 N_("y - stage this hunk\n"
  43                    "n - do not stage this hunk\n"
  44                    "q - quit; do not stage this hunk or any of the remaining "
  45                         "ones\n"
  46                    "a - stage this hunk and all later hunks in the file\n"
  47                    "d - do not stage this hunk or any of the later hunks in "
  48                         "the file\n")
  49 };
  50
  51 static struct patch_mode patch_mode_stash = {
  52         .diff_cmd = { "diff-index", "HEAD", NULL },
  53         .apply_args = { "--cached", NULL },
  54         .apply_check_args = { "--cached", NULL },
  55         .prompt_mode = {
  56                 N_("Stash mode change [y,n,q,a,d%s,?]? "),
  57                 N_("Stash deletion [y,n,q,a,d%s,?]? "),
  58                 N_("Stash addition [y,n,q,a,d%s,?]? "),
  59                 N_("Stash this hunk [y,n,q,a,d%s,?]? "),
  60         },
  61         .edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "
  62                              "will immediately be marked for stashing."),
  63         .help_patch_text =
  64                 N_("y - stash this hunk\n"
  65                    "n - do not stash this hunk\n"
  66                    "q - quit; do not stash this hunk or any of the remaining "
  67                         "ones\n"
  68                    "a - stash this hunk and all later hunks in the file\n"
  69                    "d - do not stash this hunk or any of the later hunks in "
  70                         "the file\n"),
  71 };
  72
  73 static struct patch_mode patch_mode_reset_head = {
  74         .diff_cmd = { "diff-index", "--cached", NULL },
  75         .apply_args = { "-R", "--cached", NULL },
  76         .apply_check_args = { "-R", "--cached", NULL },
  77         .is_reverse = 1,
  78         .index_only = 1,
  79         .prompt_mode = {
  80                 N_("Unstage mode change [y,n,q,a,d%s,?]? "),
  81                 N_("Unstage deletion [y,n,q,a,d%s,?]? "),
  82                 N_("Unstage addition [y,n,q,a,d%s,?]? "),
  83                 N_("Unstage this hunk [y,n,q,a,d%s,?]? "),
  84         },
  85         .edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "
  86                              "will immediately be marked for unstaging."),
  87         .help_patch_text =
  88                 N_("y - unstage this hunk\n"
  89                    "n - do not unstage this hunk\n"
  90                    "q - quit; do not unstage this hunk or any of the remaining "
  91                         "ones\n"
  92                    "a - unstage this hunk and all later hunks in the file\n"
  93                    "d - do not unstage this hunk or any of the later hunks in "
  94                         "the file\n"),
  95 };
  96
  97 static struct patch_mode patch_mode_reset_nothead = {
  98         .diff_cmd = { "diff-index", "-R", "--cached", NULL },
  99         .apply_args = { "--cached", NULL },
 100         .apply_check_args = { "--cached", NULL },
 101         .index_only = 1,
 102         .prompt_mode = {
 103                 N_("Apply mode change to index [y,n,q,a,d%s,?]? "),
 104                 N_("Apply deletion to index [y,n,q,a,d%s,?]? "),
 105                 N_("Apply addition to index [y,n,q,a,d%s,?]? "),
 106                 N_("Apply this hunk to index [y,n,q,a,d%s,?]? "),
 107         },
 108         .edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "
 109                              "will immediately be marked for applying."),
 110         .help_patch_text =
 111                 N_("y - apply this hunk to index\n"
 112                    "n - do not apply this hunk to index\n"
 113                    "q - quit; do not apply this hunk or any of the remaining "
 114                         "ones\n"
 115                    "a - apply this hunk and all later hunks in the file\n"
 116                    "d - do not apply this hunk or any of the later hunks in "
 117                         "the file\n"),
 118 };
 119
 120 static struct patch_mode patch_mode_checkout_index = {
 121         .diff_cmd = { "diff-files", NULL },
 122         .apply_args = { "-R", NULL },
 123         .apply_check_args = { "-R", NULL },
 124         .is_reverse = 1,
 125         .prompt_mode = {
 126                 N_("Discard mode change from worktree [y,n,q,a,d%s,?]? "),
 127                 N_("Discard deletion from worktree [y,n,q,a,d%s,?]? "),
 128                 N_("Discard addition from worktree [y,n,q,a,d%s,?]? "),
 129                 N_("Discard this hunk from worktree [y,n,q,a,d%s,?]? "),
 130         },
 131         .edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "
 132                              "will immediately be marked for discarding."),
 133         .help_patch_text =
 134                 N_("y - discard this hunk from worktree\n"
 135                    "n - do not discard this hunk from worktree\n"
 136                    "q - quit; do not discard this hunk or any of the remaining "
 137                         "ones\n"
 138                    "a - discard this hunk and all later hunks in the file\n"
 139                    "d - do not discard this hunk or any of the later hunks in "
 140                         "the file\n"),
 141 };
 142
 143 static struct patch_mode patch_mode_checkout_head = {
 144         .diff_cmd = { "diff-index", NULL },
 145         .apply_for_checkout = 1,
 146         .apply_check_args = { "-R", NULL },
 147         .is_reverse = 1,
 148         .prompt_mode = {
 149                 N_("Discard mode change from index and worktree [y,n,q,a,d%s,?]? "),
 150                 N_("Discard deletion from index and worktree [y,n,q,a,d%s,?]? "),
 151                 N_("Discard addition from index and worktree [y,n,q,a,d%s,?]? "),
 152                 N_("Discard this hunk from index and worktree [y,n,q,a,d%s,?]? "),
 153         },
 154         .edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "
 155                              "will immediately be marked for discarding."),
 156         .help_patch_text =
 157                 N_("y - discard this hunk from index and worktree\n"
 158                    "n - do not discard this hunk from index and worktree\n"
 159                    "q - quit; do not discard this hunk or any of the remaining "
 160                         "ones\n"
 161                    "a - discard this hunk and all later hunks in the file\n"
 162                    "d - do not discard this hunk or any of the later hunks in "
 163                         "the file\n"),
 164 };
 165
 166 static struct patch_mode patch_mode_checkout_nothead = {
 167         .diff_cmd = { "diff-index", "-R", NULL },
 168         .apply_for_checkout = 1,
 169         .apply_check_args = { NULL },
 170         .prompt_mode = {
 171                 N_("Apply mode change to index and worktree [y,n,q,a,d%s,?]? "),
 172                 N_("Apply deletion to index and worktree [y,n,q,a,d%s,?]? "),
 173                 N_("Apply addition to index and worktree [y,n,q,a,d%s,?]? "),
 174                 N_("Apply this hunk to index and worktree [y,n,q,a,d%s,?]? "),
 175         },
 176         .edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "
 177                              "will immediately be marked for applying."),
 178         .help_patch_text =
 179                 N_("y - apply this hunk to index and worktree\n"
 180                    "n - do not apply this hunk to index and worktree\n"
 181                    "q - quit; do not apply this hunk or any of the remaining "
 182                         "ones\n"
 183                    "a - apply this hunk and all later hunks in the file\n"
 184                    "d - do not apply this hunk or any of the later hunks in "
 185                         "the file\n"),
 186 };
 187
 188 static struct patch_mode patch_mode_worktree_head = {
 189         .diff_cmd = { "diff-index", NULL },
 190         .apply_args = { "-R", NULL },
 191         .apply_check_args = { "-R", NULL },
 192         .is_reverse = 1,
 193         .prompt_mode = {
 194                 N_("Discard mode change from index and worktree [y,n,q,a,d%s,?]? "),
 195                 N_("Discard deletion from index and worktree [y,n,q,a,d%s,?]? "),
 196                 N_("Discard addition from index and worktree [y,n,q,a,d%s,?]? "),
 197                 N_("Discard this hunk from index and worktree [y,n,q,a,d%s,?]? "),
 198         },
 199         .edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "
 200                              "will immediately be marked for discarding."),
 201         .help_patch_text =
 202                 N_("y - discard this hunk from worktree\n"
 203                    "n - do not discard this hunk from worktree\n"
 204                    "q - quit; do not discard this hunk or any of the remaining "
 205                         "ones\n"
 206                    "a - discard this hunk and all later hunks in the file\n"
 207                    "d - do not discard this hunk or any of the later hunks in "
 208                         "the file\n"),
 209 };
 210
 211 static struct patch_mode patch_mode_worktree_nothead = {
 212         .diff_cmd = { "diff-index", "-R", NULL },
 213         .apply_args = { NULL },
 214         .apply_check_args = { NULL },
 215         .prompt_mode = {
 216                 N_("Apply mode change to index and worktree [y,n,q,a,d%s,?]? "),
 217                 N_("Apply deletion to index and worktree [y,n,q,a,d%s,?]? "),
 218                 N_("Apply addition to index and worktree [y,n,q,a,d%s,?]? "),
 219                 N_("Apply this hunk to index and worktree [y,n,q,a,d%s,?]? "),
 220         },
 221         .edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "
 222                              "will immediately be marked for applying."),
 223         .help_patch_text =
 224                 N_("y - apply this hunk to worktree\n"
 225                    "n - do not apply this hunk to worktree\n"
 226                    "q - quit; do not apply this hunk or any of the remaining "
 227                         "ones\n"
 228                    "a - apply this hunk and all later hunks in the file\n"
 229                    "d - do not apply this hunk or any of the later hunks in "
 230                         "the file\n"),
 231 };
 232
 233 struct hunk_header {
 234         unsigned long old_offset, old_count, new_offset, new_count;
 235         /*
 236          * Start/end offsets to the extra text after the second `@@` in the
 237          * hunk header, e.g. the function signature. This is expected to
 238          * include the newline.
 239          */
 240         size_t extra_start, extra_end, colored_extra_start, colored_extra_end;
 241 };
 242
 243 struct hunk {
 244         size_t start, end, colored_start, colored_end, splittable_into;
 245         ssize_t delta;
 246         enum { UNDECIDED_HUNK = 0, SKIP_HUNK, USE_HUNK } use;
 247         struct hunk_header header;
 248 };
 249
 250 struct add_p_state {
 251         struct add_i_state s;
 252         struct strbuf answer, buf;
 253
 254         /* parsed diff */
 255         struct strbuf plain, colored;
 256         struct file_diff {
 257                 struct hunk head;
 258                 struct hunk *hunk;
 259                 size_t hunk_nr, hunk_alloc;
 260                 unsigned deleted:1, added:1, mode_change:1,binary:1;
 261         } *file_diff;
 262         size_t file_diff_nr;
 263
 264         /* patch mode */
 265         struct patch_mode *mode;
 266         const char *revision;
 267 };
 268
 269 static void add_p_state_clear(struct add_p_state *s)
 270 {
 271         size_t i;
 272
 273         strbuf_release(&s->answer);
 274         strbuf_release(&s->buf);
 275         strbuf_release(&s->plain);
 276         strbuf_release(&s->colored);
 277         for (i = 0; i < s->file_diff_nr; i++)
 278                 free(s->file_diff[i].hunk);
 279         free(s->file_diff);
 280         clear_add_i_state(&s->s);
 281 }
 282
 283 static void err(struct add_p_state *s, const char *fmt, ...)
 284 {
 285         va_list args;
 286
 287         va_start(args, fmt);
 288         fputs(s->s.error_color, stderr);
 289         vfprintf(stderr, fmt, args);
 290         fputs(s->s.reset_color, stderr);
 291         fputc('\n', stderr);
 292         va_end(args);
 293 }
 294
 295 static void setup_child_process(struct add_p_state *s,
 296                                 struct child_process *cp, ...)
 297 {
 298         va_list ap;
 299         const char *arg;
 300
 301         va_start(ap, cp);
 302         while ((arg = va_arg(ap, const char *)))
 303                 strvec_push(&cp->args, arg);
 304         va_end(ap);
 305
 306         cp->git_cmd = 1;
 307         strvec_pushf(&cp->env_array,
 308                      INDEX_ENVIRONMENT "=%s", s->s.r->index_file);
 309 }
 310
 311 static int parse_range(const char **p,
 312                        unsigned long *offset, unsigned long *count)
 313 {
 314         char *pend;
 315
 316         *offset = strtoul(*p, &pend, 10);
 317         if (pend == *p)
 318                 return -1;
 319         if (*pend != ',') {
 320                 *count = 1;
 321                 *p = pend;
 322                 return 0;
 323         }
 324         *count = strtoul(pend + 1, (char **)p, 10);
 325         return *p == pend + 1 ? -1 : 0;
 326 }
 327
 328 static int parse_hunk_header(struct add_p_state *s, struct hunk *hunk)
 329 {
 330         struct hunk_header *header = &hunk->header;
 331         const char *line = s->plain.buf + hunk->start, *p = line;
 332         char *eol = memchr(p, '\n', s->plain.len - hunk->start);
 333
 334         if (!eol)
 335                 eol = s->plain.buf + s->plain.len;
 336
 337         if (!skip_prefix(p, "@@ -", &p) ||
 338             parse_range(&p, &header->old_offset, &header->old_count) < 0 ||
 339             !skip_prefix(p, " +", &p) ||
 340             parse_range(&p, &header->new_offset, &header->new_count) < 0 ||
 341             !skip_prefix(p, " @@", &p))
 342                 return error(_("could not parse hunk header '%.*s'"),
 343                              (int)(eol - line), line);
 344
 345         hunk->start = eol - s->plain.buf + (*eol == '\n');
 346         header->extra_start = p - s->plain.buf;
 347         header->extra_end = hunk->start;
 348
 349         if (!s->colored.len) {
 350                 header->colored_extra_start = header->colored_extra_end = 0;
 351                 return 0;
 352         }
 353
 354         /* Now find the extra text in the colored diff */
 355         line = s->colored.buf + hunk->colored_start;
 356         eol = memchr(line, '\n', s->colored.len - hunk->colored_start);
 357         if (!eol)
 358                 eol = s->colored.buf + s->colored.len;
 359         p = memmem(line, eol - line, "@@ -", 4);
 360         if (!p)
 361                 return error(_("could not parse colored hunk header '%.*s'"),
 362                              (int)(eol - line), line);
 363         p = memmem(p + 4, eol - p - 4, " @@", 3);
 364         if (!p)
 365                 return error(_("could not parse colored hunk header '%.*s'"),
 366                              (int)(eol - line), line);
 367         hunk->colored_start = eol - s->colored.buf + (*eol == '\n');
 368         header->colored_extra_start = p + 3 - s->colored.buf;
 369         header->colored_extra_end = hunk->colored_start;
 370
 371         return 0;
 372 }
 373
 374 static int is_octal(const char *p, size_t len)
 375 {
 376         if (!len)
 377                 return 0;
 378
 379         while (len--)
 380                 if (*p < '0' || *(p++) > '7')
 381                         return 0;
 382         return 1;
 383 }
 384
 385 static int parse_diff(struct add_p_state *s, const struct pathspec *ps)
 386 {
 387         struct strvec args = STRVEC_INIT;
 388         const char *diff_algorithm = s->s.interactive_diff_algorithm;
 389         struct strbuf *plain = &s->plain, *colored = NULL;
 390         struct child_process cp = CHILD_PROCESS_INIT;
 391         char *p, *pend, *colored_p = NULL, *colored_pend = NULL, marker = '\0';
 392         size_t file_diff_alloc = 0, i, color_arg_index;
 393         struct file_diff *file_diff = NULL;
 394         struct hunk *hunk = NULL;
 395         int res;
 396
 397         strvec_pushv(&args, s->mode->diff_cmd);
 398         if (diff_algorithm)
 399                 strvec_pushf(&args, "--diff-algorithm=%s", diff_algorithm);
 400         if (s->revision) {
 401                 struct object_id oid;
 402                 strvec_push(&args,
 403                             /* could be on an unborn branch */
 404                             !strcmp("HEAD", s->revision) &&
 405                             get_oid("HEAD", &oid) ?
 406                             empty_tree_oid_hex() : s->revision);
 407         }
 408         color_arg_index = args.nr;
 409         /* Use `--no-color` explicitly, just in case `diff.color = always`. */
 410         strvec_pushl(&args, "--no-color", "-p", "--", NULL);
 411         for (i = 0; i < ps->nr; i++)
 412                 strvec_push(&args, ps->items[i].original);
 413
 414         setup_child_process(s, &cp, NULL);
 415         cp.argv = args.v;
 416         res = capture_command(&cp, plain, 0);
 417         if (res) {
 418                 strvec_clear(&args);
 419                 return error(_("could not parse diff"));
 420         }
 421         if (!plain->len) {
 422                 strvec_clear(&args);
 423                 return 0;
 424         }
 425         strbuf_complete_line(plain);
 426
 427         if (want_color_fd(1, -1)) {
 428                 struct child_process colored_cp = CHILD_PROCESS_INIT;
 429                 const char *diff_filter = s->s.interactive_diff_filter;
 430
 431                 setup_child_process(s, &colored_cp, NULL);
 432                 xsnprintf((char *)args.v[color_arg_index], 8, "--color");
 433                 colored_cp.argv = args.v;
 434                 colored = &s->colored;
 435                 res = capture_command(&colored_cp, colored, 0);
 436                 strvec_clear(&args);
 437                 if (res)
 438                         return error(_("could not parse colored diff"));
 439
 440                 if (diff_filter) {
 441                         struct child_process filter_cp = CHILD_PROCESS_INIT;
 442
 443                         setup_child_process(s, &filter_cp,
 444                                             diff_filter, NULL);
 445                         filter_cp.git_cmd = 0;
 446                         filter_cp.use_shell = 1;
 447                         strbuf_reset(&s->buf);
 448                         if (pipe_command(&filter_cp,
 449                                          colored->buf, colored->len,
 450                                          &s->buf, colored->len,
 451                                          NULL, 0) < 0)
 452                                 return error(_("failed to run '%s'"),
 453                                              diff_filter);
 454                         strbuf_swap(colored, &s->buf);
 455                 }
 456
 457                 strbuf_complete_line(colored);
 458                 colored_p = colored->buf;
 459                 colored_pend = colored_p + colored->len;
 460         }
 461         strvec_clear(&args);
 462
 463         /* parse files and hunks */
 464         p = plain->buf;
 465         pend = p + plain->len;
 466         while (p != pend) {
 467                 char *eol = memchr(p, '\n', pend - p);
 468                 const char *deleted = NULL, *mode_change = NULL;
 469
 470                 if (!eol)
 471                         eol = pend;
 472
 473                 if (starts_with(p, "diff ")) {
 474                         ALLOC_GROW_BY(s->file_diff, s->file_diff_nr, 1,
 475                                    file_diff_alloc);
 476                         file_diff = s->file_diff + s->file_diff_nr - 1;
 477                         hunk = &file_diff->head;
 478                         hunk->start = p - plain->buf;
 479                         if (colored_p)
 480                                 hunk->colored_start = colored_p - colored->buf;
 481                         marker = '\0';
 482                 } else if (p == plain->buf)
 483                         BUG("diff starts with unexpected line:\n"
 484                             "%.*s\n", (int)(eol - p), p);
 485                 else if (file_diff->deleted)
 486                         ; /* keep the rest of the file in a single "hunk" */
 487                 else if (starts_with(p, "@@ ") ||
 488                          (hunk == &file_diff->head &&
 489                           (skip_prefix(p, "deleted file", &deleted)))) {
 490                         if (marker == '-' || marker == '+')
 491                                 /*
 492                                  * Should not happen; previous hunk did not end
 493                                  * in a context line? Handle it anyway.
 494                                  */
 495                                 hunk->splittable_into++;
 496
 497                         ALLOC_GROW_BY(file_diff->hunk, file_diff->hunk_nr, 1,
 498                                    file_diff->hunk_alloc);
 499                         hunk = file_diff->hunk + file_diff->hunk_nr - 1;
 500
 501                         hunk->start = p - plain->buf;
 502                         if (colored)
 503                                 hunk->colored_start = colored_p - colored->buf;
 504
 505                         if (deleted)
 506                                 file_diff->deleted = 1;
 507                         else if (parse_hunk_header(s, hunk) < 0)
 508                                 return -1;
 509
 510                         /*
 511                          * Start counting into how many hunks this one can be
 512                          * split
 513                          */
 514                         marker = *p;
 515                 } else if (hunk == &file_diff->head &&
 516                            starts_with(p, "new file")) {
 517                         file_diff->added = 1;
 518                 } else if (hunk == &file_diff->head &&
 519                            skip_prefix(p, "old mode ", &mode_change) &&
 520                            is_octal(mode_change, eol - mode_change)) {
 521                         if (file_diff->mode_change)
 522                                 BUG("double mode change?\n\n%.*s",
 523                                     (int)(eol - plain->buf), plain->buf);
 524                         if (file_diff->hunk_nr)
 525                                 BUG("mode change in the middle?\n\n%.*s",
 526                                     (int)(eol - plain->buf), plain->buf);
 527
 528                         /*
 529                          * Do *not* change `hunk`: the mode change pseudo-hunk
 530                          * is _part of_ the header "hunk".
 531                          */
 532                         file_diff->mode_change = 1;
 533                         ALLOC_GROW_BY(file_diff->hunk, file_diff->hunk_nr, 1,
 534                                    file_diff->hunk_alloc);
 535                         file_diff->hunk->start = p - plain->buf;
 536                         if (colored_p)
 537                                 file_diff->hunk->colored_start =
 538                                         colored_p - colored->buf;
 539                 } else if (hunk == &file_diff->head &&
 540                            skip_prefix(p, "new mode ", &mode_change) &&
 541                            is_octal(mode_change, eol - mode_change)) {
 542
 543                         /*
 544                          * Extend the "mode change" pseudo-hunk to include also
 545                          * the "new mode" line.
 546                          */
 547                         if (!file_diff->mode_change)
 548                                 BUG("'new mode' without 'old mode'?\n\n%.*s",
 549                                     (int)(eol - plain->buf), plain->buf);
 550                         if (file_diff->hunk_nr != 1)
 551                                 BUG("mode change in the middle?\n\n%.*s",
 552                                     (int)(eol - plain->buf), plain->buf);
 553                         if (p - plain->buf != file_diff->hunk->end)
 554                                 BUG("'new mode' does not immediately follow "
 555                                     "'old mode'?\n\n%.*s",
 556                                     (int)(eol - plain->buf), plain->buf);
 557                 } else if (hunk == &file_diff->head &&
 558                            starts_with(p, "Binary files "))
 559                         file_diff->binary = 1;
 560
 561                 if (!!file_diff->deleted + !!file_diff->added +
 562                     !!file_diff->mode_change > 1)
 563                         BUG("diff can only contain delete *or* add *or* a "
 564                             "mode change?!?\n%.*s",
 565                             (int)(eol - (plain->buf + file_diff->head.start)),
 566                             plain->buf + file_diff->head.start);
 567
 568                 if ((marker == '-' || marker == '+') && *p == ' ')
 569                         hunk->splittable_into++;
 570                 if (marker && *p != '\\')
 571                         marker = *p;
 572
 573                 p = eol == pend ? pend : eol + 1;
 574                 hunk->end = p - plain->buf;
 575
 576                 if (colored) {
 577                         char *colored_eol = memchr(colored_p, '\n',
 578                                                    colored_pend - colored_p);
 579                         if (colored_eol)
 580                                 colored_p = colored_eol + 1;
 581                         else if (p != pend)
 582                                 /* colored shorter than non-colored? */
 583                                 goto mismatched_output;
 584                         else
 585                                 colored_p = colored_pend;
 586
 587                         hunk->colored_end = colored_p - colored->buf;
 588                 }
 589
 590                 if (mode_change) {
 591                         if (file_diff->hunk_nr != 1)
 592                                 BUG("mode change in hunk #%d???",
 593                                     (int)file_diff->hunk_nr);
 594                         /* Adjust the end of the "mode change" pseudo-hunk */
 595                         file_diff->hunk->end = hunk->end;
 596                         if (colored)
 597                                 file_diff->hunk->colored_end = hunk->colored_end;
 598                 }
 599         }
 600
 601         if (marker == '-' || marker == '+')
 602                 /*
 603                  * Last hunk ended in non-context line (i.e. it appended lines
 604                  * to the file, so there are no trailing context lines).
 605                  */
 606                 hunk->splittable_into++;
 607
 608         /* non-colored shorter than colored? */
 609         if (colored_p != colored_pend) {
 610 mismatched_output:
 611                 error(_("mismatched output from interactive.diffFilter"));
 612                 advise(_("Your filter must maintain a one-to-one correspondence\n"
 613                          "between its input and output lines."));
 614                 return -1;
 615         }
 616
 617         return 0;
 618 }
 619
 620 static size_t find_next_line(struct strbuf *sb, size_t offset)
 621 {
 622         char *eol;
 623
 624         if (offset >= sb->len)
 625                 BUG("looking for next line beyond buffer (%d >= %d)\n%s",
 626                     (int)offset, (int)sb->len, sb->buf);
 627
 628         eol = memchr(sb->buf + offset, '\n', sb->len - offset);
 629         if (!eol)
 630                 return sb->len;
 631         return eol - sb->buf + 1;
 632 }
 633
 634 static void render_hunk(struct add_p_state *s, struct hunk *hunk,
 635                         ssize_t delta, int colored, struct strbuf *out)
 636 {
 637         struct hunk_header *header = &hunk->header;
 638
 639         if (hunk->header.old_offset != 0 || hunk->header.new_offset != 0) {
 640                 /*
 641                  * Generate the hunk header dynamically, except for special
 642                  * hunks (such as the diff header).
 643                  */
 644                 const char *p;
 645                 size_t len;
 646                 unsigned long old_offset = header->old_offset;
 647                 unsigned long new_offset = header->new_offset;
 648
 649                 if (!colored) {
 650                         p = s->plain.buf + header->extra_start;
 651                         len = header->extra_end - header->extra_start;
 652                 } else {
 653                         strbuf_addstr(out, s->s.fraginfo_color);
 654                         p = s->colored.buf + header->colored_extra_start;
 655                         len = header->colored_extra_end
 656                                 - header->colored_extra_start;
 657                 }
 658
 659                 if (s->mode->is_reverse)
 660                         old_offset -= delta;
 661                 else
 662                         new_offset += delta;
 663
 664                 strbuf_addf(out, "@@ -%lu", old_offset);
 665                 if (header->old_count != 1)
 666                         strbuf_addf(out, ",%lu", header->old_count);
 667                 strbuf_addf(out, " +%lu", new_offset);
 668                 if (header->new_count != 1)
 669                         strbuf_addf(out, ",%lu", header->new_count);
 670                 strbuf_addstr(out, " @@");
 671
 672                 if (len)
 673                         strbuf_add(out, p, len);
 674                 else if (colored)
 675                         strbuf_addf(out, "%s\n", s->s.reset_color);
 676                 else
 677                         strbuf_addch(out, '\n');
 678         }
 679
 680         if (colored)
 681                 strbuf_add(out, s->colored.buf + hunk->colored_start,
 682                            hunk->colored_end - hunk->colored_start);
 683         else
 684                 strbuf_add(out, s->plain.buf + hunk->start,
 685                            hunk->end - hunk->start);
 686 }
 687
 688 static void render_diff_header(struct add_p_state *s,
 689                                struct file_diff *file_diff, int colored,
 690                                struct strbuf *out)
 691 {
 692         /*
 693          * If there was a mode change, the first hunk is a pseudo hunk that
 694          * corresponds to the mode line in the header. If the user did not want
 695          * to stage that "hunk", we actually have to cut it out from the header.
 696          */
 697         int skip_mode_change =
 698                 file_diff->mode_change && file_diff->hunk->use != USE_HUNK;
 699         struct hunk *head = &file_diff->head, *first = file_diff->hunk;
 700
 701         if (!skip_mode_change) {
 702                 render_hunk(s, head, 0, colored, out);
 703                 return;
 704         }
 705
 706         if (colored) {
 707                 const char *p = s->colored.buf;
 708
 709                 strbuf_add(out, p + head->colored_start,
 710                             first->colored_start - head->colored_start);
 711                 strbuf_add(out, p + first->colored_end,
 712                             head->colored_end - first->colored_end);
 713         } else {
 714                 const char *p = s->plain.buf;
 715
 716                 strbuf_add(out, p + head->start, first->start - head->start);
 717                 strbuf_add(out, p + first->end, head->end - first->end);
 718         }
 719 }
 720
 721 /* Coalesce hunks again that were split */
 722 static int merge_hunks(struct add_p_state *s, struct file_diff *file_diff,
 723                        size_t *hunk_index, int use_all, struct hunk *merged)
 724 {
 725         size_t i = *hunk_index, delta;
 726         struct hunk *hunk = file_diff->hunk + i;
 727         /* `header` corresponds to the merged hunk */
 728         struct hunk_header *header = &merged->header, *next;
 729
 730         if (!use_all && hunk->use != USE_HUNK)
 731                 return 0;
 732
 733         *merged = *hunk;
 734         /* We simply skip the colored part (if any) when merging hunks */
 735         merged->colored_start = merged->colored_end = 0;
 736
 737         for (; i + 1 < file_diff->hunk_nr; i++) {
 738                 hunk++;
 739                 next = &hunk->header;
 740
 741                 /*
 742                  * Stop merging hunks when:
 743                  *
 744                  * - the hunk is not selected for use, or
 745                  * - the hunk does not overlap with the already-merged hunk(s)
 746                  */
 747                 if ((!use_all && hunk->use != USE_HUNK) ||
 748                     header->new_offset >= next->new_offset + merged->delta ||
 749                     header->new_offset + header->new_count
 750                     < next->new_offset + merged->delta)
 751                         break;
 752
 753                 /*
 754                  * If the hunks were not edited, and overlap, we can simply
 755                  * extend the line range.
 756                  */
 757                 if (merged->start < hunk->start && merged->end > hunk->start) {
 758                         merged->end = hunk->end;
 759                         merged->colored_end = hunk->colored_end;
 760                         delta = 0;
 761                 } else {
 762                         const char *plain = s->plain.buf;
 763                         size_t  overlapping_line_count = header->new_offset
 764                                 + header->new_count - merged->delta
 765                                 - next->new_offset;
 766                         size_t overlap_end = hunk->start;
 767                         size_t overlap_start = overlap_end;
 768                         size_t overlap_next, len, j;
 769
 770                         /*
 771                          * One of the hunks was edited: the modified hunk was
 772                          * appended to the strbuf `s->plain`.
 773                          *
 774                          * Let's ensure that at least the last context line of
 775                          * the first hunk overlaps with the corresponding line
 776                          * of the second hunk, and then merge.
 777                          */
 778                         for (j = 0; j < overlapping_line_count; j++) {
 779                                 overlap_next = find_next_line(&s->plain,
 780                                                               overlap_end);
 781
 782                                 if (overlap_next > hunk->end)
 783                                         BUG("failed to find %d context lines "
 784                                             "in:\n%.*s",
 785                                             (int)overlapping_line_count,
 786                                             (int)(hunk->end - hunk->start),
 787                                             plain + hunk->start);
 788
 789                                 if (plain[overlap_end] != ' ')
 790                                         return error(_("expected context line "
 791                                                        "#%d in\n%.*s"),
 792                                                      (int)(j + 1),
 793                                                      (int)(hunk->end
 794                                                            - hunk->start),
 795                                                      plain + hunk->start);
 796
 797                                 overlap_start = overlap_end;
 798                                 overlap_end = overlap_next;
 799                         }
 800                         len = overlap_end - overlap_start;
 801
 802                         if (len > merged->end - merged->start ||
 803                             memcmp(plain + merged->end - len,
 804                                    plain + overlap_start, len))
 805                                 return error(_("hunks do not overlap:\n%.*s\n"
 806                                                "\tdoes not end with:\n%.*s"),
 807                                              (int)(merged->end - merged->start),
 808                                              plain + merged->start,
 809                                              (int)len, plain + overlap_start);
 810
 811                         /*
 812                          * Since the start-end ranges are not adjacent, we
 813                          * cannot simply take the union of the ranges. To
 814                          * address that, we temporarily append the union of the
 815                          * lines to the `plain` strbuf.
 816                          */
 817                         if (merged->end != s->plain.len) {
 818                                 size_t start = s->plain.len;
 819
 820                                 strbuf_add(&s->plain, plain + merged->start,
 821                                            merged->end - merged->start);
 822                                 plain = s->plain.buf;
 823                                 merged->start = start;
 824                                 merged->end = s->plain.len;
 825                         }
 826
 827                         strbuf_add(&s->plain,
 828                                    plain + overlap_end,
 829                                    hunk->end - overlap_end);
 830                         merged->end = s->plain.len;
 831                         merged->splittable_into += hunk->splittable_into;
 832                         delta = merged->delta;
 833                         merged->delta += hunk->delta;
 834                 }
 835
 836                 header->old_count = next->old_offset + next->old_count
 837                         - header->old_offset;
 838                 header->new_count = next->new_offset + delta
 839                         + next->new_count - header->new_offset;
 840         }
 841
 842         if (i == *hunk_index)
 843                 return 0;
 844
 845         *hunk_index = i;
 846         return 1;
 847 }
 848
 849 static void reassemble_patch(struct add_p_state *s,
 850                              struct file_diff *file_diff, int use_all,
 851                              struct strbuf *out)
 852 {
 853         struct hunk *hunk;
 854         size_t save_len = s->plain.len, i;
 855         ssize_t delta = 0;
 856
 857         render_diff_header(s, file_diff, 0, out);
 858
 859         for (i = file_diff->mode_change; i < file_diff->hunk_nr; i++) {
 860                 struct hunk merged = { 0 };
 861
 862                 hunk = file_diff->hunk + i;
 863                 if (!use_all && hunk->use != USE_HUNK)
 864                         delta += hunk->header.old_count
 865                                 - hunk->header.new_count;
 866                 else {
 867                         /* merge overlapping hunks into a temporary hunk */
 868                         if (merge_hunks(s, file_diff, &i, use_all, &merged))
 869                                 hunk = &merged;
 870
 871                         render_hunk(s, hunk, delta, 0, out);
 872
 873                         /*
 874                          * In case `merge_hunks()` used `plain` as a scratch
 875                          * pad (this happens when an edited hunk had to be
 876                          * coalesced with another hunk).
 877                          */
 878                         strbuf_setlen(&s->plain, save_len);
 879
 880                         delta += hunk->delta;
 881                 }
 882         }
 883 }
 884
 885 static int split_hunk(struct add_p_state *s, struct file_diff *file_diff,
 886                        size_t hunk_index)
 887 {
 888         int colored = !!s->colored.len, first = 1;
 889         struct hunk *hunk = file_diff->hunk + hunk_index;
 890         size_t splittable_into;
 891         size_t end, colored_end, current, colored_current = 0, context_line_count;
 892         struct hunk_header remaining, *header;
 893         char marker, ch;
 894
 895         if (hunk_index >= file_diff->hunk_nr)
 896                 BUG("invalid hunk index: %d (must be >= 0 and < %d)",
 897                     (int)hunk_index, (int)file_diff->hunk_nr);
 898
 899         if (hunk->splittable_into < 2)
 900                 return 0;
 901         splittable_into = hunk->splittable_into;
 902
 903         end = hunk->end;
 904         colored_end = hunk->colored_end;
 905
 906         remaining = hunk->header;
 907
 908         file_diff->hunk_nr += splittable_into - 1;
 909         ALLOC_GROW(file_diff->hunk, file_diff->hunk_nr, file_diff->hunk_alloc);
 910         if (hunk_index + splittable_into < file_diff->hunk_nr)
 911                 memmove(file_diff->hunk + hunk_index + splittable_into,
 912                         file_diff->hunk + hunk_index + 1,
 913                         (file_diff->hunk_nr - hunk_index - splittable_into)
 914                         * sizeof(*hunk));
 915         hunk = file_diff->hunk + hunk_index;
 916         hunk->splittable_into = 1;
 917         memset(hunk + 1, 0, (splittable_into - 1) * sizeof(*hunk));
 918
 919         header = &hunk->header;
 920         header->old_count = header->new_count = 0;
 921
 922         current = hunk->start;
 923         if (colored)
 924                 colored_current = hunk->colored_start;
 925         marker = '\0';
 926         context_line_count = 0;
 927
 928         while (splittable_into > 1) {
 929                 ch = s->plain.buf[current];
 930
 931                 if (!ch)
 932                         BUG("buffer overrun while splitting hunks");
 933
 934                 /*
 935                  * Is this the first context line after a chain of +/- lines?
 936                  * Then record the start of the next split hunk.
 937                  */
 938                 if ((marker == '-' || marker == '+') && ch == ' ') {
 939                         first = 0;
 940                         hunk[1].start = current;
 941                         if (colored)
 942                                 hunk[1].colored_start = colored_current;
 943                         context_line_count = 0;
 944                 }
 945
 946                 /*
 947                  * Was the previous line a +/- one? Alternatively, is this the
 948                  * first line (and not a +/- one)?
 949                  *
 950                  * Then just increment the appropriate counter and continue
 951                  * with the next line.
 952                  */
 953                 if (marker != ' ' || (ch != '-' && ch != '+')) {
 954 next_hunk_line:
 955                         /* Comment lines are attached to the previous line */
 956                         if (ch == '\\')
 957                                 ch = marker ? marker : ' ';
 958
 959                         /* current hunk not done yet */
 960                         if (ch == ' ')
 961                                 context_line_count++;
 962                         else if (ch == '-')
 963                                 header->old_count++;
 964                         else if (ch == '+')
 965                                 header->new_count++;
 966                         else
 967                                 BUG("unhandled diff marker: '%c'", ch);
 968                         marker = ch;
 969                         current = find_next_line(&s->plain, current);
 970                         if (colored)
 971                                 colored_current =
 972                                         find_next_line(&s->colored,
 973                                                        colored_current);
 974                         continue;
 975                 }
 976
 977                 /*
 978                  * We got us the start of a new hunk!
 979                  *
 980                  * This is a context line, so it is shared with the previous
 981                  * hunk, if any.
 982                  */
 983
 984                 if (first) {
 985                         if (header->old_count || header->new_count)
 986                                 BUG("counts are off: %d/%d",
 987                                     (int)header->old_count,
 988                                     (int)header->new_count);
 989
 990                         header->old_count = context_line_count;
 991                         header->new_count = context_line_count;
 992                         context_line_count = 0;
 993                         first = 0;
 994                         goto next_hunk_line;
 995                 }
 996
 997                 remaining.old_offset += header->old_count;
 998                 remaining.old_count -= header->old_count;
 999                 remaining.new_offset += header->new_count;
1000                 remaining.new_count -= header->new_count;
1001
1002                 /* initialize next hunk header's offsets */
1003                 hunk[1].header.old_offset =
1004                         header->old_offset + header->old_count;
1005                 hunk[1].header.new_offset =
1006                         header->new_offset + header->new_count;
1007
1008                 /* add one split hunk */
1009                 header->old_count += context_line_count;
1010                 header->new_count += context_line_count;
1011
1012                 hunk->end = current;
1013                 if (colored)
1014                         hunk->colored_end = colored_current;
1015
1016                 hunk++;
1017                 hunk->splittable_into = 1;
1018                 hunk->use = hunk[-1].use;
1019                 header = &hunk->header;
1020
1021                 header->old_count = header->new_count = context_line_count;
1022                 context_line_count = 0;
1023
1024                 splittable_into--;
1025                 marker = ch;
1026         }
1027
1028         /* last hunk simply gets the rest */
1029         if (header->old_offset != remaining.old_offset)
1030                 BUG("miscounted old_offset: %lu != %lu",
1031                     header->old_offset, remaining.old_offset);
1032         if (header->new_offset != remaining.new_offset)
1033                 BUG("miscounted new_offset: %lu != %lu",
1034                     header->new_offset, remaining.new_offset);
1035         header->old_count = remaining.old_count;
1036         header->new_count = remaining.new_count;
1037         hunk->end = end;
1038         if (colored)
1039                 hunk->colored_end = colored_end;
1040
1041         return 0;
1042 }
1043
1044 static void recolor_hunk(struct add_p_state *s, struct hunk *hunk)
1045 {
1046         const char *plain = s->plain.buf;
1047         size_t current, eol, next;
1048
1049         if (!s->colored.len)
1050                 return;
1051
1052         hunk->colored_start = s->colored.len;
1053         for (current = hunk->start; current < hunk->end; ) {
1054                 for (eol = current; eol < hunk->end; eol++)
1055                         if (plain[eol] == '\n')
1056                                 break;
1057                 next = eol + (eol < hunk->end);
1058                 if (eol > current && plain[eol - 1] == '\r')
1059                         eol--;
1060
1061                 strbuf_addstr(&s->colored,
1062                               plain[current] == '-' ?
1063                               s->s.file_old_color :
1064                               plain[current] == '+' ?
1065                               s->s.file_new_color :
1066                               s->s.context_color);
1067                 strbuf_add(&s->colored, plain + current, eol - current);
1068                 strbuf_addstr(&s->colored, s->s.reset_color);
1069                 if (next > eol)
1070                         strbuf_add(&s->colored, plain + eol, next - eol);
1071                 current = next;
1072         }
1073         hunk->colored_end = s->colored.len;
1074 }
1075
1076 static int edit_hunk_manually(struct add_p_state *s, struct hunk *hunk)
1077 {
1078         size_t i;
1079
1080         strbuf_reset(&s->buf);
1081         strbuf_commented_addf(&s->buf, _("Manual hunk edit mode -- see bottom for "
1082                                       "a quick guide.\n"));
1083         render_hunk(s, hunk, 0, 0, &s->buf);
1084         strbuf_commented_addf(&s->buf,
1085                               _("---\n"
1086                                 "To remove '%c' lines, make them ' ' lines "
1087                                 "(context).\n"
1088                                 "To remove '%c' lines, delete them.\n"
1089                                 "Lines starting with %c will be removed.\n"),
1090                               s->mode->is_reverse ? '+' : '-',
1091                               s->mode->is_reverse ? '-' : '+',
1092                               comment_line_char);
1093         strbuf_commented_addf(&s->buf, "%s", _(s->mode->edit_hunk_hint));
1094         /*
1095          * TRANSLATORS: 'it' refers to the patch mentioned in the previous
1096          * messages.
1097          */
1098         strbuf_commented_addf(&s->buf,
1099                               _("If it does not apply cleanly, you will be "
1100                                 "given an opportunity to\n"
1101                                 "edit again.  If all lines of the hunk are "
1102                                 "removed, then the edit is\n"
1103                                 "aborted and the hunk is left unchanged.\n"));
1104
1105         if (strbuf_edit_interactively(&s->buf, "addp-hunk-edit.diff", NULL) < 0)
1106                 return -1;
1107
1108         /* strip out commented lines */
1109         hunk->start = s->plain.len;
1110         for (i = 0; i < s->buf.len; ) {
1111                 size_t next = find_next_line(&s->buf, i);
1112
1113                 if (s->buf.buf[i] != comment_line_char)
1114                         strbuf_add(&s->plain, s->buf.buf + i, next - i);
1115                 i = next;
1116         }
1117
1118         hunk->end = s->plain.len;
1119         if (hunk->end == hunk->start)
1120                 /* The user aborted editing by deleting everything */
1121                 return 0;
1122
1123         recolor_hunk(s, hunk);
1124
1125         /*
1126          * If the hunk header is intact, parse it, otherwise simply use the
1127          * hunk header prior to editing (which will adjust `hunk->start` to
1128          * skip the hunk header).
1129          */
1130         if (s->plain.buf[hunk->start] == '@' &&
1131             parse_hunk_header(s, hunk) < 0)
1132                 return error(_("could not parse hunk header"));
1133
1134         return 1;
1135 }
1136
1137 static ssize_t recount_edited_hunk(struct add_p_state *s, struct hunk *hunk,
1138                                    size_t orig_old_count, size_t orig_new_count)
1139 {
1140         struct hunk_header *header = &hunk->header;
1141         size_t i;
1142
1143         header->old_count = header->new_count = 0;
1144         for (i = hunk->start; i < hunk->end; ) {
1145                 switch (s->plain.buf[i]) {
1146                 case '-':
1147                         header->old_count++;
1148                         break;
1149                 case '+':
1150                         header->new_count++;
1151                         break;
1152                 case ' ': case '\r': case '\n':
1153                         header->old_count++;
1154                         header->new_count++;
1155                         break;
1156                 }
1157
1158                 i = find_next_line(&s->plain, i);
1159         }
1160
1161         return orig_old_count - orig_new_count
1162                 - header->old_count + header->new_count;
1163 }
1164
1165 static int run_apply_check(struct add_p_state *s,
1166                            struct file_diff *file_diff)
1167 {
1168         struct child_process cp = CHILD_PROCESS_INIT;
1169
1170         strbuf_reset(&s->buf);
1171         reassemble_patch(s, file_diff, 1, &s->buf);
1172
1173         setup_child_process(s, &cp,
1174                             "apply", "--check", NULL);
1175         strvec_pushv(&cp.args, s->mode->apply_check_args);
1176         if (pipe_command(&cp, s->buf.buf, s->buf.len, NULL, 0, NULL, 0))
1177                 return error(_("'git apply --cached' failed"));
1178
1179         return 0;
1180 }
1181
1182 static int read_single_character(struct add_p_state *s)
1183 {
1184         if (s->s.use_single_key) {
1185                 int res = read_key_without_echo(&s->answer);
1186                 printf("%s\n", res == EOF ? "" : s->answer.buf);
1187                 return res;
1188         }
1189
1190         if (git_read_line_interactively(&s->answer) == EOF)
1191                 return EOF;
1192         return 0;
1193 }
1194
1195 static int prompt_yesno(struct add_p_state *s, const char *prompt)
1196 {
1197         for (;;) {
1198                 color_fprintf(stdout, s->s.prompt_color, "%s", _(prompt));
1199                 fflush(stdout);
1200                 if (read_single_character(s) == EOF)
1201                         return -1;
1202                 switch (tolower(s->answer.buf[0])) {
1203                 case 'n': return 0;
1204                 case 'y': return 1;
1205                 }
1206         }
1207 }
1208
1209 static int edit_hunk_loop(struct add_p_state *s,
1210                           struct file_diff *file_diff, struct hunk *hunk)
1211 {
1212         size_t plain_len = s->plain.len, colored_len = s->colored.len;
1213         struct hunk backup;
1214
1215         backup = *hunk;
1216
1217         for (;;) {
1218                 int res = edit_hunk_manually(s, hunk);
1219                 if (res == 0) {
1220                         /* abandoned */
1221                         *hunk = backup;
1222                         return -1;
1223                 }
1224
1225                 if (res > 0) {
1226                         hunk->delta +=
1227                                 recount_edited_hunk(s, hunk,
1228                                                     backup.header.old_count,
1229                                                     backup.header.new_count);
1230                         if (!run_apply_check(s, file_diff))
1231                                 return 0;
1232                 }
1233
1234                 /* Drop edits (they were appended to s->plain) */
1235                 strbuf_setlen(&s->plain, plain_len);
1236                 strbuf_setlen(&s->colored, colored_len);
1237                 *hunk = backup;
1238
1239                 /*
1240                  * TRANSLATORS: do not translate [y/n]
1241                  * The program will only accept that input at this point.
1242                  * Consider translating (saying "no" discards!) as
1243                  * (saying "n" for "no" discards!) if the translation
1244                  * of the word "no" does not start with n.
1245                  */
1246                 res = prompt_yesno(s, _("Your edited hunk does not apply. "
1247                                         "Edit again (saying \"no\" discards!) "
1248                                         "[y/n]? "));
1249                 if (res < 1)
1250                         return -1;
1251         }
1252 }
1253
1254 static int apply_for_checkout(struct add_p_state *s, struct strbuf *diff,
1255                               int is_reverse)
1256 {
1257         const char *reverse = is_reverse ? "-R" : NULL;
1258         struct child_process check_index = CHILD_PROCESS_INIT;
1259         struct child_process check_worktree = CHILD_PROCESS_INIT;
1260         struct child_process apply_index = CHILD_PROCESS_INIT;
1261         struct child_process apply_worktree = CHILD_PROCESS_INIT;
1262         int applies_index, applies_worktree;
1263
1264         setup_child_process(s, &check_index,
1265                             "apply", "--cached", "--check", reverse, NULL);
1266         applies_index = !pipe_command(&check_index, diff->buf, diff->len,
1267                                       NULL, 0, NULL, 0);
1268
1269         setup_child_process(s, &check_worktree,
1270                             "apply", "--check", reverse, NULL);
1271         applies_worktree = !pipe_command(&check_worktree, diff->buf, diff->len,
1272                                          NULL, 0, NULL, 0);
1273
1274         if (applies_worktree && applies_index) {
1275                 setup_child_process(s, &apply_index,
1276                                     "apply", "--cached", reverse, NULL);
1277                 pipe_command(&apply_index, diff->buf, diff->len,
1278                              NULL, 0, NULL, 0);
1279
1280                 setup_child_process(s, &apply_worktree,
1281                                     "apply", reverse, NULL);
1282                 pipe_command(&apply_worktree, diff->buf, diff->len,
1283                              NULL, 0, NULL, 0);
1284
1285                 return 1;
1286         }
1287
1288         if (!applies_index) {
1289                 err(s, _("The selected hunks do not apply to the index!"));
1290                 if (prompt_yesno(s, _("Apply them to the worktree "
1291                                           "anyway? ")) > 0) {
1292                         setup_child_process(s, &apply_worktree,
1293                                             "apply", reverse, NULL);
1294                         return pipe_command(&apply_worktree, diff->buf,
1295                                             diff->len, NULL, 0, NULL, 0);
1296                 }
1297                 err(s, _("Nothing was applied.\n"));
1298         } else
1299                 /* As a last resort, show the diff to the user */
1300                 fwrite(diff->buf, diff->len, 1, stderr);
1301
1302         return 0;
1303 }
1304
1305 #define SUMMARY_HEADER_WIDTH 20
1306 #define SUMMARY_LINE_WIDTH 80
1307 static void summarize_hunk(struct add_p_state *s, struct hunk *hunk,
1308                            struct strbuf *out)
1309 {
1310         struct hunk_header *header = &hunk->header;
1311         struct strbuf *plain = &s->plain;
1312         size_t len = out->len, i;
1313
1314         strbuf_addf(out, " -%lu,%lu +%lu,%lu ",
1315                     header->old_offset, header->old_count,
1316                     header->new_offset, header->new_count);
1317         if (out->len - len < SUMMARY_HEADER_WIDTH)
1318                 strbuf_addchars(out, ' ',
1319                                 SUMMARY_HEADER_WIDTH + len - out->len);
1320         for (i = hunk->start; i < hunk->end; i = find_next_line(plain, i))
1321                 if (plain->buf[i] != ' ')
1322                         break;
1323         if (i < hunk->end)
1324                 strbuf_add(out, plain->buf + i, find_next_line(plain, i) - i);
1325         if (out->len - len > SUMMARY_LINE_WIDTH)
1326                 strbuf_setlen(out, len + SUMMARY_LINE_WIDTH);
1327         strbuf_complete_line(out);
1328 }
1329
1330 #define DISPLAY_HUNKS_LINES 20
1331 static size_t display_hunks(struct add_p_state *s,
1332                             struct file_diff *file_diff, size_t start_index)
1333 {
1334         size_t end_index = start_index + DISPLAY_HUNKS_LINES;
1335
1336         if (end_index > file_diff->hunk_nr)
1337                 end_index = file_diff->hunk_nr;
1338
1339         while (start_index < end_index) {
1340                 struct hunk *hunk = file_diff->hunk + start_index++;
1341
1342                 strbuf_reset(&s->buf);
1343                 strbuf_addf(&s->buf, "%c%2d: ", hunk->use == USE_HUNK ? '+'
1344                             : hunk->use == SKIP_HUNK ? '-' : ' ',
1345                             (int)start_index);
1346                 summarize_hunk(s, hunk, &s->buf);
1347                 fputs(s->buf.buf, stdout);
1348         }
1349
1350         return end_index;
1351 }
1352
1353 static const char help_patch_remainder[] =
1354 N_("j - leave this hunk undecided, see next undecided hunk\n"
1355    "J - leave this hunk undecided, see next hunk\n"
1356    "k - leave this hunk undecided, see previous undecided hunk\n"
1357    "K - leave this hunk undecided, see previous hunk\n"
1358    "g - select a hunk to go to\n"
1359    "/ - search for a hunk matching the given regex\n"
1360    "s - split the current hunk into smaller hunks\n"
1361    "e - manually edit the current hunk\n"
1362    "? - print help\n");
1363
1364 static int patch_update_file(struct add_p_state *s,
1365                              struct file_diff *file_diff)
1366 {
1367         size_t hunk_index = 0;
1368         ssize_t i, undecided_previous, undecided_next;
1369         struct hunk *hunk;
1370         char ch;
1371         struct child_process cp = CHILD_PROCESS_INIT;
1372         int colored = !!s->colored.len, quit = 0;
1373         enum prompt_mode_type prompt_mode_type;
1374         enum {
1375                 ALLOW_GOTO_PREVIOUS_HUNK = 1 << 0,
1376                 ALLOW_GOTO_PREVIOUS_UNDECIDED_HUNK = 1 << 1,
1377                 ALLOW_GOTO_NEXT_HUNK = 1 << 2,
1378                 ALLOW_GOTO_NEXT_UNDECIDED_HUNK = 1 << 3,
1379                 ALLOW_SEARCH_AND_GOTO = 1 << 4,
1380                 ALLOW_SPLIT = 1 << 5,
1381                 ALLOW_EDIT = 1 << 6
1382         } permitted = 0;
1383
1384         /* Empty added files have no hunks */
1385         if (!file_diff->hunk_nr && !file_diff->added)
1386                 return 0;
1387
1388         strbuf_reset(&s->buf);
1389         render_diff_header(s, file_diff, colored, &s->buf);
1390         fputs(s->buf.buf, stdout);
1391         for (;;) {
1392                 if (hunk_index >= file_diff->hunk_nr)
1393                         hunk_index = 0;
1394                 hunk = file_diff->hunk_nr
1395                                 ? file_diff->hunk + hunk_index
1396                                 : &file_diff->head;
1397                 undecided_previous = -1;
1398                 undecided_next = -1;
1399
1400                 if (file_diff->hunk_nr) {
1401                         for (i = hunk_index - 1; i >= 0; i--)
1402                                 if (file_diff->hunk[i].use == UNDECIDED_HUNK) {
1403                                         undecided_previous = i;
1404                                         break;
1405                                 }
1406
1407                         for (i = hunk_index + 1; i < file_diff->hunk_nr; i++)
1408                                 if (file_diff->hunk[i].use == UNDECIDED_HUNK) {
1409                                         undecided_next = i;
1410                                         break;
1411                                 }
1412                 }
1413
1414                 /* Everything decided? */
1415                 if (undecided_previous < 0 && undecided_next < 0 &&
1416                     hunk->use != UNDECIDED_HUNK)
1417                         break;
1418
1419                 strbuf_reset(&s->buf);
1420                 if (file_diff->hunk_nr) {
1421                         render_hunk(s, hunk, 0, colored, &s->buf);
1422                         fputs(s->buf.buf, stdout);
1423
1424                         strbuf_reset(&s->buf);
1425                         if (undecided_previous >= 0) {
1426                                 permitted |= ALLOW_GOTO_PREVIOUS_UNDECIDED_HUNK;
1427                                 strbuf_addstr(&s->buf, ",k");
1428                         }
1429                         if (hunk_index) {
1430                                 permitted |= ALLOW_GOTO_PREVIOUS_HUNK;
1431                                 strbuf_addstr(&s->buf, ",K");
1432                         }
1433                         if (undecided_next >= 0) {
1434                                 permitted |= ALLOW_GOTO_NEXT_UNDECIDED_HUNK;
1435                                 strbuf_addstr(&s->buf, ",j");
1436                         }
1437                         if (hunk_index + 1 < file_diff->hunk_nr) {
1438                                 permitted |= ALLOW_GOTO_NEXT_HUNK;
1439                                 strbuf_addstr(&s->buf, ",J");
1440                         }
1441                         if (file_diff->hunk_nr > 1) {
1442                                 permitted |= ALLOW_SEARCH_AND_GOTO;
1443                                 strbuf_addstr(&s->buf, ",g,/");
1444                         }
1445                         if (hunk->splittable_into > 1) {
1446                                 permitted |= ALLOW_SPLIT;
1447                                 strbuf_addstr(&s->buf, ",s");
1448                         }
1449                         if (hunk_index + 1 > file_diff->mode_change &&
1450                             !file_diff->deleted) {
1451                                 permitted |= ALLOW_EDIT;
1452                                 strbuf_addstr(&s->buf, ",e");
1453                         }
1454                 }
1455                 if (file_diff->deleted)
1456                         prompt_mode_type = PROMPT_DELETION;
1457                 else if (file_diff->added)
1458                         prompt_mode_type = PROMPT_ADDITION;
1459                 else if (file_diff->mode_change && !hunk_index)
1460                         prompt_mode_type = PROMPT_MODE_CHANGE;
1461                 else
1462                         prompt_mode_type = PROMPT_HUNK;
1463
1464                 printf("%s(%"PRIuMAX"/%"PRIuMAX") ", s->s.prompt_color,
1465                               (uintmax_t)hunk_index + 1,
1466                               (uintmax_t)(file_diff->hunk_nr
1467                                                 ? file_diff->hunk_nr
1468                                                 : 1));
1469                 printf(_(s->mode->prompt_mode[prompt_mode_type]),
1470                        s->buf.buf);
1471                 if (*s->s.reset_color)
1472                         fputs(s->s.reset_color, stdout);
1473                 fflush(stdout);
1474                 if (read_single_character(s) == EOF)
1475                         break;
1476
1477                 if (!s->answer.len)
1478                         continue;
1479                 ch = tolower(s->answer.buf[0]);
1480                 if (ch == 'y') {
1481                         hunk->use = USE_HUNK;
1482 soft_increment:
1483                         hunk_index = undecided_next < 0 ?
1484                                 file_diff->hunk_nr : undecided_next;
1485                 } else if (ch == 'n') {
1486                         hunk->use = SKIP_HUNK;
1487                         goto soft_increment;
1488                 } else if (ch == 'a') {
1489                         if (file_diff->hunk_nr) {
1490                                 for (; hunk_index < file_diff->hunk_nr; hunk_index++) {
1491                                         hunk = file_diff->hunk + hunk_index;
1492                                         if (hunk->use == UNDECIDED_HUNK)
1493                                                 hunk->use = USE_HUNK;
1494                                 }
1495                         } else if (hunk->use == UNDECIDED_HUNK) {
1496                                 hunk->use = USE_HUNK;
1497                         }
1498                 } else if (ch == 'd' || ch == 'q') {
1499                         if (file_diff->hunk_nr) {
1500                                 for (; hunk_index < file_diff->hunk_nr; hunk_index++) {
1501                                         hunk = file_diff->hunk + hunk_index;
1502                                         if (hunk->use == UNDECIDED_HUNK)
1503                                                 hunk->use = SKIP_HUNK;
1504                                 }
1505                         } else if (hunk->use == UNDECIDED_HUNK) {
1506                                 hunk->use = SKIP_HUNK;
1507                         }
1508                         if (ch == 'q') {
1509                                 quit = 1;
1510                                 break;
1511                         }
1512                 } else if (s->answer.buf[0] == 'K') {
1513                         if (permitted & ALLOW_GOTO_PREVIOUS_HUNK)
1514                                 hunk_index--;
1515                         else
1516                                 err(s, _("No previous hunk"));
1517                 } else if (s->answer.buf[0] == 'J') {
1518                         if (permitted & ALLOW_GOTO_NEXT_HUNK)
1519                                 hunk_index++;
1520                         else
1521                                 err(s, _("No next hunk"));
1522                 } else if (s->answer.buf[0] == 'k') {
1523                         if (permitted & ALLOW_GOTO_PREVIOUS_UNDECIDED_HUNK)
1524                                 hunk_index = undecided_previous;
1525                         else
1526                                 err(s, _("No previous hunk"));
1527                 } else if (s->answer.buf[0] == 'j') {
1528                         if (permitted & ALLOW_GOTO_NEXT_UNDECIDED_HUNK)
1529                                 hunk_index = undecided_next;
1530                         else
1531                                 err(s, _("No next hunk"));
1532                 } else if (s->answer.buf[0] == 'g') {
1533                         char *pend;
1534                         unsigned long response;
1535
1536                         if (!(permitted & ALLOW_SEARCH_AND_GOTO)) {
1537                                 err(s, _("No other hunks to goto"));
1538                                 continue;
1539                         }
1540                         strbuf_remove(&s->answer, 0, 1);
1541                         strbuf_trim(&s->answer);
1542                         i = hunk_index - DISPLAY_HUNKS_LINES / 2;
1543                         if (i < file_diff->mode_change)
1544                                 i = file_diff->mode_change;
1545                         while (s->answer.len == 0) {
1546                                 i = display_hunks(s, file_diff, i);
1547                                 printf("%s", i < file_diff->hunk_nr ?
1548                                        _("go to which hunk (<ret> to see "
1549                                          "more)? ") : _("go to which hunk? "));
1550                                 fflush(stdout);
1551                                 if (strbuf_getline(&s->answer,
1552                                                    stdin) == EOF)
1553                                         break;
1554                                 strbuf_trim_trailing_newline(&s->answer);
1555                         }
1556
1557                         strbuf_trim(&s->answer);
1558                         response = strtoul(s->answer.buf, &pend, 10);
1559                         if (*pend || pend == s->answer.buf)
1560                                 err(s, _("Invalid number: '%s'"),
1561                                     s->answer.buf);
1562                         else if (0 < response && response <= file_diff->hunk_nr)
1563                                 hunk_index = response - 1;
1564                         else
1565                                 err(s, Q_("Sorry, only %d hunk available.",
1566                                           "Sorry, only %d hunks available.",
1567                                           file_diff->hunk_nr),
1568                                     (int)file_diff->hunk_nr);
1569                 } else if (s->answer.buf[0] == '/') {
1570                         regex_t regex;
1571                         int ret;
1572
1573                         if (!(permitted & ALLOW_SEARCH_AND_GOTO)) {
1574                                 err(s, _("No other hunks to search"));
1575                                 continue;
1576                         }
1577                         strbuf_remove(&s->answer, 0, 1);
1578                         strbuf_trim_trailing_newline(&s->answer);
1579                         if (s->answer.len == 0) {
1580                                 printf("%s", _("search for regex? "));
1581                                 fflush(stdout);
1582                                 if (strbuf_getline(&s->answer,
1583                                                    stdin) == EOF)
1584                                         break;
1585                                 strbuf_trim_trailing_newline(&s->answer);
1586                                 if (s->answer.len == 0)
1587                                         continue;
1588                         }
1589                         ret = regcomp(&regex, s->answer.buf,
1590                                       REG_EXTENDED | REG_NOSUB | REG_NEWLINE);
1591                         if (ret) {
1592                                 char errbuf[1024];
1593
1594                                 regerror(ret, &regex, errbuf, sizeof(errbuf));
1595                                 err(s, _("Malformed search regexp %s: %s"),
1596                                     s->answer.buf, errbuf);
1597                                 continue;
1598                         }
1599                         i = hunk_index;
1600                         for (;;) {
1601                                 /* render the hunk into a scratch buffer */
1602                                 render_hunk(s, file_diff->hunk + i, 0, 0,
1603                                             &s->buf);
1604                                 if (regexec(&regex, s->buf.buf, 0, NULL, 0)
1605                                     != REG_NOMATCH)
1606                                         break;
1607                                 i++;
1608                                 if (i == file_diff->hunk_nr)
1609                                         i = 0;
1610                                 if (i != hunk_index)
1611                                         continue;
1612                                 err(s, _("No hunk matches the given pattern"));
1613                                 break;
1614                         }
1615                         hunk_index = i;
1616                 } else if (s->answer.buf[0] == 's') {
1617                         size_t splittable_into = hunk->splittable_into;
1618                         if (!(permitted & ALLOW_SPLIT))
1619                                 err(s, _("Sorry, cannot split this hunk"));
1620                         else if (!split_hunk(s, file_diff,
1621                                              hunk - file_diff->hunk))
1622                                 color_fprintf_ln(stdout, s->s.header_color,
1623                                                  _("Split into %d hunks."),
1624                                                  (int)splittable_into);
1625                 } else if (s->answer.buf[0] == 'e') {
1626                         if (!(permitted & ALLOW_EDIT))
1627                                 err(s, _("Sorry, cannot edit this hunk"));
1628                         else if (edit_hunk_loop(s, file_diff, hunk) >= 0) {
1629                                 hunk->use = USE_HUNK;
1630                                 goto soft_increment;
1631                         }
1632                 } else {
1633                         const char *p = _(help_patch_remainder), *eol = p;
1634
1635                         color_fprintf(stdout, s->s.help_color, "%s",
1636                                       _(s->mode->help_patch_text));
1637
1638                         /*
1639                          * Show only those lines of the remainder that are
1640                          * actually applicable with the current hunk.
1641                          */
1642                         for (; *p; p = eol + (*eol == '\n')) {
1643                                 eol = strchrnul(p, '\n');
1644
1645                                 /*
1646                                  * `s->buf` still contains the part of the
1647                                  * commands shown in the prompt that are not
1648                                  * always available.
1649                                  */
1650                                 if (*p != '?' && !strchr(s->buf.buf, *p))
1651                                         continue;
1652
1653                                 color_fprintf_ln(stdout, s->s.help_color,
1654                                                  "%.*s", (int)(eol - p), p);
1655                         }
1656                 }
1657         }
1658
1659         /* Any hunk to be used? */
1660         for (i = 0; i < file_diff->hunk_nr; i++)
1661                 if (file_diff->hunk[i].use == USE_HUNK)
1662                         break;
1663
1664         if (i < file_diff->hunk_nr ||
1665             (!file_diff->hunk_nr && file_diff->head.use == USE_HUNK)) {
1666                 /* At least one hunk selected: apply */
1667                 strbuf_reset(&s->buf);
1668                 reassemble_patch(s, file_diff, 0, &s->buf);
1669
1670                 discard_index(s->s.r->index);
1671                 if (s->mode->apply_for_checkout)
1672                         apply_for_checkout(s, &s->buf,
1673                                            s->mode->is_reverse);
1674                 else {
1675                         setup_child_process(s, &cp, "apply", NULL);
1676                         strvec_pushv(&cp.args, s->mode->apply_args);
1677                         if (pipe_command(&cp, s->buf.buf, s->buf.len,
1678                                          NULL, 0, NULL, 0))
1679                                 error(_("'git apply' failed"));
1680                 }
1681                 if (repo_read_index(s->s.r) >= 0)
1682                         repo_refresh_and_write_index(s->s.r, REFRESH_QUIET, 0,
1683                                                      1, NULL, NULL, NULL);
1684         }
1685
1686         putchar('\n');
1687         return quit;
1688 }
1689
1690 int run_add_p(struct repository *r, enum add_p_mode mode,
1691               const char *revision, const struct pathspec *ps)
1692 {
1693         struct add_p_state s = {
1694                 { r }, STRBUF_INIT, STRBUF_INIT, STRBUF_INIT, STRBUF_INIT
1695         };
1696         size_t i, binary_count = 0;
1697
1698         init_add_i_state(&s.s, r);
1699
1700         if (mode == ADD_P_STASH)
1701                 s.mode = &patch_mode_stash;
1702         else if (mode == ADD_P_RESET) {
1703                 /*
1704                  * NEEDSWORK: Instead of comparing to the literal "HEAD",
1705                  * compare the commit objects instead so that other ways of
1706                  * saying the same thing (such as "@") are also handled
1707                  * appropriately.
1708                  *
1709                  * This applies to the cases below too.
1710                  */
1711                 if (!revision || !strcmp(revision, "HEAD"))
1712                         s.mode = &patch_mode_reset_head;
1713                 else
1714                         s.mode = &patch_mode_reset_nothead;
1715         } else if (mode == ADD_P_CHECKOUT) {
1716                 if (!revision)
1717                         s.mode = &patch_mode_checkout_index;
1718                 else if (!strcmp(revision, "HEAD"))
1719                         s.mode = &patch_mode_checkout_head;
1720                 else
1721                         s.mode = &patch_mode_checkout_nothead;
1722         } else if (mode == ADD_P_WORKTREE) {
1723                 if (!revision)
1724                         s.mode = &patch_mode_checkout_index;
1725                 else if (!strcmp(revision, "HEAD"))
1726                         s.mode = &patch_mode_worktree_head;
1727                 else
1728                         s.mode = &patch_mode_worktree_nothead;
1729         } else
1730                 s.mode = &patch_mode_add;
1731         s.revision = revision;
1732
1733         if (discard_index(r->index) < 0 || repo_read_index(r) < 0 ||
1734             (!s.mode->index_only &&
1735              repo_refresh_and_write_index(r, REFRESH_QUIET, 0, 1,
1736                                           NULL, NULL, NULL) < 0) ||
1737             parse_diff(&s, ps) < 0) {
1738                 add_p_state_clear(&s);
1739                 return -1;
1740         }
1741
1742         for (i = 0; i < s.file_diff_nr; i++)
1743                 if (s.file_diff[i].binary && !s.file_diff[i].hunk_nr)
1744                         binary_count++;
1745                 else if (patch_update_file(&s, s.file_diff + i))
1746                         break;
1747
1748         if (s.file_diff_nr == 0)
1749                 fprintf(stderr, _("No changes.\n"));
1750         else if (binary_count == s.file_diff_nr)
1751                 fprintf(stderr, _("Only binary files changed.\n"));
1752
1753         add_p_state_clear(&s);
1754         return 0;
1755 }