convert.c: refactor crlf_action

Refactor the determination and usage of crlf_action.
Today, when no "crlf" attribute are set on a file, crlf_action is set to
CRLF_GUESS. Use CRLF_UNDEFINED instead, and search for "text" or "eol" as
before.
After searching for line ending attributes, save the value in
struct conv_attrs.crlf_action attr_action,
so that get_convert_attr_ascii() is able report the attributes.

Replace the old CRLF_GUESS usage:
CRLF_GUESS && core.autocrlf=true -> CRLF_AUTO_CRLF
CRLF_GUESS && core.autocrlf=false -> CRLF_BINARY
CRLF_GUESS && core.autocrlf=input -> CRLF_AUTO_INPUT

Save the action in conv_attrs.crlf_action (as before) and change
all callers.

Make more clear, what is what, by defining:

- CRLF_UNDEFINED : No attributes set. Temparally used, until core.autocrlf
and core.eol is evaluated and one of CRLF_BINARY,
CRLF_AUTO_INPUT or CRLF_AUTO_CRLF is selected
- CRLF_BINARY    : No processing of line endings.
- CRLF_TEXT      : attribute "text" is set, line endings are processed.
- CRLF_TEXT_INPUT: attribute "input" or "eol=lf" is set. This implies text.
- CRLF_TEXT_CRLF : attribute "eol=crlf" is set. This implies text.
- CRLF_AUTO      : attribute "auto" is set.
- CRLF_AUTO_INPUT: core.autocrlf=input (no attributes)
- CRLF_AUTO_CRLF : core.autocrlf=true  (no attributes)

Signed-off-by: Torsten Bögershausen <tboegi@web.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/convert.c b/convert.c
index 557e574da60fee6302140fbcb9e154e1cafd5253..e4e2877129f4d02db41ec9d31e47e507e86c2e5b 100644 (file)
--- a/convert.c
+++ b/convert.c
@@ -19,12 +19,14 @@
 #define CONVERT_STAT_BITS_BIN       0x4
 
 enum crlf_action {
 #define CONVERT_STAT_BITS_BIN       0x4
 
 enum crlf_action {

-       CRLF_GUESS = -1,
-       CRLF_BINARY = 0,
+       CRLF_UNDEFINED,
+       CRLF_BINARY,

        CRLF_TEXT,
        CRLF_TEXT,

-       CRLF_INPUT,
-       CRLF_CRLF,
-       CRLF_AUTO
+       CRLF_TEXT_INPUT,
+       CRLF_TEXT_CRLF,
+       CRLF_AUTO,
+       CRLF_AUTO_INPUT,
+       CRLF_AUTO_CRLF

 };
 
 struct text_stat {
 };
 
 struct text_stat {


@@ -167,18 +169,19 @@ static enum eol output_eol(enum crlf_action crlf_action)
        switch (crlf_action) {
        case CRLF_BINARY:
                return EOL_UNSET;
        switch (crlf_action) {
        case CRLF_BINARY:
                return EOL_UNSET;

-       case CRLF_CRLF:
+       case CRLF_TEXT_CRLF:

                return EOL_CRLF;
                return EOL_CRLF;

-       case CRLF_INPUT:
+       case CRLF_TEXT_INPUT:

                return EOL_LF;
                return EOL_LF;

-       case CRLF_GUESS:
-               if (!auto_crlf)
-                       return EOL_UNSET;
-               /* fall through */
+       case CRLF_UNDEFINED:
+       case CRLF_AUTO_CRLF:
+       case CRLF_AUTO_INPUT:

        case CRLF_TEXT:
        case CRLF_AUTO:
        case CRLF_TEXT:
        case CRLF_AUTO:

+               /* fall through */

                return text_eol_is_crlf() ? EOL_CRLF : EOL_LF;
        }
                return text_eol_is_crlf() ? EOL_CRLF : EOL_LF;
        }

+       warning("Illegal crlf_action %d\n", (int)crlf_action);

        return core_eol;
 }
 
        return core_eol;
 }
 


@@ -235,7 +238,6 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
        char *dst;
 
        if (crlf_action == CRLF_BINARY ||
        char *dst;
 
        if (crlf_action == CRLF_BINARY ||

-           (crlf_action == CRLF_GUESS && auto_crlf == AUTO_CRLF_FALSE) ||

            (src && !len))
                return 0;
 
            (src && !len))
                return 0;
 


