diff --git a/Modules/pyexpat.c b/Modules/pyexpat.c
index f8b3bce..4eb8eea 100644
--- a/Modules/pyexpat.c
+++ b/Modules/pyexpat.c
@@ -38,21 +38,21 @@
 #define VERSION "1.9"
 
 enum HandlerTypes{
-        StartElement, 
-        EndElement, 
-        ProcessingInstruction, 
-        CharacterData,
-        UnparsedEntityDecl,
-        NotationDecl,
-        StartNamespaceDecl,
-        EndNamespaceDecl,
-        Comment,
-        StartCdataSection,
-        EndCdataSection,
-        Default,
-        DefaultHandlerExpand,
-        NotStandalone,
-        ExternalEntityRef
+	StartElement, 
+	EndElement, 
+	ProcessingInstruction, 
+	CharacterData,
+	UnparsedEntityDecl,
+	NotationDecl,
+	StartNamespaceDecl,
+	EndNamespaceDecl,
+	Comment,
+	StartCdataSection,
+	EndCdataSection,
+	Default,
+	DefaultHandlerExpand,
+	NotStandalone,
+	ExternalEntityRef
 };
 
 static PyObject *ErrorObject;
@@ -62,10 +62,12 @@
 /* Declarations for objects of type xmlparser */
 
 typedef struct {
-        PyObject_HEAD
+	PyObject_HEAD
 
-        XML_Parser itself;
-        PyObject **handlers;
+	XML_Parser itself;
+        int returns_unicode; /* True if Unicode strings are returned;
+				if false, UTF-8 strings are returned */
+	PyObject **handlers;
 } xmlparseobject;
 
 staticforward PyTypeObject Xmlparsetype;
@@ -73,19 +75,54 @@
 typedef void (*xmlhandlersetter)( XML_Parser *self, void *meth );
 typedef void* xmlhandler;
 
-struct HandlerInfo{
-        const char *name;
-        xmlhandlersetter setter;
-        xmlhandler handler;
+struct HandlerInfo {
+	const char *name;
+	xmlhandlersetter setter;
+	xmlhandler handler;
 };
 
 staticforward struct HandlerInfo handler_info[];
 
-static PyObject *conv_atts( XML_Char **atts){
+/* Convert an array of attributes and their values into a Python dict */
+
+static PyObject *conv_atts_using_string( XML_Char **atts){
+	PyObject *attrs_obj=NULL;
+	XML_Char **attrs_p, **attrs_k;
+	int attrs_len;
+	PyObject *rv;
+
+	if( (attrs_obj = PyDict_New()) == NULL ) 
+		goto finally;
+	for(attrs_len=0, attrs_p = atts; 
+	    *attrs_p;
+	    attrs_p++, attrs_len++) {
+		if (attrs_len%2) {
+			rv=PyString_FromString(*attrs_p);  
+			if (! rv) {
+				Py_DECREF(attrs_obj);
+				attrs_obj=NULL;
+				goto finally;
+			}
+			if (PyDict_SetItemString(
+			       attrs_obj,
+			       (char*)*attrs_k, rv) < 0){
+				Py_DECREF(attrs_obj);
+				attrs_obj=NULL;
+				goto finally;
+			}
+			Py_DECREF(rv);
+		}
+		else attrs_k=attrs_p;
+	}
+	finally:
+	return attrs_obj;
+}
+
+#if !(PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6)
+static PyObject *conv_atts_using_unicode( XML_Char **atts){
         PyObject *attrs_obj=NULL;
         XML_Char **attrs_p, **attrs_k;
         int attrs_len;
-        PyObject *rv;
 
         if( (attrs_obj = PyDict_New()) == NULL ) 
                 goto finally;
@@ -93,20 +130,29 @@
             *attrs_p;
             attrs_p++, attrs_len++) {
                 if (attrs_len%2) {
-                        rv=PyString_FromString(*attrs_p);  
-                        if (! rv) {
+		        PyObject *attr_str, *value_str;
+		        const char *p = (const char *) (*attrs_k);
+                        attr_str=PyUnicode_DecodeUTF8(p, strlen(p), "strict"); 
+                        if (! attr_str) {
                                 Py_DECREF(attrs_obj);
                                 attrs_obj=NULL;
                                 goto finally;
                         }
-                        if (PyDict_SetItemString(
-                               attrs_obj,
-                               (char*)*attrs_k, rv) < 0){
+			p = (const char *) *attrs_p;
+                        value_str=PyUnicode_DecodeUTF8(p, strlen(p), "strict");
+                        if (! value_str) {
+                                Py_DECREF(attrs_obj);
+                                Py_DECREF(attr_str);
+                                attrs_obj=NULL;
+                                goto finally;
+                        }
+                        if (PyDict_SetItem(attrs_obj, attr_str, value_str) < 0) {
                                 Py_DECREF(attrs_obj);
                                 attrs_obj=NULL;
                                 goto finally;
                         }
-                        Py_DECREF(rv);
+                        Py_DECREF(attr_str);
+                        Py_DECREF(value_str);
                 }
                 else attrs_k=attrs_p;
         }
@@ -114,131 +160,222 @@
         return attrs_obj;
 }
 
+/* Convert a string of XML_Chars into a Unicode string.
+   Returns None if str is a null pointer. */
+
+static PyObject *conv_string_to_unicode( XML_Char *str ) {
+  /* XXX currently this code assumes that XML_Char is 8-bit, 
+     and hence in UTF-8.  */
+  /* UTF-8 from Expat, Unicode desired */
+  if (str == NULL) {Py_INCREF(Py_None); return Py_None;}
+  return PyUnicode_DecodeUTF8( (const char *)str, 
+			       strlen( (const char *)str ), 
+			       "strict" );
+}
+
+static PyObject *conv_string_len_to_unicode( const XML_Char *str, int len ) {
+  /* XXX currently this code assumes that XML_Char is 8-bit, 
+     and hence in UTF-8.  */
+  /* UTF-8 from Expat, Unicode desired */
+  if (str == NULL) {Py_INCREF(Py_None); return Py_None;}
+  return PyUnicode_DecodeUTF8( (const char *)str, 
+			       len, 
+			       "strict" );
+}
+#endif
+
+/* Convert a string of XML_Chars into an 8-bit Python string.
+   Returns None if str is a null pointer. */
+
+static PyObject *conv_string_to_utf8( XML_Char *str ) {
+  /* XXX currently this code assumes that XML_Char is 8-bit, 
+     and hence in UTF-8.  */
+  /* UTF-8 from Expat, UTF-8 desired */
+  if (str == NULL) {Py_INCREF(Py_None); return Py_None;}
+  return PyString_FromString( (const char *)str );
+}
+
+static PyObject *conv_string_len_to_utf8( const XML_Char *str, 
+					  int len ) 
+{
+  /* XXX currently this code assumes that XML_Char is 8-bit, 
+     and hence in UTF-8.  */
+  /* UTF-8 from Expat, UTF-8 desired */
+  if (str == NULL) {Py_INCREF(Py_None); return Py_None;}
+  return PyString_FromStringAndSize( (const char *)str, len );
+}
+
 /* Callback routines */
 
-void clear_handlers( xmlparseobject *self );
+static void clear_handlers( xmlparseobject *self );
 
-void flag_error( xmlparseobject *self ){
-        clear_handlers(self);
+static void flag_error( xmlparseobject *self ){
+	clear_handlers(self);
 }
 
 #define RC_HANDLER( RC, NAME, PARAMS, INIT, PARAM_FORMAT, CONVERSION, \
-                RETURN, GETUSERDATA) \
+		RETURN, GETUSERDATA) \
 \
 static RC my_##NAME##Handler PARAMS {\
-        xmlparseobject *self = GETUSERDATA ; \
-        PyObject *args=NULL; \
-        PyObject *rv=NULL; \
-        INIT \
+	xmlparseobject *self = GETUSERDATA ; \
+	PyObject *args=NULL; \
+	PyObject *rv=NULL; \
+	INIT \
 \
-        if (self->handlers[NAME] \
-            && self->handlers[NAME] != Py_None) { \
-                args = Py_BuildValue PARAM_FORMAT ;\
-                if (!args) return RETURN; \
-                rv = PyEval_CallObject(self->handlers[NAME], args); \
-                Py_DECREF(args); \
-                if (rv == NULL) { \
-                        flag_error( self ); \
-                        return RETURN; \
-                } \
-                CONVERSION \
-                Py_DECREF(rv); \
-        } \
-        return RETURN; \
+	if (self->handlers[NAME] \
+	    && self->handlers[NAME] != Py_None) { \
+		args = Py_BuildValue PARAM_FORMAT ;\
+		if (!args) return RETURN; \
+		rv = PyEval_CallObject(self->handlers[NAME], args); \
+		Py_DECREF(args); \
+		if (rv == NULL) { \
+			flag_error( self ); \
+			return RETURN; \
+		} \
+		CONVERSION \
+		Py_DECREF(rv); \
+	} \
+	return RETURN; \
 }
 
-#define NOTHING /**/
+#if PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6
+#define STRING_CONV_FUNC conv_string_to_utf8
+#else
+/* Python 1.6 and later versions */
+#define STRING_CONV_FUNC (self->returns_unicode \
+                          ? conv_string_to_unicode : conv_string_to_utf8)
+#endif
 
 #define VOID_HANDLER( NAME, PARAMS, PARAM_FORMAT ) \
