[PATCH v3 00/49] libify apply and use lib in am, part 1

classic Classic list List threaded Threaded
51 messages Options
123
Reply | Threaded
Open this post in threaded view
|

[PATCH v3 40/49] builtin/apply: move 'ws_error_action' into 'struct apply_state'

Christian Couder-2
To libify the apply functionality the 'ws_error_action' variable should
not be static and global to the file. Let's move it into
'struct apply_state'.

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

diff --git a/builtin/apply.c b/builtin/apply.c
index 91b6283..61d809a 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -21,6 +21,13 @@
 #include "ll-merge.h"
 #include "rerere.h"
 
+enum ws_error_action {
+ nowarn_ws_error,
+ warn_on_ws_error,
+ die_on_ws_error,
+ correct_ws_error
+};
+
 struct apply_state {
  const char *prefix;
  int prefix_length;
@@ -61,6 +68,7 @@ struct apply_state {
  int has_include;
 
  /* These control whitespace errors */
+ enum ws_error_action ws_error_action;
  const char *whitespace_option;
  int whitespace_error;
  int squelch_whitespace_errors;
@@ -74,12 +82,6 @@ static const char * const apply_usage[] = {
  NULL
 };
 
-static enum ws_error_action {
- nowarn_ws_error,
- warn_on_ws_error,
- die_on_ws_error,
- correct_ws_error
-} ws_error_action = warn_on_ws_error;
 
 static enum ws_ignore {
  ignore_ws_none,
@@ -90,28 +92,28 @@ static enum ws_ignore {
 static void parse_whitespace_option(struct apply_state *state, const char *option)
 {
  if (!option) {
- ws_error_action = warn_on_ws_error;
+ state->ws_error_action = warn_on_ws_error;
  return;
  }
  if (!strcmp(option, "warn")) {
- ws_error_action = warn_on_ws_error;
+ state->ws_error_action = warn_on_ws_error;
  return;
  }
  if (!strcmp(option, "nowarn")) {
- ws_error_action = nowarn_ws_error;
+ state->ws_error_action = nowarn_ws_error;
  return;
  }
  if (!strcmp(option, "error")) {
- ws_error_action = die_on_ws_error;
+ state->ws_error_action = die_on_ws_error;
  return;
  }
  if (!strcmp(option, "error-all")) {
- ws_error_action = die_on_ws_error;
+ state->ws_error_action = die_on_ws_error;
  state->squelch_whitespace_errors = 0;
  return;
  }
  if (!strcmp(option, "strip") || !strcmp(option, "fix")) {
- ws_error_action = correct_ws_error;
+ state->ws_error_action = correct_ws_error;
  return;
  }
  die(_("unrecognized whitespace option '%s'"), option);
@@ -135,7 +137,7 @@ static void parse_ignorewhitespace_option(const char *option)
 static void set_default_whitespace_mode(struct apply_state *state)
 {
  if (!state->whitespace_option && !apply_default_whitespace)
- ws_error_action = (state->apply ? warn_on_ws_error : nowarn_ws_error);
+ state->ws_error_action = (state->apply ? warn_on_ws_error : nowarn_ws_error);
 }
 
 /*
@@ -1670,12 +1672,12 @@ static int parse_fragment(struct apply_state *state,
  leading++;
  trailing++;
  if (!state->apply_in_reverse &&
-    ws_error_action == correct_ws_error)
+    state->ws_error_action == correct_ws_error)
  check_whitespace(state, line, len, patch->ws_rule);
  break;
  case '-':
  if (state->apply_in_reverse &&
-    ws_error_action != nowarn_ws_error)
+    state->ws_error_action != nowarn_ws_error)
  check_whitespace(state, line, len, patch->ws_rule);
  deleted++;
  oldlines--;
@@ -1683,7 +1685,7 @@ static int parse_fragment(struct apply_state *state,
  break;
  case '+':
  if (!state->apply_in_reverse &&
-    ws_error_action != nowarn_ws_error)
+    state->ws_error_action != nowarn_ws_error)
  check_whitespace(state, line, len, patch->ws_rule);
  added++;
  newlines--;
@@ -2396,7 +2398,8 @@ static int line_by_line_fuzzy_match(struct image *img,
  return 1;
 }
 
-static int match_fragment(struct image *img,
+static int match_fragment(struct apply_state *state,
+  struct image *img,
   struct image *preimage,
   struct image *postimage,
   unsigned long try,
@@ -2417,7 +2420,7 @@ static int match_fragment(struct image *img,
  preimage_limit = preimage->nr;
  if (match_end && (preimage->nr + try_lno != img->nr))
  return 0;
- } else if (ws_error_action == correct_ws_error &&
+ } else if (state->ws_error_action == correct_ws_error &&
    (ws_rule & WS_BLANK_AT_EOF)) {
  /*
  * This hunk extends beyond the end of img, and we are
@@ -2489,7 +2492,7 @@ static int match_fragment(struct image *img,
  return line_by_line_fuzzy_match(img, preimage, postimage,
  try, try_lno, preimage_limit);
 
- if (ws_error_action != correct_ws_error)
+ if (state->ws_error_action != correct_ws_error)
  return 0;
 
  /*
@@ -2601,7 +2604,8 @@ static int match_fragment(struct image *img,
  return 0;
 }
 
-static int find_pos(struct image *img,
+static int find_pos(struct apply_state *state,
+    struct image *img,
     struct image *preimage,
     struct image *postimage,
     int line,
@@ -2645,7 +2649,7 @@ static int find_pos(struct image *img,
  try_lno = line;
 
  for (i = 0; ; i++) {
- if (match_fragment(img, preimage, postimage,
+ if (match_fragment(state, img, preimage, postimage,
    try, try_lno, ws_rule,
    match_beginning, match_end))
  return try_lno;
@@ -2858,7 +2862,7 @@ static int apply_one_fragment(struct apply_state *state,
  start = newlines.len;
  if (first != '+' ||
     !state->whitespace_error ||
-    ws_error_action != correct_ws_error) {
+    state->ws_error_action != correct_ws_error) {
  strbuf_add(&newlines, patch + 1, plen);
  }
  else {
@@ -2936,7 +2940,7 @@ static int apply_one_fragment(struct apply_state *state,
 
  for (;;) {
 
- applied_pos = find_pos(img, &preimage, &postimage, pos,
+ applied_pos = find_pos(state, img, &preimage, &postimage, pos,
        ws_rule, match_beginning, match_end);
 
  if (applied_pos >= 0)
@@ -2972,10 +2976,10 @@ static int apply_one_fragment(struct apply_state *state,
  if (new_blank_lines_at_end &&
     preimage.nr + applied_pos >= img->nr &&
     (ws_rule & WS_BLANK_AT_EOF) &&
-    ws_error_action != nowarn_ws_error) {
+    state->ws_error_action != nowarn_ws_error) {
  record_ws_error(state, WS_BLANK_AT_EOF, "+", 1,
  found_new_blank_lines_at_end);
- if (ws_error_action == correct_ws_error) {
+ if (state->ws_error_action == correct_ws_error) {
  while (new_blank_lines_at_end--)
  remove_last_line(&postimage);
  }
@@ -2986,7 +2990,7 @@ static int apply_one_fragment(struct apply_state *state,
  * apply_patch->check_patch_list->check_patch->
  * apply_data->apply_fragments->apply_one_fragment
  */
- if (ws_error_action == die_on_ws_error)
+ if (state->ws_error_action == die_on_ws_error)
  state->apply = 0;
  }
 
@@ -4530,7 +4534,7 @@ static int apply_patch(struct apply_state *state,
  if (!list && !skipped_patch)
  die(_("unrecognized input"));
 
- if (state->whitespace_error && (ws_error_action == die_on_ws_error))
+ if (state->whitespace_error && (state->ws_error_action == die_on_ws_error))
  state->apply = 0;
 
  state->update_index = state->check_index && state->apply;
@@ -4645,6 +4649,7 @@ static void init_apply_state(struct apply_state *state, const char *prefix)
  state->p_value = 1;
  state->p_context = UINT_MAX;
  state->squelch_whitespace_errors = 5;
+ state->ws_error_action = warn_on_ws_error;
  strbuf_init(&state->root, 0);
 
  git_apply_config();
@@ -4801,7 +4806,7 @@ int cmd_apply(int argc, const char **argv, const char *prefix)
    squelched),
  squelched);
  }
- if (ws_error_action == die_on_ws_error)
+ if (state.ws_error_action == die_on_ws_error)
  die(Q_("%d line adds whitespace errors.",
        "%d lines add whitespace errors.",
        state.whitespace_error),
--
2.8.3.443.gaeee61e

--
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 v3 41/49] builtin/apply: move 'ws_ignore_action' into 'struct apply_state'

Christian Couder-2
In reply to this post by Christian Couder-2
To libify the apply functionality the 'ws_ignore_action' variable should
not be static and global to the file. Let's move it into
'struct apply_state'.

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

diff --git a/builtin/apply.c b/builtin/apply.c
index 61d809a..e5bc9cc 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -28,6 +28,12 @@ enum ws_error_action {
  correct_ws_error
 };
 
+
+enum ws_ignore {
+ ignore_ws_none,
+ ignore_ws_change
+};
+
 struct apply_state {
  const char *prefix;
  int prefix_length;
@@ -69,6 +75,7 @@ struct apply_state {
 
  /* These control whitespace errors */
  enum ws_error_action ws_error_action;
+ enum ws_ignore ws_ignore_action;
  const char *whitespace_option;
  int whitespace_error;
  int squelch_whitespace_errors;
@@ -82,13 +89,6 @@ static const char * const apply_usage[] = {
  NULL
 };
 
-
-static enum ws_ignore {
- ignore_ws_none,
- ignore_ws_change
-} ws_ignore_action = ignore_ws_none;
-
-
 static void parse_whitespace_option(struct apply_state *state, const char *option)
 {
  if (!option) {
@@ -119,16 +119,17 @@ static void parse_whitespace_option(struct apply_state *state, const char *optio
  die(_("unrecognized whitespace option '%s'"), option);
 }
 
-static void parse_ignorewhitespace_option(const char *option)
+static void parse_ignorewhitespace_option(struct apply_state *state,
+  const char *option)
 {
  if (!option || !strcmp(option, "no") ||
     !strcmp(option, "false") || !strcmp(option, "never") ||
     !strcmp(option, "none")) {
- ws_ignore_action = ignore_ws_none;
+ state->ws_ignore_action = ignore_ws_none;
  return;
  }
  if (!strcmp(option, "change")) {
- ws_ignore_action = ignore_ws_change;
+ state->ws_ignore_action = ignore_ws_change;
  return;
  }
  die(_("unrecognized whitespace ignore option '%s'"), option);
@@ -2488,7 +2489,7 @@ static int match_fragment(struct apply_state *state,
  * 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)
+ if (state->ws_ignore_action == ignore_ws_change)
  return line_by_line_fuzzy_match(img, preimage, postimage,
  try, try_lno, preimage_limit);
 
@@ -4611,12 +4612,13 @@ static int option_parse_p(const struct option *opt,
 }
 
 static int option_parse_space_change(const struct option *opt,
-  const char *arg, int unset)
+     const char *arg, int unset)
 {
+ struct apply_state *state = opt->value;
  if (unset)
- ws_ignore_action = ignore_ws_none;
+ state->ws_ignore_action = ignore_ws_none;
  else
- ws_ignore_action = ignore_ws_change;
+ state->ws_ignore_action = ignore_ws_change;
  return 0;
 }
 
@@ -4650,13 +4652,14 @@ static void init_apply_state(struct apply_state *state, const char *prefix)
  state->p_context = UINT_MAX;
  state->squelch_whitespace_errors = 5;
  state->ws_error_action = warn_on_ws_error;
+ state->ws_ignore_action = ignore_ws_none;
  strbuf_init(&state->root, 0);
 
  git_apply_config();
  if (apply_default_whitespace)
  parse_whitespace_option(state, apply_default_whitespace);
  if (apply_default_ignorewhitespace)
- parse_ignorewhitespace_option(apply_default_ignorewhitespace);
+ parse_ignorewhitespace_option(state, apply_default_ignorewhitespace);
 }
 
 static void clear_apply_state(struct apply_state *state)
@@ -4717,10 +4720,10 @@ int cmd_apply(int argc, const char **argv, const char *prefix)
  { OPTION_CALLBACK, 0, "whitespace", &state, N_("action"),
  N_("detect new or modified lines that have whitespace errors"),
  0, option_parse_whitespace },
- { OPTION_CALLBACK, 0, "ignore-space-change", NULL, NULL,
+ { OPTION_CALLBACK, 0, "ignore-space-change", &state, NULL,
  N_("ignore changes in whitespace when finding context"),
  PARSE_OPT_NOARG, option_parse_space_change },
- { OPTION_CALLBACK, 0, "ignore-whitespace", NULL, NULL,
+ { OPTION_CALLBACK, 0, "ignore-whitespace", &state, NULL,
  N_("ignore changes in whitespace when finding context"),
  PARSE_OPT_NOARG, option_parse_space_change },
  OPT_BOOL('R', "reverse", &state.apply_in_reverse,
--
2.8.3.443.gaeee61e

--
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 v3 42/49] builtin/apply: move 'max_change' and 'max_len' into 'struct apply_state'

Christian Couder-2
In reply to this post by Christian Couder-2
To libify the apply functionality the 'max_change' and 'max_len'
variables should not be static and global to the file. Let's move
them into 'struct apply_state'.

Reviewed-by: Stefan Beller <[hidden email]>
Signed-off-by: Christian Couder <[hidden email]>
---
 builtin/apply.c | 49 +++++++++++++++++++++++++------------------------
 1 file changed, 25 insertions(+), 24 deletions(-)

diff --git a/builtin/apply.c b/builtin/apply.c
index e5bc9cc..9e7d181 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -73,6 +73,14 @@ struct apply_state {
  struct string_list limit_by_name;
  int has_include;
 
+ /*
+ * For "diff-stat" like behaviour, we keep track of the biggest change
+ * we've seen, and the longest filename. That allows us to do simple
+ * scaling.
+ */
+ int max_change;
+ int max_len;
+
  /* These control whitespace errors */
  enum ws_error_action ws_error_action;
  enum ws_ignore ws_ignore_action;
@@ -141,13 +149,6 @@ static void set_default_whitespace_mode(struct apply_state *state)
  state->ws_error_action = (state->apply ? warn_on_ws_error : nowarn_ws_error);
 }
 
-/*
- * For "diff-stat" like behaviour, we keep track of the biggest change
- * we've seen, and the longest filename. That allows us to do simple
- * scaling.
- */
-static int max_change, max_len;
-
 /*
  * Various "current state", notably line numbers and what
  * file (and how) we're patching right now.. The "is_xxxx"
@@ -2172,7 +2173,7 @@ static const char pluses[] =
 static const char minuses[]=
 "----------------------------------------------------------------------";
 
-static void show_stats(struct patch *patch)
+static void show_stats(struct apply_state *state, struct patch *patch)
 {
  struct strbuf qname = STRBUF_INIT;
  char *cp = patch->new_name ? patch->new_name : patch->old_name;
@@ -2183,7 +2184,7 @@ static void show_stats(struct patch *patch)
  /*
  * "scale" the filename
  */
- max = max_len;
+ max = state->max_len;
  if (max > 50)
  max = 50;
 
@@ -2206,13 +2207,13 @@ static void show_stats(struct patch *patch)
  /*
  * scale the add/delete
  */
- max = max + max_change > 70 ? 70 - max : max_change;
+ max = max + state->max_change > 70 ? 70 - max : state->max_change;
  add = patch->lines_added;
  del = patch->lines_deleted;
 
- if (max_change > 0) {
- int total = ((add + del) * max + max_change / 2) / max_change;
- add = (add * max + max_change / 2) / max_change;
+ if (state->max_change > 0) {
+ int total = ((add + del) * max + state->max_change / 2) / state->max_change;
+ add = (add * max + state->max_change / 2) / state->max_change;
  del = total - add;
  }
  printf("%5d %.*s%.*s\n", patch->lines_added + patch->lines_deleted,
@@ -4038,7 +4039,7 @@ static void build_fake_ancestor(struct patch *list, const char *filename)
  discard_index(&result);
 }
 
-static void stat_patch_list(struct patch *patch)
+static void stat_patch_list(struct apply_state *state, struct patch *patch)
 {
  int files, adds, dels;
 
@@ -4046,7 +4047,7 @@ static void stat_patch_list(struct patch *patch)
  files++;
  adds += patch->lines_added;
  dels += patch->lines_deleted;
- show_stats(patch);
+ show_stats(state, patch);
  }
 
  print_stat_summary(stdout, files, adds, dels);
@@ -4144,25 +4145,25 @@ static void summary_patch_list(struct patch *patch)
  }
 }
 
-static void patch_stats(struct patch *patch)
+static void patch_stats(struct apply_state *state, struct patch *patch)
 {
  int lines = patch->lines_added + patch->lines_deleted;
 
- if (lines > max_change)
- max_change = lines;
+ if (lines > state->max_change)
+ state->max_change = lines;
  if (patch->old_name) {
  int len = quote_c_style(patch->old_name, NULL, NULL, 0);
  if (!len)
  len = strlen(patch->old_name);
- if (len > max_len)
- max_len = len;
+ if (len > state->max_len)
+ state->max_len = len;
  }
  if (patch->new_name) {
  int len = quote_c_style(patch->new_name, NULL, NULL, 0);
  if (!len)
  len = strlen(patch->new_name);
- if (len > max_len)
- max_len = len;
+ if (len > state->max_len)
+ state->max_len = len;
  }
 }
 
@@ -4519,7 +4520,7 @@ static int apply_patch(struct apply_state *state,
  if (state->apply_in_reverse)
  reverse_patches(patch);
  if (use_patch(state, patch)) {
- patch_stats(patch);
+ patch_stats(state, patch);
  *listp = patch;
  listp = &patch->next;
  }
@@ -4563,7 +4564,7 @@ static int apply_patch(struct apply_state *state,
  build_fake_ancestor(list, state->fake_ancestor);
 
  if (state->diffstat)
- stat_patch_list(list);
+ stat_patch_list(state, list);
 
  if (state->numstat)
  numstat_patch_list(state, list);
--
2.8.3.443.gaeee61e

--
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 v3 43/49] builtin/apply: move 'state_linenr' global into 'struct apply_state'

Christian Couder-2
In reply to this post by Christian Couder-2
To libify the apply functionality the 'state_linenr' variable should
not be static and global to the file. Let's move it into
'struct apply_state'.

Reviewed-by: Stefan Beller <[hidden email]>
Signed-off-by: Christian Couder <[hidden email]>
---
 builtin/apply.c | 71 +++++++++++++++++++++++++++++----------------------------
 1 file changed, 36 insertions(+), 35 deletions(-)

diff --git a/builtin/apply.c b/builtin/apply.c
index 9e7d181..dd56a8e 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -73,6 +73,9 @@ struct apply_state {
  struct string_list limit_by_name;
  int has_include;
 
+ /* Various "current state" */
+ int linenr; /* current line number */
+
  /*
  * For "diff-stat" like behaviour, we keep track of the biggest change
  * we've seen, and the longest filename. That allows us to do simple
@@ -149,13 +152,6 @@ static void set_default_whitespace_mode(struct apply_state *state)
  state->ws_error_action = (state->apply ? warn_on_ws_error : nowarn_ws_error);
 }
 
-/*
- * Various "current state", notably line numbers and what
- * file (and how) we're patching right now.. The "is_xxxx"
- * things are flags, where -1 means "don't know yet".
- */
-static int state_linenr = 1;
-
 /*
  * This represents one "hunk" from a patch, starting with
  * "@@ -oldpos,oldlines +newpos,newlines @@" marker.  The
@@ -932,7 +928,7 @@ static void parse_traditional_patch(struct apply_state *state,
  }
  }
  if (!name)
- die(_("unable to find filename in patch at line %d"), state_linenr);
+ die(_("unable to find filename in patch at line %d"), state->linenr);
 }
 
 static int gitdiff_hdrend(struct apply_state *state,
@@ -970,17 +966,17 @@ static void gitdiff_verify_name(struct apply_state *state,
  char *another;
  if (isnull)
  die(_("git apply: bad git-diff - expected /dev/null, got %s on line %d"),
-    *name, state_linenr);
+    *name, state->linenr);
  another = find_name(state, 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") :
-    _("git apply: bad git-diff - inconsistent old filename on line %d"), state_linenr);
+    _("git apply: bad git-diff - inconsistent old filename on line %d"), state->linenr);
  free(another);
  } 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"), state_linenr);
+ die(_("git apply: bad git-diff - expected /dev/null on line %d"), state->linenr);
  }
 }
 
@@ -1343,8 +1339,8 @@ static int parse_git_header(struct apply_state *state,
 
  line += len;
  size -= len;
- state_linenr++;
- for (offset = len ; size > 0 ; offset += len, size -= len, line += len, state_linenr++) {
+ state->linenr++;
+ for (offset = len ; size > 0 ; offset += len, size -= len, line += len, state->linenr++) {
  static const struct opentry {
  const char *str;
  int (*fn)(struct apply_state *, const char *, struct patch *);
@@ -1515,7 +1511,7 @@ static int find_header(struct apply_state *state,
  patch->is_new = patch->is_delete = -1;
  patch->old_mode = patch->new_mode = 0;
  patch->old_name = patch->new_name = NULL;
- for (offset = 0; size > 0; offset += len, size -= len, line += len, state_linenr++) {
+ for (offset = 0; size > 0; offset += len, size -= len, line += len, state->linenr++) {
  unsigned long nextlen;
 
  len = linelen(line, size);
@@ -1536,7 +1532,7 @@ static int find_header(struct apply_state *state,
  if (parse_fragment_header(line, len, &dummy) < 0)
  continue;
  die(_("patch fragment without header at line %d: %.*s"),
-    state_linenr, (int)len-1, line);
+    state->linenr, (int)len-1, line);
  }
 
  if (size < len + 6)
@@ -1557,13 +1553,13 @@ static int find_header(struct apply_state *state,
        "git diff header lacks filename information when removing "
        "%d leading pathname components (line %d)",
        state->p_value),
-    state->p_value, state_linenr);
+    state->p_value, state->linenr);
  patch->old_name = xstrdup(patch->def_name);
  patch->new_name = xstrdup(patch->def_name);
  }
  if (!patch->is_delete && !patch->new_name)
  die("git diff header lacks filename information "
-    "(line %d)", state_linenr);
+    "(line %d)", state->linenr);
  patch->is_toplevel_relative = 1;
  *hdrsize = git_hdr_len;
  return offset;
@@ -1585,7 +1581,7 @@ static int find_header(struct apply_state *state,
  /* Ok, we'll consider it a patch */
  parse_traditional_patch(state, line, line+len, patch);
  *hdrsize = len + nextlen;
- state_linenr += 2;
+ state->linenr += 2;
  return offset;
  }
  return -1;
@@ -1620,7 +1616,7 @@ static void check_whitespace(struct apply_state *state,
 {
  unsigned result = ws_check(line + 1, len - 1, ws_rule);
 
- record_ws_error(state, result, line + 1, len - 2, state_linenr);
+ record_ws_error(state, result, line + 1, len - 2, state->linenr);
 }
 
 /*
@@ -1653,11 +1649,11 @@ static int parse_fragment(struct apply_state *state,
  /* Parse the thing.. */
  line += len;
  size -= len;
- state_linenr++;
+ state->linenr++;
  added = deleted = 0;
  for (offset = len;
      0 < size;
-     offset += len, size -= len, line += len, state_linenr++) {
+     offset += len, size -= len, line += len, state->linenr++) {
  if (!oldlines && !newlines)
  break;
  len = linelen(line, size);
@@ -1756,10 +1752,10 @@ static int parse_single_patch(struct apply_state *state,
  int len;
 
  fragment = xcalloc(1, sizeof(*fragment));
- fragment->linenr = state_linenr;
+ fragment->linenr = state->linenr;
  len = parse_fragment(state, line, size, patch, fragment);
  if (len <= 0)
- die(_("corrupt patch at line %d"), state_linenr);
+ die(_("corrupt patch at line %d"), state->linenr);
  fragment->patch = line;
  fragment->size = len;
  oldlines += fragment->oldlines;
@@ -1845,7 +1841,8 @@ static char *inflate_it(const void *data, unsigned long size,
  * points at an allocated memory that the caller must free, so
  * it is marked as "->free_patch = 1".
  */
-static struct fragment *parse_binary_hunk(char **buf_p,
+static struct fragment *parse_binary_hunk(struct apply_state *state,
+  char **buf_p,
   unsigned long *sz_p,
   int *status_p,
   int *used_p)
@@ -1887,13 +1884,13 @@ static struct fragment *parse_binary_hunk(char **buf_p,
  else
  return NULL;
 
- state_linenr++;
+ state->linenr++;
  buffer += llen;
  while (1) {
  int byte_length, max_byte_length, newsize;
  llen = linelen(buffer, size);
  used += llen;
- state_linenr++;
+ state->linenr++;
  if (llen == 1) {
  /* consume the blank line */
  buffer++;
@@ -1947,7 +1944,7 @@ static struct fragment *parse_binary_hunk(char **buf_p,
  free(data);
  *status_p = -1;
  error(_("corrupt binary patch at line %d: %.*s"),
-      state_linenr-1, llen-1, buffer);
+      state->linenr-1, llen-1, buffer);
  return NULL;
 }
 
@@ -1956,7 +1953,10 @@ static struct fragment *parse_binary_hunk(char **buf_p,
  *   -1 in case of error,
  *   the length of the parsed binary patch otherwise
  */
-static int parse_binary(char *buffer, unsigned long size, struct patch *patch)
+static int parse_binary(struct apply_state *state,
+ char *buffer,
+ unsigned long size,
+ struct patch *patch)
 {
  /*
  * We have read "GIT binary patch\n"; what follows is a line
@@ -1977,15 +1977,15 @@ static int parse_binary(char *buffer, unsigned long size, struct patch *patch)
  int status;
  int used, used_1;
 
- forward = parse_binary_hunk(&buffer, &size, &status, &used);
+ forward = parse_binary_hunk(state, &buffer, &size, &status, &used);
  if (!forward && !status)
  /* there has to be one hunk (forward hunk) */
- return error(_("unrecognized binary patch at line %d"), state_linenr-1);
+ return error(_("unrecognized binary patch at line %d"), state->linenr-1);
  if (status)
  /* otherwise we already gave an error message */
  return status;
 
- reverse = parse_binary_hunk(&buffer, &size, &status, &used_1);
+ reverse = parse_binary_hunk(state, &buffer, &size, &status, &used_1);
  if (reverse)
  used += used_1;
  else if (status) {
@@ -2100,8 +2100,8 @@ static int parse_chunk(struct apply_state *state, char *buffer, unsigned long si
  if (llen == sizeof(git_binary) - 1 &&
     !memcmp(git_binary, buffer + hd, llen)) {
  int used;
- state_linenr++;
- used = parse_binary(buffer + hd + llen,
+ state->linenr++;
+ used = parse_binary(state, buffer + hd + llen,
     size - hd - llen, patch);
  if (used < 0)
  return -1;
@@ -2121,7 +2121,7 @@ static int parse_chunk(struct apply_state *state, char *buffer, unsigned long si
  int len = strlen(binhdr[i]);
  if (len < size - hd &&
     !memcmp(binhdr[i], buffer + hd, len)) {
- state_linenr++;
+ state->linenr++;
  patch->is_binary = 1;
  patchsize = llen;
  break;
@@ -2135,7 +2135,7 @@ static int parse_chunk(struct apply_state *state, char *buffer, unsigned long si
  */
  if ((state->apply || state->check) &&
     (!patch->is_binary && !metadata_changes(patch)))
- die(_("patch with only garbage at line %d"), state_linenr);
+ die(_("patch with only garbage at line %d"), state->linenr);
  }
 
  return offset + hdrsize + patchsize;
@@ -4654,6 +4654,7 @@ static void init_apply_state(struct apply_state *state, const char *prefix)
  state->squelch_whitespace_errors = 5;
  state->ws_error_action = warn_on_ws_error;
  state->ws_ignore_action = ignore_ws_none;
+ state->linenr = 1;
  strbuf_init(&state->root, 0);
 
  git_apply_config();
--
2.8.3.443.gaeee61e

--
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 v3 44/49] builtin/apply: move 'fn_table' global into 'struct apply_state'

Christian Couder-2
In reply to this post by Christian Couder-2
To libify the apply functionality the 'fn_table' variable should
not be static and global to the file. Let's move it into
'struct apply_state'.

As fn_table is cleared at the end of apply_patch(), it is not
necessary to clear it in clear_apply_state().

Reviewed-by: Stefan Beller <[hidden email]>
Signed-off-by: Christian Couder <[hidden email]>
---
 builtin/apply.c | 47 +++++++++++++++++++++++++----------------------
 1 file changed, 25 insertions(+), 22 deletions(-)

diff --git a/builtin/apply.c b/builtin/apply.c
index dd56a8e..47622be 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -84,6 +84,12 @@ struct apply_state {
  int max_change;
  int max_len;
 
+ /*
+ * Records filenames that have been touched, in order to handle
+ * the case where more than one patches touch the same file.
+ */
+ struct string_list fn_table;
+
  /* These control whitespace errors */
  enum ws_error_action ws_error_action;
  enum ws_ignore ws_ignore_action;
@@ -271,13 +277,6 @@ struct image {
  struct line *line;
 };
 
-/*
- * Records filenames that have been touched, in order to handle
- * the case where more than one patches touch the same file.
- */
-
-static struct string_list fn_table;
-
 static uint32_t hash_line(const char *cp, size_t len)
 {
  size_t i;
@@ -3207,14 +3206,14 @@ static int read_file_or_gitlink(const struct cache_entry *ce, struct strbuf *buf
  return read_blob_object(buf, ce->sha1, ce->ce_mode);
 }
 
-static struct patch *in_fn_table(const char *name)
+static struct patch *in_fn_table(struct apply_state *state, const char *name)
 {
  struct string_list_item *item;
 
  if (name == NULL)
  return NULL;
 
- item = string_list_lookup(&fn_table, name);
+ item = string_list_lookup(&state->fn_table, name);
  if (item != NULL)
  return (struct patch *)item->util;
 
@@ -3246,7 +3245,7 @@ static int was_deleted(struct patch *patch)
  return patch == PATH_WAS_DELETED;
 }
 
-static void add_to_fn_table(struct patch *patch)
+static void add_to_fn_table(struct apply_state *state, struct patch *patch)
 {
  struct string_list_item *item;
 
@@ -3256,7 +3255,7 @@ static void add_to_fn_table(struct patch *patch)
  * file creations and copies
  */
  if (patch->new_name != NULL) {
- item = string_list_insert(&fn_table, patch->new_name);
+ item = string_list_insert(&state->fn_table, patch->new_name);
  item->util = patch;
  }
 
@@ -3265,12 +3264,12 @@ static void add_to_fn_table(struct patch *patch)
  * later chunks shouldn't patch old names
  */
  if ((patch->new_name == NULL) || (patch->is_rename)) {
- item = string_list_insert(&fn_table, patch->old_name);
+ item = string_list_insert(&state->fn_table, patch->old_name);
  item->util = PATH_WAS_DELETED;
  }
 }
 
-static void prepare_fn_table(struct patch *patch)
+static void prepare_fn_table(struct apply_state *state, struct patch *patch)
 {
  /*
  * store information about incoming file deletion
@@ -3278,7 +3277,7 @@ static void prepare_fn_table(struct patch *patch)
  while (patch) {
  if ((patch->new_name == NULL) || (patch->is_rename)) {
  struct string_list_item *item;
- item = string_list_insert(&fn_table, patch->old_name);
+ item = string_list_insert(&state->fn_table, patch->old_name);
  item->util = PATH_TO_BE_DELETED;
  }
  patch = patch->next;
@@ -3299,7 +3298,9 @@ static int checkout_target(struct index_state *istate,
  return 0;
 }
 
-static struct patch *previous_patch(struct patch *patch, int *gone)
+static struct patch *previous_patch(struct apply_state *state,
+    struct patch *patch,
+    int *gone)
 {
  struct patch *previous;
 
@@ -3307,7 +3308,7 @@ static struct patch *previous_patch(struct patch *patch, int *gone)
  if (patch->is_copy || patch->is_rename)
  return NULL; /* "git" patches do not depend on the order */
 
- previous = in_fn_table(patch->old_name);
+ previous = in_fn_table(state, patch->old_name);
  if (!previous)
  return NULL;
 
@@ -3376,7 +3377,7 @@ static int load_preimage(struct apply_state *state,
  struct patch *previous;
  int status;
 
- previous = previous_patch(patch, &status);
+ previous = previous_patch(state, patch, &status);
  if (status)
  return error(_("path %s has been renamed/deleted"),
      patch->old_name);
@@ -3572,7 +3573,7 @@ static int apply_data(struct apply_state *state, struct patch *patch,
  }
  patch->result = image.buf;
  patch->resultsize = image.len;
- add_to_fn_table(patch);
+ add_to_fn_table(state, patch);
  free(image.line_allocated);
 
  if (0 < patch->is_delete && patch->resultsize)
@@ -3606,7 +3607,7 @@ static int check_preimage(struct apply_state *state,
  return 0;
 
  assert(patch->is_new <= 0);
- previous = previous_patch(patch, &status);
+ previous = previous_patch(state, patch, &status);
 
  if (status)
  return error(_("path %s has been renamed/deleted"), old_name);
@@ -3852,7 +3853,7 @@ static int check_patch(struct apply_state *state, struct patch *patch)
  * B and rename from A to B is handled the same way by asking
  * was_deleted().
  */
- if ((tpatch = in_fn_table(new_name)) &&
+ if ((tpatch = in_fn_table(state, new_name)) &&
     (was_deleted(tpatch) || to_be_deleted(tpatch)))
  ok_if_exists = 1;
  else
@@ -3930,7 +3931,7 @@ static int check_patch_list(struct apply_state *state, struct patch *patch)
  int err = 0;
 
  prepare_symlink_changes(patch);
- prepare_fn_table(patch);
+ prepare_fn_table(state, patch);
  while (patch) {
  if (state->apply_verbosely)
  say_patch_name(stderr,
@@ -4574,7 +4575,7 @@ static int apply_patch(struct apply_state *state,
 
  free_patch_list(list);
  strbuf_release(&buf);
- string_list_clear(&fn_table, 0);
+ string_list_clear(&state->fn_table, 0);
  return 0;
 }
 
@@ -4668,6 +4669,8 @@ static void clear_apply_state(struct apply_state *state)
 {
  string_list_clear(&state->limit_by_name, 0);
  strbuf_release(&state->root);
+
+ /* &state->fn_table is cleared at the end of apply_patch() */
 }
 
 int cmd_apply(int argc, const char **argv, const char *prefix)
--
2.8.3.443.gaeee61e

--
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 v3 45/49] builtin/apply: move 'symlink_changes' global into 'struct apply_state'

Christian Couder-2
In reply to this post by Christian Couder-2
To libify the apply functionality the 'symlink_changes' variable should
not be static and global to the file. Let's move it into
'struct apply_state'.

Reviewed-by: Stefan Beller <[hidden email]>
Signed-off-by: Christian Couder <[hidden email]>
---
 builtin/apply.c | 50 ++++++++++++++++++++++++++++----------------------
 1 file changed, 28 insertions(+), 22 deletions(-)

diff --git a/builtin/apply.c b/builtin/apply.c
index 47622be..980bb34 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -34,6 +34,20 @@ enum ws_ignore {
  ignore_ws_change
 };
 
+/*
+ * We need to keep track of how symlinks in the preimage are
+ * manipulated by the patches.  A patch to add a/b/c where a/b
+ * is a symlink should not be allowed to affect the directory
+ * the symlink points at, but if the same patch removes a/b,
+ * it is perfectly fine, as the patch removes a/b to make room
+ * to create a directory a/b so that a/b/c can be created.
+ *
+ * See also "struct string_list symlink_changes" in "struct
+ * apply_state".
+ */
+#define SYMLINK_GOES_AWAY 01
+#define SYMLINK_IN_RESULT 02
+
 struct apply_state {
  const char *prefix;
  int prefix_length;
@@ -75,6 +89,7 @@ struct apply_state {
 
  /* Various "current state" */
  int linenr; /* current line number */
+ struct string_list symlink_changes; /* we have to track symlinks */
 
  /*
  * For "diff-stat" like behaviour, we keep track of the biggest change
@@ -3702,52 +3717,42 @@ static int check_to_create(struct apply_state *state,
  return 0;
 }
 
-/*
- * We need to keep track of how symlinks in the preimage are
- * manipulated by the patches.  A patch to add a/b/c where a/b
- * is a symlink should not be allowed to affect the directory
- * the symlink points at, but if the same patch removes a/b,
- * it is perfectly fine, as the patch removes a/b to make room
- * to create a directory a/b so that a/b/c can be created.
- */
-static struct string_list symlink_changes;
-#define SYMLINK_GOES_AWAY 01
-#define SYMLINK_IN_RESULT 02
-
-static uintptr_t register_symlink_changes(const char *path, uintptr_t what)
+static uintptr_t register_symlink_changes(struct apply_state *state,
+  const char *path,
+  uintptr_t what)
 {
  struct string_list_item *ent;
 
- ent = string_list_lookup(&symlink_changes, path);
+ ent = string_list_lookup(&state->symlink_changes, path);
  if (!ent) {
- ent = string_list_insert(&symlink_changes, path);
+ ent = string_list_insert(&state->symlink_changes, path);
  ent->util = (void *)0;
  }
  ent->util = (void *)(what | ((uintptr_t)ent->util));
  return (uintptr_t)ent->util;
 }
 
-static uintptr_t check_symlink_changes(const char *path)
+static uintptr_t check_symlink_changes(struct apply_state *state, const char *path)
 {
  struct string_list_item *ent;
 
- ent = string_list_lookup(&symlink_changes, path);
+ ent = string_list_lookup(&state->symlink_changes, path);
  if (!ent)
  return 0;
  return (uintptr_t)ent->util;
 }
 
-static void prepare_symlink_changes(struct patch *patch)
+static void prepare_symlink_changes(struct apply_state *state, struct patch *patch)
 {
  for ( ; patch; patch = patch->next) {
  if ((patch->old_name && S_ISLNK(patch->old_mode)) &&
     (patch->is_rename || patch->is_delete))
  /* the symlink at patch->old_name is removed */
- register_symlink_changes(patch->old_name, SYMLINK_GOES_AWAY);
+ register_symlink_changes(state, patch->old_name, SYMLINK_GOES_AWAY);
 
  if (patch->new_name && S_ISLNK(patch->new_mode))
  /* the symlink at patch->new_name is created or remains */
- register_symlink_changes(patch->new_name, SYMLINK_IN_RESULT);
+ register_symlink_changes(state, patch->new_name, SYMLINK_IN_RESULT);
  }
 }
 
@@ -3761,7 +3766,7 @@ static int path_is_beyond_symlink_1(struct apply_state *state, struct strbuf *na
  if (!name->len)
  break;
  name->buf[name->len] = '\0';
- change = check_symlink_changes(name->buf);
+ change = check_symlink_changes(state, name->buf);
  if (change & SYMLINK_IN_RESULT)
  return 1;
  if (change & SYMLINK_GOES_AWAY)
@@ -3930,7 +3935,7 @@ static int check_patch_list(struct apply_state *state, struct patch *patch)
 {
  int err = 0;
 
- prepare_symlink_changes(patch);
+ prepare_symlink_changes(state, patch);
  prepare_fn_table(state, patch);
  while (patch) {
  if (state->apply_verbosely)
@@ -4668,6 +4673,7 @@ static void init_apply_state(struct apply_state *state, const char *prefix)
 static void clear_apply_state(struct apply_state *state)
 {
  string_list_clear(&state->limit_by_name, 0);
+ string_list_clear(&state->symlink_changes, 0);
  strbuf_release(&state->root);
 
  /* &state->fn_table is cleared at the end of apply_patch() */
--
2.8.3.443.gaeee61e

--
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 v3 46/49] builtin/apply: move 'state' check into check_apply_state()

Christian Couder-2
In reply to this post by Christian Couder-2
To libify the apply functionality we should provide a function
to check that the values in a 'struct apply_state' instance are
coherent. Let's move the code to do that into a new
check_apply_state() function.

Reviewed-by: Stefan Beller <[hidden email]>
Signed-off-by: Christian Couder <[hidden email]>
---
 builtin/apply.c | 52 +++++++++++++++++++++++++++++-----------------------
 1 file changed, 29 insertions(+), 23 deletions(-)

diff --git a/builtin/apply.c b/builtin/apply.c
index 980bb34..8095026 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -4679,11 +4679,38 @@ static void clear_apply_state(struct apply_state *state)
  /* &state->fn_table is cleared at the end of apply_patch() */
 }
 
+static void check_apply_state(struct apply_state *state, int force_apply)
+{
+ int is_not_gitdir = !startup_info->have_repository;
+
+ if (state->apply_with_reject && state->threeway)
+ die("--reject and --3way cannot be used together.");
+ if (state->cached && state->threeway)
+ die("--cached and --3way cannot be used together.");
+ if (state->threeway) {
+ if (is_not_gitdir)
+ die(_("--3way outside a repository"));
+ state->check_index = 1;
+ }
+ if (state->apply_with_reject)
+ state->apply = state->apply_verbosely = 1;
+ if (!force_apply && (state->diffstat || state->numstat || state->summary || state->check || state->fake_ancestor))
+ state->apply = 0;
+ if (state->check_index && is_not_gitdir)
+ die(_("--index outside a repository"));
+ if (state->cached) {
+ if (is_not_gitdir)
+ die(_("--cached outside a repository"));
+ state->check_index = 1;
+ }
+ if (state->check_index)
+ state->unsafe_paths = 0;
+}
+
 int cmd_apply(int argc, const char **argv, const char *prefix)
 {
  int i;
  int errs = 0;
- int is_not_gitdir = !startup_info->have_repository;
  int force_apply = 0;
  int options = 0;
  int read_stdin = 1;
@@ -4763,28 +4790,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 (state.apply_with_reject && state.threeway)
- die("--reject and --3way cannot be used together.");
- if (state.cached && state.threeway)
- die("--cached and --3way cannot be used together.");
- if (state.threeway) {
- if (is_not_gitdir)
- die(_("--3way outside a repository"));
- state.check_index = 1;
- }
- if (state.apply_with_reject)
- state.apply = state.apply_verbosely = 1;
- if (!force_apply && (state.diffstat || state.numstat || state.summary || state.check || state.fake_ancestor))
- state.apply = 0;
- if (state.check_index && is_not_gitdir)
- die(_("--index outside a repository"));
- if (state.cached) {
- if (is_not_gitdir)
- die(_("--cached outside a repository"));
- state.check_index = 1;
- }
- if (state.check_index)
- state.unsafe_paths = 0;
+ check_apply_state(&state, force_apply);
 
  for (i = 0; i < argc; i++) {
  const char *arg = argv[i];
--
2.8.3.443.gaeee61e

--
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 v3 47/49] builtin/apply: move applying patches into apply_all_patches()

Christian Couder-2
In reply to this post by Christian Couder-2
To libify the apply functionality we should provide a function to
apply many patches. Let's move the code to do that into a new
apply_all_patches() function.

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

diff --git a/builtin/apply.c b/builtin/apply.c
index 8095026..5027f1b 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -4707,13 +4707,80 @@ static void check_apply_state(struct apply_state *state, int force_apply)
  state->unsafe_paths = 0;
 }
 
-int cmd_apply(int argc, const char **argv, const char *prefix)
+static int apply_all_patches(struct apply_state *state,
+     int argc,
+     const char **argv,
+     int options)
 {
  int i;
  int errs = 0;
+ int read_stdin = 1;
+
+ for (i = 0; i < argc; i++) {
+ const char *arg = argv[i];
+ int fd;
+
+ if (!strcmp(arg, "-")) {
+ errs |= apply_patch(state, 0, "<stdin>", options);
+ read_stdin = 0;
+ continue;
+ } 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(state);
+ errs |= apply_patch(state, fd, arg, options);
+ close(fd);
+ }
+ set_default_whitespace_mode(state);
+ if (read_stdin)
+ errs |= apply_patch(state, 0, "<stdin>", options);
+
+ if (state->whitespace_error) {
+ if (state->squelch_whitespace_errors &&
+    state->squelch_whitespace_errors < state->whitespace_error) {
+ int squelched =
+ state->whitespace_error - state->squelch_whitespace_errors;
+ warning(Q_("squelched %d whitespace error",
+   "squelched %d whitespace errors",
+   squelched),
+ squelched);
+ }
+ if (state->ws_error_action == die_on_ws_error)
+ die(Q_("%d line adds whitespace errors.",
+       "%d lines add whitespace errors.",
+       state->whitespace_error),
+    state->whitespace_error);
+ if (state->applied_after_fixing_ws && state->apply)
+ warning("%d line%s applied after"
+ " fixing whitespace errors.",
+ state->applied_after_fixing_ws,
+ state->applied_after_fixing_ws == 1 ? "" : "s");
+ else if (state->whitespace_error)
+ warning(Q_("%d line adds whitespace errors.",
+   "%d lines add whitespace errors.",
+   state->whitespace_error),
+ state->whitespace_error);
+ }
+
+ if (state->update_index) {
+ if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK))
+ die(_("Unable to write new index file"));
+ }
+
+ return !!errs;
+}
+
+int cmd_apply(int argc, const char **argv, const char *prefix)
+{
  int force_apply = 0;
  int options = 0;
- int read_stdin = 1;
+ int ret;
  struct apply_state state;
 
  struct option builtin_apply_options[] = {
@@ -4792,63 +4859,9 @@ int cmd_apply(int argc, const char **argv, const char *prefix)
 
  check_apply_state(&state, force_apply);
 
- for (i = 0; i < argc; i++) {
- const char *arg = argv[i];
- int fd;
-
- if (!strcmp(arg, "-")) {
- errs |= apply_patch(&state, 0, "<stdin>", options);
- read_stdin = 0;
- continue;
- } 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(&state);
- errs |= apply_patch(&state, fd, arg, options);
- close(fd);
- }
- set_default_whitespace_mode(&state);
- if (read_stdin)
- errs |= apply_patch(&state, 0, "<stdin>", options);
- if (state.whitespace_error) {
- if (state.squelch_whitespace_errors &&
-    state.squelch_whitespace_errors < state.whitespace_error) {
- int squelched =
- state.whitespace_error - state.squelch_whitespace_errors;
- warning(Q_("squelched %d whitespace error",
-   "squelched %d whitespace errors",
-   squelched),
- squelched);
- }
- if (state.ws_error_action == die_on_ws_error)
- die(Q_("%d line adds whitespace errors.",
-       "%d lines add whitespace errors.",
-       state.whitespace_error),
-    state.whitespace_error);
- if (state.applied_after_fixing_ws && state.apply)
- warning("%d line%s applied after"
- " fixing whitespace errors.",
- state.applied_after_fixing_ws,
- state.applied_after_fixing_ws == 1 ? "" : "s");
- else if (state.whitespace_error)
- warning(Q_("%d line adds whitespace errors.",
-   "%d lines add whitespace errors.",
-   state.whitespace_error),
- state.whitespace_error);
- }
-
- if (state.update_index) {
- if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK))
- die(_("Unable to write new index file"));
- }
+ ret = apply_all_patches(&state, argc, argv, options);
 
  clear_apply_state(&state);
 
- return !!errs;
+ return ret;
 }
--
2.8.3.443.gaeee61e

--
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 v3 48/49] builtin/apply: move 'lock_file' global into 'struct apply_state'

Christian Couder-2
In reply to this post by Christian Couder-2
We cannot have a 'struct lock_file' allocated on the stack, as lockfile.c
keeps a linked list of all created lock_file structures. So let's make the
'lock_file' variable a pointer to a 'struct lock_file'

As the same instance of this struct can be reused, let's add an argument
to init_apply_state(), so that the caller can supply the same instance to
different calls. And let's alloc an instance in init_apply_state(), if the
caller doesn't want to supply one.

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

diff --git a/builtin/apply.c b/builtin/apply.c
index 5027f1b..5d46b7c 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -52,6 +52,12 @@ struct apply_state {
  const char *prefix;
  int prefix_length;
 
+ /*
+ * Since lockfile.c keeps a linked list of all created
+ * lock_file structures, it isn't safe to free(lock_file).
+ */
+ struct lock_file *lock_file;
+
  /* These control what gets looked at and modified */
  int apply; /* this is not a dry-run */
  int cached; /* apply to the index only */
@@ -4493,8 +4499,6 @@ static int write_out_results(struct apply_state *state, struct patch *list)
  return errs;
 }
 
-static struct lock_file lock_file;
-
 #define INACCURATE_EOF (1<<0)
 #define RECOUNT (1<<1)
 
@@ -4547,7 +4551,7 @@ static int apply_patch(struct apply_state *state,
 
  state->update_index = state->check_index && state->apply;
  if (state->update_index && newfd < 0)
- newfd = hold_locked_index(&lock_file, 1);
+ newfd = hold_locked_index(state->lock_file, 1);
 
  if (state->check_index) {
  if (read_cache() < 0)
@@ -4648,11 +4652,14 @@ static int option_parse_directory(const struct option *opt,
  return 0;
 }
 
-static void init_apply_state(struct apply_state *state, const char *prefix)
+static void init_apply_state(struct apply_state *state,
+     const char *prefix,
+     struct lock_file *lock_file)
 {
  memset(state, 0, sizeof(*state));
  state->prefix = prefix;
  state->prefix_length = state->prefix ? strlen(state->prefix) : 0;
+ state->lock_file = lock_file ? lock_file : xcalloc(1, sizeof(*lock_file));
  state->apply = 1;
  state->line_termination = '\n';
  state->p_value = 1;
@@ -4769,7 +4776,7 @@ static int apply_all_patches(struct apply_state *state,
  }
 
  if (state->update_index) {
- if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK))
+ if (write_locked_index(&the_index, state->lock_file, COMMIT_LOCK))
  die(_("Unable to write new index file"));
  }
 
@@ -4852,7 +4859,7 @@ int cmd_apply(int argc, const char **argv, const char *prefix)
  OPT_END()
  };
 
- init_apply_state(&state, prefix);
+ init_apply_state(&state, prefix, NULL);
 
  argc = parse_options(argc, argv, state.prefix, builtin_apply_options,
  apply_usage, 0);
--
2.8.3.443.gaeee61e

--
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 v3 49/49] builtin/apply: move 'newfd' global into 'struct apply_state'

Christian Couder-2
In reply to this post by Christian Couder-2
To libify the apply functionality the 'newfd' variable should
not be static and global to the file. Let's move it into
'struct apply_state'.

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 5d46b7c..c1c5592 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -57,6 +57,7 @@ struct apply_state {
  * lock_file structures, it isn't safe to free(lock_file).
  */
  struct lock_file *lock_file;
+ int newfd;
 
  /* These control what gets looked at and modified */
  int apply; /* this is not a dry-run */
@@ -120,8 +121,6 @@ struct apply_state {
  int applied_after_fixing_ws;
 };
 
-static int newfd = -1;
-
 static const char * const apply_usage[] = {
  N_("git apply [<options>] [<patch>...]"),
  NULL
@@ -4550,8 +4549,8 @@ static int apply_patch(struct apply_state *state,
  state->apply = 0;
 
  state->update_index = state->check_index && state->apply;
- if (state->update_index && newfd < 0)
- newfd = hold_locked_index(state->lock_file, 1);
+ if (state->update_index && state->newfd < 0)
+ state->newfd = hold_locked_index(state->lock_file, 1);
 
  if (state->check_index) {
  if (read_cache() < 0)
@@ -4660,6 +4659,7 @@ static void init_apply_state(struct apply_state *state,
  state->prefix = prefix;
  state->prefix_length = state->prefix ? strlen(state->prefix) : 0;
  state->lock_file = lock_file ? lock_file : xcalloc(1, sizeof(*lock_file));
+ state->newfd = -1;
  state->apply = 1;
  state->line_termination = '\n';
  state->p_value = 1;
@@ -4778,6 +4778,7 @@ static int apply_all_patches(struct apply_state *state,
  if (state->update_index) {
  if (write_locked_index(&the_index, state->lock_file, COMMIT_LOCK))
  die(_("Unable to write new index file"));
+ state->newfd = -1;
  }
 
  return !!errs;
--
2.8.3.443.gaeee61e

--
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
|

Re: [PATCH v3 00/49] libify apply and use lib in am, part 1

Christian Couder-2
In reply to this post by Christian Couder-2
On Tue, May 24, 2016 at 10:10 AM, Christian Couder
<[hidden email]> wrote:
>
> I will send a diff between this version and the 50 first patches of v2
> soon as a reply to this email.

Here is the diff:

diff --git a/builtin/apply.c b/builtin/apply.c
index ec55768..c1c5592 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -59,44 +59,44 @@ struct apply_state {
     struct lock_file *lock_file;
     int newfd;

-    int apply;
+    /* These control what gets looked at and modified */
+    int apply; /* this is not a dry-run */
+    int cached; /* apply to the index only */
+    int check; /* preimage must match working tree, don't actually apply */
+    int check_index; /* preimage must match the indexed version */
+    int update_index; /* check_index && apply */
+
+    /* These control cosmetic aspect of the output */
+    int diffstat; /* just show a diffstat, and don't actually apply */
+    int numstat; /* just show a numeric diffstat, and don't actually apply */
+    int summary; /* just report creation, deletion, etc, and don't
actually apply */
+
+    /* These boolean parameters control how the apply is done */
     int allow_overlap;
     int apply_in_reverse;
     int apply_with_reject;
     int apply_verbosely;
-
-    /* --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;
-
-    /* --numstat does numeric diffstat, and doesn't actually apply */
-    int numstat;
-
-    int summary;
-    int threeway;
     int no_add;
+    int threeway;
+    int unidiff_zero;
+    int unsafe_paths;
+
+    /* Other non boolean parameters */
     const char *fake_ancestor;
     const char *patch_input_file;
-    struct string_list limit_by_name;
-    int has_include;
+    int line_termination;
     struct strbuf root;
-    struct string_list symlink_changes;
-
-    /*
-     *  --check turns on checking that the working tree matches the
-     *    files that are being modified, but doesn't apply the patch
-     */
-    int check;
+    int p_value;
+    int p_value_known;
+    unsigned int p_context;

-    /* --index updates the cache as well. */
-    int check_index;
+    /* Exclude and include path parameters */
+    struct string_list limit_by_name;
+    int has_include;

-    int unidiff_zero;
-    int update_index;
-    int unsafe_paths;
-    int line_termination;
+    /* Various "current state" */
+    int linenr; /* current line number */
+    struct string_list symlink_changes; /* we have to track symlinks */

     /*
      * For "diff-stat" like behaviour, we keep track of the biggest change
@@ -106,30 +106,19 @@ struct apply_state {
     int max_change;
     int max_len;

-    /*
-     * Various "current state", notably line numbers and what
-     * file (and how) we're patching right now.. The "is_xxxx"
-     * things are flags, where -1 means "don't know yet".
-     */
-    int linenr;
-
     /*
      * Records filenames that have been touched, in order to handle
      * the case where more than one patches touch the same file.
      */
     struct string_list fn_table;
-
-    int p_value;
-    int p_value_known;
-    unsigned int p_context;

+    /* These control whitespace errors */
+    enum ws_error_action ws_error_action;
+    enum ws_ignore ws_ignore_action;
     const char *whitespace_option;
     int whitespace_error;
     int squelch_whitespace_errors;
     int applied_after_fixing_ws;
-
-    enum ws_error_action ws_error_action;
-    enum ws_ignore ws_ignore_action;
 };

 static const char * const apply_usage[] = {
@@ -4688,6 +4677,15 @@ static void init_apply_state(struct apply_state *state,
         parse_ignorewhitespace_option(state, apply_default_ignorewhitespace);
 }

+static void clear_apply_state(struct apply_state *state)
+{
+    string_list_clear(&state->limit_by_name, 0);
+    string_list_clear(&state->symlink_changes, 0);
+    strbuf_release(&state->root);
+
+    /* &state->fn_table is cleared at the end of apply_patch() */
+}
+
 static void check_apply_state(struct apply_state *state, int force_apply)
 {
     int is_not_gitdir = !startup_info->have_repository;
@@ -4790,6 +4788,7 @@ int cmd_apply(int argc, const char **argv, const
char *prefix)
 {
     int force_apply = 0;
     int options = 0;
+    int ret;
     struct apply_state state;

     struct option builtin_apply_options[] = {
@@ -4868,5 +4867,9 @@ int cmd_apply(int argc, const char **argv, const
char *prefix)

     check_apply_state(&state, force_apply);

-    return apply_all_patches(&state, argc, argv, options);
+    ret = apply_all_patches(&state, argc, argv, options);
+
+    clear_apply_state(&state);
+
+    return ret;
 }
--
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
123