Git Test Coverage Report (Dec. 18)

Git Test Coverage Report (Dec. 18)

[Derrick Stolee]

Here is today's test-coverage report.

Thanks,
-Stolee

[1] https://derrickstolee.github.io/git-test-coverage/reports/2019-12-18-commits.txt
[2] https://derrickstolee.github.io/git-test-coverage/reports/2019-12-18.txt
[2] https://derrickstolee.github.io/git-test-coverage/reports/2019-12-18.htm

---

pu	bca46e3060e7375827de0056eab64cad9e556b76
jch	0c7f8a73bddc98b1aeac27d2e8bf3e3109eab9b4
next	64cd5c46229f533beb7b49a8dfd1c5104da25b00
master	b02fd2accad4d48078671adf38fe5b5976d77304
master@{1}	083378cc35c4dbcc607e4cdd24a5fca440163d17


Uncovered code in 'pu' not in 'jch'
--------------------------------------------------------

Commits introducing uncovered code:
Johannes Schindelin	25ea47af built-in add -p: adjust hunk headers as needed
add-interactive.c
25ea47af 29) void init_add_i_state(struct add_i_state *s, struct repository *r)
25ea47af 47) init_color(r, s, "fraginfo", s->fraginfo_color,

add-patch.c
25ea47af 282)  INDEX_ENVIRONMENT "=%s", s->s.r->index_file);
25ea47af 283) }
25ea47af 285) static int parse_range(const char **p,
25ea47af 290) *offset = strtoul(*p, &pend, 10);
25ea47af 291) if (pend == *p)
25ea47af 292) return -1;
25ea47af 293) if (*pend != ',') {
25ea47af 294) *count = 1;
25ea47af 295) *p = pend;
25ea47af 296) return 0;
25ea47af 298) *count = strtoul(pend + 1, (char **)p, 10);
25ea47af 299) return *p == pend + 1 ? -1 : 0;
25ea47af 302) static int parse_hunk_header(struct add_p_state *s, struct hunk *hunk)
25ea47af 304) struct hunk_header *header = &hunk->header;
25ea47af 305) const char *line = s->plain.buf + hunk->start, *p = line;
25ea47af 306) char *eol = memchr(p, '\n', s->plain.len - hunk->start);
25ea47af 308) if (!eol)
25ea47af 309) eol = s->plain.buf + s->plain.len;
25ea47af 311) if (!skip_prefix(p, "@@ -", &p) ||
25ea47af 312)     parse_range(&p, &header->old_offset, &header->old_count) < 0 ||
25ea47af 313)     !skip_prefix(p, " +", &p) ||
25ea47af 314)     parse_range(&p, &header->new_offset, &header->new_count) < 0 ||
25ea47af 315)     !skip_prefix(p, " @@", &p))
25ea47af 319) hunk->start = eol - s->plain.buf + (*eol == '\n');
25ea47af 320) header->extra_start = p - s->plain.buf;
25ea47af 321) header->extra_end = hunk->start;
25ea47af 323) if (!s->colored.len) {
25ea47af 324) header->colored_extra_start = header->colored_extra_end = 0;
25ea47af 325) return 0;
25ea47af 329) line = s->colored.buf + hunk->colored_start;
25ea47af 330) eol = memchr(line, '\n', s->colored.len - hunk->colored_start);
25ea47af 331) if (!eol)
25ea47af 332) eol = s->colored.buf + s->colored.len;
25ea47af 333) p = memmem(line, eol - line, "@@ -", 4);
25ea47af 334) if (!p)
25ea47af 337) p = memmem(p + 4, eol - p - 4, " @@", 3);
25ea47af 338) if (!p)
25ea47af 341) hunk->colored_start = eol - s->colored.buf + (*eol == '\n');
25ea47af 342) header->colored_extra_start = p + 3 - s->colored.buf;
25ea47af 343) header->colored_extra_end = hunk->colored_start;
25ea47af 345) return 0;
25ea47af 464) return -1;
25ea47af 577) struct hunk_header *header = &hunk->header;
25ea47af 579) if (hunk->header.old_offset != 0 || hunk->header.new_offset != 0) {
25ea47af 586) unsigned long old_offset = header->old_offset;
25ea47af 587) unsigned long new_offset = header->new_offset;
25ea47af 589) if (!colored) {
25ea47af 590) p = s->plain.buf + header->extra_start;
25ea47af 591) len = header->extra_end - header->extra_start;
25ea47af 593) strbuf_addstr(out, s->s.fraginfo_color);
25ea47af 594) p = s->colored.buf + header->colored_extra_start;
25ea47af 595) len = header->colored_extra_end
25ea47af 596) - header->colored_extra_start;
25ea47af 604) strbuf_addf(out, "@@ -%lu,%lu +%lu,%lu @@",
25ea47af 607) if (len)
25ea47af 608) strbuf_add(out, p, len);
25ea47af 609) else if (colored)
25ea47af 610) strbuf_addf(out, "%s\n", GIT_COLOR_RESET);
25ea47af 612) strbuf_addch(out, '\n');
25ea47af 790) ssize_t delta = 0;
25ea47af 799) delta += hunk->header.old_count
25ea47af 800) - hunk->header.new_count;
25ea47af 806) render_hunk(s, hunk, delta, 0, out);
25ea47af 1329) render_hunk(s, hunk, 0, colored, &s->buf);
25ea47af 1552) discard_index(s->s.r->index);
25ea47af 1563) if (!repo_read_index(s->s.r))
25ea47af 1564) repo_refresh_and_write_index(s->s.r, REFRESH_QUIET, 0,
25ea47af 1575) struct add_p_state s = {
25ea47af 1580) init_add_i_state(&s.s, r);

Johannes Schindelin	c1f1a9b0 built-in stash: use the built-in `git add -p` if so configured
builtin/stash.c
c1f1a9b0 1026) setenv(INDEX_ENVIRONMENT, old_index_env, 1);

Johannes Schindelin	09032028 legacy stash -p: respect the add.interactive.usebuiltin setting
builtin/add.c
09032028 450) parse_pathspec(&pathspec, 0,
09032028 456) return run_add_interactive(NULL, "--patch=stash", &pathspec);

Johannes Schindelin	1c6d07b9 built-in add -p: implement the "worktree" patch modes
add-patch.c
1c6d07b9 1596) } else if (mode == ADD_P_WORKTREE) {
1c6d07b9 1597) if (!revision)
1c6d07b9 1598) s.mode = &patch_mode_checkout_index;
1c6d07b9 1599) else if (!strcmp(revision, "HEAD"))
1c6d07b9 1600) s.mode = &patch_mode_worktree_head;
1c6d07b9 1602) s.mode = &patch_mode_worktree_nothead;

builtin/add.c
1c6d07b9 213) else if (!strcmp(patch_mode, "--patch=worktree"))
1c6d07b9 214) mode = ADD_P_WORKTREE;

Johannes Schindelin	169205be built-in add -p: implement the "stash" and "reset" patch modes
add-patch.c
169205be 1582) if (mode == ADD_P_STASH)
169205be 1583) s.mode = &patch_mode_stash;
169205be 1584) else if (mode == ADD_P_RESET) {
169205be 1585) if (!revision || !strcmp(revision, "HEAD"))
169205be 1586) s.mode = &patch_mode_reset_head;
169205be 1588) s.mode = &patch_mode_reset_nothead;
169205be 1604) s.mode = &patch_mode_stage;
169205be 1608)     (!s.mode->index_only &&
169205be 1609)      repo_refresh_and_write_index(r, REFRESH_QUIET, 0, 1,
169205be 1610)   NULL, NULL, NULL) < 0) ||

builtin/add.c
169205be 207) else if (!strcmp(patch_mode, "--patch=stash"))
169205be 208) mode = ADD_P_STASH;
169205be 209) else if (!strcmp(patch_mode, "--patch=reset"))
169205be 210) mode = ADD_P_RESET;

Johannes Schindelin	54d9d9b2 built-in add -p: only show the applicable parts of the help text
add-patch.c
54d9d9b2 1516) const char *p = _(help_patch_remainder), *eol = p;
54d9d9b2 1518) color_fprintf(stdout, s->s.help_color, "%s",
54d9d9b2 1525) for (; *p; p = eol + (*eol == '\n')) {
54d9d9b2 1526) eol = strchrnul(p, '\n');
54d9d9b2 1533) if (*p != '?' && !strchr(s->buf.buf, *p))
54d9d9b2 1534) continue;
54d9d9b2 1536) color_fprintf_ln(stdout, s->s.help_color,
54d9d9b2 1537)  "%.*s", (int)(eol - p), p);

Johannes Schindelin	12c24cf8 built-in add -p: color the prompt and the help text
add-patch.c
12c24cf8 1356) color_fprintf(stdout, s->s.prompt_color,
12c24cf8 1360) color_fprintf(stdout, s->s.prompt_color,

Johannes Schindelin	0ecd9d27 built-in add -p: show different prompts for mode changes and deletions
add-patch.c
0ecd9d27 1349) if (file_diff->deleted)
0ecd9d27 1350) prompt_mode_type = PROMPT_DELETION;
0ecd9d27 1351) else if (file_diff->mode_change && !hunk_index)
0ecd9d27 1352) prompt_mode_type = PROMPT_MODE_CHANGE;
0ecd9d27 1354) prompt_mode_type = PROMPT_HUNK;

Johannes Schindelin	d6cf8733 built-in add -p: implement the '/' ("search regex") command
add-patch.c
d6cf8733 1342) strbuf_addstr(&s->buf, ",g,/");
d6cf8733 1452) } else if (s->answer.buf[0] == '/') {
d6cf8733 1456) if (file_diff->hunk_nr < 2) {
d6cf8733 1457) err(s, _("No other hunks to search"));
d6cf8733 1458) continue;
d6cf8733 1460) strbuf_remove(&s->answer, 0, 1);
d6cf8733 1461) strbuf_trim_trailing_newline(&s->answer);
d6cf8733 1462) if (s->answer.len == 0) {
d6cf8733 1463) printf("%s", _("search for regex? "));
d6cf8733 1464) fflush(stdout);
d6cf8733 1465) if (strbuf_getline(&s->answer,
d6cf8733 1467) break;
d6cf8733 1468) strbuf_trim_trailing_newline(&s->answer);
d6cf8733 1469) if (s->answer.len == 0)
d6cf8733 1470) continue;
d6cf8733 1472) ret = regcomp(&regex, s->answer.buf,
d6cf8733 1474) if (ret) {
d6cf8733 1478) err(s, _("Malformed search regexp %s: %s"),
d6cf8733 1480) continue;
d6cf8733 1482) i = hunk_index;
d6cf8733 1485) render_hunk(s, file_diff->hunk + i, 0, 0,
d6cf8733 1487) if (regexec(&regex, s->buf.buf, 0, NULL, 0)
d6cf8733 1489) break;
d6cf8733 1490) i++;
d6cf8733 1491) if (i == file_diff->hunk_nr)
d6cf8733 1492) i = 0;
d6cf8733 1493) if (i != hunk_index)
d6cf8733 1494) continue;
d6cf8733 1495) err(s, _("No hunk matches the given pattern"));
d6cf8733 1496) break;
d6cf8733 1497) }
d6cf8733 1498) hunk_index = i;

