[systemd.git] / src / basic / strv.h

/* SPDX-License-Identifier: LGPL-2.1+ */
#pragma once

/***
  This file is part of systemd.

  Copyright 2010 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <fnmatch.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stddef.h>

#include "alloc-util.h"
#include "extract-word.h"
#include "macro.h"
#include "util.h"

char *strv_find(char **l, const char *name) _pure_;
char *strv_find_prefix(char **l, const char *name) _pure_;
char *strv_find_startswith(char **l, const char *name) _pure_;

char **strv_free(char **l);
DEFINE_TRIVIAL_CLEANUP_FUNC(char**, strv_free);
#define _cleanup_strv_free_ _cleanup_(strv_freep)

char **strv_free_erase(char **l);
DEFINE_TRIVIAL_CLEANUP_FUNC(char**, strv_free_erase);
#define _cleanup_strv_free_erase_ _cleanup_(strv_free_erasep)

void strv_clear(char **l);

char **strv_copy(char * const *l);
unsigned strv_length(char * const *l) _pure_;

int strv_extend_strv(char ***a, char **b, bool filter_duplicates);
int strv_extend_strv_concat(char ***a, char **b, const char *suffix);
int strv_extend(char ***l, const char *value);
int strv_extendf(char ***l, const char *format, ...) _printf_(2,0);
int strv_extend_front(char ***l, const char *value);
int strv_push(char ***l, char *value);
int strv_push_pair(char ***l, char *a, char *b);
int strv_push_prepend(char ***l, char *value);
int strv_consume(char ***l, char *value);
int strv_consume_pair(char ***l, char *a, char *b);
int strv_consume_prepend(char ***l, char *value);

char **strv_remove(char **l, const char *s);
char **strv_uniq(char **l);
bool strv_is_uniq(char **l);

bool strv_equal(char **a, char **b);

#define strv_contains(l, s) (!!strv_find((l), (s)))

char **strv_new(const char *x, ...) _sentinel_;
char **strv_new_ap(const char *x, va_list ap);

#define STRV_IGNORE ((const char *) -1)

static inline const char* STRV_IFNOTNULL(const char *x) {
        return x ? x : STRV_IGNORE;
}

static inline bool strv_isempty(char * const *l) {
        return !l || !*l;
}

char **strv_split(const char *s, const char *separator);
char **strv_split_newlines(const char *s);

int strv_split_extract(char ***t, const char *s, const char *separators, ExtractFlags flags);

char *strv_join(char **l, const char *separator);
char *strv_join_quoted(char **l);

char **strv_parse_nulstr(const char *s, size_t l);
char **strv_split_nulstr(const char *s);
int strv_make_nulstr(char **l, char **p, size_t *n);

bool strv_overlap(char **a, char **b) _pure_;

#define STRV_FOREACH(s, l)                      \
        for ((s) = (l); (s) && *(s); (s)++)

#define STRV_FOREACH_BACKWARDS(s, l)                                \
        for (s = ({                                                 \
                        char **_l = l;                              \
                        _l ? _l + strv_length(_l) - 1U : NULL;      \
                        });                                         \
             (l) && ((s) >= (l));                                   \
             (s)--)

#define STRV_FOREACH_PAIR(x, y, l)               \
        for ((x) = (l), (y) = (x+1); (x) && *(x) && *(y); (x) += 2, (y) = (x + 1))

char **strv_sort(char **l);
void strv_print(char **l);

#define STRV_MAKE(...) ((char**) ((const char*[]) { __VA_ARGS__, NULL }))

#define STRV_MAKE_EMPTY ((char*[1]) { NULL })

#define strv_from_stdarg_alloca(first)                          \
        ({                                                      \
                char **_l;                                      \
                                                                \
                if (!first)                                     \
                        _l = (char**) &first;                   \
                else {                                          \
                        unsigned _n;                            \
                        va_list _ap;                            \
                                                                \
                        _n = 1;                                 \
                        va_start(_ap, first);                   \
                        while (va_arg(_ap, char*))              \
                                _n++;                           \
                        va_end(_ap);                            \
                                                                \
                        _l = newa(char*, _n+1);                 \
                        _l[_n = 0] = (char*) first;             \
                        va_start(_ap, first);                   \
                        for (;;) {                              \
                                _l[++_n] = va_arg(_ap, char*);  \
                                if (!_l[_n])                    \
                                        break;                  \
                        }                                       \
                        va_end(_ap);                            \
                }                                               \
                _l;                                             \
        })

#define STR_IN_SET(x, ...) strv_contains(STRV_MAKE(__VA_ARGS__), x)
#define STRPTR_IN_SET(x, ...)                                    \
        ({                                                       \
                const char* _x = (x);                            \
                _x && strv_contains(STRV_MAKE(__VA_ARGS__), _x); \
        })

#define FOREACH_STRING(x, ...)                               \
        for (char **_l = ({                                  \
                char **_ll = STRV_MAKE(__VA_ARGS__);         \
                x = _ll ? _ll[0] : NULL;                     \
                _ll;                                         \
        });                                                  \
        _l && *_l;                                           \
        x = ({                                               \
                _l ++;                                       \
                _l[0];                                       \
        }))

char **strv_reverse(char **l);
char **strv_shell_escape(char **l, const char *bad);

bool strv_fnmatch(char* const* patterns, const char *s, int flags);

static inline bool strv_fnmatch_or_empty(char* const* patterns, const char *s, int flags) {
        assert(s);
        return strv_isempty(patterns) ||
               strv_fnmatch(patterns, s, flags);
}

char ***strv_free_free(char ***l);

char **strv_skip(char **l, size_t n);

int strv_extend_n(char ***l, const char *value, size_t n);

int fputstrv(FILE *f, char **l, const char *separator, bool *space);

#define strv_free_and_replace(a, b)             \
        ({                                      \
                strv_free(a);                   \
                (a) = (b);                      \
                (b) = NULL;                     \
                0;                              \
        })
Commit	Line	Data
52ad194e	1	/* SPDX-License-Identifier: LGPL-2.1+ */
663996b3 MS	2	#pragma once
	3
	4	/***
	5	This file is part of systemd.
	6
	7	Copyright 2010 Lennart Poettering
	8
	9	systemd is free software; you can redistribute it and/or modify it
	10	under the terms of the GNU Lesser General Public License as published by
	11	the Free Software Foundation; either version 2.1 of the License, or
	12	(at your option) any later version.
	13
	14	systemd is distributed in the hope that it will be useful, but
	15	WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	17	Lesser General Public License for more details.
	18
	19	You should have received a copy of the GNU Lesser General Public License
	20	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	21	***/
	22
