mirror of
https://github.com/git/git
synced 2024-08-27 11:39:22 +00:00
![Junio C Hamano](/assets/img/avatar_default.png)
Earlier we said 'crlf lets the path go through core.autocrlf process while !crlf disables it altogether'. This fixes the semantics to: - Lack of 'crlf' attribute makes core.autocrlf to apply (i.e. we guess based on the contents and if platform expresses its desire to have CRLF line endings via core.autocrlf, we do so). - Setting 'crlf' attribute to true forces CRLF line endings in working tree files, even if blob does not look like text (e.g. contains NUL or other bytes we consider binary). - Setting 'crlf' attribute to false disables conversion. Signed-off-by: Junio C Hamano <junkio@cox.net>
256 lines
5.3 KiB
C
256 lines
5.3 KiB
C
#include "cache.h"
|
|
#include "attr.h"
|
|
|
|
/*
|
|
* convert.c - convert a file when checking it out and checking it in.
|
|
*
|
|
* This should use the pathname to decide on whether it wants to do some
|
|
* more interesting conversions (automatic gzip/unzip, general format
|
|
* conversions etc etc), but by default it just does automatic CRLF<->LF
|
|
* translation when the "auto_crlf" option is set.
|
|
*/
|
|
|
|
struct text_stat {
|
|
/* CR, LF and CRLF counts */
|
|
unsigned cr, lf, crlf;
|
|
|
|
/* These are just approximations! */
|
|
unsigned printable, nonprintable;
|
|
};
|
|
|
|
static void gather_stats(const char *buf, unsigned long size, struct text_stat *stats)
|
|
{
|
|
unsigned long i;
|
|
|
|
memset(stats, 0, sizeof(*stats));
|
|
|
|
for (i = 0; i < size; i++) {
|
|
unsigned char c = buf[i];
|
|
if (c == '\r') {
|
|
stats->cr++;
|
|
if (i+1 < size && buf[i+1] == '\n')
|
|
stats->crlf++;
|
|
continue;
|
|
}
|
|
if (c == '\n') {
|
|
stats->lf++;
|
|
continue;
|
|
}
|
|
if (c == 127)
|
|
/* DEL */
|
|
stats->nonprintable++;
|
|
else if (c < 32) {
|
|
switch (c) {
|
|
/* BS, HT, ESC and FF */
|
|
case '\b': case '\t': case '\033': case '\014':
|
|
stats->printable++;
|
|
break;
|
|
default:
|
|
stats->nonprintable++;
|
|
}
|
|
}
|
|
else
|
|
stats->printable++;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* The same heuristics as diff.c::mmfile_is_binary()
|
|
*/
|
|
static int is_binary(unsigned long size, struct text_stat *stats)
|
|
{
|
|
|
|
if ((stats->printable >> 7) < stats->nonprintable)
|
|
return 1;
|
|
/*
|
|
* Other heuristics? Average line length might be relevant,
|
|
* as might LF vs CR vs CRLF counts..
|
|
*
|
|
* NOTE! It might be normal to have a low ratio of CRLF to LF
|
|
* (somebody starts with a LF-only file and edits it with an editor
|
|
* that adds CRLF only to lines that are added..). But do we
|
|
* want to support CR-only? Probably not.
|
|
*/
|
|
return 0;
|
|
}
|
|
|
|
static int crlf_to_git(const char *path, char **bufp, unsigned long *sizep, int guess)
|
|
{
|
|
char *buffer, *nbuf;
|
|
unsigned long size, nsize;
|
|
struct text_stat stats;
|
|
|
|
if (guess && !auto_crlf)
|
|
return 0;
|
|
|
|
size = *sizep;
|
|
if (!size)
|
|
return 0;
|
|
buffer = *bufp;
|
|
|
|
gather_stats(buffer, size, &stats);
|
|
|
|
/* No CR? Nothing to convert, regardless. */
|
|
if (!stats.cr)
|
|
return 0;
|
|
|
|
if (guess) {
|
|
/*
|
|
* We're currently not going to even try to convert stuff
|
|
* that has bare CR characters. Does anybody do that crazy
|
|
* stuff?
|
|
*/
|
|
if (stats.cr != stats.crlf)
|
|
return 0;
|
|
|
|
/*
|
|
* And add some heuristics for binary vs text, of course...
|
|
*/
|
|
if (is_binary(size, &stats))
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Ok, allocate a new buffer, fill it in, and return true
|
|
* to let the caller know that we switched buffers on it.
|
|
*/
|
|
nsize = size - stats.crlf;
|
|
nbuf = xmalloc(nsize);
|
|
*bufp = nbuf;
|
|
*sizep = nsize;
|
|
|
|
if (guess) {
|
|
do {
|
|
unsigned char c = *buffer++;
|
|
if (c != '\r')
|
|
*nbuf++ = c;
|
|
} while (--size);
|
|
} else {
|
|
do {
|
|
unsigned char c = *buffer++;
|
|
if (! (c == '\r' && (1 < size && *buffer == '\n')))
|
|
*nbuf++ = c;
|
|
} while (--size);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int autocrlf_to_git(const char *path, char **bufp, unsigned long *sizep)
|
|
{
|
|
return crlf_to_git(path, bufp, sizep, 1);
|
|
}
|
|
|
|
static int forcecrlf_to_git(const char *path, char **bufp, unsigned long *sizep)
|
|
{
|
|
return crlf_to_git(path, bufp, sizep, 0);
|
|
}
|
|
|
|
static int crlf_to_working_tree(const char *path, char **bufp, unsigned long *sizep, int guess)
|
|
{
|
|
char *buffer, *nbuf;
|
|
unsigned long size, nsize;
|
|
struct text_stat stats;
|
|
unsigned char last;
|
|
|
|
if (guess && auto_crlf <= 0)
|
|
return 0;
|
|
|
|
size = *sizep;
|
|
if (!size)
|
|
return 0;
|
|
buffer = *bufp;
|
|
|
|
gather_stats(buffer, size, &stats);
|
|
|
|
/* No LF? Nothing to convert, regardless. */
|
|
if (!stats.lf)
|
|
return 0;
|
|
|
|
/* Was it already in CRLF format? */
|
|
if (stats.lf == stats.crlf)
|
|
return 0;
|
|
|
|
if (guess) {
|
|
/* If we have any bare CR characters, we're not going to touch it */
|
|
if (stats.cr != stats.crlf)
|
|
return 0;
|
|
|
|
if (is_binary(size, &stats))
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Ok, allocate a new buffer, fill it in, and return true
|
|
* to let the caller know that we switched buffers on it.
|
|
*/
|
|
nsize = size + stats.lf - stats.crlf;
|
|
nbuf = xmalloc(nsize);
|
|
*bufp = nbuf;
|
|
*sizep = nsize;
|
|
last = 0;
|
|
do {
|
|
unsigned char c = *buffer++;
|
|
if (c == '\n' && last != '\r')
|
|
*nbuf++ = '\r';
|
|
*nbuf++ = c;
|
|
last = c;
|
|
} while (--size);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int autocrlf_to_working_tree(const char *path, char **bufp, unsigned long *sizep)
|
|
{
|
|
return crlf_to_working_tree(path, bufp, sizep, 1);
|
|
}
|
|
|
|
static int forcecrlf_to_working_tree(const char *path, char **bufp, unsigned long *sizep)
|
|
{
|
|
return crlf_to_working_tree(path, bufp, sizep, 0);
|
|
}
|
|
|
|
static void setup_crlf_check(struct git_attr_check *check)
|
|
{
|
|
static struct git_attr *attr_crlf;
|
|
|
|
if (!attr_crlf)
|
|
attr_crlf = git_attr("crlf", 4);
|
|
check->attr = attr_crlf;
|
|
}
|
|
|
|
static int git_path_check_crlf(const char *path)
|
|
{
|
|
struct git_attr_check attr_crlf_check;
|
|
|
|
setup_crlf_check(&attr_crlf_check);
|
|
|
|
if (git_checkattr(path, 1, &attr_crlf_check))
|
|
return -1;
|
|
return attr_crlf_check.isset;
|
|
}
|
|
|
|
int convert_to_git(const char *path, char **bufp, unsigned long *sizep)
|
|
{
|
|
switch (git_path_check_crlf(path)) {
|
|
case 0:
|
|
return 0;
|
|
case 1:
|
|
return forcecrlf_to_git(path, bufp, sizep);
|
|
default:
|
|
return autocrlf_to_git(path, bufp, sizep);
|
|
}
|
|
}
|
|
|
|
int convert_to_working_tree(const char *path, char **bufp, unsigned long *sizep)
|
|
{
|
|
switch (git_path_check_crlf(path)) {
|
|
case 0:
|
|
return 0;
|
|
case 1:
|
|
return forcecrlf_to_working_tree(path, bufp, sizep);
|
|
default:
|
|
return autocrlf_to_working_tree(path, bufp, sizep);
|
|
}
|
|
}
|