#define USE_THE_REPOSITORY_VARIABLE

#include "git-compat-util.h"

#include "add-interactive.h"

#include "advice.h"

#include "editor.h"

#include "environment.h"

#include "gettext.h"

#include "object-name.h"

#include "pager.h"

#include "read-cache-ll.h"

#include "repository.h"

#include "strbuf.h"

#include "sigchain.h"

#include "run-command.h"

#include "strvec.h"

#include "pathspec.h"

#include "color.h"

#include "compat/terminal.h"

#include "prompt.h"

enum prompt_mode_type {

  PROMPT_MODE_CHANGE = 0, PROMPT_DELETION, PROMPT_ADDITION, PROMPT_HUNK,

  PROMPT_MODE_MAX, /* must be last */

};

struct patch_mode {

  /*

   * The magic constant 4 is chosen such that all patch modes

   * provide enough space for three command-line arguments followed by a

   * trailing `NULL`.

   */

  const char *diff_cmd[4], *apply_args[4], *apply_check_args[4];

  unsigned is_reverse:1, index_only:1, apply_for_checkout:1;

  const char *prompt_mode[PROMPT_MODE_MAX];

  const char *edit_hunk_hint, *help_patch_text;

};

static struct patch_mode patch_mode_add = {

  .diff_cmd = { "diff-files", NULL },

  .apply_args = { "--cached", NULL },

  .apply_check_args = { "--cached", NULL },

  .prompt_mode = {

    N_("Stage mode change [y,n,q,a,d%s,?]? "),

    N_("Stage deletion [y,n,q,a,d%s,?]? "),

    N_("Stage addition [y,n,q,a,d%s,?]? "),

    N_("Stage this hunk [y,n,q,a,d%s,?]? ")

  },

  .edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "

           "will immediately be marked for staging."),

  .help_patch_text =

    N_("y - stage this hunk\n"

       "n - do not stage this hunk\n"

       "q - quit; do not stage this hunk or any of the remaining "

      "ones\n"

       "a - stage this hunk and all later hunks in the file\n"

       "d - do not stage this hunk or any of the later hunks in "

      "the file\n")

};

static struct patch_mode patch_mode_stash = {

  .diff_cmd = { "diff-index", "HEAD", NULL },

  .apply_args = { "--cached", NULL },

  .apply_check_args = { "--cached", NULL },

  .prompt_mode = {

    N_("Stash mode change [y,n,q,a,d%s,?]? "),

    N_("Stash deletion [y,n,q,a,d%s,?]? "),

    N_("Stash addition [y,n,q,a,d%s,?]? "),

    N_("Stash this hunk [y,n,q,a,d%s,?]? "),

  },

  .edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "

           "will immediately be marked for stashing."),

  .help_patch_text =

    N_("y - stash this hunk\n"

       "n - do not stash this hunk\n"

       "q - quit; do not stash this hunk or any of the remaining "

      "ones\n"

       "a - stash this hunk and all later hunks in the file\n"

       "d - do not stash this hunk or any of the later hunks in "

      "the file\n"),

};

static struct patch_mode patch_mode_reset_head = {

  .diff_cmd = { "diff-index", "--cached", NULL },

  .apply_args = { "-R", "--cached", NULL },

  .apply_check_args = { "-R", "--cached", NULL },

  .is_reverse = 1,

  .index_only = 1,

  .prompt_mode = {

    N_("Unstage mode change [y,n,q,a,d%s,?]? "),

    N_("Unstage deletion [y,n,q,a,d%s,?]? "),

    N_("Unstage addition [y,n,q,a,d%s,?]? "),

    N_("Unstage this hunk [y,n,q,a,d%s,?]? "),

  },

  .edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "

           "will immediately be marked for unstaging."),

  .help_patch_text =

    N_("y - unstage this hunk\n"

       "n - do not unstage this hunk\n"

       "q - quit; do not unstage this hunk or any of the remaining "

      "ones\n"

       "a - unstage this hunk and all later hunks in the file\n"

       "d - do not unstage this hunk or any of the later hunks in "

      "the file\n"),

};