Johannes Schindelin	b38dd9e7 strbuf: add a helper function to call the editor "on an strbuf"
strbuf.c
b38dd9e7 1129) int strbuf_edit_interactively(struct strbuf *buffer, const char *path,
b38dd9e7 1132) char *path2 = NULL;
b38dd9e7 1133) int fd, res = 0;
b38dd9e7 1135) if (!is_absolute_path(path))
b38dd9e7 1136) path = path2 = xstrdup(git_path("%s", path));
b38dd9e7 1138) fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0666);
b38dd9e7 1139) if (fd < 0)
b38dd9e7 1140) res = error_errno(_("could not open '%s' for writing"), path);
b38dd9e7 1141) else if (write_in_full(fd, buffer->buf, buffer->len) < 0) {
b38dd9e7 1142) res = error_errno(_("could not write to '%s'"), path);
b38dd9e7 1143) close(fd);
b38dd9e7 1144) } else if (close(fd) < 0)
b38dd9e7 1145) res = error_errno(_("could not close '%s'"), path);
b38dd9e7 1147) strbuf_reset(buffer);
b38dd9e7 1148) if (launch_editor(path, buffer, env) < 0)
b38dd9e7 1149) res = error_errno(_("could not edit '%s'"), path);
b38dd9e7 1150) unlink(path);
b38dd9e7 1153) free(path2);
b38dd9e7 1154) return res;

Johannes Schindelin	9254bdfb built-in add -p: implement the 'g' ("goto") command
add-patch.c
9254bdfb 1230) static void summarize_hunk(struct add_p_state *s, struct hunk *hunk,
9254bdfb 1233) struct hunk_header *header = &hunk->header;
9254bdfb 1234) struct strbuf *plain = &s->plain;
9254bdfb 1235) size_t len = out->len, i;
9254bdfb 1237) strbuf_addf(out, " -%lu,%lu +%lu,%lu ",
9254bdfb 1240) if (out->len - len < SUMMARY_HEADER_WIDTH)
9254bdfb 1241) strbuf_addchars(out, ' ',
9254bdfb 1242) SUMMARY_HEADER_WIDTH + len - out->len);
9254bdfb 1243) for (i = hunk->start; i < hunk->end; i = find_next_line(plain, i))
9254bdfb 1244) if (plain->buf[i] != ' ')
9254bdfb 1245) break;
9254bdfb 1246) if (i < hunk->end)
9254bdfb 1247) strbuf_add(out, plain->buf + i, find_next_line(plain, i) - i);
9254bdfb 1248) if (out->len - len > SUMMARY_LINE_WIDTH)
9254bdfb 1249) strbuf_setlen(out, len + SUMMARY_LINE_WIDTH);
9254bdfb 1250) strbuf_complete_line(out);
9254bdfb 1251) }
9254bdfb 1254) static size_t display_hunks(struct add_p_state *s,
9254bdfb 1257) size_t end_index = start_index + DISPLAY_HUNKS_LINES;
9254bdfb 1259) if (end_index > file_diff->hunk_nr)
9254bdfb 1260) end_index = file_diff->hunk_nr;
9254bdfb 1262) while (start_index < end_index) {
9254bdfb 1263) struct hunk *hunk = file_diff->hunk + start_index++;
9254bdfb 1265) strbuf_reset(&s->buf);
9254bdfb 1266) strbuf_addf(&s->buf, "%c%2d: ", hunk->use == USE_HUNK ? '+'
9254bdfb 1267)     : hunk->use == SKIP_HUNK ? '-' : ' ',
9254bdfb 1269) summarize_hunk(s, hunk, &s->buf);
9254bdfb 1270) fputs(s->buf.buf, stdout);
9254bdfb 1273) return end_index;
9254bdfb 1341) if (file_diff->hunk_nr > 1)
9254bdfb 1415) } else if (s->answer.buf[0] == 'g') {
9254bdfb 1419) if (file_diff->hunk_nr < 2) {
9254bdfb 1420) err(s, _("No other hunks to goto"));
9254bdfb 1421) continue;
9254bdfb 1423) strbuf_remove(&s->answer, 0, 1);
9254bdfb 1424) strbuf_trim(&s->answer);
9254bdfb 1425) i = hunk_index - DISPLAY_HUNKS_LINES / 2;
9254bdfb 1426) if (i < file_diff->mode_change)
9254bdfb 1427) i = file_diff->mode_change;
9254bdfb 1428) while (s->answer.len == 0) {
9254bdfb 1429) i = display_hunks(s, file_diff, i);
9254bdfb 1430) printf("%s", i < file_diff->hunk_nr ?
9254bdfb 1433) fflush(stdout);
9254bdfb 1434) if (strbuf_getline(&s->answer,
9254bdfb 1436) break;
9254bdfb 1437) strbuf_trim_trailing_newline(&s->answer);
9254bdfb 1440) strbuf_trim(&s->answer);
9254bdfb 1441) response = strtoul(s->answer.buf, &pend, 10);
9254bdfb 1442) if (*pend || pend == s->answer.buf)
9254bdfb 1443) err(s, _("Invalid number: '%s'"),
9254bdfb 1445) else if (0 < response && response <= file_diff->hunk_nr)
9254bdfb 1446) hunk_index = response - 1;
9254bdfb 1448) err(s, Q_("Sorry, only %d hunk available.",
9254bdfb 1451)     (int)file_diff->hunk_nr);

Johannes Schindelin	ae4780e8 built-in add -p: implement the "checkout" patch modes
add-patch.c
ae4780e8 1177) static int apply_for_checkout(struct add_p_state *s, struct strbuf *diff,
ae4780e8 1180) const char *reverse = is_reverse ? "-R" : NULL;
ae4780e8 1181) struct child_process check_index = CHILD_PROCESS_INIT;
ae4780e8 1182) struct child_process check_worktree = CHILD_PROCESS_INIT;
ae4780e8 1183) struct child_process apply_index = CHILD_PROCESS_INIT;
ae4780e8 1184) struct child_process apply_worktree = CHILD_PROCESS_INIT;
ae4780e8 1187) setup_child_process(s, &check_index,
ae4780e8 1189) applies_index = !pipe_command(&check_index, diff->buf, diff->len,
ae4780e8 1192) setup_child_process(s, &check_worktree,
ae4780e8 1194) applies_worktree = !pipe_command(&check_worktree, diff->buf, diff->len,
ae4780e8 1197) if (applies_worktree && applies_index) {
ae4780e8 1198) setup_child_process(s, &apply_index,
ae4780e8 1200) pipe_command(&apply_index, diff->buf, diff->len,
ae4780e8 1203) setup_child_process(s, &apply_worktree,
ae4780e8 1205) pipe_command(&apply_worktree, diff->buf, diff->len,
ae4780e8 1208) return 1;
ae4780e8 1211) if (!applies_index) {
ae4780e8 1212) err(s, _("The selected hunks do not apply to the index!"));
ae4780e8 1213) if (prompt_yesno(s, _("Apply them to the worktree "
ae4780e8 1215) setup_child_process(s, &apply_worktree,
ae4780e8 1217) return pipe_command(&apply_worktree, diff->buf,
ae4780e8 1220) err(s, _("Nothing was applied.\n"));
ae4780e8 1223) fwrite(diff->buf, diff->len, 1, stderr);
ae4780e8 1225) return 0;
ae4780e8 1553) if (s->mode->apply_for_checkout)
ae4780e8 1554) apply_for_checkout(s, &s->buf,
ae4780e8 1555)    s->mode->is_reverse);
ae4780e8 1557) setup_child_process(s, &cp, "apply", NULL);
ae4780e8 1558) argv_array_pushv(&cp.args, s->mode->apply);
ae4780e8 1559) if (pipe_command(&cp, s->buf.buf, s->buf.len,
ae4780e8 1589) } else if (mode == ADD_P_CHECKOUT) {
ae4780e8 1590) if (!revision)
ae4780e8 1591) s.mode = &patch_mode_checkout_index;
ae4780e8 1592) else if (!strcmp(revision, "HEAD"))
ae4780e8 1593) s.mode = &patch_mode_checkout_head;
ae4780e8 1595) s.mode = &patch_mode_checkout_nothead;

builtin/add.c
ae4780e8 211) else if (!strcmp(patch_mode, "--patch=checkout"))
ae4780e8 212) mode = ADD_P_CHECKOUT;

Johannes Schindelin	ade246ef built-in add -p: implement the 'q' ("quit") command
add-patch.c
ade246ef 1295) int colored = !!s->colored.len, quit = 0;
ade246ef 1385) } else if (ch == 'd' || ch == 'q') {
ade246ef 1391) if (ch == 'q') {
ade246ef 1392) quit = 1;
ade246ef 1393) break;
ade246ef 1569) return quit;

Johannes Schindelin	2e408319 built-in add -p: show helpful hint when nothing can be staged
add-patch.c
2e408319 511) } else if (hunk == &file_diff->head &&
2e408319 512)    starts_with(p, "Binary files "))
2e408319 513) file_diff->binary = 1;
2e408319 1578) size_t i, binary_count = 0;
2e408319 1618) if (s.file_diff[i].binary && !s.file_diff[i].hunk_nr)
2e408319 1619) binary_count++;
2e408319 1620) else if (patch_update_file(&s, s.file_diff + i))
2e408319 1623) if (s.file_diff_nr == 0)
2e408319 1624) fprintf(stderr, _("No changes.\n"));
2e408319 1625) else if (binary_count == s.file_diff_nr)
2e408319 1626) fprintf(stderr, _("Only binary files changed.\n"));

