undef/git-commit-vandalism
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

convert_to_git(): safe_crlf/checksafe becomes int conv_flags

Browse Source 
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>
This commit is contained in:
Torsten Bögershausen 2018-01-13 23:49:31 +01:00 committed by Junio C Hamano
parent 1eaabe34fc
commit 8462ff43e4
8 changed files with 46 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
apply.c
View File

@ -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, static int read_old_data(struct stat *st, struct patch *patch,
const char *path, struct strbuf *buf) const char *path, struct strbuf *buf)
{ {
enum safe_crlf safe_crlf = patch->crlf_in_old ? int conv_flags = patch->crlf_in_old ?
SAFE_CRLF_KEEP_CRLF : SAFE_CRLF_RENORMALIZE; CONV_EOL_KEEP_CRLF : CONV_EOL_RENORMALIZE;
switch (st->st_mode & S_IFMT) { switch (st->st_mode & S_IFMT) {
case S_IFLNK: case S_IFLNK:
if (strbuf_readlink(buf, path, st->st_size) < 0) 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 * should never look at the index when explicit crlf option
* is given. * 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; return 0;
default: default:
return -1; return -1;

2
combine-diff.c
View File

@ -1053,7 +1053,7 @@ static void show_patch_diff(struct combine_diff_path *elem, int num_parent,
if (is_file) { if (is_file) {
struct strbuf buf = STRBUF_INIT; 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); free(result);
result = strbuf_detach(&buf, &len); result = strbuf_detach(&buf, &len);
result_size = len; result_size = len;

7
config.c
View File

@ -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;
} }

38
convert.c
View File

@ -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 ) { if (old_stats->crlf && !new_stats->crlf ) {
/* /*
* CRLFs would not be restored by checkout * 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" warning(_("CRLF will be replaced by LF in %s.\n"
"The file will have its original line" "The file will have its original line"
" endings in your working directory."), path); " 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 ) { } else if (old_stats->lonelf && !new_stats->lonelf ) {
/* /*
* CRLFs would be added by checkout * 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" warning(_("LF will be replaced by CRLF in %s.\n"
"The file will have its original line" "The file will have its original line"
" endings in your working directory."), path); " 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, static int crlf_to_git(const struct index_state *istate,
const char *path, const char *src, size_t len, const char *path, const char *src, size_t len,
struct strbuf *buf, struct strbuf *buf,
enum crlf_action crlf_action, enum safe_crlf checksafe) enum crlf_action crlf_action, int conv_flags)
{ {
struct text_stat stats; struct text_stat stats;
char *dst; 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 * unless we want to renormalize in a merge or
* cherry-pick. * cherry-pick.
*/ */
if ((checksafe != SAFE_CRLF_RENORMALIZE) && if ((!(conv_flags & CONV_EOL_RENORMALIZE)) &&
has_crlf_in_index(istate, path)) has_crlf_in_index(istate, path))
convert_crlf_into_lf = 0; convert_crlf_into_lf = 0;
} }
if ((checksafe == SAFE_CRLF_WARN || if (((conv_flags & CONV_EOL_RNDTRP_WARN) ||
(checksafe == SAFE_CRLF_FAIL)) && len) { ((conv_flags & CONV_EOL_RNDTRP_DIE) && len))) {
struct text_stat new_stats; struct text_stat new_stats;
memcpy(&new_stats, &stats, sizeof(new_stats)); memcpy(&new_stats, &stats, sizeof(new_stats));
/* simulate "git add" */ /* 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.crlf += new_stats.lonelf;
new_stats.lonelf = 0; 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) if (!convert_crlf_into_lf)
return 0; return 0;
@ -1129,7 +1129,7 @@ const char *get_convert_attr_ascii(const char *path)
int convert_to_git(const struct index_state *istate, int convert_to_git(const struct index_state *istate,
const char *path, const char *src, size_t len, 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; int ret = 0;
struct conv_attrs ca; struct conv_attrs ca;
@ -1144,8 +1144,8 @@ int convert_to_git(const struct index_state *istate,
src = dst->buf; src = dst->buf;
len = dst->len; len = dst->len;
} }
if (checksafe != SAFE_CRLF_KEEP_CRLF) { if (!(conv_flags & CONV_EOL_KEEP_CRLF)) {
ret |= crlf_to_git(istate, path, src, len, dst, ca.crlf_action, checksafe); ret |= crlf_to_git(istate, path, src, len, dst, ca.crlf_action, conv_flags);
if (ret && dst) { if (ret && dst) {
src = dst->buf; src = dst->buf;
len = dst->len; 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, void convert_to_git_filter_fd(const struct index_state *istate,
const char *path, int fd, struct strbuf *dst, const char *path, int fd, struct strbuf *dst,
enum safe_crlf checksafe) int conv_flags)
{ {
struct conv_attrs ca; struct conv_attrs ca;
convert_attrs(&ca, path); 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)) if (!apply_filter(path, NULL, 0, fd, dst, ca.drv, CAP_CLEAN, NULL))
die("%s: clean filter '%s' failed", path, ca.drv->name); 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; src = dst->buf;
len = dst->len; 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);
} }
/***************************************************************** /*****************************************************************

17
convert.h
View File

@ -8,15 +8,12 @@
struct index_state; struct index_state;
enum safe_crlf { #define CONV_EOL_RNDTRP_DIE (1<<0) /* Die if CRLF to LF to CRLF is different */
SAFE_CRLF_FALSE = 0, #define CONV_EOL_RNDTRP_WARN (1<<1) /* Warn if CRLF to LF to CRLF is different */
SAFE_CRLF_FAIL = 1, #define CONV_EOL_RENORMALIZE (1<<2) /* Convert CRLF to LF */
SAFE_CRLF_WARN = 2, #define CONV_EOL_KEEP_CRLF (1<<3) /* Keep CRLF line endings as is */
SAFE_CRLF_RENORMALIZE = 3,
SAFE_CRLF_KEEP_CRLF = 4
};
extern enum safe_crlf safe_crlf; extern int global_conv_flags_eol;
enum auto_crlf { enum auto_crlf {
AUTO_CRLF_FALSE = 0, AUTO_CRLF_FALSE = 0,
@ -66,7 +63,7 @@ extern const char *get_convert_attr_ascii(const char *path);
/* returns 1 if *dst was used */ /* returns 1 if *dst was used */
extern int convert_to_git(const struct index_state *istate, extern int convert_to_git(const struct index_state *istate,
const char *path, const char *src, size_t len, 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, extern int convert_to_working_tree(const char *path, const char *src,
size_t len, struct strbuf *dst); size_t len, struct strbuf *dst);
extern int async_convert_to_working_tree(const char *path, const char *src, 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, extern void convert_to_git_filter_fd(const struct index_state *istate,
const char *path, int fd, const char *path, int fd,
struct strbuf *dst, 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);
/***************************************************************** /*****************************************************************

8
diff.c
View File

@ -3520,13 +3520,13 @@ int diff_populate_filespec(struct diff_filespec *s, unsigned int flags)
{ {
int size_only = flags & CHECK_SIZE_ONLY; int size_only = flags & CHECK_SIZE_ONLY;
int err = 0; int err = 0;
int conv_flags = global_conv_flags_eol;
/* /*
* demote FAIL to WARN to allow inspecting the situation * demote FAIL to WARN to allow inspecting the situation
* instead of refusing. * instead of refusing.
*/ */
enum safe_crlf crlf_warn = (safe_crlf == SAFE_CRLF_FAIL if (conv_flags & CONV_EOL_RNDTRP_DIE)
? SAFE_CRLF_WARN conv_flags = CONV_EOL_RNDTRP_WARN;
: safe_crlf);
if (!DIFF_FILE_VALID(s)) if (!DIFF_FILE_VALID(s))
die("internal error: asking to populate invalid file."); 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; size_t size = 0;
munmap(s->data, s->size); munmap(s->data, s->size);
s->should_munmap = 0; s->should_munmap = 0;

2
environment.c
View File

@ -49,7 +49,7 @@ enum auto_crlf auto_crlf = AUTO_CRLF_FALSE;
int check_replace_refs = 1; int check_replace_refs = 1;
char *git_replace_ref_base; char *git_replace_ref_base;
enum eol core_eol = EOL_UNSET; 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; unsigned whitespace_rule_cfg = WS_DEFAULT_RULE;
enum branch_track git_branch_track = BRANCH_TRACK_REMOTE; enum branch_track git_branch_track = BRANCH_TRACK_REMOTE;
enum rebase_setup_type autorebase = AUTOREBASE_NEVER; enum rebase_setup_type autorebase = AUTOREBASE_NEVER;

12
sha1_file.c
View File

@ -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) { if ((type == OBJ_BLOB) && path) {
struct strbuf nbuf = STRBUF_INIT; struct strbuf nbuf = STRBUF_INIT;
if (convert_to_git(&the_index, path, buf, size, &nbuf, if (convert_to_git(&the_index, path, buf, size, &nbuf,
get_safe_crlf(flags))) { get_conv_flags(flags))) {
buf = strbuf_detach(&nbuf, &size); buf = strbuf_detach(&nbuf, &size);
re_allocated = 1; 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)); assert(would_convert_to_git_filter_fd(path));
convert_to_git_filter_fd(&the_index, path, fd, &sbuf, convert_to_git_filter_fd(&the_index, path, fd, &sbuf,
get_safe_crlf(flags)); get_conv_flags(flags));
if (write_object) if (write_object)
ret = write_sha1_file(sbuf.buf, sbuf.len, typename(OBJ_BLOB), ret = write_sha1_file(sbuf.buf, sbuf.len, typename(OBJ_BLOB),