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