create ref-filter from for-each-ref

---
 builtin/for-each-ref.c | 63 ++++++++++++++++++++++++++++++++------------------
 1 file changed, 40 insertions(+), 23 deletions(-)

builtin/for-each-ref.c +40 ~~-23~~

index 83f9cf9..48da5a4 100644
@@ -837,6 +837,43 @@ struct grab_ref_cbdata {
 };
 
 /*
+ * Given a refname, return 1 if the refname matches with one of the patterns
+ * while the pattern is a pathname like 'refs/tags' or 'refs/heads/master'
+ * and so on, else return 0. Supports use of wild characters.
+ */
+static int match_name_as_path(const char **pattern, const char *refname)
+{
+	int namelen = strlen(refname);
+	for (; *pattern; pattern++) {
+		const char *p = *pattern;
+		int plen = strlen(p);
+
+		if ((plen <= namelen) &&
+		    !strncmp(refname, p, plen) &&
+		    (refname[plen] == '\0' ||
+		     refname[plen] == '/' ||
+		     p[plen-1] == '/'))
+			return 1;
+		if (!wildmatch(p, refname, WM_PATHNAME, NULL))
+			return 1;
+	}
+	return 0;
+}
+
+/* Allocate space for a new refinfo and copy the objectname and flag to it */
+static struct refinfo *new_refinfo(const char *refname,
+				   const unsigned char *objectname,
+				   int flag)
+{
+	struct refinfo *ref = xcalloc(1, sizeof(struct refinfo));
+	ref->refname = xstrdup(refname);
+	hashcpy(ref->objectname, objectname);
+	ref->flag = flag;
+
+	return ref;
+}
+
+/*
  * A call-back given to for_each_ref().  Filter refs and keep them for
  * later object processing.
  */

@@ -851,35 +888,15 @@ static int grab_single_ref(const char *refname, const unsigned char *sha1, int f
 		  return 0;
 	}
 
-	if (*cb->grab_pattern) {
-		const char **pattern;
-		int namelen = strlen(refname);
-		for (pattern = cb->grab_pattern; *pattern; pattern++) {
-			const char *p = *pattern;
-			int plen = strlen(p);
-
-			if ((plen <= namelen) &&
-			    !strncmp(refname, p, plen) &&
-			    (refname[plen] == '\0' ||
-			     refname[plen] == '/' ||
-			     p[plen-1] == '/'))
-				break;
-			if (!wildmatch(p, refname, WM_PATHNAME, NULL))
-				break;
-		}
-		if (!*pattern)
-			return 0;
-	}
+	if (*cb->grab_pattern && !match_name_as_path(cb->grab_pattern, refname))
+		return 0;
 
 	/*
 	 * We do not open the object yet; sort may only need refname
 	 * to do its job and the resulting list may yet to be pruned
 	 * by maxcount logic.
 	 */
-	ref = xcalloc(1, sizeof(*ref));
-	ref->refname = xstrdup(refname);
-	hashcpy(ref->objectname, sha1);
-	ref->flag = flag;
+	ref = new_refinfo(refname, sha1, flag);
 
 	cnt = cb->grab_cnt;
 	REALLOC_ARRAY(cb->grab_array, cnt + 1);

Signature · 1 line

2.4.2

Karthik Nayak

author

2016-06-15 23:05 UTC #2 lore raw

PATCH v5 2/10 for-each-ref: clean up code

In 'grab_single_ref()' remove the extra count variable 'cnt' and use the variable 'grab_cnt' of structure 'grab_ref_cbdata' directly instead.

Change comment in 'struct ref_sort' to reflect changes in code.

---
 builtin/for-each-ref.c | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

builtin/for-each-ref.c +3 -6

