xref: /unit/src/nxt_string.h (revision 704:1fcac04f0a15)
1 
2 /*
3  * Copyright (C) Igor Sysoev
4  * Copyright (C) NGINX, Inc.
5  */
6 
7 #ifndef _NXT_STRING_H_INCLUDED_
8 #define _NXT_STRING_H_INCLUDED_
9 
10 
11 #define                                                                       \
12 nxt_lowcase(c)                                                                \
13     (u_char) ((c >= 'A' && c <= 'Z') ? c | 0x20 : c)
14 
15 #define                                                                       \
16 nxt_upcase(c)                                                                 \
17     (u_char) ((c >= 'a' && c <= 'z') ? c & ~0x20 : c)
18 
19 #define                                                                       \
20 nxt_isdigit(c)                                                                \
21     ((u_char) ((c) - '0') <= 9)
22 
23 
24 #define                                                                       \
25 nxt_strlen(s)                                                                 \
26     strlen((char *) s)
27 
28 
29 #define                                                                       \
30 nxt_memzero(buf, length)                                                      \
31     (void) memset(buf, 0, length)
32 
33 
34 #define                                                                       \
35 nxt_memset(buf, c, length)                                                    \
36     (void) memset(buf, c, length)
37 
38 
39 #define                                                                       \
40 nxt_memcpy(dst, src, length)                                                  \
41     (void) memcpy(dst, src, length)
42 
43 
44 NXT_EXPORT void nxt_memcpy_lowcase(u_char *dst, const u_char *src,
45     size_t length);
46 
47 
48 /*
49  * nxt_cpymem() is an inline function but not a macro to
50  * eliminate possible double evaluation of length "length".
51  */
52 nxt_inline void *
53 nxt_cpymem(void *dst, const void *src, size_t length)
54 {
55     return ((u_char *) memcpy(dst, src, length)) + length;
56 }
57 
58 
59 #define                                                                       \
60 nxt_memmove(dst, src, length)                                                 \
61     (void) memmove(dst, src, length)
62 
63 
64 #define                                                                       \
65 nxt_memcmp(s1, s2, length)                                                    \
66     memcmp((char *) s1, (char *) s2, length)
67 
68 
69 #define                                                                       \
70 nxt_memchr(s, c, length)                                                      \
71     memchr((char *) s, c, length)
72 
73 
74 #define                                                                       \
75 nxt_strcmp(s1, s2)                                                            \
76     strcmp((char *) s1, (char *) s2)
77 
78 
79 #define                                                                       \
80 nxt_strncmp(s1, s2, length)                                                   \
81     strncmp((char *) s1, (char *) s2, length)
82 
83 
84 NXT_EXPORT u_char *nxt_cpystrn(u_char *dst, const u_char *src, size_t length);
85 NXT_EXPORT nxt_int_t nxt_strcasecmp(const u_char *s1, const u_char *s2);
86 NXT_EXPORT nxt_int_t nxt_strncasecmp(const u_char *s1, const u_char *s2,
87     size_t length);
88 NXT_EXPORT nxt_int_t nxt_memcasecmp(const u_char *s1, const u_char *s2,
89     size_t length);
90 
91 NXT_EXPORT u_char *nxt_memstrn(const u_char *s, const u_char *end,
92     const char *ss, size_t length);
93 NXT_EXPORT u_char *nxt_memcasestrn(const u_char *s, const u_char *end,
94     const char *ss, size_t length);
95 NXT_EXPORT u_char *nxt_rmemstrn(const u_char *s, const u_char *end,
96     const char *ss, size_t length);
97 NXT_EXPORT size_t nxt_str_strip(u_char *start, u_char *end);
98 
99 
100 typedef struct {
101     size_t                    length;
102     u_char                    *start;
103 } nxt_str_t;
104 
105 
106 #define nxt_string(str)       { nxt_length(str), (u_char *) str }
107 #define nxt_string_zero(str)  { sizeof(str), (u_char *) str }
108 #define nxt_null_string       { 0, NULL }
109 
110 
111 #define                                                                       \
112 nxt_str_set(str, text)                                                        \
113     do {                                                                      \
114         (str)->length = nxt_length(text);                                     \
115         (str)->start = (u_char *) text;                                       \
116     } while (0)
117 
118 
119 #define                                                                       \
120 nxt_str_null(str)                                                             \
121     do {                                                                      \
122         (str)->length = 0;                                                    \
123         (str)->start = NULL;                                                  \
124     } while (0)
125 
126 
127 NXT_EXPORT nxt_str_t *nxt_str_alloc(nxt_mp_t *mp, size_t length);
128 NXT_EXPORT nxt_str_t *nxt_str_dup(nxt_mp_t *mp, nxt_str_t *dst,
129     const nxt_str_t *src);
130 NXT_EXPORT char *nxt_str_cstrz(nxt_mp_t *mp, const nxt_str_t *src);
131 
132 
133 #define                                                                       \
134 nxt_strstr_eq(s1, s2)                                                         \
135     (((s1)->length == (s2)->length)                                           \
136       && (nxt_memcmp((s1)->start, (s2)->start, (s1)->length) == 0))
137 
138 
139 #define                                                                       \
140 nxt_strcasestr_eq(s1, s2)                                                     \
141     (((s1)->length == (s2)->length)                                           \
142       && (nxt_memcasecmp((s1)->start, (s2)->start, (s1)->length) == 0))
143 
144 
145 #define                                                                       \
146 nxt_str_eq(s, p, _length)                                                     \
147     (((s)->length == _length) && (nxt_memcmp((s)->start, p, _length) == 0))
148 
149 
150 #define                                                                       \
151 nxt_str_start(s, p, _length)                                                  \
152     (((s)->length >= _length) && (nxt_memcmp((s)->start, p, _length) == 0))
153 
154 
155 #define                                                                       \
156 nxt_strchr_eq(s, c)                                                           \
157     (((s)->length == 1) && ((s)->start[0] == c))
158 
159 
160 #define                                                                       \
161 nxt_strchr_start(s, c)                                                        \
162     (((s)->length != 0) && ((s)->start[0] == c))
163 
164 
165 NXT_EXPORT nxt_int_t nxt_strverscmp(const u_char *s1, const u_char *s2);
166 NXT_EXPORT nxt_bool_t nxt_strvers_match(u_char *version, u_char *prefix,
167     size_t length);
168 
169 
170 #endif /* _NXT_STRING_H_INCLUDED_ */
171