static struct patch_mode patch_mode_reset_nothead = {

  .diff_cmd = { "diff-index", "-R", "--cached", NULL },

  .apply_args = { "--cached", NULL },

  .apply_check_args = { "--cached", NULL },

  .index_only = 1,

  .prompt_mode = {

    N_("Apply mode change to index [y,n,q,a,d%s,?]? "),

    N_("Apply deletion to index [y,n,q,a,d%s,?]? "),

    N_("Apply addition to index [y,n,q,a,d%s,?]? "),

    N_("Apply this hunk to index [y,n,q,a,d%s,?]? "),

  },

  .edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "

           "will immediately be marked for applying."),

  .help_patch_text =

    N_("y - apply this hunk to index\n"

       "n - do not apply this hunk to index\n"

       "q - quit; do not apply this hunk or any of the remaining "

      "ones\n"

       "a - apply this hunk and all later hunks in the file\n"

       "d - do not apply this hunk or any of the later hunks in "

      "the file\n"),

};

static struct patch_mode patch_mode_checkout_index = {

  .diff_cmd = { "diff-files", NULL },

  .apply_args = { "-R", NULL },

  .apply_check_args = { "-R", NULL },

  .is_reverse = 1,

  .prompt_mode = {

    N_("Discard mode change from worktree [y,n,q,a,d%s,?]? "),

    N_("Discard deletion from worktree [y,n,q,a,d%s,?]? "),

    N_("Discard addition from worktree [y,n,q,a,d%s,?]? "),

    N_("Discard this hunk from worktree [y,n,q,a,d%s,?]? "),

  },

  .edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "

           "will immediately be marked for discarding."),

  .help_patch_text =

    N_("y - discard this hunk from worktree\n"

       "n - do not discard this hunk from worktree\n"

       "q - quit; do not discard this hunk or any of the remaining "

      "ones\n"

       "a - discard this hunk and all later hunks in the file\n"

       "d - do not discard this hunk or any of the later hunks in "

      "the file\n"),

};

static struct patch_mode patch_mode_checkout_head = {

  .diff_cmd = { "diff-index", NULL },

  .apply_for_checkout = 1,

  .apply_check_args = { "-R", NULL },

  .is_reverse = 1,

  .prompt_mode = {

    N_("Discard mode change from index and worktree [y,n,q,a,d%s,?]? "),

    N_("Discard deletion from index and worktree [y,n,q,a,d%s,?]? "),

    N_("Discard addition from index and worktree [y,n,q,a,d%s,?]? "),

    N_("Discard this hunk from index and worktree [y,n,q,a,d%s,?]? "),

  },

  .edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "

           "will immediately be marked for discarding."),

  .help_patch_text =

    N_("y - discard this hunk from index and worktree\n"

       "n - do not discard this hunk from index and worktree\n"

       "q - quit; do not discard this hunk or any of the remaining "

      "ones\n"

       "a - discard this hunk and all later hunks in the file\n"

       "d - do not discard this hunk or any of the later hunks in "

      "the file\n"),

};

static struct patch_mode patch_mode_checkout_nothead = {

  .diff_cmd = { "diff-index", "-R", NULL },

  .apply_for_checkout = 1,

  .apply_check_args = { NULL },

  .prompt_mode = {

    N_("Apply mode change to index and worktree [y,n,q,a,d%s,?]? "),

    N_("Apply deletion to index and worktree [y,n,q,a,d%s,?]? "),

    N_("Apply addition to index and worktree [y,n,q,a,d%s,?]? "),

    N_("Apply this hunk to index and worktree [y,n,q,a,d%s,?]? "),

  },

  .edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "

           "will immediately be marked for applying."),

  .help_patch_text =

    N_("y - apply this hunk to index and worktree\n"

       "n - do not apply this hunk to index and worktree\n"

       "q - quit; do not apply this hunk or any of the remaining "

      "ones\n"

       "a - apply this hunk and all later hunks in the file\n"

       "d - do not apply this hunk or any of the later hunks in "

      "the file\n"),

};

static struct patch_mode patch_mode_worktree_head = {

