container_of: don't put member_ptr in container_off.
[ccan] / ccan / str / str.h
1 /* Placed into the public domain. */
2 #ifndef CCAN_STR_H
3 #define CCAN_STR_H
4 #include "config.h"
5 #include <string.h>
6 #include <stdbool.h>
7 #include <ctype.h>
8
9 /**
10  * streq - Are two strings equal?
11  * @a: first string
12  * @b: first string
13  *
14  * This macro is arguably more readable than "!strcmp(a, b)".
15  *
16  * Example:
17  *      if (streq(somestring, ""))
18  *              printf("String is empty!\n");
19  */
20 #define streq(a,b) (strcmp((a),(b)) == 0)
21
22 /**
23  * strstarts - Does this string start with this prefix?
24  * @str: string to test
25  * @prefix: prefix to look for at start of str
26  *
27  * Example:
28  *      if (strstarts(somestring, "foo"))
29  *              printf("String %s begins with 'foo'!\n", somestring);
30  */
31 #define strstarts(str,prefix) (strncmp((str),(prefix),strlen(prefix)) == 0)
32
33 /**
34  * strends - Does this string end with this postfix?
35  * @str: string to test
36  * @postfix: postfix to look for at end of str
37  *
38  * Example:
39  *      if (strends(somestring, "foo"))
40  *              printf("String %s end with 'foo'!\n", somestring);
41  */
42 static inline bool strends(const char *str, const char *postfix)
43 {
44         if (strlen(str) < strlen(postfix))
45                 return false;
46
47         return streq(str + strlen(str) - strlen(postfix), postfix);
48 }
49
50 /**
51  * stringify - Turn expression into a string literal
52  * @expr: any C expression
53  *
54  * Example:
55  *      #define PRINT_COND_IF_FALSE(cond) \
56  *              ((cond) || printf("%s is false!", stringify(cond)))
57  */
58 #define stringify(expr)         stringify_1(expr)
59 /* Double-indirection required to stringify expansions */
60 #define stringify_1(expr)       #expr
61
62 /**
63  * strcount - Count number of (non-overlapping) occurrences of a substring.
64  * @haystack: a C string
65  * @needle: a substring
66  *
67  * Example:
68  *      int i;
69  *      i = strcount("aaa aaa", "a");  // i = 6;
70  *      i = strcount("aaa aaa", "ab"); // i = 0;
71  *      i = strcount("aaa aaa", "aa"); // i = 2;
72  */
73 size_t strcount(const char *haystack, const char *needle);
74
75 /**
76  * cisalnum - isalnum() which takes a char (and doesn't accept EOF)
77  * @c: a character
78  *
79  * Surprisingly, the standard ctype.h isalnum() takes an int, which
80  * must have the value of EOF (-1) or an unsigned char.  This variant
81  * takes a real char, and doesn't accept EOF.
82  */
83 static inline bool cisalnum(char c)
84 {
85         return isalnum((unsigned char)c);
86 }
87 static inline bool cisalpha(char c)
88 {
89         return isalpha((unsigned char)c);
90 }
91 static inline bool cisascii(char c)
92 {
93         return isascii((unsigned char)c);
94 }
95 #if HAVE_ISBLANK
96 static inline bool cisblank(char c)
97 {
98         return isblank((unsigned char)c);
99 }
100 #endif
101 static inline bool ciscntrl(char c)
102 {
103         return iscntrl((unsigned char)c);
104 }
105 static inline bool cisdigit(char c)
106 {
107         return isdigit((unsigned char)c);
108 }
109 static inline bool cisgraph(char c)
110 {
111         return isgraph((unsigned char)c);
112 }
113 static inline bool cislower(char c)
114 {
115         return islower((unsigned char)c);
116 }
117 static inline bool cisprint(char c)
118 {
119         return isprint((unsigned char)c);
120 }
121 static inline bool cispunct(char c)
122 {
123         return ispunct((unsigned char)c);
124 }
125 static inline bool cisspace(char c)
126 {
127         return isspace((unsigned char)c);
128 }
129 static inline bool cisupper(char c)
130 {
131         return isupper((unsigned char)c);
132 }
133 static inline bool cisxdigit(char c)
134 {
135         return isxdigit((unsigned char)c);
136 }
137
138 #include <ccan/str/str_debug.h>
139
140 /* These checks force things out of line, hence they are under DEBUG. */
141 #ifdef CCAN_STR_DEBUG
142 #include <ccan/build_assert/build_assert.h>
143
144 /* These are commonly misused: they take -1 or an *unsigned* char value. */
145 #undef isalnum
146 #undef isalpha
147 #undef isascii
148 #undef isblank
149 #undef iscntrl
150 #undef isdigit
151 #undef isgraph
152 #undef islower
153 #undef isprint
154 #undef ispunct
155 #undef isspace
156 #undef isupper
157 #undef isxdigit
158
159 /* You can use a char if char is unsigned. */
160 #if HAVE_BUILTIN_TYPES_COMPATIBLE_P && HAVE_TYPEOF
161 #define str_check_arg_(i)                                               \
162         ((i) + BUILD_ASSERT_OR_ZERO(!__builtin_types_compatible_p(typeof(i), \
163                                                                   char) \
164                                     || (char)255 > 0))
165 #else
166 #define str_check_arg_(i) (i)
167 #endif
168
169 #define isalnum(i) str_isalnum(str_check_arg_(i))
170 #define isalpha(i) str_isalpha(str_check_arg_(i))
171 #define isascii(i) str_isascii(str_check_arg_(i))
172 #if HAVE_ISBLANK
173 #define isblank(i) str_isblank(str_check_arg_(i))
174 #endif
175 #define iscntrl(i) str_iscntrl(str_check_arg_(i))
176 #define isdigit(i) str_isdigit(str_check_arg_(i))
177 #define isgraph(i) str_isgraph(str_check_arg_(i))
178 #define islower(i) str_islower(str_check_arg_(i))
179 #define isprint(i) str_isprint(str_check_arg_(i))
180 #define ispunct(i) str_ispunct(str_check_arg_(i))
181 #define isspace(i) str_isspace(str_check_arg_(i))
182 #define isupper(i) str_isupper(str_check_arg_(i))
183 #define isxdigit(i) str_isxdigit(str_check_arg_(i))
184
185 #if HAVE_TYPEOF
186 /* With GNU magic, we can make const-respecting standard string functions. */
187 #undef strstr
188 #undef strchr
189 #undef strrchr
190
191 /* + 0 is needed to decay array into pointer. */
192 #define strstr(haystack, needle)                                        \
193         ((typeof((haystack) + 0))str_strstr((haystack), (needle)))
194 #define strchr(haystack, c)                                     \
195         ((typeof((haystack) + 0))str_strchr((haystack), (c)))
196 #define strrchr(haystack, c)                                    \
197         ((typeof((haystack) + 0))str_strrchr((haystack), (c)))
198 #endif
199 #endif /* CCAN_STR_DEBUG */
200
201 #endif /* CCAN_STR_H */