http-push: convert process_ls_object and descendants to object_id
[gitweb.git] / builtin / tag.c
index dbc6f5b74b6c64153bc8e1cc5e24830586cbcfe1..d0070b37c215ca209c31ae1d9e774fe4944f806e 100644 (file)
@@ -66,45 +66,42 @@ static int list_tags(struct ref_filter *filter, struct ref_sorting *sorting, con
 }
 
 typedef int (*each_tag_name_fn)(const char *name, const char *ref,
-                               const unsigned char *sha1, const void *cb_data);
+                               const struct object_id *oid, const void *cb_data);
 
 static int for_each_tag_name(const char **argv, each_tag_name_fn fn,
                             const void *cb_data)
 {
        const char **p;
-       char ref[PATH_MAX];
+       struct strbuf ref = STRBUF_INIT;
        int had_error = 0;
-       unsigned char sha1[20];
+       struct object_id oid;
 
        for (p = argv; *p; p++) {
-               if (snprintf(ref, sizeof(ref), "refs/tags/%s", *p)
-                                       >= sizeof(ref)) {
-                       error(_("tag name too long: %.*s..."), 50, *p);
-                       had_error = 1;
-                       continue;
-               }
-               if (read_ref(ref, sha1)) {
+               strbuf_reset(&ref);
+               strbuf_addf(&ref, "refs/tags/%s", *p);
+               if (read_ref(ref.buf, oid.hash)) {
                        error(_("tag '%s' not found."), *p);
                        had_error = 1;
                        continue;
                }
-               if (fn(*p, ref, sha1, cb_data))
+               if (fn(*p, ref.buf, &oid, cb_data))
                        had_error = 1;
        }
+       strbuf_release(&ref);
        return had_error;
 }
 
 static int delete_tag(const char *name, const char *ref,
-                     const unsigned char *sha1, const void *cb_data)
+                     const struct object_id *oid, const void *cb_data)
 {
-       if (delete_ref(NULL, ref, sha1, 0))
+       if (delete_ref(NULL, ref, oid->hash, 0))
                return 1;
-       printf(_("Deleted tag '%s' (was %s)\n"), name, find_unique_abbrev(sha1, DEFAULT_ABBREV));
+       printf(_("Deleted tag '%s' (was %s)\n"), name, find_unique_abbrev(oid->hash, DEFAULT_ABBREV));
        return 0;
 }
 
 static int verify_tag(const char *name, const char *ref,
-                     const unsigned char *sha1, const void *cb_data)
+                     const struct object_id *oid, const void *cb_data)
 {
        int flags;
        const char *fmt_pretty = cb_data;
@@ -113,11 +110,11 @@ static int verify_tag(const char *name, const char *ref,
        if (fmt_pretty)
                flags = GPG_VERIFY_OMIT_STATUS;
 
-       if (gpg_verify_tag(sha1, name, flags))
+       if (gpg_verify_tag(oid->hash, name, flags))
                return -1;
 
        if (fmt_pretty)
-               pretty_print_ref(name, sha1, fmt_pretty);
+               pretty_print_ref(name, oid->hash, fmt_pretty);
 
        return 0;
 }
@@ -185,13 +182,13 @@ static int git_tag_config(const char *var, const char *value, void *cb)
        return git_default_config(var, value, cb);
 }
 
-static void write_tag_body(int fd, const unsigned char *sha1)
+static void write_tag_body(int fd, const struct object_id *oid)
 {
        unsigned long size;
        enum object_type type;
        char *buf, *sp;
 
-       buf = read_sha1_file(sha1, &type, &size);
+       buf = read_sha1_file(oid->hash, &type, &size);
        if (!buf)
                return;
        /* skip header */
@@ -207,11 +204,11 @@ static void write_tag_body(int fd, const unsigned char *sha1)
        free(buf);
 }
 
-static int build_tag_object(struct strbuf *buf, int sign, unsigned char *result)
+static int build_tag_object(struct strbuf *buf, int sign, struct object_id *result)
 {
        if (sign && do_sign(buf) < 0)
                return error(_("unable to sign the tag"));
-       if (write_sha1_file(buf->buf, buf->len, tag_type, result) < 0)
+       if (write_sha1_file(buf->buf, buf->len, tag_type, result->hash) < 0)
                return error(_("unable to write tag file"));
        return 0;
 }
@@ -226,31 +223,27 @@ struct create_tag_options {
        } cleanup_mode;
 };
 
