[linux-block.git] / tools / perf / util / intlist.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Based on intlist.c by:
 * (c) 2009 Arnaldo Carvalho de Melo <acme@redhat.com>
 */

#include <errno.h>
#include <stdlib.h>
#include <linux/compiler.h>

#include "intlist.h"

static struct rb_node *intlist__node_new(struct rblist *rblist __maybe_unused,
					 const void *entry)
{
	unsigned long i = (unsigned long)entry;
	struct rb_node *rc = NULL;
	struct int_node *node = malloc(sizeof(*node));

	if (node != NULL) {
		node->i = i;
		node->priv = NULL;
		rc = &node->rb_node;
	}

	return rc;
}

static void int_node__delete(struct int_node *ilist)
{
	free(ilist);
}

static void intlist__node_delete(struct rblist *rblist __maybe_unused,
				 struct rb_node *rb_node)
{
	struct int_node *node = container_of(rb_node, struct int_node, rb_node);

	int_node__delete(node);
}

static int intlist__node_cmp(struct rb_node *rb_node, const void *entry)
{
	unsigned long i = (unsigned long)entry;
	struct int_node *node = container_of(rb_node, struct int_node, rb_node);

	if (node->i > i)
		return 1;
	else if (node->i < i)
		return -1;

	return 0;
}

int intlist__add(struct intlist *ilist, unsigned long i)
{
	return rblist__add_node(&ilist->rblist, (void *)i);
}

void intlist__remove(struct intlist *ilist, struct int_node *node)
{
	rblist__remove_node(&ilist->rblist, &node->rb_node);
}

static struct int_node *__intlist__findnew(struct intlist *ilist,
					   unsigned long i, bool create)
{
	struct int_node *node = NULL;
	struct rb_node *rb_node;

	if (ilist == NULL)
		return NULL;

	if (create)
		rb_node = rblist__findnew(&ilist->rblist, (void *)i);
	else
		rb_node = rblist__find(&ilist->rblist, (void *)i);

	if (rb_node)
		node = container_of(rb_node, struct int_node, rb_node);

	return node;
}

struct int_node *intlist__find(struct intlist *ilist, unsigned long i)
{
	return __intlist__findnew(ilist, i, false);
}

struct int_node *intlist__findnew(struct intlist *ilist, unsigned long i)
{
	return __intlist__findnew(ilist, i, true);
}

static int intlist__parse_list(struct intlist *ilist, const char *s)
{
	char *sep;
	int err;

	do {
		unsigned long value = strtol(s, &sep, 10);
		err = -EINVAL;
		if (*sep != ',' && *sep != '\0')
			break;
		err = intlist__add(ilist, value);
		if (err)
			break;
		s = sep + 1;
	} while (*sep != '\0');

	return err;
}

struct intlist *intlist__new(const char *slist)
{
	struct intlist *ilist = malloc(sizeof(*ilist));

	if (ilist != NULL) {
		rblist__init(&ilist->rblist);
		ilist->rblist.node_cmp    = intlist__node_cmp;
		ilist->rblist.node_new    = intlist__node_new;
		ilist->rblist.node_delete = intlist__node_delete;

		if (slist && intlist__parse_list(ilist, slist))
			goto out_delete;
	}

	return ilist;
out_delete:
	intlist__delete(ilist);
	return NULL;
}

void intlist__delete(struct intlist *ilist)
{
	if (ilist != NULL)
		rblist__delete(&ilist->rblist);
}

struct int_node *intlist__entry(const struct intlist *ilist, unsigned int idx)
{
	struct int_node *node = NULL;
	struct rb_node *rb_node;

	rb_node = rblist__entry(&ilist->rblist, idx);
	if (rb_node)
		node = container_of(rb_node, struct int_node, rb_node);

	return node;
}
Commit	Line	Data
5efdfe75	1	// SPDX-License-Identifier: GPL-2.0-only
70b40c4a DA	2	/*
	3	* Based on intlist.c by:
	4	* (c) 2009 Arnaldo Carvalho de Melo <acme@redhat.com>
70b40c4a DA	5	*/
	6
	7	#include <errno.h>
	8	#include <stdlib.h>
	9	#include <linux/compiler.h>
	10
	11	#include "intlist.h"
	12
1d037ca1	13	static struct rb_node intlist__node_new(struct rblist rblist __maybe_unused,
70b40c4a DA	14	const void *entry)
70b40c4a DA	15	{
94253393	16	unsigned long i = (unsigned long)entry;
70b40c4a DA	17	struct rb_node *rc = NULL;
	18	struct int_node node = malloc(sizeof(node));
	19
	20	if (node != NULL) {
	21	node->i = i;
2969b129	22	node->priv = NULL;
70b40c4a DA	23	rc = &node->rb_node;
	24	}
	25
	26	return rc;
	27	}
	28
	29	static void int_node__delete(struct int_node *ilist)
	30	{
	31	free(ilist);
	32	}
	33
