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