git

1
#define USE_THE_REPOSITORY_VARIABLE
2

3
#include "git-compat-util.h"
4
#include "add-interactive.h"
5
#include "advice.h"
6
#include "editor.h"
7
#include "environment.h"
8
#include "gettext.h"
9
#include "object-name.h"
10
#include "pager.h"
11
#include "read-cache-ll.h"
12
#include "repository.h"
13
#include "strbuf.h"
14
#include "sigchain.h"
15
#include "run-command.h"
16
#include "strvec.h"
17
#include "pathspec.h"
18
#include "color.h"
19
#include "compat/terminal.h"
20
#include "prompt.h"
21

22
enum prompt_mode_type {
23
	PROMPT_MODE_CHANGE = 0, PROMPT_DELETION, PROMPT_ADDITION, PROMPT_HUNK,
24
	PROMPT_MODE_MAX, /* must be last */
25
};
26

27
struct patch_mode {
28
	/*
29
	 * The magic constant 4 is chosen such that all patch modes
30
	 * provide enough space for three command-line arguments followed by a
31
	 * trailing `NULL`.
32
	 */
33
	const char *diff_cmd[4], *apply_args[4], *apply_check_args[4];
34
	unsigned is_reverse:1, index_only:1, apply_for_checkout:1;
35
	const char *prompt_mode[PROMPT_MODE_MAX];
36
	const char *edit_hunk_hint, *help_patch_text;
37
};
38

39
static struct patch_mode patch_mode_add = {
40
	.diff_cmd = { "diff-files", NULL },
41
	.apply_args = { "--cached", NULL },
42
	.apply_check_args = { "--cached", NULL },
43
	.prompt_mode = {
44
		N_("Stage mode change [y,n,q,a,d%s,?]? "),
45
		N_("Stage deletion [y,n,q,a,d%s,?]? "),
46
		N_("Stage addition [y,n,q,a,d%s,?]? "),
47
		N_("Stage this hunk [y,n,q,a,d%s,?]? ")
48
	},
49
	.edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "
50
			     "will immediately be marked for staging."),
51
	.help_patch_text =
52
		N_("y - stage this hunk\n"
53
		   "n - do not stage this hunk\n"
54
		   "q - quit; do not stage this hunk or any of the remaining "
55
			"ones\n"
56
		   "a - stage this hunk and all later hunks in the file\n"
57
		   "d - do not stage this hunk or any of the later hunks in "
58
			"the file\n")
59
};
60

61
static struct patch_mode patch_mode_stash = {
62
	.diff_cmd = { "diff-index", "HEAD", NULL },
63
	.apply_args = { "--cached", NULL },
64
	.apply_check_args = { "--cached", NULL },
65
	.prompt_mode = {
66
		N_("Stash mode change [y,n,q,a,d%s,?]? "),
67
		N_("Stash deletion [y,n,q,a,d%s,?]? "),
68
		N_("Stash addition [y,n,q,a,d%s,?]? "),
69
		N_("Stash this hunk [y,n,q,a,d%s,?]? "),
70
	},
71
	.edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "
72
			     "will immediately be marked for stashing."),
73
	.help_patch_text =
74
		N_("y - stash this hunk\n"
75
		   "n - do not stash this hunk\n"
76
		   "q - quit; do not stash this hunk or any of the remaining "
77
			"ones\n"
78
		   "a - stash this hunk and all later hunks in the file\n"
79
		   "d - do not stash this hunk or any of the later hunks in "
80
			"the file\n"),
81
};
82

83
static struct patch_mode patch_mode_reset_head = {
84
	.diff_cmd = { "diff-index", "--cached", NULL },
85
	.apply_args = { "-R", "--cached", NULL },
86
	.apply_check_args = { "-R", "--cached", NULL },
87
	.is_reverse = 1,
88
	.index_only = 1,
89
	.prompt_mode = {
90
		N_("Unstage mode change [y,n,q,a,d%s,?]? "),
91
		N_("Unstage deletion [y,n,q,a,d%s,?]? "),
92
		N_("Unstage addition [y,n,q,a,d%s,?]? "),
93
		N_("Unstage this hunk [y,n,q,a,d%s,?]? "),
94
	},
95
	.edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "
96
			     "will immediately be marked for unstaging."),
97
	.help_patch_text =
98
		N_("y - unstage this hunk\n"
99
		   "n - do not unstage this hunk\n"
100
		   "q - quit; do not unstage this hunk or any of the remaining "
101
			"ones\n"
102
		   "a - unstage this hunk and all later hunks in the file\n"
103
		   "d - do not unstage this hunk or any of the later hunks in "
104
			"the file\n"),
105
};
106

107
static struct patch_mode patch_mode_reset_nothead = {
108
	.diff_cmd = { "diff-index", "-R", "--cached", NULL },
109
	.apply_args = { "--cached", NULL },
110
	.apply_check_args = { "--cached", NULL },
111
	.index_only = 1,
112
	.prompt_mode = {
113
		N_("Apply mode change to index [y,n,q,a,d%s,?]? "),
114
		N_("Apply deletion to index [y,n,q,a,d%s,?]? "),
115
		N_("Apply addition to index [y,n,q,a,d%s,?]? "),
116
		N_("Apply this hunk to index [y,n,q,a,d%s,?]? "),
117
	},
118
	.edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "
119
			     "will immediately be marked for applying."),
120
	.help_patch_text =
121
		N_("y - apply this hunk to index\n"
122
		   "n - do not apply this hunk to index\n"
123
		   "q - quit; do not apply this hunk or any of the remaining "
124
			"ones\n"
125
		   "a - apply this hunk and all later hunks in the file\n"
126
		   "d - do not apply this hunk or any of the later hunks in "
127
			"the file\n"),
128
};
129

130
static struct patch_mode patch_mode_checkout_index = {
131
	.diff_cmd = { "diff-files", NULL },
132
	.apply_args = { "-R", NULL },
133
	.apply_check_args = { "-R", NULL },
134
	.is_reverse = 1,
135
	.prompt_mode = {
136
		N_("Discard mode change from worktree [y,n,q,a,d%s,?]? "),
137
		N_("Discard deletion from worktree [y,n,q,a,d%s,?]? "),
138
		N_("Discard addition from worktree [y,n,q,a,d%s,?]? "),
139
		N_("Discard this hunk from worktree [y,n,q,a,d%s,?]? "),
140
	},
141
	.edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "
142
			     "will immediately be marked for discarding."),
143
	.help_patch_text =
144
		N_("y - discard this hunk from worktree\n"
145
		   "n - do not discard this hunk from worktree\n"
146
		   "q - quit; do not discard this hunk or any of the remaining "
147
			"ones\n"
148
		   "a - discard this hunk and all later hunks in the file\n"
149
		   "d - do not discard this hunk or any of the later hunks in "
150
			"the file\n"),
151
};
152

153
static struct patch_mode patch_mode_checkout_head = {
154
	.diff_cmd = { "diff-index", NULL },
155
	.apply_for_checkout = 1,
156
	.apply_check_args = { "-R", NULL },
157
	.is_reverse = 1,
158
	.prompt_mode = {
159
		N_("Discard mode change from index and worktree [y,n,q,a,d%s,?]? "),
160
		N_("Discard deletion from index and worktree [y,n,q,a,d%s,?]? "),
161
		N_("Discard addition from index and worktree [y,n,q,a,d%s,?]? "),
162
		N_("Discard this hunk from index and worktree [y,n,q,a,d%s,?]? "),
163
	},
164
	.edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "
165
			     "will immediately be marked for discarding."),
166
	.help_patch_text =
167
		N_("y - discard this hunk from index and worktree\n"
168
		   "n - do not discard this hunk from index and worktree\n"
169
		   "q - quit; do not discard this hunk or any of the remaining "
170
			"ones\n"
171
		   "a - discard this hunk and all later hunks in the file\n"
172
		   "d - do not discard this hunk or any of the later hunks in "
173
			"the file\n"),
174
};
175

176
static struct patch_mode patch_mode_checkout_nothead = {
177
	.diff_cmd = { "diff-index", "-R", NULL },
178
	.apply_for_checkout = 1,
179
	.apply_check_args = { NULL },
180
	.prompt_mode = {
181
		N_("Apply mode change to index and worktree [y,n,q,a,d%s,?]? "),
182
		N_("Apply deletion to index and worktree [y,n,q,a,d%s,?]? "),
183
		N_("Apply addition to index and worktree [y,n,q,a,d%s,?]? "),
184
		N_("Apply this hunk to index and worktree [y,n,q,a,d%s,?]? "),
185
	},
186
	.edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "
187
			     "will immediately be marked for applying."),
188
	.help_patch_text =
189
		N_("y - apply this hunk to index and worktree\n"
190
		   "n - do not apply this hunk to index and worktree\n"
191
		   "q - quit; do not apply this hunk or any of the remaining "
192
			"ones\n"
193
		   "a - apply this hunk and all later hunks in the file\n"
194
		   "d - do not apply this hunk or any of the later hunks in "
195
			"the file\n"),
196
};
197