-        RC_HANDLER( void, NAME, PARAMS, NOTHING, PARAM_FORMAT, NOTHING, NOTHING,\
-        (xmlparseobject *)userData )
+	RC_HANDLER( void, NAME, PARAMS, ;, PARAM_FORMAT, ;, ;,\
+	(xmlparseobject *)userData )
 
 #define INT_HANDLER( NAME, PARAMS, PARAM_FORMAT )\
-        RC_HANDLER( int, NAME, PARAMS, int rc=0;, PARAM_FORMAT,  \
-                        rc = PyInt_AsLong( rv );, rc, \
-        (xmlparseobject *)userData )
+	RC_HANDLER( int, NAME, PARAMS, int rc=0;, PARAM_FORMAT,  \
+			rc = PyInt_AsLong( rv );, rc, \
+	(xmlparseobject *)userData )
 
+#if PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6
 VOID_HANDLER( StartElement, 
-                (void *userData, const XML_Char *name, const XML_Char **atts ), 
-                ("(sO&)", name, conv_atts, atts ) )
+		(void *userData, const XML_Char *name, const XML_Char **atts ), 
+                ("(O&O&)", STRING_CONV_FUNC, name, 
+		 conv_atts_using_string, atts ) )
+#else
+/* Python 1.6 and later */
+VOID_HANDLER( StartElement, 
+		(void *userData, const XML_Char *name, const XML_Char **atts ), 
+                ("(O&O&)", STRING_CONV_FUNC, name, 
+		 (self->returns_unicode  
+		  ? conv_atts_using_unicode 
+		  : conv_atts_using_string), atts ) )
+#endif
 
 VOID_HANDLER( EndElement, 
-                (void *userData, const XML_Char *name ), 
-                ("(s)", name) )
+		(void *userData, const XML_Char *name ), 
+                ("(O&)", STRING_CONV_FUNC, name) )
 
 VOID_HANDLER( ProcessingInstruction,
-                (void *userData, 
-                const XML_Char *target, 
-                const XML_Char *data),
-                ("(ss)",target, data ))
+		(void *userData, 
+		const XML_Char *target, 
+		const XML_Char *data),
+                ("(O&O&)",STRING_CONV_FUNC,target, STRING_CONV_FUNC,data ))
 
+#if PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6
 VOID_HANDLER( CharacterData, 
-                (void *userData, const XML_Char *data, int len), 
-                ("(s#)", data, len ) )
+	      (void *userData, const XML_Char *data, int len), 
+	      ("(O)", conv_string_len_to_utf8(data,len) ) )
+#else
+VOID_HANDLER( CharacterData, 
+	      (void *userData, const XML_Char *data, int len), 
+	      ("(O)", (self->returns_unicode 
+		       ? conv_string_len_to_unicode(data,len) 
+		       : conv_string_len_to_utf8(data,len) ) ) )
+#endif
 
 VOID_HANDLER( UnparsedEntityDecl,
-                (void *userData, 
-                        const XML_Char *entityName,
-                        const XML_Char *base,
-                        const XML_Char *systemId,
-                        const XML_Char *publicId,
-                        const XML_Char *notationName),
-                ("(sssss)", entityName, base, systemId, publicId, notationName))
+		(void *userData, 
+			const XML_Char *entityName,
+			const XML_Char *base,
+			const XML_Char *systemId,
+		        const XML_Char *publicId,
+		        const XML_Char *notationName),
+                ("(O&O&O&O&O&)", 
+		 STRING_CONV_FUNC,entityName, STRING_CONV_FUNC,base, 
+		 STRING_CONV_FUNC,systemId, STRING_CONV_FUNC,publicId, 
+		 STRING_CONV_FUNC,notationName))
 
 VOID_HANDLER( NotationDecl, 
-                (void *userData,
-                        const XML_Char *notationName,
-                        const XML_Char *base,
-                        const XML_Char *systemId,
-                        const XML_Char *publicId),
-                ("(ssss)", notationName, base, systemId, publicId))
+		(void *userData,
+			const XML_Char *notationName,
+			const XML_Char *base,
+			const XML_Char *systemId,
+			const XML_Char *publicId),
+                ("(O&O&O&O&)", 
+		 STRING_CONV_FUNC,notationName, STRING_CONV_FUNC,base, 
+		 STRING_CONV_FUNC,systemId, STRING_CONV_FUNC,publicId))
 
 VOID_HANDLER( StartNamespaceDecl,
-                (void *userData,
-                      const XML_Char *prefix,
-                      const XML_Char *uri),
-                ("(ss)", prefix, uri ))
+		(void *userData,
+		      const XML_Char *prefix,
+		      const XML_Char *uri),
+                ("(O&O&)", STRING_CONV_FUNC,prefix, STRING_CONV_FUNC,uri ))
 
 VOID_HANDLER( EndNamespaceDecl,
-                (void *userData,
-                    const XML_Char *prefix),
-                ("(s)", prefix ))
+		(void *userData,
+		    const XML_Char *prefix),
+                ("(O&)", STRING_CONV_FUNC,prefix ))
 
 VOID_HANDLER( Comment,
                (void *userData, const XML_Char *prefix),
-                ("(s)", prefix))
+                ("(O&)", STRING_CONV_FUNC,prefix))
 
 VOID_HANDLER( StartCdataSection,
                (void *userData),
-              ("()" ))
-                
+		("()" ))
+		
 VOID_HANDLER( EndCdataSection,
                (void *userData),
-                ("()" ))
+		("()" ))
 