Johannes Schindelin	bcdd297b built-in add -p: implement hunk editing
add-interactive.c
bcdd297b 49) init_color(r, s, "context", s->context_color,
bcdd297b 51) init_color(r, s, "old", s->file_old_color,
bcdd297b 53) init_color(r, s, "new", s->file_new_color,

add-patch.c
bcdd297b 660) size_t i = *hunk_index, delta;
bcdd297b 665) if (!use_all && hunk->use != USE_HUNK)
bcdd297b 682) if ((!use_all && hunk->use != USE_HUNK) ||
bcdd297b 683)     header->new_offset >= next->new_offset + merged->delta ||
bcdd297b 684)     header->new_offset + header->new_count
bcdd297b 685)     < next->new_offset + merged->delta)
bcdd297b 692) if (merged->start < hunk->start && merged->end > hunk->start) {
bcdd297b 693) merged->end = hunk->end;
bcdd297b 694) merged->colored_end = hunk->colored_end;
bcdd297b 695) delta = 0;
bcdd297b 697) const char *plain = s->plain.buf;
bcdd297b 698) size_t  overlapping_line_count = header->new_offset
bcdd297b 699) + header->new_count - merged->delta
bcdd297b 700) - next->new_offset;
bcdd297b 701) size_t overlap_end = hunk->start;
bcdd297b 702) size_t overlap_start = overlap_end;
bcdd297b 713) for (j = 0; j < overlapping_line_count; j++) {
bcdd297b 714) overlap_next = find_next_line(&s->plain,
bcdd297b 717) if (overlap_next > hunk->end)
bcdd297b 724) if (plain[overlap_end] != ' ')
bcdd297b 732) overlap_start = overlap_end;
bcdd297b 733) overlap_end = overlap_next;
bcdd297b 735) len = overlap_end - overlap_start;
bcdd297b 737) if (len > merged->end - merged->start ||
bcdd297b 738)     memcmp(plain + merged->end - len,
bcdd297b 752) if (merged->end != s->plain.len) {
bcdd297b 753) size_t start = s->plain.len;
bcdd297b 755) strbuf_add(&s->plain, plain + merged->start,
bcdd297b 756)    merged->end - merged->start);
bcdd297b 757) plain = s->plain.buf;
bcdd297b 758) merged->start = start;
bcdd297b 759) merged->end = s->plain.len;
bcdd297b 762) strbuf_add(&s->plain,
bcdd297b 764)    hunk->end - overlap_end);
bcdd297b 765) merged->end = s->plain.len;
bcdd297b 766) merged->splittable_into += hunk->splittable_into;
bcdd297b 767) delta = merged->delta;
bcdd297b 768) merged->delta += hunk->delta;
bcdd297b 773) header->new_count = next->new_offset + delta
bcdd297b 774) + next->new_count - header->new_offset;
bcdd297b 789) size_t save_len = s->plain.len, i;
bcdd297b 798) if (!use_all && hunk->use != USE_HUNK)
bcdd297b 803) if (merge_hunks(s, file_diff, &i, use_all, &merged))
bcdd297b 813) strbuf_setlen(&s->plain, save_len);
bcdd297b 815) delta += hunk->delta;
bcdd297b 979) static void recolor_hunk(struct add_p_state *s, struct hunk *hunk)
bcdd297b 981) const char *plain = s->plain.buf;
bcdd297b 984) if (!s->colored.len)
bcdd297b 985) return;
bcdd297b 987) hunk->colored_start = s->colored.len;
bcdd297b 988) for (current = hunk->start; current < hunk->end; ) {
bcdd297b 989) for (eol = current; eol < hunk->end; eol++)
bcdd297b 990) if (plain[eol] == '\n')
bcdd297b 991) break;
bcdd297b 992) next = eol + (eol < hunk->end);
bcdd297b 993) if (eol > current && plain[eol - 1] == '\r')
bcdd297b 994) eol--;
bcdd297b 996) strbuf_addstr(&s->colored,
bcdd297b 997)       plain[current] == '-' ?
bcdd297b 999)       plain[current] == '+' ?
bcdd297b 1002) strbuf_add(&s->colored, plain + current, eol - current);
bcdd297b 1003) strbuf_addstr(&s->colored, GIT_COLOR_RESET);
bcdd297b 1004) if (next > eol)
bcdd297b 1005) strbuf_add(&s->colored, plain + eol, next - eol);
bcdd297b 1006) current = next;
bcdd297b 1008) hunk->colored_end = s->colored.len;
bcdd297b 1011) static int edit_hunk_manually(struct add_p_state *s, struct hunk *hunk)
bcdd297b 1015) strbuf_reset(&s->buf);
bcdd297b 1016) strbuf_commented_addf(&s->buf, _("Manual hunk edit mode -- see bottom for "
bcdd297b 1018) render_hunk(s, hunk, 0, 0, &s->buf);
bcdd297b 1019) strbuf_commented_addf(&s->buf,
bcdd297b 1033) strbuf_commented_addf(&s->buf,
bcdd297b 1040) if (strbuf_edit_interactively(&s->buf, "addp-hunk-edit.diff", NULL) < 0)
bcdd297b 1041) return -1;
bcdd297b 1044) hunk->start = s->plain.len;
bcdd297b 1045) for (i = 0; i < s->buf.len; ) {
bcdd297b 1046) size_t next = find_next_line(&s->buf, i);
bcdd297b 1048) if (s->buf.buf[i] != comment_line_char)
bcdd297b 1049) strbuf_add(&s->plain, s->buf.buf + i, next - i);
bcdd297b 1050) i = next;
bcdd297b 1053) hunk->end = s->plain.len;
bcdd297b 1054) if (hunk->end == hunk->start)
bcdd297b 1056) return 0;
bcdd297b 1058) recolor_hunk(s, hunk);
bcdd297b 1065) if (s->plain.buf[hunk->start] == '@' &&
bcdd297b 1066)     parse_hunk_header(s, hunk) < 0)
bcdd297b 1069) return 1;
bcdd297b 1072) static ssize_t recount_edited_hunk(struct add_p_state *s, struct hunk *hunk,
bcdd297b 1075) struct hunk_header *header = &hunk->header;
bcdd297b 1078) header->old_count = header->new_count = 0;
bcdd297b 1079) for (i = hunk->start; i < hunk->end; ) {
bcdd297b 1080) switch (s->plain.buf[i]) {
bcdd297b 1082) header->old_count++;
bcdd297b 1083) break;
bcdd297b 1085) header->new_count++;
bcdd297b 1086) break;
bcdd297b 1088) header->old_count++;
bcdd297b 1089) header->new_count++;
bcdd297b 1090) break;
bcdd297b 1093) i = find_next_line(&s->plain, i);
bcdd297b 1096) return orig_old_count - orig_new_count
bcdd297b 1097) - header->old_count + header->new_count;
bcdd297b 1100) static int run_apply_check(struct add_p_state *s,
bcdd297b 1103) struct child_process cp = CHILD_PROCESS_INIT;
bcdd297b 1105) strbuf_reset(&s->buf);
bcdd297b 1106) reassemble_patch(s, file_diff, 1, &s->buf);
bcdd297b 1108) setup_child_process(s, &cp,
bcdd297b 1111) if (pipe_command(&cp, s->buf.buf, s->buf.len, NULL, 0, NULL, 0))
bcdd297b 1114) return 0;
bcdd297b 1117) static int prompt_yesno(struct add_p_state *s, const char *prompt)
bcdd297b 1120) color_fprintf(stdout, s->s.prompt_color, "%s", _(prompt));
bcdd297b 1121) fflush(stdout);
bcdd297b 1122) if (strbuf_getline(&s->answer, stdin) == EOF)
bcdd297b 1123) return -1;
bcdd297b 1124) strbuf_trim_trailing_newline(&s->answer);
bcdd297b 1125) switch (tolower(s->answer.buf[0])) {
bcdd297b 1126) case 'n': return 0;
bcdd297b 1127) case 'y': return 1;
bcdd297b 1129) }
bcdd297b 1132) static int edit_hunk_loop(struct add_p_state *s,
bcdd297b 1135) size_t plain_len = s->plain.len, colored_len = s->colored.len;
bcdd297b 1138) backup = *hunk;
bcdd297b 1141) int res = edit_hunk_manually(s, hunk);
bcdd297b 1142) if (res == 0) {
bcdd297b 1144) *hunk = backup;
bcdd297b 1145) return -1;
bcdd297b 1148) if (res > 0) {
bcdd297b 1149) hunk->delta +=
bcdd297b 1150) recount_edited_hunk(s, hunk,
bcdd297b 1153) if (!run_apply_check(s, file_diff))
bcdd297b 1154) return 0;
bcdd297b 1158) strbuf_setlen(&s->plain, plain_len);
bcdd297b 1159) strbuf_setlen(&s->colored, colored_len);
bcdd297b 1160) *hunk = backup;
bcdd297b 1169) res = prompt_yesno(s, _("Your edited hunk does not apply. "
bcdd297b 1172) if (res < 1)
bcdd297b 1173) return -1;
bcdd297b 1174) }
bcdd297b 1345) if (hunk_index + 1 > file_diff->mode_change &&
bcdd297b 1346)     !file_diff->deleted)
bcdd297b 1347) strbuf_addstr(&s->buf, ",e");
bcdd297b 1508) } else if (s->answer.buf[0] == 'e') {
bcdd297b 1509) if (hunk_index + 1 == file_diff->mode_change)
bcdd297b 1510) err(s, _("Sorry, cannot edit this hunk"));
bcdd297b 1511) else if (edit_hunk_loop(s, file_diff, hunk) >= 0) {
bcdd297b 1512) hunk->use = USE_HUNK;
bcdd297b 1513) goto soft_increment;
bcdd297b 1550) reassemble_patch(s, file_diff, 0, &s->buf);

Johannes Schindelin	1942ee44 built-in add -i: wire up the new C code for the `patch` command
add-interactive.c
1942ee44 918) struct pathspec ps_selected = { 0 };
1942ee44 924) parse_pathspec(&ps_selected,
1942ee44 929) clear_pathspec(&ps_selected);

Johannes Schindelin	11f2c0da built-in add -p: coalesce hunks after splitting them
add-patch.c
11f2c0da 657) static int merge_hunks(struct add_p_state *s, struct file_diff *file_diff,
11f2c0da 661) struct hunk *hunk = file_diff->hunk + i;
11f2c0da 663) struct hunk_header *header = &merged->header, *next;
11f2c0da 666) return 0;
11f2c0da 668) *merged = *hunk;
11f2c0da 670) merged->colored_start = merged->colored_end = 0;
11f2c0da 672) for (; i + 1 < file_diff->hunk_nr; i++) {
11f2c0da 673) hunk++;
11f2c0da 674) next = &hunk->header;
11f2c0da 771) header->old_count = next->old_offset + next->old_count
11f2c0da 772) - header->old_offset;
11f2c0da 777) if (i == *hunk_index)
11f2c0da 778) return 0;
11f2c0da 780) *hunk_index = i;
11f2c0da 781) return 1;
11f2c0da 795) struct hunk merged = { 0 };
11f2c0da 804) hunk = &merged;

Johannes Schindelin	7584dd3c built-in add -p: offer a helpful error message when hunk navigation failed
add-patch.c
7584dd3c 257) static void err(struct add_p_state *s, const char *fmt, ...)
7584dd3c 261) va_start(args, fmt);
7584dd3c 262) fputs(s->s.error_color, stderr);
7584dd3c 263) vfprintf(stderr, fmt, args);
7584dd3c 264) fputs(s->s.reset_color, stderr);
7584dd3c 265) fputc('\n', stderr);
7584dd3c 266) va_end(args);
7584dd3c 267) }
7584dd3c 1395) } else if (s->answer.buf[0] == 'K') {
7584dd3c 1396) if (hunk_index)
7584dd3c 1397) hunk_index--;
7584dd3c 1399) err(s, _("No previous hunk"));
7584dd3c 1400) } else if (s->answer.buf[0] == 'J') {
7584dd3c 1402) hunk_index++;
7584dd3c 1404) err(s, _("No next hunk"));
7584dd3c 1405) } else if (s->answer.buf[0] == 'k') {
7584dd3c 1406) if (undecided_previous >= 0)
7584dd3c 1407) hunk_index = undecided_previous;
7584dd3c 1409) err(s, _("No previous hunk"));
7584dd3c 1410) } else if (s->answer.buf[0] == 'j') {
7584dd3c 1411) if (undecided_next >= 0)
7584dd3c 1412) hunk_index = undecided_next;
7584dd3c 1414) err(s, _("No next hunk"));