198
static struct patch_mode patch_mode_worktree_head = {
199
	.diff_cmd = { "diff-index", NULL },
200
	.apply_args = { "-R", NULL },
201
	.apply_check_args = { "-R", NULL },
202
	.is_reverse = 1,
203
	.prompt_mode = {
204
		N_("Discard mode change from worktree [y,n,q,a,d%s,?]? "),
205
		N_("Discard deletion from worktree [y,n,q,a,d%s,?]? "),
206
		N_("Discard addition from worktree [y,n,q,a,d%s,?]? "),
207
		N_("Discard this hunk from worktree [y,n,q,a,d%s,?]? "),
208
	},
209
	.edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "
210
			     "will immediately be marked for discarding."),
211
	.help_patch_text =
212
		N_("y - discard this hunk from worktree\n"
213
		   "n - do not discard this hunk from worktree\n"
214
		   "q - quit; do not discard this hunk or any of the remaining "
215
			"ones\n"
216
		   "a - discard this hunk and all later hunks in the file\n"
217
		   "d - do not discard this hunk or any of the later hunks in "
218
			"the file\n"),
219
};
220

221
static struct patch_mode patch_mode_worktree_nothead = {
222
	.diff_cmd = { "diff-index", "-R", NULL },
223
	.apply_args = { NULL },
224
	.apply_check_args = { NULL },
225
	.prompt_mode = {
226
		N_("Apply mode change to worktree [y,n,q,a,d%s,?]? "),
227
		N_("Apply deletion to worktree [y,n,q,a,d%s,?]? "),
228
		N_("Apply addition to worktree [y,n,q,a,d%s,?]? "),
229
		N_("Apply this hunk to worktree [y,n,q,a,d%s,?]? "),
230
	},
231
	.edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "
232
			     "will immediately be marked for applying."),
233
	.help_patch_text =
234
		N_("y - apply this hunk to worktree\n"
235
		   "n - do not apply this hunk to worktree\n"
236
		   "q - quit; do not apply this hunk or any of the remaining "
237
			"ones\n"
238
		   "a - apply this hunk and all later hunks in the file\n"
239
		   "d - do not apply this hunk or any of the later hunks in "
240
			"the file\n"),
241
};
242

243
struct hunk_header {
244
	unsigned long old_offset, old_count, new_offset, new_count;
245
	/*
246
	 * Start/end offsets to the extra text after the second `@@` in the
247
	 * hunk header, e.g. the function signature. This is expected to
248
	 * include the newline.
249
	 */
250
	size_t extra_start, extra_end, colored_extra_start, colored_extra_end;
251
	unsigned suppress_colored_line_range:1;
252
};
253

254
struct hunk {
255
	size_t start, end, colored_start, colored_end, splittable_into;
256
	ssize_t delta;
257
	enum { UNDECIDED_HUNK = 0, SKIP_HUNK, USE_HUNK } use;
258
	struct hunk_header header;
259
};
260

261
struct add_p_state {
262
	struct add_i_state s;
263
	struct strbuf answer, buf;
264

265
	/* parsed diff */
266
	struct strbuf plain, colored;
267
	struct file_diff {
268
		struct hunk head;
269
		struct hunk *hunk;
270
		size_t hunk_nr, hunk_alloc;
271
		unsigned deleted:1, added:1, mode_change:1,binary:1;
272
	} *file_diff;
273
	size_t file_diff_nr;
274

275
	/* patch mode */
276
	struct patch_mode *mode;
277
	const char *revision;
278
};
279

280
static void add_p_state_clear(struct add_p_state *s)
281
{
282
	size_t i;
283

284
	strbuf_release(&s->answer);
285
	strbuf_release(&s->buf);
286
	strbuf_release(&s->plain);
287
	strbuf_release(&s->colored);
288
	for (i = 0; i < s->file_diff_nr; i++)
289
		free(s->file_diff[i].hunk);
290
	free(s->file_diff);
291
	clear_add_i_state(&s->s);
292
}
293

294
__attribute__((format (printf, 2, 3)))
295
static void err(struct add_p_state *s, const char *fmt, ...)
296
{
297
	va_list args;
298

299
	va_start(args, fmt);
300
	fputs(s->s.error_color, stdout);
301
	vprintf(fmt, args);
302
	puts(s->s.reset_color);
303
	va_end(args);
304
}
305

306
LAST_ARG_MUST_BE_NULL
307
static void setup_child_process(struct add_p_state *s,
308
				struct child_process *cp, ...)
309
{
310
	va_list ap;
311
	const char *arg;
312

313
	va_start(ap, cp);
314
	while ((arg = va_arg(ap, const char *)))
315
		strvec_push(&cp->args, arg);
316
	va_end(ap);
317

318
	cp->git_cmd = 1;
319
	strvec_pushf(&cp->env,
320
		     INDEX_ENVIRONMENT "=%s", s->s.r->index_file);
321
}
322

323
static int parse_range(const char **p,
324
		       unsigned long *offset, unsigned long *count)
325
{
326
	char *pend;
327

328
	*offset = strtoul(*p, &pend, 10);
329
	if (pend == *p)
330
		return -1;
331
	if (*pend != ',') {
332
		*count = 1;
333
		*p = pend;
334
		return 0;
335
	}
336
	*count = strtoul(pend + 1, (char **)p, 10);
337
	return *p == pend + 1 ? -1 : 0;
338
}
339

340
static int parse_hunk_header(struct add_p_state *s, struct hunk *hunk)
341
{
342
	struct hunk_header *header = &hunk->header;
343
	const char *line = s->plain.buf + hunk->start, *p = line;
344
	char *eol = memchr(p, '\n', s->plain.len - hunk->start);
345

346
	if (!eol)
347
		eol = s->plain.buf + s->plain.len;
348

349
	if (!skip_prefix(p, "@@ -", &p) ||
350
	    parse_range(&p, &header->old_offset, &header->old_count) < 0 ||
351
	    !skip_prefix(p, " +", &p) ||
352
	    parse_range(&p, &header->new_offset, &header->new_count) < 0 ||
353
	    !skip_prefix(p, " @@", &p))
354
		return error(_("could not parse hunk header '%.*s'"),
355
			     (int)(eol - line), line);
356

357
	hunk->start = eol - s->plain.buf + (*eol == '\n');
358
	header->extra_start = p - s->plain.buf;
359
	header->extra_end = hunk->start;
360

361
	if (!s->colored.len) {
362
		header->colored_extra_start = header->colored_extra_end = 0;
363
		return 0;
364
	}
365

366
	/* Now find the extra text in the colored diff */
367
	line = s->colored.buf + hunk->colored_start;
368
	eol = memchr(line, '\n', s->colored.len - hunk->colored_start);
369
	if (!eol)
370
		eol = s->colored.buf + s->colored.len;
371
	p = memmem(line, eol - line, "@@ -", 4);
372
	if (p && (p = memmem(p + 4, eol - p - 4, " @@", 3))) {
373
		header->colored_extra_start = p + 3 - s->colored.buf;
374
	} else {
375
		/* could not parse colored hunk header, leave as-is */
376
		header->colored_extra_start = hunk->colored_start;
377
		header->suppress_colored_line_range = 1;
378
	}
379
	hunk->colored_start = eol - s->colored.buf + (*eol == '\n');
380
	header->colored_extra_end = hunk->colored_start;
381

382
	return 0;
383
}
384

385
static int is_octal(const char *p, size_t len)
386
{
387
	if (!len)
388
		return 0;
389

390
	while (len--)
391
		if (*p < '0' || *(p++) > '7')
392
			return 0;
393
	return 1;
394
}
395

396
static void complete_file(char marker, struct hunk *hunk)
397
{
398
	if (marker == '-' || marker == '+')
399
		/*
400
		 * Last hunk ended in non-context line (i.e. it
401
		 * appended lines to the file, so there are no
402
		 * trailing context lines).
403
		 */
404
		hunk->splittable_into++;
405
}
406

407
/* Empty context lines may omit the leading ' ' */
408
static int normalize_marker(const char *p)
409
{
410
	return p[0] == '\n' || (p[0] == '\r' && p[1] == '\n') ? ' ' : p[0];
411
}
412