+#if PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6
 VOID_HANDLER( Default,
-                (void *userData,  const XML_Char *s, int len),
-                ("(s#)",s,len))
+	      (void *userData,  const XML_Char *s, int len),
+	      ("(O)", conv_string_len_to_utf8(s,len) ) )
 
 VOID_HANDLER( DefaultHandlerExpand,
-                (void *userData,  const XML_Char *s, int len),
-                ("(s#)",s,len))
+	      (void *userData,  const XML_Char *s, int len),
+	      ("(O)", conv_string_len_to_utf8(s,len) ) )
+#else
+VOID_HANDLER( Default,
+	      (void *userData,  const XML_Char *s, int len),
+	      ("(O)", (self->returns_unicode 
+		       ? conv_string_len_to_unicode(s,len) 
+		       : conv_string_len_to_utf8(s,len) ) ) )
+
+VOID_HANDLER( DefaultHandlerExpand,
+	      (void *userData,  const XML_Char *s, int len),
+	      ("(O)", (self->returns_unicode 
+		       ? conv_string_len_to_unicode(s,len) 
+		       : conv_string_len_to_utf8(s,len) ) ) )
+#endif
 
 INT_HANDLER( NotStandalone, 
-                (void *userData), 
-                ("()"))
+		(void *userData), 
+		("()"))
 
 RC_HANDLER( int, ExternalEntityRef,
-                (XML_Parser parser,
-                    const XML_Char *context,
-                    const XML_Char *base,
-                    const XML_Char *systemId,
-                    const XML_Char *publicId),
-                int rc=0;,
-                ("(ssss)", context, base, systemId, publicId ),
-                rc = PyInt_AsLong( rv );, rc,
-                XML_GetUserData( parser ) )
-                
+		(XML_Parser parser,
+		    const XML_Char *context,
+		    const XML_Char *base,
+		    const XML_Char *systemId,
+		    const XML_Char *publicId),
+		int rc=0;,
+                ("(O&O&O&O&)", 
+		 STRING_CONV_FUNC,context, STRING_CONV_FUNC,base, 
+		 STRING_CONV_FUNC,systemId, STRING_CONV_FUNC,publicId ),
+		rc = PyInt_AsLong( rv );, rc,
+		XML_GetUserData( parser ) )
+		
 
 
 /* File reading copied from cPickle */
@@ -295,61 +432,61 @@
 static PyObject *
 xmlparse_Parse( xmlparseobject *self, PyObject *args )
 {
-        char *s;
-        int slen;
-        int isFinal = 0;
-        int rv;
+	char *s;
+	int slen;
+	int isFinal = 0;
+	int rv;
 
-        if (!PyArg_ParseTuple(args, "s#|i", &s, &slen, &isFinal))
-                return NULL;
-        rv = XML_Parse(self->itself, s, slen, isFinal);
-        if( PyErr_Occurred() ){ 
-                return NULL;
-        }
-        else if (rv == 0) {
+	if (!PyArg_ParseTuple(args, "s#|i", &s, &slen, &isFinal))
+		return NULL;
+	rv = XML_Parse(self->itself, s, slen, isFinal);
+	if( PyErr_Occurred() ){	
+		return NULL;
+	}
+	else if (rv == 0) {
                 PyErr_Format(ErrorObject, "%.200s: line %i, column %i",
-                             XML_ErrorString( XML_GetErrorCode(self->itself) ),
-                             XML_GetErrorLineNumber(self->itself),
-                             XML_GetErrorColumnNumber(self->itself) );
-                return NULL;
-        }
+			     XML_ErrorString( XML_GetErrorCode(self->itself) ),
+			     XML_GetErrorLineNumber(self->itself),
+			     XML_GetErrorColumnNumber(self->itself) );
+		return NULL;
+	}
 
-        return Py_BuildValue("i", rv);
+	return Py_BuildValue("i", rv);
 }
 
 #define BUF_SIZE 2048
 
 int readinst(char *buf, int buf_size, PyObject *meth){
-        PyObject *arg=NULL;
-        PyObject *bytes=NULL;
-        PyObject *str=NULL;
-        int len;
+	PyObject *arg=NULL;
+	PyObject *bytes=NULL;
+	PyObject *str=NULL;
+	int len;
 
-        UNLESS(bytes = PyInt_FromLong(buf_size)) {
-                if (!PyErr_Occurred())
-                PyErr_SetNone(PyExc_EOFError);
-                goto finally;
-        }
+	UNLESS(bytes = PyInt_FromLong(buf_size)) {
+		if (!PyErr_Occurred())
+		PyErr_SetNone(PyExc_EOFError);
+		goto finally;
+	}
 
-        UNLESS(arg)
-                UNLESS(arg = PyTuple_New(1))
-                    goto finally;
+	UNLESS(arg)
+		UNLESS(arg = PyTuple_New(1))
+		    goto finally;
 
-        Py_INCREF(bytes);
-        if (PyTuple_SetItem(arg, 0, bytes) < 0)
-                goto finally;
+	Py_INCREF(bytes);
+	if (PyTuple_SetItem(arg, 0, bytes) < 0)
+		goto finally;
 
-        UNLESS(str = PyObject_CallObject(meth, arg))
-                goto finally;
+	UNLESS(str = PyObject_CallObject(meth, arg))
+		goto finally;
 
-        UNLESS(PyString_Check( str ))
-                goto finally;
+	UNLESS(PyString_Check( str ))
+		goto finally;
 
-        len=PyString_GET_SIZE( str );
-        strncpy( buf, PyString_AsString(str), len );
-        Py_XDECREF( str );
+	len=PyString_GET_SIZE( str );
+	strncpy( buf, PyString_AsString(str), len );
+	Py_XDECREF( str );
 finally:
-        return len;
+	return len;
 }
 
 static char xmlparse_ParseFile__doc__[] = 
