3 #include "run-command.h"
8 * convert.c - convert a file when checking it out and checking it in.
10 * This should use the pathname to decide on whether it wants to do some
11 * more interesting conversions (automatic gzip/unzip, general format
12 * conversions etc etc), but by default it just does automatic CRLF<->LF
13 * translation when the "text" attribute or "auto_crlf" option is set.
26 /* NUL, CR, LF and CRLF counts */
27 unsigned nul
, cr
, lf
, crlf
;
29 /* These are just approximations! */
30 unsigned printable
, nonprintable
;
33 static void gather_stats(const char *buf
, unsigned long size
, struct text_stat
*stats
)
37 memset(stats
, 0, sizeof(*stats
));
39 for (i
= 0; i
< size
; i
++) {
40 unsigned char c
= buf
[i
];
43 if (i
+1 < size
&& buf
[i
+1] == '\n')
53 stats
->nonprintable
++;
56 /* BS, HT, ESC and FF */
57 case '\b': case '\t': case '\033': case '\014':
64 stats
->nonprintable
++;
71 /* If file ends with EOF then don't count this EOF as non-printable. */
72 if (size
>= 1 && buf
[size
-1] == '\032')
73 stats
->nonprintable
--;
77 * The same heuristics as diff.c::mmfile_is_binary()
79 static int is_binary(unsigned long size
, struct text_stat
*stats
)
84 if ((stats
->printable
>> 7) < stats
->nonprintable
)
87 * Other heuristics? Average line length might be relevant,
88 * as might LF vs CR vs CRLF counts..
90 * NOTE! It might be normal to have a low ratio of CRLF to LF
91 * (somebody starts with a LF-only file and edits it with an editor
92 * that adds CRLF only to lines that are added..). But do we
93 * want to support CR-only? Probably not.
98 static enum eol
output_eol(enum crlf_action crlf_action
)
100 switch (crlf_action
) {
113 if (auto_crlf
== AUTO_CRLF_TRUE
)
115 else if (auto_crlf
== AUTO_CRLF_INPUT
)
117 else if (core_eol
== EOL_UNSET
)
123 static void check_safe_crlf(const char *path
, enum crlf_action crlf_action
,
124 struct text_stat
*stats
, enum safe_crlf checksafe
)
129 if (output_eol(crlf_action
) == EOL_LF
) {
131 * CRLFs would not be restored by checkout:
132 * check if we'd remove CRLFs
135 if (checksafe
== SAFE_CRLF_WARN
)
136 warning("CRLF will be replaced by LF in %s.\nThe file will have its original line endings in your working directory.", path
);
137 else /* i.e. SAFE_CRLF_FAIL */
138 die("CRLF would be replaced by LF in %s.", path
);
140 } else if (output_eol(crlf_action
) == EOL_CRLF
) {
142 * CRLFs would be added by checkout:
143 * check if we have "naked" LFs
145 if (stats
->lf
!= stats
->crlf
) {
146 if (checksafe
== SAFE_CRLF_WARN
)
147 warning("LF will be replaced by CRLF in %s.\nThe file will have its original line endings in your working directory.", path
);
148 else /* i.e. SAFE_CRLF_FAIL */
149 die("LF would be replaced by CRLF in %s", path
);
154 static int has_cr_in_index(const char *path
)
160 data
= read_blob_data_from_cache(path
, &sz
);
163 has_cr
= memchr(data
, '\r', sz
) != NULL
;
168 static int crlf_to_git(const char *path
, const char *src
, size_t len
,
170 enum crlf_action crlf_action
, enum safe_crlf checksafe
)
172 struct text_stat stats
;
175 if (crlf_action
== CRLF_BINARY
||
176 (crlf_action
== CRLF_GUESS
&& auto_crlf
== AUTO_CRLF_FALSE
) ||
181 * If we are doing a dry-run and have no source buffer, there is
182 * nothing to analyze; we must assume we would convert.
187 gather_stats(src
, len
, &stats
);
189 if (crlf_action
== CRLF_AUTO
|| crlf_action
== CRLF_GUESS
) {
191 * We're currently not going to even try to convert stuff
192 * that has bare CR characters. Does anybody do that crazy
195 if (stats
.cr
!= stats
.crlf
)
199 * And add some heuristics for binary vs text, of course...
201 if (is_binary(len
, &stats
))
204 if (crlf_action
== CRLF_GUESS
) {
206 * If the file in the index has any CR in it, do not convert.
207 * This is the new safer autocrlf handling.
209 if (has_cr_in_index(path
))
214 check_safe_crlf(path
, crlf_action
, &stats
, checksafe
);
216 /* Optimization: No CR? Nothing to convert, regardless. */
221 * At this point all of our source analysis is done, and we are sure we
222 * would convert. If we are in dry-run mode, we can give an answer.
227 /* only grow if not in place */
228 if (strbuf_avail(buf
) + buf
->len
< len
)
229 strbuf_grow(buf
, len
- buf
->len
);
231 if (crlf_action
== CRLF_AUTO
|| crlf_action
== CRLF_GUESS
) {
233 * If we guessed, we already know we rejected a file with
234 * lone CR, and we can strip a CR without looking at what
238 unsigned char c
= *src
++;
244 unsigned char c
= *src
++;
245 if (! (c
== '\r' && (1 < len
&& *src
== '\n')))
249 strbuf_setlen(buf
, dst
- buf
->buf
);
253 static int crlf_to_worktree(const char *path
, const char *src
, size_t len
,
254 struct strbuf
*buf
, enum crlf_action crlf_action
)
256 char *to_free
= NULL
;
257 struct text_stat stats
;
259 if (!len
|| output_eol(crlf_action
) != EOL_CRLF
)
262 gather_stats(src
, len
, &stats
);
264 /* No LF? Nothing to convert, regardless. */
268 /* Was it already in CRLF format? */
269 if (stats
.lf
== stats
.crlf
)
272 if (crlf_action
== CRLF_AUTO
|| crlf_action
== CRLF_GUESS
) {
273 if (crlf_action
== CRLF_GUESS
) {
274 /* If we have any CR or CRLF line endings, we do not touch it */
275 /* This is the new safer autocrlf-handling */
276 if (stats
.cr
> 0 || stats
.crlf
> 0)
280 /* If we have any bare CR characters, we're not going to touch it */
281 if (stats
.cr
!= stats
.crlf
)
284 if (is_binary(len
, &stats
))
288 /* are we "faking" in place editing ? */
290 to_free
= strbuf_detach(buf
, NULL
);
292 strbuf_grow(buf
, len
+ stats
.lf
- stats
.crlf
);
294 const char *nl
= memchr(src
, '\n', len
);
297 if (nl
> src
&& nl
[-1] == '\r') {
298 strbuf_add(buf
, src
, nl
+ 1 - src
);
300 strbuf_add(buf
, src
, nl
- src
);
301 strbuf_addstr(buf
, "\r\n");
306 strbuf_add(buf
, src
, len
);
312 struct filter_params
{
319 static int filter_buffer(int in
, int out
, void *data
)
322 * Spawn cmd and feed the buffer contents through its stdin.
324 struct child_process child_process
;
325 struct filter_params
*params
= (struct filter_params
*)data
;
326 int write_err
, status
;
327 const char *argv
[] = { NULL
, NULL
};
329 /* apply % substitution to cmd */
330 struct strbuf cmd
= STRBUF_INIT
;
331 struct strbuf path
= STRBUF_INIT
;
332 struct strbuf_expand_dict_entry dict
[] = {
337 /* quote the path to preserve spaces, etc. */
338 sq_quote_buf(&path
, params
->path
);
339 dict
[0].value
= path
.buf
;
341 /* expand all %f with the quoted path */
342 strbuf_expand(&cmd
, params
->cmd
, strbuf_expand_dict_cb
, &dict
);
343 strbuf_release(&path
);
347 memset(&child_process
, 0, sizeof(child_process
));
348 child_process
.argv
= argv
;
349 child_process
.use_shell
= 1;
350 child_process
.in
= -1;
351 child_process
.out
= out
;
353 if (start_command(&child_process
))
354 return error("cannot fork to run external filter %s", params
->cmd
);
356 sigchain_push(SIGPIPE
, SIG_IGN
);
358 write_err
= (write_in_full(child_process
.in
, params
->src
, params
->size
) < 0);
359 if (close(child_process
.in
))
362 error("cannot feed the input to external filter %s", params
->cmd
);
364 sigchain_pop(SIGPIPE
);
366 status
= finish_command(&child_process
);
368 error("external filter %s failed %d", params
->cmd
, status
);
370 strbuf_release(&cmd
);
371 return (write_err
|| status
);
374 static int apply_filter(const char *path
, const char *src
, size_t len
,
375 struct strbuf
*dst
, const char *cmd
)
378 * Create a pipeline to have the command filter the buffer's
381 * (child --> cmd) --> us
384 struct strbuf nbuf
= STRBUF_INIT
;
386 struct filter_params params
;
394 memset(&async
, 0, sizeof(async
));
395 async
.proc
= filter_buffer
;
396 async
.data
= ¶ms
;
404 if (start_async(&async
))
405 return 0; /* error was already reported */
407 if (strbuf_read(&nbuf
, async
.out
, len
) < 0) {
408 error("read from external filter %s failed", cmd
);
411 if (close(async
.out
)) {
412 error("read from external filter %s failed", cmd
);
415 if (finish_async(&async
)) {
416 error("external filter %s failed", cmd
);
421 strbuf_swap(dst
, &nbuf
);
423 strbuf_release(&nbuf
);
427 static struct convert_driver
{
429 struct convert_driver
*next
;
433 } *user_convert
, **user_convert_tail
;
435 static int read_convert_config(const char *var
, const char *value
, void *cb
)
437 const char *ep
, *name
;
439 struct convert_driver
*drv
;
442 * External conversion drivers are configured using
443 * "filter.<name>.variable".
445 if (prefixcmp(var
, "filter.") || (ep
= strrchr(var
, '.')) == var
+ 6)
449 for (drv
= user_convert
; drv
; drv
= drv
->next
)
450 if (!strncmp(drv
->name
, name
, namelen
) && !drv
->name
[namelen
])
453 drv
= xcalloc(1, sizeof(struct convert_driver
));
454 drv
->name
= xmemdupz(name
, namelen
);
455 *user_convert_tail
= drv
;
456 user_convert_tail
= &(drv
->next
);
462 * filter.<name>.smudge and filter.<name>.clean specifies
467 * The command-line will not be interpolated in any way.
470 if (!strcmp("smudge", ep
))
471 return git_config_string(&drv
->smudge
, var
, value
);
473 if (!strcmp("clean", ep
))
474 return git_config_string(&drv
->clean
, var
, value
);
476 if (!strcmp("required", ep
)) {
477 drv
->required
= git_config_bool(var
, value
);
484 static int count_ident(const char *cp
, unsigned long size
)
487 * "$Id: 0000000000000000000000000000000000000000 $" <=> "$Id$"
499 if (memcmp("Id", cp
, 2))
510 * "$Id: ... "; scan up to the closing dollar sign and discard.
526 static int ident_to_git(const char *path
, const char *src
, size_t len
,
527 struct strbuf
*buf
, int ident
)
531 if (!ident
|| (src
&& !count_ident(src
, len
)))
537 /* only grow if not in place */
538 if (strbuf_avail(buf
) + buf
->len
< len
)
539 strbuf_grow(buf
, len
- buf
->len
);
542 dollar
= memchr(src
, '$', len
);
545 memmove(dst
, src
, dollar
+ 1 - src
);
546 dst
+= dollar
+ 1 - src
;
547 len
-= dollar
+ 1 - src
;
550 if (len
> 3 && !memcmp(src
, "Id:", 3)) {
551 dollar
= memchr(src
+ 3, '$', len
- 3);
554 if (memchr(src
+ 3, '\n', dollar
- src
- 3)) {
555 /* Line break before the next dollar. */
559 memcpy(dst
, "Id$", 3);
561 len
-= dollar
+ 1 - src
;
565 memmove(dst
, src
, len
);
566 strbuf_setlen(buf
, dst
+ len
- buf
->buf
);
570 static int ident_to_worktree(const char *path
, const char *src
, size_t len
,
571 struct strbuf
*buf
, int ident
)
573 unsigned char sha1
[20];
574 char *to_free
= NULL
, *dollar
, *spc
;
580 cnt
= count_ident(src
, len
);
584 /* are we "faking" in place editing ? */
586 to_free
= strbuf_detach(buf
, NULL
);
587 hash_sha1_file(src
, len
, "blob", sha1
);
589 strbuf_grow(buf
, len
+ cnt
* 43);
591 /* step 1: run to the next '$' */
592 dollar
= memchr(src
, '$', len
);
595 strbuf_add(buf
, src
, dollar
+ 1 - src
);
596 len
-= dollar
+ 1 - src
;
599 /* step 2: does it looks like a bit like Id:xxx$ or Id$ ? */
600 if (len
< 3 || memcmp("Id", src
, 2))
603 /* step 3: skip over Id$ or Id:xxxxx$ */
607 } else if (src
[2] == ':') {
609 * It's possible that an expanded Id has crept its way into the
610 * repository, we cope with that by stripping the expansion out.
611 * This is probably not a good idea, since it will cause changes
612 * on checkout, which won't go away by stash, but let's keep it
615 dollar
= memchr(src
+ 3, '$', len
- 3);
617 /* incomplete keyword, no more '$', so just quit the loop */
621 if (memchr(src
+ 3, '\n', dollar
- src
- 3)) {
622 /* Line break before the next dollar. */
626 spc
= memchr(src
+ 4, ' ', dollar
- src
- 4);
627 if (spc
&& spc
< dollar
-1) {
628 /* There are spaces in unexpected places.
629 * This is probably an id from some other
630 * versioning system. Keep it for now.
635 len
-= dollar
+ 1 - src
;
638 /* it wasn't a "Id$" or "Id:xxxx$" */
642 /* step 4: substitute */
643 strbuf_addstr(buf
, "Id: ");
644 strbuf_add(buf
, sha1_to_hex(sha1
), 40);
645 strbuf_addstr(buf
, " $");
647 strbuf_add(buf
, src
, len
);
653 static enum crlf_action
git_path_check_crlf(const char *path
, struct git_attr_check
*check
)
655 const char *value
= check
->value
;
657 if (ATTR_TRUE(value
))
659 else if (ATTR_FALSE(value
))
661 else if (ATTR_UNSET(value
))
663 else if (!strcmp(value
, "input"))
665 else if (!strcmp(value
, "auto"))
670 static enum eol
git_path_check_eol(const char *path
, struct git_attr_check
*check
)
672 const char *value
= check
->value
;
674 if (ATTR_UNSET(value
))
676 else if (!strcmp(value
, "lf"))
678 else if (!strcmp(value
, "crlf"))
683 static struct convert_driver
*git_path_check_convert(const char *path
,
684 struct git_attr_check
*check
)
686 const char *value
= check
->value
;
687 struct convert_driver
*drv
;
689 if (ATTR_TRUE(value
) || ATTR_FALSE(value
) || ATTR_UNSET(value
))
691 for (drv
= user_convert
; drv
; drv
= drv
->next
)
692 if (!strcmp(value
, drv
->name
))
697 static int git_path_check_ident(const char *path
, struct git_attr_check
*check
)
699 const char *value
= check
->value
;
701 return !!ATTR_TRUE(value
);
704 static enum crlf_action
input_crlf_action(enum crlf_action text_attr
, enum eol eol_attr
)
706 if (text_attr
== CRLF_BINARY
)
708 if (eol_attr
== EOL_LF
)
710 if (eol_attr
== EOL_CRLF
)
716 struct convert_driver
*drv
;
717 enum crlf_action crlf_action
;
722 static const char *conv_attr_name
[] = {
723 "crlf", "ident", "filter", "eol", "text",
725 #define NUM_CONV_ATTRS ARRAY_SIZE(conv_attr_name)
727 static void convert_attrs(struct conv_attrs
*ca
, const char *path
)
730 static struct git_attr_check ccheck
[NUM_CONV_ATTRS
];
732 if (!ccheck
[0].attr
) {
733 for (i
= 0; i
< NUM_CONV_ATTRS
; i
++)
734 ccheck
[i
].attr
= git_attr(conv_attr_name
[i
]);
735 user_convert_tail
= &user_convert
;
736 git_config(read_convert_config
, NULL
);
739 if (!git_check_attr(path
, NUM_CONV_ATTRS
, ccheck
)) {
740 ca
->crlf_action
= git_path_check_crlf(path
, ccheck
+ 4);
741 if (ca
->crlf_action
== CRLF_GUESS
)
742 ca
->crlf_action
= git_path_check_crlf(path
, ccheck
+ 0);
743 ca
->ident
= git_path_check_ident(path
, ccheck
+ 1);
744 ca
->drv
= git_path_check_convert(path
, ccheck
+ 2);
745 ca
->eol_attr
= git_path_check_eol(path
, ccheck
+ 3);
748 ca
->crlf_action
= CRLF_GUESS
;
749 ca
->eol_attr
= EOL_UNSET
;
754 int convert_to_git(const char *path
, const char *src
, size_t len
,
755 struct strbuf
*dst
, enum safe_crlf checksafe
)
758 const char *filter
= NULL
;
760 struct conv_attrs ca
;
762 convert_attrs(&ca
, path
);
764 filter
= ca
.drv
->clean
;
765 required
= ca
.drv
->required
;
768 ret
|= apply_filter(path
, src
, len
, dst
, filter
);
769 if (!ret
&& required
)
770 die("%s: clean filter '%s' failed", path
, ca
.drv
->name
);
776 ca
.crlf_action
= input_crlf_action(ca
.crlf_action
, ca
.eol_attr
);
777 ret
|= crlf_to_git(path
, src
, len
, dst
, ca
.crlf_action
, checksafe
);
782 return ret
| ident_to_git(path
, src
, len
, dst
, ca
.ident
);
785 static int convert_to_working_tree_internal(const char *path
, const char *src
,
786 size_t len
, struct strbuf
*dst
,
789 int ret
= 0, ret_filter
= 0;
790 const char *filter
= NULL
;
792 struct conv_attrs ca
;
794 convert_attrs(&ca
, path
);
796 filter
= ca
.drv
->smudge
;
797 required
= ca
.drv
->required
;
800 ret
|= ident_to_worktree(path
, src
, len
, dst
, ca
.ident
);
806 * CRLF conversion can be skipped if normalizing, unless there
807 * is a smudge filter. The filter might expect CRLFs.
809 if (filter
|| !normalizing
) {
810 ca
.crlf_action
= input_crlf_action(ca
.crlf_action
, ca
.eol_attr
);
811 ret
|= crlf_to_worktree(path
, src
, len
, dst
, ca
.crlf_action
);
818 ret_filter
= apply_filter(path
, src
, len
, dst
, filter
);
819 if (!ret_filter
&& required
)
820 die("%s: smudge filter %s failed", path
, ca
.drv
->name
);
822 return ret
| ret_filter
;
825 int convert_to_working_tree(const char *path
, const char *src
, size_t len
, struct strbuf
*dst
)
827 return convert_to_working_tree_internal(path
, src
, len
, dst
, 0);
830 int renormalize_buffer(const char *path
, const char *src
, size_t len
, struct strbuf
*dst
)
832 int ret
= convert_to_working_tree_internal(path
, src
, len
, dst
, 1);
837 return ret
| convert_to_git(path
, src
, len
, dst
, SAFE_CRLF_FALSE
);
840 /*****************************************************************
842 * Streaming converison support
844 *****************************************************************/
846 typedef int (*filter_fn
)(struct stream_filter
*,
847 const char *input
, size_t *isize_p
,
848 char *output
, size_t *osize_p
);
849 typedef void (*free_fn
)(struct stream_filter
*);
851 struct stream_filter_vtbl
{
856 struct stream_filter
{
857 struct stream_filter_vtbl
*vtbl
;
860 static int null_filter_fn(struct stream_filter
*filter
,
861 const char *input
, size_t *isize_p
,
862 char *output
, size_t *osize_p
)
867 return 0; /* we do not keep any states */
869 if (*osize_p
< count
)
872 memmove(output
, input
, count
);
879 static void null_free_fn(struct stream_filter
*filter
)
881 ; /* nothing -- null instances are shared */
884 static struct stream_filter_vtbl null_vtbl
= {
889 static struct stream_filter null_filter_singleton
= {
893 int is_null_stream_filter(struct stream_filter
*filter
)
895 return filter
== &null_filter_singleton
;
903 struct lf_to_crlf_filter
{
904 struct stream_filter filter
;
909 static int lf_to_crlf_filter_fn(struct stream_filter
*filter
,
910 const char *input
, size_t *isize_p
,
911 char *output
, size_t *osize_p
)
914 struct lf_to_crlf_filter
*lf_to_crlf
= (struct lf_to_crlf_filter
*)filter
;
917 * We may be holding onto the CR to see if it is followed by a
918 * LF, in which case we would need to go to the main loop.
919 * Otherwise, just emit it to the output stream.
921 if (lf_to_crlf
->has_held
&& (lf_to_crlf
->held
!= '\r' || !input
)) {
922 output
[o
++] = lf_to_crlf
->held
;
923 lf_to_crlf
->has_held
= 0;
926 /* We are told to drain */
933 if (count
|| lf_to_crlf
->has_held
) {
937 if (lf_to_crlf
->has_held
) {
939 lf_to_crlf
->has_held
= 0;
942 for (i
= 0; o
< *osize_p
&& i
< count
; i
++) {
949 * Previous round saw CR and it is not followed
950 * by a LF; emit the CR before processing the
957 * We may have consumed the last output slot,
958 * in which case we need to break out of this
959 * loop; hold the current character before
963 lf_to_crlf
->has_held
= 1;
964 lf_to_crlf
->held
= ch
;
965 continue; /* break but increment i */
980 if (!lf_to_crlf
->has_held
&& was_cr
) {
981 lf_to_crlf
->has_held
= 1;
982 lf_to_crlf
->held
= '\r';
988 static void lf_to_crlf_free_fn(struct stream_filter
*filter
)
993 static struct stream_filter_vtbl lf_to_crlf_vtbl
= {
994 lf_to_crlf_filter_fn
,
998 static struct stream_filter
*lf_to_crlf_filter(void)
1000 struct lf_to_crlf_filter
*lf_to_crlf
= xcalloc(1, sizeof(*lf_to_crlf
));
1002 lf_to_crlf
->filter
.vtbl
= &lf_to_crlf_vtbl
;
1003 return (struct stream_filter
*)lf_to_crlf
;
1009 #define FILTER_BUFFER 1024
1010 struct cascade_filter
{
1011 struct stream_filter filter
;
1012 struct stream_filter
*one
;
1013 struct stream_filter
*two
;
1014 char buf
[FILTER_BUFFER
];
1018 static int cascade_filter_fn(struct stream_filter
*filter
,
1019 const char *input
, size_t *isize_p
,
1020 char *output
, size_t *osize_p
)
1022 struct cascade_filter
*cas
= (struct cascade_filter
*) filter
;
1024 size_t sz
= *osize_p
;
1025 size_t to_feed
, remaining
;
1028 * input -- (one) --> buf -- (two) --> output
1030 while (filled
< sz
) {
1031 remaining
= sz
- filled
;
1033 /* do we already have something to feed two with? */
1034 if (cas
->ptr
< cas
->end
) {
1035 to_feed
= cas
->end
- cas
->ptr
;
1036 if (stream_filter(cas
->two
,
1037 cas
->buf
+ cas
->ptr
, &to_feed
,
1038 output
+ filled
, &remaining
))
1040 cas
->ptr
+= (cas
->end
- cas
->ptr
) - to_feed
;
1041 filled
= sz
- remaining
;
1045 /* feed one from upstream and have it emit into our buffer */
1046 to_feed
= input
? *isize_p
: 0;
1047 if (input
&& !to_feed
)
1049 remaining
= sizeof(cas
->buf
);
1050 if (stream_filter(cas
->one
,
1052 cas
->buf
, &remaining
))
1054 cas
->end
= sizeof(cas
->buf
) - remaining
;
1057 size_t fed
= *isize_p
- to_feed
;
1062 /* do we know that we drained one completely? */
1063 if (input
|| cas
->end
)
1066 /* tell two to drain; we have nothing more to give it */
1068 remaining
= sz
- filled
;
1069 if (stream_filter(cas
->two
,
1071 output
+ filled
, &remaining
))
1073 if (remaining
== (sz
- filled
))
1074 break; /* completely drained two */
1075 filled
= sz
- remaining
;
1081 static void cascade_free_fn(struct stream_filter
*filter
)
1083 struct cascade_filter
*cas
= (struct cascade_filter
*)filter
;
1084 free_stream_filter(cas
->one
);
1085 free_stream_filter(cas
->two
);
1089 static struct stream_filter_vtbl cascade_vtbl
= {
1094 static struct stream_filter
*cascade_filter(struct stream_filter
*one
,
1095 struct stream_filter
*two
)
1097 struct cascade_filter
*cascade
;
1099 if (!one
|| is_null_stream_filter(one
))
1101 if (!two
|| is_null_stream_filter(two
))
1104 cascade
= xmalloc(sizeof(*cascade
));
1107 cascade
->end
= cascade
->ptr
= 0;
1108 cascade
->filter
.vtbl
= &cascade_vtbl
;
1109 return (struct stream_filter
*)cascade
;
1115 #define IDENT_DRAINING (-1)
1116 #define IDENT_SKIPPING (-2)
1117 struct ident_filter
{
1118 struct stream_filter filter
;
1121 char ident
[45]; /* ": x40 $" */
1124 static int is_foreign_ident(const char *str
)
1128 if (prefixcmp(str
, "$Id: "))
1130 for (i
= 5; str
[i
]; i
++) {
1131 if (isspace(str
[i
]) && str
[i
+1] != '$')
1137 static void ident_drain(struct ident_filter
*ident
, char **output_p
, size_t *osize_p
)
1139 size_t to_drain
= ident
->left
.len
;
1141 if (*osize_p
< to_drain
)
1142 to_drain
= *osize_p
;
1144 memcpy(*output_p
, ident
->left
.buf
, to_drain
);
1145 strbuf_remove(&ident
->left
, 0, to_drain
);
1146 *output_p
+= to_drain
;
1147 *osize_p
-= to_drain
;
1149 if (!ident
->left
.len
)
1153 static int ident_filter_fn(struct stream_filter
*filter
,
1154 const char *input
, size_t *isize_p
,
1155 char *output
, size_t *osize_p
)
1157 struct ident_filter
*ident
= (struct ident_filter
*)filter
;
1158 static const char head
[] = "$Id";
1161 /* drain upon eof */
1162 switch (ident
->state
) {
1164 strbuf_add(&ident
->left
, head
, ident
->state
);
1165 case IDENT_SKIPPING
:
1167 case IDENT_DRAINING
:
1168 ident_drain(ident
, &output
, osize_p
);
1173 while (*isize_p
|| (ident
->state
== IDENT_DRAINING
)) {
1176 if (ident
->state
== IDENT_DRAINING
) {
1177 ident_drain(ident
, &output
, osize_p
);
1186 if (ident
->state
== IDENT_SKIPPING
) {
1188 * Skipping until '$' or LF, but keeping them
1189 * in case it is a foreign ident.
1191 strbuf_addch(&ident
->left
, ch
);
1192 if (ch
!= '\n' && ch
!= '$')
1194 if (ch
== '$' && !is_foreign_ident(ident
->left
.buf
)) {
1195 strbuf_setlen(&ident
->left
, sizeof(head
) - 1);
1196 strbuf_addstr(&ident
->left
, ident
->ident
);
1198 ident
->state
= IDENT_DRAINING
;
1202 if (ident
->state
< sizeof(head
) &&
1203 head
[ident
->state
] == ch
) {
1209 strbuf_add(&ident
->left
, head
, ident
->state
);
1210 if (ident
->state
== sizeof(head
) - 1) {
1211 if (ch
!= ':' && ch
!= '$') {
1212 strbuf_addch(&ident
->left
, ch
);
1218 strbuf_addch(&ident
->left
, ch
);
1219 ident
->state
= IDENT_SKIPPING
;
1221 strbuf_addstr(&ident
->left
, ident
->ident
);
1222 ident
->state
= IDENT_DRAINING
;
1227 strbuf_addch(&ident
->left
, ch
);
1228 ident
->state
= IDENT_DRAINING
;
1233 static void ident_free_fn(struct stream_filter
*filter
)
1235 struct ident_filter
*ident
= (struct ident_filter
*)filter
;
1236 strbuf_release(&ident
->left
);
1240 static struct stream_filter_vtbl ident_vtbl
= {
1245 static struct stream_filter
*ident_filter(const unsigned char *sha1
)
1247 struct ident_filter
*ident
= xmalloc(sizeof(*ident
));
1249 sprintf(ident
->ident
, ": %s $", sha1_to_hex(sha1
));
1250 strbuf_init(&ident
->left
, 0);
1251 ident
->filter
.vtbl
= &ident_vtbl
;
1253 return (struct stream_filter
*)ident
;
1257 * Return an appropriately constructed filter for the path, or NULL if
1258 * the contents cannot be filtered without reading the whole thing
1261 * Note that you would be crazy to set CRLF, smuge/clean or ident to a
1262 * large binary blob you would want us not to slurp into the memory!
1264 struct stream_filter
*get_stream_filter(const char *path
, const unsigned char *sha1
)
1266 struct conv_attrs ca
;
1267 enum crlf_action crlf_action
;
1268 struct stream_filter
*filter
= NULL
;
1270 convert_attrs(&ca
, path
);
1272 if (ca
.drv
&& (ca
.drv
->smudge
|| ca
.drv
->clean
))
1276 filter
= ident_filter(sha1
);
1278 crlf_action
= input_crlf_action(ca
.crlf_action
, ca
.eol_attr
);
1280 if ((crlf_action
== CRLF_BINARY
) || (crlf_action
== CRLF_INPUT
) ||
1281 (crlf_action
== CRLF_GUESS
&& auto_crlf
== AUTO_CRLF_FALSE
))
1282 filter
= cascade_filter(filter
, &null_filter_singleton
);
1284 else if (output_eol(crlf_action
) == EOL_CRLF
&&
1285 !(crlf_action
== CRLF_AUTO
|| crlf_action
== CRLF_GUESS
))
1286 filter
= cascade_filter(filter
, lf_to_crlf_filter());
1291 void free_stream_filter(struct stream_filter
*filter
)
1293 filter
->vtbl
->free(filter
);
1296 int stream_filter(struct stream_filter
*filter
,
1297 const char *input
, size_t *isize_p
,
1298 char *output
, size_t *osize_p
)
1300 return filter
->vtbl
->filter(filter
, input
, isize_p
, output
, osize_p
);