413
static int parse_diff(struct add_p_state *s, const struct pathspec *ps)
414
{
415
	struct strvec args = STRVEC_INIT;
416
	const char *diff_algorithm = s->s.interactive_diff_algorithm;
417
	struct strbuf *plain = &s->plain, *colored = NULL;
418
	struct child_process cp = CHILD_PROCESS_INIT;
419
	char *p, *pend, *colored_p = NULL, *colored_pend = NULL, marker = '\0';
420
	size_t file_diff_alloc = 0, i, color_arg_index;
421
	struct file_diff *file_diff = NULL;
422
	struct hunk *hunk = NULL;
423
	int res;
424

425
	strvec_pushv(&args, s->mode->diff_cmd);
426
	if (diff_algorithm)
427
		strvec_pushf(&args, "--diff-algorithm=%s", diff_algorithm);
428
	if (s->revision) {
429
		struct object_id oid;
430
		strvec_push(&args,
431
			    /* could be on an unborn branch */
432
			    !strcmp("HEAD", s->revision) &&
433
			    repo_get_oid(the_repository, "HEAD", &oid) ?
434
			    empty_tree_oid_hex(the_repository->hash_algo) : s->revision);
435
	}
436
	color_arg_index = args.nr;
437
	/* Use `--no-color` explicitly, just in case `diff.color = always`. */
438
	strvec_pushl(&args, "--no-color", "--ignore-submodules=dirty", "-p",
439
		     "--", NULL);
440
	for (i = 0; i < ps->nr; i++)
441
		strvec_push(&args, ps->items[i].original);
442

443
	setup_child_process(s, &cp, NULL);
444
	strvec_pushv(&cp.args, args.v);
445
	res = capture_command(&cp, plain, 0);
446
	if (res) {
447
		strvec_clear(&args);
448
		return error(_("could not parse diff"));
449
	}
450
	if (!plain->len) {
451
		strvec_clear(&args);
452
		return 0;
453
	}
454
	strbuf_complete_line(plain);
455

456
	if (want_color_fd(1, -1)) {
457
		struct child_process colored_cp = CHILD_PROCESS_INIT;
458
		const char *diff_filter = s->s.interactive_diff_filter;
459

460
		setup_child_process(s, &colored_cp, NULL);
461
		xsnprintf((char *)args.v[color_arg_index], 8, "--color");
462
		strvec_pushv(&colored_cp.args, args.v);
463
		colored = &s->colored;
464
		res = capture_command(&colored_cp, colored, 0);
465
		strvec_clear(&args);
466
		if (res)
467
			return error(_("could not parse colored diff"));
468

469
		if (diff_filter) {
470
			struct child_process filter_cp = CHILD_PROCESS_INIT;
471

472
			setup_child_process(s, &filter_cp,
473
					    diff_filter, NULL);
474
			filter_cp.git_cmd = 0;
475
			filter_cp.use_shell = 1;
476
			strbuf_reset(&s->buf);
477
			if (pipe_command(&filter_cp,
478
					 colored->buf, colored->len,
479
					 &s->buf, colored->len,
480
					 NULL, 0) < 0)
481
				return error(_("failed to run '%s'"),
482
					     diff_filter);
483
			strbuf_swap(colored, &s->buf);
484
		}
485

486
		strbuf_complete_line(colored);
487
		colored_p = colored->buf;
488
		colored_pend = colored_p + colored->len;
489
	}
490
	strvec_clear(&args);
491

492
	/* parse files and hunks */
493
	p = plain->buf;
494
	pend = p + plain->len;
495
	while (p != pend) {
496
		char *eol = memchr(p, '\n', pend - p);
497
		const char *deleted = NULL, *mode_change = NULL;
498
		char ch = normalize_marker(p);
499

500
		if (!eol)
501
			eol = pend;
502

503
		if (starts_with(p, "diff ") ||
504
		    starts_with(p, "* Unmerged path ")) {
505
			complete_file(marker, hunk);
506
			ALLOC_GROW_BY(s->file_diff, s->file_diff_nr, 1,
507
				   file_diff_alloc);
508
			file_diff = s->file_diff + s->file_diff_nr - 1;
509
			hunk = &file_diff->head;
510
			hunk->start = p - plain->buf;
511
			if (colored_p)
512
				hunk->colored_start = colored_p - colored->buf;
513
			marker = '\0';
514
		} else if (p == plain->buf)
515
			BUG("diff starts with unexpected line:\n"
516
			    "%.*s\n", (int)(eol - p), p);
517
		else if (file_diff->deleted)
518
			; /* keep the rest of the file in a single "hunk" */
519
		else if (starts_with(p, "@@ ") ||
520
			 (hunk == &file_diff->head &&
521
			  (skip_prefix(p, "deleted file", &deleted)))) {
522
			if (marker == '-' || marker == '+')
523
				/*
524
				 * Should not happen; previous hunk did not end
525
				 * in a context line? Handle it anyway.
526
				 */
527
				hunk->splittable_into++;
528

529
			ALLOC_GROW_BY(file_diff->hunk, file_diff->hunk_nr, 1,
530
				   file_diff->hunk_alloc);
531
			hunk = file_diff->hunk + file_diff->hunk_nr - 1;
532

533
			hunk->start = p - plain->buf;
534
			if (colored)
535
				hunk->colored_start = colored_p - colored->buf;
536

537
			if (deleted)
538
				file_diff->deleted = 1;
539
			else if (parse_hunk_header(s, hunk) < 0)
540
				return -1;
541

542
			/*
543
			 * Start counting into how many hunks this one can be
544
			 * split
545
			 */
546
			marker = ch;
547
		} else if (hunk == &file_diff->head &&
548
			   starts_with(p, "new file")) {
549
			file_diff->added = 1;
550
		} else if (hunk == &file_diff->head &&
551
			   skip_prefix(p, "old mode ", &mode_change) &&
552
			   is_octal(mode_change, eol - mode_change)) {
553
			if (file_diff->mode_change)
554
				BUG("double mode change?\n\n%.*s",
555
				    (int)(eol - plain->buf), plain->buf);
556
			if (file_diff->hunk_nr)
557
				BUG("mode change in the middle?\n\n%.*s",
558
				    (int)(eol - plain->buf), plain->buf);
559

560
			/*
561
			 * Do *not* change `hunk`: the mode change pseudo-hunk
562
			 * is _part of_ the header "hunk".
563
			 */
564
			file_diff->mode_change = 1;
565
			ALLOC_GROW_BY(file_diff->hunk, file_diff->hunk_nr, 1,
566
				   file_diff->hunk_alloc);
567
			file_diff->hunk->start = p - plain->buf;
568
			if (colored_p)
569
				file_diff->hunk->colored_start =
570
					colored_p - colored->buf;
571
		} else if (hunk == &file_diff->head &&
572
			   skip_prefix(p, "new mode ", &mode_change) &&
573
			   is_octal(mode_change, eol - mode_change)) {
574

575
			/*
576
			 * Extend the "mode change" pseudo-hunk to include also
577
			 * the "new mode" line.
578
			 */
579
			if (!file_diff->mode_change)
580
				BUG("'new mode' without 'old mode'?\n\n%.*s",
581
				    (int)(eol - plain->buf), plain->buf);
582
			if (file_diff->hunk_nr != 1)
583
				BUG("mode change in the middle?\n\n%.*s",
584
				    (int)(eol - plain->buf), plain->buf);
585
			if (p - plain->buf != file_diff->hunk->end)
586
				BUG("'new mode' does not immediately follow "
587
				    "'old mode'?\n\n%.*s",
588
				    (int)(eol - plain->buf), plain->buf);
589
		} else if (hunk == &file_diff->head &&
590
			   starts_with(p, "Binary files "))
591
			file_diff->binary = 1;
592

593
		if (!!file_diff->deleted + !!file_diff->added +
594
		    !!file_diff->mode_change > 1)
595
			BUG("diff can only contain delete *or* add *or* a "
596
			    "mode change?!?\n%.*s",
597
			    (int)(eol - (plain->buf + file_diff->head.start)),
598
			    plain->buf + file_diff->head.start);
599

600
		if ((marker == '-' || marker == '+') && ch == ' ')
601
			hunk->splittable_into++;
602
		if (marker && ch != '\\')
603
			marker = ch;
604

605
		p = eol == pend ? pend : eol + 1;
606
		hunk->end = p - plain->buf;
607

608
		if (colored) {
609
			char *colored_eol = memchr(colored_p, '\n',
610
						   colored_pend - colored_p);
611
			if (colored_eol)
612
				colored_p = colored_eol + 1;
613
			else if (p != pend)
614
				/* non-colored has more lines? */
615
				goto mismatched_output;
616
			else if (colored_p == colored_pend)
617
				/* last line has no matching colored one? */
618
				goto mismatched_output;
619
			else
620
				colored_p = colored_pend;
621

622
			hunk->colored_end = colored_p - colored->buf;
623
		}
624

625
		if (mode_change) {
626
			if (file_diff->hunk_nr != 1)
627
				BUG("mode change in hunk #%d???",
628
				    (int)file_diff->hunk_nr);
629
			/* Adjust the end of the "mode change" pseudo-hunk */
630
			file_diff->hunk->end = hunk->end;
631
			if (colored)
632
				file_diff->hunk->colored_end = hunk->colored_end;
633
		}
634
	}
635
	complete_file(marker, hunk);
636

637
	/* non-colored shorter than colored? */
638
	if (colored_p != colored_pend) {
639
mismatched_output:
640
		error(_("mismatched output from interactive.diffFilter"));
641
		advise(_("Your filter must maintain a one-to-one correspondence\n"
642
			 "between its input and output lines."));
643
		return -1;
644
	}
645

646
	return 0;
647
}
648

649
static size_t find_next_line(struct strbuf *sb, size_t offset)
650
{
651
	char *eol;
652

653
	if (offset >= sb->len)
654
		BUG("looking for next line beyond buffer (%d >= %d)\n%s",
655
		    (int)offset, (int)sb->len, sb->buf);
656

657
	eol = memchr(sb->buf + offset, '\n', sb->len - offset);
658
	if (!eol)
659
		return sb->len;
660
	return eol - sb->buf + 1;
661
}
662

663
static void render_hunk(struct add_p_state *s, struct hunk *hunk,
664
			ssize_t delta, int colored, struct strbuf *out)
