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 1216853 : static inline bool streq_ptr(const char *a, const char *b) {
33 1216853 : return strcmp_ptr(a, b) == 0;
34 : }
35 :
36 9509 : static inline const char* strempty(const char *s) {
37 9509 : return s ?: "";
38 : }
39 :
40 451 : static inline const char* strnull(const char *s) {
41 451 : return s ?: "(null)";
42 : }
43 :
44 17100 : static inline const char *strna(const char *s) {
45 17100 : return s ?: "n/a";
46 : }
47 :
48 2221044 : static inline bool isempty(const char *p) {
49 2221044 : return !p || !p[0];
50 : }
51 :
52 1890 : static inline const char *empty_to_null(const char *p) {
53 1890 : return isempty(p) ? NULL : p;
54 : }
55 :
56 29 : static inline const char *empty_to_dash(const char *str) {
57 29 : return isempty(str) ? "-" : str;
58 : }
59 :
60 204 : static inline bool empty_or_dash(const char *str) {
61 178 : return !str ||
62 382 : str[0] == 0 ||
63 178 : (str[0] == '-' && str[1] == 0);
64 : }
65 :
66 20 : static inline const char *empty_or_dash_to_null(const char *p) {
67 20 : return empty_or_dash(p) ? NULL : p;
68 : }
69 :
70 72870 : static inline char *startswith(const char *s, const char *prefix) {
71 : size_t l;
72 :
73 72870 : l = strlen(prefix);
74 72870 : if (strncmp(s, prefix, l) == 0)
75 8415 : return (char*) s + l;
76 :
77 64455 : return NULL;
78 : }
79 :
80 39031 : static inline char *startswith_no_case(const char *s, const char *prefix) {
81 : size_t l;
82 :
83 39031 : l = strlen(prefix);
84 39031 : if (strncasecmp(s, prefix, l) == 0)
85 532 : return (char*) s + l;
86 :
87 38499 : 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 35903 : static inline char *skip_leading_chars(const char *s, const char *bad) {
137 :
138 35903 : if (!s)
139 0 : return NULL;
140 :
141 35903 : if (!bad)
142 0 : bad = WHITESPACE;
143 :
144 35903 : 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 36597 : static inline bool _pure_ in_charset(const char *s, const char* charset) {
160 36597 : assert(s);
161 36597 : assert(charset);
162 36597 : 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 96 : static inline char *ellipsize(const char *s, size_t length, unsigned percent) {
169 96 : 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 531618 : static inline size_t strlen_ptr(const char *s) {
202 531618 : if (!s)
203 166161 : return 0;
204 :
205 365457 : 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 213 : static inline void *memory_startswith(const void *p, size_t sz, const char *token) {
216 : size_t n;
217 :
218 213 : assert(token);
219 :
220 213 : n = strlen(token);
221 213 : if (sz < n)
222 79 : return NULL;
223 :
224 134 : assert(p);
225 :
226 134 : if (memcmp(p, token, n) != 0)
227 106 : return NULL;
228 :
229 28 : 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 19 : static inline void *memory_startswith_no_case(const void *p, size_t sz, const char *token) {
236 : size_t n, i;
237 :
238 19 : assert(token);
239 :
240 19 : n = strlen(token);
241 19 : if (sz < n)
242 1 : return NULL;
243 :
244 18 : assert(p);
245 :
246 44 : for (i = 0; i < n; i++) {
247 27 : if (ascii_tolower(((char *)p)[i]) != ascii_tolower(token[i]))
248 1 : return NULL;
249 : }
250 :
251 17 : return (uint8_t*) p + n;
252 : }
253 :
254 86 : static inline char* str_realloc(char **p) {
255 : /* Reallocate *p to actual size */
256 :
257 86 : if (!*p)
258 0 : return NULL;
259 :
260 86 : char *t = realloc(*p, strlen(*p) + 1);
261 86 : if (!t)
262 0 : return NULL;
263 :
264 86 : return (*p = t);
265 : }
|
