Modules/stropmodule.c

   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         errno = 0;
 883         PyFPE_START_PROTECT("strop_atof", return 0)
 884         x = PyOS_ascii_strtod(s, &end);
 885         PyFPE_END_PROTECT(x)
 886         while (*end && isspace(Py_CHARMASK(*end)))
 887                 end++;
 888         if (*end != '\0') {
 889                 PyOS_snprintf(buffer, sizeof(buffer),
 890                               "invalid literal for atof(): %.200s", s);
 891                 PyErr_SetString(PyExc_ValueError, buffer);
 892                 return NULL;
 893         }
 894         else if (errno != 0) {
 895                 PyOS_snprintf(buffer, sizeof(buffer),
 896                               "atof() literal too large: %.200s", s);
 897                 PyErr_SetString(PyExc_ValueError, buffer);
 898                 return NULL;
 899         }
 900         return PyFloat_FromDouble(x);
 901 }
 902
 903
 904 PyDoc_STRVAR(maketrans__doc__,
 905 "maketrans(frm, to) -> string\n"
 906 "\n"
 907 "Return a translation table (a string of 256 bytes long)\n"
 908 "suitable for use in string.translate.  The strings frm and to\n"
 909 "must be of the same length.");
 910
 911 static PyObject *
 912 strop_maketrans(PyObject *self, PyObject *args)
 913 {
 914         unsigned char *c, *from=NULL, *to=NULL;
 915         Py_ssize_t i, fromlen=0, tolen=0;
 916         PyObject *result;
 917
 918         if (!PyArg_ParseTuple(args, "t#t#:maketrans", &from, &fromlen, &to, &tolen))
 919                 return NULL;
 920
 921         if (fromlen != tolen) {
 922                 PyErr_SetString(PyExc_ValueError,
 923                                 "maketrans arguments must have same length");
 924                 return NULL;
 925         }
 926
 927         result = PyString_FromStringAndSize((char *)NULL, 256);
 928         if (result == NULL)
 929                 return NULL;
 930         c = (unsigned char *) PyString_AS_STRING((PyStringObject *)result);
 931         for (i = 0; i < 256; i++)
 932                 c[i]=(unsigned char)i;
 933         for (i = 0; i < fromlen; i++)
 934                 c[from[i]]=to[i];
 935
 936         return result;
 937 }
 938
 939
 940 PyDoc_STRVAR(translate__doc__,
 941 "translate(s,table [,deletechars]) -> string\n"
 942 "\n"
 943 "Return a copy of the string s, where all characters occurring\n"
 944 "in the optional argument deletechars are removed, and the\n"
 945 "remaining characters have been mapped through the given\n"
 946 "translation table, which must be a string of length 256.");
 947
 948 static PyObject *
 949 strop_translate(PyObject *self, PyObject *args)
 950 {
 951         register char *input, *table, *output;
 952         Py_ssize_t i;
 953         int c, changed = 0;
 954         PyObject *input_obj;
 955         char *table1, *output_start, *del_table=NULL;
 956         Py_ssize_t inlen, tablen, dellen = 0;
 957         PyObject *result;
 958         int trans_table[256];
 959
 960         WARN;
 961         if (!PyArg_ParseTuple(args, "St#|t#:translate", &input_obj,
 962                               &table1, &tablen, &del_table, &dellen))
 963                 return NULL;
 964         if (tablen != 256) {
 965                 PyErr_SetString(PyExc_ValueError,
 966                               "translation table must be 256 characters long");
 967                 return NULL;
 968         }
 969
 970         table = table1;
 971         inlen = PyString_GET_SIZE(input_obj);
 972         result = PyString_FromStringAndSize((char *)NULL, inlen);
 973         if (result == NULL)
 974                 return NULL;
 975         output_start = output = PyString_AsString(result);
 976         input = PyString_AsString(input_obj);
 977
 978         if (dellen == 0) {
 979                 /* If no deletions are required, use faster code */
 980                 for (i = inlen; --i >= 0; ) {
 981                         c = Py_CHARMASK(*input++);
 982                         if (Py_CHARMASK((*output++ = table[c])) != c)
 983                                 changed = 1;
 984                 }
 985                 if (changed)
 986                         return result;
 987                 Py_DECREF(result);
 988                 Py_INCREF(input_obj);
 989                 return input_obj;
 990         }
 991
 992         for (i = 0; i < 256; i++)
 993                 trans_table[i] = Py_CHARMASK(table[i]);
 994
 995         for (i = 0; i < dellen; i++)
 996                 trans_table[(int) Py_CHARMASK(del_table[i])] = -1;
 997
 998         for (i = inlen; --i >= 0; ) {
 999                 c = Py_CHARMASK(*input++);
1000                 if (trans_table[c] != -1)
1001                         if (Py_CHARMASK(*output++ = (char)trans_table[c]) == c)
1002                                 continue;
1003                 changed = 1;
1004         }
1005         if (!changed) {
1006                 Py_DECREF(result);
1007                 Py_INCREF(input_obj);
1008                 return input_obj;
1009         }
1010         /* Fix the size of the resulting string */
1011         if (inlen > 0)
1012                 _PyString_Resize(&result, output - output_start);
1013         return result;
1014 }
1015
1016
1017 /* What follows is used for implementing replace().  Perry Stoll. */
1018
1019 /*
1020   mymemfind
1021
1022   strstr replacement for arbitrary blocks of memory.
1023
1024   Locates the first occurrence in the memory pointed to by MEM of the
1025   contents of memory pointed to by PAT.  Returns the index into MEM if
1026   found, or -1 if not found.  If len of PAT is greater than length of
1027   MEM, the function returns -1.
1028 */
1029 static Py_ssize_t
1030 mymemfind(const char *mem, Py_ssize_t len, const char *pat, Py_ssize_t pat_len)
1031 {
1032         register Py_ssize_t ii;
1033
1034         /* pattern can not occur in the last pat_len-1 chars */
1035         len -= pat_len;
1036
1037         for (ii = 0; ii <= len; ii++) {
1038                 if (mem[ii] == pat[0] &&
1039                     (pat_len == 1 ||
1040                      memcmp(&mem[ii+1], &pat[1], pat_len-1) == 0)) {
1041                         return ii;
1042                 }
1043         }
1044         return -1;
1045 }
1046
1047 /*
1048   mymemcnt
1049
1050    Return the number of distinct times PAT is found in MEM.
1051    meaning mem=1111 and pat==11 returns 2.
1052            mem=11111 and pat==11 also return 2.
1053  */
1054 static Py_ssize_t
1055 mymemcnt(const char *mem, Py_ssize_t len, const char *pat, Py_ssize_t pat_len)
1056 {
1057         register Py_ssize_t offset = 0;
1058         Py_ssize_t nfound = 0;
1059
1060         while (len >= 0) {
1061                 offset = mymemfind(mem, len, pat, pat_len);
1062                 if (offset == -1)
1063                         break;
1064                 mem += offset + pat_len;
1065                 len -= offset + pat_len;
1066                 nfound++;
1067         }
1068         return nfound;
1069 }
1070
1071 /*
1072    mymemreplace
1073
1074    Return a string in which all occurrences of PAT in memory STR are
1075    replaced with SUB.
1076
1077    If length of PAT is less than length of STR or there are no occurrences
1078    of PAT in STR, then the original string is returned. Otherwise, a new
1079    string is allocated here and returned.
1080
1081    on return, out_len is:
1082        the length of output string, or
1083        -1 if the input string is returned, or
1084        unchanged if an error occurs (no memory).
1085
1086    return value is:
1087        the new string allocated locally, or
1088        NULL if an error occurred.
1089 */
1090 static char *
1091 mymemreplace(const char *str, Py_ssize_t len,           /* input string */
1092              const char *pat, Py_ssize_t pat_len,       /* pattern string to find */
1093              const char *sub, Py_ssize_t sub_len,       /* substitution string */
1094              Py_ssize_t count,                          /* number of replacements */
1095              Py_ssize_t *out_len)
1096 {
1097         char *out_s;
1098         char *new_s;
1099         Py_ssize_t nfound, offset, new_len;
1100
1101         if (len == 0 || pat_len > len)
1102                 goto return_same;
1103
1104         /* find length of output string */
1105         nfound = mymemcnt(str, len, pat, pat_len);
1106         if (count < 0)
1107                 count = PY_SSIZE_T_MAX;
1108         else if (nfound > count)
1109                 nfound = count;
1110         if (nfound == 0)
1111                 goto return_same;
1112
1113         new_len = len + nfound*(sub_len - pat_len);
1114         if (new_len == 0) {
1115                 /* Have to allocate something for the caller to free(). */
1116                 out_s = (char *)PyMem_MALLOC(1);
1117                 if (out_s == NULL)
1118                         return NULL;
1119                 out_s[0] = '\0';
1120         }
1121         else {
1122                 assert(new_len > 0);
1123                 new_s = (char *)PyMem_MALLOC(new_len);
1124                 if (new_s == NULL)
1125                         return NULL;
1126                 out_s = new_s;
1127
1128                 for (; count > 0 && len > 0; --count) {
1129                         /* find index of next instance of pattern */
1130                         offset = mymemfind(str, len, pat, pat_len);
1131                         if (offset == -1)
1132                                 break;
1133
1134                         /* copy non matching part of input string */
1135                         memcpy(new_s, str, offset);
1136                         str += offset + pat_len;
1137                         len -= offset + pat_len;
1138
1139                         /* copy substitute into the output string */
1140                         new_s += offset;
1141                         memcpy(new_s, sub, sub_len);
1142                         new_s += sub_len;
1143                 }
1144                 /* copy any remaining values into output string */
1145                 if (len > 0)
1146                         memcpy(new_s, str, len);
1147         }
1148         *out_len = new_len;
1149         return out_s;
1150
1151   return_same:
1152         *out_len = -1;
1153         return (char *)str; /* cast away const */
1154 }
1155
1156
1157 PyDoc_STRVAR(replace__doc__,
1158 "replace (str, old, new[, maxsplit]) -> string\n"
1159 "\n"
1160 "Return a copy of string str with all occurrences of substring\n"
1161 "old replaced by new. If the optional argument maxsplit is\n"
1162 "given, only the first maxsplit occurrences are replaced.");
1163
1164 static PyObject *
1165 strop_replace(PyObject *self, PyObject *args)
1166 {
1167         char *str, *pat,*sub,*new_s;
1168         Py_ssize_t len,pat_len,sub_len,out_len;
1169         Py_ssize_t count = -1;
1170         PyObject *newstr;
1171
1172         WARN;
1173         if (!PyArg_ParseTuple(args, "t#t#t#|n:replace",
1174                               &str, &len, &pat, &pat_len, &sub, &sub_len,
1175                               &count))
1176                 return NULL;
1177         if (pat_len <= 0) {
1178                 PyErr_SetString(PyExc_ValueError, "empty pattern string");
1179                 return NULL;
1180         }
1181         /* CAUTION:  strop treats a replace count of 0 as infinity, unlke
1182          * current (2.1) string.py and string methods.  Preserve this for
1183          * ... well, hard to say for what <wink>.
1184          */
1185         if (count == 0)
1186                 count = -1;
1187         new_s = mymemreplace(str,len,pat,pat_len,sub,sub_len,count,&out_len);
1188         if (new_s == NULL) {
1189                 PyErr_NoMemory();
1190                 return NULL;
1191         }
1192         if (out_len == -1) {
1193                 /* we're returning another reference to the input string */
1194                 newstr = PyTuple_GetItem(args, 0);
1195                 Py_XINCREF(newstr);
1196         }
1197         else {
1198                 newstr = PyString_FromStringAndSize(new_s, out_len);
1199                 PyMem_FREE(new_s);
1200         }
1201         return newstr;
1202 }
1203
1204
1205 /* List of functions defined in the module */
1206
1207 static PyMethodDef
1208 strop_methods[] = {
1209         {"atof",        strop_atof,        METH_VARARGS, atof__doc__},
1210         {"atoi",        strop_atoi,        METH_VARARGS, atoi__doc__},
1211         {"atol",        strop_atol,        METH_VARARGS, atol__doc__},
1212         {"capitalize",  strop_capitalize,  METH_O,       capitalize__doc__},
1213         {"count",       strop_count,       METH_VARARGS, count__doc__},
1214         {"expandtabs",  strop_expandtabs,  METH_VARARGS, expandtabs__doc__},
1215         {"find",        strop_find,        METH_VARARGS, find__doc__},
1216         {"join",        strop_joinfields,  METH_VARARGS, joinfields__doc__},
1217         {"joinfields",  strop_joinfields,  METH_VARARGS, joinfields__doc__},
1218         {"lstrip",      strop_lstrip,      METH_O,       lstrip__doc__},
1219         {"lower",       strop_lower,       METH_O,       lower__doc__},
1220         {"maketrans",   strop_maketrans,   METH_VARARGS, maketrans__doc__},
1221         {"replace",     strop_replace,     METH_VARARGS, replace__doc__},
1222         {"rfind",       strop_rfind,       METH_VARARGS, rfind__doc__},
1223         {"rstrip",      strop_rstrip,      METH_O,       rstrip__doc__},
1224         {"split",       strop_splitfields, METH_VARARGS, splitfields__doc__},
1225         {"splitfields", strop_splitfields, METH_VARARGS, splitfields__doc__},
1226         {"strip",       strop_strip,       METH_O,       strip__doc__},
1227         {"swapcase",    strop_swapcase,    METH_O,       swapcase__doc__},
1228         {"translate",   strop_translate,   METH_VARARGS, translate__doc__},
1229         {"upper",       strop_upper,       METH_O,       upper__doc__},
1230         {NULL,          NULL}   /* sentinel */
1231 };
1232
1233
1234 PyMODINIT_FUNC
1235 initstrop(void)
1236 {
1237         PyObject *m, *s;
1238         char buf[256];
1239         int c, n;
1240         m = Py_InitModule4("strop", strop_methods, strop_module__doc__,
1241                            (PyObject*)NULL, PYTHON_API_VERSION);
1242         if (m == NULL)
1243                 return;
1244
1245         /* Create 'whitespace' object */
1246         n = 0;
1247         for (c = 0; c < 256; c++) {
1248                 if (isspace(c))
1249                         buf[n++] = c;
1250         }
1251         s = PyString_FromStringAndSize(buf, n);
1252         if (s)
1253                 PyModule_AddObject(m, "whitespace", s);
1254
1255         /* Create 'lowercase' object */
1256         n = 0;
1257         for (c = 0; c < 256; c++) {
1258                 if (islower(c))
1259                         buf[n++] = c;
1260         }
1261         s = PyString_FromStringAndSize(buf, n);
1262         if (s)
1263                 PyModule_AddObject(m, "lowercase", s);
1264
1265         /* Create 'uppercase' object */
1266         n = 0;
1267         for (c = 0; c < 256; c++) {
1268                 if (isupper(c))
1269                         buf[n++] = c;
1270         }
1271         s = PyString_FromStringAndSize(buf, n);
1272         if (s)
1273                 PyModule_AddObject(m, "uppercase", s);
1274 }