665
{
666
	struct hunk_header *header = &hunk->header;
667

668
	if (hunk->header.old_offset != 0 || hunk->header.new_offset != 0) {
669
		/*
670
		 * Generate the hunk header dynamically, except for special
671
		 * hunks (such as the diff header).
672
		 */
673
		const char *p;
674
		size_t len;
675
		unsigned long old_offset = header->old_offset;
676
		unsigned long new_offset = header->new_offset;
677

678
		if (!colored) {
679
			p = s->plain.buf + header->extra_start;
680
			len = header->extra_end - header->extra_start;
681
		} else if (header->suppress_colored_line_range) {
682
			strbuf_add(out,
683
				   s->colored.buf + header->colored_extra_start,
684
				   header->colored_extra_end -
685
				   header->colored_extra_start);
686

687
			strbuf_add(out, s->colored.buf + hunk->colored_start,
688
				   hunk->colored_end - hunk->colored_start);
689
			return;
690
		} else {
691
			strbuf_addstr(out, s->s.fraginfo_color);
692
			p = s->colored.buf + header->colored_extra_start;
693
			len = header->colored_extra_end
694
				- header->colored_extra_start;
695
		}
696

697
		if (s->mode->is_reverse)
698
			old_offset -= delta;
699
		else
700
			new_offset += delta;
701

702
		strbuf_addf(out, "@@ -%lu", old_offset);
703
		if (header->old_count != 1)
704
			strbuf_addf(out, ",%lu", header->old_count);
705
		strbuf_addf(out, " +%lu", new_offset);
706
		if (header->new_count != 1)
707
			strbuf_addf(out, ",%lu", header->new_count);
708
		strbuf_addstr(out, " @@");
709

710
		if (len)
711
			strbuf_add(out, p, len);
712
		else if (colored)
713
			strbuf_addf(out, "%s\n", s->s.reset_color);
714
		else
715
			strbuf_addch(out, '\n');
716
	}
717

718
	if (colored)
719
		strbuf_add(out, s->colored.buf + hunk->colored_start,
720
			   hunk->colored_end - hunk->colored_start);
721
	else
722
		strbuf_add(out, s->plain.buf + hunk->start,
723
			   hunk->end - hunk->start);
724
}
725

726
static void render_diff_header(struct add_p_state *s,
727
			       struct file_diff *file_diff, int colored,
728
			       struct strbuf *out)
729
{
730
	/*
731
	 * If there was a mode change, the first hunk is a pseudo hunk that
732
	 * corresponds to the mode line in the header. If the user did not want
733
	 * to stage that "hunk", we actually have to cut it out from the header.
734
	 */
735
	int skip_mode_change =
736
		file_diff->mode_change && file_diff->hunk->use != USE_HUNK;
737
	struct hunk *head = &file_diff->head, *first = file_diff->hunk;
738

739
	if (!skip_mode_change) {
740
		render_hunk(s, head, 0, colored, out);
741
		return;
742
	}
743

744
	if (colored) {
745
		const char *p = s->colored.buf;
746

747
		strbuf_add(out, p + head->colored_start,
748
			    first->colored_start - head->colored_start);
749
		strbuf_add(out, p + first->colored_end,
750
			    head->colored_end - first->colored_end);
751
	} else {
752
		const char *p = s->plain.buf;
753

754
		strbuf_add(out, p + head->start, first->start - head->start);
755
		strbuf_add(out, p + first->end, head->end - first->end);
756
	}
757
}
758

759
/* Coalesce hunks again that were split */
760
static int merge_hunks(struct add_p_state *s, struct file_diff *file_diff,
761
		       size_t *hunk_index, int use_all, struct hunk *merged)
762
{
763
	size_t i = *hunk_index, delta;
764
	struct hunk *hunk = file_diff->hunk + i;
765
	/* `header` corresponds to the merged hunk */
766
	struct hunk_header *header = &merged->header, *next;
767

768
	if (!use_all && hunk->use != USE_HUNK)
769
		return 0;
770

771
	*merged = *hunk;
772
	/* We simply skip the colored part (if any) when merging hunks */
773
	merged->colored_start = merged->colored_end = 0;
774

775
	for (; i + 1 < file_diff->hunk_nr; i++) {
776
		hunk++;
777
		next = &hunk->header;
778

779
		/*
780
		 * Stop merging hunks when:
781
		 *
782
		 * - the hunk is not selected for use, or
783
		 * - the hunk does not overlap with the already-merged hunk(s)
784
		 */
785
		if ((!use_all && hunk->use != USE_HUNK) ||
786
		    header->new_offset >= next->new_offset + merged->delta ||
787
		    header->new_offset + header->new_count
788
		    < next->new_offset + merged->delta)
789
			break;
790

791
		/*
792
		 * If the hunks were not edited, and overlap, we can simply
793
		 * extend the line range.
794
		 */
795
		if (merged->start < hunk->start && merged->end > hunk->start) {
796
			merged->end = hunk->end;
797
			merged->colored_end = hunk->colored_end;
798
			delta = 0;
799
		} else {
800
			const char *plain = s->plain.buf;
801
			size_t  overlapping_line_count = header->new_offset
802
				+ header->new_count - merged->delta
803
				- next->new_offset;
804
			size_t overlap_end = hunk->start;
805
			size_t overlap_start = overlap_end;
806
			size_t overlap_next, len, j;
807

808
			/*
809
			 * One of the hunks was edited: the modified hunk was
810
			 * appended to the strbuf `s->plain`.
811
			 *
812
			 * Let's ensure that at least the last context line of
813
			 * the first hunk overlaps with the corresponding line
814
			 * of the second hunk, and then merge.
815
			 */
816
			for (j = 0; j < overlapping_line_count; j++) {
817
				overlap_next = find_next_line(&s->plain,
818
							      overlap_end);
819

820
				if (overlap_next > hunk->end)
821
					BUG("failed to find %d context lines "
822
					    "in:\n%.*s",
823
					    (int)overlapping_line_count,
824
					    (int)(hunk->end - hunk->start),
825
					    plain + hunk->start);
826

827
				if (normalize_marker(&plain[overlap_end]) != ' ')
828
					return error(_("expected context line "
829
						       "#%d in\n%.*s"),
830
						     (int)(j + 1),
831
						     (int)(hunk->end
832
							   - hunk->start),
833
						     plain + hunk->start);
834

835
				overlap_start = overlap_end;
836
				overlap_end = overlap_next;
837
			}
838
			len = overlap_end - overlap_start;
839

840
			if (len > merged->end - merged->start ||
841
			    memcmp(plain + merged->end - len,
842
				   plain + overlap_start, len))
843
				return error(_("hunks do not overlap:\n%.*s\n"
844
					       "\tdoes not end with:\n%.*s"),
845
					     (int)(merged->end - merged->start),
846
					     plain + merged->start,
847
					     (int)len, plain + overlap_start);
848

849
			/*
850
			 * Since the start-end ranges are not adjacent, we
851
			 * cannot simply take the union of the ranges. To
852
			 * address that, we temporarily append the union of the
853
			 * lines to the `plain` strbuf.
854
			 */
855
			if (merged->end != s->plain.len) {
856
				size_t start = s->plain.len;
857

858
				strbuf_add(&s->plain, plain + merged->start,
859
					   merged->end - merged->start);
860
				plain = s->plain.buf;
861
				merged->start = start;
862
				merged->end = s->plain.len;
863
			}
864

865
			strbuf_add(&s->plain,
866
				   plain + overlap_end,
867
				   hunk->end - overlap_end);
868
			merged->end = s->plain.len;
869
			merged->splittable_into += hunk->splittable_into;
870
			delta = merged->delta;
871
			merged->delta += hunk->delta;
872
		}
873

874
		header->old_count = next->old_offset + next->old_count
875
			- header->old_offset;
876
		header->new_count = next->new_offset + delta
877
			+ next->new_count - header->new_offset;
878
	}
879

880
	if (i == *hunk_index)
881
		return 0;
882

883
	*hunk_index = i;
884
	return 1;
885
}
886

887
static void reassemble_patch(struct add_p_state *s,
888
			     struct file_diff *file_diff, int use_all,
889
			     struct strbuf *out)
890
{
891
	struct hunk *hunk;
892
	size_t save_len = s->plain.len, i;
893
	ssize_t delta = 0;
894

895
	render_diff_header(s, file_diff, 0, out);
896

897
	for (i = file_diff->mode_change; i < file_diff->hunk_nr; i++) {
898
		struct hunk merged = { 0 };
899

900
		hunk = file_diff->hunk + i;
901
		if (!use_all && hunk->use != USE_HUNK)
902
			delta += hunk->header.old_count
903
				- hunk->header.new_count;
904
		else {
905
			/* merge overlapping hunks into a temporary hunk */
906
			if (merge_hunks(s, file_diff, &i, use_all, &merged))
907
				hunk = &merged;
908

909
			render_hunk(s, hunk, delta, 0, out);
910

911
			/*
912
			 * In case `merge_hunks()` used `plain` as a scratch
913
			 * pad (this happens when an edited hunk had to be
914
			 * coalesced with another hunk).
915
			 */
916
			strbuf_setlen(&s->plain, save_len);
917

918
			delta += hunk->delta;
919
		}
920
	}
921
}
922

923
static int split_hunk(struct add_p_state *s, struct file_diff *file_diff,
924
		       size_t hunk_index)
