[PATCH 00/83] libify apply and use lib in am

classic Classic list List threaded Threaded
156 messages Options
1234 ... 8
Reply | Threaded
Open this post in threaded view
|

[PATCH 00/83] libify apply and use lib in am

Christian Couder-2
This is a patch series about libifying `git apply` functionality, and
using this libified functionality in `git am`, so that no 'git apply'
process is spawn anymore. This makes `git am` significantly faster, so
`git rebase`, when it uses the am backend, is also significantly
faster.

This has initially been discussed in the following thread:

http://thread.gmane.org/gmane.comp.version-control.git/287236/

A RFC patch series was sent previously that only got rid of the global
variables and refactored the code around a bit:

http://thread.gmane.org/gmane.comp.version-control.git/288489/

This new patch series is built on top of that previous work, so
patches 1/83 to 47/83 are from the previous RFC patch series and
patches after that are new.

Sorry if this patch series is a bit long. I can split it into two or
more series if it is prefered.

The benefits are not just related to not creating new processes. When
`git am` launched a `git apply` process, this new process had to read
the index from disk. Then after the `git apply`process had terminated,
`git am` dropped its index and read the index from disk to get the
index that had been modified by the `git apply`process. This was
inefficient and also prevented the split-index mechanism to provide
many performance benefits.

Performance numbers:

  - A few days ago Ævar did a huge many-hundred commit rebase on the
    kernel with untracked cache.

command: git rebase --onto 1993b17 52bef0c 29dde7c

Vanilla "next" without split index:                1m54.953s
Vanilla "next" with split index:                   1m22.476s
This series on top of "next" without split index:  1m12.034s
This series on top of "next" with split index:     0m15.678s

Ævar used his Debian laptop with SSD.

  - Some days ago I tested rebasing 13 commits in Booking.com's
    monorepo on a Red Hat 6.5 server with split-index and
    GIT_TRACE_PERFORMANCE=1.

With Git v2.8.0, the rebase took 6.375888383 s, with the git am
command launched by the rebase command taking 3.705677431 s.

With this series on top of next, the rebase took 3.044529494 s, with
the git am command launched by the rebase command taking 0.583521168
s.

No tests on Windows have been performed, but it could be interesting
to test on this platform.

Christian Couder (83):
  builtin/apply: make gitdiff_verify_name() return void
  builtin/apply: avoid parameter shadowing 'p_value' global
  builtin/apply: avoid parameter shadowing 'linenr' global
  builtin/apply: avoid local variable shadowing 'len' parameter
  builtin/apply: extract line_by_line_fuzzy_match() from
    match_fragment()
  builtin/apply: move 'options' variable into cmd_apply()
  builtin/apply: introduce 'struct apply_state' to start libifying
  builtin/apply: move 'unidiff_zero' global into 'struct apply_state'
  builtin/apply: move 'check' global into 'struct apply_state'
  builtin/apply: move 'check_index' global into 'struct apply_state'
  builtin/apply: move 'apply_in_reverse' global into 'struct
    apply_state'
  builtin/apply: move 'apply_with_reject' global into 'struct
    apply_state'
  builtin/apply: move 'apply_verbosely' global into 'struct apply_state'
  builtin/apply: move 'update_index' global into 'struct apply_state'
  builtin/apply: move 'allow_overlap' global into 'struct apply_state'
  builtin/apply: move 'cached' global into 'struct apply_state'
  builtin/apply: move 'diffstat' global into 'struct apply_state'
  builtin/apply: move 'numstat' global into 'struct apply_state'
  builtin/apply: move 'summary' global into 'struct apply_state'
  builtin/apply: move 'threeway' global into 'struct apply_state'
  builtin/apply: move 'no-add' global into 'struct apply_state'
  builtin/apply: move 'unsafe_paths' global into 'struct apply_state'
  builtin/apply: move 'line_termination' global into 'struct
    apply_state'
  builtin/apply: move 'fake_ancestor' global into 'struct apply_state'
  builtin/apply: move 'p_context' global into 'struct apply_state'
  builtin/apply: move 'apply' global into 'struct apply_state'
  builtin/apply: move 'read_stdin' global into cmd_apply()
  builtin/apply: move 'patch_input_file' global into 'struct
    apply_state'
  builtin/apply: move 'limit_by_name' global into 'struct apply_state'
  builtin/apply: move 'has_include' global into 'struct apply_state'
  builtin/apply: move 'p_value' global into 'struct apply_state'
  builtin/apply: move 'p_value_known' global into 'struct apply_state'
  builtin/apply: move 'root' global into 'struct apply_state'
  builtin/apply: move 'whitespace_error' global into 'struct
    apply_state'
  builtin/apply: move 'whitespace_option' into 'struct apply_state'
  builtin/apply: remove whitespace_option arg from
    set_default_whitespace_mode()
  builtin/apply: move 'squelch_whitespace_errors' into 'struct
    apply_state'
  builtin/apply: move 'applied_after_fixing_ws' into 'struct
    apply_state'
  builtin/apply: move 'ws_error_action' into 'struct apply_state'
  builtin/apply: move 'ws_ignore_action' into 'struct apply_state'
  builtin/apply: move 'max_change' and 'max_len' into 'struct
    apply_state'
  builtin/apply: move 'linenr' global into 'struct apply_state'
  builtin/apply: move 'fn_table' global into 'struct apply_state'
  builtin/apply: move 'symlink_changes' global into 'struct apply_state'
  builtin/apply: move 'state' init into init_apply_state()
  builtin/apply: move 'state' check into check_apply_state()
  builtin/apply: move applying patches into apply_all_patches()
  builtin/apply: rename 'prefix_' parameter to 'prefix'
  builtin/apply: move 'lock_file' global into 'struct apply_state'
  builtin/apply: get rid of the 'newfd' global
  builtin/apply: make apply_patch() return -1 instead of die()ing
  builtin/apply: read_patch_file() return -1 instead of die()ing
  builtin/apply: make find_header() return -1 instead of die()ing
  builtin/apply: make parse_chunk() return a negative integer on error
  builtin/apply: make parse_single_patch() return -1 on error
  apply: move 'struct apply_state' to apply.h
  builtin/apply: libify parse_whitespace_option()
  builtin/apply: libify parse_ignorewhitespace_option()
  builtin/apply: move init_apply_state() to apply.c
  apply: libify init_apply_state()
  builtin/apply: libify check_apply_state()
  builtin/apply: move check_apply_state() to apply.c
  builtin/apply: make apply_all_patches() return -1 on error
  builtin/apply: make parse_traditional_patch() return -1 on error
  builtin/apply: make gitdiff_verify_name() return -1 on error
  builtin/apply: change die_on_unsafe_path() to check_unsafe_path()
  builtin/apply: make build_fake_ancestor() return -1 on error
  builtin/apply: make remove_file() return -1 on error
  builtin/apply: make add_conflicted_stages_file() return -1 on error
  builtin/apply: make add_index_file() return -1 on error
  builtin/apply: make create_file() return -1 on error
  builtin/apply: make write_out_one_result() return -1 on error
  builtin/apply: make write_out_results() return -1 on error
  builtin/apply: make try_create_file() return -1 on error
  builtin/apply: make create_one_file() return -1 on error
  builtin/apply: rename option parsing functions
  apply: rename and move opt constants to apply.h
  Move libified code from builtin/apply.c to apply.{c,h}
  apply: make some parsing functions static again
  run-command: make dup_devnull() non static
  apply: roll back index in case of error
  environment: add set_index_file()
  builtin/am: use apply api in run_apply()

 Makefile               |    1 +
 apply.c                | 4796 ++++++++++++++++++++++++++++++++++++++++++++++++
 apply.h                |  149 ++
 builtin/am.c           |  103 +-
 builtin/apply.c        | 4665 +---------------------------------------------
 cache.h                |    1 +
 environment.c          |    5 +
 run-command.c          |    2 +-
 run-command.h          |    6 +
 t/t4012-diff-binary.sh |    4 +-
 t/t4254-am-corrupt.sh  |    2 +-
 11 files changed, 5096 insertions(+), 4638 deletions(-)
 create mode 100644 apply.c
 create mode 100644 apply.h

--
2.8.1.300.g5fed0c0

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[PATCH 01/83] builtin/apply: make gitdiff_verify_name() return void

Christian Couder-2
As the value returned by gitdiff_verify_name() is put into the
same variable that is passed as a parameter to this function,
it is simpler to pass the address of the variable and have
gitdiff_verify_name() change the variable itself.

Signed-off-by: Christian Couder <[hidden email]>
---
 builtin/apply.c | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/builtin/apply.c b/builtin/apply.c
index 8e4da2e..fe5aebd 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -925,43 +925,43 @@ static int gitdiff_hdrend(const char *line, struct patch *patch)
 #define DIFF_OLD_NAME 0
 #define DIFF_NEW_NAME 1
 
-static char *gitdiff_verify_name(const char *line, int isnull, char *orig_name, int side)
+static void gitdiff_verify_name(const char *line, int isnull, char **name, int side)
 {
- if (!orig_name && !isnull)
- return find_name(line, NULL, p_value, TERM_TAB);
+ if (!*name && !isnull) {
+ *name = find_name(line, NULL, p_value, TERM_TAB);
+ return;
+ }
 
- if (orig_name) {
- int len = strlen(orig_name);
+ if (*name) {
+ int len = strlen(*name);
  char *another;
  if (isnull)
  die(_("git apply: bad git-diff - expected /dev/null, got %s on line %d"),
-    orig_name, linenr);
+    *name, linenr);
  another = find_name(line, NULL, p_value, TERM_TAB);
- if (!another || memcmp(another, orig_name, len + 1))
+ if (!another || memcmp(another, *name, len + 1))
  die((side == DIFF_NEW_NAME) ?
     _("git apply: bad git-diff - inconsistent new filename on line %d") :
     _("git apply: bad git-diff - inconsistent old filename on line %d"), linenr);
  free(another);
- return orig_name;
  } else {
  /* expect "/dev/null" */
  if (memcmp("/dev/null", line, 9) || line[9] != '\n')
  die(_("git apply: bad git-diff - expected /dev/null on line %d"), linenr);
- return NULL;
  }
 }
 
 static int gitdiff_oldname(const char *line, struct patch *patch)
 {
- patch->old_name = gitdiff_verify_name(line, patch->is_new, patch->old_name,
-      DIFF_OLD_NAME);
+ gitdiff_verify_name(line, patch->is_new, &patch->old_name,
+    DIFF_OLD_NAME);
  return 0;
 }
 
 static int gitdiff_newname(const char *line, struct patch *patch)
 {
- patch->new_name = gitdiff_verify_name(line, patch->is_delete, patch->new_name,
-      DIFF_NEW_NAME);
+ gitdiff_verify_name(line, patch->is_delete, &patch->new_name,
+    DIFF_NEW_NAME);
  return 0;
 }
 
--
2.8.1.300.g5fed0c0

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[PATCH 02/83] builtin/apply: avoid parameter shadowing 'p_value' global

Christian Couder-2
In reply to this post by Christian Couder-2
Let's just rename the global 'state_p_value' as it will become
'state->p_value' in a following patch.

Signed-off-by: Christian Couder <[hidden email]>
---
 builtin/apply.c | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/builtin/apply.c b/builtin/apply.c
index fe5aebd..e133b38 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -35,7 +35,7 @@ static int prefix_length = -1;
 static int newfd = -1;
 
 static int unidiff_zero;
