startswith and endswith don't accept None as slice index

Objects/unicodeobject.c

 /*
 
 Unicode implementation based on original code by Fredrik Lundh,
 modified by Marc-Andre Lemburg <mal@lemburg.com> according to the
 Unicode Integration Proposal (see file Misc/unicode.txt).
 
 Major speed upgrades to the method implementations at the Reykjavik
 NeedForSpeed sprint, by Fredrik Lundh and Andrew Dalke.
 
 Copyright (c) Corporation for National Research Initiatives.
@@ skipping 23 matching lines @@
 ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
 OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 --------------------------------------------------------------------
 
 */
 
 #define PY_SSIZE_T_CLEAN
 #include "Python.h"
+#include "bytes_methods.h"
 
 #include "unicodeobject.h"
 #include "ucnhash.h"
 
 #ifdef MS_WINDOWS
 #include <windows.h>
 #endif
 
 /* Limit for the Unicode object free list */
 
@@ skipping 31 matching lines @@
    The globals are initialized by the _PyUnicode_Init() API and should
    not be used before calling that API.
 
 */
 
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+/* This dictionary holds all interned unicode strings.  Note that references
+   to strings in this dictionary are *not* counted in the string's ob_refcnt.
+   When the interned string reaches a refcnt of 0 the string deallocation
+   function will delete the reference from this dictionary.
+
+   Another way to look at this is that to say that the actual reference
+   count of a string is:  s->ob_refcnt + (s->state ? 2 : 0)
+*/
+static PyObject *interned;
+
 /* Free list for Unicode objects */
 static PyUnicodeObject *free_list;
 static int numfree;
 
 /* The empty Unicode object is shared to improve performance. */
 static PyUnicodeObject *unicode_empty;
 
 /* Single character Unicode strings in the Latin-1 range are being
    shared as well. */
 static PyUnicodeObject *unicode_latin1[256];
 
 /* Default encoding to use and assume when NULL is passed as encoding
-   parameter; it is initialized by _PyUnicode_Init().
-
-   Always use the PyUnicode_SetDefaultEncoding() and
-   PyUnicode_GetDefaultEncoding() APIs to access this global.
-
+   parameter; it is fixed to "utf-8".  Always use the
+   PyUnicode_GetDefaultEncoding() API to access this global.
+
+   Don't forget to alter Py_FileSystemDefaultEncoding if you change the
+   hard coded default!
 */
-static char unicode_default_encoding[100];
+static const char unicode_default_encoding[] = "utf-8";
 
 /* Fast detection of the most frequent whitespace characters */
 const unsigned char _Py_ascii_whitespace[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
-/*     case 0x0009: * CHARACTER TABULATION */
+/*     case 0x0009: * HORIZONTAL TABULATION */
 /*     case 0x000A: * LINE FEED */
-/*     case 0x000B: * LINE TABULATION */
+/*     case 0x000B: * VERTICAL TABULATION */
 /*     case 0x000C: * FORM FEED */
 /*     case 0x000D: * CARRIAGE RETURN */
     0, 1, 1, 1, 1, 1, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 /*     case 0x001C: * FILE SEPARATOR */
 /*     case 0x001D: * GROUP SEPARATOR */
 /*     case 0x001E: * RECORD SEPARATOR */
 /*     case 0x001F: * UNIT SEPARATOR */
     0, 0, 0, 0, 1, 1, 1, 1,
 /*     case 0x0020: * SPACE */
     1, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0
 };
 
+static PyObject *unicode_encode_call_errorhandler(const char *errors,
+       PyObject **errorHandler,const char *encoding, const char *reason,
+       const Py_UNICODE *unicode, Py_ssize_t size, PyObject **exceptionObject,
+       Py_ssize_t startpos, Py_ssize_t endpos, Py_ssize_t *newpos);
+
+static void raise_encode_exception(PyObject **exceptionObject,
+                                   const char *encoding,
+                                   const Py_UNICODE *unicode, Py_ssize_t size,
+                                   Py_ssize_t startpos, Py_ssize_t endpos,
+                                   const char *reason);
+
 /* Same for linebreaks */
 static unsigned char ascii_linebreak[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
 /*         0x000A, * LINE FEED */
-/*         0x000B, * LINE TABULATION */
-/*         0x000C, * FORM FEED */
 /*         0x000D, * CARRIAGE RETURN */
-    0, 0, 1, 1, 1, 1, 0, 0,
+    0, 0, 1, 0, 0, 1, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 /*         0x001C, * FILE SEPARATOR */
 /*         0x001D, * GROUP SEPARATOR */
 /*         0x001E, * RECORD SEPARATOR */
     0, 0, 0, 0, 1, 1, 1, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
 
@@ skipping 21 matching lines @@
 }
 
 /* --- Bloom Filters ----------------------------------------------------- */
 
 /* stuff to implement simple "bloom filters" for Unicode characters.
    to keep things simple, we use a single bitmask, using the least 5
    bits from each unicode characters as the bit index. */
 
 /* the linebreak mask is set up by Unicode_Init below */
 
-#if LONG_BIT >= 128
-#define BLOOM_WIDTH 128
-#elif LONG_BIT >= 64
-#define BLOOM_WIDTH 64
-#elif LONG_BIT >= 32
-#define BLOOM_WIDTH 32
-#else
-#error "LONG_BIT is smaller than 32"
-#endif
-
 #define BLOOM_MASK unsigned long
 
 static BLOOM_MASK bloom_linebreak;
 
