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

#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_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);

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

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