  .diff_cmd = { "diff-index", NULL },

  .apply_args = { "-R", NULL },

  .apply_check_args = { "-R", NULL },

  .is_reverse = 1,

  .prompt_mode = {

    N_("Discard mode change from worktree [y,n,q,a,d%s,?]? "),

    N_("Discard deletion from worktree [y,n,q,a,d%s,?]? "),

    N_("Discard addition from worktree [y,n,q,a,d%s,?]? "),

    N_("Discard this hunk from worktree [y,n,q,a,d%s,?]? "),

  },

  .edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "

           "will immediately be marked for discarding."),

  .help_patch_text =

    N_("y - discard this hunk from worktree\n"

       "n - do not discard this hunk from worktree\n"

       "q - quit; do not discard this hunk or any of the remaining "

      "ones\n"

       "a - discard this hunk and all later hunks in the file\n"

       "d - do not discard this hunk or any of the later hunks in "

      "the file\n"),

};

static struct patch_mode patch_mode_worktree_nothead = {

  .diff_cmd = { "diff-index", "-R", NULL },

  .apply_args = { NULL },

  .apply_check_args = { NULL },

  .prompt_mode = {

    N_("Apply mode change to worktree [y,n,q,a,d%s,?]? "),

    N_("Apply deletion to worktree [y,n,q,a,d%s,?]? "),

    N_("Apply addition to worktree [y,n,q,a,d%s,?]? "),

    N_("Apply this hunk to worktree [y,n,q,a,d%s,?]? "),

  },

  .edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "

           "will immediately be marked for applying."),

  .help_patch_text =

    N_("y - apply this hunk to worktree\n"

       "n - do not apply this hunk to worktree\n"

       "q - quit; do not apply this hunk or any of the remaining "

      "ones\n"

       "a - apply this hunk and all later hunks in the file\n"

       "d - do not apply this hunk or any of the later hunks in "

      "the file\n"),

};

struct hunk_header {

  unsigned long old_offset, old_count, new_offset, new_count;

  /*

   * Start/end offsets to the extra text after the second `@@` in the

   * hunk header, e.g. the function signature. This is expected to

   * include the newline.

   */

  size_t extra_start, extra_end, colored_extra_start, colored_extra_end;

  unsigned suppress_colored_line_range:1;

};

struct hunk {

  size_t start, end, colored_start, colored_end, splittable_into;

  ssize_t delta;

  enum { UNDECIDED_HUNK = 0, SKIP_HUNK, USE_HUNK } use;

  struct hunk_header header;

};

struct add_p_state {

  struct add_i_state s;

  struct strbuf answer, buf;

  /* parsed diff */

  struct strbuf plain, colored;

  struct file_diff {

    struct hunk head;

    struct hunk *hunk;

    size_t hunk_nr, hunk_alloc;

    unsigned deleted:1, added:1, mode_change:1,binary:1;

  } *file_diff;

  size_t file_diff_nr;

  /* patch mode */

  struct patch_mode *mode;

  const char *revision;

};

static void add_p_state_clear(struct add_p_state *s)

{

  size_t i;

  strbuf_release(&s->answer);

  strbuf_release(&s->buf);

  strbuf_release(&s->plain);

  strbuf_release(&s->colored);

  for (i = 0; i < s->file_diff_nr; i++)

    free(s->file_diff[i].hunk);

  free(s->file_diff);

  clear_add_i_state(&s->s);

}

__attribute__((format (printf, 2, 3)))

static void err(struct add_p_state *s, const char *fmt, ...)

{

  va_list args;

  va_start(args, fmt);

  fputs(s->s.error_color, stdout);

  vprintf(fmt, args);

  puts(s->s.reset_color);

  va_end(args);

}

LAST_ARG_MUST_BE_NULL

static void setup_child_process(struct add_p_state *s,

        struct child_process *cp, ...)

{

  va_list ap;

  const char *arg;

  va_start(ap, cp);

  while ((arg = va_arg(ap, const char *)))

    strvec_push(&cp->args, arg);

  va_end(ap);

  cp->git_cmd = 1;