@@ -359,53 +496,53 @@
 static PyObject *
 xmlparse_ParseFile( xmlparseobject *self, PyObject *args )
 {
-        int rv=1;
-        PyObject *f;
-        FILE *fp;
-        PyObject *readmethod=NULL;
+	int rv=1;
+	PyObject *f;
+	FILE *fp;
+	PyObject *readmethod=NULL;
 
-        if (!PyArg_ParseTuple(args, "O", &f))
-                return NULL;
+	if (!PyArg_ParseTuple(args, "O", &f))
+		return NULL;
 
-        if (PyFile_Check(f)) {
-                fp = PyFile_AsFile(f);
-        }else{
-                fp = NULL;
-                UNLESS(readmethod = PyObject_GetAttrString(f, "read")) {
-                    PyErr_Clear();
-                    PyErr_SetString( PyExc_TypeError, 
-                        "argument must have 'read' attribute" );
-                    return 0;
-                }
-        }
-        
-        for (;;) {
-                  int bytes_read;
-                  void *buf = XML_GetBuffer(self->itself, BUF_SIZE);
-                  if (buf == NULL) {
-                          /* FIXME: throw exception for no memory */
-                          return NULL;
-                  }
+	if (PyFile_Check(f)) {
+		fp = PyFile_AsFile(f);
+	}else{
+		fp = NULL;
+		UNLESS(readmethod = PyObject_GetAttrString(f, "read")) {
+		    PyErr_Clear();
+		    PyErr_SetString( PyExc_TypeError, 
+			"argument must have 'read' attribute" );
+		    return 0;
+		}
+	}
+	
+	for (;;) {
+		  int bytes_read;
+		  void *buf = XML_GetBuffer(self->itself, BUF_SIZE);
+		  if (buf == NULL) {
+		          PyErr_SetString(PyExc_MemoryError, "out of memory");
+			  return NULL;
+		  }
 
-                  if( fp ){
-                          bytes_read=fread( buf, sizeof( char ), BUF_SIZE, fp);
-                  }else{
-                          bytes_read=readinst( buf, BUF_SIZE, readmethod );
-                  }
+		  if( fp ){
+		          bytes_read=fread( buf, sizeof( char ), BUF_SIZE, fp);
+		  }else{
+			  bytes_read=readinst( buf, BUF_SIZE, readmethod );
+		  }
 
-                  if (bytes_read < 0) {
-                        PyErr_SetFromErrno(PyExc_IOError);
-                        return NULL;
-                  }
-                  rv=XML_ParseBuffer(self->itself, bytes_read, bytes_read == 0);
-                  if( PyErr_Occurred() ){
-                        return NULL;
-                  }
-                  if (!rv || bytes_read == 0)
-                        break;
-        }
+		  if (bytes_read < 0) {
+			PyErr_SetFromErrno(PyExc_IOError);
+			return NULL;
+		  }
+		  rv=XML_ParseBuffer(self->itself, bytes_read, bytes_read == 0);
+		  if( PyErr_Occurred() ){
+			return NULL;
+		  }
+		  if (!rv || bytes_read == 0)
+			break;
+	}
 
-        return Py_BuildValue("i", rv);
+	return Py_BuildValue("i", rv);
 }
 
 static char xmlparse_SetBase__doc__[] = 
@@ -419,8 +556,8 @@
     if (!PyArg_ParseTuple(args, "s", &base))
         return NULL;
     if( !XML_SetBase( self->itself, base ) ){
-        PyErr_SetNone(PyExc_MemoryError);
-        return NULL;
+	PyErr_SetNone(PyExc_MemoryError);
+	return NULL;
     }
 
     Py_INCREF(Py_None);
@@ -437,30 +574,30 @@
     PyObject *rc;
 
     if( PyTuple_Size( args )!=0 ){
-            PyArg_ParseTuple(args, "()" ); /* get good error reporting */
+	    PyArg_ParseTuple(args, "()" ); /* get good error reporting */
         return NULL;
     }
     base=XML_GetBase( self->itself );
     if( base ){
-        rc=Py_BuildValue("s", base);
+	rc=Py_BuildValue("s", base);
     }else{
-        Py_INCREF(Py_None);
-        rc=Py_None;
+	Py_INCREF(Py_None);
+	rc=Py_None;
     }
     return rc;
 
 }
 
 static struct PyMethodDef xmlparse_methods[] = {
-        {"Parse",       (PyCFunction)xmlparse_Parse,
-                METH_VARARGS,   xmlparse_Parse__doc__},
-        {"ParseFile",   (PyCFunction)xmlparse_ParseFile,
-                METH_VARARGS,   xmlparse_ParseFile__doc__},
-        {"SetBase", (PyCFunction)xmlparse_SetBase,
-                METH_VARARGS,      xmlparse_SetBase__doc__},
-        {"GetBase", (PyCFunction)xmlparse_GetBase,
-                METH_VARARGS,      xmlparse_GetBase__doc__},
-        {NULL,          NULL}           /* sentinel */
+	{"Parse",	(PyCFunction)xmlparse_Parse,
+	 	METH_VARARGS,	xmlparse_Parse__doc__},
+	{"ParseFile",	(PyCFunction)xmlparse_ParseFile,
+	 	METH_VARARGS,	xmlparse_ParseFile__doc__},
+	{"SetBase", (PyCFunction)xmlparse_SetBase,
+	 	METH_VARARGS,      xmlparse_SetBase__doc__},
+	{"GetBase", (PyCFunction)xmlparse_GetBase,
+	 	METH_VARARGS,      xmlparse_GetBase__doc__},
+	{NULL,		NULL}		/* sentinel */
 };
 
 /* ---------- */