Johannes Schindelin	f6aa7ecc built-in add -i: start implementing the `patch` functionality in C
add-patch.c
f6aa7ecc 269) static void setup_child_process(struct add_p_state *s,
f6aa7ecc 275) va_start(ap, cp);
f6aa7ecc 276) while ((arg = va_arg(ap, const char *)))
f6aa7ecc 277) argv_array_push(&cp->args, arg);
f6aa7ecc 278) va_end(ap);
f6aa7ecc 280) cp->git_cmd = 1;
f6aa7ecc 281) argv_array_pushf(&cp->env_array,
f6aa7ecc 359) static int parse_diff(struct add_p_state *s, const struct pathspec *ps)
f6aa7ecc 363) struct child_process cp = CHILD_PROCESS_INIT;
f6aa7ecc 367) struct hunk *hunk = NULL;
f6aa7ecc 382) for (i = 0; i < ps->nr; i++)
f6aa7ecc 387) res = capture_command(&cp, plain, 0);
f6aa7ecc 394) return 0;
f6aa7ecc 396) strbuf_complete_line(plain);
f6aa7ecc 416) p = plain->buf;
f6aa7ecc 417) pend = p + plain->len;
f6aa7ecc 418) while (p != pend) {
f6aa7ecc 419) char *eol = memchr(p, '\n', pend - p);
f6aa7ecc 422) if (!eol)
f6aa7ecc 423) eol = pend;
f6aa7ecc 425) if (starts_with(p, "diff ")) {
f6aa7ecc 436) } else if (p == plain->buf)
f6aa7ecc 455) memset(hunk, 0, sizeof(*hunk));
f6aa7ecc 457) hunk->start = p - plain->buf;
f6aa7ecc 525) p = eol == pend ? pend : eol + 1;
f6aa7ecc 526) hunk->end = p - plain->buf;
f6aa7ecc 557) return 0;
f6aa7ecc 574) static void render_hunk(struct add_p_state *s, struct hunk *hunk,
f6aa7ecc 621) }
f6aa7ecc 818) }
f6aa7ecc 1290) size_t hunk_index = 0;
f6aa7ecc 1294) struct child_process cp = CHILD_PROCESS_INIT;
f6aa7ecc 1299) return 0;
f6aa7ecc 1301) strbuf_reset(&s->buf);
f6aa7ecc 1303) fputs(s->buf.buf, stdout);
f6aa7ecc 1306) hunk_index = 0;
f6aa7ecc 1309) undecided_previous = -1;
f6aa7ecc 1310) for (i = hunk_index - 1; i >= 0; i--)
f6aa7ecc 1312) undecided_previous = i;
f6aa7ecc 1313) break;
f6aa7ecc 1316) undecided_next = -1;
f6aa7ecc 1319) undecided_next = i;
f6aa7ecc 1320) break;
f6aa7ecc 1324) if (undecided_previous < 0 && undecided_next < 0 &&
f6aa7ecc 1325)     hunk->use != UNDECIDED_HUNK)
f6aa7ecc 1326) break;
f6aa7ecc 1328) strbuf_reset(&s->buf);
f6aa7ecc 1330) fputs(s->buf.buf, stdout);
f6aa7ecc 1332) strbuf_reset(&s->buf);
f6aa7ecc 1333) if (undecided_previous >= 0)
f6aa7ecc 1334) strbuf_addstr(&s->buf, ",k");
f6aa7ecc 1335) if (hunk_index)
f6aa7ecc 1336) strbuf_addstr(&s->buf, ",K");
f6aa7ecc 1337) if (undecided_next >= 0)
f6aa7ecc 1338) strbuf_addstr(&s->buf, ",j");
f6aa7ecc 1340) strbuf_addstr(&s->buf, ",J");
f6aa7ecc 1363) fflush(stdout);
f6aa7ecc 1364) if (strbuf_getline(&s->answer, stdin) == EOF)
f6aa7ecc 1365) break;
f6aa7ecc 1366) strbuf_trim_trailing_newline(&s->answer);
f6aa7ecc 1368) if (!s->answer.len)
f6aa7ecc 1369) continue;
f6aa7ecc 1370) ch = tolower(s->answer.buf[0]);
f6aa7ecc 1371) if (ch == 'y') {
f6aa7ecc 1372) hunk->use = USE_HUNK;
f6aa7ecc 1374) hunk_index = undecided_next < 0 ?
f6aa7ecc 1376) } else if (ch == 'n') {
f6aa7ecc 1377) hunk->use = SKIP_HUNK;
f6aa7ecc 1378) goto soft_increment;
f6aa7ecc 1379) } else if (ch == 'a') {
f6aa7ecc 1382) if (hunk->use == UNDECIDED_HUNK)
f6aa7ecc 1383) hunk->use = USE_HUNK;
f6aa7ecc 1388) if (hunk->use == UNDECIDED_HUNK)
f6aa7ecc 1389) hunk->use = SKIP_HUNK;
f6aa7ecc 1540) }
f6aa7ecc 1545) break;
f6aa7ecc 1549) strbuf_reset(&s->buf);
f6aa7ecc 1568) putchar('\n');
f6aa7ecc 1607) if (discard_index(r->index) < 0 || repo_read_index(r) < 0 ||
f6aa7ecc 1611)     parse_diff(&s, ps) < 0) {
f6aa7ecc 1612) strbuf_release(&s.plain);
f6aa7ecc 1614) return -1;
f6aa7ecc 1628) strbuf_release(&s.answer);
f6aa7ecc 1629) strbuf_release(&s.buf);
f6aa7ecc 1630) strbuf_release(&s.plain);
f6aa7ecc 1632) return 0;

builtin/add.c
f6aa7ecc 202) if (!patch_mode)

Johannes Schindelin	572bdc3a built-in add -p: prepare for patch modes other than "stage"
add-interactive.c
572bdc3a 927) res = run_add_p(s->r, ADD_P_STAGE, NULL, &ps_selected);

add-patch.c
572bdc3a 370) argv_array_pushv(&args, s->mode->diff);
572bdc3a 371) if (s->revision) {
572bdc3a 373) argv_array_push(&args,
572bdc3a 375) !strcmp("HEAD", s->revision) &&
572bdc3a 376) get_oid("HEAD", &oid) ?
572bdc3a 379) color_arg_index = args.argc;
572bdc3a 381) argv_array_pushl(&args, "--no-color", "-p", "--", NULL);
572bdc3a 599) if (s->mode->is_reverse)
572bdc3a 600) old_offset -= delta;
572bdc3a 602) new_offset += delta;
572bdc3a 1025)       s->mode->is_reverse ? '+' : '-',
572bdc3a 1026)       s->mode->is_reverse ? '-' : '+',
572bdc3a 1028) strbuf_commented_addf(&s->buf, "%s", _(s->mode->edit_hunk_hint));
572bdc3a 1110) argv_array_pushv(&cp.args, s->mode->apply_check);
572bdc3a 1361)       _(s->mode->prompt_mode[prompt_mode_type]),
572bdc3a 1519)       _(s->mode->help_patch_text));
572bdc3a 1572) int run_add_p(struct repository *r, enum add_p_mode mode,
572bdc3a 1605) s.revision = revision;

builtin/add.c
572bdc3a 205) if (!strcmp(patch_mode, "--patch"))
572bdc3a 206) mode = ADD_P_STAGE;
572bdc3a 218) return !!run_add_p(the_repository, mode, revision, pathspec);

Johannes Schindelin	e3bd11b4 built-in add -p: show colored hunks by default
add-patch.c
e3bd11b4 361) struct argv_array args = ARGV_ARRAY_INIT;
e3bd11b4 362) struct strbuf *plain = &s->plain, *colored = NULL;
e3bd11b4 383) argv_array_push(&args, ps->items[i].original);
e3bd11b4 385) setup_child_process(s, &cp, NULL);
e3bd11b4 386) cp.argv = args.argv;
e3bd11b4 388) if (res) {
e3bd11b4 389) argv_array_clear(&args);
e3bd11b4 392) if (!plain->len) {
e3bd11b4 393) argv_array_clear(&args);
e3bd11b4 398) if (want_color_fd(1, -1)) {
e3bd11b4 399) struct child_process colored_cp = CHILD_PROCESS_INIT;
e3bd11b4 401) setup_child_process(s, &colored_cp, NULL);
e3bd11b4 402) xsnprintf((char *)args.argv[color_arg_index], 8, "--color");
e3bd11b4 403) colored_cp.argv = args.argv;
e3bd11b4 404) colored = &s->colored;
e3bd11b4 405) res = capture_command(&colored_cp, colored, 0);
e3bd11b4 406) argv_array_clear(&args);
e3bd11b4 407) if (res)
e3bd11b4 409) strbuf_complete_line(colored);
e3bd11b4 410) colored_p = colored->buf;
e3bd11b4 411) colored_pend = colored_p + colored->len;
e3bd11b4 413) argv_array_clear(&args);
e3bd11b4 458) if (colored)
e3bd11b4 459) hunk->colored_start = colored_p - colored->buf;
e3bd11b4 528) if (colored) {
e3bd11b4 529) char *colored_eol = memchr(colored_p, '\n',
e3bd11b4 530)    colored_pend - colored_p);
e3bd11b4 531) if (colored_eol)
e3bd11b4 532) colored_p = colored_eol + 1;
e3bd11b4 534) colored_p = colored_pend;
e3bd11b4 536) hunk->colored_end = colored_p - colored->buf;
e3bd11b4 615) if (colored)
e3bd11b4 616) strbuf_add(out, s->colored.buf + hunk->colored_start,
e3bd11b4 617)    hunk->colored_end - hunk->colored_start);
e3bd11b4 619) strbuf_add(out, s->plain.buf + hunk->start,
e3bd11b4 620)    hunk->end - hunk->start);
e3bd11b4 1613) strbuf_release(&s.colored);
e3bd11b4 1631) strbuf_release(&s.colored);

