chiark / gitweb /
d029d538bd5ea46ab5cbb26cbc8ef9508623db82
[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 static inline const char *strdash_if_empty(const char *str) {
74         return isempty(str) ? "-" : str;
75 }
76
77 static inline char *startswith(const char *s, const char *prefix) {
78         size_t l;
79
80         l = strlen(prefix);
81         if (strncmp(s, prefix, l) == 0)
82                 return (char*) s + l;
83
84         return NULL;
85 }
86
87 static inline char *startswith_no_case(const char *s, const char *prefix) {
88         size_t l;
89
90         l = strlen(prefix);
91         if (strncasecmp(s, prefix, l) == 0)
92                 return (char*) s + l;
93
94         return NULL;
95 }
96
97 char *endswith(const char *s, const char *postfix) _pure_;
98 char *endswith_no_case(const char *s, const char *postfix) _pure_;
99
100 char *first_word(const char *s, const char *word) _pure_;
101
102 const char* split(const char **state, size_t *l, const char *separator, bool quoted);
103
104 #define FOREACH_WORD(word, length, s, state)                            \
105         _FOREACH_WORD(word, length, s, WHITESPACE, false, state)
106
107 #define FOREACH_WORD_SEPARATOR(word, length, s, separator, state)       \
108         _FOREACH_WORD(word, length, s, separator, false, state)
109
110 #define FOREACH_WORD_QUOTED(word, length, s, state)                     \
111         _FOREACH_WORD(word, length, s, WHITESPACE, true, state)
112
113 #define _FOREACH_WORD(word, length, s, separator, quoted, state)        \
114         for ((state) = (s), (word) = split(&(state), &(length), (separator), (quoted)); (word); (word) = split(&(state), &(length), (separator), (quoted)))
115
116 char *strappend(const char *s, const char *suffix);
117 char *strnappend(const char *s, const char *suffix, size_t length);
118
119 char *strjoin(const char *x, ...) _sentinel_;
120
121 #define strjoina(a, ...)                                                \
122         ({                                                              \
123                 const char *_appendees_[] = { a, __VA_ARGS__ };         \
124                 char *_d_, *_p_;                                        \
125                 int _len_ = 0;                                          \
126                 unsigned _i_;                                           \
127                 for (_i_ = 0; _i_ < ELEMENTSOF(_appendees_) && _appendees_[_i_]; _i_++) \
128                         _len_ += strlen(_appendees_[_i_]);              \
129                 _p_ = _d_ = alloca(_len_ + 1);                          \
130                 for (_i_ = 0; _i_ < ELEMENTSOF(_appendees_) && _appendees_[_i_]; _i_++) \
131                         _p_ = stpcpy(_p_, _appendees_[_i_]);            \
132                 *_p_ = 0;                                               \
133                 _d_;                                                    \
134         })
135
136 char *strstrip(char *s);
137 char *delete_chars(char *s, const char *bad);
138 char *truncate_nl(char *s);
139
140 char ascii_tolower(char x);
141 char *ascii_strlower(char *s);
142 char *ascii_strlower_n(char *s, size_t n);
143
144 char ascii_toupper(char x);
145 char *ascii_strupper(char *s);
146
147 int ascii_strcasecmp_n(const char *a, const char *b, size_t n);
148 int ascii_strcasecmp_nn(const char *a, size_t n, const char *b, size_t m);
149
150 bool chars_intersect(const char *a, const char *b) _pure_;
151
152 static inline bool _pure_ in_charset(const char *s, const char* charset) {
153         assert(s);
154         assert(charset);
155         return s[strspn(s, charset)] == '\0';
156 }
157
158 bool string_has_cc(const char *p, const char *ok) _pure_;
159
160 char *ellipsize_mem(const char *s, size_t old_length_bytes, size_t new_length_columns, unsigned percent);
161 char *ellipsize(const char *s, size_t length, unsigned percent);
162
163 bool nulstr_contains(const char*nulstr, const char *needle);
164
165 char* strshorten(char *s, size_t l);
166
167 char *strreplace(const char *text, const char *old_string, const char *new_string);
168
169 char *strip_tab_ansi(char **p, size_t *l);
170
171 char *strextend(char **x, ...) _sentinel_;
172
173 char *strrep(const char *s, unsigned n);
174
175 int split_pair(const char *s, const char *sep, char **l, char **r);
176
177 int free_and_strdup(char **p, const char *s);
178
179 /* Normal memmem() requires haystack to be nonnull, which is annoying for zero-length buffers */
180 static inline void *memmem_safe(const void *haystack, size_t haystacklen, const void *needle, size_t needlelen) {
181
182         if (needlelen <= 0)
183                 return (void*) haystack;
184
185         if (haystacklen < needlelen)
186                 return NULL;
187
188         assert(haystack);
189         assert(needle);
190
191         return memmem(haystack, haystacklen, needle, needlelen);
192 }
193
194 void* memory_erase(void *p, size_t l);
195 char *string_erase(char *x);
196
197 char *string_free_erase(char *s);
198 DEFINE_TRIVIAL_CLEANUP_FUNC(char *, string_free_erase);
199 #define _cleanup_string_free_erase_ _cleanup_(string_free_erasep)
200
201 bool string_is_safe(const char *p) _pure_;