-#define BLOOM_ADD(mask, ch) ((mask |= (1UL << ((ch) & (BLOOM_WIDTH - 1)))))
-#define BLOOM(mask, ch)     ((mask &  (1UL << ((ch) & (BLOOM_WIDTH - 1)))))
+#define BLOOM(mask, ch) ((mask & (1 << ((ch) & 0x1F))))
 
 #define BLOOM_LINEBREAK(ch)                                             \
     ((ch) < 128U ? ascii_linebreak[(ch)] :                              \
      (BLOOM(bloom_linebreak, (ch)) && Py_UNICODE_ISLINEBREAK(ch)))
 
 Py_LOCAL_INLINE(BLOOM_MASK) make_bloom_mask(Py_UNICODE* ptr, Py_ssize_t len)
 {
     /* calculate simple bloom-style bitmask for a given unicode string */
 
-    BLOOM_MASK mask;
+    long mask;
     Py_ssize_t i;
 
     mask = 0;
     for (i = 0; i < len; i++)
-        BLOOM_ADD(mask, ptr[i]);
+        mask |= (1 << (ptr[i] & 0x1F));
 
     return mask;
 }
 
 Py_LOCAL_INLINE(int) unicode_member(Py_UNICODE chr, Py_UNICODE* set, Py_ssize_t setlen)
 {
     Py_ssize_t i;
 
     for (i = 0; i < setlen; i++)
         if (set[i] == chr)
@@ skipping 19 matching lines @@
 
     /* Resizing shared object (unicode_empty or single character
        objects) in-place is not allowed. Use PyUnicode_Resize()
        instead ! */
 
     if (unicode == unicode_empty ||
         (unicode->length == 1 &&
          unicode->str[0] < 256U &&
          unicode_latin1[unicode->str[0]] == unicode)) {
         PyErr_SetString(PyExc_SystemError,
-                        "can't resize shared unicode objects");
+                        "can't resize shared str objects");
         return -1;
     }
 
     /* We allocate one more byte to make sure the string is Ux0000 terminated.
        The overallocation is also used by fastsearch, which assumes that it's
        safe to look at str[length] (without making any assumptions about what
        it contains). */
 
     oldstr = unicode->str;
     unicode->str = PyObject_REALLOC(unicode->str,
@@ skipping 10 matching lines @@
     /* Reset the object caches */
     if (unicode->defenc) {
         Py_CLEAR(unicode->defenc);
     }
     unicode->hash = -1;
 
     return 0;
 }
 
 /* We allocate one more byte to make sure the string is
-   Ux0000 terminated; some code relies on that.
+   Ux0000 terminated; some code (e.g. new_identifier)
+   relies on that.
 
    XXX This allocator could further be enhanced by assuring that the
    free list never reduces its size below 1.
 
 */
 
 static
 PyUnicodeObject *_PyUnicode_New(Py_ssize_t length)
 {
     register PyUnicodeObject *unicode;
@@ skipping 46 matching lines @@
      * the caller fails before initializing str -- unicode_resize()
      * reads str[0], and the Keep-Alive optimization can keep memory
      * allocated for str alive across a call to unicode_dealloc(unicode).
      * We don't want unicode_resize to read uninitialized memory in
      * that case.
      */
     unicode->str[0] = 0;
     unicode->str[length] = 0;
     unicode->length = length;
     unicode->hash = -1;
+    unicode->state = 0;
     unicode->defenc = NULL;
     return unicode;
 
   onError:
     /* XXX UNREF/NEWREF interface should be more symmetrical */
     _Py_DEC_REFTOTAL;
     _Py_ForgetReference((PyObject *)unicode);
     PyObject_Del(unicode);
     return NULL;
 }
 
 static
 void unicode_dealloc(register PyUnicodeObject *unicode)
 {
+    switch (PyUnicode_CHECK_INTERNED(unicode)) {
+    case SSTATE_NOT_INTERNED:
+        break;
+
+    case SSTATE_INTERNED_MORTAL:
+        /* revive dead object temporarily for DelItem */
+        Py_REFCNT(unicode) = 3;
+        if (PyDict_DelItem(interned, (PyObject *)unicode) != 0)
+            Py_FatalError(
+                "deletion of interned string failed");
+        break;
+
+    case SSTATE_INTERNED_IMMORTAL:
+        Py_FatalError("Immortal interned string died.");
+
+    default:
+        Py_FatalError("Inconsistent interned string state.");
+    }
+
     if (PyUnicode_CheckExact(unicode) &&
         numfree < PyUnicode_MAXFREELIST) {
         /* Keep-Alive optimization */
         if (unicode->length >= KEEPALIVE_SIZE_LIMIT) {
             PyObject_DEL(unicode->str);
             unicode->str = NULL;
             unicode->length = 0;
         }
         if (unicode->defenc) {
             Py_CLEAR(unicode->defenc);
@@ skipping 164 matching lines @@
 
 PyObject *PyUnicode_FromWideChar(register const wchar_t *w,
                                  Py_ssize_t size)
 {
     PyUnicodeObject *unicode;
     register Py_ssize_t i;
     Py_ssize_t alloc;
     const wchar_t *orig_w;
 
     if (w == NULL) {
+        if (size == 0)
+            return PyUnicode_FromStringAndSize(NULL, 0);
         PyErr_BadInternalCall();
         return NULL;
+    }
+
+    if (size == -1) {
+        size = wcslen(w);
     }
 
     alloc = size;
     orig_w = w;
     for (i = size; i > 0; i--) {
         if (*w > 0xFFFF)
             alloc++;
         w++;
     }
     w = orig_w;
@@ skipping 20 matching lines @@
 }
 
 #else
 
 PyObject *PyUnicode_FromWideChar(register const wchar_t *w,
                                  Py_ssize_t size)
 {
     PyUnicodeObject *unicode;
 
     if (w == NULL) {
+        if (size == 0)
+            return PyUnicode_FromStringAndSize(NULL, 0);
         PyErr_BadInternalCall();
         return NULL;
+    }
+
+    if (size == -1) {
+        size = wcslen(w);
     }
 
     unicode = _PyUnicode_New(size);
     if (!unicode)
         return NULL;
 
     /* Copy the wchar_t data into the new object */
 #ifdef HAVE_USABLE_WCHAR_T
     memcpy(unicode->str, w, size * sizeof(wchar_t));
 #else
@@ skipping 63 matching lines @@
 
 #ifdef VA_LIST_IS_ARRAY
     Py_MEMCPY(count, vargs, sizeof(va_list));
 #else
 #ifdef  __va_copy
     __va_copy(count, vargs);
 #else
     count = vargs;
 #endif
 #endif
-     /* step 1: count the number of %S/%R/%s format specifications
-      * (we call PyObject_Str()/PyObject_Repr()/PyUnicode_DecodeUTF8() for these
-      * objects once during step 3 and put the result in an array) */
+    /* step 1: count the number of %S/%R/%A/%s format specifications
+     * (we call PyObject_Str()/PyObject_Repr()/PyObject_ASCII()/
+     * PyUnicode_DecodeUTF8() for these objects once during step 3 and put the
+     * result in an array) */
     for (f = format; *f; f++) {
          if (*f == '%') {
              if (*(f+1)=='%')
                  continue;
-             if (*(f+1)=='S' || *(f+1)=='R')
+             if (*(f+1)=='S' || *(f+1)=='R' || *(f+1)=='A')
                  ++callcount;
-             while (isdigit((unsigned)*f))
+             while (ISDIGIT((unsigned)*f))
                  width = (width*10) + *f++ - '0';
-             while (*++f && *f != '%' && !isalpha((unsigned)*f))
+             while (*++f && *f != '%' && !ISALPHA((unsigned)*f))
                  ;
              if (*f == 's')
                  ++callcount;
          }
     }
     /* step 2: allocate memory for the results of
      * PyObject_Str()/PyObject_Repr()/PyUnicode_DecodeUTF8() calls */
     if (callcount) {
         callresults = PyObject_Malloc(sizeof(PyObject *)*callcount);
         if (!callresults) {
             PyErr_NoMemory();
             return NULL;
         }
         callresult = callresults;
     }
     /* step 3: figure out how large a buffer we need */
     for (f = format; *f; f++) {
         if (*f == '%') {
             const char* p = f;
             width = 0;
-            while (isdigit((unsigned)*f))
+            while (ISDIGIT((unsigned)*f))
                 width = (width*10) + *f++ - '0';
-            while (*++f && *f != '%' && !isalpha((unsigned)*f))
+            while (*++f && *f != '%' && !ISALPHA((unsigned)*f))
                 ;
 
             /* skip the 'l' or 'z' in {%ld, %zd, %lu, %zu} since
              * they don't affect the amount of space we reserve.
              */
             if ((*f == 'l' || *f == 'z') &&
                 (f[1] == 'd' || f[1] == 'u'))
                 ++f;
 
             switch (*f) {
@@ skipping 66 matching lines @@
                 PyObject *repr;
                 assert(obj);
                 repr = PyObject_Repr(obj);
                 if (!repr)
                     goto fail;
                 n += PyUnicode_GET_SIZE(repr);
                 /* Remember the repr and switch to the next slot */
                 *callresult++ = repr;
                 break;
             }
+            case 'A':
+            {
+                PyObject *obj = va_arg(count, PyObject *);
+                PyObject *ascii;
+                assert(obj);
+                ascii = PyObject_ASCII(obj);
+                if (!ascii)
+                    goto fail;
+                n += PyUnicode_GET_SIZE(ascii);
+                /* Remember the repr and switch to the next slot */
+                *callresult++ = ascii;
+                break;
+            }
             case 'p':
                 (void) va_arg(count, int);
                 /* maximum 64-bit pointer representation:
                  * 0xffffffffffffffff
                  * so 19 characters is enough.
                  * XXX I count 18 -- what's the extra for?
                  */
                 n += 19;
                 break;
             default:
@@ skipping 32 matching lines @@
     callresult = callresults;
 
     for (f = format; *f; f++) {
         if (*f == '%') {
             const char* p = f++;
             int longflag = 0;
             int size_tflag = 0;
             zeropad = (*f == '0');
             /* parse the width.precision part */
             width = 0;
-            while (isdigit((unsigned)*f))
+            while (ISDIGIT((unsigned)*f))
                 width = (width*10) + *f++ - '0';
             precision = 0;
             if (*f == '.') {
                 f++;
-                while (isdigit((unsigned)*f))
+                while (ISDIGIT((unsigned)*f))
                     precision = (precision*10) + *f++ - '0';
             }
             /* handle the long flag, but only for %ld and %lu.
                others can be added when necessary. */
             if (*f == 'l' && (f[1] == 'd' || f[1] == 'u')) {
                 longflag = 1;
                 ++f;
             }
             /* handle the size_t flag. */
             if (*f == 'z' && (f[1] == 'd' || f[1] == 'u')) {
@@ skipping 177 matching lines @@
     if (size > PyUnicode_GET_SIZE(unicode))
         return PyUnicode_GET_SIZE(unicode);
     else
         return size;
 }
 
 #endif
 
 PyObject *PyUnicode_FromOrdinal(int ordinal)
 {
-    Py_UNICODE s[1];
-
-#ifdef Py_UNICODE_WIDE
+    Py_UNICODE s[2];
+
     if (ordinal < 0 || ordinal > 0x10ffff) {
         PyErr_SetString(PyExc_ValueError,
-                        "unichr() arg not in range(0x110000) "
-                        "(wide Python build)");
-        return NULL;
-    }
-#else
-    if (ordinal < 0 || ordinal > 0xffff) {
-        PyErr_SetString(PyExc_ValueError,
-                        "unichr() arg not in range(0x10000) "
-                        "(narrow Python build)");
-        return NULL;
+                        "chr() arg not in range(0x110000)");
+        return NULL;
+    }
+
+#ifndef Py_UNICODE_WIDE
+    if (ordinal > 0xffff) {
+        ordinal -= 0x10000;
+        s[0] = 0xD800 | (ordinal >> 10);
+        s[1] = 0xDC00 | (ordinal & 0x3FF);
+        return PyUnicode_FromUnicode(s, 2);
     }
 #endif
 
     s[0] = (Py_UNICODE)ordinal;
     return PyUnicode_FromUnicode(s, 1);
 }
 
 PyObject *PyUnicode_FromObject(register PyObject *obj)
 {
     /* XXX Perhaps we should make this API an alias of
-       PyObject_Unicode() instead ?! */
+       PyObject_Str() instead ?! */
     if (PyUnicode_CheckExact(obj)) {
         Py_INCREF(obj);
         return obj;
     }
     if (PyUnicode_Check(obj)) {
         /* For a Unicode subtype that's not a Unicode object,
            return a true Unicode object with the same data. */
         return PyUnicode_FromUnicode(PyUnicode_AS_UNICODE(obj),
                                      PyUnicode_GET_SIZE(obj));
     }
-    return PyUnicode_FromEncodedObject(obj, NULL, "strict");
+    PyErr_Format(PyExc_TypeError,
+                 "Can't convert '%.100s' object to str implicitly",
+                 Py_TYPE(obj)->tp_name);
+    return NULL;
 }
 
 PyObject *PyUnicode_FromEncodedObject(register PyObject *obj,
                                       const char *encoding,
                                       const char *errors)
 {
-    const char *s = NULL;
-    Py_ssize_t len;
+    Py_buffer buffer;
     PyObject *v;
 
     if (obj == NULL) {
         PyErr_BadInternalCall();
         return NULL;
     }
 
-#if 0
-    /* For b/w compatibility we also accept Unicode objects provided
-       that no encodings is given and then redirect to
-       PyObject_Unicode() which then applies the additional logic for
-       Unicode subclasses.
-
-       NOTE: This API should really only be used for object which
-       represent *encoded* Unicode !
-
-    */
-    if (PyUnicode_Check(obj)) {
-        if (encoding) {
-            PyErr_SetString(PyExc_TypeError,
-                            "decoding Unicode is not supported");
-            return NULL;
-        }
-        return PyObject_Unicode(obj);
-    }
-#else
+    /* Decoding bytes objects is the most common case and should be fast */
+    if (PyBytes_Check(obj)) {
+        if (PyBytes_GET_SIZE(obj) == 0) {
+            Py_INCREF(unicode_empty);
+            v = (PyObject *) unicode_empty;
+        }
+        else {
+            v = PyUnicode_Decode(
+                    PyBytes_AS_STRING(obj), PyBytes_GET_SIZE(obj),
+                    encoding, errors);
+        }
+        return v;
+    }
+
     if (PyUnicode_Check(obj)) {
         PyErr_SetString(PyExc_TypeError,
-                        "decoding Unicode is not supported");
-        return NULL;
-    }
-#endif
-
-    /* Coerce object */
-    if (PyString_Check(obj)) {
-        s = PyString_AS_STRING(obj);
-        len = PyString_GET_SIZE(obj);
-    }
-    else if (PyByteArray_Check(obj)) {
-        /* Python 2.x specific */
+                        "decoding str is not supported");
+        return NULL;
+    }
+
+    /* Retrieve a bytes buffer view through the PEP 3118 buffer interface */
+    if (PyObject_GetBuffer(obj, &buffer, PyBUF_SIMPLE) < 0) {
         PyErr_Format(PyExc_TypeError,
-                     "decoding bytearray is not supported");
-        return NULL;
-    }
-    else if (PyObject_AsCharBuffer(obj, &s, &len)) {
-        /* Overwrite the error message with something more useful in
-           case of a TypeError. */
-        if (PyErr_ExceptionMatches(PyExc_TypeError))
-            PyErr_Format(PyExc_TypeError,
-                         "coercing to Unicode: need string or buffer, "
-                         "%.80s found",
-                         Py_TYPE(obj)->tp_name);
-        goto onError;
-    }
-
-    /* Convert to Unicode */
-    if (len == 0) {
+                     "coercing to str: need bytes, bytearray "
+                     "or buffer-like object, %.80s found",
+                     Py_TYPE(obj)->tp_name);
+        return NULL;
+    }
+
+    if (buffer.len == 0) {
         Py_INCREF(unicode_empty);
-        v = (PyObject *)unicode_empty;
+        v = (PyObject *) unicode_empty;
     }
     else
-        v = PyUnicode_Decode(s, len, encoding, errors);
-
+        v = PyUnicode_Decode((char*) buffer.buf, buffer.len, encoding, errors);
+
+    PyBuffer_Release(&buffer);
     return v;
-
-  onError:
-    return NULL;
 }
 
 PyObject *PyUnicode_Decode(const char *s,
                            Py_ssize_t size,
                            const char *encoding,
                            const char *errors)
 {
     PyObject *buffer = NULL, *unicode;
+    Py_buffer info;
+    char lower[20];  /* Enough for any encoding name we recognize */
+    char *l;
+    const char *e;
 
     if (encoding == NULL)
         encoding = PyUnicode_GetDefaultEncoding();
 
+    /* Convert encoding to lower case and replace '_' with '-' in order to
+       catch e.g. UTF_8 */
+    e = encoding;
+    l = lower;
+    while (*e && l < &lower[(sizeof lower) - 2]) {
+        if (ISUPPER(*e)) {
+            *l++ = TOLOWER(*e++);
+        }
+        else if (*e == '_') {
+            *l++ = '-';
+            e++;
+        }
+        else {
+            *l++ = *e++;
+        }
+    }
+    *l = '\0';
+
     /* Shortcuts for common default encodings */
-    if (strcmp(encoding, "utf-8") == 0)
+    if (strcmp(lower, "utf-8") == 0)
         return PyUnicode_DecodeUTF8(s, size, errors);
-    else if (strcmp(encoding, "latin-1") == 0)
+    else if ((strcmp(lower, "latin-1") == 0) ||
+             (strcmp(lower, "iso-8859-1") == 0))
         return PyUnicode_DecodeLatin1(s, size, errors);
 #if defined(MS_WINDOWS) && defined(HAVE_USABLE_WCHAR_T)
-    else if (strcmp(encoding, "mbcs") == 0)
+    else if (strcmp(lower, "mbcs") == 0)
         return PyUnicode_DecodeMBCS(s, size, errors);
 #endif
-    else if (strcmp(encoding, "ascii") == 0)
+    else if (strcmp(lower, "ascii") == 0)
         return PyUnicode_DecodeASCII(s, size, errors);
+    else if (strcmp(lower, "utf-16") == 0)
+        return PyUnicode_DecodeUTF16(s, size, errors, 0);
+    else if (strcmp(lower, "utf-32") == 0)
+        return PyUnicode_DecodeUTF32(s, size, errors, 0);
 
     /* Decode via the codec registry */
-    buffer = PyBuffer_FromMemory((void *)s, size);
+    buffer = NULL;
+    if (PyBuffer_FillInfo(&info, NULL, (void *)s, size, 1, PyBUF_FULL_RO) < 0)
+        goto onError;
+    buffer = PyMemoryView_FromBuffer(&info);
     if (buffer == NULL)
         goto onError;
     unicode = PyCodec_Decode(buffer, encoding, errors);
     if (unicode == NULL)
         goto onError;
     if (!PyUnicode_Check(unicode)) {
         PyErr_Format(PyExc_TypeError,
-                     "decoder did not return an unicode object (type=%.400s)",
+                     "decoder did not return a str object (type=%.400s)",
                      Py_TYPE(unicode)->tp_name);
         Py_DECREF(unicode);
         goto onError;
     }
     Py_DECREF(buffer);
     return unicode;
 
   onError:
     Py_XDECREF(buffer);
     return NULL;
@@ skipping 16 matching lines @@
     /* Decode via the codec registry */
     v = PyCodec_Decode(unicode, encoding, errors);
     if (v == NULL)
         goto onError;
     return v;
 
   onError:
     return NULL;
 }
 
+PyObject *PyUnicode_AsDecodedUnicode(PyObject *unicode,
+                                     const char *encoding,
+                                     const char *errors)
+{
+    PyObject *v;
+
+    if (!PyUnicode_Check(unicode)) {
+        PyErr_BadArgument();
+        goto onError;
+    }
+
+    if (encoding == NULL)
+        encoding = PyUnicode_GetDefaultEncoding();
+
+    /* Decode via the codec registry */
+    v = PyCodec_Decode(unicode, encoding, errors);
+    if (v == NULL)
+        goto onError;
+    if (!PyUnicode_Check(v)) {
+        PyErr_Format(PyExc_TypeError,
+                     "decoder did not return a str object (type=%.400s)",
+                     Py_TYPE(v)->tp_name);
+        Py_DECREF(v);
+        goto onError;
+    }
+    return v;
+
+  onError:
+    return NULL;
+}
+
 PyObject *PyUnicode_Encode(const Py_UNICODE *s,
                            Py_ssize_t size,
                            const char *encoding,
                            const char *errors)
 {
     PyObject *v, *unicode;
 
     unicode = PyUnicode_FromUnicode(s, size);
     if (unicode == NULL)
         return NULL;
@@ skipping 27 matching lines @@
 }
 
 PyObject *PyUnicode_AsEncodedString(PyObject *unicode,
                                     const char *encoding,
                                     const char *errors)
 {
     PyObject *v;
 
     if (!PyUnicode_Check(unicode)) {
         PyErr_BadArgument();
-        goto onError;
+        return NULL;
     }
 
     if (encoding == NULL)
         encoding = PyUnicode_GetDefaultEncoding();
 
     /* Shortcuts for common default encodings */
     if (errors == NULL) {
         if (strcmp(encoding, "utf-8") == 0)
             return PyUnicode_AsUTF8String(unicode);
         else if (strcmp(encoding, "latin-1") == 0)
             return PyUnicode_AsLatin1String(unicode);
 #if defined(MS_WINDOWS) && defined(HAVE_USABLE_WCHAR_T)
         else if (strcmp(encoding, "mbcs") == 0)
             return PyUnicode_AsMBCSString(unicode);
 #endif
         else if (strcmp(encoding, "ascii") == 0)
             return PyUnicode_AsASCIIString(unicode);
-    }
+        /* During bootstrap, we may need to find the encodings
+           package, to load the file system encoding, and require the
+           file system encoding in order to load the encodings
+           package.
+
+           Break out of this dependency by assuming that the path to
+           the encodings module is ASCII-only.  XXX could try wcstombs
+           instead, if the file system encoding is the locale's
+           encoding. */
+        else if (Py_FileSystemDefaultEncoding &&
+                 strcmp(encoding, Py_FileSystemDefaultEncoding) == 0 &&
+                 !PyThreadState_GET()->interp->codecs_initialized)
+            return PyUnicode_AsASCIIString(unicode);
+    }
+
+    /* Encode via the codec registry */
+    v = PyCodec_Encode(unicode, encoding, errors);
+    if (v == NULL)
+        return NULL;
+
+    /* The normal path */
+    if (PyBytes_Check(v))
+        return v;
+
+    /* If the codec returns a buffer, raise a warning and convert to bytes */
+    if (PyByteArray_Check(v)) {
+        char msg[100];
+        PyObject *b;
+        PyOS_snprintf(msg, sizeof(msg),
+                      "encoder %s returned buffer instead of bytes",
+                      encoding);
+        if (PyErr_WarnEx(PyExc_RuntimeWarning, msg, 1) < 0) {
+            Py_DECREF(v);
+            return NULL;
+        }
+
+        b = PyBytes_FromStringAndSize(PyByteArray_AS_STRING(v), Py_SIZE(v));
+        Py_DECREF(v);
+        return b;
+    }
+
+    PyErr_Format(PyExc_TypeError,
+                 "encoder did not return a bytes object (type=%.400s)",
+                 Py_TYPE(v)->tp_name);
+    Py_DECREF(v);
+    return NULL;
+}
+
+PyObject *PyUnicode_AsEncodedUnicode(PyObject *unicode,
+                                     const char *encoding,
+                                     const char *errors)
+{
+    PyObject *v;
+
+    if (!PyUnicode_Check(unicode)) {
+        PyErr_BadArgument();
+        goto onError;
+    }
+
+    if (encoding == NULL)
+        encoding = PyUnicode_GetDefaultEncoding();
 
     /* Encode via the codec registry */
     v = PyCodec_Encode(unicode, encoding, errors);
     if (v == NULL)
         goto onError;
-    if (!PyString_Check(v)) {
+    if (!PyUnicode_Check(v)) {
         PyErr_Format(PyExc_TypeError,
-                     "encoder did not return a string object (type=%.400s)",
+                     "encoder did not return an str object (type=%.400s)",
                      Py_TYPE(v)->tp_name);
         Py_DECREF(v);
         goto onError;
     }
     return v;
 
   onError:
     return NULL;
 }
 
 PyObject *_PyUnicode_AsDefaultEncodedString(PyObject *unicode,
                                             const char *errors)
 {
     PyObject *v = ((PyUnicodeObject *)unicode)->defenc;
-
     if (v)
         return v;
-    v = PyUnicode_AsEncodedString(unicode, NULL, errors);
-    if (v && errors == NULL)
-        ((PyUnicodeObject *)unicode)->defenc = v;
+    if (errors != NULL)
+        Py_FatalError("non-NULL encoding in _PyUnicode_AsDefaultEncodedString");
+    v = PyUnicode_EncodeUTF8(PyUnicode_AS_UNICODE(unicode),
+                             PyUnicode_GET_SIZE(unicode),
+                             NULL);
+    if (!v)
+        return NULL;
+    ((PyUnicodeObject *)unicode)->defenc = v;
     return v;
+}
+
+PyObject*
+PyUnicode_DecodeFSDefault(const char *s) {
+    Py_ssize_t size = (Py_ssize_t)strlen(s);
+    return PyUnicode_DecodeFSDefaultAndSize(s, size);
+}
+
+PyObject*
+PyUnicode_DecodeFSDefaultAndSize(const char *s, Py_ssize_t size)
+{
+    /* During the early bootstrapping process, Py_FileSystemDefaultEncoding
+       can be undefined. If it is case, decode using UTF-8. The following assumes
+       that Py_FileSystemDefaultEncoding is set to a built-in encoding during the
+       bootstrapping process where the codecs aren't ready yet.
+    */
+    if (Py_FileSystemDefaultEncoding) {
+#if defined(MS_WINDOWS) && defined(HAVE_USABLE_WCHAR_T)
+        if (strcmp(Py_FileSystemDefaultEncoding, "mbcs") == 0) {
+            return PyUnicode_DecodeMBCS(s, size, "replace");
+        }
+#elif defined(__APPLE__)
+        if (strcmp(Py_FileSystemDefaultEncoding, "utf-8") == 0) {
+            return PyUnicode_DecodeUTF8(s, size, "replace");
+        }
+#endif
+        return PyUnicode_Decode(s, size,
+                                Py_FileSystemDefaultEncoding,
+                                "replace");
+    }
+    else {
+        return PyUnicode_DecodeUTF8(s, size, "replace");
+    }
+}
+
+/* Convert the argument to a bytes object, according to the file
+   system encoding */
+
+int
+PyUnicode_FSConverter(PyObject* arg, void* addr)
+{
+    PyObject *output = NULL;
+    Py_ssize_t size;
+    void *data;
+    if (arg == NULL) {
+        Py_DECREF(*(PyObject**)addr);
+        return 1;
+    }
+    if (PyBytes_Check(arg) || PyByteArray_Check(arg)) {
+        output = arg;
+        Py_INCREF(output);
+    }
+    else {
+        arg = PyUnicode_FromObject(arg);
+        if (!arg)
+            return 0;
+        output = PyUnicode_AsEncodedObject(arg, 
+                                           Py_FileSystemDefaultEncoding,
+                                           "surrogateescape");
+        Py_DECREF(arg);
+        if (!output)
+            return 0;
+        if (!PyBytes_Check(output)) {
+            Py_DECREF(output);
+            PyErr_SetString(PyExc_TypeError, "encoder failed to return bytes");
+            return 0;
+        }
+    }
+    if (PyBytes_Check(output)) {
+         size = PyBytes_GET_SIZE(output);
+         data = PyBytes_AS_STRING(output);
+    } 
+    else {
+         size = PyByteArray_GET_SIZE(output);
+         data = PyByteArray_AS_STRING(output);
+    }
+    if (size != strlen(data)) {
+        PyErr_SetString(PyExc_TypeError, "embedded NUL character");
+        Py_DECREF(output);
+        return 0;
+    }
+    *(PyObject**)addr = output;
+    return Py_CLEANUP_SUPPORTED;
+}
+
+
+char*
+_PyUnicode_AsStringAndSize(PyObject *unicode, Py_ssize_t *psize)
+{
+    PyObject *bytes;
+    if (!PyUnicode_Check(unicode)) {
+        PyErr_BadArgument();
+        return NULL;
+    }
+    bytes = _PyUnicode_AsDefaultEncodedString(unicode, NULL);
+    if (bytes == NULL)
+        return NULL;
+    if (psize != NULL)
+        *psize = PyBytes_GET_SIZE(bytes);
+    return PyBytes_AS_STRING(bytes);
+}
+
+char*
+_PyUnicode_AsString(PyObject *unicode)
+{
+    return _PyUnicode_AsStringAndSize(unicode, NULL);
 }
 
 Py_UNICODE *PyUnicode_AsUnicode(PyObject *unicode)
 {
     if (!PyUnicode_Check(unicode)) {
         PyErr_BadArgument();
         goto onError;
     }
     return PyUnicode_AS_UNICODE(unicode);
 
@@ skipping 13 matching lines @@
     return -1;
 }
 
 const char *PyUnicode_GetDefaultEncoding(void)
 {
     return unicode_default_encoding;
 }
 
 int PyUnicode_SetDefaultEncoding(const char *encoding)
 {
-    PyObject *v;
-
-    /* Make sure the encoding is valid. As side effect, this also
-       loads the encoding into the codec registry cache. */
-    v = _PyCodec_Lookup(encoding);
-    if (v == NULL)
-        goto onError;
-    Py_DECREF(v);
-    strncpy(unicode_default_encoding,
-            encoding,
-            sizeof(unicode_default_encoding));
+    if (strcmp(encoding, unicode_default_encoding) != 0) {
+        PyErr_Format(PyExc_ValueError,
+                     "Can only set default encoding to %s",
+                     unicode_default_encoding);
+        return -1;
+    }
     return 0;
-
-  onError:
-    return -1;
 }
 
 /* error handling callback helper:
    build arguments, call the callback and check the arguments,
    if no exception occurred, copy the replacement to the output
    and adjust various state variables.
    return 0 on success, -1 on error
 */
 
 static
 int unicode_decode_call_errorhandler(const char *errors, PyObject **errorHandler,
                                      const char *encoding, const char *reason,
-                                     const char *input, Py_ssize_t insize, Py_ssize_t *startinpos,
+                                     const char **input, const char **inend, Py_ssize_t *startinpos,
                                      Py_ssize_t *endinpos, PyObject **exceptionObject, const char **inptr,
                                      PyUnicodeObject **output, Py_ssize_t *outpos, Py_UNICODE **outptr)
 {
-    static char *argparse = "O!n;decoding error handler must return (unicode, int) tuple";
+    static char *argparse = "O!n;decoding error handler must return (str, int) tuple";
 
     PyObject *restuple = NULL;
     PyObject *repunicode = NULL;
     Py_ssize_t outsize = PyUnicode_GET_SIZE(*output);
+    Py_ssize_t insize;
     Py_ssize_t requiredsize;
     Py_ssize_t newpos;
     Py_UNICODE *repptr;
+    PyObject *inputobj = NULL;
     Py_ssize_t repsize;
     int res = -1;
 
     if (*errorHandler == NULL) {
         *errorHandler = PyCodec_LookupError(errors);
         if (*errorHandler == NULL)
             goto onError;
     }
 
     if (*exceptionObject == NULL) {
         *exceptionObject = PyUnicodeDecodeError_Create(
-            encoding, input, insize, *startinpos, *endinpos, reason);
+            encoding, *input, *inend-*input, *startinpos, *endinpos, reason);
         if (*exceptionObject == NULL)
             goto onError;
     }
     else {
         if (PyUnicodeDecodeError_SetStart(*exceptionObject, *startinpos))
             goto onError;
         if (PyUnicodeDecodeError_SetEnd(*exceptionObject, *endinpos))
             goto onError;
         if (PyUnicodeDecodeError_SetReason(*exceptionObject, reason))
             goto onError;
     }
 
     restuple = PyObject_CallFunctionObjArgs(*errorHandler, *exceptionObject, NULL);
     if (restuple == NULL)
         goto onError;
     if (!PyTuple_Check(restuple)) {
         PyErr_SetString(PyExc_TypeError, &argparse[4]);
         goto onError;
     }
     if (!PyArg_ParseTuple(restuple, argparse, &PyUnicode_Type, &repunicode, &newpos))
         goto onError;
+
+    /* Copy back the bytes variables, which might have been modified by the
+       callback */
+    inputobj = PyUnicodeDecodeError_GetObject(*exceptionObject);
+    if (!inputobj)
+        goto onError;
+    if (!PyBytes_Check(inputobj)) {
+        PyErr_Format(PyExc_TypeError, "exception attribute object must be bytes");
+    }
+    *input = PyBytes_AS_STRING(inputobj);
+    insize = PyBytes_GET_SIZE(inputobj);
+    *inend = *input + insize;
+    /* we can DECREF safely, as the exception has another reference,
+       so the object won't go away. */
+    Py_DECREF(inputobj);
+
     if (newpos<0)
         newpos = insize+newpos;
     if (newpos<0 || newpos>insize) {
         PyErr_Format(PyExc_IndexError, "position %zd from error handler out of bounds", newpos);
         goto onError;
     }
 
     /* need more space? (at least enough for what we
        have+the replacement+the rest of the string (starting
        at the new input position), so we won't have to check space
        when there are no errors in the rest of the string) */
     repptr = PyUnicode_AS_UNICODE(repunicode);
     repsize = PyUnicode_GET_SIZE(repunicode);
     requiredsize = *outpos + repsize + insize-newpos;
     if (requiredsize > outsize) {
         if (requiredsize<2*outsize)
             requiredsize = 2*outsize;
         if (_PyUnicode_Resize(output, requiredsize) < 0)
             goto onError;
         *outptr = PyUnicode_AS_UNICODE(*output) + *outpos;
     }
     *endinpos = newpos;
-    *inptr = input + newpos;
+    *inptr = *input + newpos;
     Py_UNICODE_COPY(*outptr, repptr, repsize);
     *outptr += repsize;
     *outpos += repsize;
+
     /* we made it! */
     res = 0;
 
   onError:
     Py_XDECREF(restuple);
     return res;
 }
 
 /* --- UTF-7 Codec -------------------------------------------------------- */
 
 /* See RFC2152 for details.  We encode conservatively and decode liberally. */
 
 /* Three simple macros defining base-64. */
 
 /* Is c a base-64 character? */
 
 #define IS_BASE64(c) \
-    (isalnum(c) || (c) == '+' || (c) == '/')
+    (((c) >= 'A' && (c) <= 'Z') ||     \
+     ((c) >= 'a' && (c) <= 'z') ||     \
+     ((c) >= '0' && (c) <= '9') ||     \
+     (c) == '+' || (c) == '/')
 
 /* given that c is a base-64 character, what is its base-64 value? */
 
 #define FROM_BASE64(c)                                                  \
     (((c) >= 'A' && (c) <= 'Z') ? (c) - 'A' :                           \
      ((c) >= 'a' && (c) <= 'z') ? (c) - 'a' + 26 :                      \
      ((c) >= '0' && (c) <= '9') ? (c) - '0' + 52 :                      \
      (c) == '+' ? 62 : 63)
 
 /* What is the base-64 character of the bottom 6 bits of n? */
@@ skipping 97 matching lines @@
         if (consumed)
             *consumed = 0;
         return (PyObject *)unicode;
     }
 
     p = unicode->str;
     shiftOutStart = p;
     e = s + size;
 
     while (s < e) {
-        Py_UNICODE ch = (unsigned char) *s;
+        Py_UNICODE ch;
+      restart:
+        ch = (unsigned char) *s;
 
         if (inShift) { /* in a base-64 section */
             if (IS_BASE64(ch)) { /* consume a base-64 character */
                 base64buffer = (base64buffer << 6) | FROM_BASE64(ch);
                 base64bits += 6;
                 s++;
                 if (base64bits >= 16) {
                     /* we have enough bits for a UTF-16 value */
                     Py_UNICODE outCh = (Py_UNICODE)
                                        (base64buffer >> (base64bits-16));
@@ skipping 81 matching lines @@
             errmsg = "unexpected special character";
             goto utf7Error;
         }
         continue;
 utf7Error:
         outpos = p-PyUnicode_AS_UNICODE(unicode);
         endinpos = s-starts;
         if (unicode_decode_call_errorhandler(
                 errors, &errorHandler,
                 "utf7", errmsg,
-                starts, size, &startinpos, &endinpos, &exc, &s,
+                &starts, &e, &startinpos, &endinpos, &exc, &s,
                 &unicode, &outpos, &p))
             goto onError;
     }
 
     /* end of string */
 
     if (inShift && !consumed) { /* in shift sequence, no more to follow */
         /* if we're in an inconsistent state, that's an error */
         if (surrogate ||
                 (base64bits >= 6) ||
                 (base64bits > 0 && base64buffer != 0)) {
             outpos = p-PyUnicode_AS_UNICODE(unicode);
             endinpos = size;
             if (unicode_decode_call_errorhandler(
                     errors, &errorHandler,
                     "utf7", "unterminated shift sequence",
-                    starts, size, &startinpos, &endinpos, &exc, &s,
+                    &starts, &e, &startinpos, &endinpos, &exc, &s,
                     &unicode, &outpos, &p))
                 goto onError;
+            if (s < e)
+                goto restart;
         }
     }
 
     /* return state */
     if (consumed) {
         if (inShift) {
             p = shiftOutStart; /* back off output */
             *consumed = startinpos;
         }
         else {
@@ skipping 25 matching lines @@
     PyObject *v;
     /* It might be possible to tighten this worst case */
     Py_ssize_t allocated = 8 * size;
     int inShift = 0;
     Py_ssize_t i = 0;
     unsigned int base64bits = 0;
     unsigned long base64buffer = 0;
     char * out;
     char * start;
 
+    if (size == 0)
+        return PyBytes_FromStringAndSize(NULL, 0);
+
     if (allocated / 8 != size)
         return PyErr_NoMemory();
 
-    if (size == 0)
-        return PyString_FromStringAndSize(NULL, 0);
-
-    v = PyString_FromStringAndSize(NULL, allocated);
+    v = PyBytes_FromStringAndSize(NULL, allocated);
     if (v == NULL)
         return NULL;
 
-    start = out = PyString_AS_STRING(v);
+    start = out = PyBytes_AS_STRING(v);
     for (;i < size; ++i) {
         Py_UNICODE ch = s[i];
 
         if (inShift) {
             if (ENCODE_DIRECT(ch, !base64SetO, !base64WhiteSpace)) {
                 /* shifting out */
                 if (base64bits) { /* output remaining bits */
                     *out++ = TO_BASE64(base64buffer << (6-base64bits));
                     base64buffer = 0;
                     base64bits = 0;
@@ skipping 43 matching lines @@
         base64buffer = (base64buffer << 16) | ch;
         while (base64bits >= 6) {
             *out++ = TO_BASE64(base64buffer >> (base64bits-6));
             base64bits -= 6;
         }
     }
     if (base64bits)
         *out++= TO_BASE64(base64buffer << (6-base64bits) );
     if (inShift)
         *out++ = '-';
-
-    if (_PyString_Resize(&v, out - start))
+    if (_PyBytes_Resize(&v, out - start) < 0)
         return NULL;
     return v;
 }
 
 #undef IS_BASE64
 #undef FROM_BASE64
 #undef TO_BASE64
 #undef DECODE_DIRECT
 #undef ENCODE_DIRECT
 
@@ skipping 21 matching lines @@
     4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0  /* F0-F4 + F5-FF */
 };
 
 PyObject *PyUnicode_DecodeUTF8(const char *s,
                                Py_ssize_t size,
                                const char *errors)
 {
     return PyUnicode_DecodeUTF8Stateful(s, size, errors, NULL);
 }
 
+/* Mask to check or force alignment of a pointer to C 'long' boundaries */
+#define LONG_PTR_MASK (size_t) (SIZEOF_LONG - 1)
+
+/* Mask to quickly check whether a C 'long' contains a
+   non-ASCII, UTF8-encoded char. */
+#if (SIZEOF_LONG == 8)
+# define ASCII_CHAR_MASK 0x8080808080808080L
+#elif (SIZEOF_LONG == 4)
+# define ASCII_CHAR_MASK 0x80808080L
+#else
+# error C 'long' size should be either 4 or 8!
+#endif
+
 PyObject *PyUnicode_DecodeUTF8Stateful(const char *s,
                                        Py_ssize_t size,
                                        const char *errors,
                                        Py_ssize_t *consumed)
 {
     const char *starts = s;
     int n;
     int k;
     Py_ssize_t startinpos;
     Py_ssize_t endinpos;
     Py_ssize_t outpos;
-    const char *e;
+    const char *e, *aligned_end;
     PyUnicodeObject *unicode;
     Py_UNICODE *p;
     const char *errmsg = "";
     PyObject *errorHandler = NULL;
     PyObject *exc = NULL;
 
     /* Note: size will always be longer than the resulting Unicode
        character count */
     unicode = _PyUnicode_New(size);
     if (!unicode)
         return NULL;
     if (size == 0) {
         if (consumed)
             *consumed = 0;
         return (PyObject *)unicode;
     }
 
     /* Unpack UTF-8 encoded data */
     p = unicode->str;
     e = s + size;
+    aligned_end = (const char *) ((size_t) e & ~LONG_PTR_MASK);
 
     while (s < e) {
         Py_UCS4 ch = (unsigned char)*s;
+
+        if (ch < 0x80) {
+            /* Fast path for runs of ASCII characters. Given that common UTF-8
+               input will consist of an overwhelming majority of ASCII
+               characters, we try to optimize for this case by checking
+               as many characters as a C 'long' can contain.
+               First, check if we can do an aligned read, as most CPUs have
+               a penalty for unaligned reads.
+            */
+            if (!((size_t) s & LONG_PTR_MASK)) {
+                /* Help register allocation */
+                register const char *_s = s;
+                register Py_UNICODE *_p = p;
+                while (_s < aligned_end) {
+                    /* Read a whole long at a time (either 4 or 8 bytes),
+                       and do a fast unrolled copy if it only contains ASCII
+                       characters. */
+                    unsigned long data = *(unsigned long *) _s;
+                    if (data & ASCII_CHAR_MASK)
+                        break;
+                    _p[0] = (unsigned char) _s[0];
+                    _p[1] = (unsigned char) _s[1];
+                    _p[2] = (unsigned char) _s[2];
+                    _p[3] = (unsigned char) _s[3];
+#if (SIZEOF_LONG == 8)
+                    _p[4] = (unsigned char) _s[4];
+                    _p[5] = (unsigned char) _s[5];
+                    _p[6] = (unsigned char) _s[6];
+                    _p[7] = (unsigned char) _s[7];
+#endif
+                    _s += SIZEOF_LONG;
+                    _p += SIZEOF_LONG;
+                }
+                s = _s;
+                p = _p;
+                if (s == e)
+                    break;
+                ch = (unsigned char)*s;
+            }
+        }
 
         if (ch < 0x80) {
             *p++ = (Py_UNICODE)ch;
             s++;
             continue;
         }
 
         n = utf8_code_length[ch];
 
         if (s + n > e) {
@@ skipping 29 matching lines @@
                 startinpos = s-starts;
                 endinpos = startinpos + 1;
                 goto utf8Error;
             }
             ch = ((s[0] & 0x1f) << 6) + (s[1] & 0x3f);
             assert ((ch > 0x007F) && (ch <= 0x07FF));
             *p++ = (Py_UNICODE)ch;
             break;
 
         case 3:
-            /* XXX: surrogates shouldn't be valid UTF-8!
-               see http://www.unicode.org/versions/Unicode5.2.0/ch03.pdf
-               (table 3-7) and http://www.rfc-editor.org/rfc/rfc3629.txt
-               Uncomment the 2 lines below to make them invalid,
-               codepoints: d800-dfff; UTF-8: \xed\xa0\x80-\xed\xbf\xbf. */
+            /* Decoding UTF-8 sequences in range \xed\xa0\x80-\xed\xbf\xbf
+               will result in surrogates in range d800-dfff. Surrogates are
+               not valid UTF-8 so they are rejected.
+               See http://www.unicode.org/versions/Unicode5.2.0/ch03.pdf
+               (table 3-7) and http://www.rfc-editor.org/rfc/rfc3629.txt */
             if ((s[1] & 0xc0) != 0x80 ||
                 (s[2] & 0xc0) != 0x80 ||
                 ((unsigned char)s[0] == 0xE0 &&
-                 (unsigned char)s[1] < 0xA0)/* ||
+                 (unsigned char)s[1] < 0xA0) ||
                 ((unsigned char)s[0] == 0xED &&
-                 (unsigned char)s[1] > 0x9F)*/) {
+                 (unsigned char)s[1] > 0x9F)) {
                 errmsg = "invalid continuation byte";
                 startinpos = s-starts;
                 endinpos = startinpos + 1;
 
                 /* if s[1] first two bits are 1 and 0, then the invalid
                    continuation byte is s[2], so increment endinpos by 1,
                    if not, s[1] is invalid and endinpos doesn't need to
                    be incremented. */
                 if ((s[1] & 0xC0) == 0x80)
                     endinpos++;
@@ skipping 43 matching lines @@
             break;
         }
         s += n;
         continue;
 
       utf8Error:
         outpos = p-PyUnicode_AS_UNICODE(unicode);
         if (unicode_decode_call_errorhandler(
                 errors, &errorHandler,
                 "utf8", errmsg,
-                starts, size, &startinpos, &endinpos, &exc, &s,
+                &starts, &e, &startinpos, &endinpos, &exc, &s,
                 &unicode, &outpos, &p))
             goto onError;
+        aligned_end = (const char *) ((size_t) e & ~LONG_PTR_MASK);
     }
     if (consumed)
         *consumed = s-starts;
 
     /* Adjust length */
     if (_PyUnicode_Resize(&unicode, p - unicode->str) < 0)
         goto onError;
 
     Py_XDECREF(errorHandler);
     Py_XDECREF(exc);
     return (PyObject *)unicode;
 
   onError:
     Py_XDECREF(errorHandler);
     Py_XDECREF(exc);
     Py_DECREF(unicode);
     return NULL;
 }
+
+#undef ASCII_CHAR_MASK
+
 
 /* Allocation strategy:  if the string is short, convert into a stack buffer
    and allocate exactly as much space needed at the end.  Else allocate the
    maximum possible needed (4 result bytes per Unicode character), and return
    the excess memory at the end.
 */
 PyObject *
 PyUnicode_EncodeUTF8(const Py_UNICODE *s,
                      Py_ssize_t size,
                      const char *errors)
 {
 #define MAX_SHORT_UNICHARS 300  /* largest size we'll do on the stack */
 
-    Py_ssize_t i;           /* index into s of next input byte */
-    PyObject *v;        /* result string object */
-    char *p;            /* next free byte in output buffer */
-    Py_ssize_t nallocated;  /* number of result bytes allocated */
-    Py_ssize_t nneeded;        /* number of result bytes needed */
+    Py_ssize_t i;                /* index into s of next input byte */
+    PyObject *result;            /* result string object */
+    char *p;                     /* next free byte in output buffer */
+    Py_ssize_t nallocated;      /* number of result bytes allocated */
+    Py_ssize_t nneeded;            /* number of result bytes needed */
     char stackbuf[MAX_SHORT_UNICHARS * 4];
+    PyObject *errorHandler = NULL;
+    PyObject *exc = NULL;
 
     assert(s != NULL);
     assert(size >= 0);
 
     if (size <= MAX_SHORT_UNICHARS) {
         /* Write into the stack buffer; nallocated can't overflow.
          * At the end, we'll allocate exactly as much heap space as it
          * turns out we need.
          */
         nallocated = Py_SAFE_DOWNCAST(sizeof(stackbuf), size_t, int);
-        v = NULL;   /* will allocate after we're done */
+        result = NULL;   /* will allocate after we're done */
         p = stackbuf;
     }
     else {
         /* Overallocate on the heap, and give the excess back at the end. */
         nallocated = size * 4;
         if (nallocated / 4 != size)  /* overflow! */
             return PyErr_NoMemory();
-        v = PyString_FromStringAndSize(NULL, nallocated);
-        if (v == NULL)
+        result = PyBytes_FromStringAndSize(NULL, nallocated);
+        if (result == NULL)
             return NULL;
-        p = PyString_AS_STRING(v);
+        p = PyBytes_AS_STRING(result);
     }
 
     for (i = 0; i < size;) {
         Py_UCS4 ch = s[i++];
 
         if (ch < 0x80)
             /* Encode ASCII */
             *p++ = (char) ch;
 
         else if (ch < 0x0800) {
             /* Encode Latin-1 */
             *p++ = (char)(0xc0 | (ch >> 6));
             *p++ = (char)(0x80 | (ch & 0x3f));
-        }
-        else {
-            /* Encode UCS2 Unicode ordinals */
-            if (ch < 0x10000) {
-                /* Special case: check for high surrogate */
-                if (0xD800 <= ch && ch <= 0xDBFF && i != size) {
-                    Py_UCS4 ch2 = s[i];
-                    /* Check for low surrogate and combine the two to
-                       form a UCS4 value */
-                    if (0xDC00 <= ch2 && ch2 <= 0xDFFF) {
-                        ch = ((ch - 0xD800) << 10 | (ch2 - 0xDC00)) + 0x10000;
-                        i++;
-                        goto encodeUCS4;
-                    }
-                    /* Fall through: handles isolated high surrogates */
-                }
-                *p++ = (char)(0xe0 | (ch >> 12));
+        } else if (0xD800 <= ch && ch <= 0xDFFF) {
+#ifndef Py_UNICODE_WIDE
+            /* Special case: check for high and low surrogate */
+            if (ch <= 0xDBFF && i != size && 0xDC00 <= s[i] && s[i] <= 0xDFFF) {
+                Py_UCS4 ch2 = s[i];
+                /* Combine the two surrogates to form a UCS4 value */
+                ch = ((ch - 0xD800) << 10 | (ch2 - 0xDC00)) + 0x10000;
+                i++;
+
+                /* Encode UCS4 Unicode ordinals */
+                *p++ = (char)(0xf0 | (ch >> 18));
+                *p++ = (char)(0x80 | ((ch >> 12) & 0x3f));
                 *p++ = (char)(0x80 | ((ch >> 6) & 0x3f));
                 *p++ = (char)(0x80 | (ch & 0x3f));
-                continue;
-            }
-          encodeUCS4:
+            } else {
+#endif
+                Py_ssize_t newpos;
+                PyObject *rep;
+                Py_ssize_t repsize, k;
+                rep = unicode_encode_call_errorhandler
+                    (errors, &errorHandler, "utf-8", "surrogates not allowed",
+                     s, size, &exc, i-1, i, &newpos);
+                if (!rep)
+                    goto error;
+
+                if (PyBytes_Check(rep))
+                    repsize = PyBytes_GET_SIZE(rep);
+                else
+                    repsize = PyUnicode_GET_SIZE(rep);
+
+                if (repsize > 4) {
+                    Py_ssize_t offset;
+
+                    if (result == NULL)
+                        offset = p - stackbuf;
+                    else
+                        offset = p - PyBytes_AS_STRING(result);
+
+                    if (nallocated > PY_SSIZE_T_MAX - repsize + 4) {
+                        /* integer overflow */
+                        PyErr_NoMemory();
+                        goto error;
+                    }
+                    nallocated += repsize - 4;
+                    if (result != NULL) {
+                        if (_PyBytes_Resize(&result, nallocated) < 0)
+                            goto error;
+                    } else {
+                        result = PyBytes_FromStringAndSize(NULL, nallocated);
+                        if (result == NULL)
+                            goto error;
+                        Py_MEMCPY(PyBytes_AS_STRING(result), stackbuf, offset);
+                    }
+                    p = PyBytes_AS_STRING(result) + offset;
+                }
+
+                if (PyBytes_Check(rep)) {
+                    char *prep = PyBytes_AS_STRING(rep);
+                    for(k = repsize; k > 0; k--)
+                        *p++ = *prep++;
+                } else /* rep is unicode */ {
+                    Py_UNICODE *prep = PyUnicode_AS_UNICODE(rep);
+                    Py_UNICODE c;
+
+                    for(k=0; k<repsize; k++) {
+                        c = prep[k];
+                        if (0x80 <= c) {
+                            raise_encode_exception(&exc, "utf-8", s, size,
+                                                   i-1, i, "surrogates not allowed");
+                            goto error;
+                        }
+                        *p++ = (char)prep[k];
+                    }
+                }
+                Py_DECREF(rep);
+#ifndef Py_UNICODE_WIDE
+            }
+#endif
+        } else if (ch < 0x10000) {
+            *p++ = (char)(0xe0 | (ch >> 12));
+            *p++ = (char)(0x80 | ((ch >> 6) & 0x3f));
+            *p++ = (char)(0x80 | (ch & 0x3f));
+        } else /* ch >= 0x10000 */ {
             /* Encode UCS4 Unicode ordinals */
             *p++ = (char)(0xf0 | (ch >> 18));
             *p++ = (char)(0x80 | ((ch >> 12) & 0x3f));
             *p++ = (char)(0x80 | ((ch >> 6) & 0x3f));
             *p++ = (char)(0x80 | (ch & 0x3f));
         }
     }
 
-    if (v == NULL) {
+    if (result == NULL) {
         /* This was stack allocated. */
         nneeded = p - stackbuf;
         assert(nneeded <= nallocated);
-        v = PyString_FromStringAndSize(stackbuf, nneeded);
+        result = PyBytes_FromStringAndSize(stackbuf, nneeded);
     }
     else {
         /* Cut back to size actually needed. */
-        nneeded = p - PyString_AS_STRING(v);
+        nneeded = p - PyBytes_AS_STRING(result);
         assert(nneeded <= nallocated);
-        if (_PyString_Resize(&v, nneeded))
-            return NULL;
-    }
-    return v;
+        _PyBytes_Resize(&result, nneeded);
+    }
+    Py_XDECREF(errorHandler);
+    Py_XDECREF(exc);
+    return result;
+ error:
+    Py_XDECREF(errorHandler);
+    Py_XDECREF(exc);
+    Py_XDECREF(result);
+    return NULL;
 
 #undef MAX_SHORT_UNICHARS
 }
 
 PyObject *PyUnicode_AsUTF8String(PyObject *unicode)
 {
     if (!PyUnicode_Check(unicode)) {
         PyErr_BadArgument();
         return NULL;
     }
@@ skipping 145 matching lines @@
         else
 #endif
             *p++ = ch;
         q += 4;
         continue;
       utf32Error:
         outpos = p-PyUnicode_AS_UNICODE(unicode);
         if (unicode_decode_call_errorhandler(
                 errors, &errorHandler,
                 "utf32", errmsg,
-                starts, size, &startinpos, &endinpos, &exc, (const char **)&q,
+                &starts, (const char **)&e, &startinpos, &endinpos, &exc, (const char **)&q,
                 &unicode, &outpos, &p))
             goto onError;
     }
 
     if (byteorder)
         *byteorder = bo;
 
     if (consumed)
         *consumed = (const char *)q-starts;
 
@@ skipping 47 matching lines @@
 #ifndef Py_UNICODE_WIDE
     for (i = pairs = 0; i < size-1; i++)
         if (0xD800 <= s[i] && s[i] <= 0xDBFF &&
             0xDC00 <= s[i+1] && s[i+1] <= 0xDFFF)
             pairs++;
 #endif
     nsize = (size - pairs + (byteorder == 0));
     bytesize = nsize * 4;
     if (bytesize / 4 != nsize)
         return PyErr_NoMemory();
-    v = PyString_FromStringAndSize(NULL, bytesize);
+    v = PyBytes_FromStringAndSize(NULL, bytesize);
     if (v == NULL)
         return NULL;
 
-    p = (unsigned char *)PyString_AS_STRING(v);
+    p = (unsigned char *)PyBytes_AS_STRING(v);
     if (byteorder == 0)
         STORECHAR(0xFEFF);
     if (size == 0)
-        return v;
+        goto done;
 
     if (byteorder == -1) {
         /* force LE */
         iorder[0] = 0;
         iorder[1] = 1;
         iorder[2] = 2;
         iorder[3] = 3;
     }
     else if (byteorder == 1) {
         /* force BE */
@@ skipping 10 matching lines @@
             Py_UCS4 ch2 = *s;
             if (0xDC00 <= ch2 && ch2 <= 0xDFFF) {
                 ch = (((ch & 0x3FF)<<10) | (ch2 & 0x3FF)) + 0x10000;
                 s++;
                 size--;
             }
         }
 #endif
         STORECHAR(ch);
     }
+
+  done:
     return v;
 #undef STORECHAR
 }
 
 PyObject *PyUnicode_AsUTF32String(PyObject *unicode)
 {
     if (!PyUnicode_Check(unicode)) {
         PyErr_BadArgument();
         return NULL;
     }
     return PyUnicode_EncodeUTF32(PyUnicode_AS_UNICODE(unicode),
                                  PyUnicode_GET_SIZE(unicode),
                                  NULL,
                                  0);
 }
 
 /* --- UTF-16 Codec ------------------------------------------------------- */
 
 PyObject *
 PyUnicode_DecodeUTF16(const char *s,
                       Py_ssize_t size,
                       const char *errors,
                       int *byteorder)
 {
     return PyUnicode_DecodeUTF16Stateful(s, size, errors, byteorder, NULL);
 }
+
+/* Two masks for fast checking of whether a C 'long' may contain
+   UTF16-encoded surrogate characters. This is an efficient heuristic,
+   assuming that non-surrogate characters with a code point >= 0x8000 are
+   rare in most input.
+   FAST_CHAR_MASK is used when the input is in native byte ordering,
+   SWAPPED_FAST_CHAR_MASK when the input is in byteswapped ordering.
+*/
+#if (SIZEOF_LONG == 8)
+# define FAST_CHAR_MASK         0x8000800080008000L
+# define SWAPPED_FAST_CHAR_MASK 0x0080008000800080L
+#elif (SIZEOF_LONG == 4)
+# define FAST_CHAR_MASK         0x80008000L
+# define SWAPPED_FAST_CHAR_MASK 0x00800080L
+#else
+# error C 'long' size should be either 4 or 8!
+#endif
 
 PyObject *
 PyUnicode_DecodeUTF16Stateful(const char *s,
                               Py_ssize_t size,
                               const char *errors,
                               int *byteorder,
                               Py_ssize_t *consumed)
 {
     const char *starts = s;
     Py_ssize_t startinpos;
     Py_ssize_t endinpos;
     Py_ssize_t outpos;
     PyUnicodeObject *unicode;
     Py_UNICODE *p;
-    const unsigned char *q, *e;
+    const unsigned char *q, *e, *aligned_end;
     int bo = 0;       /* assume native ordering by default */
+    int native_ordering = 0;
     const char *errmsg = "";
     /* Offsets from q for retrieving byte pairs in the right order. */
 #ifdef BYTEORDER_IS_LITTLE_ENDIAN
     int ihi = 1, ilo = 0;
 #else
     int ihi = 0, ilo = 1;
 #endif
     PyObject *errorHandler = NULL;
     PyObject *exc = NULL;
 
     /* Note: size will always be longer than the resulting Unicode
        character count */
     unicode = _PyUnicode_New(size);
     if (!unicode)
         return NULL;
     if (size == 0)
         return (PyObject *)unicode;
 
     /* Unpack UTF-16 encoded data */
     p = unicode->str;
     q = (unsigned char *)s;
-    e = q + size;
+    e = q + size - 1;
 
     if (byteorder)
         bo = *byteorder;
 
     /* Check for BOM marks (U+FEFF) in the input and adjust current
        byte order setting accordingly. In native mode, the leading BOM
        mark is skipped, in all other modes, it is copied to the output
        stream as-is (giving a ZWNBSP character). */
     if (bo == 0) {
         if (size >= 2) {
@@ skipping 23 matching lines @@
     if (bo == -1) {
         /* force LE */
         ihi = 1;
         ilo = 0;
     }
     else if (bo == 1) {
         /* force BE */
         ihi = 0;
         ilo = 1;
     }
-
+#ifdef BYTEORDER_IS_LITTLE_ENDIAN
+    native_ordering = ilo < ihi;
+#else
+    native_ordering = ilo > ihi;
+#endif
+
+    aligned_end = (const unsigned char *) ((size_t) e & ~LONG_PTR_MASK);
     while (q < e) {
         Py_UNICODE ch;
-        /* remaining bytes at the end? (size should be even) */
-        if (e-q<2) {
-            if (consumed)
+        /* First check for possible aligned read of a C 'long'. Unaligned
+           reads are more expensive, better to defer to another iteration. */
+        if (!((size_t) q & LONG_PTR_MASK)) {
+            /* Fast path for runs of non-surrogate chars. */
+            register const unsigned char *_q = q;
+            Py_UNICODE *_p = p;
+            if (native_ordering) {
+                /* Native ordering is simple: as long as the input cannot
+                   possibly contain a surrogate char, do an unrolled copy
+                   of several 16-bit code points to the target object.
+                   The non-surrogate check is done on several input bytes
+                   at a time (as many as a C 'long' can contain). */
+                while (_q < aligned_end) {
+                    unsigned long data = * (unsigned long *) _q;
+                    if (data & FAST_CHAR_MASK)
+                        break;
+                    _p[0] = ((unsigned short *) _q)[0];
+                    _p[1] = ((unsigned short *) _q)[1];
+#if (SIZEOF_LONG == 8)
+                    _p[2] = ((unsigned short *) _q)[2];
+                    _p[3] = ((unsigned short *) _q)[3];
+#endif
+                    _q += SIZEOF_LONG;
+                    _p += SIZEOF_LONG / 2;
+                }
+            }
+            else {
+                /* Byteswapped ordering is similar, but we must decompose
+                   the copy bytewise, and take care of zero'ing out the
+                   upper bytes if the target object is in 32-bit units
+                   (that is, in UCS-4 builds). */
+                while (_q < aligned_end) {
+                    unsigned long data = * (unsigned long *) _q;
+                    if (data & SWAPPED_FAST_CHAR_MASK)
+                        break;
+                    /* Zero upper bytes in UCS-4 builds */
+#if (Py_UNICODE_SIZE > 2)
+                    _p[0] = 0;
+                    _p[1] = 0;
+#if (SIZEOF_LONG == 8)
+                    _p[2] = 0;
+                    _p[3] = 0;
+#endif
+#endif
+                    /* Issue #4916; UCS-4 builds on big endian machines must
+                       fill the two last bytes of each 4-byte unit. */
+#if (!defined(BYTEORDER_IS_LITTLE_ENDIAN) && Py_UNICODE_SIZE > 2)
+# define OFF 2
+#else
+# define OFF 0
+#endif
+                    ((unsigned char *) _p)[OFF + 1] = _q[0];
+                    ((unsigned char *) _p)[OFF + 0] = _q[1];
+                    ((unsigned char *) _p)[OFF + 1 + Py_UNICODE_SIZE] = _q[2];
+                    ((unsigned char *) _p)[OFF + 0 + Py_UNICODE_SIZE] = _q[3];
+#if (SIZEOF_LONG == 8)
+                    ((unsigned char *) _p)[OFF + 1 + 2 * Py_UNICODE_SIZE] = _q[4];
+                    ((unsigned char *) _p)[OFF + 0 + 2 * Py_UNICODE_SIZE] = _q[5];
+                    ((unsigned char *) _p)[OFF + 1 + 3 * Py_UNICODE_SIZE] = _q[6];
+                    ((unsigned char *) _p)[OFF + 0 + 3 * Py_UNICODE_SIZE] = _q[7];
+#endif
+#undef OFF
+                    _q += SIZEOF_LONG;
+                    _p += SIZEOF_LONG / 2;
+                }
+            }
+            p = _p;
+            q = _q;
+            if (q >= e)
                 break;
-            errmsg = "truncated data";
-            startinpos = ((const char *)q)-starts;
-            endinpos = ((const char *)e)-starts;
-            goto utf16Error;
-            /* The remaining input chars are ignored if the callback
-               chooses to skip the input */
         }
         ch = (q[ihi] << 8) | q[ilo];
 
         q += 2;
 
         if (ch < 0xD800 || ch > 0xDFFF) {
             *p++ = ch;
             continue;
         }
 
         /* UTF-16 code pair: */
-        if (q >= e) {
+        if (q > e) {
             errmsg = "unexpected end of data";
-            startinpos = (((const char *)q)-2)-starts;
-            endinpos = ((const char *)e)-starts;
+            startinpos = (((const char *)q) - 2) - starts;
+            endinpos = ((const char *)e) + 1 - starts;
             goto utf16Error;
         }
         if (0xD800 <= ch && ch <= 0xDBFF) {
             Py_UNICODE ch2 = (q[ihi] << 8) | q[ilo];
             q += 2;
             if (0xDC00 <= ch2 && ch2 <= 0xDFFF) {
 #ifndef Py_UNICODE_WIDE
                 *p++ = ch;
                 *p++ = ch2;
 #else
                 *p++ = (((ch & 0x3FF)<<10) | (ch2 & 0x3FF)) + 0x10000;
 #endif
                 continue;
             }
             else {
                 errmsg = "illegal UTF-16 surrogate";
                 startinpos = (((const char *)q)-4)-starts;
                 endinpos = startinpos+2;
                 goto utf16Error;
             }
 
         }
         errmsg = "illegal encoding";
         startinpos = (((const char *)q)-2)-starts;
         endinpos = startinpos+2;
         /* Fall through to report the error */
 
       utf16Error:
-        outpos = p-PyUnicode_AS_UNICODE(unicode);
+        outpos = p - PyUnicode_AS_UNICODE(unicode);
         if (unicode_decode_call_errorhandler(
-                errors, &errorHandler,
+                errors,
+                &errorHandler,
                 "utf16", errmsg,
-                starts, size, &startinpos, &endinpos, &exc, (const char **)&q,
-                &unicode, &outpos, &p))
+                &starts,
+                (const char **)&e,
+                &startinpos,
+                &endinpos,
+                &exc,
+                (const char **)&q,
+                &unicode,
+                &outpos,
+                &p))
             goto onError;
+    }
+    /* remaining byte at the end? (size should be even) */
+    if (e == q) {
+        if (!consumed) {
+            errmsg = "truncated data";
+            startinpos = ((const char *)q) - starts;
+            endinpos = ((const char *)e) + 1 - starts;
+            outpos = p - PyUnicode_AS_UNICODE(unicode);
+            if (unicode_decode_call_errorhandler(
+                    errors,
+                    &errorHandler,
+                    "utf16", errmsg,
+                    &starts,
+                    (const char **)&e,
+                    &startinpos,
+                    &endinpos,
+                    &exc,
+                    (const char **)&q,
+                    &unicode,
+                    &outpos,
+                    &p))
+                goto onError;
+            /* The remaining input chars are ignored if the callback
+               chooses to skip the input */
+        }
     }
 
     if (byteorder)
         *byteorder = bo;
 
     if (consumed)
         *consumed = (const char *)q-starts;
 
     /* Adjust length */
     if (_PyUnicode_Resize(&unicode, p - unicode->str) < 0)
         goto onError;
 
     Py_XDECREF(errorHandler);
     Py_XDECREF(exc);
     return (PyObject *)unicode;
 
   onError:
     Py_DECREF(unicode);
     Py_XDECREF(errorHandler);
     Py_XDECREF(exc);
     return NULL;
 }
+
+#undef FAST_CHAR_MASK
+#undef SWAPPED_FAST_CHAR_MASK
 
 PyObject *
 PyUnicode_EncodeUTF16(const Py_UNICODE *s,
                       Py_ssize_t size,
                       const char *errors,
                       int byteorder)
 {
     PyObject *v;
     unsigned char *p;
     Py_ssize_t nsize, bytesize;
@@ skipping 22 matching lines @@
             pairs++;
 #endif
     /* 2 * (size + pairs + (byteorder == 0)) */
     if (size > PY_SSIZE_T_MAX ||
         size > PY_SSIZE_T_MAX - pairs - (byteorder == 0))
         return PyErr_NoMemory();
     nsize = size + pairs + (byteorder == 0);
     bytesize = nsize * 2;
     if (bytesize / 2 != nsize)
         return PyErr_NoMemory();
-    v = PyString_FromStringAndSize(NULL, bytesize);
+    v = PyBytes_FromStringAndSize(NULL, bytesize);
     if (v == NULL)
         return NULL;
 
-    p = (unsigned char *)PyString_AS_STRING(v);
+    p = (unsigned char *)PyBytes_AS_STRING(v);
     if (byteorder == 0)
         STORECHAR(0xFEFF);
     if (size == 0)
-        return v;
+        goto done;
 
     if (byteorder == -1) {
         /* force LE */
         ihi = 1;
         ilo = 0;
     }
     else if (byteorder == 1) {
         /* force BE */
         ihi = 0;
         ilo = 1;
     }
 
     while (size-- > 0) {
         Py_UNICODE ch = *s++;
         Py_UNICODE ch2 = 0;
 #ifdef Py_UNICODE_WIDE
         if (ch >= 0x10000) {
             ch2 = 0xDC00 | ((ch-0x10000) & 0x3FF);
             ch  = 0xD800 | ((ch-0x10000) >> 10);
         }
 #endif
         STORECHAR(ch);
         if (ch2)
             STORECHAR(ch2);
     }
+
+  done:
     return v;
 #undef STORECHAR
 }
 
 PyObject *PyUnicode_AsUTF16String(PyObject *unicode)
 {
     if (!PyUnicode_Check(unicode)) {
         PyErr_BadArgument();
         return NULL;
     }
@@ skipping 100 matching lines @@
             digits = 8;
             message = "truncated \\UXXXXXXXX escape";
         hexescape:
             chr = 0;
             outpos = p-PyUnicode_AS_UNICODE(v);
             if (s+digits>end) {
                 endinpos = size;
                 if (unicode_decode_call_errorhandler(
                         errors, &errorHandler,
                         "unicodeescape", "end of string in escape sequence",
-                        starts, size, &startinpos, &endinpos, &exc, &s,
+                        &starts, &end, &startinpos, &endinpos, &exc, &s,
                         &v, &outpos, &p))
                     goto onError;
                 goto nextByte;
             }
             for (i = 0; i < digits; ++i) {
                 c = (unsigned char) s[i];
-                if (!isxdigit(c)) {
+                if (!ISXDIGIT(c)) {
                     endinpos = (s+i+1)-starts;
                     if (unicode_decode_call_errorhandler(
                             errors, &errorHandler,
                             "unicodeescape", message,
-                            starts, size, &startinpos, &endinpos, &exc, &s,
+                            &starts, &end, &startinpos, &endinpos, &exc, &s,
                             &v, &outpos, &p))
                         goto onError;
                     goto nextByte;
                 }
                 chr = (chr<<4) & ~0xF;
                 if (c >= '0' && c <= '9')
                     chr += c - '0';
                 else if (c >= 'a' && c <= 'f')
                     chr += 10 + c - 'a';
                 else
@@ skipping 18 matching lines @@
                 chr -= 0x10000L;
                 *p++ = 0xD800 + (Py_UNICODE) (chr >> 10);
                 *p++ = 0xDC00 + (Py_UNICODE) (chr & 0x03FF);
 #endif
             } else {
                 endinpos = s-starts;
                 outpos = p-PyUnicode_AS_UNICODE(v);
                 if (unicode_decode_call_errorhandler(
                         errors, &errorHandler,
                         "unicodeescape", "illegal Unicode character",
-                        starts, size, &startinpos, &endinpos, &exc, &s,
+                        &starts, &end, &startinpos, &endinpos, &exc, &s,
                         &v, &outpos, &p))
                     goto onError;
             }
             break;
 
             /* \N{name} */
         case 'N':
             message = "malformed \\N character escape";
             if (ucnhash_CAPI == NULL) {
                 /* load the unicode data module */
@@ skipping 12 matching lines @@
                     s++;
                     if (ucnhash_CAPI->getcode(NULL, start, (int)(s-start-1), &chr))
                         goto store;
                 }
             }
             endinpos = s-starts;
             outpos = p-PyUnicode_AS_UNICODE(v);
             if (unicode_decode_call_errorhandler(
                     errors, &errorHandler,
                     "unicodeescape", message,
-                    starts, size, &startinpos, &endinpos, &exc, &s,
+                    &starts, &end, &startinpos, &endinpos, &exc, &s,
                     &v, &outpos, &p))
                 goto onError;
             break;
 
         default:
             if (s > end) {
                 message = "\\ at end of string";
                 s--;
                 endinpos = s-starts;
                 outpos = p-PyUnicode_AS_UNICODE(v);
                 if (unicode_decode_call_errorhandler(
                         errors, &errorHandler,
                         "unicodeescape", message,
-                        starts, size, &startinpos, &endinpos, &exc, &s,
+                        &starts, &end, &startinpos, &endinpos, &exc, &s,
                         &v, &outpos, &p))
                     goto onError;
             }
             else {
                 *p++ = '\\';
                 *p++ = (unsigned char)s[-1];
             }
             break;
         }
       nextByte:
@@ skipping 37 matching lines @@
 
     while (size-- > 0) {
         if (*s == ch)
             return s;
         s++;
     }
 
     return NULL;
 }
 
-static
-PyObject *unicodeescape_string(const Py_UNICODE *s,
-                               Py_ssize_t size,
-                               int quotes)
+static const char *hexdigits = "0123456789abcdef";
+
+PyObject *PyUnicode_EncodeUnicodeEscape(const Py_UNICODE *s,
+                                        Py_ssize_t size)
 {
     PyObject *repr;
     char *p;
 
-    static const char *hexdigit = "0123456789abcdef";
 #ifdef Py_UNICODE_WIDE
     const Py_ssize_t expandsize = 10;
 #else
     const Py_ssize_t expandsize = 6;
 #endif
 
     /* XXX(nnorwitz): rather than over-allocating, it would be
        better to choose a different scheme.  Perhaps scan the
        first N-chars of the string and allocate based on that size.
     */
     /* Initial allocation is based on the longest-possible unichr
        escape.
 
        In wide (UTF-32) builds '\U00xxxxxx' is 10 chars per source
        unichr, so in this case it's the longest unichr escape. In
        narrow (UTF-16) builds this is five chars per source unichr
        since there are two unichrs in the surrogate pair, so in narrow
        (UTF-16) builds it's not the longest unichr escape.
 
        In wide or narrow builds '\uxxxx' is 6 chars per source unichr,
        so in the narrow (UTF-16) build case it's the longest unichr
        escape.
     */
 
+    if (size == 0)
+        return PyBytes_FromStringAndSize(NULL, 0);
+
     if (size > (PY_SSIZE_T_MAX - 2 - 1) / expandsize)
         return PyErr_NoMemory();
 
-    repr = PyString_FromStringAndSize(NULL,
-                                      2
-                                      + expandsize*size
-                                      + 1);
+    repr = PyBytes_FromStringAndSize(NULL,
+                                     2
+                                     + expandsize*size
+                                     + 1);
     if (repr == NULL)
         return NULL;
 
-    p = PyString_AS_STRING(repr);
-
-    if (quotes) {
-        *p++ = 'u';
-        *p++ = (findchar(s, size, '\'') &&
-                !findchar(s, size, '"')) ? '"' : '\'';
-    }
+    p = PyBytes_AS_STRING(repr);
+
     while (size-- > 0) {
         Py_UNICODE ch = *s++;
 
-        /* Escape quotes and backslashes */
-        if ((quotes &&
-             ch == (Py_UNICODE) PyString_AS_STRING(repr)[1]) || ch == '\\') {
+        /* Escape backslashes */
+        if (ch == '\\') {
             *p++ = '\\';
             *p++ = (char) ch;
             continue;
         }
 
 #ifdef Py_UNICODE_WIDE
         /* Map 21-bit characters to '\U00xxxxxx' */
         else if (ch >= 0x10000) {
             *p++ = '\\';
             *p++ = 'U';
-            *p++ = hexdigit[(ch >> 28) & 0x0000000F];
-            *p++ = hexdigit[(ch >> 24) & 0x0000000F];
-            *p++ = hexdigit[(ch >> 20) & 0x0000000F];
-            *p++ = hexdigit[(ch >> 16) & 0x0000000F];
-            *p++ = hexdigit[(ch >> 12) & 0x0000000F];
-            *p++ = hexdigit[(ch >> 8) & 0x0000000F];
-            *p++ = hexdigit[(ch >> 4) & 0x0000000F];
-            *p++ = hexdigit[ch & 0x0000000F];
+            *p++ = hexdigits[(ch >> 28) & 0x0000000F];
+            *p++ = hexdigits[(ch >> 24) & 0x0000000F];
+            *p++ = hexdigits[(ch >> 20) & 0x0000000F];
+            *p++ = hexdigits[(ch >> 16) & 0x0000000F];
+            *p++ = hexdigits[(ch >> 12) & 0x0000000F];
+            *p++ = hexdigits[(ch >> 8) & 0x0000000F];
+            *p++ = hexdigits[(ch >> 4) & 0x0000000F];
+            *p++ = hexdigits[ch & 0x0000000F];
             continue;
         }
 #else
         /* Map UTF-16 surrogate pairs to '\U00xxxxxx' */
         else if (ch >= 0xD800 && ch < 0xDC00) {
             Py_UNICODE ch2;
             Py_UCS4 ucs;
 
             ch2 = *s++;
             size--;
             if (ch2 >= 0xDC00 && ch2 <= 0xDFFF) {
                 ucs = (((ch & 0x03FF) << 10) | (ch2 & 0x03FF)) + 0x00010000;
                 *p++ = '\\';
                 *p++ = 'U';
-                *p++ = hexdigit[(ucs >> 28) & 0x0000000F];
-                *p++ = hexdigit[(ucs >> 24) & 0x0000000F];
-                *p++ = hexdigit[(ucs >> 20) & 0x0000000F];
-                *p++ = hexdigit[(ucs >> 16) & 0x0000000F];
-                *p++ = hexdigit[(ucs >> 12) & 0x0000000F];
-                *p++ = hexdigit[(ucs >> 8) & 0x0000000F];
-                *p++ = hexdigit[(ucs >> 4) & 0x0000000F];
-                *p++ = hexdigit[ucs & 0x0000000F];
+                *p++ = hexdigits[(ucs >> 28) & 0x0000000F];
+                *p++ = hexdigits[(ucs >> 24) & 0x0000000F];
+                *p++ = hexdigits[(ucs >> 20) & 0x0000000F];
+                *p++ = hexdigits[(ucs >> 16) & 0x0000000F];
+                *p++ = hexdigits[(ucs >> 12) & 0x0000000F];
+                *p++ = hexdigits[(ucs >> 8) & 0x0000000F];
+                *p++ = hexdigits[(ucs >> 4) & 0x0000000F];
+                *p++ = hexdigits[ucs & 0x0000000F];
                 continue;
             }
             /* Fall through: isolated surrogates are copied as-is */
             s--;
             size++;
         }
 #endif
 
         /* Map 16-bit characters to '\uxxxx' */
         if (ch >= 256) {
             *p++ = '\\';
             *p++ = 'u';
-            *p++ = hexdigit[(ch >> 12) & 0x000F];
-            *p++ = hexdigit[(ch >> 8) & 0x000F];
-            *p++ = hexdigit[(ch >> 4) & 0x000F];
-            *p++ = hexdigit[ch & 0x000F];
+            *p++ = hexdigits[(ch >> 12) & 0x000F];
+            *p++ = hexdigits[(ch >> 8) & 0x000F];
+            *p++ = hexdigits[(ch >> 4) & 0x000F];
+            *p++ = hexdigits[ch & 0x000F];
         }
 
         /* Map special whitespace to '\t', \n', '\r' */
         else if (ch == '\t') {
             *p++ = '\\';
             *p++ = 't';
         }
         else if (ch == '\n') {
             *p++ = '\\';
             *p++ = 'n';
         }
         else if (ch == '\r') {
             *p++ = '\\';
             *p++ = 'r';
         }
 
         /* Map non-printable US ASCII to '\xhh' */
         else if (ch < ' ' || ch >= 0x7F) {
             *p++ = '\\';
             *p++ = 'x';
-            *p++ = hexdigit[(ch >> 4) & 0x000F];
-            *p++ = hexdigit[ch & 0x000F];
+            *p++ = hexdigits[(ch >> 4) & 0x000F];
+            *p++ = hexdigits[ch & 0x000F];
         }
 
         /* Copy everything else as-is */
         else
             *p++ = (char) ch;
     }
-    if (quotes)
-        *p++ = PyString_AS_STRING(repr)[1];
-
-    *p = '\0';
-    if (_PyString_Resize(&repr, p - PyString_AS_STRING(repr)))
+
+    assert(p - PyBytes_AS_STRING(repr) > 0);
+    if (_PyBytes_Resize(&repr, p - PyBytes_AS_STRING(repr)) < 0)
         return NULL;
     return repr;
 }
 
-PyObject *PyUnicode_EncodeUnicodeEscape(const Py_UNICODE *s,
-                                        Py_ssize_t size)
-{
-    return unicodeescape_string(s, size, 0);
-}
-
 PyObject *PyUnicode_AsUnicodeEscapeString(PyObject *unicode)
 {
+    PyObject *s;
     if (!PyUnicode_Check(unicode)) {
         PyErr_BadArgument();
         return NULL;
     }
-    return PyUnicode_EncodeUnicodeEscape(PyUnicode_AS_UNICODE(unicode),
-                                         PyUnicode_GET_SIZE(unicode));
+    s = PyUnicode_EncodeUnicodeEscape(PyUnicode_AS_UNICODE(unicode),
+                                      PyUnicode_GET_SIZE(unicode));
+    return s;
 }
 
 /* --- Raw Unicode Escape Codec ------------------------------------------- */
 
 PyObject *PyUnicode_DecodeRawUnicodeEscape(const char *s,
                                            Py_ssize_t size,
                                            const char *errors)
 {
     const char *starts = s;
     Py_ssize_t startinpos;
@@ skipping 44 matching lines @@
             continue;
         }
         p--;
         count = *s=='u' ? 4 : 8;
         s++;
 
         /* \uXXXX with 4 hex digits, \Uxxxxxxxx with 8 */
         outpos = p-PyUnicode_AS_UNICODE(v);
         for (x = 0, i = 0; i < count; ++i, ++s) {
             c = (unsigned char)*s;
-            if (!isxdigit(c)) {
+            if (!ISXDIGIT(c)) {
                 endinpos = s-starts;
                 if (unicode_decode_call_errorhandler(
                         errors, &errorHandler,
                         "rawunicodeescape", "truncated \\uXXXX",
-                        starts, size, &startinpos, &endinpos, &exc, &s,
+                        &starts, &end, &startinpos, &endinpos, &exc, &s,
                         &v, &outpos, &p))
                     goto onError;
                 goto nextByte;
             }
             x = (x<<4) & ~0xF;
             if (c >= '0' && c <= '9')
                 x += c - '0';
             else if (c >= 'a' && c <= 'f')
                 x += 10 + c - 'a';
             else
@@ skipping 11 matching lines @@
             x -= 0x10000L;
             *p++ = 0xD800 + (Py_UNICODE) (x >> 10);
             *p++ = 0xDC00 + (Py_UNICODE) (x & 0x03FF);
 #endif
         } else {
             endinpos = s-starts;
             outpos = p-PyUnicode_AS_UNICODE(v);
             if (unicode_decode_call_errorhandler(
                     errors, &errorHandler,
                     "rawunicodeescape", "\\Uxxxxxxxx out of range",
-                    starts, size, &startinpos, &endinpos, &exc, &s,
+                    &starts, &end, &startinpos, &endinpos, &exc, &s,
                     &v, &outpos, &p))
                 goto onError;
         }
       nextByte:
         ;
     }
     if (_PyUnicode_Resize(&v, p - PyUnicode_AS_UNICODE(v)) < 0)
         goto onError;
     Py_XDECREF(errorHandler);
     Py_XDECREF(exc);
     return (PyObject *)v;
 
   onError:
     Py_XDECREF(v);
     Py_XDECREF(errorHandler);
     Py_XDECREF(exc);
     return NULL;
 }
 
 PyObject *PyUnicode_EncodeRawUnicodeEscape(const Py_UNICODE *s,
                                            Py_ssize_t size)
 {
     PyObject *repr;
     char *p;
     char *q;
 
-    static const char *hexdigit = "0123456789abcdef";
 #ifdef Py_UNICODE_WIDE
     const Py_ssize_t expandsize = 10;
 #else
     const Py_ssize_t expandsize = 6;
 #endif
 
     if (size > PY_SSIZE_T_MAX / expandsize)
         return PyErr_NoMemory();
 
-    repr = PyString_FromStringAndSize(NULL, expandsize * size);
+    repr = PyBytes_FromStringAndSize(NULL, expandsize * size);
     if (repr == NULL)
         return NULL;
     if (size == 0)
         return repr;
 
-    p = q = PyString_AS_STRING(repr);
+    p = q = PyBytes_AS_STRING(repr);
     while (size-- > 0) {
         Py_UNICODE ch = *s++;
 #ifdef Py_UNICODE_WIDE
         /* Map 32-bit characters to '\Uxxxxxxxx' */
         if (ch >= 0x10000) {
             *p++ = '\\';
             *p++ = 'U';
-            *p++ = hexdigit[(ch >> 28) & 0xf];
-            *p++ = hexdigit[(ch >> 24) & 0xf];
-            *p++ = hexdigit[(ch >> 20) & 0xf];
-            *p++ = hexdigit[(ch >> 16) & 0xf];
-            *p++ = hexdigit[(ch >> 12) & 0xf];
-            *p++ = hexdigit[(ch >> 8) & 0xf];
-            *p++ = hexdigit[(ch >> 4) & 0xf];
-            *p++ = hexdigit[ch & 15];
+            *p++ = hexdigits[(ch >> 28) & 0xf];
+            *p++ = hexdigits[(ch >> 24) & 0xf];
+            *p++ = hexdigits[(ch >> 20) & 0xf];
+            *p++ = hexdigits[(ch >> 16) & 0xf];
+            *p++ = hexdigits[(ch >> 12) & 0xf];
+            *p++ = hexdigits[(ch >> 8) & 0xf];
+            *p++ = hexdigits[(ch >> 4) & 0xf];
+            *p++ = hexdigits[ch & 15];
         }
         else
 #else
             /* Map UTF-16 surrogate pairs to '\U00xxxxxx' */
             if (ch >= 0xD800 && ch < 0xDC00) {
                 Py_UNICODE ch2;
                 Py_UCS4 ucs;
 
                 ch2 = *s++;
                 size--;
                 if (ch2 >= 0xDC00 && ch2 <= 0xDFFF) {
                     ucs = (((ch & 0x03FF) << 10) | (ch2 & 0x03FF)) + 0x00010000;
                     *p++ = '\\';
                     *p++ = 'U';
-                    *p++ = hexdigit[(ucs >> 28) & 0xf];
-                    *p++ = hexdigit[(ucs >> 24) & 0xf];
-                    *p++ = hexdigit[(ucs >> 20) & 0xf];
-                    *p++ = hexdigit[(ucs >> 16) & 0xf];
-                    *p++ = hexdigit[(ucs >> 12) & 0xf];
-                    *p++ = hexdigit[(ucs >> 8) & 0xf];
-                    *p++ = hexdigit[(ucs >> 4) & 0xf];
-                    *p++ = hexdigit[ucs & 0xf];
+                    *p++ = hexdigits[(ucs >> 28) & 0xf];
+                    *p++ = hexdigits[(ucs >> 24) & 0xf];
+                    *p++ = hexdigits[(ucs >> 20) & 0xf];
+                    *p++ = hexdigits[(ucs >> 16) & 0xf];
+                    *p++ = hexdigits[(ucs >> 12) & 0xf];
+                    *p++ = hexdigits[(ucs >> 8) & 0xf];
+                    *p++ = hexdigits[(ucs >> 4) & 0xf];
+                    *p++ = hexdigits[ucs & 0xf];
                     continue;
                 }
                 /* Fall through: isolated surrogates are copied as-is */
                 s--;
                 size++;
             }
 #endif
         /* Map 16-bit characters to '\uxxxx' */
         if (ch >= 256) {
             *p++ = '\\';
             *p++ = 'u';
-            *p++ = hexdigit[(ch >> 12) & 0xf];
-            *p++ = hexdigit[(ch >> 8) & 0xf];
-            *p++ = hexdigit[(ch >> 4) & 0xf];
-            *p++ = hexdigit[ch & 15];
+            *p++ = hexdigits[(ch >> 12) & 0xf];
+            *p++ = hexdigits[(ch >> 8) & 0xf];
+            *p++ = hexdigits[(ch >> 4) & 0xf];
+            *p++ = hexdigits[ch & 15];
         }
         /* Copy everything else as-is */
         else
             *p++ = (char) ch;
     }
-    *p = '\0';
-    if (_PyString_Resize(&repr, p - q))
+    size = p - q;
+
+    assert(size > 0);
+    if (_PyBytes_Resize(&repr, size) < 0)
         return NULL;
     return repr;
 }
 
 PyObject *PyUnicode_AsRawUnicodeEscapeString(PyObject *unicode)
 {
+    PyObject *s;
     if (!PyUnicode_Check(unicode)) {
         PyErr_BadArgument();
         return NULL;
     }
-    return PyUnicode_EncodeRawUnicodeEscape(PyUnicode_AS_UNICODE(unicode),
-                                            PyUnicode_GET_SIZE(unicode));
+    s = PyUnicode_EncodeRawUnicodeEscape(PyUnicode_AS_UNICODE(unicode),
+                                         PyUnicode_GET_SIZE(unicode));
+
+    return s;
 }
 
 /* --- Unicode Internal Codec ------------------------------------------- */
 
 PyObject *_PyUnicode_DecodeUnicodeInternal(const char *s,
                                            Py_ssize_t size,
                                            const char *errors)
 {
     const char *starts = s;
     Py_ssize_t startinpos;
@@ skipping 36 matching lines @@
                 reason = "truncated input";
             }
             else {
                 endinpos = s - starts + Py_UNICODE_SIZE;
                 reason = "illegal code point (> 0x10FFFF)";
             }
             outpos = p - PyUnicode_AS_UNICODE(v);
             if (unicode_decode_call_errorhandler(
                     errors, &errorHandler,
                     "unicode_internal", reason,
-                    starts, size, &startinpos, &endinpos, &exc, &s,
+                    &starts, &end, &startinpos, &endinpos, &exc, &s,
                     &v, &outpos, &p)) {
                 goto onError;
             }
         }
         else {
             p++;
             s += Py_UNICODE_SIZE;
         }
     }
 
@@ skipping 11 matching lines @@
 }
 
 /* --- Latin-1 Codec ------------------------------------------------------ */
 
 PyObject *PyUnicode_DecodeLatin1(const char *s,
                                  Py_ssize_t size,
                                  const char *errors)
 {
     PyUnicodeObject *v;
     Py_UNICODE *p;
+    const char *e, *unrolled_end;
 
     /* Latin-1 is equivalent to the first 256 ordinals in Unicode. */
     if (size == 1) {
         Py_UNICODE r = *(unsigned char*)s;
         return PyUnicode_FromUnicode(&r, 1);
     }
 
     v = _PyUnicode_New(size);
     if (v == NULL)
         goto onError;
     if (size == 0)
         return (PyObject *)v;
     p = PyUnicode_AS_UNICODE(v);
-    while (size-- > 0)
-        *p++ = (unsigned char)*s++;
+    e = s + size;
+    /* Unrolling the copy makes it much faster by reducing the looping
+       overhead. This is similar to what many memcpy() implementations do. */
+    unrolled_end = e - 4;
+    while (s < unrolled_end) {
+        p[0] = (unsigned char) s[0];
+        p[1] = (unsigned char) s[1];
+        p[2] = (unsigned char) s[2];
+        p[3] = (unsigned char) s[3];
+        s += 4;
+        p += 4;
+    }
+    while (s < e)
+        *p++ = (unsigned char) *s++;
     return (PyObject *)v;
 
   onError:
     Py_XDECREF(v);
     return NULL;
 }
 
 /* create or adjust a UnicodeEncodeError */
 static void make_encode_exception(PyObject **exceptionObject,
                                   const char *encoding,
@@ skipping 36 matching lines @@
    build arguments, call the callback and check the arguments,
    put the result into newpos and return the replacement string, which
    has to be freed by the caller */
 static PyObject *unicode_encode_call_errorhandler(const char *errors,
                                                   PyObject **errorHandler,
                                                   const char *encoding, const char *reason,
                                                   const Py_UNICODE *unicode, Py_ssize_t size, PyObject **exceptionObject,
                                                   Py_ssize_t startpos, Py_ssize_t endpos,
                                                   Py_ssize_t *newpos)
 {
-    static char *argparse = "O!n;encoding error handler must return (unicode, int) tuple";
+    static char *argparse = "On;encoding error handler must return (str/bytes, int) tuple";
 
     PyObject *restuple;
     PyObject *resunicode;
 
     if (*errorHandler == NULL) {
         *errorHandler = PyCodec_LookupError(errors);
         if (*errorHandler == NULL)
             return NULL;
     }
 
     make_encode_exception(exceptionObject,
                           encoding, unicode, size, startpos, endpos, reason);
     if (*exceptionObject == NULL)
         return NULL;
 
     restuple = PyObject_CallFunctionObjArgs(
         *errorHandler, *exceptionObject, NULL);
     if (restuple == NULL)
         return NULL;
     if (!PyTuple_Check(restuple)) {
-        PyErr_SetString(PyExc_TypeError, &argparse[4]);
+        PyErr_SetString(PyExc_TypeError, &argparse[3]);
         Py_DECREF(restuple);
         return NULL;
     }
-    if (!PyArg_ParseTuple(restuple, argparse, &PyUnicode_Type,
+    if (!PyArg_ParseTuple(restuple, argparse,
                           &resunicode, newpos)) {
+        Py_DECREF(restuple);
+        return NULL;
+    }
+    if (!PyUnicode_Check(resunicode) && !PyBytes_Check(resunicode)) {
+        PyErr_SetString(PyExc_TypeError, &argparse[3]);
         Py_DECREF(restuple);
         return NULL;
     }
     if (*newpos<0)
         *newpos = size+*newpos;
     if (*newpos<0 || *newpos>size) {
         PyErr_Format(PyExc_IndexError, "position %zd from error handler out of bounds", *newpos);
         Py_DECREF(restuple);
         return NULL;
     }
@@ skipping 10 matching lines @@
     /* output object */
     PyObject *res;
     /* pointers to the beginning and end+1 of input */
     const Py_UNICODE *startp = p;
     const Py_UNICODE *endp = p + size;
     /* pointer to the beginning of the unencodable characters */
     /* const Py_UNICODE *badp = NULL; */
     /* pointer into the output */
     char *str;
     /* current output position */
-    Py_ssize_t respos = 0;
     Py_ssize_t ressize;
     const char *encoding = (limit == 256) ? "latin-1" : "ascii";
     const char *reason = (limit == 256) ? "ordinal not in range(256)" : "ordinal not in range(128)";
     PyObject *errorHandler = NULL;
     PyObject *exc = NULL;
     /* the following variable is used for caching string comparisons
      * -1=not initialized, 0=unknown, 1=strict, 2=replace, 3=ignore, 4=xmlcharrefreplace */
     int known_errorHandler = -1;
 
     /* allocate enough for a simple encoding without
        replacements, if we need more, we'll resize */
-    res = PyString_FromStringAndSize(NULL, size);
+    if (size == 0)
+        return PyBytes_FromStringAndSize(NULL, 0);
+    res = PyBytes_FromStringAndSize(NULL, size);
     if (res == NULL)
-        goto onError;
-    if (size == 0)
-        return res;
-    str = PyString_AS_STRING(res);
+        return NULL;
+    str = PyBytes_AS_STRING(res);
     ressize = size;
 
     while (p<endp) {
         Py_UNICODE c = *p;
 
         /* can we encode this? */
         if (c<limit) {
             /* no overflow check, because we know that the space is enough */
             *str++ = (char)c;
             ++p;
@@ skipping 29 matching lines @@
             case 1: /* strict */
                 raise_encode_exception(&exc, encoding, startp, size, collstart-startp, collend-startp, reason);
                 goto onError;
             case 2: /* replace */
                 while (collstart++<collend)
                     *str++ = '?'; /* fall through */
             case 3: /* ignore */
                 p = collend;
                 break;
             case 4: /* xmlcharrefreplace */
-                respos = str-PyString_AS_STRING(res);
+                respos = str - PyBytes_AS_STRING(res);
                 /* determine replacement size (temporarily (mis)uses p) */
                 for (p = collstart, repsize = 0; p < collend; ++p) {
                     if (*p<10)
                         repsize += 2+1+1;
                     else if (*p<100)
                         repsize += 2+2+1;
                     else if (*p<1000)
                         repsize += 2+3+1;
                     else if (*p<10000)
                         repsize += 2+4+1;
 #ifndef Py_UNICODE_WIDE
                     else
                         repsize += 2+5+1;
 #else
                     else if (*p<100000)
                         repsize += 2+5+1;
                     else if (*p<1000000)
                         repsize += 2+6+1;
                     else
                         repsize += 2+7+1;
 #endif
                 }
                 requiredsize = respos+repsize+(endp-collend);
                 if (requiredsize > ressize) {
                     if (requiredsize<2*ressize)
                         requiredsize = 2*ressize;
-                    if (_PyString_Resize(&res, requiredsize))
+                    if (_PyBytes_Resize(&res, requiredsize))
                         goto onError;
-                    str = PyString_AS_STRING(res) + respos;
+                    str = PyBytes_AS_STRING(res) + respos;
                     ressize = requiredsize;
                 }
                 /* generate replacement (temporarily (mis)uses p) */
                 for (p = collstart; p < collend; ++p) {
                     str += sprintf(str, "&#%d;", (int)*p);
                 }
                 p = collend;
                 break;
             default:
                 repunicode = unicode_encode_call_errorhandler(errors, &errorHandler,
                                                               encoding, reason, startp, size, &exc,
                                                               collstart-startp, collend-startp, &newpos);
                 if (repunicode == NULL)
                     goto onError;
-                /* need more space? (at least enough for what we have+the
-                   replacement+the rest of the string, so we won't have to
-                   check space for encodable characters) */
-                respos = str-PyString_AS_STRING(res);
+                if (PyBytes_Check(repunicode)) {
+                    /* Directly copy bytes result to output. */
+                    repsize = PyBytes_Size(repunicode);
+                    if (repsize > 1) {
+                        /* Make room for all additional bytes. */
+                        respos = str - PyBytes_AS_STRING(res);
+                        if (_PyBytes_Resize(&res, ressize+repsize-1)) {
+                            Py_DECREF(repunicode);
+                            goto onError;
+                        }
+                        str = PyBytes_AS_STRING(res) + respos;
+                        ressize += repsize-1;
+                    }
+                    memcpy(str, PyBytes_AsString(repunicode), repsize);
+                    str += repsize;
+                    p = startp + newpos;
+                    Py_DECREF(repunicode);
+                    break;
+                }
+                /* need more space? (at least enough for what we
+                   have+the replacement+the rest of the string, so
+                   we won't have to check space for encodable characters) */
+                respos = str - PyBytes_AS_STRING(res);
                 repsize = PyUnicode_GET_SIZE(repunicode);
                 requiredsize = respos+repsize+(endp-collend);
                 if (requiredsize > ressize) {
                     if (requiredsize<2*ressize)
                         requiredsize = 2*ressize;
-                    if (_PyString_Resize(&res, requiredsize)) {
+                    if (_PyBytes_Resize(&res, requiredsize)) {
                         Py_DECREF(repunicode);
                         goto onError;
                     }
-                    str = PyString_AS_STRING(res) + respos;
+                    str = PyBytes_AS_STRING(res) + respos;
                     ressize = requiredsize;
                 }
                 /* check if there is anything unencodable in the replacement
                    and copy it to the output */
                 for (uni2 = PyUnicode_AS_UNICODE(repunicode);repsize-->0; ++uni2, ++str) {
                     c = *uni2;
                     if (c >= limit) {
                         raise_encode_exception(&exc, encoding, startp, size,
                                                unicodepos, unicodepos+1, reason);
                         Py_DECREF(repunicode);
                         goto onError;
                     }
                     *str = (char)c;
                 }
                 p = startp + newpos;
                 Py_DECREF(repunicode);
             }
         }
     }
     /* Resize if we allocated to much */
-    respos = str-PyString_AS_STRING(res);
-    if (respos<ressize)
-        /* If this falls res will be NULL */
-        _PyString_Resize(&res, respos);
+    size = str - PyBytes_AS_STRING(res);
+    if (size < ressize) { /* If this falls res will be NULL */
+        assert(size >= 0);
+        if (_PyBytes_Resize(&res, size) < 0)
+            goto onError;
+    }
+
     Py_XDECREF(errorHandler);
     Py_XDECREF(exc);
     return res;
 
   onError:
     Py_XDECREF(res);
     Py_XDECREF(errorHandler);
     Py_XDECREF(exc);
     return NULL;
 }
@@ skipping 51 matching lines @@
             *p++ = c;
             ++s;
         }
         else {
             startinpos = s-starts;
             endinpos = startinpos + 1;
             outpos = p - (Py_UNICODE *)PyUnicode_AS_UNICODE(v);
             if (unicode_decode_call_errorhandler(
                     errors, &errorHandler,
                     "ascii", "ordinal not in range(128)",
-                    starts, size, &startinpos, &endinpos, &exc, &s,
+                    &starts, &e, &startinpos, &endinpos, &exc, &s,
                     &v, &outpos, &p))
                 goto onError;
         }
     }
-    if (p - PyUnicode_AS_UNICODE(v) < PyString_GET_SIZE(v))
+    if (p - PyUnicode_AS_UNICODE(v) < PyUnicode_GET_SIZE(v))
         if (_PyUnicode_Resize(&v, p - PyUnicode_AS_UNICODE(v)) < 0)
             goto onError;
     Py_XDECREF(errorHandler);
     Py_XDECREF(exc);
     return (PyObject *)v;
 
   onError:
     Py_XDECREF(v);
     Py_XDECREF(errorHandler);
     Py_XDECREF(exc);
@@ skipping 157 matching lines @@
     if (size > 0) {
         mbcssize = WideCharToMultiByte(CP_ACP, 0, p, size, NULL, 0, NULL, NULL);
         if (mbcssize == 0) {
             PyErr_SetFromWindowsErrWithFilename(0, NULL);
             return -1;
         }
     }
 
     if (*repr == NULL) {
         /* Create string object */
-        *repr = PyString_FromStringAndSize(NULL, mbcssize);
+        *repr = PyBytes_FromStringAndSize(NULL, mbcssize);
         if (*repr == NULL)
             return -1;
     }
     else {
         /* Extend string object */
-        n = PyString_Size(*repr);
-        if (_PyString_Resize(repr, n + mbcssize) < 0)
+        n = PyBytes_Size(*repr);
+        if (_PyBytes_Resize(repr, n + mbcssize) < 0)
             return -1;
     }
 
     /* Do the conversion */
     if (size > 0) {
-        char *s = PyString_AS_STRING(*repr) + n;
+        char *s = PyBytes_AS_STRING(*repr) + n;
         if (0 == WideCharToMultiByte(CP_ACP, 0, p, size, s, mbcssize, NULL, NULL)) {
             PyErr_SetFromWindowsErrWithFilename(0, NULL);
             return -1;
         }
     }
 
     return 0;
 }
 
 PyObject *PyUnicode_EncodeMBCS(const Py_UNICODE *p,
@@ skipping 84 matching lines @@
                 x = mapstring[ch];
 
             if (x == 0xfffe) {
                 /* undefined mapping */
                 outpos = p-PyUnicode_AS_UNICODE(v);
                 startinpos = s-starts;
                 endinpos = startinpos+1;
                 if (unicode_decode_call_errorhandler(
                         errors, &errorHandler,
                         "charmap", "character maps to <undefined>",
-                        starts, size, &startinpos, &endinpos, &exc, &s,
+                        &starts, &e, &startinpos, &endinpos, &exc, &s,
                         &v, &outpos, &p)) {
                     goto onError;
                 }
                 continue;
             }
             *p++ = x;
             ++s;
         }
     }
     else {
         while (s < e) {
             unsigned char ch = *s;
             PyObject *w, *x;
 
             /* Get mapping (char ordinal -> integer, Unicode char or None) */
-            w = PyInt_FromLong((long)ch);
+            w = PyLong_FromLong((long)ch);
             if (w == NULL)
                 goto onError;
             x = PyObject_GetItem(mapping, w);
             Py_DECREF(w);
             if (x == NULL) {
                 if (PyErr_ExceptionMatches(PyExc_LookupError)) {
                     /* No mapping found means: mapping is undefined. */
                     PyErr_Clear();
                     x = Py_None;
                     Py_INCREF(x);
                 } else
                     goto onError;
             }
 
             /* Apply mapping */
-            if (PyInt_Check(x)) {
-                long value = PyInt_AS_LONG(x);
+            if (PyLong_Check(x)) {
+                long value = PyLong_AS_LONG(x);
                 if (value < 0 || value > 65535) {
                     PyErr_SetString(PyExc_TypeError,
                                     "character mapping must be in range(65536)");
                     Py_DECREF(x);
                     goto onError;
                 }
                 *p++ = (Py_UNICODE)value;
             }
             else if (x == Py_None) {
                 /* undefined mapping */
                 outpos = p-PyUnicode_AS_UNICODE(v);
                 startinpos = s-starts;
                 endinpos = startinpos+1;
                 if (unicode_decode_call_errorhandler(
                         errors, &errorHandler,
                         "charmap", "character maps to <undefined>",
-                        starts, size, &startinpos, &endinpos, &exc, &s,
+                        &starts, &e, &startinpos, &endinpos, &exc, &s,
                         &v, &outpos, &p)) {
                     Py_DECREF(x);
                     goto onError;
                 }
                 Py_DECREF(x);
                 continue;
             }
             else if (PyUnicode_Check(x)) {
                 Py_ssize_t targetsize = PyUnicode_GET_SIZE(x);
 
@@ skipping 21 matching lines @@
                                     PyUnicode_AS_UNICODE(x),
                                     targetsize);
                     p += targetsize;
                     extrachars -= targetsize;
                 }
                 /* 1-0 mapping: skip the character */
             }
             else {
                 /* wrong return value */
                 PyErr_SetString(PyExc_TypeError,
-                                "character mapping must return integer, None or unicode");
+                                "character mapping must return integer, None or str");
                 Py_DECREF(x);
                 goto onError;
             }
             Py_DECREF(x);
             ++s;
         }
     }
     if (p - PyUnicode_AS_UNICODE(v) < PyUnicode_GET_SIZE(v))
         if (_PyUnicode_Resize(&v, p - PyUnicode_AS_UNICODE(v)) < 0)
             goto onError;