Johannes Schindelin	510aeca1 built-in add -p: implement the hunk splitting feature
add-patch.c
510aeca1 364) char *p, *pend, *colored_p = NULL, *colored_pend = NULL, marker = '\0';
510aeca1 435) marker = '\0';
510aeca1 444) if (marker == '-' || marker == '+')
510aeca1 449) hunk->splittable_into++;
510aeca1 470) marker = *p;
510aeca1 520) if ((marker == '-' || marker == '+') && *p == ' ')
510aeca1 521) hunk->splittable_into++;
510aeca1 522) if (marker && *p != '\\')
510aeca1 523) marker = *p;
510aeca1 550) if (marker == '-' || marker == '+')
510aeca1 555) hunk->splittable_into++;
510aeca1 560) static size_t find_next_line(struct strbuf *sb, size_t offset)
510aeca1 564) if (offset >= sb->len)
510aeca1 568) eol = memchr(sb->buf + offset, '\n', sb->len - offset);
510aeca1 569) if (!eol)
510aeca1 570) return sb->len;
510aeca1 571) return eol - sb->buf + 1;
510aeca1 820) static int split_hunk(struct add_p_state *s, struct file_diff *file_diff,
510aeca1 823) int colored = !!s->colored.len, first = 1;
510aeca1 824) struct hunk *hunk = file_diff->hunk + hunk_index;
510aeca1 826) size_t end, colored_end, current, colored_current = 0, context_line_count;
510aeca1 830) if (hunk_index >= file_diff->hunk_nr)
510aeca1 834) if (hunk->splittable_into < 2)
510aeca1 835) return 0;
510aeca1 836) splittable_into = hunk->splittable_into;
510aeca1 838) end = hunk->end;
510aeca1 839) colored_end = hunk->colored_end;
510aeca1 841) remaining = hunk->header;
510aeca1 843) file_diff->hunk_nr += splittable_into - 1;
510aeca1 844) ALLOC_GROW(file_diff->hunk, file_diff->hunk_nr, file_diff->hunk_alloc);
510aeca1 845) if (hunk_index + splittable_into < file_diff->hunk_nr)
510aeca1 846) memmove(file_diff->hunk + hunk_index + splittable_into,
510aeca1 847) file_diff->hunk + hunk_index + 1,
510aeca1 848) (file_diff->hunk_nr - hunk_index - splittable_into)
510aeca1 850) hunk = file_diff->hunk + hunk_index;
510aeca1 851) hunk->splittable_into = 1;
510aeca1 852) memset(hunk + 1, 0, (splittable_into - 1) * sizeof(*hunk));
510aeca1 854) header = &hunk->header;
510aeca1 855) header->old_count = header->new_count = 0;
510aeca1 857) current = hunk->start;
510aeca1 858) if (colored)
510aeca1 859) colored_current = hunk->colored_start;
510aeca1 860) marker = '\0';
510aeca1 861) context_line_count = 0;
510aeca1 863) while (splittable_into > 1) {
510aeca1 864) ch = s->plain.buf[current];
510aeca1 866) if (!ch)
510aeca1 873) if ((marker == '-' || marker == '+') && ch == ' ') {
510aeca1 874) first = 0;
510aeca1 875) hunk[1].start = current;
510aeca1 876) if (colored)
510aeca1 877) hunk[1].colored_start = colored_current;
510aeca1 878) context_line_count = 0;
510aeca1 888) if (marker != ' ' || (ch != '-' && ch != '+')) {
510aeca1 891) if (ch == '\\')
510aeca1 892) ch = marker ? marker : ' ';
510aeca1 895) if (ch == ' ')
510aeca1 896) context_line_count++;
510aeca1 897) else if (ch == '-')
510aeca1 898) header->old_count++;
510aeca1 899) else if (ch == '+')
510aeca1 900) header->new_count++;
510aeca1 903) marker = ch;
510aeca1 904) current = find_next_line(&s->plain, current);
510aeca1 905) if (colored)
510aeca1 906) colored_current =
510aeca1 907) find_next_line(&s->colored,
510aeca1 909) continue;
510aeca1 919) if (first) {
510aeca1 920) if (header->old_count || header->new_count)
510aeca1 925) header->old_count = context_line_count;
510aeca1 926) header->new_count = context_line_count;
510aeca1 927) context_line_count = 0;
510aeca1 928) first = 0;
510aeca1 929) goto next_hunk_line;
510aeca1 932) remaining.old_offset += header->old_count;
510aeca1 933) remaining.old_count -= header->old_count;
510aeca1 934) remaining.new_offset += header->new_count;
510aeca1 935) remaining.new_count -= header->new_count;
510aeca1 938) hunk[1].header.old_offset =
510aeca1 939) header->old_offset + header->old_count;
510aeca1 940) hunk[1].header.new_offset =
510aeca1 941) header->new_offset + header->new_count;
510aeca1 944) header->old_count += context_line_count;
510aeca1 945) header->new_count += context_line_count;
510aeca1 947) hunk->end = current;
510aeca1 948) if (colored)
510aeca1 949) hunk->colored_end = colored_current;
510aeca1 951) hunk++;
510aeca1 952) hunk->splittable_into = 1;
510aeca1 953) hunk->use = hunk[-1].use;
510aeca1 954) header = &hunk->header;
510aeca1 956) header->old_count = header->new_count = context_line_count;
510aeca1 957) context_line_count = 0;
510aeca1 959) splittable_into--;
510aeca1 960) marker = ch;
510aeca1 964) if (header->old_offset != remaining.old_offset)
510aeca1 967) if (header->new_offset != remaining.new_offset)
510aeca1 970) header->old_count = remaining.old_count;
510aeca1 971) header->new_count = remaining.new_count;
510aeca1 972) hunk->end = end;
510aeca1 973) if (colored)
510aeca1 974) hunk->colored_end = colored_end;
510aeca1 976) return 0;
510aeca1 1343) if (hunk->splittable_into > 1)
510aeca1 1344) strbuf_addstr(&s->buf, ",s");
510aeca1 1499) } else if (s->answer.buf[0] == 's') {
510aeca1 1500) size_t splittable_into = hunk->splittable_into;
510aeca1 1501) if (splittable_into < 2)
510aeca1 1502) err(s, _("Sorry, cannot split this hunk"));
510aeca1 1503) else if (!split_hunk(s, file_diff,
510aeca1 1504)      hunk - file_diff->hunk))
510aeca1 1505) color_fprintf_ln(stdout, s->s.header_color,

Johannes Schindelin	80399aec built-in add -p: support multi-file diffs
add-patch.c
80399aec 365) size_t file_diff_alloc = 0, i, color_arg_index;
80399aec 366) struct file_diff *file_diff = NULL;
80399aec 426) s->file_diff_nr++;
80399aec 427) ALLOC_GROW(s->file_diff, s->file_diff_nr,
80399aec 429) file_diff = s->file_diff + s->file_diff_nr - 1;
80399aec 430) memset(file_diff, 0, sizeof(*file_diff));
80399aec 431) hunk = &file_diff->head;
80399aec 432) hunk->start = p - plain->buf;
80399aec 433) if (colored_p)
80399aec 434) hunk->colored_start = colored_p - colored->buf;
80399aec 451) file_diff->hunk_nr++;
80399aec 452) ALLOC_GROW(file_diff->hunk, file_diff->hunk_nr,
80399aec 454) hunk = file_diff->hunk + file_diff->hunk_nr - 1;
80399aec 784) static void reassemble_patch(struct add_p_state *s,
80399aec 797) hunk = file_diff->hunk + i;
80399aec 1287) static int patch_update_file(struct add_p_state *s,
80399aec 1298) if (!file_diff->hunk_nr)
80399aec 1305) if (hunk_index >= file_diff->hunk_nr)
80399aec 1307) hunk = file_diff->hunk + hunk_index;
80399aec 1311) if (file_diff->hunk[i].use == UNDECIDED_HUNK) {
80399aec 1317) for (i = hunk_index + 1; i < file_diff->hunk_nr; i++)
80399aec 1318) if (file_diff->hunk[i].use == UNDECIDED_HUNK) {
80399aec 1339) if (hunk_index + 1 < file_diff->hunk_nr)
80399aec 1359)       (uintmax_t)file_diff->hunk_nr);
80399aec 1375) file_diff->hunk_nr : undecided_next;
80399aec 1380) for (; hunk_index < file_diff->hunk_nr; hunk_index++) {
80399aec 1381) hunk = file_diff->hunk + hunk_index;
80399aec 1386) for (; hunk_index < file_diff->hunk_nr; hunk_index++) {
80399aec 1387) hunk = file_diff->hunk + hunk_index;
80399aec 1401) if (hunk_index + 1 < file_diff->hunk_nr)
80399aec 1543) for (i = 0; i < file_diff->hunk_nr; i++)
80399aec 1544) if (file_diff->hunk[i].use == USE_HUNK)
80399aec 1547) if (i < file_diff->hunk_nr) {
80399aec 1617) for (i = 0; i < s.file_diff_nr; i++)
80399aec 1621) break;

Johannes Schindelin	47dc4fd5 built-in add -p: handle deleted empty files
add-patch.c
47dc4fd5 439) else if (file_diff->deleted)
47dc4fd5 441) else if (starts_with(p, "@@ ") ||
47dc4fd5 442)  (hunk == &file_diff->head &&
47dc4fd5 443)   skip_prefix(p, "deleted file", &deleted))) {
47dc4fd5 461) if (deleted)
47dc4fd5 462) file_diff->deleted = 1;
47dc4fd5 463) else if (parse_hunk_header(s, hunk) < 0)

Johannes Schindelin	5906d5de built-in app -p: allow selecting a mode change as a "hunk"
add-patch.c
5906d5de 348) static int is_octal(const char *p, size_t len)
5906d5de 350) if (!len)
5906d5de 351) return 0;
5906d5de 353) while (len--)
5906d5de 354) if (*p < '0' || *(p++) > '7')
5906d5de 355) return 0;
5906d5de 356) return 1;
5906d5de 420) const char *deleted = NULL, *mode_change = NULL;
5906d5de 471) } else if (hunk == &file_diff->head &&
5906d5de 472)    skip_prefix(p, "old mode ", &mode_change) &&
5906d5de 473)    is_octal(mode_change, eol - mode_change)) {
5906d5de 474) if (file_diff->mode_change)
5906d5de 477) if (file_diff->hunk_nr++)
5906d5de 485) file_diff->mode_change = 1;
5906d5de 486) ALLOC_GROW(file_diff->hunk, file_diff->hunk_nr,
5906d5de 488) memset(file_diff->hunk, 0, sizeof(struct hunk));
5906d5de 489) file_diff->hunk->start = p - plain->buf;
5906d5de 490) if (colored_p)
5906d5de 491) file_diff->hunk->colored_start =
5906d5de 492) colored_p - colored->buf;
5906d5de 493) } else if (hunk == &file_diff->head &&
5906d5de 494)    skip_prefix(p, "new mode ", &mode_change) &&
5906d5de 495)    is_octal(mode_change, eol - mode_change)) {
5906d5de 501) if (!file_diff->mode_change)
5906d5de 504) if (file_diff->hunk_nr != 1)
5906d5de 507) if (p - plain->buf != file_diff->hunk->end)
5906d5de 515) if (file_diff->deleted && file_diff->mode_change)
5906d5de 539) if (mode_change) {
5906d5de 540) if (file_diff->hunk_nr != 1)
5906d5de 544) file_diff->hunk->end = hunk->end;
5906d5de 545) if (colored)
5906d5de 546) file_diff->hunk->colored_end = hunk->colored_end;
5906d5de 623) static void render_diff_header(struct add_p_state *s,
5906d5de 632) int skip_mode_change =
5906d5de 633) file_diff->mode_change && file_diff->hunk->use != USE_HUNK;
5906d5de 634) struct hunk *head = &file_diff->head, *first = file_diff->hunk;
5906d5de 636) if (!skip_mode_change) {
5906d5de 637) render_hunk(s, head, 0, colored, out);
5906d5de 638) return;
5906d5de 641) if (colored) {
5906d5de 642) const char *p = s->colored.buf;
5906d5de 644) strbuf_add(out, p + head->colored_start,
5906d5de 645)     first->colored_start - head->colored_start);
5906d5de 646) strbuf_add(out, p + first->colored_end,
5906d5de 647)     head->colored_end - first->colored_end);
5906d5de 649) const char *p = s->plain.buf;
5906d5de 651) strbuf_add(out, p + head->start, first->start - head->start);
5906d5de 652) strbuf_add(out, p + first->end, head->end - first->end);
5906d5de 792) render_diff_header(s, file_diff, 0, out);
5906d5de 794) for (i = file_diff->mode_change; i < file_diff->hunk_nr; i++) {
5906d5de 1302) render_diff_header(s, file_diff, colored, &s->buf);

Jonathan Nieder	ee70c128 index: offer advice for unknown index extensions
read-cache.c
ee70c128 1756) if (advice_unknown_index_extension) {

Josh Steadmon	6da1f1a9 protocol: advertise multiple supported versions
remote-curl.c
6da1f1a9 354) return 0;

Matheus Tavares	beebb9d2 object-store: allow threaded access to object reading
packfile.c
beebb9d2 1465) return;

sha1-file.c
beebb9d2 1431) return;
beebb9d2 1440) return;

Phillip Wood	430b75f7 commit: give correct advice for empty commit during a rebase
sequencer.c
430b75f7 1583)     return -1;



Uncovered code in 'jch' not in 'next'
--------------------------------------------------------

Commits introducing uncovered code:
Alban Gruin	0d50cf5e sequencer: move check_todo_list_from_file() to rebase-interactive.c
rebase-interactive.c
0d50cf5e 210) goto out;
0d50cf5e 215) goto out;
0d50cf5e 224) fprintf(stderr, _(edit_todo_list_advice));

Alex Torok	fed842f0 rebase: fix --fork-point with short refname
builtin/merge-base.c
fed842f0 128) return 1;

Martin Ågren	3bf986d6 builtin/config: collect "value_regexp" data in a struct
builtin/config.c
3bf986d6 329) FREE_AND_NULL(cmd_line_value.regexp);

Martin Ågren	3bcdd852 builtin/config: extract `handle_value_regex()` from `get_value()`
builtin/config.c
3bcdd852 330) return CONFIG_INVALID_PATTERN;
3bcdd852 375) goto free_strings;



Uncovered code in 'next' not in 'master'
--------------------------------------------------------

Commits introducing uncovered code:
Derrick Stolee	d89f09c8 clone: add --sparse mode
builtin/clone.c
d89f09c8 753) result = 1;
d89f09c8 1132) return 1;

Derrick Stolee	e091228e sparse-checkout: update working directory in-process
builtin/sparse-checkout.c
e091228e 85) return 0;

Derrick Stolee	bab3c359 sparse-checkout: create 'init' subcommand
builtin/sparse-checkout.c
bab3c359 221) return 1;
bab3c359 275) return 1;

Derrick Stolee	190a65f9 sparse-checkout: respect core.ignoreCase in cone mode
builtin/sparse-checkout.c
190a65f9 337)    strihash(e->pattern) :

dir.c
190a65f9 669)    strihash(translated->pattern) :
190a65f9 700)    strihash(translated->pattern) :

Derrick Stolee	af09ce24 sparse-checkout: init and set in cone mode
builtin/sparse-checkout.c
af09ce24 352) return;

Derrick Stolee	96cc8ab5 sparse-checkout: use hashmaps for cone patterns
dir.c
96cc8ab5 656) pl->use_cone_patterns = 0;
96cc8ab5 658) goto clear_hashmaps;
96cc8ab5 682) hashmap_add(&pl->parent_hashmap, &translated->ent);
96cc8ab5 683) hashmap_remove(&pl->recursive_hashmap, &translated->ent, &data);
96cc8ab5 684) free(data);
96cc8ab5 685) return;
96cc8ab5 691) goto clear_hashmaps;
96cc8ab5 709) hashmap_remove(&pl->parent_hashmap, &translated->ent, &data);
96cc8ab5 710) free(data);
96cc8ab5 711) free(translated);
96cc8ab5 1273) return MATCHED;

