convert: add filter.<driver>.process option

diff --git a/ref-filter.c b/ref-filter.c
index d13d002270f3b0a04c2e7b5669dc87dba9132b79..9adbb8af3eaa138ccf161a91ce5b00e366fae7fa 100644 (file)
--- a/ref-filter.c
+++ b/ref-filter.c
@@ -74,14 +74,14 @@ static void remote_ref_atom_parser(struct used_atom *atom, const char *arg)
 static void body_atom_parser(struct used_atom *atom, const char *arg)
 {
        if (arg)
-               die("%%(body) does not take arguments");
+               die(_("%%(body) does not take arguments"));
        atom->u.contents.option = C_BODY_DEP;
 }
 
 static void subject_atom_parser(struct used_atom *atom, const char *arg)
 {
        if (arg)
-               die("%%(subject) does not take arguments");
+               die(_("%%(subject) does not take arguments"));
        atom->u.contents.option = C_SUB;
 }
 
@@ -241,7 +241,7 @@ int parse_ref_filter_atom(const char *atom, const char *ep)
        if (*sp == '*' && sp < ep)
                sp++; /* deref */
        if (ep <= sp)
-               die("malformed field name: %.*s", (int)(ep-atom), atom);
+               die(_("malformed field name: %.*s"), (int)(ep-atom), atom);
 
        /* Do we have the atom already used elsewhere? */
        for (i = 0; i < used_atom_cnt; i++) {
@@ -267,7 +267,7 @@ int parse_ref_filter_atom(const char *atom, const char *ep)
        }
 
        if (ARRAY_SIZE(valid_atom) <= i)
-               die("unknown field name: %.*s", (int)(ep-atom), atom);
+               die(_("unknown field name: %.*s"), (int)(ep-atom), atom);
 
        /* Add it in, including the deref prefix */
        at = used_atom_cnt;
@@ -421,7 +421,7 @@ int verify_ref_format(const char *format)
                int at;
 
                if (!ep)
-                       return error("malformed format string %s", sp);
+                       return error(_("malformed format string %s"), sp);
                /* sp points at "%(" and ep points at the closing ")" */
                at = parse_ref_filter_atom(sp + 2, ep);
                cp = ep + 1;
@@ -875,12 +875,12 @@ static const char *strip_ref_components(const char *refname, const char *nr_arg)
        const char *start = refname;
 
        if (nr < 1 || *end != '\0')
-               die(":strip= requires a positive integer argument");
+               die(_(":strip= requires a positive integer argument"));
 
        while (remaining) {
                switch (*start++) {
                case '\0':
-                       die("ref '%s' does not have %ld components to :strip",
+                       die(_("ref '%s' does not have %ld components to :strip"),
                            refname, nr);
                case '/':
                        remaining--;
@@ -1043,7 +1043,7 @@ static void populate_value(struct ref_array_item *ref)
                        else if (skip_prefix(formatp, "strip=", &arg))
                                refname = strip_ref_components(refname, arg);
                        else
-                               die("unknown %.*s format %s",
+                               die(_("unknown %.*s format %s"),
                                    (int)(formatp - name), name, formatp);
                }
 
@@ -1063,10 +1063,10 @@ static void populate_value(struct ref_array_item *ref)
  need_obj:
        buf = get_obj(ref->objectname, &obj, &size, &eaten);
        if (!buf)
-               die("missing object %s for %s",
+               die(_("missing object %s for %s"),
                    sha1_to_hex(ref->objectname), ref->refname);
        if (!obj)
-               die("parse_object_buffer failed on %s for %s",
+               die(_("parse_object_buffer failed on %s for %s"),
                    sha1_to_hex(ref->objectname), ref->refname);
 
        grab_values(ref->value, 0, obj, buf, size);
@@ -1094,10 +1094,10 @@ static void populate_value(struct ref_array_item *ref)
         */
        buf = get_obj(tagged, &obj, &size, &eaten);
        if (!buf)
-               die("missing object %s for %s",
+               die(_("missing object %s for %s"),
                    sha1_to_hex(tagged), ref->refname);
        if (!obj)
-               die("parse_object_buffer failed on %s for %s",
+               die(_("parse_object_buffer failed on %s for %s"),
                    sha1_to_hex(tagged), ref->refname);
        grab_values(ref->value, 1, obj, buf, size);
        if (!eaten)
@@ -1321,10 +1321,8 @@ static struct ref_array_item *new_ref_array_item(const char *refname,
                                                 const unsigned char *objectname,
                                                 int flag)
 {
-       size_t len = strlen(refname);
-       struct ref_array_item *ref = xcalloc(1, sizeof(struct ref_array_item) + len + 1);
-       memcpy(ref->refname, refname, len);
-       ref->refname[len] = '\0';
+       struct ref_array_item *ref;
+       FLEX_ALLOC_STR(ref, refname, refname);
        hashcpy(ref->objectname, objectname);
        ref->flag = flag;
 
@@ -1372,12 +1370,12 @@ static int ref_filter_handler(const char *refname, const struct object_id *oid,
        unsigned int kind;
 
        if (flag & REF_BAD_NAME) {
-               warning("ignoring ref with broken name %s", refname);
+               warning(_("ignoring ref with broken name %s"), refname);
                return 0;
        }
 
        if (flag & REF_ISBROKEN) {
-               warning("ignoring broken ref %s", refname);
+               warning(_("ignoring broken ref %s"), refname);
                return 0;
        }
 
@@ -1578,24 +1576,6 @@ void ref_array_sort(struct ref_sorting *sorting, struct ref_array *array)
        qsort(array->items, array->nr, sizeof(struct ref_array_item *), compare_refs);
 }
 
-static int hex1(char ch)
-{
-       if ('0' <= ch && ch <= '9')
-               return ch - '0';
-       else if ('a' <= ch && ch <= 'f')
-               return ch - 'a' + 10;
-       else if ('A' <= ch && ch <= 'F')
-               return ch - 'A' + 10;
-       return -1;
-}
-static int hex2(const char *cp)
-{
-       if (cp[0] && cp[1])
-               return (hex1(cp[0]) << 4) | hex1(cp[1]);
-       else
-               return -1;
-}
-
 static void append_literal(const char *cp, const char *ep, struct ref_formatting_state *state)
 {
        struct strbuf *s = &state->stack->output;
@@ -1605,7 +1585,7 @@ static void append_literal(const char *cp, const char *ep, struct ref_formatting
                        if (cp[1] == '%')
                                cp++;
                        else {
-                               int ch = hex2(cp + 1);
+                               int ch = hex2chr(cp + 1);
                                if (0 <= ch) {
                                        strbuf_addch(s, ch);
                                        cp += 3;