@@ -248,11 +250,11 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
 
        gather_stats(src, len, &stats);
 
 
        gather_stats(src, len, &stats);
 

-       if (crlf_action == CRLF_AUTO || crlf_action == CRLF_GUESS) {
+       if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {

                if (convert_is_binary(len, &stats))
                        return 0;
 
                if (convert_is_binary(len, &stats))
                        return 0;
 

-               if (crlf_action == CRLF_GUESS) {
+               if (crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {

                        /*
                         * If the file in the index has any CR in it, do not convert.
                         * This is the new safer autocrlf handling.
                        /*
                         * If the file in the index has any CR in it, do not convert.
                         * This is the new safer autocrlf handling.


@@ -279,7 +281,7 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
        if (strbuf_avail(buf) + buf->len < len)
                strbuf_grow(buf, len - buf->len);
        dst = buf->buf;
        if (strbuf_avail(buf) + buf->len < len)
                strbuf_grow(buf, len - buf->len);
        dst = buf->buf;

-       if (crlf_action == CRLF_AUTO || crlf_action == CRLF_GUESS) {
+       if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {

                /*
                 * If we guessed, we already know we rejected a file with
                 * lone CR, and we can strip a CR without looking at what
                /*
                 * If we guessed, we already know we rejected a file with
                 * lone CR, and we can strip a CR without looking at what


@@ -320,8 +322,8 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
        if (stats.lf == stats.crlf)
                return 0;
 
        if (stats.lf == stats.crlf)
                return 0;
 

-       if (crlf_action == CRLF_AUTO || crlf_action == CRLF_GUESS) {
-               if (crlf_action == CRLF_GUESS) {
+       if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
+               if (crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {

                        /* If we have any CR or CRLF line endings, we do not touch it */
                        /* This is the new safer autocrlf-handling */
                        if (stats.cr > 0 || stats.crlf > 0)
                        /* If we have any CR or CRLF line endings, we do not touch it */
                        /* This is the new safer autocrlf-handling */
                        if (stats.cr > 0 || stats.crlf > 0)


@@ -709,16 +711,16 @@ static enum crlf_action git_path_check_crlf(struct git_attr_check *check)
        const char *value = check->value;
 
        if (ATTR_TRUE(value))
        const char *value = check->value;
 
        if (ATTR_TRUE(value))

-               return CRLF_TEXT;
+               return text_eol_is_crlf() ? CRLF_TEXT_CRLF : CRLF_TEXT_INPUT;

        else if (ATTR_FALSE(value))
                return CRLF_BINARY;
        else if (ATTR_UNSET(value))
                ;
        else if (!strcmp(value, "input"))
        else if (ATTR_FALSE(value))
                return CRLF_BINARY;
        else if (ATTR_UNSET(value))
                ;
        else if (!strcmp(value, "input"))

-               return CRLF_INPUT;
+               return CRLF_TEXT_INPUT;

        else if (!strcmp(value, "auto"))
                return CRLF_AUTO;
        else if (!strcmp(value, "auto"))
                return CRLF_AUTO;

-       return CRLF_GUESS;
+       return CRLF_UNDEFINED;

 }
 
 static enum eol git_path_check_eol(struct git_attr_check *check)
 }
 
 static enum eol git_path_check_eol(struct git_attr_check *check)


@@ -781,7 +783,7 @@ static void convert_attrs(struct conv_attrs *ca, const char *path)
        if (!git_check_attr(path, NUM_CONV_ATTRS, ccheck)) {
                enum eol eol_attr;
                ca->crlf_action = git_path_check_crlf(ccheck + 4);
        if (!git_check_attr(path, NUM_CONV_ATTRS, ccheck)) {
                enum eol eol_attr;
                ca->crlf_action = git_path_check_crlf(ccheck + 4);

-               if (ca->crlf_action == CRLF_GUESS)
+               if (ca->crlf_action == CRLF_UNDEFINED)

                        ca->crlf_action = git_path_check_crlf(ccheck + 0);
                ca->attr_action = ca->crlf_action;
                ca->ident = git_path_check_ident(ccheck + 1);
                        ca->crlf_action = git_path_check_crlf(ccheck + 0);
                ca->attr_action = ca->crlf_action;
                ca->ident = git_path_check_ident(ccheck + 1);


@@ -790,14 +792,22 @@ static void convert_attrs(struct conv_attrs *ca, const char *path)
                        return;
                eol_attr = git_path_check_eol(ccheck + 3);
                if (eol_attr == EOL_LF)
                        return;
                eol_attr = git_path_check_eol(ccheck + 3);
                if (eol_attr == EOL_LF)

-                       ca->crlf_action = CRLF_INPUT;
+                       ca->crlf_action = CRLF_TEXT_INPUT;

                else if (eol_attr == EOL_CRLF)
                else if (eol_attr == EOL_CRLF)

-                       ca->crlf_action = CRLF_CRLF;
+                       ca->crlf_action = CRLF_TEXT_CRLF;

        } else {
                ca->drv = NULL;
        } else {
                ca->drv = NULL;

-               ca->crlf_action = CRLF_GUESS;
+               ca->crlf_action = CRLF_UNDEFINED;

                ca->ident = 0;
        }
                ca->ident = 0;
        }

+       if (ca->crlf_action == CRLF_TEXT)
+               ca->crlf_action = text_eol_is_crlf() ? CRLF_TEXT_CRLF : CRLF_TEXT_INPUT;
+       if (ca->crlf_action == CRLF_UNDEFINED && auto_crlf == AUTO_CRLF_FALSE)
+               ca->crlf_action = CRLF_BINARY;
+       if (ca->crlf_action == CRLF_UNDEFINED && auto_crlf == AUTO_CRLF_TRUE)
+               ca->crlf_action = CRLF_AUTO_CRLF;
+       if (ca->crlf_action == CRLF_UNDEFINED && auto_crlf == AUTO_CRLF_INPUT)
+               ca->crlf_action = CRLF_AUTO_INPUT;

 }
 
 int would_convert_to_git_filter_fd(const char *path)
 }
 
 int would_convert_to_git_filter_fd(const char *path)


@@ -825,18 +835,22 @@ const char *get_convert_attr_ascii(const char *path)
 
        convert_attrs(&ca, path);
        switch (ca.attr_action) {
 
        convert_attrs(&ca, path);
        switch (ca.attr_action) {

-       case CRLF_GUESS:
+       case CRLF_UNDEFINED:

                return "";
        case CRLF_BINARY:
                return "-text";
        case CRLF_TEXT:
                return "text";
                return "";
        case CRLF_BINARY:
                return "-text";
        case CRLF_TEXT:
                return "text";

-       case CRLF_INPUT:
+       case CRLF_TEXT_INPUT:

                return "text eol=lf";
                return "text eol=lf";

-       case CRLF_CRLF:
-               return "text=auto eol=crlf";
+       case CRLF_TEXT_CRLF:
+               return "text eol=crlf";

        case CRLF_AUTO:
                return "text=auto";
        case CRLF_AUTO:
                return "text=auto";

+       case CRLF_AUTO_CRLF:
+               return "text=auto eol=crlf"; /* This is not supported yet */
+       case CRLF_AUTO_INPUT:
+               return "text=auto eol=lf"; /* This is not supported yet */

        }
        return "";
 }
        }
        return "";
 }


@@ -1382,12 +1396,13 @@ struct stream_filter *get_stream_filter(const char *path, const unsigned char *s
 
        crlf_action = ca.crlf_action;
 
 
        crlf_action = ca.crlf_action;
 

-       if ((crlf_action == CRLF_BINARY) || (crlf_action == CRLF_INPUT) ||
-           (crlf_action == CRLF_GUESS && auto_crlf == AUTO_CRLF_FALSE))
+       if ((crlf_action == CRLF_BINARY) ||
+                       crlf_action == CRLF_AUTO_INPUT ||
+                       (crlf_action == CRLF_TEXT_INPUT))

                filter = cascade_filter(filter, &null_filter_singleton);
 
        else if (output_eol(crlf_action) == EOL_CRLF &&
                filter = cascade_filter(filter, &null_filter_singleton);
 
        else if (output_eol(crlf_action) == EOL_CRLF &&

-                !(crlf_action == CRLF_AUTO || crlf_action == CRLF_GUESS))
+                !(crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_CRLF))

                filter = cascade_filter(filter, lf_to_crlf_filter());
 
        return filter;
                filter = cascade_filter(filter, lf_to_crlf_filter());
 
        return filter;