Jeff King	4f0bd8b9 pack-objects: improve partial packfile reuse
builtin/pack-objects.c
4f0bd8b9 1124) return 1;
4f0bd8b9 2681) (reuse_packfile_bitmap &&
4f0bd8b9 2682)  bitmap_walk_contains(bitmap_git, reuse_packfile_bitmap, oid));

pack-bitmap.c
4f0bd8b9 808) return;
4f0bd8b9 811) return;
4f0bd8b9 823) return;
4f0bd8b9 861) i = bitmap_git->pack->num_objects / BITS_IN_EWORD;

Jeff King	7cb9754e pack-objects: introduce pack.allowPackReuse
builtin/pack-objects.c
7cb9754e 2834) allow_pack_reuse = git_config_bool(k, v);
7cb9754e 2835) return 0;

Jeff King	7b143c16 pack-bitmap: introduce bitmap_walk_contains()
pack-bitmap.c
7b143c16 903) return 0;

Tanushree Tumane	51a0a4ed bisect--helper: avoid use-after-free
builtin/bisect--helper.c
51a0a4ed 177) return -1;



Uncovered code in 'master' not in 'master@{1}'
--------------------------------------------------------

Commits introducing uncovered code:
Alban Gruin	393adf7a sequencer: directly call pick_commits() from complete_action()
sequencer.c
393adf7a 5272) goto cleanup;

Daniel Ferreira	5e82b9e4 built-in add -i: implement the `status` command
add-interactive.c
5e82b9e4 629) return -1;
5e82b9e4 632) putchar('\n');
5e82b9e4 634) return 0;

Derrick Stolee	44a4693b progress: create GIT_PROGRESS_DELAY
progress.c
44a4693b 308) return start_progress_delay(title, total, get_default_delay(), 1);

Garima Singh	a62f9d1a test-path-utils: offer to run a protectNTFS/protectHFS benchmark
t/helper/test-path-utils.c
a62f9d1a 194) static uint64_t my_random(void)
a62f9d1a 196) my_random_value = my_random_value * 1103515245 + 12345;
a62f9d1a 197) return my_random_value;
a62f9d1a 205) static double my_sqrt(double value)
a62f9d1a 207) const double epsilon = 1e-6;
a62f9d1a 208) double x = value;
a62f9d1a 210) if (value == 0)
a62f9d1a 211) return 0;
a62f9d1a 214) double delta = (value / x - x) / 2;
a62f9d1a 215) if (delta < epsilon && delta > -epsilon)
a62f9d1a 216) return x + delta;
a62f9d1a 217) x += delta;
a62f9d1a 218) }
a62f9d1a 221) static int protect_ntfs_hfs_benchmark(int argc, const char **argv)
a62f9d1a 223) size_t i, j, nr, min_len = 3, max_len = 20;
a62f9d1a 225) int repetitions = 15, file_mode = 0100644;
a62f9d1a 231) if (argc > 1 && !strcmp(argv[1], "--with-symlink-mode")) {
a62f9d1a 232) file_mode = 0120000;
a62f9d1a 233) argc--;
a62f9d1a 234) argv++;
a62f9d1a 237) nr = argc > 1 ? strtoul(argv[1], NULL, 0) : 1000000;
a62f9d1a 238) ALLOC_ARRAY(names, nr);
a62f9d1a 240) if (argc > 2) {
a62f9d1a 241) min_len = strtoul(argv[2], NULL, 0);
a62f9d1a 242) if (argc > 3)
a62f9d1a 243) max_len = strtoul(argv[3], NULL, 0);
a62f9d1a 244) if (min_len > max_len)
a62f9d1a 248) for (i = 0; i < nr; i++) {
a62f9d1a 249) size_t len = min_len + (my_random() % (max_len + 1 - min_len));
a62f9d1a 251) names[i] = xmallocz(len);
a62f9d1a 252) while (len > 0)
a62f9d1a 253) names[i][--len] = (char)(' ' + (my_random() % ('\x7f' - ' ')));
a62f9d1a 256) for (protect_ntfs = 0; protect_ntfs < 2; protect_ntfs++)
a62f9d1a 257) for (protect_hfs = 0; protect_hfs < 2; protect_hfs++) {
a62f9d1a 258) cumul = 0;
a62f9d1a 259) cumul2 = 0;
a62f9d1a 260) for (i = 0; i < repetitions; i++) {
a62f9d1a 261) begin = getnanotime();
a62f9d1a 262) for (j = 0; j < nr; j++)
a62f9d1a 263) verify_path(names[j], file_mode);
a62f9d1a 264) end = getnanotime();
a62f9d1a 265) printf("protect_ntfs = %d, protect_hfs = %d: %lfms\n", protect_ntfs, protect_hfs, (end-begin) / (double)1e6);
a62f9d1a 266) cumul += end - begin;
a62f9d1a 267) cumul2 += (end - begin) * (end - begin);
a62f9d1a 269) m[protect_ntfs][protect_hfs] = cumul / (double)repetitions;
a62f9d1a 270) v[protect_ntfs][protect_hfs] = my_sqrt(cumul2 / (double)repetitions - m[protect_ntfs][protect_hfs] * m[protect_ntfs][protect_hfs]);
a62f9d1a 271) printf("mean: %lfms, stddev: %lfms\n", m[protect_ntfs][protect_hfs] / (double)1e6, v[protect_ntfs][protect_hfs] / (double)1e6);
a62f9d1a 274) for (protect_ntfs = 0; protect_ntfs < 2; protect_ntfs++)
a62f9d1a 275) for (protect_hfs = 0; protect_hfs < 2; protect_hfs++)
a62f9d1a 276) printf("ntfs=%d/hfs=%d: %lf%% slower\n", protect_ntfs, protect_hfs, (m[protect_ntfs][protect_hfs] - m[0][0]) * 100 / m[0][0]);
a62f9d1a 278) return 0;
a62f9d1a 451) if (argc > 1 && !strcmp(argv[1], "protect_ntfs_hfs"))
a62f9d1a 452) return !!protect_ntfs_hfs_benchmark(argc - 1, argv + 1);

Garima Singh	ad155925 tests: add a helper to stress test argument quoting
t/helper/test-run-command.c
ad155925 205) static uint64_t my_random(void)
ad155925 207) uint64_t res = my_random_next;
ad155925 208) my_random_next = my_random_next * 1103515245 + 12345;
ad155925 209) return res;
ad155925 212) static int quote_stress_test(int argc, const char **argv)
ad155925 220) char special[] = ".?*\\^_\"'`{}()[]<>@~&+:;$%"; // \t\r\n\a";
ad155925 222) struct strbuf out = STRBUF_INIT;
ad155925 223) struct argv_array args = ARGV_ARRAY_INIT;
ad155925 224) struct option options[] = {
ad155925 230) const char * const usage[] = {
ad155925 235) argc = parse_options(argc, argv, NULL, options, usage, 0);
ad155925 239) for (i = 0; i < trials; i++) {
ad155925 240) struct child_process cp = CHILD_PROCESS_INIT;
ad155925 242) int ret = 0;
ad155925 244) argv_array_clear(&args);
ad155925 251) arg_offset = args.argc;
ad155925 278) cp.argv = args.argv;
ad155925 279) strbuf_reset(&out);
ad155925 280) if (pipe_command(&cp, NULL, 0, &out, 0, NULL, 0) < 0)
ad155925 283) for (j = 0, k = 0; j < arg_count; j++) {
ad155925 284) const char *arg = args.argv[j + arg_offset];
ad155925 286) if (strcmp(arg, out.buf + k))
ad155925 290) k += strlen(out.buf + k) + 1;
ad155925 293) if (k != out.len)
ad155925 297) if (ret) {
ad155925 298) fprintf(stderr, "Trial #%d failed. Arguments:\n", i);
ad155925 299) for (j = 0; j < arg_count; j++)
ad155925 300) fprintf(stderr, "arg #%d: '%s'\n",
ad155925 301) (int)j, args.argv[j + arg_offset]);
ad155925 303) strbuf_release(&out);
ad155925 304) argv_array_clear(&args);
ad155925 306) return ret;
ad155925 309) if (i && (i % 100) == 0)
ad155925 310) fprintf(stderr, "Trials completed: %d\n", (int)i);
ad155925 313) strbuf_release(&out);
ad155925 314) argv_array_clear(&args);
ad155925 316) return 0;
ad155925 319) static int quote_echo(int argc, const char **argv)
ad155925 321) while (argc > 1) {
ad155925 322) fwrite(argv[1], strlen(argv[1]), 1, stdout);
ad155925 323) fputc('\0', stdout);
ad155925 324) argv++;
ad155925 325) argc--;
ad155925 328) return 0;
ad155925 384) return !!quote_stress_test(argc - 1, argv + 1);
ad155925 387) return !!quote_echo(argc - 1, argv + 1);

Hans Jerry Illikainen	72b006f4 gpg-interface: prefer check_signature() for GPG verification
builtin/fmt-merge-msg.c
72b006f4 511) strbuf_addstr(&sig, "gpg verification failed.\n");

gpg-interface.c
72b006f4 223) return error_errno(_("could not create temporary file"));
72b006f4 226) error_errno(_("failed writing detached signature to '%s'"),
72b006f4 228) delete_tempfile(&temp);
72b006f4 229) return -1;
72b006f4 244) gpg_status = &buf;

log-tree.c
72b006f4 461) show_sig_lines(opt, status, "No signature\n");
72b006f4 535) } else if (verify_message.len <= gpg_message_offset)

Jeff King	01968302 fast-import: delay creating leading directories for export-marks
fast-import.c
01968302 1687) failure |= error_errno("unable to create leading directories of %s",
01968302 1689) return;

Johannes Schindelin	55953c77 quote-stress-test: accept arguments to test via the command-line
t/helper/test-run-command.c
55953c77 253) if (argc > 0) {
55953c77 254) trials = 1;
55953c77 255) arg_count = argc;
55953c77 256) for (j = 0; j < arg_count; j++)
55953c77 257) argv_array_push(&args, argv[j]);
55953c77 259) arg_count = 1 + (my_random() % 5);
55953c77 260) for (j = 0; j < arg_count; j++) {
55953c77 262) size_t min_len = 1;
55953c77 263) size_t arg_len = min_len +
55953c77 264) (my_random() % (ARRAY_SIZE(buf) - min_len));
55953c77 266) for (k = 0; k < arg_len; k++)
55953c77 267) buf[k] = special[my_random() %
55953c77 269) buf[arg_len] = '\0';
55953c77 271) argv_array_push(&args, buf);

Johannes Schindelin	14af7ed5 Sync with 2.17.3
t/helper/test-run-command.c
14af7ed5 249) argv_array_pushl(&args, "test-tool", "run-command",

Johannes Schindelin	379e51d1 quote-stress-test: offer to test quoting arguments for MSYS2 sh
t/helper/test-run-command.c
379e51d1 221) int i, j, k, trials = 100, skip = 0, msys2 = 0;
379e51d1 237) setenv("MSYS_NO_PATHCONV", "1", 0);
379e51d1 245) if (msys2)
379e51d1 246) argv_array_pushl(&args, "sh", "-c",

Johannes Schindelin	d2c84dad mingw: refuse to access paths with trailing spaces or periods
t/helper/test-path-utils.c
d2c84dad 454) if (argc > 1 && !strcmp(argv[1], "is_valid_path")) {
d2c84dad 455) int res = 0, expect = 1, i;
d2c84dad 457) for (i = 2; i < argc; i++)
d2c84dad 458) if (!strcmp("--not", argv[i]))
d2c84dad 459) expect = 0;
d2c84dad 460) else if (expect != is_valid_path(argv[i]))
d2c84dad 464) fprintf(stderr,
d2c84dad 466) argv[i], expect ? "" : " not");
d2c84dad 468) return !!res;