925
{
926
	int colored = !!s->colored.len, first = 1;
927
	struct hunk *hunk = file_diff->hunk + hunk_index;
928
	size_t splittable_into;
929
	size_t end, colored_end, current, colored_current = 0, context_line_count;
930
	struct hunk_header remaining, *header;
931
	char marker, ch;
932

933
	if (hunk_index >= file_diff->hunk_nr)
934
		BUG("invalid hunk index: %d (must be >= 0 and < %d)",
935
		    (int)hunk_index, (int)file_diff->hunk_nr);
936

937
	if (hunk->splittable_into < 2)
938
		return 0;
939
	splittable_into = hunk->splittable_into;
940

941
	end = hunk->end;
942
	colored_end = hunk->colored_end;
943

944
	remaining = hunk->header;
945

946
	file_diff->hunk_nr += splittable_into - 1;
947
	ALLOC_GROW(file_diff->hunk, file_diff->hunk_nr, file_diff->hunk_alloc);
948
	if (hunk_index + splittable_into < file_diff->hunk_nr)
949
		memmove(file_diff->hunk + hunk_index + splittable_into,
950
			file_diff->hunk + hunk_index + 1,
951
			(file_diff->hunk_nr - hunk_index - splittable_into)
952
			* sizeof(*hunk));
953
	hunk = file_diff->hunk + hunk_index;
954
	hunk->splittable_into = 1;
955
	memset(hunk + 1, 0, (splittable_into - 1) * sizeof(*hunk));
956

957
	header = &hunk->header;
958
	header->old_count = header->new_count = 0;
959

960
	current = hunk->start;
961
	if (colored)
962
		colored_current = hunk->colored_start;
963
	marker = '\0';
964
	context_line_count = 0;
965

966
	while (splittable_into > 1) {
967
		ch = normalize_marker(&s->plain.buf[current]);
968

969
		if (!ch)
970
			BUG("buffer overrun while splitting hunks");
971

972
		/*
973
		 * Is this the first context line after a chain of +/- lines?
974
		 * Then record the start of the next split hunk.
975
		 */
976
		if ((marker == '-' || marker == '+') && ch == ' ') {
977
			first = 0;
978
			hunk[1].start = current;
979
			if (colored)
980
				hunk[1].colored_start = colored_current;
981
			context_line_count = 0;
982
		}
983

984
		/*
985
		 * Was the previous line a +/- one? Alternatively, is this the
986
		 * first line (and not a +/- one)?
987
		 *
988
		 * Then just increment the appropriate counter and continue
989
		 * with the next line.
990
		 */
991
		if (marker != ' ' || (ch != '-' && ch != '+')) {
992
next_hunk_line:
993
			/* Comment lines are attached to the previous line */
994
			if (ch == '\\')
995
				ch = marker ? marker : ' ';
996

997
			/* current hunk not done yet */
998
			if (ch == ' ')
999
				context_line_count++;
1000
			else if (ch == '-')
1001
				header->old_count++;
1002
			else if (ch == '+')
1003
				header->new_count++;
1004
			else
1005
				BUG("unhandled diff marker: '%c'", ch);
1006
			marker = ch;
1007
			current = find_next_line(&s->plain, current);
1008
			if (colored)
1009
				colored_current =
1010
					find_next_line(&s->colored,
1011
						       colored_current);
1012
			continue;
1013
		}
1014

1015
		/*
1016
		 * We got us the start of a new hunk!
1017
		 *
1018
		 * This is a context line, so it is shared with the previous
1019
		 * hunk, if any.
1020
		 */
1021

1022
		if (first) {
1023
			if (header->old_count || header->new_count)
1024
				BUG("counts are off: %d/%d",
1025
				    (int)header->old_count,
1026
				    (int)header->new_count);
1027

1028
			header->old_count = context_line_count;
1029
			header->new_count = context_line_count;
1030
			context_line_count = 0;
1031
			first = 0;
1032
			goto next_hunk_line;
1033
		}
1034

1035
		remaining.old_offset += header->old_count;
1036
		remaining.old_count -= header->old_count;
1037
		remaining.new_offset += header->new_count;
1038
		remaining.new_count -= header->new_count;
1039

1040
		/* initialize next hunk header's offsets */
1041
		hunk[1].header.old_offset =
1042
			header->old_offset + header->old_count;
1043
		hunk[1].header.new_offset =
1044
			header->new_offset + header->new_count;
1045

1046
		/* add one split hunk */
1047
		header->old_count += context_line_count;
1048
		header->new_count += context_line_count;
1049

1050
		hunk->end = current;
1051
		if (colored)
1052
			hunk->colored_end = colored_current;
1053

1054
		hunk++;
1055
		hunk->splittable_into = 1;
1056
		hunk->use = hunk[-1].use;
1057
		header = &hunk->header;
1058

1059
		header->old_count = header->new_count = context_line_count;
1060
		context_line_count = 0;
1061

1062
		splittable_into--;
1063
		marker = ch;
1064
	}
1065

1066
	/* last hunk simply gets the rest */
1067
	if (header->old_offset != remaining.old_offset)
1068
		BUG("miscounted old_offset: %lu != %lu",
1069
		    header->old_offset, remaining.old_offset);
1070
	if (header->new_offset != remaining.new_offset)
1071
		BUG("miscounted new_offset: %lu != %lu",
1072
		    header->new_offset, remaining.new_offset);
1073
	header->old_count = remaining.old_count;
1074
	header->new_count = remaining.new_count;
1075
	hunk->end = end;
1076
	if (colored)
1077
		hunk->colored_end = colored_end;
1078

1079
	return 0;
1080
}
1081

1082
static void recolor_hunk(struct add_p_state *s, struct hunk *hunk)
1083
{
1084
	const char *plain = s->plain.buf;
1085
	size_t current, eol, next;
1086

1087
	if (!s->colored.len)
1088
		return;
1089

1090
	hunk->colored_start = s->colored.len;
1091
	for (current = hunk->start; current < hunk->end; ) {
1092
		for (eol = current; eol < hunk->end; eol++)
1093
			if (plain[eol] == '\n')
1094
				break;
1095
		next = eol + (eol < hunk->end);
1096
		if (eol > current && plain[eol - 1] == '\r')
1097
			eol--;
1098

1099
		strbuf_addstr(&s->colored,
1100
			      plain[current] == '-' ?
1101
			      s->s.file_old_color :
1102
			      plain[current] == '+' ?
1103
			      s->s.file_new_color :
1104
			      s->s.context_color);
1105
		strbuf_add(&s->colored, plain + current, eol - current);
1106
		strbuf_addstr(&s->colored, s->s.reset_color);
1107
		if (next > eol)
1108
			strbuf_add(&s->colored, plain + eol, next - eol);
1109
		current = next;
1110
	}
1111
	hunk->colored_end = s->colored.len;
1112
}
1113

1114
static int edit_hunk_manually(struct add_p_state *s, struct hunk *hunk)
1115
{
1116
	size_t i;
1117

1118
	strbuf_reset(&s->buf);
1119
	strbuf_commented_addf(&s->buf, comment_line_str,
1120
			      _("Manual hunk edit mode -- see bottom for "
1121
				"a quick guide.\n"));
1122
	render_hunk(s, hunk, 0, 0, &s->buf);
1123
	strbuf_commented_addf(&s->buf, comment_line_str,
1124
			      _("---\n"
1125
				"To remove '%c' lines, make them ' ' lines "
1126
				"(context).\n"
1127
				"To remove '%c' lines, delete them.\n"
1128
				"Lines starting with %s will be removed.\n"),
1129
			      s->mode->is_reverse ? '+' : '-',
1130
			      s->mode->is_reverse ? '-' : '+',
1131
			      comment_line_str);
1132
	strbuf_commented_addf(&s->buf, comment_line_str, "%s",
1133
			      _(s->mode->edit_hunk_hint));
1134
	/*
1135
	 * TRANSLATORS: 'it' refers to the patch mentioned in the previous
1136
	 * messages.
1137
	 */
1138
	strbuf_commented_addf(&s->buf, comment_line_str,
1139
			      _("If it does not apply cleanly, you will be "
1140
				"given an opportunity to\n"
1141
				"edit again.  If all lines of the hunk are "
1142
				"removed, then the edit is\n"
1143
				"aborted and the hunk is left unchanged.\n"));
1144

1145
	if (strbuf_edit_interactively(the_repository, &s->buf,
1146
				      "addp-hunk-edit.diff", NULL) < 0)
1147
		return -1;
1148

1149
	/* strip out commented lines */
1150
	hunk->start = s->plain.len;
1151
	for (i = 0; i < s->buf.len; ) {
1152
		size_t next = find_next_line(&s->buf, i);
1153

1154
		if (!starts_with(s->buf.buf + i, comment_line_str))
1155
			strbuf_add(&s->plain, s->buf.buf + i, next - i);
1156
		i = next;
1157
	}
1158

1159
	hunk->end = s->plain.len;
1160
	if (hunk->end == hunk->start)
1161
		/* The user aborted editing by deleting everything */
1162
		return 0;
1163

1164
	recolor_hunk(s, hunk);
1165

1166
	/*
1167
	 * If the hunk header is intact, parse it, otherwise simply use the
1168
	 * hunk header prior to editing (which will adjust `hunk->start` to
1169
	 * skip the hunk header).
1170
	 */
1171
	if (s->plain.buf[hunk->start] == '@' &&
1172
	    parse_hunk_header(s, hunk) < 0)
1173
		return error(_("could not parse hunk header"));
1174

1175
	return 1;
1176
}
1177

