X-Git-Url: https://git.proxmox.com/?p=mirror_edk2.git;a=blobdiff_plain;f=AppPkg%2FApplications%2FPython%2FPython-2.7.10%2FModules%2Fstropmodule.c;fp=AppPkg%2FApplications%2FPython%2FPython-2.7.10%2FModules%2Fstropmodule.c;h=0000000000000000000000000000000000000000;hp=cdc6cb8ef8bb19f60d6441f4d944d0db61722ebc;hb=964f432b9b0afe103c41c7613fade3e699118afe;hpb=e2d3a25f1a3135221a9c8061e1b8f90245d727eb

diff --git a/AppPkg/Applications/Python/Python-2.7.10/Modules/stropmodule.c b/AppPkg/Applications/Python/Python-2.7.10/Modules/stropmodule.c
deleted file mode 100644
index cdc6cb8ef8..0000000000
--- a/AppPkg/Applications/Python/Python-2.7.10/Modules/stropmodule.c
+++ /dev/null
@@ -1,1272 +0,0 @@
-/* strop module */
-
-#define PY_SSIZE_T_CLEAN
-#include "Python.h"
-#include <ctype.h>
-
-PyDoc_STRVAR(strop_module__doc__,
-"Common string manipulations, optimized for speed.\n"
-"\n"
-"Always use \"import string\" rather than referencing\n"
-"this module directly.");
-
-/* XXX This file assumes that the <ctype.h> is*() functions
-   XXX are defined for all 8-bit characters! */
-
-#define WARN if (PyErr_Warn(PyExc_DeprecationWarning, \
-               "strop functions are obsolete; use string methods")) \
-         return NULL
-
-/* The lstrip(), rstrip() and strip() functions are implemented
-   in do_strip(), which uses an additional parameter to indicate what
-   type of strip should occur. */
-
-#define LEFTSTRIP 0
-#define RIGHTSTRIP 1
-#define BOTHSTRIP 2
-
-
-static PyObject *
-split_whitespace(char *s, Py_ssize_t len, Py_ssize_t maxsplit)
-{
-    Py_ssize_t i = 0, j;
-    int err;
-    Py_ssize_t countsplit = 0;
-    PyObject* item;
-    PyObject *list = PyList_New(0);
-
-    if (list == NULL)
-        return NULL;
-
-    while (i < len) {
-        while (i < len && isspace(Py_CHARMASK(s[i]))) {
-            i = i+1;
-        }
-        j = i;
-        while (i < len && !isspace(Py_CHARMASK(s[i]))) {
-            i = i+1;
-        }
-        if (j < i) {
-            item = PyString_FromStringAndSize(s+j, i-j);
-            if (item == NULL)
-                goto finally;
-
-            err = PyList_Append(list, item);
-            Py_DECREF(item);
-            if (err < 0)
-                goto finally;
-
-            countsplit++;
-            while (i < len && isspace(Py_CHARMASK(s[i]))) {
-                i = i+1;
-            }
-            if (maxsplit && (countsplit >= maxsplit) && i < len) {
-                item = PyString_FromStringAndSize(
-                    s+i, len - i);
-                if (item == NULL)
-                    goto finally;
-
-                err = PyList_Append(list, item);
-                Py_DECREF(item);
-                if (err < 0)
-                    goto finally;
-
-                i = len;
-            }
-        }
-    }
-    return list;
-  finally:
-    Py_DECREF(list);
-    return NULL;
-}
-
-
-PyDoc_STRVAR(splitfields__doc__,
-"split(s [,sep [,maxsplit]]) -> list of strings\n"
-"splitfields(s [,sep [,maxsplit]]) -> list of strings\n"
-"\n"
-"Return a list of the words in the string s, using sep as the\n"
-"delimiter string.  If maxsplit is nonzero, splits into at most\n"
-"maxsplit words.  If sep is not specified, any whitespace string\n"
-"is a separator.  Maxsplit defaults to 0.\n"
-"\n"
-"(split and splitfields are synonymous)");
-
-static PyObject *
-strop_splitfields(PyObject *self, PyObject *args)
-{
-    Py_ssize_t len, n, i, j, err;
-    Py_ssize_t splitcount, maxsplit;
-    char *s, *sub;
-    PyObject *list, *item;
-
-    WARN;
-    sub = NULL;
-    n = 0;
-    splitcount = 0;
-    maxsplit = 0;
-    if (!PyArg_ParseTuple(args, "t#|z#n:split", &s, &len, &sub, &n, &maxsplit))
-        return NULL;
-    if (sub == NULL)
-        return split_whitespace(s, len, maxsplit);
-    if (n == 0) {
-        PyErr_SetString(PyExc_ValueError, "empty separator");
-        return NULL;
-    }
-
-    list = PyList_New(0);
-    if (list == NULL)
-        return NULL;
-
-    i = j = 0;
-    while (i+n <= len) {
-        if (s[i] == sub[0] && (n == 1 || memcmp(s+i, sub, n) == 0)) {
-            item = PyString_FromStringAndSize(s+j, i-j);
-            if (item == NULL)
-                goto fail;
-            err = PyList_Append(list, item);
-            Py_DECREF(item);
-            if (err < 0)
-                goto fail;
-            i = j = i + n;
-            splitcount++;
-            if (maxsplit && (splitcount >= maxsplit))
-                break;
-        }
-        else
-            i++;
-    }
-    item = PyString_FromStringAndSize(s+j, len-j);
-    if (item == NULL)
-        goto fail;
-    err = PyList_Append(list, item);
-    Py_DECREF(item);
-    if (err < 0)
-        goto fail;
-
-    return list;
-
- fail:
-    Py_DECREF(list);
-    return NULL;
-}
-
-
-PyDoc_STRVAR(joinfields__doc__,
-"join(list [,sep]) -> string\n"
-"joinfields(list [,sep]) -> string\n"
-"\n"
-"Return a string composed of the words in list, with\n"
-"intervening occurrences of sep.  Sep defaults to a single\n"
-"space.\n"
-"\n"
-"(join and joinfields are synonymous)");
-
-static PyObject *
-strop_joinfields(PyObject *self, PyObject *args)
-{
-    PyObject *seq;
-    char *sep = NULL;
-    Py_ssize_t seqlen, seplen = 0;
-    Py_ssize_t i, reslen = 0, slen = 0, sz = 100;
-    PyObject *res = NULL;
-    char* p = NULL;
-    ssizeargfunc getitemfunc;
-
-    WARN;
-    if (!PyArg_ParseTuple(args, "O|t#:join", &seq, &sep, &seplen))
-        return NULL;
-    if (sep == NULL) {
-        sep = " ";
-        seplen = 1;
-    }
-
-    seqlen = PySequence_Size(seq);
-    if (seqlen < 0 && PyErr_Occurred())
-        return NULL;
-
-    if (seqlen == 1) {
-        /* Optimization if there's only one item */
-        PyObject *item = PySequence_GetItem(seq, 0);
-        if (item && !PyString_Check(item)) {
-            PyErr_SetString(PyExc_TypeError,
-                     "first argument must be sequence of strings");
-            Py_DECREF(item);
-            return NULL;
-        }
-        return item;
-    }
-
-    if (!(res = PyString_FromStringAndSize((char*)NULL, sz)))
-        return NULL;
-    p = PyString_AsString(res);
-
-    /* optimize for lists, since it's the most common case.  all others
-     * (tuples and arbitrary sequences) just use the sequence abstract
-     * interface.
-     */
-    if (PyList_Check(seq)) {
-        for (i = 0; i < seqlen; i++) {
-            PyObject *item = PyList_GET_ITEM(seq, i);
-            if (!PyString_Check(item)) {
-                PyErr_SetString(PyExc_TypeError,
-                "first argument must be sequence of strings");
-                Py_DECREF(res);
-                return NULL;
-            }
-            slen = PyString_GET_SIZE(item);
-            if (slen > PY_SSIZE_T_MAX - reslen ||
-                seplen > PY_SSIZE_T_MAX - reslen - seplen) {
-                PyErr_SetString(PyExc_OverflowError,
-                                "input too long");
-                Py_DECREF(res);
-                return NULL;
-            }
-            while (reslen + slen + seplen >= sz) {
-                if (_PyString_Resize(&res, sz * 2) < 0)
-                    return NULL;
-                sz *= 2;
-                p = PyString_AsString(res) + reslen;
-            }
-            if (i > 0) {
-                memcpy(p, sep, seplen);
-                p += seplen;
-                reslen += seplen;
-            }
-            memcpy(p, PyString_AS_STRING(item), slen);
-            p += slen;
-            reslen += slen;
-        }
-        _PyString_Resize(&res, reslen);
-        return res;
-    }
-
-    if (seq->ob_type->tp_as_sequence == NULL ||
-             (getitemfunc = seq->ob_type->tp_as_sequence->sq_item) == NULL)
-    {
-        PyErr_SetString(PyExc_TypeError,
-                        "first argument must be a sequence");
-        return NULL;
-    }
-    /* This is now type safe */
-    for (i = 0; i < seqlen; i++) {
-        PyObject *item = getitemfunc(seq, i);
-        if (!item || !PyString_Check(item)) {
-            PyErr_SetString(PyExc_TypeError,
-                     "first argument must be sequence of strings");
-            Py_DECREF(res);
-            Py_XDECREF(item);
-            return NULL;
-        }
-        slen = PyString_GET_SIZE(item);
-        if (slen > PY_SSIZE_T_MAX - reslen ||
-            seplen > PY_SSIZE_T_MAX - reslen - seplen) {
-            PyErr_SetString(PyExc_OverflowError,
-                            "input too long");
-            Py_DECREF(res);
-            Py_XDECREF(item);
-            return NULL;
-        }
-        while (reslen + slen + seplen >= sz) {
-            if (_PyString_Resize(&res, sz * 2) < 0) {
-                Py_DECREF(item);
-                return NULL;
-            }
-            sz *= 2;
-            p = PyString_AsString(res) + reslen;
-        }
-        if (i > 0) {
-            memcpy(p, sep, seplen);
-            p += seplen;
-            reslen += seplen;
-        }
-        memcpy(p, PyString_AS_STRING(item), slen);
-        p += slen;
-        reslen += slen;
-        Py_DECREF(item);
-    }
-    _PyString_Resize(&res, reslen);
-    return res;
-}
-
-
-PyDoc_STRVAR(find__doc__,
-"find(s, sub [,start [,end]]) -> in\n"
-"\n"
-"Return the lowest index in s where substring sub is found,\n"
-"such that sub is contained within s[start,end].  Optional\n"
-"arguments start and end are interpreted as in slice notation.\n"
-"\n"
-"Return -1 on failure.");
-
-static PyObject *
-strop_find(PyObject *self, PyObject *args)
-{
-    char *s, *sub;
-    Py_ssize_t len, n, i = 0, last = PY_SSIZE_T_MAX;
-
-    WARN;
-    if (!PyArg_ParseTuple(args, "t#t#|nn:find", &s, &len, &sub, &n, &i, &last))
-        return NULL;
-
-    if (last > len)
-        last = len;
-    if (last < 0)
-        last += len;
-    if (last < 0)
-        last = 0;
-    if (i < 0)
-        i += len;
-    if (i < 0)
-        i = 0;
-
-    if (n == 0 && i <= last)
-        return PyInt_FromLong((long)i);
-
-    last -= n;
-    for (; i <= last; ++i)
-        if (s[i] == sub[0] &&
-            (n == 1 || memcmp(&s[i+1], &sub[1], n-1) == 0))
-            return PyInt_FromLong((long)i);
-
-    return PyInt_FromLong(-1L);
-}
-
-
-PyDoc_STRVAR(rfind__doc__,
-"rfind(s, sub [,start [,end]]) -> int\n"
-"\n"
-"Return the highest index in s where substring sub is found,\n"
-"such that sub is contained within s[start,end].  Optional\n"
-"arguments start and end are interpreted as in slice notation.\n"
-"\n"
-"Return -1 on failure.");
-
-static PyObject *
-strop_rfind(PyObject *self, PyObject *args)
-{
-    char *s, *sub;
-    Py_ssize_t len, n, j;
-    Py_ssize_t i = 0, last = PY_SSIZE_T_MAX;
-
-    WARN;
-    if (!PyArg_ParseTuple(args, "t#t#|nn:rfind", &s, &len, &sub, &n, &i, &last))
-        return NULL;
-
-    if (last > len)
-        last = len;
-    if (last < 0)
-        last += len;
-    if (last < 0)
-        last = 0;
-    if (i < 0)
-        i += len;
-    if (i < 0)
-        i = 0;
-
-    if (n == 0 && i <= last)
-        return PyInt_FromLong((long)last);
-
-    for (j = last-n; j >= i; --j)
-        if (s[j] == sub[0] &&
-            (n == 1 || memcmp(&s[j+1], &sub[1], n-1) == 0))
-            return PyInt_FromLong((long)j);
-
-    return PyInt_FromLong(-1L);
-}
-
-
-static PyObject *
-do_strip(PyObject *args, int striptype)
-{
-    char *s;
-    Py_ssize_t len, i, j;
-
-
-    if (PyString_AsStringAndSize(args, &s, &len))
-        return NULL;
-
-    i = 0;
-    if (striptype != RIGHTSTRIP) {
-        while (i < len && isspace(Py_CHARMASK(s[i]))) {
-            i++;
-        }
-    }
-
-    j = len;
-    if (striptype != LEFTSTRIP) {
-        do {
-            j--;
-        } while (j >= i && isspace(Py_CHARMASK(s[j])));
-        j++;
-    }
-
-    if (i == 0 && j == len) {
-        Py_INCREF(args);
-        return args;
-    }
-    else
-        return PyString_FromStringAndSize(s+i, j-i);
-}
-
-
-PyDoc_STRVAR(strip__doc__,
-"strip(s) -> string\n"
-"\n"
-"Return a copy of the string s with leading and trailing\n"
-"whitespace removed.");
-
-static PyObject *
-strop_strip(PyObject *self, PyObject *args)
-{
-    WARN;
-    return do_strip(args, BOTHSTRIP);
-}
-
-
-PyDoc_STRVAR(lstrip__doc__,
-"lstrip(s) -> string\n"
-"\n"
-"Return a copy of the string s with leading whitespace removed.");
-
-static PyObject *
-strop_lstrip(PyObject *self, PyObject *args)
-{
-    WARN;
-    return do_strip(args, LEFTSTRIP);
-}
-
-
-PyDoc_STRVAR(rstrip__doc__,
-"rstrip(s) -> string\n"
-"\n"
-"Return a copy of the string s with trailing whitespace removed.");
-
-static PyObject *
-strop_rstrip(PyObject *self, PyObject *args)
-{
-    WARN;
-    return do_strip(args, RIGHTSTRIP);
-}
-
-
-PyDoc_STRVAR(lower__doc__,
-"lower(s) -> string\n"
-"\n"
-"Return a copy of the string s converted to lowercase.");
-
-static PyObject *
-strop_lower(PyObject *self, PyObject *args)
-{
-    char *s, *s_new;
-    Py_ssize_t i, n;
-    PyObject *newstr;
-    int changed;
-
-    WARN;
-    if (PyString_AsStringAndSize(args, &s, &n))
-        return NULL;
-    newstr = PyString_FromStringAndSize(NULL, n);
-    if (newstr == NULL)
-        return NULL;
-    s_new = PyString_AsString(newstr);
-    changed = 0;
-    for (i = 0; i < n; i++) {
-        int c = Py_CHARMASK(*s++);
-        if (isupper(c)) {
-            changed = 1;
-            *s_new = tolower(c);
-        } else
-            *s_new = c;
-        s_new++;
-    }
-    if (!changed) {
-        Py_DECREF(newstr);
-        Py_INCREF(args);
-        return args;
-    }
-    return newstr;
-}
-
-
-PyDoc_STRVAR(upper__doc__,
-"upper(s) -> string\n"
-"\n"
-"Return a copy of the string s converted to uppercase.");
-
-static PyObject *
-strop_upper(PyObject *self, PyObject *args)
-{
-    char *s, *s_new;
-    Py_ssize_t i, n;
-    PyObject *newstr;
-    int changed;
-
-    WARN;
-    if (PyString_AsStringAndSize(args, &s, &n))
-        return NULL;
-    newstr = PyString_FromStringAndSize(NULL, n);
-    if (newstr == NULL)
-        return NULL;
-    s_new = PyString_AsString(newstr);
-    changed = 0;
-    for (i = 0; i < n; i++) {
-        int c = Py_CHARMASK(*s++);
-        if (islower(c)) {
-            changed = 1;
-            *s_new = toupper(c);
-        } else
-            *s_new = c;
-        s_new++;
-    }
-    if (!changed) {
-        Py_DECREF(newstr);
-        Py_INCREF(args);
-        return args;
-    }
-    return newstr;
-}
-
-
-PyDoc_STRVAR(capitalize__doc__,
-"capitalize(s) -> string\n"
-"\n"
-"Return a copy of the string s with only its first character\n"
-"capitalized.");
-
-static PyObject *
-strop_capitalize(PyObject *self, PyObject *args)
-{
-    char *s, *s_new;
-    Py_ssize_t i, n;
-    PyObject *newstr;
-    int changed;
-
-    WARN;
-    if (PyString_AsStringAndSize(args, &s, &n))
-        return NULL;
-    newstr = PyString_FromStringAndSize(NULL, n);
-    if (newstr == NULL)
-        return NULL;
-    s_new = PyString_AsString(newstr);
-    changed = 0;
-    if (0 < n) {
-        int c = Py_CHARMASK(*s++);
-        if (islower(c)) {
-            changed = 1;
-            *s_new = toupper(c);
-        } else
-            *s_new = c;
-        s_new++;
-    }
-    for (i = 1; i < n; i++) {
-        int c = Py_CHARMASK(*s++);
-        if (isupper(c)) {
-            changed = 1;
-            *s_new = tolower(c);
-        } else
-            *s_new = c;
-        s_new++;
-    }
-    if (!changed) {
-        Py_DECREF(newstr);
-        Py_INCREF(args);
-        return args;
-    }
-    return newstr;
-}
-
-
-PyDoc_STRVAR(expandtabs__doc__,
-"expandtabs(string, [tabsize]) -> string\n"
-"\n"
-"Expand tabs in a string, i.e. replace them by one or more spaces,\n"
-"depending on the current column and the given tab size (default 8).\n"
-"The column number is reset to zero after each newline occurring in the\n"
-"string.  This doesn't understand other non-printing characters.");
-
-static PyObject *
-strop_expandtabs(PyObject *self, PyObject *args)
-{
-    /* Original by Fredrik Lundh */
-    char* e;
-    char* p;
-    char* q;
-    Py_ssize_t i, j;
-    PyObject* out;
-    char* string;
-    Py_ssize_t stringlen;
-    int tabsize = 8;
-
-    WARN;
-    /* Get arguments */
-    if (!PyArg_ParseTuple(args, "s#|i:expandtabs", &string, &stringlen, &tabsize))
-        return NULL;
-    if (tabsize < 1) {
-        PyErr_SetString(PyExc_ValueError,
-                        "tabsize must be at least 1");
-        return NULL;
-    }
-
-    /* First pass: determine size of output string */
-    i = j = 0; /* j: current column; i: total of previous lines */
-    e = string + stringlen;
-    for (p = string; p < e; p++) {
-        if (*p == '\t') {
-            Py_ssize_t incr = tabsize - (j%tabsize);
-            if (j > PY_SSIZE_T_MAX - incr)
-                goto overflow;
-            j += incr;
-        } else {
-            if (j > PY_SSIZE_T_MAX - 1)
-                goto overflow;
-            j++;
-            if (*p == '\n') {
-                if (i > PY_SSIZE_T_MAX - j)
-                    goto overflow;
-                i += j;
-                j = 0;
-            }
-        }
-    }
-
-    if (i > PY_SSIZE_T_MAX - j)
-        goto overflow;
-
-    /* Second pass: create output string and fill it */
-    out = PyString_FromStringAndSize(NULL, i+j);
-    if (out == NULL)
-        return NULL;
-
-    i = 0;
-    q = PyString_AS_STRING(out);
-
-    for (p = string; p < e; p++) {
-        if (*p == '\t') {
-            j = tabsize - (i%tabsize);
-            i += j;
-            while (j-- > 0)
-                *q++ = ' ';
-        } else {
-            *q++ = *p;
-            i++;
-            if (*p == '\n')
-                i = 0;
-        }
-    }
-
-    return out;
-  overflow:
-    PyErr_SetString(PyExc_OverflowError, "result is too long");
-    return NULL;
-}
-
-
-PyDoc_STRVAR(count__doc__,
-"count(s, sub[, start[, end]]) -> int\n"
-"\n"
-"Return the number of occurrences of substring sub in string\n"
-"s[start:end].  Optional arguments start and end are\n"
-"interpreted as in slice notation.");
-
-static PyObject *
-strop_count(PyObject *self, PyObject *args)
-{
-    char *s, *sub;
-    Py_ssize_t len, n;
-    Py_ssize_t i = 0, last = PY_SSIZE_T_MAX;
-    Py_ssize_t m, r;
-
-    WARN;
-    if (!PyArg_ParseTuple(args, "t#t#|nn:count", &s, &len, &sub, &n, &i, &last))
-        return NULL;
-    if (last > len)
-        last = len;
-    if (last < 0)
-        last += len;
-    if (last < 0)
-        last = 0;
-    if (i < 0)
-        i += len;
-    if (i < 0)
-        i = 0;
-    m = last + 1 - n;
-    if (n == 0)
-        return PyInt_FromLong((long) (m-i));
-
-    r = 0;
-    while (i < m) {
-        if (!memcmp(s+i, sub, n)) {
-            r++;
-            i += n;
-        } else {
-            i++;
-        }
-    }
-    return PyInt_FromLong((long) r);
-}
-
-
-PyDoc_STRVAR(swapcase__doc__,
-"swapcase(s) -> string\n"
-"\n"
-"Return a copy of the string s with upper case characters\n"
-"converted to lowercase and vice versa.");
-
-static PyObject *
-strop_swapcase(PyObject *self, PyObject *args)
-{
-    char *s, *s_new;
-    Py_ssize_t i, n;
-    PyObject *newstr;
-    int changed;
-
-    WARN;
-    if (PyString_AsStringAndSize(args, &s, &n))
-        return NULL;
-    newstr = PyString_FromStringAndSize(NULL, n);
-    if (newstr == NULL)
-        return NULL;
-    s_new = PyString_AsString(newstr);
-    changed = 0;
-    for (i = 0; i < n; i++) {
-        int c = Py_CHARMASK(*s++);
-        if (islower(c)) {
-            changed = 1;
-            *s_new = toupper(c);
-        }
-        else if (isupper(c)) {
-            changed = 1;
-            *s_new = tolower(c);
-        }
-        else
-            *s_new = c;
-        s_new++;
-    }
-    if (!changed) {
-        Py_DECREF(newstr);
-        Py_INCREF(args);
-        return args;
-    }
-    return newstr;
-}
-
-
-PyDoc_STRVAR(atoi__doc__,
-"atoi(s [,base]) -> int\n"
-"\n"
-"Return the integer represented by the string s in the given\n"
-"base, which defaults to 10.  The string s must consist of one\n"
-"or more digits, possibly preceded by a sign.  If base is 0, it\n"
-"is chosen from the leading characters of s, 0 for octal, 0x or\n"
-"0X for hexadecimal.  If base is 16, a preceding 0x or 0X is\n"
-"accepted.");
-
-static PyObject *
-strop_atoi(PyObject *self, PyObject *args)
-{
-    char *s, *end;
-    int base = 10;
-    long x;
-    char buffer[256]; /* For errors */
-
-    WARN;
-    if (!PyArg_ParseTuple(args, "s|i:atoi", &s, &base))
-        return NULL;
-
-    if ((base != 0 && base < 2) || base > 36) {
-        PyErr_SetString(PyExc_ValueError, "invalid base for atoi()");
-        return NULL;
-    }
-
-    while (*s && isspace(Py_CHARMASK(*s)))
-        s++;
-    errno = 0;
-    if (base == 0 && s[0] == '0')
-        x = (long) PyOS_strtoul(s, &end, base);
-    else
-        x = PyOS_strtol(s, &end, base);
-    if (end == s || !isalnum(Py_CHARMASK(end[-1])))
-        goto bad;
-    while (*end && isspace(Py_CHARMASK(*end)))
-        end++;
-    if (*end != '\0') {
-  bad:
-        PyOS_snprintf(buffer, sizeof(buffer),
-                      "invalid literal for atoi(): %.200s", s);
-        PyErr_SetString(PyExc_ValueError, buffer);
-        return NULL;
-    }
-    else if (errno != 0) {
-        PyOS_snprintf(buffer, sizeof(buffer),
-                      "atoi() literal too large: %.200s", s);
-        PyErr_SetString(PyExc_ValueError, buffer);
-        return NULL;
-    }
-    return PyInt_FromLong(x);
-}
-
-
-PyDoc_STRVAR(atol__doc__,
-"atol(s [,base]) -> long\n"
-"\n"
-"Return the long integer represented by the string s in the\n"
-"given base, which defaults to 10.  The string s must consist\n"
-"of one or more digits, possibly preceded by a sign.  If base\n"
-"is 0, it is chosen from the leading characters of s, 0 for\n"
-"octal, 0x or 0X for hexadecimal.  If base is 16, a preceding\n"
-"0x or 0X is accepted.  A trailing L or l is not accepted,\n"
-"unless base is 0.");
-
-static PyObject *
-strop_atol(PyObject *self, PyObject *args)
-{
-    char *s, *end;
-    int base = 10;
-    PyObject *x;
-    char buffer[256]; /* For errors */
-
-    WARN;
-    if (!PyArg_ParseTuple(args, "s|i:atol", &s, &base))
-        return NULL;
-
-    if ((base != 0 && base < 2) || base > 36) {
-        PyErr_SetString(PyExc_ValueError, "invalid base for atol()");
-        return NULL;
-    }
-
-    while (*s && isspace(Py_CHARMASK(*s)))
-        s++;
-    if (s[0] == '\0') {
-        PyErr_SetString(PyExc_ValueError, "empty string for atol()");
-        return NULL;
-    }
-    x = PyLong_FromString(s, &end, base);
-    if (x == NULL)
-        return NULL;
-    if (base == 0 && (*end == 'l' || *end == 'L'))
-        end++;
-    while (*end && isspace(Py_CHARMASK(*end)))
-        end++;
-    if (*end != '\0') {
-        PyOS_snprintf(buffer, sizeof(buffer),
-                      "invalid literal for atol(): %.200s", s);
-        PyErr_SetString(PyExc_ValueError, buffer);
-        Py_DECREF(x);
-        return NULL;
-    }
-    return x;
-}
-
-
-PyDoc_STRVAR(atof__doc__,
-"atof(s) -> float\n"
-"\n"
-"Return the floating point number represented by the string s.");
-
-static PyObject *
-strop_atof(PyObject *self, PyObject *args)
-{
-    char *s, *end;
-    double x;
-    char buffer[256]; /* For errors */
-
-    WARN;
-    if (!PyArg_ParseTuple(args, "s:atof", &s))
-        return NULL;
-    while (*s && isspace(Py_CHARMASK(*s)))
-        s++;
-    if (s[0] == '\0') {
-        PyErr_SetString(PyExc_ValueError, "empty string for atof()");
-        return NULL;
-    }
-
-    PyFPE_START_PROTECT("strop_atof", return 0)
-    x = PyOS_string_to_double(s, &end, PyExc_OverflowError);
-    PyFPE_END_PROTECT(x)
-    if (x == -1 && PyErr_Occurred())
-        return NULL;
-    while (*end && isspace(Py_CHARMASK(*end)))
-        end++;
-    if (*end != '\0') {
-        PyOS_snprintf(buffer, sizeof(buffer),
-                      "invalid literal for atof(): %.200s", s);
-        PyErr_SetString(PyExc_ValueError, buffer);
-        return NULL;
-    }
-    return PyFloat_FromDouble(x);
-}
-
-
-PyDoc_STRVAR(maketrans__doc__,
-"maketrans(frm, to) -> string\n"
-"\n"
-"Return a translation table (a string of 256 bytes long)\n"
-"suitable for use in string.translate.  The strings frm and to\n"
-"must be of the same length.");
-
-static PyObject *
-strop_maketrans(PyObject *self, PyObject *args)
-{
-    unsigned char *c, *from=NULL, *to=NULL;
-    Py_ssize_t i, fromlen=0, tolen=0;
-    PyObject *result;
-
-    if (!PyArg_ParseTuple(args, "t#t#:maketrans", &from, &fromlen, &to, &tolen))
-        return NULL;
-
-    if (fromlen != tolen) {
-        PyErr_SetString(PyExc_ValueError,
-                        "maketrans arguments must have same length");
-        return NULL;
-    }
-
-    result = PyString_FromStringAndSize((char *)NULL, 256);
-    if (result == NULL)
-        return NULL;
-    c = (unsigned char *) PyString_AS_STRING((PyStringObject *)result);
-    for (i = 0; i < 256; i++)
-        c[i]=(unsigned char)i;
-    for (i = 0; i < fromlen; i++)
-        c[from[i]]=to[i];
-
-    return result;
-}
-
-
-PyDoc_STRVAR(translate__doc__,
-"translate(s,table [,deletechars]) -> string\n"
-"\n"
-"Return a copy of the string s, where all characters occurring\n"
-"in the optional argument deletechars are removed, and the\n"
-"remaining characters have been mapped through the given\n"
-"translation table, which must be a string of length 256.");
-
-static PyObject *
-strop_translate(PyObject *self, PyObject *args)
-{
-    register char *input, *table, *output;
-    Py_ssize_t i;
-    int c, changed = 0;
-    PyObject *input_obj;
-    char *table1, *output_start, *del_table=NULL;
-    Py_ssize_t inlen, tablen, dellen = 0;
-    PyObject *result;
-    int trans_table[256];
-
-    WARN;
-    if (!PyArg_ParseTuple(args, "St#|t#:translate", &input_obj,
-                          &table1, &tablen, &del_table, &dellen))
-        return NULL;
-    if (tablen != 256) {
-        PyErr_SetString(PyExc_ValueError,
-                      "translation table must be 256 characters long");
-        return NULL;
-    }
-
-    table = table1;
-    inlen = PyString_GET_SIZE(input_obj);
-    result = PyString_FromStringAndSize((char *)NULL, inlen);
-    if (result == NULL)
-        return NULL;
-    output_start = output = PyString_AsString(result);
-    input = PyString_AsString(input_obj);
-
-    if (dellen == 0) {
-        /* If no deletions are required, use faster code */
-        for (i = inlen; --i >= 0; ) {
-            c = Py_CHARMASK(*input++);
-            if (Py_CHARMASK((*output++ = table[c])) != c)
-                changed = 1;
-        }
-        if (changed)
-            return result;
-        Py_DECREF(result);
-        Py_INCREF(input_obj);
-        return input_obj;
-    }
-
-    for (i = 0; i < 256; i++)
-        trans_table[i] = Py_CHARMASK(table[i]);
-
-    for (i = 0; i < dellen; i++)
-        trans_table[(int) Py_CHARMASK(del_table[i])] = -1;
-
-    for (i = inlen; --i >= 0; ) {
-        c = Py_CHARMASK(*input++);
-        if (trans_table[c] != -1)
-            if (Py_CHARMASK(*output++ = (char)trans_table[c]) == c)
-                continue;
-        changed = 1;
-    }
-    if (!changed) {
-        Py_DECREF(result);
-        Py_INCREF(input_obj);
-        return input_obj;
-    }
-    /* Fix the size of the resulting string */
-    if (inlen > 0)
-        _PyString_Resize(&result, output - output_start);
-    return result;
-}
-
-
-/* What follows is used for implementing replace().  Perry Stoll. */
-
-/*
-  mymemfind
-
-  strstr replacement for arbitrary blocks of memory.
-
-  Locates the first occurrence in the memory pointed to by MEM of the
-  contents of memory pointed to by PAT.  Returns the index into MEM if
-  found, or -1 if not found.  If len of PAT is greater than length of
-  MEM, the function returns -1.
-*/
-static Py_ssize_t
-mymemfind(const char *mem, Py_ssize_t len, const char *pat, Py_ssize_t pat_len)
-{
-    register Py_ssize_t ii;
-
-    /* pattern can not occur in the last pat_len-1 chars */
-    len -= pat_len;
-
-    for (ii = 0; ii <= len; ii++) {
-        if (mem[ii] == pat[0] &&
-            (pat_len == 1 ||
-             memcmp(&mem[ii+1], &pat[1], pat_len-1) == 0)) {
-            return ii;
-        }
-    }
-    return -1;
-}
-
-/*
-  mymemcnt
-
-   Return the number of distinct times PAT is found in MEM.
-   meaning mem=1111 and pat==11 returns 2.
-       mem=11111 and pat==11 also return 2.
- */
-static Py_ssize_t
-mymemcnt(const char *mem, Py_ssize_t len, const char *pat, Py_ssize_t pat_len)
-{
-    register Py_ssize_t offset = 0;
-    Py_ssize_t nfound = 0;
-
-    while (len >= 0) {
-        offset = mymemfind(mem, len, pat, pat_len);
-        if (offset == -1)
-            break;
-        mem += offset + pat_len;
-        len -= offset + pat_len;
-        nfound++;
-    }
-    return nfound;
-}
-
-/*
-   mymemreplace
-
-   Return a string in which all occurrences of PAT in memory STR are
-   replaced with SUB.
-
-   If length of PAT is less than length of STR or there are no occurrences
-   of PAT in STR, then the original string is returned. Otherwise, a new
-   string is allocated here and returned.
-
-   on return, out_len is:
-       the length of output string, or
-       -1 if the input string is returned, or
-       unchanged if an error occurs (no memory).
-
-   return value is:
-       the new string allocated locally, or
-       NULL if an error occurred.
-*/
-static char *
-mymemreplace(const char *str, Py_ssize_t len,           /* input string */
-         const char *pat, Py_ssize_t pat_len,           /* pattern string to find */
-         const char *sub, Py_ssize_t sub_len,           /* substitution string */
-         Py_ssize_t count,                              /* number of replacements */
-         Py_ssize_t *out_len)
-{
-    char *out_s;
-    char *new_s;
-    Py_ssize_t nfound, offset, new_len;
-
-    if (len == 0 || pat_len > len)
-        goto return_same;
-
-    /* find length of output string */
-    nfound = mymemcnt(str, len, pat, pat_len);
-    if (count < 0)
-        count = PY_SSIZE_T_MAX;
-    else if (nfound > count)
-        nfound = count;
-    if (nfound == 0)
-        goto return_same;
-
-    new_len = len + nfound*(sub_len - pat_len);
-    if (new_len == 0) {
-        /* Have to allocate something for the caller to free(). */
-        out_s = (char *)PyMem_MALLOC(1);
-        if (out_s == NULL)
-            return NULL;
-        out_s[0] = '\0';
-    }
-    else {
-        assert(new_len > 0);
-        new_s = (char *)PyMem_MALLOC(new_len);
-        if (new_s == NULL)
-            return NULL;
-        out_s = new_s;
-
-        for (; count > 0 && len > 0; --count) {
-            /* find index of next instance of pattern */
-            offset = mymemfind(str, len, pat, pat_len);
-            if (offset == -1)
-                break;
-
-            /* copy non matching part of input string */
-            memcpy(new_s, str, offset);
-            str += offset + pat_len;
-            len -= offset + pat_len;
-
-            /* copy substitute into the output string */
-            new_s += offset;
-            memcpy(new_s, sub, sub_len);
-            new_s += sub_len;
-        }
-        /* copy any remaining values into output string */
-        if (len > 0)
-            memcpy(new_s, str, len);
-    }
-    *out_len = new_len;
-    return out_s;
-
-  return_same:
-    *out_len = -1;
-    return (char *)str; /* cast away const */
-}
-
-
-PyDoc_STRVAR(replace__doc__,
-"replace (str, old, new[, maxsplit]) -> string\n"
-"\n"
-"Return a copy of string str with all occurrences of substring\n"
-"old replaced by new. If the optional argument maxsplit is\n"
-"given, only the first maxsplit occurrences are replaced.");
-
-static PyObject *
-strop_replace(PyObject *self, PyObject *args)
-{
-    char *str, *pat,*sub,*new_s;
-    Py_ssize_t len,pat_len,sub_len,out_len;
-    Py_ssize_t count = -1;
-    PyObject *newstr;
-
-    WARN;
-    if (!PyArg_ParseTuple(args, "t#t#t#|n:replace",
-                          &str, &len, &pat, &pat_len, &sub, &sub_len,
-                          &count))
-        return NULL;
-    if (pat_len <= 0) {
-        PyErr_SetString(PyExc_ValueError, "empty pattern string");
-        return NULL;
-    }
-    /* CAUTION:  strop treats a replace count of 0 as infinity, unlke
-     * current (2.1) string.py and string methods.  Preserve this for
-     * ... well, hard to say for what <wink>.
-     */
-    if (count == 0)
-        count = -1;
-    new_s = mymemreplace(str,len,pat,pat_len,sub,sub_len,count,&out_len);
-    if (new_s == NULL) {
-        PyErr_NoMemory();
-        return NULL;
-    }
-    if (out_len == -1) {
-        /* we're returning another reference to the input string */
-        newstr = PyTuple_GetItem(args, 0);
-        Py_XINCREF(newstr);
-    }
-    else {
-        newstr = PyString_FromStringAndSize(new_s, out_len);
-        PyMem_FREE(new_s);
-    }
-    return newstr;
-}
-
-
-/* List of functions defined in the module */
-
-static PyMethodDef
-strop_methods[] = {
-    {"atof",            strop_atof,        METH_VARARGS, atof__doc__},
-    {"atoi",            strop_atoi,        METH_VARARGS, atoi__doc__},
-    {"atol",            strop_atol,        METH_VARARGS, atol__doc__},
-    {"capitalize",      strop_capitalize,  METH_O,       capitalize__doc__},
-    {"count",           strop_count,       METH_VARARGS, count__doc__},
-    {"expandtabs",      strop_expandtabs,  METH_VARARGS, expandtabs__doc__},
-    {"find",            strop_find,        METH_VARARGS, find__doc__},
-    {"join",            strop_joinfields,  METH_VARARGS, joinfields__doc__},
-    {"joinfields",      strop_joinfields,  METH_VARARGS, joinfields__doc__},
-    {"lstrip",          strop_lstrip,      METH_O,       lstrip__doc__},
-    {"lower",           strop_lower,       METH_O,       lower__doc__},
-    {"maketrans",       strop_maketrans,   METH_VARARGS, maketrans__doc__},
-    {"replace",         strop_replace,     METH_VARARGS, replace__doc__},
-    {"rfind",           strop_rfind,       METH_VARARGS, rfind__doc__},
-    {"rstrip",          strop_rstrip,      METH_O,       rstrip__doc__},
-    {"split",           strop_splitfields, METH_VARARGS, splitfields__doc__},
-    {"splitfields",     strop_splitfields, METH_VARARGS, splitfields__doc__},
-    {"strip",           strop_strip,       METH_O,       strip__doc__},
-    {"swapcase",        strop_swapcase,    METH_O,       swapcase__doc__},
-    {"translate",       strop_translate,   METH_VARARGS, translate__doc__},
-    {"upper",           strop_upper,       METH_O,       upper__doc__},
-    {NULL,              NULL}   /* sentinel */
-};
-
-
-PyMODINIT_FUNC
-initstrop(void)
-{
-    PyObject *m, *s;
-    char buf[256];
-    int c, n;
-    m = Py_InitModule4("strop", strop_methods, strop_module__doc__,
-                       (PyObject*)NULL, PYTHON_API_VERSION);
-    if (m == NULL)
-        return;
-
-    /* Create 'whitespace' object */
-    n = 0;
-    for (c = 0; c < 256; c++) {
-        if (isspace(c))
-            buf[n++] = c;
-    }
-    s = PyString_FromStringAndSize(buf, n);
-    if (s)
-        PyModule_AddObject(m, "whitespace", s);
-
-    /* Create 'lowercase' object */
-    n = 0;
-    for (c = 0; c < 256; c++) {
-        if (islower(c))
-            buf[n++] = c;
-    }
-    s = PyString_FromStringAndSize(buf, n);
-    if (s)
-        PyModule_AddObject(m, "lowercase", s);
-
-    /* Create 'uppercase' object */
-    n = 0;
-    for (c = 0; c < 256; c++) {
-        if (isupper(c))
-            buf[n++] = c;
-    }
-    s = PyString_FromStringAndSize(buf, n);
-    if (s)
-        PyModule_AddObject(m, "uppercase", s);
-}