Johannes Schindelin	eea4a7f4 mingw: demonstrate that all file handles are inherited by child processes
t/helper/test-run-command.c
eea4a7f4 331) static int inherit_handle(const char *argv0)
eea4a7f4 333) struct child_process cp = CHILD_PROCESS_INIT;
eea4a7f4 338) xsnprintf(path, sizeof(path), "out-XXXXXX");
eea4a7f4 339) tmp = xmkstemp(path);
eea4a7f4 341) argv_array_pushl(&cp.args,
eea4a7f4 343) cp.in = -1;
eea4a7f4 344) cp.no_stdout = cp.no_stderr = 1;
eea4a7f4 345) if (start_command(&cp) < 0)
eea4a7f4 349) close(tmp);
eea4a7f4 350) if (unlink(path))
eea4a7f4 353) if (close(cp.in) < 0 || finish_command(&cp) < 0)
eea4a7f4 356) return 0;
eea4a7f4 359) static int inherit_handle_child(void)
eea4a7f4 361) struct strbuf buf = STRBUF_INIT;
eea4a7f4 363) if (strbuf_read(&buf, 0, 0) < 0)
eea4a7f4 365) printf("Received %s\n", buf.buf);
eea4a7f4 366) strbuf_release(&buf);
eea4a7f4 368) return 0;
eea4a7f4 379) exit(inherit_handle(argv[0]));
eea4a7f4 381) exit(inherit_handle_child());

Johannes Schindelin	cc756edd unpack-trees: let merged_entry() pass through do_add_entry()'s errors
unpack-trees.c
cc756edd 2067) return -1;

Johannes Schindelin	288a74bc is_ntfs_dotgit(): only verify the leading segment
read-cache.c
288a74bc 1001) if (is_ntfs_dotgitmodules(path))
288a74bc 1002) return 0;

Johannes Schindelin	7530a628 quote-stress-test: allow skipping some trials
t/helper/test-run-command.c
7530a628 275) if (i < skip)
7530a628 276) continue;

Johannes Schindelin	f37c2264 built-in add -i: prepare for multi-selection commands
add-interactive.c
f37c2264 88) FREE_AND_NULL(list->selected);
f37c2264 195) static void list(struct add_i_state *s, struct string_list *list, int *selected,
f37c2264 208) opts->print_item(i, selected ? selected[i] : 0, list->items + i,
f37c2264 249) int singleton = opts->flags & SINGLETON;
f37c2264 250) int immediate = opts->flags & IMMEDIATE;
f37c2264 253) ssize_t res = singleton ? LIST_AND_CHOOSE_ERROR : 0;
f37c2264 255) if (!singleton) {
f37c2264 256) free(items->selected);
f37c2264 257) CALLOC_ARRAY(items->selected, items->items.nr);
f37c2264 260) if (singleton && !immediate)
f37c2264 270) list(s, &items->items, items->selected, &opts->list_opts);
f37c2264 273) fputs(singleton ? "> " : ">> ", stdout);
f37c2264 278) if (immediate)
f37c2264 279) res = LIST_AND_CHOOSE_QUIT;
f37c2264 295) int choose = 1;
f37c2264 297) ssize_t from = -1, to = -1;
f37c2264 307) if (*p == '-') {
f37c2264 308) choose = 0;
f37c2264 309) p++;
f37c2264 310) sep--;
f37c2264 313) if (sep == 1 && *p == '*') {
f37c2264 314) from = 0;
f37c2264 315) to = items->items.nr;
f37c2264 316) } else if (isdigit(*p)) {
f37c2264 327) from = strtoul(p, &endp, 10) - 1;
f37c2264 328) if (endp == p + sep)
f37c2264 329) to = from + 1;
f37c2264 330) else if (*endp == '-') {
f37c2264 331) to = strtoul(++endp, &endp, 10);
f37c2264 333) if (endp != p + sep)
f37c2264 334) from = -1;
f37c2264 340) if (from < 0) {
f37c2264 341) from = find_unique(p, items);
f37c2264 342) if (from >= 0)
f37c2264 343) to = from + 1;
f37c2264 346) if (from < 0 || from >= items->items.nr ||
f37c2264 347)     (singleton && from + 1 != to)) {
f37c2264 350) break;
f37c2264 351) } else if (singleton) {
f37c2264 352) res = from;
f37c2264 356) if (to > items->items.nr)
f37c2264 357) to = items->items.nr;
f37c2264 359) for (; from < to; from++)
f37c2264 360) if (items->selected[from] != choose) {
f37c2264 361) items->selected[from] = choose;
f37c2264 362) res += choose ? +1 : -1;
f37c2264 368) if ((immediate && res != LIST_AND_CHOOSE_ERROR) ||
f37c2264 369)     !strcmp(input.buf, "*"))
f37c2264 588) static void print_file_item(int i, int selected, struct string_list_item *item,
f37c2264 621) printf("%c%2d: %s", selected ? '*' : ' ', i + 1, d->buf.buf);
f37c2264 1028) static void print_command_item(int i, int selected,

Johannes Schindelin	bdfef049 Sync with 2.16.6
fsck.c
bdfef049 627) if (!S_ISLNK(mode))
bdfef049 628) oidset_insert(&gitmodules_found, oid);

Johannes Schindelin	c08171d1 built-in add -i: allow filtering the modified files list
add-interactive.c
c08171d1 447) if (s->skip_unseen)
c08171d1 448) continue;
c08171d1 460) adddel = s->mode == FROM_INDEX ?
c08171d1 487) static int get_modified_files(struct repository *r,
c08171d1 497) struct collection_status s = { 0 };
c08171d1 508) for (i = 0; i < 2; i++) {
c08171d1 512) if (filter == INDEX_ONLY)
c08171d1 513) s.mode = (i == 0) ? FROM_INDEX : FROM_WORKTREE;
c08171d1 515) s.mode = (i == 0) ? FROM_WORKTREE : FROM_INDEX;
c08171d1 516) s.skip_unseen = filter && i;
c08171d1 531) if (s.mode == FROM_INDEX)

Johannes Schindelin	8746e072 built-in add -i: implement the `patch` command
add-interactive.c
8746e072 462) other_adddel = s->mode == FROM_INDEX ?
8746e072 463) &file_item->worktree : &file_item->index;
8746e072 467) if (stat.files[i]->is_binary) {
8746e072 468) if (!other_adddel->binary)
8746e072 469) s->binary_count++;
8746e072 472) if (stat.files[i]->is_unmerged) {
8746e072 473) if (!other_adddel->unmerged)
8746e072 474) s->unmerged_count++;
8746e072 475) adddel->unmerged = 1;
8746e072 542) if (unmerged_count)
8746e072 543) *unmerged_count = s.unmerged_count;
8746e072 544) if (binary_count)
8746e072 545) *binary_count = s.binary_count;
8746e072 628) if (get_modified_files(s->r, NO_FILTER, files, ps, NULL, NULL) < 0)
8746e072 645) if (get_modified_files(s->r, WORKTREE_ONLY, files, ps, NULL, NULL) < 0)
8746e072 724) if (get_modified_files(s->r, INDEX_ONLY, files, ps, NULL, NULL) < 0)
8746e072 876) static int run_patch(struct add_i_state *s, const struct pathspec *ps,
8746e072 880) int res = 0;
8746e072 882) size_t unmerged_count = 0, binary_count = 0;
8746e072 884) if (get_modified_files(s->r, WORKTREE_ONLY, files, ps,
8746e072 886) return -1;
8746e072 888) if (unmerged_count || binary_count) {
8746e072 889) for (i = j = 0; i < files->items.nr; i++) {
8746e072 890) struct file_item *item = files->items.items[i].util;
8746e072 892) if (item->index.binary || item->worktree.binary) {
8746e072 893) free(item);
8746e072 894) free(files->items.items[i].string);
8746e072 895) } else if (item->index.unmerged ||
8746e072 897) color_fprintf_ln(stderr, s->error_color,
8746e072 899)  files->items.items[i].string);
8746e072 900) free(item);
8746e072 901) free(files->items.items[i].string);
8746e072 903) files->items.items[j++] = files->items.items[i];
8746e072 905) files->items.nr = j;
8746e072 908) if (!files->items.nr) {
8746e072 909) if (binary_count)
8746e072 910) fprintf(stderr, _("Only binary files changed.\n"));
8746e072 912) fprintf(stderr, _("No changes.\n"));
8746e072 913) return 0;
8746e072 916) opts->prompt = N_("Patch update");
8746e072 917) count = list_and_choose(s, files, opts);
8746e072 918) if (count >= 0) {
8746e072 919) struct argv_array args = ARGV_ARRAY_INIT;
8746e072 921) argv_array_pushl(&args, "git", "add--interactive", "--patch",
8746e072 923) for (i = 0; i < files->items.nr; i++)
8746e072 924) if (files->selected[i])
8746e072 925) argv_array_push(&args,
8746e072 926) files->items.items[i].string);
8746e072 927) res = run_command_v_opt(args.argv, 0);
8746e072 928) argv_array_clear(&args);
8746e072 931) return res;

Johannes Schindelin	a8c45be9 built-in add -i: implement the `update` command
add-interactive.c
a8c45be9 504) prefix_item_list_clear(files);
a8c45be9 505) s.files = &files->items;
a8c45be9 548) string_list_sort(&files->items);
a8c45be9 593) const char *highlighted = NULL;
a8c45be9 600) if (c->prefix_length > 0 &&
a8c45be9 601)     is_valid_prefix(item->string, c->prefix_length)) {
a8c45be9 602) strbuf_reset(&d->name);
a8c45be9 603) strbuf_addf(&d->name, "%s%.*s%s%s", d->color,
a8c45be9 604)     (int)c->prefix_length, item->string, d->reset,
a8c45be9 605)     item->string + c->prefix_length);
a8c45be9 606) highlighted = d->name.buf;
a8c45be9 618) strbuf_addf(&d->buf, d->modified_fmt, d->index.buf, d->worktree.buf,
a8c45be9 631) list(s, &files->items, NULL, &opts->list_opts);
a8c45be9 637) static int run_update(struct add_i_state *s, const struct pathspec *ps,
a8c45be9 641) int res = 0, fd;
a8c45be9 648) if (!files->items.nr) {
a8c45be9 649) putchar('\n');
a8c45be9 650) return 0;
a8c45be9 653) opts->prompt = N_("Update");
a8c45be9 654) count = list_and_choose(s, files, opts);
a8c45be9 655) if (count <= 0) {
a8c45be9 656) putchar('\n');
a8c45be9 657) return 0;
a8c45be9 660) fd = repo_hold_locked_index(s->r, &index_lock, LOCK_REPORT_ON_ERROR);
a8c45be9 661) if (fd < 0) {
a8c45be9 662) putchar('\n');
a8c45be9 663) return -1;
a8c45be9 666) for (i = 0; i < files->items.nr; i++) {
a8c45be9 667) const char *name = files->items.items[i].string;
a8c45be9 668) if (files->selected[i] &&
a8c45be9 669)     add_file_to_index(s->r->index, name, 0) < 0) {
a8c45be9 671) break;
a8c45be9 675) if (!res && write_locked_index(s->r->index, &index_lock, COMMIT_LOCK) < 0)
a8c45be9 678) if (!res)
a8c45be9 679) printf(Q_("updated %d path\n",
a8c45be9 682) putchar('\n');
a8c45be9 683) return res;
a8c45be9 995) static void choose_prompt_help(struct add_i_state *s)
a8c45be9 997) color_fprintf_ln(stdout, s->help_color, "%s",
a8c45be9 999) color_fprintf_ln(stdout, s->help_color, "1          - %s",
a8c45be9 1001) color_fprintf_ln(stdout, s->help_color, "3-5        - %s",
a8c45be9 1003) color_fprintf_ln(stdout, s->help_color, "2-3,6-9    - %s",
a8c45be9 1005) color_fprintf_ln(stdout, s->help_color, "foo        - %s",
a8c45be9 1007) color_fprintf_ln(stdout, s->help_color, "-...       - %s",
a8c45be9 1009) color_fprintf_ln(stdout, s->help_color, "*          - %s",
a8c45be9 1011) color_fprintf_ln(stdout, s->help_color, "           - %s",
a8c45be9 1013) }
a8c45be9 1083) struct list_and_choose_options opts = {
a8c45be9 1088) struct prefix_item_list files = PREFIX_ITEM_LIST_INIT;
a8c45be9 1109) print_file_item_data.color = data.color;
a8c45be9 1110) print_file_item_data.reset = data.reset;
a8c45be9 1115) opts.list_opts.header = header.buf;
a8c45be9 1144) prefix_item_list_clear(&files);
a8c45be9 1146) strbuf_release(&print_file_item_data.name);

