convert_to_git(): safe_crlf/checksafe becomes int conv_flags

When calling convert_to_git(), the checksafe parameter defined what
should happen if the EOL conversion (CRLF --> LF --> CRLF) does not
roundtrip cleanly. In addition, it also defined if line endings should
be renormalized (CRLF --> LF) or kept as they are.

checksafe was an safe_crlf enum with these values:
SAFE_CRLF_FALSE:       do nothing in case of EOL roundtrip errors
SAFE_CRLF_FAIL:        die in case of EOL roundtrip errors
SAFE_CRLF_WARN:        print a warning in case of EOL roundtrip errors
SAFE_CRLF_RENORMALIZE: change CRLF to LF
SAFE_CRLF_KEEP_CRLF:   keep all line endings as they are

In some cases the integer value 0 was passed as checksafe parameter
instead of the correct enum value SAFE_CRLF_FALSE. That was no problem
because SAFE_CRLF_FALSE is defined as 0.

FALSE/FAIL/WARN are different from RENORMALIZE and KEEP_CRLF. Therefore,
an enum is not ideal. Let's use a integer bit pattern instead and rename
the parameter to conv_flags to make it more generically usable. This
allows us to extend the bit pattern in a subsequent commit.

Reported-By: Randall S. Becker <rsbecker@nexbridge.com>
Helped-By: Lars Schneider <larsxschneider@gmail.com>
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
Signed-off-by: Lars Schneider <larsxschneider@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/apply.c b/apply.c
index 321a9fa68d491f7e5e89dc9e398b067f67a10c77..f8b67bfee2c39cc3fbebb7a3c72dfb9cb4fcb56f 100644 (file)
--- a/apply.c
+++ b/apply.c
@@ -2263,8 +2263,8 @@ static void show_stats(struct apply_state *state, struct patch *patch)
 static int read_old_data(struct stat *st, struct patch *patch,
                         const char *path, struct strbuf *buf)
 {
 static int read_old_data(struct stat *st, struct patch *patch,
                         const char *path, struct strbuf *buf)
 {

-       enum safe_crlf safe_crlf = patch->crlf_in_old ?
-               SAFE_CRLF_KEEP_CRLF : SAFE_CRLF_RENORMALIZE;
+       int conv_flags = patch->crlf_in_old ?
+               CONV_EOL_KEEP_CRLF : CONV_EOL_RENORMALIZE;

        switch (st->st_mode & S_IFMT) {
        case S_IFLNK:
                if (strbuf_readlink(buf, path, st->st_size) < 0)
        switch (st->st_mode & S_IFMT) {
        case S_IFLNK:
                if (strbuf_readlink(buf, path, st->st_size) < 0)


@@ -2281,7 +2281,7 @@ static int read_old_data(struct stat *st, struct patch *patch,
                 * should never look at the index when explicit crlf option
                 * is given.
                 */
                 * should never look at the index when explicit crlf option
                 * is given.
                 */

-               convert_to_git(NULL, path, buf->buf, buf->len, buf, safe_crlf);
+               convert_to_git(NULL, path, buf->buf, buf->len, buf, conv_flags);

                return 0;
        default:
                return -1;
                return 0;
        default:
                return -1;

diff --git a/combine-diff.c b/combine-diff.c
index 2505de119a2be37e9dfb313a2e44db68595ad13f..19f30c33539f69c773c7b104be8355d4e7e4fcdd 100644 (file)
--- a/combine-diff.c
+++ b/combine-diff.c
@@ -1053,7 +1053,7 @@ static void show_patch_diff(struct combine_diff_path *elem, int num_parent,
                        if (is_file) {
                                struct strbuf buf = STRBUF_INIT;
 
                        if (is_file) {
                                struct strbuf buf = STRBUF_INIT;
 

-                               if (convert_to_git(&the_index, elem->path, result, len, &buf, safe_crlf)) {
+                               if (convert_to_git(&the_index, elem->path, result, len, &buf, global_conv_flags_eol)) {

                                        free(result);
                                        result = strbuf_detach(&buf, &len);
                                        result_size = len;
                                        free(result);
                                        result = strbuf_detach(&buf, &len);
                                        result_size = len;

diff --git a/config.c b/config.c
index e617c2018d22b6d389548a3573d2deb2ec608b99..1f003fbb90bed98e1d8fb25543f76f8d0cfaf78c 100644 (file)
--- a/config.c
+++ b/config.c
@@ -1149,11 +1149,14 @@ static int git_default_core_config(const char *var, const char *value)
        }
 
        if (!strcmp(var, "core.safecrlf")) {
        }
 
        if (!strcmp(var, "core.safecrlf")) {

+               int eol_rndtrp_die;

                if (value && !strcasecmp(value, "warn")) {
                if (value && !strcasecmp(value, "warn")) {

-                       safe_crlf = SAFE_CRLF_WARN;
+                       global_conv_flags_eol = CONV_EOL_RNDTRP_WARN;

                        return 0;
                }
                        return 0;
                }

-               safe_crlf = git_config_bool(var, value);
+               eol_rndtrp_die = git_config_bool(var, value);
+               global_conv_flags_eol = eol_rndtrp_die ?
+                       CONV_EOL_RNDTRP_DIE : CONV_EOL_RNDTRP_WARN;

                return 0;
        }
 
                return 0;
        }
 

diff --git a/convert.c b/convert.c
index 1a41a48e15efd7a6c3030e7a0d1097cbc08099c1..b976eb968c8289414c415e7beefa91c0816d5158 100644 (file)
--- a/convert.c
+++ b/convert.c
@@ -193,30 +193,30 @@ static enum eol output_eol(enum crlf_action crlf_action)
        return core_eol;
 }
 
        return core_eol;
 }
 

-static void check_safe_crlf(const char *path, enum crlf_action crlf_action,
+static void check_global_conv_flags_eol(const char *path, enum crlf_action crlf_action,

                            struct text_stat *old_stats, struct text_stat *new_stats,
                            struct text_stat *old_stats, struct text_stat *new_stats,

-                           enum safe_crlf checksafe)
+                           int conv_flags)

 {
        if (old_stats->crlf && !new_stats->crlf ) {
                /*
                 * CRLFs would not be restored by checkout
                 */
 {
        if (old_stats->crlf && !new_stats->crlf ) {
                /*
                 * CRLFs would not be restored by checkout
                 */

-               if (checksafe == SAFE_CRLF_WARN)
+               if (conv_flags & CONV_EOL_RNDTRP_DIE)
+                       die(_("CRLF would be replaced by LF in %s."), path);
+               else if (conv_flags & CONV_EOL_RNDTRP_WARN)

                        warning(_("CRLF will be replaced by LF in %s.\n"
                                  "The file will have its original line"
                                  " endings in your working directory."), path);
                        warning(_("CRLF will be replaced by LF in %s.\n"
                                  "The file will have its original line"
                                  " endings in your working directory."), path);

-               else /* i.e. SAFE_CRLF_FAIL */
-                       die(_("CRLF would be replaced by LF in %s."), path);

        } else if (old_stats->lonelf && !new_stats->lonelf ) {
                /*
                 * CRLFs would be added by checkout
                 */
        } else if (old_stats->lonelf && !new_stats->lonelf ) {
                /*
                 * CRLFs would be added by checkout
                 */

-               if (checksafe == SAFE_CRLF_WARN)
+               if (conv_flags & CONV_EOL_RNDTRP_DIE)
+                       die(_("LF would be replaced by CRLF in %s"), path);
+               else if (conv_flags & CONV_EOL_RNDTRP_WARN)

                        warning(_("LF will be replaced by CRLF in %s.\n"
                                  "The file will have its original line"
                                  " endings in your working directory."), path);
                        warning(_("LF will be replaced by CRLF in %s.\n"
                                  "The file will have its original line"
                                  " endings in your working directory."), path);

-               else /* i.e. SAFE_CRLF_FAIL */
-                       die(_("LF would be replaced by CRLF in %s"), path);

        }
 }
 
        }
 }
 


@@ -268,7 +268,7 @@ static int will_convert_lf_to_crlf(size_t len, struct text_stat *stats,
 static int crlf_to_git(const struct index_state *istate,
                       const char *path, const char *src, size_t len,
                       struct strbuf *buf,
 static int crlf_to_git(const struct index_state *istate,
                       const char *path, const char *src, size_t len,
                       struct strbuf *buf,

-                      enum crlf_action crlf_action, enum safe_crlf checksafe)
+                      enum crlf_action crlf_action, int conv_flags)

 {
        struct text_stat stats;
        char *dst;
 {
        struct text_stat stats;
        char *dst;


@@ -298,12 +298,12 @@ static int crlf_to_git(const struct index_state *istate,
                 * unless we want to renormalize in a merge or
                 * cherry-pick.
                 */
                 * unless we want to renormalize in a merge or
                 * cherry-pick.
                 */

-               if ((checksafe != SAFE_CRLF_RENORMALIZE) &&
+               if ((!(conv_flags & CONV_EOL_RENORMALIZE)) &&

                    has_crlf_in_index(istate, path))
                        convert_crlf_into_lf = 0;
        }
                    has_crlf_in_index(istate, path))
                        convert_crlf_into_lf = 0;
        }

-       if ((checksafe == SAFE_CRLF_WARN ||
-           (checksafe == SAFE_CRLF_FAIL)) && len) {
+       if (((conv_flags & CONV_EOL_RNDTRP_WARN) ||
+            ((conv_flags & CONV_EOL_RNDTRP_DIE) && len))) {

                struct text_stat new_stats;
                memcpy(&new_stats, &stats, sizeof(new_stats));
                /* simulate "git add" */
                struct text_stat new_stats;
                memcpy(&new_stats, &stats, sizeof(new_stats));
                /* simulate "git add" */


@@ -316,7 +316,7 @@ static int crlf_to_git(const struct index_state *istate,
                        new_stats.crlf += new_stats.lonelf;
                        new_stats.lonelf = 0;
                }
                        new_stats.crlf += new_stats.lonelf;
                        new_stats.lonelf = 0;
                }

-               check_safe_crlf(path, crlf_action, &stats, &new_stats, checksafe);
+               check_global_conv_flags_eol(path, crlf_action, &stats, &new_stats, conv_flags);

        }
        if (!convert_crlf_into_lf)
                return 0;
        }
        if (!convert_crlf_into_lf)
                return 0;


@@ -1129,7 +1129,7 @@ const char *get_convert_attr_ascii(const char *path)
 
 int convert_to_git(const struct index_state *istate,
                   const char *path, const char *src, size_t len,
 
 int convert_to_git(const struct index_state *istate,
                   const char *path, const char *src, size_t len,

-                   struct strbuf *dst, enum safe_crlf checksafe)
+                  struct strbuf *dst, int conv_flags)

 {
        int ret = 0;
        struct conv_attrs ca;
 {
        int ret = 0;
        struct conv_attrs ca;


@@ -1144,8 +1144,8 @@ int convert_to_git(const struct index_state *istate,
                src = dst->buf;
                len = dst->len;
        }
                src = dst->buf;
                len = dst->len;
        }

-       if (checksafe != SAFE_CRLF_KEEP_CRLF) {
-               ret |= crlf_to_git(istate, path, src, len, dst, ca.crlf_action, checksafe);
+       if (!(conv_flags & CONV_EOL_KEEP_CRLF)) {
+               ret |= crlf_to_git(istate, path, src, len, dst, ca.crlf_action, conv_flags);

                if (ret && dst) {
                        src = dst->buf;
                        len = dst->len;
                if (ret && dst) {
                        src = dst->buf;
                        len = dst->len;


@@ -1156,7 +1156,7 @@ int convert_to_git(const struct index_state *istate,
 
 void convert_to_git_filter_fd(const struct index_state *istate,
                              const char *path, int fd, struct strbuf *dst,
 
 void convert_to_git_filter_fd(const struct index_state *istate,
                              const char *path, int fd, struct strbuf *dst,

-                             enum safe_crlf checksafe)
+                             int conv_flags)

 {
        struct conv_attrs ca;
        convert_attrs(&ca, path);
 {
        struct conv_attrs ca;
        convert_attrs(&ca, path);


@@ -1167,7 +1167,7 @@ void convert_to_git_filter_fd(const struct index_state *istate,
        if (!apply_filter(path, NULL, 0, fd, dst, ca.drv, CAP_CLEAN, NULL))
                die("%s: clean filter '%s' failed", path, ca.drv->name);
 
        if (!apply_filter(path, NULL, 0, fd, dst, ca.drv, CAP_CLEAN, NULL))
                die("%s: clean filter '%s' failed", path, ca.drv->name);
 

-       crlf_to_git(istate, path, dst->buf, dst->len, dst, ca.crlf_action, checksafe);
+       crlf_to_git(istate, path, dst->buf, dst->len, dst, ca.crlf_action, conv_flags);

        ident_to_git(path, dst->buf, dst->len, dst, ca.ident);
 }
 
        ident_to_git(path, dst->buf, dst->len, dst, ca.ident);
 }
 


@@ -1226,7 +1226,7 @@ int renormalize_buffer(const struct index_state *istate, const char *path,
                src = dst->buf;
                len = dst->len;
        }
                src = dst->buf;
                len = dst->len;
        }

-       return ret | convert_to_git(istate, path, src, len, dst, SAFE_CRLF_RENORMALIZE);
+       return ret | convert_to_git(istate, path, src, len, dst, CONV_EOL_RENORMALIZE);

 }
 
 /*****************************************************************
 }
 
 /*****************************************************************

diff --git a/convert.h b/convert.h
index 4f2da225a8926f92e465c7dea27cdc4589864e1f..65ab3e516745775b52f36a370ba7880a34c8b2a5 100644 (file)
--- a/convert.h
+++ b/convert.h
@@ -8,15 +8,12 @@
 
 struct index_state;
 
 
 struct index_state;
 

-enum safe_crlf {
-       SAFE_CRLF_FALSE = 0,
-       SAFE_CRLF_FAIL = 1,
-       SAFE_CRLF_WARN = 2,
-       SAFE_CRLF_RENORMALIZE = 3,
-       SAFE_CRLF_KEEP_CRLF = 4
-};
+#define CONV_EOL_RNDTRP_DIE   (1<<0) /* Die if CRLF to LF to CRLF is different */
+#define CONV_EOL_RNDTRP_WARN  (1<<1) /* Warn if CRLF to LF to CRLF is different */
+#define CONV_EOL_RENORMALIZE  (1<<2) /* Convert CRLF to LF */
+#define CONV_EOL_KEEP_CRLF    (1<<3) /* Keep CRLF line endings as is */

 
 

-extern enum safe_crlf safe_crlf;
+extern int global_conv_flags_eol;

 
 enum auto_crlf {
        AUTO_CRLF_FALSE = 0,
 
 enum auto_crlf {
        AUTO_CRLF_FALSE = 0,


@@ -66,7 +63,7 @@ extern const char *get_convert_attr_ascii(const char *path);
 /* returns 1 if *dst was used */
 extern int convert_to_git(const struct index_state *istate,
                          const char *path, const char *src, size_t len,
 /* returns 1 if *dst was used */
 extern int convert_to_git(const struct index_state *istate,
                          const char *path, const char *src, size_t len,

-                         struct strbuf *dst, enum safe_crlf checksafe);
+                         struct strbuf *dst, int conv_flags);

 extern int convert_to_working_tree(const char *path, const char *src,
                                   size_t len, struct strbuf *dst);
 extern int async_convert_to_working_tree(const char *path, const char *src,
 extern int convert_to_working_tree(const char *path, const char *src,
                                   size_t len, struct strbuf *dst);
 extern int async_convert_to_working_tree(const char *path, const char *src,


@@ -85,7 +82,7 @@ static inline int would_convert_to_git(const struct index_state *istate,
 extern void convert_to_git_filter_fd(const struct index_state *istate,
                                     const char *path, int fd,
                                     struct strbuf *dst,
 extern void convert_to_git_filter_fd(const struct index_state *istate,
                                     const char *path, int fd,
                                     struct strbuf *dst,

-                                    enum safe_crlf checksafe);
+                                    int conv_flags);

 extern int would_convert_to_git_filter_fd(const char *path);
 
 /*****************************************************************
 extern int would_convert_to_git_filter_fd(const char *path);
 
 /*****************************************************************

diff --git a/diff.c b/diff.c
index fb22b19f09ab13032b0484e64326fef92bb0681f..35cca04f259804476d758f871cba60bae7fe940a 100644 (file)
--- a/diff.c
+++ b/diff.c
@@ -3520,13 +3520,13 @@ int diff_populate_filespec(struct diff_filespec *s, unsigned int flags)
 {
        int size_only = flags & CHECK_SIZE_ONLY;
        int err = 0;
 {
        int size_only = flags & CHECK_SIZE_ONLY;
        int err = 0;

+       int conv_flags = global_conv_flags_eol;

        /*
         * demote FAIL to WARN to allow inspecting the situation
         * instead of refusing.
         */
        /*
         * demote FAIL to WARN to allow inspecting the situation
         * instead of refusing.
         */

-       enum safe_crlf crlf_warn = (safe_crlf == SAFE_CRLF_FAIL
-                                   ? SAFE_CRLF_WARN
-                                   : safe_crlf);
+       if (conv_flags & CONV_EOL_RNDTRP_DIE)
+               conv_flags = CONV_EOL_RNDTRP_WARN;

 
        if (!DIFF_FILE_VALID(s))
                die("internal error: asking to populate invalid file.");
 
        if (!DIFF_FILE_VALID(s))
                die("internal error: asking to populate invalid file.");


@@ -3603,7 +3603,7 @@ int diff_populate_filespec(struct diff_filespec *s, unsigned int flags)
                /*
                 * Convert from working tree format to canonical git format
                 */
                /*
                 * Convert from working tree format to canonical git format
                 */

-               if (convert_to_git(&the_index, s->path, s->data, s->size, &buf, crlf_warn)) {
+               if (convert_to_git(&the_index, s->path, s->data, s->size, &buf, conv_flags)) {

                        size_t size = 0;
                        munmap(s->data, s->size);
                        s->should_munmap = 0;
                        size_t size = 0;
                        munmap(s->data, s->size);
                        s->should_munmap = 0;

diff --git a/environment.c b/environment.c
index 63ac38a46f8f01ee3d09ed8e09bd93acba63b21a..10a32c20accd5943f4fcd410846647d9630366a2 100644 (file)
--- a/environment.c
+++ b/environment.c
@@ -49,7 +49,7 @@ enum auto_crlf auto_crlf = AUTO_CRLF_FALSE;
 int check_replace_refs = 1;
 char *git_replace_ref_base;
 enum eol core_eol = EOL_UNSET;
 int check_replace_refs = 1;
 char *git_replace_ref_base;
 enum eol core_eol = EOL_UNSET;

-enum safe_crlf safe_crlf = SAFE_CRLF_WARN;
+int global_conv_flags_eol = CONV_EOL_RNDTRP_WARN;

 unsigned whitespace_rule_cfg = WS_DEFAULT_RULE;
 enum branch_track git_branch_track = BRANCH_TRACK_REMOTE;
 enum rebase_setup_type autorebase = AUTOREBASE_NEVER;
 unsigned whitespace_rule_cfg = WS_DEFAULT_RULE;
 enum branch_track git_branch_track = BRANCH_TRACK_REMOTE;
 enum rebase_setup_type autorebase = AUTOREBASE_NEVER;

diff --git a/sha1_file.c b/sha1_file.c
index 3da70ac650a8cdeca6ef8a6a424a7740d38267d5..6bc7c6ada9ec56564a6007bcca54e76d430ebea3 100644 (file)
--- a/sha1_file.c
+++ b/sha1_file.c
@@ -133,14 +133,14 @@ static struct cached_object *find_cached_object(const unsigned char *sha1)
 }
 
 
 }
 
 

-static enum safe_crlf get_safe_crlf(unsigned flags)
+static int get_conv_flags(unsigned flags)

 {
        if (flags & HASH_RENORMALIZE)
 {
        if (flags & HASH_RENORMALIZE)

-               return SAFE_CRLF_RENORMALIZE;
+               return CONV_EOL_RENORMALIZE;

        else if (flags & HASH_WRITE_OBJECT)
        else if (flags & HASH_WRITE_OBJECT)

-               return safe_crlf;
+         return global_conv_flags_eol;

        else
        else

-               return SAFE_CRLF_FALSE;
+               return 0;

 }
 
 
 }
 
 


@@ -1752,7 +1752,7 @@ static int index_mem(struct object_id *oid, void *buf, size_t size,
        if ((type == OBJ_BLOB) && path) {
                struct strbuf nbuf = STRBUF_INIT;
                if (convert_to_git(&the_index, path, buf, size, &nbuf,
        if ((type == OBJ_BLOB) && path) {
                struct strbuf nbuf = STRBUF_INIT;
                if (convert_to_git(&the_index, path, buf, size, &nbuf,

-                                  get_safe_crlf(flags))) {
+                                  get_conv_flags(flags))) {

                        buf = strbuf_detach(&nbuf, &size);
                        re_allocated = 1;
                }
                        buf = strbuf_detach(&nbuf, &size);
                        re_allocated = 1;
                }


@@ -1786,7 +1786,7 @@ static int index_stream_convert_blob(struct object_id *oid, int fd,
        assert(would_convert_to_git_filter_fd(path));
 
        convert_to_git_filter_fd(&the_index, path, fd, &sbuf,
        assert(would_convert_to_git_filter_fd(path));
 
        convert_to_git_filter_fd(&the_index, path, fd, &sbuf,

-                                get_safe_crlf(flags));
+                                get_conv_flags(flags));

 
        if (write_object)
                ret = write_sha1_file(sbuf.buf, sbuf.len, typename(OBJ_BLOB),
 
        if (write_object)
                ret = write_sha1_file(sbuf.buf, sbuf.len, typename(OBJ_BLOB),