chiark / gitweb /
tests: add tests for environment serialization
[elogind.git] / src / basic / string-util.h
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
22 #include <alloca.h>
23 #include <stdbool.h>
24 #include <stddef.h>
25 #include <string.h>
26
27 #include "macro.h"
28
29 /* What is interpreted as whitespace? */
30 #define WHITESPACE        " \t\n\r"
31 #define NEWLINE           "\n\r"
32 #define QUOTES            "\"\'"
33 #define COMMENTS          "#;"
34 #define GLOB_CHARS        "*?["
35 #define DIGITS            "0123456789"
36 #define LOWERCASE_LETTERS "abcdefghijklmnopqrstuvwxyz"
37 #define UPPERCASE_LETTERS "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
38 #define LETTERS           LOWERCASE_LETTERS UPPERCASE_LETTERS
39 #define ALPHANUMERICAL    LETTERS DIGITS
40 #define HEXDIGITS         DIGITS "abcdefABCDEF"
41
42 #define streq(a,b) (strcmp((a),(b)) == 0)
43 #define strneq(a, b, n) (strncmp((a), (b), (n)) == 0)
44 #define strcaseeq(a,b) (strcasecmp((a),(b)) == 0)
45 #define strncaseeq(a, b, n) (strncasecmp((a), (b), (n)) == 0)
46
47 int strcmp_ptr(const char *a, const char *b) _pure_;
48
49 static inline bool streq_ptr(const char *a, const char *b) {
50         return strcmp_ptr(a, b) == 0;
51 }
52
53 static inline const char* strempty(const char *s) {
54         return s ? s : "";
55 }
56
57 static inline const char* strnull(const char *s) {
58         return s ? s : "(null)";
59 }
60
61 static inline const char *strna(const char *s) {
62         return s ? s : "n/a";
63 }
64
65 static inline bool isempty(const char *p) {
66         return !p || !p[0];
67 }
68
69 static inline const char *empty_to_null(const char *p) {
70         return isempty(p) ? NULL : p;
71 }
72
73 #if 0 /// UNNEEDED by elogind
74 static inline const char *strdash_if_empty(const char *str) {
75         return isempty(str) ? "-" : str;
76 }
77 #endif // 0
78
79 static inline char *startswith(const char *s, const char *prefix) {
80         size_t l;
81
82         l = strlen(prefix);
83         if (strncmp(s, prefix, l) == 0)
84                 return (char*) s + l;
85
86         return NULL;
87 }
88
89 #if 0 /// UNNEEDED by elogind
90 static inline char *startswith_no_case(const char *s, const char *prefix) {
91         size_t l;
92
93         l = strlen(prefix);
94         if (strncasecmp(s, prefix, l) == 0)
95                 return (char*) s + l;
96
97         return NULL;
98 }
99 #endif // 0
100
101 char *endswith(const char *s, const char *postfix) _pure_;
102 char *endswith_no_case(const char *s, const char *postfix) _pure_;
103
104 char *first_word(const char *s, const char *word) _pure_;
105
106 const char* split(const char **state, size_t *l, const char *separator, bool quoted);
107
108 #define FOREACH_WORD(word, length, s, state)                            \
109         _FOREACH_WORD(word, length, s, WHITESPACE, false, state)
110
111 #define FOREACH_WORD_SEPARATOR(word, length, s, separator, state)       \
112         _FOREACH_WORD(word, length, s, separator, false, state)
113
114 #define _FOREACH_WORD(word, length, s, separator, quoted, state)        \
115         for ((state) = (s), (word) = split(&(state), &(length), (separator), (quoted)); (word); (word) = split(&(state), &(length), (separator), (quoted)))
116
117 char *strappend(const char *s, const char *suffix);
118 char *strnappend(const char *s, const char *suffix, size_t length);
119
120 char *strjoin_real(const char *x, ...) _sentinel_;
121 #define strjoin(a, ...) strjoin_real((a), __VA_ARGS__, NULL)
122
123 #define strjoina(a, ...)                                                \
124         ({                                                              \
125                 const char *_appendees_[] = { a, __VA_ARGS__ };         \
126                 char *_d_, *_p_;                                        \
127                 int _len_ = 0;                                          \
128                 unsigned _i_;                                           \
129                 for (_i_ = 0; _i_ < ELEMENTSOF(_appendees_) && _appendees_[_i_]; _i_++) \
130                         _len_ += strlen(_appendees_[_i_]);              \
131                 _p_ = _d_ = alloca(_len_ + 1);                          \
132                 for (_i_ = 0; _i_ < ELEMENTSOF(_appendees_) && _appendees_[_i_]; _i_++) \
133                         _p_ = stpcpy(_p_, _appendees_[_i_]);            \
134                 *_p_ = 0;                                               \
135                 _d_;                                                    \
136         })
137
138 char *strstrip(char *s);
139 #if 0 /// UNNEEDED by elogind
140 char *delete_chars(char *s, const char *bad);
141 #endif // 0
142 char *truncate_nl(char *s);
143
144 #if 0 /// UNNEEDED by elogind
145 char ascii_tolower(char x);
146 char *ascii_strlower(char *s);
147 char *ascii_strlower_n(char *s, size_t n);
148
149 char ascii_toupper(char x);
150 char *ascii_strupper(char *s);
151
152 int ascii_strcasecmp_n(const char *a, const char *b, size_t n);
153 int ascii_strcasecmp_nn(const char *a, size_t n, const char *b, size_t m);
154
155 bool chars_intersect(const char *a, const char *b) _pure_;
156 #endif // 0
157
158 static inline bool _pure_ in_charset(const char *s, const char* charset) {
159         assert(s);
160         assert(charset);
161         return s[strspn(s, charset)] == '\0';
162 }
163
164 bool string_has_cc(const char *p, const char *ok) _pure_;
165
166 char *ellipsize_mem(const char *s, size_t old_length_bytes, size_t new_length_columns, unsigned percent);
167 char *ellipsize(const char *s, size_t length, unsigned percent);
168
169 bool nulstr_contains(const char*nulstr, const char *needle);
170
171 char* strshorten(char *s, size_t l);
172
173 char *strreplace(const char *text, const char *old_string, const char *new_string);
174
175 char *strip_tab_ansi(char **p, size_t *l);
176
177 char *strextend(char **x, ...) _sentinel_;
178
179 char *strrep(const char *s, unsigned n);
180
181 int split_pair(const char *s, const char *sep, char **l, char **r);
182
183 int free_and_strdup(char **p, const char *s);
184
185 /* Normal memmem() requires haystack to be nonnull, which is annoying for zero-length buffers */
186 static inline void *memmem_safe(const void *haystack, size_t haystacklen, const void *needle, size_t needlelen) {
187
188         if (needlelen <= 0)
189                 return (void*) haystack;
190
191         if (haystacklen < needlelen)
192                 return NULL;
193
194         assert(haystack);
195         assert(needle);
196
197         return memmem(haystack, haystacklen, needle, needlelen);
198 }
199
200 #if !HAVE_DECL_EXPLICIT_BZERO
201 void explicit_bzero(void *p, size_t l);
202 #endif
203
204 char *string_erase(char *x);
205
206 char *string_free_erase(char *s);
207 DEFINE_TRIVIAL_CLEANUP_FUNC(char *, string_free_erase);
208 #define _cleanup_string_free_erase_ _cleanup_(string_free_erasep)
209
210 bool string_is_safe(const char *p) _pure_;