blob: e9e9039397fa96ed8b903201c42668071e3cb64f [file] [log] [blame]
Guido van Rossume270b431992-09-03 20:21:07 +00001/***********************************************************
Guido van Rossum524b5881995-01-04 19:10:35 +00002Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
3The Netherlands.
Guido van Rossume270b431992-09-03 20:21:07 +00004
5 All Rights Reserved
6
Guido van Rossumd266eb41996-10-25 14:44:06 +00007Permission to use, copy, modify, and distribute this software and its
8documentation for any purpose and without fee is hereby granted,
Guido van Rossume270b431992-09-03 20:21:07 +00009provided that the above copyright notice appear in all copies and that
Guido van Rossumd266eb41996-10-25 14:44:06 +000010both that copyright notice and this permission notice appear in
Guido van Rossume270b431992-09-03 20:21:07 +000011supporting documentation, and that the names of Stichting Mathematisch
Guido van Rossumd266eb41996-10-25 14:44:06 +000012Centrum or CWI or Corporation for National Research Initiatives or
13CNRI not be used in advertising or publicity pertaining to
14distribution of the software without specific, written prior
15permission.
Guido van Rossume270b431992-09-03 20:21:07 +000016
Guido van Rossumd266eb41996-10-25 14:44:06 +000017While CWI is the initial source for this software, a modified version
18is made available by the Corporation for National Research Initiatives
19(CNRI) at the Internet address ftp://ftp.python.org.
20
21STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
22REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
23MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
24CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
25DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
26PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
27TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
28PERFORMANCE OF THIS SOFTWARE.
Guido van Rossume270b431992-09-03 20:21:07 +000029
30******************************************************************/
31
32/* strop module */
33
Guido van Rossum983c9301997-12-29 19:52:29 +000034static char strop_module__doc__[] =
Guido van Rossum23e21e71997-12-29 19:57:36 +000035"Common string manipulations, optimized for speed.\n\
Guido van Rossum786205e1997-12-30 05:10:14 +000036\n\
Guido van Rossum983c9301997-12-29 19:52:29 +000037Always use \"import string\" rather than referencing\n\
Guido van Rossum23e21e71997-12-29 19:57:36 +000038this module directly.";
Guido van Rossum983c9301997-12-29 19:52:29 +000039
Barry Warsawf5256011996-12-09 18:35:56 +000040#include "Python.h"
Guido van Rossume270b431992-09-03 20:21:07 +000041
Guido van Rossum7b7c5781997-03-14 04:13:56 +000042#ifdef HAVE_LIMITS_H
43#include <limits.h>
44#else
45#define INT_MAX 2147483647
46#endif
47
Guido van Rossumd05eb8b1993-07-08 11:12:36 +000048#include <ctype.h>
Guido van Rossume22e6441993-07-09 10:51:31 +000049/* XXX This file assumes that the <ctype.h> is*() functions
50 XXX are defined for all 8-bit characters! */
Guido van Rossumd05eb8b1993-07-08 11:12:36 +000051
Guido van Rossum7999a5c1996-08-08 19:16:15 +000052/* The lstrip(), rstrip() and strip() functions are implemented
53 in do_strip(), which uses an additional parameter to indicate what
54 type of strip should occur. */
55
56#define LEFTSTRIP 0
57#define RIGHTSTRIP 1
58#define BOTHSTRIP 2
59
Guido van Rossume270b431992-09-03 20:21:07 +000060
Barry Warsawf5256011996-12-09 18:35:56 +000061static PyObject *
Guido van Rossum7999a5c1996-08-08 19:16:15 +000062split_whitespace(s, len, maxsplit)
Guido van Rossume270b431992-09-03 20:21:07 +000063 char *s;
Guido van Rossum009e79b1995-05-03 17:40:23 +000064 int len;
Guido van Rossum7999a5c1996-08-08 19:16:15 +000065 int maxsplit;
Guido van Rossum009e79b1995-05-03 17:40:23 +000066{
Barry Warsawe8fc29c1997-01-03 22:45:34 +000067 int i = 0, j, err;
68 int countsplit = 0;
69 PyObject* item;
70 PyObject *list = PyList_New(0);
Guido van Rossume270b431992-09-03 20:21:07 +000071
Guido van Rossume270b431992-09-03 20:21:07 +000072 if (list == NULL)
73 return NULL;
74
Guido van Rossume270b431992-09-03 20:21:07 +000075 while (i < len) {
Guido van Rossum7f7f2741995-02-10 17:01:56 +000076 while (i < len && isspace(Py_CHARMASK(s[i]))) {
Guido van Rossume270b431992-09-03 20:21:07 +000077 i = i+1;
78 }
79 j = i;
Guido van Rossumee1813d1995-02-14 00:58:59 +000080 while (i < len && !isspace(Py_CHARMASK(s[i]))) {
Guido van Rossume270b431992-09-03 20:21:07 +000081 i = i+1;
82 }
83 if (j < i) {
Barry Warsawf5256011996-12-09 18:35:56 +000084 item = PyString_FromStringAndSize(s+j, (int)(i-j));
Barry Warsawe8fc29c1997-01-03 22:45:34 +000085 if (item == NULL)
86 goto finally;
87
Barry Warsawf5256011996-12-09 18:35:56 +000088 err = PyList_Append(list, item);
89 Py_DECREF(item);
Barry Warsawe8fc29c1997-01-03 22:45:34 +000090 if (err < 0)
91 goto finally;
Guido van Rossum7999a5c1996-08-08 19:16:15 +000092
93 countsplit++;
Barry Warsaw93be92d1997-12-02 00:29:30 +000094 while (i < len && isspace(Py_CHARMASK(s[i]))) {
95 i = i+1;
96 }
97 if (maxsplit && (countsplit >= maxsplit) && i < len) {
Barry Warsawf5256011996-12-09 18:35:56 +000098 item = PyString_FromStringAndSize(
99 s+i, (int)(len - i));
Barry Warsawe8fc29c1997-01-03 22:45:34 +0000100 if (item == NULL)
101 goto finally;
102
Barry Warsawf5256011996-12-09 18:35:56 +0000103 err = PyList_Append(list, item);
104 Py_DECREF(item);
Barry Warsawe8fc29c1997-01-03 22:45:34 +0000105 if (err < 0)
106 goto finally;
107
Guido van Rossum7999a5c1996-08-08 19:16:15 +0000108 i = len;
109 }
Guido van Rossume270b431992-09-03 20:21:07 +0000110 }
111 }
Guido van Rossume270b431992-09-03 20:21:07 +0000112 return list;
Barry Warsawe8fc29c1997-01-03 22:45:34 +0000113 finally:
114 Py_DECREF(list);
115 return NULL;
Guido van Rossume270b431992-09-03 20:21:07 +0000116}
117
118
Guido van Rossum983c9301997-12-29 19:52:29 +0000119static char splitfields__doc__[] =
120"split(str [,sep [,maxsplit]]) -> list of strings\n\
121splitfields(str [,sep [,maxsplit]]) -> list of strings\n\
122\n\
123Return a list of the words in the string s, using sep as the\n\
124delimiter string. If maxsplit is nonzero, splits into at most\n\
125maxsplit words If sep is not specified, any whitespace string\n\
126is a separator. Maxsplit defaults to 0.\n\
127\n\
128(split and splitfields are synonymous)";
129
Barry Warsawf5256011996-12-09 18:35:56 +0000130static PyObject *
Guido van Rossume270b431992-09-03 20:21:07 +0000131strop_splitfields(self, args)
Barry Warsawf5256011996-12-09 18:35:56 +0000132 PyObject *self; /* Not used */
133 PyObject *args;
Guido van Rossume270b431992-09-03 20:21:07 +0000134{
Guido van Rossum572d2d91993-11-05 10:14:49 +0000135 int len, n, i, j, err;
Guido van Rossum7999a5c1996-08-08 19:16:15 +0000136 int splitcount, maxsplit;
Guido van Rossume270b431992-09-03 20:21:07 +0000137 char *s, *sub;
Barry Warsawf5256011996-12-09 18:35:56 +0000138 PyObject *list, *item;
Guido van Rossume270b431992-09-03 20:21:07 +0000139
Guido van Rossum009e79b1995-05-03 17:40:23 +0000140 sub = NULL;
141 n = 0;
Guido van Rossum7999a5c1996-08-08 19:16:15 +0000142 splitcount = 0;
143 maxsplit = 0;
Barry Warsawf5256011996-12-09 18:35:56 +0000144 if (!PyArg_ParseTuple(args, "s#|z#i", &s, &len, &sub, &n, &maxsplit))
Guido van Rossume270b431992-09-03 20:21:07 +0000145 return NULL;
Guido van Rossum009e79b1995-05-03 17:40:23 +0000146 if (sub == NULL)
Guido van Rossum7999a5c1996-08-08 19:16:15 +0000147 return split_whitespace(s, len, maxsplit);
Guido van Rossume270b431992-09-03 20:21:07 +0000148 if (n == 0) {
Barry Warsawf5256011996-12-09 18:35:56 +0000149 PyErr_SetString(PyExc_ValueError, "empty separator");
Guido van Rossume270b431992-09-03 20:21:07 +0000150 return NULL;
151 }
152
Barry Warsawf5256011996-12-09 18:35:56 +0000153 list = PyList_New(0);
Guido van Rossume270b431992-09-03 20:21:07 +0000154 if (list == NULL)
155 return NULL;
156
157 i = j = 0;
158 while (i+n <= len) {
Guido van Rossuma0ca4c41996-10-04 13:39:37 +0000159 if (s[i] == sub[0] && (n == 1 || memcmp(s+i, sub, n) == 0)) {
Barry Warsawf5256011996-12-09 18:35:56 +0000160 item = PyString_FromStringAndSize(s+j, (int)(i-j));
Guido van Rossum572d2d91993-11-05 10:14:49 +0000161 if (item == NULL)
162 goto fail;
Barry Warsawf5256011996-12-09 18:35:56 +0000163 err = PyList_Append(list, item);
164 Py_DECREF(item);
Guido van Rossum572d2d91993-11-05 10:14:49 +0000165 if (err < 0)
166 goto fail;
Guido van Rossume270b431992-09-03 20:21:07 +0000167 i = j = i + n;
Guido van Rossum7999a5c1996-08-08 19:16:15 +0000168 splitcount++;
169 if (maxsplit && (splitcount >= maxsplit))
170 break;
Guido van Rossume270b431992-09-03 20:21:07 +0000171 }
172 else
173 i++;
174 }
Barry Warsawf5256011996-12-09 18:35:56 +0000175 item = PyString_FromStringAndSize(s+j, (int)(len-j));
Guido van Rossum572d2d91993-11-05 10:14:49 +0000176 if (item == NULL)
177 goto fail;
Barry Warsawf5256011996-12-09 18:35:56 +0000178 err = PyList_Append(list, item);
179 Py_DECREF(item);
Guido van Rossum572d2d91993-11-05 10:14:49 +0000180 if (err < 0)
181 goto fail;
Guido van Rossume270b431992-09-03 20:21:07 +0000182
183 return list;
Guido van Rossum572d2d91993-11-05 10:14:49 +0000184
185 fail:
Barry Warsawf5256011996-12-09 18:35:56 +0000186 Py_DECREF(list);
Guido van Rossum572d2d91993-11-05 10:14:49 +0000187 return NULL;
Guido van Rossume270b431992-09-03 20:21:07 +0000188}
189
190
Guido van Rossum983c9301997-12-29 19:52:29 +0000191static char joinfields__doc__[] =
192"join(list [,sep]) -> string\n\
193joinfields(list [,sep]) -> string\n\
194\n\
195Return a string composed of the words in list, with\n\
Guido van Rossum23e21e71997-12-29 19:57:36 +0000196intervening occurences of sep. Sep defaults to a single\n\
197space.\n\
Guido van Rossum983c9301997-12-29 19:52:29 +0000198\n\
Guido van Rossum23e21e71997-12-29 19:57:36 +0000199(join and joinfields are synonymous)";
Guido van Rossum983c9301997-12-29 19:52:29 +0000200
Barry Warsawf5256011996-12-09 18:35:56 +0000201static PyObject *
Guido van Rossumc89705d1992-11-26 08:54:07 +0000202strop_joinfields(self, args)
Barry Warsawf5256011996-12-09 18:35:56 +0000203 PyObject *self; /* Not used */
204 PyObject *args;
Guido van Rossumc89705d1992-11-26 08:54:07 +0000205{
Barry Warsawd4ff1b91997-01-06 22:48:32 +0000206 PyObject *seq;
207 char *sep = NULL;
208 int seqlen, seplen = 0;
209 int i, reslen = 0, slen = 0, sz = 100;
210 PyObject *res = NULL;
211 char* p = NULL;
212 intargfunc getitemfunc;
Guido van Rossumc89705d1992-11-26 08:54:07 +0000213
Barry Warsawf5256011996-12-09 18:35:56 +0000214 if (!PyArg_ParseTuple(args, "O|s#", &seq, &sep, &seplen))
Guido van Rossumc89705d1992-11-26 08:54:07 +0000215 return NULL;
Guido van Rossum009e79b1995-05-03 17:40:23 +0000216 if (sep == NULL) {
217 sep = " ";
218 seplen = 1;
219 }
Barry Warsawd4ff1b91997-01-06 22:48:32 +0000220
221 seqlen = PySequence_Length(seq);
222 if (seqlen < 0 && PyErr_Occurred())
223 return NULL;
224
225 if (seqlen == 1) {
226 /* Optimization if there's only one item */
227 PyObject *item = PySequence_GetItem(seq, 0);
Guido van Rossum1ad1b3f1998-02-06 22:37:12 +0000228 if (item && !PyString_Check(item)) {
Barry Warsawd4ff1b91997-01-06 22:48:32 +0000229 PyErr_SetString(PyExc_TypeError,
230 "first argument must be sequence of strings");
Guido van Rossum1ad1b3f1998-02-06 22:37:12 +0000231 return NULL;
232 }
Barry Warsawd4ff1b91997-01-06 22:48:32 +0000233 return item;
234 }
235
236 if (!(res = PyString_FromStringAndSize((char*)NULL, sz)))
237 return NULL;
238 p = PyString_AsString(res);
239
240 /* optimize for lists, since it's the most common case. all others
241 * (tuples and arbitrary sequences) just use the sequence abstract
242 * interface.
Barry Warsaw04d2d151997-01-03 23:46:51 +0000243 */
244 if (PyList_Check(seq)) {
Barry Warsawd4ff1b91997-01-06 22:48:32 +0000245 for (i = 0; i < seqlen; i++) {
246 PyObject *item = PyList_GET_ITEM(seq, i);
247 if (!PyString_Check(item)) {
248 PyErr_SetString(PyExc_TypeError,
249 "first argument must be sequence of strings");
250 Py_DECREF(res);
251 return NULL;
252 }
253 slen = PyString_GET_SIZE(item);
254 while (reslen + slen + seplen >= sz) {
255 if (_PyString_Resize(&res, sz * 2)) {
256 Py_DECREF(res);
257 return NULL;
258 }
259 sz *= 2;
260 p = PyString_AsString(res) + reslen;
261 }
262 if (i > 0) {
263 memcpy(p, sep, seplen);
264 p += seplen;
265 reslen += seplen;
266 }
267 memcpy(p, PyString_AS_STRING(item), slen);
268 p += slen;
269 reslen += slen;
270 }
271 if (_PyString_Resize(&res, reslen)) {
272 Py_DECREF(res);
273 res = NULL;
274 }
275 return res;
Barry Warsaw04d2d151997-01-03 23:46:51 +0000276 }
Barry Warsawd4ff1b91997-01-06 22:48:32 +0000277 else if (!PySequence_Check(seq)) {
Barry Warsawf5256011996-12-09 18:35:56 +0000278 PyErr_SetString(PyExc_TypeError,
Barry Warsawe8fc29c1997-01-03 22:45:34 +0000279 "first argument must be a sequence");
Guido van Rossumc89705d1992-11-26 08:54:07 +0000280 return NULL;
281 }
Barry Warsawd4ff1b91997-01-06 22:48:32 +0000282 /* type safe */
283 getitemfunc = seq->ob_type->tp_as_sequence->sq_item;
Guido van Rossumc89705d1992-11-26 08:54:07 +0000284 for (i = 0; i < seqlen; i++) {
Barry Warsawd4ff1b91997-01-06 22:48:32 +0000285 PyObject *item = getitemfunc(seq, i);
286 if (!item || !PyString_Check(item)) {
Barry Warsawf5256011996-12-09 18:35:56 +0000287 PyErr_SetString(PyExc_TypeError,
Barry Warsawe8fc29c1997-01-03 22:45:34 +0000288 "first argument must be sequence of strings");
Barry Warsawd4ff1b91997-01-06 22:48:32 +0000289 Py_DECREF(res);
290 Py_XDECREF(item);
Guido van Rossumc89705d1992-11-26 08:54:07 +0000291 return NULL;
292 }
Barry Warsawd4ff1b91997-01-06 22:48:32 +0000293 slen = PyString_GET_SIZE(item);
294 while (reslen + slen + seplen >= sz) {
295 if (_PyString_Resize(&res, sz * 2)) {
296 Py_DECREF(res);
297 Py_DECREF(item);
298 return NULL;
299 }
300 sz *= 2;
301 p = PyString_AsString(res) + reslen;
Barry Warsawe8fc29c1997-01-03 22:45:34 +0000302 }
Guido van Rossumc89705d1992-11-26 08:54:07 +0000303 if (i > 0) {
304 memcpy(p, sep, seplen);
305 p += seplen;
Barry Warsawd4ff1b91997-01-06 22:48:32 +0000306 reslen += seplen;
Guido van Rossumc89705d1992-11-26 08:54:07 +0000307 }
Barry Warsawd4ff1b91997-01-06 22:48:32 +0000308 memcpy(p, PyString_AS_STRING(item), slen);
309 p += slen;
310 reslen += slen;
311 Py_DECREF(item);
Guido van Rossumc89705d1992-11-26 08:54:07 +0000312 }
Barry Warsawd4ff1b91997-01-06 22:48:32 +0000313 if (_PyString_Resize(&res, reslen)) {
314 Py_DECREF(res);
315 res = NULL;
Guido van Rossumc89705d1992-11-26 08:54:07 +0000316 }
317 return res;
318}
319
Guido van Rossum983c9301997-12-29 19:52:29 +0000320
321static char find__doc__[] =
322"find(s, sub [,start [,end]]) -> in\n\
323\n\
324Return the lowest index in s where substring sub is found,\n\
325such that sub is contained within s[start,end]. Optional\n\
326arguments start and end are interpreted as in slice notation.\n\
327\n\
328Return -1 on failure.";
329
Barry Warsawf5256011996-12-09 18:35:56 +0000330static PyObject *
Guido van Rossum5806a4f1994-08-17 13:15:46 +0000331strop_find(self, args)
Barry Warsawf5256011996-12-09 18:35:56 +0000332 PyObject *self; /* Not used */
333 PyObject *args;
Guido van Rossume270b431992-09-03 20:21:07 +0000334{
335 char *s, *sub;
Guido van Rossum7b7c5781997-03-14 04:13:56 +0000336 int len, n, i = 0, last = INT_MAX;
Guido van Rossume270b431992-09-03 20:21:07 +0000337
Guido van Rossum7b7c5781997-03-14 04:13:56 +0000338 if (!PyArg_ParseTuple(args, "s#s#|ii", &s, &len, &sub, &n, &i, &last))
Barry Warsawe8fc29c1997-01-03 22:45:34 +0000339 return NULL;
340
Guido van Rossum7b7c5781997-03-14 04:13:56 +0000341 if (last > len)
342 last = len;
343 if (last < 0)
344 last += len;
345 if (last < 0)
346 last = 0;
Barry Warsawe8fc29c1997-01-03 22:45:34 +0000347 if (i < 0)
348 i += len;
349 if (i < 0)
Guido van Rossume270b431992-09-03 20:21:07 +0000350 i = 0;
Guido van Rossume270b431992-09-03 20:21:07 +0000351
Guido van Rossum031c6311998-03-24 04:19:22 +0000352 if (n == 0 && i <= last)
Barry Warsawf5256011996-12-09 18:35:56 +0000353 return PyInt_FromLong((long)i);
Guido van Rossume270b431992-09-03 20:21:07 +0000354
Guido van Rossum7b7c5781997-03-14 04:13:56 +0000355 last -= n;
356 for (; i <= last; ++i)
Guido van Rossumee9012f1993-10-26 15:23:55 +0000357 if (s[i] == sub[0] &&
Guido van Rossuma0ca4c41996-10-04 13:39:37 +0000358 (n == 1 || memcmp(&s[i+1], &sub[1], n-1) == 0))
Barry Warsawf5256011996-12-09 18:35:56 +0000359 return PyInt_FromLong((long)i);
Guido van Rossumee9012f1993-10-26 15:23:55 +0000360
Barry Warsawf5256011996-12-09 18:35:56 +0000361 return PyInt_FromLong(-1L);
Guido van Rossumee9012f1993-10-26 15:23:55 +0000362}
363
364
Guido van Rossum983c9301997-12-29 19:52:29 +0000365static char rfind__doc__[] =
366"rfind(s, sub [,start [,end]]) -> int\n\
367\n\
368Return the highest index in s where substring sub is found,\n\
369such that sub is contained within s[start,end]. Optional\n\
370arguments start and end are interpreted as in slice notation.\n\
371\n\
372Return -1 on failure.";
373
Barry Warsawf5256011996-12-09 18:35:56 +0000374static PyObject *
Guido van Rossum5806a4f1994-08-17 13:15:46 +0000375strop_rfind(self, args)
Barry Warsawf5256011996-12-09 18:35:56 +0000376 PyObject *self; /* Not used */
377 PyObject *args;
Guido van Rossumee9012f1993-10-26 15:23:55 +0000378{
379 char *s, *sub;
Barry Warsawe8fc29c1997-01-03 22:45:34 +0000380 int len, n, j;
Guido van Rossum7b7c5781997-03-14 04:13:56 +0000381 int i = 0, last = INT_MAX;
Guido van Rossumee9012f1993-10-26 15:23:55 +0000382
Guido van Rossum7b7c5781997-03-14 04:13:56 +0000383 if (!PyArg_ParseTuple(args, "s#s#|ii", &s, &len, &sub, &n, &i, &last))
Barry Warsawe8fc29c1997-01-03 22:45:34 +0000384 return NULL;
385
Guido van Rossum7b7c5781997-03-14 04:13:56 +0000386 if (last > len)
387 last = len;
388 if (last < 0)
389 last += len;
390 if (last < 0)
391 last = 0;
Barry Warsawe8fc29c1997-01-03 22:45:34 +0000392 if (i < 0)
393 i += len;
394 if (i < 0)
Guido van Rossumb6775db1994-08-01 11:34:53 +0000395 i = 0;
Guido van Rossumee9012f1993-10-26 15:23:55 +0000396
Guido van Rossum031c6311998-03-24 04:19:22 +0000397 if (n == 0 && i <= last)
Guido van Rossum7b7c5781997-03-14 04:13:56 +0000398 return PyInt_FromLong((long)last);
Guido van Rossumee9012f1993-10-26 15:23:55 +0000399
Guido van Rossum7b7c5781997-03-14 04:13:56 +0000400 for (j = last-n; j >= i; --j)
Guido van Rossumb6775db1994-08-01 11:34:53 +0000401 if (s[j] == sub[0] &&
Guido van Rossuma0ca4c41996-10-04 13:39:37 +0000402 (n == 1 || memcmp(&s[j+1], &sub[1], n-1) == 0))
Barry Warsawf5256011996-12-09 18:35:56 +0000403 return PyInt_FromLong((long)j);
Guido van Rossume270b431992-09-03 20:21:07 +0000404
Barry Warsawf5256011996-12-09 18:35:56 +0000405 return PyInt_FromLong(-1L);
Guido van Rossume270b431992-09-03 20:21:07 +0000406}
407
Guido van Rossum983c9301997-12-29 19:52:29 +0000408
Barry Warsawf5256011996-12-09 18:35:56 +0000409static PyObject *
Guido van Rossum7999a5c1996-08-08 19:16:15 +0000410do_strip(args, striptype)
Barry Warsawf5256011996-12-09 18:35:56 +0000411 PyObject *args;
Guido van Rossum7999a5c1996-08-08 19:16:15 +0000412 int striptype;
413{
414 char *s;
415 int len, i, j;
416
417
Barry Warsawf5256011996-12-09 18:35:56 +0000418 if (!PyArg_Parse(args, "s#", &s, &len))
Guido van Rossum7999a5c1996-08-08 19:16:15 +0000419 return NULL;
420
421 i = 0;
422 if (striptype != RIGHTSTRIP) {
423 while (i < len && isspace(Py_CHARMASK(s[i]))) {
424 i++;
425 }
426 }
Guido van Rossum7999a5c1996-08-08 19:16:15 +0000427
428 j = len;
429 if (striptype != LEFTSTRIP) {
430 do {
431 j--;
432 } while (j >= i && isspace(Py_CHARMASK(s[j])));
433 j++;
434 }
435
436 if (i == 0 && j == len) {
Barry Warsawf5256011996-12-09 18:35:56 +0000437 Py_INCREF(args);
Guido van Rossum7999a5c1996-08-08 19:16:15 +0000438 return args;
439 }
440 else
Barry Warsawf5256011996-12-09 18:35:56 +0000441 return PyString_FromStringAndSize(s+i, j-i);
Guido van Rossum7999a5c1996-08-08 19:16:15 +0000442}
443
Guido van Rossume270b431992-09-03 20:21:07 +0000444
Guido van Rossum983c9301997-12-29 19:52:29 +0000445static char strip__doc__[] =
446"strip(s) -> string\n\
447\n\
448Return a copy of the string s with leading and trailing\n\
449whitespace removed.";
450
Barry Warsawf5256011996-12-09 18:35:56 +0000451static PyObject *
Guido van Rossume270b431992-09-03 20:21:07 +0000452strop_strip(self, args)
Barry Warsawf5256011996-12-09 18:35:56 +0000453 PyObject *self; /* Not used */
454 PyObject *args;
Guido van Rossume270b431992-09-03 20:21:07 +0000455{
Guido van Rossum7999a5c1996-08-08 19:16:15 +0000456 return do_strip(args, BOTHSTRIP);
457}
Guido van Rossume270b431992-09-03 20:21:07 +0000458
Guido van Rossum983c9301997-12-29 19:52:29 +0000459
460static char lstrip__doc__[] =
461"lstrip(s) -> string\n\
462\n\
463Return a copy of the string s with leading whitespace removed.";
464
Barry Warsawf5256011996-12-09 18:35:56 +0000465static PyObject *
Guido van Rossum7999a5c1996-08-08 19:16:15 +0000466strop_lstrip(self, args)
Barry Warsawf5256011996-12-09 18:35:56 +0000467 PyObject *self; /* Not used */
468 PyObject *args;
Guido van Rossum7999a5c1996-08-08 19:16:15 +0000469{
Guido van Rossum7999a5c1996-08-08 19:16:15 +0000470 return do_strip(args, LEFTSTRIP);
471}
Guido van Rossume270b431992-09-03 20:21:07 +0000472
Guido van Rossum983c9301997-12-29 19:52:29 +0000473
474static char rstrip__doc__[] =
475"rstrip(s) -> string\n\
476\n\
477Return a copy of the string s with trailing whitespace removed.";
478
Barry Warsawf5256011996-12-09 18:35:56 +0000479static PyObject *
Guido van Rossum7999a5c1996-08-08 19:16:15 +0000480strop_rstrip(self, args)
Barry Warsawf5256011996-12-09 18:35:56 +0000481 PyObject *self; /* Not used */
482 PyObject *args;
Guido van Rossum7999a5c1996-08-08 19:16:15 +0000483{
Guido van Rossum7999a5c1996-08-08 19:16:15 +0000484 return do_strip(args, RIGHTSTRIP);
Guido van Rossume270b431992-09-03 20:21:07 +0000485}
486
487
Guido van Rossum983c9301997-12-29 19:52:29 +0000488static char lower__doc__[] =
489"lower(s) -> string\n\
490\n\
491Return a copy of the string s converted to lowercase.";
492
Barry Warsawf5256011996-12-09 18:35:56 +0000493static PyObject *
Barry Warsaw04d2d151997-01-03 23:46:51 +0000494strop_lower(self, args)
Barry Warsawf5256011996-12-09 18:35:56 +0000495 PyObject *self; /* Not used */
496 PyObject *args;
Guido van Rossum5c850621992-09-11 23:55:51 +0000497{
Sjoerd Mullender3bb8a051993-10-22 12:04:32 +0000498 char *s, *s_new;
Guido van Rossum5c850621992-09-11 23:55:51 +0000499 int i, n;
Barry Warsawf5256011996-12-09 18:35:56 +0000500 PyObject *new;
Guido van Rossum5c850621992-09-11 23:55:51 +0000501 int changed;
502
Barry Warsawf5256011996-12-09 18:35:56 +0000503 if (!PyArg_Parse(args, "s#", &s, &n))
Guido van Rossum5c850621992-09-11 23:55:51 +0000504 return NULL;
Barry Warsawf5256011996-12-09 18:35:56 +0000505 new = PyString_FromStringAndSize(NULL, n);
Guido van Rossum5c850621992-09-11 23:55:51 +0000506 if (new == NULL)
507 return NULL;
Barry Warsawf5256011996-12-09 18:35:56 +0000508 s_new = PyString_AsString(new);
Guido van Rossum5c850621992-09-11 23:55:51 +0000509 changed = 0;
510 for (i = 0; i < n; i++) {
Guido van Rossum7f7f2741995-02-10 17:01:56 +0000511 int c = Py_CHARMASK(*s++);
Barry Warsaw04d2d151997-01-03 23:46:51 +0000512 if (isupper(c)) {
Guido van Rossum5c850621992-09-11 23:55:51 +0000513 changed = 1;
Barry Warsaw04d2d151997-01-03 23:46:51 +0000514 *s_new = tolower(c);
Sjoerd Mullender3bb8a051993-10-22 12:04:32 +0000515 } else
516 *s_new = c;
517 s_new++;
Guido van Rossum5c850621992-09-11 23:55:51 +0000518 }
519 if (!changed) {
Barry Warsawf5256011996-12-09 18:35:56 +0000520 Py_DECREF(new);
521 Py_INCREF(args);
Guido van Rossum5c850621992-09-11 23:55:51 +0000522 return args;
523 }
524 return new;
525}
526
527
Guido van Rossum983c9301997-12-29 19:52:29 +0000528static char upper__doc__[] =
529"upper(s) -> string\n\
530\n\
531Return a copy of the string s converted to uppercase.";
532
Barry Warsawf5256011996-12-09 18:35:56 +0000533static PyObject *
Guido van Rossum5c850621992-09-11 23:55:51 +0000534strop_upper(self, args)
Barry Warsawf5256011996-12-09 18:35:56 +0000535 PyObject *self; /* Not used */
536 PyObject *args;
Guido van Rossum5c850621992-09-11 23:55:51 +0000537{
Barry Warsaw04d2d151997-01-03 23:46:51 +0000538 char *s, *s_new;
539 int i, n;
540 PyObject *new;
541 int changed;
542
543 if (!PyArg_Parse(args, "s#", &s, &n))
544 return NULL;
545 new = PyString_FromStringAndSize(NULL, n);
546 if (new == NULL)
547 return NULL;
548 s_new = PyString_AsString(new);
549 changed = 0;
550 for (i = 0; i < n; i++) {
551 int c = Py_CHARMASK(*s++);
552 if (islower(c)) {
553 changed = 1;
554 *s_new = toupper(c);
555 } else
556 *s_new = c;
557 s_new++;
558 }
559 if (!changed) {
560 Py_DECREF(new);
561 Py_INCREF(args);
562 return args;
563 }
564 return new;
Guido van Rossum5c850621992-09-11 23:55:51 +0000565}
566
567
Guido van Rossum983c9301997-12-29 19:52:29 +0000568static char capitalize__doc__[] =
569"capitalize(s) -> string\n\
570\n\
571Return a copy of the string s with only its first character\n\
572capitalized.";
573
Barry Warsawf5256011996-12-09 18:35:56 +0000574static PyObject *
Guido van Rossum27457531996-06-12 04:24:52 +0000575strop_capitalize(self, args)
Barry Warsawf5256011996-12-09 18:35:56 +0000576 PyObject *self; /* Not used */
577 PyObject *args;
Guido van Rossum27457531996-06-12 04:24:52 +0000578{
579 char *s, *s_new;
580 int i, n;
Barry Warsawf5256011996-12-09 18:35:56 +0000581 PyObject *new;
Guido van Rossum27457531996-06-12 04:24:52 +0000582 int changed;
583
Barry Warsawf5256011996-12-09 18:35:56 +0000584 if (!PyArg_Parse(args, "s#", &s, &n))
Guido van Rossum27457531996-06-12 04:24:52 +0000585 return NULL;
Barry Warsawf5256011996-12-09 18:35:56 +0000586 new = PyString_FromStringAndSize(NULL, n);
Guido van Rossum27457531996-06-12 04:24:52 +0000587 if (new == NULL)
588 return NULL;
Barry Warsawf5256011996-12-09 18:35:56 +0000589 s_new = PyString_AsString(new);
Guido van Rossum27457531996-06-12 04:24:52 +0000590 changed = 0;
Guido van Rossum529c9631996-06-17 16:59:33 +0000591 if (0 < n) {
Guido van Rossum27457531996-06-12 04:24:52 +0000592 int c = Py_CHARMASK(*s++);
593 if (islower(c)) {
594 changed = 1;
595 *s_new = toupper(c);
596 } else
597 *s_new = c;
598 s_new++;
599 }
600 for (i = 1; i < n; i++) {
601 int c = Py_CHARMASK(*s++);
602 if (isupper(c)) {
603 changed = 1;
604 *s_new = tolower(c);
605 } else
606 *s_new = c;
607 s_new++;
608 }
609 if (!changed) {
Barry Warsawf5256011996-12-09 18:35:56 +0000610 Py_DECREF(new);
611 Py_INCREF(args);
Guido van Rossum27457531996-06-12 04:24:52 +0000612 return args;
613 }
614 return new;
615}
616
617
Guido van Rossum983c9301997-12-29 19:52:29 +0000618static char swapcase__doc__[] =
619"swapcase(s) -> string\n\
620\n\
621Return a copy of the string s with upper case characters\n\
622converted to lowercase and vice versa.";
623
Barry Warsawf5256011996-12-09 18:35:56 +0000624static PyObject *
Guido van Rossum5c850621992-09-11 23:55:51 +0000625strop_swapcase(self, args)
Barry Warsawf5256011996-12-09 18:35:56 +0000626 PyObject *self; /* Not used */
627 PyObject *args;
Guido van Rossum5c850621992-09-11 23:55:51 +0000628{
Sjoerd Mullender3bb8a051993-10-22 12:04:32 +0000629 char *s, *s_new;
Guido van Rossum5c850621992-09-11 23:55:51 +0000630 int i, n;
Barry Warsawf5256011996-12-09 18:35:56 +0000631 PyObject *new;
Guido van Rossum5c850621992-09-11 23:55:51 +0000632 int changed;
633
Barry Warsawf5256011996-12-09 18:35:56 +0000634 if (!PyArg_Parse(args, "s#", &s, &n))
Guido van Rossum5c850621992-09-11 23:55:51 +0000635 return NULL;
Barry Warsawf5256011996-12-09 18:35:56 +0000636 new = PyString_FromStringAndSize(NULL, n);
Guido van Rossum5c850621992-09-11 23:55:51 +0000637 if (new == NULL)
638 return NULL;
Barry Warsawf5256011996-12-09 18:35:56 +0000639 s_new = PyString_AsString(new);
Guido van Rossum5c850621992-09-11 23:55:51 +0000640 changed = 0;
641 for (i = 0; i < n; i++) {
Guido van Rossum7f7f2741995-02-10 17:01:56 +0000642 int c = Py_CHARMASK(*s++);
Guido van Rossum5c850621992-09-11 23:55:51 +0000643 if (islower(c)) {
644 changed = 1;
Sjoerd Mullender3bb8a051993-10-22 12:04:32 +0000645 *s_new = toupper(c);
Guido van Rossum5c850621992-09-11 23:55:51 +0000646 }
647 else if (isupper(c)) {
648 changed = 1;
Sjoerd Mullender3bb8a051993-10-22 12:04:32 +0000649 *s_new = tolower(c);
Guido van Rossum5c850621992-09-11 23:55:51 +0000650 }
Sjoerd Mullender3bb8a051993-10-22 12:04:32 +0000651 else
652 *s_new = c;
653 s_new++;
Guido van Rossum5c850621992-09-11 23:55:51 +0000654 }
655 if (!changed) {
Barry Warsawf5256011996-12-09 18:35:56 +0000656 Py_DECREF(new);
657 Py_INCREF(args);
Guido van Rossum5c850621992-09-11 23:55:51 +0000658 return args;
659 }
660 return new;
661}
662
663
Guido van Rossum983c9301997-12-29 19:52:29 +0000664static char atoi__doc__[] =
665"atoi(s [,base]) -> int\n\
666\n\
667Return the integer represented by the string s in the given\n\
668base, which defaults to 10. The string s must consist of one\n\
669or more digits, possibly preceded by a sign. If base is 0, it\n\
670is chosen from the leading characters of s, 0 for octal, 0x or\n\
6710X for hexadecimal. If base is 16, a preceding 0x or 0X is\n\
672accepted.";
673
Barry Warsawf5256011996-12-09 18:35:56 +0000674static PyObject *
Guido van Rossumb6775db1994-08-01 11:34:53 +0000675strop_atoi(self, args)
Barry Warsawf5256011996-12-09 18:35:56 +0000676 PyObject *self; /* Not used */
677 PyObject *args;
Guido van Rossumb6775db1994-08-01 11:34:53 +0000678{
Barry Warsawf5256011996-12-09 18:35:56 +0000679 extern long PyOS_strtol Py_PROTO((const char *, char **, int));
680 extern unsigned long
681 PyOS_strtoul Py_PROTO((const char *, char **, int));
Guido van Rossumb6775db1994-08-01 11:34:53 +0000682 char *s, *end;
683 int base = 10;
684 long x;
Guido van Rossumc35f9331996-09-11 23:30:42 +0000685 char buffer[256]; /* For errors */
Guido van Rossumb6775db1994-08-01 11:34:53 +0000686
Barry Warsawe8fc29c1997-01-03 22:45:34 +0000687 if (!PyArg_ParseTuple(args, "s|i", &s, &base))
Guido van Rossumb6775db1994-08-01 11:34:53 +0000688 return NULL;
Barry Warsawe8fc29c1997-01-03 22:45:34 +0000689
690 if ((base != 0 && base < 2) || base > 36) {
691 PyErr_SetString(PyExc_ValueError, "invalid base for atoi()");
692 return NULL;
693 }
694
Guido van Rossumc35f9331996-09-11 23:30:42 +0000695 while (*s && isspace(Py_CHARMASK(*s)))
696 s++;
Guido van Rossum171191e1996-08-21 20:02:25 +0000697 if (s[0] == '\0') {
Barry Warsawf5256011996-12-09 18:35:56 +0000698 PyErr_SetString(PyExc_ValueError, "empty string for atoi()");
Guido van Rossum171191e1996-08-21 20:02:25 +0000699 return NULL;
700 }
Guido van Rossumb6775db1994-08-01 11:34:53 +0000701 errno = 0;
702 if (base == 0 && s[0] == '0')
Barry Warsawf5256011996-12-09 18:35:56 +0000703 x = (long) PyOS_strtoul(s, &end, base);
Guido van Rossumb6775db1994-08-01 11:34:53 +0000704 else
Barry Warsawf5256011996-12-09 18:35:56 +0000705 x = PyOS_strtol(s, &end, base);
Guido van Rossumc35f9331996-09-11 23:30:42 +0000706 while (*end && isspace(Py_CHARMASK(*end)))
707 end++;
Guido van Rossumb6775db1994-08-01 11:34:53 +0000708 if (*end != '\0') {
Guido van Rossumc35f9331996-09-11 23:30:42 +0000709 sprintf(buffer, "invalid literal for atoi(): %.200s", s);
Barry Warsawf5256011996-12-09 18:35:56 +0000710 PyErr_SetString(PyExc_ValueError, buffer);
Guido van Rossumb6775db1994-08-01 11:34:53 +0000711 return NULL;
712 }
713 else if (errno != 0) {
Guido van Rossumc35f9331996-09-11 23:30:42 +0000714 sprintf(buffer, "atoi() literal too large: %.200s", s);
Barry Warsawf5256011996-12-09 18:35:56 +0000715 PyErr_SetString(PyExc_ValueError, buffer);
Guido van Rossumb6775db1994-08-01 11:34:53 +0000716 return NULL;
717 }
Barry Warsawf5256011996-12-09 18:35:56 +0000718 return PyInt_FromLong(x);
Guido van Rossumb6775db1994-08-01 11:34:53 +0000719}
720
721
Guido van Rossum983c9301997-12-29 19:52:29 +0000722static char atol__doc__[] =
723"atol(s [,base]) -> long\n\
724\n\
725Return the long integer represented by the string s in the\n\
726given base, which defaults to 10. The string s must consist\n\
727of one or more digits, possibly preceded by a sign. If base\n\
728is 0, it is chosen from the leading characters of s, 0 for\n\
729octal, 0x or 0X for hexadecimal. If base is 16, a preceding\n\
7300x or 0X is accepted. A trailing L or l is not accepted,\n\
731unless base is 0.";
732
Barry Warsawf5256011996-12-09 18:35:56 +0000733static PyObject *
Guido van Rossumb6775db1994-08-01 11:34:53 +0000734strop_atol(self, args)
Barry Warsawf5256011996-12-09 18:35:56 +0000735 PyObject *self; /* Not used */
736 PyObject *args;
Guido van Rossumb6775db1994-08-01 11:34:53 +0000737{
738 char *s, *end;
739 int base = 10;
Barry Warsawf5256011996-12-09 18:35:56 +0000740 PyObject *x;
Guido van Rossumc35f9331996-09-11 23:30:42 +0000741 char buffer[256]; /* For errors */
Guido van Rossumb6775db1994-08-01 11:34:53 +0000742
Barry Warsawe8fc29c1997-01-03 22:45:34 +0000743 if (!PyArg_ParseTuple(args, "s|i", &s, &base))
Guido van Rossumb6775db1994-08-01 11:34:53 +0000744 return NULL;
Barry Warsawe8fc29c1997-01-03 22:45:34 +0000745
746 if ((base != 0 && base < 2) || base > 36) {
747 PyErr_SetString(PyExc_ValueError, "invalid base for atol()");
748 return NULL;
749 }
750
Guido van Rossumc35f9331996-09-11 23:30:42 +0000751 while (*s && isspace(Py_CHARMASK(*s)))
752 s++;
Guido van Rossum171191e1996-08-21 20:02:25 +0000753 if (s[0] == '\0') {
Barry Warsawf5256011996-12-09 18:35:56 +0000754 PyErr_SetString(PyExc_ValueError, "empty string for atol()");
Guido van Rossum171191e1996-08-21 20:02:25 +0000755 return NULL;
756 }
Barry Warsawf5256011996-12-09 18:35:56 +0000757 x = PyLong_FromString(s, &end, base);
Guido van Rossumb6775db1994-08-01 11:34:53 +0000758 if (x == NULL)
759 return NULL;
760 if (base == 0 && (*end == 'l' || *end == 'L'))
761 end++;
Guido van Rossumc35f9331996-09-11 23:30:42 +0000762 while (*end && isspace(Py_CHARMASK(*end)))
763 end++;
Guido van Rossumb6775db1994-08-01 11:34:53 +0000764 if (*end != '\0') {
Guido van Rossumc35f9331996-09-11 23:30:42 +0000765 sprintf(buffer, "invalid literal for atol(): %.200s", s);
Barry Warsawf5256011996-12-09 18:35:56 +0000766 PyErr_SetString(PyExc_ValueError, buffer);
767 Py_DECREF(x);
Guido van Rossumb6775db1994-08-01 11:34:53 +0000768 return NULL;
769 }
770 return x;
771}
772
773
Guido van Rossum983c9301997-12-29 19:52:29 +0000774static char atof__doc__[] =
775"atof(s) -> float\n\
776\n\
777Return the floating point number represented by the string s.";
778
Barry Warsawf5256011996-12-09 18:35:56 +0000779static PyObject *
Guido van Rossumb6775db1994-08-01 11:34:53 +0000780strop_atof(self, args)
Barry Warsawf5256011996-12-09 18:35:56 +0000781 PyObject *self; /* Not used */
782 PyObject *args;
Guido van Rossumb6775db1994-08-01 11:34:53 +0000783{
Barry Warsawf5256011996-12-09 18:35:56 +0000784 extern double strtod Py_PROTO((const char *, char **));
Guido van Rossumb6775db1994-08-01 11:34:53 +0000785 char *s, *end;
786 double x;
Guido van Rossumc35f9331996-09-11 23:30:42 +0000787 char buffer[256]; /* For errors */
Guido van Rossumb6775db1994-08-01 11:34:53 +0000788
Guido van Rossum74608f81997-12-30 05:44:10 +0000789 if (!PyArg_ParseTuple(args, "s", &s))
Guido van Rossumb6775db1994-08-01 11:34:53 +0000790 return NULL;
Guido van Rossumc35f9331996-09-11 23:30:42 +0000791 while (*s && isspace(Py_CHARMASK(*s)))
792 s++;
Guido van Rossum171191e1996-08-21 20:02:25 +0000793 if (s[0] == '\0') {
Barry Warsawf5256011996-12-09 18:35:56 +0000794 PyErr_SetString(PyExc_ValueError, "empty string for atof()");
Guido van Rossum171191e1996-08-21 20:02:25 +0000795 return NULL;
796 }
Guido van Rossumb6775db1994-08-01 11:34:53 +0000797 errno = 0;
Guido van Rossum52fa3a61997-02-14 22:59:58 +0000798 PyFPE_START_PROTECT("strop_atof", return 0)
Guido van Rossumb6775db1994-08-01 11:34:53 +0000799 x = strtod(s, &end);
Guido van Rossum7b7c5781997-03-14 04:13:56 +0000800 PyFPE_END_PROTECT(x)
Guido van Rossumc35f9331996-09-11 23:30:42 +0000801 while (*end && isspace(Py_CHARMASK(*end)))
802 end++;
Guido van Rossumb6775db1994-08-01 11:34:53 +0000803 if (*end != '\0') {
Guido van Rossumc35f9331996-09-11 23:30:42 +0000804 sprintf(buffer, "invalid literal for atof(): %.200s", s);
Barry Warsawf5256011996-12-09 18:35:56 +0000805 PyErr_SetString(PyExc_ValueError, buffer);
Guido van Rossumb6775db1994-08-01 11:34:53 +0000806 return NULL;
807 }
808 else if (errno != 0) {
Guido van Rossumc35f9331996-09-11 23:30:42 +0000809 sprintf(buffer, "atof() literal too large: %.200s", s);
Barry Warsawf5256011996-12-09 18:35:56 +0000810 PyErr_SetString(PyExc_ValueError, buffer);
Guido van Rossumb6775db1994-08-01 11:34:53 +0000811 return NULL;
812 }
Barry Warsawf5256011996-12-09 18:35:56 +0000813 return PyFloat_FromDouble(x);
Guido van Rossumb6775db1994-08-01 11:34:53 +0000814}
815
816
Guido van Rossum983c9301997-12-29 19:52:29 +0000817static char maketrans__doc__[] =
818"maketrans(frm, to) -> string\n\
819\n\
820Return a translation table (a string of 256 bytes long)\n\
821suitable for use in string.translate. The strings frm and to\n\
822must be of the same length.";
823
Guido van Rossumed7253c1996-07-23 18:12:39 +0000824static PyObject *
825strop_maketrans(self, args)
826 PyObject *self; /* Not used */
827 PyObject *args;
828{
Guido van Rossume0548b81997-01-06 16:50:09 +0000829 unsigned char *c, *from=NULL, *to=NULL;
Guido van Rossumed7253c1996-07-23 18:12:39 +0000830 int i, fromlen=0, tolen=0;
Guido van Rossume0548b81997-01-06 16:50:09 +0000831 PyObject *result;
Guido van Rossumed7253c1996-07-23 18:12:39 +0000832
Barry Warsawe8fc29c1997-01-03 22:45:34 +0000833 if (!PyArg_ParseTuple(args, "s#s#", &from, &fromlen, &to, &tolen))
834 return NULL;
Guido van Rossumed7253c1996-07-23 18:12:39 +0000835
Barry Warsawe8fc29c1997-01-03 22:45:34 +0000836 if (fromlen != tolen) {
Barry Warsawf5256011996-12-09 18:35:56 +0000837 PyErr_SetString(PyExc_ValueError,
Guido van Rossumed7253c1996-07-23 18:12:39 +0000838 "maketrans arguments must have same length");
839 return NULL;
840 }
Guido van Rossume0548b81997-01-06 16:50:09 +0000841
842 result = PyString_FromStringAndSize((char *)NULL, 256);
843 if (result == NULL)
844 return NULL;
845 c = (unsigned char *) PyString_AS_STRING((PyStringObject *)result);
Barry Warsawe8fc29c1997-01-03 22:45:34 +0000846 for (i = 0; i < 256; i++)
Guido van Rossumed7253c1996-07-23 18:12:39 +0000847 c[i]=(unsigned char)i;
Barry Warsawe8fc29c1997-01-03 22:45:34 +0000848 for (i = 0; i < fromlen; i++)
Guido van Rossumed7253c1996-07-23 18:12:39 +0000849 c[from[i]]=to[i];
Barry Warsawe8fc29c1997-01-03 22:45:34 +0000850
Guido van Rossume0548b81997-01-06 16:50:09 +0000851 return result;
Guido van Rossumed7253c1996-07-23 18:12:39 +0000852}
853
854
Guido van Rossum983c9301997-12-29 19:52:29 +0000855static char translate__doc__[] =
856"translate(s,table [,deletechars]) -> string\n\
857\n\
858Return a copy of the string s, where all characters occurring\n\
859in the optional argument deletechars are removed, and the\n\
860remaining characters have been mapped through the given\n\
861translation table, which must be a string of length 256.";
862
Barry Warsawf5256011996-12-09 18:35:56 +0000863static PyObject *
Guido van Rossuma3127e81995-09-13 17:39:06 +0000864strop_translate(self, args)
Barry Warsawf5256011996-12-09 18:35:56 +0000865 PyObject *self;
866 PyObject *args;
Guido van Rossuma3127e81995-09-13 17:39:06 +0000867{
Guido van Rossume0548b81997-01-06 16:50:09 +0000868 register char *input, *table, *output;
869 register int i, c, changed = 0;
870 PyObject *input_obj;
871 char *table1, *output_start, *del_table=NULL;
Barry Warsawe8fc29c1997-01-03 22:45:34 +0000872 int inlen, tablen, dellen = 0;
Guido van Rossumed7253c1996-07-23 18:12:39 +0000873 PyObject *result;
Guido van Rossume0548b81997-01-06 16:50:09 +0000874 int trans_table[256];
Guido van Rossuma3127e81995-09-13 17:39:06 +0000875
Guido van Rossume0548b81997-01-06 16:50:09 +0000876 if (!PyArg_ParseTuple(args, "Ss#|s#", &input_obj,
877 &table1, &tablen, &del_table, &dellen))
Guido van Rossuma3127e81995-09-13 17:39:06 +0000878 return NULL;
879 if (tablen != 256) {
Barry Warsawf5256011996-12-09 18:35:56 +0000880 PyErr_SetString(PyExc_ValueError,
Barry Warsawe8fc29c1997-01-03 22:45:34 +0000881 "translation table must be 256 characters long");
Guido van Rossuma3127e81995-09-13 17:39:06 +0000882 return NULL;
883 }
Barry Warsawe8fc29c1997-01-03 22:45:34 +0000884
Guido van Rossume0548b81997-01-06 16:50:09 +0000885 table = table1;
886 inlen = PyString_Size(input_obj);
Guido van Rossumed7253c1996-07-23 18:12:39 +0000887 result = PyString_FromStringAndSize((char *)NULL, inlen);
Guido van Rossuma3127e81995-09-13 17:39:06 +0000888 if (result == NULL)
889 return NULL;
Guido van Rossumed7253c1996-07-23 18:12:39 +0000890 output_start = output = PyString_AsString(result);
Guido van Rossume0548b81997-01-06 16:50:09 +0000891 input = PyString_AsString(input_obj);
Barry Warsawe8fc29c1997-01-03 22:45:34 +0000892
Guido van Rossume0548b81997-01-06 16:50:09 +0000893 if (dellen == 0) {
894 /* If no deletions are required, use faster code */
895 for (i = inlen; --i >= 0; ) {
896 c = Py_CHARMASK(*input++);
897 if (Py_CHARMASK((*output++ = table[c])) != c)
898 changed = 1;
Guido van Rossumed7253c1996-07-23 18:12:39 +0000899 }
Guido van Rossume0548b81997-01-06 16:50:09 +0000900 if (changed)
901 return result;
902 Py_DECREF(result);
903 Py_INCREF(input_obj);
904 return input_obj;
Guido van Rossuma3127e81995-09-13 17:39:06 +0000905 }
Guido van Rossume0548b81997-01-06 16:50:09 +0000906
907 for (i = 0; i < 256; i++)
908 trans_table[i] = Py_CHARMASK(table[i]);
909
Guido van Rossum983c9301997-12-29 19:52:29 +0000910 for (i = 0; i < dellen; i++)
Guido van Rossum1ed5e571997-04-29 21:34:16 +0000911 trans_table[(int) Py_CHARMASK(del_table[i])] = -1;
Guido van Rossume0548b81997-01-06 16:50:09 +0000912
913 for (i = inlen; --i >= 0; ) {
914 c = Py_CHARMASK(*input++);
915 if (trans_table[c] != -1)
916 if (Py_CHARMASK(*output++ = (char)trans_table[c]) == c)
917 continue;
918 changed = 1;
919 }
920 if (!changed) {
921 Py_DECREF(result);
922 Py_INCREF(input_obj);
923 return input_obj;
924 }
925 /* Fix the size of the resulting string */
926 if (inlen > 0 &&_PyString_Resize(&result, output-output_start))
Guido van Rossum983c9301997-12-29 19:52:29 +0000927 return NULL;
Guido van Rossuma3127e81995-09-13 17:39:06 +0000928 return result;
929}
930
931
Guido van Rossum101923b1997-04-02 06:11:18 +0000932/* What follows is used for implementing replace(). Perry Stoll. */
933
934/*
935 mymemfind
936
937 strstr replacement for arbitrary blocks of memory.
938
939 Locates the first occurance in the memory pointed to by MEM of the
940 contents of memory pointed to by PAT. Returns the index into MEM if
941 found, or -1 if not found. If len of PAT is greater than length of
Guido van Rossum983c9301997-12-29 19:52:29 +0000942 MEM, the function returns -1.
Guido van Rossum101923b1997-04-02 06:11:18 +0000943*/
944static int mymemfind(mem, len, pat, pat_len)
945 char *mem;
946 int len;
947 char *pat;
948 int pat_len;
949{
950 register int ii;
951
952 /* pattern can not occur in the last pat_len-1 chars */
953 len -= pat_len;
954
955 for (ii = 0; ii <= len; ii++) {
956 if (mem[ii] == pat[0] &&
957 (pat_len == 1 ||
958 memcmp(&mem[ii+1], &pat[1], pat_len-1) == 0)) {
959 return ii;
960 }
961 }
962 return -1;
963}
964
965/*
966 mymemcnt
967
968 Return the number of distinct times PAT is found in MEM.
969 meaning mem=1111 and pat==11 returns 2.
970 mem=11111 and pat==11 also return 2.
971 */
972static int mymemcnt(mem, len, pat, pat_len)
973 char *mem;
974 int len;
975 char *pat;
976 int pat_len;
977{
978 register int offset = 0;
979 int nfound = 0;
980
981 while (len >= 0) {
982 offset = mymemfind(mem, len, pat, pat_len);
983 if (offset == -1)
984 break;
985 mem += offset + pat_len;
986 len -= offset + pat_len;
987 nfound++;
988 }
989 return nfound;
990}
991
Guido van Rossum983c9301997-12-29 19:52:29 +0000992/*
Guido van Rossum101923b1997-04-02 06:11:18 +0000993 mymemreplace
994
995 Return a string in which all occurences of PAT in memory STR are
Guido van Rossum983c9301997-12-29 19:52:29 +0000996 replaced with SUB.
Guido van Rossum101923b1997-04-02 06:11:18 +0000997
998 If length of PAT is less than length of STR or there are no occurences
999 of PAT in STR, then the original string is returned. Otherwise, a new
1000 string is allocated here and returned.
Guido van Rossum983c9301997-12-29 19:52:29 +00001001
Guido van Rossum101923b1997-04-02 06:11:18 +00001002 on return, out_len is:
1003 the length of output string, or
1004 -1 if the input string is returned, or
1005 unchanged if an error occurs (no memory).
1006
1007 return value is:
1008 the new string allocated locally, or
1009 NULL if an error occurred.
1010*/
Barry Warsawf577c081997-11-29 00:10:07 +00001011static char *mymemreplace(str, len, pat, pat_len, sub, sub_len, count, out_len)
Guido van Rossum101923b1997-04-02 06:11:18 +00001012 char *str;
1013 int len; /* input string */
1014 char *pat;
1015 int pat_len; /* pattern string to find */
1016 char *sub;
1017 int sub_len; /* substitution string */
Barry Warsawf577c081997-11-29 00:10:07 +00001018 int count; /* number of replacements, 0 == all */
Guido van Rossum101923b1997-04-02 06:11:18 +00001019 int *out_len;
1020
1021{
1022 char *out_s;
1023 char *new_s;
1024 int nfound, offset, new_len;
1025
1026 if (len == 0 || pat_len > len)
1027 goto return_same;
1028
1029 /* find length of output string */
1030 nfound = mymemcnt(str, len, pat, pat_len);
Barry Warsawf577c081997-11-29 00:10:07 +00001031 if (count > 0)
1032 nfound = nfound > count ? count : nfound;
Guido van Rossum101923b1997-04-02 06:11:18 +00001033 if (nfound == 0)
1034 goto return_same;
1035 new_len = len + nfound*(sub_len - pat_len);
1036
1037 new_s = (char *)malloc(new_len);
1038 if (new_s == NULL) return NULL;
1039
1040 *out_len = new_len;
1041 out_s = new_s;
1042
1043 while (len > 0) {
1044 /* find index of next instance of pattern */
1045 offset = mymemfind(str, len, pat, pat_len);
1046 /* if not found, break out of loop */
1047 if (offset == -1) break;
1048
1049 /* copy non matching part of input string */
1050 memcpy(new_s, str, offset); /* copy part of str before pat */
1051 str += offset + pat_len; /* move str past pattern */
1052 len -= offset + pat_len; /* reduce length of str remaining */
1053
1054 /* copy substitute into the output string */
1055 new_s += offset; /* move new_s to dest for sub string */
1056 memcpy(new_s, sub, sub_len); /* copy substring into new_s */
1057 new_s += sub_len; /* offset new_s past sub string */
Barry Warsawf577c081997-11-29 00:10:07 +00001058
1059 /* break when we've done count replacements */
1060 if (--count == 0) break;
Guido van Rossum101923b1997-04-02 06:11:18 +00001061 }
1062 /* copy any remaining values into output string */
1063 if (len > 0)
1064 memcpy(new_s, str, len);
1065 return out_s;
1066
1067 return_same:
1068 *out_len = -1;
1069 return str;
1070}
1071
1072
Guido van Rossum983c9301997-12-29 19:52:29 +00001073static char replace__doc__[] =
1074"replace (str, old, new[, maxsplit]) -> string\n\
1075\n\
1076Return a copy of string str with all occurrences of substring\n\
1077old replaced by new. If the optional argument maxsplit is\n\
1078given, only the first maxsplit occurrences are replaced.";
1079
1080static PyObject *
Guido van Rossum101923b1997-04-02 06:11:18 +00001081strop_replace(self, args)
1082 PyObject *self; /* Not used */
1083 PyObject *args;
1084{
1085 char *str, *pat,*sub,*new_s;
1086 int len,pat_len,sub_len,out_len;
Barry Warsawf577c081997-11-29 00:10:07 +00001087 int count = 0;
Guido van Rossum101923b1997-04-02 06:11:18 +00001088 PyObject *new;
1089
Barry Warsawf577c081997-11-29 00:10:07 +00001090 if (!PyArg_ParseTuple(args, "s#s#s#|i",
1091 &str, &len, &pat, &pat_len, &sub, &sub_len,
1092 &count))
Guido van Rossum101923b1997-04-02 06:11:18 +00001093 return NULL;
Barry Warsawf577c081997-11-29 00:10:07 +00001094 new_s = mymemreplace(str,len,pat,pat_len,sub,sub_len,count,&out_len);
Guido van Rossum101923b1997-04-02 06:11:18 +00001095 if (new_s == NULL) {
1096 PyErr_NoMemory();
1097 return NULL;
1098 }
1099 if (out_len == -1) {
1100 /* we're returning another reference to the input string */
1101 new = PyTuple_GetItem(args, 0);
1102 Py_XINCREF(new);
1103 }
1104 else {
1105 new = PyString_FromStringAndSize(new_s, out_len);
1106 free(new_s);
1107 }
1108 return new;
1109}
1110
1111
Guido van Rossume270b431992-09-03 20:21:07 +00001112/* List of functions defined in the module */
1113
Barry Warsawe8fc29c1997-01-03 22:45:34 +00001114static PyMethodDef
1115strop_methods[] = {
Guido van Rossum983c9301997-12-29 19:52:29 +00001116 {"atof", strop_atof, 1, atof__doc__},
1117 {"atoi", strop_atoi, 1, atoi__doc__},
1118 {"atol", strop_atol, 1, atol__doc__},
Guido van Rossum74608f81997-12-30 05:44:10 +00001119 {"capitalize", strop_capitalize, 0, capitalize__doc__},
Guido van Rossum983c9301997-12-29 19:52:29 +00001120 {"find", strop_find, 1, find__doc__},
1121 {"join", strop_joinfields, 1, joinfields__doc__},
1122 {"joinfields", strop_joinfields, 1, joinfields__doc__},
Guido van Rossum74608f81997-12-30 05:44:10 +00001123 {"lstrip", strop_lstrip, 0, lstrip__doc__},
1124 {"lower", strop_lower, 0, lower__doc__},
Guido van Rossum983c9301997-12-29 19:52:29 +00001125 {"maketrans", strop_maketrans, 1, maketrans__doc__},
1126 {"replace", strop_replace, 1, replace__doc__},
1127 {"rfind", strop_rfind, 1, rfind__doc__},
Guido van Rossum74608f81997-12-30 05:44:10 +00001128 {"rstrip", strop_rstrip, 0, rstrip__doc__},
Guido van Rossum983c9301997-12-29 19:52:29 +00001129 {"split", strop_splitfields, 1, splitfields__doc__},
1130 {"splitfields", strop_splitfields, 1, splitfields__doc__},
Guido van Rossum74608f81997-12-30 05:44:10 +00001131 {"strip", strop_strip, 0, strip__doc__},
1132 {"swapcase", strop_swapcase, 0, swapcase__doc__},
Guido van Rossum983c9301997-12-29 19:52:29 +00001133 {"translate", strop_translate, 1, translate__doc__},
Guido van Rossum74608f81997-12-30 05:44:10 +00001134 {"upper", strop_upper, 0, upper__doc__},
Guido van Rossume270b431992-09-03 20:21:07 +00001135 {NULL, NULL} /* sentinel */
1136};
1137
1138
Guido van Rossume270b431992-09-03 20:21:07 +00001139void
1140initstrop()
1141{
Barry Warsawf5256011996-12-09 18:35:56 +00001142 PyObject *m, *d, *s;
Guido van Rossumd05eb8b1993-07-08 11:12:36 +00001143 char buf[256];
1144 int c, n;
Guido van Rossum983c9301997-12-29 19:52:29 +00001145 m = Py_InitModule4("strop", strop_methods, strop_module__doc__,
1146 (PyObject*)NULL, PYTHON_API_VERSION);
Barry Warsawf5256011996-12-09 18:35:56 +00001147 d = PyModule_GetDict(m);
Guido van Rossume22e6441993-07-09 10:51:31 +00001148
1149 /* Create 'whitespace' object */
Guido van Rossumd05eb8b1993-07-08 11:12:36 +00001150 n = 0;
Guido van Rossum7f7f2741995-02-10 17:01:56 +00001151 for (c = 0; c < 256; c++) {
Guido van Rossumd05eb8b1993-07-08 11:12:36 +00001152 if (isspace(c))
1153 buf[n++] = c;
1154 }
Barry Warsawf5256011996-12-09 18:35:56 +00001155 s = PyString_FromStringAndSize(buf, n);
Guido van Rossume22e6441993-07-09 10:51:31 +00001156 if (s) {
Barry Warsawf5256011996-12-09 18:35:56 +00001157 PyDict_SetItemString(d, "whitespace", s);
1158 Py_DECREF(s);
Guido van Rossume22e6441993-07-09 10:51:31 +00001159 }
1160 /* Create 'lowercase' object */
1161 n = 0;
Guido van Rossum7f7f2741995-02-10 17:01:56 +00001162 for (c = 0; c < 256; c++) {
Guido van Rossume22e6441993-07-09 10:51:31 +00001163 if (islower(c))
1164 buf[n++] = c;
1165 }
Barry Warsawf5256011996-12-09 18:35:56 +00001166 s = PyString_FromStringAndSize(buf, n);
Guido van Rossume22e6441993-07-09 10:51:31 +00001167 if (s) {
Barry Warsawf5256011996-12-09 18:35:56 +00001168 PyDict_SetItemString(d, "lowercase", s);
1169 Py_DECREF(s);
Guido van Rossume22e6441993-07-09 10:51:31 +00001170 }
1171
1172 /* Create 'uppercase' object */
1173 n = 0;
Guido van Rossum7f7f2741995-02-10 17:01:56 +00001174 for (c = 0; c < 256; c++) {
Guido van Rossume22e6441993-07-09 10:51:31 +00001175 if (isupper(c))
1176 buf[n++] = c;
1177 }
Barry Warsawf5256011996-12-09 18:35:56 +00001178 s = PyString_FromStringAndSize(buf, n);
Guido van Rossume22e6441993-07-09 10:51:31 +00001179 if (s) {
Barry Warsawf5256011996-12-09 18:35:56 +00001180 PyDict_SetItemString(d, "uppercase", s);
1181 Py_DECREF(s);
Guido van Rossume22e6441993-07-09 10:51:31 +00001182 }
1183
Barry Warsawf5256011996-12-09 18:35:56 +00001184 if (PyErr_Occurred())
1185 Py_FatalError("can't initialize module strop");
Guido van Rossume270b431992-09-03 20:21:07 +00001186}