  strvec_pushf(&cp->env,

         INDEX_ENVIRONMENT "=%s", s->s.r->index_file);

}

static int parse_range(const char **p,

           unsigned long *offset, unsigned long *count)

{

  char *pend;

  *offset = strtoul(*p, &pend, 10);

  if (pend == *p)

    return -1;

  if (*pend != ',') {

    *count = 1;

    *p = pend;

    return 0;

  }

  *count = strtoul(pend + 1, (char **)p, 10);

  return *p == pend + 1 ? -1 : 0;

}

static int parse_hunk_header(struct add_p_state *s, struct hunk *hunk)

{

  struct hunk_header *header = &hunk->header;

  const char *line = s->plain.buf + hunk->start, *p = line;

  char *eol = memchr(p, '\n', s->plain.len - hunk->start);

  if (!eol)

    eol = s->plain.buf + s->plain.len;

  if (!skip_prefix(p, "@@ -", &p) ||

      parse_range(&p, &header->old_offset, &header->old_count) < 0 ||

      !skip_prefix(p, " +", &p) ||

      parse_range(&p, &header->new_offset, &header->new_count) < 0 ||

      !skip_prefix(p, " @@", &p))

    return error(_("could not parse hunk header '%.*s'"),

           (int)(eol - line), line);

  hunk->start = eol - s->plain.buf + (*eol == '\n');

  header->extra_start = p - s->plain.buf;

  header->extra_end = hunk->start;

  if (!s->colored.len) {

    header->colored_extra_start = header->colored_extra_end = 0;

    return 0;

  }

  /* Now find the extra text in the colored diff */

  line = s->colored.buf + hunk->colored_start;

  eol = memchr(line, '\n', s->colored.len - hunk->colored_start);

  if (!eol)

    eol = s->colored.buf + s->colored.len;

  p = memmem(line, eol - line, "@@ -", 4);

  if (p && (p = memmem(p + 4, eol - p - 4, " @@", 3))) {

    header->colored_extra_start = p + 3 - s->colored.buf;

  } else {

    /* could not parse colored hunk header, leave as-is */

    header->colored_extra_start = hunk->colored_start;

    header->suppress_colored_line_range = 1;

  }

  hunk->colored_start = eol - s->colored.buf + (*eol == '\n');

  header->colored_extra_end = hunk->colored_start;

  return 0;

}

static int is_octal(const char *p, size_t len)

{

  if (!len)

    return 0;

  while (len--)

    if (*p < '0' || *(p++) > '7')

      return 0;

  return 1;

}

static void complete_file(char marker, struct hunk *hunk)

{

  if (marker == '-' || marker == '+')

    /*

     * Last hunk ended in non-context line (i.e. it

     * appended lines to the file, so there are no

     * trailing context lines).

     */

    hunk->splittable_into++;

}

/* Empty context lines may omit the leading ' ' */

static int normalize_marker(const char *p)

{

  return p[0] == '\n' || (p[0] == '\r' && p[1] == '\n') ? ' ' : p[0];

}

static int parse_diff(struct add_p_state *s, const struct pathspec *ps)

