Merge branch 'maint'
[git.git] / convert.c
blob9ee31b0ee0949e1d45ac70b463efbb0d47132b32
1 #include "cache.h"
2 #include "attr.h"
3 #include "run-command.h"
5 /*
6 * convert.c - convert a file when checking it out and checking it in.
8 * This should use the pathname to decide on whether it wants to do some
9 * more interesting conversions (automatic gzip/unzip, general format
10 * conversions etc etc), but by default it just does automatic CRLF<->LF
11 * translation when the "auto_crlf" option is set.
14 #define CRLF_GUESS (-1)
15 #define CRLF_BINARY 0
16 #define CRLF_TEXT 1
17 #define CRLF_INPUT 2
19 struct text_stat {
20 /* CR, LF and CRLF counts */
21 unsigned cr, lf, crlf;
23 /* These are just approximations! */
24 unsigned printable, nonprintable;
27 static void gather_stats(const char *buf, unsigned long size, struct text_stat *stats)
29 unsigned long i;
31 memset(stats, 0, sizeof(*stats));
33 for (i = 0; i < size; i++) {
34 unsigned char c = buf[i];
35 if (c == '\r') {
36 stats->cr++;
37 if (i+1 < size && buf[i+1] == '\n')
38 stats->crlf++;
39 continue;
41 if (c == '\n') {
42 stats->lf++;
43 continue;
45 if (c == 127)
46 /* DEL */
47 stats->nonprintable++;
48 else if (c < 32) {
49 switch (c) {
50 /* BS, HT, ESC and FF */
51 case '\b': case '\t': case '\033': case '\014':
52 stats->printable++;
53 break;
54 default:
55 stats->nonprintable++;
58 else
59 stats->printable++;
64 * The same heuristics as diff.c::mmfile_is_binary()
66 static int is_binary(unsigned long size, struct text_stat *stats)
69 if ((stats->printable >> 7) < stats->nonprintable)
70 return 1;
72 * Other heuristics? Average line length might be relevant,
73 * as might LF vs CR vs CRLF counts..
75 * NOTE! It might be normal to have a low ratio of CRLF to LF
76 * (somebody starts with a LF-only file and edits it with an editor
77 * that adds CRLF only to lines that are added..). But do we
78 * want to support CR-only? Probably not.
80 return 0;
83 static char *crlf_to_git(const char *path, const char *src, unsigned long *sizep, int action)
85 char *buffer, *dst;
86 unsigned long size, nsize;
87 struct text_stat stats;
89 if ((action == CRLF_BINARY) || (action == CRLF_GUESS && !auto_crlf))
90 return NULL;
92 size = *sizep;
93 if (!size)
94 return NULL;
96 gather_stats(src, size, &stats);
98 /* No CR? Nothing to convert, regardless. */
99 if (!stats.cr)
100 return NULL;
102 if (action == CRLF_GUESS) {
104 * We're currently not going to even try to convert stuff
105 * that has bare CR characters. Does anybody do that crazy
106 * stuff?
108 if (stats.cr != stats.crlf)
109 return NULL;
112 * And add some heuristics for binary vs text, of course...
114 if (is_binary(size, &stats))
115 return NULL;
119 * Ok, allocate a new buffer, fill it in, and return it
120 * to let the caller know that we switched buffers.
122 nsize = size - stats.crlf;
123 buffer = xmalloc(nsize);
124 *sizep = nsize;
126 dst = buffer;
127 if (action == CRLF_GUESS) {
129 * If we guessed, we already know we rejected a file with
130 * lone CR, and we can strip a CR without looking at what
131 * follow it.
133 do {
134 unsigned char c = *src++;
135 if (c != '\r')
136 *dst++ = c;
137 } while (--size);
138 } else {
139 do {
140 unsigned char c = *src++;
141 if (! (c == '\r' && (1 < size && *src == '\n')))
142 *dst++ = c;
143 } while (--size);
146 return buffer;
149 static char *crlf_to_worktree(const char *path, const char *src, unsigned long *sizep, int action)
151 char *buffer, *dst;
152 unsigned long size, nsize;
153 struct text_stat stats;
154 unsigned char last;
156 if ((action == CRLF_BINARY) || (action == CRLF_INPUT) ||
157 (action == CRLF_GUESS && auto_crlf <= 0))
158 return NULL;
160 size = *sizep;
161 if (!size)
162 return NULL;
164 gather_stats(src, size, &stats);
166 /* No LF? Nothing to convert, regardless. */
167 if (!stats.lf)
168 return NULL;
170 /* Was it already in CRLF format? */
171 if (stats.lf == stats.crlf)
172 return NULL;
174 if (action == CRLF_GUESS) {
175 /* If we have any bare CR characters, we're not going to touch it */
176 if (stats.cr != stats.crlf)
177 return NULL;
179 if (is_binary(size, &stats))
180 return NULL;
184 * Ok, allocate a new buffer, fill it in, and return it
185 * to let the caller know that we switched buffers.
187 nsize = size + stats.lf - stats.crlf;
188 buffer = xmalloc(nsize);
189 *sizep = nsize;
190 last = 0;
192 dst = buffer;
193 do {
194 unsigned char c = *src++;
195 if (c == '\n' && last != '\r')
196 *dst++ = '\r';
197 *dst++ = c;
198 last = c;
199 } while (--size);
201 return buffer;
204 static int filter_buffer(const char *path, const char *src,
205 unsigned long size, const char *cmd)
208 * Spawn cmd and feed the buffer contents through its stdin.
210 struct child_process child_process;
211 int pipe_feed[2];
212 int write_err, status;
214 memset(&child_process, 0, sizeof(child_process));
216 if (pipe(pipe_feed) < 0) {
217 error("cannot create pipe to run external filter %s", cmd);
218 return 1;
221 child_process.pid = fork();
222 if (child_process.pid < 0) {
223 error("cannot fork to run external filter %s", cmd);
224 close(pipe_feed[0]);
225 close(pipe_feed[1]);
226 return 1;
228 if (!child_process.pid) {
229 dup2(pipe_feed[0], 0);
230 close(pipe_feed[0]);
231 close(pipe_feed[1]);
232 execlp("sh", "sh", "-c", cmd, NULL);
233 return 1;
235 close(pipe_feed[0]);
237 write_err = (write_in_full(pipe_feed[1], src, size) < 0);
238 if (close(pipe_feed[1]))
239 write_err = 1;
240 if (write_err)
241 error("cannot feed the input to external filter %s", cmd);
243 status = finish_command(&child_process);
244 if (status)
245 error("external filter %s failed %d", cmd, -status);
246 return (write_err || status);
249 static char *apply_filter(const char *path, const char *src,
250 unsigned long *sizep, const char *cmd)
253 * Create a pipeline to have the command filter the buffer's
254 * contents.
256 * (child --> cmd) --> us
258 const int SLOP = 4096;
259 int pipe_feed[2];
260 int status;
261 char *dst;
262 unsigned long dstsize, dstalloc;
263 struct child_process child_process;
265 if (!cmd)
266 return NULL;
268 memset(&child_process, 0, sizeof(child_process));
270 if (pipe(pipe_feed) < 0) {
271 error("cannot create pipe to run external filter %s", cmd);
272 return NULL;
275 fflush(NULL);
276 child_process.pid = fork();
277 if (child_process.pid < 0) {
278 error("cannot fork to run external filter %s", cmd);
279 close(pipe_feed[0]);
280 close(pipe_feed[1]);
281 return NULL;
283 if (!child_process.pid) {
284 dup2(pipe_feed[1], 1);
285 close(pipe_feed[0]);
286 close(pipe_feed[1]);
287 exit(filter_buffer(path, src, *sizep, cmd));
289 close(pipe_feed[1]);
291 dstalloc = *sizep;
292 dst = xmalloc(dstalloc);
293 dstsize = 0;
295 while (1) {
296 ssize_t numread = xread(pipe_feed[0], dst + dstsize,
297 dstalloc - dstsize);
299 if (numread <= 0) {
300 if (!numread)
301 break;
302 error("read from external filter %s failed", cmd);
303 free(dst);
304 dst = NULL;
305 break;
307 dstsize += numread;
308 if (dstalloc <= dstsize + SLOP) {
309 dstalloc = dstsize + SLOP;
310 dst = xrealloc(dst, dstalloc);
313 if (close(pipe_feed[0])) {
314 error("read from external filter %s failed", cmd);
315 free(dst);
316 dst = NULL;
319 status = finish_command(&child_process);
320 if (status) {
321 error("external filter %s failed %d", cmd, -status);
322 free(dst);
323 dst = NULL;
326 if (dst)
327 *sizep = dstsize;
328 return dst;
331 static struct convert_driver {
332 const char *name;
333 struct convert_driver *next;
334 char *smudge;
335 char *clean;
336 } *user_convert, **user_convert_tail;
338 static int read_convert_config(const char *var, const char *value)
340 const char *ep, *name;
341 int namelen;
342 struct convert_driver *drv;
345 * External conversion drivers are configured using
346 * "filter.<name>.variable".
348 if (prefixcmp(var, "filter.") || (ep = strrchr(var, '.')) == var + 6)
349 return 0;
350 name = var + 7;
351 namelen = ep - name;
352 for (drv = user_convert; drv; drv = drv->next)
353 if (!strncmp(drv->name, name, namelen) && !drv->name[namelen])
354 break;
355 if (!drv) {
356 char *namebuf;
357 drv = xcalloc(1, sizeof(struct convert_driver));
358 namebuf = xmalloc(namelen + 1);
359 memcpy(namebuf, name, namelen);
360 namebuf[namelen] = 0;
361 drv->name = namebuf;
362 drv->next = NULL;
363 *user_convert_tail = drv;
364 user_convert_tail = &(drv->next);
367 ep++;
370 * filter.<name>.smudge and filter.<name>.clean specifies
371 * the command line:
373 * command-line
375 * The command-line will not be interpolated in any way.
378 if (!strcmp("smudge", ep)) {
379 if (!value)
380 return error("%s: lacks value", var);
381 drv->smudge = strdup(value);
382 return 0;
385 if (!strcmp("clean", ep)) {
386 if (!value)
387 return error("%s: lacks value", var);
388 drv->clean = strdup(value);
389 return 0;
391 return 0;
394 static void setup_convert_check(struct git_attr_check *check)
396 static struct git_attr *attr_crlf;
397 static struct git_attr *attr_ident;
398 static struct git_attr *attr_filter;
400 if (!attr_crlf) {
401 attr_crlf = git_attr("crlf", 4);
402 attr_ident = git_attr("ident", 5);
403 attr_filter = git_attr("filter", 6);
404 user_convert_tail = &user_convert;
405 git_config(read_convert_config);
407 check[0].attr = attr_crlf;
408 check[1].attr = attr_ident;
409 check[2].attr = attr_filter;
412 static int count_ident(const char *cp, unsigned long size)
415 * "$ident: 0000000000000000000000000000000000000000 $" <=> "$ident$"
417 int cnt = 0;
418 char ch;
420 while (size) {
421 ch = *cp++;
422 size--;
423 if (ch != '$')
424 continue;
425 if (size < 6)
426 break;
427 if (memcmp("ident", cp, 5))
428 continue;
429 ch = cp[5];
430 cp += 6;
431 size -= 6;
432 if (ch == '$')
433 cnt++; /* $ident$ */
434 if (ch != ':')
435 continue;
438 * "$ident: ... "; scan up to the closing dollar sign and discard.
440 while (size) {
441 ch = *cp++;
442 size--;
443 if (ch == '$') {
444 cnt++;
445 break;
449 return cnt;
452 static char *ident_to_git(const char *path, const char *src, unsigned long *sizep, int ident)
454 int cnt;
455 unsigned long size;
456 char *dst, *buf;
458 if (!ident)
459 return NULL;
460 size = *sizep;
461 cnt = count_ident(src, size);
462 if (!cnt)
463 return NULL;
464 buf = xmalloc(size);
466 for (dst = buf; size; size--) {
467 char ch = *src++;
468 *dst++ = ch;
469 if ((ch == '$') && (6 <= size) &&
470 !memcmp("ident:", src, 6)) {
471 unsigned long rem = size - 6;
472 const char *cp = src + 6;
473 do {
474 ch = *cp++;
475 if (ch == '$')
476 break;
477 rem--;
478 } while (rem);
479 if (!rem)
480 continue;
481 memcpy(dst, "ident$", 6);
482 dst += 6;
483 size -= (cp - src);
484 src = cp;
488 *sizep = dst - buf;
489 return buf;
492 static char *ident_to_worktree(const char *path, const char *src, unsigned long *sizep, int ident)
494 int cnt;
495 unsigned long size;
496 char *dst, *buf;
497 unsigned char sha1[20];
499 if (!ident)
500 return NULL;
502 size = *sizep;
503 cnt = count_ident(src, size);
504 if (!cnt)
505 return NULL;
507 hash_sha1_file(src, size, "blob", sha1);
508 buf = xmalloc(size + cnt * 43);
510 for (dst = buf; size; size--) {
511 const char *cp;
512 char ch = *src++;
513 *dst++ = ch;
514 if ((ch != '$') || (size < 6) || memcmp("ident", src, 5))
515 continue;
517 if (src[5] == ':') {
518 /* discard up to but not including the closing $ */
519 unsigned long rem = size - 6;
520 cp = src + 6;
521 do {
522 ch = *cp++;
523 if (ch == '$')
524 break;
525 rem--;
526 } while (rem);
527 if (!rem)
528 continue;
529 size -= (cp - src);
530 } else if (src[5] == '$')
531 cp = src + 5;
532 else
533 continue;
535 memcpy(dst, "ident: ", 7);
536 dst += 7;
537 memcpy(dst, sha1_to_hex(sha1), 40);
538 dst += 40;
539 *dst++ = ' ';
540 size -= (cp - src);
541 src = cp;
542 *dst++ = *src++;
543 size--;
546 *sizep = dst - buf;
547 return buf;
550 static int git_path_check_crlf(const char *path, struct git_attr_check *check)
552 const char *value = check->value;
554 if (ATTR_TRUE(value))
555 return CRLF_TEXT;
556 else if (ATTR_FALSE(value))
557 return CRLF_BINARY;
558 else if (ATTR_UNSET(value))
560 else if (!strcmp(value, "input"))
561 return CRLF_INPUT;
562 return CRLF_GUESS;
565 static struct convert_driver *git_path_check_convert(const char *path,
566 struct git_attr_check *check)
568 const char *value = check->value;
569 struct convert_driver *drv;
571 if (ATTR_TRUE(value) || ATTR_FALSE(value) || ATTR_UNSET(value))
572 return NULL;
573 for (drv = user_convert; drv; drv = drv->next)
574 if (!strcmp(value, drv->name))
575 return drv;
576 return NULL;
579 static int git_path_check_ident(const char *path, struct git_attr_check *check)
581 const char *value = check->value;
583 return !!ATTR_TRUE(value);
586 char *convert_to_git(const char *path, const char *src, unsigned long *sizep)
588 struct git_attr_check check[3];
589 int crlf = CRLF_GUESS;
590 int ident = 0;
591 char *filter = NULL;
592 char *buf, *buf2;
594 setup_convert_check(check);
595 if (!git_checkattr(path, ARRAY_SIZE(check), check)) {
596 struct convert_driver *drv;
597 crlf = git_path_check_crlf(path, check + 0);
598 ident = git_path_check_ident(path, check + 1);
599 drv = git_path_check_convert(path, check + 2);
600 if (drv && drv->clean)
601 filter = drv->clean;
604 buf = apply_filter(path, src, sizep, filter);
606 buf2 = crlf_to_git(path, buf ? buf : src, sizep, crlf);
607 if (buf2) {
608 free(buf);
609 buf = buf2;
612 buf2 = ident_to_git(path, buf ? buf : src, sizep, ident);
613 if (buf2) {
614 free(buf);
615 buf = buf2;
618 return buf;
621 char *convert_to_working_tree(const char *path, const char *src, unsigned long *sizep)
623 struct git_attr_check check[3];
624 int crlf = CRLF_GUESS;
625 int ident = 0;
626 char *filter = NULL;
627 char *buf, *buf2;
629 setup_convert_check(check);
630 if (!git_checkattr(path, ARRAY_SIZE(check), check)) {
631 struct convert_driver *drv;
632 crlf = git_path_check_crlf(path, check + 0);
633 ident = git_path_check_ident(path, check + 1);
634 drv = git_path_check_convert(path, check + 2);
635 if (drv && drv->smudge)
636 filter = drv->smudge;
639 buf = ident_to_worktree(path, src, sizep, ident);
641 buf2 = crlf_to_worktree(path, buf ? buf : src, sizep, crlf);
642 if (buf2) {
643 free(buf);
644 buf = buf2;
647 buf2 = apply_filter(path, buf ? buf : src, sizep, filter);
648 if (buf2) {
649 free(buf);
650 buf = buf2;
653 return buf;