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