{

  struct strvec args = STRVEC_INIT;

  const char *diff_algorithm = s->s.interactive_diff_algorithm;

  struct strbuf *plain = &s->plain, *colored = NULL;

  struct child_process cp = CHILD_PROCESS_INIT;

  char *p, *pend, *colored_p = NULL, *colored_pend = NULL, marker = '\0';

  size_t file_diff_alloc = 0, i, color_arg_index;

  struct file_diff *file_diff = NULL;

  struct hunk *hunk = NULL;

  int res;

  strvec_pushv(&args, s->mode->diff_cmd);

  if (diff_algorithm)

    strvec_pushf(&args, "--diff-algorithm=%s", diff_algorithm);

  if (s->revision) {

    struct object_id oid;

    strvec_push(&args,

          /* could be on an unborn branch */

          !strcmp("HEAD", s->revision) &&

          repo_get_oid(the_repository, "HEAD", &oid) ?

          empty_tree_oid_hex(the_repository->hash_algo) : s->revision);

  }

  color_arg_index = args.nr;

  /* Use `--no-color` explicitly, just in case `diff.color = always`. */

  strvec_pushl(&args, "--no-color", "--ignore-submodules=dirty", "-p",

         "--", NULL);

  for (i = 0; i < ps->nr; i++)

    strvec_push(&args, ps->items[i].original);

  setup_child_process(s, &cp, NULL);

  strvec_pushv(&cp.args, args.v);

  res = capture_command(&cp, plain, 0);

  if (res) {

    strvec_clear(&args);

    return error(_("could not parse diff"));

  }

  if (!plain->len) {

    strvec_clear(&args);

    return 0;

  }

  strbuf_complete_line(plain);

  if (want_color_fd(1, -1)) {

    struct child_process colored_cp = CHILD_PROCESS_INIT;

    const char *diff_filter = s->s.interactive_diff_filter;

    setup_child_process(s, &colored_cp, NULL);

    xsnprintf((char *)args.v[color_arg_index], 8, "--color");

    strvec_pushv(&colored_cp.args, args.v);

    colored = &s->colored;

    res = capture_command(&colored_cp, colored, 0);

    strvec_clear(&args);

    if (res)

      return error(_("could not parse colored diff"));

    if (diff_filter) {

      struct child_process filter_cp = CHILD_PROCESS_INIT;

      setup_child_process(s, &filter_cp,

              diff_filter, NULL);

      filter_cp.git_cmd = 0;

      filter_cp.use_shell = 1;

      strbuf_reset(&s->buf);

      if (pipe_command(&filter_cp,

           colored->buf, colored->len,

           &s->buf, colored->len,

           NULL, 0) < 0)

        return error(_("failed to run '%s'"),

               diff_filter);

      strbuf_swap(colored, &s->buf);

    }

    strbuf_complete_line(colored);

    colored_p = colored->buf;

    colored_pend = colored_p + colored->len;

  }

  strvec_clear(&args);

  /* parse files and hunks */

  p = plain->buf;

  pend = p + plain->len;

  while (p != pend) {

    char *eol = memchr(p, '\n', pend - p);

    const char *deleted = NULL, *mode_change = NULL;

    char ch = normalize_marker(p);

    if (!eol)

      eol = pend;

    if (starts_with(p, "diff ") ||

        starts_with(p, "* Unmerged path ")) {

      complete_file(marker, hunk);

      ALLOC_GROW_BY(s->file_diff, s->file_diff_nr, 1,

           file_diff_alloc);

      file_diff = s->file_diff + s->file_diff_nr - 1;

      hunk = &file_diff->head;

      hunk->start = p - plain->buf;

      if (colored_p)

        hunk->colored_start = colored_p - colored->buf;

      marker = '\0';

    } else if (p == plain->buf)

      BUG("diff starts with unexpected line:\n"

          "%.*s\n", (int)(eol - p), p);

    else if (file_diff->deleted)

      ; /* keep the rest of the file in a single "hunk" */

    else if (starts_with(p, "@@ ") ||

       (hunk == &file_diff->head &&

        (skip_prefix(p, "deleted file", &deleted)))) {

      if (marker == '-' || marker == '+')

        /*

         * Should not happen; previous hunk did not end

         * in a context line? Handle it anyway.

         */

        hunk->splittable_into++;

      ALLOC_GROW_BY(file_diff->hunk, file_diff->hunk_nr, 1,

           file_diff->hunk_alloc);

      hunk = file_diff->hunk + file_diff->hunk_nr - 1;

      hunk->start = p - plain->buf;

      if (colored)

        hunk->colored_start = colored_p - colored->buf;

      if (deleted)

        file_diff->deleted = 1;

      else if (parse_hunk_header(s, hunk) < 0)

        return -1;

      /*

       * Start counting into how many hunks this one can be

       * split

       */

      marker = ch;

    } else if (hunk == &file_diff->head &&

         starts_with(p, "new file")) {

      file_diff->added = 1;

    } else if (hunk == &file_diff->head &&

         skip_prefix(p, "old mode ", &mode_change) &&

         is_octal(mode_change, eol - mode_change)) {

      if (file_diff->mode_change)

        BUG("double mode change?\n\n%.*s",

            (int)(eol - plain->buf), plain->buf);

      if (file_diff->hunk_nr)

        BUG("mode change in the middle?\n\n%.*s",

            (int)(eol - plain->buf), plain->buf);

      /*

       * Do *not* change `hunk`: the mode change pseudo-hunk

       * is _part of_ the header "hunk".

       */

      file_diff->mode_change = 1;

      ALLOC_GROW_BY(file_diff->hunk, file_diff->hunk_nr, 1,

           file_diff->hunk_alloc);

      file_diff->hunk->start = p - plain->buf;

      if (colored_p)

        file_diff->hunk->colored_start =

          colored_p - colored->buf;

    } else if (hunk == &file_diff->head &&

         skip_prefix(p, "new mode ", &mode_change) &&

         is_octal(mode_change, eol - mode_change)) {

      /*

       * Extend the "mode change" pseudo-hunk to include also

       * the "new mode" line.

       */

      if (!file_diff->mode_change)

        BUG("'new mode' without 'old mode'?\n\n%.*s",

            (int)(eol - plain->buf), plain->buf);

      if (file_diff->hunk_nr != 1)

        BUG("mode change in the middle?\n\n%.*s",

            (int)(eol - plain->buf), plain->buf);

      if (p - plain->buf != file_diff->hunk->end)

        BUG("'new mode' does not immediately follow "

            "'old mode'?\n\n%.*s",

            (int)(eol - plain->buf), plain->buf);

    } else if (hunk == &file_diff->head &&

         starts_with(p, "Binary files "))

      file_diff->binary = 1;

    if (!!file_diff->deleted + !!file_diff->added +

        !!file_diff->mode_change > 1)

      BUG("diff can only contain delete *or* add *or* a "

          "mode change?!?\n%.*s",

          (int)(eol - (plain->buf + file_diff->head.start)),

          plain->buf + file_diff->head.start);

    if ((marker == '-' || marker == '+') && ch == ' ')

      hunk->splittable_into++;

    if (marker && ch != '\\')

      marker = ch;

    p = eol == pend ? pend : eol + 1;

    hunk->end = p - plain->buf;

    if (colored) {

      char *colored_eol = memchr(colored_p, '\n',

               colored_pend - colored_p);

      if (colored_eol)

        colored_p = colored_eol + 1;

      else if (p != pend)

        /* non-colored has more lines? */

        goto mismatched_output;

      else if (colored_p == colored_pend)

        /* last line has no matching colored one? */

        goto mismatched_output;

      else

        colored_p = colored_pend;

      hunk->colored_end = colored_p - colored->buf;

    }

    if (mode_change) {

      if (file_diff->hunk_nr != 1)

        BUG("mode change in hunk #%d???",

            (int)file_diff->hunk_nr);

      /* Adjust the end of the "mode change" pseudo-hunk */

      file_diff->hunk->end = hunk->end;

      if (colored)

        file_diff->hunk->colored_end = hunk->colored_end;

    }

  }

  complete_file(marker, hunk);

  /* non-colored shorter than colored? */

  if (colored_p != colored_pend) {

mismatched_output:

    error(_("mismatched output from interactive.diffFilter"));

    advise(_("Your filter must maintain a one-to-one correspondence\n"

       "between its input and output lines."));

    return -1;

  }

  return 0;

}