@@ -468,134 +605,168 @@
 
 static xmlparseobject *
 newxmlparseobject( char *encoding, char *namespace_separator){
-        int i;
-        xmlparseobject *self;
-        
+	int i;
+	xmlparseobject *self;
+	
+#if PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6
+	self = PyObject_NEW(xmlparseobject, &Xmlparsetype);
+	if (self == NULL)
+		return NULL;
+
+	self->returns_unicode = 0;
+#else
+        /* Code for versions 1.6 and later */
         self = PyObject_New(xmlparseobject, &Xmlparsetype);
-        if (self == NULL)
-                return NULL;
+	if (self == NULL)
+		return NULL;
 
-        if (namespace_separator) {
-                self->itself = XML_ParserCreateNS(encoding, 
-                                                *namespace_separator);
-        }else{
-                self->itself = XML_ParserCreate(encoding);
-        }
+	self->returns_unicode = 1;
+#endif
+	if (namespace_separator) {
+		self->itself = XML_ParserCreateNS(encoding, 
+						*namespace_separator);
+	}else{
+		self->itself = XML_ParserCreate(encoding);
+	}
 
-        if( self->itself==NULL ){
-                        PyErr_SetString(PyExc_RuntimeError, 
-                                        "XML_ParserCreate failed");
-                        Py_DECREF(self);
-                        return NULL;
-        }
+	if( self->itself==NULL ){
+		        PyErr_SetString(PyExc_RuntimeError, 
+					"XML_ParserCreate failed");
+			Py_DECREF(self);
+			return NULL;
+	}
 
-        XML_SetUserData(self->itself, (void *)self);
+	XML_SetUserData(self->itself, (void *)self);
 
-        for( i=0; handler_info[i].name!=NULL;i++);
+	for( i=0; handler_info[i].name!=NULL;i++);
 
-        self->handlers=malloc( sizeof( PyObject *)*i );
+	self->handlers=malloc( sizeof( PyObject *)*i );
 
-        clear_handlers( self );
+	clear_handlers( self );
 
-        return self;
+	return self;
 }
 
 
 static void
 xmlparse_dealloc( xmlparseobject *self )
 {
-        int i;
-        if (self->itself)
-                XML_ParserFree(self->itself);
-        self->itself = NULL;
+	int i;
+	if (self->itself)
+		XML_ParserFree(self->itself);
+	self->itself = NULL;
 
-        for( i=0; handler_info[i].name!=NULL; i++ ){
-                Py_XDECREF( self->handlers[i] );
-        }
+	for( i=0; handler_info[i].name!=NULL; i++ ){
+		Py_XDECREF( self->handlers[i] );
+	}
+#if PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6
+        /* Code for versions before 1.6 */
+        free(self);
+#else
+        /* Code for versions 1.6 and later */
         PyObject_Del(self);
+#endif
 }
 
 static int handlername2int( const char *name ){
-        int i;
-        for( i=0;handler_info[i].name!=NULL;i++){
-                if( strcmp( name, handler_info[i].name )==0 ){
-                        return i;
-                }
-        }
-        return -1;
+	int i;
+	for( i=0;handler_info[i].name!=NULL;i++){
+		if( strcmp( name, handler_info[i].name )==0 ){
+			return i;
+		}
+	}
+	return -1;
 }
 
 static PyObject *
 xmlparse_getattr(xmlparseobject *self, char *name)
 {
-        int handlernum;
-        if (strcmp(name, "ErrorCode") == 0)
-                return Py_BuildValue("l",
-                                (long)XML_GetErrorCode(self->itself));
-        if (strcmp(name, "ErrorLineNumber") == 0)
-                return Py_BuildValue("l",
-                                (long)XML_GetErrorLineNumber(self->itself));
-        if (strcmp(name, "ErrorColumnNumber") == 0)
-                return Py_BuildValue("l",
-                                (long)XML_GetErrorColumnNumber(self->itself));
-        if (strcmp(name, "ErrorByteIndex") == 0)
-                return Py_BuildValue("l",
-                                XML_GetErrorByteIndex(self->itself));
+	int handlernum;
+	if (strcmp(name, "ErrorCode") == 0)
+		return Py_BuildValue("l",
+				(long)XML_GetErrorCode(self->itself));
+	if (strcmp(name, "ErrorLineNumber") == 0)
+		return Py_BuildValue("l",
+				(long)XML_GetErrorLineNumber(self->itself));
+	if (strcmp(name, "ErrorColumnNumber") == 0)
+		return Py_BuildValue("l",
+				(long)XML_GetErrorColumnNumber(self->itself));
+	if (strcmp(name, "ErrorByteIndex") == 0)
+		return Py_BuildValue("l",
+				XML_GetErrorByteIndex(self->itself));
+        if (strcmp(name, "returns_unicode") == 0)
+	        return Py_BuildValue("i", self->returns_unicode);
 
-        handlernum=handlername2int( name );
+	handlernum=handlername2int( name );
 
-        if( handlernum!=-1 && self->handlers[handlernum]!=NULL){
-                Py_INCREF( self->handlers[handlernum] );
-                return self->handlers[handlernum];
-        }
+	if( handlernum!=-1 && self->handlers[handlernum]!=NULL){
+		Py_INCREF( self->handlers[handlernum] );
+		return self->handlers[handlernum];
+	}
 
-        if (strcmp(name, "__members__") == 0){
-                int i;
-                PyObject *rc=PyList_New(0);
-                for(i=0; handler_info[i].name!=NULL;i++ ){
-                        PyList_Append( rc, 
-                                PyString_FromString( handler_info[i].name ) );
-                }
-                PyList_Append( rc, PyString_FromString( "ErrorCode" )); 
-                PyList_Append( rc, PyString_FromString( "ErrorLineNumber" ));
-                PyList_Append( rc, PyString_FromString( "ErrorColumnNumber")); 
-                PyList_Append( rc, PyString_FromString( "ErrorByteIndex" )); 
+	if (strcmp(name, "__members__") == 0){
+		int i;
+		PyObject *rc=PyList_New(0);
+		for(i=0; handler_info[i].name!=NULL;i++ ){
+			PyList_Append( rc, 
+				PyString_FromString( handler_info[i].name ) );
+		}
+		PyList_Append( rc, PyString_FromString( "ErrorCode" )); 
+		PyList_Append( rc, PyString_FromString( "ErrorLineNumber" ));
+		PyList_Append( rc, PyString_FromString( "ErrorColumnNumber")); 
+		PyList_Append( rc, PyString_FromString( "ErrorByteIndex" )); 
 
-                return rc;
-        }
+		return rc;
+	}
 
-        return Py_FindMethod(xmlparse_methods, (PyObject *)self, name);
+	return Py_FindMethod(xmlparse_methods, (PyObject *)self, name);
 }
 
 static int sethandler( xmlparseobject *self, const char *name, PyObject* v ){
-        int handlernum = handlername2int( name );
-        if( handlernum!=-1 ){
-                Py_INCREF( v );
-                Py_XDECREF( self->handlers[handlernum] );
-                self->handlers[handlernum]=v;
-                handler_info[handlernum].setter( self->itself, 
-                                handler_info[handlernum].handler );
-                return 1;
-        }
+	int handlernum = handlername2int( name );
+	if( handlernum!=-1 ){
+		Py_INCREF( v );
+		Py_XDECREF( self->handlers[handlernum] );
+		self->handlers[handlernum]=v;
+		handler_info[handlernum].setter( self->itself, 
+				handler_info[handlernum].handler );
+		return 1;
+	}
 
-        return 0;
+	return 0;
 }
 
 static int
 xmlparse_setattr( xmlparseobject *self, char *name, PyObject *v)
 {
-        /* Set attribute 'name' to value 'v'. v==NULL means delete */
-        if (v==NULL) {
-                PyErr_SetString(PyExc_RuntimeError, "Cannot delete attribute");
-                return -1;
-        }
+	/* Set attribute 'name' to value 'v'. v==NULL means delete */
+	if (v==NULL) {
+		PyErr_SetString(PyExc_RuntimeError, "Cannot delete attribute");
+		return -1;
+	}
 
-        if( sethandler( self, name, v ) ){
-                return 0;
-        }
+        if (strcmp(name, "returns_unicode") == 0) {
+		PyObject *intobj = PyNumber_Int(v);
+		if (intobj == NULL) return -1;
+		if (PyInt_AsLong(intobj)) {
+#if PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6
+		  PyErr_SetString(PyExc_ValueError, 
+			 "Cannot return Unicode strings in Python 1.5");
+		  return -1;
+#else
+		  self->returns_unicode = 1;
+#endif
+		}
+		else                      self->returns_unicode = 0;
+		Py_DECREF(intobj);
+		return 0;
+	}
+	if( sethandler( self, name, v ) ){
+		return 0;
+	}
 
-        PyErr_SetString( PyExc_AttributeError, name );
-        return -1;
+	PyErr_SetString( PyExc_AttributeError, name );
+	return -1;
 }
 
 static char Xmlparsetype__doc__[] = 