db2df898	23	#include <fnmatch.h>
663996b3 MS	24	#include <stdarg.h>
663996b3 MS	25	#include <stdbool.h>
4c89c718	26	#include <stddef.h>
663996b3	27
4c89c718	28	#include "alloc-util.h"
db2df898	29	#include "extract-word.h"
4c89c718	30	#include "macro.h"
60f067b4	31	#include "util.h"
663996b3 MS	32
	33	char strv_find(char l, const char name) _pure_;
	34	char strv_find_prefix(char l, const char name) _pure_;
5eef597e	35	char strv_find_startswith(char l, const char name) _pure_;
663996b3	36
e3bff60a	37	char strv_free(char l);
60f067b4	38	DEFINE_TRIVIAL_CLEANUP_FUNC(char**, strv_free);
663996b3 MS	39	#define _cleanup_strv_free_ _cleanup_(strv_freep)
663996b3 MS	40
db2df898 MP	41	char strv_free_erase(char l);
	42	DEFINE_TRIVIAL_CLEANUP_FUNC(char**, strv_free_erase);
	43	#define _cleanup_strv_free_erase_ _cleanup_(strv_free_erasep)
	44
e735f4d4 MP	45	void strv_clear(char **l);
e735f4d4 MP	46
663996b3 MS	47	char *strv_copy(char const *l);
	48	unsigned strv_length(char * const *l) _pure_;
	49
6300502b	50	int strv_extend_strv(char *a, char b, bool filter_duplicates);
60f067b4	51	int strv_extend_strv_concat(char *a, char b, const char *suffix);
663996b3	52	int strv_extend(char **l, const char value);
60f067b4	53	int strv_extendf(char **l, const char format, ...) _printf_(2,0);
aa27b158	54	int strv_extend_front(char **l, const char value);
663996b3	55	int strv_push(char **l, char value);
f47781d8	56	int strv_push_pair(char **l, char a, char *b);
e842803a	57	int strv_push_prepend(char **l, char value);
60f067b4	58	int strv_consume(char **l, char value);
f47781d8	59	int strv_consume_pair(char **l, char a, char *b);
e842803a	60	int strv_consume_prepend(char **l, char value);
663996b3 MS	61
663996b3 MS	62	char strv_remove(char l, const char *s);
663996b3	63	char strv_uniq(char l);
e735f4d4	64	bool strv_is_uniq(char **l);
663996b3	65
f47781d8 MP	66	bool strv_equal(char a, char b);
f47781d8 MP	67
663996b3 MS	68	#define strv_contains(l, s) (!!strv_find((l), (s)))
	69
	70	char *strv_new(const char x, ...) _sentinel_;
	71	char *strv_new_ap(const char x, va_list ap);
	72