static size_t find_next_line(struct strbuf *sb, size_t offset)

{

  char *eol;

  if (offset >= sb->len)

    BUG("looking for next line beyond buffer (%d >= %d)\n%s",

        (int)offset, (int)sb->len, sb->buf);

  eol = memchr(sb->buf + offset, '\n', sb->len - offset);

  if (!eol)

    return sb->len;

  return eol - sb->buf + 1;

}

static void render_hunk(struct add_p_state *s, struct hunk *hunk,

      ssize_t delta, int colored, struct strbuf *out)

{

  struct hunk_header *header = &hunk->header;

  if (hunk->header.old_offset != 0 || hunk->header.new_offset != 0) {

    /*

     * Generate the hunk header dynamically, except for special

     * hunks (such as the diff header).

     */

    const char *p;

    size_t len;

    unsigned long old_offset = header->old_offset;

    unsigned long new_offset = header->new_offset;

    if (!colored) {

      p = s->plain.buf + header->extra_start;

      len = header->extra_end - header->extra_start;

    } else if (header->suppress_colored_line_range) {

      strbuf_add(out,

           s->colored.buf + header->colored_extra_start,

           header->colored_extra_end -

           header->colored_extra_start);

      strbuf_add(out, s->colored.buf + hunk->colored_start,

           hunk->colored_end - hunk->colored_start);

      return;

    } else {

      strbuf_addstr(out, s->s.fraginfo_color);

      p = s->colored.buf + header->colored_extra_start;

      len = header->colored_extra_end

        - header->colored_extra_start;

    }

    if (s->mode->is_reverse)

      old_offset -= delta;

    else

      new_offset += delta;

    strbuf_addf(out, "@@ -%lu", old_offset);

    if (header->old_count != 1)

      strbuf_addf(out, ",%lu", header->old_count);

    strbuf_addf(out, " +%lu", new_offset);

    if (header->new_count != 1)

      strbuf_addf(out, ",%lu", header->new_count);

    strbuf_addstr(out, " @@");

    if (len)

      strbuf_add(out, p, len);

    else if (colored)

      strbuf_addf(out, "%s\n", s->s.reset_color);

    else

      strbuf_addch(out, '\n');

  }

  if (colored)

    strbuf_add(out, s->colored.buf + hunk->colored_start,

         hunk->colored_end - hunk->colored_start);

  else

    strbuf_add(out, s->plain.buf + hunk->start,

         hunk->end - hunk->start);

}