@@ -603,28 +774,28 @@
 ;
 
 static PyTypeObject Xmlparsetype = {
-        PyObject_HEAD_INIT(NULL)
-        0,                              /*ob_size*/
-        "xmlparser",                    /*tp_name*/
-        sizeof(xmlparseobject),         /*tp_basicsize*/
-        0,                              /*tp_itemsize*/
-        /* methods */
-        (destructor)xmlparse_dealloc,   /*tp_dealloc*/
-        (printfunc)0,           /*tp_print*/
-        (getattrfunc)xmlparse_getattr,  /*tp_getattr*/
-        (setattrfunc)xmlparse_setattr,  /*tp_setattr*/
-        (cmpfunc)0,             /*tp_compare*/
-        (reprfunc)0,            /*tp_repr*/
-        0,                      /*tp_as_number*/
-        0,              /*tp_as_sequence*/
-        0,              /*tp_as_mapping*/
-        (hashfunc)0,            /*tp_hash*/
-        (ternaryfunc)0,         /*tp_call*/
-        (reprfunc)0,            /*tp_str*/
+	PyObject_HEAD_INIT(NULL)
+	0,				/*ob_size*/
+	"xmlparser",			/*tp_name*/
+	sizeof(xmlparseobject),		/*tp_basicsize*/
+	0,				/*tp_itemsize*/
+	/* methods */
+	(destructor)xmlparse_dealloc,	/*tp_dealloc*/
+	(printfunc)0,		/*tp_print*/
+	(getattrfunc)xmlparse_getattr,	/*tp_getattr*/
+	(setattrfunc)xmlparse_setattr,	/*tp_setattr*/
+	(cmpfunc)0,		/*tp_compare*/
+	(reprfunc)0,		/*tp_repr*/
+	0,			/*tp_as_number*/
+	0,		/*tp_as_sequence*/
+	0,		/*tp_as_mapping*/
+	(hashfunc)0,		/*tp_hash*/
+	(ternaryfunc)0,		/*tp_call*/
+	(reprfunc)0,		/*tp_str*/
 
-        /* Space for future expansion */
-        0L,0L,0L,0L,
-        Xmlparsetype__doc__ /* Documentation string */
+	/* Space for future expansion */
+	0L,0L,0L,0L,
+	Xmlparsetype__doc__ /* Documentation string */
 };
 
 /* End of code for xmlparser objects */
@@ -637,13 +808,13 @@
 
 static PyObject *
 pyexpat_ParserCreate(PyObject *notused, PyObject *args, PyObject *kw) {
-        char *encoding  = NULL, *namespace_separator=NULL;
-        static char *kwlist[] = {"encoding", "namespace_separator", NULL};
+	char *encoding  = NULL, *namespace_separator=NULL;
+	static char *kwlist[] = {"encoding", "namespace_separator", NULL};
 
-        if (!PyArg_ParseTupleAndKeywords(args, kw, "|zz", kwlist,
-                                         &encoding, &namespace_separator))
-                return NULL;
-        return (PyObject *)newxmlparseobject(encoding, namespace_separator);
+	if (!PyArg_ParseTupleAndKeywords(args, kw, "|zz", kwlist,
+					 &encoding, &namespace_separator))
+		return NULL;
+	return (PyObject *)newxmlparseobject(encoding, namespace_separator);
 }
 
 static char pyexpat_ErrorString__doc__[] =
@@ -652,219 +823,226 @@
 
 static PyObject *
 pyexpat_ErrorString(self, args)
-        PyObject *self; /* Not used */
-        PyObject *args;
+	PyObject *self;	/* Not used */
+	PyObject *args;
 {
-        long code;
-        
-        if (!PyArg_ParseTuple(args, "l", &code))
-                return NULL;
-        return Py_BuildValue("z", XML_ErrorString((int)code));
+	long code;
+	
+	if (!PyArg_ParseTuple(args, "l", &code))
+		return NULL;
+	return Py_BuildValue("z", XML_ErrorString((int)code));
 }
 
 /* List of methods defined in the module */
 
 static struct PyMethodDef pyexpat_methods[] = {
-        {"ParserCreate",        (PyCFunction)pyexpat_ParserCreate,
-                 METH_VARARGS|METH_KEYWORDS, pyexpat_ParserCreate__doc__},
-        {"ErrorString", (PyCFunction)pyexpat_ErrorString,
-                METH_VARARGS,   pyexpat_ErrorString__doc__},
+	{"ParserCreate",	(PyCFunction)pyexpat_ParserCreate,
+		 METH_VARARGS|METH_KEYWORDS, pyexpat_ParserCreate__doc__},
+	{"ErrorString",	(PyCFunction)pyexpat_ErrorString,
+	 	METH_VARARGS,	pyexpat_ErrorString__doc__},
  
-        {NULL,   (PyCFunction)NULL, 0, NULL}            /* sentinel */
+	{NULL,	 (PyCFunction)NULL, 0, NULL}		/* sentinel */
 };
 
-
-/* Initialization function for the module (*must* be called initpyexpat) */
+/* Module docstring */
 
 static char pyexpat_module_documentation[] = 
 "Python wrapper for Expat parser."
 ;
 
