ad106ef35fb0729709b243d6292980f15cd1b0a5
   1#include "cache.h"
   2#include "attr.h"
   3
   4/*
   5 * convert.c - convert a file when checking it out and checking it in.
   6 *
   7 * This should use the pathname to decide on whether it wants to do some
   8 * more interesting conversions (automatic gzip/unzip, general format
   9 * conversions etc etc), but by default it just does automatic CRLF<->LF
  10 * translation when the "auto_crlf" option is set.
  11 */
  12
  13#define CRLF_GUESS      (-1)
  14#define CRLF_BINARY     0
  15#define CRLF_TEXT       1
  16#define CRLF_INPUT      2
  17
  18struct text_stat {
  19        /* CR, LF and CRLF counts */
  20        unsigned cr, lf, crlf;
  21
  22        /* These are just approximations! */
  23        unsigned printable, nonprintable;
  24};
  25
  26static void gather_stats(const char *buf, unsigned long size, struct text_stat *stats)
  27{
  28        unsigned long i;
  29
  30        memset(stats, 0, sizeof(*stats));
  31
  32        for (i = 0; i < size; i++) {
  33                unsigned char c = buf[i];
  34                if (c == '\r') {
  35                        stats->cr++;
  36                        if (i+1 < size && buf[i+1] == '\n')
  37                                stats->crlf++;
  38                        continue;
  39                }
  40                if (c == '\n') {
  41                        stats->lf++;
  42                        continue;
  43                }
  44                if (c == 127)
  45                        /* DEL */
  46                        stats->nonprintable++;
  47                else if (c < 32) {
  48                        switch (c) {
  49                                /* BS, HT, ESC and FF */
  50                        case '\b': case '\t': case '\033': case '\014':
  51                                stats->printable++;
  52                                break;
  53                        default:
  54                                stats->nonprintable++;
  55                        }
  56                }
  57                else
  58                        stats->printable++;
  59        }
  60}
  61
  62/*
  63 * The same heuristics as diff.c::mmfile_is_binary()
  64 */
  65static int is_binary(unsigned long size, struct text_stat *stats)
  66{
  67
  68        if ((stats->printable >> 7) < stats->nonprintable)
  69                return 1;
  70        /*
  71         * Other heuristics? Average line length might be relevant,
  72         * as might LF vs CR vs CRLF counts..
  73         *
  74         * NOTE! It might be normal to have a low ratio of CRLF to LF
  75         * (somebody starts with a LF-only file and edits it with an editor
  76         * that adds CRLF only to lines that are added..). But do  we
  77         * want to support CR-only? Probably not.
  78         */
  79        return 0;
  80}
  81
  82static char *crlf_to_git(const char *path, const char *src, unsigned long *sizep, int action)
  83{
  84        char *buffer, *dst;
  85        unsigned long size, nsize;
  86        struct text_stat stats;
  87
  88        if ((action == CRLF_BINARY) || (action == CRLF_GUESS && !auto_crlf))
  89                return NULL;
  90
  91        size = *sizep;
  92        if (!size)
  93                return NULL;
  94
  95        gather_stats(src, size, &stats);
  96
  97        /* No CR? Nothing to convert, regardless. */
  98        if (!stats.cr)
  99                return NULL;
 100
 101        if (action == CRLF_GUESS) {
 102                /*
 103                 * We're currently not going to even try to convert stuff
 104                 * that has bare CR characters. Does anybody do that crazy
 105                 * stuff?
 106                 */
 107                if (stats.cr != stats.crlf)
 108                        return NULL;
 109
 110                /*
 111                 * And add some heuristics for binary vs text, of course...
 112                 */
 113                if (is_binary(size, &stats))
 114                        return NULL;
 115        }
 116
 117        /*
 118         * Ok, allocate a new buffer, fill it in, and return it
 119         * to let the caller know that we switched buffers.
 120         */
 121        nsize = size - stats.crlf;
 122        buffer = xmalloc(nsize);
 123        *sizep = nsize;
 124
 125        dst = buffer;
 126        if (action == CRLF_GUESS) {
 127                /*
 128                 * If we guessed, we already know we rejected a file with
 129                 * lone CR, and we can strip a CR without looking at what
 130                 * follow it.
 131                 */
 132                do {
 133                        unsigned char c = *src++;
 134                        if (c != '\r')
 135                                *dst++ = c;
 136                } while (--size);
 137        } else {
 138                do {
 139                        unsigned char c = *src++;
 140                        if (! (c == '\r' && (1 < size && *src == '\n')))
 141                                *dst++ = c;
 142                } while (--size);
 143        }
 144
 145        return buffer;
 146}
 147
 148static char *crlf_to_worktree(const char *path, const char *src, unsigned long *sizep, int action)
 149{
 150        char *buffer, *dst;
 151        unsigned long size, nsize;
 152        struct text_stat stats;
 153        unsigned char last;
 154
 155        if ((action == CRLF_BINARY) || (action == CRLF_INPUT) ||
 156            (action == CRLF_GUESS && auto_crlf <= 0))
 157                return NULL;
 158
 159        size = *sizep;
 160        if (!size)
 161                return NULL;
 162
 163        gather_stats(src, size, &stats);
 164
 165        /* No LF? Nothing to convert, regardless. */
 166        if (!stats.lf)
 167                return NULL;
 168
 169        /* Was it already in CRLF format? */
 170        if (stats.lf == stats.crlf)
 171                return NULL;
 172
 173        if (action == CRLF_GUESS) {
 174                /* If we have any bare CR characters, we're not going to touch it */
 175                if (stats.cr != stats.crlf)
 176                        return NULL;
 177
 178                if (is_binary(size, &stats))
 179                        return NULL;
 180        }
 181
 182        /*
 183         * Ok, allocate a new buffer, fill it in, and return it
 184         * to let the caller know that we switched buffers.
 185         */
 186        nsize = size + stats.lf - stats.crlf;
 187        buffer = xmalloc(nsize);
 188        *sizep = nsize;
 189        last = 0;
 190
 191        dst = buffer;
 192        do {
 193                unsigned char c = *src++;
 194                if (c == '\n' && last != '\r')
 195                        *dst++ = '\r';
 196                *dst++ = c;
 197                last = c;
 198        } while (--size);
 199
 200        return buffer;
 201}
 202
 203static void setup_convert_check(struct git_attr_check *check)
 204{
 205        static struct git_attr *attr_crlf;
 206
 207        if (!attr_crlf)
 208                attr_crlf = git_attr("crlf", 4);
 209        check->attr = attr_crlf;
 210}
 211
 212static int git_path_check_crlf(const char *path, struct git_attr_check *check)
 213{
 214        const char *value = check->value;
 215
 216        if (ATTR_TRUE(value))
 217                return CRLF_TEXT;
 218        else if (ATTR_FALSE(value))
 219                return CRLF_BINARY;
 220        else if (ATTR_UNSET(value))
 221                ;
 222        else if (!strcmp(value, "input"))
 223                return CRLF_INPUT;
 224        return CRLF_GUESS;
 225}
 226
 227char *convert_to_git(const char *path, const char *src, unsigned long *sizep)
 228{
 229        struct git_attr_check check[1];
 230        int crlf = CRLF_GUESS;
 231
 232        setup_convert_check(check);
 233        if (!git_checkattr(path, 1, check)) {
 234                crlf = git_path_check_crlf(path, check);
 235        }
 236        return crlf_to_git(path, src, sizep, crlf);
 237}
 238
 239char *convert_to_working_tree(const char *path, const char *src, unsigned long *sizep)
 240{
 241        struct git_attr_check check[1];
 242        int crlf = CRLF_GUESS;
 243
 244        setup_convert_check(check);
 245        if (!git_checkattr(path, 1, check)) {
 246                crlf = git_path_check_crlf(path, check);
 247        }
 248        return crlf_to_worktree(path, src, sizep, crlf);
 249}