2 #include "add-interactive.h"
4 #include "run-command.h"
5 #include "argv-array.h"
9 #include "compat/terminal.h"
11 enum prompt_mode_type
{
12 PROMPT_MODE_CHANGE
= 0, PROMPT_DELETION
, PROMPT_ADDITION
, PROMPT_HUNK
,
13 PROMPT_MODE_MAX
, /* must be last */
18 * The magic constant 4 is chosen such that all patch modes
19 * provide enough space for three command-line arguments followed by a
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
;
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
},
33 N_("Stage mode change [y,n,q,a,d%s,?]? "),
34 N_("Stage deletion [y,n,q,a,d%s,?]? "),
35 N_("Stage addition [y,n,q,a,d%s,?]? "),
36 N_("Stage this hunk [y,n,q,a,d%s,?]? ")
38 .edit_hunk_hint
= N_("If the patch applies cleanly, the edited hunk "
39 "will immediately be marked for staging."),
41 N_("y - stage this hunk\n"
42 "n - do not stage this hunk\n"
43 "q - quit; do not stage this hunk or any of the remaining "
45 "a - stage this hunk and all later hunks in the file\n"
46 "d - do not stage this hunk or any of the later hunks in "
50 static struct patch_mode patch_mode_stash
= {
51 .diff_cmd
= { "diff-index", "HEAD", NULL
},
52 .apply_args
= { "--cached", NULL
},
53 .apply_check_args
= { "--cached", NULL
},
55 N_("Stash mode change [y,n,q,a,d%s,?]? "),
56 N_("Stash deletion [y,n,q,a,d%s,?]? "),
57 N_("Stash addition [y,n,q,a,d%s,?]? "),
58 N_("Stash this hunk [y,n,q,a,d%s,?]? "),
60 .edit_hunk_hint
= N_("If the patch applies cleanly, the edited hunk "
61 "will immediately be marked for stashing."),
63 N_("y - stash this hunk\n"
64 "n - do not stash this hunk\n"
65 "q - quit; do not stash this hunk or any of the remaining "
67 "a - stash this hunk and all later hunks in the file\n"
68 "d - do not stash this hunk or any of the later hunks in "
72 static struct patch_mode patch_mode_reset_head
= {
73 .diff_cmd
= { "diff-index", "--cached", NULL
},
74 .apply_args
= { "-R", "--cached", NULL
},
75 .apply_check_args
= { "-R", "--cached", NULL
},
79 N_("Unstage mode change [y,n,q,a,d%s,?]? "),
80 N_("Unstage deletion [y,n,q,a,d%s,?]? "),
81 N_("Unstage addition [y,n,q,a,d%s,?]? "),
82 N_("Unstage this hunk [y,n,q,a,d%s,?]? "),
84 .edit_hunk_hint
= N_("If the patch applies cleanly, the edited hunk "
85 "will immediately be marked for unstaging."),
87 N_("y - unstage this hunk\n"
88 "n - do not unstage this hunk\n"
89 "q - quit; do not unstage this hunk or any of the remaining "
91 "a - unstage this hunk and all later hunks in the file\n"
92 "d - do not unstage this hunk or any of the later hunks in "
96 static struct patch_mode patch_mode_reset_nothead
= {
97 .diff_cmd
= { "diff-index", "-R", "--cached", NULL
},
98 .apply_args
= { "--cached", NULL
},
99 .apply_check_args
= { "--cached", NULL
},
102 N_("Apply mode change to index [y,n,q,a,d%s,?]? "),
103 N_("Apply deletion to index [y,n,q,a,d%s,?]? "),
104 N_("Apply addition to index [y,n,q,a,d%s,?]? "),
105 N_("Apply this hunk to index [y,n,q,a,d%s,?]? "),
107 .edit_hunk_hint
= N_("If the patch applies cleanly, the edited hunk "
108 "will immediately be marked for applying."),
110 N_("y - apply this hunk to index\n"
111 "n - do not apply this hunk to index\n"
112 "q - quit; do not apply this hunk or any of the remaining "
114 "a - apply this hunk and all later hunks in the file\n"
115 "d - do not apply this hunk or any of the later hunks in "
119 static struct patch_mode patch_mode_checkout_index
= {
120 .diff_cmd
= { "diff-files", NULL
},
121 .apply_args
= { "-R", NULL
},
122 .apply_check_args
= { "-R", NULL
},
125 N_("Discard mode change from worktree [y,n,q,a,d%s,?]? "),
126 N_("Discard deletion from worktree [y,n,q,a,d%s,?]? "),
127 N_("Discard addition from worktree [y,n,q,a,d%s,?]? "),
128 N_("Discard this hunk from worktree [y,n,q,a,d%s,?]? "),
130 .edit_hunk_hint
= N_("If the patch applies cleanly, the edited hunk "
131 "will immediately be marked for discarding."),
133 N_("y - discard this hunk from worktree\n"
134 "n - do not discard this hunk from worktree\n"
135 "q - quit; do not discard this hunk or any of the remaining "
137 "a - discard this hunk and all later hunks in the file\n"
138 "d - do not discard this hunk or any of the later hunks in "
142 static struct patch_mode patch_mode_checkout_head
= {
143 .diff_cmd
= { "diff-index", NULL
},
144 .apply_for_checkout
= 1,
145 .apply_check_args
= { "-R", NULL
},
148 N_("Discard mode change from index and worktree [y,n,q,a,d%s,?]? "),
149 N_("Discard deletion from index and worktree [y,n,q,a,d%s,?]? "),
150 N_("Discard addition from index and worktree [y,n,q,a,d%s,?]? "),
151 N_("Discard this hunk from index and worktree [y,n,q,a,d%s,?]? "),
153 .edit_hunk_hint
= N_("If the patch applies cleanly, the edited hunk "
154 "will immediately be marked for discarding."),
156 N_("y - discard this hunk from index and worktree\n"
157 "n - do not discard this hunk from index and worktree\n"
158 "q - quit; do not discard this hunk or any of the remaining "
160 "a - discard this hunk and all later hunks in the file\n"
161 "d - do not discard this hunk or any of the later hunks in "
165 static struct patch_mode patch_mode_checkout_nothead
= {
166 .diff_cmd
= { "diff-index", "-R", NULL
},
167 .apply_for_checkout
= 1,
168 .apply_check_args
= { NULL
},
170 N_("Apply mode change to index and worktree [y,n,q,a,d%s,?]? "),
171 N_("Apply deletion to index and worktree [y,n,q,a,d%s,?]? "),
172 N_("Apply addition to index and worktree [y,n,q,a,d%s,?]? "),
173 N_("Apply this hunk to index and worktree [y,n,q,a,d%s,?]? "),
175 .edit_hunk_hint
= N_("If the patch applies cleanly, the edited hunk "
176 "will immediately be marked for applying."),
178 N_("y - apply this hunk to index and worktree\n"
179 "n - do not apply this hunk to index and worktree\n"
180 "q - quit; do not apply this hunk or any of the remaining "
182 "a - apply this hunk and all later hunks in the file\n"
183 "d - do not apply this hunk or any of the later hunks in "
187 static struct patch_mode patch_mode_worktree_head
= {
188 .diff_cmd
= { "diff-index", NULL
},
189 .apply_args
= { "-R", NULL
},
190 .apply_check_args
= { "-R", NULL
},
193 N_("Discard mode change from index and worktree [y,n,q,a,d%s,?]? "),
194 N_("Discard deletion from index and worktree [y,n,q,a,d%s,?]? "),
195 N_("Discard addition from index and worktree [y,n,q,a,d%s,?]? "),
196 N_("Discard this hunk from index and worktree [y,n,q,a,d%s,?]? "),
198 .edit_hunk_hint
= N_("If the patch applies cleanly, the edited hunk "
199 "will immediately be marked for discarding."),
201 N_("y - discard this hunk from worktree\n"
202 "n - do not discard this hunk from worktree\n"
203 "q - quit; do not discard this hunk or any of the remaining "
205 "a - discard this hunk and all later hunks in the file\n"
206 "d - do not discard this hunk or any of the later hunks in "
210 static struct patch_mode patch_mode_worktree_nothead
= {
211 .diff_cmd
= { "diff-index", "-R", NULL
},
212 .apply_args
= { NULL
},
213 .apply_check_args
= { NULL
},
215 N_("Apply mode change to index and worktree [y,n,q,a,d%s,?]? "),
216 N_("Apply deletion to index and worktree [y,n,q,a,d%s,?]? "),
217 N_("Apply addition to index and worktree [y,n,q,a,d%s,?]? "),
218 N_("Apply this hunk to index and worktree [y,n,q,a,d%s,?]? "),
220 .edit_hunk_hint
= N_("If the patch applies cleanly, the edited hunk "
221 "will immediately be marked for applying."),
223 N_("y - apply this hunk to worktree\n"
224 "n - do not apply this hunk to worktree\n"
225 "q - quit; do not apply this hunk or any of the remaining "
227 "a - apply this hunk and all later hunks in the file\n"
228 "d - do not apply this hunk or any of the later hunks in "
233 unsigned long old_offset
, old_count
, new_offset
, new_count
;
235 * Start/end offsets to the extra text after the second `@@` in the
236 * hunk header, e.g. the function signature. This is expected to
237 * include the newline.
239 size_t extra_start
, extra_end
, colored_extra_start
, colored_extra_end
;
243 size_t start
, end
, colored_start
, colored_end
, splittable_into
;
245 enum { UNDECIDED_HUNK
= 0, SKIP_HUNK
, USE_HUNK
} use
;
246 struct hunk_header header
;
250 struct add_i_state s
;
251 struct strbuf answer
, buf
;
254 struct strbuf plain
, colored
;
258 size_t hunk_nr
, hunk_alloc
;
259 unsigned deleted
:1, added
:1, mode_change
:1,binary
:1;
264 struct patch_mode
*mode
;
265 const char *revision
;
268 static void err(struct add_p_state
*s
, const char *fmt
, ...)
273 fputs(s
->s
.error_color
, stderr
);
274 vfprintf(stderr
, fmt
, args
);
275 fputs(s
->s
.reset_color
, stderr
);
280 static void setup_child_process(struct add_p_state
*s
,
281 struct child_process
*cp
, ...)
287 while ((arg
= va_arg(ap
, const char *)))
288 argv_array_push(&cp
->args
, arg
);
292 argv_array_pushf(&cp
->env_array
,
293 INDEX_ENVIRONMENT
"=%s", s
->s
.r
->index_file
);
296 static int parse_range(const char **p
,
297 unsigned long *offset
, unsigned long *count
)
301 *offset
= strtoul(*p
, &pend
, 10);
309 *count
= strtoul(pend
+ 1, (char **)p
, 10);
310 return *p
== pend
+ 1 ? -1 : 0;
313 static int parse_hunk_header(struct add_p_state
*s
, struct hunk
*hunk
)
315 struct hunk_header
*header
= &hunk
->header
;
316 const char *line
= s
->plain
.buf
+ hunk
->start
, *p
= line
;
317 char *eol
= memchr(p
, '\n', s
->plain
.len
- hunk
->start
);
320 eol
= s
->plain
.buf
+ s
->plain
.len
;
322 if (!skip_prefix(p
, "@@ -", &p
) ||
323 parse_range(&p
, &header
->old_offset
, &header
->old_count
) < 0 ||
324 !skip_prefix(p
, " +", &p
) ||
325 parse_range(&p
, &header
->new_offset
, &header
->new_count
) < 0 ||
326 !skip_prefix(p
, " @@", &p
))
327 return error(_("could not parse hunk header '%.*s'"),
328 (int)(eol
- line
), line
);
330 hunk
->start
= eol
- s
->plain
.buf
+ (*eol
== '\n');
331 header
->extra_start
= p
- s
->plain
.buf
;
332 header
->extra_end
= hunk
->start
;
334 if (!s
->colored
.len
) {
335 header
->colored_extra_start
= header
->colored_extra_end
= 0;
339 /* Now find the extra text in the colored diff */
340 line
= s
->colored
.buf
+ hunk
->colored_start
;
341 eol
= memchr(line
, '\n', s
->colored
.len
- hunk
->colored_start
);
343 eol
= s
->colored
.buf
+ s
->colored
.len
;
344 p
= memmem(line
, eol
- line
, "@@ -", 4);
346 return error(_("could not parse colored hunk header '%.*s'"),
347 (int)(eol
- line
), line
);
348 p
= memmem(p
+ 4, eol
- p
- 4, " @@", 3);
350 return error(_("could not parse colored hunk header '%.*s'"),
351 (int)(eol
- line
), line
);
352 hunk
->colored_start
= eol
- s
->colored
.buf
+ (*eol
== '\n');
353 header
->colored_extra_start
= p
+ 3 - s
->colored
.buf
;
354 header
->colored_extra_end
= hunk
->colored_start
;
359 static int is_octal(const char *p
, size_t len
)
365 if (*p
< '0' || *(p
++) > '7')
370 static int parse_diff(struct add_p_state
*s
, const struct pathspec
*ps
)
372 struct argv_array args
= ARGV_ARRAY_INIT
;
373 const char *diff_algorithm
= s
->s
.interactive_diff_algorithm
;
374 struct strbuf
*plain
= &s
->plain
, *colored
= NULL
;
375 struct child_process cp
= CHILD_PROCESS_INIT
;
376 char *p
, *pend
, *colored_p
= NULL
, *colored_pend
= NULL
, marker
= '\0';
377 size_t file_diff_alloc
= 0, i
, color_arg_index
;
378 struct file_diff
*file_diff
= NULL
;
379 struct hunk
*hunk
= NULL
;
382 argv_array_pushv(&args
, s
->mode
->diff_cmd
);
384 argv_array_pushf(&args
, "--diff-algorithm=%s", diff_algorithm
);
386 struct object_id oid
;
387 argv_array_push(&args
,
388 /* could be on an unborn branch */
389 !strcmp("HEAD", s
->revision
) &&
390 get_oid("HEAD", &oid
) ?
391 empty_tree_oid_hex() : s
->revision
);
393 color_arg_index
= args
.argc
;
394 /* Use `--no-color` explicitly, just in case `diff.color = always`. */
395 argv_array_pushl(&args
, "--no-color", "-p", "--", NULL
);
396 for (i
= 0; i
< ps
->nr
; i
++)
397 argv_array_push(&args
, ps
->items
[i
].original
);
399 setup_child_process(s
, &cp
, NULL
);
401 res
= capture_command(&cp
, plain
, 0);
403 argv_array_clear(&args
);
404 return error(_("could not parse diff"));
407 argv_array_clear(&args
);
410 strbuf_complete_line(plain
);
412 if (want_color_fd(1, -1)) {
413 struct child_process colored_cp
= CHILD_PROCESS_INIT
;
414 const char *diff_filter
= s
->s
.interactive_diff_filter
;
416 setup_child_process(s
, &colored_cp
, NULL
);
417 xsnprintf((char *)args
.argv
[color_arg_index
], 8, "--color");
418 colored_cp
.argv
= args
.argv
;
419 colored
= &s
->colored
;
420 res
= capture_command(&colored_cp
, colored
, 0);
421 argv_array_clear(&args
);
423 return error(_("could not parse colored diff"));
426 struct child_process filter_cp
= CHILD_PROCESS_INIT
;
428 setup_child_process(s
, &filter_cp
,
430 filter_cp
.git_cmd
= 0;
431 filter_cp
.use_shell
= 1;
432 strbuf_reset(&s
->buf
);
433 if (pipe_command(&filter_cp
,
434 colored
->buf
, colored
->len
,
435 &s
->buf
, colored
->len
,
437 return error(_("failed to run '%s'"),
439 strbuf_swap(colored
, &s
->buf
);
442 strbuf_complete_line(colored
);
443 colored_p
= colored
->buf
;
444 colored_pend
= colored_p
+ colored
->len
;
446 argv_array_clear(&args
);
448 /* parse files and hunks */
450 pend
= p
+ plain
->len
;
452 char *eol
= memchr(p
, '\n', pend
- p
);
453 const char *deleted
= NULL
, *added
= NULL
, *mode_change
= NULL
;
458 if (starts_with(p
, "diff ")) {
460 ALLOC_GROW(s
->file_diff
, s
->file_diff_nr
,
462 file_diff
= s
->file_diff
+ s
->file_diff_nr
- 1;
463 memset(file_diff
, 0, sizeof(*file_diff
));
464 hunk
= &file_diff
->head
;
465 hunk
->start
= p
- plain
->buf
;
467 hunk
->colored_start
= colored_p
- colored
->buf
;
469 } else if (p
== plain
->buf
)
470 BUG("diff starts with unexpected line:\n"
471 "%.*s\n", (int)(eol
- p
), p
);
472 else if (file_diff
->deleted
|| file_diff
->added
)
473 ; /* keep the rest of the file in a single "hunk" */
474 else if (starts_with(p
, "@@ ") ||
475 (hunk
== &file_diff
->head
&&
476 (skip_prefix(p
, "deleted file", &deleted
) ||
477 skip_prefix(p
, "new file", &added
)))) {
478 if (marker
== '-' || marker
== '+')
480 * Should not happen; previous hunk did not end
481 * in a context line? Handle it anyway.
483 hunk
->splittable_into
++;
485 file_diff
->hunk_nr
++;
486 ALLOC_GROW(file_diff
->hunk
, file_diff
->hunk_nr
,
487 file_diff
->hunk_alloc
);
488 hunk
= file_diff
->hunk
+ file_diff
->hunk_nr
- 1;
489 memset(hunk
, 0, sizeof(*hunk
));
491 hunk
->start
= p
- plain
->buf
;
493 hunk
->colored_start
= colored_p
- colored
->buf
;
496 file_diff
->deleted
= 1;
498 file_diff
->added
= 1;
499 else if (parse_hunk_header(s
, hunk
) < 0)
503 * Start counting into how many hunks this one can be
507 } else if (hunk
== &file_diff
->head
&&
508 skip_prefix(p
, "old mode ", &mode_change
) &&
509 is_octal(mode_change
, eol
- mode_change
)) {
510 if (file_diff
->mode_change
)
511 BUG("double mode change?\n\n%.*s",
512 (int)(eol
- plain
->buf
), plain
->buf
);
513 if (file_diff
->hunk_nr
++)
514 BUG("mode change in the middle?\n\n%.*s",
515 (int)(eol
- plain
->buf
), plain
->buf
);
518 * Do *not* change `hunk`: the mode change pseudo-hunk
519 * is _part of_ the header "hunk".
521 file_diff
->mode_change
= 1;
522 ALLOC_GROW(file_diff
->hunk
, file_diff
->hunk_nr
,
523 file_diff
->hunk_alloc
);
524 memset(file_diff
->hunk
, 0, sizeof(struct hunk
));
525 file_diff
->hunk
->start
= p
- plain
->buf
;
527 file_diff
->hunk
->colored_start
=
528 colored_p
- colored
->buf
;
529 } else if (hunk
== &file_diff
->head
&&
530 skip_prefix(p
, "new mode ", &mode_change
) &&
531 is_octal(mode_change
, eol
- mode_change
)) {
534 * Extend the "mode change" pseudo-hunk to include also
535 * the "new mode" line.
537 if (!file_diff
->mode_change
)
538 BUG("'new mode' without 'old mode'?\n\n%.*s",
539 (int)(eol
- plain
->buf
), plain
->buf
);
540 if (file_diff
->hunk_nr
!= 1)
541 BUG("mode change in the middle?\n\n%.*s",
542 (int)(eol
- plain
->buf
), plain
->buf
);
543 if (p
- plain
->buf
!= file_diff
->hunk
->end
)
544 BUG("'new mode' does not immediately follow "
545 "'old mode'?\n\n%.*s",
546 (int)(eol
- plain
->buf
), plain
->buf
);
547 } else if (hunk
== &file_diff
->head
&&
548 starts_with(p
, "Binary files "))
549 file_diff
->binary
= 1;
551 if (!!file_diff
->deleted
+ !!file_diff
->added
+
552 !!file_diff
->mode_change
> 1)
553 BUG("diff can only contain delete *or* add *or* a "
554 "mode change?!?\n%.*s",
555 (int)(eol
- (plain
->buf
+ file_diff
->head
.start
)),
556 plain
->buf
+ file_diff
->head
.start
);
558 if ((marker
== '-' || marker
== '+') && *p
== ' ')
559 hunk
->splittable_into
++;
560 if (marker
&& *p
!= '\\')
563 p
= eol
== pend
? pend
: eol
+ 1;
564 hunk
->end
= p
- plain
->buf
;
567 char *colored_eol
= memchr(colored_p
, '\n',
568 colored_pend
- colored_p
);
570 colored_p
= colored_eol
+ 1;
572 /* colored shorter than non-colored? */
573 goto mismatched_output
;
575 colored_p
= colored_pend
;
577 hunk
->colored_end
= colored_p
- colored
->buf
;
581 if (file_diff
->hunk_nr
!= 1)
582 BUG("mode change in hunk #%d???",
583 (int)file_diff
->hunk_nr
);
584 /* Adjust the end of the "mode change" pseudo-hunk */
585 file_diff
->hunk
->end
= hunk
->end
;
587 file_diff
->hunk
->colored_end
= hunk
->colored_end
;
591 if (marker
== '-' || marker
== '+')
593 * Last hunk ended in non-context line (i.e. it appended lines
594 * to the file, so there are no trailing context lines).
596 hunk
->splittable_into
++;
598 /* non-colored shorter than colored? */
599 if (colored_p
!= colored_pend
) {
601 error(_("mismatched output from interactive.diffFilter"));
602 advise(_("Your filter must maintain a one-to-one correspondence\n"
603 "between its input and output lines."));
610 static size_t find_next_line(struct strbuf
*sb
, size_t offset
)
614 if (offset
>= sb
->len
)
615 BUG("looking for next line beyond buffer (%d >= %d)\n%s",
616 (int)offset
, (int)sb
->len
, sb
->buf
);
618 eol
= memchr(sb
->buf
+ offset
, '\n', sb
->len
- offset
);
621 return eol
- sb
->buf
+ 1;
624 static void render_hunk(struct add_p_state
*s
, struct hunk
*hunk
,
625 ssize_t delta
, int colored
, struct strbuf
*out
)
627 struct hunk_header
*header
= &hunk
->header
;
629 if (hunk
->header
.old_offset
!= 0 || hunk
->header
.new_offset
!= 0) {
631 * Generate the hunk header dynamically, except for special
632 * hunks (such as the diff header).
636 unsigned long old_offset
= header
->old_offset
;
637 unsigned long new_offset
= header
->new_offset
;
640 p
= s
->plain
.buf
+ header
->extra_start
;
641 len
= header
->extra_end
- header
->extra_start
;
643 strbuf_addstr(out
, s
->s
.fraginfo_color
);
644 p
= s
->colored
.buf
+ header
->colored_extra_start
;
645 len
= header
->colored_extra_end
646 - header
->colored_extra_start
;
649 if (s
->mode
->is_reverse
)
654 strbuf_addf(out
, "@@ -%lu,%lu +%lu,%lu @@",
655 old_offset
, header
->old_count
,
656 new_offset
, header
->new_count
);
658 strbuf_add(out
, p
, len
);
660 strbuf_addf(out
, "%s\n", GIT_COLOR_RESET
);
662 strbuf_addch(out
, '\n');
666 strbuf_add(out
, s
->colored
.buf
+ hunk
->colored_start
,
667 hunk
->colored_end
- hunk
->colored_start
);
669 strbuf_add(out
, s
->plain
.buf
+ hunk
->start
,
670 hunk
->end
- hunk
->start
);
673 static void render_diff_header(struct add_p_state
*s
,
674 struct file_diff
*file_diff
, int colored
,
678 * If there was a mode change, the first hunk is a pseudo hunk that
679 * corresponds to the mode line in the header. If the user did not want
680 * to stage that "hunk", we actually have to cut it out from the header.
682 int skip_mode_change
=
683 file_diff
->mode_change
&& file_diff
->hunk
->use
!= USE_HUNK
;
684 struct hunk
*head
= &file_diff
->head
, *first
= file_diff
->hunk
;
686 if (!skip_mode_change
) {
687 render_hunk(s
, head
, 0, colored
, out
);
692 const char *p
= s
->colored
.buf
;
694 strbuf_add(out
, p
+ head
->colored_start
,
695 first
->colored_start
- head
->colored_start
);
696 strbuf_add(out
, p
+ first
->colored_end
,
697 head
->colored_end
- first
->colored_end
);
699 const char *p
= s
->plain
.buf
;
701 strbuf_add(out
, p
+ head
->start
, first
->start
- head
->start
);
702 strbuf_add(out
, p
+ first
->end
, head
->end
- first
->end
);
706 /* Coalesce hunks again that were split */
707 static int merge_hunks(struct add_p_state
*s
, struct file_diff
*file_diff
,
708 size_t *hunk_index
, int use_all
, struct hunk
*merged
)
710 size_t i
= *hunk_index
, delta
;
711 struct hunk
*hunk
= file_diff
->hunk
+ i
;
712 /* `header` corresponds to the merged hunk */
713 struct hunk_header
*header
= &merged
->header
, *next
;
715 if (!use_all
&& hunk
->use
!= USE_HUNK
)
719 /* We simply skip the colored part (if any) when merging hunks */
720 merged
->colored_start
= merged
->colored_end
= 0;
722 for (; i
+ 1 < file_diff
->hunk_nr
; i
++) {
724 next
= &hunk
->header
;
727 * Stop merging hunks when:
729 * - the hunk is not selected for use, or
730 * - the hunk does not overlap with the already-merged hunk(s)
732 if ((!use_all
&& hunk
->use
!= USE_HUNK
) ||
733 header
->new_offset
>= next
->new_offset
+ merged
->delta
||
734 header
->new_offset
+ header
->new_count
735 < next
->new_offset
+ merged
->delta
)
739 * If the hunks were not edited, and overlap, we can simply
740 * extend the line range.
742 if (merged
->start
< hunk
->start
&& merged
->end
> hunk
->start
) {
743 merged
->end
= hunk
->end
;
744 merged
->colored_end
= hunk
->colored_end
;
747 const char *plain
= s
->plain
.buf
;
748 size_t overlapping_line_count
= header
->new_offset
749 + header
->new_count
- merged
->delta
751 size_t overlap_end
= hunk
->start
;
752 size_t overlap_start
= overlap_end
;
753 size_t overlap_next
, len
, j
;
756 * One of the hunks was edited: the modified hunk was
757 * appended to the strbuf `s->plain`.
759 * Let's ensure that at least the last context line of
760 * the first hunk overlaps with the corresponding line
761 * of the second hunk, and then merge.
763 for (j
= 0; j
< overlapping_line_count
; j
++) {
764 overlap_next
= find_next_line(&s
->plain
,
767 if (overlap_next
> hunk
->end
)
768 BUG("failed to find %d context lines "
770 (int)overlapping_line_count
,
771 (int)(hunk
->end
- hunk
->start
),
772 plain
+ hunk
->start
);
774 if (plain
[overlap_end
] != ' ')
775 return error(_("expected context line "
780 plain
+ hunk
->start
);
782 overlap_start
= overlap_end
;
783 overlap_end
= overlap_next
;
785 len
= overlap_end
- overlap_start
;
787 if (len
> merged
->end
- merged
->start
||
788 memcmp(plain
+ merged
->end
- len
,
789 plain
+ overlap_start
, len
))
790 return error(_("hunks do not overlap:\n%.*s\n"
791 "\tdoes not end with:\n%.*s"),
792 (int)(merged
->end
- merged
->start
),
793 plain
+ merged
->start
,
794 (int)len
, plain
+ overlap_start
);
797 * Since the start-end ranges are not adjacent, we
798 * cannot simply take the union of the ranges. To
799 * address that, we temporarily append the union of the
800 * lines to the `plain` strbuf.
802 if (merged
->end
!= s
->plain
.len
) {
803 size_t start
= s
->plain
.len
;
805 strbuf_add(&s
->plain
, plain
+ merged
->start
,
806 merged
->end
- merged
->start
);
807 plain
= s
->plain
.buf
;
808 merged
->start
= start
;
809 merged
->end
= s
->plain
.len
;
812 strbuf_add(&s
->plain
,
814 hunk
->end
- overlap_end
);
815 merged
->end
= s
->plain
.len
;
816 merged
->splittable_into
+= hunk
->splittable_into
;
817 delta
= merged
->delta
;
818 merged
->delta
+= hunk
->delta
;
821 header
->old_count
= next
->old_offset
+ next
->old_count
822 - header
->old_offset
;
823 header
->new_count
= next
->new_offset
+ delta
824 + next
->new_count
- header
->new_offset
;
827 if (i
== *hunk_index
)
834 static void reassemble_patch(struct add_p_state
*s
,
835 struct file_diff
*file_diff
, int use_all
,
839 size_t save_len
= s
->plain
.len
, i
;
842 render_diff_header(s
, file_diff
, 0, out
);
844 for (i
= file_diff
->mode_change
; i
< file_diff
->hunk_nr
; i
++) {
845 struct hunk merged
= { 0 };
847 hunk
= file_diff
->hunk
+ i
;
848 if (!use_all
&& hunk
->use
!= USE_HUNK
)
849 delta
+= hunk
->header
.old_count
850 - hunk
->header
.new_count
;
852 /* merge overlapping hunks into a temporary hunk */
853 if (merge_hunks(s
, file_diff
, &i
, use_all
, &merged
))
856 render_hunk(s
, hunk
, delta
, 0, out
);
859 * In case `merge_hunks()` used `plain` as a scratch
860 * pad (this happens when an edited hunk had to be
861 * coalesced with another hunk).
863 strbuf_setlen(&s
->plain
, save_len
);
865 delta
+= hunk
->delta
;
870 static int split_hunk(struct add_p_state
*s
, struct file_diff
*file_diff
,
873 int colored
= !!s
->colored
.len
, first
= 1;
874 struct hunk
*hunk
= file_diff
->hunk
+ hunk_index
;
875 size_t splittable_into
;
876 size_t end
, colored_end
, current
, colored_current
= 0, context_line_count
;
877 struct hunk_header remaining
, *header
;
880 if (hunk_index
>= file_diff
->hunk_nr
)
881 BUG("invalid hunk index: %d (must be >= 0 and < %d)",
882 (int)hunk_index
, (int)file_diff
->hunk_nr
);
884 if (hunk
->splittable_into
< 2)
886 splittable_into
= hunk
->splittable_into
;
889 colored_end
= hunk
->colored_end
;
891 remaining
= hunk
->header
;
893 file_diff
->hunk_nr
+= splittable_into
- 1;
894 ALLOC_GROW(file_diff
->hunk
, file_diff
->hunk_nr
, file_diff
->hunk_alloc
);
895 if (hunk_index
+ splittable_into
< file_diff
->hunk_nr
)
896 memmove(file_diff
->hunk
+ hunk_index
+ splittable_into
,
897 file_diff
->hunk
+ hunk_index
+ 1,
898 (file_diff
->hunk_nr
- hunk_index
- splittable_into
)
900 hunk
= file_diff
->hunk
+ hunk_index
;
901 hunk
->splittable_into
= 1;
902 memset(hunk
+ 1, 0, (splittable_into
- 1) * sizeof(*hunk
));
904 header
= &hunk
->header
;
905 header
->old_count
= header
->new_count
= 0;
907 current
= hunk
->start
;
909 colored_current
= hunk
->colored_start
;
911 context_line_count
= 0;
913 while (splittable_into
> 1) {
914 ch
= s
->plain
.buf
[current
];
917 BUG("buffer overrun while splitting hunks");
920 * Is this the first context line after a chain of +/- lines?
921 * Then record the start of the next split hunk.
923 if ((marker
== '-' || marker
== '+') && ch
== ' ') {
925 hunk
[1].start
= current
;
927 hunk
[1].colored_start
= colored_current
;
928 context_line_count
= 0;
932 * Was the previous line a +/- one? Alternatively, is this the
933 * first line (and not a +/- one)?
935 * Then just increment the appropriate counter and continue
936 * with the next line.
938 if (marker
!= ' ' || (ch
!= '-' && ch
!= '+')) {
940 /* Comment lines are attached to the previous line */
942 ch
= marker
? marker
: ' ';
944 /* current hunk not done yet */
946 context_line_count
++;
952 BUG("unhandled diff marker: '%c'", ch
);
954 current
= find_next_line(&s
->plain
, current
);
957 find_next_line(&s
->colored
,
963 * We got us the start of a new hunk!
965 * This is a context line, so it is shared with the previous
970 if (header
->old_count
|| header
->new_count
)
971 BUG("counts are off: %d/%d",
972 (int)header
->old_count
,
973 (int)header
->new_count
);
975 header
->old_count
= context_line_count
;
976 header
->new_count
= context_line_count
;
977 context_line_count
= 0;
982 remaining
.old_offset
+= header
->old_count
;
983 remaining
.old_count
-= header
->old_count
;
984 remaining
.new_offset
+= header
->new_count
;
985 remaining
.new_count
-= header
->new_count
;
987 /* initialize next hunk header's offsets */
988 hunk
[1].header
.old_offset
=
989 header
->old_offset
+ header
->old_count
;
990 hunk
[1].header
.new_offset
=
991 header
->new_offset
+ header
->new_count
;
993 /* add one split hunk */
994 header
->old_count
+= context_line_count
;
995 header
->new_count
+= context_line_count
;
999 hunk
->colored_end
= colored_current
;
1002 hunk
->splittable_into
= 1;
1003 hunk
->use
= hunk
[-1].use
;
1004 header
= &hunk
->header
;
1006 header
->old_count
= header
->new_count
= context_line_count
;
1007 context_line_count
= 0;
1013 /* last hunk simply gets the rest */
1014 if (header
->old_offset
!= remaining
.old_offset
)
1015 BUG("miscounted old_offset: %lu != %lu",
1016 header
->old_offset
, remaining
.old_offset
);
1017 if (header
->new_offset
!= remaining
.new_offset
)
1018 BUG("miscounted new_offset: %lu != %lu",
1019 header
->new_offset
, remaining
.new_offset
);
1020 header
->old_count
= remaining
.old_count
;
1021 header
->new_count
= remaining
.new_count
;
1024 hunk
->colored_end
= colored_end
;
1029 static void recolor_hunk(struct add_p_state
*s
, struct hunk
*hunk
)
1031 const char *plain
= s
->plain
.buf
;
1032 size_t current
, eol
, next
;
1034 if (!s
->colored
.len
)
1037 hunk
->colored_start
= s
->colored
.len
;
1038 for (current
= hunk
->start
; current
< hunk
->end
; ) {
1039 for (eol
= current
; eol
< hunk
->end
; eol
++)
1040 if (plain
[eol
] == '\n')
1042 next
= eol
+ (eol
< hunk
->end
);
1043 if (eol
> current
&& plain
[eol
- 1] == '\r')
1046 strbuf_addstr(&s
->colored
,
1047 plain
[current
] == '-' ?
1048 s
->s
.file_old_color
:
1049 plain
[current
] == '+' ?
1050 s
->s
.file_new_color
:
1051 s
->s
.context_color
);
1052 strbuf_add(&s
->colored
, plain
+ current
, eol
- current
);
1053 strbuf_addstr(&s
->colored
, GIT_COLOR_RESET
);
1055 strbuf_add(&s
->colored
, plain
+ eol
, next
- eol
);
1058 hunk
->colored_end
= s
->colored
.len
;
1061 static int edit_hunk_manually(struct add_p_state
*s
, struct hunk
*hunk
)
1065 strbuf_reset(&s
->buf
);
1066 strbuf_commented_addf(&s
->buf
, _("Manual hunk edit mode -- see bottom for "
1067 "a quick guide.\n"));
1068 render_hunk(s
, hunk
, 0, 0, &s
->buf
);
1069 strbuf_commented_addf(&s
->buf
,
1071 "To remove '%c' lines, make them ' ' lines "
1073 "To remove '%c' lines, delete them.\n"
1074 "Lines starting with %c will be removed.\n"),
1075 s
->mode
->is_reverse
? '+' : '-',
1076 s
->mode
->is_reverse
? '-' : '+',
1078 strbuf_commented_addf(&s
->buf
, "%s", _(s
->mode
->edit_hunk_hint
));
1080 * TRANSLATORS: 'it' refers to the patch mentioned in the previous
1083 strbuf_commented_addf(&s
->buf
,
1084 _("If it does not apply cleanly, you will be "
1085 "given an opportunity to\n"
1086 "edit again. If all lines of the hunk are "
1087 "removed, then the edit is\n"
1088 "aborted and the hunk is left unchanged.\n"));
1090 if (strbuf_edit_interactively(&s
->buf
, "addp-hunk-edit.diff", NULL
) < 0)
1093 /* strip out commented lines */
1094 hunk
->start
= s
->plain
.len
;
1095 for (i
= 0; i
< s
->buf
.len
; ) {
1096 size_t next
= find_next_line(&s
->buf
, i
);
1098 if (s
->buf
.buf
[i
] != comment_line_char
)
1099 strbuf_add(&s
->plain
, s
->buf
.buf
+ i
, next
- i
);
1103 hunk
->end
= s
->plain
.len
;
1104 if (hunk
->end
== hunk
->start
)
1105 /* The user aborted editing by deleting everything */
1108 recolor_hunk(s
, hunk
);
1111 * If the hunk header is intact, parse it, otherwise simply use the
1112 * hunk header prior to editing (which will adjust `hunk->start` to
1113 * skip the hunk header).
1115 if (s
->plain
.buf
[hunk
->start
] == '@' &&
1116 parse_hunk_header(s
, hunk
) < 0)
1117 return error(_("could not parse hunk header"));
1122 static ssize_t
recount_edited_hunk(struct add_p_state
*s
, struct hunk
*hunk
,
1123 size_t orig_old_count
, size_t orig_new_count
)
1125 struct hunk_header
*header
= &hunk
->header
;
1128 header
->old_count
= header
->new_count
= 0;
1129 for (i
= hunk
->start
; i
< hunk
->end
; ) {
1130 switch (s
->plain
.buf
[i
]) {
1132 header
->old_count
++;
1135 header
->new_count
++;
1137 case ' ': case '\r': case '\n':
1138 header
->old_count
++;
1139 header
->new_count
++;
1143 i
= find_next_line(&s
->plain
, i
);
1146 return orig_old_count
- orig_new_count
1147 - header
->old_count
+ header
->new_count
;
1150 static int run_apply_check(struct add_p_state
*s
,
1151 struct file_diff
*file_diff
)
1153 struct child_process cp
= CHILD_PROCESS_INIT
;
1155 strbuf_reset(&s
->buf
);
1156 reassemble_patch(s
, file_diff
, 1, &s
->buf
);
1158 setup_child_process(s
, &cp
,
1159 "apply", "--check", NULL
);
1160 argv_array_pushv(&cp
.args
, s
->mode
->apply_check_args
);
1161 if (pipe_command(&cp
, s
->buf
.buf
, s
->buf
.len
, NULL
, 0, NULL
, 0))
1162 return error(_("'git apply --cached' failed"));
1167 static int read_single_character(struct add_p_state
*s
)
1169 if (s
->s
.use_single_key
) {
1170 int res
= read_key_without_echo(&s
->answer
);
1171 printf("%s\n", res
== EOF
? "" : s
->answer
.buf
);
1175 if (strbuf_getline(&s
->answer
, stdin
) == EOF
)
1177 strbuf_trim_trailing_newline(&s
->answer
);
1181 static int prompt_yesno(struct add_p_state
*s
, const char *prompt
)
1184 color_fprintf(stdout
, s
->s
.prompt_color
, "%s", _(prompt
));
1186 if (read_single_character(s
) == EOF
)
1188 switch (tolower(s
->answer
.buf
[0])) {
1195 static int edit_hunk_loop(struct add_p_state
*s
,
1196 struct file_diff
*file_diff
, struct hunk
*hunk
)
1198 size_t plain_len
= s
->plain
.len
, colored_len
= s
->colored
.len
;
1204 int res
= edit_hunk_manually(s
, hunk
);
1213 recount_edited_hunk(s
, hunk
,
1214 backup
.header
.old_count
,
1215 backup
.header
.new_count
);
1216 if (!run_apply_check(s
, file_diff
))
1220 /* Drop edits (they were appended to s->plain) */
1221 strbuf_setlen(&s
->plain
, plain_len
);
1222 strbuf_setlen(&s
->colored
, colored_len
);
1226 * TRANSLATORS: do not translate [y/n]
1227 * The program will only accept that input at this point.
1228 * Consider translating (saying "no" discards!) as
1229 * (saying "n" for "no" discards!) if the translation
1230 * of the word "no" does not start with n.
1232 res
= prompt_yesno(s
, _("Your edited hunk does not apply. "
1233 "Edit again (saying \"no\" discards!) "
1240 static int apply_for_checkout(struct add_p_state
*s
, struct strbuf
*diff
,
1243 const char *reverse
= is_reverse
? "-R" : NULL
;
1244 struct child_process check_index
= CHILD_PROCESS_INIT
;
1245 struct child_process check_worktree
= CHILD_PROCESS_INIT
;
1246 struct child_process apply_index
= CHILD_PROCESS_INIT
;
1247 struct child_process apply_worktree
= CHILD_PROCESS_INIT
;
1248 int applies_index
, applies_worktree
;
1250 setup_child_process(s
, &check_index
,
1251 "apply", "--cached", "--check", reverse
, NULL
);
1252 applies_index
= !pipe_command(&check_index
, diff
->buf
, diff
->len
,
1255 setup_child_process(s
, &check_worktree
,
1256 "apply", "--check", reverse
, NULL
);
1257 applies_worktree
= !pipe_command(&check_worktree
, diff
->buf
, diff
->len
,
1260 if (applies_worktree
&& applies_index
) {
1261 setup_child_process(s
, &apply_index
,
1262 "apply", "--cached", reverse
, NULL
);
1263 pipe_command(&apply_index
, diff
->buf
, diff
->len
,
1266 setup_child_process(s
, &apply_worktree
,
1267 "apply", reverse
, NULL
);
1268 pipe_command(&apply_worktree
, diff
->buf
, diff
->len
,
1274 if (!applies_index
) {
1275 err(s
, _("The selected hunks do not apply to the index!"));
1276 if (prompt_yesno(s
, _("Apply them to the worktree "
1278 setup_child_process(s
, &apply_worktree
,
1279 "apply", reverse
, NULL
);
1280 return pipe_command(&apply_worktree
, diff
->buf
,
1281 diff
->len
, NULL
, 0, NULL
, 0);
1283 err(s
, _("Nothing was applied.\n"));
1285 /* As a last resort, show the diff to the user */
1286 fwrite(diff
->buf
, diff
->len
, 1, stderr
);
1291 #define SUMMARY_HEADER_WIDTH 20
1292 #define SUMMARY_LINE_WIDTH 80
1293 static void summarize_hunk(struct add_p_state
*s
, struct hunk
*hunk
,
1296 struct hunk_header
*header
= &hunk
->header
;
1297 struct strbuf
*plain
= &s
->plain
;
1298 size_t len
= out
->len
, i
;
1300 strbuf_addf(out
, " -%lu,%lu +%lu,%lu ",
1301 header
->old_offset
, header
->old_count
,
1302 header
->new_offset
, header
->new_count
);
1303 if (out
->len
- len
< SUMMARY_HEADER_WIDTH
)
1304 strbuf_addchars(out
, ' ',
1305 SUMMARY_HEADER_WIDTH
+ len
- out
->len
);
1306 for (i
= hunk
->start
; i
< hunk
->end
; i
= find_next_line(plain
, i
))
1307 if (plain
->buf
[i
] != ' ')
1310 strbuf_add(out
, plain
->buf
+ i
, find_next_line(plain
, i
) - i
);
1311 if (out
->len
- len
> SUMMARY_LINE_WIDTH
)
1312 strbuf_setlen(out
, len
+ SUMMARY_LINE_WIDTH
);
1313 strbuf_complete_line(out
);
1316 #define DISPLAY_HUNKS_LINES 20
1317 static size_t display_hunks(struct add_p_state
*s
,
1318 struct file_diff
*file_diff
, size_t start_index
)
1320 size_t end_index
= start_index
+ DISPLAY_HUNKS_LINES
;
1322 if (end_index
> file_diff
->hunk_nr
)
1323 end_index
= file_diff
->hunk_nr
;
1325 while (start_index
< end_index
) {
1326 struct hunk
*hunk
= file_diff
->hunk
+ start_index
++;
1328 strbuf_reset(&s
->buf
);
1329 strbuf_addf(&s
->buf
, "%c%2d: ", hunk
->use
== USE_HUNK
? '+'
1330 : hunk
->use
== SKIP_HUNK
? '-' : ' ',
1332 summarize_hunk(s
, hunk
, &s
->buf
);
1333 fputs(s
->buf
.buf
, stdout
);
1339 static const char help_patch_remainder
[] =
1340 N_("j - leave this hunk undecided, see next undecided hunk\n"
1341 "J - leave this hunk undecided, see next hunk\n"
1342 "k - leave this hunk undecided, see previous undecided hunk\n"
1343 "K - leave this hunk undecided, see previous hunk\n"
1344 "g - select a hunk to go to\n"
1345 "/ - search for a hunk matching the given regex\n"
1346 "s - split the current hunk into smaller hunks\n"
1347 "e - manually edit the current hunk\n"
1348 "? - print help\n");
1350 static int patch_update_file(struct add_p_state
*s
,
1351 struct file_diff
*file_diff
)
1353 size_t hunk_index
= 0;
1354 ssize_t i
, undecided_previous
, undecided_next
;
1357 struct child_process cp
= CHILD_PROCESS_INIT
;
1358 int colored
= !!s
->colored
.len
, quit
= 0;
1359 enum prompt_mode_type prompt_mode_type
;
1361 if (!file_diff
->hunk_nr
)
1364 strbuf_reset(&s
->buf
);
1365 render_diff_header(s
, file_diff
, colored
, &s
->buf
);
1366 fputs(s
->buf
.buf
, stdout
);
1368 if (hunk_index
>= file_diff
->hunk_nr
)
1370 hunk
= file_diff
->hunk
+ hunk_index
;
1372 undecided_previous
= -1;
1373 for (i
= hunk_index
- 1; i
>= 0; i
--)
1374 if (file_diff
->hunk
[i
].use
== UNDECIDED_HUNK
) {
1375 undecided_previous
= i
;
1379 undecided_next
= -1;
1380 for (i
= hunk_index
+ 1; i
< file_diff
->hunk_nr
; i
++)
1381 if (file_diff
->hunk
[i
].use
== UNDECIDED_HUNK
) {
1386 /* Everything decided? */
1387 if (undecided_previous
< 0 && undecided_next
< 0 &&
1388 hunk
->use
!= UNDECIDED_HUNK
)
1391 strbuf_reset(&s
->buf
);
1392 render_hunk(s
, hunk
, 0, colored
, &s
->buf
);
1393 fputs(s
->buf
.buf
, stdout
);
1395 strbuf_reset(&s
->buf
);
1396 if (undecided_previous
>= 0)
1397 strbuf_addstr(&s
->buf
, ",k");
1399 strbuf_addstr(&s
->buf
, ",K");
1400 if (undecided_next
>= 0)
1401 strbuf_addstr(&s
->buf
, ",j");
1402 if (hunk_index
+ 1 < file_diff
->hunk_nr
)
1403 strbuf_addstr(&s
->buf
, ",J");
1404 if (file_diff
->hunk_nr
> 1)
1405 strbuf_addstr(&s
->buf
, ",g,/");
1406 if (hunk
->splittable_into
> 1)
1407 strbuf_addstr(&s
->buf
, ",s");
1408 if (hunk_index
+ 1 > file_diff
->mode_change
&&
1409 !file_diff
->deleted
)
1410 strbuf_addstr(&s
->buf
, ",e");
1412 if (file_diff
->deleted
)
1413 prompt_mode_type
= PROMPT_DELETION
;
1414 else if (file_diff
->added
)
1415 prompt_mode_type
= PROMPT_ADDITION
;
1416 else if (file_diff
->mode_change
&& !hunk_index
)
1417 prompt_mode_type
= PROMPT_MODE_CHANGE
;
1419 prompt_mode_type
= PROMPT_HUNK
;
1421 color_fprintf(stdout
, s
->s
.prompt_color
,
1422 "(%"PRIuMAX
"/%"PRIuMAX
") ",
1423 (uintmax_t)hunk_index
+ 1,
1424 (uintmax_t)file_diff
->hunk_nr
);
1425 color_fprintf(stdout
, s
->s
.prompt_color
,
1426 _(s
->mode
->prompt_mode
[prompt_mode_type
]),
1429 if (read_single_character(s
) == EOF
)
1434 ch
= tolower(s
->answer
.buf
[0]);
1436 hunk
->use
= USE_HUNK
;
1438 hunk_index
= undecided_next
< 0 ?
1439 file_diff
->hunk_nr
: undecided_next
;
1440 } else if (ch
== 'n') {
1441 hunk
->use
= SKIP_HUNK
;
1442 goto soft_increment
;
1443 } else if (ch
== 'a') {
1444 for (; hunk_index
< file_diff
->hunk_nr
; hunk_index
++) {
1445 hunk
= file_diff
->hunk
+ hunk_index
;
1446 if (hunk
->use
== UNDECIDED_HUNK
)
1447 hunk
->use
= USE_HUNK
;
1449 } else if (ch
== 'd' || ch
== 'q') {
1450 for (; hunk_index
< file_diff
->hunk_nr
; hunk_index
++) {
1451 hunk
= file_diff
->hunk
+ hunk_index
;
1452 if (hunk
->use
== UNDECIDED_HUNK
)
1453 hunk
->use
= SKIP_HUNK
;
1459 } else if (s
->answer
.buf
[0] == 'K') {
1463 err(s
, _("No previous hunk"));
1464 } else if (s
->answer
.buf
[0] == 'J') {
1465 if (hunk_index
+ 1 < file_diff
->hunk_nr
)
1468 err(s
, _("No next hunk"));
1469 } else if (s
->answer
.buf
[0] == 'k') {
1470 if (undecided_previous
>= 0)
1471 hunk_index
= undecided_previous
;
1473 err(s
, _("No previous hunk"));
1474 } else if (s
->answer
.buf
[0] == 'j') {
1475 if (undecided_next
>= 0)
1476 hunk_index
= undecided_next
;
1478 err(s
, _("No next hunk"));
1479 } else if (s
->answer
.buf
[0] == 'g') {
1481 unsigned long response
;
1483 if (file_diff
->hunk_nr
< 2) {
1484 err(s
, _("No other hunks to goto"));
1487 strbuf_remove(&s
->answer
, 0, 1);
1488 strbuf_trim(&s
->answer
);
1489 i
= hunk_index
- DISPLAY_HUNKS_LINES
/ 2;
1490 if (i
< file_diff
->mode_change
)
1491 i
= file_diff
->mode_change
;
1492 while (s
->answer
.len
== 0) {
1493 i
= display_hunks(s
, file_diff
, i
);
1494 printf("%s", i
< file_diff
->hunk_nr
?
1495 _("go to which hunk (<ret> to see "
1496 "more)? ") : _("go to which hunk? "));
1498 if (strbuf_getline(&s
->answer
,
1501 strbuf_trim_trailing_newline(&s
->answer
);
1504 strbuf_trim(&s
->answer
);
1505 response
= strtoul(s
->answer
.buf
, &pend
, 10);
1506 if (*pend
|| pend
== s
->answer
.buf
)
1507 err(s
, _("Invalid number: '%s'"),
1509 else if (0 < response
&& response
<= file_diff
->hunk_nr
)
1510 hunk_index
= response
- 1;
1512 err(s
, Q_("Sorry, only %d hunk available.",
1513 "Sorry, only %d hunks available.",
1514 file_diff
->hunk_nr
),
1515 (int)file_diff
->hunk_nr
);
1516 } else if (s
->answer
.buf
[0] == '/') {
1520 if (file_diff
->hunk_nr
< 2) {
1521 err(s
, _("No other hunks to search"));
1524 strbuf_remove(&s
->answer
, 0, 1);
1525 strbuf_trim_trailing_newline(&s
->answer
);
1526 if (s
->answer
.len
== 0) {
1527 printf("%s", _("search for regex? "));
1529 if (strbuf_getline(&s
->answer
,
1532 strbuf_trim_trailing_newline(&s
->answer
);
1533 if (s
->answer
.len
== 0)
1536 ret
= regcomp(®ex
, s
->answer
.buf
,
1537 REG_EXTENDED
| REG_NOSUB
| REG_NEWLINE
);
1541 regerror(ret
, ®ex
, errbuf
, sizeof(errbuf
));
1542 err(s
, _("Malformed search regexp %s: %s"),
1543 s
->answer
.buf
, errbuf
);
1548 /* render the hunk into a scratch buffer */
1549 render_hunk(s
, file_diff
->hunk
+ i
, 0, 0,
1551 if (regexec(®ex
, s
->buf
.buf
, 0, NULL
, 0)
1555 if (i
== file_diff
->hunk_nr
)
1557 if (i
!= hunk_index
)
1559 err(s
, _("No hunk matches the given pattern"));
1563 } else if (s
->answer
.buf
[0] == 's') {
1564 size_t splittable_into
= hunk
->splittable_into
;
1565 if (splittable_into
< 2)
1566 err(s
, _("Sorry, cannot split this hunk"));
1567 else if (!split_hunk(s
, file_diff
,
1568 hunk
- file_diff
->hunk
))
1569 color_fprintf_ln(stdout
, s
->s
.header_color
,
1570 _("Split into %d hunks."),
1571 (int)splittable_into
);
1572 } else if (s
->answer
.buf
[0] == 'e') {
1573 if (hunk_index
+ 1 == file_diff
->mode_change
)
1574 err(s
, _("Sorry, cannot edit this hunk"));
1575 else if (edit_hunk_loop(s
, file_diff
, hunk
) >= 0) {
1576 hunk
->use
= USE_HUNK
;
1577 goto soft_increment
;
1580 const char *p
= _(help_patch_remainder
), *eol
= p
;
1582 color_fprintf(stdout
, s
->s
.help_color
, "%s",
1583 _(s
->mode
->help_patch_text
));
1586 * Show only those lines of the remainder that are
1587 * actually applicable with the current hunk.
1589 for (; *p
; p
= eol
+ (*eol
== '\n')) {
1590 eol
= strchrnul(p
, '\n');
1593 * `s->buf` still contains the part of the
1594 * commands shown in the prompt that are not
1597 if (*p
!= '?' && !strchr(s
->buf
.buf
, *p
))
1600 color_fprintf_ln(stdout
, s
->s
.help_color
,
1601 "%.*s", (int)(eol
- p
), p
);
1606 /* Any hunk to be used? */
1607 for (i
= 0; i
< file_diff
->hunk_nr
; i
++)
1608 if (file_diff
->hunk
[i
].use
== USE_HUNK
)
1611 if (i
< file_diff
->hunk_nr
) {
1612 /* At least one hunk selected: apply */
1613 strbuf_reset(&s
->buf
);
1614 reassemble_patch(s
, file_diff
, 0, &s
->buf
);
1616 discard_index(s
->s
.r
->index
);
1617 if (s
->mode
->apply_for_checkout
)
1618 apply_for_checkout(s
, &s
->buf
,
1619 s
->mode
->is_reverse
);
1621 setup_child_process(s
, &cp
, "apply", NULL
);
1622 argv_array_pushv(&cp
.args
, s
->mode
->apply_args
);
1623 if (pipe_command(&cp
, s
->buf
.buf
, s
->buf
.len
,
1625 error(_("'git apply' failed"));
1627 if (!repo_read_index(s
->s
.r
))
1628 repo_refresh_and_write_index(s
->s
.r
, REFRESH_QUIET
, 0,
1629 1, NULL
, NULL
, NULL
);
1636 int run_add_p(struct repository
*r
, enum add_p_mode mode
,
1637 const char *revision
, const struct pathspec
*ps
)
1639 struct add_p_state s
= {
1640 { r
}, STRBUF_INIT
, STRBUF_INIT
, STRBUF_INIT
, STRBUF_INIT
1642 size_t i
, binary_count
= 0;
1644 init_add_i_state(&s
.s
, r
);
1646 if (mode
== ADD_P_STASH
)
1647 s
.mode
= &patch_mode_stash
;
1648 else if (mode
== ADD_P_RESET
) {
1649 if (!revision
|| !strcmp(revision
, "HEAD"))
1650 s
.mode
= &patch_mode_reset_head
;
1652 s
.mode
= &patch_mode_reset_nothead
;
1653 } else if (mode
== ADD_P_CHECKOUT
) {
1655 s
.mode
= &patch_mode_checkout_index
;
1656 else if (!strcmp(revision
, "HEAD"))
1657 s
.mode
= &patch_mode_checkout_head
;
1659 s
.mode
= &patch_mode_checkout_nothead
;
1660 } else if (mode
== ADD_P_WORKTREE
) {
1662 s
.mode
= &patch_mode_checkout_index
;
1663 else if (!strcmp(revision
, "HEAD"))
1664 s
.mode
= &patch_mode_worktree_head
;
1666 s
.mode
= &patch_mode_worktree_nothead
;
1668 s
.mode
= &patch_mode_add
;
1669 s
.revision
= revision
;
1671 if (discard_index(r
->index
) < 0 || repo_read_index(r
) < 0 ||
1672 (!s
.mode
->index_only
&&
1673 repo_refresh_and_write_index(r
, REFRESH_QUIET
, 0, 1,
1674 NULL
, NULL
, NULL
) < 0) ||
1675 parse_diff(&s
, ps
) < 0) {
1676 strbuf_release(&s
.plain
);
1677 strbuf_release(&s
.colored
);
1678 clear_add_i_state(&s
.s
);
1682 for (i
= 0; i
< s
.file_diff_nr
; i
++)
1683 if (s
.file_diff
[i
].binary
&& !s
.file_diff
[i
].hunk_nr
)
1685 else if (patch_update_file(&s
, s
.file_diff
+ i
))
1688 if (s
.file_diff_nr
== 0)
1689 fprintf(stderr
, _("No changes.\n"));
1690 else if (binary_count
== s
.file_diff_nr
)
1691 fprintf(stderr
, _("Only binary files changed.\n"));
1693 strbuf_release(&s
.answer
);
1694 strbuf_release(&s
.buf
);
1695 strbuf_release(&s
.plain
);
1696 strbuf_release(&s
.colored
);
1697 clear_add_i_state(&s
.s
);