src/basic/strv.h

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