apply: revamp the parsing of incomplete lines

A patch file represents the incomplete line at the end of the file
with two lines, one that is the usual "context" with " " as the
first letter, "added" with "+" as the first letter, or "removed"
with "-" as the first letter that shows the content of the line,
plus an extra "\ No newline at the end of file" line that comes
immediately after it.

Ever since the apply machinery was written, the "git apply"
machinery parses "\ No newline at the end of file" line
independently, without even knowing what line the incomplete-ness
applies to, simply because it does not even remember what the
previous line was.

This poses a problem if we want to check and warn on an incomplete
line.  Revamp the code that parses a fragment, to actually drop the
'\n' at the end of the incoming patch file that terminates a line,
so that check_whitespace() calls made from the code path actually
sees an incomplete as incomplete.

Note that the result of this parsing is not directly used by the
code path that applies the patch.  apply_one_fragment() function
already checks if each of the patch text it handles is followed by a
line that begins with a backslash to drop the newline at the end of
the current line it is looking at.  In a sense, this patch harmonizes
the behaviour of the parsing side to what is already done in the
application side.

Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/apply.c b/apply.c
index a2ceb3fb40d3b5eae9b524008a1781ea91d87ecf..2b0f8bdab554632f85276db2327175c7ba444cc6 100644 (file)
--- a/apply.c
+++ b/apply.c
@@ -1670,6 +1670,35 @@ static void check_old_for_crlf(struct patch *patch, const char *line, int len)
 }
 
 
+/*
+ * Just saw a single line in a fragment.  If it is a part of this hunk
+ * that is a context " ", an added "+", or a removed "-" line, it may
+ * be followed by "\\ No newline..." to signal that the last "\n" on
+ * this line needs to be dropped.  Depending on locale settings when
+ * the patch was produced we don't know what this line would exactly
+ * say. The only thing we do know is that it begins with "\ ".
+ * Checking for 12 is just for sanity check; "\ No newline..." would
+ * be at least that long in any l10n.
+ *
+ * Return 0 if the line we saw is not followed by "\ No newline...",
+ * or length of that line.  The caller will use it to skip over the
+ * "\ No newline..." line.
+ */
+static int adjust_incomplete(const char *line, int len,
+                            unsigned long size)
+{
+       int nextlen;
+
+       if (*line != '\n' && *line != ' ' && *line != '+' && *line != '-')
+               return 0;
+       if (size - len < 12 || memcmp(line + len, "\\ ", 2))
+               return 0;
+       nextlen = linelen(line + len, size - len);
+       if (nextlen < 12)
+               return 0;
+       return nextlen;
+}
+
 /*
  * Parse a unified diff. Note that this really needs to parse each
  * fragment separately, since the only way to know the difference
@@ -1684,6 +1713,7 @@ static int parse_fragment(struct apply_state *state,
 {
        int added, deleted;
        int len = linelen(line, size), offset;
+       int skip_len = 0;
        unsigned long oldlines, newlines;
        unsigned long leading, trailing;
 
@@ -1710,6 +1740,22 @@ static int parse_fragment(struct apply_state *state,
                len = linelen(line, size);
                if (!len || line[len-1] != '\n')
                        return -1;
+
+               /*
+                * For an incomplete line, skip_len counts the bytes
+                * on "\\ No newline..." marker line that comes next
+                * to the current line.
+                *
+                * Reduce "len" to drop the newline at the end of
+                * line[], but add one to "skip_len", which will be
+                * added back to "len" for the next iteration, to
+                * compensate.
+                */
+               skip_len = adjust_incomplete(line, len, size);
+               if (skip_len) {
+                       len--;
+                       skip_len++;
+               }
                switch (*line) {
                default:
                        return -1;
@@ -1745,20 +1791,10 @@ static int parse_fragment(struct apply_state *state,
                        newlines--;
                        trailing = 0;
                        break;
-
-               /*
-                * We allow "\ No newline at end of file". Depending
-                * on locale settings when the patch was produced we
-                * don't know what this line looks like. The only
-                * thing we do know is that it begins with "\ ".
-                * Checking for 12 is just for sanity check -- any
-                * l10n of "\ No newline..." is at least that long.
-                */
-               case '\\':
-                       if (len < 12 || memcmp(line, "\\ ", 2))
-                               return -1;
-                       break;
                }
+
+               /* eat the "\\ No newline..." as well, if exists */
+               len += skip_len;
        }
        if (oldlines || newlines)
                return -1;
@@ -1768,14 +1804,6 @@ static int parse_fragment(struct apply_state *state,
        fragment->leading = leading;
        fragment->trailing = trailing;
 
-       /*
-        * If a fragment ends with an incomplete line, we failed to include
-        * it in the above loop because we hit oldlines == newlines == 0
-        * before seeing it.
-        */
-       if (12 < size && !memcmp(line, "\\ ", 2))
-               offset += linelen(line, size);
-
        patch->lines_added += added;
        patch->lines_deleted += deleted;