Branch data Line data Source code
1 : : /* SPDX-License-Identifier: LGPL-2.1+ */
2 : : #pragma once
3 : :
4 : : #include <alloca.h>
5 : : #include <stdbool.h>
6 : : #include <stddef.h>
7 : : #include <string.h>
8 : :
9 : : #include "alloc-util.h"
10 : : #include "macro.h"
11 : :
12 : : /* What is interpreted as whitespace? */
13 : : #define WHITESPACE " \t\n\r"
14 : : #define NEWLINE "\n\r"
15 : : #define QUOTES "\"\'"
16 : : #define COMMENTS "#;"
17 : : #define GLOB_CHARS "*?["
18 : : #define DIGITS "0123456789"
19 : : #define LOWERCASE_LETTERS "abcdefghijklmnopqrstuvwxyz"
20 : : #define UPPERCASE_LETTERS "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
21 : : #define LETTERS LOWERCASE_LETTERS UPPERCASE_LETTERS
22 : : #define ALPHANUMERICAL LETTERS DIGITS
23 : : #define HEXDIGITS DIGITS "abcdefABCDEF"
24 : :
25 : : #define streq(a,b) (strcmp((a),(b)) == 0)
26 : : #define strneq(a, b, n) (strncmp((a), (b), (n)) == 0)
27 : : #define strcaseeq(a,b) (strcasecmp((a),(b)) == 0)
28 : : #define strncaseeq(a, b, n) (strncasecmp((a), (b), (n)) == 0)
29 : :
30 : : int strcmp_ptr(const char *a, const char *b) _pure_;
31 : :
32 : 4910101 : static inline bool streq_ptr(const char *a, const char *b) {
33 : 4910101 : return strcmp_ptr(a, b) == 0;
34 : : }
35 : :
36 : 38084 : static inline const char* strempty(const char *s) {
37 [ + + ]: 38084 : return s ?: "";
38 : : }
39 : :
40 : 1804 : static inline const char* strnull(const char *s) {
41 [ + + ]: 1804 : return s ?: "(null)";
42 : : }
43 : :
44 : 67887 : static inline const char *strna(const char *s) {
45 [ + + ]: 67887 : return s ?: "n/a";
46 : : }
47 : :
48 : 8866496 : static inline bool isempty(const char *p) {
49 [ + + + + ]: 8866496 : return !p || !p[0];
50 : : }
51 : :
52 : 7648 : static inline const char *empty_to_null(const char *p) {
53 [ + - ]: 7648 : return isempty(p) ? NULL : p;
54 : : }
55 : :
56 : 116 : static inline const char *empty_to_dash(const char *str) {
57 [ + + ]: 116 : return isempty(str) ? "-" : str;
58 : : }
59 : :
60 : 816 : static inline bool empty_or_dash(const char *str) {
61 : 712 : return !str ||
62 [ + + + - ]: 1528 : str[0] == 0 ||
63 [ + + + - ]: 712 : (str[0] == '-' && str[1] == 0);
64 : : }
65 : :
66 : 80 : static inline const char *empty_or_dash_to_null(const char *p) {
67 [ + + ]: 80 : return empty_or_dash(p) ? NULL : p;
68 : : }
69 : :
70 : 295830 : static inline char *startswith(const char *s, const char *prefix) {
71 : : size_t l;
72 : :
73 : 295830 : l = strlen(prefix);
74 [ + + ]: 295830 : if (strncmp(s, prefix, l) == 0)
75 : 34060 : return (char*) s + l;
76 : :
77 : 261770 : return NULL;
78 : : }
79 : :
80 : 156316 : static inline char *startswith_no_case(const char *s, const char *prefix) {
81 : : size_t l;
82 : :
83 : 156316 : l = strlen(prefix);
84 [ + + ]: 156316 : if (strncasecmp(s, prefix, l) == 0)
85 : 1994 : return (char*) s + l;
86 : :
87 : 154322 : return NULL;
88 : : }
89 : :
90 : : char *endswith(const char *s, const char *postfix) _pure_;
91 : : char *endswith_no_case(const char *s, const char *postfix) _pure_;
92 : :
93 : : char *first_word(const char *s, const char *word) _pure_;
94 : :
95 : : typedef enum SplitFlags {
96 : : SPLIT_QUOTES = 0x01 << 0,
97 : : SPLIT_RELAX = 0x01 << 1,
98 : : } SplitFlags;
99 : :
100 : : const char* split(const char **state, size_t *l, const char *separator, SplitFlags flags);
101 : :
102 : : #define FOREACH_WORD(word, length, s, state) \
103 : : _FOREACH_WORD(word, length, s, WHITESPACE, 0, state)
104 : :
105 : : #define FOREACH_WORD_SEPARATOR(word, length, s, separator, state) \
106 : : _FOREACH_WORD(word, length, s, separator, 0, state)
107 : :
108 : : #define _FOREACH_WORD(word, length, s, separator, flags, state) \
109 : : for ((state) = (s), (word) = split(&(state), &(length), (separator), (flags)); (word); (word) = split(&(state), &(length), (separator), (flags)))
110 : :
111 : : char *strnappend(const char *s, const char *suffix, size_t length);
112 : :
113 : : char *strjoin_real(const char *x, ...) _sentinel_;
114 : : #define strjoin(a, ...) strjoin_real((a), __VA_ARGS__, NULL)
115 : :
116 : : #define strjoina(a, ...) \
117 : : ({ \
118 : : const char *_appendees_[] = { a, __VA_ARGS__ }; \
119 : : char *_d_, *_p_; \
120 : : size_t _len_ = 0; \
121 : : size_t _i_; \
122 : : for (_i_ = 0; _i_ < ELEMENTSOF(_appendees_) && _appendees_[_i_]; _i_++) \
123 : : _len_ += strlen(_appendees_[_i_]); \
124 : : _p_ = _d_ = newa(char, _len_ + 1); \
125 : : for (_i_ = 0; _i_ < ELEMENTSOF(_appendees_) && _appendees_[_i_]; _i_++) \
126 : : _p_ = stpcpy(_p_, _appendees_[_i_]); \
127 : : *_p_ = 0; \
128 : : _d_; \
129 : : })
130 : :
131 : : char *strstrip(char *s);
132 : : char *delete_chars(char *s, const char *bad);
133 : : char *delete_trailing_chars(char *s, const char *bad);
134 : : char *truncate_nl(char *s);
135 : :
136 : 143700 : static inline char *skip_leading_chars(const char *s, const char *bad) {
137 : :
138 [ - + ]: 143700 : if (!s)
139 : 0 : return NULL;
140 : :
141 [ - + ]: 143700 : if (!bad)
142 : 0 : bad = WHITESPACE;
143 : :
144 : 143700 : return (char*) s + strspn(s, bad);
145 : : }
146 : :
147 : : char ascii_tolower(char x);
148 : : char *ascii_strlower(char *s);
149 : : char *ascii_strlower_n(char *s, size_t n);
150 : :
151 : : char ascii_toupper(char x);
152 : : char *ascii_strupper(char *s);
153 : :
154 : : int ascii_strcasecmp_n(const char *a, const char *b, size_t n);
155 : : int ascii_strcasecmp_nn(const char *a, size_t n, const char *b, size_t m);
156 : :
157 : : bool chars_intersect(const char *a, const char *b) _pure_;
158 : :
159 : 148884 : static inline bool _pure_ in_charset(const char *s, const char* charset) {
160 [ - + ]: 148884 : assert(s);
161 [ - + ]: 148884 : assert(charset);
162 : 148884 : return s[strspn(s, charset)] == '\0';
163 : : }
164 : :
165 : : bool string_has_cc(const char *p, const char *ok) _pure_;
166 : :
167 : : char *ellipsize_mem(const char *s, size_t old_length_bytes, size_t new_length_columns, unsigned percent);
168 : 384 : static inline char *ellipsize(const char *s, size_t length, unsigned percent) {
169 : 384 : return ellipsize_mem(s, strlen(s), length, percent);
170 : : }
171 : :
172 : : char *cellescape(char *buf, size_t len, const char *s);
173 : :
174 : : /* This limit is arbitrary, enough to give some idea what the string contains */
175 : : #define CELLESCAPE_DEFAULT_LENGTH 64
176 : :
177 : : char* strshorten(char *s, size_t l);
178 : :
179 : : char *strreplace(const char *text, const char *old_string, const char *new_string);
180 : :
181 : : char *strip_tab_ansi(char **ibuf, size_t *_isz, size_t highlight[2]);
182 : :
183 : : char *strextend_with_separator(char **x, const char *separator, ...) _sentinel_;
184 : :
185 : : #define strextend(x, ...) strextend_with_separator(x, NULL, __VA_ARGS__)
186 : :
187 : : char *strrep(const char *s, unsigned n);
188 : :
189 : : int split_pair(const char *s, const char *sep, char **l, char **r);
190 : :
191 : : int free_and_strdup(char **p, const char *s);
192 : 0 : static inline int free_and_strdup_warn(char **p, const char *s) {
193 [ # # ]: 0 : if (free_and_strdup(p, s) < 0)
194 : 0 : return log_oom();
195 : 0 : return 0;
196 : : }
197 : : int free_and_strndup(char **p, const char *s, size_t l);
198 : :
199 : : bool string_is_safe(const char *p) _pure_;
200 : :
201 : 2114628 : static inline size_t strlen_ptr(const char *s) {
202 [ + + ]: 2114628 : if (!s)
203 : 658908 : return 0;
204 : :
205 : 1455720 : return strlen(s);
206 : : }
207 : :
208 : : DISABLE_WARNING_STRINGOP_TRUNCATION;
209 : 0 : static inline void strncpy_exact(char *buf, const char *src, size_t buf_len) {
210 : 0 : strncpy(buf, src, buf_len);
211 : 0 : }
212 : : REENABLE_WARNING;
213 : :
214 : : /* Like startswith(), but operates on arbitrary memory blocks */
215 : 852 : static inline void *memory_startswith(const void *p, size_t sz, const char *token) {
216 : : size_t n;
217 : :
218 [ - + ]: 852 : assert(token);
219 : :
220 : 852 : n = strlen(token);
221 [ + + ]: 852 : if (sz < n)
222 : 316 : return NULL;
223 : :
224 [ - + ]: 536 : assert(p);
225 : :
226 [ + + ]: 536 : if (memcmp(p, token, n) != 0)
227 : 424 : return NULL;
228 : :
229 : 112 : return (uint8_t*) p + n;
230 : : }
231 : :
232 : : /* Like startswith_no_case(), but operates on arbitrary memory blocks.
233 : : * It works only for ASCII strings.
234 : : */
235 : 76 : static inline void *memory_startswith_no_case(const void *p, size_t sz, const char *token) {
236 : : size_t n, i;
237 : :
238 [ - + ]: 76 : assert(token);
239 : :
240 : 76 : n = strlen(token);
241 [ + + ]: 76 : if (sz < n)
242 : 4 : return NULL;
243 : :
244 [ - + ]: 72 : assert(p);
245 : :
246 [ + + ]: 176 : for (i = 0; i < n; i++) {
247 [ + + ]: 108 : if (ascii_tolower(((char *)p)[i]) != ascii_tolower(token[i]))
248 : 4 : return NULL;
249 : : }
250 : :
251 : 68 : return (uint8_t*) p + n;
252 : : }
253 : :
254 : 344 : static inline char* str_realloc(char **p) {
255 : : /* Reallocate *p to actual size */
256 : :
257 [ - + ]: 344 : if (!*p)
258 : 0 : return NULL;
259 : :
260 : 344 : char *t = realloc(*p, strlen(*p) + 1);
261 [ - + ]: 344 : if (!t)
262 : 0 : return NULL;
263 : :
264 : 344 : return (*p = t);
265 : : }
|