1178
static ssize_t recount_edited_hunk(struct add_p_state *s, struct hunk *hunk,
1179
				   size_t orig_old_count, size_t orig_new_count)
1180
{
1181
	struct hunk_header *header = &hunk->header;
1182
	size_t i;
1183

1184
	header->old_count = header->new_count = 0;
1185
	for (i = hunk->start; i < hunk->end; ) {
1186
		switch(normalize_marker(&s->plain.buf[i])) {
1187
		case '-':
1188
			header->old_count++;
1189
			break;
1190
		case '+':
1191
			header->new_count++;
1192
			break;
1193
		case ' ':
1194
			header->old_count++;
1195
			header->new_count++;
1196
			break;
1197
		}
1198

1199
		i = find_next_line(&s->plain, i);
1200
	}
1201

1202
	return orig_old_count - orig_new_count
1203
		- header->old_count + header->new_count;
1204
}
1205

1206
static int run_apply_check(struct add_p_state *s,
1207
			   struct file_diff *file_diff)
1208
{
1209
	struct child_process cp = CHILD_PROCESS_INIT;
1210

1211
	strbuf_reset(&s->buf);
1212
	reassemble_patch(s, file_diff, 1, &s->buf);
1213

1214
	setup_child_process(s, &cp,
1215
			    "apply", "--check", NULL);
1216
	strvec_pushv(&cp.args, s->mode->apply_check_args);
1217
	if (pipe_command(&cp, s->buf.buf, s->buf.len, NULL, 0, NULL, 0))
1218
		return error(_("'git apply --cached' failed"));
1219

1220
	return 0;
1221
}
1222

1223
static int read_single_character(struct add_p_state *s)
1224
{
1225
	if (s->s.use_single_key) {
1226
		int res = read_key_without_echo(&s->answer);
1227
		printf("%s\n", res == EOF ? "" : s->answer.buf);
1228
		return res;
1229
	}
1230

1231
	if (git_read_line_interactively(&s->answer) == EOF)
1232
		return EOF;
1233
	return 0;
1234
}
1235

1236
static int prompt_yesno(struct add_p_state *s, const char *prompt)
1237
{
1238
	for (;;) {
1239
		color_fprintf(stdout, s->s.prompt_color, "%s", _(prompt));
1240
		fflush(stdout);
1241
		if (read_single_character(s) == EOF)
1242
			return -1;
1243
		/* do not limit to 1-byte input to allow 'no' etc. */
1244
		switch (tolower(s->answer.buf[0])) {
1245
		case 'n': return 0;
1246
		case 'y': return 1;
1247
		}
1248
	}
1249
}
1250

1251
static int edit_hunk_loop(struct add_p_state *s,
1252
			  struct file_diff *file_diff, struct hunk *hunk)
1253
{
1254
	size_t plain_len = s->plain.len, colored_len = s->colored.len;
1255
	struct hunk backup;
1256

1257
	backup = *hunk;
1258

1259
	for (;;) {
1260
		int res = edit_hunk_manually(s, hunk);
1261
		if (res == 0) {
1262
			/* abandoned */
1263
			*hunk = backup;
1264
			return -1;
1265
		}
1266

1267
		if (res > 0) {
1268
			hunk->delta +=
1269
				recount_edited_hunk(s, hunk,
1270
						    backup.header.old_count,
1271
						    backup.header.new_count);
1272
			if (!run_apply_check(s, file_diff))
1273
				return 0;
1274
		}
1275

1276
		/* Drop edits (they were appended to s->plain) */
1277
		strbuf_setlen(&s->plain, plain_len);
1278
		strbuf_setlen(&s->colored, colored_len);
1279
		*hunk = backup;
1280

1281
		/*
1282
		 * TRANSLATORS: do not translate [y/n]
1283
		 * The program will only accept that input at this point.
1284
		 * Consider translating (saying "no" discards!) as
1285
		 * (saying "n" for "no" discards!) if the translation
1286
		 * of the word "no" does not start with n.
1287
		 */
1288
		res = prompt_yesno(s, _("Your edited hunk does not apply. "
1289
					"Edit again (saying \"no\" discards!) "
1290
					"[y/n]? "));
1291
		if (res < 1)
1292
			return -1;
1293
	}
1294
}
1295

1296
static int apply_for_checkout(struct add_p_state *s, struct strbuf *diff,
1297
			      int is_reverse)
1298
{
1299
	const char *reverse = is_reverse ? "-R" : NULL;
1300
	struct child_process check_index = CHILD_PROCESS_INIT;
1301
	struct child_process check_worktree = CHILD_PROCESS_INIT;
1302
	struct child_process apply_index = CHILD_PROCESS_INIT;
1303
	struct child_process apply_worktree = CHILD_PROCESS_INIT;
1304
	int applies_index, applies_worktree;
1305

1306
	setup_child_process(s, &check_index,
1307
			    "apply", "--cached", "--check", reverse, NULL);
1308
	applies_index = !pipe_command(&check_index, diff->buf, diff->len,
1309
				      NULL, 0, NULL, 0);
1310

1311
	setup_child_process(s, &check_worktree,
1312
			    "apply", "--check", reverse, NULL);
1313
	applies_worktree = !pipe_command(&check_worktree, diff->buf, diff->len,
1314
					 NULL, 0, NULL, 0);
1315

1316
	if (applies_worktree && applies_index) {
1317
		setup_child_process(s, &apply_index,
1318
				    "apply", "--cached", reverse, NULL);
1319
		pipe_command(&apply_index, diff->buf, diff->len,
1320
			     NULL, 0, NULL, 0);
1321

1322
		setup_child_process(s, &apply_worktree,
1323
				    "apply", reverse, NULL);
1324
		pipe_command(&apply_worktree, diff->buf, diff->len,
1325
			     NULL, 0, NULL, 0);
1326

1327
		return 1;
1328
	}
1329

1330
	if (!applies_index) {
1331
		err(s, _("The selected hunks do not apply to the index!"));
1332
		if (prompt_yesno(s, _("Apply them to the worktree "
1333
					  "anyway? ")) > 0) {
1334
			setup_child_process(s, &apply_worktree,
1335
					    "apply", reverse, NULL);
1336
			return pipe_command(&apply_worktree, diff->buf,
1337
					    diff->len, NULL, 0, NULL, 0);
1338
		}
1339
		err(s, _("Nothing was applied.\n"));
1340
	} else
1341
		/* As a last resort, show the diff to the user */
1342
		fwrite(diff->buf, diff->len, 1, stdout);
1343

1344
	return 0;
1345
}
1346

1347
#define SUMMARY_HEADER_WIDTH 20
1348
#define SUMMARY_LINE_WIDTH 80
1349
static void summarize_hunk(struct add_p_state *s, struct hunk *hunk,
1350
			   struct strbuf *out)
1351
{
1352
	struct hunk_header *header = &hunk->header;
1353
	struct strbuf *plain = &s->plain;
1354
	size_t len = out->len, i;
1355

1356
	strbuf_addf(out, " -%lu,%lu +%lu,%lu ",
1357
		    header->old_offset, header->old_count,
1358
		    header->new_offset, header->new_count);
1359
	if (out->len - len < SUMMARY_HEADER_WIDTH)
1360
		strbuf_addchars(out, ' ',
1361
				SUMMARY_HEADER_WIDTH + len - out->len);
1362
	for (i = hunk->start; i < hunk->end; i = find_next_line(plain, i))
1363
		if (plain->buf[i] != ' ')
1364
			break;
1365
	if (i < hunk->end)
1366
		strbuf_add(out, plain->buf + i, find_next_line(plain, i) - i);
1367
	if (out->len - len > SUMMARY_LINE_WIDTH)
1368
		strbuf_setlen(out, len + SUMMARY_LINE_WIDTH);
1369
	strbuf_complete_line(out);
1370
}
1371

1372
#define DISPLAY_HUNKS_LINES 20
1373
static size_t display_hunks(struct add_p_state *s,
1374
			    struct file_diff *file_diff, size_t start_index)
1375
{
1376
	size_t end_index = start_index + DISPLAY_HUNKS_LINES;
1377

1378
	if (end_index > file_diff->hunk_nr)
1379
		end_index = file_diff->hunk_nr;
1380

1381
	while (start_index < end_index) {
1382
		struct hunk *hunk = file_diff->hunk + start_index++;
1383

1384
		strbuf_reset(&s->buf);
1385
		strbuf_addf(&s->buf, "%c%2d: ", hunk->use == USE_HUNK ? '+'
1386
			    : hunk->use == SKIP_HUNK ? '-' : ' ',
1387
			    (int)start_index);
1388
		summarize_hunk(s, hunk, &s->buf);
1389
		fputs(s->buf.buf, stdout);
1390
	}
1391

1392
	return end_index;
1393
}
1394

1395
static const char help_patch_remainder[] =
1396
N_("j - leave this hunk undecided, see next undecided hunk\n"
1397
   "J - leave this hunk undecided, see next hunk\n"
1398
   "k - leave this hunk undecided, see previous undecided hunk\n"
1399
   "K - leave this hunk undecided, see previous hunk\n"
1400
   "g - select a hunk to go to\n"
1401
   "/ - search for a hunk matching the given regex\n"
1402
   "s - split the current hunk into smaller hunks\n"
1403
   "e - manually edit the current hunk\n"
1404
   "p - print the current hunk, 'P' to use the pager\n"
1405
   "? - print help\n");