index 48da5a4..0ca9836 100644
@@ -27,7 +27,7 @@ struct atom_value {
 
 struct ref_sort {
 	struct ref_sort *next;
-	int atom; /* index into used_atom array */
+	int atom; /* index into 'struct atom_value *' array */
 	unsigned reverse : 1;
 };

@@ -881,7 +881,6 @@ static int grab_single_ref(const char *refname, const unsigned char *sha1, int f
 {
 	struct grab_ref_cbdata *cb = cb_data;
 	struct refinfo *ref;
-	int cnt;
 
 	if (flag & REF_BAD_NAME) {
 		  warning("ignoring ref with broken name %s", refname);

@@ -898,10 +897,8 @@ static int grab_single_ref(const char *refname, const unsigned char *sha1, int f
 	 */
 	ref = new_refinfo(refname, sha1, flag);
 
-	cnt = cb->grab_cnt;
-	REALLOC_ARRAY(cb->grab_array, cnt + 1);
-	cb->grab_array[cnt++] = ref;
-	cb->grab_cnt = cnt;
+	REALLOC_ARRAY(cb->grab_array, cb->grab_cnt + 1);
+	cb->grab_array[cb->grab_cnt++] = ref;
 	return 0;
 }

Signature · 1 line

2.4.2

Matthieu Moy

2016-06-15 23:05 UTC #3 lore raw

Re: [WIP/PATCH v5 02/10] for-each-ref: clean up code

Quoted 5 lines · Karthik Nayak

In 'grab_single_ref()' remove the extra count variable 'cnt' and use the variable 'grab_cnt' of structure 'grab_ref_cbdata' directly instead.
Change comment in 'struct ref_sort' to reflect changes in code.

I don't see how the comment change is related to the code change:

Quoted 17 lines

struct ref_sort {

builtin/for-each-ref.c +1 -2

 	struct ref_sort *next;
-	int atom; /* index into used_atom array */
+	int atom; /* index into 'struct atom_value *' array */
 	unsigned reverse : 1;
 };

@@ -881,7 +881,6 @@ static int grab_single_ref(const char *refname, const unsigned char *sha1, int f
 {
 	struct grab_ref_cbdata *cb = cb_data;
 	struct refinfo *ref;
-	int cnt;
 
 	if (flag & REF_BAD_NAME) {
 		  warning("ignoring ref with broken name %s", refname);

@@ -898,10 +897,8 @@ static int grab_single_ref(const char *refname, const unsigned char *sha1, int f
 	 */

builtin/for-each-ref.c static int grab_single_ref(const char *refname, const unsigned char *sha1, int f · line 903

Quoted 10 lines

builtin/for-each-ref.c +2 -4

 	ref = new_refinfo(refname, sha1, flag);
 
-	cnt = cb->grab_cnt;
-	REALLOC_ARRAY(cb->grab_array, cnt + 1);
-	cb->grab_array[cnt++] = ref;
-	cb->grab_cnt = cnt;
+	REALLOC_ARRAY(cb->grab_array, cb->grab_cnt + 1);
+	cb->grab_array[cb->grab_cnt++] = ref;
 	return 0;
 }

Did you squash the comment change into the wrong commit?

Signature · 2 lines

Matthieu Moy
http://www-verimag.imag.fr/~moy/

Karthik Nayak

author

2016-06-15 23:05 UTC #4 lore raw

Re: [WIP/PATCH v5 02/10] for-each-ref: clean up code

Quoted 29 lines · Matthieu Moy

Quoted 5 lines · Karthik Nayak
In 'grab_single_ref()' remove the extra count variable 'cnt' and use the variable 'grab_cnt' of structure 'grab_ref_cbdata' directly instead.
Change comment in 'struct ref_sort' to reflect changes in code.
I don't see how the comment change is related to the code change:
Quoted 19 lines
  struct ref_sort {
  	struct ref_sort *next;
builtin/for-each-ref.c +1 -2
-	int atom; /* index into used_atom array */
+	int atom; /* index into 'struct atom_value *' array */
  	unsigned reverse : 1;
  };
@@ -881,7 +881,6 @@ static int grab_single_ref(const char *refname, const unsigned char *sha1, int f
  {
  	struct grab_ref_cbdata *cb = cb_data;
  	struct refinfo *ref;
-	int cnt;
 
  	if (flag & REF_BAD_NAME) {
  		  warning("ignoring ref with broken name %s", refname);
@@ -898,10 +897,8 @@ static int grab_single_ref(const char *refname, const unsigned char *sha1, int f
  	 */
  	ref = new_refinfo(refname, sha1, flag);
 

Quoted 11 lines

builtin/for-each-ref.c static int grab_single_ref(const char *refname, const unsigned char *sha1, int f · line 903
Quoted 8 lines
builtin/for-each-ref.c +2 -4
-	cnt = cb->grab_cnt;
-	REALLOC_ARRAY(cb->grab_array, cnt + 1);
-	cb->grab_array[cnt++] = ref;
-	cb->grab_cnt = cnt;
+	REALLOC_ARRAY(cb->grab_array, cb->grab_cnt + 1);
+	cb->grab_array[cb->grab_cnt++] = ref;
  	return 0;
  }
Did you squash the comment change into the wrong commit?

What I meant was, change the comment to reflect changes in code since the comment was made, not relevant to the simplification of code.

I put these two together as they are trivial changes. Either I could reword the commit message or split the commit.

Signature · 2 lines

Regards,
Karthik

Matthieu Moy

2016-06-15 23:05 UTC #5 lore raw

Re: [WIP/PATCH v5 02/10] for-each-ref: clean up code

Quoted 2 lines · Karthik Nayak

I put these two together as they are trivial changes. Either I could reword the commit message or split the commit.

I'd split the commit. Actually, even though it's only a small comment change, it's not so "trivial" in the sense that one needs a good understanding of the code to check the correctness of your patch.

Signature · 2 lines

Matthieu Moy
http://www-verimag.imag.fr/~moy/

Karthik Nayak

author

2016-06-15 23:05 UTC #6 lore raw

PATCH v5 3/10 for-each-ref: rename 'refinfo' to 'ref_array_item'

Rename 'refinfo' to 'ref_array_item' as a preparatory step for introduction of new structures in the forthcoming patch.

Re-order the fields in 'ref_array_item' so that refname can be eventually converted to a FLEX_ARRAY.

Make 'symref' a non const char pointer, so that the compiler doesn't throw an error when we try to free the memory allocated to it.

---
 builtin/for-each-ref.c | 42 +++++++++++++++++++++---------------------
 1 file changed, 21 insertions(+), 21 deletions(-)

builtin/for-each-ref.c +21 ~~-21~~

index 0ca9836..b8d17b6 100644
@@ -31,12 +31,12 @@ struct ref_sort {
 	unsigned reverse : 1;
 };
 
-struct refinfo {
-	char *refname;
+struct ref_array_item {
 	unsigned char objectname[20];
 	int flag;
-	const char *symref;
+	char *symref;
 	struct atom_value *value;
+	char *refname;
 };
 
 static struct {

@@ -85,7 +85,7 @@ static struct {
  * a "*" to denote deref_tag().
  *
  * We parse given format string and sort specifiers, and make a list
- * of properties that we need to extract out of objects.  refinfo
+ * of properties that we need to extract out of objects.  ref_array_item
  * structure will hold an array of values extracted that can be
  * indexed with the "atom number", which is an index into this
  * array.

@@ -622,7 +622,7 @@ static inline char *copy_advance(char *dst, const char *src)
 /*
  * Parse the object referred by ref, and grab needed value.
  */
-static void populate_value(struct refinfo *ref)
+static void populate_value(struct ref_array_item *ref)
 {
 	void *buf;
 	struct object *obj;

@@ -821,7 +821,7 @@ static void populate_value(struct refinfo *ref)
  * Given a ref, return the value for the atom.  This lazily gets value
  * out of the object by calling populate value.
  */
-static void get_value(struct refinfo *ref, int atom, struct atom_value **v)
+static void get_value(struct ref_array_item *ref, int atom, struct atom_value **v)
 {
 	if (!ref->value) {
 		populate_value(ref);

@@ -831,7 +831,7 @@ static void get_value(struct refinfo *ref, int atom, struct atom_value **v)
 }
 
 struct grab_ref_cbdata {
-	struct refinfo **grab_array;
+	struct ref_array_item **grab_array;
 	const char **grab_pattern;
 	int grab_cnt;
 };

@@ -860,12 +860,12 @@ static int match_name_as_path(const char **pattern, const char *refname)
 	return 0;
 }
 
-/* Allocate space for a new refinfo and copy the objectname and flag to it */
-static struct refinfo *new_refinfo(const char *refname,
-				   const unsigned char *objectname,
-				   int flag)
+/* Allocate space for a new ref_array_item and copy the objectname and flag to it */
+static struct ref_array_item *new_ref_array_item(const char *refname,
+						 const unsigned char *objectname,
+						 int flag)
 {
-	struct refinfo *ref = xcalloc(1, sizeof(struct refinfo));
+	struct ref_array_item *ref = xcalloc(1, sizeof(struct ref_array_item));
 	ref->refname = xstrdup(refname);
 	hashcpy(ref->objectname, objectname);
 	ref->flag = flag;

@@ -880,7 +880,7 @@ static struct refinfo *new_refinfo(const char *refname,
 static int grab_single_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
 {
 	struct grab_ref_cbdata *cb = cb_data;
-	struct refinfo *ref;
+	struct ref_array_item *ref;
 
 	if (flag & REF_BAD_NAME) {
 		  warning("ignoring ref with broken name %s", refname);

@@ -895,14 +895,14 @@ static int grab_single_ref(const char *refname, const unsigned char *sha1, int f
 	 * to do its job and the resulting list may yet to be pruned
 	 * by maxcount logic.
 	 */
-	ref = new_refinfo(refname, sha1, flag);
+	ref = new_ref_array_item(refname, sha1, flag);
 
 	REALLOC_ARRAY(cb->grab_array, cb->grab_cnt + 1);
 	cb->grab_array[cb->grab_cnt++] = ref;
 	return 0;
 }
 
-static int cmp_ref_sort(struct ref_sort *s, struct refinfo *a, struct refinfo *b)
+static int cmp_ref_sort(struct ref_sort *s, struct ref_array_item *a, struct ref_array_item *b)
 {
 	struct atom_value *va, *vb;
 	int cmp;

@@ -929,8 +929,8 @@ static int cmp_ref_sort(struct ref_sort *s, struct refinfo *a, struct refinfo *b
 static struct ref_sort *ref_sort;
 static int compare_refs(const void *a_, const void *b_)
 {
-	struct refinfo *a = *((struct refinfo **)a_);
-	struct refinfo *b = *((struct refinfo **)b_);
+	struct ref_array_item *a = *((struct ref_array_item **)a_);
+	struct ref_array_item *b = *((struct ref_array_item **)b_);
 	struct ref_sort *s;
 
 	for (s = ref_sort; s; s = s->next) {

@@ -941,10 +941,10 @@ static int compare_refs(const void *a_, const void *b_)
 	return 0;
 }
 
-static void sort_refs(struct ref_sort *sort, struct refinfo **refs, int num_refs)
+static void sort_refs(struct ref_sort *sort, struct ref_array_item **refs, int num_refs)
 {
 	ref_sort = sort;
-	qsort(refs, num_refs, sizeof(struct refinfo *), compare_refs);
+	qsort(refs, num_refs, sizeof(struct ref_array_item *), compare_refs);
 }
 
 static void print_value(struct atom_value *v, int quote_style)

@@ -1011,7 +1011,7 @@ static void emit(const char *cp, const char *ep)
 	}
 }
 
-static void show_ref(struct refinfo *info, const char *format, int quote_style)
+static void show_ref(struct ref_array_item *info, const char *format, int quote_style)
 {
 	const char *cp, *sp, *ep;

@@ -1084,7 +1084,7 @@ int cmd_for_each_ref(int argc, const char **argv, const char *prefix)
 	const char *format = "%(objectname) %(objecttype)\t%(refname)";
 	struct ref_sort *sort = NULL, **sort_tail = &sort;
 	int maxcount = 0, quote_style = 0;
-	struct refinfo **refs;
+	struct ref_array_item **refs;
 	struct grab_ref_cbdata cbdata;
 
 	struct option opts[] = {

Signature · 1 line

2.4.2

Matthieu Moy

2016-06-15 23:05 UTC #7 lore raw

Re: [WIP/PATCH v5 03/10] for-each-ref: rename 'refinfo' to 'ref_array_item'

Quoted 2 lines · Karthik Nayak

Make 'symref' a non const char pointer, so that the compiler doesn't throw an error when we try to free the memory allocated to it.

Casting to non-cost when calling free() is a common pattern. I think it would make more sense to cast at free() time and keep the member const.

Signature · 2 lines

Matthieu Moy
http://www-verimag.imag.fr/~moy/

Karthik Nayak

author

2016-06-15 23:05 UTC #8 lore raw

Re: [WIP/PATCH v5 03/10] for-each-ref: rename 'refinfo' to 'ref_array_item'

Quoted 8 lines · Matthieu Moy

Quoted 2 lines · Karthik Nayak
Make 'symref' a non const char pointer, so that the compiler doesn't throw an error when we try to free the memory allocated to it.
Casting to non-cost when calling free() is a common pattern. I think it would make more sense to cast at free() time and keep the member const.

Ok! will do that. thanks :)

Signature · 2 lines

Regards,
Karthik

Karthik Nayak

author

2016-06-15 23:05 UTC #9 lore raw

PATCH v5 4/10 for-each-ref: introduce new structures for better organisation

Introduce 'ref_filter_cbdata' which will hold 'ref_filter' (conditions to filter the refs on) and 'ref_array' (the array of ref_array_items). Modify the code to use these new structures.

This is a preparatory patch to eventually move code from 'for-each-ref' to 'ref-filter' and make it publicly available.

---
 builtin/for-each-ref.c | 54 ++++++++++++++++++++++++++++----------------------
 1 file changed, 30 insertions(+), 24 deletions(-)

builtin/for-each-ref.c +30 ~~-24~~

index b8d17b6..169ccc8 100644
@@ -39,6 +39,20 @@ struct ref_array_item {
 	char *refname;
 };
 
+struct ref_array {
+	int nr, alloc;
+	struct ref_array_item **items;
+};
+
+struct ref_filter {
+	const char **name_patterns;
+};
+
+struct ref_filter_cbdata {
+	struct ref_array array;
+	struct ref_filter filter;
+};
+
 static struct {
 	const char *name;
 	cmp_type cmp_type;

@@ -830,12 +844,6 @@ static void get_value(struct ref_array_item *ref, int atom, struct atom_value **
 	*v = &ref->value[atom];
 }
 
-struct grab_ref_cbdata {
-	struct ref_array_item **grab_array;
-	const char **grab_pattern;
-	int grab_cnt;
-};
-
 /*
  * Given a refname, return 1 if the refname matches with one of the patterns
  * while the pattern is a pathname like 'refs/tags' or 'refs/heads/master'

@@ -879,7 +887,8 @@ static struct ref_array_item *new_ref_array_item(const char *refname,
  */
 static int grab_single_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
 {
-	struct grab_ref_cbdata *cb = cb_data;
+	struct ref_filter_cbdata *ref_cbdata = cb_data;
+	struct ref_filter *filter = &ref_cbdata->filter;
 	struct ref_array_item *ref;
 
 	if (flag & REF_BAD_NAME) {

@@ -887,7 +896,7 @@ static int grab_single_ref(const char *refname, const unsigned char *sha1, int f
 		  return 0;
 	}
 
-	if (*cb->grab_pattern && !match_name_as_path(cb->grab_pattern, refname))
+	if (*filter->name_patterns && !match_name_as_path(filter->name_patterns, refname))
 		return 0;
 
 	/*

@@ -897,8 +906,8 @@ static int grab_single_ref(const char *refname, const unsigned char *sha1, int f
 	 */
 	ref = new_ref_array_item(refname, sha1, flag);
 
-	REALLOC_ARRAY(cb->grab_array, cb->grab_cnt + 1);
-	cb->grab_array[cb->grab_cnt++] = ref;
+	REALLOC_ARRAY(ref_cbdata->array.items, ref_cbdata->array.nr + 1);
+	ref_cbdata->array.items[ref_cbdata->array.nr++] = ref;
 	return 0;
 }

@@ -941,10 +950,10 @@ static int compare_refs(const void *a_, const void *b_)
 	return 0;
 }
 
-static void sort_refs(struct ref_sort *sort, struct ref_array_item **refs, int num_refs)
+static void sort_refs(struct ref_sort *sort, struct ref_array *array)
 {
 	ref_sort = sort;
-	qsort(refs, num_refs, sizeof(struct ref_array_item *), compare_refs);
+	qsort(array->items, array->nr, sizeof(struct ref_array_item *), compare_refs);
 }
 
 static void print_value(struct atom_value *v, int quote_style)

@@ -1080,12 +1089,11 @@ static char const * const for_each_ref_usage[] = {
 
 int cmd_for_each_ref(int argc, const char **argv, const char *prefix)
 {
-	int i, num_refs;
+	int i;
 	const char *format = "%(objectname) %(objecttype)\t%(refname)";
 	struct ref_sort *sort = NULL, **sort_tail = &sort;
 	int maxcount = 0, quote_style = 0;
-	struct ref_array_item **refs;
-	struct grab_ref_cbdata cbdata;
+	struct ref_filter_cbdata ref_cbdata;
 
 	struct option opts[] = {
 		OPT_BIT('s', "shell", &quote_style,

@@ -1123,17 +1131,15 @@ int cmd_for_each_ref(int argc, const char **argv, const char *prefix)
 	/* for warn_ambiguous_refs */
 	git_config(git_default_config, NULL);
 
-	memset(&cbdata, 0, sizeof(cbdata));
-	cbdata.grab_pattern = argv;
-	for_each_rawref(grab_single_ref, &cbdata);
-	refs = cbdata.grab_array;
-	num_refs = cbdata.grab_cnt;
+	memset(&ref_cbdata, 0, sizeof(ref_cbdata));
+	ref_cbdata.filter.name_patterns = argv;
+	for_each_rawref(grab_single_ref, &ref_cbdata);
 
-	sort_refs(sort, refs, num_refs);
+	sort_refs(sort, &ref_cbdata.array);
 
-	if (!maxcount || num_refs < maxcount)
-		maxcount = num_refs;
+	if (!maxcount || ref_cbdata.array.nr < maxcount)
+		maxcount = ref_cbdata.array.nr;
 	for (i = 0; i < maxcount; i++)
-		show_ref(refs[i], format, quote_style);
+		show_ref(ref_cbdata.array.items[i], format, quote_style);
 	return 0;
 }

Signature · 1 line

2.4.2

Karthik Nayak

author

2016-06-15 23:05 UTC #10 lore raw

PATCH v5 5/10 for-each-ref: introduce 'ref_array_clear()'

Introduce and implement 'ref_array_clear()' which will free all allocated memory for 'ref_array'.

---
 builtin/for-each-ref.c | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

builtin/for-each-ref.c +21 -0

index 169ccc8..54f03c9 100644
@@ -911,6 +911,26 @@ static int grab_single_ref(const char *refname, const unsigned char *sha1, int f
 	return 0;
 }
 
+/*  Free memory allocated for a ref_array_item */
+static void free_array_item(struct ref_array_item *item)
+{
+	free(item->symref);
+	free(item->refname);
+	free(item);
+}
+
+/* Free all memory allocated for ref_array */
+void ref_array_clear(struct ref_array *array)
+{
+	int i;
+
+	for (i = 0; i < array->nr; i++)
+		free_array_item(array->items[i]);
+	free(array->items);
+	array->items = NULL;
+	array->nr = array->alloc = 0;
+}
+
 static int cmp_ref_sort(struct ref_sort *s, struct ref_array_item *a, struct ref_array_item *b)
 {
 	struct atom_value *va, *vb;

@@ -1141,5 +1161,6 @@ int cmd_for_each_ref(int argc, const char **argv, const char *prefix)
 		maxcount = ref_cbdata.array.nr;
 	for (i = 0; i < maxcount; i++)
 		show_ref(ref_cbdata.array.items[i], format, quote_style);
+	ref_array_clear(&ref_cbdata.array);
 	return 0;
 }

Signature · 1 line

2.4.2

Matthieu Moy

2016-06-15 23:05 UTC #11 lore raw

Re: [WIP/PATCH v5 05/10] for-each-ref: introduce 'ref_array_clear()'

builtin/for-each-ref.c static int grab_single_ref(const char *refname, const unsigned char *sha1, int f · line 923

Quoted 2 lines · Karthik Nayak

builtin/for-each-ref.c +2 -0

+/* Free all memory allocated for ref_array */
+void ref_array_clear(struct ref_array *array)

Is this a private function? If so, then add static. If not, you probably want to export it in a .h file.

Signature · 2 lines

Matthieu Moy
http://www-verimag.imag.fr/~moy/

Karthik Nayak

author

2016-06-15 23:05 UTC #12 lore raw

Re: [WIP/PATCH v5 05/10] for-each-ref: introduce 'ref_array_clear()'

Quoted 8 lines · Matthieu Moy

builtin/for-each-ref.c static int grab_single_ref(const char *refname, const unsigned char *sha1, int f · line 923
Quoted 2 lines · Karthik Nayak
builtin/for-each-ref.c +2 -0
+/* Free all memory allocated for ref_array */
+void ref_array_clear(struct ref_array *array)
Is this a private function? If so, then add static. If not, you probably want to export it in a .h file.

It is in ref-filter.h.

Signature · 2 lines

Regards,
Karthik

Karthik Nayak

author

2016-06-15 23:05 UTC #13 lore raw

Re: [WIP/PATCH v5 05/10] for-each-ref: introduce 'ref_array_clear()'

In reply to Matthieu Moy

Quoted 8 lines · Matthieu Moy

builtin/for-each-ref.c static int grab_single_ref(const char *refname, const unsigned char *sha1, int f · line 923
Quoted 2 lines · Karthik Nayak
builtin/for-each-ref.c +2 -0
+/* Free all memory allocated for ref_array */
+void ref_array_clear(struct ref_array *array)
Is this a private function? If so, then add static. If not, you probably want to export it in a .h file.

It is in ref-filter.h.

Signature · 2 lines

Regards,
Karthik

Matthieu Moy

2016-06-15 23:05 UTC #14 lore raw

Re: [WIP/PATCH v5 05/10] for-each-ref: introduce 'ref_array_clear()'

Quoted 10 lines · Karthik Nayak

Quoted 8 lines · Matthieu Moy
builtin/for-each-ref.c static int grab_single_ref(const char *refname, const unsigned char *sha1, int f · line 923
Quoted 2 lines · Karthik Nayak
builtin/for-each-ref.c +2 -0
+/* Free all memory allocated for ref_array */
+void ref_array_clear(struct ref_array *array)
Is this a private function? If so, then add static. If not, you probably want to export it in a .h file.
It is in ref-filter.h.

Ah, OK. It comes later in the series.

Signature · 2 lines

Matthieu Moy
http://www-verimag.imag.fr/~moy/

Junio C Hamano

2016-06-15 23:05 UTC #15 lore raw

Re: [WIP/PATCH v5 05/10] for-each-ref: introduce 'ref_array_clear()'

Quoted 11 lines · Matthieu Moy

Quoted 9 lines · Karthik Nayak
Quoted 8 lines · Matthieu Moy
builtin/for-each-ref.c static int grab_single_ref(const char *refname, const unsigned char *sha1, int f · line 923
Quoted 2 lines · Karthik Nayak
builtin/for-each-ref.c +2 -0
+/* Free all memory allocated for ref_array */
+void ref_array_clear(struct ref_array *array)
Is this a private function? If so, then add static. If not, you probably want to export it in a .h file.

Quoted 3 lines

Quoted 1 line
It is in ref-filter.h.
Ah, OK. It comes later in the series.

Confused I am; if it comes later not in the same patch then it is not OK, is it?

Matthieu Moy

2016-06-15 23:05 UTC #16 lore raw

Re: [WIP/PATCH v5 05/10] for-each-ref: introduce 'ref_array_clear()'

Quoted 13 lines · Junio C Hamano

Quoted 11 lines · Matthieu Moy
Quoted 9 lines · Karthik Nayak
Quoted 8 lines · Matthieu Moy
builtin/for-each-ref.c static int grab_single_ref(const char *refname, const unsigned char *sha1, int f · line 923
Quoted 2 lines · Karthik Nayak
builtin/for-each-ref.c +2 -0
+/* Free all memory allocated for ref_array */
+void ref_array_clear(struct ref_array *array)
Is this a private function? If so, then add static. If not, you probably want to export it in a .h file.

Quoted 6 lines

Quoted 3 lines
Quoted 1 line
It is in ref-filter.h.
Ah, OK. It comes later in the series.
Confused I am; if it comes later not in the same patch then it is not OK, is it?

We could introduce ref-filter.h earlier, indeed. To me, the current solution is good enough, but introducing ref-filter.h early and adding function definition there in the same commit as you drop the "static" keyword for them would clearly be an improvement.

Signature · 2 lines

Matthieu Moy
http://www-verimag.imag.fr/~moy/

Karthik Nayak

author

2016-06-15 23:05 UTC #17 lore raw

Re: [WIP/PATCH v5 05/10] for-each-ref: introduce 'ref_array_clear()'

Quoted 19 lines · Matthieu Moy

Quoted 17 lines · Junio C Hamano
Quoted 14 lines · Matthieu Moy
Quoted 10 lines · Karthik Nayak
Quoted 8 lines · Matthieu Moy
builtin/for-each-ref.c static int grab_single_ref(const char *refname, const unsigned char *sha1, int f · line 923
Quoted 2 lines · Karthik Nayak
builtin/for-each-ref.c +2 -0
+/* Free all memory allocated for ref_array */
+void ref_array_clear(struct ref_array *array)
Is this a private function? If so, then add static. If not, you probably want to export it in a .h file.
It is in ref-filter.h.
Ah, OK. It comes later in the series.

Quoted 8 lines

Quoted 2 lines
Confused I am; if it comes later not in the same patch then it is not OK, is it?
We could introduce ref-filter.h earlier, indeed. To me, the current solution is good enough, but introducing ref-filter.h early and adding function definition there in the same commit as you drop the "static" keyword for them would clearly be an improvement.

But that would break the flow, wouldn't it? I wanted ref-filter to be introduced together, hence right after ref-filter.h we move code to ref-filter.c

Signature · 2 lines

Regards,
Karthik

Matthieu Moy

2016-06-15 23:05 UTC #18 lore raw

Re: [WIP/PATCH v5 05/10] for-each-ref: introduce 'ref_array_clear()'

Quoted 10 lines · Karthik Nayak

Quoted 4 lines · Matthieu Moy
We could introduce ref-filter.h earlier, indeed. To me, the current solution is good enough, but introducing ref-filter.h early and adding function definition there in the same commit as you drop the "static" keyword for them would clearly be an improvement.
But that would break the flow, wouldn't it? I wanted ref-filter to be introduced together, hence right after ref-filter.h we move code to ref-filter.c

That's why I find the current solution good enough: it also has advantages. But in the current series, when you say "make functions public", you are not actually doing so since they're not exported in a .h file.

Conversely, PATCH 07 does two things: move code from for-each-ref.c and introduce new declarations. Had you introduced these declarations earlier, this patch would have been pure code movement.

In both cases, you have intermediate states that are not fully
consistant: either you have public functions in the builtin/ directory (which sometimes happen in Git's codebase, but we try to avoid it), or you have non-static functions that are not declared in a .h.

Signature · 2 lines

Matthieu Moy
http://www-verimag.imag.fr/~moy/

Karthik Nayak

author

2016-06-15 23:05 UTC #19 lore raw

PATCH v5 6/10 for-each-ref: rename some functions and make them public

Rename some of the functions and make them publicly available. This is a preparatory step for moving code from 'for-each-ref' to 'ref-filter' to make meaningful, targeted services available to other commands via public APIs.

Functions renamed are:
parse_atom() -> parse_ref_filter_atom()
verify_format() -> verify_ref_format()
get_value() -> get_ref_atom_value()
grab_single_ref() -> ref_filter_handler()
sort_ref() -> ref_array_sort()
show_ref() -> show_ref_array_item()
default_sort() -> ref_default_sorting()
opt_parse_sort() -> parse_opt_ref_sorting()
cmp_ref_sort() -> cmp_ref_sorting()

Rename 'struct ref_sort' to 'struct ref_sorting' in this context.

Based-on-patch-by Jeff King <[email protected]>

---
 builtin/for-each-ref.c | 67 +++++++++++++++++++++++++-------------------------
 1 file changed, 34 insertions(+), 33 deletions(-)

builtin/for-each-ref.c +34 ~~-33~~

index 54f03c9..f6403be 100644
@@ -25,8 +25,8 @@ struct atom_value {
 	unsigned long ul; /* used for sorting when not FIELD_STR */
 };
 
-struct ref_sort {
-	struct ref_sort *next;
+struct ref_sorting {
+	struct ref_sorting *next;
 	int atom; /* index into 'struct atom_value *' array */
 	unsigned reverse : 1;
 };

@@ -112,7 +112,7 @@ static int need_color_reset_at_eol;
 /*
  * Used to parse format string and sort specifiers
  */
-static int parse_atom(const char *atom, const char *ep)
+int parse_ref_filter_atom(const char *atom, const char *ep)
 {
 	const char *sp;
 	int i, at;

@@ -189,7 +189,7 @@ static const char *find_next(const char *cp)
  * Make sure the format string is well formed, and parse out
  * the used atoms.
  */
-static int verify_format(const char *format)
+int verify_ref_format(const char *format)
 {
 	const char *cp, *sp;

@@ -201,7 +201,7 @@ static int verify_format(const char *format)
 		if (!ep)
 			return error("malformed format string %s", sp);
 		/* sp points at "%(" and ep points at the closing ")" */
-		at = parse_atom(sp + 2, ep);
+		at = parse_ref_filter_atom(sp + 2, ep);
 		cp = ep + 1;
 
 		if (skip_prefix(used_atom[at], "color:", &color))

@@ -408,7 +408,7 @@ static void grab_date(const char *buf, struct atom_value *v, const char *atomnam
 	/*
 	 * We got here because atomname ends in "date" or "date<something>";
 	 * it's not possible that <something> is not ":<format>" because
-	 * parse_atom() wouldn't have allowed it, so we can assume that no
+	 * parse_ref_filter_atom() wouldn't have allowed it, so we can assume that no
 	 * ":" means no format is specified, and use the default.
 	 */
 	formatp = strchr(atomname, ':');

@@ -835,7 +835,7 @@ static void populate_value(struct ref_array_item *ref)
  * Given a ref, return the value for the atom.  This lazily gets value
  * out of the object by calling populate value.
  */
-static void get_value(struct ref_array_item *ref, int atom, struct atom_value **v)
+static void get_ref_atom_value(struct ref_array_item *ref, int atom, struct atom_value **v)
 {
 	if (!ref->value) {
 		populate_value(ref);

@@ -885,7 +885,7 @@ static struct ref_array_item *new_ref_array_item(const char *refname,
  * A call-back given to for_each_ref().  Filter refs and keep them for
  * later object processing.
  */
-static int grab_single_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
+int ref_filter_handler(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
 {
 	struct ref_filter_cbdata *ref_cbdata = cb_data;
 	struct ref_filter *filter = &ref_cbdata->filter;

@@ -931,14 +931,14 @@ void ref_array_clear(struct ref_array *array)
 	array->nr = array->alloc = 0;
 }
 
-static int cmp_ref_sort(struct ref_sort *s, struct ref_array_item *a, struct ref_array_item *b)
+static int cmp_ref_sorting(struct ref_sorting *s, struct ref_array_item *a, struct ref_array_item *b)
 {
 	struct atom_value *va, *vb;
 	int cmp;
 	cmp_type cmp_type = used_atom_type[s->atom];
 
-	get_value(a, s->atom, &va);
-	get_value(b, s->atom, &vb);
+	get_ref_atom_value(a, s->atom, &va);
+	get_ref_atom_value(b, s->atom, &vb);
 	switch (cmp_type) {
 	case FIELD_STR:
 		cmp = strcmp(va->s, vb->s);

@@ -955,24 +955,24 @@ static int cmp_ref_sort(struct ref_sort *s, struct ref_array_item *a, struct ref
 	return (s->reverse) ? -cmp : cmp;
 }
 
-static struct ref_sort *ref_sort;
+static struct ref_sorting *ref_sorting;
 static int compare_refs(const void *a_, const void *b_)
 {
 	struct ref_array_item *a = *((struct ref_array_item **)a_);
 	struct ref_array_item *b = *((struct ref_array_item **)b_);
-	struct ref_sort *s;
+	struct ref_sorting *s;
 
-	for (s = ref_sort; s; s = s->next) {
-		int cmp = cmp_ref_sort(s, a, b);
+	for (s = ref_sorting; s; s = s->next) {
+		int cmp = cmp_ref_sorting(s, a, b);
 		if (cmp)
 			return cmp;
 	}
 	return 0;
 }
 
-static void sort_refs(struct ref_sort *sort, struct ref_array *array)
+void ref_array_sort(struct ref_sorting *sort, struct ref_array *array)
 {
-	ref_sort = sort;
+	ref_sorting = sort;
 	qsort(array->items, array->nr, sizeof(struct ref_array_item *), compare_refs);
 }

@@ -1040,7 +1040,7 @@ static void emit(const char *cp, const char *ep)
 	}
 }
 
-static void show_ref(struct ref_array_item *info, const char *format, int quote_style)
+void show_ref_array_item(struct ref_array_item *info, const char *format, int quote_style)
 {
 	const char *cp, *sp, *ep;

@@ -1050,7 +1050,7 @@ static void show_ref(struct ref_array_item *info, const char *format, int quote_
 		ep = strchr(sp, ')');
 		if (cp < sp)
 			emit(cp, sp);
-		get_value(info, parse_atom(sp + 2, ep), &atomv);
+		get_ref_atom_value(info, parse_ref_filter_atom(sp + 2, ep), &atomv);
 		print_value(atomv, quote_style);
 	}
 	if (*cp) {

@@ -1069,21 +1069,22 @@ static void show_ref(struct ref_array_item *info, const char *format, int quote_
 	putchar('\n');
 }
 
-static struct ref_sort *default_sort(void)
+/*  If no sorting option is given, use refname to sort as default */
+struct ref_sorting *ref_default_sorting(void)
 {
 	static const char cstr_name[] = "refname";
 
-	struct ref_sort *sort = xcalloc(1, sizeof(*sort));
+	struct ref_sorting *sort = xcalloc(1, sizeof(*sort));
 
 	sort->next = NULL;
-	sort->atom = parse_atom(cstr_name, cstr_name + strlen(cstr_name));
+	sort->atom = parse_ref_filter_atom(cstr_name, cstr_name + strlen(cstr_name));
 	return sort;
 }
 
-static int opt_parse_sort(const struct option *opt, const char *arg, int unset)
+int parse_opt_ref_sorting(const struct option *opt, const char *arg, int unset)
 {
-	struct ref_sort **sort_tail = opt->value;
-	struct ref_sort *s;
+	struct ref_sorting **sort_tail = opt->value;
+	struct ref_sorting *s;
 	int len;
 
 	if (!arg) /* should --no-sort void the list ? */

@@ -1098,7 +1099,7 @@ static int opt_parse_sort(const struct option *opt, const char *arg, int unset)
 		arg++;
 	}
 	len = strlen(arg);
-	s->atom = parse_atom(arg, arg+len);
+	s->atom = parse_ref_filter_atom(arg, arg+len);
 	return 0;
 }

@@ -1111,7 +1112,7 @@ int cmd_for_each_ref(int argc, const char **argv, const char *prefix)
 {
 	int i;
 	const char *format = "%(objectname) %(objecttype)\t%(refname)";
-	struct ref_sort *sort = NULL, **sort_tail = &sort;
+	struct ref_sorting *sort = NULL, **sort_tail = &sort;
 	int maxcount = 0, quote_style = 0;
 	struct ref_filter_cbdata ref_cbdata;

@@ -1129,7 +1130,7 @@ int cmd_for_each_ref(int argc, const char **argv, const char *prefix)
 		OPT_INTEGER( 0 , "count", &maxcount, N_("show only <n> matched refs")),
 		OPT_STRING(  0 , "format", &format, N_("format"), N_("format to use for the output")),
 		OPT_CALLBACK(0 , "sort", sort_tail, N_("key"),
-			    N_("field name to sort on"), &opt_parse_sort),
+			    N_("field name to sort on"), &parse_opt_ref_sorting),
 		OPT_END(),
 	};

@@ -1142,25 +1143,25 @@ int cmd_for_each_ref(int argc, const char **argv, const char *prefix)
 		error("more than one quoting style?");
 		usage_with_options(for_each_ref_usage, opts);
 	}
-	if (verify_format(format))
+	if (verify_ref_format(format))
 		usage_with_options(for_each_ref_usage, opts);
 
 	if (!sort)
-		sort = default_sort();
+		sort = ref_default_sorting();
 
 	/* for warn_ambiguous_refs */
 	git_config(git_default_config, NULL);
 
 	memset(&ref_cbdata, 0, sizeof(ref_cbdata));
 	ref_cbdata.filter.name_patterns = argv;
-	for_each_rawref(grab_single_ref, &ref_cbdata);
+	for_each_rawref(ref_filter_handler, &ref_cbdata);
 
-	sort_refs(sort, &ref_cbdata.array);
+	ref_array_sort(sort, &ref_cbdata.array);
 
 	if (!maxcount || ref_cbdata.array.nr < maxcount)
 		maxcount = ref_cbdata.array.nr;
 	for (i = 0; i < maxcount; i++)
-		show_ref(ref_cbdata.array.items[i], format, quote_style);
+		show_ref_array_item(ref_cbdata.array.items[i], format, quote_style);
 	ref_array_clear(&ref_cbdata.array);
 	return 0;
 }

Signature · 1 line

2.4.2

Karthik Nayak

author

2016-06-15 23:05 UTC #20 lore raw

PATCH v5 7/10 ref-filter: add 'ref-filter.h'

This is step one of creating a common library for 'for-each-ref', 'branch -l' and 'tag -l'. This creates a header file with the functions and data structures that ref-filter will provide. We move the data structures created in for-each-ref to this header file.

---
 builtin/for-each-ref.c | 41 +------------------------------
 ref-filter.h           | 66 ++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 67 insertions(+), 40 deletions(-)
 create mode 100644 ref-filter.h

builtin/for-each-ref.c +1 ~~-40~~

index f6403be..39f7c9a 100644
@@ -10,49 +10,10 @@
 #include "parse-options.h"
 #include "remote.h"
 #include "color.h"
-
-/* Quoting styles */
-#define QUOTE_NONE 0
-#define QUOTE_SHELL 1
-#define QUOTE_PERL 2
-#define QUOTE_PYTHON 4
-#define QUOTE_TCL 8
+#include "ref-filter.h"
 
 typedef enum { FIELD_STR, FIELD_ULONG, FIELD_TIME } cmp_type;
 
-struct atom_value {
-	const char *s;
-	unsigned long ul; /* used for sorting when not FIELD_STR */
-};
-
-struct ref_sorting {
-	struct ref_sorting *next;
-	int atom; /* index into 'struct atom_value *' array */
-	unsigned reverse : 1;
-};
-
-struct ref_array_item {
-	unsigned char objectname[20];
-	int flag;
-	char *symref;
-	struct atom_value *value;
-	char *refname;
-};
-
-struct ref_array {
-	int nr, alloc;
-	struct ref_array_item **items;
-};
-
-struct ref_filter {
-	const char **name_patterns;
-};
-
-struct ref_filter_cbdata {
-	struct ref_array array;
-	struct ref_filter filter;
-};
-
 static struct {
 	const char *name;
 	cmp_type cmp_type;

ref-filter.h new file +66 -0

66 lines not on this page · raw message

Signature · 1 line

2.4.2

Karthik Nayak

author

2016-06-15 23:05 UTC #21 lore raw

PATCH v5 8/10 ref-filter: move code from 'for-each-ref'

Move most of the code from 'for-each-ref' to 'ref-filter' to make it publicly available to other commands, this is to unify the code of 'tag -l', 'branch -l' and 'for-each-ref' so that they can share their implementations with each other.

Add 'ref-filter' to the Makefile, this completes the movement of code from 'for-each-ref' to 'ref-filter'.

---
 Makefile               |    1 +
 builtin/for-each-ref.c | 1059 -----------------------------------------------
 ref-filter.c           | 1062 ++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 1063 insertions(+), 1059 deletions(-)
 create mode 100644 ref-filter.c

Makefile +1 -0

index 54ec511..d715b66 100644
@@ -762,6 +762,7 @@ LIB_OBJS += reachable.o
 LIB_OBJS += read-cache.o
 LIB_OBJS += reflog-walk.o
 LIB_OBJS += refs.o
+LIB_OBJS += ref-filter.o
 LIB_OBJS += remote.o
 LIB_OBJS += replace_object.o
 LIB_OBJS += rerere.o

builtin/for-each-ref.c +0 ~~-1059~~

1,068 lines not on this page · raw message

ref-filter.c new file +1062 -0

1,062 lines not on this page · raw message

Signature · 1 line

2.4.2

Karthik Nayak

author

2016-06-15 23:05 UTC #22 lore raw

PATCH v5 9/10 for-each-ref: introduce filter_refs()

Introduce filter_refs() which will act as an API for users to call and provide a function which will iterate over a set of refs while filtering out the required refs.

Currently this will wrap around ref_filter_handler(). Hence, ref_filter_handler is made file scope static.

Helped-by Junio C Hamano <[email protected]>

---
 builtin/for-each-ref.c |  2 +-
 ref-filter.c           | 12 +++++++++++-
 ref-filter.h           |  8 ++++++--
 3 files changed, 18 insertions(+), 4 deletions(-)

builtin/for-each-ref.c +1 -1

index e237194..2a16947 100644
@@ -56,7 +56,7 @@ int cmd_for_each_ref(int argc, const char **argv, const char *prefix)
 
 	memset(&ref_cbdata, 0, sizeof(ref_cbdata));
 	ref_cbdata.filter.name_patterns = argv;
-	for_each_rawref(ref_filter_handler, &ref_cbdata);
+	filter_refs(for_each_rawref, &ref_cbdata);
 
 	ref_array_sort(sort, &ref_cbdata.array);

ref-filter.c +11 -1

index 95e72f6..c32b86f 100644
@@ -843,7 +843,7 @@ static struct ref_array_item *new_ref_array_item(const char *refname,
  * A call-back given to for_each_ref().  Filter refs and keep them for
  * later object processing.
  */
-int ref_filter_handler(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
+static int ref_filter_handler(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
 {
 	struct ref_filter_cbdata *ref_cbdata = cb_data;
 	struct ref_filter *filter = &ref_cbdata->filter;

@@ -889,6 +889,16 @@ void ref_array_clear(struct ref_array *array)
 	array->nr = array->alloc = 0;
 }
 
+/*
+ * API for filtering a set of refs. The refs are provided and iterated
+ * over using the for_each_ref_fn(). The refs are stored into and filtered
+ * based on the ref_filter_cbdata structure.
+ */
+int filter_refs(int (for_each_ref_fn)(each_ref_fn, void *), struct ref_filter_cbdata *data)
+{
+	return for_each_ref_fn(ref_filter_handler, data);
+}
+
 static int cmp_ref_sorting(struct ref_sorting *s, struct ref_array_item *a, struct ref_array_item *b)
 {
 	struct atom_value *va, *vb;

ref-filter.h +6 -2

index 1432ff6..15e6766 100644
@@ -46,8 +46,12 @@ struct ref_filter_cbdata {
 	struct ref_filter filter;
 };
 
-/*  Callback function for for_each_*ref(). This filters the refs based on the filters set */
-int ref_filter_handler(const char *refname, const unsigned char *sha1, int flag, void *cb_data);
+/*
+ * API for filtering a set of refs. The refs are provided and iterated
+ * over using the for_each_ref_fn(). The refs are stored into and filtered
+ * based on the ref_filter_cbdata structure.
+ */
+int filter_refs(int (for_each_ref_fn)(each_ref_fn, void *), struct ref_filter_cbdata *data);
 /*  Clear all memory allocated to ref_array */
 void ref_array_clear(struct ref_array *array);
 /*  Parse format string and sort specifiers */

Signature · 1 line

2.4.2

Karthik Nayak

author

2016-06-15 23:05 UTC #23 lore raw

PATCH v5 10/10 ref-filter: make 'ref_array_item' use a FLEX_ARRAY for refname

This would remove the need of using a pointer to store refname.

---
 ref-filter.c | 7 ++++---
 ref-filter.h | 2 +-
 2 files changed, 5 insertions(+), 4 deletions(-)

ref-filter.c +4 -3

index c32b86f..1bd1a28 100644
@@ -831,8 +831,10 @@ static struct ref_array_item *new_ref_array_item(const char *refname,
 						 const unsigned char *objectname,
 						 int flag)
 {
-	struct ref_array_item *ref = xcalloc(1, sizeof(struct ref_array_item));
-	ref->refname = xstrdup(refname);
+	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';
 	hashcpy(ref->objectname, objectname);
 	ref->flag = flag;

@@ -873,7 +875,6 @@ static int ref_filter_handler(const char *refname, const unsigned char *sha1, in
 static void free_array_item(struct ref_array_item *item)
 {
 	free(item->symref);
-	free(item->refname);
 	free(item);
 }

ref-filter.h +1 -1

index 15e6766..041a39a 100644
@@ -29,7 +29,7 @@ struct ref_array_item {
 	int flag;
 	char *symref;
 	struct atom_value *value;
-	char *refname;
+	char refname[FLEX_ARRAY];
 };
 
 struct ref_array {

Signature · 1 line

2.4.2

Karthik Nayak

author

2016-06-15 23:05 UTC #24 lore raw

Quoted 8 lines · Karthik Nayak

Version for of this patch can be found here :
http://www.mail-archive.com/[email protected]/msg70280.html
Changes in this version:
*    Rename functions to better suit the code.
*    implement filter_refs()
*    use FLEX_ARRAY for refname
*    other small changes

I request that this series be ignored, will push again. I hadn't rebased on master (latest), there'll be merge conflicts. Sorry for the inconvenience.

Signature · 2 lines

Regards,
Karthik

Christian Couder

2016-06-15 23:05 UTC #25 lore raw