Restoring authorship annotation for <[email protected]>. Commit 1 of 2.

19 files changed, 5044 insertions, 5044 deletions

diff --git a/contrib/tools/python3/src/Modules/_sqlite/cache.c b/contrib/tools/python3/src/Modules/_sqlite/cache.c
index 758fc022f78..7c6d7953b6f 100644
--- a/contrib/tools/python3/src/Modules/_sqlite/cache.c
+++ b/contrib/tools/python3/src/Modules/_sqlite/cache.c
@@ -1,362 +1,362 @@
-/* cache .c - a LRU cache
- *
- * Copyright (C) 2004-2010 Gerhard Häring <[email protected]>
- *
- * This file is part of pysqlite.
- *
- * This software is provided 'as-is', without any express or implied
- * warranty.  In no event will the authors be held liable for any damages
- * arising from the use of this software.
- *
- * Permission is granted to anyone to use this software for any purpose,
- * including commercial applications, and to alter it and redistribute it
- * freely, subject to the following restrictions:
- *
- * 1. The origin of this software must not be misrepresented; you must not
- *    claim that you wrote the original software. If you use this software
- *    in a product, an acknowledgment in the product documentation would be
- *    appreciated but is not required.
- * 2. Altered source versions must be plainly marked as such, and must not be
- *    misrepresented as being the original software.
- * 3. This notice may not be removed or altered from any source distribution.
- */
-
-#include "cache.h"
-#include <limits.h>
-
-/* only used internally */
-pysqlite_Node* pysqlite_new_node(PyObject* key, PyObject* data)
-{
-    pysqlite_Node* node;
-
-    node = (pysqlite_Node*) (pysqlite_NodeType.tp_alloc(&pysqlite_NodeType, 0));
-    if (!node) {
-        return NULL;
-    }
-
-    Py_INCREF(key);
-    node->key = key;
-
-    Py_INCREF(data);
-    node->data = data;
-
-    node->prev = NULL;
-    node->next = NULL;
-
-    return node;
-}
-
-void pysqlite_node_dealloc(pysqlite_Node* self)
-{
-    Py_DECREF(self->key);
-    Py_DECREF(self->data);
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-int pysqlite_cache_init(pysqlite_Cache* self, PyObject* args, PyObject* kwargs)
-{
-    PyObject* factory;
-    int size = 10;
-
-    self->factory = NULL;
-
-    if (!PyArg_ParseTuple(args, "O|i", &factory, &size)) {
-        return -1;
-    }
-
-    /* minimum cache size is 5 entries */
-    if (size < 5) {
-        size = 5;
-    }
-    self->size = size;
-    self->first = NULL;
-    self->last = NULL;
-
-    self->mapping = PyDict_New();
-    if (!self->mapping) {
-        return -1;
-    }
-
-    Py_INCREF(factory);
-    self->factory = factory;
-
-    self->decref_factory = 1;
-
-    return 0;
-}
-
-void pysqlite_cache_dealloc(pysqlite_Cache* self)
-{
-    pysqlite_Node* node;
-    pysqlite_Node* delete_node;
-
-    if (!self->factory) {
-        /* constructor failed, just get out of here */
-        return;
-    }
-
-    /* iterate over all nodes and deallocate them */
-    node = self->first;
-    while (node) {
-        delete_node = node;
-        node = node->next;
-        Py_DECREF(delete_node);
-    }
-
-    if (self->decref_factory) {
-        Py_DECREF(self->factory);
-    }
-    Py_DECREF(self->mapping);
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
+/* cache .c - a LRU cache 
+ * 
+ * Copyright (C) 2004-2010 Gerhard Häring <[email protected]> 
+ * 
+ * This file is part of pysqlite. 
+ * 
+ * This software is provided 'as-is', without any express or implied 
+ * warranty.  In no event will the authors be held liable for any damages 
+ * arising from the use of this software. 
+ * 
+ * Permission is granted to anyone to use this software for any purpose, 
+ * including commercial applications, and to alter it and redistribute it 
+ * freely, subject to the following restrictions: 
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not 
+ *    claim that you wrote the original software. If you use this software 
+ *    in a product, an acknowledgment in the product documentation would be 
+ *    appreciated but is not required. 
+ * 2. Altered source versions must be plainly marked as such, and must not be 
+ *    misrepresented as being the original software. 
+ * 3. This notice may not be removed or altered from any source distribution. 
+ */ 
+ 
+#include "cache.h" 
+#include <limits.h> 
+ 
+/* only used internally */ 
+pysqlite_Node* pysqlite_new_node(PyObject* key, PyObject* data) 
+{ 
+    pysqlite_Node* node; 
+ 
+    node = (pysqlite_Node*) (pysqlite_NodeType.tp_alloc(&pysqlite_NodeType, 0)); 
+    if (!node) { 
+        return NULL; 
+    } 
+ 
+    Py_INCREF(key); 
+    node->key = key; 
+ 
+    Py_INCREF(data); 
+    node->data = data; 
+ 
+    node->prev = NULL; 
+    node->next = NULL; 
+ 
+    return node; 
+} 
+ 
+void pysqlite_node_dealloc(pysqlite_Node* self) 
+{ 
+    Py_DECREF(self->key); 
+    Py_DECREF(self->data); 
+ 
+    Py_TYPE(self)->tp_free((PyObject*)self); 
+} 
+ 
+int pysqlite_cache_init(pysqlite_Cache* self, PyObject* args, PyObject* kwargs) 
+{ 
+    PyObject* factory; 
+    int size = 10; 
+ 
+    self->factory = NULL; 
+ 
+    if (!PyArg_ParseTuple(args, "O|i", &factory, &size)) { 
+        return -1; 
+    } 
+ 
+    /* minimum cache size is 5 entries */ 
+    if (size < 5) { 
+        size = 5; 
+    } 
+    self->size = size; 
+    self->first = NULL; 
+    self->last = NULL; 
+ 
+    self->mapping = PyDict_New(); 
+    if (!self->mapping) { 
+        return -1; 
+    } 
+ 
+    Py_INCREF(factory); 
+    self->factory = factory; 
+ 
+    self->decref_factory = 1; 
+ 
+    return 0; 
+} 
+ 
+void pysqlite_cache_dealloc(pysqlite_Cache* self) 
+{ 
+    pysqlite_Node* node; 
+    pysqlite_Node* delete_node; 
+ 
+    if (!self->factory) { 
+        /* constructor failed, just get out of here */ 
+        return; 
+    } 
+ 
+    /* iterate over all nodes and deallocate them */ 
+    node = self->first; 
+    while (node) { 
+        delete_node = node; 
+        node = node->next; 
+        Py_DECREF(delete_node); 
+    } 
+ 
+    if (self->decref_factory) { 
+        Py_DECREF(self->factory); 
+    } 
+    Py_DECREF(self->mapping); 
+ 
+    Py_TYPE(self)->tp_free((PyObject*)self); 
+} 
+ 
 PyObject* pysqlite_cache_get(pysqlite_Cache* self, PyObject* key)
-{
-    pysqlite_Node* node;
-    pysqlite_Node* ptr;
-    PyObject* data;
-
+{ 
+    pysqlite_Node* node; 
+    pysqlite_Node* ptr; 
+    PyObject* data; 
+ 
     node = (pysqlite_Node*)PyDict_GetItemWithError(self->mapping, key);
-    if (node) {
-        /* an entry for this key already exists in the cache */
-
-        /* increase usage counter of the node found */
-        if (node->count < LONG_MAX) {
-            node->count++;
-        }
-
-        /* if necessary, reorder entries in the cache by swapping positions */
-        if (node->prev && node->count > node->prev->count) {
-            ptr = node->prev;
-
-            while (ptr->prev && node->count > ptr->prev->count) {
-                ptr = ptr->prev;
-            }
-
-            if (node->next) {
-                node->next->prev = node->prev;
-            } else {
-                self->last = node->prev;
-            }
-            if (node->prev) {
-                node->prev->next = node->next;
-            }
-            if (ptr->prev) {
-                ptr->prev->next = node;
-            } else {
-                self->first = node;
-            }
-
-            node->next = ptr;
-            node->prev = ptr->prev;
-            if (!node->prev) {
-                self->first = node;
-            }
-            ptr->prev = node;
-        }
+    if (node) { 
+        /* an entry for this key already exists in the cache */ 
+ 
+        /* increase usage counter of the node found */ 
+        if (node->count < LONG_MAX) { 
+            node->count++; 
+        } 
+ 
+        /* if necessary, reorder entries in the cache by swapping positions */ 
+        if (node->prev && node->count > node->prev->count) { 
+            ptr = node->prev; 
+ 
+            while (ptr->prev && node->count > ptr->prev->count) { 
+                ptr = ptr->prev; 
+            } 
+ 
+            if (node->next) { 
+                node->next->prev = node->prev; 
+            } else { 
+                self->last = node->prev; 
+            } 
+            if (node->prev) { 
+                node->prev->next = node->next; 
+            } 
+            if (ptr->prev) { 
+                ptr->prev->next = node; 
+            } else { 
+                self->first = node; 
+            } 
+ 
+            node->next = ptr; 
+            node->prev = ptr->prev; 
+            if (!node->prev) { 
+                self->first = node; 
+            } 
+            ptr->prev = node; 
+        } 
     }
     else if (PyErr_Occurred()) {
         return NULL;
     }
     else {
-        /* There is no entry for this key in the cache, yet. We'll insert a new
-         * entry in the cache, and make space if necessary by throwing the
-         * least used item out of the cache. */
-
-        if (PyDict_GET_SIZE(self->mapping) == self->size) {
-            if (self->last) {
-                node = self->last;
-
-                if (PyDict_DelItem(self->mapping, self->last->key) != 0) {
-                    return NULL;
-                }
-
-                if (node->prev) {
-                    node->prev->next = NULL;
-                }
-                self->last = node->prev;
-                node->prev = NULL;
-
-                Py_DECREF(node);
-            }
-        }
-
+        /* There is no entry for this key in the cache, yet. We'll insert a new 
+         * entry in the cache, and make space if necessary by throwing the 
+         * least used item out of the cache. */ 
+ 
+        if (PyDict_GET_SIZE(self->mapping) == self->size) { 
+            if (self->last) { 
+                node = self->last; 
+ 
+                if (PyDict_DelItem(self->mapping, self->last->key) != 0) { 
+                    return NULL; 
+                } 
+ 
+                if (node->prev) { 
+                    node->prev->next = NULL; 
+                } 
+                self->last = node->prev; 
+                node->prev = NULL; 
+ 
+                Py_DECREF(node); 
+            } 
+        } 
+ 
         /* We cannot replace this by PyObject_CallOneArg() since
          * PyObject_CallFunction() has a special case when using a
          * single tuple as argument. */
-        data = PyObject_CallFunction(self->factory, "O", key);
-
-        if (!data) {
-            return NULL;
-        }
-
-        node = pysqlite_new_node(key, data);
-        if (!node) {
-            return NULL;
-        }
-        node->prev = self->last;
-
-        Py_DECREF(data);
-
-        if (PyDict_SetItem(self->mapping, key, (PyObject*)node) != 0) {
-            Py_DECREF(node);
-            return NULL;
-        }
-
-        if (self->last) {
-            self->last->next = node;
-        } else {
-            self->first = node;
-        }
-        self->last = node;
-    }
-
-    Py_INCREF(node->data);
-    return node->data;
-}
-
-PyObject* pysqlite_cache_display(pysqlite_Cache* self, PyObject* args)
-{
-    pysqlite_Node* ptr;
-    PyObject* prevkey;
-    PyObject* nextkey;
-    PyObject* display_str;
-
-    ptr = self->first;
-
-    while (ptr) {
-        if (ptr->prev) {
-            prevkey = ptr->prev->key;
-        } else {
-            prevkey = Py_None;
-        }
-
-        if (ptr->next) {
-            nextkey = ptr->next->key;
-        } else {
-            nextkey = Py_None;
-        }
-
-        display_str = PyUnicode_FromFormat("%S <- %S -> %S\n",
-                                           prevkey, ptr->key, nextkey);
-        if (!display_str) {
-            return NULL;
-        }
-        PyObject_Print(display_str, stdout, Py_PRINT_RAW);
-        Py_DECREF(display_str);
-
-        ptr = ptr->next;
-    }
-
-    Py_RETURN_NONE;
-}
-
-static PyMethodDef cache_methods[] = {
-    {"get", (PyCFunction)pysqlite_cache_get, METH_O,
-        PyDoc_STR("Gets an entry from the cache or calls the factory function to produce one.")},
-    {"display", (PyCFunction)pysqlite_cache_display, METH_NOARGS,
-        PyDoc_STR("For debugging only.")},
-    {NULL, NULL}
-};
-
-PyTypeObject pysqlite_NodeType = {
-        PyVarObject_HEAD_INIT(NULL, 0)
-        MODULE_NAME "Node",                             /* tp_name */
-        sizeof(pysqlite_Node),                          /* tp_basicsize */
-        0,                                              /* tp_itemsize */
-        (destructor)pysqlite_node_dealloc,              /* tp_dealloc */
+        data = PyObject_CallFunction(self->factory, "O", key); 
+ 
+        if (!data) { 
+            return NULL; 
+        } 
+ 
+        node = pysqlite_new_node(key, data); 
+        if (!node) { 
+            return NULL; 
+        } 
+        node->prev = self->last; 
+ 
+        Py_DECREF(data); 
+ 
+        if (PyDict_SetItem(self->mapping, key, (PyObject*)node) != 0) { 
+            Py_DECREF(node); 
+            return NULL; 
+        } 
+ 
+        if (self->last) { 
+            self->last->next = node; 
+        } else { 
+            self->first = node; 
+        } 
+        self->last = node; 
+    } 
+ 
+    Py_INCREF(node->data); 
+    return node->data; 
+} 
+ 
+PyObject* pysqlite_cache_display(pysqlite_Cache* self, PyObject* args) 
+{ 
+    pysqlite_Node* ptr; 
+    PyObject* prevkey; 
+    PyObject* nextkey; 
+    PyObject* display_str; 
+ 
+    ptr = self->first; 
+ 
+    while (ptr) { 
+        if (ptr->prev) { 
+            prevkey = ptr->prev->key; 
+        } else { 
+            prevkey = Py_None; 
+        } 
+ 
+        if (ptr->next) { 
+            nextkey = ptr->next->key; 
+        } else { 
+            nextkey = Py_None; 
+        } 
+ 
+        display_str = PyUnicode_FromFormat("%S <- %S -> %S\n", 
+                                           prevkey, ptr->key, nextkey); 
+        if (!display_str) { 
+            return NULL; 
+        } 
+        PyObject_Print(display_str, stdout, Py_PRINT_RAW); 
+        Py_DECREF(display_str); 
+ 
+        ptr = ptr->next; 
+    } 
+ 
+    Py_RETURN_NONE; 
+} 
+ 
+static PyMethodDef cache_methods[] = { 
+    {"get", (PyCFunction)pysqlite_cache_get, METH_O, 
+        PyDoc_STR("Gets an entry from the cache or calls the factory function to produce one.")}, 
+    {"display", (PyCFunction)pysqlite_cache_display, METH_NOARGS, 
+        PyDoc_STR("For debugging only.")}, 
+    {NULL, NULL} 
+}; 
+ 
+PyTypeObject pysqlite_NodeType = { 
+        PyVarObject_HEAD_INIT(NULL, 0) 
+        MODULE_NAME "Node",                             /* tp_name */ 
+        sizeof(pysqlite_Node),                          /* tp_basicsize */ 
+        0,                                              /* tp_itemsize */ 
+        (destructor)pysqlite_node_dealloc,              /* tp_dealloc */ 
         0,                                              /* tp_vectorcall_offset */
-        0,                                              /* tp_getattr */
-        0,                                              /* tp_setattr */
+        0,                                              /* tp_getattr */ 
+        0,                                              /* tp_setattr */ 
         0,                                              /* tp_as_async */
-        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 */
-        Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,         /* tp_flags */
-        0,                                              /* tp_doc */
-        0,                                              /* tp_traverse */
-        0,                                              /* tp_clear */
-        0,                                              /* tp_richcompare */
-        0,                                              /* tp_weaklistoffset */
-        0,                                              /* tp_iter */
-        0,                                              /* tp_iternext */
-        0,                                              /* tp_methods */
-        0,                                              /* tp_members */
-        0,                                              /* tp_getset */
-        0,                                              /* tp_base */
-        0,                                              /* tp_dict */
-        0,                                              /* tp_descr_get */
-        0,                                              /* tp_descr_set */
-        0,                                              /* tp_dictoffset */
-        (initproc)0,                                    /* tp_init */
-        0,                                              /* tp_alloc */
-        0,                                              /* tp_new */
-        0                                               /* tp_free */
-};
-
-PyTypeObject pysqlite_CacheType = {
-        PyVarObject_HEAD_INIT(NULL, 0)
-        MODULE_NAME ".Cache",                           /* tp_name */
-        sizeof(pysqlite_Cache),                         /* tp_basicsize */
-        0,                                              /* tp_itemsize */
-        (destructor)pysqlite_cache_dealloc,             /* tp_dealloc */
+        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 */ 
+        Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,         /* tp_flags */ 
+        0,                                              /* tp_doc */ 
+        0,                                              /* tp_traverse */ 
+        0,                                              /* tp_clear */ 
+        0,                                              /* tp_richcompare */ 
+        0,                                              /* tp_weaklistoffset */ 
+        0,                                              /* tp_iter */ 
+        0,                                              /* tp_iternext */ 
+        0,                                              /* tp_methods */ 
+        0,                                              /* tp_members */ 
+        0,                                              /* tp_getset */ 
+        0,                                              /* tp_base */ 
+        0,                                              /* tp_dict */ 
+        0,                                              /* tp_descr_get */ 
+        0,                                              /* tp_descr_set */ 
+        0,                                              /* tp_dictoffset */ 
+        (initproc)0,                                    /* tp_init */ 
+        0,                                              /* tp_alloc */ 
+        0,                                              /* tp_new */ 
+        0                                               /* tp_free */ 
+}; 
+ 
+PyTypeObject pysqlite_CacheType = { 
+        PyVarObject_HEAD_INIT(NULL, 0) 
+        MODULE_NAME ".Cache",                           /* tp_name */ 
+        sizeof(pysqlite_Cache),                         /* tp_basicsize */ 
+        0,                                              /* tp_itemsize */ 
+        (destructor)pysqlite_cache_dealloc,             /* tp_dealloc */ 
         0,                                              /* tp_vectorcall_offset */
-        0,                                              /* tp_getattr */
-        0,                                              /* tp_setattr */
+        0,                                              /* tp_getattr */ 
+        0,                                              /* tp_setattr */ 
         0,                                              /* tp_as_async */
-        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 */
-        Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,         /* tp_flags */
-        0,                                              /* tp_doc */
-        0,                                              /* tp_traverse */
-        0,                                              /* tp_clear */
-        0,                                              /* tp_richcompare */
-        0,                                              /* tp_weaklistoffset */
-        0,                                              /* tp_iter */
-        0,                                              /* tp_iternext */
-        cache_methods,                                  /* tp_methods */
-        0,                                              /* tp_members */
-        0,                                              /* tp_getset */
-        0,                                              /* tp_base */
-        0,                                              /* tp_dict */
-        0,                                              /* tp_descr_get */
-        0,                                              /* tp_descr_set */
-        0,                                              /* tp_dictoffset */
-        (initproc)pysqlite_cache_init,                  /* tp_init */
-        0,                                              /* tp_alloc */
-        0,                                              /* tp_new */
-        0                                               /* tp_free */
-};
-
-extern int pysqlite_cache_setup_types(void)
-{
-    int rc;
-
-    pysqlite_NodeType.tp_new = PyType_GenericNew;
-    pysqlite_CacheType.tp_new = PyType_GenericNew;
-
-    rc = PyType_Ready(&pysqlite_NodeType);
-    if (rc < 0) {
-        return rc;
-    }
-
-    rc = PyType_Ready(&pysqlite_CacheType);
-    return rc;
-}
+        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 */ 
+        Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,         /* tp_flags */ 
+        0,                                              /* tp_doc */ 
+        0,                                              /* tp_traverse */ 
+        0,                                              /* tp_clear */ 
+        0,                                              /* tp_richcompare */ 
+        0,                                              /* tp_weaklistoffset */ 
+        0,                                              /* tp_iter */ 
+        0,                                              /* tp_iternext */ 
+        cache_methods,                                  /* tp_methods */ 
+        0,                                              /* tp_members */ 
+        0,                                              /* tp_getset */ 
+        0,                                              /* tp_base */ 
+        0,                                              /* tp_dict */ 
+        0,                                              /* tp_descr_get */ 
+        0,                                              /* tp_descr_set */ 
+        0,                                              /* tp_dictoffset */ 
+        (initproc)pysqlite_cache_init,                  /* tp_init */ 
+        0,                                              /* tp_alloc */ 
+        0,                                              /* tp_new */ 
+        0                                               /* tp_free */ 
+}; 
+ 
+extern int pysqlite_cache_setup_types(void) 
+{ 
+    int rc; 
+ 
+    pysqlite_NodeType.tp_new = PyType_GenericNew; 
+    pysqlite_CacheType.tp_new = PyType_GenericNew; 
+ 
+    rc = PyType_Ready(&pysqlite_NodeType); 
+    if (rc < 0) { 
+        return rc; 
+    } 
+ 
+    rc = PyType_Ready(&pysqlite_CacheType); 
+    return rc; 
+} 
diff --git a/contrib/tools/python3/src/Modules/_sqlite/cache.h b/contrib/tools/python3/src/Modules/_sqlite/cache.h
index 529010967c4..b1988c30c3f 100644
--- a/contrib/tools/python3/src/Modules/_sqlite/cache.h
+++ b/contrib/tools/python3/src/Modules/_sqlite/cache.h
@@ -1,74 +1,74 @@
-/* cache.h - definitions for the LRU cache
- *
- * Copyright (C) 2004-2010 Gerhard Häring <[email protected]>
- *
- * This file is part of pysqlite.
- *
- * This software is provided 'as-is', without any express or implied
- * warranty.  In no event will the authors be held liable for any damages
- * arising from the use of this software.
- *
- * Permission is granted to anyone to use this software for any purpose,
- * including commercial applications, and to alter it and redistribute it
- * freely, subject to the following restrictions:
- *
- * 1. The origin of this software must not be misrepresented; you must not
- *    claim that you wrote the original software. If you use this software
- *    in a product, an acknowledgment in the product documentation would be
- *    appreciated but is not required.
- * 2. Altered source versions must be plainly marked as such, and must not be
- *    misrepresented as being the original software.
- * 3. This notice may not be removed or altered from any source distribution.
- */
-
-#ifndef PYSQLITE_CACHE_H
-#define PYSQLITE_CACHE_H
+/* cache.h - definitions for the LRU cache 
+ * 
+ * Copyright (C) 2004-2010 Gerhard Häring <[email protected]> 
+ * 
+ * This file is part of pysqlite. 
+ * 
+ * This software is provided 'as-is', without any express or implied 
+ * warranty.  In no event will the authors be held liable for any damages 
+ * arising from the use of this software. 
+ * 
+ * Permission is granted to anyone to use this software for any purpose, 
+ * including commercial applications, and to alter it and redistribute it 
+ * freely, subject to the following restrictions: 
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not 
+ *    claim that you wrote the original software. If you use this software 
+ *    in a product, an acknowledgment in the product documentation would be 
+ *    appreciated but is not required. 
+ * 2. Altered source versions must be plainly marked as such, and must not be 
+ *    misrepresented as being the original software. 
+ * 3. This notice may not be removed or altered from any source distribution. 
+ */ 
+ 
+#ifndef PYSQLITE_CACHE_H 
+#define PYSQLITE_CACHE_H 
 #define PY_SSIZE_T_CLEAN
-#include "Python.h"
-
-/* The LRU cache is implemented as a combination of a doubly-linked with a
- * dictionary. The list items are of type 'Node' and the dictionary has the
- * nodes as values. */
-
-typedef struct _pysqlite_Node
-{
-    PyObject_HEAD
-    PyObject* key;
-    PyObject* data;
-    long count;
-    struct _pysqlite_Node* prev;
-    struct _pysqlite_Node* next;
-} pysqlite_Node;
-
-typedef struct
-{
-    PyObject_HEAD
-    int size;
-
-    /* a dictionary mapping keys to Node entries */
-    PyObject* mapping;
-
-    /* the factory callable */
-    PyObject* factory;
-
-    pysqlite_Node* first;
-    pysqlite_Node* last;
-
-    /* if set, decrement the factory function when the Cache is deallocated.
-     * this is almost always desirable, but not in the pysqlite context */
-    int decref_factory;
-} pysqlite_Cache;
-
-extern PyTypeObject pysqlite_NodeType;
-extern PyTypeObject pysqlite_CacheType;
-
-int pysqlite_node_init(pysqlite_Node* self, PyObject* args, PyObject* kwargs);
-void pysqlite_node_dealloc(pysqlite_Node* self);
-
-int pysqlite_cache_init(pysqlite_Cache* self, PyObject* args, PyObject* kwargs);
-void pysqlite_cache_dealloc(pysqlite_Cache* self);
-PyObject* pysqlite_cache_get(pysqlite_Cache* self, PyObject* args);
-
-int pysqlite_cache_setup_types(void);
-
-#endif
+#include "Python.h" 
+ 
+/* The LRU cache is implemented as a combination of a doubly-linked with a 
+ * dictionary. The list items are of type 'Node' and the dictionary has the 
+ * nodes as values. */ 
+ 
+typedef struct _pysqlite_Node 
+{ 
+    PyObject_HEAD 
+    PyObject* key; 
+    PyObject* data; 
+    long count; 
+    struct _pysqlite_Node* prev; 
+    struct _pysqlite_Node* next; 
+} pysqlite_Node; 
+ 
+typedef struct 
+{ 
+    PyObject_HEAD 
+    int size; 
+ 
+    /* a dictionary mapping keys to Node entries */ 
+    PyObject* mapping; 
+ 
+    /* the factory callable */ 
+    PyObject* factory; 
+ 
+    pysqlite_Node* first; 
+    pysqlite_Node* last; 
+ 
+    /* if set, decrement the factory function when the Cache is deallocated. 
+     * this is almost always desirable, but not in the pysqlite context */ 
+    int decref_factory; 
+} pysqlite_Cache; 
+ 
+extern PyTypeObject pysqlite_NodeType; 
+extern PyTypeObject pysqlite_CacheType; 
+ 
+int pysqlite_node_init(pysqlite_Node* self, PyObject* args, PyObject* kwargs); 
+void pysqlite_node_dealloc(pysqlite_Node* self); 
+ 
+int pysqlite_cache_init(pysqlite_Cache* self, PyObject* args, PyObject* kwargs); 
+void pysqlite_cache_dealloc(pysqlite_Cache* self); 
+PyObject* pysqlite_cache_get(pysqlite_Cache* self, PyObject* args); 
+ 
+int pysqlite_cache_setup_types(void); 
+ 
+#endif 
diff --git a/contrib/tools/python3/src/Modules/_sqlite/connection.c b/contrib/tools/python3/src/Modules/_sqlite/connection.c
index 30e333a4b86..f4d41b73fac 100644
--- a/contrib/tools/python3/src/Modules/_sqlite/connection.c
+++ b/contrib/tools/python3/src/Modules/_sqlite/connection.c
@@ -1,529 +1,529 @@
-/* connection.c - the connection type
- *
- * Copyright (C) 2004-2010 Gerhard Häring <[email protected]>
- *
- * This file is part of pysqlite.
- *
- * This software is provided 'as-is', without any express or implied
- * warranty.  In no event will the authors be held liable for any damages
- * arising from the use of this software.
- *
- * Permission is granted to anyone to use this software for any purpose,
- * including commercial applications, and to alter it and redistribute it
- * freely, subject to the following restrictions:
- *
- * 1. The origin of this software must not be misrepresented; you must not
- *    claim that you wrote the original software. If you use this software
- *    in a product, an acknowledgment in the product documentation would be
- *    appreciated but is not required.
- * 2. Altered source versions must be plainly marked as such, and must not be
- *    misrepresented as being the original software.
- * 3. This notice may not be removed or altered from any source distribution.
- */
-
-#include "cache.h"
-#include "module.h"
+/* connection.c - the connection type 
+ * 
+ * Copyright (C) 2004-2010 Gerhard Häring <[email protected]> 
+ * 
+ * This file is part of pysqlite. 
+ * 
+ * This software is provided 'as-is', without any express or implied 
+ * warranty.  In no event will the authors be held liable for any damages 
+ * arising from the use of this software. 
+ * 
+ * Permission is granted to anyone to use this software for any purpose, 
+ * including commercial applications, and to alter it and redistribute it 
+ * freely, subject to the following restrictions: 
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not 
+ *    claim that you wrote the original software. If you use this software 
+ *    in a product, an acknowledgment in the product documentation would be 
+ *    appreciated but is not required. 
+ * 2. Altered source versions must be plainly marked as such, and must not be 
+ *    misrepresented as being the original software. 
+ * 3. This notice may not be removed or altered from any source distribution. 
+ */ 
+ 
+#include "cache.h" 
+#include "module.h" 
 #include "structmember.h"         // PyMemberDef
-#include "connection.h"
-#include "statement.h"
-#include "cursor.h"
-#include "prepare_protocol.h"
-#include "util.h"
-
-#define ACTION_FINALIZE 1
-#define ACTION_RESET 2
-
-#if SQLITE_VERSION_NUMBER >= 3003008
-#ifndef SQLITE_OMIT_LOAD_EXTENSION
-#define HAVE_LOAD_EXTENSION
-#endif
-#endif
-
-#if SQLITE_VERSION_NUMBER >= 3006011
-#define HAVE_BACKUP_API
-#endif
-
-_Py_IDENTIFIER(cursor);
-
-static const char * const begin_statements[] = {
-    "BEGIN ",
-    "BEGIN DEFERRED",
-    "BEGIN IMMEDIATE",
-    "BEGIN EXCLUSIVE",
-    NULL
-};
-
-static int pysqlite_connection_set_isolation_level(pysqlite_Connection* self, PyObject* isolation_level, void *Py_UNUSED(ignored));
-static void _pysqlite_drop_unused_cursor_references(pysqlite_Connection* self);
-
-
-static void _sqlite3_result_error(sqlite3_context* ctx, const char* errmsg, int len)
-{
-    /* in older SQLite versions, calling sqlite3_result_error in callbacks
-     * triggers a bug in SQLite that leads either to irritating results or
-     * segfaults, depending on the SQLite version */
-#if SQLITE_VERSION_NUMBER >= 3003003
-    sqlite3_result_error(ctx, errmsg, len);
-#else
-    PyErr_SetString(pysqlite_OperationalError, errmsg);
-#endif
-}
-
-int pysqlite_connection_init(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)
-{
-    static char *kwlist[] = {
-        "database", "timeout", "detect_types", "isolation_level",
-        "check_same_thread", "factory", "cached_statements", "uri",
-        NULL
-    };
-
+#include "connection.h" 
+#include "statement.h" 
+#include "cursor.h" 
+#include "prepare_protocol.h" 
+#include "util.h" 
+ 
+#define ACTION_FINALIZE 1 
+#define ACTION_RESET 2 
+ 
+#if SQLITE_VERSION_NUMBER >= 3003008 
+#ifndef SQLITE_OMIT_LOAD_EXTENSION 
+#define HAVE_LOAD_EXTENSION 
+#endif 
+#endif 
+ 
+#if SQLITE_VERSION_NUMBER >= 3006011 
+#define HAVE_BACKUP_API 
+#endif 
+ 
+_Py_IDENTIFIER(cursor); 
+ 
+static const char * const begin_statements[] = { 
+    "BEGIN ", 
+    "BEGIN DEFERRED", 
+    "BEGIN IMMEDIATE", 
+    "BEGIN EXCLUSIVE", 
+    NULL 
+}; 
+ 
+static int pysqlite_connection_set_isolation_level(pysqlite_Connection* self, PyObject* isolation_level, void *Py_UNUSED(ignored)); 
+static void _pysqlite_drop_unused_cursor_references(pysqlite_Connection* self); 
+ 
+ 
+static void _sqlite3_result_error(sqlite3_context* ctx, const char* errmsg, int len) 
+{ 
+    /* in older SQLite versions, calling sqlite3_result_error in callbacks 
+     * triggers a bug in SQLite that leads either to irritating results or 
+     * segfaults, depending on the SQLite version */ 
+#if SQLITE_VERSION_NUMBER >= 3003003 
+    sqlite3_result_error(ctx, errmsg, len); 
+#else 
+    PyErr_SetString(pysqlite_OperationalError, errmsg); 
+#endif 
+} 
+ 
+int pysqlite_connection_init(pysqlite_Connection* self, PyObject* args, PyObject* kwargs) 
+{ 
+    static char *kwlist[] = { 
+        "database", "timeout", "detect_types", "isolation_level", 
+        "check_same_thread", "factory", "cached_statements", "uri", 
+        NULL 
+    }; 
+ 
     const char* database;
-    PyObject* database_obj;
-    int detect_types = 0;
-    PyObject* isolation_level = NULL;
-    PyObject* factory = NULL;
-    int check_same_thread = 1;
-    int cached_statements = 100;
-    int uri = 0;
-    double timeout = 5.0;
-    int rc;
-
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O&|diOiOip", kwlist,
-                                     PyUnicode_FSConverter, &database_obj, &timeout, &detect_types,
-                                     &isolation_level, &check_same_thread,
-                                     &factory, &cached_statements, &uri))
-    {
-        return -1;
-    }
-
+    PyObject* database_obj; 
+    int detect_types = 0; 
+    PyObject* isolation_level = NULL; 
+    PyObject* factory = NULL; 
+    int check_same_thread = 1; 
+    int cached_statements = 100; 
+    int uri = 0; 
+    double timeout = 5.0; 
+    int rc; 
+ 
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O&|diOiOip", kwlist, 
+                                     PyUnicode_FSConverter, &database_obj, &timeout, &detect_types, 
+                                     &isolation_level, &check_same_thread, 
+                                     &factory, &cached_statements, &uri)) 
+    { 
+        return -1; 
+    } 
+ 
     if (PySys_Audit("sqlite3.connect", "O", database_obj) < 0) {
         Py_DECREF(database_obj);
         return -1;
     }
 
-    database = PyBytes_AsString(database_obj);
-
-    self->begin_statement = NULL;
-
-    Py_CLEAR(self->statement_cache);
-    Py_CLEAR(self->statements);
-    Py_CLEAR(self->cursors);
-
-    Py_INCREF(Py_None);
-    Py_XSETREF(self->row_factory, Py_None);
-
-    Py_INCREF(&PyUnicode_Type);
-    Py_XSETREF(self->text_factory, (PyObject*)&PyUnicode_Type);
-
-#ifdef SQLITE_OPEN_URI
-    Py_BEGIN_ALLOW_THREADS
-    rc = sqlite3_open_v2(database, &self->db,
-                         SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE |
-                         (uri ? SQLITE_OPEN_URI : 0), NULL);
-#else
-    if (uri) {
-        PyErr_SetString(pysqlite_NotSupportedError, "URIs not supported");
-        return -1;
-    }
-    Py_BEGIN_ALLOW_THREADS
-    /* No need to use sqlite3_open_v2 as sqlite3_open(filename, db) is the
-       same as sqlite3_open_v2(filename, db, SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE, NULL). */
-    rc = sqlite3_open(database, &self->db);
-#endif
-    Py_END_ALLOW_THREADS
-
-    Py_DECREF(database_obj);
-
+    database = PyBytes_AsString(database_obj); 
+ 
+    self->begin_statement = NULL; 
+ 
+    Py_CLEAR(self->statement_cache); 
+    Py_CLEAR(self->statements); 
+    Py_CLEAR(self->cursors); 
+ 
+    Py_INCREF(Py_None); 
+    Py_XSETREF(self->row_factory, Py_None); 
+ 
+    Py_INCREF(&PyUnicode_Type); 
+    Py_XSETREF(self->text_factory, (PyObject*)&PyUnicode_Type); 
+ 
+#ifdef SQLITE_OPEN_URI 
+    Py_BEGIN_ALLOW_THREADS 
+    rc = sqlite3_open_v2(database, &self->db, 
+                         SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | 
+                         (uri ? SQLITE_OPEN_URI : 0), NULL); 
+#else 
+    if (uri) { 
+        PyErr_SetString(pysqlite_NotSupportedError, "URIs not supported"); 
+        return -1; 
+    } 
+    Py_BEGIN_ALLOW_THREADS 
+    /* No need to use sqlite3_open_v2 as sqlite3_open(filename, db) is the 
+       same as sqlite3_open_v2(filename, db, SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE, NULL). */ 
+    rc = sqlite3_open(database, &self->db); 
+#endif 
+    Py_END_ALLOW_THREADS 
+ 
+    Py_DECREF(database_obj); 
+ 
     if (self->db == NULL && rc == SQLITE_NOMEM) {
         PyErr_NoMemory();
         return -1;
     }
-    if (rc != SQLITE_OK) {
-        _pysqlite_seterror(self->db, NULL);
-        return -1;
-    }
-
-    if (!isolation_level) {
-        isolation_level = PyUnicode_FromString("");
-        if (!isolation_level) {
-            return -1;
-        }
-    } else {
-        Py_INCREF(isolation_level);
-    }
-    Py_CLEAR(self->isolation_level);
+    if (rc != SQLITE_OK) { 
+        _pysqlite_seterror(self->db, NULL); 
+        return -1; 
+    } 
+ 
+    if (!isolation_level) { 
+        isolation_level = PyUnicode_FromString(""); 
+        if (!isolation_level) { 
+            return -1; 
+        } 
+    } else { 
+        Py_INCREF(isolation_level); 
+    } 
+    Py_CLEAR(self->isolation_level); 
     if (pysqlite_connection_set_isolation_level(self, isolation_level, NULL) != 0) {
-        Py_DECREF(isolation_level);
-        return -1;
-    }
-    Py_DECREF(isolation_level);
-
-    self->statement_cache = (pysqlite_Cache*)PyObject_CallFunction((PyObject*)&pysqlite_CacheType, "Oi", self, cached_statements);
-    if (PyErr_Occurred()) {
-        return -1;
-    }
-
-    self->created_statements = 0;
-    self->created_cursors = 0;
-
-    /* Create lists of weak references to statements/cursors */
-    self->statements = PyList_New(0);
-    self->cursors = PyList_New(0);
-    if (!self->statements || !self->cursors) {
-        return -1;
-    }
-
-    /* By default, the Cache class INCREFs the factory in its initializer, and
-     * decrefs it in its deallocator method. Since this would create a circular
-     * reference here, we're breaking it by decrementing self, and telling the
-     * cache class to not decref the factory (self) in its deallocator.
-     */
-    self->statement_cache->decref_factory = 0;
-    Py_DECREF(self);
-
-    self->detect_types = detect_types;
-    self->timeout = timeout;
-    (void)sqlite3_busy_timeout(self->db, (int)(timeout*1000));
-    self->thread_ident = PyThread_get_thread_ident();
-    if (!check_same_thread && sqlite3_libversion_number() < 3003001) {
-        PyErr_SetString(pysqlite_NotSupportedError, "shared connections not available");
-        return -1;
-    }
-    self->check_same_thread = check_same_thread;
-
+        Py_DECREF(isolation_level); 
+        return -1; 
+    } 
+    Py_DECREF(isolation_level); 
+ 
+    self->statement_cache = (pysqlite_Cache*)PyObject_CallFunction((PyObject*)&pysqlite_CacheType, "Oi", self, cached_statements); 
+    if (PyErr_Occurred()) { 
+        return -1; 
+    } 
+ 
+    self->created_statements = 0; 
+    self->created_cursors = 0; 
+ 
+    /* Create lists of weak references to statements/cursors */ 
+    self->statements = PyList_New(0); 
+    self->cursors = PyList_New(0); 
+    if (!self->statements || !self->cursors) { 
+        return -1; 
+    } 
+ 
+    /* By default, the Cache class INCREFs the factory in its initializer, and 
+     * decrefs it in its deallocator method. Since this would create a circular 
+     * reference here, we're breaking it by decrementing self, and telling the 
+     * cache class to not decref the factory (self) in its deallocator. 
+     */ 
+    self->statement_cache->decref_factory = 0; 
+    Py_DECREF(self); 
+ 
+    self->detect_types = detect_types; 
+    self->timeout = timeout; 
+    (void)sqlite3_busy_timeout(self->db, (int)(timeout*1000)); 
+    self->thread_ident = PyThread_get_thread_ident(); 
+    if (!check_same_thread && sqlite3_libversion_number() < 3003001) { 
+        PyErr_SetString(pysqlite_NotSupportedError, "shared connections not available"); 
+        return -1; 
+    } 
+    self->check_same_thread = check_same_thread; 
+ 
     self->function_pinboard_trace_callback = NULL;
     self->function_pinboard_progress_handler = NULL;
     self->function_pinboard_authorizer_cb = NULL;
-
-    Py_XSETREF(self->collations, PyDict_New());
-    if (!self->collations) {
-        return -1;
-    }
-
-    self->Warning               = pysqlite_Warning;
-    self->Error                 = pysqlite_Error;
-    self->InterfaceError        = pysqlite_InterfaceError;
-    self->DatabaseError         = pysqlite_DatabaseError;
-    self->DataError             = pysqlite_DataError;
-    self->OperationalError      = pysqlite_OperationalError;
-    self->IntegrityError        = pysqlite_IntegrityError;
-    self->InternalError         = pysqlite_InternalError;
-    self->ProgrammingError      = pysqlite_ProgrammingError;
-    self->NotSupportedError     = pysqlite_NotSupportedError;
-
+ 
+    Py_XSETREF(self->collations, PyDict_New()); 
+    if (!self->collations) { 
+        return -1; 
+    } 
+ 
+    self->Warning               = pysqlite_Warning; 
+    self->Error                 = pysqlite_Error; 
+    self->InterfaceError        = pysqlite_InterfaceError; 
+    self->DatabaseError         = pysqlite_DatabaseError; 
+    self->DataError             = pysqlite_DataError; 
+    self->OperationalError      = pysqlite_OperationalError; 
+    self->IntegrityError        = pysqlite_IntegrityError; 
+    self->InternalError         = pysqlite_InternalError; 
+    self->ProgrammingError      = pysqlite_ProgrammingError; 
+    self->NotSupportedError     = pysqlite_NotSupportedError; 
+ 
     self->initialized = 1;
 
-    return 0;
-}
-
-/* action in (ACTION_RESET, ACTION_FINALIZE) */
-void pysqlite_do_all_statements(pysqlite_Connection* self, int action, int reset_cursors)
-{
-    int i;
-    PyObject* weakref;
-    PyObject* statement;
-    pysqlite_Cursor* cursor;
-
-    for (i = 0; i < PyList_Size(self->statements); i++) {
-        weakref = PyList_GetItem(self->statements, i);
-        statement = PyWeakref_GetObject(weakref);
-        if (statement != Py_None) {
-            Py_INCREF(statement);
-            if (action == ACTION_RESET) {
-                (void)pysqlite_statement_reset((pysqlite_Statement*)statement);
-            } else {
-                (void)pysqlite_statement_finalize((pysqlite_Statement*)statement);
-            }
-            Py_DECREF(statement);
-        }
-    }
-
-    if (reset_cursors) {
-        for (i = 0; i < PyList_Size(self->cursors); i++) {
-            weakref = PyList_GetItem(self->cursors, i);
-            cursor = (pysqlite_Cursor*)PyWeakref_GetObject(weakref);
-            if ((PyObject*)cursor != Py_None) {
-                cursor->reset = 1;
-            }
-        }
-    }
-}
-
-void pysqlite_connection_dealloc(pysqlite_Connection* self)
-{
-    Py_XDECREF(self->statement_cache);
-
-    /* Clean up if user has not called .close() explicitly. */
-    if (self->db) {
-        SQLITE3_CLOSE(self->db);
-    }
-
-    Py_XDECREF(self->isolation_level);
+    return 0; 
+} 
+ 
+/* action in (ACTION_RESET, ACTION_FINALIZE) */ 
+void pysqlite_do_all_statements(pysqlite_Connection* self, int action, int reset_cursors) 
+{ 
+    int i; 
+    PyObject* weakref; 
+    PyObject* statement; 
+    pysqlite_Cursor* cursor; 
+ 
+    for (i = 0; i < PyList_Size(self->statements); i++) { 
+        weakref = PyList_GetItem(self->statements, i); 
+        statement = PyWeakref_GetObject(weakref); 
+        if (statement != Py_None) { 
+            Py_INCREF(statement); 
+            if (action == ACTION_RESET) { 
+                (void)pysqlite_statement_reset((pysqlite_Statement*)statement); 
+            } else { 
+                (void)pysqlite_statement_finalize((pysqlite_Statement*)statement); 
+            } 
+            Py_DECREF(statement); 
+        } 
+    } 
+ 
+    if (reset_cursors) { 
+        for (i = 0; i < PyList_Size(self->cursors); i++) { 
+            weakref = PyList_GetItem(self->cursors, i); 
+            cursor = (pysqlite_Cursor*)PyWeakref_GetObject(weakref); 
+            if ((PyObject*)cursor != Py_None) { 
+                cursor->reset = 1; 
+            } 
+        } 
+    } 
+} 
+ 
+void pysqlite_connection_dealloc(pysqlite_Connection* self) 
+{ 
+    Py_XDECREF(self->statement_cache); 
+ 
+    /* Clean up if user has not called .close() explicitly. */ 
+    if (self->db) { 
+        SQLITE3_CLOSE(self->db); 
+    } 
+ 
+    Py_XDECREF(self->isolation_level); 
     Py_XDECREF(self->function_pinboard_trace_callback);
     Py_XDECREF(self->function_pinboard_progress_handler);
     Py_XDECREF(self->function_pinboard_authorizer_cb);
-    Py_XDECREF(self->row_factory);
-    Py_XDECREF(self->text_factory);
-    Py_XDECREF(self->collations);
-    Py_XDECREF(self->statements);
-    Py_XDECREF(self->cursors);
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-/*
- * Registers a cursor with the connection.
- *
- * 0 => error; 1 => ok
- */
-int pysqlite_connection_register_cursor(pysqlite_Connection* connection, PyObject* cursor)
-{
-    PyObject* weakref;
-
-    weakref = PyWeakref_NewRef((PyObject*)cursor, NULL);
-    if (!weakref) {
-        goto error;
-    }
-
-    if (PyList_Append(connection->cursors, weakref) != 0) {
-        Py_CLEAR(weakref);
-        goto error;
-    }
-
-    Py_DECREF(weakref);
-
-    return 1;
-error:
-    return 0;
-}
-
-PyObject* pysqlite_connection_cursor(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)
-{
-    static char *kwlist[] = {"factory", NULL};
-    PyObject* factory = NULL;
-    PyObject* cursor;
-
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O", kwlist,
-                                     &factory)) {
-        return NULL;
-    }
-
-    if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
-        return NULL;
-    }
-
-    if (factory == NULL) {
-        factory = (PyObject*)&pysqlite_CursorType;
-    }
-
+    Py_XDECREF(self->row_factory); 
+    Py_XDECREF(self->text_factory); 
+    Py_XDECREF(self->collations); 
+    Py_XDECREF(self->statements); 
+    Py_XDECREF(self->cursors); 
+    Py_TYPE(self)->tp_free((PyObject*)self); 
+} 
+ 
+/* 
+ * Registers a cursor with the connection. 
+ * 
+ * 0 => error; 1 => ok 
+ */ 
+int pysqlite_connection_register_cursor(pysqlite_Connection* connection, PyObject* cursor) 
+{ 
+    PyObject* weakref; 
+ 
+    weakref = PyWeakref_NewRef((PyObject*)cursor, NULL); 
+    if (!weakref) { 
+        goto error; 
+    } 
+ 
+    if (PyList_Append(connection->cursors, weakref) != 0) { 
+        Py_CLEAR(weakref); 
+        goto error; 
+    } 
+ 
+    Py_DECREF(weakref); 
+ 
+    return 1; 
+error: 
+    return 0; 
+} 
+ 
+PyObject* pysqlite_connection_cursor(pysqlite_Connection* self, PyObject* args, PyObject* kwargs) 
+{ 
+    static char *kwlist[] = {"factory", NULL}; 
+    PyObject* factory = NULL; 
+    PyObject* cursor; 
+ 
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O", kwlist, 
+                                     &factory)) { 
+        return NULL; 
+    } 
+ 
+    if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) { 
+        return NULL; 
+    } 
+ 
+    if (factory == NULL) { 
+        factory = (PyObject*)&pysqlite_CursorType; 
+    } 
+ 
     cursor = PyObject_CallOneArg(factory, (PyObject *)self);
-    if (cursor == NULL)
-        return NULL;
-    if (!PyObject_TypeCheck(cursor, &pysqlite_CursorType)) {
-        PyErr_Format(PyExc_TypeError,
-                     "factory must return a cursor, not %.100s",
-                     Py_TYPE(cursor)->tp_name);
-        Py_DECREF(cursor);
-        return NULL;
-    }
-
-    _pysqlite_drop_unused_cursor_references(self);
-
-    if (cursor && self->row_factory != Py_None) {
-        Py_INCREF(self->row_factory);
-        Py_XSETREF(((pysqlite_Cursor *)cursor)->row_factory, self->row_factory);
-    }
-
-    return cursor;
-}
-
-PyObject* pysqlite_connection_close(pysqlite_Connection* self, PyObject* args)
-{
-    int rc;
-
-    if (!pysqlite_check_thread(self)) {
-        return NULL;
-    }
-
+    if (cursor == NULL) 
+        return NULL; 
+    if (!PyObject_TypeCheck(cursor, &pysqlite_CursorType)) { 
+        PyErr_Format(PyExc_TypeError, 
+                     "factory must return a cursor, not %.100s", 
+                     Py_TYPE(cursor)->tp_name); 
+        Py_DECREF(cursor); 
+        return NULL; 
+    } 
+ 
+    _pysqlite_drop_unused_cursor_references(self); 
+ 
+    if (cursor && self->row_factory != Py_None) { 
+        Py_INCREF(self->row_factory); 
+        Py_XSETREF(((pysqlite_Cursor *)cursor)->row_factory, self->row_factory); 
+    } 
+ 
+    return cursor; 
+} 
+ 
+PyObject* pysqlite_connection_close(pysqlite_Connection* self, PyObject* args) 
+{ 
+    int rc; 
+ 
+    if (!pysqlite_check_thread(self)) { 
+        return NULL; 
+    } 
+ 
     if (!self->initialized) {
         PyErr_SetString(pysqlite_ProgrammingError,
                         "Base Connection.__init__ not called.");
         return NULL;
     }
 
-    pysqlite_do_all_statements(self, ACTION_FINALIZE, 1);
-
-    if (self->db) {
-        rc = SQLITE3_CLOSE(self->db);
-
-        if (rc != SQLITE_OK) {
-            _pysqlite_seterror(self->db, NULL);
-            return NULL;
-        } else {
-            self->db = NULL;
-        }
-    }
-
-    Py_RETURN_NONE;
-}
-
-/*
- * Checks if a connection object is usable (i. e. not closed).
- *
- * 0 => error; 1 => ok
- */
-int pysqlite_check_connection(pysqlite_Connection* con)
-{
-    if (!con->initialized) {
-        PyErr_SetString(pysqlite_ProgrammingError, "Base Connection.__init__ not called.");
-        return 0;
-    }
-
-    if (!con->db) {
-        PyErr_SetString(pysqlite_ProgrammingError, "Cannot operate on a closed database.");
-        return 0;
-    } else {
-        return 1;
-    }
-}
-
-PyObject* _pysqlite_connection_begin(pysqlite_Connection* self)
-{
-    int rc;
-    const char* tail;
-    sqlite3_stmt* statement;
-
-    Py_BEGIN_ALLOW_THREADS
-    rc = sqlite3_prepare_v2(self->db, self->begin_statement, -1, &statement, &tail);
-    Py_END_ALLOW_THREADS
-
-    if (rc != SQLITE_OK) {
-        _pysqlite_seterror(self->db, statement);
-        goto error;
-    }
-
-    rc = pysqlite_step(statement, self);
-    if (rc != SQLITE_DONE) {
-        _pysqlite_seterror(self->db, statement);
-    }
-
-    Py_BEGIN_ALLOW_THREADS
-    rc = sqlite3_finalize(statement);
-    Py_END_ALLOW_THREADS
-
-    if (rc != SQLITE_OK && !PyErr_Occurred()) {
-        _pysqlite_seterror(self->db, NULL);
-    }
-
-error:
-    if (PyErr_Occurred()) {
-        return NULL;
-    } else {
-        Py_RETURN_NONE;
-    }
-}
-
-PyObject* pysqlite_connection_commit(pysqlite_Connection* self, PyObject* args)
-{
-    int rc;
-    const char* tail;
-    sqlite3_stmt* statement;
-
-    if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
-        return NULL;
-    }
-
-    if (!sqlite3_get_autocommit(self->db)) {
-
-        Py_BEGIN_ALLOW_THREADS
-        rc = sqlite3_prepare_v2(self->db, "COMMIT", -1, &statement, &tail);
-        Py_END_ALLOW_THREADS
-        if (rc != SQLITE_OK) {
-            _pysqlite_seterror(self->db, NULL);
-            goto error;
-        }
-
-        rc = pysqlite_step(statement, self);
-        if (rc != SQLITE_DONE) {
-            _pysqlite_seterror(self->db, statement);
-        }
-
-        Py_BEGIN_ALLOW_THREADS
-        rc = sqlite3_finalize(statement);
-        Py_END_ALLOW_THREADS
-        if (rc != SQLITE_OK && !PyErr_Occurred()) {
-            _pysqlite_seterror(self->db, NULL);
-        }
-
-    }
-
-error:
-    if (PyErr_Occurred()) {
-        return NULL;
-    } else {
-        Py_RETURN_NONE;
-    }
-}
-
-PyObject* pysqlite_connection_rollback(pysqlite_Connection* self, PyObject* args)
-{
-    int rc;
-    const char* tail;
-    sqlite3_stmt* statement;
-
-    if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
-        return NULL;
-    }
-
-    if (!sqlite3_get_autocommit(self->db)) {
-        pysqlite_do_all_statements(self, ACTION_RESET, 1);
-
-        Py_BEGIN_ALLOW_THREADS
-        rc = sqlite3_prepare_v2(self->db, "ROLLBACK", -1, &statement, &tail);
-        Py_END_ALLOW_THREADS
-        if (rc != SQLITE_OK) {
-            _pysqlite_seterror(self->db, NULL);
-            goto error;
-        }
-
-        rc = pysqlite_step(statement, self);
-        if (rc != SQLITE_DONE) {
-            _pysqlite_seterror(self->db, statement);
-        }
-
-        Py_BEGIN_ALLOW_THREADS
-        rc = sqlite3_finalize(statement);
-        Py_END_ALLOW_THREADS
-        if (rc != SQLITE_OK && !PyErr_Occurred()) {
-            _pysqlite_seterror(self->db, NULL);
-        }
-
-    }
-
-error:
-    if (PyErr_Occurred()) {
-        return NULL;
-    } else {
-        Py_RETURN_NONE;
-    }
-}
-
-static int
-_pysqlite_set_result(sqlite3_context* context, PyObject* py_val)
-{
-    if (py_val == Py_None) {
-        sqlite3_result_null(context);
-    } else if (PyLong_Check(py_val)) {
-        sqlite_int64 value = _pysqlite_long_as_int64(py_val);
-        if (value == -1 && PyErr_Occurred())
-            return -1;
-        sqlite3_result_int64(context, value);
-    } else if (PyFloat_Check(py_val)) {
-        sqlite3_result_double(context, PyFloat_AsDouble(py_val));
-    } else if (PyUnicode_Check(py_val)) {
+    pysqlite_do_all_statements(self, ACTION_FINALIZE, 1); 
+ 
+    if (self->db) { 
+        rc = SQLITE3_CLOSE(self->db); 
+ 
+        if (rc != SQLITE_OK) { 
+            _pysqlite_seterror(self->db, NULL); 
+            return NULL; 
+        } else { 
+            self->db = NULL; 
+        } 
+    } 
+ 
+    Py_RETURN_NONE; 
+} 
+ 
+/* 
+ * Checks if a connection object is usable (i. e. not closed). 
+ * 
+ * 0 => error; 1 => ok 
+ */ 
+int pysqlite_check_connection(pysqlite_Connection* con) 
+{ 
+    if (!con->initialized) { 
+        PyErr_SetString(pysqlite_ProgrammingError, "Base Connection.__init__ not called."); 
+        return 0; 
+    } 
+ 
+    if (!con->db) { 
+        PyErr_SetString(pysqlite_ProgrammingError, "Cannot operate on a closed database."); 
+        return 0; 
+    } else { 
+        return 1; 
+    } 
+} 
+ 
+PyObject* _pysqlite_connection_begin(pysqlite_Connection* self) 
+{ 
+    int rc; 
+    const char* tail; 
+    sqlite3_stmt* statement; 
+ 
+    Py_BEGIN_ALLOW_THREADS 
+    rc = sqlite3_prepare_v2(self->db, self->begin_statement, -1, &statement, &tail); 
+    Py_END_ALLOW_THREADS 
+ 
+    if (rc != SQLITE_OK) { 
+        _pysqlite_seterror(self->db, statement); 
+        goto error; 
+    } 
+ 
+    rc = pysqlite_step(statement, self); 
+    if (rc != SQLITE_DONE) { 
+        _pysqlite_seterror(self->db, statement); 
+    } 
+ 
+    Py_BEGIN_ALLOW_THREADS 
+    rc = sqlite3_finalize(statement); 
+    Py_END_ALLOW_THREADS 
+ 
+    if (rc != SQLITE_OK && !PyErr_Occurred()) { 
+        _pysqlite_seterror(self->db, NULL); 
+    } 
+ 
+error: 
+    if (PyErr_Occurred()) { 
+        return NULL; 
+    } else { 
+        Py_RETURN_NONE; 
+    } 
+} 
+ 
+PyObject* pysqlite_connection_commit(pysqlite_Connection* self, PyObject* args) 
+{ 
+    int rc; 
+    const char* tail; 
+    sqlite3_stmt* statement; 
+ 
+    if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) { 
+        return NULL; 
+    } 
+ 
+    if (!sqlite3_get_autocommit(self->db)) { 
+ 
+        Py_BEGIN_ALLOW_THREADS 
+        rc = sqlite3_prepare_v2(self->db, "COMMIT", -1, &statement, &tail); 
+        Py_END_ALLOW_THREADS 
+        if (rc != SQLITE_OK) { 
+            _pysqlite_seterror(self->db, NULL); 
+            goto error; 
+        } 
+ 
+        rc = pysqlite_step(statement, self); 
+        if (rc != SQLITE_DONE) { 
+            _pysqlite_seterror(self->db, statement); 
+        } 
+ 
+        Py_BEGIN_ALLOW_THREADS 
+        rc = sqlite3_finalize(statement); 
+        Py_END_ALLOW_THREADS 
+        if (rc != SQLITE_OK && !PyErr_Occurred()) { 
+            _pysqlite_seterror(self->db, NULL); 
+        } 
+ 
+    } 
+ 
+error: 
+    if (PyErr_Occurred()) { 
+        return NULL; 
+    } else { 
+        Py_RETURN_NONE; 
+    } 
+} 
+ 
+PyObject* pysqlite_connection_rollback(pysqlite_Connection* self, PyObject* args) 
+{ 
+    int rc; 
+    const char* tail; 
+    sqlite3_stmt* statement; 
+ 
+    if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) { 
+        return NULL; 
+    } 
+ 
+    if (!sqlite3_get_autocommit(self->db)) { 
+        pysqlite_do_all_statements(self, ACTION_RESET, 1); 
+ 
+        Py_BEGIN_ALLOW_THREADS 
+        rc = sqlite3_prepare_v2(self->db, "ROLLBACK", -1, &statement, &tail); 
+        Py_END_ALLOW_THREADS 
+        if (rc != SQLITE_OK) { 
+            _pysqlite_seterror(self->db, NULL); 
+            goto error; 
+        } 
+ 
+        rc = pysqlite_step(statement, self); 
+        if (rc != SQLITE_DONE) { 
+            _pysqlite_seterror(self->db, statement); 
+        } 
+ 
+        Py_BEGIN_ALLOW_THREADS 
+        rc = sqlite3_finalize(statement); 
+        Py_END_ALLOW_THREADS 
+        if (rc != SQLITE_OK && !PyErr_Occurred()) { 
+            _pysqlite_seterror(self->db, NULL); 
+        } 
+ 
+    } 
+ 
+error: 
+    if (PyErr_Occurred()) { 
+        return NULL; 
+    } else { 
+        Py_RETURN_NONE; 
+    } 
+} 
+ 
+static int 
+_pysqlite_set_result(sqlite3_context* context, PyObject* py_val) 
+{ 
+    if (py_val == Py_None) { 
+        sqlite3_result_null(context); 
+    } else if (PyLong_Check(py_val)) { 
+        sqlite_int64 value = _pysqlite_long_as_int64(py_val); 
+        if (value == -1 && PyErr_Occurred()) 
+            return -1; 
+        sqlite3_result_int64(context, value); 
+    } else if (PyFloat_Check(py_val)) { 
+        sqlite3_result_double(context, PyFloat_AsDouble(py_val)); 
+    } else if (PyUnicode_Check(py_val)) { 
         Py_ssize_t sz;
         const char *str = PyUnicode_AsUTF8AndSize(py_val, &sz);
         if (str == NULL) {
-            return -1;
+            return -1; 
         }
         if (sz > INT_MAX) {
             PyErr_SetString(PyExc_OverflowError,
@@ -531,49 +531,49 @@ _pysqlite_set_result(sqlite3_context* context, PyObject* py_val)
             return -1;
         }
         sqlite3_result_text(context, str, (int)sz, SQLITE_TRANSIENT);
-    } else if (PyObject_CheckBuffer(py_val)) {
-        Py_buffer view;
-        if (PyObject_GetBuffer(py_val, &view, PyBUF_SIMPLE) != 0) {
-            PyErr_SetString(PyExc_ValueError,
-                            "could not convert BLOB to buffer");
-            return -1;
-        }
-        if (view.len > INT_MAX) {
-            PyErr_SetString(PyExc_OverflowError,
-                            "BLOB longer than INT_MAX bytes");
-            PyBuffer_Release(&view);
-            return -1;
-        }
-        sqlite3_result_blob(context, view.buf, (int)view.len, SQLITE_TRANSIENT);
-        PyBuffer_Release(&view);
-    } else {
-        return -1;
-    }
-    return 0;
-}
-
-PyObject* _pysqlite_build_py_params(sqlite3_context *context, int argc, sqlite3_value** argv)
-{
-    PyObject* args;
-    int i;
-    sqlite3_value* cur_value;
-    PyObject* cur_py_value;
-    Py_ssize_t buflen;
-
-    args = PyTuple_New(argc);
-    if (!args) {
-        return NULL;
-    }
-
-    for (i = 0; i < argc; i++) {
-        cur_value = argv[i];
-        switch (sqlite3_value_type(argv[i])) {
-            case SQLITE_INTEGER:
+    } else if (PyObject_CheckBuffer(py_val)) { 
+        Py_buffer view; 
+        if (PyObject_GetBuffer(py_val, &view, PyBUF_SIMPLE) != 0) { 
+            PyErr_SetString(PyExc_ValueError, 
+                            "could not convert BLOB to buffer"); 
+            return -1; 
+        } 
+        if (view.len > INT_MAX) { 
+            PyErr_SetString(PyExc_OverflowError, 
+                            "BLOB longer than INT_MAX bytes"); 
+            PyBuffer_Release(&view); 
+            return -1; 
+        } 
+        sqlite3_result_blob(context, view.buf, (int)view.len, SQLITE_TRANSIENT); 
+        PyBuffer_Release(&view); 
+    } else { 
+        return -1; 
+    } 
+    return 0; 
+} 
+ 
+PyObject* _pysqlite_build_py_params(sqlite3_context *context, int argc, sqlite3_value** argv) 
+{ 
+    PyObject* args; 
+    int i; 
+    sqlite3_value* cur_value; 
+    PyObject* cur_py_value; 
+    Py_ssize_t buflen; 
+ 
+    args = PyTuple_New(argc); 
+    if (!args) { 
+        return NULL; 
+    } 
+ 
+    for (i = 0; i < argc; i++) { 
+        cur_value = argv[i]; 
+        switch (sqlite3_value_type(argv[i])) { 
+            case SQLITE_INTEGER: 
                 cur_py_value = PyLong_FromLongLong(sqlite3_value_int64(cur_value));
-                break;
-            case SQLITE_FLOAT:
-                cur_py_value = PyFloat_FromDouble(sqlite3_value_double(cur_value));
-                break;
+                break; 
+            case SQLITE_FLOAT: 
+                cur_py_value = PyFloat_FromDouble(sqlite3_value_double(cur_value)); 
+                break; 
             case SQLITE_TEXT: {
                 sqlite3 *db = sqlite3_context_db_handle(context);
                 const char *text = (const char *)sqlite3_value_text(cur_value);
@@ -581,285 +581,285 @@ PyObject* _pysqlite_build_py_params(sqlite3_context *context, int argc, sqlite3_
                 if (text == NULL && sqlite3_errcode(db) == SQLITE_NOMEM) {
                     PyErr_NoMemory();
                     goto error;
-                }
+                } 
 
                 Py_ssize_t size = sqlite3_value_bytes(cur_value);
                 cur_py_value = PyUnicode_FromStringAndSize(text, size);
-                break;
+                break; 
             }
-            case SQLITE_BLOB:
-                buflen = sqlite3_value_bytes(cur_value);
-                cur_py_value = PyBytes_FromStringAndSize(
-                    sqlite3_value_blob(cur_value), buflen);
-                break;
-            case SQLITE_NULL:
-            default:
-                Py_INCREF(Py_None);
-                cur_py_value = Py_None;
-        }
-
-        if (!cur_py_value) {
+            case SQLITE_BLOB: 
+                buflen = sqlite3_value_bytes(cur_value); 
+                cur_py_value = PyBytes_FromStringAndSize( 
+                    sqlite3_value_blob(cur_value), buflen); 
+                break; 
+            case SQLITE_NULL: 
+            default: 
+                Py_INCREF(Py_None); 
+                cur_py_value = Py_None; 
+        } 
+ 
+        if (!cur_py_value) { 
             goto error;
-        }
-
-        PyTuple_SetItem(args, i, cur_py_value);
-
-    }
-
-    return args;
+        } 
+ 
+        PyTuple_SetItem(args, i, cur_py_value); 
+ 
+    } 
+ 
+    return args; 
 
 error:
     Py_DECREF(args);
     return NULL;
-}
-
-void _pysqlite_func_callback(sqlite3_context* context, int argc, sqlite3_value** argv)
-{
-    PyObject* args;
-    PyObject* py_func;
-    PyObject* py_retval = NULL;
-    int ok;
-
-    PyGILState_STATE threadstate;
-
-    threadstate = PyGILState_Ensure();
-
-    py_func = (PyObject*)sqlite3_user_data(context);
-
-    args = _pysqlite_build_py_params(context, argc, argv);
-    if (args) {
-        py_retval = PyObject_CallObject(py_func, args);
-        Py_DECREF(args);
-    }
-
-    ok = 0;
-    if (py_retval) {
-        ok = _pysqlite_set_result(context, py_retval) == 0;
-        Py_DECREF(py_retval);
-    }
-    if (!ok) {
-        if (_pysqlite_enable_callback_tracebacks) {
-            PyErr_Print();
-        } else {
-            PyErr_Clear();
-        }
-        _sqlite3_result_error(context, "user-defined function raised exception", -1);
-    }
-
-    PyGILState_Release(threadstate);
-}
-
-static void _pysqlite_step_callback(sqlite3_context *context, int argc, sqlite3_value** params)
-{
-    PyObject* args;
-    PyObject* function_result = NULL;
-    PyObject* aggregate_class;
-    PyObject** aggregate_instance;
-    PyObject* stepmethod = NULL;
-
-    PyGILState_STATE threadstate;
-
-    threadstate = PyGILState_Ensure();
-
-    aggregate_class = (PyObject*)sqlite3_user_data(context);
-
-    aggregate_instance = (PyObject**)sqlite3_aggregate_context(context, sizeof(PyObject*));
-
-    if (*aggregate_instance == NULL) {
-        *aggregate_instance = _PyObject_CallNoArg(aggregate_class);
-
-        if (PyErr_Occurred()) {
-            *aggregate_instance = 0;
-            if (_pysqlite_enable_callback_tracebacks) {
-                PyErr_Print();
-            } else {
-                PyErr_Clear();
-            }
-            _sqlite3_result_error(context, "user-defined aggregate's '__init__' method raised error", -1);
-            goto error;
-        }
-    }
-
-    stepmethod = PyObject_GetAttrString(*aggregate_instance, "step");
-    if (!stepmethod) {
-        goto error;
-    }
-
-    args = _pysqlite_build_py_params(context, argc, params);
-    if (!args) {
-        goto error;
-    }
-
-    function_result = PyObject_CallObject(stepmethod, args);
-    Py_DECREF(args);
-
-    if (!function_result) {
-        if (_pysqlite_enable_callback_tracebacks) {
-            PyErr_Print();
-        } else {
-            PyErr_Clear();
-        }
-        _sqlite3_result_error(context, "user-defined aggregate's 'step' method raised error", -1);
-    }
-
-error:
-    Py_XDECREF(stepmethod);
-    Py_XDECREF(function_result);
-
-    PyGILState_Release(threadstate);
-}
-
-void _pysqlite_final_callback(sqlite3_context* context)
-{
-    PyObject* function_result;
-    PyObject** aggregate_instance;
-    _Py_IDENTIFIER(finalize);
-    int ok;
-    PyObject *exception, *value, *tb;
-    int restore;
-
-    PyGILState_STATE threadstate;
-
-    threadstate = PyGILState_Ensure();
-
-    aggregate_instance = (PyObject**)sqlite3_aggregate_context(context, sizeof(PyObject*));
-    if (!*aggregate_instance) {
-        /* this branch is executed if there was an exception in the aggregate's
-         * __init__ */
-
-        goto error;
-    }
-
-    /* Keep the exception (if any) of the last call to step() */
-    PyErr_Fetch(&exception, &value, &tb);
-    restore = 1;
-
+} 
+ 
+void _pysqlite_func_callback(sqlite3_context* context, int argc, sqlite3_value** argv) 
+{ 
+    PyObject* args; 
+    PyObject* py_func; 
+    PyObject* py_retval = NULL; 
+    int ok; 
+ 
+    PyGILState_STATE threadstate; 
+ 
+    threadstate = PyGILState_Ensure(); 
+ 
+    py_func = (PyObject*)sqlite3_user_data(context); 
+ 
+    args = _pysqlite_build_py_params(context, argc, argv); 
+    if (args) { 
+        py_retval = PyObject_CallObject(py_func, args); 
+        Py_DECREF(args); 
+    } 
+ 
+    ok = 0; 
+    if (py_retval) { 
+        ok = _pysqlite_set_result(context, py_retval) == 0; 
+        Py_DECREF(py_retval); 
+    } 
+    if (!ok) { 
+        if (_pysqlite_enable_callback_tracebacks) { 
+            PyErr_Print(); 
+        } else { 
+            PyErr_Clear(); 
+        } 
+        _sqlite3_result_error(context, "user-defined function raised exception", -1); 
+    } 
+ 
+    PyGILState_Release(threadstate); 
+} 
+ 
+static void _pysqlite_step_callback(sqlite3_context *context, int argc, sqlite3_value** params) 
+{ 
+    PyObject* args; 
+    PyObject* function_result = NULL; 
+    PyObject* aggregate_class; 
+    PyObject** aggregate_instance; 
+    PyObject* stepmethod = NULL; 
+ 
+    PyGILState_STATE threadstate; 
+ 
+    threadstate = PyGILState_Ensure(); 
+ 
+    aggregate_class = (PyObject*)sqlite3_user_data(context); 
+ 
+    aggregate_instance = (PyObject**)sqlite3_aggregate_context(context, sizeof(PyObject*)); 
+ 
+    if (*aggregate_instance == NULL) { 
+        *aggregate_instance = _PyObject_CallNoArg(aggregate_class); 
+ 
+        if (PyErr_Occurred()) { 
+            *aggregate_instance = 0; 
+            if (_pysqlite_enable_callback_tracebacks) { 
+                PyErr_Print(); 
+            } else { 
+                PyErr_Clear(); 
+            } 
+            _sqlite3_result_error(context, "user-defined aggregate's '__init__' method raised error", -1); 
+            goto error; 
+        } 
+    } 
+ 
+    stepmethod = PyObject_GetAttrString(*aggregate_instance, "step"); 
+    if (!stepmethod) { 
+        goto error; 
+    } 
+ 
+    args = _pysqlite_build_py_params(context, argc, params); 
+    if (!args) { 
+        goto error; 
+    } 
+ 
+    function_result = PyObject_CallObject(stepmethod, args); 
+    Py_DECREF(args); 
+ 
+    if (!function_result) { 
+        if (_pysqlite_enable_callback_tracebacks) { 
+            PyErr_Print(); 
+        } else { 
+            PyErr_Clear(); 
+        } 
+        _sqlite3_result_error(context, "user-defined aggregate's 'step' method raised error", -1); 
+    } 
+ 
+error: 
+    Py_XDECREF(stepmethod); 
+    Py_XDECREF(function_result); 
+ 
+    PyGILState_Release(threadstate); 
+} 
+ 
+void _pysqlite_final_callback(sqlite3_context* context) 
+{ 
+    PyObject* function_result; 
+    PyObject** aggregate_instance; 
+    _Py_IDENTIFIER(finalize); 
+    int ok; 
+    PyObject *exception, *value, *tb; 
+    int restore; 
+ 
+    PyGILState_STATE threadstate; 
+ 
+    threadstate = PyGILState_Ensure(); 
+ 
+    aggregate_instance = (PyObject**)sqlite3_aggregate_context(context, sizeof(PyObject*)); 
+    if (!*aggregate_instance) { 
+        /* this branch is executed if there was an exception in the aggregate's 
+         * __init__ */ 
+ 
+        goto error; 
+    } 
+ 
+    /* Keep the exception (if any) of the last call to step() */ 
+    PyErr_Fetch(&exception, &value, &tb); 
+    restore = 1; 
+ 
     function_result = _PyObject_CallMethodIdNoArgs(*aggregate_instance, &PyId_finalize);
-
-    Py_DECREF(*aggregate_instance);
-
-    ok = 0;
-    if (function_result) {
-        ok = _pysqlite_set_result(context, function_result) == 0;
-        Py_DECREF(function_result);
-    }
-    if (!ok) {
-        if (_pysqlite_enable_callback_tracebacks) {
-            PyErr_Print();
-        } else {
-            PyErr_Clear();
-        }
-        _sqlite3_result_error(context, "user-defined aggregate's 'finalize' method raised error", -1);
-#if SQLITE_VERSION_NUMBER < 3003003
-        /* with old SQLite versions, _sqlite3_result_error() sets a new Python
-           exception, so don't restore the previous exception */
-        restore = 0;
-#endif
-    }
-
-    if (restore) {
-        /* Restore the exception (if any) of the last call to step(),
-           but clear also the current exception if finalize() failed */
-        PyErr_Restore(exception, value, tb);
-    }
-
-error:
-    PyGILState_Release(threadstate);
-}
-
-static void _pysqlite_drop_unused_statement_references(pysqlite_Connection* self)
-{
-    PyObject* new_list;
-    PyObject* weakref;
-    int i;
-
-    /* we only need to do this once in a while */
-    if (self->created_statements++ < 200) {
-        return;
-    }
-
-    self->created_statements = 0;
-
-    new_list = PyList_New(0);
-    if (!new_list) {
-        return;
-    }
-
-    for (i = 0; i < PyList_Size(self->statements); i++) {
-        weakref = PyList_GetItem(self->statements, i);
-        if (PyWeakref_GetObject(weakref) != Py_None) {
-            if (PyList_Append(new_list, weakref) != 0) {
-                Py_DECREF(new_list);
-                return;
-            }
-        }
-    }
-
-    Py_SETREF(self->statements, new_list);
-}
-
-static void _pysqlite_drop_unused_cursor_references(pysqlite_Connection* self)
-{
-    PyObject* new_list;
-    PyObject* weakref;
-    int i;
-
-    /* we only need to do this once in a while */
-    if (self->created_cursors++ < 200) {
-        return;
-    }
-
-    self->created_cursors = 0;
-
-    new_list = PyList_New(0);
-    if (!new_list) {
-        return;
-    }
-
-    for (i = 0; i < PyList_Size(self->cursors); i++) {
-        weakref = PyList_GetItem(self->cursors, i);
-        if (PyWeakref_GetObject(weakref) != Py_None) {
-            if (PyList_Append(new_list, weakref) != 0) {
-                Py_DECREF(new_list);
-                return;
-            }
-        }
-    }
-
-    Py_SETREF(self->cursors, new_list);
-}
-
+ 
+    Py_DECREF(*aggregate_instance); 
+ 
+    ok = 0; 
+    if (function_result) { 
+        ok = _pysqlite_set_result(context, function_result) == 0; 
+        Py_DECREF(function_result); 
+    } 
+    if (!ok) { 
+        if (_pysqlite_enable_callback_tracebacks) { 
+            PyErr_Print(); 
+        } else { 
+            PyErr_Clear(); 
+        } 
+        _sqlite3_result_error(context, "user-defined aggregate's 'finalize' method raised error", -1); 
+#if SQLITE_VERSION_NUMBER < 3003003 
+        /* with old SQLite versions, _sqlite3_result_error() sets a new Python 
+           exception, so don't restore the previous exception */ 
+        restore = 0; 
+#endif 
+    } 
+ 
+    if (restore) { 
+        /* Restore the exception (if any) of the last call to step(), 
+           but clear also the current exception if finalize() failed */ 
+        PyErr_Restore(exception, value, tb); 
+    } 
+ 
+error: 
+    PyGILState_Release(threadstate); 
+} 
+ 
+static void _pysqlite_drop_unused_statement_references(pysqlite_Connection* self) 
+{ 
+    PyObject* new_list; 
+    PyObject* weakref; 
+    int i; 
+ 
+    /* we only need to do this once in a while */ 
+    if (self->created_statements++ < 200) { 
+        return; 
+    } 
+ 
+    self->created_statements = 0; 
+ 
+    new_list = PyList_New(0); 
+    if (!new_list) { 
+        return; 
+    } 
+ 
+    for (i = 0; i < PyList_Size(self->statements); i++) { 
+        weakref = PyList_GetItem(self->statements, i); 
+        if (PyWeakref_GetObject(weakref) != Py_None) { 
+            if (PyList_Append(new_list, weakref) != 0) { 
+                Py_DECREF(new_list); 
+                return; 
+            } 
+        } 
+    } 
+ 
+    Py_SETREF(self->statements, new_list); 
+} 
+ 
+static void _pysqlite_drop_unused_cursor_references(pysqlite_Connection* self) 
+{ 
+    PyObject* new_list; 
+    PyObject* weakref; 
+    int i; 
+ 
+    /* we only need to do this once in a while */ 
+    if (self->created_cursors++ < 200) { 
+        return; 
+    } 
+ 
+    self->created_cursors = 0; 
+ 
+    new_list = PyList_New(0); 
+    if (!new_list) { 
+        return; 
+    } 
+ 
+    for (i = 0; i < PyList_Size(self->cursors); i++) { 
+        weakref = PyList_GetItem(self->cursors, i); 
+        if (PyWeakref_GetObject(weakref) != Py_None) { 
+            if (PyList_Append(new_list, weakref) != 0) { 
+                Py_DECREF(new_list); 
+                return; 
+            } 
+        } 
+    } 
+ 
+    Py_SETREF(self->cursors, new_list); 
+} 
+ 
 static void _destructor(void* args)
 {
     Py_DECREF((PyObject*)args);
 }
 
-PyObject* pysqlite_connection_create_function(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)
-{
+PyObject* pysqlite_connection_create_function(pysqlite_Connection* self, PyObject* args, PyObject* kwargs) 
+{ 
     static char *kwlist[] = {"name", "narg", "func", "deterministic", NULL};
-
-    PyObject* func;
-    char* name;
-    int narg;
-    int rc;
+ 
+    PyObject* func; 
+    char* name; 
+    int narg; 
+    int rc; 
     int deterministic = 0;
     int flags = SQLITE_UTF8;
-
-    if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
-        return NULL;
-    }
-
+ 
+    if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) { 
+        return NULL; 
+    } 
+ 
     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "siO|$p", kwlist,
                                      &name, &narg, &func, &deterministic))
-    {
-        return NULL;
-    }
-
+    { 
+        return NULL; 
+    } 
+ 
     if (deterministic) {
 #if SQLITE_VERSION_NUMBER < 3008003
         PyErr_SetString(pysqlite_NotSupportedError,
                         "deterministic=True requires SQLite 3.8.3 or higher");
-        return NULL;
+        return NULL; 
 #else
         if (sqlite3_libversion_number() < 3008003) {
             PyErr_SetString(pysqlite_NotSupportedError,
@@ -868,7 +868,7 @@ PyObject* pysqlite_connection_create_function(pysqlite_Connection* self, PyObjec
         }
         flags |= SQLITE_DETERMINISTIC;
 #endif
-    }
+    } 
     Py_INCREF(func);
     rc = sqlite3_create_function_v2(self->db,
                                     name,
@@ -879,32 +879,32 @@ PyObject* pysqlite_connection_create_function(pysqlite_Connection* self, PyObjec
                                     NULL,
                                     NULL,
                                     &_destructor);  // will decref func
-
-    if (rc != SQLITE_OK) {
-        /* Workaround for SQLite bug: no error code or string is available here */
-        PyErr_SetString(pysqlite_OperationalError, "Error creating function");
-        return NULL;
-    }
-    Py_RETURN_NONE;
-}
-
-PyObject* pysqlite_connection_create_aggregate(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)
-{
-    PyObject* aggregate_class;
-
-    int n_arg;
-    char* name;
-    static char *kwlist[] = { "name", "n_arg", "aggregate_class", NULL };
-    int rc;
-
-    if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
-        return NULL;
-    }
-
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "siO:create_aggregate",
-                                      kwlist, &name, &n_arg, &aggregate_class)) {
-        return NULL;
-    }
+ 
+    if (rc != SQLITE_OK) { 
+        /* Workaround for SQLite bug: no error code or string is available here */ 
+        PyErr_SetString(pysqlite_OperationalError, "Error creating function"); 
+        return NULL; 
+    } 
+    Py_RETURN_NONE; 
+} 
+ 
+PyObject* pysqlite_connection_create_aggregate(pysqlite_Connection* self, PyObject* args, PyObject* kwargs) 
+{ 
+    PyObject* aggregate_class; 
+ 
+    int n_arg; 
+    char* name; 
+    static char *kwlist[] = { "name", "n_arg", "aggregate_class", NULL }; 
+    int rc; 
+ 
+    if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) { 
+        return NULL; 
+    } 
+ 
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "siO:create_aggregate", 
+                                      kwlist, &name, &n_arg, &aggregate_class)) { 
+        return NULL; 
+    } 
     Py_INCREF(aggregate_class);
     rc = sqlite3_create_function_v2(self->db,
                                     name,
@@ -915,292 +915,292 @@ PyObject* pysqlite_connection_create_aggregate(pysqlite_Connection* self, PyObje
                                     &_pysqlite_step_callback,
                                     &_pysqlite_final_callback,
                                     &_destructor); // will decref func
-    if (rc != SQLITE_OK) {
-        /* Workaround for SQLite bug: no error code or string is available here */
-        PyErr_SetString(pysqlite_OperationalError, "Error creating aggregate");
-        return NULL;
-    }
-    Py_RETURN_NONE;
-}
-
-static int _authorizer_callback(void* user_arg, int action, const char* arg1, const char* arg2 , const char* dbname, const char* access_attempt_source)
-{
-    PyObject *ret;
-    int rc;
-    PyGILState_STATE gilstate;
-
-    gilstate = PyGILState_Ensure();
-
-    ret = PyObject_CallFunction((PyObject*)user_arg, "issss", action, arg1, arg2, dbname, access_attempt_source);
-
-    if (ret == NULL) {
-        if (_pysqlite_enable_callback_tracebacks)
-            PyErr_Print();
-        else
-            PyErr_Clear();
-
-        rc = SQLITE_DENY;
-    }
-    else {
-        if (PyLong_Check(ret)) {
-            rc = _PyLong_AsInt(ret);
-            if (rc == -1 && PyErr_Occurred()) {
-                if (_pysqlite_enable_callback_tracebacks)
-                    PyErr_Print();
-                else
-                    PyErr_Clear();
-                rc = SQLITE_DENY;
-            }
-        }
-        else {
-            rc = SQLITE_DENY;
-        }
-        Py_DECREF(ret);
-    }
-
-    PyGILState_Release(gilstate);
-    return rc;
-}
-
-static int _progress_handler(void* user_arg)
-{
-    int rc;
-    PyObject *ret;
-    PyGILState_STATE gilstate;
-
-    gilstate = PyGILState_Ensure();
-    ret = _PyObject_CallNoArg((PyObject*)user_arg);
-
-    if (!ret) {
-        if (_pysqlite_enable_callback_tracebacks) {
-            PyErr_Print();
-        } else {
-            PyErr_Clear();
-        }
-
-        /* abort query if error occurred */
-        rc = 1;
-    } else {
-        rc = (int)PyObject_IsTrue(ret);
-        Py_DECREF(ret);
-    }
-
-    PyGILState_Release(gilstate);
-    return rc;
-}
-
-static void _trace_callback(void* user_arg, const char* statement_string)
-{
-    PyObject *py_statement = NULL;
-    PyObject *ret = NULL;
-
-    PyGILState_STATE gilstate;
-
-    gilstate = PyGILState_Ensure();
-    py_statement = PyUnicode_DecodeUTF8(statement_string,
-            strlen(statement_string), "replace");
-    if (py_statement) {
+    if (rc != SQLITE_OK) { 
+        /* Workaround for SQLite bug: no error code or string is available here */ 
+        PyErr_SetString(pysqlite_OperationalError, "Error creating aggregate"); 
+        return NULL; 
+    } 
+    Py_RETURN_NONE; 
+} 
+ 
+static int _authorizer_callback(void* user_arg, int action, const char* arg1, const char* arg2 , const char* dbname, const char* access_attempt_source) 
+{ 
+    PyObject *ret; 
+    int rc; 
+    PyGILState_STATE gilstate; 
+ 
+    gilstate = PyGILState_Ensure(); 
+ 
+    ret = PyObject_CallFunction((PyObject*)user_arg, "issss", action, arg1, arg2, dbname, access_attempt_source); 
+ 
+    if (ret == NULL) { 
+        if (_pysqlite_enable_callback_tracebacks) 
+            PyErr_Print(); 
+        else 
+            PyErr_Clear(); 
+ 
+        rc = SQLITE_DENY; 
+    } 
+    else { 
+        if (PyLong_Check(ret)) { 
+            rc = _PyLong_AsInt(ret); 
+            if (rc == -1 && PyErr_Occurred()) { 
+                if (_pysqlite_enable_callback_tracebacks) 
+                    PyErr_Print(); 
+                else 
+                    PyErr_Clear(); 
+                rc = SQLITE_DENY; 
+            } 
+        } 
+        else { 
+            rc = SQLITE_DENY; 
+        } 
+        Py_DECREF(ret); 
+    } 
+ 
+    PyGILState_Release(gilstate); 
+    return rc; 
+} 
+ 
+static int _progress_handler(void* user_arg) 
+{ 
+    int rc; 
+    PyObject *ret; 
+    PyGILState_STATE gilstate; 
+ 
+    gilstate = PyGILState_Ensure(); 
+    ret = _PyObject_CallNoArg((PyObject*)user_arg); 
+ 
+    if (!ret) { 
+        if (_pysqlite_enable_callback_tracebacks) { 
+            PyErr_Print(); 
+        } else { 
+            PyErr_Clear(); 
+        } 
+ 
+        /* abort query if error occurred */ 
+        rc = 1; 
+    } else { 
+        rc = (int)PyObject_IsTrue(ret); 
+        Py_DECREF(ret); 
+    } 
+ 
+    PyGILState_Release(gilstate); 
+    return rc; 
+} 
+ 
+static void _trace_callback(void* user_arg, const char* statement_string) 
+{ 
+    PyObject *py_statement = NULL; 
+    PyObject *ret = NULL; 
+ 
+    PyGILState_STATE gilstate; 
+ 
+    gilstate = PyGILState_Ensure(); 
+    py_statement = PyUnicode_DecodeUTF8(statement_string, 
+            strlen(statement_string), "replace"); 
+    if (py_statement) { 
         ret = PyObject_CallOneArg((PyObject*)user_arg, py_statement);
-        Py_DECREF(py_statement);
-    }
-
-    if (ret) {
-        Py_DECREF(ret);
-    } else {
-        if (_pysqlite_enable_callback_tracebacks) {
-            PyErr_Print();
-        } else {
-            PyErr_Clear();
-        }
-    }
-
-    PyGILState_Release(gilstate);
-}
-
-static PyObject* pysqlite_connection_set_authorizer(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)
-{
-    PyObject* authorizer_cb;
-
-    static char *kwlist[] = { "authorizer_callback", NULL };
-    int rc;
-
-    if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
-        return NULL;
-    }
-
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:set_authorizer",
-                                      kwlist, &authorizer_cb)) {
-        return NULL;
-    }
-
-    rc = sqlite3_set_authorizer(self->db, _authorizer_callback, (void*)authorizer_cb);
-    if (rc != SQLITE_OK) {
-        PyErr_SetString(pysqlite_OperationalError, "Error setting authorizer callback");
+        Py_DECREF(py_statement); 
+    } 
+ 
+    if (ret) { 
+        Py_DECREF(ret); 
+    } else { 
+        if (_pysqlite_enable_callback_tracebacks) { 
+            PyErr_Print(); 
+        } else { 
+            PyErr_Clear(); 
+        } 
+    } 
+ 
+    PyGILState_Release(gilstate); 
+} 
+ 
+static PyObject* pysqlite_connection_set_authorizer(pysqlite_Connection* self, PyObject* args, PyObject* kwargs) 
+{ 
+    PyObject* authorizer_cb; 
+ 
+    static char *kwlist[] = { "authorizer_callback", NULL }; 
+    int rc; 
+ 
+    if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) { 
+        return NULL; 
+    } 
+ 
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:set_authorizer", 
+                                      kwlist, &authorizer_cb)) { 
+        return NULL; 
+    } 
+ 
+    rc = sqlite3_set_authorizer(self->db, _authorizer_callback, (void*)authorizer_cb); 
+    if (rc != SQLITE_OK) { 
+        PyErr_SetString(pysqlite_OperationalError, "Error setting authorizer callback"); 
         Py_XSETREF(self->function_pinboard_authorizer_cb, NULL);
-        return NULL;
+        return NULL; 
     } else {
         Py_INCREF(authorizer_cb);
         Py_XSETREF(self->function_pinboard_authorizer_cb, authorizer_cb);
-    }
-    Py_RETURN_NONE;
-}
-
-static PyObject* pysqlite_connection_set_progress_handler(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)
-{
-    PyObject* progress_handler;
-    int n;
-
-    static char *kwlist[] = { "progress_handler", "n", NULL };
-
-    if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
-        return NULL;
-    }
-
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Oi:set_progress_handler",
-                                      kwlist, &progress_handler, &n)) {
-        return NULL;
-    }
-
-    if (progress_handler == Py_None) {
-        /* None clears the progress handler previously set */
-        sqlite3_progress_handler(self->db, 0, 0, (void*)0);
+    } 
+    Py_RETURN_NONE; 
+} 
+ 
+static PyObject* pysqlite_connection_set_progress_handler(pysqlite_Connection* self, PyObject* args, PyObject* kwargs) 
+{ 
+    PyObject* progress_handler; 
+    int n; 
+ 
+    static char *kwlist[] = { "progress_handler", "n", NULL }; 
+ 
+    if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) { 
+        return NULL; 
+    } 
+ 
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Oi:set_progress_handler", 
+                                      kwlist, &progress_handler, &n)) { 
+        return NULL; 
+    } 
+ 
+    if (progress_handler == Py_None) { 
+        /* None clears the progress handler previously set */ 
+        sqlite3_progress_handler(self->db, 0, 0, (void*)0); 
         Py_XSETREF(self->function_pinboard_progress_handler, NULL);
-    } else {
-        sqlite3_progress_handler(self->db, n, _progress_handler, progress_handler);
+    } else { 
+        sqlite3_progress_handler(self->db, n, _progress_handler, progress_handler); 
         Py_INCREF(progress_handler);
         Py_XSETREF(self->function_pinboard_progress_handler, progress_handler);
-    }
-    Py_RETURN_NONE;
-}
-
-static PyObject* pysqlite_connection_set_trace_callback(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)
-{
-    PyObject* trace_callback;
-
-    static char *kwlist[] = { "trace_callback", NULL };
-
-    if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
-        return NULL;
-    }
-
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:set_trace_callback",
-                                      kwlist, &trace_callback)) {
-        return NULL;
-    }
-
-    if (trace_callback == Py_None) {
-        /* None clears the trace callback previously set */
-        sqlite3_trace(self->db, 0, (void*)0);
+    } 
+    Py_RETURN_NONE; 
+} 
+ 
+static PyObject* pysqlite_connection_set_trace_callback(pysqlite_Connection* self, PyObject* args, PyObject* kwargs) 
+{ 
+    PyObject* trace_callback; 
+ 
+    static char *kwlist[] = { "trace_callback", NULL }; 
+ 
+    if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) { 
+        return NULL; 
+    } 
+ 
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:set_trace_callback", 
+                                      kwlist, &trace_callback)) { 
+        return NULL; 
+    } 
+ 
+    if (trace_callback == Py_None) { 
+        /* None clears the trace callback previously set */ 
+        sqlite3_trace(self->db, 0, (void*)0); 
         Py_XSETREF(self->function_pinboard_trace_callback, NULL);
-    } else {
-        sqlite3_trace(self->db, _trace_callback, trace_callback);
+    } else { 
+        sqlite3_trace(self->db, _trace_callback, trace_callback); 
         Py_INCREF(trace_callback);
         Py_XSETREF(self->function_pinboard_trace_callback, trace_callback);
-    }
-
-    Py_RETURN_NONE;
-}
-
-#ifdef HAVE_LOAD_EXTENSION
-static PyObject* pysqlite_enable_load_extension(pysqlite_Connection* self, PyObject* args)
-{
-    int rc;
-    int onoff;
-
-    if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
-        return NULL;
-    }
-
-    if (!PyArg_ParseTuple(args, "i", &onoff)) {
-        return NULL;
-    }
-
-    rc = sqlite3_enable_load_extension(self->db, onoff);
-
-    if (rc != SQLITE_OK) {
-        PyErr_SetString(pysqlite_OperationalError, "Error enabling load extension");
-        return NULL;
-    } else {
-        Py_RETURN_NONE;
-    }
-}
-
-static PyObject* pysqlite_load_extension(pysqlite_Connection* self, PyObject* args)
-{
-    int rc;
-    char* extension_name;
-    char* errmsg;
-
-    if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
-        return NULL;
-    }
-
-    if (!PyArg_ParseTuple(args, "s", &extension_name)) {
-        return NULL;
-    }
-
-    rc = sqlite3_load_extension(self->db, extension_name, 0, &errmsg);
-    if (rc != 0) {
-        PyErr_SetString(pysqlite_OperationalError, errmsg);
-        return NULL;
-    } else {
-        Py_RETURN_NONE;
-    }
-}
-#endif
-
-int pysqlite_check_thread(pysqlite_Connection* self)
-{
-    if (self->check_same_thread) {
-        if (PyThread_get_thread_ident() != self->thread_ident) {
-            PyErr_Format(pysqlite_ProgrammingError,
-                        "SQLite objects created in a thread can only be used in that same thread. "
-                        "The object was created in thread id %lu and this is thread id %lu.",
-                        self->thread_ident, PyThread_get_thread_ident());
-            return 0;
-        }
-
-    }
-    return 1;
-}
-
-static PyObject* pysqlite_connection_get_isolation_level(pysqlite_Connection* self, void* unused)
-{
+    } 
+ 
+    Py_RETURN_NONE; 
+} 
+ 
+#ifdef HAVE_LOAD_EXTENSION 
+static PyObject* pysqlite_enable_load_extension(pysqlite_Connection* self, PyObject* args) 
+{ 
+    int rc; 
+    int onoff; 
+ 
+    if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) { 
+        return NULL; 
+    } 
+ 
+    if (!PyArg_ParseTuple(args, "i", &onoff)) { 
+        return NULL; 
+    } 
+ 
+    rc = sqlite3_enable_load_extension(self->db, onoff); 
+ 
+    if (rc != SQLITE_OK) { 
+        PyErr_SetString(pysqlite_OperationalError, "Error enabling load extension"); 
+        return NULL; 
+    } else { 
+        Py_RETURN_NONE; 
+    } 
+} 
+ 
+static PyObject* pysqlite_load_extension(pysqlite_Connection* self, PyObject* args) 
+{ 
+    int rc; 
+    char* extension_name; 
+    char* errmsg; 
+ 
+    if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) { 
+        return NULL; 
+    } 
+ 
+    if (!PyArg_ParseTuple(args, "s", &extension_name)) { 
+        return NULL; 
+    } 
+ 
+    rc = sqlite3_load_extension(self->db, extension_name, 0, &errmsg); 
+    if (rc != 0) { 
+        PyErr_SetString(pysqlite_OperationalError, errmsg); 
+        return NULL; 
+    } else { 
+        Py_RETURN_NONE; 
+    } 
+} 
+#endif 
+ 
+int pysqlite_check_thread(pysqlite_Connection* self) 
+{ 
+    if (self->check_same_thread) { 
+        if (PyThread_get_thread_ident() != self->thread_ident) { 
+            PyErr_Format(pysqlite_ProgrammingError, 
+                        "SQLite objects created in a thread can only be used in that same thread. " 
+                        "The object was created in thread id %lu and this is thread id %lu.", 
+                        self->thread_ident, PyThread_get_thread_ident()); 
+            return 0; 
+        } 
+ 
+    } 
+    return 1; 
+} 
+ 
+static PyObject* pysqlite_connection_get_isolation_level(pysqlite_Connection* self, void* unused) 
+{ 
     if (!pysqlite_check_connection(self)) {
         return NULL;
     }
-    Py_INCREF(self->isolation_level);
-    return self->isolation_level;
-}
-
-static PyObject* pysqlite_connection_get_total_changes(pysqlite_Connection* self, void* unused)
-{
-    if (!pysqlite_check_connection(self)) {
-        return NULL;
-    } else {
-        return Py_BuildValue("i", sqlite3_total_changes(self->db));
-    }
-}
-
-static PyObject* pysqlite_connection_get_in_transaction(pysqlite_Connection* self, void* unused)
-{
-    if (!pysqlite_check_connection(self)) {
-        return NULL;
-    }
-    if (!sqlite3_get_autocommit(self->db)) {
-        Py_RETURN_TRUE;
-    }
-    Py_RETURN_FALSE;
-}
-
-static int
-pysqlite_connection_set_isolation_level(pysqlite_Connection* self, PyObject* isolation_level, void *Py_UNUSED(ignored))
-{
-    if (isolation_level == NULL) {
-        PyErr_SetString(PyExc_AttributeError, "cannot delete attribute");
-        return -1;
-    }
-    if (isolation_level == Py_None) {
+    Py_INCREF(self->isolation_level); 
+    return self->isolation_level; 
+} 
+ 
+static PyObject* pysqlite_connection_get_total_changes(pysqlite_Connection* self, void* unused) 
+{ 
+    if (!pysqlite_check_connection(self)) { 
+        return NULL; 
+    } else { 
+        return Py_BuildValue("i", sqlite3_total_changes(self->db)); 
+    } 
+} 
+ 
+static PyObject* pysqlite_connection_get_in_transaction(pysqlite_Connection* self, void* unused) 
+{ 
+    if (!pysqlite_check_connection(self)) { 
+        return NULL; 
+    } 
+    if (!sqlite3_get_autocommit(self->db)) { 
+        Py_RETURN_TRUE; 
+    } 
+    Py_RETURN_FALSE; 
+} 
+ 
+static int 
+pysqlite_connection_set_isolation_level(pysqlite_Connection* self, PyObject* isolation_level, void *Py_UNUSED(ignored)) 
+{ 
+    if (isolation_level == NULL) { 
+        PyErr_SetString(PyExc_AttributeError, "cannot delete attribute"); 
+        return -1; 
+    } 
+    if (isolation_level == Py_None) { 
         /* We might get called during connection init, so we cannot use
          * pysqlite_connection_commit() here. */
         if (self->db && !sqlite3_get_autocommit(self->db)) {
@@ -1211,330 +1211,330 @@ pysqlite_connection_set_isolation_level(pysqlite_Connection* self, PyObject* iso
             if (rc != SQLITE_OK) {
                 return _pysqlite_seterror(self->db, NULL);
             }
-        }
-
-        self->begin_statement = NULL;
-    } else {
-        const char * const *candidate;
-        PyObject *uppercase_level;
-        _Py_IDENTIFIER(upper);
-
-        if (!PyUnicode_Check(isolation_level)) {
-            PyErr_Format(PyExc_TypeError,
-                         "isolation_level must be a string or None, not %.100s",
-                         Py_TYPE(isolation_level)->tp_name);
-            return -1;
-        }
-
+        } 
+ 
+        self->begin_statement = NULL; 
+    } else { 
+        const char * const *candidate; 
+        PyObject *uppercase_level; 
+        _Py_IDENTIFIER(upper); 
+ 
+        if (!PyUnicode_Check(isolation_level)) { 
+            PyErr_Format(PyExc_TypeError, 
+                         "isolation_level must be a string or None, not %.100s", 
+                         Py_TYPE(isolation_level)->tp_name); 
+            return -1; 
+        } 
+ 
         uppercase_level = _PyObject_CallMethodIdOneArg(
-                        (PyObject *)&PyUnicode_Type, &PyId_upper,
+                        (PyObject *)&PyUnicode_Type, &PyId_upper, 
                         isolation_level);
-        if (!uppercase_level) {
-            return -1;
-        }
-        for (candidate = begin_statements; *candidate; candidate++) {
-            if (_PyUnicode_EqualToASCIIString(uppercase_level, *candidate + 6))
-                break;
-        }
-        Py_DECREF(uppercase_level);
-        if (!*candidate) {
-            PyErr_SetString(PyExc_ValueError,
-                            "invalid value for isolation_level");
-            return -1;
-        }
-        self->begin_statement = *candidate;
-    }
-
-    Py_INCREF(isolation_level);
-    Py_XSETREF(self->isolation_level, isolation_level);
-    return 0;
-}
-
-PyObject* pysqlite_connection_call(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)
-{
-    PyObject* sql;
-    pysqlite_Statement* statement;
-    PyObject* weakref;
-    int rc;
-
-    if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
-        return NULL;
-    }
-
-    if (!_PyArg_NoKeywords(MODULE_NAME ".Connection", kwargs))
-        return NULL;
-
+        if (!uppercase_level) { 
+            return -1; 
+        } 
+        for (candidate = begin_statements; *candidate; candidate++) { 
+            if (_PyUnicode_EqualToASCIIString(uppercase_level, *candidate + 6)) 
+                break; 
+        } 
+        Py_DECREF(uppercase_level); 
+        if (!*candidate) { 
+            PyErr_SetString(PyExc_ValueError, 
+                            "invalid value for isolation_level"); 
+            return -1; 
+        } 
+        self->begin_statement = *candidate; 
+    } 
+ 
+    Py_INCREF(isolation_level); 
+    Py_XSETREF(self->isolation_level, isolation_level); 
+    return 0; 
+} 
+ 
+PyObject* pysqlite_connection_call(pysqlite_Connection* self, PyObject* args, PyObject* kwargs) 
+{ 
+    PyObject* sql; 
+    pysqlite_Statement* statement; 
+    PyObject* weakref; 
+    int rc; 
+ 
+    if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) { 
+        return NULL; 
+    } 
+ 
+    if (!_PyArg_NoKeywords(MODULE_NAME ".Connection", kwargs)) 
+        return NULL; 
+ 
     if (!PyArg_ParseTuple(args, "U", &sql))
-        return NULL;
-
-    _pysqlite_drop_unused_statement_references(self);
-
-    statement = PyObject_New(pysqlite_Statement, &pysqlite_StatementType);
-    if (!statement) {
-        return NULL;
-    }
-
-    statement->db = NULL;
-    statement->st = NULL;
-    statement->sql = NULL;
-    statement->in_use = 0;
-    statement->in_weakreflist = NULL;
-
-    rc = pysqlite_statement_create(statement, self, sql);
-    if (rc != SQLITE_OK) {
-        if (rc == PYSQLITE_TOO_MUCH_SQL) {
-            PyErr_SetString(pysqlite_Warning, "You can only execute one statement at a time.");
-        } else if (rc == PYSQLITE_SQL_WRONG_TYPE) {
-            if (PyErr_ExceptionMatches(PyExc_TypeError))
-                PyErr_SetString(pysqlite_Warning, "SQL is of wrong type. Must be string.");
-        } else {
-            (void)pysqlite_statement_reset(statement);
-            _pysqlite_seterror(self->db, NULL);
-        }
-        goto error;
-    }
-
-    weakref = PyWeakref_NewRef((PyObject*)statement, NULL);
-    if (weakref == NULL)
-        goto error;
-    if (PyList_Append(self->statements, weakref) != 0) {
-        Py_DECREF(weakref);
-        goto error;
-    }
-    Py_DECREF(weakref);
-
-    return (PyObject*)statement;
-
-error:
-    Py_DECREF(statement);
-    return NULL;
-}
-
-PyObject* pysqlite_connection_execute(pysqlite_Connection* self, PyObject* args)
-{
-    PyObject* cursor = 0;
-    PyObject* result = 0;
-    PyObject* method = 0;
-
+        return NULL; 
+ 
+    _pysqlite_drop_unused_statement_references(self); 
+ 
+    statement = PyObject_New(pysqlite_Statement, &pysqlite_StatementType); 
+    if (!statement) { 
+        return NULL; 
+    } 
+ 
+    statement->db = NULL; 
+    statement->st = NULL; 
+    statement->sql = NULL; 
+    statement->in_use = 0; 
+    statement->in_weakreflist = NULL; 
+ 
+    rc = pysqlite_statement_create(statement, self, sql); 
+    if (rc != SQLITE_OK) { 
+        if (rc == PYSQLITE_TOO_MUCH_SQL) { 
+            PyErr_SetString(pysqlite_Warning, "You can only execute one statement at a time."); 
+        } else if (rc == PYSQLITE_SQL_WRONG_TYPE) { 
+            if (PyErr_ExceptionMatches(PyExc_TypeError)) 
+                PyErr_SetString(pysqlite_Warning, "SQL is of wrong type. Must be string."); 
+        } else { 
+            (void)pysqlite_statement_reset(statement); 
+            _pysqlite_seterror(self->db, NULL); 
+        } 
+        goto error; 
+    } 
+ 
+    weakref = PyWeakref_NewRef((PyObject*)statement, NULL); 
+    if (weakref == NULL) 
+        goto error; 
+    if (PyList_Append(self->statements, weakref) != 0) { 
+        Py_DECREF(weakref); 
+        goto error; 
+    } 
+    Py_DECREF(weakref); 
+ 
+    return (PyObject*)statement; 
+ 
+error: 
+    Py_DECREF(statement); 
+    return NULL; 
+} 
+ 
+PyObject* pysqlite_connection_execute(pysqlite_Connection* self, PyObject* args) 
+{ 
+    PyObject* cursor = 0; 
+    PyObject* result = 0; 
+    PyObject* method = 0; 
+ 
     cursor = _PyObject_CallMethodIdNoArgs((PyObject*)self, &PyId_cursor);
-    if (!cursor) {
-        goto error;
-    }
-
-    method = PyObject_GetAttrString(cursor, "execute");
-    if (!method) {
-        Py_CLEAR(cursor);
-        goto error;
-    }
-
-    result = PyObject_CallObject(method, args);
-    if (!result) {
-        Py_CLEAR(cursor);
-    }
-
-error:
-    Py_XDECREF(result);
-    Py_XDECREF(method);
-
-    return cursor;
-}
-
-PyObject* pysqlite_connection_executemany(pysqlite_Connection* self, PyObject* args)
-{
-    PyObject* cursor = 0;
-    PyObject* result = 0;
-    PyObject* method = 0;
-
+    if (!cursor) { 
+        goto error; 
+    } 
+ 
+    method = PyObject_GetAttrString(cursor, "execute"); 
+    if (!method) { 
+        Py_CLEAR(cursor); 
+        goto error; 
+    } 
+ 
+    result = PyObject_CallObject(method, args); 
+    if (!result) { 
+        Py_CLEAR(cursor); 
+    } 
+ 
+error: 
+    Py_XDECREF(result); 
+    Py_XDECREF(method); 
+ 
+    return cursor; 
+} 
+ 
+PyObject* pysqlite_connection_executemany(pysqlite_Connection* self, PyObject* args) 
+{ 
+    PyObject* cursor = 0; 
+    PyObject* result = 0; 
+    PyObject* method = 0; 
+ 
     cursor = _PyObject_CallMethodIdNoArgs((PyObject*)self, &PyId_cursor);
-    if (!cursor) {
-        goto error;
-    }
-
-    method = PyObject_GetAttrString(cursor, "executemany");
-    if (!method) {
-        Py_CLEAR(cursor);
-        goto error;
-    }
-
-    result = PyObject_CallObject(method, args);
-    if (!result) {
-        Py_CLEAR(cursor);
-    }
-
-error:
-    Py_XDECREF(result);
-    Py_XDECREF(method);
-
-    return cursor;
-}
-
-PyObject* pysqlite_connection_executescript(pysqlite_Connection* self, PyObject* args)
-{
-    PyObject* cursor = 0;
-    PyObject* result = 0;
-    PyObject* method = 0;
-
+    if (!cursor) { 
+        goto error; 
+    } 
+ 
+    method = PyObject_GetAttrString(cursor, "executemany"); 
+    if (!method) { 
+        Py_CLEAR(cursor); 
+        goto error; 
+    } 
+ 
+    result = PyObject_CallObject(method, args); 
+    if (!result) { 
+        Py_CLEAR(cursor); 
+    } 
+ 
+error: 
+    Py_XDECREF(result); 
+    Py_XDECREF(method); 
+ 
+    return cursor; 
+} 
+ 
+PyObject* pysqlite_connection_executescript(pysqlite_Connection* self, PyObject* args) 
+{ 
+    PyObject* cursor = 0; 
+    PyObject* result = 0; 
+    PyObject* method = 0; 
+ 
     cursor = _PyObject_CallMethodIdNoArgs((PyObject*)self, &PyId_cursor);
-    if (!cursor) {
-        goto error;
-    }
-
-    method = PyObject_GetAttrString(cursor, "executescript");
-    if (!method) {
-        Py_CLEAR(cursor);
-        goto error;
-    }
-
-    result = PyObject_CallObject(method, args);
-    if (!result) {
-        Py_CLEAR(cursor);
-    }
-
-error:
-    Py_XDECREF(result);
-    Py_XDECREF(method);
-
-    return cursor;
-}
-
-/* ------------------------- COLLATION CODE ------------------------ */
-
-static int
-pysqlite_collation_callback(
-        void* context,
-        int text1_length, const void* text1_data,
-        int text2_length, const void* text2_data)
-{
-    PyObject* callback = (PyObject*)context;
-    PyObject* string1 = 0;
-    PyObject* string2 = 0;
-    PyGILState_STATE gilstate;
-    PyObject* retval = NULL;
-    long longval;
-    int result = 0;
-    gilstate = PyGILState_Ensure();
-
-    if (PyErr_Occurred()) {
-        goto finally;
-    }
-
-    string1 = PyUnicode_FromStringAndSize((const char*)text1_data, text1_length);
-    string2 = PyUnicode_FromStringAndSize((const char*)text2_data, text2_length);
-
-    if (!string1 || !string2) {
-        goto finally; /* failed to allocate strings */
-    }
-
-    retval = PyObject_CallFunctionObjArgs(callback, string1, string2, NULL);
-
-    if (!retval) {
-        /* execution failed */
-        goto finally;
-    }
-
-    longval = PyLong_AsLongAndOverflow(retval, &result);
-    if (longval == -1 && PyErr_Occurred()) {
-        PyErr_Clear();
-        result = 0;
-    }
-    else if (!result) {
-        if (longval > 0)
-            result = 1;
-        else if (longval < 0)
-            result = -1;
-    }
-
-finally:
-    Py_XDECREF(string1);
-    Py_XDECREF(string2);
-    Py_XDECREF(retval);
-    PyGILState_Release(gilstate);
-    return result;
-}
-
-static PyObject *
-pysqlite_connection_interrupt(pysqlite_Connection* self, PyObject* args)
-{
-    PyObject* retval = NULL;
-
-    if (!pysqlite_check_connection(self)) {
-        goto finally;
-    }
-
-    sqlite3_interrupt(self->db);
-
-    Py_INCREF(Py_None);
-    retval = Py_None;
-
-finally:
-    return retval;
-}
-
-/* Function author: Paul Kippes <[email protected]>
- * Class method of Connection to call the Python function _iterdump
- * of the sqlite3 module.
- */
-static PyObject *
-pysqlite_connection_iterdump(pysqlite_Connection* self, PyObject* args)
-{
+    if (!cursor) { 
+        goto error; 
+    } 
+ 
+    method = PyObject_GetAttrString(cursor, "executescript"); 
+    if (!method) { 
+        Py_CLEAR(cursor); 
+        goto error; 
+    } 
+ 
+    result = PyObject_CallObject(method, args); 
+    if (!result) { 
+        Py_CLEAR(cursor); 
+    } 
+ 
+error: 
+    Py_XDECREF(result); 
+    Py_XDECREF(method); 
+ 
+    return cursor; 
+} 
+ 
+/* ------------------------- COLLATION CODE ------------------------ */ 
+ 
+static int 
+pysqlite_collation_callback( 
+        void* context, 
+        int text1_length, const void* text1_data, 
+        int text2_length, const void* text2_data) 
+{ 
+    PyObject* callback = (PyObject*)context; 
+    PyObject* string1 = 0; 
+    PyObject* string2 = 0; 
+    PyGILState_STATE gilstate; 
+    PyObject* retval = NULL; 
+    long longval; 
+    int result = 0; 
+    gilstate = PyGILState_Ensure(); 
+ 
+    if (PyErr_Occurred()) { 
+        goto finally; 
+    } 
+ 
+    string1 = PyUnicode_FromStringAndSize((const char*)text1_data, text1_length); 
+    string2 = PyUnicode_FromStringAndSize((const char*)text2_data, text2_length); 
+ 
+    if (!string1 || !string2) { 
+        goto finally; /* failed to allocate strings */ 
+    } 
+ 
+    retval = PyObject_CallFunctionObjArgs(callback, string1, string2, NULL); 
+ 
+    if (!retval) { 
+        /* execution failed */ 
+        goto finally; 
+    } 
+ 
+    longval = PyLong_AsLongAndOverflow(retval, &result); 
+    if (longval == -1 && PyErr_Occurred()) { 
+        PyErr_Clear(); 
+        result = 0; 
+    } 
+    else if (!result) { 
+        if (longval > 0) 
+            result = 1; 
+        else if (longval < 0) 
+            result = -1; 
+    } 
+ 
+finally: 
+    Py_XDECREF(string1); 
+    Py_XDECREF(string2); 
+    Py_XDECREF(retval); 
+    PyGILState_Release(gilstate); 
+    return result; 
+} 
+ 
+static PyObject * 
+pysqlite_connection_interrupt(pysqlite_Connection* self, PyObject* args) 
+{ 
+    PyObject* retval = NULL; 
+ 
+    if (!pysqlite_check_connection(self)) { 
+        goto finally; 
+    } 
+ 
+    sqlite3_interrupt(self->db); 
+ 
+    Py_INCREF(Py_None); 
+    retval = Py_None; 
+ 
+finally: 
+    return retval; 
+} 
+ 
+/* Function author: Paul Kippes <[email protected]> 
+ * Class method of Connection to call the Python function _iterdump 
+ * of the sqlite3 module. 
+ */ 
+static PyObject * 
+pysqlite_connection_iterdump(pysqlite_Connection* self, PyObject* args) 
+{ 
     _Py_IDENTIFIER(_iterdump);
-    PyObject* retval = NULL;
-    PyObject* module = NULL;
-    PyObject* module_dict;
-    PyObject* pyfn_iterdump;
-
-    if (!pysqlite_check_connection(self)) {
-        goto finally;
-    }
-
-    module = PyImport_ImportModule(MODULE_NAME ".dump");
-    if (!module) {
-        goto finally;
-    }
-
-    module_dict = PyModule_GetDict(module);
-    if (!module_dict) {
-        goto finally;
-    }
-
+    PyObject* retval = NULL; 
+    PyObject* module = NULL; 
+    PyObject* module_dict; 
+    PyObject* pyfn_iterdump; 
+ 
+    if (!pysqlite_check_connection(self)) { 
+        goto finally; 
+    } 
+ 
+    module = PyImport_ImportModule(MODULE_NAME ".dump"); 
+    if (!module) { 
+        goto finally; 
+    } 
+ 
+    module_dict = PyModule_GetDict(module); 
+    if (!module_dict) { 
+        goto finally; 
+    } 
+ 
     pyfn_iterdump = _PyDict_GetItemIdWithError(module_dict, &PyId__iterdump);
-    if (!pyfn_iterdump) {
+    if (!pyfn_iterdump) { 
         if (!PyErr_Occurred()) {
             PyErr_SetString(pysqlite_OperationalError,
                             "Failed to obtain _iterdump() reference");
         }
-        goto finally;
-    }
-
+        goto finally; 
+    } 
+ 
     retval = PyObject_CallOneArg(pyfn_iterdump, (PyObject *)self);
-
-finally:
-    Py_XDECREF(module);
-    return retval;
-}
-
-#ifdef HAVE_BACKUP_API
-static PyObject *
-pysqlite_connection_backup(pysqlite_Connection *self, PyObject *args, PyObject *kwds)
-{
-    PyObject *target = NULL;
-    int pages = -1;
-    PyObject *progress = Py_None;
-    const char *name = "main";
-    int rc;
-    int callback_error = 0;
+ 
+finally: 
+    Py_XDECREF(module); 
+    return retval; 
+} 
+ 
+#ifdef HAVE_BACKUP_API 
+static PyObject * 
+pysqlite_connection_backup(pysqlite_Connection *self, PyObject *args, PyObject *kwds) 
+{ 
+    PyObject *target = NULL; 
+    int pages = -1; 
+    PyObject *progress = Py_None; 
+    const char *name = "main"; 
+    int rc; 
+    int callback_error = 0; 
     PyObject *sleep_obj = NULL;
     int sleep_ms = 250;
-    sqlite3 *bck_conn;
-    sqlite3_backup *bck_handle;
-    static char *keywords[] = {"target", "pages", "progress", "name", "sleep", NULL};
-
+    sqlite3 *bck_conn; 
+    sqlite3_backup *bck_handle; 
+    static char *keywords[] = {"target", "pages", "progress", "name", "sleep", NULL}; 
+ 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|$iOsO:backup", keywords,
-                                     &pysqlite_ConnectionType, &target,
+                                     &pysqlite_ConnectionType, &target, 
                                      &pages, &progress, &name, &sleep_obj)) {
-        return NULL;
-    }
-
+        return NULL; 
+    } 
+ 
     if (sleep_obj != NULL) {
         _PyTime_t sleep_secs;
         if (_PyTime_FromSecondsObject(&sleep_secs, sleep_obj,
@@ -1554,243 +1554,243 @@ pysqlite_connection_backup(pysqlite_Connection *self, PyObject *args, PyObject *
         return NULL;
     }
 
-    if (!pysqlite_check_connection((pysqlite_Connection *)target)) {
-        return NULL;
-    }
-
-    if ((pysqlite_Connection *)target == self) {
-        PyErr_SetString(PyExc_ValueError, "target cannot be the same connection instance");
-        return NULL;
-    }
-
-#if SQLITE_VERSION_NUMBER < 3008008
-    /* Since 3.8.8 this is already done, per commit
-       https://www.sqlite.org/src/info/169b5505498c0a7e */
-    if (!sqlite3_get_autocommit(((pysqlite_Connection *)target)->db)) {
-        PyErr_SetString(pysqlite_OperationalError, "target is in transaction");
-        return NULL;
-    }
-#endif
-
-    if (progress != Py_None && !PyCallable_Check(progress)) {
-        PyErr_SetString(PyExc_TypeError, "progress argument must be a callable");
-        return NULL;
-    }
-
-    if (pages == 0) {
-        pages = -1;
-    }
-
-    bck_conn = ((pysqlite_Connection *)target)->db;
-
-    Py_BEGIN_ALLOW_THREADS
-    bck_handle = sqlite3_backup_init(bck_conn, "main", self->db, name);
-    Py_END_ALLOW_THREADS
-
-    if (bck_handle) {
-        do {
-            Py_BEGIN_ALLOW_THREADS
-            rc = sqlite3_backup_step(bck_handle, pages);
-            Py_END_ALLOW_THREADS
-
-            if (progress != Py_None) {
-                PyObject *res;
-
-                res = PyObject_CallFunction(progress, "iii", rc,
-                                            sqlite3_backup_remaining(bck_handle),
-                                            sqlite3_backup_pagecount(bck_handle));
-                if (res == NULL) {
-                    /* User's callback raised an error: interrupt the loop and
-                       propagate it. */
-                    callback_error = 1;
-                    rc = -1;
-                } else {
-                    Py_DECREF(res);
-                }
-            }
-
-            /* Sleep for a while if there are still further pages to copy and
-               the engine could not make any progress */
-            if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED) {
-                Py_BEGIN_ALLOW_THREADS
+    if (!pysqlite_check_connection((pysqlite_Connection *)target)) { 
+        return NULL; 
+    } 
+ 
+    if ((pysqlite_Connection *)target == self) { 
+        PyErr_SetString(PyExc_ValueError, "target cannot be the same connection instance"); 
+        return NULL; 
+    } 
+ 
+#if SQLITE_VERSION_NUMBER < 3008008 
+    /* Since 3.8.8 this is already done, per commit 
+       https://www.sqlite.org/src/info/169b5505498c0a7e */ 
+    if (!sqlite3_get_autocommit(((pysqlite_Connection *)target)->db)) { 
+        PyErr_SetString(pysqlite_OperationalError, "target is in transaction"); 
+        return NULL; 
+    } 
+#endif 
+ 
+    if (progress != Py_None && !PyCallable_Check(progress)) { 
+        PyErr_SetString(PyExc_TypeError, "progress argument must be a callable"); 
+        return NULL; 
+    } 
+ 
+    if (pages == 0) { 
+        pages = -1; 
+    } 
+ 
+    bck_conn = ((pysqlite_Connection *)target)->db; 
+ 
+    Py_BEGIN_ALLOW_THREADS 
+    bck_handle = sqlite3_backup_init(bck_conn, "main", self->db, name); 
+    Py_END_ALLOW_THREADS 
+ 
+    if (bck_handle) { 
+        do { 
+            Py_BEGIN_ALLOW_THREADS 
+            rc = sqlite3_backup_step(bck_handle, pages); 
+            Py_END_ALLOW_THREADS 
+ 
+            if (progress != Py_None) { 
+                PyObject *res; 
+ 
+                res = PyObject_CallFunction(progress, "iii", rc, 
+                                            sqlite3_backup_remaining(bck_handle), 
+                                            sqlite3_backup_pagecount(bck_handle)); 
+                if (res == NULL) { 
+                    /* User's callback raised an error: interrupt the loop and 
+                       propagate it. */ 
+                    callback_error = 1; 
+                    rc = -1; 
+                } else { 
+                    Py_DECREF(res); 
+                } 
+            } 
+ 
+            /* Sleep for a while if there are still further pages to copy and 
+               the engine could not make any progress */ 
+            if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED) { 
+                Py_BEGIN_ALLOW_THREADS 
                 sqlite3_sleep(sleep_ms);
-                Py_END_ALLOW_THREADS
-            }
-        } while (rc == SQLITE_OK || rc == SQLITE_BUSY || rc == SQLITE_LOCKED);
-
-        Py_BEGIN_ALLOW_THREADS
-        rc = sqlite3_backup_finish(bck_handle);
-        Py_END_ALLOW_THREADS
-    } else {
-        rc = _pysqlite_seterror(bck_conn, NULL);
-    }
-
-    if (!callback_error && rc != SQLITE_OK) {
-        /* We cannot use _pysqlite_seterror() here because the backup APIs do
-           not set the error status on the connection object, but rather on
-           the backup handle. */
-        if (rc == SQLITE_NOMEM) {
-            (void)PyErr_NoMemory();
-        } else {
-#if SQLITE_VERSION_NUMBER > 3007015
-            PyErr_SetString(pysqlite_OperationalError, sqlite3_errstr(rc));
-#else
-            switch (rc) {
-                case SQLITE_ERROR:
-                    /* Description of SQLITE_ERROR in SQLite 3.7.14 and older
-                       releases. */
-                    PyErr_SetString(pysqlite_OperationalError,
-                                    "SQL logic error or missing database");
-                    break;
-                case SQLITE_READONLY:
-                    PyErr_SetString(pysqlite_OperationalError,
-                                    "attempt to write a readonly database");
-                    break;
-                case SQLITE_BUSY:
-                    PyErr_SetString(pysqlite_OperationalError, "database is locked");
-                    break;
-                case SQLITE_LOCKED:
-                    PyErr_SetString(pysqlite_OperationalError,
-                                    "database table is locked");
-                    break;
-                default:
-                    PyErr_Format(pysqlite_OperationalError,
-                                 "unrecognized error code: %d", rc);
-                    break;
-            }
-#endif
-        }
-    }
-
-    if (!callback_error && rc == SQLITE_OK) {
-        Py_RETURN_NONE;
-    } else {
-        return NULL;
-    }
-}
-#endif
-
-static PyObject *
-pysqlite_connection_create_collation(pysqlite_Connection* self, PyObject* args)
-{
-    PyObject* callable;
-    PyObject* uppercase_name = 0;
-    PyObject* name;
-    PyObject* retval;
-    Py_ssize_t i, len;
-    _Py_IDENTIFIER(upper);
-    const char *uppercase_name_str;
-    int rc;
-    unsigned int kind;
+                Py_END_ALLOW_THREADS 
+            } 
+        } while (rc == SQLITE_OK || rc == SQLITE_BUSY || rc == SQLITE_LOCKED); 
+ 
+        Py_BEGIN_ALLOW_THREADS 
+        rc = sqlite3_backup_finish(bck_handle); 
+        Py_END_ALLOW_THREADS 
+    } else { 
+        rc = _pysqlite_seterror(bck_conn, NULL); 
+    } 
+ 
+    if (!callback_error && rc != SQLITE_OK) { 
+        /* We cannot use _pysqlite_seterror() here because the backup APIs do 
+           not set the error status on the connection object, but rather on 
+           the backup handle. */ 
+        if (rc == SQLITE_NOMEM) { 
+            (void)PyErr_NoMemory(); 
+        } else { 
+#if SQLITE_VERSION_NUMBER > 3007015 
+            PyErr_SetString(pysqlite_OperationalError, sqlite3_errstr(rc)); 
+#else 
+            switch (rc) { 
+                case SQLITE_ERROR: 
+                    /* Description of SQLITE_ERROR in SQLite 3.7.14 and older 
+                       releases. */ 
+                    PyErr_SetString(pysqlite_OperationalError, 
+                                    "SQL logic error or missing database"); 
+                    break; 
+                case SQLITE_READONLY: 
+                    PyErr_SetString(pysqlite_OperationalError, 
+                                    "attempt to write a readonly database"); 
+                    break; 
+                case SQLITE_BUSY: 
+                    PyErr_SetString(pysqlite_OperationalError, "database is locked"); 
+                    break; 
+                case SQLITE_LOCKED: 
+                    PyErr_SetString(pysqlite_OperationalError, 
+                                    "database table is locked"); 
+                    break; 
+                default: 
+                    PyErr_Format(pysqlite_OperationalError, 
+                                 "unrecognized error code: %d", rc); 
+                    break; 
+            } 
+#endif 
+        } 
+    } 
+ 
+    if (!callback_error && rc == SQLITE_OK) { 
+        Py_RETURN_NONE; 
+    } else { 
+        return NULL; 
+    } 
+} 
+#endif 
+ 
+static PyObject * 
+pysqlite_connection_create_collation(pysqlite_Connection* self, PyObject* args) 
+{ 
+    PyObject* callable; 
+    PyObject* uppercase_name = 0; 
+    PyObject* name; 
+    PyObject* retval; 
+    Py_ssize_t i, len; 
+    _Py_IDENTIFIER(upper); 
+    const char *uppercase_name_str; 
+    int rc; 
+    unsigned int kind; 
     const void *data;
-
-    if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
-        goto finally;
-    }
-
-    if (!PyArg_ParseTuple(args, "UO:create_collation(name, callback)",
-                          &name, &callable)) {
-        goto finally;
-    }
-
+ 
+    if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) { 
+        goto finally; 
+    } 
+ 
+    if (!PyArg_ParseTuple(args, "UO:create_collation(name, callback)", 
+                          &name, &callable)) { 
+        goto finally; 
+    } 
+ 
     uppercase_name = _PyObject_CallMethodIdOneArg((PyObject *)&PyUnicode_Type,
                                                   &PyId_upper, name);
-    if (!uppercase_name) {
-        goto finally;
-    }
-
-    if (PyUnicode_READY(uppercase_name))
-        goto finally;
-    len = PyUnicode_GET_LENGTH(uppercase_name);
-    kind = PyUnicode_KIND(uppercase_name);
-    data = PyUnicode_DATA(uppercase_name);
-    for (i=0; i<len; i++) {
-        Py_UCS4 ch = PyUnicode_READ(kind, data, i);
-        if ((ch >= '0' && ch <= '9')
-         || (ch >= 'A' && ch <= 'Z')
-         || (ch == '_'))
-        {
-            continue;
-        } else {
-            PyErr_SetString(pysqlite_ProgrammingError, "invalid character in collation name");
-            goto finally;
-        }
-    }
-
-    uppercase_name_str = PyUnicode_AsUTF8(uppercase_name);
-    if (!uppercase_name_str)
-        goto finally;
-
-    if (callable != Py_None && !PyCallable_Check(callable)) {
-        PyErr_SetString(PyExc_TypeError, "parameter must be callable");
-        goto finally;
-    }
-
-    if (callable != Py_None) {
-        if (PyDict_SetItem(self->collations, uppercase_name, callable) == -1)
-            goto finally;
-    } else {
-        if (PyDict_DelItem(self->collations, uppercase_name) == -1)
-            goto finally;
-    }
-
-    rc = sqlite3_create_collation(self->db,
-                                  uppercase_name_str,
-                                  SQLITE_UTF8,
-                                  (callable != Py_None) ? callable : NULL,
-                                  (callable != Py_None) ? pysqlite_collation_callback : NULL);
-    if (rc != SQLITE_OK) {
+    if (!uppercase_name) { 
+        goto finally; 
+    } 
+ 
+    if (PyUnicode_READY(uppercase_name)) 
+        goto finally; 
+    len = PyUnicode_GET_LENGTH(uppercase_name); 
+    kind = PyUnicode_KIND(uppercase_name); 
+    data = PyUnicode_DATA(uppercase_name); 
+    for (i=0; i<len; i++) { 
+        Py_UCS4 ch = PyUnicode_READ(kind, data, i); 
+        if ((ch >= '0' && ch <= '9') 
+         || (ch >= 'A' && ch <= 'Z') 
+         || (ch == '_')) 
+        { 
+            continue; 
+        } else { 
+            PyErr_SetString(pysqlite_ProgrammingError, "invalid character in collation name"); 
+            goto finally; 
+        } 
+    } 
+ 
+    uppercase_name_str = PyUnicode_AsUTF8(uppercase_name); 
+    if (!uppercase_name_str) 
+        goto finally; 
+ 
+    if (callable != Py_None && !PyCallable_Check(callable)) { 
+        PyErr_SetString(PyExc_TypeError, "parameter must be callable"); 
+        goto finally; 
+    } 
+ 
+    if (callable != Py_None) { 
+        if (PyDict_SetItem(self->collations, uppercase_name, callable) == -1) 
+            goto finally; 
+    } else { 
+        if (PyDict_DelItem(self->collations, uppercase_name) == -1) 
+            goto finally; 
+    } 
+ 
+    rc = sqlite3_create_collation(self->db, 
+                                  uppercase_name_str, 
+                                  SQLITE_UTF8, 
+                                  (callable != Py_None) ? callable : NULL, 
+                                  (callable != Py_None) ? pysqlite_collation_callback : NULL); 
+    if (rc != SQLITE_OK) { 
         if (callable != Py_None) {
             if (PyDict_DelItem(self->collations, uppercase_name) < 0) {
                 PyErr_Clear();
             }
         }
-        _pysqlite_seterror(self->db, NULL);
-        goto finally;
-    }
-
-finally:
-    Py_XDECREF(uppercase_name);
-
-    if (PyErr_Occurred()) {
-        retval = NULL;
-    } else {
-        Py_INCREF(Py_None);
-        retval = Py_None;
-    }
-
-    return retval;
-}
-
-/* Called when the connection is used as a context manager. Returns itself as a
- * convenience to the caller. */
-static PyObject *
-pysqlite_connection_enter(pysqlite_Connection* self, PyObject* args)
-{
-    Py_INCREF(self);
-    return (PyObject*)self;
-}
-
-/** Called when the connection is used as a context manager. If there was any
- * exception, a rollback takes place; otherwise we commit. */
-static PyObject *
-pysqlite_connection_exit(pysqlite_Connection* self, PyObject* args)
-{
+        _pysqlite_seterror(self->db, NULL); 
+        goto finally; 
+    } 
+ 
+finally: 
+    Py_XDECREF(uppercase_name); 
+ 
+    if (PyErr_Occurred()) { 
+        retval = NULL; 
+    } else { 
+        Py_INCREF(Py_None); 
+        retval = Py_None; 
+    } 
+ 
+    return retval; 
+} 
+ 
+/* Called when the connection is used as a context manager. Returns itself as a 
+ * convenience to the caller. */ 
+static PyObject * 
+pysqlite_connection_enter(pysqlite_Connection* self, PyObject* args) 
+{ 
+    Py_INCREF(self); 
+    return (PyObject*)self; 
+} 
+ 
+/** Called when the connection is used as a context manager. If there was any 
+ * exception, a rollback takes place; otherwise we commit. */ 
+static PyObject * 
+pysqlite_connection_exit(pysqlite_Connection* self, PyObject* args) 
+{ 
     PyObject *exc_type, *exc_value, *exc_tb;
-    if (!PyArg_ParseTuple(args, "OOO", &exc_type, &exc_value, &exc_tb)) {
-        return NULL;
-    }
-
+    if (!PyArg_ParseTuple(args, "OOO", &exc_type, &exc_value, &exc_tb)) { 
+        return NULL; 
+    } 
+ 
     int commit = 0;
     PyObject *result;
-    if (exc_type == Py_None && exc_value == Py_None && exc_tb == Py_None) {
+    if (exc_type == Py_None && exc_value == Py_None && exc_tb == Py_None) { 
         commit = 1;
         result = pysqlite_connection_commit(self, NULL);
-    }
+    } 
     else {
         result = pysqlite_connection_rollback(self, NULL);
     }
-
+ 
     if (result == NULL) {
         if (commit) {
             /* Commit failed; try to rollback in order to unlock the database.
@@ -1806,132 +1806,132 @@ pysqlite_connection_exit(pysqlite_Connection* self, PyObject* args)
                 PyErr_Restore(exc, val, tb);
             }
         }
-        return NULL;
-    }
-    Py_DECREF(result);
-
-    Py_RETURN_FALSE;
-}
-
-static const char connection_doc[] =
-PyDoc_STR("SQLite database connection object.");
-
-static PyGetSetDef connection_getset[] = {
-    {"isolation_level",  (getter)pysqlite_connection_get_isolation_level, (setter)pysqlite_connection_set_isolation_level},
-    {"total_changes",  (getter)pysqlite_connection_get_total_changes, (setter)0},
-    {"in_transaction",  (getter)pysqlite_connection_get_in_transaction, (setter)0},
-    {NULL}
-};
-
-static PyMethodDef connection_methods[] = {
+        return NULL; 
+    } 
+    Py_DECREF(result); 
+ 
+    Py_RETURN_FALSE; 
+} 
+ 
+static const char connection_doc[] = 
+PyDoc_STR("SQLite database connection object."); 
+ 
+static PyGetSetDef connection_getset[] = { 
+    {"isolation_level",  (getter)pysqlite_connection_get_isolation_level, (setter)pysqlite_connection_set_isolation_level}, 
+    {"total_changes",  (getter)pysqlite_connection_get_total_changes, (setter)0}, 
+    {"in_transaction",  (getter)pysqlite_connection_get_in_transaction, (setter)0}, 
+    {NULL} 
+}; 
+ 
+static PyMethodDef connection_methods[] = { 
     {"cursor", (PyCFunction)(void(*)(void))pysqlite_connection_cursor, METH_VARARGS|METH_KEYWORDS,
-        PyDoc_STR("Return a cursor for the connection.")},
-    {"close", (PyCFunction)pysqlite_connection_close, METH_NOARGS,
-        PyDoc_STR("Closes the connection.")},
-    {"commit", (PyCFunction)pysqlite_connection_commit, METH_NOARGS,
-        PyDoc_STR("Commit the current transaction.")},
-    {"rollback", (PyCFunction)pysqlite_connection_rollback, METH_NOARGS,
-        PyDoc_STR("Roll back the current transaction.")},
+        PyDoc_STR("Return a cursor for the connection.")}, 
+    {"close", (PyCFunction)pysqlite_connection_close, METH_NOARGS, 
+        PyDoc_STR("Closes the connection.")}, 
+    {"commit", (PyCFunction)pysqlite_connection_commit, METH_NOARGS, 
+        PyDoc_STR("Commit the current transaction.")}, 
+    {"rollback", (PyCFunction)pysqlite_connection_rollback, METH_NOARGS, 
+        PyDoc_STR("Roll back the current transaction.")}, 
     {"create_function", (PyCFunction)(void(*)(void))pysqlite_connection_create_function, METH_VARARGS|METH_KEYWORDS,
-        PyDoc_STR("Creates a new function. Non-standard.")},
+        PyDoc_STR("Creates a new function. Non-standard.")}, 
     {"create_aggregate", (PyCFunction)(void(*)(void))pysqlite_connection_create_aggregate, METH_VARARGS|METH_KEYWORDS,
-        PyDoc_STR("Creates a new aggregate. Non-standard.")},
+        PyDoc_STR("Creates a new aggregate. Non-standard.")}, 
     {"set_authorizer", (PyCFunction)(void(*)(void))pysqlite_connection_set_authorizer, METH_VARARGS|METH_KEYWORDS,
-        PyDoc_STR("Sets authorizer callback. Non-standard.")},
-    #ifdef HAVE_LOAD_EXTENSION
-    {"enable_load_extension", (PyCFunction)pysqlite_enable_load_extension, METH_VARARGS,
-        PyDoc_STR("Enable dynamic loading of SQLite extension modules. Non-standard.")},
-    {"load_extension", (PyCFunction)pysqlite_load_extension, METH_VARARGS,
-        PyDoc_STR("Load SQLite extension module. Non-standard.")},
-    #endif
+        PyDoc_STR("Sets authorizer callback. Non-standard.")}, 
+    #ifdef HAVE_LOAD_EXTENSION 
+    {"enable_load_extension", (PyCFunction)pysqlite_enable_load_extension, METH_VARARGS, 
+        PyDoc_STR("Enable dynamic loading of SQLite extension modules. Non-standard.")}, 
+    {"load_extension", (PyCFunction)pysqlite_load_extension, METH_VARARGS, 
+        PyDoc_STR("Load SQLite extension module. Non-standard.")}, 
+    #endif 
     {"set_progress_handler", (PyCFunction)(void(*)(void))pysqlite_connection_set_progress_handler, METH_VARARGS|METH_KEYWORDS,
-        PyDoc_STR("Sets progress handler callback. Non-standard.")},
+        PyDoc_STR("Sets progress handler callback. Non-standard.")}, 
     {"set_trace_callback", (PyCFunction)(void(*)(void))pysqlite_connection_set_trace_callback, METH_VARARGS|METH_KEYWORDS,
-        PyDoc_STR("Sets a trace callback called for each SQL statement (passed as unicode). Non-standard.")},
-    {"execute", (PyCFunction)pysqlite_connection_execute, METH_VARARGS,
-        PyDoc_STR("Executes a SQL statement. Non-standard.")},
-    {"executemany", (PyCFunction)pysqlite_connection_executemany, METH_VARARGS,
-        PyDoc_STR("Repeatedly executes a SQL statement. Non-standard.")},
-    {"executescript", (PyCFunction)pysqlite_connection_executescript, METH_VARARGS,
-        PyDoc_STR("Executes a multiple SQL statements at once. Non-standard.")},
-    {"create_collation", (PyCFunction)pysqlite_connection_create_collation, METH_VARARGS,
-        PyDoc_STR("Creates a collation function. Non-standard.")},
-    {"interrupt", (PyCFunction)pysqlite_connection_interrupt, METH_NOARGS,
-        PyDoc_STR("Abort any pending database operation. Non-standard.")},
-    {"iterdump", (PyCFunction)pysqlite_connection_iterdump, METH_NOARGS,
-        PyDoc_STR("Returns iterator to the dump of the database in an SQL text format. Non-standard.")},
-    #ifdef HAVE_BACKUP_API
+        PyDoc_STR("Sets a trace callback called for each SQL statement (passed as unicode). Non-standard.")}, 
+    {"execute", (PyCFunction)pysqlite_connection_execute, METH_VARARGS, 
+        PyDoc_STR("Executes a SQL statement. Non-standard.")}, 
+    {"executemany", (PyCFunction)pysqlite_connection_executemany, METH_VARARGS, 
+        PyDoc_STR("Repeatedly executes a SQL statement. Non-standard.")}, 
+    {"executescript", (PyCFunction)pysqlite_connection_executescript, METH_VARARGS, 
+        PyDoc_STR("Executes a multiple SQL statements at once. Non-standard.")}, 
+    {"create_collation", (PyCFunction)pysqlite_connection_create_collation, METH_VARARGS, 
+        PyDoc_STR("Creates a collation function. Non-standard.")}, 
+    {"interrupt", (PyCFunction)pysqlite_connection_interrupt, METH_NOARGS, 
+        PyDoc_STR("Abort any pending database operation. Non-standard.")}, 
+    {"iterdump", (PyCFunction)pysqlite_connection_iterdump, METH_NOARGS, 
+        PyDoc_STR("Returns iterator to the dump of the database in an SQL text format. Non-standard.")}, 
+    #ifdef HAVE_BACKUP_API 
     {"backup", (PyCFunction)(void(*)(void))pysqlite_connection_backup, METH_VARARGS | METH_KEYWORDS,
-        PyDoc_STR("Makes a backup of the database. Non-standard.")},
-    #endif
-    {"__enter__", (PyCFunction)pysqlite_connection_enter, METH_NOARGS,
-        PyDoc_STR("For context manager. Non-standard.")},
-    {"__exit__", (PyCFunction)pysqlite_connection_exit, METH_VARARGS,
-        PyDoc_STR("For context manager. Non-standard.")},
-    {NULL, NULL}
-};
-
-static struct PyMemberDef connection_members[] =
-{
-    {"Warning", T_OBJECT, offsetof(pysqlite_Connection, Warning), READONLY},
-    {"Error", T_OBJECT, offsetof(pysqlite_Connection, Error), READONLY},
-    {"InterfaceError", T_OBJECT, offsetof(pysqlite_Connection, InterfaceError), READONLY},
-    {"DatabaseError", T_OBJECT, offsetof(pysqlite_Connection, DatabaseError), READONLY},
-    {"DataError", T_OBJECT, offsetof(pysqlite_Connection, DataError), READONLY},
-    {"OperationalError", T_OBJECT, offsetof(pysqlite_Connection, OperationalError), READONLY},
-    {"IntegrityError", T_OBJECT, offsetof(pysqlite_Connection, IntegrityError), READONLY},
-    {"InternalError", T_OBJECT, offsetof(pysqlite_Connection, InternalError), READONLY},
-    {"ProgrammingError", T_OBJECT, offsetof(pysqlite_Connection, ProgrammingError), READONLY},
-    {"NotSupportedError", T_OBJECT, offsetof(pysqlite_Connection, NotSupportedError), READONLY},
-    {"row_factory", T_OBJECT, offsetof(pysqlite_Connection, row_factory)},
-    {"text_factory", T_OBJECT, offsetof(pysqlite_Connection, text_factory)},
-    {NULL}
-};
-
-PyTypeObject pysqlite_ConnectionType = {
-        PyVarObject_HEAD_INIT(NULL, 0)
-        MODULE_NAME ".Connection",                      /* tp_name */
-        sizeof(pysqlite_Connection),                    /* tp_basicsize */
-        0,                                              /* tp_itemsize */
-        (destructor)pysqlite_connection_dealloc,        /* tp_dealloc */
+        PyDoc_STR("Makes a backup of the database. Non-standard.")}, 
+    #endif 
+    {"__enter__", (PyCFunction)pysqlite_connection_enter, METH_NOARGS, 
+        PyDoc_STR("For context manager. Non-standard.")}, 
+    {"__exit__", (PyCFunction)pysqlite_connection_exit, METH_VARARGS, 
+        PyDoc_STR("For context manager. Non-standard.")}, 
+    {NULL, NULL} 
+}; 
+ 
+static struct PyMemberDef connection_members[] = 
+{ 
+    {"Warning", T_OBJECT, offsetof(pysqlite_Connection, Warning), READONLY}, 
+    {"Error", T_OBJECT, offsetof(pysqlite_Connection, Error), READONLY}, 
+    {"InterfaceError", T_OBJECT, offsetof(pysqlite_Connection, InterfaceError), READONLY}, 
+    {"DatabaseError", T_OBJECT, offsetof(pysqlite_Connection, DatabaseError), READONLY}, 
+    {"DataError", T_OBJECT, offsetof(pysqlite_Connection, DataError), READONLY}, 
+    {"OperationalError", T_OBJECT, offsetof(pysqlite_Connection, OperationalError), READONLY}, 
+    {"IntegrityError", T_OBJECT, offsetof(pysqlite_Connection, IntegrityError), READONLY}, 
+    {"InternalError", T_OBJECT, offsetof(pysqlite_Connection, InternalError), READONLY}, 
+    {"ProgrammingError", T_OBJECT, offsetof(pysqlite_Connection, ProgrammingError), READONLY}, 
+    {"NotSupportedError", T_OBJECT, offsetof(pysqlite_Connection, NotSupportedError), READONLY}, 
+    {"row_factory", T_OBJECT, offsetof(pysqlite_Connection, row_factory)}, 
+    {"text_factory", T_OBJECT, offsetof(pysqlite_Connection, text_factory)}, 
+    {NULL} 
+}; 
+ 
+PyTypeObject pysqlite_ConnectionType = { 
+        PyVarObject_HEAD_INIT(NULL, 0) 
+        MODULE_NAME ".Connection",                      /* tp_name */ 
+        sizeof(pysqlite_Connection),                    /* tp_basicsize */ 
+        0,                                              /* tp_itemsize */ 
+        (destructor)pysqlite_connection_dealloc,        /* tp_dealloc */ 
         0,                                              /* tp_vectorcall_offset */
-        0,                                              /* tp_getattr */
-        0,                                              /* tp_setattr */
+        0,                                              /* tp_getattr */ 
+        0,                                              /* tp_setattr */ 
         0,                                              /* tp_as_async */
-        0,                                              /* tp_repr */
-        0,                                              /* tp_as_number */
-        0,                                              /* tp_as_sequence */
-        0,                                              /* tp_as_mapping */
-        0,                                              /* tp_hash */
-        (ternaryfunc)pysqlite_connection_call,          /* tp_call */
-        0,                                              /* tp_str */
-        0,                                              /* tp_getattro */
-        0,                                              /* tp_setattro */
-        0,                                              /* tp_as_buffer */
-        Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,         /* tp_flags */
-        connection_doc,                                 /* tp_doc */
-        0,                                              /* tp_traverse */
-        0,                                              /* tp_clear */
-        0,                                              /* tp_richcompare */
-        0,                                              /* tp_weaklistoffset */
-        0,                                              /* tp_iter */
-        0,                                              /* tp_iternext */
-        connection_methods,                             /* tp_methods */
-        connection_members,                             /* tp_members */
-        connection_getset,                              /* tp_getset */
-        0,                                              /* tp_base */
-        0,                                              /* tp_dict */
-        0,                                              /* tp_descr_get */
-        0,                                              /* tp_descr_set */
-        0,                                              /* tp_dictoffset */
-        (initproc)pysqlite_connection_init,             /* tp_init */
-        0,                                              /* tp_alloc */
-        0,                                              /* tp_new */
-        0                                               /* tp_free */
-};
-
-extern int pysqlite_connection_setup_types(void)
-{
-    pysqlite_ConnectionType.tp_new = PyType_GenericNew;
-    return PyType_Ready(&pysqlite_ConnectionType);
-}
+        0,                                              /* tp_repr */ 
+        0,                                              /* tp_as_number */ 
+        0,                                              /* tp_as_sequence */ 
+        0,                                              /* tp_as_mapping */ 
+        0,                                              /* tp_hash */ 
+        (ternaryfunc)pysqlite_connection_call,          /* tp_call */ 
+        0,                                              /* tp_str */ 
+        0,                                              /* tp_getattro */ 
+        0,                                              /* tp_setattro */ 
+        0,                                              /* tp_as_buffer */ 
+        Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,         /* tp_flags */ 
+        connection_doc,                                 /* tp_doc */ 
+        0,                                              /* tp_traverse */ 
+        0,                                              /* tp_clear */ 
+        0,                                              /* tp_richcompare */ 
+        0,                                              /* tp_weaklistoffset */ 
+        0,                                              /* tp_iter */ 
+        0,                                              /* tp_iternext */ 
+        connection_methods,                             /* tp_methods */ 
+        connection_members,                             /* tp_members */ 
+        connection_getset,                              /* tp_getset */ 
+        0,                                              /* tp_base */ 
+        0,                                              /* tp_dict */ 
+        0,                                              /* tp_descr_get */ 
+        0,                                              /* tp_descr_set */ 
+        0,                                              /* tp_dictoffset */ 
+        (initproc)pysqlite_connection_init,             /* tp_init */ 
+        0,                                              /* tp_alloc */ 
+        0,                                              /* tp_new */ 
+        0                                               /* tp_free */ 
+}; 
+ 
+extern int pysqlite_connection_setup_types(void) 
+{ 
+    pysqlite_ConnectionType.tp_new = PyType_GenericNew; 
+    return PyType_Ready(&pysqlite_ConnectionType); 
+} 
diff --git a/contrib/tools/python3/src/Modules/_sqlite/connection.h b/contrib/tools/python3/src/Modules/_sqlite/connection.h
index 206085e00a0..3875fe2aebf 100644
--- a/contrib/tools/python3/src/Modules/_sqlite/connection.h
+++ b/contrib/tools/python3/src/Modules/_sqlite/connection.h
@@ -1,127 +1,127 @@
-/* connection.h - definitions for the connection type
- *
- * Copyright (C) 2004-2010 Gerhard Häring <[email protected]>
- *
- * This file is part of pysqlite.
- *
- * This software is provided 'as-is', without any express or implied
- * warranty.  In no event will the authors be held liable for any damages
- * arising from the use of this software.
- *
- * Permission is granted to anyone to use this software for any purpose,
- * including commercial applications, and to alter it and redistribute it
- * freely, subject to the following restrictions:
- *
- * 1. The origin of this software must not be misrepresented; you must not
- *    claim that you wrote the original software. If you use this software
- *    in a product, an acknowledgment in the product documentation would be
- *    appreciated but is not required.
- * 2. Altered source versions must be plainly marked as such, and must not be
- *    misrepresented as being the original software.
- * 3. This notice may not be removed or altered from any source distribution.
- */
-
-#ifndef PYSQLITE_CONNECTION_H
-#define PYSQLITE_CONNECTION_H
+/* connection.h - definitions for the connection type 
+ * 
+ * Copyright (C) 2004-2010 Gerhard Häring <[email protected]> 
+ * 
+ * This file is part of pysqlite. 
+ * 
+ * This software is provided 'as-is', without any express or implied 
+ * warranty.  In no event will the authors be held liable for any damages 
+ * arising from the use of this software. 
+ * 
+ * Permission is granted to anyone to use this software for any purpose, 
+ * including commercial applications, and to alter it and redistribute it 
+ * freely, subject to the following restrictions: 
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not 
+ *    claim that you wrote the original software. If you use this software 
+ *    in a product, an acknowledgment in the product documentation would be 
+ *    appreciated but is not required. 
+ * 2. Altered source versions must be plainly marked as such, and must not be 
+ *    misrepresented as being the original software. 
+ * 3. This notice may not be removed or altered from any source distribution. 
+ */ 
+ 
+#ifndef PYSQLITE_CONNECTION_H 
+#define PYSQLITE_CONNECTION_H 
 #define PY_SSIZE_T_CLEAN
-#include "Python.h"
-#include "pythread.h"
-#include "structmember.h"
-
-#include "cache.h"
-#include "module.h"
-
-#include "sqlite3.h"
-
-typedef struct
-{
-    PyObject_HEAD
-    sqlite3* db;
-
-    /* the type detection mode. Only 0, PARSE_DECLTYPES, PARSE_COLNAMES or a
-     * bitwise combination thereof makes sense */
-    int detect_types;
-
-    /* the timeout value in seconds for database locks */
-    double timeout;
-
-    /* for internal use in the timeout handler: when did the timeout handler
-     * first get called with count=0? */
-    double timeout_started;
-
-    /* None for autocommit, otherwise a PyUnicode with the isolation level */
-    PyObject* isolation_level;
-
-    /* NULL for autocommit, otherwise a string with the BEGIN statement */
-    const char* begin_statement;
-
-    /* 1 if a check should be performed for each API call if the connection is
-     * used from the same thread it was created in */
-    int check_same_thread;
-
-    int initialized;
-
-    /* thread identification of the thread the connection was created in */
-    unsigned long thread_ident;
-
-    pysqlite_Cache* statement_cache;
-
-    /* Lists of weak references to statements and cursors used within this connection */
-    PyObject* statements;
-    PyObject* cursors;
-
-    /* Counters for how many statements/cursors were created in the connection. May be
-     * reset to 0 at certain intervals */
-    int created_statements;
-    int created_cursors;
-
-    PyObject* row_factory;
-
-    /* Determines how bytestrings from SQLite are converted to Python objects:
-     * - PyUnicode_Type:        Python Unicode objects are constructed from UTF-8 bytestrings
-     * - PyBytes_Type:          The bytestrings are returned as-is.
-     * - Any custom callable:   Any object returned from the callable called with the bytestring
-     *                          as single parameter.
-     */
-    PyObject* text_factory;
-
+#include "Python.h" 
+#include "pythread.h" 
+#include "structmember.h" 
+ 
+#include "cache.h" 
+#include "module.h" 
+ 
+#include "sqlite3.h" 
+ 
+typedef struct 
+{ 
+    PyObject_HEAD 
+    sqlite3* db; 
+ 
+    /* the type detection mode. Only 0, PARSE_DECLTYPES, PARSE_COLNAMES or a 
+     * bitwise combination thereof makes sense */ 
+    int detect_types; 
+ 
+    /* the timeout value in seconds for database locks */ 
+    double timeout; 
+ 
+    /* for internal use in the timeout handler: when did the timeout handler 
+     * first get called with count=0? */ 
+    double timeout_started; 
+ 
+    /* None for autocommit, otherwise a PyUnicode with the isolation level */ 
+    PyObject* isolation_level; 
+ 
+    /* NULL for autocommit, otherwise a string with the BEGIN statement */ 
+    const char* begin_statement; 
+ 
+    /* 1 if a check should be performed for each API call if the connection is 
+     * used from the same thread it was created in */ 
+    int check_same_thread; 
+ 
+    int initialized; 
+ 
+    /* thread identification of the thread the connection was created in */ 
+    unsigned long thread_ident; 
+ 
+    pysqlite_Cache* statement_cache; 
+ 
+    /* Lists of weak references to statements and cursors used within this connection */ 
+    PyObject* statements; 
+    PyObject* cursors; 
+ 
+    /* Counters for how many statements/cursors were created in the connection. May be 
+     * reset to 0 at certain intervals */ 
+    int created_statements; 
+    int created_cursors; 
+ 
+    PyObject* row_factory; 
+ 
+    /* Determines how bytestrings from SQLite are converted to Python objects: 
+     * - PyUnicode_Type:        Python Unicode objects are constructed from UTF-8 bytestrings 
+     * - PyBytes_Type:          The bytestrings are returned as-is. 
+     * - Any custom callable:   Any object returned from the callable called with the bytestring 
+     *                          as single parameter. 
+     */ 
+    PyObject* text_factory; 
+ 
     /* remember references to object used in trace_callback/progress_handler/authorizer_cb */
     PyObject* function_pinboard_trace_callback;
     PyObject* function_pinboard_progress_handler;
     PyObject* function_pinboard_authorizer_cb;
-
-    /* a dictionary of registered collation name => collation callable mappings */
-    PyObject* collations;
-
-    /* Exception objects */
-    PyObject* Warning;
-    PyObject* Error;
-    PyObject* InterfaceError;
-    PyObject* DatabaseError;
-    PyObject* DataError;
-    PyObject* OperationalError;
-    PyObject* IntegrityError;
-    PyObject* InternalError;
-    PyObject* ProgrammingError;
-    PyObject* NotSupportedError;
-} pysqlite_Connection;
-
-extern PyTypeObject pysqlite_ConnectionType;
-
-PyObject* pysqlite_connection_alloc(PyTypeObject* type, int aware);
-void pysqlite_connection_dealloc(pysqlite_Connection* self);
-PyObject* pysqlite_connection_cursor(pysqlite_Connection* self, PyObject* args, PyObject* kwargs);
-PyObject* pysqlite_connection_close(pysqlite_Connection* self, PyObject* args);
-PyObject* _pysqlite_connection_begin(pysqlite_Connection* self);
-PyObject* pysqlite_connection_commit(pysqlite_Connection* self, PyObject* args);
-PyObject* pysqlite_connection_rollback(pysqlite_Connection* self, PyObject* args);
-PyObject* pysqlite_connection_new(PyTypeObject* type, PyObject* args, PyObject* kw);
-int pysqlite_connection_init(pysqlite_Connection* self, PyObject* args, PyObject* kwargs);
-
-int pysqlite_connection_register_cursor(pysqlite_Connection* connection, PyObject* cursor);
-int pysqlite_check_thread(pysqlite_Connection* self);
-int pysqlite_check_connection(pysqlite_Connection* con);
-
-int pysqlite_connection_setup_types(void);
-
-#endif
+ 
+    /* a dictionary of registered collation name => collation callable mappings */ 
+    PyObject* collations; 
+ 
+    /* Exception objects */ 
+    PyObject* Warning; 
+    PyObject* Error; 
+    PyObject* InterfaceError; 
+    PyObject* DatabaseError; 
+    PyObject* DataError; 
+    PyObject* OperationalError; 
+    PyObject* IntegrityError; 
+    PyObject* InternalError; 
+    PyObject* ProgrammingError; 
+    PyObject* NotSupportedError; 
+} pysqlite_Connection; 
+ 
+extern PyTypeObject pysqlite_ConnectionType; 
+ 
+PyObject* pysqlite_connection_alloc(PyTypeObject* type, int aware); 
+void pysqlite_connection_dealloc(pysqlite_Connection* self); 
+PyObject* pysqlite_connection_cursor(pysqlite_Connection* self, PyObject* args, PyObject* kwargs); 
+PyObject* pysqlite_connection_close(pysqlite_Connection* self, PyObject* args); 
+PyObject* _pysqlite_connection_begin(pysqlite_Connection* self); 
+PyObject* pysqlite_connection_commit(pysqlite_Connection* self, PyObject* args); 
+PyObject* pysqlite_connection_rollback(pysqlite_Connection* self, PyObject* args); 
+PyObject* pysqlite_connection_new(PyTypeObject* type, PyObject* args, PyObject* kw); 
+int pysqlite_connection_init(pysqlite_Connection* self, PyObject* args, PyObject* kwargs); 
+ 
+int pysqlite_connection_register_cursor(pysqlite_Connection* connection, PyObject* cursor); 
+int pysqlite_check_thread(pysqlite_Connection* self); 
+int pysqlite_check_connection(pysqlite_Connection* con); 
+ 
+int pysqlite_connection_setup_types(void); 
+ 
+#endif 
diff --git a/contrib/tools/python3/src/Modules/_sqlite/cursor.c b/contrib/tools/python3/src/Modules/_sqlite/cursor.c
index dd0ce7e1ea6..1884694373e 100644
--- a/contrib/tools/python3/src/Modules/_sqlite/cursor.c
+++ b/contrib/tools/python3/src/Modules/_sqlite/cursor.c
@@ -1,207 +1,207 @@
-/* cursor.c - the cursor type
- *
- * Copyright (C) 2004-2010 Gerhard Häring <[email protected]>
- *
- * This file is part of pysqlite.
- *
- * This software is provided 'as-is', without any express or implied
- * warranty.  In no event will the authors be held liable for any damages
- * arising from the use of this software.
- *
- * Permission is granted to anyone to use this software for any purpose,
- * including commercial applications, and to alter it and redistribute it
- * freely, subject to the following restrictions:
- *
- * 1. The origin of this software must not be misrepresented; you must not
- *    claim that you wrote the original software. If you use this software
- *    in a product, an acknowledgment in the product documentation would be
- *    appreciated but is not required.
- * 2. Altered source versions must be plainly marked as such, and must not be
- *    misrepresented as being the original software.
- * 3. This notice may not be removed or altered from any source distribution.
- */
-
-#include "cursor.h"
-#include "module.h"
-#include "util.h"
-
-PyObject* pysqlite_cursor_iternext(pysqlite_Cursor* self);
-
-static const char errmsg_fetch_across_rollback[] = "Cursor needed to be reset because of commit/rollback and can no longer be fetched from.";
-
-static int pysqlite_cursor_init(pysqlite_Cursor* self, PyObject* args, PyObject* kwargs)
-{
-    pysqlite_Connection* connection;
-
-    if (!PyArg_ParseTuple(args, "O!", &pysqlite_ConnectionType, &connection))
-    {
-        return -1;
-    }
-
-    Py_INCREF(connection);
-    Py_XSETREF(self->connection, connection);
-    Py_CLEAR(self->statement);
-    Py_CLEAR(self->next_row);
+/* cursor.c - the cursor type 
+ * 
+ * Copyright (C) 2004-2010 Gerhard Häring <[email protected]> 
+ * 
+ * This file is part of pysqlite. 
+ * 
+ * This software is provided 'as-is', without any express or implied 
+ * warranty.  In no event will the authors be held liable for any damages 
+ * arising from the use of this software. 
+ * 
+ * Permission is granted to anyone to use this software for any purpose, 
+ * including commercial applications, and to alter it and redistribute it 
+ * freely, subject to the following restrictions: 
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not 
+ *    claim that you wrote the original software. If you use this software 
+ *    in a product, an acknowledgment in the product documentation would be 
+ *    appreciated but is not required. 
+ * 2. Altered source versions must be plainly marked as such, and must not be 
+ *    misrepresented as being the original software. 
+ * 3. This notice may not be removed or altered from any source distribution. 
+ */ 
+ 
+#include "cursor.h" 
+#include "module.h" 
+#include "util.h" 
+ 
+PyObject* pysqlite_cursor_iternext(pysqlite_Cursor* self); 
+ 
+static const char errmsg_fetch_across_rollback[] = "Cursor needed to be reset because of commit/rollback and can no longer be fetched from."; 
+ 
+static int pysqlite_cursor_init(pysqlite_Cursor* self, PyObject* args, PyObject* kwargs) 
+{ 
+    pysqlite_Connection* connection; 
+ 
+    if (!PyArg_ParseTuple(args, "O!", &pysqlite_ConnectionType, &connection)) 
+    { 
+        return -1; 
+    } 
+ 
+    Py_INCREF(connection); 
+    Py_XSETREF(self->connection, connection); 
+    Py_CLEAR(self->statement); 
+    Py_CLEAR(self->next_row); 
     Py_CLEAR(self->row_cast_map);
-
-    Py_INCREF(Py_None);
-    Py_XSETREF(self->description, Py_None);
-
-    Py_INCREF(Py_None);
-    Py_XSETREF(self->lastrowid, Py_None);
-
-    self->arraysize = 1;
-    self->closed = 0;
-    self->reset = 0;
-
-    self->rowcount = -1L;
-
-    Py_INCREF(Py_None);
-    Py_XSETREF(self->row_factory, Py_None);
-
-    if (!pysqlite_check_thread(self->connection)) {
-        return -1;
-    }
-
-    if (!pysqlite_connection_register_cursor(connection, (PyObject*)self)) {
-        return -1;
-    }
-
-    self->initialized = 1;
-
-    return 0;
-}
-
-static void pysqlite_cursor_dealloc(pysqlite_Cursor* self)
-{
-    /* Reset the statement if the user has not closed the cursor */
-    if (self->statement) {
-        pysqlite_statement_reset(self->statement);
-        Py_DECREF(self->statement);
-    }
-
-    Py_XDECREF(self->connection);
-    Py_XDECREF(self->row_cast_map);
-    Py_XDECREF(self->description);
-    Py_XDECREF(self->lastrowid);
-    Py_XDECREF(self->row_factory);
-    Py_XDECREF(self->next_row);
-
-    if (self->in_weakreflist != NULL) {
-        PyObject_ClearWeakRefs((PyObject*)self);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
+ 
+    Py_INCREF(Py_None); 
+    Py_XSETREF(self->description, Py_None); 
+ 
+    Py_INCREF(Py_None); 
+    Py_XSETREF(self->lastrowid, Py_None); 
+ 
+    self->arraysize = 1; 
+    self->closed = 0; 
+    self->reset = 0; 
+ 
+    self->rowcount = -1L; 
+ 
+    Py_INCREF(Py_None); 
+    Py_XSETREF(self->row_factory, Py_None); 
+ 
+    if (!pysqlite_check_thread(self->connection)) { 
+        return -1; 
+    } 
+ 
+    if (!pysqlite_connection_register_cursor(connection, (PyObject*)self)) { 
+        return -1; 
+    } 
+ 
+    self->initialized = 1; 
+ 
+    return 0; 
+} 
+ 
+static void pysqlite_cursor_dealloc(pysqlite_Cursor* self) 
+{ 
+    /* Reset the statement if the user has not closed the cursor */ 
+    if (self->statement) { 
+        pysqlite_statement_reset(self->statement); 
+        Py_DECREF(self->statement); 
+    } 
+ 
+    Py_XDECREF(self->connection); 
+    Py_XDECREF(self->row_cast_map); 
+    Py_XDECREF(self->description); 
+    Py_XDECREF(self->lastrowid); 
+    Py_XDECREF(self->row_factory); 
+    Py_XDECREF(self->next_row); 
+ 
+    if (self->in_weakreflist != NULL) { 
+        PyObject_ClearWeakRefs((PyObject*)self); 
+    } 
+ 
+    Py_TYPE(self)->tp_free((PyObject*)self); 
+} 
+ 
 static PyObject *
 _pysqlite_get_converter(const char *keystr, Py_ssize_t keylen)
-{
+{ 
     PyObject *key;
     PyObject *upcase_key;
     PyObject *retval;
-    _Py_IDENTIFIER(upper);
-
+    _Py_IDENTIFIER(upper); 
+ 
     key = PyUnicode_FromStringAndSize(keystr, keylen);
     if (!key) {
         return NULL;
     }
     upcase_key = _PyObject_CallMethodIdNoArgs(key, &PyId_upper);
     Py_DECREF(key);
-    if (!upcase_key) {
-        return NULL;
-    }
-
+    if (!upcase_key) { 
+        return NULL; 
+    } 
+ 
     retval = PyDict_GetItemWithError(_pysqlite_converters, upcase_key);
-    Py_DECREF(upcase_key);
-
-    return retval;
-}
-
+    Py_DECREF(upcase_key); 
+ 
+    return retval; 
+} 
+ 
 static int
 pysqlite_build_row_cast_map(pysqlite_Cursor* self)
-{
-    int i;
-    const char* pos;
-    const char* colname;
-    const char* decltype;
-    PyObject* converter;
-
-    if (!self->connection->detect_types) {
-        return 0;
-    }
-
-    Py_XSETREF(self->row_cast_map, PyList_New(0));
+{ 
+    int i; 
+    const char* pos; 
+    const char* colname; 
+    const char* decltype; 
+    PyObject* converter; 
+ 
+    if (!self->connection->detect_types) { 
+        return 0; 
+    } 
+ 
+    Py_XSETREF(self->row_cast_map, PyList_New(0)); 
     if (!self->row_cast_map) {
         return -1;
     }
-
-    for (i = 0; i < sqlite3_column_count(self->statement->st); i++) {
-        converter = NULL;
-
-        if (self->connection->detect_types & PARSE_COLNAMES) {
-            colname = sqlite3_column_name(self->statement->st, i);
-            if (colname) {
+ 
+    for (i = 0; i < sqlite3_column_count(self->statement->st); i++) { 
+        converter = NULL; 
+ 
+        if (self->connection->detect_types & PARSE_COLNAMES) { 
+            colname = sqlite3_column_name(self->statement->st, i); 
+            if (colname) { 
                 const char *type_start = NULL;
-                for (pos = colname; *pos != 0; pos++) {
-                    if (*pos == '[') {
-                        type_start = pos + 1;
+                for (pos = colname; *pos != 0; pos++) { 
+                    if (*pos == '[') { 
+                        type_start = pos + 1; 
                     }
                     else if (*pos == ']' && type_start != NULL) {
                         converter = _pysqlite_get_converter(type_start, pos - type_start);
                         if (!converter && PyErr_Occurred()) {
                             Py_CLEAR(self->row_cast_map);
                             return -1;
-                        }
-                        break;
-                    }
-                }
-            }
-        }
-
-        if (!converter && self->connection->detect_types & PARSE_DECLTYPES) {
-            decltype = sqlite3_column_decltype(self->statement->st, i);
-            if (decltype) {
-                for (pos = decltype;;pos++) {
-                    /* Converter names are split at '(' and blanks.
-                     * This allows 'INTEGER NOT NULL' to be treated as 'INTEGER' and
-                     * 'NUMBER(10)' to be treated as 'NUMBER', for example.
-                     * In other words, it will work as people expect it to work.*/
-                    if (*pos == ' ' || *pos == '(' || *pos == 0) {
+                        } 
+                        break; 
+                    } 
+                } 
+            } 
+        } 
+ 
+        if (!converter && self->connection->detect_types & PARSE_DECLTYPES) { 
+            decltype = sqlite3_column_decltype(self->statement->st, i); 
+            if (decltype) { 
+                for (pos = decltype;;pos++) { 
+                    /* Converter names are split at '(' and blanks. 
+                     * This allows 'INTEGER NOT NULL' to be treated as 'INTEGER' and 
+                     * 'NUMBER(10)' to be treated as 'NUMBER', for example. 
+                     * In other words, it will work as people expect it to work.*/ 
+                    if (*pos == ' ' || *pos == '(' || *pos == 0) { 
                         converter = _pysqlite_get_converter(decltype, pos - decltype);
                         if (!converter && PyErr_Occurred()) {
                             Py_CLEAR(self->row_cast_map);
-                            return -1;
-                        }
-                        break;
-                    }
-                }
-            }
-        }
-
-        if (!converter) {
-            converter = Py_None;
-        }
-
-        if (PyList_Append(self->row_cast_map, converter) != 0) {
-            Py_CLEAR(self->row_cast_map);
-            return -1;
-        }
-    }
-
-    return 0;
-}
-
+                            return -1; 
+                        } 
+                        break; 
+                    } 
+                } 
+            } 
+        } 
+ 
+        if (!converter) { 
+            converter = Py_None; 
+        } 
+ 
+        if (PyList_Append(self->row_cast_map, converter) != 0) { 
+            Py_CLEAR(self->row_cast_map); 
+            return -1; 
+        } 
+    } 
+ 
+    return 0; 
+} 
+ 
 static PyObject *
 _pysqlite_build_column_name(pysqlite_Cursor *self, const char *colname)
-{
-    const char* pos;
+{ 
+    const char* pos; 
     Py_ssize_t len;
-
-    if (!colname) {
-        Py_RETURN_NONE;
-    }
-
+ 
+    if (!colname) { 
+        Py_RETURN_NONE; 
+    } 
+ 
     if (self->connection->detect_types & PARSE_COLNAMES) {
         for (pos = colname; *pos; pos++) {
             if (*pos == '[') {
@@ -209,51 +209,51 @@ _pysqlite_build_column_name(pysqlite_Cursor *self, const char *colname)
                     pos--;
                 }
                 break;
-            }
-        }
+            } 
+        } 
         len = pos - colname;
-    }
+    } 
     else {
         len = strlen(colname);
     }
     return PyUnicode_FromStringAndSize(colname, len);
-}
-
-/*
- * Returns a row from the currently active SQLite statement
- *
- * Precondidition:
- * - sqlite3_step() has been called before and it returned SQLITE_ROW.
- */
+} 
+ 
+/* 
+ * Returns a row from the currently active SQLite statement 
+ * 
+ * Precondidition: 
+ * - sqlite3_step() has been called before and it returned SQLITE_ROW. 
+ */ 
 static PyObject *
 _pysqlite_fetch_one_row(pysqlite_Cursor* self)
-{
-    int i, numcols;
-    PyObject* row;
-    PyObject* item = NULL;
-    int coltype;
-    PyObject* converter;
-    PyObject* converted;
-    Py_ssize_t nbytes;
-    const char* val_str;
-    char buf[200];
-    const char* colname;
+{ 
+    int i, numcols; 
+    PyObject* row; 
+    PyObject* item = NULL; 
+    int coltype; 
+    PyObject* converter; 
+    PyObject* converted; 
+    Py_ssize_t nbytes; 
+    const char* val_str; 
+    char buf[200]; 
+    const char* colname; 
     PyObject* error_msg;
-
-    if (self->reset) {
-        PyErr_SetString(pysqlite_InterfaceError, errmsg_fetch_across_rollback);
-        return NULL;
-    }
-
-    Py_BEGIN_ALLOW_THREADS
-    numcols = sqlite3_data_count(self->statement->st);
-    Py_END_ALLOW_THREADS
-
-    row = PyTuple_New(numcols);
-    if (!row)
-        return NULL;
-
-    for (i = 0; i < numcols; i++) {
+ 
+    if (self->reset) { 
+        PyErr_SetString(pysqlite_InterfaceError, errmsg_fetch_across_rollback); 
+        return NULL; 
+    } 
+ 
+    Py_BEGIN_ALLOW_THREADS 
+    numcols = sqlite3_data_count(self->statement->st); 
+    Py_END_ALLOW_THREADS 
+ 
+    row = PyTuple_New(numcols); 
+    if (!row) 
+        return NULL; 
+ 
+    for (i = 0; i < numcols; i++) { 
         if (self->connection->detect_types
                 && self->row_cast_map != NULL
                 && i < PyList_GET_SIZE(self->row_cast_map))
@@ -261,290 +261,290 @@ _pysqlite_fetch_one_row(pysqlite_Cursor* self)
             converter = PyList_GET_ITEM(self->row_cast_map, i);
         }
         else {
-            converter = Py_None;
-        }
-
-        if (converter != Py_None) {
-            nbytes = sqlite3_column_bytes(self->statement->st, i);
-            val_str = (const char*)sqlite3_column_blob(self->statement->st, i);
-            if (!val_str) {
-                Py_INCREF(Py_None);
-                converted = Py_None;
-            } else {
-                item = PyBytes_FromStringAndSize(val_str, nbytes);
-                if (!item)
-                    goto error;
+            converter = Py_None; 
+        } 
+ 
+        if (converter != Py_None) { 
+            nbytes = sqlite3_column_bytes(self->statement->st, i); 
+            val_str = (const char*)sqlite3_column_blob(self->statement->st, i); 
+            if (!val_str) { 
+                Py_INCREF(Py_None); 
+                converted = Py_None; 
+            } else { 
+                item = PyBytes_FromStringAndSize(val_str, nbytes); 
+                if (!item) 
+                    goto error; 
                 converted = PyObject_CallOneArg(converter, item);
-                Py_DECREF(item);
-            }
-        } else {
-            Py_BEGIN_ALLOW_THREADS
-            coltype = sqlite3_column_type(self->statement->st, i);
-            Py_END_ALLOW_THREADS
-            if (coltype == SQLITE_NULL) {
-                Py_INCREF(Py_None);
-                converted = Py_None;
-            } else if (coltype == SQLITE_INTEGER) {
+                Py_DECREF(item); 
+            } 
+        } else { 
+            Py_BEGIN_ALLOW_THREADS 
+            coltype = sqlite3_column_type(self->statement->st, i); 
+            Py_END_ALLOW_THREADS 
+            if (coltype == SQLITE_NULL) { 
+                Py_INCREF(Py_None); 
+                converted = Py_None; 
+            } else if (coltype == SQLITE_INTEGER) { 
                 converted = PyLong_FromLongLong(sqlite3_column_int64(self->statement->st, i));
-            } else if (coltype == SQLITE_FLOAT) {
-                converted = PyFloat_FromDouble(sqlite3_column_double(self->statement->st, i));
-            } else if (coltype == SQLITE_TEXT) {
-                val_str = (const char*)sqlite3_column_text(self->statement->st, i);
-                nbytes = sqlite3_column_bytes(self->statement->st, i);
-                if (self->connection->text_factory == (PyObject*)&PyUnicode_Type) {
-                    converted = PyUnicode_FromStringAndSize(val_str, nbytes);
+            } else if (coltype == SQLITE_FLOAT) { 
+                converted = PyFloat_FromDouble(sqlite3_column_double(self->statement->st, i)); 
+            } else if (coltype == SQLITE_TEXT) { 
+                val_str = (const char*)sqlite3_column_text(self->statement->st, i); 
+                nbytes = sqlite3_column_bytes(self->statement->st, i); 
+                if (self->connection->text_factory == (PyObject*)&PyUnicode_Type) { 
+                    converted = PyUnicode_FromStringAndSize(val_str, nbytes); 
                     if (!converted && PyErr_ExceptionMatches(PyExc_UnicodeDecodeError)) {
-                        PyErr_Clear();
-                        colname = sqlite3_column_name(self->statement->st, i);
-                        if (!colname) {
-                            colname = "<unknown column name>";
-                        }
-                        PyOS_snprintf(buf, sizeof(buf) - 1, "Could not decode to UTF-8 column '%s' with text '%s'",
-                                     colname , val_str);
+                        PyErr_Clear(); 
+                        colname = sqlite3_column_name(self->statement->st, i); 
+                        if (!colname) { 
+                            colname = "<unknown column name>"; 
+                        } 
+                        PyOS_snprintf(buf, sizeof(buf) - 1, "Could not decode to UTF-8 column '%s' with text '%s'", 
+                                     colname , val_str); 
                         error_msg = PyUnicode_Decode(buf, strlen(buf), "ascii", "replace");
                         if (!error_msg) {
-                            PyErr_SetString(pysqlite_OperationalError, "Could not decode to UTF-8");
-                        } else {
+                            PyErr_SetString(pysqlite_OperationalError, "Could not decode to UTF-8"); 
+                        } else { 
                             PyErr_SetObject(pysqlite_OperationalError, error_msg);
                             Py_DECREF(error_msg);
-                        }
-                    }
-                } else if (self->connection->text_factory == (PyObject*)&PyBytes_Type) {
-                    converted = PyBytes_FromStringAndSize(val_str, nbytes);
-                } else if (self->connection->text_factory == (PyObject*)&PyByteArray_Type) {
-                    converted = PyByteArray_FromStringAndSize(val_str, nbytes);
-                } else {
-                    converted = PyObject_CallFunction(self->connection->text_factory, "y#", val_str, nbytes);
-                }
-            } else {
-                /* coltype == SQLITE_BLOB */
-                nbytes = sqlite3_column_bytes(self->statement->st, i);
+                        } 
+                    } 
+                } else if (self->connection->text_factory == (PyObject*)&PyBytes_Type) { 
+                    converted = PyBytes_FromStringAndSize(val_str, nbytes); 
+                } else if (self->connection->text_factory == (PyObject*)&PyByteArray_Type) { 
+                    converted = PyByteArray_FromStringAndSize(val_str, nbytes); 
+                } else { 
+                    converted = PyObject_CallFunction(self->connection->text_factory, "y#", val_str, nbytes); 
+                } 
+            } else { 
+                /* coltype == SQLITE_BLOB */ 
+                nbytes = sqlite3_column_bytes(self->statement->st, i); 
                 converted = PyBytes_FromStringAndSize(
-                    sqlite3_column_blob(self->statement->st, i), nbytes);
-            }
-        }
-
+                    sqlite3_column_blob(self->statement->st, i), nbytes); 
+            } 
+        } 
+ 
         if (!converted) {
             goto error;
-        }
+        } 
         PyTuple_SetItem(row, i, converted);
-    }
-
-    if (PyErr_Occurred())
-        goto error;
-
-    return row;
-
-error:
-    Py_DECREF(row);
-    return NULL;
-}
-
-/*
- * Checks if a cursor object is usable.
- *
- * 0 => error; 1 => ok
- */
-static int check_cursor(pysqlite_Cursor* cur)
-{
-    if (!cur->initialized) {
-        PyErr_SetString(pysqlite_ProgrammingError, "Base Cursor.__init__ not called.");
-        return 0;
-    }
-
-    if (cur->closed) {
-        PyErr_SetString(pysqlite_ProgrammingError, "Cannot operate on a closed cursor.");
-        return 0;
-    }
-
-    if (cur->locked) {
-        PyErr_SetString(pysqlite_ProgrammingError, "Recursive use of cursors not allowed.");
-        return 0;
-    }
-
-    return pysqlite_check_thread(cur->connection) && pysqlite_check_connection(cur->connection);
-}
-
+    } 
+ 
+    if (PyErr_Occurred()) 
+        goto error; 
+ 
+    return row; 
+ 
+error: 
+    Py_DECREF(row); 
+    return NULL; 
+} 
+ 
+/* 
+ * Checks if a cursor object is usable. 
+ * 
+ * 0 => error; 1 => ok 
+ */ 
+static int check_cursor(pysqlite_Cursor* cur) 
+{ 
+    if (!cur->initialized) { 
+        PyErr_SetString(pysqlite_ProgrammingError, "Base Cursor.__init__ not called."); 
+        return 0; 
+    } 
+ 
+    if (cur->closed) { 
+        PyErr_SetString(pysqlite_ProgrammingError, "Cannot operate on a closed cursor."); 
+        return 0; 
+    } 
+ 
+    if (cur->locked) { 
+        PyErr_SetString(pysqlite_ProgrammingError, "Recursive use of cursors not allowed."); 
+        return 0; 
+    } 
+ 
+    return pysqlite_check_thread(cur->connection) && pysqlite_check_connection(cur->connection); 
+} 
+ 
 static PyObject *
 _pysqlite_query_execute(pysqlite_Cursor* self, int multiple, PyObject* args)
-{
-    PyObject* operation;
-    PyObject* parameters_list = NULL;
-    PyObject* parameters_iter = NULL;
-    PyObject* parameters = NULL;
-    int i;
-    int rc;
-    PyObject* func_args;
-    PyObject* result;
-    int numcols;
-    PyObject* descriptor;
+{ 
+    PyObject* operation; 
+    PyObject* parameters_list = NULL; 
+    PyObject* parameters_iter = NULL; 
+    PyObject* parameters = NULL; 
+    int i; 
+    int rc; 
+    PyObject* func_args; 
+    PyObject* result; 
+    int numcols; 
+    PyObject* descriptor; 
     PyObject* column_name;
-    PyObject* second_argument = NULL;
-    sqlite_int64 lastrowid;
-
-    if (!check_cursor(self)) {
-        goto error;
-    }
-
-    self->locked = 1;
-    self->reset = 0;
-
-    Py_CLEAR(self->next_row);
-
-    if (multiple) {
-        /* executemany() */
+    PyObject* second_argument = NULL; 
+    sqlite_int64 lastrowid; 
+ 
+    if (!check_cursor(self)) { 
+        goto error; 
+    } 
+ 
+    self->locked = 1; 
+    self->reset = 0; 
+ 
+    Py_CLEAR(self->next_row); 
+ 
+    if (multiple) { 
+        /* executemany() */ 
         if (!PyArg_ParseTuple(args, "UO", &operation, &second_argument)) {
-            goto error;
-        }
-
-        if (PyIter_Check(second_argument)) {
-            /* iterator */
-            Py_INCREF(second_argument);
-            parameters_iter = second_argument;
-        } else {
-            /* sequence */
-            parameters_iter = PyObject_GetIter(second_argument);
-            if (!parameters_iter) {
-                goto error;
-            }
-        }
-    } else {
-        /* execute() */
+            goto error; 
+        } 
+ 
+        if (PyIter_Check(second_argument)) { 
+            /* iterator */ 
+            Py_INCREF(second_argument); 
+            parameters_iter = second_argument; 
+        } else { 
+            /* sequence */ 
+            parameters_iter = PyObject_GetIter(second_argument); 
+            if (!parameters_iter) { 
+                goto error; 
+            } 
+        } 
+    } else { 
+        /* execute() */ 
         if (!PyArg_ParseTuple(args, "U|O", &operation, &second_argument)) {
-            goto error;
-        }
-
-        parameters_list = PyList_New(0);
-        if (!parameters_list) {
-            goto error;
-        }
-
-        if (second_argument == NULL) {
-            second_argument = PyTuple_New(0);
-            if (!second_argument) {
-                goto error;
-            }
-        } else {
-            Py_INCREF(second_argument);
-        }
-        if (PyList_Append(parameters_list, second_argument) != 0) {
-            Py_DECREF(second_argument);
-            goto error;
-        }
-        Py_DECREF(second_argument);
-
-        parameters_iter = PyObject_GetIter(parameters_list);
-        if (!parameters_iter) {
-            goto error;
-        }
-    }
-
-    if (self->statement != NULL) {
-        /* There is an active statement */
-        pysqlite_statement_reset(self->statement);
-    }
-
-    /* reset description and rowcount */
-    Py_INCREF(Py_None);
-    Py_SETREF(self->description, Py_None);
-    self->rowcount = 0L;
-
-    func_args = PyTuple_New(1);
-    if (!func_args) {
-        goto error;
-    }
-    Py_INCREF(operation);
-    if (PyTuple_SetItem(func_args, 0, operation) != 0) {
-        goto error;
-    }
-
-    if (self->statement) {
-        (void)pysqlite_statement_reset(self->statement);
-    }
-
-    Py_XSETREF(self->statement,
-              (pysqlite_Statement *)pysqlite_cache_get(self->connection->statement_cache, func_args));
-    Py_DECREF(func_args);
-
-    if (!self->statement) {
-        goto error;
-    }
-
-    if (self->statement->in_use) {
-        Py_SETREF(self->statement,
-                  PyObject_New(pysqlite_Statement, &pysqlite_StatementType));
-        if (!self->statement) {
-            goto error;
-        }
-        rc = pysqlite_statement_create(self->statement, self->connection, operation);
-        if (rc != SQLITE_OK) {
-            Py_CLEAR(self->statement);
-            goto error;
-        }
-    }
-
-    pysqlite_statement_reset(self->statement);
-    pysqlite_statement_mark_dirty(self->statement);
-
-    /* We start a transaction implicitly before a DML statement.
-       SELECT is the only exception. See #9924. */
-    if (self->connection->begin_statement && self->statement->is_dml) {
-        if (sqlite3_get_autocommit(self->connection->db)) {
-            result = _pysqlite_connection_begin(self->connection);
-            if (!result) {
-                goto error;
-            }
-            Py_DECREF(result);
-        }
-    }
-
-    while (1) {
-        parameters = PyIter_Next(parameters_iter);
-        if (!parameters) {
-            break;
-        }
-
-        pysqlite_statement_mark_dirty(self->statement);
-
-        pysqlite_statement_bind_parameters(self->statement, parameters);
-        if (PyErr_Occurred()) {
-            goto error;
-        }
-
-        rc = pysqlite_step(self->statement->st, self->connection);
-        if (rc != SQLITE_DONE && rc != SQLITE_ROW) {
-            if (PyErr_Occurred()) {
-                /* there was an error that occurred in a user-defined callback */
-                if (_pysqlite_enable_callback_tracebacks) {
-                    PyErr_Print();
-                } else {
-                    PyErr_Clear();
-                }
-            }
-            (void)pysqlite_statement_reset(self->statement);
-            _pysqlite_seterror(self->connection->db, NULL);
-            goto error;
-        }
-
-        if (pysqlite_build_row_cast_map(self) != 0) {
+            goto error; 
+        } 
+ 
+        parameters_list = PyList_New(0); 
+        if (!parameters_list) { 
+            goto error; 
+        } 
+ 
+        if (second_argument == NULL) { 
+            second_argument = PyTuple_New(0); 
+            if (!second_argument) { 
+                goto error; 
+            } 
+        } else { 
+            Py_INCREF(second_argument); 
+        } 
+        if (PyList_Append(parameters_list, second_argument) != 0) { 
+            Py_DECREF(second_argument); 
+            goto error; 
+        } 
+        Py_DECREF(second_argument); 
+ 
+        parameters_iter = PyObject_GetIter(parameters_list); 
+        if (!parameters_iter) { 
+            goto error; 
+        } 
+    } 
+ 
+    if (self->statement != NULL) { 
+        /* There is an active statement */ 
+        pysqlite_statement_reset(self->statement); 
+    } 
+ 
+    /* reset description and rowcount */ 
+    Py_INCREF(Py_None); 
+    Py_SETREF(self->description, Py_None); 
+    self->rowcount = 0L; 
+ 
+    func_args = PyTuple_New(1); 
+    if (!func_args) { 
+        goto error; 
+    } 
+    Py_INCREF(operation); 
+    if (PyTuple_SetItem(func_args, 0, operation) != 0) { 
+        goto error; 
+    } 
+ 
+    if (self->statement) { 
+        (void)pysqlite_statement_reset(self->statement); 
+    } 
+ 
+    Py_XSETREF(self->statement, 
+              (pysqlite_Statement *)pysqlite_cache_get(self->connection->statement_cache, func_args)); 
+    Py_DECREF(func_args); 
+ 
+    if (!self->statement) { 
+        goto error; 
+    } 
+ 
+    if (self->statement->in_use) { 
+        Py_SETREF(self->statement, 
+                  PyObject_New(pysqlite_Statement, &pysqlite_StatementType)); 
+        if (!self->statement) { 
+            goto error; 
+        } 
+        rc = pysqlite_statement_create(self->statement, self->connection, operation); 
+        if (rc != SQLITE_OK) { 
+            Py_CLEAR(self->statement); 
+            goto error; 
+        } 
+    } 
+ 
+    pysqlite_statement_reset(self->statement); 
+    pysqlite_statement_mark_dirty(self->statement); 
+ 
+    /* We start a transaction implicitly before a DML statement. 
+       SELECT is the only exception. See #9924. */ 
+    if (self->connection->begin_statement && self->statement->is_dml) { 
+        if (sqlite3_get_autocommit(self->connection->db)) { 
+            result = _pysqlite_connection_begin(self->connection); 
+            if (!result) { 
+                goto error; 
+            } 
+            Py_DECREF(result); 
+        } 
+    } 
+ 
+    while (1) { 
+        parameters = PyIter_Next(parameters_iter); 
+        if (!parameters) { 
+            break; 
+        } 
+ 
+        pysqlite_statement_mark_dirty(self->statement); 
+ 
+        pysqlite_statement_bind_parameters(self->statement, parameters); 
+        if (PyErr_Occurred()) { 
+            goto error; 
+        } 
+ 
+        rc = pysqlite_step(self->statement->st, self->connection); 
+        if (rc != SQLITE_DONE && rc != SQLITE_ROW) { 
+            if (PyErr_Occurred()) { 
+                /* there was an error that occurred in a user-defined callback */ 
+                if (_pysqlite_enable_callback_tracebacks) { 
+                    PyErr_Print(); 
+                } else { 
+                    PyErr_Clear(); 
+                } 
+            } 
+            (void)pysqlite_statement_reset(self->statement); 
+            _pysqlite_seterror(self->connection->db, NULL); 
+            goto error; 
+        } 
+ 
+        if (pysqlite_build_row_cast_map(self) != 0) { 
             _PyErr_FormatFromCause(pysqlite_OperationalError, "Error while building row_cast_map");
-            goto error;
-        }
-
-        assert(rc == SQLITE_ROW || rc == SQLITE_DONE);
-        Py_BEGIN_ALLOW_THREADS
-        numcols = sqlite3_column_count(self->statement->st);
-        Py_END_ALLOW_THREADS
-        if (self->description == Py_None && numcols > 0) {
-            Py_SETREF(self->description, PyTuple_New(numcols));
-            if (!self->description) {
-                goto error;
-            }
-            for (i = 0; i < numcols; i++) {
-                descriptor = PyTuple_New(7);
-                if (!descriptor) {
-                    goto error;
-                }
+            goto error; 
+        } 
+ 
+        assert(rc == SQLITE_ROW || rc == SQLITE_DONE); 
+        Py_BEGIN_ALLOW_THREADS 
+        numcols = sqlite3_column_count(self->statement->st); 
+        Py_END_ALLOW_THREADS 
+        if (self->description == Py_None && numcols > 0) { 
+            Py_SETREF(self->description, PyTuple_New(numcols)); 
+            if (!self->description) { 
+                goto error; 
+            } 
+            for (i = 0; i < numcols; i++) { 
+                descriptor = PyTuple_New(7); 
+                if (!descriptor) { 
+                    goto error; 
+                } 
                 column_name = _pysqlite_build_column_name(self,
                                 sqlite3_column_name(self->statement->st, i));
                 if (!column_name) {
@@ -552,410 +552,410 @@ _pysqlite_query_execute(pysqlite_Cursor* self, int multiple, PyObject* args)
                     goto error;
                 }
                 PyTuple_SetItem(descriptor, 0, column_name);
-                Py_INCREF(Py_None); PyTuple_SetItem(descriptor, 1, Py_None);
-                Py_INCREF(Py_None); PyTuple_SetItem(descriptor, 2, Py_None);
-                Py_INCREF(Py_None); PyTuple_SetItem(descriptor, 3, Py_None);
-                Py_INCREF(Py_None); PyTuple_SetItem(descriptor, 4, Py_None);
-                Py_INCREF(Py_None); PyTuple_SetItem(descriptor, 5, Py_None);
-                Py_INCREF(Py_None); PyTuple_SetItem(descriptor, 6, Py_None);
-                PyTuple_SetItem(self->description, i, descriptor);
-            }
-        }
-
-        if (self->statement->is_dml) {
-            self->rowcount += (long)sqlite3_changes(self->connection->db);
-        } else {
-            self->rowcount= -1L;
-        }
-
-        if (!multiple) {
-            Py_BEGIN_ALLOW_THREADS
-            lastrowid = sqlite3_last_insert_rowid(self->connection->db);
-            Py_END_ALLOW_THREADS
+                Py_INCREF(Py_None); PyTuple_SetItem(descriptor, 1, Py_None); 
+                Py_INCREF(Py_None); PyTuple_SetItem(descriptor, 2, Py_None); 
+                Py_INCREF(Py_None); PyTuple_SetItem(descriptor, 3, Py_None); 
+                Py_INCREF(Py_None); PyTuple_SetItem(descriptor, 4, Py_None); 
+                Py_INCREF(Py_None); PyTuple_SetItem(descriptor, 5, Py_None); 
+                Py_INCREF(Py_None); PyTuple_SetItem(descriptor, 6, Py_None); 
+                PyTuple_SetItem(self->description, i, descriptor); 
+            } 
+        } 
+ 
+        if (self->statement->is_dml) { 
+            self->rowcount += (long)sqlite3_changes(self->connection->db); 
+        } else { 
+            self->rowcount= -1L; 
+        } 
+ 
+        if (!multiple) { 
+            Py_BEGIN_ALLOW_THREADS 
+            lastrowid = sqlite3_last_insert_rowid(self->connection->db); 
+            Py_END_ALLOW_THREADS 
             Py_SETREF(self->lastrowid, PyLong_FromLongLong(lastrowid));
             if (self->lastrowid == NULL) {
                 goto error;
             }
-        }
-
-        if (rc == SQLITE_ROW) {
-            if (multiple) {
-                PyErr_SetString(pysqlite_ProgrammingError, "executemany() can only execute DML statements.");
-                goto error;
-            }
-
-            self->next_row = _pysqlite_fetch_one_row(self);
-            if (self->next_row == NULL)
-                goto error;
-        } else if (rc == SQLITE_DONE && !multiple) {
-            pysqlite_statement_reset(self->statement);
-            Py_CLEAR(self->statement);
-        }
-
-        if (multiple) {
-            pysqlite_statement_reset(self->statement);
-        }
-        Py_XDECREF(parameters);
-    }
-
-error:
-    Py_XDECREF(parameters);
-    Py_XDECREF(parameters_iter);
-    Py_XDECREF(parameters_list);
-
-    self->locked = 0;
-
-    if (PyErr_Occurred()) {
-        self->rowcount = -1L;
-        return NULL;
-    } else {
-        Py_INCREF(self);
-        return (PyObject*)self;
-    }
-}
-
-PyObject* pysqlite_cursor_execute(pysqlite_Cursor* self, PyObject* args)
-{
-    return _pysqlite_query_execute(self, 0, args);
-}
-
-PyObject* pysqlite_cursor_executemany(pysqlite_Cursor* self, PyObject* args)
-{
-    return _pysqlite_query_execute(self, 1, args);
-}
-
+        } 
+ 
+        if (rc == SQLITE_ROW) { 
+            if (multiple) { 
+                PyErr_SetString(pysqlite_ProgrammingError, "executemany() can only execute DML statements."); 
+                goto error; 
+            } 
+ 
+            self->next_row = _pysqlite_fetch_one_row(self); 
+            if (self->next_row == NULL) 
+                goto error; 
+        } else if (rc == SQLITE_DONE && !multiple) { 
+            pysqlite_statement_reset(self->statement); 
+            Py_CLEAR(self->statement); 
+        } 
+ 
+        if (multiple) { 
+            pysqlite_statement_reset(self->statement); 
+        } 
+        Py_XDECREF(parameters); 
+    } 
+ 
+error: 
+    Py_XDECREF(parameters); 
+    Py_XDECREF(parameters_iter); 
+    Py_XDECREF(parameters_list); 
+ 
+    self->locked = 0; 
+ 
+    if (PyErr_Occurred()) { 
+        self->rowcount = -1L; 
+        return NULL; 
+    } else { 
+        Py_INCREF(self); 
+        return (PyObject*)self; 
+    } 
+} 
+ 
+PyObject* pysqlite_cursor_execute(pysqlite_Cursor* self, PyObject* args) 
+{ 
+    return _pysqlite_query_execute(self, 0, args); 
+} 
+ 
+PyObject* pysqlite_cursor_executemany(pysqlite_Cursor* self, PyObject* args) 
+{ 
+    return _pysqlite_query_execute(self, 1, args); 
+} 
+ 
 static PyObject *
 pysqlite_cursor_executescript(pysqlite_Cursor* self, PyObject* args)
-{
-    PyObject* script_obj;
-    const char* script_cstr;
-    sqlite3_stmt* statement;
-    int rc;
-    PyObject* result;
-
-    if (!PyArg_ParseTuple(args, "O", &script_obj)) {
-        return NULL;
-    }
-
-    if (!check_cursor(self)) {
-        return NULL;
-    }
-
-    self->reset = 0;
-
-    if (PyUnicode_Check(script_obj)) {
-        script_cstr = PyUnicode_AsUTF8(script_obj);
-        if (!script_cstr) {
-            return NULL;
-        }
-    } else {
-        PyErr_SetString(PyExc_ValueError, "script argument must be unicode.");
-        return NULL;
-    }
-
-    /* commit first */
-    result = pysqlite_connection_commit(self->connection, NULL);
-    if (!result) {
-        goto error;
-    }
-    Py_DECREF(result);
-
-    while (1) {
-        Py_BEGIN_ALLOW_THREADS
-        rc = sqlite3_prepare_v2(self->connection->db,
-                                script_cstr,
-                                -1,
-                                &statement,
-                                &script_cstr);
-        Py_END_ALLOW_THREADS
-        if (rc != SQLITE_OK) {
-            _pysqlite_seterror(self->connection->db, NULL);
-            goto error;
-        }
-
-        /* execute statement, and ignore results of SELECT statements */
-        rc = SQLITE_ROW;
-        while (rc == SQLITE_ROW) {
-            rc = pysqlite_step(statement, self->connection);
-            if (PyErr_Occurred()) {
-                (void)sqlite3_finalize(statement);
-                goto error;
-            }
-        }
-
-        if (rc != SQLITE_DONE) {
-            (void)sqlite3_finalize(statement);
-            _pysqlite_seterror(self->connection->db, NULL);
-            goto error;
-        }
-
-        rc = sqlite3_finalize(statement);
-        if (rc != SQLITE_OK) {
-            _pysqlite_seterror(self->connection->db, NULL);
-            goto error;
-        }
-
-        if (*script_cstr == (char)0) {
-            break;
-        }
-    }
-
-error:
-    if (PyErr_Occurred()) {
-        return NULL;
-    } else {
-        Py_INCREF(self);
-        return (PyObject*)self;
-    }
-}
-
-PyObject* pysqlite_cursor_iternext(pysqlite_Cursor *self)
-{
-    PyObject* next_row_tuple;
-    PyObject* next_row;
-    int rc;
-
-    if (!check_cursor(self)) {
-        return NULL;
-    }
-
-    if (self->reset) {
-        PyErr_SetString(pysqlite_InterfaceError, errmsg_fetch_across_rollback);
-        return NULL;
-    }
-
-    if (!self->next_row) {
-         if (self->statement) {
-            (void)pysqlite_statement_reset(self->statement);
-            Py_CLEAR(self->statement);
-        }
-        return NULL;
-    }
-
-    next_row_tuple = self->next_row;
-    assert(next_row_tuple != NULL);
-    self->next_row = NULL;
-
-    if (self->row_factory != Py_None) {
-        next_row = PyObject_CallFunction(self->row_factory, "OO", self, next_row_tuple);
-        if (next_row == NULL) {
-            self->next_row = next_row_tuple;
-            return NULL;
-        }
-        Py_DECREF(next_row_tuple);
-    } else {
-        next_row = next_row_tuple;
-    }
-
-    if (self->statement) {
-        rc = pysqlite_step(self->statement->st, self->connection);
-        if (PyErr_Occurred()) {
-            (void)pysqlite_statement_reset(self->statement);
-            Py_DECREF(next_row);
-            return NULL;
-        }
-        if (rc != SQLITE_DONE && rc != SQLITE_ROW) {
-            (void)pysqlite_statement_reset(self->statement);
-            Py_DECREF(next_row);
-            _pysqlite_seterror(self->connection->db, NULL);
-            return NULL;
-        }
-
-        if (rc == SQLITE_ROW) {
-            self->next_row = _pysqlite_fetch_one_row(self);
-            if (self->next_row == NULL) {
-                (void)pysqlite_statement_reset(self->statement);
-                return NULL;
-            }
-        }
-    }
-
-    return next_row;
-}
-
-PyObject* pysqlite_cursor_fetchone(pysqlite_Cursor* self, PyObject* args)
-{
-    PyObject* row;
-
-    row = pysqlite_cursor_iternext(self);
-    if (!row && !PyErr_Occurred()) {
-        Py_RETURN_NONE;
-    }
-
-    return row;
-}
-
-PyObject* pysqlite_cursor_fetchmany(pysqlite_Cursor* self, PyObject* args, PyObject* kwargs)
-{
+{ 
+    PyObject* script_obj; 
+    const char* script_cstr; 
+    sqlite3_stmt* statement; 
+    int rc; 
+    PyObject* result; 
+ 
+    if (!PyArg_ParseTuple(args, "O", &script_obj)) { 
+        return NULL; 
+    } 
+ 
+    if (!check_cursor(self)) { 
+        return NULL; 
+    } 
+ 
+    self->reset = 0; 
+ 
+    if (PyUnicode_Check(script_obj)) { 
+        script_cstr = PyUnicode_AsUTF8(script_obj); 
+        if (!script_cstr) { 
+            return NULL; 
+        } 
+    } else { 
+        PyErr_SetString(PyExc_ValueError, "script argument must be unicode."); 
+        return NULL; 
+    } 
+ 
+    /* commit first */ 
+    result = pysqlite_connection_commit(self->connection, NULL); 
+    if (!result) { 
+        goto error; 
+    } 
+    Py_DECREF(result); 
+ 
+    while (1) { 
+        Py_BEGIN_ALLOW_THREADS 
+        rc = sqlite3_prepare_v2(self->connection->db, 
+                                script_cstr, 
+                                -1, 
+                                &statement, 
+                                &script_cstr); 
+        Py_END_ALLOW_THREADS 
+        if (rc != SQLITE_OK) { 
+            _pysqlite_seterror(self->connection->db, NULL); 
+            goto error; 
+        } 
+ 
+        /* execute statement, and ignore results of SELECT statements */ 
+        rc = SQLITE_ROW; 
+        while (rc == SQLITE_ROW) { 
+            rc = pysqlite_step(statement, self->connection); 
+            if (PyErr_Occurred()) { 
+                (void)sqlite3_finalize(statement); 
+                goto error; 
+            } 
+        } 
+ 
+        if (rc != SQLITE_DONE) { 
+            (void)sqlite3_finalize(statement); 
+            _pysqlite_seterror(self->connection->db, NULL); 
+            goto error; 
+        } 
+ 
+        rc = sqlite3_finalize(statement); 
+        if (rc != SQLITE_OK) { 
+            _pysqlite_seterror(self->connection->db, NULL); 
+            goto error; 
+        } 
+ 
+        if (*script_cstr == (char)0) { 
+            break; 
+        } 
+    } 
+ 
+error: 
+    if (PyErr_Occurred()) { 
+        return NULL; 
+    } else { 
+        Py_INCREF(self); 
+        return (PyObject*)self; 
+    } 
+} 
+ 
+PyObject* pysqlite_cursor_iternext(pysqlite_Cursor *self) 
+{ 
+    PyObject* next_row_tuple; 
+    PyObject* next_row; 
+    int rc; 
+ 
+    if (!check_cursor(self)) { 
+        return NULL; 
+    } 
+ 
+    if (self->reset) { 
+        PyErr_SetString(pysqlite_InterfaceError, errmsg_fetch_across_rollback); 
+        return NULL; 
+    } 
+ 
+    if (!self->next_row) { 
+         if (self->statement) { 
+            (void)pysqlite_statement_reset(self->statement); 
+            Py_CLEAR(self->statement); 
+        } 
+        return NULL; 
+    } 
+ 
+    next_row_tuple = self->next_row; 
+    assert(next_row_tuple != NULL); 
+    self->next_row = NULL; 
+ 
+    if (self->row_factory != Py_None) { 
+        next_row = PyObject_CallFunction(self->row_factory, "OO", self, next_row_tuple); 
+        if (next_row == NULL) { 
+            self->next_row = next_row_tuple; 
+            return NULL; 
+        } 
+        Py_DECREF(next_row_tuple); 
+    } else { 
+        next_row = next_row_tuple; 
+    } 
+ 
+    if (self->statement) { 
+        rc = pysqlite_step(self->statement->st, self->connection); 
+        if (PyErr_Occurred()) { 
+            (void)pysqlite_statement_reset(self->statement); 
+            Py_DECREF(next_row); 
+            return NULL; 
+        } 
+        if (rc != SQLITE_DONE && rc != SQLITE_ROW) { 
+            (void)pysqlite_statement_reset(self->statement); 
+            Py_DECREF(next_row); 
+            _pysqlite_seterror(self->connection->db, NULL); 
+            return NULL; 
+        } 
+ 
+        if (rc == SQLITE_ROW) { 
+            self->next_row = _pysqlite_fetch_one_row(self); 
+            if (self->next_row == NULL) { 
+                (void)pysqlite_statement_reset(self->statement); 
+                return NULL; 
+            } 
+        } 
+    } 
+ 
+    return next_row; 
+} 
+ 
+PyObject* pysqlite_cursor_fetchone(pysqlite_Cursor* self, PyObject* args) 
+{ 
+    PyObject* row; 
+ 
+    row = pysqlite_cursor_iternext(self); 
+    if (!row && !PyErr_Occurred()) { 
+        Py_RETURN_NONE; 
+    } 
+ 
+    return row; 
+} 
+ 
+PyObject* pysqlite_cursor_fetchmany(pysqlite_Cursor* self, PyObject* args, PyObject* kwargs) 
+{ 
     static char *kwlist[] = {"size", NULL};
-
-    PyObject* row;
-    PyObject* list;
-    int maxrows = self->arraysize;
-    int counter = 0;
-
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i:fetchmany", kwlist, &maxrows)) {
-        return NULL;
-    }
-
-    list = PyList_New(0);
-    if (!list) {
-        return NULL;
-    }
-
+ 
+    PyObject* row; 
+    PyObject* list; 
+    int maxrows = self->arraysize; 
+    int counter = 0; 
+ 
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i:fetchmany", kwlist, &maxrows)) { 
+        return NULL; 
+    } 
+ 
+    list = PyList_New(0); 
+    if (!list) { 
+        return NULL; 
+    } 
+ 
     while ((row = pysqlite_cursor_iternext(self))) {
         if (PyList_Append(list, row) < 0) {
             Py_DECREF(row);
             break;
         }
         Py_DECREF(row);
-
-        if (++counter == maxrows) {
-            break;
-        }
-    }
-
-    if (PyErr_Occurred()) {
-        Py_DECREF(list);
-        return NULL;
-    } else {
-        return list;
-    }
-}
-
-PyObject* pysqlite_cursor_fetchall(pysqlite_Cursor* self, PyObject* args)
-{
-    PyObject* row;
-    PyObject* list;
-
-    list = PyList_New(0);
-    if (!list) {
-        return NULL;
-    }
-
+ 
+        if (++counter == maxrows) { 
+            break; 
+        } 
+    } 
+ 
+    if (PyErr_Occurred()) { 
+        Py_DECREF(list); 
+        return NULL; 
+    } else { 
+        return list; 
+    } 
+} 
+ 
+PyObject* pysqlite_cursor_fetchall(pysqlite_Cursor* self, PyObject* args) 
+{ 
+    PyObject* row; 
+    PyObject* list; 
+ 
+    list = PyList_New(0); 
+    if (!list) { 
+        return NULL; 
+    } 
+ 
     while ((row = pysqlite_cursor_iternext(self))) {
         if (PyList_Append(list, row) < 0) {
             Py_DECREF(row);
             break;
         }
         Py_DECREF(row);
-    }
-
-    if (PyErr_Occurred()) {
-        Py_DECREF(list);
-        return NULL;
-    } else {
-        return list;
-    }
-}
-
-PyObject* pysqlite_noop(pysqlite_Connection* self, PyObject* args)
-{
-    /* don't care, return None */
-    Py_RETURN_NONE;
-}
-
-PyObject* pysqlite_cursor_close(pysqlite_Cursor* self, PyObject* args)
-{
-    if (!self->connection) {
-        PyErr_SetString(pysqlite_ProgrammingError,
-                        "Base Cursor.__init__ not called.");
-        return NULL;
-    }
-    if (!pysqlite_check_thread(self->connection) || !pysqlite_check_connection(self->connection)) {
-        return NULL;
-    }
-
-    if (self->statement) {
-        (void)pysqlite_statement_reset(self->statement);
-        Py_CLEAR(self->statement);
-    }
-
-    self->closed = 1;
-
-    Py_RETURN_NONE;
-}
-
-static PyMethodDef cursor_methods[] = {
-    {"execute", (PyCFunction)pysqlite_cursor_execute, METH_VARARGS,
-        PyDoc_STR("Executes a SQL statement.")},
-    {"executemany", (PyCFunction)pysqlite_cursor_executemany, METH_VARARGS,
-        PyDoc_STR("Repeatedly executes a SQL statement.")},
-    {"executescript", (PyCFunction)pysqlite_cursor_executescript, METH_VARARGS,
-        PyDoc_STR("Executes a multiple SQL statements at once. Non-standard.")},
-    {"fetchone", (PyCFunction)pysqlite_cursor_fetchone, METH_NOARGS,
-        PyDoc_STR("Fetches one row from the resultset.")},
+    } 
+ 
+    if (PyErr_Occurred()) { 
+        Py_DECREF(list); 
+        return NULL; 
+    } else { 
+        return list; 
+    } 
+} 
+ 
+PyObject* pysqlite_noop(pysqlite_Connection* self, PyObject* args) 
+{ 
+    /* don't care, return None */ 
+    Py_RETURN_NONE; 
+} 
+ 
+PyObject* pysqlite_cursor_close(pysqlite_Cursor* self, PyObject* args) 
+{ 
+    if (!self->connection) { 
+        PyErr_SetString(pysqlite_ProgrammingError, 
+                        "Base Cursor.__init__ not called."); 
+        return NULL; 
+    } 
+    if (!pysqlite_check_thread(self->connection) || !pysqlite_check_connection(self->connection)) { 
+        return NULL; 
+    } 
+ 
+    if (self->statement) { 
+        (void)pysqlite_statement_reset(self->statement); 
+        Py_CLEAR(self->statement); 
+    } 
+ 
+    self->closed = 1; 
+ 
+    Py_RETURN_NONE; 
+} 
+ 
+static PyMethodDef cursor_methods[] = { 
+    {"execute", (PyCFunction)pysqlite_cursor_execute, METH_VARARGS, 
+        PyDoc_STR("Executes a SQL statement.")}, 
+    {"executemany", (PyCFunction)pysqlite_cursor_executemany, METH_VARARGS, 
+        PyDoc_STR("Repeatedly executes a SQL statement.")}, 
+    {"executescript", (PyCFunction)pysqlite_cursor_executescript, METH_VARARGS, 
+        PyDoc_STR("Executes a multiple SQL statements at once. Non-standard.")}, 
+    {"fetchone", (PyCFunction)pysqlite_cursor_fetchone, METH_NOARGS, 
+        PyDoc_STR("Fetches one row from the resultset.")}, 
     {"fetchmany", (PyCFunction)(void(*)(void))pysqlite_cursor_fetchmany, METH_VARARGS|METH_KEYWORDS,
-        PyDoc_STR("Fetches several rows from the resultset.")},
-    {"fetchall", (PyCFunction)pysqlite_cursor_fetchall, METH_NOARGS,
-        PyDoc_STR("Fetches all rows from the resultset.")},
-    {"close", (PyCFunction)pysqlite_cursor_close, METH_NOARGS,
-        PyDoc_STR("Closes the cursor.")},
-    {"setinputsizes", (PyCFunction)pysqlite_noop, METH_VARARGS,
-        PyDoc_STR("Required by DB-API. Does nothing in pysqlite.")},
-    {"setoutputsize", (PyCFunction)pysqlite_noop, METH_VARARGS,
-        PyDoc_STR("Required by DB-API. Does nothing in pysqlite.")},
-    {NULL, NULL}
-};
-
-static struct PyMemberDef cursor_members[] =
-{
-    {"connection", T_OBJECT, offsetof(pysqlite_Cursor, connection), READONLY},
-    {"description", T_OBJECT, offsetof(pysqlite_Cursor, description), READONLY},
-    {"arraysize", T_INT, offsetof(pysqlite_Cursor, arraysize), 0},
-    {"lastrowid", T_OBJECT, offsetof(pysqlite_Cursor, lastrowid), READONLY},
-    {"rowcount", T_LONG, offsetof(pysqlite_Cursor, rowcount), READONLY},
-    {"row_factory", T_OBJECT, offsetof(pysqlite_Cursor, row_factory), 0},
-    {NULL}
-};
-
-static const char cursor_doc[] =
-PyDoc_STR("SQLite database cursor class.");
-
-PyTypeObject pysqlite_CursorType = {
-        PyVarObject_HEAD_INIT(NULL, 0)
-        MODULE_NAME ".Cursor",                          /* tp_name */
-        sizeof(pysqlite_Cursor),                        /* tp_basicsize */
-        0,                                              /* tp_itemsize */
-        (destructor)pysqlite_cursor_dealloc,            /* tp_dealloc */
+        PyDoc_STR("Fetches several rows from the resultset.")}, 
+    {"fetchall", (PyCFunction)pysqlite_cursor_fetchall, METH_NOARGS, 
+        PyDoc_STR("Fetches all rows from the resultset.")}, 
+    {"close", (PyCFunction)pysqlite_cursor_close, METH_NOARGS, 
+        PyDoc_STR("Closes the cursor.")}, 
+    {"setinputsizes", (PyCFunction)pysqlite_noop, METH_VARARGS, 
+        PyDoc_STR("Required by DB-API. Does nothing in pysqlite.")}, 
+    {"setoutputsize", (PyCFunction)pysqlite_noop, METH_VARARGS, 
+        PyDoc_STR("Required by DB-API. Does nothing in pysqlite.")}, 
+    {NULL, NULL} 
+}; 
+ 
+static struct PyMemberDef cursor_members[] = 
+{ 
+    {"connection", T_OBJECT, offsetof(pysqlite_Cursor, connection), READONLY}, 
+    {"description", T_OBJECT, offsetof(pysqlite_Cursor, description), READONLY}, 
+    {"arraysize", T_INT, offsetof(pysqlite_Cursor, arraysize), 0}, 
+    {"lastrowid", T_OBJECT, offsetof(pysqlite_Cursor, lastrowid), READONLY}, 
+    {"rowcount", T_LONG, offsetof(pysqlite_Cursor, rowcount), READONLY}, 
+    {"row_factory", T_OBJECT, offsetof(pysqlite_Cursor, row_factory), 0}, 
+    {NULL} 
+}; 
+ 
+static const char cursor_doc[] = 
+PyDoc_STR("SQLite database cursor class."); 
+ 
+PyTypeObject pysqlite_CursorType = { 
+        PyVarObject_HEAD_INIT(NULL, 0) 
+        MODULE_NAME ".Cursor",                          /* tp_name */ 
+        sizeof(pysqlite_Cursor),                        /* tp_basicsize */ 
+        0,                                              /* tp_itemsize */ 
+        (destructor)pysqlite_cursor_dealloc,            /* tp_dealloc */ 
         0,                                              /* tp_vectorcall_offset */
-        0,                                              /* tp_getattr */
-        0,                                              /* tp_setattr */
+        0,                                              /* tp_getattr */ 
+        0,                                              /* tp_setattr */ 
         0,                                              /* tp_as_async */
-        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 */
-        Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
-        cursor_doc,                                     /* tp_doc */
-        0,                                              /* tp_traverse */
-        0,                                              /* tp_clear */
-        0,                                              /* tp_richcompare */
-        offsetof(pysqlite_Cursor, in_weakreflist),      /* tp_weaklistoffset */
+        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 */ 
+        Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ 
+        cursor_doc,                                     /* tp_doc */ 
+        0,                                              /* tp_traverse */ 
+        0,                                              /* tp_clear */ 
+        0,                                              /* tp_richcompare */ 
+        offsetof(pysqlite_Cursor, in_weakreflist),      /* tp_weaklistoffset */ 
         PyObject_SelfIter,                              /* tp_iter */
-        (iternextfunc)pysqlite_cursor_iternext,         /* tp_iternext */
-        cursor_methods,                                 /* tp_methods */
-        cursor_members,                                 /* tp_members */
-        0,                                              /* tp_getset */
-        0,                                              /* tp_base */
-        0,                                              /* tp_dict */
-        0,                                              /* tp_descr_get */
-        0,                                              /* tp_descr_set */
-        0,                                              /* tp_dictoffset */
-        (initproc)pysqlite_cursor_init,                 /* tp_init */
-        0,                                              /* tp_alloc */
-        0,                                              /* tp_new */
-        0                                               /* tp_free */
-};
-
-extern int pysqlite_cursor_setup_types(void)
-{
-    pysqlite_CursorType.tp_new = PyType_GenericNew;
-    return PyType_Ready(&pysqlite_CursorType);
-}
+        (iternextfunc)pysqlite_cursor_iternext,         /* tp_iternext */ 
+        cursor_methods,                                 /* tp_methods */ 
+        cursor_members,                                 /* tp_members */ 
+        0,                                              /* tp_getset */ 
+        0,                                              /* tp_base */ 
+        0,                                              /* tp_dict */ 
+        0,                                              /* tp_descr_get */ 
+        0,                                              /* tp_descr_set */ 
+        0,                                              /* tp_dictoffset */ 
+        (initproc)pysqlite_cursor_init,                 /* tp_init */ 
+        0,                                              /* tp_alloc */ 
+        0,                                              /* tp_new */ 
+        0                                               /* tp_free */ 
+}; 
+ 
+extern int pysqlite_cursor_setup_types(void) 
+{ 
+    pysqlite_CursorType.tp_new = PyType_GenericNew; 
+    return PyType_Ready(&pysqlite_CursorType); 
+} 
diff --git a/contrib/tools/python3/src/Modules/_sqlite/cursor.h b/contrib/tools/python3/src/Modules/_sqlite/cursor.h
index 4a20e756f78..6e0fe913960 100644
--- a/contrib/tools/python3/src/Modules/_sqlite/cursor.h
+++ b/contrib/tools/python3/src/Modules/_sqlite/cursor.h
@@ -1,70 +1,70 @@
-/* cursor.h - definitions for the cursor type
- *
- * Copyright (C) 2004-2010 Gerhard Häring <[email protected]>
- *
- * This file is part of pysqlite.
- *
- * This software is provided 'as-is', without any express or implied
- * warranty.  In no event will the authors be held liable for any damages
- * arising from the use of this software.
- *
- * Permission is granted to anyone to use this software for any purpose,
- * including commercial applications, and to alter it and redistribute it
- * freely, subject to the following restrictions:
- *
- * 1. The origin of this software must not be misrepresented; you must not
- *    claim that you wrote the original software. If you use this software
- *    in a product, an acknowledgment in the product documentation would be
- *    appreciated but is not required.
- * 2. Altered source versions must be plainly marked as such, and must not be
- *    misrepresented as being the original software.
- * 3. This notice may not be removed or altered from any source distribution.
- */
-
-#ifndef PYSQLITE_CURSOR_H
-#define PYSQLITE_CURSOR_H
+/* cursor.h - definitions for the cursor type 
+ * 
+ * Copyright (C) 2004-2010 Gerhard Häring <[email protected]> 
+ * 
+ * This file is part of pysqlite. 
+ * 
+ * This software is provided 'as-is', without any express or implied 
+ * warranty.  In no event will the authors be held liable for any damages 
+ * arising from the use of this software. 
+ * 
+ * Permission is granted to anyone to use this software for any purpose, 
+ * including commercial applications, and to alter it and redistribute it 
+ * freely, subject to the following restrictions: 
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not 
+ *    claim that you wrote the original software. If you use this software 
+ *    in a product, an acknowledgment in the product documentation would be 
+ *    appreciated but is not required. 
+ * 2. Altered source versions must be plainly marked as such, and must not be 
+ *    misrepresented as being the original software. 
+ * 3. This notice may not be removed or altered from any source distribution. 
+ */ 
+ 
+#ifndef PYSQLITE_CURSOR_H 
+#define PYSQLITE_CURSOR_H 
 #define PY_SSIZE_T_CLEAN
-#include "Python.h"
-
-#include "statement.h"
-#include "connection.h"
-#include "module.h"
-
-typedef struct
-{
-    PyObject_HEAD
-    pysqlite_Connection* connection;
-    PyObject* description;
-    PyObject* row_cast_map;
-    int arraysize;
-    PyObject* lastrowid;
-    long rowcount;
-    PyObject* row_factory;
-    pysqlite_Statement* statement;
-    int closed;
-    int reset;
-    int locked;
-    int initialized;
-
-    /* the next row to be returned, NULL if no next row available */
-    PyObject* next_row;
-
-    PyObject* in_weakreflist; /* List of weak references */
-} pysqlite_Cursor;
-
-extern PyTypeObject pysqlite_CursorType;
-
-PyObject* pysqlite_cursor_execute(pysqlite_Cursor* self, PyObject* args);
-PyObject* pysqlite_cursor_executemany(pysqlite_Cursor* self, PyObject* args);
-PyObject* pysqlite_cursor_getiter(pysqlite_Cursor *self);
-PyObject* pysqlite_cursor_iternext(pysqlite_Cursor *self);
-PyObject* pysqlite_cursor_fetchone(pysqlite_Cursor* self, PyObject* args);
-PyObject* pysqlite_cursor_fetchmany(pysqlite_Cursor* self, PyObject* args, PyObject* kwargs);
-PyObject* pysqlite_cursor_fetchall(pysqlite_Cursor* self, PyObject* args);
-PyObject* pysqlite_noop(pysqlite_Connection* self, PyObject* args);
-PyObject* pysqlite_cursor_close(pysqlite_Cursor* self, PyObject* args);
-
-int pysqlite_cursor_setup_types(void);
-
-#define UNKNOWN (-1)
-#endif
+#include "Python.h" 
+ 
+#include "statement.h" 
+#include "connection.h" 
+#include "module.h" 
+ 
+typedef struct 
+{ 
+    PyObject_HEAD 
+    pysqlite_Connection* connection; 
+    PyObject* description; 
+    PyObject* row_cast_map; 
+    int arraysize; 
+    PyObject* lastrowid; 
+    long rowcount; 
+    PyObject* row_factory; 
+    pysqlite_Statement* statement; 
+    int closed; 
+    int reset; 
+    int locked; 
+    int initialized; 
+ 
+    /* the next row to be returned, NULL if no next row available */ 
+    PyObject* next_row; 
+ 
+    PyObject* in_weakreflist; /* List of weak references */ 
+} pysqlite_Cursor; 
+ 
+extern PyTypeObject pysqlite_CursorType; 
+ 
+PyObject* pysqlite_cursor_execute(pysqlite_Cursor* self, PyObject* args); 
+PyObject* pysqlite_cursor_executemany(pysqlite_Cursor* self, PyObject* args); 
+PyObject* pysqlite_cursor_getiter(pysqlite_Cursor *self); 
+PyObject* pysqlite_cursor_iternext(pysqlite_Cursor *self); 
+PyObject* pysqlite_cursor_fetchone(pysqlite_Cursor* self, PyObject* args); 
+PyObject* pysqlite_cursor_fetchmany(pysqlite_Cursor* self, PyObject* args, PyObject* kwargs); 
+PyObject* pysqlite_cursor_fetchall(pysqlite_Cursor* self, PyObject* args); 
+PyObject* pysqlite_noop(pysqlite_Connection* self, PyObject* args); 
+PyObject* pysqlite_cursor_close(pysqlite_Cursor* self, PyObject* args); 
+ 
+int pysqlite_cursor_setup_types(void); 
+ 
+#define UNKNOWN (-1) 
+#endif 
diff --git a/contrib/tools/python3/src/Modules/_sqlite/microprotocols.c b/contrib/tools/python3/src/Modules/_sqlite/microprotocols.c
index 3b2d7f42b87..cac71a61869 100644
--- a/contrib/tools/python3/src/Modules/_sqlite/microprotocols.c
+++ b/contrib/tools/python3/src/Modules/_sqlite/microprotocols.c
@@ -1,104 +1,104 @@
-/* microprotocols.c - minimalist and non-validating protocols implementation
- *
- * Copyright (C) 2003-2004 Federico Di Gregorio <[email protected]>
- *
- * This file is part of psycopg and was adapted for pysqlite. Federico Di
- * Gregorio gave the permission to use it within pysqlite under the following
- * license:
- *
- * This software is provided 'as-is', without any express or implied
- * warranty.  In no event will the authors be held liable for any damages
- * arising from the use of this software.
- *
- * Permission is granted to anyone to use this software for any purpose,
- * including commercial applications, and to alter it and redistribute it
- * freely, subject to the following restrictions:
- *
- * 1. The origin of this software must not be misrepresented; you must not
- *    claim that you wrote the original software. If you use this software
- *    in a product, an acknowledgment in the product documentation would be
- *    appreciated but is not required.
- * 2. Altered source versions must be plainly marked as such, and must not be
- *    misrepresented as being the original software.
- * 3. This notice may not be removed or altered from any source distribution.
- */
-
-#include <Python.h>
-
-#include "cursor.h"
-#include "microprotocols.h"
-#include "prepare_protocol.h"
-
-
-/** the adapters registry **/
-
-static PyObject *psyco_adapters = NULL;
-
-/* pysqlite_microprotocols_init - initialize the adapters dictionary */
-
-int
-pysqlite_microprotocols_init(PyObject *dict)
-{
-    /* create adapters dictionary and put it in module namespace */
-    if ((psyco_adapters = PyDict_New()) == NULL) {
-        return -1;
-    }
-
-    return PyDict_SetItemString(dict, "adapters", psyco_adapters);
-}
-
-
-/* pysqlite_microprotocols_add - add a reverse type-caster to the dictionary */
-
-int
-pysqlite_microprotocols_add(PyTypeObject *type, PyObject *proto, PyObject *cast)
-{
-    PyObject* key;
-    int rc;
-
-    if (proto == NULL) proto = (PyObject*)&pysqlite_PrepareProtocolType;
-
-    key = Py_BuildValue("(OO)", (PyObject*)type, proto);
-    if (!key) {
-        return -1;
-    }
-
-    rc = PyDict_SetItem(psyco_adapters, key, cast);
-    Py_DECREF(key);
-
-    return rc;
-}
-
-/* pysqlite_microprotocols_adapt - adapt an object to the built-in protocol */
-
-PyObject *
-pysqlite_microprotocols_adapt(PyObject *obj, PyObject *proto, PyObject *alt)
-{
+/* microprotocols.c - minimalist and non-validating protocols implementation 
+ * 
+ * Copyright (C) 2003-2004 Federico Di Gregorio <[email protected]> 
+ * 
+ * This file is part of psycopg and was adapted for pysqlite. Federico Di 
+ * Gregorio gave the permission to use it within pysqlite under the following 
+ * license: 
+ * 
+ * This software is provided 'as-is', without any express or implied 
+ * warranty.  In no event will the authors be held liable for any damages 
+ * arising from the use of this software. 
+ * 
+ * Permission is granted to anyone to use this software for any purpose, 
+ * including commercial applications, and to alter it and redistribute it 
+ * freely, subject to the following restrictions: 
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not 
+ *    claim that you wrote the original software. If you use this software 
+ *    in a product, an acknowledgment in the product documentation would be 
+ *    appreciated but is not required. 
+ * 2. Altered source versions must be plainly marked as such, and must not be 
+ *    misrepresented as being the original software. 
+ * 3. This notice may not be removed or altered from any source distribution. 
+ */ 
+ 
+#include <Python.h> 
+ 
+#include "cursor.h" 
+#include "microprotocols.h" 
+#include "prepare_protocol.h" 
+ 
+ 
+/** the adapters registry **/ 
+ 
+static PyObject *psyco_adapters = NULL; 
+ 
+/* pysqlite_microprotocols_init - initialize the adapters dictionary */ 
+ 
+int 
+pysqlite_microprotocols_init(PyObject *dict) 
+{ 
+    /* create adapters dictionary and put it in module namespace */ 
+    if ((psyco_adapters = PyDict_New()) == NULL) { 
+        return -1; 
+    } 
+ 
+    return PyDict_SetItemString(dict, "adapters", psyco_adapters); 
+} 
+ 
+ 
+/* pysqlite_microprotocols_add - add a reverse type-caster to the dictionary */ 
+ 
+int 
+pysqlite_microprotocols_add(PyTypeObject *type, PyObject *proto, PyObject *cast) 
+{ 
+    PyObject* key; 
+    int rc; 
+ 
+    if (proto == NULL) proto = (PyObject*)&pysqlite_PrepareProtocolType; 
+ 
+    key = Py_BuildValue("(OO)", (PyObject*)type, proto); 
+    if (!key) { 
+        return -1; 
+    } 
+ 
+    rc = PyDict_SetItem(psyco_adapters, key, cast); 
+    Py_DECREF(key); 
+ 
+    return rc; 
+} 
+ 
+/* pysqlite_microprotocols_adapt - adapt an object to the built-in protocol */ 
+ 
+PyObject * 
+pysqlite_microprotocols_adapt(PyObject *obj, PyObject *proto, PyObject *alt) 
+{ 
     _Py_IDENTIFIER(__adapt__);
     _Py_IDENTIFIER(__conform__);
     PyObject *adapter, *key, *adapted;
-
-    /* we don't check for exact type conformance as specified in PEP 246
-       because the pysqlite_PrepareProtocolType type is abstract and there is no
-       way to get a quotable object to be its instance */
-
-    /* look for an adapter in the registry */
+ 
+    /* we don't check for exact type conformance as specified in PEP 246 
+       because the pysqlite_PrepareProtocolType type is abstract and there is no 
+       way to get a quotable object to be its instance */ 
+ 
+    /* look for an adapter in the registry */ 
     key = Py_BuildValue("(OO)", (PyObject*)Py_TYPE(obj), proto);
-    if (!key) {
-        return NULL;
-    }
+    if (!key) { 
+        return NULL; 
+    } 
     adapter = PyDict_GetItemWithError(psyco_adapters, key);
-    Py_DECREF(key);
-    if (adapter) {
+    Py_DECREF(key); 
+    if (adapter) { 
         Py_INCREF(adapter);
         adapted = PyObject_CallOneArg(adapter, obj);
         Py_DECREF(adapter);
-        return adapted;
-    }
+        return adapted; 
+    } 
     if (PyErr_Occurred()) {
         return NULL;
     }
-
+ 
     /* try to have the protocol adapt this object */
     if (_PyObject_LookupAttrId(proto, &PyId___adapt__, &adapter) < 0) {
         return NULL;
@@ -106,54 +106,54 @@ pysqlite_microprotocols_adapt(PyObject *obj, PyObject *proto, PyObject *alt)
     if (adapter) {
         adapted = PyObject_CallOneArg(adapter, obj);
         Py_DECREF(adapter);
-
+ 
         if (adapted == Py_None) {
             Py_DECREF(adapted);
-        }
+        } 
         else if (adapted || !PyErr_ExceptionMatches(PyExc_TypeError)) {
             return adapted;
         }
         else {
             PyErr_Clear();
         }
-    }
-
-    /* and finally try to have the object adapt itself */
+    } 
+ 
+    /* and finally try to have the object adapt itself */ 
     if (_PyObject_LookupAttrId(obj, &PyId___conform__, &adapter) < 0) {
         return NULL;
     }
     if (adapter) {
         adapted = PyObject_CallOneArg(adapter, proto);
         Py_DECREF(adapter);
-
+ 
         if (adapted == Py_None) {
             Py_DECREF(adapted);
-        }
+        } 
         else if (adapted || !PyErr_ExceptionMatches(PyExc_TypeError)) {
             return adapted;
-        }
+        } 
         else {
             PyErr_Clear();
         }
-    }
-
+    } 
+ 
     if (alt) {
         Py_INCREF(alt);
         return alt;
     }
-    /* else set the right exception and return NULL */
-    PyErr_SetString(pysqlite_ProgrammingError, "can't adapt");
-    return NULL;
-}
-
-/** module-level functions **/
-
-PyObject *
-pysqlite_adapt(pysqlite_Cursor *self, PyObject *args)
-{
-    PyObject *obj, *alt = NULL;
-    PyObject *proto = (PyObject*)&pysqlite_PrepareProtocolType;
-
-    if (!PyArg_ParseTuple(args, "O|OO", &obj, &proto, &alt)) return NULL;
-    return pysqlite_microprotocols_adapt(obj, proto, alt);
-}
+    /* else set the right exception and return NULL */ 
+    PyErr_SetString(pysqlite_ProgrammingError, "can't adapt"); 
+    return NULL; 
+} 
+ 
+/** module-level functions **/ 
+ 
+PyObject * 
+pysqlite_adapt(pysqlite_Cursor *self, PyObject *args) 
+{ 
+    PyObject *obj, *alt = NULL; 
+    PyObject *proto = (PyObject*)&pysqlite_PrepareProtocolType; 
+ 
+    if (!PyArg_ParseTuple(args, "O|OO", &obj, &proto, &alt)) return NULL; 
+    return pysqlite_microprotocols_adapt(obj, proto, alt); 
+} 
diff --git a/contrib/tools/python3/src/Modules/_sqlite/microprotocols.h b/contrib/tools/python3/src/Modules/_sqlite/microprotocols.h
index 5418c2b98fd..33e82e680cc 100644
--- a/contrib/tools/python3/src/Modules/_sqlite/microprotocols.h
+++ b/contrib/tools/python3/src/Modules/_sqlite/microprotocols.h
@@ -1,52 +1,52 @@
-/* microprotocols.c - definitions for minimalist and non-validating protocols
- *
- * Copyright (C) 2003-2004 Federico Di Gregorio <[email protected]>
- *
- * This file is part of psycopg and was adapted for pysqlite. Federico Di
- * Gregorio gave the permission to use it within pysqlite under the following
- * license:
- *
- * This software is provided 'as-is', without any express or implied
- * warranty.  In no event will the authors be held liable for any damages
- * arising from the use of this software.
- *
- * Permission is granted to anyone to use this software for any purpose,
- * including commercial applications, and to alter it and redistribute it
- * freely, subject to the following restrictions:
- *
- * 1. The origin of this software must not be misrepresented; you must not
- *    claim that you wrote the original software. If you use this software
- *    in a product, an acknowledgment in the product documentation would be
- *    appreciated but is not required.
- * 2. Altered source versions must be plainly marked as such, and must not be
- *    misrepresented as being the original software.
- * 3. This notice may not be removed or altered from any source distribution.
- */
-
-#ifndef PSYCOPG_MICROPROTOCOLS_H
-#define PSYCOPG_MICROPROTOCOLS_H 1
-
+/* microprotocols.c - definitions for minimalist and non-validating protocols 
+ * 
+ * Copyright (C) 2003-2004 Federico Di Gregorio <[email protected]> 
+ * 
+ * This file is part of psycopg and was adapted for pysqlite. Federico Di 
+ * Gregorio gave the permission to use it within pysqlite under the following 
+ * license: 
+ * 
+ * This software is provided 'as-is', without any express or implied 
+ * warranty.  In no event will the authors be held liable for any damages 
+ * arising from the use of this software. 
+ * 
+ * Permission is granted to anyone to use this software for any purpose, 
+ * including commercial applications, and to alter it and redistribute it 
+ * freely, subject to the following restrictions: 
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not 
+ *    claim that you wrote the original software. If you use this software 
+ *    in a product, an acknowledgment in the product documentation would be 
+ *    appreciated but is not required. 
+ * 2. Altered source versions must be plainly marked as such, and must not be 
+ *    misrepresented as being the original software. 
+ * 3. This notice may not be removed or altered from any source distribution. 
+ */ 
+ 
+#ifndef PSYCOPG_MICROPROTOCOLS_H 
+#define PSYCOPG_MICROPROTOCOLS_H 1 
+ 
 #define PY_SSIZE_T_CLEAN
-#include <Python.h>
-
-/** the names of the three mandatory methods **/
-
-#define MICROPROTOCOLS_GETQUOTED_NAME "getquoted"
-#define MICROPROTOCOLS_GETSTRING_NAME "getstring"
-#define MICROPROTOCOLS_GETBINARY_NAME "getbinary"
-
-/** exported functions **/
-
-/* used by module.c to init the microprotocols system */
-extern int pysqlite_microprotocols_init(PyObject *dict);
-extern int pysqlite_microprotocols_add(
-    PyTypeObject *type, PyObject *proto, PyObject *cast);
-extern PyObject *pysqlite_microprotocols_adapt(
-    PyObject *obj, PyObject *proto, PyObject *alt);
-
-extern PyObject *
-    pysqlite_adapt(pysqlite_Cursor* self, PyObject *args);
-#define pysqlite_adapt_doc \
-    "adapt(obj, protocol, alternate) -> adapt obj to given protocol. Non-standard."
-
-#endif /* !defined(PSYCOPG_MICROPROTOCOLS_H) */
+#include <Python.h> 
+ 
+/** the names of the three mandatory methods **/ 
+ 
+#define MICROPROTOCOLS_GETQUOTED_NAME "getquoted" 
+#define MICROPROTOCOLS_GETSTRING_NAME "getstring" 
+#define MICROPROTOCOLS_GETBINARY_NAME "getbinary" 
+ 
+/** exported functions **/ 
+ 
+/* used by module.c to init the microprotocols system */ 
+extern int pysqlite_microprotocols_init(PyObject *dict); 
+extern int pysqlite_microprotocols_add( 
+    PyTypeObject *type, PyObject *proto, PyObject *cast); 
+extern PyObject *pysqlite_microprotocols_adapt( 
+    PyObject *obj, PyObject *proto, PyObject *alt); 
+ 
+extern PyObject * 
+    pysqlite_adapt(pysqlite_Cursor* self, PyObject *args); 
+#define pysqlite_adapt_doc \ 
+    "adapt(obj, protocol, alternate) -> adapt obj to given protocol. Non-standard." 
+ 
+#endif /* !defined(PSYCOPG_MICROPROTOCOLS_H) */ 
diff --git a/contrib/tools/python3/src/Modules/_sqlite/module.c b/contrib/tools/python3/src/Modules/_sqlite/module.c
index 44811835d42..d43280b4f2c 100644
--- a/contrib/tools/python3/src/Modules/_sqlite/module.c
+++ b/contrib/tools/python3/src/Modules/_sqlite/module.c
@@ -1,343 +1,343 @@
-/* module.c - the module itself
- *
- * Copyright (C) 2004-2010 Gerhard Häring <[email protected]>
- *
- * This file is part of pysqlite.
- *
- * This software is provided 'as-is', without any express or implied
- * warranty.  In no event will the authors be held liable for any damages
- * arising from the use of this software.
- *
- * Permission is granted to anyone to use this software for any purpose,
- * including commercial applications, and to alter it and redistribute it
- * freely, subject to the following restrictions:
- *
- * 1. The origin of this software must not be misrepresented; you must not
- *    claim that you wrote the original software. If you use this software
- *    in a product, an acknowledgment in the product documentation would be
- *    appreciated but is not required.
- * 2. Altered source versions must be plainly marked as such, and must not be
- *    misrepresented as being the original software.
- * 3. This notice may not be removed or altered from any source distribution.
- */
-
-#include "connection.h"
-#include "statement.h"
-#include "cursor.h"
-#include "cache.h"
-#include "prepare_protocol.h"
-#include "microprotocols.h"
-#include "row.h"
-
-#if SQLITE_VERSION_NUMBER >= 3003003
-#define HAVE_SHARED_CACHE
-#endif
-
-/* static objects at module-level */
-
-PyObject *pysqlite_Error = NULL;
-PyObject *pysqlite_Warning = NULL;
-PyObject *pysqlite_InterfaceError = NULL;
-PyObject *pysqlite_DatabaseError = NULL;
-PyObject *pysqlite_InternalError = NULL;
-PyObject *pysqlite_OperationalError = NULL;
-PyObject *pysqlite_ProgrammingError = NULL;
-PyObject *pysqlite_IntegrityError = NULL;
-PyObject *pysqlite_DataError = NULL;
-PyObject *pysqlite_NotSupportedError = NULL;
-
-PyObject* _pysqlite_converters = NULL;
-int _pysqlite_enable_callback_tracebacks = 0;
-int pysqlite_BaseTypeAdapted = 0;
-
-static PyObject* module_connect(PyObject* self, PyObject* args, PyObject*
-        kwargs)
-{
-    /* Python seems to have no way of extracting a single keyword-arg at
-     * C-level, so this code is redundant with the one in connection_init in
-     * connection.c and must always be copied from there ... */
-
-    static char *kwlist[] = {
-        "database", "timeout", "detect_types", "isolation_level",
-        "check_same_thread", "factory", "cached_statements", "uri",
-        NULL
-    };
-    PyObject* database;
-    int detect_types = 0;
-    PyObject* isolation_level;
-    PyObject* factory = NULL;
-    int check_same_thread = 1;
-    int cached_statements;
-    int uri = 0;
-    double timeout = 5.0;
-
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|diOiOip", kwlist,
-                                     &database, &timeout, &detect_types,
-                                     &isolation_level, &check_same_thread,
-                                     &factory, &cached_statements, &uri))
-    {
-        return NULL;
-    }
-
-    if (factory == NULL) {
-        factory = (PyObject*)&pysqlite_ConnectionType;
-    }
-
+/* module.c - the module itself 
+ * 
+ * Copyright (C) 2004-2010 Gerhard Häring <[email protected]> 
+ * 
+ * This file is part of pysqlite. 
+ * 
+ * This software is provided 'as-is', without any express or implied 
+ * warranty.  In no event will the authors be held liable for any damages 
+ * arising from the use of this software. 
+ * 
+ * Permission is granted to anyone to use this software for any purpose, 
+ * including commercial applications, and to alter it and redistribute it 
+ * freely, subject to the following restrictions: 
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not 
+ *    claim that you wrote the original software. If you use this software 
+ *    in a product, an acknowledgment in the product documentation would be 
+ *    appreciated but is not required. 
+ * 2. Altered source versions must be plainly marked as such, and must not be 
+ *    misrepresented as being the original software. 
+ * 3. This notice may not be removed or altered from any source distribution. 
+ */ 
+ 
+#include "connection.h" 
+#include "statement.h" 
+#include "cursor.h" 
+#include "cache.h" 
+#include "prepare_protocol.h" 
+#include "microprotocols.h" 
+#include "row.h" 
+ 
+#if SQLITE_VERSION_NUMBER >= 3003003 
+#define HAVE_SHARED_CACHE 
+#endif 
+ 
+/* static objects at module-level */ 
+ 
+PyObject *pysqlite_Error = NULL; 
+PyObject *pysqlite_Warning = NULL; 
+PyObject *pysqlite_InterfaceError = NULL; 
+PyObject *pysqlite_DatabaseError = NULL; 
+PyObject *pysqlite_InternalError = NULL; 
+PyObject *pysqlite_OperationalError = NULL; 
+PyObject *pysqlite_ProgrammingError = NULL; 
+PyObject *pysqlite_IntegrityError = NULL; 
+PyObject *pysqlite_DataError = NULL; 
+PyObject *pysqlite_NotSupportedError = NULL; 
+ 
+PyObject* _pysqlite_converters = NULL; 
+int _pysqlite_enable_callback_tracebacks = 0; 
+int pysqlite_BaseTypeAdapted = 0; 
+ 
+static PyObject* module_connect(PyObject* self, PyObject* args, PyObject* 
+        kwargs) 
+{ 
+    /* Python seems to have no way of extracting a single keyword-arg at 
+     * C-level, so this code is redundant with the one in connection_init in 
+     * connection.c and must always be copied from there ... */ 
+ 
+    static char *kwlist[] = { 
+        "database", "timeout", "detect_types", "isolation_level", 
+        "check_same_thread", "factory", "cached_statements", "uri", 
+        NULL 
+    }; 
+    PyObject* database; 
+    int detect_types = 0; 
+    PyObject* isolation_level; 
+    PyObject* factory = NULL; 
+    int check_same_thread = 1; 
+    int cached_statements; 
+    int uri = 0; 
+    double timeout = 5.0; 
+ 
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|diOiOip", kwlist, 
+                                     &database, &timeout, &detect_types, 
+                                     &isolation_level, &check_same_thread, 
+                                     &factory, &cached_statements, &uri)) 
+    { 
+        return NULL; 
+    } 
+ 
+    if (factory == NULL) { 
+        factory = (PyObject*)&pysqlite_ConnectionType; 
+    } 
+ 
     return PyObject_Call(factory, args, kwargs);
-}
-
-PyDoc_STRVAR(module_connect_doc,
-"connect(database[, timeout, detect_types, isolation_level,\n\
-        check_same_thread, factory, cached_statements, uri])\n\
-\n\
-Opens a connection to the SQLite database file *database*. You can use\n\
-\":memory:\" to open a database connection to a database that resides in\n\
-RAM instead of on disk.");
-
-static PyObject* module_complete(PyObject* self, PyObject* args, PyObject*
-        kwargs)
-{
+} 
+ 
+PyDoc_STRVAR(module_connect_doc, 
+"connect(database[, timeout, detect_types, isolation_level,\n\ 
+        check_same_thread, factory, cached_statements, uri])\n\ 
+\n\ 
+Opens a connection to the SQLite database file *database*. You can use\n\ 
+\":memory:\" to open a database connection to a database that resides in\n\ 
+RAM instead of on disk."); 
+ 
+static PyObject* module_complete(PyObject* self, PyObject* args, PyObject* 
+        kwargs) 
+{ 
     static char *kwlist[] = {"statement", NULL};
-    char* statement;
-
-    PyObject* result;
-
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s", kwlist, &statement))
-    {
-        return NULL;
-    }
-
-    if (sqlite3_complete(statement)) {
-        result = Py_True;
-    } else {
-        result = Py_False;
-    }
-
-    Py_INCREF(result);
-
-    return result;
-}
-
-PyDoc_STRVAR(module_complete_doc,
-"complete_statement(sql)\n\
-\n\
-Checks if a string contains a complete SQL statement. Non-standard.");
-
-#ifdef HAVE_SHARED_CACHE
-static PyObject* module_enable_shared_cache(PyObject* self, PyObject* args, PyObject*
-        kwargs)
-{
+    char* statement; 
+ 
+    PyObject* result; 
+ 
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s", kwlist, &statement)) 
+    { 
+        return NULL; 
+    } 
+ 
+    if (sqlite3_complete(statement)) { 
+        result = Py_True; 
+    } else { 
+        result = Py_False; 
+    } 
+ 
+    Py_INCREF(result); 
+ 
+    return result; 
+} 
+ 
+PyDoc_STRVAR(module_complete_doc, 
+"complete_statement(sql)\n\ 
+\n\ 
+Checks if a string contains a complete SQL statement. Non-standard."); 
+ 
+#ifdef HAVE_SHARED_CACHE 
+static PyObject* module_enable_shared_cache(PyObject* self, PyObject* args, PyObject* 
+        kwargs) 
+{ 
     static char *kwlist[] = {"do_enable", NULL};
-    int do_enable;
-    int rc;
-
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i", kwlist, &do_enable))
-    {
-        return NULL;
-    }
-
-    rc = sqlite3_enable_shared_cache(do_enable);
-
-    if (rc != SQLITE_OK) {
-        PyErr_SetString(pysqlite_OperationalError, "Changing the shared_cache flag failed");
-        return NULL;
-    } else {
-        Py_RETURN_NONE;
-    }
-}
-
-PyDoc_STRVAR(module_enable_shared_cache_doc,
-"enable_shared_cache(do_enable)\n\
-\n\
-Enable or disable shared cache mode for the calling thread.\n\
-Experimental/Non-standard.");
-#endif /* HAVE_SHARED_CACHE */
-
-static PyObject* module_register_adapter(PyObject* self, PyObject* args)
-{
-    PyTypeObject* type;
-    PyObject* caster;
-    int rc;
-
-    if (!PyArg_ParseTuple(args, "OO", &type, &caster)) {
-        return NULL;
-    }
-
-    /* a basic type is adapted; there's a performance optimization if that's not the case
-     * (99 % of all usages) */
-    if (type == &PyLong_Type || type == &PyFloat_Type
-            || type == &PyUnicode_Type || type == &PyByteArray_Type) {
-        pysqlite_BaseTypeAdapted = 1;
-    }
-
-    rc = pysqlite_microprotocols_add(type, (PyObject*)&pysqlite_PrepareProtocolType, caster);
-    if (rc == -1)
-        return NULL;
-
-    Py_RETURN_NONE;
-}
-
-PyDoc_STRVAR(module_register_adapter_doc,
-"register_adapter(type, callable)\n\
-\n\
-Registers an adapter with pysqlite's adapter registry. Non-standard.");
-
-static PyObject* module_register_converter(PyObject* self, PyObject* args)
-{
-    PyObject* orig_name;
-    PyObject* name = NULL;
-    PyObject* callable;
-    PyObject* retval = NULL;
-    _Py_IDENTIFIER(upper);
-
-    if (!PyArg_ParseTuple(args, "UO", &orig_name, &callable)) {
-        return NULL;
-    }
-
-    /* convert the name to upper case */
+    int do_enable; 
+    int rc; 
+ 
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i", kwlist, &do_enable)) 
+    { 
+        return NULL; 
+    } 
+ 
+    rc = sqlite3_enable_shared_cache(do_enable); 
+ 
+    if (rc != SQLITE_OK) { 
+        PyErr_SetString(pysqlite_OperationalError, "Changing the shared_cache flag failed"); 
+        return NULL; 
+    } else { 
+        Py_RETURN_NONE; 
+    } 
+} 
+ 
+PyDoc_STRVAR(module_enable_shared_cache_doc, 
+"enable_shared_cache(do_enable)\n\ 
+\n\ 
+Enable or disable shared cache mode for the calling thread.\n\ 
+Experimental/Non-standard."); 
+#endif /* HAVE_SHARED_CACHE */ 
+ 
+static PyObject* module_register_adapter(PyObject* self, PyObject* args) 
+{ 
+    PyTypeObject* type; 
+    PyObject* caster; 
+    int rc; 
+ 
+    if (!PyArg_ParseTuple(args, "OO", &type, &caster)) { 
+        return NULL; 
+    } 
+ 
+    /* a basic type is adapted; there's a performance optimization if that's not the case 
+     * (99 % of all usages) */ 
+    if (type == &PyLong_Type || type == &PyFloat_Type 
+            || type == &PyUnicode_Type || type == &PyByteArray_Type) { 
+        pysqlite_BaseTypeAdapted = 1; 
+    } 
+ 
+    rc = pysqlite_microprotocols_add(type, (PyObject*)&pysqlite_PrepareProtocolType, caster); 
+    if (rc == -1) 
+        return NULL; 
+ 
+    Py_RETURN_NONE; 
+} 
+ 
+PyDoc_STRVAR(module_register_adapter_doc, 
+"register_adapter(type, callable)\n\ 
+\n\ 
+Registers an adapter with pysqlite's adapter registry. Non-standard."); 
+ 
+static PyObject* module_register_converter(PyObject* self, PyObject* args) 
+{ 
+    PyObject* orig_name; 
+    PyObject* name = NULL; 
+    PyObject* callable; 
+    PyObject* retval = NULL; 
+    _Py_IDENTIFIER(upper); 
+ 
+    if (!PyArg_ParseTuple(args, "UO", &orig_name, &callable)) { 
+        return NULL; 
+    } 
+ 
+    /* convert the name to upper case */ 
     name = _PyObject_CallMethodIdNoArgs(orig_name, &PyId_upper);
-    if (!name) {
-        goto error;
-    }
-
-    if (PyDict_SetItem(_pysqlite_converters, name, callable) != 0) {
-        goto error;
-    }
-
-    Py_INCREF(Py_None);
-    retval = Py_None;
-error:
-    Py_XDECREF(name);
-    return retval;
-}
-
-PyDoc_STRVAR(module_register_converter_doc,
-"register_converter(typename, callable)\n\
-\n\
-Registers a converter with pysqlite. Non-standard.");
-
-static PyObject* enable_callback_tracebacks(PyObject* self, PyObject* args)
-{
-    if (!PyArg_ParseTuple(args, "i", &_pysqlite_enable_callback_tracebacks)) {
-        return NULL;
-    }
-
-    Py_RETURN_NONE;
-}
-
-PyDoc_STRVAR(enable_callback_tracebacks_doc,
-"enable_callback_tracebacks(flag)\n\
-\n\
-Enable or disable callback functions throwing errors to stderr.");
-
-static void converters_init(PyObject* dict)
-{
-    _pysqlite_converters = PyDict_New();
-    if (!_pysqlite_converters) {
-        return;
-    }
-
-    PyDict_SetItemString(dict, "converters", _pysqlite_converters);
-}
-
-static PyMethodDef module_methods[] = {
+    if (!name) { 
+        goto error; 
+    } 
+ 
+    if (PyDict_SetItem(_pysqlite_converters, name, callable) != 0) { 
+        goto error; 
+    } 
+ 
+    Py_INCREF(Py_None); 
+    retval = Py_None; 
+error: 
+    Py_XDECREF(name); 
+    return retval; 
+} 
+ 
+PyDoc_STRVAR(module_register_converter_doc, 
+"register_converter(typename, callable)\n\ 
+\n\ 
+Registers a converter with pysqlite. Non-standard."); 
+ 
+static PyObject* enable_callback_tracebacks(PyObject* self, PyObject* args) 
+{ 
+    if (!PyArg_ParseTuple(args, "i", &_pysqlite_enable_callback_tracebacks)) { 
+        return NULL; 
+    } 
+ 
+    Py_RETURN_NONE; 
+} 
+ 
+PyDoc_STRVAR(enable_callback_tracebacks_doc, 
+"enable_callback_tracebacks(flag)\n\ 
+\n\ 
+Enable or disable callback functions throwing errors to stderr."); 
+ 
+static void converters_init(PyObject* dict) 
+{ 
+    _pysqlite_converters = PyDict_New(); 
+    if (!_pysqlite_converters) { 
+        return; 
+    } 
+ 
+    PyDict_SetItemString(dict, "converters", _pysqlite_converters); 
+} 
+ 
+static PyMethodDef module_methods[] = { 
     {"connect",  (PyCFunction)(void(*)(void))module_connect,
-     METH_VARARGS | METH_KEYWORDS, module_connect_doc},
+     METH_VARARGS | METH_KEYWORDS, module_connect_doc}, 
     {"complete_statement",  (PyCFunction)(void(*)(void))module_complete,
-     METH_VARARGS | METH_KEYWORDS, module_complete_doc},
-#ifdef HAVE_SHARED_CACHE
+     METH_VARARGS | METH_KEYWORDS, module_complete_doc}, 
+#ifdef HAVE_SHARED_CACHE 
     {"enable_shared_cache",  (PyCFunction)(void(*)(void))module_enable_shared_cache,
-     METH_VARARGS | METH_KEYWORDS, module_enable_shared_cache_doc},
-#endif
-    {"register_adapter", (PyCFunction)module_register_adapter,
-     METH_VARARGS, module_register_adapter_doc},
-    {"register_converter", (PyCFunction)module_register_converter,
-     METH_VARARGS, module_register_converter_doc},
-    {"adapt",  (PyCFunction)pysqlite_adapt, METH_VARARGS,
-     pysqlite_adapt_doc},
-    {"enable_callback_tracebacks",  (PyCFunction)enable_callback_tracebacks,
-     METH_VARARGS, enable_callback_tracebacks_doc},
-    {NULL, NULL}
-};
-
-struct _IntConstantPair {
-    const char *constant_name;
-    int constant_value;
-};
-
-typedef struct _IntConstantPair IntConstantPair;
-
-static const IntConstantPair _int_constants[] = {
-    {"PARSE_DECLTYPES", PARSE_DECLTYPES},
-    {"PARSE_COLNAMES", PARSE_COLNAMES},
-
-    {"SQLITE_OK", SQLITE_OK},
-    {"SQLITE_DENY", SQLITE_DENY},
-    {"SQLITE_IGNORE", SQLITE_IGNORE},
-    {"SQLITE_CREATE_INDEX", SQLITE_CREATE_INDEX},
-    {"SQLITE_CREATE_TABLE", SQLITE_CREATE_TABLE},
-    {"SQLITE_CREATE_TEMP_INDEX", SQLITE_CREATE_TEMP_INDEX},
-    {"SQLITE_CREATE_TEMP_TABLE", SQLITE_CREATE_TEMP_TABLE},
-    {"SQLITE_CREATE_TEMP_TRIGGER", SQLITE_CREATE_TEMP_TRIGGER},
-    {"SQLITE_CREATE_TEMP_VIEW", SQLITE_CREATE_TEMP_VIEW},
-    {"SQLITE_CREATE_TRIGGER", SQLITE_CREATE_TRIGGER},
-    {"SQLITE_CREATE_VIEW", SQLITE_CREATE_VIEW},
-    {"SQLITE_DELETE", SQLITE_DELETE},
-    {"SQLITE_DROP_INDEX", SQLITE_DROP_INDEX},
-    {"SQLITE_DROP_TABLE", SQLITE_DROP_TABLE},
-    {"SQLITE_DROP_TEMP_INDEX", SQLITE_DROP_TEMP_INDEX},
-    {"SQLITE_DROP_TEMP_TABLE", SQLITE_DROP_TEMP_TABLE},
-    {"SQLITE_DROP_TEMP_TRIGGER", SQLITE_DROP_TEMP_TRIGGER},
-    {"SQLITE_DROP_TEMP_VIEW", SQLITE_DROP_TEMP_VIEW},
-    {"SQLITE_DROP_TRIGGER", SQLITE_DROP_TRIGGER},
-    {"SQLITE_DROP_VIEW", SQLITE_DROP_VIEW},
-    {"SQLITE_INSERT", SQLITE_INSERT},
-    {"SQLITE_PRAGMA", SQLITE_PRAGMA},
-    {"SQLITE_READ", SQLITE_READ},
-    {"SQLITE_SELECT", SQLITE_SELECT},
-    {"SQLITE_TRANSACTION", SQLITE_TRANSACTION},
-    {"SQLITE_UPDATE", SQLITE_UPDATE},
-    {"SQLITE_ATTACH", SQLITE_ATTACH},
-    {"SQLITE_DETACH", SQLITE_DETACH},
-#if SQLITE_VERSION_NUMBER >= 3002001
-    {"SQLITE_ALTER_TABLE", SQLITE_ALTER_TABLE},
-    {"SQLITE_REINDEX", SQLITE_REINDEX},
-#endif
-#if SQLITE_VERSION_NUMBER >= 3003000
-    {"SQLITE_ANALYZE", SQLITE_ANALYZE},
-#endif
-#if SQLITE_VERSION_NUMBER >= 3003007
-    {"SQLITE_CREATE_VTABLE", SQLITE_CREATE_VTABLE},
-    {"SQLITE_DROP_VTABLE", SQLITE_DROP_VTABLE},
-#endif
-#if SQLITE_VERSION_NUMBER >= 3003008
-    {"SQLITE_FUNCTION", SQLITE_FUNCTION},
-#endif
-#if SQLITE_VERSION_NUMBER >= 3006008
-    {"SQLITE_SAVEPOINT", SQLITE_SAVEPOINT},
-#endif
-#if SQLITE_VERSION_NUMBER >= 3008003
-    {"SQLITE_RECURSIVE", SQLITE_RECURSIVE},
-#endif
-#if SQLITE_VERSION_NUMBER >= 3006011
-    {"SQLITE_DONE", SQLITE_DONE},
-#endif
-    {(char*)NULL, 0}
-};
-
-
-static struct PyModuleDef _sqlite3module = {
-        PyModuleDef_HEAD_INIT,
-        "_sqlite3",
-        NULL,
-        -1,
-        module_methods,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-};
-
+     METH_VARARGS | METH_KEYWORDS, module_enable_shared_cache_doc}, 
+#endif 
+    {"register_adapter", (PyCFunction)module_register_adapter, 
+     METH_VARARGS, module_register_adapter_doc}, 
+    {"register_converter", (PyCFunction)module_register_converter, 
+     METH_VARARGS, module_register_converter_doc}, 
+    {"adapt",  (PyCFunction)pysqlite_adapt, METH_VARARGS, 
+     pysqlite_adapt_doc}, 
+    {"enable_callback_tracebacks",  (PyCFunction)enable_callback_tracebacks, 
+     METH_VARARGS, enable_callback_tracebacks_doc}, 
+    {NULL, NULL} 
+}; 
+ 
+struct _IntConstantPair { 
+    const char *constant_name; 
+    int constant_value; 
+}; 
+ 
+typedef struct _IntConstantPair IntConstantPair; 
+ 
+static const IntConstantPair _int_constants[] = { 
+    {"PARSE_DECLTYPES", PARSE_DECLTYPES}, 
+    {"PARSE_COLNAMES", PARSE_COLNAMES}, 
+ 
+    {"SQLITE_OK", SQLITE_OK}, 
+    {"SQLITE_DENY", SQLITE_DENY}, 
+    {"SQLITE_IGNORE", SQLITE_IGNORE}, 
+    {"SQLITE_CREATE_INDEX", SQLITE_CREATE_INDEX}, 
+    {"SQLITE_CREATE_TABLE", SQLITE_CREATE_TABLE}, 
+    {"SQLITE_CREATE_TEMP_INDEX", SQLITE_CREATE_TEMP_INDEX}, 
+    {"SQLITE_CREATE_TEMP_TABLE", SQLITE_CREATE_TEMP_TABLE}, 
+    {"SQLITE_CREATE_TEMP_TRIGGER", SQLITE_CREATE_TEMP_TRIGGER}, 
+    {"SQLITE_CREATE_TEMP_VIEW", SQLITE_CREATE_TEMP_VIEW}, 
+    {"SQLITE_CREATE_TRIGGER", SQLITE_CREATE_TRIGGER}, 
+    {"SQLITE_CREATE_VIEW", SQLITE_CREATE_VIEW}, 
+    {"SQLITE_DELETE", SQLITE_DELETE}, 
+    {"SQLITE_DROP_INDEX", SQLITE_DROP_INDEX}, 
+    {"SQLITE_DROP_TABLE", SQLITE_DROP_TABLE}, 
+    {"SQLITE_DROP_TEMP_INDEX", SQLITE_DROP_TEMP_INDEX}, 
+    {"SQLITE_DROP_TEMP_TABLE", SQLITE_DROP_TEMP_TABLE}, 
+    {"SQLITE_DROP_TEMP_TRIGGER", SQLITE_DROP_TEMP_TRIGGER}, 
+    {"SQLITE_DROP_TEMP_VIEW", SQLITE_DROP_TEMP_VIEW}, 
+    {"SQLITE_DROP_TRIGGER", SQLITE_DROP_TRIGGER}, 
+    {"SQLITE_DROP_VIEW", SQLITE_DROP_VIEW}, 
+    {"SQLITE_INSERT", SQLITE_INSERT}, 
+    {"SQLITE_PRAGMA", SQLITE_PRAGMA}, 
+    {"SQLITE_READ", SQLITE_READ}, 
+    {"SQLITE_SELECT", SQLITE_SELECT}, 
+    {"SQLITE_TRANSACTION", SQLITE_TRANSACTION}, 
+    {"SQLITE_UPDATE", SQLITE_UPDATE}, 
+    {"SQLITE_ATTACH", SQLITE_ATTACH}, 
+    {"SQLITE_DETACH", SQLITE_DETACH}, 
+#if SQLITE_VERSION_NUMBER >= 3002001 
+    {"SQLITE_ALTER_TABLE", SQLITE_ALTER_TABLE}, 
+    {"SQLITE_REINDEX", SQLITE_REINDEX}, 
+#endif 
+#if SQLITE_VERSION_NUMBER >= 3003000 
+    {"SQLITE_ANALYZE", SQLITE_ANALYZE}, 
+#endif 
+#if SQLITE_VERSION_NUMBER >= 3003007 
+    {"SQLITE_CREATE_VTABLE", SQLITE_CREATE_VTABLE}, 
+    {"SQLITE_DROP_VTABLE", SQLITE_DROP_VTABLE}, 
+#endif 
+#if SQLITE_VERSION_NUMBER >= 3003008 
+    {"SQLITE_FUNCTION", SQLITE_FUNCTION}, 
+#endif 
+#if SQLITE_VERSION_NUMBER >= 3006008 
+    {"SQLITE_SAVEPOINT", SQLITE_SAVEPOINT}, 
+#endif 
+#if SQLITE_VERSION_NUMBER >= 3008003 
+    {"SQLITE_RECURSIVE", SQLITE_RECURSIVE}, 
+#endif 
+#if SQLITE_VERSION_NUMBER >= 3006011 
+    {"SQLITE_DONE", SQLITE_DONE}, 
+#endif 
+    {(char*)NULL, 0} 
+}; 
+ 
+ 
+static struct PyModuleDef _sqlite3module = { 
+        PyModuleDef_HEAD_INIT, 
+        "_sqlite3", 
+        NULL, 
+        -1, 
+        module_methods, 
+        NULL, 
+        NULL, 
+        NULL, 
+        NULL 
+}; 
+ 
 #define ADD_TYPE(module, type)                 \
 do {                                           \
     if (PyModule_AddType(module, &type) < 0) { \
@@ -346,133 +346,133 @@ do {                                           \
     }                                          \
 } while (0)
 
-PyMODINIT_FUNC PyInit__sqlite3(void)
-{
-    PyObject *module, *dict;
-    PyObject *tmp_obj;
-    int i;
-
-    module = PyModule_Create(&_sqlite3module);
-
-    if (!module ||
-        (pysqlite_row_setup_types() < 0) ||
-        (pysqlite_cursor_setup_types() < 0) ||
-        (pysqlite_connection_setup_types() < 0) ||
-        (pysqlite_cache_setup_types() < 0) ||
-        (pysqlite_statement_setup_types() < 0) ||
-        (pysqlite_prepare_protocol_setup_types() < 0)
-       ) {
-        Py_XDECREF(module);
-        return NULL;
-    }
-
+PyMODINIT_FUNC PyInit__sqlite3(void) 
+{ 
+    PyObject *module, *dict; 
+    PyObject *tmp_obj; 
+    int i; 
+ 
+    module = PyModule_Create(&_sqlite3module); 
+ 
+    if (!module || 
+        (pysqlite_row_setup_types() < 0) || 
+        (pysqlite_cursor_setup_types() < 0) || 
+        (pysqlite_connection_setup_types() < 0) || 
+        (pysqlite_cache_setup_types() < 0) || 
+        (pysqlite_statement_setup_types() < 0) || 
+        (pysqlite_prepare_protocol_setup_types() < 0) 
+       ) { 
+        Py_XDECREF(module); 
+        return NULL; 
+    } 
+ 
     ADD_TYPE(module, pysqlite_ConnectionType);
     ADD_TYPE(module, pysqlite_CursorType);
     ADD_TYPE(module, pysqlite_PrepareProtocolType);
     ADD_TYPE(module, pysqlite_RowType);
-
-    if (!(dict = PyModule_GetDict(module))) {
-        goto error;
-    }
-
-    /*** Create DB-API Exception hierarchy */
-
-    if (!(pysqlite_Error = PyErr_NewException(MODULE_NAME ".Error", PyExc_Exception, NULL))) {
-        goto error;
-    }
-    PyDict_SetItemString(dict, "Error", pysqlite_Error);
-
-    if (!(pysqlite_Warning = PyErr_NewException(MODULE_NAME ".Warning", PyExc_Exception, NULL))) {
-        goto error;
-    }
-    PyDict_SetItemString(dict, "Warning", pysqlite_Warning);
-
-    /* Error subclasses */
-
-    if (!(pysqlite_InterfaceError = PyErr_NewException(MODULE_NAME ".InterfaceError", pysqlite_Error, NULL))) {
-        goto error;
-    }
-    PyDict_SetItemString(dict, "InterfaceError", pysqlite_InterfaceError);
-
-    if (!(pysqlite_DatabaseError = PyErr_NewException(MODULE_NAME ".DatabaseError", pysqlite_Error, NULL))) {
-        goto error;
-    }
-    PyDict_SetItemString(dict, "DatabaseError", pysqlite_DatabaseError);
-
-    /* pysqlite_DatabaseError subclasses */
-
-    if (!(pysqlite_InternalError = PyErr_NewException(MODULE_NAME ".InternalError", pysqlite_DatabaseError, NULL))) {
-        goto error;
-    }
-    PyDict_SetItemString(dict, "InternalError", pysqlite_InternalError);
-
-    if (!(pysqlite_OperationalError = PyErr_NewException(MODULE_NAME ".OperationalError", pysqlite_DatabaseError, NULL))) {
-        goto error;
-    }
-    PyDict_SetItemString(dict, "OperationalError", pysqlite_OperationalError);
-
-    if (!(pysqlite_ProgrammingError = PyErr_NewException(MODULE_NAME ".ProgrammingError", pysqlite_DatabaseError, NULL))) {
-        goto error;
-    }
-    PyDict_SetItemString(dict, "ProgrammingError", pysqlite_ProgrammingError);
-
-    if (!(pysqlite_IntegrityError = PyErr_NewException(MODULE_NAME ".IntegrityError", pysqlite_DatabaseError,NULL))) {
-        goto error;
-    }
-    PyDict_SetItemString(dict, "IntegrityError", pysqlite_IntegrityError);
-
-    if (!(pysqlite_DataError = PyErr_NewException(MODULE_NAME ".DataError", pysqlite_DatabaseError, NULL))) {
-        goto error;
-    }
-    PyDict_SetItemString(dict, "DataError", pysqlite_DataError);
-
-    if (!(pysqlite_NotSupportedError = PyErr_NewException(MODULE_NAME ".NotSupportedError", pysqlite_DatabaseError, NULL))) {
-        goto error;
-    }
-    PyDict_SetItemString(dict, "NotSupportedError", pysqlite_NotSupportedError);
-
-    /* In Python 2.x, setting Connection.text_factory to
-       OptimizedUnicode caused Unicode objects to be returned for
-       non-ASCII data and bytestrings to be returned for ASCII data.
-       Now OptimizedUnicode is an alias for str, so it has no
-       effect. */
-    Py_INCREF((PyObject*)&PyUnicode_Type);
-    PyDict_SetItemString(dict, "OptimizedUnicode", (PyObject*)&PyUnicode_Type);
-
-    /* Set integer constants */
-    for (i = 0; _int_constants[i].constant_name != NULL; i++) {
-        tmp_obj = PyLong_FromLong(_int_constants[i].constant_value);
-        if (!tmp_obj) {
-            goto error;
-        }
-        PyDict_SetItemString(dict, _int_constants[i].constant_name, tmp_obj);
-        Py_DECREF(tmp_obj);
-    }
-
-    if (!(tmp_obj = PyUnicode_FromString(PYSQLITE_VERSION))) {
-        goto error;
-    }
-    PyDict_SetItemString(dict, "version", tmp_obj);
-    Py_DECREF(tmp_obj);
-
-    if (!(tmp_obj = PyUnicode_FromString(sqlite3_libversion()))) {
-        goto error;
-    }
-    PyDict_SetItemString(dict, "sqlite_version", tmp_obj);
-    Py_DECREF(tmp_obj);
-
-    /* initialize microprotocols layer */
-    pysqlite_microprotocols_init(dict);
-
-    /* initialize the default converters */
-    converters_init(dict);
-
-error:
-    if (PyErr_Occurred())
-    {
-        PyErr_SetString(PyExc_ImportError, MODULE_NAME ": init failed");
-        Py_DECREF(module);
-        module = NULL;
-    }
-    return module;
-}
+ 
+    if (!(dict = PyModule_GetDict(module))) { 
+        goto error; 
+    } 
+ 
+    /*** Create DB-API Exception hierarchy */ 
+ 
+    if (!(pysqlite_Error = PyErr_NewException(MODULE_NAME ".Error", PyExc_Exception, NULL))) { 
+        goto error; 
+    } 
+    PyDict_SetItemString(dict, "Error", pysqlite_Error); 
+ 
+    if (!(pysqlite_Warning = PyErr_NewException(MODULE_NAME ".Warning", PyExc_Exception, NULL))) { 
+        goto error; 
+    } 
+    PyDict_SetItemString(dict, "Warning", pysqlite_Warning); 
+ 
+    /* Error subclasses */ 
+ 
+    if (!(pysqlite_InterfaceError = PyErr_NewException(MODULE_NAME ".InterfaceError", pysqlite_Error, NULL))) { 
+        goto error; 
+    } 
+    PyDict_SetItemString(dict, "InterfaceError", pysqlite_InterfaceError); 
+ 
+    if (!(pysqlite_DatabaseError = PyErr_NewException(MODULE_NAME ".DatabaseError", pysqlite_Error, NULL))) { 
+        goto error; 
+    } 
+    PyDict_SetItemString(dict, "DatabaseError", pysqlite_DatabaseError); 
+ 
+    /* pysqlite_DatabaseError subclasses */ 
+ 
+    if (!(pysqlite_InternalError = PyErr_NewException(MODULE_NAME ".InternalError", pysqlite_DatabaseError, NULL))) { 
+        goto error; 
+    } 
+    PyDict_SetItemString(dict, "InternalError", pysqlite_InternalError); 
+ 
+    if (!(pysqlite_OperationalError = PyErr_NewException(MODULE_NAME ".OperationalError", pysqlite_DatabaseError, NULL))) { 
+        goto error; 
+    } 
+    PyDict_SetItemString(dict, "OperationalError", pysqlite_OperationalError); 
+ 
+    if (!(pysqlite_ProgrammingError = PyErr_NewException(MODULE_NAME ".ProgrammingError", pysqlite_DatabaseError, NULL))) { 
+        goto error; 
+    } 
+    PyDict_SetItemString(dict, "ProgrammingError", pysqlite_ProgrammingError); 
+ 
+    if (!(pysqlite_IntegrityError = PyErr_NewException(MODULE_NAME ".IntegrityError", pysqlite_DatabaseError,NULL))) { 
+        goto error; 
+    } 
+    PyDict_SetItemString(dict, "IntegrityError", pysqlite_IntegrityError); 
+ 
+    if (!(pysqlite_DataError = PyErr_NewException(MODULE_NAME ".DataError", pysqlite_DatabaseError, NULL))) { 
+        goto error; 
+    } 
+    PyDict_SetItemString(dict, "DataError", pysqlite_DataError); 
+ 
+    if (!(pysqlite_NotSupportedError = PyErr_NewException(MODULE_NAME ".NotSupportedError", pysqlite_DatabaseError, NULL))) { 
+        goto error; 
+    } 
+    PyDict_SetItemString(dict, "NotSupportedError", pysqlite_NotSupportedError); 
+ 
+    /* In Python 2.x, setting Connection.text_factory to 
+       OptimizedUnicode caused Unicode objects to be returned for 
+       non-ASCII data and bytestrings to be returned for ASCII data. 
+       Now OptimizedUnicode is an alias for str, so it has no 
+       effect. */ 
+    Py_INCREF((PyObject*)&PyUnicode_Type); 
+    PyDict_SetItemString(dict, "OptimizedUnicode", (PyObject*)&PyUnicode_Type); 
+ 
+    /* Set integer constants */ 
+    for (i = 0; _int_constants[i].constant_name != NULL; i++) { 
+        tmp_obj = PyLong_FromLong(_int_constants[i].constant_value); 
+        if (!tmp_obj) { 
+            goto error; 
+        } 
+        PyDict_SetItemString(dict, _int_constants[i].constant_name, tmp_obj); 
+        Py_DECREF(tmp_obj); 
+    } 
+ 
+    if (!(tmp_obj = PyUnicode_FromString(PYSQLITE_VERSION))) { 
+        goto error; 
+    } 
+    PyDict_SetItemString(dict, "version", tmp_obj); 
+    Py_DECREF(tmp_obj); 
+ 
+    if (!(tmp_obj = PyUnicode_FromString(sqlite3_libversion()))) { 
+        goto error; 
+    } 
+    PyDict_SetItemString(dict, "sqlite_version", tmp_obj); 
+    Py_DECREF(tmp_obj); 
+ 
+    /* initialize microprotocols layer */ 
+    pysqlite_microprotocols_init(dict); 
+ 
+    /* initialize the default converters */ 
+    converters_init(dict); 
+ 
+error: 
+    if (PyErr_Occurred()) 
+    { 
+        PyErr_SetString(PyExc_ImportError, MODULE_NAME ": init failed"); 
+        Py_DECREF(module); 
+        module = NULL; 
+    } 
+    return module; 
+} 
diff --git a/contrib/tools/python3/src/Modules/_sqlite/module.h b/contrib/tools/python3/src/Modules/_sqlite/module.h
index 3185ec97888..30794127d39 100644
--- a/contrib/tools/python3/src/Modules/_sqlite/module.h
+++ b/contrib/tools/python3/src/Modules/_sqlite/module.h
@@ -1,53 +1,53 @@
-/* module.h - definitions for the module
- *
- * Copyright (C) 2004-2010 Gerhard Häring <[email protected]>
- *
- * This file is part of pysqlite.
- *
- * This software is provided 'as-is', without any express or implied
- * warranty.  In no event will the authors be held liable for any damages
- * arising from the use of this software.
- *
- * Permission is granted to anyone to use this software for any purpose,
- * including commercial applications, and to alter it and redistribute it
- * freely, subject to the following restrictions:
- *
- * 1. The origin of this software must not be misrepresented; you must not
- *    claim that you wrote the original software. If you use this software
- *    in a product, an acknowledgment in the product documentation would be
- *    appreciated but is not required.
- * 2. Altered source versions must be plainly marked as such, and must not be
- *    misrepresented as being the original software.
- * 3. This notice may not be removed or altered from any source distribution.
- */
-
-#ifndef PYSQLITE_MODULE_H
-#define PYSQLITE_MODULE_H
+/* module.h - definitions for the module 
+ * 
+ * Copyright (C) 2004-2010 Gerhard Häring <[email protected]> 
+ * 
+ * This file is part of pysqlite. 
+ * 
+ * This software is provided 'as-is', without any express or implied 
+ * warranty.  In no event will the authors be held liable for any damages 
+ * arising from the use of this software. 
+ * 
+ * Permission is granted to anyone to use this software for any purpose, 
+ * including commercial applications, and to alter it and redistribute it 
+ * freely, subject to the following restrictions: 
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not 
+ *    claim that you wrote the original software. If you use this software 
+ *    in a product, an acknowledgment in the product documentation would be 
+ *    appreciated but is not required. 
+ * 2. Altered source versions must be plainly marked as such, and must not be 
+ *    misrepresented as being the original software. 
+ * 3. This notice may not be removed or altered from any source distribution. 
+ */ 
+ 
+#ifndef PYSQLITE_MODULE_H 
+#define PYSQLITE_MODULE_H 
 #define PY_SSIZE_T_CLEAN
-#include "Python.h"
-
-#define PYSQLITE_VERSION "2.6.0"
-
-extern PyObject* pysqlite_Error;
-extern PyObject* pysqlite_Warning;
-extern PyObject* pysqlite_InterfaceError;
-extern PyObject* pysqlite_DatabaseError;
-extern PyObject* pysqlite_InternalError;
-extern PyObject* pysqlite_OperationalError;
-extern PyObject* pysqlite_ProgrammingError;
-extern PyObject* pysqlite_IntegrityError;
-extern PyObject* pysqlite_DataError;
-extern PyObject* pysqlite_NotSupportedError;
-
-/* A dictionary, mapping column types (INTEGER, VARCHAR, etc.) to converter
- * functions, that convert the SQL value to the appropriate Python value.
- * The key is uppercase.
- */
-extern PyObject* _pysqlite_converters;
-
-extern int _pysqlite_enable_callback_tracebacks;
-extern int pysqlite_BaseTypeAdapted;
-
-#define PARSE_DECLTYPES 1
-#define PARSE_COLNAMES 2
-#endif
+#include "Python.h" 
+ 
+#define PYSQLITE_VERSION "2.6.0" 
+ 
+extern PyObject* pysqlite_Error; 
+extern PyObject* pysqlite_Warning; 
+extern PyObject* pysqlite_InterfaceError; 
+extern PyObject* pysqlite_DatabaseError; 
+extern PyObject* pysqlite_InternalError; 
+extern PyObject* pysqlite_OperationalError; 
+extern PyObject* pysqlite_ProgrammingError; 
+extern PyObject* pysqlite_IntegrityError; 
+extern PyObject* pysqlite_DataError; 
+extern PyObject* pysqlite_NotSupportedError; 
+ 
+/* A dictionary, mapping column types (INTEGER, VARCHAR, etc.) to converter 
+ * functions, that convert the SQL value to the appropriate Python value. 
+ * The key is uppercase. 
+ */ 
+extern PyObject* _pysqlite_converters; 
+ 
+extern int _pysqlite_enable_callback_tracebacks; 
+extern int pysqlite_BaseTypeAdapted; 
+ 
+#define PARSE_DECLTYPES 1 
+#define PARSE_COLNAMES 2 
+#endif 
diff --git a/contrib/tools/python3/src/Modules/_sqlite/prepare_protocol.c b/contrib/tools/python3/src/Modules/_sqlite/prepare_protocol.c
index 05a2ca5a652..f027f0bea42 100644
--- a/contrib/tools/python3/src/Modules/_sqlite/prepare_protocol.c
+++ b/contrib/tools/python3/src/Modules/_sqlite/prepare_protocol.c
@@ -1,83 +1,83 @@
-/* prepare_protocol.c - the protocol for preparing values for SQLite
- *
- * Copyright (C) 2005-2010 Gerhard Häring <[email protected]>
- *
- * This file is part of pysqlite.
- *
- * This software is provided 'as-is', without any express or implied
- * warranty.  In no event will the authors be held liable for any damages
- * arising from the use of this software.
- *
- * Permission is granted to anyone to use this software for any purpose,
- * including commercial applications, and to alter it and redistribute it
- * freely, subject to the following restrictions:
- *
- * 1. The origin of this software must not be misrepresented; you must not
- *    claim that you wrote the original software. If you use this software
- *    in a product, an acknowledgment in the product documentation would be
- *    appreciated but is not required.
- * 2. Altered source versions must be plainly marked as such, and must not be
- *    misrepresented as being the original software.
- * 3. This notice may not be removed or altered from any source distribution.
- */
-
-#include "prepare_protocol.h"
-
-int pysqlite_prepare_protocol_init(pysqlite_PrepareProtocol* self, PyObject* args, PyObject* kwargs)
-{
-    return 0;
-}
-
-void pysqlite_prepare_protocol_dealloc(pysqlite_PrepareProtocol* self)
-{
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-PyTypeObject pysqlite_PrepareProtocolType= {
-        PyVarObject_HEAD_INIT(NULL, 0)
-        MODULE_NAME ".PrepareProtocol",                 /* tp_name */
-        sizeof(pysqlite_PrepareProtocol),               /* tp_basicsize */
-        0,                                              /* tp_itemsize */
-        (destructor)pysqlite_prepare_protocol_dealloc,  /* tp_dealloc */
+/* prepare_protocol.c - the protocol for preparing values for SQLite 
+ * 
+ * Copyright (C) 2005-2010 Gerhard Häring <[email protected]> 
+ * 
+ * This file is part of pysqlite. 
+ * 
+ * This software is provided 'as-is', without any express or implied 
+ * warranty.  In no event will the authors be held liable for any damages 
+ * arising from the use of this software. 
+ * 
+ * Permission is granted to anyone to use this software for any purpose, 
+ * including commercial applications, and to alter it and redistribute it 
+ * freely, subject to the following restrictions: 
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not 
+ *    claim that you wrote the original software. If you use this software 
+ *    in a product, an acknowledgment in the product documentation would be 
+ *    appreciated but is not required. 
+ * 2. Altered source versions must be plainly marked as such, and must not be 
+ *    misrepresented as being the original software. 
+ * 3. This notice may not be removed or altered from any source distribution. 
+ */ 
+ 
+#include "prepare_protocol.h" 
+ 
+int pysqlite_prepare_protocol_init(pysqlite_PrepareProtocol* self, PyObject* args, PyObject* kwargs) 
+{ 
+    return 0; 
+} 
+ 
+void pysqlite_prepare_protocol_dealloc(pysqlite_PrepareProtocol* self) 
+{ 
+    Py_TYPE(self)->tp_free((PyObject*)self); 
+} 
+ 
+PyTypeObject pysqlite_PrepareProtocolType= { 
+        PyVarObject_HEAD_INIT(NULL, 0) 
+        MODULE_NAME ".PrepareProtocol",                 /* tp_name */ 
+        sizeof(pysqlite_PrepareProtocol),               /* tp_basicsize */ 
+        0,                                              /* tp_itemsize */ 
+        (destructor)pysqlite_prepare_protocol_dealloc,  /* tp_dealloc */ 
         0,                                              /* tp_vectorcall_offset */
-        0,                                              /* tp_getattr */
-        0,                                              /* tp_setattr */
+        0,                                              /* tp_getattr */ 
+        0,                                              /* tp_setattr */ 
         0,                                              /* tp_as_async */
-        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 */
-        Py_TPFLAGS_DEFAULT,                             /* tp_flags */
-        0,                                              /* tp_doc */
-        0,                                              /* tp_traverse */
-        0,                                              /* tp_clear */
-        0,                                              /* tp_richcompare */
-        0,                                              /* tp_weaklistoffset */
-        0,                                              /* tp_iter */
-        0,                                              /* tp_iternext */
-        0,                                              /* tp_methods */
-        0,                                              /* tp_members */
-        0,                                              /* tp_getset */
-        0,                                              /* tp_base */
-        0,                                              /* tp_dict */
-        0,                                              /* tp_descr_get */
-        0,                                              /* tp_descr_set */
-        0,                                              /* tp_dictoffset */
-        (initproc)pysqlite_prepare_protocol_init,       /* tp_init */
-        0,                                              /* tp_alloc */
-        0,                                              /* tp_new */
-        0                                               /* tp_free */
-};
-
-extern int pysqlite_prepare_protocol_setup_types(void)
-{
-    pysqlite_PrepareProtocolType.tp_new = PyType_GenericNew;
+        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 */ 
+        Py_TPFLAGS_DEFAULT,                             /* tp_flags */ 
+        0,                                              /* tp_doc */ 
+        0,                                              /* tp_traverse */ 
+        0,                                              /* tp_clear */ 
+        0,                                              /* tp_richcompare */ 
+        0,                                              /* tp_weaklistoffset */ 
+        0,                                              /* tp_iter */ 
+        0,                                              /* tp_iternext */ 
+        0,                                              /* tp_methods */ 
+        0,                                              /* tp_members */ 
+        0,                                              /* tp_getset */ 
+        0,                                              /* tp_base */ 
+        0,                                              /* tp_dict */ 
+        0,                                              /* tp_descr_get */ 
+        0,                                              /* tp_descr_set */ 
+        0,                                              /* tp_dictoffset */ 
+        (initproc)pysqlite_prepare_protocol_init,       /* tp_init */ 
+        0,                                              /* tp_alloc */ 
+        0,                                              /* tp_new */ 
+        0                                               /* tp_free */ 
+}; 
+ 
+extern int pysqlite_prepare_protocol_setup_types(void) 
+{ 
+    pysqlite_PrepareProtocolType.tp_new = PyType_GenericNew; 
     Py_SET_TYPE(&pysqlite_PrepareProtocolType, &PyType_Type);
-    return PyType_Ready(&pysqlite_PrepareProtocolType);
-}
+    return PyType_Ready(&pysqlite_PrepareProtocolType); 
+} 
diff --git a/contrib/tools/python3/src/Modules/_sqlite/prepare_protocol.h b/contrib/tools/python3/src/Modules/_sqlite/prepare_protocol.h
index 3998a55e51c..885b8065903 100644
--- a/contrib/tools/python3/src/Modules/_sqlite/prepare_protocol.h
+++ b/contrib/tools/python3/src/Modules/_sqlite/prepare_protocol.h
@@ -1,42 +1,42 @@
-/* prepare_protocol.h - the protocol for preparing values for SQLite
- *
- * Copyright (C) 2005-2010 Gerhard Häring <[email protected]>
- *
- * This file is part of pysqlite.
- *
- * This software is provided 'as-is', without any express or implied
- * warranty.  In no event will the authors be held liable for any damages
- * arising from the use of this software.
- *
- * Permission is granted to anyone to use this software for any purpose,
- * including commercial applications, and to alter it and redistribute it
- * freely, subject to the following restrictions:
- *
- * 1. The origin of this software must not be misrepresented; you must not
- *    claim that you wrote the original software. If you use this software
- *    in a product, an acknowledgment in the product documentation would be
- *    appreciated but is not required.
- * 2. Altered source versions must be plainly marked as such, and must not be
- *    misrepresented as being the original software.
- * 3. This notice may not be removed or altered from any source distribution.
- */
-
-#ifndef PYSQLITE_PREPARE_PROTOCOL_H
-#define PYSQLITE_PREPARE_PROTOCOL_H
+/* prepare_protocol.h - the protocol for preparing values for SQLite 
+ * 
+ * Copyright (C) 2005-2010 Gerhard Häring <[email protected]> 
+ * 
+ * This file is part of pysqlite. 
+ * 
+ * This software is provided 'as-is', without any express or implied 
+ * warranty.  In no event will the authors be held liable for any damages 
+ * arising from the use of this software. 
+ * 
+ * Permission is granted to anyone to use this software for any purpose, 
+ * including commercial applications, and to alter it and redistribute it 
+ * freely, subject to the following restrictions: 
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not 
+ *    claim that you wrote the original software. If you use this software 
+ *    in a product, an acknowledgment in the product documentation would be 
+ *    appreciated but is not required. 
+ * 2. Altered source versions must be plainly marked as such, and must not be 
+ *    misrepresented as being the original software. 
+ * 3. This notice may not be removed or altered from any source distribution. 
+ */ 
+ 
+#ifndef PYSQLITE_PREPARE_PROTOCOL_H 
+#define PYSQLITE_PREPARE_PROTOCOL_H 
 #define PY_SSIZE_T_CLEAN
-#include "Python.h"
-
-typedef struct
-{
-    PyObject_HEAD
-} pysqlite_PrepareProtocol;
-
-extern PyTypeObject pysqlite_PrepareProtocolType;
-
-int pysqlite_prepare_protocol_init(pysqlite_PrepareProtocol* self, PyObject* args, PyObject* kwargs);
-void pysqlite_prepare_protocol_dealloc(pysqlite_PrepareProtocol* self);
-
-int pysqlite_prepare_protocol_setup_types(void);
-
-#define UNKNOWN (-1)
-#endif
+#include "Python.h" 
+ 
+typedef struct 
+{ 
+    PyObject_HEAD 
+} pysqlite_PrepareProtocol; 
+ 
+extern PyTypeObject pysqlite_PrepareProtocolType; 
+ 
+int pysqlite_prepare_protocol_init(pysqlite_PrepareProtocol* self, PyObject* args, PyObject* kwargs); 
+void pysqlite_prepare_protocol_dealloc(pysqlite_PrepareProtocol* self); 
+ 
+int pysqlite_prepare_protocol_setup_types(void); 
+ 
+#define UNKNOWN (-1) 
+#endif 
diff --git a/contrib/tools/python3/src/Modules/_sqlite/row.c b/contrib/tools/python3/src/Modules/_sqlite/row.c
index 4b47108278a..07e7ce9990b 100644
--- a/contrib/tools/python3/src/Modules/_sqlite/row.c
+++ b/contrib/tools/python3/src/Modules/_sqlite/row.c
@@ -1,81 +1,81 @@
-/* row.c - an enhanced tuple for database rows
- *
- * Copyright (C) 2005-2010 Gerhard Häring <[email protected]>
- *
- * This file is part of pysqlite.
- *
- * This software is provided 'as-is', without any express or implied
- * warranty.  In no event will the authors be held liable for any damages
- * arising from the use of this software.
- *
- * Permission is granted to anyone to use this software for any purpose,
- * including commercial applications, and to alter it and redistribute it
- * freely, subject to the following restrictions:
- *
- * 1. The origin of this software must not be misrepresented; you must not
- *    claim that you wrote the original software. If you use this software
- *    in a product, an acknowledgment in the product documentation would be
- *    appreciated but is not required.
- * 2. Altered source versions must be plainly marked as such, and must not be
- *    misrepresented as being the original software.
- * 3. This notice may not be removed or altered from any source distribution.
- */
-
-#include "row.h"
-#include "cursor.h"
-
-void pysqlite_row_dealloc(pysqlite_Row* self)
-{
-    Py_XDECREF(self->data);
-    Py_XDECREF(self->description);
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-static PyObject *
-pysqlite_row_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
-{
-    pysqlite_Row *self;
-    PyObject* data;
-    pysqlite_Cursor* cursor;
-
-    assert(type != NULL && type->tp_alloc != NULL);
-
-    if (!_PyArg_NoKeywords("Row", kwargs))
-        return NULL;
-    if (!PyArg_ParseTuple(args, "OO", &cursor, &data))
-        return NULL;
-
-    if (!PyObject_TypeCheck((PyObject*)cursor, &pysqlite_CursorType)) {
-        PyErr_SetString(PyExc_TypeError, "instance of cursor required for first argument");
-        return NULL;
-    }
-
-    if (!PyTuple_Check(data)) {
-        PyErr_SetString(PyExc_TypeError, "tuple required for second argument");
-        return NULL;
-    }
-
-    self = (pysqlite_Row *) type->tp_alloc(type, 0);
-    if (self == NULL)
-        return NULL;
-
-    Py_INCREF(data);
-    self->data = data;
-
-    Py_INCREF(cursor->description);
-    self->description = cursor->description;
-
-    return (PyObject *) self;
-}
-
-PyObject* pysqlite_row_item(pysqlite_Row* self, Py_ssize_t idx)
-{
-   PyObject* item = PyTuple_GetItem(self->data, idx);
-   Py_XINCREF(item);
-   return item;
-}
-
+/* row.c - an enhanced tuple for database rows 
+ * 
+ * Copyright (C) 2005-2010 Gerhard Häring <[email protected]> 
+ * 
+ * This file is part of pysqlite. 
+ * 
+ * This software is provided 'as-is', without any express or implied 
+ * warranty.  In no event will the authors be held liable for any damages 
+ * arising from the use of this software. 
+ * 
+ * Permission is granted to anyone to use this software for any purpose, 
+ * including commercial applications, and to alter it and redistribute it 
+ * freely, subject to the following restrictions: 
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not 
+ *    claim that you wrote the original software. If you use this software 
+ *    in a product, an acknowledgment in the product documentation would be 
+ *    appreciated but is not required. 
+ * 2. Altered source versions must be plainly marked as such, and must not be 
+ *    misrepresented as being the original software. 
+ * 3. This notice may not be removed or altered from any source distribution. 
+ */ 
+ 
+#include "row.h" 
+#include "cursor.h" 
+ 
+void pysqlite_row_dealloc(pysqlite_Row* self) 
+{ 
+    Py_XDECREF(self->data); 
+    Py_XDECREF(self->description); 
+ 
+    Py_TYPE(self)->tp_free((PyObject*)self); 
+} 
+ 
+static PyObject * 
+pysqlite_row_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) 
+{ 
+    pysqlite_Row *self; 
+    PyObject* data; 
+    pysqlite_Cursor* cursor; 
+ 
+    assert(type != NULL && type->tp_alloc != NULL); 
+ 
+    if (!_PyArg_NoKeywords("Row", kwargs)) 
+        return NULL; 
+    if (!PyArg_ParseTuple(args, "OO", &cursor, &data)) 
+        return NULL; 
+ 
+    if (!PyObject_TypeCheck((PyObject*)cursor, &pysqlite_CursorType)) { 
+        PyErr_SetString(PyExc_TypeError, "instance of cursor required for first argument"); 
+        return NULL; 
+    } 
+ 
+    if (!PyTuple_Check(data)) { 
+        PyErr_SetString(PyExc_TypeError, "tuple required for second argument"); 
+        return NULL; 
+    } 
+ 
+    self = (pysqlite_Row *) type->tp_alloc(type, 0); 
+    if (self == NULL) 
+        return NULL; 
+ 
+    Py_INCREF(data); 
+    self->data = data; 
+ 
+    Py_INCREF(cursor->description); 
+    self->description = cursor->description; 
+ 
+    return (PyObject *) self; 
+} 
+ 
+PyObject* pysqlite_row_item(pysqlite_Row* self, Py_ssize_t idx) 
+{ 
+   PyObject* item = PyTuple_GetItem(self->data, idx); 
+   Py_XINCREF(item); 
+   return item; 
+} 
+ 
 static int
 equal_ignore_case(PyObject *left, PyObject *right)
 {
@@ -104,175 +104,175 @@ equal_ignore_case(PyObject *left, PyObject *right)
     return 1;
 }
 
-PyObject* pysqlite_row_subscript(pysqlite_Row* self, PyObject* idx)
-{
-    Py_ssize_t _idx;
-    Py_ssize_t nitems, i;
-    PyObject* item;
-
-    if (PyLong_Check(idx)) {
-        _idx = PyNumber_AsSsize_t(idx, PyExc_IndexError);
-        if (_idx == -1 && PyErr_Occurred())
-            return NULL;
-        if (_idx < 0)
-           _idx += PyTuple_GET_SIZE(self->data);
-        item = PyTuple_GetItem(self->data, _idx);
-        Py_XINCREF(item);
-        return item;
-    } else if (PyUnicode_Check(idx)) {
-        nitems = PyTuple_Size(self->description);
-
-        for (i = 0; i < nitems; i++) {
-            PyObject *obj;
-            obj = PyTuple_GET_ITEM(self->description, i);
-            obj = PyTuple_GET_ITEM(obj, 0);
+PyObject* pysqlite_row_subscript(pysqlite_Row* self, PyObject* idx) 
+{ 
+    Py_ssize_t _idx; 
+    Py_ssize_t nitems, i; 
+    PyObject* item; 
+ 
+    if (PyLong_Check(idx)) { 
+        _idx = PyNumber_AsSsize_t(idx, PyExc_IndexError); 
+        if (_idx == -1 && PyErr_Occurred()) 
+            return NULL; 
+        if (_idx < 0) 
+           _idx += PyTuple_GET_SIZE(self->data); 
+        item = PyTuple_GetItem(self->data, _idx); 
+        Py_XINCREF(item); 
+        return item; 
+    } else if (PyUnicode_Check(idx)) { 
+        nitems = PyTuple_Size(self->description); 
+ 
+        for (i = 0; i < nitems; i++) { 
+            PyObject *obj; 
+            obj = PyTuple_GET_ITEM(self->description, i); 
+            obj = PyTuple_GET_ITEM(obj, 0); 
             int eq = equal_ignore_case(idx, obj);
             if (eq < 0) {
-                return NULL;
-            }
+                return NULL; 
+            } 
             if (eq) {
-                /* found item */
-                item = PyTuple_GetItem(self->data, i);
-                Py_INCREF(item);
-                return item;
-            }
-        }
-
-        PyErr_SetString(PyExc_IndexError, "No item with that key");
-        return NULL;
-    }
-    else if (PySlice_Check(idx)) {
-        return PyObject_GetItem(self->data, idx);
-    }
-    else {
-        PyErr_SetString(PyExc_IndexError, "Index must be int or string");
-        return NULL;
-    }
-}
-
-static Py_ssize_t
-pysqlite_row_length(pysqlite_Row* self)
-{
-    return PyTuple_GET_SIZE(self->data);
-}
-
+                /* found item */ 
+                item = PyTuple_GetItem(self->data, i); 
+                Py_INCREF(item); 
+                return item; 
+            } 
+        } 
+ 
+        PyErr_SetString(PyExc_IndexError, "No item with that key"); 
+        return NULL; 
+    } 
+    else if (PySlice_Check(idx)) { 
+        return PyObject_GetItem(self->data, idx); 
+    } 
+    else { 
+        PyErr_SetString(PyExc_IndexError, "Index must be int or string"); 
+        return NULL; 
+    } 
+} 
+ 
+static Py_ssize_t 
+pysqlite_row_length(pysqlite_Row* self) 
+{ 
+    return PyTuple_GET_SIZE(self->data); 
+} 
+ 
 PyObject* pysqlite_row_keys(pysqlite_Row* self, PyObject *Py_UNUSED(ignored))
-{
-    PyObject* list;
-    Py_ssize_t nitems, i;
-
-    list = PyList_New(0);
-    if (!list) {
-        return NULL;
-    }
-    nitems = PyTuple_Size(self->description);
-
-    for (i = 0; i < nitems; i++) {
-        if (PyList_Append(list, PyTuple_GET_ITEM(PyTuple_GET_ITEM(self->description, i), 0)) != 0) {
-            Py_DECREF(list);
-            return NULL;
-        }
-    }
-
-    return list;
-}
-
-static PyObject* pysqlite_iter(pysqlite_Row* self)
-{
-    return PyObject_GetIter(self->data);
-}
-
-static Py_hash_t pysqlite_row_hash(pysqlite_Row *self)
-{
-    return PyObject_Hash(self->description) ^ PyObject_Hash(self->data);
-}
-
-static PyObject* pysqlite_row_richcompare(pysqlite_Row *self, PyObject *_other, int opid)
-{
-    if (opid != Py_EQ && opid != Py_NE)
-        Py_RETURN_NOTIMPLEMENTED;
-
+{ 
+    PyObject* list; 
+    Py_ssize_t nitems, i; 
+ 
+    list = PyList_New(0); 
+    if (!list) { 
+        return NULL; 
+    } 
+    nitems = PyTuple_Size(self->description); 
+ 
+    for (i = 0; i < nitems; i++) { 
+        if (PyList_Append(list, PyTuple_GET_ITEM(PyTuple_GET_ITEM(self->description, i), 0)) != 0) { 
+            Py_DECREF(list); 
+            return NULL; 
+        } 
+    } 
+ 
+    return list; 
+} 
+ 
+static PyObject* pysqlite_iter(pysqlite_Row* self) 
+{ 
+    return PyObject_GetIter(self->data); 
+} 
+ 
+static Py_hash_t pysqlite_row_hash(pysqlite_Row *self) 
+{ 
+    return PyObject_Hash(self->description) ^ PyObject_Hash(self->data); 
+} 
+ 
+static PyObject* pysqlite_row_richcompare(pysqlite_Row *self, PyObject *_other, int opid) 
+{ 
+    if (opid != Py_EQ && opid != Py_NE) 
+        Py_RETURN_NOTIMPLEMENTED; 
+ 
     if (PyObject_TypeCheck(_other, &pysqlite_RowType)) {
-        pysqlite_Row *other = (pysqlite_Row *)_other;
+        pysqlite_Row *other = (pysqlite_Row *)_other; 
         int eq = PyObject_RichCompareBool(self->description, other->description, Py_EQ);
         if (eq < 0) {
             return NULL;
         }
         if (eq) {
-            return PyObject_RichCompare(self->data, other->data, opid);
-        }
+            return PyObject_RichCompare(self->data, other->data, opid); 
+        } 
         return PyBool_FromLong(opid != Py_EQ);
-    }
-    Py_RETURN_NOTIMPLEMENTED;
-}
-
-PyMappingMethods pysqlite_row_as_mapping = {
-    /* mp_length        */ (lenfunc)pysqlite_row_length,
-    /* mp_subscript     */ (binaryfunc)pysqlite_row_subscript,
-    /* mp_ass_subscript */ (objobjargproc)0,
-};
-
-static PySequenceMethods pysqlite_row_as_sequence = {
-   /* sq_length */         (lenfunc)pysqlite_row_length,
-   /* sq_concat */         0,
-   /* sq_repeat */         0,
-   /* sq_item */           (ssizeargfunc)pysqlite_row_item,
-};
-
-
-static PyMethodDef pysqlite_row_methods[] = {
-    {"keys", (PyCFunction)pysqlite_row_keys, METH_NOARGS,
-        PyDoc_STR("Returns the keys of the row.")},
-    {NULL, NULL}
-};
-
-
-PyTypeObject pysqlite_RowType = {
-        PyVarObject_HEAD_INIT(NULL, 0)
-        MODULE_NAME ".Row",                             /* tp_name */
-        sizeof(pysqlite_Row),                           /* tp_basicsize */
-        0,                                              /* tp_itemsize */
-        (destructor)pysqlite_row_dealloc,               /* tp_dealloc */
+    } 
+    Py_RETURN_NOTIMPLEMENTED; 
+} 
+ 
+PyMappingMethods pysqlite_row_as_mapping = { 
+    /* mp_length        */ (lenfunc)pysqlite_row_length, 
+    /* mp_subscript     */ (binaryfunc)pysqlite_row_subscript, 
+    /* mp_ass_subscript */ (objobjargproc)0, 
+}; 
+ 
+static PySequenceMethods pysqlite_row_as_sequence = { 
+   /* sq_length */         (lenfunc)pysqlite_row_length, 
+   /* sq_concat */         0, 
+   /* sq_repeat */         0, 
+   /* sq_item */           (ssizeargfunc)pysqlite_row_item, 
+}; 
+ 
+ 
+static PyMethodDef pysqlite_row_methods[] = { 
+    {"keys", (PyCFunction)pysqlite_row_keys, METH_NOARGS, 
+        PyDoc_STR("Returns the keys of the row.")}, 
+    {NULL, NULL} 
+}; 
+ 
+ 
+PyTypeObject pysqlite_RowType = { 
+        PyVarObject_HEAD_INIT(NULL, 0) 
+        MODULE_NAME ".Row",                             /* tp_name */ 
+        sizeof(pysqlite_Row),                           /* tp_basicsize */ 
+        0,                                              /* tp_itemsize */ 
+        (destructor)pysqlite_row_dealloc,               /* tp_dealloc */ 
         0,                                              /* tp_vectorcall_offset */
-        0,                                              /* tp_getattr */
-        0,                                              /* tp_setattr */
+        0,                                              /* tp_getattr */ 
+        0,                                              /* tp_setattr */ 
         0,                                              /* tp_as_async */
-        0,                                              /* tp_repr */
-        0,                                              /* tp_as_number */
-        0,                                              /* tp_as_sequence */
-        0,                                              /* tp_as_mapping */
-        (hashfunc)pysqlite_row_hash,                    /* tp_hash */
-        0,                                              /* tp_call */
-        0,                                              /* tp_str */
-        0,                                              /* tp_getattro */
-        0,                                              /* tp_setattro */
-        0,                                              /* tp_as_buffer */
-        Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,         /* tp_flags */
-        0,                                              /* tp_doc */
-        (traverseproc)0,                                /* tp_traverse */
-        0,                                              /* tp_clear */
-        (richcmpfunc)pysqlite_row_richcompare,          /* tp_richcompare */
-        0,                                              /* tp_weaklistoffset */
-        (getiterfunc)pysqlite_iter,                     /* tp_iter */
-        0,                                              /* tp_iternext */
-        pysqlite_row_methods,                           /* tp_methods */
-        0,                                              /* tp_members */
-        0,                                              /* tp_getset */
-        0,                                              /* tp_base */
-        0,                                              /* tp_dict */
-        0,                                              /* tp_descr_get */
-        0,                                              /* tp_descr_set */
-        0,                                              /* tp_dictoffset */
-        0,                                              /* tp_init */
-        0,                                              /* tp_alloc */
-        0,                                              /* tp_new */
-        0                                               /* tp_free */
-};
-
-extern int pysqlite_row_setup_types(void)
-{
-    pysqlite_RowType.tp_new = pysqlite_row_new;
-    pysqlite_RowType.tp_as_mapping = &pysqlite_row_as_mapping;
-    pysqlite_RowType.tp_as_sequence = &pysqlite_row_as_sequence;
-    return PyType_Ready(&pysqlite_RowType);
-}
+        0,                                              /* tp_repr */ 
+        0,                                              /* tp_as_number */ 
+        0,                                              /* tp_as_sequence */ 
+        0,                                              /* tp_as_mapping */ 
+        (hashfunc)pysqlite_row_hash,                    /* tp_hash */ 
+        0,                                              /* tp_call */ 
+        0,                                              /* tp_str */ 
+        0,                                              /* tp_getattro */ 
+        0,                                              /* tp_setattro */ 
+        0,                                              /* tp_as_buffer */ 
+        Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,         /* tp_flags */ 
+        0,                                              /* tp_doc */ 
+        (traverseproc)0,                                /* tp_traverse */ 
+        0,                                              /* tp_clear */ 
+        (richcmpfunc)pysqlite_row_richcompare,          /* tp_richcompare */ 
+        0,                                              /* tp_weaklistoffset */ 
+        (getiterfunc)pysqlite_iter,                     /* tp_iter */ 
+        0,                                              /* tp_iternext */ 
+        pysqlite_row_methods,                           /* tp_methods */ 
+        0,                                              /* tp_members */ 
+        0,                                              /* tp_getset */ 
+        0,                                              /* tp_base */ 
+        0,                                              /* tp_dict */ 
+        0,                                              /* tp_descr_get */ 
+        0,                                              /* tp_descr_set */ 
+        0,                                              /* tp_dictoffset */ 
+        0,                                              /* tp_init */ 
+        0,                                              /* tp_alloc */ 
+        0,                                              /* tp_new */ 
+        0                                               /* tp_free */ 
+}; 
+ 
+extern int pysqlite_row_setup_types(void) 
+{ 
+    pysqlite_RowType.tp_new = pysqlite_row_new; 
+    pysqlite_RowType.tp_as_mapping = &pysqlite_row_as_mapping; 
+    pysqlite_RowType.tp_as_sequence = &pysqlite_row_as_sequence; 
+    return PyType_Ready(&pysqlite_RowType); 
+} 
diff --git a/contrib/tools/python3/src/Modules/_sqlite/row.h b/contrib/tools/python3/src/Modules/_sqlite/row.h
index 4ad506f8dd9..0c9e5860714 100644
--- a/contrib/tools/python3/src/Modules/_sqlite/row.h
+++ b/contrib/tools/python3/src/Modules/_sqlite/row.h
@@ -1,40 +1,40 @@
-/* row.h - an enhanced tuple for database rows
- *
- * Copyright (C) 2005-2010 Gerhard Häring <[email protected]>
- *
- * This file is part of pysqlite.
- *
- * This software is provided 'as-is', without any express or implied
- * warranty.  In no event will the authors be held liable for any damages
- * arising from the use of this software.
- *
- * Permission is granted to anyone to use this software for any purpose,
- * including commercial applications, and to alter it and redistribute it
- * freely, subject to the following restrictions:
- *
- * 1. The origin of this software must not be misrepresented; you must not
- *    claim that you wrote the original software. If you use this software
- *    in a product, an acknowledgment in the product documentation would be
- *    appreciated but is not required.
- * 2. Altered source versions must be plainly marked as such, and must not be
- *    misrepresented as being the original software.
- * 3. This notice may not be removed or altered from any source distribution.
- */
-
-#ifndef PYSQLITE_ROW_H
-#define PYSQLITE_ROW_H
+/* row.h - an enhanced tuple for database rows 
+ * 
+ * Copyright (C) 2005-2010 Gerhard Häring <[email protected]> 
+ * 
+ * This file is part of pysqlite. 
+ * 
+ * This software is provided 'as-is', without any express or implied 
+ * warranty.  In no event will the authors be held liable for any damages 
+ * arising from the use of this software. 
+ * 
+ * Permission is granted to anyone to use this software for any purpose, 
+ * including commercial applications, and to alter it and redistribute it 
+ * freely, subject to the following restrictions: 
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not 
+ *    claim that you wrote the original software. If you use this software 
+ *    in a product, an acknowledgment in the product documentation would be 
+ *    appreciated but is not required. 
+ * 2. Altered source versions must be plainly marked as such, and must not be 
+ *    misrepresented as being the original software. 
+ * 3. This notice may not be removed or altered from any source distribution. 
+ */ 
+ 
+#ifndef PYSQLITE_ROW_H 
+#define PYSQLITE_ROW_H 
 #define PY_SSIZE_T_CLEAN
-#include "Python.h"
-
-typedef struct _Row
-{
-    PyObject_HEAD
-    PyObject* data;
-    PyObject* description;
-} pysqlite_Row;
-
-extern PyTypeObject pysqlite_RowType;
-
-int pysqlite_row_setup_types(void);
-
-#endif
+#include "Python.h" 
+ 
+typedef struct _Row 
+{ 
+    PyObject_HEAD 
+    PyObject* data; 
+    PyObject* description; 
+} pysqlite_Row; 
+ 
+extern PyTypeObject pysqlite_RowType; 
+ 
+int pysqlite_row_setup_types(void); 
+ 
+#endif 
diff --git a/contrib/tools/python3/src/Modules/_sqlite/statement.c b/contrib/tools/python3/src/Modules/_sqlite/statement.c
index 23c204e7521..382046b6da2 100644
--- a/contrib/tools/python3/src/Modules/_sqlite/statement.c
+++ b/contrib/tools/python3/src/Modules/_sqlite/statement.c
@@ -1,507 +1,507 @@
-/* statement.c - the statement type
- *
- * Copyright (C) 2005-2010 Gerhard Häring <[email protected]>
- *
- * This file is part of pysqlite.
- *
- * This software is provided 'as-is', without any express or implied
- * warranty.  In no event will the authors be held liable for any damages
- * arising from the use of this software.
- *
- * Permission is granted to anyone to use this software for any purpose,
- * including commercial applications, and to alter it and redistribute it
- * freely, subject to the following restrictions:
- *
- * 1. The origin of this software must not be misrepresented; you must not
- *    claim that you wrote the original software. If you use this software
- *    in a product, an acknowledgment in the product documentation would be
- *    appreciated but is not required.
- * 2. Altered source versions must be plainly marked as such, and must not be
- *    misrepresented as being the original software.
- * 3. This notice may not be removed or altered from any source distribution.
- */
-
-#include "statement.h"
-#include "cursor.h"
-#include "connection.h"
-#include "microprotocols.h"
-#include "prepare_protocol.h"
-#include "util.h"
-
-/* prototypes */
-static int pysqlite_check_remaining_sql(const char* tail);
-
-typedef enum {
-    LINECOMMENT_1,
-    IN_LINECOMMENT,
-    COMMENTSTART_1,
-    IN_COMMENT,
-    COMMENTEND_1,
-    NORMAL
-} parse_remaining_sql_state;
-
-typedef enum {
-    TYPE_LONG,
-    TYPE_FLOAT,
-    TYPE_UNICODE,
-    TYPE_BUFFER,
-    TYPE_UNKNOWN
-} parameter_type;
-
-int pysqlite_statement_create(pysqlite_Statement* self, pysqlite_Connection* connection, PyObject* sql)
-{
-    const char* tail;
-    int rc;
-    const char* sql_cstr;
-    Py_ssize_t sql_cstr_len;
-    const char* p;
-
-    self->st = NULL;
-    self->in_use = 0;
-
+/* statement.c - the statement type 
+ * 
+ * Copyright (C) 2005-2010 Gerhard Häring <[email protected]> 
+ * 
+ * This file is part of pysqlite. 
+ * 
+ * This software is provided 'as-is', without any express or implied 
+ * warranty.  In no event will the authors be held liable for any damages 
+ * arising from the use of this software. 
+ * 
+ * Permission is granted to anyone to use this software for any purpose, 
+ * including commercial applications, and to alter it and redistribute it 
+ * freely, subject to the following restrictions: 
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not 
+ *    claim that you wrote the original software. If you use this software 
+ *    in a product, an acknowledgment in the product documentation would be 
+ *    appreciated but is not required. 
+ * 2. Altered source versions must be plainly marked as such, and must not be 
+ *    misrepresented as being the original software. 
+ * 3. This notice may not be removed or altered from any source distribution. 
+ */ 
+ 
+#include "statement.h" 
+#include "cursor.h" 
+#include "connection.h" 
+#include "microprotocols.h" 
+#include "prepare_protocol.h" 
+#include "util.h" 
+ 
+/* prototypes */ 
+static int pysqlite_check_remaining_sql(const char* tail); 
+ 
+typedef enum { 
+    LINECOMMENT_1, 
+    IN_LINECOMMENT, 
+    COMMENTSTART_1, 
+    IN_COMMENT, 
+    COMMENTEND_1, 
+    NORMAL 
+} parse_remaining_sql_state; 
+ 
+typedef enum { 
+    TYPE_LONG, 
+    TYPE_FLOAT, 
+    TYPE_UNICODE, 
+    TYPE_BUFFER, 
+    TYPE_UNKNOWN 
+} parameter_type; 
+ 
+int pysqlite_statement_create(pysqlite_Statement* self, pysqlite_Connection* connection, PyObject* sql) 
+{ 
+    const char* tail; 
+    int rc; 
+    const char* sql_cstr; 
+    Py_ssize_t sql_cstr_len; 
+    const char* p; 
+ 
+    self->st = NULL; 
+    self->in_use = 0; 
+ 
     assert(PyUnicode_Check(sql));
 
-    sql_cstr = PyUnicode_AsUTF8AndSize(sql, &sql_cstr_len);
-    if (sql_cstr == NULL) {
-        rc = PYSQLITE_SQL_WRONG_TYPE;
-        return rc;
-    }
-    if (strlen(sql_cstr) != (size_t)sql_cstr_len) {
-        PyErr_SetString(PyExc_ValueError, "the query contains a null character");
-        return PYSQLITE_SQL_WRONG_TYPE;
-    }
-
-    self->in_weakreflist = NULL;
-    Py_INCREF(sql);
-    self->sql = sql;
-
-    /* Determine if the statement is a DML statement.
-       SELECT is the only exception. See #9924. */
-    self->is_dml = 0;
-    for (p = sql_cstr; *p != 0; p++) {
-        switch (*p) {
-            case ' ':
-            case '\r':
-            case '\n':
-            case '\t':
-                continue;
-        }
-
-        self->is_dml = (PyOS_strnicmp(p, "insert", 6) == 0)
-                    || (PyOS_strnicmp(p, "update", 6) == 0)
-                    || (PyOS_strnicmp(p, "delete", 6) == 0)
-                    || (PyOS_strnicmp(p, "replace", 7) == 0);
-        break;
-    }
-
-    Py_BEGIN_ALLOW_THREADS
-    rc = sqlite3_prepare_v2(connection->db,
-                            sql_cstr,
-                            -1,
-                            &self->st,
-                            &tail);
-    Py_END_ALLOW_THREADS
-
-    self->db = connection->db;
-
-    if (rc == SQLITE_OK && pysqlite_check_remaining_sql(tail)) {
-        (void)sqlite3_finalize(self->st);
-        self->st = NULL;
-        rc = PYSQLITE_TOO_MUCH_SQL;
-    }
-
-    return rc;
-}
-
-int pysqlite_statement_bind_parameter(pysqlite_Statement* self, int pos, PyObject* parameter)
-{
-    int rc = SQLITE_OK;
-    const char *string;
-    Py_ssize_t buflen;
-    parameter_type paramtype;
-
-    if (parameter == Py_None) {
-        rc = sqlite3_bind_null(self->st, pos);
-        goto final;
-    }
-
-    if (PyLong_CheckExact(parameter)) {
-        paramtype = TYPE_LONG;
-    } else if (PyFloat_CheckExact(parameter)) {
-        paramtype = TYPE_FLOAT;
-    } else if (PyUnicode_CheckExact(parameter)) {
-        paramtype = TYPE_UNICODE;
-    } else if (PyLong_Check(parameter)) {
-        paramtype = TYPE_LONG;
-    } else if (PyFloat_Check(parameter)) {
-        paramtype = TYPE_FLOAT;
-    } else if (PyUnicode_Check(parameter)) {
-        paramtype = TYPE_UNICODE;
-    } else if (PyObject_CheckBuffer(parameter)) {
-        paramtype = TYPE_BUFFER;
-    } else {
-        paramtype = TYPE_UNKNOWN;
-    }
-
-    switch (paramtype) {
-        case TYPE_LONG: {
-            sqlite_int64 value = _pysqlite_long_as_int64(parameter);
-            if (value == -1 && PyErr_Occurred())
-                rc = -1;
-            else
-                rc = sqlite3_bind_int64(self->st, pos, value);
-            break;
-        }
-        case TYPE_FLOAT:
-            rc = sqlite3_bind_double(self->st, pos, PyFloat_AsDouble(parameter));
-            break;
-        case TYPE_UNICODE:
-            string = PyUnicode_AsUTF8AndSize(parameter, &buflen);
-            if (string == NULL)
-                return -1;
-            if (buflen > INT_MAX) {
-                PyErr_SetString(PyExc_OverflowError,
-                                "string longer than INT_MAX bytes");
-                return -1;
-            }
-            rc = sqlite3_bind_text(self->st, pos, string, (int)buflen, SQLITE_TRANSIENT);
-            break;
-        case TYPE_BUFFER: {
-            Py_buffer view;
-            if (PyObject_GetBuffer(parameter, &view, PyBUF_SIMPLE) != 0) {
-                PyErr_SetString(PyExc_ValueError, "could not convert BLOB to buffer");
-                return -1;
-            }
-            if (view.len > INT_MAX) {
-                PyErr_SetString(PyExc_OverflowError,
-                                "BLOB longer than INT_MAX bytes");
-                PyBuffer_Release(&view);
-                return -1;
-            }
-            rc = sqlite3_bind_blob(self->st, pos, view.buf, (int)view.len, SQLITE_TRANSIENT);
-            PyBuffer_Release(&view);
-            break;
-        }
-        case TYPE_UNKNOWN:
-            rc = -1;
-    }
-
-final:
-    return rc;
-}
-
-/* returns 0 if the object is one of Python's internal ones that don't need to be adapted */
-static int _need_adapt(PyObject* obj)
-{
-    if (pysqlite_BaseTypeAdapted) {
-        return 1;
-    }
-
-    if (PyLong_CheckExact(obj) || PyFloat_CheckExact(obj)
-          || PyUnicode_CheckExact(obj) || PyByteArray_CheckExact(obj)) {
-        return 0;
-    } else {
-        return 1;
-    }
-}
-
-void pysqlite_statement_bind_parameters(pysqlite_Statement* self, PyObject* parameters)
-{
-    PyObject* current_param;
-    PyObject* adapted;
-    const char* binding_name;
-    int i;
-    int rc;
-    int num_params_needed;
-    Py_ssize_t num_params;
-
-    Py_BEGIN_ALLOW_THREADS
-    num_params_needed = sqlite3_bind_parameter_count(self->st);
-    Py_END_ALLOW_THREADS
-
-    if (PyTuple_CheckExact(parameters) || PyList_CheckExact(parameters) || (!PyDict_Check(parameters) && PySequence_Check(parameters))) {
-        /* parameters passed as sequence */
-        if (PyTuple_CheckExact(parameters)) {
-            num_params = PyTuple_GET_SIZE(parameters);
-        } else if (PyList_CheckExact(parameters)) {
-            num_params = PyList_GET_SIZE(parameters);
-        } else {
-            num_params = PySequence_Size(parameters);
+    sql_cstr = PyUnicode_AsUTF8AndSize(sql, &sql_cstr_len); 
+    if (sql_cstr == NULL) { 
+        rc = PYSQLITE_SQL_WRONG_TYPE; 
+        return rc; 
+    } 
+    if (strlen(sql_cstr) != (size_t)sql_cstr_len) { 
+        PyErr_SetString(PyExc_ValueError, "the query contains a null character"); 
+        return PYSQLITE_SQL_WRONG_TYPE; 
+    } 
+ 
+    self->in_weakreflist = NULL; 
+    Py_INCREF(sql); 
+    self->sql = sql; 
+ 
+    /* Determine if the statement is a DML statement. 
+       SELECT is the only exception. See #9924. */ 
+    self->is_dml = 0; 
+    for (p = sql_cstr; *p != 0; p++) { 
+        switch (*p) { 
+            case ' ': 
+            case '\r': 
+            case '\n': 
+            case '\t': 
+                continue; 
+        } 
+ 
+        self->is_dml = (PyOS_strnicmp(p, "insert", 6) == 0) 
+                    || (PyOS_strnicmp(p, "update", 6) == 0) 
+                    || (PyOS_strnicmp(p, "delete", 6) == 0) 
+                    || (PyOS_strnicmp(p, "replace", 7) == 0); 
+        break; 
+    } 
+ 
+    Py_BEGIN_ALLOW_THREADS 
+    rc = sqlite3_prepare_v2(connection->db, 
+                            sql_cstr, 
+                            -1, 
+                            &self->st, 
+                            &tail); 
+    Py_END_ALLOW_THREADS 
+ 
+    self->db = connection->db; 
+ 
+    if (rc == SQLITE_OK && pysqlite_check_remaining_sql(tail)) { 
+        (void)sqlite3_finalize(self->st); 
+        self->st = NULL; 
+        rc = PYSQLITE_TOO_MUCH_SQL; 
+    } 
+ 
+    return rc; 
+} 
+ 
+int pysqlite_statement_bind_parameter(pysqlite_Statement* self, int pos, PyObject* parameter) 
+{ 
+    int rc = SQLITE_OK; 
+    const char *string; 
+    Py_ssize_t buflen; 
+    parameter_type paramtype; 
+ 
+    if (parameter == Py_None) { 
+        rc = sqlite3_bind_null(self->st, pos); 
+        goto final; 
+    } 
+ 
+    if (PyLong_CheckExact(parameter)) { 
+        paramtype = TYPE_LONG; 
+    } else if (PyFloat_CheckExact(parameter)) { 
+        paramtype = TYPE_FLOAT; 
+    } else if (PyUnicode_CheckExact(parameter)) { 
+        paramtype = TYPE_UNICODE; 
+    } else if (PyLong_Check(parameter)) { 
+        paramtype = TYPE_LONG; 
+    } else if (PyFloat_Check(parameter)) { 
+        paramtype = TYPE_FLOAT; 
+    } else if (PyUnicode_Check(parameter)) { 
+        paramtype = TYPE_UNICODE; 
+    } else if (PyObject_CheckBuffer(parameter)) { 
+        paramtype = TYPE_BUFFER; 
+    } else { 
+        paramtype = TYPE_UNKNOWN; 
+    } 
+ 
+    switch (paramtype) { 
+        case TYPE_LONG: { 
+            sqlite_int64 value = _pysqlite_long_as_int64(parameter); 
+            if (value == -1 && PyErr_Occurred()) 
+                rc = -1; 
+            else 
+                rc = sqlite3_bind_int64(self->st, pos, value); 
+            break; 
+        } 
+        case TYPE_FLOAT: 
+            rc = sqlite3_bind_double(self->st, pos, PyFloat_AsDouble(parameter)); 
+            break; 
+        case TYPE_UNICODE: 
+            string = PyUnicode_AsUTF8AndSize(parameter, &buflen); 
+            if (string == NULL) 
+                return -1; 
+            if (buflen > INT_MAX) { 
+                PyErr_SetString(PyExc_OverflowError, 
+                                "string longer than INT_MAX bytes"); 
+                return -1; 
+            } 
+            rc = sqlite3_bind_text(self->st, pos, string, (int)buflen, SQLITE_TRANSIENT); 
+            break; 
+        case TYPE_BUFFER: { 
+            Py_buffer view; 
+            if (PyObject_GetBuffer(parameter, &view, PyBUF_SIMPLE) != 0) { 
+                PyErr_SetString(PyExc_ValueError, "could not convert BLOB to buffer"); 
+                return -1; 
+            } 
+            if (view.len > INT_MAX) { 
+                PyErr_SetString(PyExc_OverflowError, 
+                                "BLOB longer than INT_MAX bytes"); 
+                PyBuffer_Release(&view); 
+                return -1; 
+            } 
+            rc = sqlite3_bind_blob(self->st, pos, view.buf, (int)view.len, SQLITE_TRANSIENT); 
+            PyBuffer_Release(&view); 
+            break; 
+        } 
+        case TYPE_UNKNOWN: 
+            rc = -1; 
+    } 
+ 
+final: 
+    return rc; 
+} 
+ 
+/* returns 0 if the object is one of Python's internal ones that don't need to be adapted */ 
+static int _need_adapt(PyObject* obj) 
+{ 
+    if (pysqlite_BaseTypeAdapted) { 
+        return 1; 
+    } 
+ 
+    if (PyLong_CheckExact(obj) || PyFloat_CheckExact(obj) 
+          || PyUnicode_CheckExact(obj) || PyByteArray_CheckExact(obj)) { 
+        return 0; 
+    } else { 
+        return 1; 
+    } 
+} 
+ 
+void pysqlite_statement_bind_parameters(pysqlite_Statement* self, PyObject* parameters) 
+{ 
+    PyObject* current_param; 
+    PyObject* adapted; 
+    const char* binding_name; 
+    int i; 
+    int rc; 
+    int num_params_needed; 
+    Py_ssize_t num_params; 
+ 
+    Py_BEGIN_ALLOW_THREADS 
+    num_params_needed = sqlite3_bind_parameter_count(self->st); 
+    Py_END_ALLOW_THREADS 
+ 
+    if (PyTuple_CheckExact(parameters) || PyList_CheckExact(parameters) || (!PyDict_Check(parameters) && PySequence_Check(parameters))) { 
+        /* parameters passed as sequence */ 
+        if (PyTuple_CheckExact(parameters)) { 
+            num_params = PyTuple_GET_SIZE(parameters); 
+        } else if (PyList_CheckExact(parameters)) { 
+            num_params = PyList_GET_SIZE(parameters); 
+        } else { 
+            num_params = PySequence_Size(parameters); 
             if (num_params == -1) {
                 return;
             }
-        }
-        if (num_params != num_params_needed) {
-            PyErr_Format(pysqlite_ProgrammingError,
-                         "Incorrect number of bindings supplied. The current "
-                         "statement uses %d, and there are %zd supplied.",
-                         num_params_needed, num_params);
-            return;
-        }
-        for (i = 0; i < num_params; i++) {
-            if (PyTuple_CheckExact(parameters)) {
-                current_param = PyTuple_GET_ITEM(parameters, i);
+        } 
+        if (num_params != num_params_needed) { 
+            PyErr_Format(pysqlite_ProgrammingError, 
+                         "Incorrect number of bindings supplied. The current " 
+                         "statement uses %d, and there are %zd supplied.", 
+                         num_params_needed, num_params); 
+            return; 
+        } 
+        for (i = 0; i < num_params; i++) { 
+            if (PyTuple_CheckExact(parameters)) { 
+                current_param = PyTuple_GET_ITEM(parameters, i); 
                 Py_INCREF(current_param);
-            } else if (PyList_CheckExact(parameters)) {
+            } else if (PyList_CheckExact(parameters)) { 
                 current_param = PyList_GetItem(parameters, i);
-                Py_XINCREF(current_param);
-            } else {
-                current_param = PySequence_GetItem(parameters, i);
-            }
-            if (!current_param) {
-                return;
-            }
-
-            if (!_need_adapt(current_param)) {
-                adapted = current_param;
-            } else {
+                Py_XINCREF(current_param); 
+            } else { 
+                current_param = PySequence_GetItem(parameters, i); 
+            } 
+            if (!current_param) { 
+                return; 
+            } 
+ 
+            if (!_need_adapt(current_param)) { 
+                adapted = current_param; 
+            } else { 
                 adapted = pysqlite_microprotocols_adapt(current_param, (PyObject*)&pysqlite_PrepareProtocolType, current_param);
                 Py_DECREF(current_param);
                 if (!adapted) {
                     return;
-                }
-            }
-
-            rc = pysqlite_statement_bind_parameter(self, i + 1, adapted);
-            Py_DECREF(adapted);
-
-            if (rc != SQLITE_OK) {
-                if (!PyErr_Occurred()) {
-                    PyErr_Format(pysqlite_InterfaceError, "Error binding parameter %d - probably unsupported type.", i);
-                }
-                return;
-            }
-        }
-    } else if (PyDict_Check(parameters)) {
-        /* parameters passed as dictionary */
-        for (i = 1; i <= num_params_needed; i++) {
+                } 
+            } 
+ 
+            rc = pysqlite_statement_bind_parameter(self, i + 1, adapted); 
+            Py_DECREF(adapted); 
+ 
+            if (rc != SQLITE_OK) { 
+                if (!PyErr_Occurred()) { 
+                    PyErr_Format(pysqlite_InterfaceError, "Error binding parameter %d - probably unsupported type.", i); 
+                } 
+                return; 
+            } 
+        } 
+    } else if (PyDict_Check(parameters)) { 
+        /* parameters passed as dictionary */ 
+        for (i = 1; i <= num_params_needed; i++) { 
             PyObject *binding_name_obj;
-            Py_BEGIN_ALLOW_THREADS
-            binding_name = sqlite3_bind_parameter_name(self->st, i);
-            Py_END_ALLOW_THREADS
-            if (!binding_name) {
-                PyErr_Format(pysqlite_ProgrammingError, "Binding %d has no name, but you supplied a dictionary (which has only names).", i);
-                return;
-            }
-
-            binding_name++; /* skip first char (the colon) */
+            Py_BEGIN_ALLOW_THREADS 
+            binding_name = sqlite3_bind_parameter_name(self->st, i); 
+            Py_END_ALLOW_THREADS 
+            if (!binding_name) { 
+                PyErr_Format(pysqlite_ProgrammingError, "Binding %d has no name, but you supplied a dictionary (which has only names).", i); 
+                return; 
+            } 
+ 
+            binding_name++; /* skip first char (the colon) */ 
             binding_name_obj = PyUnicode_FromString(binding_name);
             if (!binding_name_obj) {
                 return;
             }
-            if (PyDict_CheckExact(parameters)) {
+            if (PyDict_CheckExact(parameters)) { 
                 current_param = PyDict_GetItemWithError(parameters, binding_name_obj);
-                Py_XINCREF(current_param);
-            } else {
+                Py_XINCREF(current_param); 
+            } else { 
                 current_param = PyObject_GetItem(parameters, binding_name_obj);
-            }
+            } 
             Py_DECREF(binding_name_obj);
-            if (!current_param) {
+            if (!current_param) { 
                 if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_LookupError)) {
                     PyErr_Format(pysqlite_ProgrammingError, "You did not supply a value for binding %d.", i);
                 }
-                return;
-            }
-
-            if (!_need_adapt(current_param)) {
-                adapted = current_param;
-            } else {
+                return; 
+            } 
+ 
+            if (!_need_adapt(current_param)) { 
+                adapted = current_param; 
+            } else { 
                 adapted = pysqlite_microprotocols_adapt(current_param, (PyObject*)&pysqlite_PrepareProtocolType, current_param);
                 Py_DECREF(current_param);
                 if (!adapted) {
                     return;
-                }
-            }
-
-            rc = pysqlite_statement_bind_parameter(self, i, adapted);
-            Py_DECREF(adapted);
-
-            if (rc != SQLITE_OK) {
-                if (!PyErr_Occurred()) {
-                    PyErr_Format(pysqlite_InterfaceError, "Error binding parameter :%s - probably unsupported type.", binding_name);
-                }
-                return;
-           }
-        }
-    } else {
-        PyErr_SetString(PyExc_ValueError, "parameters are of unsupported type");
-    }
-}
-
-int pysqlite_statement_finalize(pysqlite_Statement* self)
-{
-    int rc;
-
-    rc = SQLITE_OK;
-    if (self->st) {
-        Py_BEGIN_ALLOW_THREADS
-        rc = sqlite3_finalize(self->st);
-        Py_END_ALLOW_THREADS
-        self->st = NULL;
-    }
-
-    self->in_use = 0;
-
-    return rc;
-}
-
-int pysqlite_statement_reset(pysqlite_Statement* self)
-{
-    int rc;
-
-    rc = SQLITE_OK;
-
-    if (self->in_use && self->st) {
-        Py_BEGIN_ALLOW_THREADS
-        rc = sqlite3_reset(self->st);
-        Py_END_ALLOW_THREADS
-
-        if (rc == SQLITE_OK) {
-            self->in_use = 0;
-        }
-    }
-
-    return rc;
-}
-
-void pysqlite_statement_mark_dirty(pysqlite_Statement* self)
-{
-    self->in_use = 1;
-}
-
-void pysqlite_statement_dealloc(pysqlite_Statement* self)
-{
-    if (self->st) {
-        Py_BEGIN_ALLOW_THREADS
-        sqlite3_finalize(self->st);
-        Py_END_ALLOW_THREADS
-    }
-
-    self->st = NULL;
-
-    Py_XDECREF(self->sql);
-
-    if (self->in_weakreflist != NULL) {
-        PyObject_ClearWeakRefs((PyObject*)self);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-/*
- * Checks if there is anything left in an SQL string after SQLite compiled it.
- * This is used to check if somebody tried to execute more than one SQL command
- * with one execute()/executemany() command, which the DB-API and we don't
- * allow.
- *
- * Returns 1 if there is more left than should be. 0 if ok.
- */
-static int pysqlite_check_remaining_sql(const char* tail)
-{
-    const char* pos = tail;
-
-    parse_remaining_sql_state state = NORMAL;
-
-    for (;;) {
-        switch (*pos) {
-            case 0:
-                return 0;
-            case '-':
-                if (state == NORMAL) {
-                    state  = LINECOMMENT_1;
-                } else if (state == LINECOMMENT_1) {
-                    state = IN_LINECOMMENT;
-                }
-                break;
-            case ' ':
-            case '\t':
-                break;
-            case '\n':
-            case 13:
-                if (state == IN_LINECOMMENT) {
-                    state = NORMAL;
-                }
-                break;
-            case '/':
-                if (state == NORMAL) {
-                    state = COMMENTSTART_1;
-                } else if (state == COMMENTEND_1) {
-                    state = NORMAL;
-                } else if (state == COMMENTSTART_1) {
-                    return 1;
-                }
-                break;
-            case '*':
-                if (state == NORMAL) {
-                    return 1;
-                } else if (state == LINECOMMENT_1) {
-                    return 1;
-                } else if (state == COMMENTSTART_1) {
-                    state = IN_COMMENT;
-                } else if (state == IN_COMMENT) {
-                    state = COMMENTEND_1;
-                }
-                break;
-            default:
-                if (state == COMMENTEND_1) {
-                    state = IN_COMMENT;
-                } else if (state == IN_LINECOMMENT) {
-                } else if (state == IN_COMMENT) {
-                } else {
-                    return 1;
-                }
-        }
-
-        pos++;
-    }
-
-    return 0;
-}
-
-PyTypeObject pysqlite_StatementType = {
-        PyVarObject_HEAD_INIT(NULL, 0)
-        MODULE_NAME ".Statement",                       /* tp_name */
-        sizeof(pysqlite_Statement),                     /* tp_basicsize */
-        0,                                              /* tp_itemsize */
-        (destructor)pysqlite_statement_dealloc,         /* tp_dealloc */
+                } 
+            } 
+ 
+            rc = pysqlite_statement_bind_parameter(self, i, adapted); 
+            Py_DECREF(adapted); 
+ 
+            if (rc != SQLITE_OK) { 
+                if (!PyErr_Occurred()) { 
+                    PyErr_Format(pysqlite_InterfaceError, "Error binding parameter :%s - probably unsupported type.", binding_name); 
+                } 
+                return; 
+           } 
+        } 
+    } else { 
+        PyErr_SetString(PyExc_ValueError, "parameters are of unsupported type"); 
+    } 
+} 
+ 
+int pysqlite_statement_finalize(pysqlite_Statement* self) 
+{ 
+    int rc; 
+ 
+    rc = SQLITE_OK; 
+    if (self->st) { 
+        Py_BEGIN_ALLOW_THREADS 
+        rc = sqlite3_finalize(self->st); 
+        Py_END_ALLOW_THREADS 
+        self->st = NULL; 
+    } 
+ 
+    self->in_use = 0; 
+ 
+    return rc; 
+} 
+ 
+int pysqlite_statement_reset(pysqlite_Statement* self) 
+{ 
+    int rc; 
+ 
+    rc = SQLITE_OK; 
+ 
+    if (self->in_use && self->st) { 
+        Py_BEGIN_ALLOW_THREADS 
+        rc = sqlite3_reset(self->st); 
+        Py_END_ALLOW_THREADS 
+ 
+        if (rc == SQLITE_OK) { 
+            self->in_use = 0; 
+        } 
+    } 
+ 
+    return rc; 
+} 
+ 
+void pysqlite_statement_mark_dirty(pysqlite_Statement* self) 
+{ 
+    self->in_use = 1; 
+} 
+ 
+void pysqlite_statement_dealloc(pysqlite_Statement* self) 
+{ 
+    if (self->st) { 
+        Py_BEGIN_ALLOW_THREADS 
+        sqlite3_finalize(self->st); 
+        Py_END_ALLOW_THREADS 
+    } 
+ 
+    self->st = NULL; 
+ 
+    Py_XDECREF(self->sql); 
+ 
+    if (self->in_weakreflist != NULL) { 
+        PyObject_ClearWeakRefs((PyObject*)self); 
+    } 
+ 
+    Py_TYPE(self)->tp_free((PyObject*)self); 
+} 
+ 
+/* 
+ * Checks if there is anything left in an SQL string after SQLite compiled it. 
+ * This is used to check if somebody tried to execute more than one SQL command 
+ * with one execute()/executemany() command, which the DB-API and we don't 
+ * allow. 
+ * 
+ * Returns 1 if there is more left than should be. 0 if ok. 
+ */ 
+static int pysqlite_check_remaining_sql(const char* tail) 
+{ 
+    const char* pos = tail; 
+ 
+    parse_remaining_sql_state state = NORMAL; 
+ 
+    for (;;) { 
+        switch (*pos) { 
+            case 0: 
+                return 0; 
+            case '-': 
+                if (state == NORMAL) { 
+                    state  = LINECOMMENT_1; 
+                } else if (state == LINECOMMENT_1) { 
+                    state = IN_LINECOMMENT; 
+                } 
+                break; 
+            case ' ': 
+            case '\t': 
+                break; 
+            case '\n': 
+            case 13: 
+                if (state == IN_LINECOMMENT) { 
+                    state = NORMAL; 
+                } 
+                break; 
+            case '/': 
+                if (state == NORMAL) { 
+                    state = COMMENTSTART_1; 
+                } else if (state == COMMENTEND_1) { 
+                    state = NORMAL; 
+                } else if (state == COMMENTSTART_1) { 
+                    return 1; 
+                } 
+                break; 
+            case '*': 
+                if (state == NORMAL) { 
+                    return 1; 
+                } else if (state == LINECOMMENT_1) { 
+                    return 1; 
+                } else if (state == COMMENTSTART_1) { 
+                    state = IN_COMMENT; 
+                } else if (state == IN_COMMENT) { 
+                    state = COMMENTEND_1; 
+                } 
+                break; 
+            default: 
+                if (state == COMMENTEND_1) { 
+                    state = IN_COMMENT; 
+                } else if (state == IN_LINECOMMENT) { 
+                } else if (state == IN_COMMENT) { 
+                } else { 
+                    return 1; 
+                } 
+        } 
+ 
+        pos++; 
+    } 
+ 
+    return 0; 
+} 
+ 
+PyTypeObject pysqlite_StatementType = { 
+        PyVarObject_HEAD_INIT(NULL, 0) 
+        MODULE_NAME ".Statement",                       /* tp_name */ 
+        sizeof(pysqlite_Statement),                     /* tp_basicsize */ 
+        0,                                              /* tp_itemsize */ 
+        (destructor)pysqlite_statement_dealloc,         /* tp_dealloc */ 
         0,                                              /* tp_vectorcall_offset */
-        0,                                              /* tp_getattr */
-        0,                                              /* tp_setattr */
+        0,                                              /* tp_getattr */ 
+        0,                                              /* tp_setattr */ 
         0,                                              /* tp_as_async */
-        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 */
-        Py_TPFLAGS_DEFAULT,                             /* tp_flags */
-        0,                                              /* tp_doc */
-        0,                                              /* tp_traverse */
-        0,                                              /* tp_clear */
-        0,                                              /* tp_richcompare */
-        offsetof(pysqlite_Statement, in_weakreflist),   /* tp_weaklistoffset */
-        0,                                              /* tp_iter */
-        0,                                              /* tp_iternext */
-        0,                                              /* tp_methods */
-        0,                                              /* tp_members */
-        0,                                              /* tp_getset */
-        0,                                              /* tp_base */
-        0,                                              /* tp_dict */
-        0,                                              /* tp_descr_get */
-        0,                                              /* tp_descr_set */
-        0,                                              /* tp_dictoffset */
-        (initproc)0,                                    /* tp_init */
-        0,                                              /* tp_alloc */
-        0,                                              /* tp_new */
-        0                                               /* tp_free */
-};
-
-extern int pysqlite_statement_setup_types(void)
-{
-    pysqlite_StatementType.tp_new = PyType_GenericNew;
-    return PyType_Ready(&pysqlite_StatementType);
-}
+        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 */ 
+        Py_TPFLAGS_DEFAULT,                             /* tp_flags */ 
+        0,                                              /* tp_doc */ 
+        0,                                              /* tp_traverse */ 
+        0,                                              /* tp_clear */ 
+        0,                                              /* tp_richcompare */ 
+        offsetof(pysqlite_Statement, in_weakreflist),   /* tp_weaklistoffset */ 
+        0,                                              /* tp_iter */ 
+        0,                                              /* tp_iternext */ 
+        0,                                              /* tp_methods */ 
+        0,                                              /* tp_members */ 
+        0,                                              /* tp_getset */ 
+        0,                                              /* tp_base */ 
+        0,                                              /* tp_dict */ 
+        0,                                              /* tp_descr_get */ 
+        0,                                              /* tp_descr_set */ 
+        0,                                              /* tp_dictoffset */ 
+        (initproc)0,                                    /* tp_init */ 
+        0,                                              /* tp_alloc */ 
+        0,                                              /* tp_new */ 
+        0                                               /* tp_free */ 
+}; 
+ 
+extern int pysqlite_statement_setup_types(void) 
+{ 
+    pysqlite_StatementType.tp_new = PyType_GenericNew; 
+    return PyType_Ready(&pysqlite_StatementType); 
+} 
diff --git a/contrib/tools/python3/src/Modules/_sqlite/statement.h b/contrib/tools/python3/src/Modules/_sqlite/statement.h
index 5002f02dc5b..52d5c4f823d 100644
--- a/contrib/tools/python3/src/Modules/_sqlite/statement.h
+++ b/contrib/tools/python3/src/Modules/_sqlite/statement.h
@@ -1,60 +1,60 @@
-/* statement.h - definitions for the statement type
- *
- * Copyright (C) 2005-2010 Gerhard Häring <[email protected]>
- *
- * This file is part of pysqlite.
- *
- * This software is provided 'as-is', without any express or implied
- * warranty.  In no event will the authors be held liable for any damages
- * arising from the use of this software.
- *
- * Permission is granted to anyone to use this software for any purpose,
- * including commercial applications, and to alter it and redistribute it
- * freely, subject to the following restrictions:
- *
- * 1. The origin of this software must not be misrepresented; you must not
- *    claim that you wrote the original software. If you use this software
- *    in a product, an acknowledgment in the product documentation would be
- *    appreciated but is not required.
- * 2. Altered source versions must be plainly marked as such, and must not be
- *    misrepresented as being the original software.
- * 3. This notice may not be removed or altered from any source distribution.
- */
-
-#ifndef PYSQLITE_STATEMENT_H
-#define PYSQLITE_STATEMENT_H
+/* statement.h - definitions for the statement type 
+ * 
+ * Copyright (C) 2005-2010 Gerhard Häring <[email protected]> 
+ * 
+ * This file is part of pysqlite. 
+ * 
+ * This software is provided 'as-is', without any express or implied 
+ * warranty.  In no event will the authors be held liable for any damages 
+ * arising from the use of this software. 
+ * 
+ * Permission is granted to anyone to use this software for any purpose, 
+ * including commercial applications, and to alter it and redistribute it 
+ * freely, subject to the following restrictions: 
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not 
+ *    claim that you wrote the original software. If you use this software 
+ *    in a product, an acknowledgment in the product documentation would be 
+ *    appreciated but is not required. 
+ * 2. Altered source versions must be plainly marked as such, and must not be 
+ *    misrepresented as being the original software. 
+ * 3. This notice may not be removed or altered from any source distribution. 
+ */ 
+ 
+#ifndef PYSQLITE_STATEMENT_H 
+#define PYSQLITE_STATEMENT_H 
 #define PY_SSIZE_T_CLEAN
-#include "Python.h"
-
-#include "connection.h"
-#include "sqlite3.h"
-
-#define PYSQLITE_TOO_MUCH_SQL (-100)
-#define PYSQLITE_SQL_WRONG_TYPE (-101)
-
-typedef struct
-{
-    PyObject_HEAD
-    sqlite3* db;
-    sqlite3_stmt* st;
-    PyObject* sql;
-    int in_use;
-    int is_dml;
-    PyObject* in_weakreflist; /* List of weak references */
-} pysqlite_Statement;
-
-extern PyTypeObject pysqlite_StatementType;
-
-int pysqlite_statement_create(pysqlite_Statement* self, pysqlite_Connection* connection, PyObject* sql);
-void pysqlite_statement_dealloc(pysqlite_Statement* self);
-
-int pysqlite_statement_bind_parameter(pysqlite_Statement* self, int pos, PyObject* parameter);
-void pysqlite_statement_bind_parameters(pysqlite_Statement* self, PyObject* parameters);
-
-int pysqlite_statement_finalize(pysqlite_Statement* self);
-int pysqlite_statement_reset(pysqlite_Statement* self);
-void pysqlite_statement_mark_dirty(pysqlite_Statement* self);
-
-int pysqlite_statement_setup_types(void);
-
-#endif
+#include "Python.h" 
+ 
+#include "connection.h" 
+#include "sqlite3.h" 
+ 
+#define PYSQLITE_TOO_MUCH_SQL (-100) 
+#define PYSQLITE_SQL_WRONG_TYPE (-101) 
+ 
+typedef struct 
+{ 
+    PyObject_HEAD 
+    sqlite3* db; 
+    sqlite3_stmt* st; 
+    PyObject* sql; 
+    int in_use; 
+    int is_dml; 
+    PyObject* in_weakreflist; /* List of weak references */ 
+} pysqlite_Statement; 
+ 
+extern PyTypeObject pysqlite_StatementType; 
+ 
+int pysqlite_statement_create(pysqlite_Statement* self, pysqlite_Connection* connection, PyObject* sql); 
+void pysqlite_statement_dealloc(pysqlite_Statement* self); 
+ 
+int pysqlite_statement_bind_parameter(pysqlite_Statement* self, int pos, PyObject* parameter); 
+void pysqlite_statement_bind_parameters(pysqlite_Statement* self, PyObject* parameters); 
+ 
+int pysqlite_statement_finalize(pysqlite_Statement* self); 
+int pysqlite_statement_reset(pysqlite_Statement* self); 
+void pysqlite_statement_mark_dirty(pysqlite_Statement* self); 
+ 
+int pysqlite_statement_setup_types(void); 
+ 
+#endif 
diff --git a/contrib/tools/python3/src/Modules/_sqlite/util.c b/contrib/tools/python3/src/Modules/_sqlite/util.c
index 1dbabcdd94a..4501b3c7181 100644
--- a/contrib/tools/python3/src/Modules/_sqlite/util.c
+++ b/contrib/tools/python3/src/Modules/_sqlite/util.c
@@ -1,130 +1,130 @@
-/* util.c - various utility functions
- *
- * Copyright (C) 2005-2010 Gerhard Häring <[email protected]>
- *
- * This file is part of pysqlite.
- *
- * This software is provided 'as-is', without any express or implied
- * warranty.  In no event will the authors be held liable for any damages
- * arising from the use of this software.
- *
- * Permission is granted to anyone to use this software for any purpose,
- * including commercial applications, and to alter it and redistribute it
- * freely, subject to the following restrictions:
- *
- * 1. The origin of this software must not be misrepresented; you must not
- *    claim that you wrote the original software. If you use this software
- *    in a product, an acknowledgment in the product documentation would be
- *    appreciated but is not required.
- * 2. Altered source versions must be plainly marked as such, and must not be
- *    misrepresented as being the original software.
- * 3. This notice may not be removed or altered from any source distribution.
- */
-
-#include "module.h"
-#include "connection.h"
-
-int pysqlite_step(sqlite3_stmt* statement, pysqlite_Connection* connection)
-{
-    int rc;
-
-    if (statement == NULL) {
-        /* this is a workaround for SQLite 3.5 and later. it now apparently
-         * returns NULL for "no-operation" statements */
-        rc = SQLITE_OK;
-    } else {
-        Py_BEGIN_ALLOW_THREADS
-        rc = sqlite3_step(statement);
-        Py_END_ALLOW_THREADS
-    }
-
-    return rc;
-}
-
-/**
- * Checks the SQLite error code and sets the appropriate DB-API exception.
- * Returns the error code (0 means no error occurred).
- */
-int _pysqlite_seterror(sqlite3* db, sqlite3_stmt* st)
-{
-    int errorcode = sqlite3_errcode(db);
-
-    switch (errorcode)
-    {
-        case SQLITE_OK:
-            PyErr_Clear();
-            break;
-        case SQLITE_INTERNAL:
-        case SQLITE_NOTFOUND:
-            PyErr_SetString(pysqlite_InternalError, sqlite3_errmsg(db));
-            break;
-        case SQLITE_NOMEM:
-            (void)PyErr_NoMemory();
-            break;
-        case SQLITE_ERROR:
-        case SQLITE_PERM:
-        case SQLITE_ABORT:
-        case SQLITE_BUSY:
-        case SQLITE_LOCKED:
-        case SQLITE_READONLY:
-        case SQLITE_INTERRUPT:
-        case SQLITE_IOERR:
-        case SQLITE_FULL:
-        case SQLITE_CANTOPEN:
-        case SQLITE_PROTOCOL:
-        case SQLITE_EMPTY:
-        case SQLITE_SCHEMA:
-            PyErr_SetString(pysqlite_OperationalError, sqlite3_errmsg(db));
-            break;
-        case SQLITE_CORRUPT:
-            PyErr_SetString(pysqlite_DatabaseError, sqlite3_errmsg(db));
-            break;
-        case SQLITE_TOOBIG:
-            PyErr_SetString(pysqlite_DataError, sqlite3_errmsg(db));
-            break;
-        case SQLITE_CONSTRAINT:
-        case SQLITE_MISMATCH:
-            PyErr_SetString(pysqlite_IntegrityError, sqlite3_errmsg(db));
-            break;
-        case SQLITE_MISUSE:
-            PyErr_SetString(pysqlite_ProgrammingError, sqlite3_errmsg(db));
-            break;
-        default:
-            PyErr_SetString(pysqlite_DatabaseError, sqlite3_errmsg(db));
-            break;
-    }
-
-    return errorcode;
-}
-
-#ifdef WORDS_BIGENDIAN
-# define IS_LITTLE_ENDIAN 0
-#else
-# define IS_LITTLE_ENDIAN 1
-#endif
-
-sqlite_int64
-_pysqlite_long_as_int64(PyObject * py_val)
-{
-    int overflow;
-    long long value = PyLong_AsLongLongAndOverflow(py_val, &overflow);
-    if (value == -1 && PyErr_Occurred())
-        return -1;
-    if (!overflow) {
-# if SIZEOF_LONG_LONG > 8
-        if (-0x8000000000000000LL <= value && value <= 0x7FFFFFFFFFFFFFFFLL)
-# endif
-            return value;
-    }
-    else if (sizeof(value) < sizeof(sqlite_int64)) {
-        sqlite_int64 int64val;
-        if (_PyLong_AsByteArray((PyLongObject *)py_val,
-                                (unsigned char *)&int64val, sizeof(int64val),
-                                IS_LITTLE_ENDIAN, 1 /* signed */) >= 0) {
-            return int64val;
-        }
-    }
-    PyErr_SetString(PyExc_OverflowError,
-                    "Python int too large to convert to SQLite INTEGER");
-    return -1;
-}
+/* util.c - various utility functions 
+ * 
+ * Copyright (C) 2005-2010 Gerhard Häring <[email protected]> 
+ * 
+ * This file is part of pysqlite. 
+ * 
+ * This software is provided 'as-is', without any express or implied 
+ * warranty.  In no event will the authors be held liable for any damages 
+ * arising from the use of this software. 
+ * 
+ * Permission is granted to anyone to use this software for any purpose, 
+ * including commercial applications, and to alter it and redistribute it 
+ * freely, subject to the following restrictions: 
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not 
+ *    claim that you wrote the original software. If you use this software 
+ *    in a product, an acknowledgment in the product documentation would be 
+ *    appreciated but is not required. 
+ * 2. Altered source versions must be plainly marked as such, and must not be 
+ *    misrepresented as being the original software. 
+ * 3. This notice may not be removed or altered from any source distribution. 
+ */ 
+ 
+#include "module.h" 
+#include "connection.h" 
+ 
+int pysqlite_step(sqlite3_stmt* statement, pysqlite_Connection* connection) 
+{ 
+    int rc; 
+ 
+    if (statement == NULL) { 
+        /* this is a workaround for SQLite 3.5 and later. it now apparently 
+         * returns NULL for "no-operation" statements */ 
+        rc = SQLITE_OK; 
+    } else { 
+        Py_BEGIN_ALLOW_THREADS 
+        rc = sqlite3_step(statement); 
+        Py_END_ALLOW_THREADS 
+    } 
+ 
+    return rc; 
+} 
+ 
+/** 
+ * Checks the SQLite error code and sets the appropriate DB-API exception. 
+ * Returns the error code (0 means no error occurred). 
+ */ 
+int _pysqlite_seterror(sqlite3* db, sqlite3_stmt* st) 
+{ 
+    int errorcode = sqlite3_errcode(db); 
+ 
+    switch (errorcode) 
+    { 
+        case SQLITE_OK: 
+            PyErr_Clear(); 
+            break; 
+        case SQLITE_INTERNAL: 
+        case SQLITE_NOTFOUND: 
+            PyErr_SetString(pysqlite_InternalError, sqlite3_errmsg(db)); 
+            break; 
+        case SQLITE_NOMEM: 
+            (void)PyErr_NoMemory(); 
+            break; 
+        case SQLITE_ERROR: 
+        case SQLITE_PERM: 
+        case SQLITE_ABORT: 
+        case SQLITE_BUSY: 
+        case SQLITE_LOCKED: 
+        case SQLITE_READONLY: 
+        case SQLITE_INTERRUPT: 
+        case SQLITE_IOERR: 
+        case SQLITE_FULL: 
+        case SQLITE_CANTOPEN: 
+        case SQLITE_PROTOCOL: 
+        case SQLITE_EMPTY: 
+        case SQLITE_SCHEMA: 
+            PyErr_SetString(pysqlite_OperationalError, sqlite3_errmsg(db)); 
+            break; 
+        case SQLITE_CORRUPT: 
+            PyErr_SetString(pysqlite_DatabaseError, sqlite3_errmsg(db)); 
+            break; 
+        case SQLITE_TOOBIG: 
+            PyErr_SetString(pysqlite_DataError, sqlite3_errmsg(db)); 
+            break; 
+        case SQLITE_CONSTRAINT: 
+        case SQLITE_MISMATCH: 
+            PyErr_SetString(pysqlite_IntegrityError, sqlite3_errmsg(db)); 
+            break; 
+        case SQLITE_MISUSE: 
+            PyErr_SetString(pysqlite_ProgrammingError, sqlite3_errmsg(db)); 
+            break; 
+        default: 
+            PyErr_SetString(pysqlite_DatabaseError, sqlite3_errmsg(db)); 
+            break; 
+    } 
+ 
+    return errorcode; 
+} 
+ 
+#ifdef WORDS_BIGENDIAN 
+# define IS_LITTLE_ENDIAN 0 
+#else 
+# define IS_LITTLE_ENDIAN 1 
+#endif 
+ 
+sqlite_int64 
+_pysqlite_long_as_int64(PyObject * py_val) 
+{ 
+    int overflow; 
+    long long value = PyLong_AsLongLongAndOverflow(py_val, &overflow); 
+    if (value == -1 && PyErr_Occurred()) 
+        return -1; 
+    if (!overflow) { 
+# if SIZEOF_LONG_LONG > 8 
+        if (-0x8000000000000000LL <= value && value <= 0x7FFFFFFFFFFFFFFFLL) 
+# endif 
+            return value; 
+    } 
+    else if (sizeof(value) < sizeof(sqlite_int64)) { 
+        sqlite_int64 int64val; 
+        if (_PyLong_AsByteArray((PyLongObject *)py_val, 
+                                (unsigned char *)&int64val, sizeof(int64val), 
+                                IS_LITTLE_ENDIAN, 1 /* signed */) >= 0) { 
+            return int64val; 
+        } 
+    } 
+    PyErr_SetString(PyExc_OverflowError, 
+                    "Python int too large to convert to SQLite INTEGER"); 
+    return -1; 
+} 
diff --git a/contrib/tools/python3/src/Modules/_sqlite/util.h b/contrib/tools/python3/src/Modules/_sqlite/util.h
index c5a220e9b0a..a3e01e24462 100644
--- a/contrib/tools/python3/src/Modules/_sqlite/util.h
+++ b/contrib/tools/python3/src/Modules/_sqlite/util.h
@@ -1,48 +1,48 @@
-/* util.h - various utility functions
- *
- * Copyright (C) 2005-2010 Gerhard Häring <[email protected]>
- *
- * This file is part of pysqlite.
- *
- * This software is provided 'as-is', without any express or implied
- * warranty.  In no event will the authors be held liable for any damages
- * arising from the use of this software.
- *
- * Permission is granted to anyone to use this software for any purpose,
- * including commercial applications, and to alter it and redistribute it
- * freely, subject to the following restrictions:
- *
- * 1. The origin of this software must not be misrepresented; you must not
- *    claim that you wrote the original software. If you use this software
- *    in a product, an acknowledgment in the product documentation would be
- *    appreciated but is not required.
- * 2. Altered source versions must be plainly marked as such, and must not be
- *    misrepresented as being the original software.
- * 3. This notice may not be removed or altered from any source distribution.
- */
-
-#ifndef PYSQLITE_UTIL_H
-#define PYSQLITE_UTIL_H
+/* util.h - various utility functions 
+ * 
+ * Copyright (C) 2005-2010 Gerhard Häring <[email protected]> 
+ * 
+ * This file is part of pysqlite. 
+ * 
+ * This software is provided 'as-is', without any express or implied 
+ * warranty.  In no event will the authors be held liable for any damages 
+ * arising from the use of this software. 
+ * 
+ * Permission is granted to anyone to use this software for any purpose, 
+ * including commercial applications, and to alter it and redistribute it 
+ * freely, subject to the following restrictions: 
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not 
+ *    claim that you wrote the original software. If you use this software 
+ *    in a product, an acknowledgment in the product documentation would be 
+ *    appreciated but is not required. 
+ * 2. Altered source versions must be plainly marked as such, and must not be 
+ *    misrepresented as being the original software. 
+ * 3. This notice may not be removed or altered from any source distribution. 
+ */ 
+ 
+#ifndef PYSQLITE_UTIL_H 
+#define PYSQLITE_UTIL_H 
 #define PY_SSIZE_T_CLEAN
-#include "Python.h"
-#include "pythread.h"
-#include "sqlite3.h"
-#include "connection.h"
-
-int pysqlite_step(sqlite3_stmt* statement, pysqlite_Connection* connection);
-
-/**
- * Checks the SQLite error code and sets the appropriate DB-API exception.
- * Returns the error code (0 means no error occurred).
- */
-int _pysqlite_seterror(sqlite3* db, sqlite3_stmt* st);
-
-sqlite_int64 _pysqlite_long_as_int64(PyObject * value);
-
-#if SQLITE_VERSION_NUMBER >= 3007014
-#define SQLITE3_CLOSE sqlite3_close_v2
-#else
-#define SQLITE3_CLOSE sqlite3_close
-#endif
-
-#endif
+#include "Python.h" 
+#include "pythread.h" 
+#include "sqlite3.h" 
+#include "connection.h" 
+ 
+int pysqlite_step(sqlite3_stmt* statement, pysqlite_Connection* connection); 
+ 
+/** 
+ * Checks the SQLite error code and sets the appropriate DB-API exception. 
+ * Returns the error code (0 means no error occurred). 
+ */ 
+int _pysqlite_seterror(sqlite3* db, sqlite3_stmt* st); 
+ 
+sqlite_int64 _pysqlite_long_as_int64(PyObject * value); 
+ 
+#if SQLITE_VERSION_NUMBER >= 3007014 
+#define SQLITE3_CLOSE sqlite3_close_v2 
+#else 
+#define SQLITE3_CLOSE sqlite3_close 
+#endif 
+ 
+#endif 
diff --git a/contrib/tools/python3/src/Modules/_sqlite/ya.make b/contrib/tools/python3/src/Modules/_sqlite/ya.make
index 44f7188be0c..f0d6ca9c4d3 100644
--- a/contrib/tools/python3/src/Modules/_sqlite/ya.make
+++ b/contrib/tools/python3/src/Modules/_sqlite/ya.make
@@ -1,46 +1,46 @@
-LIBRARY()
-
-OWNER(g:contrib orivej)
-
-LICENSE(Python-2.0)
-
-PEERDIR(
-    contrib/libs/sqlite3
-)
-
-ADDINCL(
-    contrib/libs/sqlite3
-)
-
-IF (USE_SYSTEM_PYTHON)
-    # Prevent configure error when arcadia python is a tool in a system python graph.
-    ADDINCL(
-        contrib/tools/python3/src/Include
-    )
-ENDIF()
-
+LIBRARY() 
+ 
+OWNER(g:contrib orivej) 
+ 
+LICENSE(Python-2.0) 
+ 
+PEERDIR( 
+    contrib/libs/sqlite3 
+) 
+ 
+ADDINCL( 
+    contrib/libs/sqlite3 
+) 
+ 
+IF (USE_SYSTEM_PYTHON) 
+    # Prevent configure error when arcadia python is a tool in a system python graph. 
+    ADDINCL( 
+        contrib/tools/python3/src/Include 
+    ) 
+ENDIF() 
+ 
 CFLAGS(
     -DMODULE_NAME=\"sqlite3\"
 )
 
-PYTHON3_ADDINCL()
-
-NO_COMPILER_WARNINGS()
-
-NO_RUNTIME()
-
-SRCS(
-    cache.c
-    connection.c
-    cursor.c
-    microprotocols.c
-    module.c
-    prepare_protocol.c
-    row.c
-    statement.c
-    util.c
-)
-
-PY_REGISTER(_sqlite3)
-
-END()
+PYTHON3_ADDINCL() 
+ 
+NO_COMPILER_WARNINGS() 
+ 
+NO_RUNTIME() 
+ 
+SRCS( 
+    cache.c 
+    connection.c 
+    cursor.c 
+    microprotocols.c 
+    module.c 
+    prepare_protocol.c 
+    row.c 
+    statement.c 
+    util.c 
+) 
+ 
+PY_REGISTER(_sqlite3) 
+ 
+END()