1406

1407
static int patch_update_file(struct add_p_state *s,
1408
			     struct file_diff *file_diff)
1409
{
1410
	size_t hunk_index = 0;
1411
	ssize_t i, undecided_previous, undecided_next, rendered_hunk_index = -1;
1412
	struct hunk *hunk;
1413
	char ch;
1414
	struct child_process cp = CHILD_PROCESS_INIT;
1415
	int colored = !!s->colored.len, quit = 0, use_pager = 0;
1416
	enum prompt_mode_type prompt_mode_type;
1417
	enum {
1418
		ALLOW_GOTO_PREVIOUS_HUNK = 1 << 0,
1419
		ALLOW_GOTO_PREVIOUS_UNDECIDED_HUNK = 1 << 1,
1420
		ALLOW_GOTO_NEXT_HUNK = 1 << 2,
1421
		ALLOW_GOTO_NEXT_UNDECIDED_HUNK = 1 << 3,
1422
		ALLOW_SEARCH_AND_GOTO = 1 << 4,
1423
		ALLOW_SPLIT = 1 << 5,
1424
		ALLOW_EDIT = 1 << 6
1425
	} permitted = 0;
1426

1427
	/* Empty added files have no hunks */
1428
	if (!file_diff->hunk_nr && !file_diff->added)
1429
		return 0;
1430

1431
	strbuf_reset(&s->buf);
1432
	render_diff_header(s, file_diff, colored, &s->buf);
1433
	fputs(s->buf.buf, stdout);
1434
	for (;;) {
1435
		if (hunk_index >= file_diff->hunk_nr)
1436
			hunk_index = 0;
1437
		hunk = file_diff->hunk_nr
1438
				? file_diff->hunk + hunk_index
1439
				: &file_diff->head;
1440
		undecided_previous = -1;
1441
		undecided_next = -1;
1442

1443
		if (file_diff->hunk_nr) {
1444
			for (i = hunk_index - 1; i >= 0; i--)
1445
				if (file_diff->hunk[i].use == UNDECIDED_HUNK) {
1446
					undecided_previous = i;
1447
					break;
1448
				}
1449

1450
			for (i = hunk_index + 1; i < file_diff->hunk_nr; i++)
1451
				if (file_diff->hunk[i].use == UNDECIDED_HUNK) {
1452
					undecided_next = i;
1453
					break;
1454
				}
1455
		}
1456

1457
		/* Everything decided? */
1458
		if (undecided_previous < 0 && undecided_next < 0 &&
1459
		    hunk->use != UNDECIDED_HUNK)
1460
			break;
1461

1462
		strbuf_reset(&s->buf);
1463
		if (file_diff->hunk_nr) {
1464
			if (rendered_hunk_index != hunk_index) {
1465
				if (use_pager) {
1466
					setup_pager();
1467
					sigchain_push(SIGPIPE, SIG_IGN);
1468
				}
1469
				render_hunk(s, hunk, 0, colored, &s->buf);
1470
				fputs(s->buf.buf, stdout);
1471
				rendered_hunk_index = hunk_index;
1472
				if (use_pager) {
1473
					sigchain_pop(SIGPIPE);
1474
					wait_for_pager();
1475
					use_pager = 0;
1476
				}
1477
			}
1478

1479
			strbuf_reset(&s->buf);
1480
			if (undecided_previous >= 0) {
1481
				permitted |= ALLOW_GOTO_PREVIOUS_UNDECIDED_HUNK;
1482
				strbuf_addstr(&s->buf, ",k");
1483
			}
1484
			if (hunk_index) {
1485
				permitted |= ALLOW_GOTO_PREVIOUS_HUNK;
1486
				strbuf_addstr(&s->buf, ",K");
1487
			}
1488
			if (undecided_next >= 0) {
1489
				permitted |= ALLOW_GOTO_NEXT_UNDECIDED_HUNK;
1490
				strbuf_addstr(&s->buf, ",j");
1491
			}
1492
			if (hunk_index + 1 < file_diff->hunk_nr) {
1493
				permitted |= ALLOW_GOTO_NEXT_HUNK;
1494
				strbuf_addstr(&s->buf, ",J");
1495
			}
1496
			if (file_diff->hunk_nr > 1) {
1497
				permitted |= ALLOW_SEARCH_AND_GOTO;
1498
				strbuf_addstr(&s->buf, ",g,/");
1499
			}
1500
			if (hunk->splittable_into > 1) {
1501
				permitted |= ALLOW_SPLIT;
1502
				strbuf_addstr(&s->buf, ",s");
1503
			}
1504
			if (hunk_index + 1 > file_diff->mode_change &&
1505
			    !file_diff->deleted) {
1506
				permitted |= ALLOW_EDIT;
1507
				strbuf_addstr(&s->buf, ",e");
1508
			}
1509
			strbuf_addstr(&s->buf, ",p");
1510
		}
1511
		if (file_diff->deleted)
1512
			prompt_mode_type = PROMPT_DELETION;
1513
		else if (file_diff->added)
1514
			prompt_mode_type = PROMPT_ADDITION;
1515
		else if (file_diff->mode_change && !hunk_index)
1516
			prompt_mode_type = PROMPT_MODE_CHANGE;
1517
		else
1518
			prompt_mode_type = PROMPT_HUNK;
1519

1520
		printf("%s(%"PRIuMAX"/%"PRIuMAX") ", s->s.prompt_color,
1521
			      (uintmax_t)hunk_index + 1,
1522
			      (uintmax_t)(file_diff->hunk_nr
1523
						? file_diff->hunk_nr
1524
						: 1));
1525
		printf(_(s->mode->prompt_mode[prompt_mode_type]),
1526
		       s->buf.buf);
1527
		if (*s->s.reset_color)
1528
			fputs(s->s.reset_color, stdout);
1529
		fflush(stdout);
1530
		if (read_single_character(s) == EOF)
1531
			break;
1532

1533
		if (!s->answer.len)
1534
			continue;
1535
		ch = tolower(s->answer.buf[0]);
1536

1537
		/* 'g' takes a hunk number and '/' takes a regexp */
1538
		if (s->answer.len != 1 && (ch != 'g' && ch != '/')) {
1539
			err(s, _("Only one letter is expected, got '%s'"), s->answer.buf);
1540
			continue;
1541
		}
1542
		if (ch == 'y') {
1543
			hunk->use = USE_HUNK;
1544
soft_increment:
1545
			hunk_index = undecided_next < 0 ?
1546
				file_diff->hunk_nr : undecided_next;
1547
		} else if (ch == 'n') {
1548
			hunk->use = SKIP_HUNK;
1549
			goto soft_increment;
1550
		} else if (ch == 'a') {
1551
			if (file_diff->hunk_nr) {
1552
				for (; hunk_index < file_diff->hunk_nr; hunk_index++) {
1553
					hunk = file_diff->hunk + hunk_index;
1554
					if (hunk->use == UNDECIDED_HUNK)
1555
						hunk->use = USE_HUNK;
1556
				}
1557
			} else if (hunk->use == UNDECIDED_HUNK) {
1558
				hunk->use = USE_HUNK;
1559
			}
1560
		} else if (ch == 'd' || ch == 'q') {
1561
			if (file_diff->hunk_nr) {
1562
				for (; hunk_index < file_diff->hunk_nr; hunk_index++) {
1563
					hunk = file_diff->hunk + hunk_index;
1564
					if (hunk->use == UNDECIDED_HUNK)
1565
						hunk->use = SKIP_HUNK;
1566
				}
1567
			} else if (hunk->use == UNDECIDED_HUNK) {
1568
				hunk->use = SKIP_HUNK;
1569
			}
1570
			if (ch == 'q') {
1571
				quit = 1;
1572
				break;
1573
			}
1574
		} else if (s->answer.buf[0] == 'K') {
1575
			if (permitted & ALLOW_GOTO_PREVIOUS_HUNK)
1576
				hunk_index--;
1577
			else
1578
				err(s, _("No previous hunk"));
1579
		} else if (s->answer.buf[0] == 'J') {
1580
			if (permitted & ALLOW_GOTO_NEXT_HUNK)
1581
				hunk_index++;
1582
			else
1583
				err(s, _("No next hunk"));
1584
		} else if (s->answer.buf[0] == 'k') {
1585
			if (permitted & ALLOW_GOTO_PREVIOUS_UNDECIDED_HUNK)
1586
				hunk_index = undecided_previous;
1587
			else
1588
				err(s, _("No previous hunk"));
1589
		} else if (s->answer.buf[0] == 'j') {
1590
			if (permitted & ALLOW_GOTO_NEXT_UNDECIDED_HUNK)
1591
				hunk_index = undecided_next;
1592
			else
1593
				err(s, _("No next hunk"));
1594
		} else if (s->answer.buf[0] == 'g') {
1595
			char *pend;
1596
			unsigned long response;
1597

1598
			if (!(permitted & ALLOW_SEARCH_AND_GOTO)) {
1599
				err(s, _("No other hunks to goto"));
1600
				continue;
1601
			}
1602
			strbuf_remove(&s->answer, 0, 1);
1603
			strbuf_trim(&s->answer);
1604
			i = hunk_index - DISPLAY_HUNKS_LINES / 2;
1605
			if (i < (int)file_diff->mode_change)
1606
				i = file_diff->mode_change;
1607
			while (s->answer.len == 0) {
1608
				i = display_hunks(s, file_diff, i);
1609
				printf("%s", i < file_diff->hunk_nr ?
1610
				       _("go to which hunk (<ret> to see "
1611
					 "more)? ") : _("go to which hunk? "));
1612
				fflush(stdout);
1613
				if (strbuf_getline(&s->answer,
1614
						   stdin) == EOF)
1615
					break;
1616
				strbuf_trim_trailing_newline(&s->answer);
1617
			}
1618

1619
			strbuf_trim(&s->answer);
1620
			response = strtoul(s->answer.buf, &pend, 10);
1621
			if (*pend || pend == s->answer.buf)
1622
				err(s, _("Invalid number: '%s'"),
1623
				    s->answer.buf);
1624
			else if (0 < response && response <= file_diff->hunk_nr)
1625
				hunk_index = response - 1;
1626
			else
1627
				err(s, Q_("Sorry, only %d hunk available.",
1628
					  "Sorry, only %d hunks available.",
1629
					  file_diff->hunk_nr),
1630
				    (int)file_diff->hunk_nr);
1631
		} else if (s->answer.buf[0] == '/') {
1632
			regex_t regex;
1633
			int ret;
1634

1635
			if (!(permitted & ALLOW_SEARCH_AND_GOTO)) {
1636
				err(s, _("No other hunks to search"));
1637
				continue;
1638
			}
1639
			strbuf_remove(&s->answer, 0, 1);
1640
			strbuf_trim_trailing_newline(&s->answer);
1641
			if (s->answer.len == 0) {
1642
				printf("%s", _("search for regex? "));
1643
				fflush(stdout);
1644
				if (strbuf_getline(&s->answer,
1645
						   stdin) == EOF)
1646
					break;
1647
				strbuf_trim_trailing_newline(&s->answer);
1648
				if (s->answer.len == 0)
1649
					continue;
1650
			}
1651
			ret = regcomp(&regex, s->answer.buf,
1652
				      REG_EXTENDED | REG_NOSUB | REG_NEWLINE);
1653
			if (ret) {
1654
				char errbuf[1024];
1655

1656
				regerror(ret, &regex, errbuf, sizeof(errbuf));
1657
				err(s, _("Malformed search regexp %s: %s"),
1658
				    s->answer.buf, errbuf);
1659
				continue;
1660
			}
1661
			i = hunk_index;
1662
			for (;;) {
1663
				/* render the hunk into a scratch buffer */
1664
				render_hunk(s, file_diff->hunk + i, 0, 0,
1665
					    &s->buf);
1666
				if (regexec(&regex, s->buf.buf, 0, NULL, 0)
1667
				    != REG_NOMATCH)
1668
					break;
1669
				i++;
1670
				if (i == file_diff->hunk_nr)
1671
					i = 0;
1672
				if (i != hunk_index)
1673
					continue;
1674
				err(s, _("No hunk matches the given pattern"));
1675
				break;
1676
			}
1677
			regfree(&regex);
1678
			hunk_index = i;
1679
		} else if (s->answer.buf[0] == 's') {
1680
			size_t splittable_into = hunk->splittable_into;
1681
			if (!(permitted & ALLOW_SPLIT)) {
1682
				err(s, _("Sorry, cannot split this hunk"));
1683
			} else if (!split_hunk(s, file_diff,
1684
					     hunk - file_diff->hunk)) {
1685
				color_fprintf_ln(stdout, s->s.header_color,
1686
						 _("Split into %d hunks."),
1687
						 (int)splittable_into);
1688
				rendered_hunk_index = -1;
1689
			}
1690
		} else if (s->answer.buf[0] == 'e') {
1691
			if (!(permitted & ALLOW_EDIT))
1692
				err(s, _("Sorry, cannot edit this hunk"));
1693
			else if (edit_hunk_loop(s, file_diff, hunk) >= 0) {
1694
				hunk->use = USE_HUNK;
1695
				goto soft_increment;
1696
			}
1697
		} else if (ch == 'p') {
1698
			rendered_hunk_index = -1;
1699
			use_pager = (s->answer.buf[0] == 'P') ? 1 : 0;
1700
		} else if (s->answer.buf[0] == '?') {
1701
			const char *p = _(help_patch_remainder), *eol = p;
1702

1703
			color_fprintf(stdout, s->s.help_color, "%s",
1704
				      _(s->mode->help_patch_text));
1705

1706
			/*
1707
			 * Show only those lines of the remainder that are
1708
			 * actually applicable with the current hunk.
1709
			 */
1710
			for (; *p; p = eol + (*eol == '\n')) {
1711
				eol = strchrnul(p, '\n');
1712

1713
				/*
1714
				 * `s->buf` still contains the part of the
1715
				 * commands shown in the prompt that are not
1716
				 * always available.
1717
				 */
1718
				if (*p != '?' && !strchr(s->buf.buf, *p))
1719
					continue;
1720

1721
				color_fprintf_ln(stdout, s->s.help_color,
1722
						 "%.*s", (int)(eol - p), p);
1723
			}
1724
		} else {
1725
			err(s, _("Unknown command '%s' (use '?' for help)"),
1726
			    s->answer.buf);
1727
		}
1728
	}
1729

1730
	/* Any hunk to be used? */
1731
	for (i = 0; i < file_diff->hunk_nr; i++)
1732
		if (file_diff->hunk[i].use == USE_HUNK)
1733
			break;
1734

1735
	if (i < file_diff->hunk_nr ||
1736
	    (!file_diff->hunk_nr && file_diff->head.use == USE_HUNK)) {
1737
		/* At least one hunk selected: apply */
1738
		strbuf_reset(&s->buf);
1739
		reassemble_patch(s, file_diff, 0, &s->buf);
1740

1741
		discard_index(s->s.r->index);
1742
		if (s->mode->apply_for_checkout)
1743
			apply_for_checkout(s, &s->buf,
1744
					   s->mode->is_reverse);
1745
		else {
1746
			setup_child_process(s, &cp, "apply", NULL);
1747
			strvec_pushv(&cp.args, s->mode->apply_args);
1748
			if (pipe_command(&cp, s->buf.buf, s->buf.len,
1749
					 NULL, 0, NULL, 0))
1750
				error(_("'git apply' failed"));
1751
		}
1752
		if (repo_read_index(s->s.r) >= 0)
1753
			repo_refresh_and_write_index(s->s.r, REFRESH_QUIET, 0,
1754
						     1, NULL, NULL, NULL);
1755
	}
1756

1757
	putchar('\n');
1758
	return quit;
1759
}
1760

