apply: reorder functions to move image-related things together

While most of the functions relating to `struct image` are relatively
close to one another, `fuzzy_matchlines()` sits in between those even
though it is rather unrelated.

Reorder functions such that `struct image`-related functions are next to
each other. While at it, move `clear_image()` to the top such that it is
close to the struct definition itself. This makes this lifecycle-related
thing easy to discover.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/apply.c b/apply.c
index 6e1060a952c31769eb7294d8b93e225f53278c78..9dd2f4d2158e604761769c918c917cc0f1c7fe17 100644 (file)
--- a/apply.c
+++ b/apply.c
@@ -285,6 +285,13 @@ struct image {
        struct line *line;
 };
 
+static void clear_image(struct image *image)
+{
+       free(image->buf);
+       free(image->line_allocated);
+       memset(image, 0, sizeof(*image));
+}
+
 static uint32_t hash_line(const char *cp, size_t len)
 {
        size_t i;
@@ -297,42 +304,6 @@ static uint32_t hash_line(const char *cp, size_t len)
        return h;
 }
 
-/*
- * Compare lines s1 of length n1 and s2 of length n2, ignoring
- * whitespace difference. Returns 1 if they match, 0 otherwise
- */
-static int fuzzy_matchlines(const char *s1, size_t n1,
-                           const char *s2, size_t n2)
-{
-       const char *end1 = s1 + n1;
-       const char *end2 = s2 + n2;
-
-       /* ignore line endings */
-       while (s1 < end1 && (end1[-1] == '\r' || end1[-1] == '\n'))
-               end1--;
-       while (s2 < end2 && (end2[-1] == '\r' || end2[-1] == '\n'))
-               end2--;
-
-       while (s1 < end1 && s2 < end2) {
-               if (isspace(*s1)) {
-                       /*
-                        * Skip whitespace. We check on both buffers
-                        * because we don't want "a b" to match "ab".
-                        */
-                       if (!isspace(*s2))
-                               return 0;
-                       while (s1 < end1 && isspace(*s1))
-                               s1++;
-                       while (s2 < end2 && isspace(*s2))
-                               s2++;
-               } else if (*s1++ != *s2++)
-                       return 0;
-       }
-
-       /* If we reached the end on one side only, lines don't match. */
-       return s1 == end1 && s2 == end2;
-}
-
 static void add_line_info(struct image *img, const char *bol, size_t len, unsigned flag)
 {
        ALLOC_GROW(img->line_allocated, img->nr + 1, img->alloc);
@@ -373,11 +344,17 @@ static void prepare_image(struct image *image, char *buf, size_t len,
        image->line = image->line_allocated;
 }
 
-static void clear_image(struct image *image)
+static void remove_first_line(struct image *img)
 {
-       free(image->buf);
-       free(image->line_allocated);
-       memset(image, 0, sizeof(*image));
+       img->buf += img->line[0].len;
+       img->len -= img->line[0].len;
+       img->line++;
+       img->nr--;
+}
+
+static void remove_last_line(struct image *img)
+{
+       img->len -= img->line[--img->nr].len;
 }
 
 /* fmt must contain _one_ %s and no other substitution */
@@ -2419,6 +2396,42 @@ static void update_pre_post_images(struct image *preimage,
        postimage->nr -= reduced;
 }
 
+/*
+ * Compare lines s1 of length n1 and s2 of length n2, ignoring
+ * whitespace difference. Returns 1 if they match, 0 otherwise
+ */
+static int fuzzy_matchlines(const char *s1, size_t n1,
+                           const char *s2, size_t n2)
+{
+       const char *end1 = s1 + n1;
+       const char *end2 = s2 + n2;
+
+       /* ignore line endings */
+       while (s1 < end1 && (end1[-1] == '\r' || end1[-1] == '\n'))
+               end1--;
+       while (s2 < end2 && (end2[-1] == '\r' || end2[-1] == '\n'))
+               end2--;
+
+       while (s1 < end1 && s2 < end2) {
+               if (isspace(*s1)) {
+                       /*
+                        * Skip whitespace. We check on both buffers
+                        * because we don't want "a b" to match "ab".
+                        */
+                       if (!isspace(*s2))
+                               return 0;
+                       while (s1 < end1 && isspace(*s1))
+                               s1++;
+                       while (s2 < end2 && isspace(*s2))
+                               s2++;
+               } else if (*s1++ != *s2++)
+                       return 0;
+       }
+
+       /* If we reached the end on one side only, lines don't match. */
+       return s1 == end1 && s2 == end2;
+}
+
 static int line_by_line_fuzzy_match(struct image *img,
                                    struct image *preimage,
                                    struct image *postimage,
@@ -2804,19 +2817,6 @@ static int find_pos(struct apply_state *state,
        return -1;
 }
 
-static void remove_first_line(struct image *img)
-{
-       img->buf += img->line[0].len;
-       img->len -= img->line[0].len;
-       img->line++;
-       img->nr--;
-}
-
-static void remove_last_line(struct image *img)
-{
-       img->len -= img->line[--img->nr].len;
-}
-
 /*
  * The change from "preimage" and "postimage" has been found to
  * apply at applied_pos (counts in line numbers) in "img".