static void render_diff_header(struct add_p_state *s,

             struct file_diff *file_diff, int colored,

             struct strbuf *out)

{

  /*

   * If there was a mode change, the first hunk is a pseudo hunk that

   * corresponds to the mode line in the header. If the user did not want

   * to stage that "hunk", we actually have to cut it out from the header.

   */

  int skip_mode_change =

    file_diff->mode_change && file_diff->hunk->use != USE_HUNK;

  struct hunk *head = &file_diff->head, *first = file_diff->hunk;

  if (!skip_mode_change) {

    render_hunk(s, head, 0, colored, out);

    return;

  }

  if (colored) {

    const char *p = s->colored.buf;

    strbuf_add(out, p + head->colored_start,

          first->colored_start - head->colored_start);

    strbuf_add(out, p + first->colored_end,

          head->colored_end - first->colored_end);

  } else {

    const char *p = s->plain.buf;

    strbuf_add(out, p + head->start, first->start - head->start);

    strbuf_add(out, p + first->end, head->end - first->end);

  }

}

/* Coalesce hunks again that were split */

static int merge_hunks(struct add_p_state *s, struct file_diff *file_diff,

           size_t *hunk_index, int use_all, struct hunk *merged)

{

  size_t i = *hunk_index, delta;

  struct hunk *hunk = file_diff->hunk + i;

  /* `header` corresponds to the merged hunk */

  struct hunk_header *header = &merged->header, *next;

  if (!use_all && hunk->use != USE_HUNK)

    return 0;

  *merged = *hunk;

  /* We simply skip the colored part (if any) when merging hunks */

  merged->colored_start = merged->colored_end = 0;

  for (; i + 1 < file_diff->hunk_nr; i++) {

    hunk++;

    next = &hunk->header;

    /*

     * Stop merging hunks when:

     *

     * - the hunk is not selected for use, or

     * - the hunk does not overlap with the already-merged hunk(s)

     */

    if ((!use_all && hunk->use != USE_HUNK) ||

        header->new_offset >= next->new_offset + merged->delta ||

        header->new_offset + header->new_count

        < next->new_offset + merged->delta)

      break;

    /*

     * If the hunks were not edited, and overlap, we can simply

     * extend the line range.

     */

    if (merged->start < hunk->start && merged->end > hunk->start) {

      merged->end = hunk->end;

      merged->colored_end = hunk->colored_end;

      delta = 0;

    } else {

      const char *plain = s->plain.buf;

      size_t  overlapping_line_count = header->new_offset

        + header->new_count - merged->delta

        - next->new_offset;

      size_t overlap_end = hunk->start;

      size_t overlap_start = overlap_end;

      size_t overlap_next, len, j;

      /*

       * One of the hunks was edited: the modified hunk was

       * appended to the strbuf `s->plain`.

       *

       * Let's ensure that at least the last context line of

       * the first hunk overlaps with the corresponding line

       * of the second hunk, and then merge.

       */

      for (j = 0; j < overlapping_line_count; j++) {

        overlap_next = find_next_line(&s->plain,

                    overlap_end);

        if (overlap_next > hunk->end)

          BUG("failed to find %d context lines "

              "in:\n%.*s",

              (int)overlapping_line_count,

              (int)(hunk->end - hunk->start),

              plain + hunk->start);

        if (normalize_marker(&plain[overlap_end]) != ' ')

          return error(_("expected context line "

                   "#%d in\n%.*s"),

                 (int)(j + 1),

                 (int)(hunk->end

                 - hunk->start),

                 plain + hunk->start);

        overlap_start = overlap_end;

        overlap_end = overlap_next;

      }

      len = overlap_end - overlap_start;

      if (len > merged->end - merged->start ||

          memcmp(plain + merged->end - len,

           plain + overlap_start, len))

        return error(_("hunks do not overlap:\n%.*s\n"

                 "\tdoes not end with:\n%.*s"),

               (int)(merged->end - merged->start),

               plain + merged->start,

               (int)len, plain + overlap_start);

      /*

       * Since the start-end ranges are not adjacent, we

       * cannot simply take the union of the ranges. To

       * address that, we temporarily append the union of the

       * lines to the `plain` strbuf.

       */

      if (merged->end != s->plain.len) {

        size_t start = s->plain.len;

        strbuf_add(&s->plain, plain + merged->start,

             merged->end - merged->start);

        plain = s->plain.buf;

        merged->start = start;

        merged->end = s->plain.len;

      }

      strbuf_add(&s->plain,

           plain + overlap_end,

           hunk->end - overlap_end);

      merged->end = s->plain.len;

      merged->splittable_into += hunk->splittable_into;

      delta = merged->delta;

      merged->delta += hunk->delta;

    }

    header->old_count = next->old_offset + next->old_count

      - header->old_offset;

    header->new_count = next->new_offset + delta

      + next->new_count - header->new_offset;

  }

  if (i == *hunk_index)

    return 0;

  *hunk_index = i;

  return 1;

}