@@ skipping 14 matching lines @@
     PyObject_HEAD
     unsigned char level1[32];
     int count2, count3;
     unsigned char level23[1];
 };
 
 static PyObject*
 encoding_map_size(PyObject *obj, PyObject* args)
 {
     struct encoding_map *map = (struct encoding_map*)obj;
-    return PyInt_FromLong(sizeof(*map) - 1 + 16*map->count2 +
-                          128*map->count3);
+    return PyLong_FromLong(sizeof(*map) - 1 + 16*map->count2 +
+                           128*map->count3);
 }
 
 static PyMethodDef encoding_map_methods[] = {
     {"size", encoding_map_size, METH_NOARGS,
      PyDoc_STR("Return the size (in bytes) of this object") },
     { 0 }
 };
 
 static void
 encoding_map_dealloc(PyObject* o)
 {
     PyObject_FREE(o);
 }
 
 static PyTypeObject EncodingMapType = {
     PyVarObject_HEAD_INIT(NULL, 0)
     "EncodingMap",          /*tp_name*/
     sizeof(struct encoding_map),   /*tp_basicsize*/
     0,                      /*tp_itemsize*/
     /* methods */
     encoding_map_dealloc,   /*tp_dealloc*/
     0,                      /*tp_print*/
     0,                      /*tp_getattr*/
     0,                      /*tp_setattr*/
-    0,                      /*tp_compare*/
+    0,                      /*tp_reserved*/
     0,                      /*tp_repr*/
     0,                      /*tp_as_number*/
     0,                      /*tp_as_sequence*/
     0,                      /*tp_as_mapping*/
     0,                      /*tp_hash*/
     0,                      /*tp_call*/
     0,                      /*tp_str*/
     0,                      /*tp_getattro*/
     0,                      /*tp_setattro*/
     0,                      /*tp_as_buffer*/
@@ skipping 69 matching lines @@
 
     if (count2 >= 0xFF || count3 >= 0xFF)
         need_dict = 1;
 
     if (need_dict) {
         PyObject *result = PyDict_New();
         PyObject *key, *value;
         if (!result)
             return NULL;
         for (i = 0; i < 256; i++) {
-            value = NULL;
-            key = PyInt_FromLong(decode[i]);
-            value = PyInt_FromLong(i);
+            key = value = NULL;
+            key = PyLong_FromLong(decode[i]);
+            value = PyLong_FromLong(i);
             if (!key || !value)
                 goto failed1;
             if (PyDict_SetItem(result, key, value) == -1)
                 goto failed1;
             Py_DECREF(key);
             Py_DECREF(value);
         }
         return result;
       failed1:
         Py_XDECREF(key);
@@ skipping 67 matching lines @@
         return -1;
     }
     return i;
 }
 
 /* Lookup the character ch in the mapping. If the character
    can't be found, Py_None is returned (or NULL, if another
    error occurred). */
 static PyObject *charmapencode_lookup(Py_UNICODE c, PyObject *mapping)
 {
-    PyObject *w = PyInt_FromLong((long)c);
+    PyObject *w = PyLong_FromLong((long)c);
     PyObject *x;
 
     if (w == NULL)
         return NULL;
     x = PyObject_GetItem(mapping, w);
     Py_DECREF(w);
     if (x == NULL) {
         if (PyErr_ExceptionMatches(PyExc_LookupError)) {
             /* No mapping found means: mapping is undefined. */
             PyErr_Clear();
             x = Py_None;
             Py_INCREF(x);
             return x;
         } else
             return NULL;
     }
     else if (x == Py_None)
         return x;
-    else if (PyInt_Check(x)) {
-        long value = PyInt_AS_LONG(x);
+    else if (PyLong_Check(x)) {
+        long value = PyLong_AS_LONG(x);
         if (value < 0 || value > 255) {
             PyErr_SetString(PyExc_TypeError,
                             "character mapping must be in range(256)");
             Py_DECREF(x);
             return NULL;
         }
         return x;
     }
-    else if (PyString_Check(x))
+    else if (PyBytes_Check(x))
         return x;
     else {
         /* wrong return value */
-        PyErr_SetString(PyExc_TypeError,
-                        "character mapping must return integer, None or str");
+        PyErr_Format(PyExc_TypeError,
+                     "character mapping must return integer, bytes or None, not %.400s",
+                     x->ob_type->tp_name);
         Py_DECREF(x);
         return NULL;
     }
 }
 
 static int
 charmapencode_resize(PyObject **outobj, Py_ssize_t *outpos, Py_ssize_t requiredsize)
 {
-    Py_ssize_t outsize = PyString_GET_SIZE(*outobj);
+    Py_ssize_t outsize = PyBytes_GET_SIZE(*outobj);
     /* exponentially overallocate to minimize reallocations */
     if (requiredsize < 2*outsize)
         requiredsize = 2*outsize;
-    if (_PyString_Resize(outobj, requiredsize)) {
-        return 0;
-    }
-    return 1;
+    if (_PyBytes_Resize(outobj, requiredsize))
+        return -1;
+    return 0;
 }
 
 typedef enum charmapencode_result {
     enc_SUCCESS, enc_FAILED, enc_EXCEPTION
 }charmapencode_result;
 /* lookup the character, put the result in the output string and adjust
-   various state variables. Reallocate the output string if not enough
+   various state variables. Resize the output bytes object if not enough
    space is available. Return a new reference to the object that
    was put in the output buffer, or Py_None, if the mapping was undefined
    (in which case no character was written) or NULL, if a
    reallocation error occurred. The caller must decref the result */
 static
 charmapencode_result charmapencode_output(Py_UNICODE c, PyObject *mapping,
                                           PyObject **outobj, Py_ssize_t *outpos)
 {
     PyObject *rep;
     char *outstart;
-    Py_ssize_t outsize = PyString_GET_SIZE(*outobj);
+    Py_ssize_t outsize = PyBytes_GET_SIZE(*outobj);
 
     if (Py_TYPE(mapping) == &EncodingMapType) {
         int res = encoding_map_lookup(c, mapping);
         Py_ssize_t requiredsize = *outpos+1;
         if (res == -1)
             return enc_FAILED;
         if (outsize<requiredsize)
-            if (!charmapencode_resize(outobj, outpos, requiredsize))
+            if (charmapencode_resize(outobj, outpos, requiredsize))
                 return enc_EXCEPTION;
-        outstart = PyString_AS_STRING(*outobj);
+        outstart = PyBytes_AS_STRING(*outobj);
         outstart[(*outpos)++] = (char)res;
         return enc_SUCCESS;
     }
 
     rep = charmapencode_lookup(c, mapping);
     if (rep==NULL)
         return enc_EXCEPTION;
     else if (rep==Py_None) {
         Py_DECREF(rep);
         return enc_FAILED;
     } else {
-        if (PyInt_Check(rep)) {
+        if (PyLong_Check(rep)) {
             Py_ssize_t requiredsize = *outpos+1;
             if (outsize<requiredsize)
-                if (!charmapencode_resize(outobj, outpos, requiredsize)) {
+                if (charmapencode_resize(outobj, outpos, requiredsize)) {
                     Py_DECREF(rep);
                     return enc_EXCEPTION;
                 }
-            outstart = PyString_AS_STRING(*outobj);
-            outstart[(*outpos)++] = (char)PyInt_AS_LONG(rep);
+            outstart = PyBytes_AS_STRING(*outobj);
+            outstart[(*outpos)++] = (char)PyLong_AS_LONG(rep);
         }
         else {
-            const char *repchars = PyString_AS_STRING(rep);
-            Py_ssize_t repsize = PyString_GET_SIZE(rep);
+            const char *repchars = PyBytes_AS_STRING(rep);
+            Py_ssize_t repsize = PyBytes_GET_SIZE(rep);
             Py_ssize_t requiredsize = *outpos+repsize;
             if (outsize<requiredsize)
-                if (!charmapencode_resize(outobj, outpos, requiredsize)) {
+                if (charmapencode_resize(outobj, outpos, requiredsize)) {
                     Py_DECREF(rep);
                     return enc_EXCEPTION;
                 }
-            outstart = PyString_AS_STRING(*outobj);
+            outstart = PyBytes_AS_STRING(*outobj);
             memcpy(outstart + *outpos, repchars, repsize);
             *outpos += repsize;
         }
     }
     Py_DECREF(rep);
     return enc_SUCCESS;
 }
 
 /* handle an error in PyUnicode_EncodeCharmap
    Return 0 on success, -1 on error */
@@ skipping 87 matching lines @@
             }
         }
         *inpos = collendpos;
         break;
     default:
         repunicode = unicode_encode_call_errorhandler(errors, errorHandler,
                                                       encoding, reason, p, size, exceptionObject,
                                                       collstartpos, collendpos, &newpos);
         if (repunicode == NULL)
             return -1;
+        if (PyBytes_Check(repunicode)) {
+            /* Directly copy bytes result to output. */
+            Py_ssize_t outsize = PyBytes_Size(*res);
+            Py_ssize_t requiredsize;
+            repsize = PyBytes_Size(repunicode);
+            requiredsize = *respos + repsize;
+            if (requiredsize > outsize)
+                /* Make room for all additional bytes. */
+                if (charmapencode_resize(res, respos, requiredsize)) {
+                    Py_DECREF(repunicode);
+                    return -1;
+                }
+            memcpy(PyBytes_AsString(*res) + *respos,
+                   PyBytes_AsString(repunicode),  repsize);
+            *respos += repsize;
+            *inpos = newpos;
+            Py_DECREF(repunicode);
+            break;
+        }
         /* generate replacement  */
         repsize = PyUnicode_GET_SIZE(repunicode);
         for (uni2 = PyUnicode_AS_UNICODE(repunicode); repsize-->0; ++uni2) {
             x = charmapencode_output(*uni2, mapping, res, respos);
             if (x==enc_EXCEPTION) {
                 return -1;
             }
             else if (x==enc_FAILED) {
                 Py_DECREF(repunicode);
                 raise_encode_exception(exceptionObject, encoding, p, size, collstartpos, collendpos, reason);
@@ skipping 23 matching lines @@
      * -1=not initialized, 0=unknown, 1=strict, 2=replace,
      * 3=ignore, 4=xmlcharrefreplace */
     int known_errorHandler = -1;
 
     /* Default to Latin-1 */
     if (mapping == NULL)
         return PyUnicode_EncodeLatin1(p, size, errors);
 
     /* allocate enough for a simple encoding without
        replacements, if we need more, we'll resize */
-    res = PyString_FromStringAndSize(NULL, size);
+    res = PyBytes_FromStringAndSize(NULL, size);
     if (res == NULL)
         goto onError;
     if (size == 0)
         return res;
 
     while (inpos<size) {
         /* try to encode it */
         charmapencode_result x = charmapencode_output(p[inpos], mapping, &res, &respos);
         if (x==enc_EXCEPTION) /* error */
             goto onError;
         if (x==enc_FAILED) { /* unencodable character */
             if (charmap_encoding_error(p, size, &inpos, mapping,
                                        &exc,
                                        &known_errorHandler, &errorHandler, errors,
                                        &res, &respos)) {
                 goto onError;
             }
         }
         else
             /* done with this character => adjust input position */
             ++inpos;
     }
 
     /* Resize if we allocated to much */
-    if (respos<PyString_GET_SIZE(res)) {
-        if (_PyString_Resize(&res, respos))
+    if (respos<PyBytes_GET_SIZE(res))
+        if (_PyBytes_Resize(&res, respos) < 0)
             goto onError;
-    }
+
     Py_XDECREF(exc);
     Py_XDECREF(errorHandler);
     return res;
 
   onError:
     Py_XDECREF(res);
     Py_XDECREF(exc);
     Py_XDECREF(errorHandler);
     return NULL;
 }
@@ skipping 51 matching lines @@
    build arguments, call the callback and check the arguments,
    put the result into newpos and return the replacement string, which
    has to be freed by the caller */
 static PyObject *unicode_translate_call_errorhandler(const char *errors,
                                                      PyObject **errorHandler,
                                                      const char *reason,
                                                      const Py_UNICODE *unicode, Py_ssize_t size, PyObject **exceptionObject,
                                                      Py_ssize_t startpos, Py_ssize_t endpos,
                                                      Py_ssize_t *newpos)
 {
-    static char *argparse = "O!n;translating error handler must return (unicode, int) tuple";
+    static char *argparse = "O!n;translating error handler must return (str, int) tuple";
 
     Py_ssize_t i_newpos;
     PyObject *restuple;
     PyObject *resunicode;
 
     if (*errorHandler == NULL) {
         *errorHandler = PyCodec_LookupError(errors);
         if (*errorHandler == NULL)
             return NULL;
     }
@@ skipping 30 matching lines @@
     Py_DECREF(restuple);
     return resunicode;
 }
 
 /* Lookup the character ch in the mapping and put the result in result,
    which must be decrefed by the caller.
    Return 0 on success, -1 on error */
 static
 int charmaptranslate_lookup(Py_UNICODE c, PyObject *mapping, PyObject **result)
 {
-    PyObject *w = PyInt_FromLong((long)c);
+    PyObject *w = PyLong_FromLong((long)c);
     PyObject *x;
 
     if (w == NULL)
         return -1;
     x = PyObject_GetItem(mapping, w);
     Py_DECREF(w);
     if (x == NULL) {
         if (PyErr_ExceptionMatches(PyExc_LookupError)) {
             /* No mapping found means: use 1:1 mapping. */
             PyErr_Clear();
             *result = NULL;
             return 0;
         } else
             return -1;
     }
     else if (x == Py_None) {
         *result = x;
         return 0;
     }
-    else if (PyInt_Check(x)) {
-        long value = PyInt_AS_LONG(x);
+    else if (PyLong_Check(x)) {
+        long value = PyLong_AS_LONG(x);
         long max = PyUnicode_GetMax();
         if (value < 0 || value > max) {
             PyErr_Format(PyExc_TypeError,
-                         "character mapping must be in range(0x%lx)", max+1);
+                         "character mapping must be in range(0x%x)", max+1);
             Py_DECREF(x);
             return -1;
         }
         *result = x;
         return 0;
     }
     else if (PyUnicode_Check(x)) {
         *result = x;
         return 0;
     }
     else {
         /* wrong return value */
         PyErr_SetString(PyExc_TypeError,
-                        "character mapping must return integer, None or unicode");
+                        "character mapping must return integer, None or str");
         Py_DECREF(x);
         return -1;
     }
 }
 /* ensure that *outobj is at least requiredsize characters long,
    if not reallocate and adjust various state variables.
    Return 0 on success, -1 on error */
 static
 int charmaptranslate_makespace(PyObject **outobj, Py_UNICODE **outp,
                                Py_ssize_t requiredsize)
@@ skipping 23 matching lines @@
                             PyObject **res)
 {
     if (charmaptranslate_lookup(*curinp, mapping, res))
         return -1;
     if (*res==NULL) {
         /* not found => default to 1:1 mapping */
         *(*outp)++ = *curinp;
     }
     else if (*res==Py_None)
         ;
-    else if (PyInt_Check(*res)) {
+    else if (PyLong_Check(*res)) {
         /* no overflow check, because we know that the space is enough */
-        *(*outp)++ = (Py_UNICODE)PyInt_AS_LONG(*res);
+        *(*outp)++ = (Py_UNICODE)PyLong_AS_LONG(*res);
     }
     else if (PyUnicode_Check(*res)) {
         Py_ssize_t repsize = PyUnicode_GET_SIZE(*res);
         if (repsize==1) {
             /* no overflow check, because we know that the space is enough */
             *(*outp)++ = *PyUnicode_AS_UNICODE(*res);
         }
         else if (repsize!=0) {
             /* more than one character */
             Py_ssize_t requiredsize = (*outp-PyUnicode_AS_UNICODE(*outobj)) +
@@ skipping 261 matching lines @@
             for (p = collstart; p < collend; ++p)
                 output += sprintf(output, "&#%d;", (int)*p);
             p = collend;
             break;
         default:
             repunicode = unicode_encode_call_errorhandler(errors, &errorHandler,
                                                           encoding, reason, s, length, &exc,
                                                           collstart-s, collend-s, &newpos);
             if (repunicode == NULL)
                 goto onError;
+            if (!PyUnicode_Check(repunicode)) {
+                /* Byte results not supported, since they have no decimal property. */
+                PyErr_SetString(PyExc_TypeError, "error handler should return unicode");
+                Py_DECREF(repunicode);
+                goto onError;
+            }
             /* generate replacement  */
             repsize = PyUnicode_GET_SIZE(repunicode);
             for (uni2 = PyUnicode_AS_UNICODE(repunicode); repsize-->0; ++uni2) {
                 Py_UNICODE ch = *uni2;
                 if (Py_UNICODE_ISSPACE(ch))
                     *output++ = ' ';
                 else {
                     decimal = Py_UNICODE_TODECIMAL(ch);
                     if (decimal >= 0)
                         *output++ = '0' + decimal;
@@ skipping 20 matching lines @@
   onError:
     Py_XDECREF(exc);
     Py_XDECREF(errorHandler);
     return -1;
 }
 
 /* --- Helpers ------------------------------------------------------------ */
 
 #include "stringlib/unicodedefs.h"
 #include "stringlib/fastsearch.h"
-
 #include "stringlib/count.h"
+/* Include _ParseTupleFinds from find.h */
+#define FROM_UNICODE
 #include "stringlib/find.h"
 #include "stringlib/partition.h"
-#include "stringlib/split.h"
+
+#define _Py_InsertThousandsGrouping _PyUnicode_InsertThousandsGrouping
+#define _Py_InsertThousandsGroupingLocale _PyUnicode_InsertThousandsGroupingLocale
+#include "stringlib/localeutil.h"
 
 /* helper macro to fixup start/end slice values */
-#define ADJUST_INDICES(start, end, len)         \
-    if (end > len)                              \
-        end = len;                              \
-    else if (end < 0) {                         \
-        end += len;                             \
-        if (end < 0)                            \
-            end = 0;                            \
-    }                                           \
-    if (start < 0) {                            \
-        start += len;                           \
-        if (start < 0)                          \
-            start = 0;                          \
-    }
+#define FIX_START_END(obj)                      \
+    if (start < 0)                              \
+        start += (obj)->length;                 \
+    if (start < 0)                              \
+        start = 0;                              \
+    if (end > (obj)->length)                    \
+        end = (obj)->length;                    \
+    if (end < 0)                                \
+        end += (obj)->length;                   \
+    if (end < 0)                                \
+        end = 0;
 
 Py_ssize_t PyUnicode_Count(PyObject *str,
                            PyObject *substr,
                            Py_ssize_t start,
                            Py_ssize_t end)
 {
     Py_ssize_t result;
     PyUnicodeObject* str_obj;
     PyUnicodeObject* sub_obj;
 
     str_obj = (PyUnicodeObject*) PyUnicode_FromObject(str);
     if (!str_obj)
         return -1;
     sub_obj = (PyUnicodeObject*) PyUnicode_FromObject(substr);
     if (!sub_obj) {
         Py_DECREF(str_obj);
         return -1;
     }
 
-    ADJUST_INDICES(start, end, str_obj->length);
+    FIX_START_END(str_obj);
+
     result = stringlib_count(
-        str_obj->str + start, end - start, sub_obj->str, sub_obj->length,
-        PY_SSIZE_T_MAX
+        str_obj->str + start, end - start, sub_obj->str, sub_obj->length
         );
 
     Py_DECREF(sub_obj);
     Py_DECREF(str_obj);
 
     return result;
 }
 
 Py_ssize_t PyUnicode_Find(PyObject *str,
                           PyObject *sub,
@@ skipping 34 matching lines @@
 static
 int tailmatch(PyUnicodeObject *self,
               PyUnicodeObject *substring,
               Py_ssize_t start,
               Py_ssize_t end,
               int direction)
 {
     if (substring->length == 0)
         return 1;
 
-    ADJUST_INDICES(start, end, self->length);
+    FIX_START_END(self);
+
     end -= substring->length;
     if (end < start)
         return 0;
 
     if (direction > 0) {
         if (Py_UNICODE_MATCH(self, end, substring))
             return 1;
     } else {
         if (Py_UNICODE_MATCH(self, start, substring))
             return 1;
@@ skipping 175 matching lines @@
             previous_is_cased = 1;
         else
             previous_is_cased = 0;
     }
     return 1;
 }
 
 PyObject *
 PyUnicode_Join(PyObject *separator, PyObject *seq)
 {
-    PyObject *internal_separator = NULL;
     const Py_UNICODE blank = ' ';
     const Py_UNICODE *sep = &blank;
     Py_ssize_t seplen = 1;
     PyUnicodeObject *res = NULL; /* the result */
-    Py_ssize_t res_alloc = 100;  /* # allocated bytes for string in res */
-    Py_ssize_t res_used;         /* # used bytes */
     Py_UNICODE *res_p;       /* pointer to free byte in res's string area */
     PyObject *fseq;          /* PySequence_Fast(seq) */
-    Py_ssize_t seqlen;              /* len(fseq) -- number of items in sequence */
+    Py_ssize_t seqlen;       /* len(fseq) -- number of items in sequence */
+    PyObject **items;
     PyObject *item;
-    Py_ssize_t i;
+    Py_ssize_t sz, i;
 
     fseq = PySequence_Fast(seq, "");
     if (fseq == NULL) {
         return NULL;
     }
 
-    /* Grrrr.  A codec may be invoked to convert str objects to
-     * Unicode, and so it's possible to call back into Python code
-     * during PyUnicode_FromObject(), and so it's possible for a sick
-     * codec to change the size of fseq (if seq is a list).  Therefore
-     * we have to keep refetching the size -- can't assume seqlen
-     * is invariant.
+    /* NOTE: the following code can't call back into Python code,
+     * so we are sure that fseq won't be mutated.
      */
+
     seqlen = PySequence_Fast_GET_SIZE(fseq);
     /* If empty sequence, return u"". */
     if (seqlen == 0) {
         res = _PyUnicode_New(0);  /* empty sequence; return u"" */
         goto Done;
     }
+    items = PySequence_Fast_ITEMS(fseq);
     /* If singleton sequence with an exact Unicode, return that. */
     if (seqlen == 1) {
-        item = PySequence_Fast_GET_ITEM(fseq, 0);
+        item = items[0];
         if (PyUnicode_CheckExact(item)) {
             Py_INCREF(item);
             res = (PyUnicodeObject *)item;
             goto Done;
         }
     }
-
-    /* At least two items to join, or one that isn't exact Unicode. */
-    if (seqlen > 1) {
-        /* Set up sep and seplen -- they're needed. */
+    else {
+        /* Set up sep and seplen */
         if (separator == NULL) {
             sep = &blank;
             seplen = 1;
         }
         else {
-            internal_separator = PyUnicode_FromObject(separator);
-            if (internal_separator == NULL)
+            if (!PyUnicode_Check(separator)) {
+                PyErr_Format(PyExc_TypeError,
+                             "separator: expected str instance,"
+                             " %.80s found",
+                             Py_TYPE(separator)->tp_name);
                 goto onError;
-            sep = PyUnicode_AS_UNICODE(internal_separator);
-            seplen = PyUnicode_GET_SIZE(internal_separator);
-            /* In case PyUnicode_FromObject() mutated seq. */
-            seqlen = PySequence_Fast_GET_SIZE(fseq);
-        }
-    }
-
-    /* Get space. */
-    res = _PyUnicode_New(res_alloc);
-    if (res == NULL)
-        goto onError;
-    res_p = PyUnicode_AS_UNICODE(res);
-    res_used = 0;
-
-    for (i = 0; i < seqlen; ++i) {
-        Py_ssize_t itemlen;
-        Py_ssize_t new_res_used;
-
-        item = PySequence_Fast_GET_ITEM(fseq, i);
-        /* Convert item to Unicode. */
-        if (! PyUnicode_Check(item) && ! PyString_Check(item)) {
-            PyErr_Format(PyExc_TypeError,
+            }
+            sep = PyUnicode_AS_UNICODE(separator);
+            seplen = PyUnicode_GET_SIZE(separator);
+        }
+    }
+
+    /* There are at least two things to join, or else we have a subclass
+     * of str in the sequence.
+     * Do a pre-pass to figure out the total amount of space we'll
+     * need (sz), and see whether all argument are strings.
+     */
+    sz = 0;
+    for (i = 0; i < seqlen; i++) {
+        const Py_ssize_t old_sz = sz;
+        item = items[i];
+        if (!PyUnicode_Check(item)) {