5a920b42 MP	73	#define STRV_IGNORE ((const char *) -1)
5a920b42 MP	74
663996b3	75	static inline const char* STRV_IFNOTNULL(const char *x) {
5a920b42	76	return x ? x : STRV_IGNORE;
663996b3 MS	77	}
	78
	79	static inline bool strv_isempty(char * const *l) {
	80	return !l \|\| !*l;
	81	}
	82
	83	char *strv_split(const char s, const char *separator);
663996b3 MS	84	char *strv_split_newlines(const char s);
663996b3 MS	85
13d276d0	86	int strv_split_extract(char **t, const char s, const char *separators, ExtractFlags flags);
f47781d8	87
663996b3	88	char strv_join(char l, const char separator);
14228c0d	89	char strv_join_quoted(char *l);
663996b3 MS	90
	91	char *strv_parse_nulstr(const char s, size_t l);
	92	char *strv_split_nulstr(const char s);
6300502b	93	int strv_make_nulstr(char l, char p, size_t *n);
663996b3 MS	94
	95	bool strv_overlap(char a, char b) _pure_;
	96
	97	#define STRV_FOREACH(s, l) \
	98	for ((s) = (l); (s) && *(s); (s)++)
	99
8a584da2 MP	100	#define STRV_FOREACH_BACKWARDS(s, l) \
	101	for (s = ({ \
	102	char **_l = l; \
	103	_l ? _l + strv_length(_l) - 1U : NULL; \
	104	}); \
	105	(l) && ((s) >= (l)); \
	106	(s)--)
663996b3 MS	107
	108	#define STRV_FOREACH_PAIR(x, y, l) \
	109	for ((x) = (l), (y) = (x+1); (x) && (x) && (y); (x) += 2, (y) = (x + 1))
	110
663996b3 MS	111	char strv_sort(char l);
663996b3 MS	112	void strv_print(char **l);
60f067b4 JS	113
	114	#define STRV_MAKE(...) ((char*) ((const char[]) { __VA_ARGS__, NULL }))
	115
	116	#define STRV_MAKE_EMPTY ((char*[1]) { NULL })
	117
	118	#define strv_from_stdarg_alloca(first) \
	119	({ \
	120	char **_l; \
	121	\
	122	if (!first) \
	123	_l = (char**) &first; \
	124	else { \
	125	unsigned _n; \
	126	va_list _ap; \
	127	\
	128	_n = 1; \
	129	va_start(_ap, first); \
	130	while (va_arg(_ap, char*)) \
	131	_n++; \
	132	va_end(_ap); \
	133	\
	134	_l = newa(char*, _n+1); \
	135	_l[_n = 0] = (char*) first; \
	136	va_start(_ap, first); \
	137	for (;;) { \
	138	_l[++_n] = va_arg(_ap, char*); \
	139	if (!_l[_n]) \
	140	break; \
	141	} \
	142	va_end(_ap); \
	143	} \
	144	_l; \
	145	})
	146
	147	#define STR_IN_SET(x, ...) strv_contains(STRV_MAKE(__VA_ARGS__), x)
8a584da2 MP	148	#define STRPTR_IN_SET(x, ...) \
	149	({ \
	150	const char* _x = (x); \
	151	_x && strv_contains(STRV_MAKE(__VA_ARGS__), _x); \
	152	})
60f067b4 JS	153
	154	#define FOREACH_STRING(x, ...) \
	155	for (char **_l = ({ \
	156	char **_ll = STRV_MAKE(__VA_ARGS__); \
	157	x = _ll ? _ll[0] : NULL; \
	158	_ll; \
	159	}); \
	160	_l && *_l; \
	161	x = ({ \
	162	_l ++; \
	163	_l[0]; \
	164	}))
e735f4d4 MP	165
e735f4d4 MP	166	char strv_reverse(char l);
13d276d0	167	char strv_shell_escape(char l, const char *bad);
e735f4d4 MP	168
	169	bool strv_fnmatch(char* const* patterns, const char *s, int flags);
	170
	171	static inline bool strv_fnmatch_or_empty(char* const* patterns, const char *s, int flags) {
	172	assert(s);
	173	return strv_isempty(patterns) \|\|
	174	strv_fnmatch(patterns, s, flags);
	175	}
6300502b MP	176
	177	char *strv_free_free(char *l);
	178
	179	char strv_skip(char l, size_t n);
	180
	181	int strv_extend_n(char **l, const char value, size_t n);
4c89c718 MP	182
4c89c718 MP	183	int fputstrv(FILE f, char l, const char separator, bool *space);
52ad194e MB	184
	185	#define strv_free_and_replace(a, b) \
	186	({ \
	187	strv_free(a); \
	188	(a) = (b); \
	189	(b) = NULL; \
	190	0; \
	191	})