Johannes Schindelin	0c3944a6 add-interactive: make sure to release `rev.prune_data`
add-interactive.c
0c3944a6 538) if (ps)
0c3944a6 539) clear_pathspec(&rev.prune_data);

Johannes Schindelin	ab1e1ccc built-in add -i: re-implement `add-untracked` in C
add-interactive.c
ab1e1ccc 609) if (d->only_names) {
ab1e1ccc 610) printf("%c%2d: %s", selected ? '*' : ' ', i + 1,
ab1e1ccc 612) return;
ab1e1ccc 794) static int get_untracked_files(struct repository *r,
ab1e1ccc 798) struct dir_struct dir = { 0 };
ab1e1ccc 800) struct strbuf buf = STRBUF_INIT;
ab1e1ccc 802) if (repo_read_index(r) < 0)
ab1e1ccc 805) prefix_item_list_clear(files);
ab1e1ccc 806) setup_standard_excludes(&dir);
ab1e1ccc 807) add_pattern_list(&dir, EXC_CMDL, "--exclude option");
ab1e1ccc 808) fill_directory(&dir, r->index, ps);
ab1e1ccc 810) for (i = 0; i < dir.nr; i++) {
ab1e1ccc 811) struct dir_entry *ent = dir.entries[i];
ab1e1ccc 813) if (index_name_is_other(r->index, ent->name, ent->len)) {
ab1e1ccc 814) strbuf_reset(&buf);
ab1e1ccc 815) strbuf_add(&buf, ent->name, ent->len);
ab1e1ccc 816) add_file_item(&files->items, buf.buf);
ab1e1ccc 820) strbuf_release(&buf);
ab1e1ccc 824) static int run_add_untracked(struct add_i_state *s, const struct pathspec *ps,
ab1e1ccc 828) struct print_file_item_data *d = opts->list_opts.print_item_data;
ab1e1ccc 829) int res = 0, fd;
ab1e1ccc 833) if (get_untracked_files(s->r, files, ps) < 0)
ab1e1ccc 834) return -1;
ab1e1ccc 836) if (!files->items.nr) {
ab1e1ccc 837) printf(_("No untracked files.\n"));
ab1e1ccc 838) goto finish_add_untracked;
ab1e1ccc 841) opts->prompt = N_("Add untracked");
ab1e1ccc 842) d->only_names = 1;
ab1e1ccc 843) count = list_and_choose(s, files, opts);
ab1e1ccc 844) d->only_names = 0;
ab1e1ccc 845) if (count <= 0)
ab1e1ccc 846) goto finish_add_untracked;
ab1e1ccc 848) fd = repo_hold_locked_index(s->r, &index_lock, LOCK_REPORT_ON_ERROR);
ab1e1ccc 849) if (fd < 0) {
ab1e1ccc 850) res = -1;
ab1e1ccc 851) goto finish_add_untracked;
ab1e1ccc 854) for (i = 0; i < files->items.nr; i++) {
ab1e1ccc 855) const char *name = files->items.items[i].string;
ab1e1ccc 856) if (files->selected[i] &&
ab1e1ccc 857)     add_file_to_index(s->r->index, name, 0) < 0) {
ab1e1ccc 859) break;
ab1e1ccc 863) if (!res &&
ab1e1ccc 864)     write_locked_index(s->r->index, &index_lock, COMMIT_LOCK) < 0)
ab1e1ccc 867) if (!res)
ab1e1ccc 868) printf(Q_("added %d path\n",
ab1e1ccc 872) putchar('\n');
ab1e1ccc 873) return res;

Johannes Schindelin	c54ef5e4 built-in add -i: re-implement `revert` in C
add-interactive.c
c54ef5e4 686) static void revert_from_diff(struct diff_queue_struct *q,
c54ef5e4 689) int i, add_flags = ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE;
c54ef5e4 691) for (i = 0; i < q->nr; i++) {
c54ef5e4 692) struct diff_filespec *one = q->queue[i]->one;
c54ef5e4 695) if (!(one->mode && !is_null_oid(&one->oid))) {
c54ef5e4 696) remove_file_from_index(opt->repo->index, one->path);
c54ef5e4 697) printf(_("note: %s is untracked now.\n"), one->path);
c54ef5e4 699) ce = make_cache_entry(opt->repo->index, one->mode,
c54ef5e4 700)       &one->oid, one->path, 0, 0);
c54ef5e4 701) if (!ce)
c54ef5e4 704) add_index_entry(opt->repo->index, ce, add_flags);
c54ef5e4 707) }
c54ef5e4 709) static int run_revert(struct add_i_state *s, const struct pathspec *ps,
c54ef5e4 713) int res = 0, fd;
c54ef5e4 717) int is_initial = !resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, &oid,
c54ef5e4 722) struct diff_options diffopt = { NULL };
c54ef5e4 725) return -1;
c54ef5e4 727) if (!files->items.nr) {
c54ef5e4 728) putchar('\n');
c54ef5e4 729) return 0;
c54ef5e4 732) opts->prompt = N_("Revert");
c54ef5e4 733) count = list_and_choose(s, files, opts);
c54ef5e4 734) if (count <= 0)
c54ef5e4 735) goto finish_revert;
c54ef5e4 737) fd = repo_hold_locked_index(s->r, &index_lock, LOCK_REPORT_ON_ERROR);
c54ef5e4 738) if (fd < 0) {
c54ef5e4 739) res = -1;
c54ef5e4 740) goto finish_revert;
c54ef5e4 743) if (is_initial)
c54ef5e4 744) oidcpy(&oid, s->r->hash_algo->empty_tree);
c54ef5e4 746) tree = parse_tree_indirect(&oid);
c54ef5e4 747) if (!tree) {
c54ef5e4 749) goto finish_revert;
c54ef5e4 751) oidcpy(&oid, &tree->object.oid);
c54ef5e4 754) ALLOC_ARRAY(paths, count + 1);
c54ef5e4 755) for (i = j = 0; i < files->items.nr; i++)
c54ef5e4 756) if (files->selected[i])
c54ef5e4 757) paths[j++] = files->items.items[i].string;
c54ef5e4 758) paths[j] = NULL;
c54ef5e4 760) parse_pathspec(&diffopt.pathspec, 0,
c54ef5e4 764) diffopt.output_format = DIFF_FORMAT_CALLBACK;
c54ef5e4 765) diffopt.format_callback = revert_from_diff;
c54ef5e4 766) diffopt.flags.override_submodule_config = 1;
c54ef5e4 767) diffopt.repo = s->r;
c54ef5e4 769) if (do_diff_cache(&oid, &diffopt))
c54ef5e4 770) res = -1;
c54ef5e4 772) diffcore_std(&diffopt);
c54ef5e4 773) diff_flush(&diffopt);
c54ef5e4 775) free(paths);
c54ef5e4 776) clear_pathspec(&diffopt.pathspec);
c54ef5e4 778) if (!res && write_locked_index(s->r->index, &index_lock,
c54ef5e4 780) res = -1;
c54ef5e4 782) res = repo_refresh_and_write_index(s->r, REFRESH_QUIET, 0, 1,
c54ef5e4 785) if (!res)
c54ef5e4 786) printf(Q_("reverted %d path\n",
c54ef5e4 791) return res;

Johannes Schindelin	d7633578 built-in add -i: re-implement the `diff` command
add-interactive.c
d7633578 934) static int run_diff(struct add_i_state *s, const struct pathspec *ps,
d7633578 938) int res = 0;
d7633578 942) int is_initial = !resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, &oid,
d7633578 944) if (get_modified_files(s->r, INDEX_ONLY, files, ps, NULL, NULL) < 0)
d7633578 945) return -1;
d7633578 947) if (!files->items.nr) {
d7633578 948) putchar('\n');
d7633578 949) return 0;
d7633578 952) opts->prompt = N_("Review diff");
d7633578 953) opts->flags = IMMEDIATE;
d7633578 954) count = list_and_choose(s, files, opts);
d7633578 955) opts->flags = 0;
d7633578 956) if (count >= 0) {
d7633578 957) struct argv_array args = ARGV_ARRAY_INIT;
d7633578 959) argv_array_pushl(&args, "git", "diff", "-p", "--cached",
d7633578 961)     s->r->hash_algo->empty_tree),
d7633578 963) for (i = 0; i < files->items.nr; i++)
d7633578 964) if (files->selected[i])
d7633578 965) argv_array_push(&args,
d7633578 966) files->items.items[i].string);
d7633578 967) res = run_command_v_opt(args.argv, 0);
d7633578 968) argv_array_clear(&args);
d7633578 971) putchar('\n');
d7633578 972) return res;

Johannes Schindelin	b4bbbbd5 apply --allow-overlap: fix a corner case
apply.c
b4bbbbd5 2672) match_beginning = 0;

Johannes Schindelin	2e697ced built-in add -i: offer the `quit` command
add-interactive.c
2e697ced 1129) if (i < 0 || i >= commands.items.nr)
2e697ced 1130) util = NULL;
2e697ced 1132) util = commands.items.items[i].util;
2e697ced 1134) if (i == LIST_AND_CHOOSE_QUIT || (util && !util->command)) {
2e697ced 1140) if (util)

Jonathan Nieder	c1547450 submodule: defend against submodule.update = !command in .gitmodules
builtin/submodule--helper.c
c1547450 1501) if (sub->update_strategy.type == SM_UPDATE_COMMAND)

Junio C Hamano	7034cd09 Sync with Git 2.24.1
fsck.c
7034cd09 630) retval += report(options, oid, OBJ_TREE,

René Scharfe	0bb313a5 xdiff: unignore changes in function context
xdiff/xemit.c
0bb313a5 223)        xchp->i1 + xchp->chg1 <= s1 &&
0bb313a5 224)        xchp->i2 + xchp->chg2 <= s2)
0bb313a5 225) xchp = xchp->next;

Rohit Ashiwal	08187b4c rebase -i: support --ignore-date
sequencer.c
08187b4c 903) return NULL;
08187b4c 920) argv_array_pushf(&child->env_array, "GIT_COMMITTER_DATE=%s", date.buf);
08187b4c 1508) res = -1;
08187b4c 1509) goto out;
08187b4c 2608) opts->allow_ff = 0;
08187b4c 2609) opts->ignore_date = 1;
08187b4c 3639) push_dates(&cmd, opts->committer_date_is_author_date);

Rohit Ashiwal	cbd8db17 rebase -i: support --committer-date-is-author-date
sequencer.c
cbd8db17 890) return NULL;
cbd8db17 989) return -1;
cbd8db17 1428) goto out;
cbd8db17 1432) goto out;
cbd8db17 2603) opts->allow_ff = 0;
cbd8db17 2604) opts->committer_date_is_author_date = 1;

Rohit Ashiwal	c068bcc5 sequencer: allow callers of read_author_script() to ignore fields
sequencer.c
c068bcc5 840) free(kv.items[date_i].util);