No issues found
1 /* strop module */
2
3 #define PY_SSIZE_T_CLEAN
4 #include "Python.h"
5 #include <ctype.h>
6
7 PyDoc_STRVAR(strop_module__doc__,
8 "Common string manipulations, optimized for speed.\n"
9 "\n"
10 "Always use \"import string\" rather than referencing\n"
11 "this module directly.");
12
13 /* XXX This file assumes that the <ctype.h> is*() functions
14 XXX are defined for all 8-bit characters! */
15
16 #define WARN if (PyErr_Warn(PyExc_DeprecationWarning, \
17 "strop functions are obsolete; use string methods")) \
18 return NULL
19
20 /* The lstrip(), rstrip() and strip() functions are implemented
21 in do_strip(), which uses an additional parameter to indicate what
22 type of strip should occur. */
23
24 #define LEFTSTRIP 0
25 #define RIGHTSTRIP 1
26 #define BOTHSTRIP 2
27
28
29 static PyObject *
30 split_whitespace(char *s, Py_ssize_t len, Py_ssize_t maxsplit)
31 {
32 Py_ssize_t i = 0, j;
33 int err;
34 Py_ssize_t countsplit = 0;
35 PyObject* item;
36 PyObject *list = PyList_New(0);
37
38 if (list == NULL)
39 return NULL;
40
41 while (i < len) {
42 while (i < len && isspace(Py_CHARMASK(s[i]))) {
43 i = i+1;
44 }
45 j = i;
46 while (i < len && !isspace(Py_CHARMASK(s[i]))) {
47 i = i+1;
48 }
49 if (j < i) {
50 item = PyString_FromStringAndSize(s+j, i-j);
51 if (item == NULL)
52 goto finally;
53
54 err = PyList_Append(list, item);
55 Py_DECREF(item);
56 if (err < 0)
57 goto finally;
58
59 countsplit++;
60 while (i < len && isspace(Py_CHARMASK(s[i]))) {
61 i = i+1;
62 }
63 if (maxsplit && (countsplit >= maxsplit) && i < len) {
64 item = PyString_FromStringAndSize(
65 s+i, len - i);
66 if (item == NULL)
67 goto finally;
68
69 err = PyList_Append(list, item);
70 Py_DECREF(item);
71 if (err < 0)
72 goto finally;
73
74 i = len;
75 }
76 }
77 }
78 return list;
79 finally:
80 Py_DECREF(list);
81 return NULL;
82 }
83
84
85 PyDoc_STRVAR(splitfields__doc__,
86 "split(s [,sep [,maxsplit]]) -> list of strings\n"
87 "splitfields(s [,sep [,maxsplit]]) -> list of strings\n"
88 "\n"
89 "Return a list of the words in the string s, using sep as the\n"
90 "delimiter string. If maxsplit is nonzero, splits into at most\n"
91 "maxsplit words. If sep is not specified, any whitespace string\n"
92 "is a separator. Maxsplit defaults to 0.\n"
93 "\n"
94 "(split and splitfields are synonymous)");
95
96 static PyObject *
97 strop_splitfields(PyObject *self, PyObject *args)
98 {
99 Py_ssize_t len, n, i, j, err;
100 Py_ssize_t splitcount, maxsplit;
101 char *s, *sub;
102 PyObject *list, *item;
103
104 WARN;
105 sub = NULL;
106 n = 0;
107 splitcount = 0;
108 maxsplit = 0;
109 if (!PyArg_ParseTuple(args, "t#|z#n:split", &s, &len, &sub, &n, &maxsplit))
110 return NULL;
111 if (sub == NULL)
112 return split_whitespace(s, len, maxsplit);
113 if (n == 0) {
114 PyErr_SetString(PyExc_ValueError, "empty separator");
115 return NULL;
116 }
117
118 list = PyList_New(0);
119 if (list == NULL)
120 return NULL;
121
122 i = j = 0;
123 while (i+n <= len) {
124 if (s[i] == sub[0] && (n == 1 || memcmp(s+i, sub, n) == 0)) {
125 item = PyString_FromStringAndSize(s+j, i-j);
126 if (item == NULL)
127 goto fail;
128 err = PyList_Append(list, item);
129 Py_DECREF(item);
130 if (err < 0)
131 goto fail;
132 i = j = i + n;
133 splitcount++;
134 if (maxsplit && (splitcount >= maxsplit))
135 break;
136 }
137 else
138 i++;
139 }
140 item = PyString_FromStringAndSize(s+j, len-j);
141 if (item == NULL)
142 goto fail;
143 err = PyList_Append(list, item);
144 Py_DECREF(item);
145 if (err < 0)
146 goto fail;
147
148 return list;
149
150 fail:
151 Py_DECREF(list);
152 return NULL;
153 }
154
155
156 PyDoc_STRVAR(joinfields__doc__,
157 "join(list [,sep]) -> string\n"
158 "joinfields(list [,sep]) -> string\n"
159 "\n"
160 "Return a string composed of the words in list, with\n"
161 "intervening occurrences of sep. Sep defaults to a single\n"
162 "space.\n"
163 "\n"
164 "(join and joinfields are synonymous)");
165
166 static PyObject *
167 strop_joinfields(PyObject *self, PyObject *args)
168 {
169 PyObject *seq;
170 char *sep = NULL;
171 Py_ssize_t seqlen, seplen = 0;
172 Py_ssize_t i, reslen = 0, slen = 0, sz = 100;
173 PyObject *res = NULL;
174 char* p = NULL;
175 ssizeargfunc getitemfunc;
176
177 WARN;
178 if (!PyArg_ParseTuple(args, "O|t#:join", &seq, &sep, &seplen))
179 return NULL;
180 if (sep == NULL) {
181 sep = " ";
182 seplen = 1;
183 }
184
185 seqlen = PySequence_Size(seq);
186 if (seqlen < 0 && PyErr_Occurred())
187 return NULL;
188
189 if (seqlen == 1) {
190 /* Optimization if there's only one item */
191 PyObject *item = PySequence_GetItem(seq, 0);
192 if (item && !PyString_Check(item)) {
193 PyErr_SetString(PyExc_TypeError,
194 "first argument must be sequence of strings");
195 Py_DECREF(item);
196 return NULL;
197 }
198 return item;
199 }
200
201 if (!(res = PyString_FromStringAndSize((char*)NULL, sz)))
202 return NULL;
203 p = PyString_AsString(res);
204
205 /* optimize for lists, since it's the most common case. all others
206 * (tuples and arbitrary sequences) just use the sequence abstract
207 * interface.
208 */
209 if (PyList_Check(seq)) {
210 for (i = 0; i < seqlen; i++) {
211 PyObject *item = PyList_GET_ITEM(seq, i);
212 if (!PyString_Check(item)) {
213 PyErr_SetString(PyExc_TypeError,
214 "first argument must be sequence of strings");
215 Py_DECREF(res);
216 return NULL;
217 }
218 slen = PyString_GET_SIZE(item);
219 if (slen > PY_SSIZE_T_MAX - reslen ||
220 seplen > PY_SSIZE_T_MAX - reslen - seplen) {
221 PyErr_SetString(PyExc_OverflowError,
222 "input too long");
223 Py_DECREF(res);
224 return NULL;
225 }
226 while (reslen + slen + seplen >= sz) {
227 if (_PyString_Resize(&res, sz * 2) < 0)
228 return NULL;
229 sz *= 2;
230 p = PyString_AsString(res) + reslen;
231 }
232 if (i > 0) {
233 memcpy(p, sep, seplen);
234 p += seplen;
235 reslen += seplen;
236 }
237 memcpy(p, PyString_AS_STRING(item), slen);
238 p += slen;
239 reslen += slen;
240 }
241 _PyString_Resize(&res, reslen);
242 return res;
243 }
244
245 if (seq->ob_type->tp_as_sequence == NULL ||
246 (getitemfunc = seq->ob_type->tp_as_sequence->sq_item) == NULL)
247 {
248 PyErr_SetString(PyExc_TypeError,
249 "first argument must be a sequence");
250 return NULL;
251 }
252 /* This is now type safe */
253 for (i = 0; i < seqlen; i++) {
254 PyObject *item = getitemfunc(seq, i);
255 if (!item || !PyString_Check(item)) {
256 PyErr_SetString(PyExc_TypeError,
257 "first argument must be sequence of strings");
258 Py_DECREF(res);
259 Py_XDECREF(item);
260 return NULL;
261 }
262 slen = PyString_GET_SIZE(item);
263 if (slen > PY_SSIZE_T_MAX - reslen ||
264 seplen > PY_SSIZE_T_MAX - reslen - seplen) {
265 PyErr_SetString(PyExc_OverflowError,
266 "input too long");
267 Py_DECREF(res);
268 Py_XDECREF(item);
269 return NULL;
270 }
271 while (reslen + slen + seplen >= sz) {
272 if (_PyString_Resize(&res, sz * 2) < 0) {
273 Py_DECREF(item);
274 return NULL;
275 }
276 sz *= 2;
277 p = PyString_AsString(res) + reslen;
278 }
279 if (i > 0) {
280 memcpy(p, sep, seplen);
281 p += seplen;
282 reslen += seplen;
283 }
284 memcpy(p, PyString_AS_STRING(item), slen);
285 p += slen;
286 reslen += slen;
287 Py_DECREF(item);
288 }
289 _PyString_Resize(&res, reslen);
290 return res;
291 }
292
293
294 PyDoc_STRVAR(find__doc__,
295 "find(s, sub [,start [,end]]) -> in\n"
296 "\n"
297 "Return the lowest index in s where substring sub is found,\n"
298 "such that sub is contained within s[start,end]. Optional\n"
299 "arguments start and end are interpreted as in slice notation.\n"
300 "\n"
301 "Return -1 on failure.");
302
303 static PyObject *
304 strop_find(PyObject *self, PyObject *args)
305 {
306 char *s, *sub;
307 Py_ssize_t len, n, i = 0, last = PY_SSIZE_T_MAX;
308
309 WARN;
310 if (!PyArg_ParseTuple(args, "t#t#|nn:find", &s, &len, &sub, &n, &i, &last))
311 return NULL;
312
313 if (last > len)
314 last = len;
315 if (last < 0)
316 last += len;
317 if (last < 0)
318 last = 0;
319 if (i < 0)
320 i += len;
321 if (i < 0)
322 i = 0;
323
324 if (n == 0 && i <= last)
325 return PyInt_FromLong((long)i);
326
327 last -= n;
328 for (; i <= last; ++i)
329 if (s[i] == sub[0] &&
330 (n == 1 || memcmp(&s[i+1], &sub[1], n-1) == 0))
331 return PyInt_FromLong((long)i);
332
333 return PyInt_FromLong(-1L);
334 }
335
336
337 PyDoc_STRVAR(rfind__doc__,
338 "rfind(s, sub [,start [,end]]) -> int\n"
339 "\n"
340 "Return the highest index in s where substring sub is found,\n"
341 "such that sub is contained within s[start,end]. Optional\n"
342 "arguments start and end are interpreted as in slice notation.\n"
343 "\n"
344 "Return -1 on failure.");
345
346 static PyObject *
347 strop_rfind(PyObject *self, PyObject *args)
348 {
349 char *s, *sub;
350 Py_ssize_t len, n, j;
351 Py_ssize_t i = 0, last = PY_SSIZE_T_MAX;
352
353 WARN;
354 if (!PyArg_ParseTuple(args, "t#t#|nn:rfind", &s, &len, &sub, &n, &i, &last))
355 return NULL;
356
357 if (last > len)
358 last = len;
359 if (last < 0)
360 last += len;
361 if (last < 0)
362 last = 0;
363 if (i < 0)
364 i += len;
365 if (i < 0)
366 i = 0;
367
368 if (n == 0 && i <= last)
369 return PyInt_FromLong((long)last);
370
371 for (j = last-n; j >= i; --j)
372 if (s[j] == sub[0] &&
373 (n == 1 || memcmp(&s[j+1], &sub[1], n-1) == 0))
374 return PyInt_FromLong((long)j);
375
376 return PyInt_FromLong(-1L);
377 }
378
379
380 static PyObject *
381 do_strip(PyObject *args, int striptype)
382 {
383 char *s;
384 Py_ssize_t len, i, j;
385
386
387 if (PyString_AsStringAndSize(args, &s, &len))
388 return NULL;
389
390 i = 0;
391 if (striptype != RIGHTSTRIP) {
392 while (i < len && isspace(Py_CHARMASK(s[i]))) {
393 i++;
394 }
395 }
396
397 j = len;
398 if (striptype != LEFTSTRIP) {
399 do {
400 j--;
401 } while (j >= i && isspace(Py_CHARMASK(s[j])));
402 j++;
403 }
404
405 if (i == 0 && j == len) {
406 Py_INCREF(args);
407 return args;
408 }
409 else
410 return PyString_FromStringAndSize(s+i, j-i);
411 }
412
413
414 PyDoc_STRVAR(strip__doc__,
415 "strip(s) -> string\n"
416 "\n"
417 "Return a copy of the string s with leading and trailing\n"
418 "whitespace removed.");
419
420 static PyObject *
421 strop_strip(PyObject *self, PyObject *args)
422 {
423 WARN;
424 return do_strip(args, BOTHSTRIP);
425 }
426
427
428 PyDoc_STRVAR(lstrip__doc__,
429 "lstrip(s) -> string\n"
430 "\n"
431 "Return a copy of the string s with leading whitespace removed.");
432
433 static PyObject *
434 strop_lstrip(PyObject *self, PyObject *args)
435 {
436 WARN;
437 return do_strip(args, LEFTSTRIP);
438 }
439
440
441 PyDoc_STRVAR(rstrip__doc__,
442 "rstrip(s) -> string\n"
443 "\n"
444 "Return a copy of the string s with trailing whitespace removed.");
445
446 static PyObject *
447 strop_rstrip(PyObject *self, PyObject *args)
448 {
449 WARN;
450 return do_strip(args, RIGHTSTRIP);
451 }
452
453
454 PyDoc_STRVAR(lower__doc__,
455 "lower(s) -> string\n"
456 "\n"
457 "Return a copy of the string s converted to lowercase.");
458
459 static PyObject *
460 strop_lower(PyObject *self, PyObject *args)
461 {
462 char *s, *s_new;
463 Py_ssize_t i, n;
464 PyObject *newstr;
465 int changed;
466
467 WARN;
468 if (PyString_AsStringAndSize(args, &s, &n))
469 return NULL;
470 newstr = PyString_FromStringAndSize(NULL, n);
471 if (newstr == NULL)
472 return NULL;
473 s_new = PyString_AsString(newstr);
474 changed = 0;
475 for (i = 0; i < n; i++) {
476 int c = Py_CHARMASK(*s++);
477 if (isupper(c)) {
478 changed = 1;
479 *s_new = tolower(c);
480 } else
481 *s_new = c;
482 s_new++;
483 }
484 if (!changed) {
485 Py_DECREF(newstr);
486 Py_INCREF(args);
487 return args;
488 }
489 return newstr;
490 }
491
492
493 PyDoc_STRVAR(upper__doc__,
494 "upper(s) -> string\n"
495 "\n"
496 "Return a copy of the string s converted to uppercase.");
497
498 static PyObject *
499 strop_upper(PyObject *self, PyObject *args)
500 {
501 char *s, *s_new;
502 Py_ssize_t i, n;
503 PyObject *newstr;
504 int changed;
505
506 WARN;
507 if (PyString_AsStringAndSize(args, &s, &n))
508 return NULL;
509 newstr = PyString_FromStringAndSize(NULL, n);
510 if (newstr == NULL)
511 return NULL;
512 s_new = PyString_AsString(newstr);
513 changed = 0;
514 for (i = 0; i < n; i++) {
515 int c = Py_CHARMASK(*s++);
516 if (islower(c)) {
517 changed = 1;
518 *s_new = toupper(c);
519 } else
520 *s_new = c;
521 s_new++;
522 }
523 if (!changed) {
524 Py_DECREF(newstr);
525 Py_INCREF(args);
526 return args;
527 }
528 return newstr;
529 }
530
531
532 PyDoc_STRVAR(capitalize__doc__,
533 "capitalize(s) -> string\n"
534 "\n"
535 "Return a copy of the string s with only its first character\n"
536 "capitalized.");
537
538 static PyObject *
539 strop_capitalize(PyObject *self, PyObject *args)
540 {
541 char *s, *s_new;
542 Py_ssize_t i, n;
543 PyObject *newstr;
544 int changed;
545
546 WARN;
547 if (PyString_AsStringAndSize(args, &s, &n))
548 return NULL;
549 newstr = PyString_FromStringAndSize(NULL, n);
550 if (newstr == NULL)
551 return NULL;
552 s_new = PyString_AsString(newstr);
553 changed = 0;
554 if (0 < n) {
555 int c = Py_CHARMASK(*s++);
556 if (islower(c)) {
557 changed = 1;
558 *s_new = toupper(c);
559 } else
560 *s_new = c;
561 s_new++;
562 }
563 for (i = 1; i < n; i++) {
564 int c = Py_CHARMASK(*s++);
565 if (isupper(c)) {
566 changed = 1;
567 *s_new = tolower(c);
568 } else
569 *s_new = c;
570 s_new++;
571 }
572 if (!changed) {
573 Py_DECREF(newstr);
574 Py_INCREF(args);
575 return args;
576 }
577 return newstr;
578 }
579
580
581 PyDoc_STRVAR(expandtabs__doc__,
582 "expandtabs(string, [tabsize]) -> string\n"
583 "\n"
584 "Expand tabs in a string, i.e. replace them by one or more spaces,\n"
585 "depending on the current column and the given tab size (default 8).\n"
586 "The column number is reset to zero after each newline occurring in the\n"
587 "string. This doesn't understand other non-printing characters.");
588
589 static PyObject *
590 strop_expandtabs(PyObject *self, PyObject *args)
591 {
592 /* Original by Fredrik Lundh */
593 char* e;
594 char* p;
595 char* q;
596 Py_ssize_t i, j, old_j;
597 PyObject* out;
598 char* string;
599 Py_ssize_t stringlen;
600 int tabsize = 8;
601
602 WARN;
603 /* Get arguments */
604 if (!PyArg_ParseTuple(args, "s#|i:expandtabs", &string, &stringlen, &tabsize))
605 return NULL;
606 if (tabsize < 1) {
607 PyErr_SetString(PyExc_ValueError,
608 "tabsize must be at least 1");
609 return NULL;
610 }
611
612 /* First pass: determine size of output string */
613 i = j = old_j = 0; /* j: current column; i: total of previous lines */
614 e = string + stringlen;
615 for (p = string; p < e; p++) {
616 if (*p == '\t') {
617 j += tabsize - (j%tabsize);
618 if (old_j > j) {
619 PyErr_SetString(PyExc_OverflowError,
620 "new string is too long");
621 return NULL;
622 }
623 old_j = j;
624 } else {
625 j++;
626 if (*p == '\n') {
627 i += j;
628 j = 0;
629 }
630 }
631 }
632
633 if ((i + j) < 0) {
634 PyErr_SetString(PyExc_OverflowError, "new string is too long");
635 return NULL;
636 }
637
638 /* Second pass: create output string and fill it */
639 out = PyString_FromStringAndSize(NULL, i+j);
640 if (out == NULL)
641 return NULL;
642
643 i = 0;
644 q = PyString_AS_STRING(out);
645
646 for (p = string; p < e; p++) {
647 if (*p == '\t') {
648 j = tabsize - (i%tabsize);
649 i += j;
650 while (j-- > 0)
651 *q++ = ' ';
652 } else {
653 *q++ = *p;
654 i++;
655 if (*p == '\n')
656 i = 0;
657 }
658 }
659
660 return out;
661 }
662
663
664 PyDoc_STRVAR(count__doc__,
665 "count(s, sub[, start[, end]]) -> int\n"
666 "\n"
667 "Return the number of occurrences of substring sub in string\n"
668 "s[start:end]. Optional arguments start and end are\n"
669 "interpreted as in slice notation.");
670
671 static PyObject *
672 strop_count(PyObject *self, PyObject *args)
673 {
674 char *s, *sub;
675 Py_ssize_t len, n;
676 Py_ssize_t i = 0, last = PY_SSIZE_T_MAX;
677 Py_ssize_t m, r;
678
679 WARN;
680 if (!PyArg_ParseTuple(args, "t#t#|nn:count", &s, &len, &sub, &n, &i, &last))
681 return NULL;
682 if (last > len)
683 last = len;
684 if (last < 0)
685 last += len;
686 if (last < 0)
687 last = 0;
688 if (i < 0)
689 i += len;
690 if (i < 0)
691 i = 0;
692 m = last + 1 - n;
693 if (n == 0)
694 return PyInt_FromLong((long) (m-i));
695
696 r = 0;
697 while (i < m) {
698 if (!memcmp(s+i, sub, n)) {
699 r++;
700 i += n;
701 } else {
702 i++;
703 }
704 }
705 return PyInt_FromLong((long) r);
706 }
707
708
709 PyDoc_STRVAR(swapcase__doc__,
710 "swapcase(s) -> string\n"
711 "\n"
712 "Return a copy of the string s with upper case characters\n"
713 "converted to lowercase and vice versa.");
714
715 static PyObject *
716 strop_swapcase(PyObject *self, PyObject *args)
717 {
718 char *s, *s_new;
719 Py_ssize_t i, n;
720 PyObject *newstr;
721 int changed;
722
723 WARN;
724 if (PyString_AsStringAndSize(args, &s, &n))
725 return NULL;
726 newstr = PyString_FromStringAndSize(NULL, n);
727 if (newstr == NULL)
728 return NULL;
729 s_new = PyString_AsString(newstr);
730 changed = 0;
731 for (i = 0; i < n; i++) {
732 int c = Py_CHARMASK(*s++);
733 if (islower(c)) {
734 changed = 1;
735 *s_new = toupper(c);
736 }
737 else if (isupper(c)) {
738 changed = 1;
739 *s_new = tolower(c);
740 }
741 else
742 *s_new = c;
743 s_new++;
744 }
745 if (!changed) {
746 Py_DECREF(newstr);
747 Py_INCREF(args);
748 return args;
749 }
750 return newstr;
751 }
752
753
754 PyDoc_STRVAR(atoi__doc__,
755 "atoi(s [,base]) -> int\n"
756 "\n"
757 "Return the integer represented by the string s in the given\n"
758 "base, which defaults to 10. The string s must consist of one\n"
759 "or more digits, possibly preceded by a sign. If base is 0, it\n"
760 "is chosen from the leading characters of s, 0 for octal, 0x or\n"
761 "0X for hexadecimal. If base is 16, a preceding 0x or 0X is\n"
762 "accepted.");
763
764 static PyObject *
765 strop_atoi(PyObject *self, PyObject *args)
766 {
767 char *s, *end;
768 int base = 10;
769 long x;
770 char buffer[256]; /* For errors */
771
772 WARN;
773 if (!PyArg_ParseTuple(args, "s|i:atoi", &s, &base))
774 return NULL;
775
776 if ((base != 0 && base < 2) || base > 36) {
777 PyErr_SetString(PyExc_ValueError, "invalid base for atoi()");
778 return NULL;
779 }
780
781 while (*s && isspace(Py_CHARMASK(*s)))
782 s++;
783 errno = 0;
784 if (base == 0 && s[0] == '0')
785 x = (long) PyOS_strtoul(s, &end, base);
786 else
787 x = PyOS_strtol(s, &end, base);
788 if (end == s || !isalnum(Py_CHARMASK(end[-1])))
789 goto bad;
790 while (*end && isspace(Py_CHARMASK(*end)))
791 end++;
792 if (*end != '\0') {
793 bad:
794 PyOS_snprintf(buffer, sizeof(buffer),
795 "invalid literal for atoi(): %.200s", s);
796 PyErr_SetString(PyExc_ValueError, buffer);
797 return NULL;
798 }
799 else if (errno != 0) {
800 PyOS_snprintf(buffer, sizeof(buffer),
801 "atoi() literal too large: %.200s", s);
802 PyErr_SetString(PyExc_ValueError, buffer);
803 return NULL;
804 }
805 return PyInt_FromLong(x);
806 }
807
808
809 PyDoc_STRVAR(atol__doc__,
810 "atol(s [,base]) -> long\n"
811 "\n"
812 "Return the long integer represented by the string s in the\n"
813 "given base, which defaults to 10. The string s must consist\n"
814 "of one or more digits, possibly preceded by a sign. If base\n"
815 "is 0, it is chosen from the leading characters of s, 0 for\n"
816 "octal, 0x or 0X for hexadecimal. If base is 16, a preceding\n"
817 "0x or 0X is accepted. A trailing L or l is not accepted,\n"
818 "unless base is 0.");
819
820 static PyObject *
821 strop_atol(PyObject *self, PyObject *args)
822 {
823 char *s, *end;
824 int base = 10;
825 PyObject *x;
826 char buffer[256]; /* For errors */
827
828 WARN;
829 if (!PyArg_ParseTuple(args, "s|i:atol", &s, &base))
830 return NULL;
831
832 if ((base != 0 && base < 2) || base > 36) {
833 PyErr_SetString(PyExc_ValueError, "invalid base for atol()");
834 return NULL;
835 }
836
837 while (*s && isspace(Py_CHARMASK(*s)))
838 s++;
839 if (s[0] == '\0') {
840 PyErr_SetString(PyExc_ValueError, "empty string for atol()");
841 return NULL;
842 }
843 x = PyLong_FromString(s, &end, base);
844 if (x == NULL)
845 return NULL;
846 if (base == 0 && (*end == 'l' || *end == 'L'))
847 end++;
848 while (*end && isspace(Py_CHARMASK(*end)))
849 end++;
850 if (*end != '\0') {
851 PyOS_snprintf(buffer, sizeof(buffer),
852 "invalid literal for atol(): %.200s", s);
853 PyErr_SetString(PyExc_ValueError, buffer);
854 Py_DECREF(x);
855 return NULL;
856 }
857 return x;
858 }
859
860
861 PyDoc_STRVAR(atof__doc__,
862 "atof(s) -> float\n"
863 "\n"
864 "Return the floating point number represented by the string s.");
865
866 static PyObject *
867 strop_atof(PyObject *self, PyObject *args)
868 {
869 char *s, *end;
870 double x;
871 char buffer[256]; /* For errors */
872
873 WARN;
874 if (!PyArg_ParseTuple(args, "s:atof", &s))
875 return NULL;
876 while (*s && isspace(Py_CHARMASK(*s)))
877 s++;
878 if (s[0] == '\0') {
879 PyErr_SetString(PyExc_ValueError, "empty string for atof()");
880 return NULL;
881 }
882
883 PyFPE_START_PROTECT("strop_atof", return 0)
884 x = PyOS_string_to_double(s, &end, PyExc_OverflowError);
885 PyFPE_END_PROTECT(x)
886 if (x == -1 && PyErr_Occurred())
887 return NULL;
888 while (*end && isspace(Py_CHARMASK(*end)))
889 end++;
890 if (*end != '\0') {
891 PyOS_snprintf(buffer, sizeof(buffer),
892 "invalid literal for atof(): %.200s", s);
893 PyErr_SetString(PyExc_ValueError, buffer);
894 return NULL;
895 }
896 return PyFloat_FromDouble(x);
897 }
898
899
900 PyDoc_STRVAR(maketrans__doc__,
901 "maketrans(frm, to) -> string\n"
902 "\n"
903 "Return a translation table (a string of 256 bytes long)\n"
904 "suitable for use in string.translate. The strings frm and to\n"
905 "must be of the same length.");
906
907 static PyObject *
908 strop_maketrans(PyObject *self, PyObject *args)
909 {
910 unsigned char *c, *from=NULL, *to=NULL;
911 Py_ssize_t i, fromlen=0, tolen=0;
912 PyObject *result;
913
914 if (!PyArg_ParseTuple(args, "t#t#:maketrans", &from, &fromlen, &to, &tolen))
915 return NULL;
916
917 if (fromlen != tolen) {
918 PyErr_SetString(PyExc_ValueError,
919 "maketrans arguments must have same length");
920 return NULL;
921 }
922
923 result = PyString_FromStringAndSize((char *)NULL, 256);
924 if (result == NULL)
925 return NULL;
926 c = (unsigned char *) PyString_AS_STRING((PyStringObject *)result);
927 for (i = 0; i < 256; i++)
928 c[i]=(unsigned char)i;
929 for (i = 0; i < fromlen; i++)
930 c[from[i]]=to[i];
931
932 return result;
933 }
934
935
936 PyDoc_STRVAR(translate__doc__,
937 "translate(s,table [,deletechars]) -> string\n"
938 "\n"
939 "Return a copy of the string s, where all characters occurring\n"
940 "in the optional argument deletechars are removed, and the\n"
941 "remaining characters have been mapped through the given\n"
942 "translation table, which must be a string of length 256.");
943
944 static PyObject *
945 strop_translate(PyObject *self, PyObject *args)
946 {
947 register char *input, *table, *output;
948 Py_ssize_t i;
949 int c, changed = 0;
950 PyObject *input_obj;
951 char *table1, *output_start, *del_table=NULL;
952 Py_ssize_t inlen, tablen, dellen = 0;
953 PyObject *result;
954 int trans_table[256];
955
956 WARN;
957 if (!PyArg_ParseTuple(args, "St#|t#:translate", &input_obj,
958 &table1, &tablen, &del_table, &dellen))
959 return NULL;
960 if (tablen != 256) {
961 PyErr_SetString(PyExc_ValueError,
962 "translation table must be 256 characters long");
963 return NULL;
964 }
965
966 table = table1;
967 inlen = PyString_GET_SIZE(input_obj);
968 result = PyString_FromStringAndSize((char *)NULL, inlen);
969 if (result == NULL)
970 return NULL;
971 output_start = output = PyString_AsString(result);
972 input = PyString_AsString(input_obj);
973
974 if (dellen == 0) {
975 /* If no deletions are required, use faster code */
976 for (i = inlen; --i >= 0; ) {
977 c = Py_CHARMASK(*input++);
978 if (Py_CHARMASK((*output++ = table[c])) != c)
979 changed = 1;
980 }
981 if (changed)
982 return result;
983 Py_DECREF(result);
984 Py_INCREF(input_obj);
985 return input_obj;
986 }
987
988 for (i = 0; i < 256; i++)
989 trans_table[i] = Py_CHARMASK(table[i]);
990
991 for (i = 0; i < dellen; i++)
992 trans_table[(int) Py_CHARMASK(del_table[i])] = -1;
993
994 for (i = inlen; --i >= 0; ) {
995 c = Py_CHARMASK(*input++);
996 if (trans_table[c] != -1)
997 if (Py_CHARMASK(*output++ = (char)trans_table[c]) == c)
998 continue;
999 changed = 1;
1000 }
1001 if (!changed) {
1002 Py_DECREF(result);
1003 Py_INCREF(input_obj);
1004 return input_obj;
1005 }
1006 /* Fix the size of the resulting string */
1007 if (inlen > 0)
1008 _PyString_Resize(&result, output - output_start);
1009 return result;
1010 }
1011
1012
1013 /* What follows is used for implementing replace(). Perry Stoll. */
1014
1015 /*
1016 mymemfind
1017
1018 strstr replacement for arbitrary blocks of memory.
1019
1020 Locates the first occurrence in the memory pointed to by MEM of the
1021 contents of memory pointed to by PAT. Returns the index into MEM if
1022 found, or -1 if not found. If len of PAT is greater than length of
1023 MEM, the function returns -1.
1024 */
1025 static Py_ssize_t
1026 mymemfind(const char *mem, Py_ssize_t len, const char *pat, Py_ssize_t pat_len)
1027 {
1028 register Py_ssize_t ii;
1029
1030 /* pattern can not occur in the last pat_len-1 chars */
1031 len -= pat_len;
1032
1033 for (ii = 0; ii <= len; ii++) {
1034 if (mem[ii] == pat[0] &&
1035 (pat_len == 1 ||
1036 memcmp(&mem[ii+1], &pat[1], pat_len-1) == 0)) {
1037 return ii;
1038 }
1039 }
1040 return -1;
1041 }
1042
1043 /*
1044 mymemcnt
1045
1046 Return the number of distinct times PAT is found in MEM.
1047 meaning mem=1111 and pat==11 returns 2.
1048 mem=11111 and pat==11 also return 2.
1049 */
1050 static Py_ssize_t
1051 mymemcnt(const char *mem, Py_ssize_t len, const char *pat, Py_ssize_t pat_len)
1052 {
1053 register Py_ssize_t offset = 0;
1054 Py_ssize_t nfound = 0;
1055
1056 while (len >= 0) {
1057 offset = mymemfind(mem, len, pat, pat_len);
1058 if (offset == -1)
1059 break;
1060 mem += offset + pat_len;
1061 len -= offset + pat_len;
1062 nfound++;
1063 }
1064 return nfound;
1065 }
1066
1067 /*
1068 mymemreplace
1069
1070 Return a string in which all occurrences of PAT in memory STR are
1071 replaced with SUB.
1072
1073 If length of PAT is less than length of STR or there are no occurrences
1074 of PAT in STR, then the original string is returned. Otherwise, a new
1075 string is allocated here and returned.
1076
1077 on return, out_len is:
1078 the length of output string, or
1079 -1 if the input string is returned, or
1080 unchanged if an error occurs (no memory).
1081
1082 return value is:
1083 the new string allocated locally, or
1084 NULL if an error occurred.
1085 */
1086 static char *
1087 mymemreplace(const char *str, Py_ssize_t len, /* input string */
1088 const char *pat, Py_ssize_t pat_len, /* pattern string to find */
1089 const char *sub, Py_ssize_t sub_len, /* substitution string */
1090 Py_ssize_t count, /* number of replacements */
1091 Py_ssize_t *out_len)
1092 {
1093 char *out_s;
1094 char *new_s;
1095 Py_ssize_t nfound, offset, new_len;
1096
1097 if (len == 0 || pat_len > len)
1098 goto return_same;
1099
1100 /* find length of output string */
1101 nfound = mymemcnt(str, len, pat, pat_len);
1102 if (count < 0)
1103 count = PY_SSIZE_T_MAX;
1104 else if (nfound > count)
1105 nfound = count;
1106 if (nfound == 0)
1107 goto return_same;
1108
1109 new_len = len + nfound*(sub_len - pat_len);
1110 if (new_len == 0) {
1111 /* Have to allocate something for the caller to free(). */
1112 out_s = (char *)PyMem_MALLOC(1);
1113 if (out_s == NULL)
1114 return NULL;
1115 out_s[0] = '\0';
1116 }
1117 else {
1118 assert(new_len > 0);
1119 new_s = (char *)PyMem_MALLOC(new_len);
1120 if (new_s == NULL)
1121 return NULL;
1122 out_s = new_s;
1123
1124 for (; count > 0 && len > 0; --count) {
1125 /* find index of next instance of pattern */
1126 offset = mymemfind(str, len, pat, pat_len);
1127 if (offset == -1)
1128 break;
1129
1130 /* copy non matching part of input string */
1131 memcpy(new_s, str, offset);
1132 str += offset + pat_len;
1133 len -= offset + pat_len;
1134
1135 /* copy substitute into the output string */
1136 new_s += offset;
1137 memcpy(new_s, sub, sub_len);
1138 new_s += sub_len;
1139 }
1140 /* copy any remaining values into output string */
1141 if (len > 0)
1142 memcpy(new_s, str, len);
1143 }
1144 *out_len = new_len;
1145 return out_s;
1146
1147 return_same:
1148 *out_len = -1;
1149 return (char *)str; /* cast away const */
1150 }
1151
1152
1153 PyDoc_STRVAR(replace__doc__,
1154 "replace (str, old, new[, maxsplit]) -> string\n"
1155 "\n"
1156 "Return a copy of string str with all occurrences of substring\n"
1157 "old replaced by new. If the optional argument maxsplit is\n"
1158 "given, only the first maxsplit occurrences are replaced.");
1159
1160 static PyObject *
1161 strop_replace(PyObject *self, PyObject *args)
1162 {
1163 char *str, *pat,*sub,*new_s;
1164 Py_ssize_t len,pat_len,sub_len,out_len;
1165 Py_ssize_t count = -1;
1166 PyObject *newstr;
1167
1168 WARN;
1169 if (!PyArg_ParseTuple(args, "t#t#t#|n:replace",
1170 &str, &len, &pat, &pat_len, &sub, &sub_len,
1171 &count))
1172 return NULL;
1173 if (pat_len <= 0) {
1174 PyErr_SetString(PyExc_ValueError, "empty pattern string");
1175 return NULL;
1176 }
1177 /* CAUTION: strop treats a replace count of 0 as infinity, unlke
1178 * current (2.1) string.py and string methods. Preserve this for
1179 * ... well, hard to say for what <wink>.
1180 */
1181 if (count == 0)
1182 count = -1;
1183 new_s = mymemreplace(str,len,pat,pat_len,sub,sub_len,count,&out_len);
1184 if (new_s == NULL) {
1185 PyErr_NoMemory();
1186 return NULL;
1187 }
1188 if (out_len == -1) {
1189 /* we're returning another reference to the input string */
1190 newstr = PyTuple_GetItem(args, 0);
1191 Py_XINCREF(newstr);
1192 }
1193 else {
1194 newstr = PyString_FromStringAndSize(new_s, out_len);
1195 PyMem_FREE(new_s);
1196 }
1197 return newstr;
1198 }
1199
1200
1201 /* List of functions defined in the module */
1202
1203 static PyMethodDef
1204 strop_methods[] = {
1205 {"atof", strop_atof, METH_VARARGS, atof__doc__},
1206 {"atoi", strop_atoi, METH_VARARGS, atoi__doc__},
1207 {"atol", strop_atol, METH_VARARGS, atol__doc__},
1208 {"capitalize", strop_capitalize, METH_O, capitalize__doc__},
1209 {"count", strop_count, METH_VARARGS, count__doc__},
1210 {"expandtabs", strop_expandtabs, METH_VARARGS, expandtabs__doc__},
1211 {"find", strop_find, METH_VARARGS, find__doc__},
1212 {"join", strop_joinfields, METH_VARARGS, joinfields__doc__},
1213 {"joinfields", strop_joinfields, METH_VARARGS, joinfields__doc__},
1214 {"lstrip", strop_lstrip, METH_O, lstrip__doc__},
1215 {"lower", strop_lower, METH_O, lower__doc__},
1216 {"maketrans", strop_maketrans, METH_VARARGS, maketrans__doc__},
1217 {"replace", strop_replace, METH_VARARGS, replace__doc__},
1218 {"rfind", strop_rfind, METH_VARARGS, rfind__doc__},
1219 {"rstrip", strop_rstrip, METH_O, rstrip__doc__},
1220 {"split", strop_splitfields, METH_VARARGS, splitfields__doc__},
1221 {"splitfields", strop_splitfields, METH_VARARGS, splitfields__doc__},
1222 {"strip", strop_strip, METH_O, strip__doc__},
1223 {"swapcase", strop_swapcase, METH_O, swapcase__doc__},
1224 {"translate", strop_translate, METH_VARARGS, translate__doc__},
1225 {"upper", strop_upper, METH_O, upper__doc__},
1226 {NULL, NULL} /* sentinel */
1227 };
1228
1229
1230 PyMODINIT_FUNC
1231 initstrop(void)
1232 {
1233 PyObject *m, *s;
1234 char buf[256];
1235 int c, n;
1236 m = Py_InitModule4("strop", strop_methods, strop_module__doc__,
1237 (PyObject*)NULL, PYTHON_API_VERSION);
1238 if (m == NULL)
1239 return;
1240
1241 /* Create 'whitespace' object */
1242 n = 0;
1243 for (c = 0; c < 256; c++) {
1244 if (isspace(c))
1245 buf[n++] = c;
1246 }
1247 s = PyString_FromStringAndSize(buf, n);
1248 if (s)
1249 PyModule_AddObject(m, "whitespace", s);
1250
1251 /* Create 'lowercase' object */
1252 n = 0;
1253 for (c = 0; c < 256; c++) {
1254 if (islower(c))
1255 buf[n++] = c;
1256 }
1257 s = PyString_FromStringAndSize(buf, n);
1258 if (s)
1259 PyModule_AddObject(m, "lowercase", s);
1260
1261 /* Create 'uppercase' object */
1262 n = 0;
1263 for (c = 0; c < 256; c++) {
1264 if (isupper(c))
1265 buf[n++] = c;
1266 }
1267 s = PyString_FromStringAndSize(buf, n);
1268 if (s)
1269 PyModule_AddObject(m, "uppercase", s);
1270 }