[thirdparty/git.git] / commit-slab-impl.h

#ifndef COMMIT_SLAB_IMPL_H
#define COMMIT_SLAB_IMPL_H

#include "git-compat-util.h"

#define implement_static_commit_slab(slabname, elemtype) \
	implement_commit_slab(slabname, elemtype, MAYBE_UNUSED static)

#define implement_shared_commit_slab(slabname, elemtype) \
	implement_commit_slab(slabname, elemtype, )

#define implement_commit_slab(slabname, elemtype, scope)		\
									\
scope void init_ ##slabname## _with_stride(struct slabname *s,		\
						   unsigned stride)	\
{									\
	unsigned int elem_size;						\
	if (!stride)							\
		stride = 1;						\
	s->stride = stride;						\
	elem_size = sizeof(elemtype) * stride;				\
	s->slab_size = COMMIT_SLAB_SIZE / elem_size;			\
	s->slab_count = 0;						\
	s->slab = NULL;							\
}									\
									\
scope void init_ ##slabname(struct slabname *s)				\
{									\
	init_ ##slabname## _with_stride(s, 1);				\
}									\
									\
scope void clear_ ##slabname(struct slabname *s)			\
{									\
	unsigned int i;							\
	for (i = 0; i < s->slab_count; i++)				\
		free(s->slab[i]);					\
	s->slab_count = 0;						\
	FREE_AND_NULL(s->slab);						\
}									\
									\
scope elemtype *slabname## _at_peek(struct slabname *s,			\
						  const struct commit *c, \
						  int add_if_missing)   \
{									\
	unsigned int nth_slab, nth_slot;				\
									\
	nth_slab = c->index / s->slab_size;				\
	nth_slot = c->index % s->slab_size;				\
									\
	if (s->slab_count <= nth_slab) {				\
		unsigned int i;						\
		if (!add_if_missing)					\
			return NULL;					\
		REALLOC_ARRAY(s->slab, nth_slab + 1);			\
		for (i = s->slab_count; i <= nth_slab; i++)		\
			s->slab[i] = NULL;				\
		s->slab_count = nth_slab + 1;				\
	}								\
	if (!s->slab[nth_slab]) {					\
		if (!add_if_missing)					\
			return NULL;					\
		s->slab[nth_slab] = xcalloc(s->slab_size,		\
					    sizeof(**s->slab) * s->stride);		\
	}								\
	return &s->slab[nth_slab][nth_slot * s->stride];		\
}									\
									\
scope elemtype *slabname## _at(struct slabname *s,			\
					     const struct commit *c)	\
{									\
	return slabname##_at_peek(s, c, 1);				\
}									\
									\
scope elemtype *slabname## _peek(struct slabname *s,			\
					     const struct commit *c)	\
{									\
	return slabname##_at_peek(s, c, 0);				\
}									\
									\
struct slabname

/*
 * Note that this redundant forward declaration is required
 * to allow a terminating semicolon, which makes instantiations look
 * like function declarations.  I.e., the expansion of
 *
 *    implement_commit_slab(indegree, int, static);
 *
 * ends in 'struct indegree;'.  This would otherwise
 * be a syntax error according (at least) to ISO C.  It's hard to
 * catch because GCC silently parses it by default.
 */

#endif	/* COMMIT_SLAB_IMPL_H */
Commit	Line	Data
a9f1f1f9 NTND	1	#ifndef COMMIT_SLAB_IMPL_H
	2	#define COMMIT_SLAB_IMPL_H
	3
bbd8eb3e	4	#include "git-compat-util.h"
a9f1f1f9	5
878f0bb8	6	#define implement_static_commit_slab(slabname, elemtype) \
bbd8eb3e	7	implement_commit_slab(slabname, elemtype, MAYBE_UNUSED static)
878f0bb8 NTND	8
	9	#define implement_shared_commit_slab(slabname, elemtype) \
	10	implement_commit_slab(slabname, elemtype, )
	11
	12	#define implement_commit_slab(slabname, elemtype, scope) \
a9f1f1f9	13	\
878f0bb8	14	scope void init_ ##slabname## _with_stride(struct slabname *s, \
a9f1f1f9 NTND	15	unsigned stride) \
	16	{ \
	17	unsigned int elem_size; \
	18	if (!stride) \
	19	stride = 1; \
	20	s->stride = stride; \
	21	elem_size = sizeof(elemtype) * stride; \
	22	s->slab_size = COMMIT_SLAB_SIZE / elem_size; \
	23	s->slab_count = 0; \
	24	s->slab = NULL; \
	25	} \
	26	\
878f0bb8	27	scope void init_ ##slabname(struct slabname *s) \
a9f1f1f9 NTND	28	{ \
	29	init_ ##slabname## _with_stride(s, 1); \
	30	} \
	31	\
878f0bb8	32	scope void clear_ ##slabname(struct slabname *s) \
a9f1f1f9 NTND	33	{ \
	34	unsigned int i; \
	35	for (i = 0; i < s->slab_count; i++) \
	36	free(s->slab[i]); \
	37	s->slab_count = 0; \
	38	FREE_AND_NULL(s->slab); \
	39	} \
	40	\
878f0bb8	41	scope elemtype slabname## _at_peek(struct slabname s, \
a9f1f1f9 NTND	42	const struct commit *c, \
	43	int add_if_missing) \
	44	{ \
	45	unsigned int nth_slab, nth_slot; \
	46	\
	47	nth_slab = c->index / s->slab_size; \
	48	nth_slot = c->index % s->slab_size; \
	49	\
	50	if (s->slab_count <= nth_slab) { \
	51	unsigned int i; \
	52	if (!add_if_missing) \
	53	return NULL; \
	54	REALLOC_ARRAY(s->slab, nth_slab + 1); \
a9f1f1f9 NTND	55	for (i = s->slab_count; i <= nth_slab; i++) \
	56	s->slab[i] = NULL; \
	57	s->slab_count = nth_slab + 1; \
	58	} \
	59	if (!s->slab[nth_slab]) { \
	60	if (!add_if_missing) \
	61	return NULL; \
	62	s->slab[nth_slab] = xcalloc(s->slab_size, \
	63	sizeof(*s->slab) s->stride); \
	64	} \
	65	return &s->slab[nth_slab][nth_slot * s->stride]; \
	66	} \
	67	\
878f0bb8	68	scope elemtype slabname## _at(struct slabname s, \
a9f1f1f9 NTND	69	const struct commit *c) \
	70	{ \
	71	return slabname##_at_peek(s, c, 1); \
	72	} \
	73	\
878f0bb8	74	scope elemtype slabname## _peek(struct slabname s, \
a9f1f1f9 NTND	75	const struct commit *c) \
	76	{ \
	77	return slabname##_at_peek(s, c, 0); \
	78	} \
	79	\
	80	struct slabname
	81
	82	/*
	83	* Note that this redundant forward declaration is required
	84	* to allow a terminating semicolon, which makes instantiations look
	85	* like function declarations. I.e., the expansion of
	86	*
878f0bb8	87	* implement_commit_slab(indegree, int, static);
a9f1f1f9 NTND	88	*
	89	* ends in 'struct indegree;'. This would otherwise
	90	* be a syntax error according (at least) to ISO C. It's hard to
	91	* catch because GCC silently parses it by default.
	92	*/
	93
	94	#endif /* COMMIT_SLAB_IMPL_H */