1761
int run_add_p(struct repository *r, enum add_p_mode mode,
1762
	      const char *revision, const struct pathspec *ps)
1763
{
1764
	struct add_p_state s = {
1765
		{ r }, STRBUF_INIT, STRBUF_INIT, STRBUF_INIT, STRBUF_INIT
1766
	};
1767
	size_t i, binary_count = 0;
1768

1769
	init_add_i_state(&s.s, r);
1770

1771
	if (mode == ADD_P_STASH)
1772
		s.mode = &patch_mode_stash;
1773
	else if (mode == ADD_P_RESET) {
1774
		if (!revision || !strcmp(revision, "HEAD"))
1775
			s.mode = &patch_mode_reset_head;
1776
		else
1777
			s.mode = &patch_mode_reset_nothead;
1778
	} else if (mode == ADD_P_CHECKOUT) {
1779
		if (!revision)
1780
			s.mode = &patch_mode_checkout_index;
1781
		else if (!strcmp(revision, "HEAD"))
1782
			s.mode = &patch_mode_checkout_head;
1783
		else
1784
			s.mode = &patch_mode_checkout_nothead;
1785
	} else if (mode == ADD_P_WORKTREE) {
1786
		if (!revision)
1787
			s.mode = &patch_mode_checkout_index;
1788
		else if (!strcmp(revision, "HEAD"))
1789
			s.mode = &patch_mode_worktree_head;
1790
		else
1791
			s.mode = &patch_mode_worktree_nothead;
1792
	} else
1793
		s.mode = &patch_mode_add;
1794
	s.revision = revision;
1795

1796
	discard_index(r->index);
1797
	if (repo_read_index(r) < 0 ||
1798
	    (!s.mode->index_only &&
1799
	     repo_refresh_and_write_index(r, REFRESH_QUIET, 0, 1,
1800
					  NULL, NULL, NULL) < 0) ||
1801
	    parse_diff(&s, ps) < 0) {
1802
		add_p_state_clear(&s);
1803
		return -1;
1804
	}
1805

1806
	for (i = 0; i < s.file_diff_nr; i++)
1807
		if (s.file_diff[i].binary && !s.file_diff[i].hunk_nr)
1808
			binary_count++;
1809
		else if (patch_update_file(&s, s.file_diff + i))
1810
			break;
1811

1812
	if (s.file_diff_nr == 0)
1813
		err(&s, _("No changes."));
1814
	else if (binary_count == s.file_diff_nr)
1815
		err(&s, _("Only binary files changed."));
1816

1817
	add_p_state_clear(&s);
1818
	return 0;
1819
}
1820