-static void create_tag(const unsigned char *object, const char *tag,
+static void create_tag(const struct object_id *object, const char *tag,
                       struct strbuf *buf, struct create_tag_options *opt,
-                      unsigned char *prev, unsigned char *result)
+                      struct object_id *prev, struct object_id *result)
 {
        enum object_type type;
-       char header_buf[1024];
-       int header_len;
+       struct strbuf header = STRBUF_INIT;
        char *path = NULL;
 
-       type = sha1_object_info(object, NULL);
+       type = sha1_object_info(object->hash, NULL);
        if (type <= OBJ_NONE)
            die(_("bad object type."));
 
-       header_len = snprintf(header_buf, sizeof(header_buf),
-                         "object %s\n"
-                         "type %s\n"
-                         "tag %s\n"
-                         "tagger %s\n\n",
-                         sha1_to_hex(object),
-                         typename(type),
-                         tag,
-                         git_committer_info(IDENT_STRICT));
-
-       if (header_len > sizeof(header_buf) - 1)
-               die(_("tag header too big."));
+       strbuf_addf(&header,
+                   "object %s\n"
+                   "type %s\n"
+                   "tag %s\n"
+                   "tagger %s\n\n",
+                   oid_to_hex(object),
+                   typename(type),
+                   tag,
+                   git_committer_info(IDENT_STRICT));
 
        if (!opt->message_given) {
                int fd;
@@ -261,7 +254,7 @@ static void create_tag(const unsigned char *object, const char *tag,
                if (fd < 0)
                        die_errno(_("could not create file '%s'"), path);
 
-               if (!is_null_sha1(prev)) {
+               if (!is_null_oid(prev)) {
                        write_tag_body(fd, prev);
                } else {
                        struct strbuf buf = STRBUF_INIT;
@@ -288,7 +281,8 @@ static void create_tag(const unsigned char *object, const char *tag,
        if (!opt->message_given && !buf->len)
                die(_("no tag message?"));
 
-       strbuf_insert(buf, 0, header_buf, header_len);
+       strbuf_insert(buf, 0, header.buf, header.len);
+       strbuf_release(&header);
 
        if (build_tag_object(buf, opt->sign, result) < 0) {
                if (path)
@@ -302,7 +296,7 @@ static void create_tag(const unsigned char *object, const char *tag,
        }
 }
 
-static void create_reflog_msg(const unsigned char *sha1, struct strbuf *sb)
+static void create_reflog_msg(const struct object_id *oid, struct strbuf *sb)
 {
        enum object_type type;
        struct commit *c;
@@ -316,17 +310,17 @@ static void create_reflog_msg(const unsigned char *sha1, struct strbuf *sb)
                strbuf_addstr(sb, rla);
        } else {
                strbuf_addstr(sb, _("tag: tagging "));
-               strbuf_add_unique_abbrev(sb, sha1, DEFAULT_ABBREV);
+               strbuf_add_unique_abbrev(sb, oid->hash, DEFAULT_ABBREV);
        }
 
        strbuf_addstr(sb, " (");
-       type = sha1_object_info(sha1, NULL);
+       type = sha1_object_info(oid->hash, NULL);
        switch (type) {
        default:
                strbuf_addstr(sb, _("object of unknown type"));
                break;
        case OBJ_COMMIT:
-               if ((buf = read_sha1_file(sha1, &type, &size)) != NULL) {
+               if ((buf = read_sha1_file(oid->hash, &type, &size)) != NULL) {
                        subject_len = find_commit_subject(buf, &subject_start);
                        strbuf_insert(sb, sb->len, subject_start, subject_len);
                } else {
@@ -334,7 +328,7 @@ static void create_reflog_msg(const unsigned char *sha1, struct strbuf *sb)
                }
                free(buf);
 
-               if ((c = lookup_commit_reference(sha1)) != NULL)
+               if ((c = lookup_commit_reference(oid)) != NULL)
                        strbuf_addf(sb, ", %s", show_date(c->date, 0, DATE_MODE(SHORT)));
                break;
        case OBJ_TREE:
@@ -384,7 +378,7 @@ int cmd_tag(int argc, const char **argv, const char *prefix)
        struct strbuf buf = STRBUF_INIT;
        struct strbuf ref = STRBUF_INIT;
        struct strbuf reflog_msg = STRBUF_INIT;
-       unsigned char object[20], prev[20];
+       struct object_id object, prev;
        const char *object_ref, *tag;
        struct create_tag_options opt;
        char *cleanup_arg = NULL;
@@ -534,14 +528,14 @@ int cmd_tag(int argc, const char **argv, const char *prefix)
        if (argc > 2)
                die(_("too many params"));
 
-       if (get_sha1(object_ref, object))
+       if (get_oid(object_ref, &object))
                die(_("Failed to resolve '%s' as a valid ref."), object_ref);
 
        if (strbuf_check_tag_ref(&ref, tag))
                die(_("'%s' is not a valid tag name."), tag);
 
-       if (read_ref(ref.buf, prev))
-               hashclr(prev);
+       if (read_ref(ref.buf, prev.hash))
+               oidclr(&prev);
        else if (!force)
                die(_("tag '%s' already exists"), tag);
 
@@ -556,24 +550,24 @@ int cmd_tag(int argc, const char **argv, const char *prefix)
        else
                die(_("Invalid cleanup mode %s"), cleanup_arg);
 
-       create_reflog_msg(object, &reflog_msg);
+       create_reflog_msg(&object, &reflog_msg);
 
        if (create_tag_object) {
                if (force_sign_annotate && !annotate)
                        opt.sign = 1;
-               create_tag(object, tag, &buf, &opt, prev, object);
+               create_tag(&object, tag, &buf, &opt, &prev, &object);
        }
 
        transaction = ref_transaction_begin(&err);
        if (!transaction ||
-           ref_transaction_update(transaction, ref.buf, object, prev,
+           ref_transaction_update(transaction, ref.buf, object.hash, prev.hash,
                                   create_reflog ? REF_FORCE_CREATE_REFLOG : 0,
                                   reflog_msg.buf, &err) ||
            ref_transaction_commit(transaction, &err))
                die("%s", err.buf);
        ref_transaction_free(transaction);
-       if (force && !is_null_sha1(prev) && hashcmp(prev, object))
-               printf(_("Updated tag '%s' (was %s)\n"), tag, find_unique_abbrev(prev, DEFAULT_ABBREV));
+       if (force && !is_null_oid(&prev) && oidcmp(&prev, &object))
+               printf(_("Updated tag '%s' (was %s)\n"), tag, find_unique_abbrev(prev.hash, DEFAULT_ABBREV));
 
        strbuf_release(&err);
        strbuf_release(&buf);