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