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