1d037ca1	34	static void intlist__node_delete(struct rblist *rblist __maybe_unused,
70b40c4a DA	35	struct rb_node *rb_node)
	36	{
	37	struct int_node *node = container_of(rb_node, struct int_node, rb_node);
	38
	39	int_node__delete(node);
	40	}
	41
	42	static int intlist__node_cmp(struct rb_node rb_node, const void entry)
	43	{
94253393	44	unsigned long i = (unsigned long)entry;
70b40c4a DA	45	struct int_node *node = container_of(rb_node, struct int_node, rb_node);
70b40c4a DA	46
94253393 JY	47	if (node->i > i)
	48	return 1;
	49	else if (node->i < i)
	50	return -1;
	51
	52	return 0;
70b40c4a DA	53	}
70b40c4a DA	54
94253393	55	int intlist__add(struct intlist *ilist, unsigned long i)
70b40c4a	56	{
94253393	57	return rblist__add_node(&ilist->rblist, (void *)i);
70b40c4a DA	58	}
70b40c4a DA	59
60ebf328	60	void intlist__remove(struct intlist ilist, struct int_node node)
70b40c4a	61	{
60ebf328	62	rblist__remove_node(&ilist->rblist, &node->rb_node);
70b40c4a DA	63	}
70b40c4a DA	64
813335b8	65	static struct int_node __intlist__findnew(struct intlist ilist,
94253393	66	unsigned long i, bool create)
70b40c4a	67	{
813335b8	68	struct int_node *node = NULL;
5a3d04d6 ACM	69	struct rb_node *rb_node;
	70
	71	if (ilist == NULL)
	72	return NULL;
70b40c4a	73
813335b8	74	if (create)
94253393	75	rb_node = rblist__findnew(&ilist->rblist, (void *)i);
813335b8	76	else
94253393	77	rb_node = rblist__find(&ilist->rblist, (void *)i);
813335b8	78
70b40c4a DA	79	if (rb_node)
	80	node = container_of(rb_node, struct int_node, rb_node);
	81
	82	return node;
	83	}
	84
94253393	85	struct int_node intlist__find(struct intlist ilist, unsigned long i)
813335b8 DA	86	{
	87	return __intlist__findnew(ilist, i, false);
	88	}
	89
94253393	90	struct int_node intlist__findnew(struct intlist ilist, unsigned long i)
813335b8 DA	91	{
	92	return __intlist__findnew(ilist, i, true);
	93	}
	94
ffe0fb76 ACM	95	static int intlist__parse_list(struct intlist ilist, const char s)
	96	{
	97	char *sep;
	98	int err;
	99
	100	do {
94253393	101	unsigned long value = strtol(s, &sep, 10);
ffe0fb76 ACM	102	err = -EINVAL;
	103	if (sep != ',' && sep != '\0')
	104	break;
	105	err = intlist__add(ilist, value);
	106	if (err)
	107	break;
	108	s = sep + 1;
	109	} while (*sep != '\0');
	110
	111	return err;
	112	}
	113
	114	struct intlist intlist__new(const char slist)
70b40c4a DA	115	{
	116	struct intlist ilist = malloc(sizeof(ilist));
	117
	118	if (ilist != NULL) {
	119	rblist__init(&ilist->rblist);
	120	ilist->rblist.node_cmp = intlist__node_cmp;
	121	ilist->rblist.node_new = intlist__node_new;
	122	ilist->rblist.node_delete = intlist__node_delete;
ffe0fb76 ACM	123
	124	if (slist && intlist__parse_list(ilist, slist))
	125	goto out_delete;
70b40c4a DA	126	}
	127
	128	return ilist;
ffe0fb76 ACM	129	out_delete:
	130	intlist__delete(ilist);
	131	return NULL;
70b40c4a DA	132	}
	133
	134	void intlist__delete(struct intlist *ilist)
	135	{
	136	if (ilist != NULL)
	137	rblist__delete(&ilist->rblist);
	138	}
	139
	140	struct int_node intlist__entry(const struct intlist ilist, unsigned int idx)
	141	{
	142	struct int_node *node = NULL;
	143	struct rb_node *rb_node;
	144
	145	rb_node = rblist__entry(&ilist->rblist, idx);
	146	if (rb_node)
	147	node = container_of(rb_node, struct int_node, rb_node);
	148
	149	return node;
	150	}