+/* Initialization function for the module */
+
 void
 initpyexpat(){
-        PyObject *m, *d;
+	PyObject *m, *d;
         char *rev="$Revision$";
-        PyObject *errors_module, *errors_dict;
+	PyObject *errors_module, *errors_dict;
 
-        Xmlparsetype.ob_type = &PyType_Type;
+	Xmlparsetype.ob_type = &PyType_Type;
 
-        /* Create the module and add the functions */
-        m = Py_InitModule4("pyexpat", pyexpat_methods,
-                pyexpat_module_documentation,
-                (PyObject*)NULL,PYTHON_API_VERSION);
+	/* Create the module and add the functions */
+	m = Py_InitModule4("pyexpat", pyexpat_methods,
+		pyexpat_module_documentation,
+		(PyObject*)NULL,PYTHON_API_VERSION);
 
-        /* Add some symbolic constants to the module */
-        d = PyModule_GetDict(m);
-        ErrorObject = PyString_FromString("pyexpat.error");
-        PyDict_SetItemString(d, "error", ErrorObject);
+	/* Add some symbolic constants to the module */
+	d = PyModule_GetDict(m);
+	ErrorObject = PyString_FromString("pyexpat.error");
+	PyDict_SetItemString(d, "error", ErrorObject);
 
-        PyDict_SetItemString(d,"__version__",
-                             PyString_FromStringAndSize(rev+11,
-                                                        strlen(rev+11)-2));
+	PyDict_SetItemString(d,"__version__",
+			     PyString_FromStringAndSize(rev+11,
+							strlen(rev+11)-2));
 
-        errors_module=PyModule_New( "errors" );
-        PyDict_SetItemString(d,"errors", errors_module );
+	errors_module=PyModule_New( "errors" );
+	PyDict_SetItemString(d,"errors", errors_module );
 
-        errors_dict=PyModule_GetDict( errors_module );
+	/* XXX When Expat supports some way of figuring out how it was
+	   compiled, this should check and set native_encoding 
+	   appropriately. 
+	*/
+	PyDict_SetItemString(d, "native_encoding", 
+			     PyString_FromString("UTF-8") );
+			     
+	errors_dict=PyModule_GetDict( errors_module );
 
 #define MYCONST(name) \
-        PyDict_SetItemString(errors_dict, #name,  \
-                                PyString_FromString( XML_ErrorString(name)))
-                
-        MYCONST(XML_ERROR_NO_MEMORY);
-        MYCONST(XML_ERROR_SYNTAX);
-        MYCONST(XML_ERROR_NO_ELEMENTS);
-        MYCONST(XML_ERROR_INVALID_TOKEN);
-        MYCONST(XML_ERROR_UNCLOSED_TOKEN);
-        MYCONST(XML_ERROR_PARTIAL_CHAR);
-        MYCONST(XML_ERROR_TAG_MISMATCH);
-        MYCONST(XML_ERROR_DUPLICATE_ATTRIBUTE);
-        MYCONST(XML_ERROR_JUNK_AFTER_DOC_ELEMENT);
-        MYCONST(XML_ERROR_PARAM_ENTITY_REF);
-        MYCONST(XML_ERROR_UNDEFINED_ENTITY);
-        MYCONST(XML_ERROR_RECURSIVE_ENTITY_REF);
-        MYCONST(XML_ERROR_ASYNC_ENTITY);
-        MYCONST(XML_ERROR_BAD_CHAR_REF);
-        MYCONST(XML_ERROR_BINARY_ENTITY_REF);
-        MYCONST(XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF);
-        MYCONST(XML_ERROR_MISPLACED_XML_PI);
-        MYCONST(XML_ERROR_UNKNOWN_ENCODING);
-        MYCONST(XML_ERROR_INCORRECT_ENCODING);
-        
-        /* Check for errors */
-        if (PyErr_Occurred())
-                Py_FatalError("can't initialize module pyexpat");
+	PyDict_SetItemString(errors_dict, #name,  \
+				PyString_FromString( XML_ErrorString(name)))
+		
+	MYCONST(XML_ERROR_NO_MEMORY);
+	MYCONST(XML_ERROR_SYNTAX);
+	MYCONST(XML_ERROR_NO_ELEMENTS);
+	MYCONST(XML_ERROR_INVALID_TOKEN);
+	MYCONST(XML_ERROR_UNCLOSED_TOKEN);
+	MYCONST(XML_ERROR_PARTIAL_CHAR);
+	MYCONST(XML_ERROR_TAG_MISMATCH);
+	MYCONST(XML_ERROR_DUPLICATE_ATTRIBUTE);
+	MYCONST(XML_ERROR_JUNK_AFTER_DOC_ELEMENT);
+	MYCONST(XML_ERROR_PARAM_ENTITY_REF);
+	MYCONST(XML_ERROR_UNDEFINED_ENTITY);
+	MYCONST(XML_ERROR_RECURSIVE_ENTITY_REF);
+	MYCONST(XML_ERROR_ASYNC_ENTITY);
+	MYCONST(XML_ERROR_BAD_CHAR_REF);
+	MYCONST(XML_ERROR_BINARY_ENTITY_REF);
+	MYCONST(XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF);
+	MYCONST(XML_ERROR_MISPLACED_XML_PI);
+	MYCONST(XML_ERROR_UNKNOWN_ENCODING);
+	MYCONST(XML_ERROR_INCORRECT_ENCODING);
+	
+	/* Check for errors */
+	if (PyErr_Occurred())
+		Py_FatalError("can't initialize module pyexpat");
 }
 
 void clear_handlers( xmlparseobject *self ){
-        int i=0;
+	int i=0;
 
-        for( i=0;handler_info[i].name!=NULL;i++ ){
-                self->handlers[i]=NULL;
-                handler_info[i].setter( self->itself, NULL );
-        }
+	for( i=0;handler_info[i].name!=NULL;i++ ){
+		self->handlers[i]=NULL;
+		handler_info[i].setter( self->itself, NULL );
+	}
 }
 
 typedef void (*pairsetter)( XML_Parser, void *handler1, void *handler2 );
 
 void pyxml_UpdatePairedHandlers( xmlparseobject *self, 
-                                int startHandler, 
-                                int endHandler,
-                                pairsetter setter){
-        void *start_handler=NULL;
-        void *end_handler=NULL;
+				int startHandler, 
+				int endHandler,
+				pairsetter setter){
+	void *start_handler=NULL;
+	void *end_handler=NULL;
 
-        if( self->handlers[startHandler] && 
-                        self->handlers[endHandler]!=Py_None ){
-                start_handler=handler_info[startHandler].handler;
-        }
-        if( self->handlers[EndElement] && 
-                        self->handlers[EndElement] !=Py_None ){
-                end_handler=handler_info[endHandler].handler;
-        }
-        
-        setter(self->itself, 
-                              start_handler,
-                              end_handler);
+	if( self->handlers[startHandler] && 
+			self->handlers[endHandler]!=Py_None ){
+		start_handler=handler_info[startHandler].handler;
+	}
+	if( self->handlers[EndElement] && 
+			self->handlers[EndElement] !=Py_None ){
+		end_handler=handler_info[endHandler].handler;
+	}
+	
+	setter(self->itself, 
+			      start_handler,
+			      end_handler);
 }
 
 void pyxml_SetStartElementHandler( XML_Parser *parser, 
-                                void *junk){
-        pyxml_UpdatePairedHandlers(
-                (xmlparseobject *)XML_GetUserData( parser ), 
-                StartElement, EndElement,
-                (pairsetter)XML_SetElementHandler);
+				void *junk){
+	pyxml_UpdatePairedHandlers(
+		(xmlparseobject *)XML_GetUserData( parser ), 
+		StartElement, EndElement,
+		(pairsetter)XML_SetElementHandler);
 }
 
 void pyxml_SetEndElementHandler( XML_Parser *parser,
-                                void *junk){
-        pyxml_UpdatePairedHandlers(
-                (xmlparseobject *)XML_GetUserData( parser ), 
-                StartElement, EndElement,
-                (pairsetter)XML_SetElementHandler);
+				void *junk){
+	pyxml_UpdatePairedHandlers(
+		(xmlparseobject *)XML_GetUserData( parser ), 
+		StartElement, EndElement,
+		(pairsetter)XML_SetElementHandler);
 }
 
 void pyxml_SetStartNamespaceDeclHandler( XML_Parser *parser,
-                                void *junk){
-        pyxml_UpdatePairedHandlers(
-                (xmlparseobject *)XML_GetUserData( parser ), 
-                StartNamespaceDecl, EndNamespaceDecl,
-                (pairsetter)XML_SetNamespaceDeclHandler);
+				void *junk){
+	pyxml_UpdatePairedHandlers(
+		(xmlparseobject *)XML_GetUserData( parser ), 
+		StartNamespaceDecl, EndNamespaceDecl,
+		(pairsetter)XML_SetNamespaceDeclHandler);
 }
 
 void pyxml_SetEndNamespaceDeclHandler( XML_Parser *parser,
-                                void *junk){
-        pyxml_UpdatePairedHandlers(
-                (xmlparseobject *)XML_GetUserData( parser ), 
-                StartNamespaceDecl, EndNamespaceDecl, 
-                (pairsetter)XML_SetNamespaceDeclHandler);
+				void *junk){
+	pyxml_UpdatePairedHandlers(
+		(xmlparseobject *)XML_GetUserData( parser ), 
+		StartNamespaceDecl, EndNamespaceDecl, 
+		(pairsetter)XML_SetNamespaceDeclHandler);
 }
 
 void pyxml_SetStartCdataSection( XML_Parser *parser,
-                                void *junk){
+				void *junk){
 
-        pyxml_UpdatePairedHandlers(
-                (xmlparseobject *)XML_GetUserData( parser ), 
-                StartCdataSection, EndCdataSection, 
-                (pairsetter)XML_SetCdataSectionHandler);
+	pyxml_UpdatePairedHandlers(
+		(xmlparseobject *)XML_GetUserData( parser ), 
+		StartCdataSection, EndCdataSection, 
+		(pairsetter)XML_SetCdataSectionHandler);
 }
 
 void pyxml_SetEndCdataSection( XML_Parser *parser,
-                                void *junk){
-        pyxml_UpdatePairedHandlers(
-                (xmlparseobject *)XML_GetUserData( parser ), 
-                StartCdataSection, EndCdataSection, 
-                (pairsetter)XML_SetCdataSectionHandler);
+				void *junk){
+	pyxml_UpdatePairedHandlers(
+		(xmlparseobject *)XML_GetUserData( parser ), 
+		StartCdataSection, EndCdataSection, 
+		(pairsetter)XML_SetCdataSectionHandler);
 }
 
