1 #include "Python.h"
2 #include "bytes_methods.h"
3
4 PyDoc_STRVAR_shared(_Py_isspace__doc__,
5 "B.isspace() -> bool\n\
6 \n\
7 Return True if all characters in B are whitespace\n\
8 and there is at least one character in B, False otherwise.");
9
10 PyObject*
_Py_bytes_isspace(const char * cptr,Py_ssize_t len)11 _Py_bytes_isspace(const char *cptr, Py_ssize_t len)
12 {
13 register const unsigned char *p
14 = (unsigned char *) cptr;
15 register const unsigned char *e;
16
17 /* Shortcut for single character strings */
18 if (len == 1 && Py_ISSPACE(*p))
19 Py_RETURN_TRUE;
20
21 /* Special case for empty strings */
22 if (len == 0)
23 Py_RETURN_FALSE;
24
25 e = p + len;
26 for (; p < e; p++) {
27 if (!Py_ISSPACE(*p))
28 Py_RETURN_FALSE;
29 }
30 Py_RETURN_TRUE;
31 }
32
33
34 PyDoc_STRVAR_shared(_Py_isalpha__doc__,
35 "B.isalpha() -> bool\n\
36 \n\
37 Return True if all characters in B are alphabetic\n\
38 and there is at least one character in B, False otherwise.");
39
40 PyObject*
_Py_bytes_isalpha(const char * cptr,Py_ssize_t len)41 _Py_bytes_isalpha(const char *cptr, Py_ssize_t len)
42 {
43 register const unsigned char *p
44 = (unsigned char *) cptr;
45 register const unsigned char *e;
46
47 /* Shortcut for single character strings */
48 if (len == 1 && Py_ISALPHA(*p))
49 Py_RETURN_TRUE;
50
51 /* Special case for empty strings */
52 if (len == 0)
53 Py_RETURN_FALSE;
54
55 e = p + len;
56 for (; p < e; p++) {
57 if (!Py_ISALPHA(*p))
58 Py_RETURN_FALSE;
59 }
60 Py_RETURN_TRUE;
61 }
62
63
64 PyDoc_STRVAR_shared(_Py_isalnum__doc__,
65 "B.isalnum() -> bool\n\
66 \n\
67 Return True if all characters in B are alphanumeric\n\
68 and there is at least one character in B, False otherwise.");
69
70 PyObject*
_Py_bytes_isalnum(const char * cptr,Py_ssize_t len)71 _Py_bytes_isalnum(const char *cptr, Py_ssize_t len)
72 {
73 register const unsigned char *p
74 = (unsigned char *) cptr;
75 register const unsigned char *e;
76
77 /* Shortcut for single character strings */
78 if (len == 1 && Py_ISALNUM(*p))
79 Py_RETURN_TRUE;
80
81 /* Special case for empty strings */
82 if (len == 0)
83 Py_RETURN_FALSE;
84
85 e = p + len;
86 for (; p < e; p++) {
87 if (!Py_ISALNUM(*p))
88 Py_RETURN_FALSE;
89 }
90 Py_RETURN_TRUE;
91 }
92
93
94 PyDoc_STRVAR_shared(_Py_isdigit__doc__,
95 "B.isdigit() -> bool\n\
96 \n\
97 Return True if all characters in B are digits\n\
98 and there is at least one character in B, False otherwise.");
99
100 PyObject*
_Py_bytes_isdigit(const char * cptr,Py_ssize_t len)101 _Py_bytes_isdigit(const char *cptr, Py_ssize_t len)
102 {
103 register const unsigned char *p
104 = (unsigned char *) cptr;
105 register const unsigned char *e;
106
107 /* Shortcut for single character strings */
108 if (len == 1 && Py_ISDIGIT(*p))
109 Py_RETURN_TRUE;
110
111 /* Special case for empty strings */
112 if (len == 0)
113 Py_RETURN_FALSE;
114
115 e = p + len;
116 for (; p < e; p++) {
117 if (!Py_ISDIGIT(*p))
118 Py_RETURN_FALSE;
119 }
120 Py_RETURN_TRUE;
121 }
122
123
124 PyDoc_STRVAR_shared(_Py_islower__doc__,
125 "B.islower() -> bool\n\
126 \n\
127 Return True if all cased characters in B are lowercase and there is\n\
128 at least one cased character in B, False otherwise.");
129
130 PyObject*
_Py_bytes_islower(const char * cptr,Py_ssize_t len)131 _Py_bytes_islower(const char *cptr, Py_ssize_t len)
132 {
133 register const unsigned char *p
134 = (unsigned char *) cptr;
135 register const unsigned char *e;
136 int cased;
137
138 /* Shortcut for single character strings */
139 if (len == 1)
140 return PyBool_FromLong(Py_ISLOWER(*p));
141
142 /* Special case for empty strings */
143 if (len == 0)
144 Py_RETURN_FALSE;
145
146 e = p + len;
147 cased = 0;
148 for (; p < e; p++) {
149 if (Py_ISUPPER(*p))
150 Py_RETURN_FALSE;
151 else if (!cased && Py_ISLOWER(*p))
152 cased = 1;
153 }
154 return PyBool_FromLong(cased);
155 }
156
157
158 PyDoc_STRVAR_shared(_Py_isupper__doc__,
159 "B.isupper() -> bool\n\
160 \n\
161 Return True if all cased characters in B are uppercase and there is\n\
162 at least one cased character in B, False otherwise.");
163
164 PyObject*
_Py_bytes_isupper(const char * cptr,Py_ssize_t len)165 _Py_bytes_isupper(const char *cptr, Py_ssize_t len)
166 {
167 register const unsigned char *p
168 = (unsigned char *) cptr;
169 register const unsigned char *e;
170 int cased;
171
172 /* Shortcut for single character strings */
173 if (len == 1)
174 return PyBool_FromLong(Py_ISUPPER(*p));
175
176 /* Special case for empty strings */
177 if (len == 0)
178 Py_RETURN_FALSE;
179
180 e = p + len;
181 cased = 0;
182 for (; p < e; p++) {
183 if (Py_ISLOWER(*p))
184 Py_RETURN_FALSE;
185 else if (!cased && Py_ISUPPER(*p))
186 cased = 1;
187 }
188 return PyBool_FromLong(cased);
189 }
190
191
192 PyDoc_STRVAR_shared(_Py_istitle__doc__,
193 "B.istitle() -> bool\n\
194 \n\
195 Return True if B is a titlecased string and there is at least one\n\
196 character in B, i.e. uppercase characters may only follow uncased\n\
197 characters and lowercase characters only cased ones. Return False\n\
198 otherwise.");
199
200 PyObject*
_Py_bytes_istitle(const char * cptr,Py_ssize_t len)201 _Py_bytes_istitle(const char *cptr, Py_ssize_t len)
202 {
203 register const unsigned char *p
204 = (unsigned char *) cptr;
205 register const unsigned char *e;
206 int cased, previous_is_cased;
207
208 /* Shortcut for single character strings */
209 if (len == 1)
210 return PyBool_FromLong(Py_ISUPPER(*p));
211
212 /* Special case for empty strings */
213 if (len == 0)
214 Py_RETURN_FALSE;
215
216 e = p + len;
217 cased = 0;
218 previous_is_cased = 0;
219 for (; p < e; p++) {
220 register const unsigned char ch = *p;
221
222 if (Py_ISUPPER(ch)) {
223 if (previous_is_cased)
224 Py_RETURN_FALSE;
225 previous_is_cased = 1;
226 cased = 1;
227 }
228 else if (Py_ISLOWER(ch)) {
229 if (!previous_is_cased)
230 Py_RETURN_FALSE;
231 previous_is_cased = 1;
232 cased = 1;
233 }
234 else
235 previous_is_cased = 0;
236 }
237 return PyBool_FromLong(cased);
238 }
239
240
241 PyDoc_STRVAR_shared(_Py_lower__doc__,
242 "B.lower() -> copy of B\n\
243 \n\
244 Return a copy of B with all ASCII characters converted to lowercase.");
245
246 void
_Py_bytes_lower(char * result,const char * cptr,Py_ssize_t len)247 _Py_bytes_lower(char *result, const char *cptr, Py_ssize_t len)
248 {
249 Py_ssize_t i;
250
251 /*
252 newobj = PyString_FromStringAndSize(NULL, len);
253 if (!newobj)
254 return NULL;
255
256 s = PyString_AS_STRING(newobj);
257 */
258
259 Py_MEMCPY(result, cptr, len);
260
261 for (i = 0; i < len; i++) {
262 int c = Py_CHARMASK(result[i]);
263 if (Py_ISUPPER(c))
264 result[i] = Py_TOLOWER(c);
265 }
266 }
267
268
269 PyDoc_STRVAR_shared(_Py_upper__doc__,
270 "B.upper() -> copy of B\n\
271 \n\
272 Return a copy of B with all ASCII characters converted to uppercase.");
273
274 void
_Py_bytes_upper(char * result,const char * cptr,Py_ssize_t len)275 _Py_bytes_upper(char *result, const char *cptr, Py_ssize_t len)
276 {
277 Py_ssize_t i;
278
279 /*
280 newobj = PyString_FromStringAndSize(NULL, len);
281 if (!newobj)
282 return NULL;
283
284 s = PyString_AS_STRING(newobj);
285 */
286
287 Py_MEMCPY(result, cptr, len);
288
289 for (i = 0; i < len; i++) {
290 int c = Py_CHARMASK(result[i]);
291 if (Py_ISLOWER(c))
292 result[i] = Py_TOUPPER(c);
293 }
294 }
295
296
297 PyDoc_STRVAR_shared(_Py_title__doc__,
298 "B.title() -> copy of B\n\
299 \n\
300 Return a titlecased version of B, i.e. ASCII words start with uppercase\n\
301 characters, all remaining cased characters have lowercase.");
302
303 void
_Py_bytes_title(char * result,char * s,Py_ssize_t len)304 _Py_bytes_title(char *result, char *s, Py_ssize_t len)
305 {
306 Py_ssize_t i;
307 int previous_is_cased = 0;
308
309 /*
310 newobj = PyString_FromStringAndSize(NULL, len);
311 if (newobj == NULL)
312 return NULL;
313 s_new = PyString_AsString(newobj);
314 */
315 for (i = 0; i < len; i++) {
316 int c = Py_CHARMASK(*s++);
317 if (Py_ISLOWER(c)) {
318 if (!previous_is_cased)
319 c = Py_TOUPPER(c);
320 previous_is_cased = 1;
321 } else if (Py_ISUPPER(c)) {
322 if (previous_is_cased)
323 c = Py_TOLOWER(c);
324 previous_is_cased = 1;
325 } else
326 previous_is_cased = 0;
327 *result++ = c;
328 }
329 }
330
331
332 PyDoc_STRVAR_shared(_Py_capitalize__doc__,
333 "B.capitalize() -> copy of B\n\
334 \n\
335 Return a copy of B with only its first character capitalized (ASCII)\n\
336 and the rest lower-cased.");
337
338 void
_Py_bytes_capitalize(char * result,char * s,Py_ssize_t len)339 _Py_bytes_capitalize(char *result, char *s, Py_ssize_t len)
340 {
341 Py_ssize_t i;
342
343 /*
344 newobj = PyString_FromStringAndSize(NULL, len);
345 if (newobj == NULL)
346 return NULL;
347 s_new = PyString_AsString(newobj);
348 */
349 if (0 < len) {
350 int c = Py_CHARMASK(*s++);
351 if (Py_ISLOWER(c))
352 *result = Py_TOUPPER(c);
353 else
354 *result = c;
355 result++;
356 }
357 for (i = 1; i < len; i++) {
358 int c = Py_CHARMASK(*s++);
359 if (Py_ISUPPER(c))
360 *result = Py_TOLOWER(c);
361 else
362 *result = c;
363 result++;
364 }
365 }
366
367
368 PyDoc_STRVAR_shared(_Py_swapcase__doc__,
369 "B.swapcase() -> copy of B\n\
370 \n\
371 Return a copy of B with uppercase ASCII characters converted\n\
372 to lowercase ASCII and vice versa.");
373
374 void
_Py_bytes_swapcase(char * result,char * s,Py_ssize_t len)375 _Py_bytes_swapcase(char *result, char *s, Py_ssize_t len)
376 {
377 Py_ssize_t i;
378
379 /*
380 newobj = PyString_FromStringAndSize(NULL, len);
381 if (newobj == NULL)
382 return NULL;
383 s_new = PyString_AsString(newobj);
384 */
385 for (i = 0; i < len; i++) {
386 int c = Py_CHARMASK(*s++);
387 if (Py_ISLOWER(c)) {
388 *result = Py_TOUPPER(c);
389 }
390 else if (Py_ISUPPER(c)) {
391 *result = Py_TOLOWER(c);
392 }
393 else
394 *result = c;
395 result++;
396 }
397 }
398
399