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 // UNNEEDED int strv_extend_strv_concat(char ***a, char **b, const char *suffix);
  50 int strv_extend(char ***l, const char *value);
  51 // UNNEEDED int strv_extendf(char ***l, const char *format, ...) _printf_(2,0);
  52 int strv_push(char ***l, char *value);
  53 int strv_push_pair(char ***l, char *a, char *b);
  54 int strv_push_prepend(char ***l, char *value);
  55 int strv_consume(char ***l, char *value);
  56 // UNNEEDED int strv_consume_pair(char ***l, char *a, char *b);
  57 int strv_consume_prepend(char ***l, char *value);
  58
  59 char **strv_remove(char **l, const char *s);
  60 char **strv_uniq(char **l);
  61 // UNNEEDED bool strv_is_uniq(char **l);
  62
  63 // UNNEEDED bool strv_equal(char **a, char **b);
  64
  65 #define strv_contains(l, s) (!!strv_find((l), (s)))
  66
  67 char **strv_new(const char *x, ...) _sentinel_;
  68 char **strv_new_ap(const char *x, va_list ap);
  69
  70 static inline const char* STRV_IFNOTNULL(const char *x) {
  71         return x ? x : (const char *) -1;
  72 }
  73
  74 static inline bool strv_isempty(char * const *l) {
  75         return !l || !*l;
  76 }
  77
  78 char **strv_split(const char *s, const char *separator);
  79 // UNNEEDED char **strv_split_newlines(const char *s);
  80
  81 // UNNEEDED int strv_split_extract(char ***t, const char *s, const char *separators, ExtractFlags flags);
  82
  83 char *strv_join(char **l, const char *separator);
  84 // UNNEEDED char *strv_join_quoted(char **l);
  85
  86 char **strv_parse_nulstr(const char *s, size_t l);
  87 char **strv_split_nulstr(const char *s);
  88 // UNNEEDED int strv_make_nulstr(char **l, char **p, size_t *n);
  89
  90 // UNNEEDED bool strv_overlap(char **a, char **b) _pure_;
  91
  92 #define STRV_FOREACH(s, l)                      \
  93         for ((s) = (l); (s) && *(s); (s)++)
  94
  95 #define STRV_FOREACH_BACKWARDS(s, l)            \
  96         STRV_FOREACH(s, l)                      \
  97                 ;                               \
  98         for ((s)--; (l) && ((s) >= (l)); (s)--)
  99
 100 #define STRV_FOREACH_PAIR(x, y, l)               \
 101         for ((x) = (l), (y) = (x+1); (x) && *(x) && *(y); (x) += 2, (y) = (x + 1))
 102
 103 char **strv_sort(char **l);
 104 // UNNEEDED void strv_print(char **l);
 105
 106 #define STRV_MAKE(...) ((char**) ((const char*[]) { __VA_ARGS__, NULL }))
 107
 108 #define STRV_MAKE_EMPTY ((char*[1]) { NULL })
 109
 110 #define strv_from_stdarg_alloca(first)                          \
 111         ({                                                      \
 112                 char **_l;                                      \
 113                                                                 \
 114                 if (!first)                                     \
 115                         _l = (char**) &first;                   \
 116                 else {                                          \
 117                         unsigned _n;                            \
 118                         va_list _ap;                            \
 119                                                                 \
 120                         _n = 1;                                 \
 121                         va_start(_ap, first);                   \
 122                         while (va_arg(_ap, char*))              \
 123                                 _n++;                           \
 124                         va_end(_ap);                            \
 125                                                                 \
 126                         _l = newa(char*, _n+1);                 \
 127                         _l[_n = 0] = (char*) first;             \
 128                         va_start(_ap, first);                   \
 129                         for (;;) {                              \
 130                                 _l[++_n] = va_arg(_ap, char*);  \
 131                                 if (!_l[_n])                    \
 132                                         break;                  \
 133                         }                                       \
 134                         va_end(_ap);                            \
 135                 }                                               \
 136                 _l;                                             \
 137         })
 138
 139 #define STR_IN_SET(x, ...) strv_contains(STRV_MAKE(__VA_ARGS__), x)
 140
 141 #define FOREACH_STRING(x, ...)                               \
 142         for (char **_l = ({                                  \
 143                 char **_ll = STRV_MAKE(__VA_ARGS__);         \
 144                 x = _ll ? _ll[0] : NULL;                     \
 145                 _ll;                                         \
 146         });                                                  \
 147         _l && *_l;                                           \
 148         x = ({                                               \
 149                 _l ++;                                       \
 150                 _l[0];                                       \
 151         }))
 152
 153 // UNNEEDED char **strv_reverse(char **l);
 154 // UNNEEDED char **strv_shell_escape(char **l, const char *bad);
 155
 156 // UNNEEDED bool strv_fnmatch(char* const* patterns, const char *s, int flags);
 157
 158 /// UNNEEDED by elogind
 159 #if 0
 160 static inline bool strv_fnmatch_or_empty(char* const* patterns, const char *s, int flags) {
 161         assert(s);
 162         return strv_isempty(patterns) ||
 163                strv_fnmatch(patterns, s, flags);
 164 }
 165 #endif // 0
 166
 167 // UNNEEDED char ***strv_free_free(char ***l);
 168
 169 // UNNEEDED char **strv_skip(char **l, size_t n);
 170
 171 // UNNEEDED int strv_extend_n(char ***l, const char *value, size_t n);