-static int p_value = 1;
+static int state_p_value = 1;
 static int p_value_known;
 static int check_index;
 static int update_index;
@@ -872,24 +872,24 @@ static void parse_traditional_patch(const char *first, const char *second, struc
  q = guess_p_value(second);
  if (p < 0) p = q;
  if (0 <= p && p == q) {
- p_value = p;
+ state_p_value = p;
  p_value_known = 1;
  }
  }
  if (is_dev_null(first)) {
  patch->is_new = 1;
  patch->is_delete = 0;
- name = find_name_traditional(second, NULL, p_value);
+ name = find_name_traditional(second, NULL, state_p_value);
  patch->new_name = name;
  } else if (is_dev_null(second)) {
  patch->is_new = 0;
  patch->is_delete = 1;
- name = find_name_traditional(first, NULL, p_value);
+ name = find_name_traditional(first, NULL, state_p_value);
  patch->old_name = name;
  } else {
  char *first_name;
- first_name = find_name_traditional(first, NULL, p_value);
- name = find_name_traditional(second, first_name, p_value);
+ first_name = find_name_traditional(first, NULL, state_p_value);
+ name = find_name_traditional(second, first_name, state_p_value);
  free(first_name);
  if (has_epoch_timestamp(first)) {
  patch->is_new = 1;
@@ -928,7 +928,7 @@ static int gitdiff_hdrend(const char *line, struct patch *patch)
 static void gitdiff_verify_name(const char *line, int isnull, char **name, int side)
 {
  if (!*name && !isnull) {
- *name = find_name(line, NULL, p_value, TERM_TAB);
+ *name = find_name(line, NULL, state_p_value, TERM_TAB);
  return;
  }
 
@@ -938,7 +938,7 @@ static void gitdiff_verify_name(const char *line, int isnull, char **name, int s
  if (isnull)
  die(_("git apply: bad git-diff - expected /dev/null, got %s on line %d"),
     *name, linenr);
- another = find_name(line, NULL, p_value, TERM_TAB);
+ another = find_name(line, NULL, state_p_value, TERM_TAB);
  if (!another || memcmp(another, *name, len + 1))
  die((side == DIFF_NEW_NAME) ?
     _("git apply: bad git-diff - inconsistent new filename on line %d") :
@@ -997,7 +997,7 @@ static int gitdiff_copysrc(const char *line, struct patch *patch)
 {
  patch->is_copy = 1;
  free(patch->old_name);
- patch->old_name = find_name(line, NULL, p_value ? p_value - 1 : 0, 0);
+ patch->old_name = find_name(line, NULL, state_p_value ? state_p_value - 1 : 0, 0);
  return 0;
 }
 
@@ -1005,7 +1005,7 @@ static int gitdiff_copydst(const char *line, struct patch *patch)
 {
  patch->is_copy = 1;
  free(patch->new_name);
- patch->new_name = find_name(line, NULL, p_value ? p_value - 1 : 0, 0);
+ patch->new_name = find_name(line, NULL, state_p_value ? state_p_value - 1 : 0, 0);
  return 0;
 }
 
@@ -1013,7 +1013,7 @@ static int gitdiff_renamesrc(const char *line, struct patch *patch)
 {
  patch->is_rename = 1;
  free(patch->old_name);
- patch->old_name = find_name(line, NULL, p_value ? p_value - 1 : 0, 0);
+ patch->old_name = find_name(line, NULL, state_p_value ? state_p_value - 1 : 0, 0);
  return 0;
 }
 
@@ -1021,7 +1021,7 @@ static int gitdiff_renamedst(const char *line, struct patch *patch)
 {
  patch->is_rename = 1;
  free(patch->new_name);
- patch->new_name = find_name(line, NULL, p_value ? p_value - 1 : 0, 0);
+ patch->new_name = find_name(line, NULL, state_p_value ? state_p_value - 1 : 0, 0);
  return 0;
 }
 
@@ -1092,10 +1092,10 @@ static const char *skip_tree_prefix(const char *line, int llen)
  int nslash;
  int i;
 
- if (!p_value)
+ if (!state_p_value)
  return (llen && line[0] == '/') ? NULL : line;
 
- nslash = p_value;
+ nslash = state_p_value;
  for (i = 0; i < llen; i++) {
  int ch = line[i];
  if (ch == '/' && --nslash <= 0)
@@ -1481,8 +1481,8 @@ static int find_header(const char *line, unsigned long size, int *hdrsize, struc
        "%d leading pathname component (line %d)",
        "git diff header lacks filename information when removing "
        "%d leading pathname components (line %d)",
-       p_value),
-    p_value, linenr);
+       state_p_value),
+    state_p_value, linenr);
  patch->old_name = xstrdup(patch->def_name);
  patch->new_name = xstrdup(patch->def_name);
  }
@@ -4461,7 +4461,7 @@ static int option_parse_include(const struct option *opt,
 static int option_parse_p(const struct option *opt,
   const char *arg, int unset)
 {
- p_value = atoi(arg);
+ state_p_value = atoi(arg);
  p_value_known = 1;
  return 0;
 }
--
2.8.1.300.g5fed0c0

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[PATCH 03/83] builtin/apply: avoid parameter shadowing 'linenr' global

Christian Couder-2
In reply to this post by Christian Couder-2
Signed-off-by: Christian Couder <[hidden email]>
---
 builtin/apply.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/builtin/apply.c b/builtin/apply.c
index e133b38..7115dc2 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -1516,7 +1516,7 @@ static int find_header(const char *line, unsigned long size, int *hdrsize, struc
  return -1;
 }
 
-static void record_ws_error(unsigned result, const char *line, int len, int linenr)
+static void record_ws_error(unsigned result, const char *line, int len, int l_nr)
 {
  char *err;
 
@@ -1530,7 +1530,7 @@ static void record_ws_error(unsigned result, const char *line, int len, int line
 
  err = whitespace_error_string(result);
  fprintf(stderr, "%s:%d: %s.\n%.*s\n",
- patch_input_file, linenr, err, len, line);
+ patch_input_file, l_nr, err, len, line);
  free(err);
 }
 
--
2.8.1.300.g5fed0c0

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[PATCH 04/83] builtin/apply: avoid local variable shadowing 'len' parameter

Christian Couder-2
In reply to this post by Christian Couder-2
Signed-off-by: Christian Couder <[hidden email]>
---
 builtin/apply.c | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/builtin/apply.c b/builtin/apply.c
index 7115dc2..78849e4 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -2194,17 +2194,17 @@ static void update_pre_post_images(struct image *preimage,
  fixed = preimage->buf;
 
  for (i = reduced = ctx = 0; i < postimage->nr; i++) {
- size_t len = postimage->line[i].len;
+ size_t l_len = postimage->line[i].len;
  if (!(postimage->line[i].flag & LINE_COMMON)) {
  /* an added line -- no counterparts in preimage */
- memmove(new, old, len);
- old += len;
- new += len;
+ memmove(new, old, l_len);
+ old += l_len;
+ new += l_len;
  continue;
  }
 
  /* a common context -- skip it in the original postimage */
- old += len;
+ old += l_len;
 
  /* and find the corresponding one in the fixed preimage */
  while (ctx < preimage->nr &&
@@ -2223,11 +2223,11 @@ static void update_pre_post_images(struct image *preimage,
  }
 
  /* and copy it in, while fixing the line length */
- len = preimage->line[ctx].len;
- memcpy(new, fixed, len);
- new += len;
- fixed += len;
- postimage->line[i].len = len;
+ l_len = preimage->line[ctx].len;
+ memcpy(new, fixed, l_len);
+ new += l_len;
+ fixed += l_len;
+ postimage->line[i].len = l_len;
  ctx++;
  }
 
--
2.8.1.300.g5fed0c0

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[PATCH 05/83] builtin/apply: extract line_by_line_fuzzy_match() from match_fragment()

Christian Couder-2
In reply to this post by Christian Couder-2
The match_fragment() function is very big and contains a big special case
algorithm that does line by line fuzzy matching. So let's extract this
algorithm in a separate line_by_line_fuzzy_match() function.

Signed-off-by: Christian Couder <[hidden email]>
---
 builtin/apply.c | 129 ++++++++++++++++++++++++++++++++------------------------
 1 file changed, 73 insertions(+), 56 deletions(-)

diff --git a/builtin/apply.c b/builtin/apply.c
index 78849e4..02239d9 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -2242,6 +2242,74 @@ static void update_pre_post_images(struct image *preimage,
  postimage->nr -= reduced;
 }
 
+static int line_by_line_fuzzy_match(struct image *img,
+    struct image *preimage,
+    struct image *postimage,
+    unsigned long try,
+    int try_lno,
+    int preimage_limit)
+{
+ int i;
+ size_t imgoff = 0;
+ size_t preoff = 0;
+ size_t postlen = postimage->len;
+ size_t extra_chars;
+ char *buf;
+ char *preimage_eof;
+ char *preimage_end;
+ struct strbuf fixed;
+ char *fixed_buf;
+ size_t fixed_len;
+
+ for (i = 0; i < preimage_limit; i++) {
+ size_t prelen = preimage->line[i].len;
+ size_t imglen = img->line[try_lno+i].len;
+
+ if (!fuzzy_matchlines(img->buf + try + imgoff, imglen,
+      preimage->buf + preoff, prelen))
+ return 0;
+ if (preimage->line[i].flag & LINE_COMMON)
+ postlen += imglen - prelen;
+ imgoff += imglen;
+ preoff += prelen;
+ }
+
+ /*
+ * Ok, the preimage matches with whitespace fuzz.
+ *
+ * imgoff now holds the true length of the target that
+ * matches the preimage before the end of the file.
+ *
+ * Count the number of characters in the preimage that fall
+ * beyond the end of the file and make sure that all of them
+ * are whitespace characters. (This can only happen if
+ * we are removing blank lines at the end of the file.)
+ */
+ buf = preimage_eof = preimage->buf + preoff;
+ for ( ; i < preimage->nr; i++)
+ preoff += preimage->line[i].len;
+ preimage_end = preimage->buf + preoff;
+ for ( ; buf < preimage_end; buf++)
+ if (!isspace(*buf))
+ return 0;
+
+ /*
+ * Update the preimage and the common postimage context
+ * lines to use the same whitespace as the target.
+ * If whitespace is missing in the target (i.e.
+ * if the preimage extends beyond the end of the file),
+ * use the whitespace from the preimage.
+ */
+ extra_chars = preimage_end - preimage_eof;
+ strbuf_init(&fixed, imgoff + extra_chars);
+ strbuf_add(&fixed, img->buf + try, imgoff);
+ strbuf_add(&fixed, preimage_eof, extra_chars);
+ fixed_buf = strbuf_detach(&fixed, &fixed_len);
+ update_pre_post_images(preimage, postimage,
+       fixed_buf, fixed_len, postlen);
+ return 1;
+}
+
 static int match_fragment(struct image *img,
   struct image *preimage,
   struct image *postimage,
@@ -2251,7 +2319,7 @@ static int match_fragment(struct image *img,
   int match_beginning, int match_end)
 {
  int i;
- char *fixed_buf, *buf, *orig, *target;
+ char *fixed_buf, *orig, *target;
  struct strbuf fixed;
  size_t fixed_len, postlen;
  int preimage_limit;
@@ -2312,6 +2380,7 @@ static int match_fragment(struct image *img,
  * There must be one non-blank context line that match
  * a line before the end of img.
  */
+ char *buf;
  char *buf_end;
 
  buf = preimage->buf;
@@ -2331,61 +2400,9 @@ static int match_fragment(struct image *img,
  * fuzzy matching. We collect all the line length information because
  * we need it to adjust whitespace if we match.
  */
- if (ws_ignore_action == ignore_ws_change) {
- size_t imgoff = 0;
- size_t preoff = 0;
- size_t postlen = postimage->len;
- size_t extra_chars;
- char *preimage_eof;
- char *preimage_end;
- for (i = 0; i < preimage_limit; i++) {
- size_t prelen = preimage->line[i].len;
- size_t imglen = img->line[try_lno+i].len;
-
- if (!fuzzy_matchlines(img->buf + try + imgoff, imglen,
-      preimage->buf + preoff, prelen))
- return 0;
- if (preimage->line[i].flag & LINE_COMMON)
- postlen += imglen - prelen;
- imgoff += imglen;
- preoff += prelen;
- }
-
- /*
- * Ok, the preimage matches with whitespace fuzz.
- *
- * imgoff now holds the true length of the target that
- * matches the preimage before the end of the file.
- *
- * Count the number of characters in the preimage that fall
- * beyond the end of the file and make sure that all of them
- * are whitespace characters. (This can only happen if
- * we are removing blank lines at the end of the file.)
- */
- buf = preimage_eof = preimage->buf + preoff;
- for ( ; i < preimage->nr; i++)
- preoff += preimage->line[i].len;
- preimage_end = preimage->buf + preoff;
- for ( ; buf < preimage_end; buf++)
- if (!isspace(*buf))
- return 0;
-
- /*
- * Update the preimage and the common postimage context
- * lines to use the same whitespace as the target.
- * If whitespace is missing in the target (i.e.
- * if the preimage extends beyond the end of the file),
- * use the whitespace from the preimage.
- */
- extra_chars = preimage_end - preimage_eof;
- strbuf_init(&fixed, imgoff + extra_chars);
- strbuf_add(&fixed, img->buf + try, imgoff);
- strbuf_add(&fixed, preimage_eof, extra_chars);
- fixed_buf = strbuf_detach(&fixed, &fixed_len);
- update_pre_post_images(preimage, postimage,
- fixed_buf, fixed_len, postlen);
- return 1;
- }
+ if (ws_ignore_action == ignore_ws_change)
+ return line_by_line_fuzzy_match(img, preimage, postimage,
+ try, try_lno, preimage_limit);
 
  if (ws_error_action != correct_ws_error)
  return 0;
--
2.8.1.300.g5fed0c0

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[PATCH 06/83] builtin/apply: move 'options' variable into cmd_apply()

Christian Couder-2
In reply to this post by Christian Couder-2
Signed-off-by: Christian Couder <[hidden email]>
---
 builtin/apply.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/builtin/apply.c b/builtin/apply.c
index 02239d9..8fd8dbc 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -79,7 +79,6 @@ static enum ws_ignore {
 static const char *patch_input_file;
 static struct strbuf root = STRBUF_INIT;
 static int read_stdin = 1;
-static int options;
 
 static void parse_whitespace_option(const char *option)
 {
@@ -4518,6 +4517,7 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
  int errs = 0;
  int is_not_gitdir = !startup_info->have_repository;
  int force_apply = 0;
+ int options = 0;
 
  const char *whitespace_option = NULL;
 
--
2.8.1.300.g5fed0c0

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[PATCH 07/83] builtin/apply: introduce 'struct apply_state' to start libifying

Christian Couder-2
In reply to this post by Christian Couder-2
Currently commands that want to use the apply functionality have to launch
a "git apply" process which can be bad for performance.

Let's start libifying the apply functionality and to do that we first need
to get rid of the global variables in "builtin/apply.c".

This patch introduces "struct apply_state" into which all the previously
global variables will be moved. A new parameter called "state" that is a
pointer to the "apply_state" structure will come at the beginning of the
helper functions that need it and will be passed around the call chain.

To start let's move the "prefix" and "prefix_length" global variables into
"struct apply_state".

Signed-off-by: Christian Couder <[hidden email]>
---
 builtin/apply.c | 94 ++++++++++++++++++++++++++++++++++-----------------------
 1 file changed, 56 insertions(+), 38 deletions(-)

diff --git a/builtin/apply.c b/builtin/apply.c
index 8fd8dbc..51e6af4 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -21,6 +21,11 @@
 #include "ll-merge.h"
 #include "rerere.h"
 
+struct apply_state {
+ const char *prefix;
+ int prefix_length;
+};
+
 /*
  *  --check turns on checking that the working tree matches the
  *    files that are being modified, but doesn't apply the patch
@@ -30,8 +35,6 @@
  *  --index updates the cache as well.
  *  --cached updates only the cache without ever touching the working tree.
  */
-static const char *prefix;
-static int prefix_length = -1;
 static int newfd = -1;
 
 static int unidiff_zero;
@@ -749,7 +752,7 @@ static int count_slashes(const char *cp)
  * Given the string after "--- " or "+++ ", guess the appropriate
  * p_value for the given patch.
  */
-static int guess_p_value(const char *nameline)
+static int guess_p_value(struct apply_state *state, const char *nameline)
 {
  char *name, *cp;
  int val = -1;
@@ -762,17 +765,17 @@ static int guess_p_value(const char *nameline)
  cp = strchr(name, '/');
  if (!cp)
  val = 0;
- else if (prefix) {
+ else if (state->prefix) {
  /*
  * Does it begin with "a/$our-prefix" and such?  Then this is
  * very likely to apply to our directory.
  */
- if (!strncmp(name, prefix, prefix_length))
- val = count_slashes(prefix);
+ if (!strncmp(name, state->prefix, state->prefix_length))
+ val = count_slashes(state->prefix);
  else {
  cp++;
- if (!strncmp(cp, prefix, prefix_length))
- val = count_slashes(prefix) + 1;
+ if (!strncmp(cp, state->prefix, state->prefix_length))
+ val = count_slashes(state->prefix) + 1;
  }
  }
  free(name);
@@ -859,7 +862,10 @@ static int has_epoch_timestamp(const char *nameline)
  * files, we can happily check the index for a match, but for creating a
  * new file we should try to match whatever "patch" does. I have no idea.
  */
-static void parse_traditional_patch(const char *first, const char *second, struct patch *patch)
+static void parse_traditional_patch(struct apply_state *state,
+    const char *first,
+    const char *second,
+    struct patch *patch)
 {
  char *name;
 
@@ -867,8 +873,8 @@ static void parse_traditional_patch(const char *first, const char *second, struc
  second += 4; /* skip "+++ " */
  if (!p_value_known) {
  int p, q;
- p = guess_p_value(first);
- q = guess_p_value(second);
+ p = guess_p_value(state, first);
+ q = guess_p_value(state, second);
  if (p < 0) p = q;
  if (0 <= p && p == q) {
  state_p_value = p;
@@ -1430,7 +1436,11 @@ static int parse_fragment_header(const char *line, int len, struct fragment *fra
  return offset;
 }
 
-static int find_header(const char *line, unsigned long size, int *hdrsize, struct patch *patch)
+static int find_header(struct apply_state *state,
+       const char *line,
+       unsigned long size,
+       int *hdrsize,
+       struct patch *patch)
 {
  unsigned long offset, len;
 
@@ -1507,7 +1517,7 @@ static int find_header(const char *line, unsigned long size, int *hdrsize, struc
  continue;
 
  /* Ok, we'll consider it a patch */
- parse_traditional_patch(line, line+len, patch);
+ parse_traditional_patch(state, line, line+len, patch);
  *hdrsize = len + nextlen;
  linenr += 2;
  return offset;
@@ -1914,21 +1924,21 @@ static int parse_binary(char *buffer, unsigned long size, struct patch *patch)
  return used;
 }
 
-static void prefix_one(char **name)
+static void prefix_one(struct apply_state *state, char **name)
 {
  char *old_name = *name;
  if (!old_name)
  return;
- *name = xstrdup(prefix_filename(prefix, prefix_length, *name));
+ *name = xstrdup(prefix_filename(state->prefix, state->prefix_length, *name));
  free(old_name);
 }
 
-static void prefix_patch(struct patch *p)
+static void prefix_patch(struct apply_state *state, struct patch *p)
 {
- if (!prefix || p->is_toplevel_relative)
+ if (!state->prefix || p->is_toplevel_relative)
  return;
- prefix_one(&p->new_name);
- prefix_one(&p->old_name);
+ prefix_one(state, &p->new_name);
+ prefix_one(state, &p->old_name);
 }
 
 /*
@@ -1945,16 +1955,16 @@ static void add_name_limit(const char *name, int exclude)
  it->util = exclude ? NULL : (void *) 1;
 }
 
-static int use_patch(struct patch *p)
+static int use_patch(struct apply_state *state, struct patch *p)
 {
  const char *pathname = p->new_name ? p->new_name : p->old_name;
  int i;
 
  /* Paths outside are not touched regardless of "--include" */
- if (0 < prefix_length) {
+ if (0 < state->prefix_length) {
  int pathlen = strlen(pathname);
- if (pathlen <= prefix_length ||
-    memcmp(prefix, pathname, prefix_length))
+ if (pathlen <= state->prefix_length ||
+    memcmp(state->prefix, pathname, state->prefix_length))
  return 0;
  }
 
@@ -1981,17 +1991,17 @@ static int use_patch(struct patch *p)
  * Return the number of bytes consumed, so that the caller can call us
  * again for the next patch.
  */
-static int parse_chunk(char *buffer, unsigned long size, struct patch *patch)
+static int parse_chunk(struct apply_state *state, char *buffer, unsigned long size, struct patch *patch)
 {
  int hdrsize, patchsize;
- int offset = find_header(buffer, size, &hdrsize, patch);
+ int offset = find_header(state, buffer, size, &hdrsize, patch);
 
  if (offset < 0)
  return offset;
 
- prefix_patch(patch);
+ prefix_patch(state, patch);
 
- if (!use_patch(patch))
+ if (!use_patch(state, patch))
  patch->ws_rule = 0;
  else
  patch->ws_rule = whitespace_rule(patch->new_name
@@ -4369,7 +4379,10 @@ static struct lock_file lock_file;
 #define INACCURATE_EOF (1<<0)
 #define RECOUNT (1<<1)
 
-static int apply_patch(int fd, const char *filename, int options)
+static int apply_patch(struct apply_state *state,
+       int fd,
+       const char *filename,
+       int options)
 {
  size_t offset;
  struct strbuf buf = STRBUF_INIT; /* owns the patch text */
@@ -4386,14 +4399,14 @@ static int apply_patch(int fd, const char *filename, int options)
  patch = xcalloc(1, sizeof(*patch));
  patch->inaccurate_eof = !!(options & INACCURATE_EOF);
  patch->recount =  !!(options & RECOUNT);
- nr = parse_chunk(buf.buf + offset, buf.len - offset, patch);
+ nr = parse_chunk(state, buf.buf + offset, buf.len - offset, patch);
  if (nr < 0) {
  free_patch(patch);
  break;
  }
  if (apply_in_reverse)
  reverse_patches(patch);
- if (use_patch(patch)) {
+ if (use_patch(state, patch)) {
  patch_stats(patch);
  *listp = patch;
  listp = &patch->next;
@@ -4518,6 +4531,7 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
  int is_not_gitdir = !startup_info->have_repository;
  int force_apply = 0;
  int options = 0;
+ struct apply_state state;
 
  const char *whitespace_option = NULL;
 
@@ -4590,15 +4604,17 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
  OPT_END()
  };
 
- prefix = prefix_;
- prefix_length = prefix ? strlen(prefix) : 0;
+ memset(&state, 0, sizeof(state));
+ state.prefix = prefix_;
+ state.prefix_length = state.prefix ? strlen(state.prefix) : 0;
+
  git_apply_config();
  if (apply_default_whitespace)
  parse_whitespace_option(apply_default_whitespace);
  if (apply_default_ignorewhitespace)
  parse_ignorewhitespace_option(apply_default_ignorewhitespace);
 
- argc = parse_options(argc, argv, prefix, builtin_apply_options,
+ argc = parse_options(argc, argv, state.prefix, builtin_apply_options,
  apply_usage, 0);
 
  if (apply_with_reject && threeway)
@@ -4629,23 +4645,25 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
  int fd;
 
  if (!strcmp(arg, "-")) {
- errs |= apply_patch(0, "<stdin>", options);
+ errs |= apply_patch(&state, 0, "<stdin>", options);
  read_stdin = 0;
  continue;
- } else if (0 < prefix_length)
- arg = prefix_filename(prefix, prefix_length, arg);
+ } else if (0 < state.prefix_length)
+ arg = prefix_filename(state.prefix,
+      state.prefix_length,
+      arg);
 
  fd = open(arg, O_RDONLY);
  if (fd < 0)
  die_errno(_("can't open patch '%s'"), arg);
  read_stdin = 0;
  set_default_whitespace_mode(whitespace_option);
- errs |= apply_patch(fd, arg, options);
+ errs |= apply_patch(&state, fd, arg, options);
  close(fd);
  }
  set_default_whitespace_mode(whitespace_option);
  if (read_stdin)
- errs |= apply_patch(0, "<stdin>", options);
+ errs |= apply_patch(&state, 0, "<stdin>", options);
  if (whitespace_error) {
  if (squelch_whitespace_errors &&
     squelch_whitespace_errors < whitespace_error) {
--
2.8.1.300.g5fed0c0

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[PATCH 08/83] builtin/apply: move 'unidiff_zero' global into 'struct apply_state'

Christian Couder-2
In reply to this post by Christian Couder-2
Signed-off-by: Christian Couder <[hidden email]>
---
 builtin/apply.c | 42 ++++++++++++++++++++++++------------------
 1 file changed, 24 insertions(+), 18 deletions(-)

diff --git a/builtin/apply.c b/builtin/apply.c
index 51e6af4..ad81210 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -24,6 +24,8 @@
 struct apply_state {
  const char *prefix;
  int prefix_length;
+
+ int unidiff_zero;
 };
 
 /*
@@ -37,7 +39,6 @@ struct apply_state {
  */
 static int newfd = -1;
 
-static int unidiff_zero;
 static int state_p_value = 1;
 static int p_value_known;
 static int check_index;
@@ -2696,7 +2697,8 @@ static void update_image(struct image *img,
  * postimage) for the hunk.  Find lines that match "preimage" in "img" and
  * replace the part of "img" with "postimage" text.
  */
-static int apply_one_fragment(struct image *img, struct fragment *frag,
+static int apply_one_fragment(struct apply_state *state,
+      struct image *img, struct fragment *frag,
       int inaccurate_eof, unsigned ws_rule,
       int nth_fragment)
 {
@@ -2838,7 +2840,7 @@ static int apply_one_fragment(struct image *img, struct fragment *frag,
  * without leading context must match at the beginning.
  */
  match_beginning = (!frag->oldpos ||
-   (frag->oldpos == 1 && !unidiff_zero));
+   (frag->oldpos == 1 && !state->unidiff_zero));
 
  /*
  * A hunk without trailing lines must match at the end.
@@ -2846,7 +2848,7 @@ static int apply_one_fragment(struct image *img, struct fragment *frag,
  * from the lack of trailing lines if the patch was generated
  * with unidiff without any context.
  */
- match_end = !unidiff_zero && !trailing;
+ match_end = !state->unidiff_zero && !trailing;
 
  pos = frag->newpos ? (frag->newpos - 1) : 0;
  preimage.buf = oldlines;
@@ -3069,7 +3071,7 @@ static int apply_binary(struct image *img, struct patch *patch)
  return 0;
 }
 
-static int apply_fragments(struct image *img, struct patch *patch)
+static int apply_fragments(struct apply_state *state, struct image *img, struct patch *patch)
 {
  struct fragment *frag = patch->fragments;
  const char *name = patch->old_name ? patch->old_name : patch->new_name;
@@ -3082,7 +3084,7 @@ static int apply_fragments(struct image *img, struct patch *patch)
 
  while (frag) {
  nth++;
- if (apply_one_fragment(img, frag, inaccurate_eof, ws_rule, nth)) {
+ if (apply_one_fragment(state, img, frag, inaccurate_eof, ws_rule, nth)) {
  error(_("patch failed: %s:%ld"), name, frag->oldpos);
  if (!apply_with_reject)
  return -1;
@@ -3390,8 +3392,11 @@ static int load_current(struct image *image, struct patch *patch)
  return 0;
 }
 
-static int try_threeway(struct image *image, struct patch *patch,
- struct stat *st, const struct cache_entry *ce)
+static int try_threeway(struct apply_state *state,
+ struct image *image,
+ struct patch *patch,
+ struct stat *st,
+ const struct cache_entry *ce)
 {
  unsigned char pre_sha1[20], post_sha1[20], our_sha1[20];
  struct strbuf buf = STRBUF_INIT;
@@ -3417,7 +3422,7 @@ static int try_threeway(struct image *image, struct patch *patch,
  img = strbuf_detach(&buf, &len);
  prepare_image(&tmp_image, img, len, 1);
  /* Apply the patch to get the post image */
- if (apply_fragments(&tmp_image, patch) < 0) {
+ if (apply_fragments(state, &tmp_image, patch) < 0) {
  clear_image(&tmp_image);
  return -1;
  }
@@ -3461,7 +3466,8 @@ static int try_threeway(struct image *image, struct patch *patch,
  return 0;
 }
 
-static int apply_data(struct patch *patch, struct stat *st, const struct cache_entry *ce)
+static int apply_data(struct apply_state *state, struct patch *patch,
+      struct stat *st, const struct cache_entry *ce)
 {
  struct image image;
 
@@ -3469,9 +3475,9 @@ static int apply_data(struct patch *patch, struct stat *st, const struct cache_e
  return -1;
 
  if (patch->direct_to_threeway ||
-    apply_fragments(&image, patch) < 0) {
+    apply_fragments(state, &image, patch) < 0) {
  /* Note: with --reject, apply_fragments() returns 0 */
- if (!threeway || try_threeway(&image, patch, st, ce) < 0)
+ if (!threeway || try_threeway(state, &image, patch, st, ce) < 0)
  return -1;
  }
  patch->result = image.buf;
@@ -3719,7 +3725,7 @@ static void die_on_unsafe_path(struct patch *patch)
  * Check and apply the patch in-core; leave the result in patch->result
  * for the caller to write it out to the final destination.
  */
-static int check_patch(struct patch *patch)
+static int check_patch(struct apply_state *state, struct patch *patch)
 {
  struct stat st;
  const char *old_name = patch->old_name;
@@ -3818,13 +3824,13 @@ static int check_patch(struct patch *patch)
  return error(_("affected file '%s' is beyond a symbolic link"),
      patch->new_name);
 
- if (apply_data(patch, &st, ce) < 0)
+ if (apply_data(state, patch, &st, ce) < 0)
  return error(_("%s: patch does not apply"), name);
  patch->rejected = 0;
  return 0;
 }
 
-static int check_patch_list(struct patch *patch)
+static int check_patch_list(struct apply_state *state, struct patch *patch)
 {
  int err = 0;
 
@@ -3834,7 +3840,7 @@ static int check_patch_list(struct patch *patch)
  if (apply_verbosely)
  say_patch_name(stderr,
        _("Checking patch %s..."), patch);
- err |= check_patch(patch);
+ err |= check_patch(state, patch);
  patch = patch->next;
  }
  return err;
@@ -4436,7 +4442,7 @@ static int apply_patch(struct apply_state *state,
  }
 
  if ((check || apply) &&
-    check_patch_list(list) < 0 &&
+    check_patch_list(state, list) < 0 &&
     !apply_with_reject)
  exit(1);
 
@@ -4585,7 +4591,7 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
  PARSE_OPT_NOARG, option_parse_space_change },
  OPT_BOOL('R', "reverse", &apply_in_reverse,
  N_("apply the patch in reverse")),
- OPT_BOOL(0, "unidiff-zero", &unidiff_zero,
+ OPT_BOOL(0, "unidiff-zero", &state.unidiff_zero,
  N_("don't expect at least one line of context")),
  OPT_BOOL(0, "reject", &apply_with_reject,
  N_("leave the rejected hunks in corresponding *.rej files")),
--
2.8.1.300.g5fed0c0

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[PATCH 09/83] builtin/apply: move 'check' global into 'struct apply_state'

Christian Couder-2
In reply to this post by Christian Couder-2
Signed-off-by: Christian Couder <[hidden email]>
---
 builtin/apply.c | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/builtin/apply.c b/builtin/apply.c
index ad81210..6c628f6 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -25,12 +25,15 @@ struct apply_state {
  const char *prefix;
  int prefix_length;
 
+ /*
+ *  --check turns on checking that the working tree matches the
+ *    files that are being modified, but doesn't apply the patch
+ */
+ int check;
  int unidiff_zero;
 };
 
 /*
- *  --check turns on checking that the working tree matches the
- *    files that are being modified, but doesn't apply the patch
  *  --stat does just a diffstat, and doesn't actually apply
  *  --numstat does numeric diffstat, and doesn't actually apply
  *  --index-info shows the old and new index info for paths if available.
@@ -47,7 +50,6 @@ static int cached;
 static int diffstat;
 static int numstat;
 static int summary;
-static int check;
 static int apply = 1;
 static int apply_in_reverse;
 static int apply_with_reject;
@@ -2053,7 +2055,7 @@ static int parse_chunk(struct apply_state *state, char *buffer, unsigned long si
  * without metadata change.  A binary patch appears
  * empty to us here.
  */
- if ((apply || check) &&
+ if ((apply || state->check) &&
     (!patch->is_binary && !metadata_changes(patch)))
  die(_("patch with only garbage at line %d"), linenr);
  }
@@ -4441,7 +4443,7 @@ static int apply_patch(struct apply_state *state,
  die(_("unable to read index file"));
  }
 
- if ((check || apply) &&
+ if ((state->check || apply) &&
     check_patch_list(state, list) < 0 &&
     !apply_with_reject)
  exit(1);
@@ -4561,7 +4563,7 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
  N_("show number of added and deleted lines in decimal notation")),
  OPT_BOOL(0, "summary", &summary,
  N_("instead of applying the patch, output a summary for the input")),
- OPT_BOOL(0, "check", &check,
+ OPT_BOOL(0, "check", &state.check,
  N_("instead of applying the patch, see if the patch is applicable")),
  OPT_BOOL(0, "index", &check_index,
  N_("make sure the patch is applicable to the current index")),
@@ -4634,7 +4636,7 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
  }
  if (apply_with_reject)
  apply = apply_verbosely = 1;
- if (!force_apply && (diffstat || numstat || summary || check || fake_ancestor))
+ if (!force_apply && (diffstat || numstat || summary || state.check || fake_ancestor))
  apply = 0;
  if (check_index && is_not_gitdir)
  die(_("--index outside a repository"));
--
2.8.1.300.g5fed0c0

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[PATCH 10/83] builtin/apply: move 'check_index' global into 'struct apply_state'

Christian Couder-2
In reply to this post by Christian Couder-2
Signed-off-by: Christian Couder <[hidden email]>
---
 builtin/apply.c | 69 +++++++++++++++++++++++++++++++++------------------------
 1 file changed, 40 insertions(+), 29 deletions(-)

diff --git a/builtin/apply.c b/builtin/apply.c
index 6c628f6..3f8671c 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -30,6 +30,10 @@ struct apply_state {
  *    files that are being modified, but doesn't apply the patch
  */
  int check;
+
+ /* --index updates the cache as well. */
+ int check_index;
+
  int unidiff_zero;
 };
 
@@ -37,14 +41,12 @@ struct apply_state {
  *  --stat does just a diffstat, and doesn't actually apply
  *  --numstat does numeric diffstat, and doesn't actually apply
  *  --index-info shows the old and new index info for paths if available.
- *  --index updates the cache as well.
  *  --cached updates only the cache without ever touching the working tree.
  */
 static int newfd = -1;
 
 static int state_p_value = 1;
 static int p_value_known;
-static int check_index;
 static int update_index;
 static int cached;
 static int diffstat;
@@ -3248,13 +3250,14 @@ static int verify_index_match(const struct cache_entry *ce, struct stat *st)
 
 #define SUBMODULE_PATCH_WITHOUT_INDEX 1
 
-static int load_patch_target(struct strbuf *buf,
+static int load_patch_target(struct apply_state *state,
+     struct strbuf *buf,
      const struct cache_entry *ce,
      struct stat *st,
      const char *name,
      unsigned expected_mode)
 {
- if (cached || check_index) {
+ if (cached || state->check_index) {
  if (read_file_or_gitlink(ce, buf))
  return error(_("read of %s failed"), name);
  } else if (name) {
@@ -3280,7 +3283,8 @@ static int load_patch_target(struct strbuf *buf,
  * applying a non-git patch that incrementally updates the tree,
  * we read from the result of a previous diff.
  */
-static int load_preimage(struct image *image,
+static int load_preimage(struct apply_state *state,
+ struct image *image,
  struct patch *patch, struct stat *st,
  const struct cache_entry *ce)
 {
@@ -3298,7 +3302,7 @@ static int load_preimage(struct image *image,
  /* We have a patched copy in memory; use that. */
  strbuf_add(&buf, previous->result, previous->resultsize);
  } else {
- status = load_patch_target(&buf, ce, st,
+ status = load_patch_target(state, &buf, ce, st,
    patch->old_name, patch->old_mode);
  if (status < 0)
  return status;
@@ -3357,7 +3361,9 @@ static int three_way_merge(struct image *image,
  * the current contents of the new_name.  In no cases other than that
  * this function will be called.
  */
-static int load_current(struct image *image, struct patch *patch)
+static int load_current(struct apply_state *state,
+ struct image *image,
+ struct patch *patch)
 {
  struct strbuf buf = STRBUF_INIT;
  int status, pos;
@@ -3384,7 +3390,7 @@ static int load_current(struct image *image, struct patch *patch)
  if (verify_index_match(ce, &st))
  return error(_("%s: does not match index"), name);
 
- status = load_patch_target(&buf, ce, &st, name, mode);
+ status = load_patch_target(state, &buf, ce, &st, name, mode);
  if (status < 0)
  return status;
  else if (status)
@@ -3434,11 +3440,11 @@ static int try_threeway(struct apply_state *state,
 
  /* our_sha1[] is ours */
  if (patch->is_new) {
- if (load_current(&tmp_image, patch))
+ if (load_current(state, &tmp_image, patch))
  return error("cannot read the current contents of '%s'",
      patch->new_name);
  } else {
- if (load_preimage(&tmp_image, patch, st, ce))
+ if (load_preimage(state, &tmp_image, patch, st, ce))
  return error("cannot read the current contents of '%s'",
      patch->old_name);
  }
@@ -3473,7 +3479,7 @@ static int apply_data(struct apply_state *state, struct patch *patch,
 {
  struct image image;
 
- if (load_preimage(&image, patch, st, ce) < 0)
+ if (load_preimage(state, &image, patch, st, ce) < 0)
  return -1;
 
  if (patch->direct_to_threeway ||
@@ -3504,7 +3510,10 @@ static int apply_data(struct apply_state *state, struct patch *patch,
  * check_patch() separately makes sure (and errors out otherwise) that
  * the path the patch creates does not exist in the current tree.
  */
-static int check_preimage(struct patch *patch, struct cache_entry **ce, struct stat *st)
+static int check_preimage(struct apply_state *state,
+  struct patch *patch,
+  struct cache_entry **ce,
+  struct stat *st)
 {
  const char *old_name = patch->old_name;
  struct patch *previous = NULL;
@@ -3527,7 +3536,7 @@ static int check_preimage(struct patch *patch, struct cache_entry **ce, struct s
  return error(_("%s: %s"), old_name, strerror(errno));
  }
 
- if (check_index && !previous) {
+ if (state->check_index && !previous) {
  int pos = cache_name_pos(old_name, strlen(old_name));
  if (pos < 0) {
  if (patch->is_new < 0)
@@ -3577,11 +3586,13 @@ static int check_preimage(struct patch *patch, struct cache_entry **ce, struct s
 #define EXISTS_IN_INDEX 1
 #define EXISTS_IN_WORKTREE 2
 
-static int check_to_create(const char *new_name, int ok_if_exists)
+static int check_to_create(struct apply_state *state,
+   const char *new_name,
+   int ok_if_exists)
 {
  struct stat nst;
 
- if (check_index &&
+ if (state->check_index &&
     cache_name_pos(new_name, strlen(new_name)) >= 0 &&
     !ok_if_exists)
  return EXISTS_IN_INDEX;
@@ -3657,7 +3668,7 @@ static void prepare_symlink_changes(struct patch *patch)
  }
 }
 
-static int path_is_beyond_symlink_1(struct strbuf *name)
+static int path_is_beyond_symlink_1(struct apply_state *state, struct strbuf *name)
 {
  do {
  unsigned int change;
@@ -3678,7 +3689,7 @@ static int path_is_beyond_symlink_1(struct strbuf *name)
  continue;
 
  /* otherwise, check the preimage */
- if (check_index) {
+ if (state->check_index) {
  struct cache_entry *ce;
 
  ce = cache_file_exists(name->buf, name->len, ignore_case);
@@ -3693,14 +3704,14 @@ static int path_is_beyond_symlink_1(struct strbuf *name)
  return 0;
 }
 
-static int path_is_beyond_symlink(const char *name_)
+static int path_is_beyond_symlink(struct apply_state *state, const char *name_)
 {
  int ret;
  struct strbuf name = STRBUF_INIT;
 
  assert(*name_ != '\0');
  strbuf_addstr(&name, name_);
- ret = path_is_beyond_symlink_1(&name);
+ ret = path_is_beyond_symlink_1(state, &name);
  strbuf_release(&name);
 
  return ret;
@@ -3740,7 +3751,7 @@ static int check_patch(struct apply_state *state, struct patch *patch)
 
  patch->rejected = 1; /* we will drop this after we succeed */
 
- status = check_preimage(patch, &ce, &st);
+ status = check_preimage(state, patch, &ce, &st);
  if (status)
  return status;
  old_name = patch->old_name;
@@ -3767,7 +3778,7 @@ static int check_patch(struct apply_state *state, struct patch *patch)
 
  if (new_name &&
     ((0 < patch->is_new) || patch->is_rename || patch->is_copy)) {
- int err = check_to_create(new_name, ok_if_exists);
+ int err = check_to_create(state, new_name, ok_if_exists);
 
  if (err && threeway) {
  patch->direct_to_threeway = 1;
@@ -3822,7 +3833,7 @@ static int check_patch(struct apply_state *state, struct patch *patch)
  * is not deposited to a path that is beyond a symbolic link
  * here.
  */
- if (!patch->is_delete && path_is_beyond_symlink(patch->new_name))
+ if (!patch->is_delete && path_is_beyond_symlink(state, patch->new_name))
  return error(_("affected file '%s' is beyond a symbolic link"),
      patch->new_name);
 
@@ -4434,11 +4445,11 @@ static int apply_patch(struct apply_state *state,
  if (whitespace_error && (ws_error_action == die_on_ws_error))
  apply = 0;
 
- update_index = check_index && apply;
+ update_index = state->check_index && apply;
  if (update_index && newfd < 0)
  newfd = hold_locked_index(&lock_file, 1);
 
- if (check_index) {
+ if (state->check_index) {
  if (read_cache() < 0)
  die(_("unable to read index file"));
  }
@@ -4565,7 +4576,7 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
  N_("instead of applying the patch, output a summary for the input")),
  OPT_BOOL(0, "check", &state.check,
  N_("instead of applying the patch, see if the patch is applicable")),
- OPT_BOOL(0, "index", &check_index,
+ OPT_BOOL(0, "index", &state.check_index,
  N_("make sure the patch is applicable to the current index")),
  OPT_BOOL(0, "cached", &cached,
  N_("apply a patch without touching the working tree")),
@@ -4632,20 +4643,20 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
  if (threeway) {
  if (is_not_gitdir)
  die(_("--3way outside a repository"));
- check_index = 1;
+ state.check_index = 1;
  }
  if (apply_with_reject)
  apply = apply_verbosely = 1;
  if (!force_apply && (diffstat || numstat || summary || state.check || fake_ancestor))
  apply = 0;
- if (check_index && is_not_gitdir)
+ if (state.check_index && is_not_gitdir)
  die(_("--index outside a repository"));
  if (cached) {
  if (is_not_gitdir)
  die(_("--cached outside a repository"));
- check_index = 1;
+ state.check_index = 1;
  }
- if (check_index)
+ if (state.check_index)
  unsafe_paths = 0;
 
  for (i = 0; i < argc; i++) {
--
2.8.1.300.g5fed0c0

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[PATCH 11/83] builtin/apply: move 'apply_in_reverse' global into 'struct apply_state'

Christian Couder-2
In reply to this post by Christian Couder-2
Signed-off-by: Christian Couder <[hidden email]>
---
 builtin/apply.c | 51 ++++++++++++++++++++++++++++++++-------------------
 1 file changed, 32 insertions(+), 19 deletions(-)

diff --git a/builtin/apply.c b/builtin/apply.c
index 3f8671c..755e0e3 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -25,6 +25,8 @@ struct apply_state {
  const char *prefix;
  int prefix_length;
 
+ int apply_in_reverse;
+
  /*
  *  --check turns on checking that the working tree matches the
  *    files that are being modified, but doesn't apply the patch
@@ -53,7 +55,6 @@ static int diffstat;
 static int numstat;
 static int summary;
 static int apply = 1;
-static int apply_in_reverse;
 static int apply_with_reject;
 static int apply_verbosely;
 static int allow_overlap;
@@ -1561,8 +1562,11 @@ static void check_whitespace(const char *line, int len, unsigned ws_rule)
  * between a "---" that is part of a patch, and a "---" that starts
  * the next patch is to look at the line counts..
  */
-static int parse_fragment(const char *line, unsigned long size,
-  struct patch *patch, struct fragment *fragment)
+static int parse_fragment(struct apply_state *state,
+  const char *line,
+  unsigned long size,
+  struct patch *patch,
+  struct fragment *fragment)
 {
  int added, deleted;
  int len = linelen(line, size), offset;
@@ -1602,12 +1606,12 @@ static int parse_fragment(const char *line, unsigned long size,
  if (!deleted && !added)
  leading++;
  trailing++;
- if (!apply_in_reverse &&
+ if (!state->apply_in_reverse &&
     ws_error_action == correct_ws_error)
  check_whitespace(line, len, patch->ws_rule);
  break;
  case '-':
- if (apply_in_reverse &&
+ if (state->apply_in_reverse &&
     ws_error_action != nowarn_ws_error)
  check_whitespace(line, len, patch->ws_rule);
  deleted++;
@@ -1615,7 +1619,7 @@ static int parse_fragment(const char *line, unsigned long size,
  trailing = 0;
  break;
  case '+':
- if (!apply_in_reverse &&
+ if (!state->apply_in_reverse &&
     ws_error_action != nowarn_ws_error)
  check_whitespace(line, len, patch->ws_rule);
  added++;
@@ -1671,7 +1675,10 @@ static int parse_fragment(const char *line, unsigned long size,
  * The (fragment->patch, fragment->size) pair points into the memory given
  * by the caller, not a copy, when we return.
  */
-static int parse_single_patch(const char *line, unsigned long size, struct patch *patch)
+static int parse_single_patch(struct apply_state *state,
+      const char *line,
+      unsigned long size,
+      struct patch *patch)
 {
  unsigned long offset = 0;
  unsigned long oldlines = 0, newlines = 0, context = 0;
@@ -1683,7 +1690,7 @@ static int parse_single_patch(const char *line, unsigned long size, struct patch
 
  fragment = xcalloc(1, sizeof(*fragment));
  fragment->linenr = linenr;
- len = parse_fragment(line, size, patch, fragment);
+ len = parse_fragment(state, line, size, patch, fragment);
  if (len <= 0)
  die(_("corrupt patch at line %d"), linenr);
  fragment->patch = line;
@@ -2013,8 +2020,10 @@ static int parse_chunk(struct apply_state *state, char *buffer, unsigned long si
  ? patch->new_name
  : patch->old_name);
 
- patchsize = parse_single_patch(buffer + offset + hdrsize,
-       size - offset - hdrsize, patch);
+ patchsize = parse_single_patch(state,
+       buffer + offset + hdrsize,
+       size - offset - hdrsize,
+       patch);
 
  if (!patchsize) {
  static const char git_binary[] = "GIT binary patch\n";
@@ -2747,7 +2756,7 @@ static int apply_one_fragment(struct apply_state *state,
  if (len < size && patch[len] == '\\')
  plen--;
  first = *patch;
- if (apply_in_reverse) {
+ if (state->apply_in_reverse) {
  if (first == '-')
  first = '+';
  else if (first == '+')
@@ -2920,7 +2929,7 @@ static int apply_one_fragment(struct apply_state *state,
 
  if (apply_verbosely && applied_pos != pos) {
  int offset = applied_pos - pos;
- if (apply_in_reverse)
+ if (state->apply_in_reverse)
  offset = 0 - offset;
  fprintf_ln(stderr,
    Q_("Hunk #%d succeeded at %d (offset %d line).",
@@ -2954,7 +2963,9 @@ out:
  return (applied_pos < 0);
 }
 
-static int apply_binary_fragment(struct image *img, struct patch *patch)
+static int apply_binary_fragment(struct apply_state *state,
+ struct image *img,
+ struct patch *patch)
 {
  struct fragment *fragment = patch->fragments;
  unsigned long len;
@@ -2967,7 +2978,7 @@ static int apply_binary_fragment(struct image *img, struct patch *patch)
      patch->old_name);
 
  /* Binary patch is irreversible without the optional second hunk */
- if (apply_in_reverse) {
+ if (state->apply_in_reverse) {
  if (!fragment->next)
  return error("cannot reverse-apply a binary patch "
      "without the reverse hunk to '%s'",
@@ -3000,7 +3011,9 @@ static int apply_binary_fragment(struct image *img, struct patch *patch)
  * but the preimage prepared by the caller in "img" is freed here
  * or in the helper function apply_binary_fragment() this calls.
  */
-static int apply_binary(struct image *img, struct patch *patch)
+static int apply_binary(struct apply_state *state,
+ struct image *img,
+ struct patch *patch)
 {
  const char *name = patch->old_name ? patch->old_name : patch->new_name;
  unsigned char sha1[20];
@@ -3061,7 +3074,7 @@ static int apply_binary(struct image *img, struct patch *patch)
  * apply the patch data to it, which is stored
  * in the patch->fragments->{patch,size}.
  */
- if (apply_binary_fragment(img, patch))
+ if (apply_binary_fragment(state, img, patch))
  return error(_("binary patch does not apply to '%s'"),
      name);
 
@@ -3084,7 +3097,7 @@ static int apply_fragments(struct apply_state *state, struct image *img, struct
  int nth = 0;
 
  if (patch->is_binary)
- return apply_binary(img, patch);
+ return apply_binary(state, img, patch);
 
  while (frag) {
  nth++;
@@ -4423,7 +4436,7 @@ static int apply_patch(struct apply_state *state,
  free_patch(patch);
  break;
  }
- if (apply_in_reverse)
+ if (state->apply_in_reverse)
  reverse_patches(patch);
  if (use_patch(state, patch)) {
  patch_stats(patch);
@@ -4602,7 +4615,7 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
  { OPTION_CALLBACK, 0, "ignore-whitespace", NULL, NULL,
  N_("ignore changes in whitespace when finding context"),
  PARSE_OPT_NOARG, option_parse_space_change },
- OPT_BOOL('R', "reverse", &apply_in_reverse,
+ OPT_BOOL('R', "reverse", &state.apply_in_reverse,
  N_("apply the patch in reverse")),
  OPT_BOOL(0, "unidiff-zero", &state.unidiff_zero,
  N_("don't expect at least one line of context")),
--
2.8.1.300.g5fed0c0

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[PATCH 12/83] builtin/apply: move 'apply_with_reject' global into 'struct apply_state'

Christian Couder-2
In reply to this post by Christian Couder-2
Signed-off-by: Christian Couder <[hidden email]>
---
 builtin/apply.c | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/builtin/apply.c b/builtin/apply.c
index 755e0e3..67560e4 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -26,6 +26,7 @@ struct apply_state {
  int prefix_length;
 
  int apply_in_reverse;
+ int apply_with_reject;
 
  /*
  *  --check turns on checking that the working tree matches the
@@ -55,7 +56,6 @@ static int diffstat;
 static int numstat;
 static int summary;
 static int apply = 1;
-static int apply_with_reject;
 static int apply_verbosely;
 static int allow_overlap;
 static int no_add;
@@ -3103,7 +3103,7 @@ static int apply_fragments(struct apply_state *state, struct image *img, struct
  nth++;
  if (apply_one_fragment(state, img, frag, inaccurate_eof, ws_rule, nth)) {
  error(_("patch failed: %s:%ld"), name, frag->oldpos);
- if (!apply_with_reject)
+ if (!state->apply_with_reject)
  return -1;
  frag->rejected = 1;
  }
@@ -4469,11 +4469,11 @@ static int apply_patch(struct apply_state *state,
 
  if ((state->check || apply) &&
     check_patch_list(state, list) < 0 &&
-    !apply_with_reject)
+    !state->apply_with_reject)
  exit(1);
 
  if (apply && write_out_results(list)) {
- if (apply_with_reject)
+ if (state->apply_with_reject)
  exit(1);
  /* with --3way, we still need to write the index out */
  return 1;
@@ -4619,7 +4619,7 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
  N_("apply the patch in reverse")),
  OPT_BOOL(0, "unidiff-zero", &state.unidiff_zero,
  N_("don't expect at least one line of context")),
- OPT_BOOL(0, "reject", &apply_with_reject,
+ OPT_BOOL(0, "reject", &state.apply_with_reject,
  N_("leave the rejected hunks in corresponding *.rej files")),
  OPT_BOOL(0, "allow-overlap", &allow_overlap,
  N_("allow overlapping hunks")),
@@ -4649,7 +4649,7 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
  argc = parse_options(argc, argv, state.prefix, builtin_apply_options,
  apply_usage, 0);
 
- if (apply_with_reject && threeway)
+ if (state.apply_with_reject && threeway)
  die("--reject and --3way cannot be used together.");
  if (cached && threeway)
  die("--cached and --3way cannot be used together.");
@@ -4658,7 +4658,7 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
  die(_("--3way outside a repository"));
  state.check_index = 1;
  }
- if (apply_with_reject)
+ if (state.apply_with_reject)
  apply = apply_verbosely = 1;
  if (!force_apply && (diffstat || numstat || summary || state.check || fake_ancestor))
  apply = 0;
--
2.8.1.300.g5fed0c0

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[PATCH 13/83] builtin/apply: move 'apply_verbosely' global into 'struct apply_state'

Christian Couder-2
In reply to this post by Christian Couder-2
Signed-off-by: Christian Couder <[hidden email]>
---
 builtin/apply.c | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/builtin/apply.c b/builtin/apply.c
index 67560e4..154679e 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -27,6 +27,7 @@ struct apply_state {
 
  int apply_in_reverse;
  int apply_with_reject;
+ int apply_verbosely;
 
  /*
  *  --check turns on checking that the working tree matches the
@@ -56,7 +57,6 @@ static int diffstat;
 static int numstat;
 static int summary;
 static int apply = 1;
-static int apply_verbosely;
 static int allow_overlap;
 static int no_add;
 static int threeway;
@@ -2812,7 +2812,7 @@ static int apply_one_fragment(struct apply_state *state,
  /* Ignore it, we already handled it */
  break;
  default:
- if (apply_verbosely)
+ if (state->apply_verbosely)
  error(_("invalid start of line: '%c'"), first);
  applied_pos = -1;
  goto out;
@@ -2927,7 +2927,7 @@ static int apply_one_fragment(struct apply_state *state,
  apply = 0;
  }
 
- if (apply_verbosely && applied_pos != pos) {
+ if (state->apply_verbosely && applied_pos != pos) {
  int offset = applied_pos - pos;
  if (state->apply_in_reverse)
  offset = 0 - offset;
@@ -2949,7 +2949,7 @@ static int apply_one_fragment(struct apply_state *state,
    leading, trailing, applied_pos+1);
  update_image(img, applied_pos, &preimage, &postimage);
  } else {
- if (apply_verbosely)
+ if (state->apply_verbosely)
  error(_("while searching for:\n%.*s"),
       (int)(old - oldlines), oldlines);
  }
@@ -3863,7 +3863,7 @@ static int check_patch_list(struct apply_state *state, struct patch *patch)
  prepare_symlink_changes(patch);
  prepare_fn_table(patch);
  while (patch) {
- if (apply_verbosely)
+ if (state->apply_verbosely)
  say_patch_name(stderr,
        _("Checking patch %s..."), patch);
  err |= check_patch(state, patch);
@@ -4294,7 +4294,7 @@ static void write_out_one_result(struct patch *patch, int phase)
  create_file(patch);
 }
 
-static int write_out_one_reject(struct patch *patch)
+static int write_out_one_reject(struct apply_state *state, struct patch *patch)
 {
  FILE *rej;
  char namebuf[PATH_MAX];
@@ -4309,7 +4309,7 @@ static int write_out_one_reject(struct patch *patch)
  }
 
  if (!cnt) {
- if (apply_verbosely)
+ if (state->apply_verbosely)
  say_patch_name(stderr,
        _("Applied patch %s cleanly."), patch);
  return 0;
@@ -4365,7 +4365,7 @@ static int write_out_one_reject(struct patch *patch)
  return -1;
 }
 
-static int write_out_results(struct patch *list)
+static int write_out_results(struct apply_state *state, struct patch *list)
 {
  int phase;
  int errs = 0;
@@ -4380,7 +4380,7 @@ static int write_out_results(struct patch *list)
  else {
  write_out_one_result(l, phase);
  if (phase == 1) {
- if (write_out_one_reject(l))
+ if (write_out_one_reject(state, l))
  errs = 1;
  if (l->conflicted_threeway) {
  string_list_append(&cpath, l->new_name);
@@ -4444,7 +4444,7 @@ static int apply_patch(struct apply_state *state,
  listp = &patch->next;
  }
  else {
- if (apply_verbosely)
+ if (state->apply_verbosely)
  say_patch_name(stderr, _("Skipped patch '%s'."), patch);
  free_patch(patch);
  skipped_patch++;
@@ -4472,7 +4472,7 @@ static int apply_patch(struct apply_state *state,
     !state->apply_with_reject)
  exit(1);
 
- if (apply && write_out_results(list)) {
+ if (apply && write_out_results(state, list)) {
  if (state->apply_with_reject)
  exit(1);
  /* with --3way, we still need to write the index out */
@@ -4623,7 +4623,7 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
  N_("leave the rejected hunks in corresponding *.rej files")),
  OPT_BOOL(0, "allow-overlap", &allow_overlap,
  N_("allow overlapping hunks")),
- OPT__VERBOSE(&apply_verbosely, N_("be verbose")),
+ OPT__VERBOSE(&state.apply_verbosely, N_("be verbose")),
  OPT_BIT(0, "inaccurate-eof", &options,
  N_("tolerate incorrectly detected missing new-line at the end of file"),
  INACCURATE_EOF),
@@ -4659,7 +4659,7 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
  state.check_index = 1;
  }
  if (state.apply_with_reject)
- apply = apply_verbosely = 1;
+ apply = state.apply_verbosely = 1;
  if (!force_apply && (diffstat || numstat || summary || state.check || fake_ancestor))
  apply = 0;
  if (state.check_index && is_not_gitdir)
--
2.8.1.300.g5fed0c0

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[PATCH 14/83] builtin/apply: move 'update_index' global into 'struct apply_state'

Christian Couder-2
In reply to this post by Christian Couder-2
Signed-off-by: Christian Couder <[hidden email]>
---
 builtin/apply.c | 46 +++++++++++++++++++++++++++-------------------
 1 file changed, 27 insertions(+), 19 deletions(-)

diff --git a/builtin/apply.c b/builtin/apply.c
index 154679e..b57be2c 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -39,6 +39,8 @@ struct apply_state {
  int check_index;
 
  int unidiff_zero;
+
+ int update_index;
 };
 
 /*
@@ -51,7 +53,6 @@ static int newfd = -1;
 
 static int state_p_value = 1;
 static int p_value_known;
-static int update_index;
 static int cached;
 static int diffstat;
 static int numstat;
@@ -4097,9 +4098,9 @@ static void patch_stats(struct patch *patch)
  }
 }
 
-static void remove_file(struct patch *patch, int rmdir_empty)
+static void remove_file(struct apply_state *state, struct patch *patch, int rmdir_empty)
 {
- if (update_index) {
+ if (state->update_index) {
  if (remove_file_from_cache(patch->old_name) < 0)
  die(_("unable to remove %s from index"), patch->old_name);
  }
@@ -4110,14 +4111,18 @@ static void remove_file(struct patch *patch, int rmdir_empty)
  }
 }
 
-static void add_index_file(const char *path, unsigned mode, void *buf, unsigned long size)
+static void add_index_file(struct apply_state *state,
+   const char *path,
+   unsigned mode,
+   void *buf,
+   unsigned long size)
 {
  struct stat st;
  struct cache_entry *ce;
  int namelen = strlen(path);
  unsigned ce_size = cache_entry_size(namelen);
 
- if (!update_index)
+ if (!state->update_index)
  return;
 
  ce = xcalloc(1, ce_size);
@@ -4227,13 +4232,14 @@ static void create_one_file(char *path, unsigned mode, const char *buf, unsigned
  die_errno(_("unable to write file '%s' mode %o"), path, mode);
 }
 
-static void add_conflicted_stages_file(struct patch *patch)
+static void add_conflicted_stages_file(struct apply_state *state,
+       struct patch *patch)
 {
  int stage, namelen;
  unsigned ce_size, mode;
  struct cache_entry *ce;
 
- if (!update_index)
+ if (!state->update_index)
  return;
  namelen = strlen(patch->new_name);
  ce_size = cache_entry_size(namelen);
@@ -4254,7 +4260,7 @@ static void add_conflicted_stages_file(struct patch *patch)
  }
 }
 
-static void create_file(struct patch *patch)
+static void create_file(struct apply_state *state, struct patch *patch)
 {
  char *path = patch->new_name;
  unsigned mode = patch->new_mode;
@@ -4266,22 +4272,24 @@ static void create_file(struct patch *patch)
  create_one_file(path, mode, buf, size);
 
  if (patch->conflicted_threeway)
- add_conflicted_stages_file(patch);
+ add_conflicted_stages_file(state, patch);
  else
- add_index_file(path, mode, buf, size);
+ add_index_file(state, path, mode, buf, size);
 }
 
 /* phase zero is to remove, phase one is to create */
-static void write_out_one_result(struct patch *patch, int phase)
+static void write_out_one_result(struct apply_state *state,
+ struct patch *patch,
+ int phase)
 {
  if (patch->is_delete > 0) {
  if (phase == 0)
- remove_file(patch, 1);
+ remove_file(state, patch, 1);
  return;
  }
  if (patch->is_new > 0 || patch->is_copy) {
  if (phase == 1)
- create_file(patch);
+ create_file(state, patch);
  return;
  }
  /*
@@ -4289,9 +4297,9 @@ static void write_out_one_result(struct patch *patch, int phase)
  * thing: remove the old, write the new
  */
  if (phase == 0)
- remove_file(patch, patch->is_rename);
+ remove_file(state, patch, patch->is_rename);
  if (phase == 1)
- create_file(patch);
+ create_file(state, patch);
 }
 
 static int write_out_one_reject(struct apply_state *state, struct patch *patch)
@@ -4378,7 +4386,7 @@ static int write_out_results(struct apply_state *state, struct patch *list)
  if (l->rejected)
  errs = 1;
  else {
- write_out_one_result(l, phase);
+ write_out_one_result(state, l, phase);
  if (phase == 1) {
  if (write_out_one_reject(state, l))
  errs = 1;
@@ -4458,8 +4466,8 @@ static int apply_patch(struct apply_state *state,
  if (whitespace_error && (ws_error_action == die_on_ws_error))
  apply = 0;
 
- update_index = state->check_index && apply;
- if (update_index && newfd < 0)
+ state->update_index = state->check_index && apply;
+ if (state->update_index && newfd < 0)
  newfd = hold_locked_index(&lock_file, 1);
 
  if (state->check_index) {
@@ -4723,7 +4731,7 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
  whitespace_error);
  }
 
- if (update_index) {
+ if (state.update_index) {
  if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK))
  die(_("Unable to write new index file"));
  }
--
2.8.1.300.g5fed0c0

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[PATCH 15/83] builtin/apply: move 'allow_overlap' global into 'struct apply_state'

Christian Couder-2
In reply to this post by Christian Couder-2
Signed-off-by: Christian Couder <[hidden email]>
---
 builtin/apply.c | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/builtin/apply.c b/builtin/apply.c
index b57be2c..a5dff99 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -25,6 +25,7 @@ struct apply_state {
  const char *prefix;
  int prefix_length;
 
+ int allow_overlap;
  int apply_in_reverse;
  int apply_with_reject;
  int apply_verbosely;
@@ -58,7 +59,6 @@ static int diffstat;
 static int numstat;
 static int summary;
 static int apply = 1;
-static int allow_overlap;
 static int no_add;
 static int threeway;
 static int unsafe_paths;
@@ -2635,7 +2635,8 @@ static void remove_last_line(struct image *img)
  * apply at applied_pos (counts in line numbers) in "img".
  * Update "img" to remove "preimage" and replace it with "postimage".
  */
-static void update_image(struct image *img,
+static void update_image(struct apply_state *state,
+ struct image *img,
  int applied_pos,
  struct image *preimage,
  struct image *postimage)
@@ -2700,7 +2701,7 @@ static void update_image(struct image *img,
  memcpy(img->line + applied_pos,
        postimage->line,
        postimage->nr * sizeof(*img->line));
- if (!allow_overlap)
+ if (!state->allow_overlap)
  for (i = 0; i < postimage->nr; i++)
  img->line[applied_pos + i].flag |= LINE_PATCHED;
  img->nr = nr;
@@ -2948,7 +2949,7 @@ static int apply_one_fragment(struct apply_state *state,
  fprintf_ln(stderr, _("Context reduced to (%ld/%ld)"
      " to apply fragment at %d"),
    leading, trailing, applied_pos+1);
- update_image(img, applied_pos, &preimage, &postimage);
+ update_image(state, img, applied_pos, &preimage, &postimage);
  } else {
  if (state->apply_verbosely)
  error(_("while searching for:\n%.*s"),
@@ -4629,7 +4630,7 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
  N_("don't expect at least one line of context")),
  OPT_BOOL(0, "reject", &state.apply_with_reject,
  N_("leave the rejected hunks in corresponding *.rej files")),
- OPT_BOOL(0, "allow-overlap", &allow_overlap,
+ OPT_BOOL(0, "allow-overlap", &state.allow_overlap,
  N_("allow overlapping hunks")),
  OPT__VERBOSE(&state.apply_verbosely, N_("be verbose")),
  OPT_BIT(0, "inaccurate-eof", &options,
--
2.8.1.300.g5fed0c0

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[PATCH 16/83] builtin/apply: move 'cached' global into 'struct apply_state'

Christian Couder-2
In reply to this post by Christian Couder-2
Signed-off-by: Christian Couder <[hidden email]>
---
 builtin/apply.c | 37 +++++++++++++++++++++----------------
 1 file changed, 21 insertions(+), 16 deletions(-)

diff --git a/builtin/apply.c b/builtin/apply.c
index a5dff99..ba828df 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -30,6 +30,9 @@ struct apply_state {
  int apply_with_reject;
  int apply_verbosely;
 
+ /* --cached updates only the cache without ever touching the working tree. */
+ int cached;
+
  /*
  *  --check turns on checking that the working tree matches the
  *    files that are being modified, but doesn't apply the patch
@@ -48,13 +51,11 @@ struct apply_state {
  *  --stat does just a diffstat, and doesn't actually apply
  *  --numstat does numeric diffstat, and doesn't actually apply
  *  --index-info shows the old and new index info for paths if available.
- *  --cached updates only the cache without ever touching the working tree.
  */
 static int newfd = -1;
 
 static int state_p_value = 1;
 static int p_value_known;
-static int cached;
 static int diffstat;
 static int numstat;
 static int summary;
@@ -3272,7 +3273,7 @@ static int load_patch_target(struct apply_state *state,
      const char *name,
      unsigned expected_mode)
 {
- if (cached || state->check_index) {
+ if (state->cached || state->check_index) {
  if (read_file_or_gitlink(ce, buf))
  return error(_("read of %s failed"), name);
  } else if (name) {
@@ -3545,7 +3546,7 @@ static int check_preimage(struct apply_state *state,
  return error(_("path %s has been renamed/deleted"), old_name);
  if (previous) {
  st_mode = previous->new_mode;
- } else if (!cached) {
+ } else if (!state->cached) {
  stat_ret = lstat(old_name, st);
  if (stat_ret && errno != ENOENT)
  return error(_("%s: %s"), old_name, strerror(errno));
@@ -3563,9 +3564,9 @@ static int check_preimage(struct apply_state *state,
  if (checkout_target(&the_index, *ce, st))
  return -1;
  }
- if (!cached && verify_index_match(*ce, st))
+ if (!state->cached && verify_index_match(*ce, st))
  return error(_("%s: does not match index"), old_name);
- if (cached)
+ if (state->cached)
  st_mode = (*ce)->ce_mode;
  } else if (stat_ret < 0) {
  if (patch->is_new < 0)
@@ -3573,7 +3574,7 @@ static int check_preimage(struct apply_state *state,
  return error(_("%s: %s"), old_name, strerror(errno));
  }
 
- if (!cached && !previous)
+ if (!state->cached && !previous)
  st_mode = ce_mode_from_stat(*ce, st->st_mode);
 
  if (patch->is_new < 0)
@@ -3611,7 +3612,7 @@ static int check_to_create(struct apply_state *state,
     cache_name_pos(new_name, strlen(new_name)) >= 0 &&
     !ok_if_exists)
  return EXISTS_IN_INDEX;
- if (cached)
+ if (state->cached)
  return 0;
 
  if (!lstat(new_name, &nst)) {
@@ -4105,7 +4106,7 @@ static void remove_file(struct apply_state *state, struct patch *patch, int rmdi
  if (remove_file_from_cache(patch->old_name) < 0)
  die(_("unable to remove %s from index"), patch->old_name);
  }
- if (!cached) {
+ if (!state->cached) {
  if (!remove_or_warn(patch->old_mode, patch->old_name) && rmdir_empty) {
  remove_path(patch->old_name);
  }
@@ -4138,7 +4139,7 @@ static void add_index_file(struct apply_state *state,
     get_sha1_hex(s, ce->sha1))
  die(_("corrupt patch for submodule %s"), path);
  } else {
- if (!cached) {
+ if (!state->cached) {
  if (lstat(path, &st) < 0)
  die_errno(_("unable to stat newly created file '%s'"),
   path);
@@ -4190,9 +4191,13 @@ static int try_create_file(const char *path, unsigned int mode, const char *buf,
  * which is true 99% of the time anyway. If they don't,
  * we create them and try again.
  */
-static void create_one_file(char *path, unsigned mode, const char *buf, unsigned long size)
+static void create_one_file(struct apply_state *state,
+    char *path,
+    unsigned mode,
+    const char *buf,
+    unsigned long size)
 {
- if (cached)
+ if (state->cached)
  return;
  if (!try_create_file(path, mode, buf, size))
  return;
@@ -4270,7 +4275,7 @@ static void create_file(struct apply_state *state, struct patch *patch)
 
  if (!mode)
  mode = S_IFREG | 0644;
- create_one_file(path, mode, buf, size);
+ create_one_file(state, path, mode, buf, size);
 
  if (patch->conflicted_threeway)
  add_conflicted_stages_file(state, patch);
@@ -4600,7 +4605,7 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
  N_("instead of applying the patch, see if the patch is applicable")),
  OPT_BOOL(0, "index", &state.check_index,
  N_("make sure the patch is applicable to the current index")),
- OPT_BOOL(0, "cached", &cached,
+ OPT_BOOL(0, "cached", &state.cached,
  N_("apply a patch without touching the working tree")),
  OPT_BOOL(0, "unsafe-paths", &unsafe_paths,
  N_("accept a patch that touches outside the working area")),
@@ -4660,7 +4665,7 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
 
  if (state.apply_with_reject && threeway)
  die("--reject and --3way cannot be used together.");
- if (cached && threeway)
+ if (state.cached && threeway)
  die("--cached and --3way cannot be used together.");
  if (threeway) {
  if (is_not_gitdir)
@@ -4673,7 +4678,7 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
  apply = 0;
  if (state.check_index && is_not_gitdir)
  die(_("--index outside a repository"));
- if (cached) {
+ if (state.cached) {
  if (is_not_gitdir)
  die(_("--cached outside a repository"));
  state.check_index = 1;
--
2.8.1.300.g5fed0c0

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[PATCH 17/83] builtin/apply: move 'diffstat' global into 'struct apply_state'

Christian Couder-2
In reply to this post by Christian Couder-2
Signed-off-by: Christian Couder <[hidden email]>
---
 builtin/apply.c | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/builtin/apply.c b/builtin/apply.c
index ba828df..d90948a 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -33,6 +33,9 @@ struct apply_state {
  /* --cached updates only the cache without ever touching the working tree. */
  int cached;
 
+ /* --stat does just a diffstat, and doesn't actually apply */
+ int diffstat;
+
  /*
  *  --check turns on checking that the working tree matches the
  *    files that are being modified, but doesn't apply the patch
@@ -48,7 +51,6 @@ struct apply_state {
 };
 
 /*
- *  --stat does just a diffstat, and doesn't actually apply
  *  --numstat does numeric diffstat, and doesn't actually apply
  *  --index-info shows the old and new index info for paths if available.
  */
@@ -56,7 +58,6 @@ static int newfd = -1;
 
 static int state_p_value = 1;
 static int p_value_known;
-static int diffstat;
 static int numstat;
 static int summary;
 static int apply = 1;
@@ -4496,7 +4497,7 @@ static int apply_patch(struct apply_state *state,
  if (fake_ancestor)
  build_fake_ancestor(list, fake_ancestor);
 
- if (diffstat)
+ if (state->diffstat)
  stat_patch_list(list);
 
  if (numstat)
@@ -4593,7 +4594,7 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
  0, option_parse_p },
  OPT_BOOL(0, "no-add", &no_add,
  N_("ignore additions made by the patch")),
- OPT_BOOL(0, "stat", &diffstat,
+ OPT_BOOL(0, "stat", &state.diffstat,
  N_("instead of applying the patch, output diffstat for the input")),
  OPT_NOOP_NOARG(0, "allow-binary-replacement"),
  OPT_NOOP_NOARG(0, "binary"),
@@ -4674,7 +4675,7 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
  }
  if (state.apply_with_reject)
  apply = state.apply_verbosely = 1;
- if (!force_apply && (diffstat || numstat || summary || state.check || fake_ancestor))
+ if (!force_apply && (state.diffstat || numstat || summary || state.check || fake_ancestor))
  apply = 0;
  if (state.check_index && is_not_gitdir)
  die(_("--index outside a repository"));
--
2.8.1.300.g5fed0c0

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[PATCH 18/83] builtin/apply: move 'numstat' global into 'struct apply_state'

Christian Couder-2
In reply to this post by Christian Couder-2
Signed-off-by: Christian Couder <[hidden email]>
---
 builtin/apply.c | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/builtin/apply.c b/builtin/apply.c
index d90948a..16d78f9 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -36,6 +36,9 @@ struct apply_state {
  /* --stat does just a diffstat, and doesn't actually apply */
  int diffstat;
 
+ /* --numstat does numeric diffstat, and doesn't actually apply */
+ int numstat;
+
  /*
  *  --check turns on checking that the working tree matches the
  *    files that are being modified, but doesn't apply the patch
@@ -51,14 +54,12 @@ struct apply_state {
 };
 
 /*
- *  --numstat does numeric diffstat, and doesn't actually apply
  *  --index-info shows the old and new index info for paths if available.
  */
 static int newfd = -1;
 
 static int state_p_value = 1;
 static int p_value_known;
-static int numstat;
 static int summary;
 static int apply = 1;
 static int no_add;
@@ -4500,7 +4501,7 @@ static int apply_patch(struct apply_state *state,
  if (state->diffstat)
  stat_patch_list(list);
 
- if (numstat)
+ if (state->numstat)
  numstat_patch_list(list);
 
  if (summary)
@@ -4598,7 +4599,7 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
  N_("instead of applying the patch, output diffstat for the input")),
  OPT_NOOP_NOARG(0, "allow-binary-replacement"),
  OPT_NOOP_NOARG(0, "binary"),
- OPT_BOOL(0, "numstat", &numstat,
+ OPT_BOOL(0, "numstat", &state.numstat,
  N_("show number of added and deleted lines in decimal notation")),
  OPT_BOOL(0, "summary", &summary,
  N_("instead of applying the patch, output a summary for the input")),
@@ -4675,7 +4676,7 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
  }
  if (state.apply_with_reject)
  apply = state.apply_verbosely = 1;
- if (!force_apply && (state.diffstat || numstat || summary || state.check || fake_ancestor))
+ if (!force_apply && (state.diffstat || state.numstat || summary || state.check || fake_ancestor))
  apply = 0;
  if (state.check_index && is_not_gitdir)
  die(_("--index outside a repository"));
--
2.8.1.300.g5fed0c0

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[PATCH 19/83] builtin/apply: move 'summary' global into 'struct apply_state'

Christian Couder-2
In reply to this post by Christian Couder-2
Signed-off-by: Christian Couder <[hidden email]>
---
 builtin/apply.c | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/builtin/apply.c b/builtin/apply.c
index 16d78f9..e488879 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -39,6 +39,8 @@ struct apply_state {
  /* --numstat does numeric diffstat, and doesn't actually apply */
  int numstat;
 
+ int summary;
+
  /*
  *  --check turns on checking that the working tree matches the
  *    files that are being modified, but doesn't apply the patch
@@ -60,7 +62,6 @@ static int newfd = -1;
 
 static int state_p_value = 1;
 static int p_value_known;
-static int summary;
 static int apply = 1;
 static int no_add;
 static int threeway;
@@ -4504,7 +4505,7 @@ static int apply_patch(struct apply_state *state,
  if (state->numstat)
  numstat_patch_list(list);
 
- if (summary)
+ if (state->summary)
  summary_patch_list(list);
 
  free_patch_list(list);
@@ -4601,7 +4602,7 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
  OPT_NOOP_NOARG(0, "binary"),
  OPT_BOOL(0, "numstat", &state.numstat,
  N_("show number of added and deleted lines in decimal notation")),
- OPT_BOOL(0, "summary", &summary,
+ OPT_BOOL(0, "summary", &state.summary,
  N_("instead of applying the patch, output a summary for the input")),
  OPT_BOOL(0, "check", &state.check,
  N_("instead of applying the patch, see if the patch is applicable")),
@@ -4676,7 +4677,7 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
  }
  if (state.apply_with_reject)
  apply = state.apply_verbosely = 1;
- if (!force_apply && (state.diffstat || state.numstat || summary || state.check || fake_ancestor))
+ if (!force_apply && (state.diffstat || state.numstat || state.summary || state.check || fake_ancestor))
  apply = 0;
  if (state.check_index && is_not_gitdir)
  die(_("--index outside a repository"));
--
2.8.1.300.g5fed0c0

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
1234 ... 8