static void reassemble_patch(struct add_p_state *s,

           struct file_diff *file_diff, int use_all,

           struct strbuf *out)

{

  struct hunk *hunk;

  size_t save_len = s->plain.len, i;

  ssize_t delta = 0;

  render_diff_header(s, file_diff, 0, out);

  for (i = file_diff->mode_change; i < file_diff->hunk_nr; i++) {

    struct hunk merged = { 0 };

    hunk = file_diff->hunk + i;

    if (!use_all && hunk->use != USE_HUNK)

      delta += hunk->header.old_count

        - hunk->header.new_count;

    else {

      /* merge overlapping hunks into a temporary hunk */

      if (merge_hunks(s, file_diff, &i, use_all, &merged))

        hunk = &merged;

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

      /*

       * In case `merge_hunks()` used `plain` as a scratch

       * pad (this happens when an edited hunk had to be

       * coalesced with another hunk).

       */

      strbuf_setlen(&s->plain, save_len);

      delta += hunk->delta;

    }

  }

}

static int split_hunk(struct add_p_state *s, struct file_diff *file_diff,

           size_t hunk_index)

{

  int colored = !!s->colored.len, first = 1;

  struct hunk *hunk = file_diff->hunk + hunk_index;

  size_t splittable_into;

  size_t end, colored_end, current, colored_current = 0, context_line_count;

  struct hunk_header remaining, *header;

  char marker, ch;