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