-static struct HandlerInfo handler_info[]=
+statichere struct HandlerInfo handler_info[]=
 {{"StartElementHandler", 
-        pyxml_SetStartElementHandler, 
-        my_StartElementHandler},
+	pyxml_SetStartElementHandler, 
+	my_StartElementHandler},
 {"EndElementHandler", 
-        pyxml_SetEndElementHandler, 
-        my_EndElementHandler},
+	pyxml_SetEndElementHandler, 
+	my_EndElementHandler},
 {"ProcessingInstructionHandler", 
-        (xmlhandlersetter)XML_SetProcessingInstructionHandler,
-        my_ProcessingInstructionHandler},
+	(xmlhandlersetter)XML_SetProcessingInstructionHandler,
+	my_ProcessingInstructionHandler},
 {"CharacterDataHandler", 
-        (xmlhandlersetter)XML_SetCharacterDataHandler,
-        my_CharacterDataHandler},
+	(xmlhandlersetter)XML_SetCharacterDataHandler,
+	my_CharacterDataHandler},
 {"UnparsedEntityDeclHandler", 
-        (xmlhandlersetter)XML_SetUnparsedEntityDeclHandler,
-        my_UnparsedEntityDeclHandler },
+	(xmlhandlersetter)XML_SetUnparsedEntityDeclHandler,
+	my_UnparsedEntityDeclHandler },
 {"NotationDeclHandler", 
-        (xmlhandlersetter)XML_SetNotationDeclHandler,
-        my_NotationDeclHandler },
+	(xmlhandlersetter)XML_SetNotationDeclHandler,
+	my_NotationDeclHandler },
 {"StartNamespaceDeclHandler", 
-        pyxml_SetStartNamespaceDeclHandler,
-        my_StartNamespaceDeclHandler },
+	pyxml_SetStartNamespaceDeclHandler,
+	my_StartNamespaceDeclHandler },
 {"EndNamespaceDeclHandler", 
-        pyxml_SetEndNamespaceDeclHandler,
-        my_EndNamespaceDeclHandler },
+	pyxml_SetEndNamespaceDeclHandler,
+	my_EndNamespaceDeclHandler },
 {"CommentHandler",
-        (xmlhandlersetter)XML_SetCommentHandler,
-        my_CommentHandler},
+	(xmlhandlersetter)XML_SetCommentHandler,
+	my_CommentHandler},
 {"StartCdataSectionHandler",
-        pyxml_SetStartCdataSection,
-        my_StartCdataSectionHandler},
+	pyxml_SetStartCdataSection,
+	my_StartCdataSectionHandler},
 {"EndCdataSectionHandler",
-        pyxml_SetEndCdataSection,
-        my_EndCdataSectionHandler},
+	pyxml_SetEndCdataSection,
+	my_EndCdataSectionHandler},
 {"DefaultHandler",
-        (xmlhandlersetter)XML_SetDefaultHandler,
-        my_DefaultHandler},
+	(xmlhandlersetter)XML_SetDefaultHandler,
+	my_DefaultHandler},
 {"DefaultHandlerExpand",
-        (xmlhandlersetter)XML_SetDefaultHandlerExpand,
-        my_DefaultHandlerExpandHandler},
+	(xmlhandlersetter)XML_SetDefaultHandlerExpand,
+	my_DefaultHandlerExpandHandler},
 {"NotStandaloneHandler",
-        (xmlhandlersetter)XML_SetNotStandaloneHandler,
-        my_NotStandaloneHandler},
+	(xmlhandlersetter)XML_SetNotStandaloneHandler,
+	my_NotStandaloneHandler},
 {"ExternalEntityRefHandler",
-        (xmlhandlersetter)XML_SetExternalEntityRefHandler,
-        my_ExternalEntityRefHandler },
+	(xmlhandlersetter)XML_SetExternalEntityRefHandler,
+	my_ExternalEntityRefHandler },
 
 {NULL, NULL, NULL } /* sentinel */
 };
 
-