Get rid of goto command in ref-filter for better readability.
Signed-off-by: Olga Telezhnaia <olyatelezhn...@gmail.com>
Mentored-by: Christian Couder <christian.cou...@gmail.com>
Mentored by: Jeff King <p...@peff.net>
---
ref-filter.c | 103 ++++++++++++++++++++++++++++++-----------------------------
1 file changed, 53 insertions(+), 50 deletions(-)
diff --git a/ref-filter.c b/ref-filter.c
index 2bd9a8fc4e39c..1b8c8787190a9 100644
--- a/ref-filter.c
+++ b/ref-filter.c
@@ -1405,16 +1405,60 @@ static const char *get_refname(struct used_atom *atom,
struct ref_array_item *re
return show_ref(&atom->u.refname, ref->refname);
}
+static void need_object(struct ref_array_item *ref) {
+ struct object *obj;
+ const struct object_id *tagged;
+ unsigned long size;
+ int eaten;
+ void *buf = get_obj(&ref->objectname, &obj, &size, &eaten);
+ if (!buf)
+ die(_("missing object %s for %s"),
+ oid_to_hex(&ref->objectname), ref->refname);
+ if (!obj)
+ die(_("parse_object_buffer failed on %s for %s"),
+ oid_to_hex(&ref->objectname), ref->refname);
+
+ grab_values(ref->value, 0, obj, buf, size);
+ if (!eaten)
+ free(buf);
+
+ /*
+ * If there is no atom that wants to know about tagged
+ * object, we are done.
+ */
+ if (!need_tagged || (obj->type != OBJ_TAG))
+ return;
+
+ /*
+ * If it is a tag object, see if we use a value that derefs
+ * the object, and if we do grab the object it refers to.
+ */
+ tagged = &((struct tag *)obj)->tagged->oid;
+
+ /*
+ * NEEDSWORK: This derefs tag only once, which
+ * is good to deal with chains of trust, but
+ * is not consistent with what deref_tag() does
+ * which peels the onion to the core.
+ */
+ buf = get_obj(tagged, &obj, &size, &eaten);
+ if (!buf)
+ die(_("missing object %s for %s"),
+ oid_to_hex(tagged), ref->refname);
+ if (!obj)
+ die(_("parse_object_buffer failed on %s for %s"),
+ oid_to_hex(tagged), ref->refname);
+ grab_values(ref->value, 1, obj, buf, size);
+ if (!eaten)
+ free(buf);
+}
+
/*
* Parse the object referred by ref, and grab needed value.
*/
static void populate_value(struct ref_array_item *ref)
{
- void *buf;
- struct object *obj;
- int eaten, i;
- unsigned long size;
- const struct object_id *tagged;
+ int i;
ref->value = xcalloc(used_atom_cnt, sizeof(struct atom_value));
@@ -1528,53 +1572,12 @@ static void populate_value(struct ref_array_item *ref)
for (i = 0; i < used_atom_cnt; i++) {
struct atom_value *v = &ref->value[i];
- if (v->s == NULL)
- goto need_obj;
+ if (v->s == NULL) {
+ need_object(ref);
+ break;
+ }
}
return;
-
- need_obj:
- buf = get_obj(&ref->objectname, &obj, &size, &eaten);
- if (!buf)
- die(_("missing object %s for %s"),
- oid_to_hex(&ref->objectname), ref->refname);
- if (!obj)
- die(_("parse_object_buffer failed on %s for %s"),
- oid_to_hex(&ref->objectname), ref->refname);
-
- grab_values(ref->value, 0, obj, buf, size);
- if (!eaten)
- free(buf);
-
- /*
- * If there is no atom that wants to know about tagged
- * object, we are done.
- */
- if (!need_tagged || (obj->type != OBJ_TAG))
- return;
-
- /*
- * If it is a tag object, see if we use a value that derefs
- * the object, and if we do grab the object it refers to.
- */
- tagged = &((struct tag *)obj)->tagged->oid;
-
- /*
- * NEEDSWORK: This derefs tag only once, which
- * is good to deal with chains of trust, but
- * is not consistent with what deref_tag() does
- * which peels the onion to the core.
- */
- buf = get_obj(tagged, &obj, &size, &eaten);
- if (!buf)
- die(_("missing object %s for %s"),
- oid_to_hex(tagged), ref->refname);
- if (!obj)
- die(_("parse_object_buffer failed on %s for %s"),
- oid_to_hex(tagged), ref->refname);
- grab_values(ref->value, 1, obj, buf, size);
- if (!eaten)
- free(buf);
}
/*
--
https://github.com/git/git/pull/450
