return text_attr;
}
+struct conv_attrs {
+ struct convert_driver *drv;
+ enum crlf_action crlf_action;
+ enum eol eol_attr;
+ int ident;
+};
+
static const char *conv_attr_name[] = {
"crlf", "ident", "filter", "eol", "text",
};
#define NUM_CONV_ATTRS ARRAY_SIZE(conv_attr_name)
-static void setup_convert_check(struct git_attr_check *check)
+static void convert_attrs(struct conv_attrs *ca, const char *path)
{
int i;
static struct git_attr_check ccheck[NUM_CONV_ATTRS];
user_convert_tail = &user_convert;
git_config(read_convert_config, NULL);
}
- for (i = 0; i < NUM_CONV_ATTRS; i++)
- check[i].attr = ccheck[i].attr;
+
+ if (!git_checkattr(path, NUM_CONV_ATTRS, ccheck)) {
+ ca->crlf_action = git_path_check_crlf(path, ccheck + 4);
+ if (ca->crlf_action == CRLF_GUESS)
+ ca->crlf_action = git_path_check_crlf(path, ccheck + 0);
+ ca->ident = git_path_check_ident(path, ccheck + 1);
+ ca->drv = git_path_check_convert(path, ccheck + 2);
+ ca->eol_attr = git_path_check_eol(path, ccheck + 3);
+ } else {
+ ca->drv = NULL;
+ ca->crlf_action = CRLF_GUESS;
+ ca->eol_attr = EOL_UNSET;
+ ca->ident = 0;
+ }
}
int convert_to_git(const char *path, const char *src, size_t len,
struct strbuf *dst, enum safe_crlf checksafe)
{
- struct git_attr_check check[NUM_CONV_ATTRS];
- enum crlf_action crlf_action = CRLF_GUESS;
- enum eol eol_attr = EOL_UNSET;
- int ident = 0, ret = 0;
+ int ret = 0;
const char *filter = NULL;
+ struct conv_attrs ca;
- setup_convert_check(check);
- if (!git_checkattr(path, ARRAY_SIZE(check), check)) {
- struct convert_driver *drv;
- crlf_action = git_path_check_crlf(path, check + 4);
- if (crlf_action == CRLF_GUESS)
- crlf_action = git_path_check_crlf(path, check + 0);
- ident = git_path_check_ident(path, check + 1);
- drv = git_path_check_convert(path, check + 2);
- eol_attr = git_path_check_eol(path, check + 3);
- if (drv && drv->clean)
- filter = drv->clean;
- }
+ convert_attrs(&ca, path);
+ if (ca.drv)
+ filter = ca.drv->clean;
ret |= apply_filter(path, src, len, dst, filter);
if (ret) {
src = dst->buf;
len = dst->len;
}
- crlf_action = input_crlf_action(crlf_action, eol_attr);
- ret |= crlf_to_git(path, src, len, dst, crlf_action, checksafe);
+ ca.crlf_action = input_crlf_action(ca.crlf_action, ca.eol_attr);
+ ret |= crlf_to_git(path, src, len, dst, ca.crlf_action, checksafe);
if (ret) {
src = dst->buf;
len = dst->len;
}
- return ret | ident_to_git(path, src, len, dst, ident);
+ return ret | ident_to_git(path, src, len, dst, ca.ident);
}
static int convert_to_working_tree_internal(const char *path, const char *src,
size_t len, struct strbuf *dst,
int normalizing)
{
- struct git_attr_check check[NUM_CONV_ATTRS];
- enum crlf_action crlf_action = CRLF_GUESS;
- enum eol eol_attr = EOL_UNSET;
- int ident = 0, ret = 0;
+ int ret = 0;
const char *filter = NULL;
+ struct conv_attrs ca;
- setup_convert_check(check);
- if (!git_checkattr(path, ARRAY_SIZE(check), check)) {
- struct convert_driver *drv;
- crlf_action = git_path_check_crlf(path, check + 4);
- if (crlf_action == CRLF_GUESS)
- crlf_action = git_path_check_crlf(path, check + 0);
- ident = git_path_check_ident(path, check + 1);
- drv = git_path_check_convert(path, check + 2);
- eol_attr = git_path_check_eol(path, check + 3);
- if (drv && drv->smudge)
- filter = drv->smudge;
- }
+ convert_attrs(&ca, path);
+ if (ca.drv)
+ filter = ca.drv->smudge;
- ret |= ident_to_worktree(path, src, len, dst, ident);
+ ret |= ident_to_worktree(path, src, len, dst, ca.ident);
if (ret) {
src = dst->buf;
len = dst->len;
* is a smudge filter. The filter might expect CRLFs.
*/
if (filter || !normalizing) {
- crlf_action = input_crlf_action(crlf_action, eol_attr);
- ret |= crlf_to_worktree(path, src, len, dst, crlf_action);
+ ca.crlf_action = input_crlf_action(ca.crlf_action, ca.eol_attr);
+ ret |= crlf_to_worktree(path, src, len, dst, ca.crlf_action);
if (ret) {
src = dst->buf;
len = dst->len;
}
return ret | convert_to_git(path, src, len, dst, 0);
}
+
+/*****************************************************************
+ *
+ * Streaming converison support
+ *
+ *****************************************************************/
+
+typedef int (*filter_fn)(struct stream_filter *,
+ const char *input, size_t *isize_p,
+ char *output, size_t *osize_p);
+typedef void (*free_fn)(struct stream_filter *);
+
+struct stream_filter_vtbl {
+ filter_fn filter;
+ free_fn free;
+};
+
+struct stream_filter {
+ struct stream_filter_vtbl *vtbl;
+};
+
+static int null_filter_fn(struct stream_filter *filter,
+ const char *input, size_t *isize_p,
+ char *output, size_t *osize_p)
+{
+ size_t count = *isize_p;
+ if (*osize_p < count)
+ count = *osize_p;
+ if (count) {
+ memmove(output, input, count);
+ *isize_p -= count;
+ *osize_p -= count;
+ }
+ return 0;
+}
+
+static void null_free_fn(struct stream_filter *filter)
+{
+ ; /* nothing -- null instances are shared */
+}
+
+static struct stream_filter_vtbl null_vtbl = {
+ null_filter_fn,
+ null_free_fn,
+};
+
+static struct stream_filter null_filter_singleton = {
+ &null_vtbl,
+};
+
+int is_null_stream_filter(struct stream_filter *filter)
+{
+ return filter == &null_filter_singleton;
+}
+
+/*
+ * Return an appropriately constructed filter for the path, or NULL if
+ * the contents cannot be filtered without reading the whole thing
+ * in-core.
+ *
+ * Note that you would be crazy to set CRLF, smuge/clean or ident to a
+ * large binary blob you would want us not to slurp into the memory!
+ */
+struct stream_filter *get_stream_filter(const char *path, const unsigned char *sha1)
+{
+ struct conv_attrs ca;
+ enum crlf_action crlf_action;
+
+ convert_attrs(&ca, path);
+
+ if (ca.ident ||
+ (ca.drv && (ca.drv->smudge || ca.drv->clean)))
+ return NULL;
+
+ crlf_action = input_crlf_action(ca.crlf_action, ca.eol_attr);
+ if ((crlf_action == CRLF_BINARY) || (crlf_action == CRLF_INPUT) ||
+ (crlf_action == CRLF_GUESS && auto_crlf == AUTO_CRLF_FALSE))
+ return &null_filter_singleton;
+
+ return NULL;
+}
+
+void free_stream_filter(struct stream_filter *filter)
+{
+ filter->vtbl->free(filter);
+}
+
+int stream_filter(struct stream_filter *filter,
+ const char *input, size_t *isize_p,
+ char *output, size_t *osize_p)
+{
+ return filter->vtbl->filter(filter, input, isize_p, output, osize_p);
+}