include: Stop using *Ptr typedefs in public headers

2026-01-26 21:41:34 +03:00 · 2025-05-14 04:04:28 +02:00
parent 0da20b834f
commit a40f36e7f2
85 changed files with 3421 additions and 3461 deletions
--- a/include/libxml/HTMLparser.h
+++ b/include/libxml/HTMLparser.h
@@ -115,55 +115,55 @@ XMLPUBFUN const htmlEntityDesc *

 XML_DEPRECATED
 XMLPUBFUN int
-			htmlIsAutoClosed(htmlDocPtr doc,
-					 htmlNodePtr elem);
+			htmlIsAutoClosed(xmlDoc *doc,
+					 xmlNode *elem);
 XML_DEPRECATED
 XMLPUBFUN int
-			htmlAutoCloseTag(htmlDocPtr doc,
+			htmlAutoCloseTag(xmlDoc *doc,
 					 const xmlChar *name,
-					 htmlNodePtr elem);
+					 xmlNode *elem);
 XML_DEPRECATED
 XMLPUBFUN const htmlEntityDesc *
-			htmlParseEntityRef(htmlParserCtxtPtr ctxt,
+			htmlParseEntityRef(htmlParserCtxt *ctxt,
 					 const xmlChar **str);
 XML_DEPRECATED
 XMLPUBFUN int
-			htmlParseCharRef(htmlParserCtxtPtr ctxt);
+			htmlParseCharRef(htmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN void
-			htmlParseElement(htmlParserCtxtPtr ctxt);
+			htmlParseElement(htmlParserCtxt *ctxt);

-XMLPUBFUN htmlParserCtxtPtr
+XMLPUBFUN htmlParserCtxt *
 			htmlNewParserCtxt(void);
-XMLPUBFUN htmlParserCtxtPtr
+XMLPUBFUN htmlParserCtxt *
 			htmlNewSAXParserCtxt(const htmlSAXHandler *sax,
 					     void *userData);

-XMLPUBFUN htmlParserCtxtPtr
+XMLPUBFUN htmlParserCtxt *
 			htmlCreateMemoryParserCtxt(const char *buffer,
 						   int size);

 XMLPUBFUN int
-			htmlParseDocument(htmlParserCtxtPtr ctxt);
+			htmlParseDocument(htmlParserCtxt *ctxt);
 XML_DEPRECATED
-XMLPUBFUN htmlDocPtr
+XMLPUBFUN xmlDoc *
 			htmlSAXParseDoc	(const xmlChar *cur,
 					 const char *encoding,
-					 htmlSAXHandlerPtr sax,
+					 htmlSAXHandler *sax,
 					 void *userData);
-XMLPUBFUN htmlDocPtr
+XMLPUBFUN xmlDoc *
 			htmlParseDoc	(const xmlChar *cur,
 					 const char *encoding);
-XMLPUBFUN htmlParserCtxtPtr
+XMLPUBFUN htmlParserCtxt *
 			htmlCreateFileParserCtxt(const char *filename,
 	                                         const char *encoding);
 XML_DEPRECATED
-XMLPUBFUN htmlDocPtr
+XMLPUBFUN xmlDoc *
 			htmlSAXParseFile(const char *filename,
 					 const char *encoding,
-					 htmlSAXHandlerPtr sax,
+					 htmlSAXHandler *sax,
 					 void *userData);
-XMLPUBFUN htmlDocPtr
+XMLPUBFUN xmlDoc *
 			htmlParseFile	(const char *filename,
 					 const char *encoding);
 XML_DEPRECATED
@@ -189,22 +189,22 @@ XMLPUBFUN int
 /*
 * Interfaces for the Push mode.
 */
-XMLPUBFUN htmlParserCtxtPtr
-			htmlCreatePushParserCtxt(htmlSAXHandlerPtr sax,
+XMLPUBFUN htmlParserCtxt *
+			htmlCreatePushParserCtxt(htmlSAXHandler *sax,
 						 void *user_data,
 						 const char *chunk,
 						 int size,
 						 const char *filename,
 						 xmlCharEncoding enc);
 XMLPUBFUN int
-			htmlParseChunk		(htmlParserCtxtPtr ctxt,
+			htmlParseChunk		(htmlParserCtxt *ctxt,
 						 const char *chunk,
 						 int size,
 						 int terminate);
 #endif /* LIBXML_PUSH_ENABLED */

 XMLPUBFUN void
-			htmlFreeParserCtxt	(htmlParserCtxtPtr ctxt);
+			htmlFreeParserCtxt	(htmlParserCtxt *ctxt);

 /*
 * New set of simpler/more flexible APIs
@@ -292,69 +292,69 @@ typedef enum {
 } htmlParserOption;

 XMLPUBFUN void
-		htmlCtxtReset		(htmlParserCtxtPtr ctxt);
+		htmlCtxtReset		(htmlParserCtxt *ctxt);
 XMLPUBFUN int
-		htmlCtxtSetOptions	(htmlParserCtxtPtr ctxt,
+		htmlCtxtSetOptions	(htmlParserCtxt *ctxt,
 					 int options);
 XMLPUBFUN int
-		htmlCtxtUseOptions	(htmlParserCtxtPtr ctxt,
+		htmlCtxtUseOptions	(htmlParserCtxt *ctxt,
 					 int options);
-XMLPUBFUN htmlDocPtr
+XMLPUBFUN xmlDoc *
 		htmlReadDoc		(const xmlChar *cur,
 					 const char *URL,
 					 const char *encoding,
 					 int options);
-XMLPUBFUN htmlDocPtr
+XMLPUBFUN xmlDoc *
 		htmlReadFile		(const char *URL,
 					 const char *encoding,
 					 int options);
-XMLPUBFUN htmlDocPtr
+XMLPUBFUN xmlDoc *
 		htmlReadMemory		(const char *buffer,
 					 int size,
 					 const char *URL,
 					 const char *encoding,
 					 int options);
-XMLPUBFUN htmlDocPtr
+XMLPUBFUN xmlDoc *
 		htmlReadFd		(int fd,
 					 const char *URL,
 					 const char *encoding,
 					 int options);
-XMLPUBFUN htmlDocPtr
+XMLPUBFUN xmlDoc *
 		htmlReadIO		(xmlInputReadCallback ioread,
 					 xmlInputCloseCallback ioclose,
 					 void *ioctx,
 					 const char *URL,
 					 const char *encoding,
 					 int options);
-XMLPUBFUN htmlDocPtr
-		htmlCtxtParseDocument	(htmlParserCtxtPtr ctxt,
-					 xmlParserInputPtr input);
-XMLPUBFUN htmlDocPtr
-		htmlCtxtReadDoc		(xmlParserCtxtPtr ctxt,
+XMLPUBFUN xmlDoc *
+		htmlCtxtParseDocument	(htmlParserCtxt *ctxt,
+					 xmlParserInput *input);
+XMLPUBFUN xmlDoc *
+		htmlCtxtReadDoc		(xmlParserCtxt *ctxt,
 					 const xmlChar *cur,
 					 const char *URL,
 					 const char *encoding,
 					 int options);
-XMLPUBFUN htmlDocPtr
-		htmlCtxtReadFile		(xmlParserCtxtPtr ctxt,
+XMLPUBFUN xmlDoc *
+		htmlCtxtReadFile		(xmlParserCtxt *ctxt,
 					 const char *filename,
 					 const char *encoding,
 					 int options);
-XMLPUBFUN htmlDocPtr
-		htmlCtxtReadMemory		(xmlParserCtxtPtr ctxt,
+XMLPUBFUN xmlDoc *
+		htmlCtxtReadMemory		(xmlParserCtxt *ctxt,
 					 const char *buffer,
 					 int size,
 					 const char *URL,
 					 const char *encoding,
 					 int options);
-XMLPUBFUN htmlDocPtr
-		htmlCtxtReadFd		(xmlParserCtxtPtr ctxt,
+XMLPUBFUN xmlDoc *
+		htmlCtxtReadFd		(xmlParserCtxt *ctxt,
 					 int fd,
 					 const char *URL,
 					 const char *encoding,
 					 int options);
-XMLPUBFUN htmlDocPtr
-		htmlCtxtReadIO		(xmlParserCtxtPtr ctxt,
+XMLPUBFUN xmlDoc *
+		htmlCtxtReadIO		(xmlParserCtxt *ctxt,
 					 xmlInputReadCallback ioread,
 					 xmlInputCloseCallback ioclose,
 					 void *ioctx,
@@ -383,7 +383,7 @@ XMLPUBFUN int htmlElementAllowedHere(const htmlElemDesc*, const xmlChar*) ;
 XML_DEPRECATED
 XMLPUBFUN htmlStatus htmlElementStatusHere(const htmlElemDesc*, const htmlElemDesc*) ;
 XML_DEPRECATED
-XMLPUBFUN htmlStatus htmlNodeStatus(htmlNodePtr, int) ;
+XMLPUBFUN htmlStatus htmlNodeStatus(xmlNode *, int) ;

 #ifdef __cplusplus
 }
--- a/include/libxml/HTMLtree.h
+++ b/include/libxml/HTMLtree.h
@@ -34,75 +34,75 @@ extern "C" {
 #define HTML_PI_NODE		XML_PI_NODE
 /** @endcond */

-XMLPUBFUN htmlDocPtr
+XMLPUBFUN xmlDoc *
 		htmlNewDoc		(const xmlChar *URI,
 					 const xmlChar *ExternalID);
-XMLPUBFUN htmlDocPtr
+XMLPUBFUN xmlDoc *
 		htmlNewDocNoDtD		(const xmlChar *URI,
 					 const xmlChar *ExternalID);
 XMLPUBFUN const xmlChar *
-		htmlGetMetaEncoding	(htmlDocPtr doc);
+		htmlGetMetaEncoding	(xmlDoc *doc);
 XMLPUBFUN int
-		htmlSetMetaEncoding	(htmlDocPtr doc,
+		htmlSetMetaEncoding	(xmlDoc *doc,
 					 const xmlChar *encoding);
 #ifdef LIBXML_OUTPUT_ENABLED
 XMLPUBFUN void
-		htmlDocDumpMemory	(xmlDocPtr cur,
+		htmlDocDumpMemory	(xmlDoc *cur,
 					 xmlChar **mem,
 					 int *size);
 XMLPUBFUN void
-		htmlDocDumpMemoryFormat	(xmlDocPtr cur,
+		htmlDocDumpMemoryFormat	(xmlDoc *cur,
 					 xmlChar **mem,
 					 int *size,
 					 int format);
 XMLPUBFUN int
 		htmlSaveFile		(const char *filename,
-					 xmlDocPtr cur);
+					 xmlDoc *cur);
 XMLPUBFUN int
 		htmlSaveFileEnc		(const char *filename,
-					 xmlDocPtr cur,
+					 xmlDoc *cur,
 					 const char *encoding);
 XMLPUBFUN int
 		htmlSaveFileFormat	(const char *filename,
-					 xmlDocPtr cur,
+					 xmlDoc *cur,
 					 const char *encoding,
 					 int format);
 XMLPUBFUN int
-		htmlNodeDump		(xmlBufferPtr buf,
-					 xmlDocPtr doc,
-					 xmlNodePtr cur);
+		htmlNodeDump		(xmlBuffer *buf,
+					 xmlDoc *doc,
+					 xmlNode *cur);
 XMLPUBFUN int
 		htmlDocDump		(FILE *f,
-					 xmlDocPtr cur);
+					 xmlDoc *cur);
 XMLPUBFUN void
 		htmlNodeDumpFile	(FILE *out,
-					 xmlDocPtr doc,
-					 xmlNodePtr cur);
+					 xmlDoc *doc,
+					 xmlNode *cur);
 XMLPUBFUN int
 		htmlNodeDumpFileFormat	(FILE *out,
-					 xmlDocPtr doc,
-					 xmlNodePtr cur,
+					 xmlDoc *doc,
+					 xmlNode *cur,
 					 const char *encoding,
 					 int format);

 XMLPUBFUN void
-		htmlNodeDumpOutput	(xmlOutputBufferPtr buf,
-					 xmlDocPtr doc,
-					 xmlNodePtr cur,
+		htmlNodeDumpOutput	(xmlOutputBuffer *buf,
+					 xmlDoc *doc,
+					 xmlNode *cur,
 					 const char *encoding);
 XMLPUBFUN void
-		htmlNodeDumpFormatOutput(xmlOutputBufferPtr buf,
-					 xmlDocPtr doc,
-					 xmlNodePtr cur,
+		htmlNodeDumpFormatOutput(xmlOutputBuffer *buf,
+					 xmlDoc *doc,
+					 xmlNode *cur,
 					 const char *encoding,
 					 int format);
 XMLPUBFUN void
-		htmlDocContentDumpOutput(xmlOutputBufferPtr buf,
-					 xmlDocPtr cur,
+		htmlDocContentDumpOutput(xmlOutputBuffer *buf,
+					 xmlDoc *cur,
 					 const char *encoding);
 XMLPUBFUN void
-		htmlDocContentDumpFormatOutput(xmlOutputBufferPtr buf,
-					 xmlDocPtr cur,
+		htmlDocContentDumpFormatOutput(xmlOutputBuffer *buf,
+					 xmlDoc *cur,
 					 const char *encoding,
 					 int format);

--- a/include/libxml/SAX2.h
+++ b/include/libxml/SAX2.h
@@ -27,7 +27,7 @@ XMLPUBFUN const xmlChar *
 		xmlSAX2GetSystemId		(void *ctx);
 XMLPUBFUN void
 		xmlSAX2SetDocumentLocator	(void *ctx,
-						 xmlSAXLocatorPtr loc);
+						 xmlSAXLocator *loc);

 XMLPUBFUN int
 		xmlSAX2GetLineNumber		(void *ctx);
@@ -51,13 +51,13 @@ XMLPUBFUN void
 						 const xmlChar *name,
 						 const xmlChar *ExternalID,
 						 const xmlChar *SystemID);
-XMLPUBFUN xmlEntityPtr
+XMLPUBFUN xmlEntity *
 		xmlSAX2GetEntity		(void *ctx,
 						 const xmlChar *name);
-XMLPUBFUN xmlEntityPtr
+XMLPUBFUN xmlEntity *
 		xmlSAX2GetParameterEntity	(void *ctx,
 						 const xmlChar *name);
-XMLPUBFUN xmlParserInputPtr
+XMLPUBFUN xmlParserInput *
 		xmlSAX2ResolveEntity		(void *ctx,
 						 const xmlChar *publicId,
 						 const xmlChar *systemId);
@@ -76,12 +76,12 @@ XMLPUBFUN void
 						 int type,
 						 int def,
 						 const xmlChar *defaultValue,
-						 xmlEnumerationPtr tree);
+						 xmlEnumeration *tree);
 XMLPUBFUN void
 		xmlSAX2ElementDecl		(void *ctx,
 						 const xmlChar *name,
 						 int type,
-						 xmlElementContentPtr content);
+						 xmlElementContent *content);
 XMLPUBFUN void
 		xmlSAX2NotationDecl		(void *ctx,
 						 const xmlChar *name,
--- a/include/libxml/c14n.h
+++ b/include/libxml/c14n.h
@@ -58,24 +58,24 @@ typedef enum {
 } xmlC14NMode;

 XMLPUBFUN int
-		xmlC14NDocSaveTo	(xmlDocPtr doc,
-					 xmlNodeSetPtr nodes,
+		xmlC14NDocSaveTo	(xmlDoc *doc,
+					 xmlNodeSet *nodes,
 					 int mode, /* a xmlC14NMode */
 					 xmlChar **inclusive_ns_prefixes,
 					 int with_comments,
-					 xmlOutputBufferPtr buf);
+					 xmlOutputBuffer *buf);

 XMLPUBFUN int
-		xmlC14NDocDumpMemory	(xmlDocPtr doc,
-					 xmlNodeSetPtr nodes,
+		xmlC14NDocDumpMemory	(xmlDoc *doc,
+					 xmlNodeSet *nodes,
 					 int mode, /* a xmlC14NMode */
 					 xmlChar **inclusive_ns_prefixes,
 					 int with_comments,
 					 xmlChar **doc_txt_ptr);

 XMLPUBFUN int
-		xmlC14NDocSave		(xmlDocPtr doc,
-					 xmlNodeSetPtr nodes,
+		xmlC14NDocSave		(xmlDoc *doc,
+					 xmlNodeSet *nodes,
 					 int mode, /* a xmlC14NMode */
 					 xmlChar **inclusive_ns_prefixes,
 					 int with_comments,
@@ -95,17 +95,17 @@ XMLPUBFUN int
 * @returns 1 if the node should be included
 */
 typedef int (*xmlC14NIsVisibleCallback)	(void* user_data,
-					 xmlNodePtr node,
-					 xmlNodePtr parent);
+					 xmlNode *node,
+					 xmlNode *parent);

 XMLPUBFUN int
-		xmlC14NExecute		(xmlDocPtr doc,
+		xmlC14NExecute		(xmlDoc *doc,
 					 xmlC14NIsVisibleCallback is_visible_callback,
 					 void* user_data,
 					 int mode, /* a xmlC14NMode */
 					 xmlChar **inclusive_ns_prefixes,
 					 int with_comments,
-					 xmlOutputBufferPtr buf);
+					 xmlOutputBuffer *buf);

 #ifdef __cplusplus
 }
--- a/include/libxml/catalog.h
+++ b/include/libxml/catalog.h
@@ -69,44 +69,44 @@ typedef xmlCatalog *xmlCatalogPtr;
 /*
 * Operations on a given catalog.
 */
-XMLPUBFUN xmlCatalogPtr
+XMLPUBFUN xmlCatalog *
 		xmlNewCatalog		(int sgml);
-XMLPUBFUN xmlCatalogPtr
+XMLPUBFUN xmlCatalog *
 		xmlLoadACatalog		(const char *filename);
-XMLPUBFUN xmlCatalogPtr
+XMLPUBFUN xmlCatalog *
 		xmlLoadSGMLSuperCatalog	(const char *filename);
 XMLPUBFUN int
-		xmlConvertSGMLCatalog	(xmlCatalogPtr catal);
+		xmlConvertSGMLCatalog	(xmlCatalog *catal);
 XMLPUBFUN int
-		xmlACatalogAdd		(xmlCatalogPtr catal,
+		xmlACatalogAdd		(xmlCatalog *catal,
 					 const xmlChar *type,
 					 const xmlChar *orig,
 					 const xmlChar *replace);
 XMLPUBFUN int
-		xmlACatalogRemove	(xmlCatalogPtr catal,
+		xmlACatalogRemove	(xmlCatalog *catal,
 					 const xmlChar *value);
 XMLPUBFUN xmlChar *
-		xmlACatalogResolve	(xmlCatalogPtr catal,
+		xmlACatalogResolve	(xmlCatalog *catal,
 					 const xmlChar *pubID,
 	                                 const xmlChar *sysID);
 XMLPUBFUN xmlChar *
-		xmlACatalogResolveSystem(xmlCatalogPtr catal,
+		xmlACatalogResolveSystem(xmlCatalog *catal,
 					 const xmlChar *sysID);
 XMLPUBFUN xmlChar *
-		xmlACatalogResolvePublic(xmlCatalogPtr catal,
+		xmlACatalogResolvePublic(xmlCatalog *catal,
 					 const xmlChar *pubID);
 XMLPUBFUN xmlChar *
-		xmlACatalogResolveURI	(xmlCatalogPtr catal,
+		xmlACatalogResolveURI	(xmlCatalog *catal,
 					 const xmlChar *URI);
 #ifdef LIBXML_OUTPUT_ENABLED
 XMLPUBFUN void
-		xmlACatalogDump		(xmlCatalogPtr catal,
+		xmlACatalogDump		(xmlCatalog *catal,
 					 FILE *out);
 #endif /* LIBXML_OUTPUT_ENABLED */
 XMLPUBFUN void
-		xmlFreeCatalog		(xmlCatalogPtr catal);
+		xmlFreeCatalog		(xmlCatalog *catal);
 XMLPUBFUN int
-		xmlCatalogIsEmpty	(xmlCatalogPtr catal);
+		xmlCatalogIsEmpty	(xmlCatalog *catal);

 /*
 * Global operations.
@@ -139,7 +139,7 @@ XMLPUBFUN int
 XMLPUBFUN int
 		xmlCatalogRemove	(const xmlChar *value);
 XML_DEPRECATED
-XMLPUBFUN xmlDocPtr
+XMLPUBFUN xmlDoc *
 		xmlParseCatalogFile	(const char *filename);
 XMLPUBFUN int
 		xmlCatalogConvert	(void);
--- a/include/libxml/debugXML.h
+++ b/include/libxml/debugXML.h
@@ -33,36 +33,36 @@ XMLPUBFUN void
 				 const xmlChar *str);
 XMLPUBFUN void
 	xmlDebugDumpAttr	(FILE *output,
-				 xmlAttrPtr attr,
+				 xmlAttr *attr,
 				 int depth);
 XMLPUBFUN void
 	xmlDebugDumpAttrList	(FILE *output,
-				 xmlAttrPtr attr,
+				 xmlAttr *attr,
 				 int depth);
 XMLPUBFUN void
 	xmlDebugDumpOneNode	(FILE *output,
-				 xmlNodePtr node,
+				 xmlNode *node,
 				 int depth);
 XMLPUBFUN void
 	xmlDebugDumpNode	(FILE *output,
-				 xmlNodePtr node,
+				 xmlNode *node,
 				 int depth);
 XMLPUBFUN void
 	xmlDebugDumpNodeList	(FILE *output,
-				 xmlNodePtr node,
+				 xmlNode *node,
 				 int depth);
 XMLPUBFUN void
 	xmlDebugDumpDocumentHead(FILE *output,
-				 xmlDocPtr doc);
+				 xmlDoc *doc);
 XMLPUBFUN void
 	xmlDebugDumpDocument	(FILE *output,
-				 xmlDocPtr doc);
+				 xmlDoc *doc);
 XMLPUBFUN void
 	xmlDebugDumpDTD		(FILE *output,
-				 xmlDtdPtr dtd);
+				 xmlDtd *dtd);
 XMLPUBFUN void
 	xmlDebugDumpEntities	(FILE *output,
-				 xmlDocPtr doc);
+				 xmlDoc *doc);

 /****************************************************************
 *								*
@@ -72,7 +72,7 @@ XMLPUBFUN void

 XMLPUBFUN int
 	xmlDebugCheckDocument	(FILE * output,
-				 xmlDocPtr doc);
+				 xmlDoc *doc);

 #ifdef __cplusplus
 }
--- a/include/libxml/dict.h
+++ b/include/libxml/dict.h
@@ -37,40 +37,40 @@ XMLPUBFUN int  xmlInitializeDict(void);
 /*
 * Constructor and destructor.
 */
-XMLPUBFUN xmlDictPtr
+XMLPUBFUN xmlDict *
 			xmlDictCreate	(void);
 XMLPUBFUN size_t
-			xmlDictSetLimit	(xmlDictPtr dict,
+			xmlDictSetLimit	(xmlDict *dict,
                                         size_t limit);
 XMLPUBFUN size_t
-			xmlDictGetUsage (xmlDictPtr dict);
-XMLPUBFUN xmlDictPtr
-			xmlDictCreateSub(xmlDictPtr sub);
+			xmlDictGetUsage (xmlDict *dict);
+XMLPUBFUN xmlDict *
+			xmlDictCreateSub(xmlDict *sub);
 XMLPUBFUN int
-			xmlDictReference(xmlDictPtr dict);
+			xmlDictReference(xmlDict *dict);
 XMLPUBFUN void
-			xmlDictFree	(xmlDictPtr dict);
+			xmlDictFree	(xmlDict *dict);

 /*
 * Lookup of entry in the dictionary.
 */
 XMLPUBFUN const xmlChar *
-			xmlDictLookup	(xmlDictPtr dict,
+			xmlDictLookup	(xmlDict *dict,
 		                         const xmlChar *name,
 		                         int len);
 XMLPUBFUN const xmlChar *
-			xmlDictExists	(xmlDictPtr dict,
+			xmlDictExists	(xmlDict *dict,
 		                         const xmlChar *name,
 		                         int len);
 XMLPUBFUN const xmlChar *
-			xmlDictQLookup	(xmlDictPtr dict,
+			xmlDictQLookup	(xmlDict *dict,
 		                         const xmlChar *prefix,
 		                         const xmlChar *name);
 XMLPUBFUN int
-			xmlDictOwns	(xmlDictPtr dict,
+			xmlDictOwns	(xmlDict *dict,
 					 const xmlChar *str);
 XMLPUBFUN int
-			xmlDictSize	(xmlDictPtr dict);
+			xmlDictSize	(xmlDict *dict);

 /*
 * Cleanup function
--- a/include/libxml/encoding.h
+++ b/include/libxml/encoding.h
@@ -239,26 +239,26 @@ XMLPUBFUN void
 	xmlCleanupCharEncodingHandlers	(void);
 XML_DEPRECATED
 XMLPUBFUN void
-	xmlRegisterCharEncodingHandler	(xmlCharEncodingHandlerPtr handler);
+	xmlRegisterCharEncodingHandler	(xmlCharEncodingHandler *handler);
 XMLPUBFUN xmlParserErrors
 	xmlLookupCharEncodingHandler	(xmlCharEncoding enc,
-					 xmlCharEncodingHandlerPtr *out);
+					 xmlCharEncodingHandler **out);
 XMLPUBFUN xmlParserErrors
 	xmlOpenCharEncodingHandler	(const char *name,
 					 int output,
-					 xmlCharEncodingHandlerPtr *out);
+					 xmlCharEncodingHandler **out);
 XMLPUBFUN xmlParserErrors
 	xmlCreateCharEncodingHandler	(const char *name,
 					 xmlCharEncFlags flags,
 					 xmlCharEncConvImpl impl,
 					 void *implCtxt,
-					 xmlCharEncodingHandlerPtr *out);
-XMLPUBFUN xmlCharEncodingHandlerPtr
+					 xmlCharEncodingHandler **out);
+XMLPUBFUN xmlCharEncodingHandler *
 	xmlGetCharEncodingHandler	(xmlCharEncoding enc);
-XMLPUBFUN xmlCharEncodingHandlerPtr
+XMLPUBFUN xmlCharEncodingHandler *
 	xmlFindCharEncodingHandler	(const char *name);
 XML_DEPRECATED
-XMLPUBFUN xmlCharEncodingHandlerPtr
+XMLPUBFUN xmlCharEncodingHandler *
 	xmlNewCharEncodingHandler	(const char *name,
 					 xmlCharEncodingInputFunc input,
 					 xmlCharEncodingOutputFunc output);
--- a/include/libxml/entities.h
+++ b/include/libxml/entities.h
@@ -91,68 +91,68 @@ struct _xmlEntity {
 typedef struct _xmlHashTable xmlEntitiesTable;
 typedef xmlEntitiesTable *xmlEntitiesTablePtr;

-XMLPUBFUN xmlEntityPtr
-			xmlNewEntity		(xmlDocPtr doc,
+XMLPUBFUN xmlEntity *
+			xmlNewEntity		(xmlDoc *doc,
 						 const xmlChar *name,
 						 int type,
 						 const xmlChar *ExternalID,
 						 const xmlChar *SystemID,
 						 const xmlChar *content);
 XMLPUBFUN void
-			xmlFreeEntity		(xmlEntityPtr entity);
+			xmlFreeEntity		(xmlEntity *entity);
 XMLPUBFUN int
-			xmlAddEntity		(xmlDocPtr doc,
+			xmlAddEntity		(xmlDoc *doc,
 						 int extSubset,
 						 const xmlChar *name,
 						 int type,
 						 const xmlChar *ExternalID,
 						 const xmlChar *SystemID,
 						 const xmlChar *content,
-						 xmlEntityPtr *out);
-XMLPUBFUN xmlEntityPtr
-			xmlAddDocEntity		(xmlDocPtr doc,
+						 xmlEntity **out);
+XMLPUBFUN xmlEntity *
+			xmlAddDocEntity		(xmlDoc *doc,
 						 const xmlChar *name,
 						 int type,
 						 const xmlChar *ExternalID,
 						 const xmlChar *SystemID,
 						 const xmlChar *content);
-XMLPUBFUN xmlEntityPtr
-			xmlAddDtdEntity		(xmlDocPtr doc,
+XMLPUBFUN xmlEntity *
+			xmlAddDtdEntity		(xmlDoc *doc,
 						 const xmlChar *name,
 						 int type,
 						 const xmlChar *ExternalID,
 						 const xmlChar *SystemID,
 						 const xmlChar *content);
-XMLPUBFUN xmlEntityPtr
+XMLPUBFUN xmlEntity *
 			xmlGetPredefinedEntity	(const xmlChar *name);
-XMLPUBFUN xmlEntityPtr
+XMLPUBFUN xmlEntity *
 			xmlGetDocEntity		(const xmlDoc *doc,
 						 const xmlChar *name);
-XMLPUBFUN xmlEntityPtr
-			xmlGetDtdEntity		(xmlDocPtr doc,
+XMLPUBFUN xmlEntity *
+			xmlGetDtdEntity		(xmlDoc *doc,
 						 const xmlChar *name);
-XMLPUBFUN xmlEntityPtr
-			xmlGetParameterEntity	(xmlDocPtr doc,
+XMLPUBFUN xmlEntity *
+			xmlGetParameterEntity	(xmlDoc *doc,
 						 const xmlChar *name);
 XMLPUBFUN xmlChar *
-			xmlEncodeEntitiesReentrant(xmlDocPtr doc,
+			xmlEncodeEntitiesReentrant(xmlDoc *doc,
 						 const xmlChar *input);
 XMLPUBFUN xmlChar *
 			xmlEncodeSpecialChars	(const xmlDoc *doc,
 						 const xmlChar *input);
-XMLPUBFUN xmlEntitiesTablePtr
+XMLPUBFUN xmlEntitiesTable *
 			xmlCreateEntitiesTable	(void);
-XMLPUBFUN xmlEntitiesTablePtr
-			xmlCopyEntitiesTable	(xmlEntitiesTablePtr table);
+XMLPUBFUN xmlEntitiesTable *
+			xmlCopyEntitiesTable	(xmlEntitiesTable *table);
 XMLPUBFUN void
-			xmlFreeEntitiesTable	(xmlEntitiesTablePtr table);
+			xmlFreeEntitiesTable	(xmlEntitiesTable *table);
 #ifdef LIBXML_OUTPUT_ENABLED
 XMLPUBFUN void
-			xmlDumpEntitiesTable	(xmlBufferPtr buf,
-						 xmlEntitiesTablePtr table);
+			xmlDumpEntitiesTable	(xmlBuffer *buf,
+						 xmlEntitiesTable *table);
 XMLPUBFUN void
-			xmlDumpEntityDecl	(xmlBufferPtr buf,
-						 xmlEntityPtr ent);
+			xmlDumpEntityDecl	(xmlBuffer *buf,
+						 xmlEntity *ent);
 #endif /* LIBXML_OUTPUT_ENABLED */

 #ifdef __cplusplus
--- a/include/libxml/hash.h
+++ b/include/libxml/hash.h
@@ -89,13 +89,13 @@ typedef void (*xmlHashScannerFull)(void *payload, void *data,
 /*
 * Constructor and destructor.
 */
-XMLPUBFUN xmlHashTablePtr
+XMLPUBFUN xmlHashTable *
 		xmlHashCreate		(int size);
-XMLPUBFUN xmlHashTablePtr
+XMLPUBFUN xmlHashTable *
 		xmlHashCreateDict	(int size,
-					 xmlDictPtr dict);
+					 xmlDict *dict);
 XMLPUBFUN void
-		xmlHashFree		(xmlHashTablePtr hash,
+		xmlHashFree		(xmlHashTable *hash,
 					 xmlHashDeallocator dealloc);
 XMLPUBFUN void
 		xmlHashDefaultDeallocator(void *entry,
@@ -105,48 +105,48 @@ XMLPUBFUN void
 * Add a new entry to the hash table.
 */
 XMLPUBFUN int
-		xmlHashAdd		(xmlHashTablePtr hash,
+		xmlHashAdd		(xmlHashTable *hash,
 		                         const xmlChar *name,
 		                         void *userdata);
 XMLPUBFUN int
-		xmlHashAddEntry		(xmlHashTablePtr hash,
+		xmlHashAddEntry		(xmlHashTable *hash,
 		                         const xmlChar *name,
 		                         void *userdata);
 XMLPUBFUN int
-		xmlHashUpdateEntry	(xmlHashTablePtr hash,
+		xmlHashUpdateEntry	(xmlHashTable *hash,
 		                         const xmlChar *name,
 		                         void *userdata,
 					 xmlHashDeallocator dealloc);
 XMLPUBFUN int
-		xmlHashAdd2		(xmlHashTablePtr hash,
+		xmlHashAdd2		(xmlHashTable *hash,
 		                         const xmlChar *name,
 		                         const xmlChar *name2,
 		                         void *userdata);
 XMLPUBFUN int
-		xmlHashAddEntry2	(xmlHashTablePtr hash,
+		xmlHashAddEntry2	(xmlHashTable *hash,
 		                         const xmlChar *name,
 		                         const xmlChar *name2,
 		                         void *userdata);
 XMLPUBFUN int
-		xmlHashUpdateEntry2	(xmlHashTablePtr hash,
+		xmlHashUpdateEntry2	(xmlHashTable *hash,
 		                         const xmlChar *name,
 		                         const xmlChar *name2,
 		                         void *userdata,
 					 xmlHashDeallocator dealloc);
 XMLPUBFUN int
-		xmlHashAdd3		(xmlHashTablePtr hash,
+		xmlHashAdd3		(xmlHashTable *hash,
 		                         const xmlChar *name,
 		                         const xmlChar *name2,
 		                         const xmlChar *name3,
 		                         void *userdata);
 XMLPUBFUN int
-		xmlHashAddEntry3	(xmlHashTablePtr hash,
+		xmlHashAddEntry3	(xmlHashTable *hash,
 		                         const xmlChar *name,
 		                         const xmlChar *name2,
 		                         const xmlChar *name3,
 		                         void *userdata);
 XMLPUBFUN int
-		xmlHashUpdateEntry3	(xmlHashTablePtr hash,
+		xmlHashUpdateEntry3	(xmlHashTable *hash,
 		                         const xmlChar *name,
 		                         const xmlChar *name2,
 		                         const xmlChar *name3,
@@ -157,16 +157,16 @@ XMLPUBFUN int
 * Remove an entry from the hash table.
 */
 XMLPUBFUN int
-		xmlHashRemoveEntry	(xmlHashTablePtr hash,
+		xmlHashRemoveEntry	(xmlHashTable *hash,
 					 const xmlChar *name,
 					 xmlHashDeallocator dealloc);
 XMLPUBFUN int
-		xmlHashRemoveEntry2	(xmlHashTablePtr hash,
+		xmlHashRemoveEntry2	(xmlHashTable *hash,
 					 const xmlChar *name,
 					 const xmlChar *name2,
 					 xmlHashDeallocator dealloc);
 XMLPUBFUN int 
-		xmlHashRemoveEntry3	(xmlHashTablePtr hash,
+		xmlHashRemoveEntry3	(xmlHashTable *hash,
 					 const xmlChar *name,
 					 const xmlChar *name2,
 					 const xmlChar *name3,
@@ -176,29 +176,29 @@ XMLPUBFUN int
 * Retrieve the payload.
 */
 XMLPUBFUN void *
-		xmlHashLookup		(xmlHashTablePtr hash,
+		xmlHashLookup		(xmlHashTable *hash,
 					 const xmlChar *name);
 XMLPUBFUN void *
-		xmlHashLookup2		(xmlHashTablePtr hash,
+		xmlHashLookup2		(xmlHashTable *hash,
 					 const xmlChar *name,
 					 const xmlChar *name2);
 XMLPUBFUN void *
-		xmlHashLookup3		(xmlHashTablePtr hash,
+		xmlHashLookup3		(xmlHashTable *hash,
 					 const xmlChar *name,
 					 const xmlChar *name2,
 					 const xmlChar *name3);
 XMLPUBFUN void *
-		xmlHashQLookup		(xmlHashTablePtr hash,
+		xmlHashQLookup		(xmlHashTable *hash,
 					 const xmlChar *prefix,
 					 const xmlChar *name);
 XMLPUBFUN void *
-		xmlHashQLookup2		(xmlHashTablePtr hash,
+		xmlHashQLookup2		(xmlHashTable *hash,
 					 const xmlChar *prefix,
 					 const xmlChar *name,
 					 const xmlChar *prefix2,
 					 const xmlChar *name2);
 XMLPUBFUN void *
-		xmlHashQLookup3		(xmlHashTablePtr hash,
+		xmlHashQLookup3		(xmlHashTable *hash,
 					 const xmlChar *prefix,
 					 const xmlChar *name,
 					 const xmlChar *prefix2,
@@ -209,32 +209,32 @@ XMLPUBFUN void *
 /*
 * Helpers.
 */
-XMLPUBFUN xmlHashTablePtr
-		xmlHashCopySafe		(xmlHashTablePtr hash,
+XMLPUBFUN xmlHashTable *
+		xmlHashCopySafe		(xmlHashTable *hash,
 					 xmlHashCopier copy,
 					 xmlHashDeallocator dealloc);
-XMLPUBFUN xmlHashTablePtr
-		xmlHashCopy		(xmlHashTablePtr hash,
+XMLPUBFUN xmlHashTable *
+		xmlHashCopy		(xmlHashTable *hash,
 					 xmlHashCopier copy);
 XMLPUBFUN int
-		xmlHashSize		(xmlHashTablePtr hash);
+		xmlHashSize		(xmlHashTable *hash);
 XMLPUBFUN void
-		xmlHashScan		(xmlHashTablePtr hash,
+		xmlHashScan		(xmlHashTable *hash,
 					 xmlHashScanner scan,
 					 void *data);
 XMLPUBFUN void
-		xmlHashScan3		(xmlHashTablePtr hash,
+		xmlHashScan3		(xmlHashTable *hash,
 					 const xmlChar *name,
 					 const xmlChar *name2,
 					 const xmlChar *name3,
 					 xmlHashScanner scan,
 					 void *data);
 XMLPUBFUN void
-		xmlHashScanFull		(xmlHashTablePtr hash,
+		xmlHashScanFull		(xmlHashTable *hash,
 					 xmlHashScannerFull scan,
 					 void *data);
 XMLPUBFUN void
-		xmlHashScanFull3	(xmlHashTablePtr hash,
+		xmlHashScanFull3	(xmlHashTable *hash,
 					 const xmlChar *name,
 					 const xmlChar *name2,
 					 const xmlChar *name3,
--- a/include/libxml/list.h
+++ b/include/libxml/list.h
@@ -31,7 +31,7 @@ typedef xmlList *xmlListPtr;
 *
 * @param lk  the data to deallocate
 */
-typedef void (*xmlListDeallocator) (xmlLinkPtr lk);
+typedef void (*xmlListDeallocator) (xmlLink *lk);
 /**
 * Callback function used to compare 2 data.
 *
@@ -50,80 +50,80 @@ typedef int  (*xmlListDataCompare) (const void *data0, const void *data1);
 typedef int (*xmlListWalker) (const void *data, void *user);

 /* Creation/Deletion */
-XMLPUBFUN xmlListPtr
+XMLPUBFUN xmlList *
 		xmlListCreate		(xmlListDeallocator deallocator,
 	                                 xmlListDataCompare compare);
 XMLPUBFUN void
-		xmlListDelete		(xmlListPtr l);
+		xmlListDelete		(xmlList *l);

 /* Basic Operators */
 XMLPUBFUN void *
-		xmlListSearch		(xmlListPtr l,
+		xmlListSearch		(xmlList *l,
 					 void *data);
 XMLPUBFUN void *
-		xmlListReverseSearch	(xmlListPtr l,
+		xmlListReverseSearch	(xmlList *l,
 					 void *data);
 XMLPUBFUN int
-		xmlListInsert		(xmlListPtr l,
+		xmlListInsert		(xmlList *l,
 					 void *data) ;
 XMLPUBFUN int
-		xmlListAppend		(xmlListPtr l,
+		xmlListAppend		(xmlList *l,
 					 void *data) ;
 XMLPUBFUN int
-		xmlListRemoveFirst	(xmlListPtr l,
+		xmlListRemoveFirst	(xmlList *l,
 					 void *data);
 XMLPUBFUN int
-		xmlListRemoveLast	(xmlListPtr l,
+		xmlListRemoveLast	(xmlList *l,
 					 void *data);
 XMLPUBFUN int
-		xmlListRemoveAll	(xmlListPtr l,
+		xmlListRemoveAll	(xmlList *l,
 					 void *data);
 XMLPUBFUN void
-		xmlListClear		(xmlListPtr l);
+		xmlListClear		(xmlList *l);
 XMLPUBFUN int
-		xmlListEmpty		(xmlListPtr l);
-XMLPUBFUN xmlLinkPtr
-		xmlListFront		(xmlListPtr l);
-XMLPUBFUN xmlLinkPtr
-		xmlListEnd		(xmlListPtr l);
+		xmlListEmpty		(xmlList *l);
+XMLPUBFUN xmlLink *
+		xmlListFront		(xmlList *l);
+XMLPUBFUN xmlLink *
+		xmlListEnd		(xmlList *l);
 XMLPUBFUN int
-		xmlListSize		(xmlListPtr l);
+		xmlListSize		(xmlList *l);

 XMLPUBFUN void
-		xmlListPopFront		(xmlListPtr l);
+		xmlListPopFront		(xmlList *l);
 XMLPUBFUN void
-		xmlListPopBack		(xmlListPtr l);
+		xmlListPopBack		(xmlList *l);
 XMLPUBFUN int
-		xmlListPushFront	(xmlListPtr l,
+		xmlListPushFront	(xmlList *l,
 					 void *data);
 XMLPUBFUN int
-		xmlListPushBack		(xmlListPtr l,
+		xmlListPushBack		(xmlList *l,
 					 void *data);

 /* Advanced Operators */
 XMLPUBFUN void
-		xmlListReverse		(xmlListPtr l);
+		xmlListReverse		(xmlList *l);
 XMLPUBFUN void
-		xmlListSort		(xmlListPtr l);
+		xmlListSort		(xmlList *l);
 XMLPUBFUN void
-		xmlListWalk		(xmlListPtr l,
+		xmlListWalk		(xmlList *l,
 					 xmlListWalker walker,
 					 void *user);
 XMLPUBFUN void
-		xmlListReverseWalk	(xmlListPtr l,
+		xmlListReverseWalk	(xmlList *l,
 					 xmlListWalker walker,
 					 void *user);
 XMLPUBFUN void
-		xmlListMerge		(xmlListPtr l1,
-					 xmlListPtr l2);
-XMLPUBFUN xmlListPtr
-		xmlListDup		(xmlListPtr old);
+		xmlListMerge		(xmlList *l1,
+					 xmlList *l2);
+XMLPUBFUN xmlList *
+		xmlListDup		(xmlList *old);
 XMLPUBFUN int
-		xmlListCopy		(xmlListPtr cur,
-					 xmlListPtr old);
+		xmlListCopy		(xmlList *cur,
+					 xmlList *old);
 /* Link operators */
 XMLPUBFUN void *
-		xmlLinkGetData          (xmlLinkPtr lk);
+		xmlLinkGetData          (xmlLink *lk);

 /* xmlListUnique() */
 /* xmlListSwap */
--- a/include/libxml/parser.h
+++ b/include/libxml/parser.h
@@ -98,7 +98,7 @@ typedef void (* xmlParserInputDeallocate)(xmlChar *str);
 */
 struct _xmlParserInput {
    /* Input buffer */
-    xmlParserInputBufferPtr buf;
+    xmlParserInputBuffer *buf;
    /* The file analyzed, if any */
    const char *filename;
    /* unused */
@@ -130,7 +130,7 @@ struct _xmlParserInput {
    /* unused */
    unsigned long parentConsumed XML_DEPRECATED_MEMBER;
    /* entity, if any */
-    xmlEntityPtr entity XML_DEPRECATED_MEMBER;
+    xmlEntity *entity XML_DEPRECATED_MEMBER;
 };

 /** @cond ignore */
@@ -230,7 +230,7 @@ typedef struct _xmlAttrHashBucket xmlAttrHashBucket;
 typedef xmlParserErrors
 (*xmlResourceLoader)(void *ctxt, const char *url, const char *publicId,
                     xmlResourceType type, xmlParserInputFlags flags,
-                     xmlParserInputPtr *out);
+                     xmlParserInput **out);

 /**
 * Parser context
@@ -252,7 +252,7 @@ struct _xmlParserCtxt {
     *
     * the document being built
     */
-    xmlDocPtr myDoc;
+    xmlDoc *myDoc;
    /**
     * @deprecated Use xmlCtxtGetStatus()
     *
@@ -296,24 +296,24 @@ struct _xmlParserCtxt {
    /**
     * Current input stream
     */
-    xmlParserInputPtr input;
+    xmlParserInput *input;
    /* Number of current input streams */
    int inputNr;
    /* Max number of input streams */
    int inputMax XML_DEPRECATED_MEMBER;
    /* stack of inputs */
-    xmlParserInputPtr *inputTab;
+    xmlParserInput **inputTab;

    /* Node analysis stack only used for DOM building */

    /* Current parsed Node */
-    xmlNodePtr node XML_DEPRECATED_MEMBER;
+    xmlNode *node XML_DEPRECATED_MEMBER;
    /* Depth of the parsing stack */
    int nodeNr XML_DEPRECATED_MEMBER;
    /* Max depth of the parsing stack */
    int nodeMax XML_DEPRECATED_MEMBER;
    /* array of nodes */
-    xmlNodePtr *nodeTab XML_DEPRECATED_MEMBER;
+    xmlNode **nodeTab XML_DEPRECATED_MEMBER;

    /* Whether node info should be kept */
    int record_info;
@@ -411,7 +411,7 @@ struct _xmlParserCtxt {
    /* to prevent entity substitution loops */
    int depth XML_DEPRECATED_MEMBER;
    /* unused */
-    xmlParserInputPtr entity XML_DEPRECATED_MEMBER;
+    xmlParserInput *entity XML_DEPRECATED_MEMBER;
    /* unused */
    int charset XML_DEPRECATED_MEMBER;
    /* Those two fields are there to speed up large node parsing */
@@ -456,7 +456,7 @@ struct _xmlParserCtxt {
     *
     * dictionary for the parser
     */
-    xmlDictPtr dict;
+    xmlDict *dict;
    /* array for the attributes callbacks */
    const xmlChar **atts XML_DEPRECATED_MEMBER;
    /* the size of the array */
@@ -488,9 +488,9 @@ struct _xmlParserCtxt {
    /* array of data for push */
    xmlStartTag *pushTab XML_DEPRECATED_MEMBER;
    /* defaulted attributes if any */
-    xmlHashTablePtr attsDefault XML_DEPRECATED_MEMBER;
+    xmlHashTable *attsDefault XML_DEPRECATED_MEMBER;
    /* non-CDATA attributes if any */
-    xmlHashTablePtr attsSpecial XML_DEPRECATED_MEMBER;
+    xmlHashTable *attsSpecial XML_DEPRECATED_MEMBER;

    /**
     * @deprecated Use xmlCtxtGetStatus()
@@ -518,11 +518,11 @@ struct _xmlParserCtxt {
    /* number of freed element nodes */
    int freeElemsNr XML_DEPRECATED_MEMBER;
    /* List of freed element nodes */
-    xmlNodePtr freeElems XML_DEPRECATED_MEMBER;
+    xmlNode *freeElems XML_DEPRECATED_MEMBER;
    /* number of freed attributes nodes */
    int freeAttrsNr XML_DEPRECATED_MEMBER;
    /* List of freed attributes nodes */
-    xmlAttrPtr freeAttrs XML_DEPRECATED_MEMBER;
+    xmlAttr *freeAttrs XML_DEPRECATED_MEMBER;

    /**
     * @deprecated Use xmlCtxtGetLastError()
@@ -599,9 +599,9 @@ struct _xmlSAXLocator {
 * @param ctx  the user data (XML parser context)
 * @param publicId  The public ID of the entity
 * @param systemId  The system ID of the entity
- * @returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
+ * @returns the xmlParserInput if inlined or NULL for DOM behaviour.
 */
-typedef xmlParserInputPtr (*resolveEntitySAXFunc) (void *ctx,
+typedef xmlParserInput *(*resolveEntitySAXFunc) (void *ctx,
 				const xmlChar *publicId,
 				const xmlChar *systemId);
 /**
@@ -633,18 +633,18 @@ typedef void (*externalSubsetSAXFunc) (void *ctx,
 *
 * @param ctx  the user data (XML parser context)
 * @param name  The entity name
- * @returns the xmlEntityPtr if found.
+ * @returns the xmlEntity if found.
 */
-typedef xmlEntityPtr (*getEntitySAXFunc) (void *ctx,
+typedef xmlEntity *(*getEntitySAXFunc) (void *ctx,
 				const xmlChar *name);
 /**
 * Get a parameter entity by name.
 *
 * @param ctx  the user data (XML parser context)
 * @param name  The entity name
- * @returns the xmlEntityPtr if found.
+ * @returns the xmlEntity if found.
 */
-typedef xmlEntityPtr (*getParameterEntitySAXFunc) (void *ctx,
+typedef xmlEntity *(*getParameterEntitySAXFunc) (void *ctx,
 				const xmlChar *name);
 /**
 * An entity definition has been parsed.
@@ -691,7 +691,7 @@ typedef void (*attributeDeclSAXFunc)(void *ctx,
 				int type,
 				int def,
 				const xmlChar *defaultValue,
-				xmlEnumerationPtr tree);
+				xmlEnumeration *tree);
 /**
 * An element definition has been parsed.
 *
@@ -703,7 +703,7 @@ typedef void (*attributeDeclSAXFunc)(void *ctx,
 typedef void (*elementDeclSAXFunc)(void *ctx,
 				const xmlChar *name,
 				int type,
-				xmlElementContentPtr content);
+				xmlElementContent *content);
 /**
 * What to do when an unparsed entity declaration is parsed.
 *
@@ -726,7 +726,7 @@ typedef void (*unparsedEntityDeclSAXFunc)(void *ctx,
 * @param loc  A SAX Locator
 */
 typedef void (*setDocumentLocatorSAXFunc) (void *ctx,
-				xmlSAXLocatorPtr loc);
+				xmlSAXLocator *loc);
 /**
 * Called when the document start being processed.
 *
@@ -1087,9 +1087,9 @@ struct _xmlSAXHandlerV1 {
 * @param context  the XML parser context
 * @returns the entity input parser.
 */
-typedef xmlParserInputPtr (*xmlExternalEntityLoader) (const char *URL,
+typedef xmlParserInput *(*xmlExternalEntityLoader) (const char *URL,
 					 const char *ID,
-					 xmlParserCtxtPtr context);
+					 xmlParserCtxt *context);

 /*
 * Variables
@@ -1235,21 +1235,21 @@ XMLPUBFUN void
 */
 XML_DEPRECATED
 XMLPUBFUN int
-		xmlParserInputRead	(xmlParserInputPtr in,
+		xmlParserInputRead	(xmlParserInput *in,
 					 int len);
 XMLPUBFUN int
-		xmlParserInputGrow	(xmlParserInputPtr in,
+		xmlParserInputGrow	(xmlParserInput *in,
 					 int len);

 /*
 * Basic parsing Interfaces
 */
 #ifdef LIBXML_SAX1_ENABLED
-XMLPUBFUN xmlDocPtr
+XMLPUBFUN xmlDoc *
 		xmlParseDoc		(const xmlChar *cur);
-XMLPUBFUN xmlDocPtr
+XMLPUBFUN xmlDoc *
 		xmlParseFile		(const char *filename);
-XMLPUBFUN xmlDocPtr
+XMLPUBFUN xmlDoc *
 		xmlParseMemory		(const char *buffer,
 					 int size);
 #endif /* LIBXML_SAX1_ENABLED */
@@ -1259,7 +1259,7 @@ XMLPUBFUN int
 XMLPUBFUN int
 		xmlKeepBlanksDefault	(int val);
 XMLPUBFUN void
-		xmlStopParser		(xmlParserCtxtPtr ctxt);
+		xmlStopParser		(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN int
 		xmlPedanticParserDefault(int val);
@@ -1294,14 +1294,14 @@ XMLPUBFUN int
 * Recovery mode
 */
 XML_DEPRECATED
-XMLPUBFUN xmlDocPtr
+XMLPUBFUN xmlDoc *
 		xmlRecoverDoc		(const xmlChar *cur);
 XML_DEPRECATED
-XMLPUBFUN xmlDocPtr
+XMLPUBFUN xmlDoc *
 		xmlRecoverMemory	(const char *buffer,
 					 int size);
 XML_DEPRECATED
-XMLPUBFUN xmlDocPtr
+XMLPUBFUN xmlDoc *
 		xmlRecoverFile		(const char *filename);
 #endif /* LIBXML_SAX1_ENABLED */

@@ -1309,163 +1309,163 @@ XMLPUBFUN xmlDocPtr
 * Less common routines and SAX interfaces
 */
 XMLPUBFUN int
-		xmlParseDocument	(xmlParserCtxtPtr ctxt);
+		xmlParseDocument	(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN int
-		xmlParseExtParsedEnt	(xmlParserCtxtPtr ctxt);
+		xmlParseExtParsedEnt	(xmlParserCtxt *ctxt);
 #ifdef LIBXML_SAX1_ENABLED
 XML_DEPRECATED
 XMLPUBFUN int
-		xmlSAXUserParseFile	(xmlSAXHandlerPtr sax,
+		xmlSAXUserParseFile	(xmlSAXHandler *sax,
 					 void *user_data,
 					 const char *filename);
 XML_DEPRECATED
 XMLPUBFUN int
-		xmlSAXUserParseMemory	(xmlSAXHandlerPtr sax,
+		xmlSAXUserParseMemory	(xmlSAXHandler *sax,
 					 void *user_data,
 					 const char *buffer,
 					 int size);
 XML_DEPRECATED
-XMLPUBFUN xmlDocPtr
-		xmlSAXParseDoc		(xmlSAXHandlerPtr sax,
+XMLPUBFUN xmlDoc *
+		xmlSAXParseDoc		(xmlSAXHandler *sax,
 					 const xmlChar *cur,
 					 int recovery);
 XML_DEPRECATED
-XMLPUBFUN xmlDocPtr
-		xmlSAXParseMemory	(xmlSAXHandlerPtr sax,
+XMLPUBFUN xmlDoc *
+		xmlSAXParseMemory	(xmlSAXHandler *sax,
 					 const char *buffer,
 					 int size,
 					 int recovery);
 XML_DEPRECATED
-XMLPUBFUN xmlDocPtr
-		xmlSAXParseMemoryWithData (xmlSAXHandlerPtr sax,
+XMLPUBFUN xmlDoc *
+		xmlSAXParseMemoryWithData (xmlSAXHandler *sax,
 					 const char *buffer,
 					 int size,
 					 int recovery,
 					 void *data);
 XML_DEPRECATED
-XMLPUBFUN xmlDocPtr
-		xmlSAXParseFile		(xmlSAXHandlerPtr sax,
+XMLPUBFUN xmlDoc *
+		xmlSAXParseFile		(xmlSAXHandler *sax,
 					 const char *filename,
 					 int recovery);
 XML_DEPRECATED
-XMLPUBFUN xmlDocPtr
-		xmlSAXParseFileWithData	(xmlSAXHandlerPtr sax,
+XMLPUBFUN xmlDoc *
+		xmlSAXParseFileWithData	(xmlSAXHandler *sax,
 					 const char *filename,
 					 int recovery,
 					 void *data);
 XML_DEPRECATED
-XMLPUBFUN xmlDocPtr
-		xmlSAXParseEntity	(xmlSAXHandlerPtr sax,
+XMLPUBFUN xmlDoc *
+		xmlSAXParseEntity	(xmlSAXHandler *sax,
 					 const char *filename);
 XML_DEPRECATED
-XMLPUBFUN xmlDocPtr
+XMLPUBFUN xmlDoc *
 		xmlParseEntity		(const char *filename);
 #endif /* LIBXML_SAX1_ENABLED */

 #ifdef LIBXML_VALID_ENABLED
-XMLPUBFUN xmlDtdPtr
-		xmlCtxtParseDtd		(xmlParserCtxtPtr ctxt,
-					 xmlParserInputPtr input,
+XMLPUBFUN xmlDtd *
+		xmlCtxtParseDtd		(xmlParserCtxt *ctxt,
+					 xmlParserInput *input,
 					 const xmlChar *ExternalID,
 					 const xmlChar *SystemID);
 XMLPUBFUN int
-		xmlCtxtValidateDocument	(xmlParserCtxtPtr ctxt,
-					 xmlDocPtr doc);
+		xmlCtxtValidateDocument	(xmlParserCtxt *ctxt,
+					 xmlDoc *doc);
 XMLPUBFUN int
-		xmlCtxtValidateDtd	(xmlParserCtxtPtr ctxt,
-					 xmlDocPtr doc,
-					 xmlDtdPtr dtd);
+		xmlCtxtValidateDtd	(xmlParserCtxt *ctxt,
+					 xmlDoc *doc,
+					 xmlDtd *dtd);
 XML_DEPRECATED
-XMLPUBFUN xmlDtdPtr
-		xmlSAXParseDTD		(xmlSAXHandlerPtr sax,
+XMLPUBFUN xmlDtd *
+		xmlSAXParseDTD		(xmlSAXHandler *sax,
 					 const xmlChar *ExternalID,
 					 const xmlChar *SystemID);
-XMLPUBFUN xmlDtdPtr
+XMLPUBFUN xmlDtd *
 		xmlParseDTD		(const xmlChar *ExternalID,
 					 const xmlChar *SystemID);
-XMLPUBFUN xmlDtdPtr
-		xmlIOParseDTD		(xmlSAXHandlerPtr sax,
-					 xmlParserInputBufferPtr input,
+XMLPUBFUN xmlDtd *
+		xmlIOParseDTD		(xmlSAXHandler *sax,
+					 xmlParserInputBuffer *input,
 					 xmlCharEncoding enc);
 #endif /* LIBXML_VALID_ENABLE */
 #ifdef LIBXML_SAX1_ENABLED
 XMLPUBFUN int
-		xmlParseBalancedChunkMemory(xmlDocPtr doc,
-					 xmlSAXHandlerPtr sax,
+		xmlParseBalancedChunkMemory(xmlDoc *doc,
+					 xmlSAXHandler *sax,
 					 void *user_data,
 					 int depth,
 					 const xmlChar *string,
-					 xmlNodePtr *lst);
+					 xmlNode **lst);
 #endif /* LIBXML_SAX1_ENABLED */
 XMLPUBFUN xmlParserErrors
-		xmlParseInNodeContext	(xmlNodePtr node,
+		xmlParseInNodeContext	(xmlNode *node,
 					 const char *data,
 					 int datalen,
 					 int options,
-					 xmlNodePtr *lst);
+					 xmlNode **lst);
 #ifdef LIBXML_SAX1_ENABLED
 XMLPUBFUN int
-		xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc,
-                     xmlSAXHandlerPtr sax,
+		xmlParseBalancedChunkMemoryRecover(xmlDoc *doc,
+                     xmlSAXHandler *sax,
                     void *user_data,
                     int depth,
                     const xmlChar *string,
-                     xmlNodePtr *lst,
+                     xmlNode **lst,
                     int recover);
 XML_DEPRECATED
 XMLPUBFUN int
-		xmlParseExternalEntity	(xmlDocPtr doc,
-					 xmlSAXHandlerPtr sax,
+		xmlParseExternalEntity	(xmlDoc *doc,
+					 xmlSAXHandler *sax,
 					 void *user_data,
 					 int depth,
 					 const xmlChar *URL,
 					 const xmlChar *ID,
-					 xmlNodePtr *lst);
+					 xmlNode **lst);
 #endif /* LIBXML_SAX1_ENABLED */
 XMLPUBFUN int
-		xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx,
+		xmlParseCtxtExternalEntity(xmlParserCtxt *ctx,
 					 const xmlChar *URL,
 					 const xmlChar *ID,
-					 xmlNodePtr *lst);
+					 xmlNode **lst);

 /*
 * Parser contexts handling.
 */
-XMLPUBFUN xmlParserCtxtPtr
+XMLPUBFUN xmlParserCtxt *
 		xmlNewParserCtxt	(void);
-XMLPUBFUN xmlParserCtxtPtr
+XMLPUBFUN xmlParserCtxt *
 		xmlNewSAXParserCtxt	(const xmlSAXHandler *sax,
 					 void *userData);
 XMLPUBFUN int
-		xmlInitParserCtxt	(xmlParserCtxtPtr ctxt);
+		xmlInitParserCtxt	(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN void
-		xmlClearParserCtxt	(xmlParserCtxtPtr ctxt);
+		xmlClearParserCtxt	(xmlParserCtxt *ctxt);
 XMLPUBFUN void
-		xmlFreeParserCtxt	(xmlParserCtxtPtr ctxt);
+		xmlFreeParserCtxt	(xmlParserCtxt *ctxt);
 #ifdef LIBXML_SAX1_ENABLED
 XML_DEPRECATED
 XMLPUBFUN void
-		xmlSetupParserForBuffer	(xmlParserCtxtPtr ctxt,
+		xmlSetupParserForBuffer	(xmlParserCtxt *ctxt,
 					 const xmlChar* buffer,
 					 const char *filename);
 #endif /* LIBXML_SAX1_ENABLED */
-XMLPUBFUN xmlParserCtxtPtr
+XMLPUBFUN xmlParserCtxt *
 		xmlCreateDocParserCtxt	(const xmlChar *cur);

 #ifdef LIBXML_PUSH_ENABLED
 /*
 * Interfaces for the Push mode.
 */
-XMLPUBFUN xmlParserCtxtPtr
-		xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax,
+XMLPUBFUN xmlParserCtxt *
+		xmlCreatePushParserCtxt(xmlSAXHandler *sax,
 					 void *user_data,
 					 const char *chunk,
 					 int size,
 					 const char *filename);
 XMLPUBFUN int
-		xmlParseChunk		(xmlParserCtxtPtr ctxt,
+		xmlParseChunk		(xmlParserCtxt *ctxt,
 					 const char *chunk,
 					 int size,
 					 int terminate);
@@ -1475,17 +1475,17 @@ XMLPUBFUN int
 * Special I/O mode.
 */

-XMLPUBFUN xmlParserCtxtPtr
-		xmlCreateIOParserCtxt	(xmlSAXHandlerPtr sax,
+XMLPUBFUN xmlParserCtxt *
+		xmlCreateIOParserCtxt	(xmlSAXHandler *sax,
 					 void *user_data,
 					 xmlInputReadCallback   ioread,
 					 xmlInputCloseCallback  ioclose,
 					 void *ioctx,
 					 xmlCharEncoding enc);

-XMLPUBFUN xmlParserInputPtr
-		xmlNewIOInputStream	(xmlParserCtxtPtr ctxt,
-					 xmlParserInputBufferPtr input,
+XMLPUBFUN xmlParserInput *
+		xmlNewIOInputStream	(xmlParserCtxt *ctxt,
+					 xmlParserInputBuffer *input,
 					 xmlCharEncoding enc);

 /*
@@ -1493,22 +1493,22 @@ XMLPUBFUN xmlParserInputPtr
 */
 XML_DEPRECATED
 XMLPUBFUN const xmlParserNodeInfo*
-		xmlParserFindNodeInfo	(xmlParserCtxtPtr ctxt,
-				         xmlNodePtr node);
+		xmlParserFindNodeInfo	(xmlParserCtxt *ctxt,
+				         xmlNode *node);
 XML_DEPRECATED
 XMLPUBFUN void
-		xmlInitNodeInfoSeq	(xmlParserNodeInfoSeqPtr seq);
+		xmlInitNodeInfoSeq	(xmlParserNodeInfoSeq *seq);
 XML_DEPRECATED
 XMLPUBFUN void
-		xmlClearNodeInfoSeq	(xmlParserNodeInfoSeqPtr seq);
+		xmlClearNodeInfoSeq	(xmlParserNodeInfoSeq *seq);
 XML_DEPRECATED
 XMLPUBFUN unsigned long
-		xmlParserFindNodeInfoIndex(xmlParserNodeInfoSeqPtr seq,
-                                         xmlNodePtr node);
+		xmlParserFindNodeInfoIndex(xmlParserNodeInfoSeq *seq,
+                                         xmlNode *node);
 XML_DEPRECATED
 XMLPUBFUN void
-		xmlParserAddNodeInfo	(xmlParserCtxtPtr ctxt,
-					 xmlParserNodeInfoPtr info);
+		xmlParserAddNodeInfo	(xmlParserCtxt *ctxt,
+					 xmlParserNodeInfo *info);

 /*
 * External entities handling actually implemented in xmlIO.
@@ -1518,14 +1518,14 @@ XMLPUBFUN void
 		xmlSetExternalEntityLoader(xmlExternalEntityLoader f);
 XMLPUBFUN xmlExternalEntityLoader
 		xmlGetExternalEntityLoader(void);
-XMLPUBFUN xmlParserInputPtr
+XMLPUBFUN xmlParserInput *
 		xmlLoadExternalEntity	(const char *URL,
 					 const char *ID,
-					 xmlParserCtxtPtr ctxt);
+					 xmlParserCtxt *ctxt);

 XML_DEPRECATED
 XMLPUBFUN long
-		xmlByteConsumed		(xmlParserCtxtPtr ctxt);
+		xmlByteConsumed		(xmlParserCtxt *ctxt);

 /*
 * New set of simpler/more flexible APIs
@@ -1722,135 +1722,135 @@ typedef enum {
 } xmlParserOption;

 XMLPUBFUN void
-		xmlCtxtReset		(xmlParserCtxtPtr ctxt);
+		xmlCtxtReset		(xmlParserCtxt *ctxt);
 XMLPUBFUN int
-		xmlCtxtResetPush	(xmlParserCtxtPtr ctxt,
+		xmlCtxtResetPush	(xmlParserCtxt *ctxt,
 					 const char *chunk,
 					 int size,
 					 const char *filename,
 					 const char *encoding);
 XMLPUBFUN int
-		xmlCtxtGetOptions	(xmlParserCtxtPtr ctxt);
+		xmlCtxtGetOptions	(xmlParserCtxt *ctxt);
 XMLPUBFUN int
-		xmlCtxtSetOptions	(xmlParserCtxtPtr ctxt,
+		xmlCtxtSetOptions	(xmlParserCtxt *ctxt,
 					 int options);
 XMLPUBFUN int
-		xmlCtxtUseOptions	(xmlParserCtxtPtr ctxt,
+		xmlCtxtUseOptions	(xmlParserCtxt *ctxt,
 					 int options);
 XMLPUBFUN void *
-		xmlCtxtGetPrivate	(xmlParserCtxtPtr ctxt);
+		xmlCtxtGetPrivate	(xmlParserCtxt *ctxt);
 XMLPUBFUN void
-		xmlCtxtSetPrivate	(xmlParserCtxtPtr ctxt,
+		xmlCtxtSetPrivate	(xmlParserCtxt *ctxt,
 					 void *priv);
 XMLPUBFUN void *
-		xmlCtxtGetCatalogs	(xmlParserCtxtPtr ctxt);
+		xmlCtxtGetCatalogs	(xmlParserCtxt *ctxt);
 XMLPUBFUN void
-		xmlCtxtSetCatalogs	(xmlParserCtxtPtr ctxt,
+		xmlCtxtSetCatalogs	(xmlParserCtxt *ctxt,
 					 void *catalogs);
-XMLPUBFUN xmlDictPtr
-		xmlCtxtGetDict		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlDict *
+		xmlCtxtGetDict		(xmlParserCtxt *ctxt);
 XMLPUBFUN void
-		xmlCtxtSetDict		(xmlParserCtxtPtr ctxt,
-					 xmlDictPtr);
+		xmlCtxtSetDict		(xmlParserCtxt *ctxt,
+					 xmlDict *);
 XMLPUBFUN xmlSAXHandler *
-		xmlCtxtGetSaxHandler	(xmlParserCtxtPtr ctxt);
+		xmlCtxtGetSaxHandler	(xmlParserCtxt *ctxt);
 XMLPUBFUN int
-		xmlCtxtSetSaxHandler	(xmlParserCtxtPtr ctxt,
+		xmlCtxtSetSaxHandler	(xmlParserCtxt *ctxt,
 					 const xmlSAXHandler *sax);
-XMLPUBFUN xmlDocPtr
-		xmlCtxtGetDocument	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlDoc *
+		xmlCtxtGetDocument	(xmlParserCtxt *ctxt);
 XMLPUBFUN int
-		xmlCtxtIsHtml		(xmlParserCtxtPtr ctxt);
+		xmlCtxtIsHtml		(xmlParserCtxt *ctxt);
 XMLPUBFUN int
-		xmlCtxtIsStopped	(xmlParserCtxtPtr ctxt);
+		xmlCtxtIsStopped	(xmlParserCtxt *ctxt);
 #ifdef LIBXML_VALID_ENABLED
-XMLPUBFUN xmlValidCtxtPtr
-		xmlCtxtGetValidCtxt	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlValidCtxt *
+		xmlCtxtGetValidCtxt	(xmlParserCtxt *ctxt);
 #endif
 XMLPUBFUN const xmlChar *
-		xmlCtxtGetVersion	(xmlParserCtxtPtr ctxt);
+		xmlCtxtGetVersion	(xmlParserCtxt *ctxt);
 XMLPUBFUN const xmlChar *
-		xmlCtxtGetDeclaredEncoding(xmlParserCtxtPtr ctxt);
+		xmlCtxtGetDeclaredEncoding(xmlParserCtxt *ctxt);
 XMLPUBFUN int
-		xmlCtxtGetStandalone	(xmlParserCtxtPtr ctxt);
+		xmlCtxtGetStandalone	(xmlParserCtxt *ctxt);
 XMLPUBFUN xmlParserStatus
-		xmlCtxtGetStatus	(xmlParserCtxtPtr ctxt);
+		xmlCtxtGetStatus	(xmlParserCtxt *ctxt);
 XMLPUBFUN void
-		xmlCtxtSetErrorHandler	(xmlParserCtxtPtr ctxt,
+		xmlCtxtSetErrorHandler	(xmlParserCtxt *ctxt,
 					 xmlStructuredErrorFunc handler,
 					 void *data);
 XMLPUBFUN void
-		xmlCtxtSetResourceLoader(xmlParserCtxtPtr ctxt,
+		xmlCtxtSetResourceLoader(xmlParserCtxt *ctxt,
 					 xmlResourceLoader loader,
 					 void *vctxt);
 XMLPUBFUN void
-		xmlCtxtSetCharEncConvImpl(xmlParserCtxtPtr ctxt,
+		xmlCtxtSetCharEncConvImpl(xmlParserCtxt *ctxt,
 					 xmlCharEncConvImpl impl,
 					 void *vctxt);
 XMLPUBFUN void
-		xmlCtxtSetMaxAmplification(xmlParserCtxtPtr ctxt,
+		xmlCtxtSetMaxAmplification(xmlParserCtxt *ctxt,
 					 unsigned maxAmpl);
-XMLPUBFUN xmlDocPtr
+XMLPUBFUN xmlDoc *
 		xmlReadDoc		(const xmlChar *cur,
 					 const char *URL,
 					 const char *encoding,
 					 int options);
-XMLPUBFUN xmlDocPtr
+XMLPUBFUN xmlDoc *
 		xmlReadFile		(const char *URL,
 					 const char *encoding,
 					 int options);
-XMLPUBFUN xmlDocPtr
+XMLPUBFUN xmlDoc *
 		xmlReadMemory		(const char *buffer,
 					 int size,
 					 const char *URL,
 					 const char *encoding,
 					 int options);
-XMLPUBFUN xmlDocPtr
+XMLPUBFUN xmlDoc *
 		xmlReadFd		(int fd,
 					 const char *URL,
 					 const char *encoding,
 					 int options);
-XMLPUBFUN xmlDocPtr
+XMLPUBFUN xmlDoc *
 		xmlReadIO		(xmlInputReadCallback ioread,
 					 xmlInputCloseCallback ioclose,
 					 void *ioctx,
 					 const char *URL,
 					 const char *encoding,
 					 int options);
-XMLPUBFUN xmlDocPtr
-		xmlCtxtParseDocument	(xmlParserCtxtPtr ctxt,
-					 xmlParserInputPtr input);
-XMLPUBFUN xmlNodePtr
-		xmlCtxtParseContent	(xmlParserCtxtPtr ctxt,
-					 xmlParserInputPtr input,
-					 xmlNodePtr node,
+XMLPUBFUN xmlDoc *
+		xmlCtxtParseDocument	(xmlParserCtxt *ctxt,
+					 xmlParserInput *input);
+XMLPUBFUN xmlNode *
+		xmlCtxtParseContent	(xmlParserCtxt *ctxt,
+					 xmlParserInput *input,
+					 xmlNode *node,
 					 int hasTextDecl);
-XMLPUBFUN xmlDocPtr
-		xmlCtxtReadDoc		(xmlParserCtxtPtr ctxt,
+XMLPUBFUN xmlDoc *
+		xmlCtxtReadDoc		(xmlParserCtxt *ctxt,
 					 const xmlChar *cur,
 					 const char *URL,
 					 const char *encoding,
 					 int options);
-XMLPUBFUN xmlDocPtr
-		xmlCtxtReadFile		(xmlParserCtxtPtr ctxt,
+XMLPUBFUN xmlDoc *
+		xmlCtxtReadFile		(xmlParserCtxt *ctxt,
 					 const char *filename,
 					 const char *encoding,
 					 int options);
-XMLPUBFUN xmlDocPtr
-		xmlCtxtReadMemory		(xmlParserCtxtPtr ctxt,
+XMLPUBFUN xmlDoc *
+		xmlCtxtReadMemory		(xmlParserCtxt *ctxt,
 					 const char *buffer,
 					 int size,
 					 const char *URL,
 					 const char *encoding,
 					 int options);
-XMLPUBFUN xmlDocPtr
-		xmlCtxtReadFd		(xmlParserCtxtPtr ctxt,
+XMLPUBFUN xmlDoc *
+		xmlCtxtReadFd		(xmlParserCtxt *ctxt,
 					 int fd,
 					 const char *URL,
 					 const char *encoding,
 					 int options);
-XMLPUBFUN xmlDocPtr
-		xmlCtxtReadIO		(xmlParserCtxtPtr ctxt,
+XMLPUBFUN xmlDoc *
+		xmlCtxtReadIO		(xmlParserCtxt *ctxt,
 					 xmlInputReadCallback ioread,
 					 xmlInputCloseCallback ioclose,
 					 void *ioctx,
@@ -1864,22 +1864,22 @@ XMLPUBFUN xmlDocPtr

 XMLPUBFUN xmlParserErrors
 xmlNewInputFromUrl(const char *url, xmlParserInputFlags flags,
-                   xmlParserInputPtr *out);
-XMLPUBFUN xmlParserInputPtr
+                   xmlParserInput **out);
+XMLPUBFUN xmlParserInput *
 xmlNewInputFromMemory(const char *url, const void *mem, size_t size,
                      xmlParserInputFlags flags);
-XMLPUBFUN xmlParserInputPtr
+XMLPUBFUN xmlParserInput *
 xmlNewInputFromString(const char *url, const char *str,
                      xmlParserInputFlags flags);
-XMLPUBFUN xmlParserInputPtr
+XMLPUBFUN xmlParserInput *
 xmlNewInputFromFd(const char *url, int fd, xmlParserInputFlags flags);
-XMLPUBFUN xmlParserInputPtr
+XMLPUBFUN xmlParserInput *
 xmlNewInputFromIO(const char *url, xmlInputReadCallback ioRead,
                  xmlInputCloseCallback ioClose, void *ioCtxt,
                  xmlParserInputFlags flags);
 XMLPUBFUN xmlParserErrors
-xmlInputSetEncodingHandler(xmlParserInputPtr input,
-                           xmlCharEncodingHandlerPtr handler);
+xmlInputSetEncodingHandler(xmlParserInput *input,
+                           xmlCharEncodingHandler *handler);

 /*
 * Library wide options
--- a/include/libxml/parserInternals.h
+++ b/include/libxml/parserInternals.h
@@ -261,71 +261,71 @@ XMLPUBFUN int                   xmlIsLetter     (int c);
 /*
 * Parser context.
 */
-XMLPUBFUN xmlParserCtxtPtr
+XMLPUBFUN xmlParserCtxt *
 			xmlCreateFileParserCtxt	(const char *filename);
-XMLPUBFUN xmlParserCtxtPtr
+XMLPUBFUN xmlParserCtxt *
 			xmlCreateURLParserCtxt	(const char *filename,
 						 int options);
-XMLPUBFUN xmlParserCtxtPtr
+XMLPUBFUN xmlParserCtxt *
 			xmlCreateMemoryParserCtxt(const char *buffer,
 						 int size);
 XML_DEPRECATED
-XMLPUBFUN xmlParserCtxtPtr
+XMLPUBFUN xmlParserCtxt *
 			xmlCreateEntityParserCtxt(const xmlChar *URL,
 						 const xmlChar *ID,
 						 const xmlChar *base);
 XMLPUBFUN void
-			xmlCtxtErrMemory	(xmlParserCtxtPtr ctxt);
+			xmlCtxtErrMemory	(xmlParserCtxt *ctxt);
 XMLPUBFUN int
-			xmlSwitchEncoding	(xmlParserCtxtPtr ctxt,
+			xmlSwitchEncoding	(xmlParserCtxt *ctxt,
 						 xmlCharEncoding enc);
 XMLPUBFUN int
-			xmlSwitchEncodingName	(xmlParserCtxtPtr ctxt,
+			xmlSwitchEncodingName	(xmlParserCtxt *ctxt,
 						 const char *encoding);
 XMLPUBFUN int
-			xmlSwitchToEncoding	(xmlParserCtxtPtr ctxt,
-					 xmlCharEncodingHandlerPtr handler);
+			xmlSwitchToEncoding	(xmlParserCtxt *ctxt,
+					 xmlCharEncodingHandler *handler);
 XML_DEPRECATED
 XMLPUBFUN int
-			xmlSwitchInputEncoding	(xmlParserCtxtPtr ctxt,
-						 xmlParserInputPtr input,
-					 xmlCharEncodingHandlerPtr handler);
+			xmlSwitchInputEncoding	(xmlParserCtxt *ctxt,
+						 xmlParserInput *input,
+					 xmlCharEncodingHandler *handler);

 /*
 * Input Streams.
 */
-XMLPUBFUN xmlParserInputPtr
-			xmlNewStringInputStream	(xmlParserCtxtPtr ctxt,
+XMLPUBFUN xmlParserInput *
+			xmlNewStringInputStream	(xmlParserCtxt *ctxt,
 						 const xmlChar *buffer);
 XML_DEPRECATED
-XMLPUBFUN xmlParserInputPtr
-			xmlNewEntityInputStream	(xmlParserCtxtPtr ctxt,
-						 xmlEntityPtr entity);
+XMLPUBFUN xmlParserInput *
+			xmlNewEntityInputStream	(xmlParserCtxt *ctxt,
+						 xmlEntity *entity);
 XMLPUBFUN int
-			xmlCtxtPushInput	(xmlParserCtxtPtr ctxt,
-						 xmlParserInputPtr input);
-XMLPUBFUN xmlParserInputPtr
-			xmlCtxtPopInput		(xmlParserCtxtPtr ctxt);
+			xmlCtxtPushInput	(xmlParserCtxt *ctxt,
+						 xmlParserInput *input);
+XMLPUBFUN xmlParserInput *
+			xmlCtxtPopInput		(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN int
-			xmlPushInput		(xmlParserCtxtPtr ctxt,
-						 xmlParserInputPtr input);
+			xmlPushInput		(xmlParserCtxt *ctxt,
+						 xmlParserInput *input);
 XML_DEPRECATED
 XMLPUBFUN xmlChar
-			xmlPopInput		(xmlParserCtxtPtr ctxt);
+			xmlPopInput		(xmlParserCtxt *ctxt);
 XMLPUBFUN void
-			xmlFreeInputStream	(xmlParserInputPtr input);
-XMLPUBFUN xmlParserInputPtr
-			xmlNewInputFromFile	(xmlParserCtxtPtr ctxt,
+			xmlFreeInputStream	(xmlParserInput *input);
+XMLPUBFUN xmlParserInput *
+			xmlNewInputFromFile	(xmlParserCtxt *ctxt,
 						 const char *filename);
-XMLPUBFUN xmlParserInputPtr
-			xmlNewInputStream	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlParserInput *
+			xmlNewInputStream	(xmlParserCtxt *ctxt);

 /*
 * Namespaces.
 */
 XMLPUBFUN xmlChar *
-			xmlSplitQName		(xmlParserCtxtPtr ctxt,
+			xmlSplitQName		(xmlParserCtxt *ctxt,
 						 const xmlChar *name,
 						 xmlChar **prefix);

@@ -334,151 +334,151 @@ XMLPUBFUN xmlChar *
 */
 XML_DEPRECATED
 XMLPUBFUN const xmlChar *
-			xmlParseName		(xmlParserCtxtPtr ctxt);
+			xmlParseName		(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN xmlChar *
-			xmlParseNmtoken		(xmlParserCtxtPtr ctxt);
+			xmlParseNmtoken		(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN xmlChar *
-			xmlParseEntityValue	(xmlParserCtxtPtr ctxt,
+			xmlParseEntityValue	(xmlParserCtxt *ctxt,
 						 xmlChar **orig);
 XML_DEPRECATED
 XMLPUBFUN xmlChar *
-			xmlParseAttValue	(xmlParserCtxtPtr ctxt);
+			xmlParseAttValue	(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN xmlChar *
-			xmlParseSystemLiteral	(xmlParserCtxtPtr ctxt);
+			xmlParseSystemLiteral	(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN xmlChar *
-			xmlParsePubidLiteral	(xmlParserCtxtPtr ctxt);
+			xmlParsePubidLiteral	(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN void
-			xmlParseCharData	(xmlParserCtxtPtr ctxt,
+			xmlParseCharData	(xmlParserCtxt *ctxt,
 						 int cdata);
 XML_DEPRECATED
 XMLPUBFUN xmlChar *
-			xmlParseExternalID	(xmlParserCtxtPtr ctxt,
+			xmlParseExternalID	(xmlParserCtxt *ctxt,
 						 xmlChar **publicID,
 						 int strict);
 XML_DEPRECATED
 XMLPUBFUN void
-			xmlParseComment		(xmlParserCtxtPtr ctxt);
+			xmlParseComment		(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN const xmlChar *
-			xmlParsePITarget	(xmlParserCtxtPtr ctxt);
+			xmlParsePITarget	(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN void
-			xmlParsePI		(xmlParserCtxtPtr ctxt);
+			xmlParsePI		(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN void
-			xmlParseNotationDecl	(xmlParserCtxtPtr ctxt);
+			xmlParseNotationDecl	(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN void
-			xmlParseEntityDecl	(xmlParserCtxtPtr ctxt);
+			xmlParseEntityDecl	(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN int
-			xmlParseDefaultDecl	(xmlParserCtxtPtr ctxt,
+			xmlParseDefaultDecl	(xmlParserCtxt *ctxt,
 						 xmlChar **value);
 XML_DEPRECATED
-XMLPUBFUN xmlEnumerationPtr
-			xmlParseNotationType	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlEnumeration *
+			xmlParseNotationType	(xmlParserCtxt *ctxt);
 XML_DEPRECATED
-XMLPUBFUN xmlEnumerationPtr
-			xmlParseEnumerationType	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlEnumeration *
+			xmlParseEnumerationType	(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN int
-			xmlParseEnumeratedType	(xmlParserCtxtPtr ctxt,
-						 xmlEnumerationPtr *tree);
+			xmlParseEnumeratedType	(xmlParserCtxt *ctxt,
+						 xmlEnumeration **tree);
 XML_DEPRECATED
 XMLPUBFUN int
-			xmlParseAttributeType	(xmlParserCtxtPtr ctxt,
-						 xmlEnumerationPtr *tree);
+			xmlParseAttributeType	(xmlParserCtxt *ctxt,
+						 xmlEnumeration **tree);
 XML_DEPRECATED
 XMLPUBFUN void
-			xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt);
+			xmlParseAttributeListDecl(xmlParserCtxt *ctxt);
 XML_DEPRECATED
-XMLPUBFUN xmlElementContentPtr
+XMLPUBFUN xmlElementContent *
 			xmlParseElementMixedContentDecl
-						(xmlParserCtxtPtr ctxt,
+						(xmlParserCtxt *ctxt,
 						 int inputchk);
 XML_DEPRECATED
-XMLPUBFUN xmlElementContentPtr
+XMLPUBFUN xmlElementContent *
 			xmlParseElementChildrenContentDecl
-						(xmlParserCtxtPtr ctxt,
+						(xmlParserCtxt *ctxt,
 						 int inputchk);
 XML_DEPRECATED
 XMLPUBFUN int
-			xmlParseElementContentDecl(xmlParserCtxtPtr ctxt,
+			xmlParseElementContentDecl(xmlParserCtxt *ctxt,
 						 const xmlChar *name,
-						 xmlElementContentPtr *result);
+						 xmlElementContent **result);
 XML_DEPRECATED
 XMLPUBFUN int
-			xmlParseElementDecl	(xmlParserCtxtPtr ctxt);
+			xmlParseElementDecl	(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN void
-			xmlParseMarkupDecl	(xmlParserCtxtPtr ctxt);
+			xmlParseMarkupDecl	(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN int
-			xmlParseCharRef		(xmlParserCtxtPtr ctxt);
+			xmlParseCharRef		(xmlParserCtxt *ctxt);
 XML_DEPRECATED
-XMLPUBFUN xmlEntityPtr
-			xmlParseEntityRef	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlEntity *
+			xmlParseEntityRef	(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN void
-			xmlParseReference	(xmlParserCtxtPtr ctxt);
+			xmlParseReference	(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN void
-			xmlParsePEReference	(xmlParserCtxtPtr ctxt);
+			xmlParsePEReference	(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN void
-			xmlParseDocTypeDecl	(xmlParserCtxtPtr ctxt);
+			xmlParseDocTypeDecl	(xmlParserCtxt *ctxt);
 #ifdef LIBXML_SAX1_ENABLED
 XML_DEPRECATED
 XMLPUBFUN const xmlChar *
-			xmlParseAttribute	(xmlParserCtxtPtr ctxt,
+			xmlParseAttribute	(xmlParserCtxt *ctxt,
 						 xmlChar **value);
 XML_DEPRECATED
 XMLPUBFUN const xmlChar *
-			xmlParseStartTag	(xmlParserCtxtPtr ctxt);
+			xmlParseStartTag	(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN void
-			xmlParseEndTag		(xmlParserCtxtPtr ctxt);
+			xmlParseEndTag		(xmlParserCtxt *ctxt);
 #endif /* LIBXML_SAX1_ENABLED */
 XML_DEPRECATED
 XMLPUBFUN void
-			xmlParseCDSect		(xmlParserCtxtPtr ctxt);
+			xmlParseCDSect		(xmlParserCtxt *ctxt);
 XMLPUBFUN void
-			xmlParseContent		(xmlParserCtxtPtr ctxt);
+			xmlParseContent		(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN void
-			xmlParseElement		(xmlParserCtxtPtr ctxt);
+			xmlParseElement		(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN xmlChar *
-			xmlParseVersionNum	(xmlParserCtxtPtr ctxt);
+			xmlParseVersionNum	(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN xmlChar *
-			xmlParseVersionInfo	(xmlParserCtxtPtr ctxt);
+			xmlParseVersionInfo	(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN xmlChar *
-			xmlParseEncName		(xmlParserCtxtPtr ctxt);
+			xmlParseEncName		(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN const xmlChar *
-			xmlParseEncodingDecl	(xmlParserCtxtPtr ctxt);
+			xmlParseEncodingDecl	(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN int
-			xmlParseSDDecl		(xmlParserCtxtPtr ctxt);
+			xmlParseSDDecl		(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN void
-			xmlParseXMLDecl		(xmlParserCtxtPtr ctxt);
+			xmlParseXMLDecl		(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN void
-			xmlParseTextDecl	(xmlParserCtxtPtr ctxt);
+			xmlParseTextDecl	(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN void
-			xmlParseMisc		(xmlParserCtxtPtr ctxt);
+			xmlParseMisc		(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN void
-			xmlParseExternalSubset	(xmlParserCtxtPtr ctxt,
+			xmlParseExternalSubset	(xmlParserCtxt *ctxt,
 						 const xmlChar *ExternalID,
 						 const xmlChar *SystemID);

@@ -490,7 +490,7 @@ XMLPUBFUN void
 /** @endcond */
 XML_DEPRECATED
 XMLPUBFUN xmlChar *
-		xmlStringDecodeEntities		(xmlParserCtxtPtr ctxt,
+		xmlStringDecodeEntities		(xmlParserCtxt *ctxt,
 						 const xmlChar *str,
 						 int what,
 						 xmlChar end,
@@ -498,7 +498,7 @@ XMLPUBFUN xmlChar *
 						 xmlChar end3);
 XML_DEPRECATED
 XMLPUBFUN xmlChar *
-		xmlStringLenDecodeEntities	(xmlParserCtxtPtr ctxt,
+		xmlStringLenDecodeEntities	(xmlParserCtxt *ctxt,
 						 const xmlChar *str,
 						 int len,
 						 int what,
@@ -510,13 +510,13 @@ XMLPUBFUN xmlChar *
 * other commodities shared between parser.c and parserInternals.
 */
 XML_DEPRECATED
-XMLPUBFUN int			xmlSkipBlankChars	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN int			xmlSkipBlankChars	(xmlParserCtxt *ctxt);
 XML_DEPRECATED
-XMLPUBFUN int			xmlStringCurrentChar	(xmlParserCtxtPtr ctxt,
+XMLPUBFUN int			xmlStringCurrentChar	(xmlParserCtxt *ctxt,
 						 const xmlChar *cur,
 						 int *len);
 XML_DEPRECATED
-XMLPUBFUN void			xmlParserHandlePEReference(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void			xmlParserHandlePEReference(xmlParserCtxt *ctxt);
 XML_DEPRECATED
 XMLPUBFUN int			xmlCheckLanguageID	(const xmlChar *lang);

@@ -524,7 +524,7 @@ XMLPUBFUN int			xmlCheckLanguageID	(const xmlChar *lang);
 * Really core function shared with HTML parser.
 */
 XML_DEPRECATED
-XMLPUBFUN int			xmlCurrentChar		(xmlParserCtxtPtr ctxt,
+XMLPUBFUN int			xmlCurrentChar		(xmlParserCtxt *ctxt,
 						 int *len);
 XML_DEPRECATED
 XMLPUBFUN int		xmlCopyCharMultiByte	(xmlChar *out,
@@ -534,9 +534,9 @@ XMLPUBFUN int			xmlCopyChar		(int len,
 						 xmlChar *out,
 						 int val);
 XML_DEPRECATED
-XMLPUBFUN void			xmlNextChar		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void			xmlNextChar		(xmlParserCtxt *ctxt);
 XML_DEPRECATED
-XMLPUBFUN void			xmlParserInputShrink	(xmlParserInputPtr in);
+XMLPUBFUN void			xmlParserInputShrink	(xmlParserInput *in);

 #ifdef __cplusplus
 }
--- a/include/libxml/pattern.h
+++ b/include/libxml/pattern.h
@@ -42,12 +42,12 @@ typedef enum {
 } xmlPatternFlags;

 XMLPUBFUN void
-			xmlFreePattern		(xmlPatternPtr comp);
+			xmlFreePattern		(xmlPattern *comp);

 XMLPUBFUN void
-			xmlFreePatternList	(xmlPatternPtr comp);
+			xmlFreePatternList	(xmlPattern *comp);

-XMLPUBFUN xmlPatternPtr
+XMLPUBFUN xmlPattern *
 			xmlPatterncompile	(const xmlChar *pattern,
 						 xmlDict *dict,
 						 int flags,
@@ -57,44 +57,44 @@ XMLPUBFUN int
 						 xmlDict *dict,
 						 int flags,
 						 const xmlChar **namespaces,
-						 xmlPatternPtr *patternOut);
+						 xmlPattern **patternOut);
 XMLPUBFUN int
-			xmlPatternMatch		(xmlPatternPtr comp,
-						 xmlNodePtr node);
+			xmlPatternMatch		(xmlPattern *comp,
+						 xmlNode *node);

 /* streaming interfaces */
 typedef struct _xmlStreamCtxt xmlStreamCtxt;
 typedef xmlStreamCtxt *xmlStreamCtxtPtr;

 XMLPUBFUN int
-			xmlPatternStreamable	(xmlPatternPtr comp);
+			xmlPatternStreamable	(xmlPattern *comp);
 XMLPUBFUN int
-			xmlPatternMaxDepth	(xmlPatternPtr comp);
+			xmlPatternMaxDepth	(xmlPattern *comp);
 XMLPUBFUN int
-			xmlPatternMinDepth	(xmlPatternPtr comp);
+			xmlPatternMinDepth	(xmlPattern *comp);
 XMLPUBFUN int
-			xmlPatternFromRoot	(xmlPatternPtr comp);
-XMLPUBFUN xmlStreamCtxtPtr
-			xmlPatternGetStreamCtxt	(xmlPatternPtr comp);
+			xmlPatternFromRoot	(xmlPattern *comp);
+XMLPUBFUN xmlStreamCtxt *
+			xmlPatternGetStreamCtxt	(xmlPattern *comp);
 XMLPUBFUN void
-			xmlFreeStreamCtxt	(xmlStreamCtxtPtr stream);
+			xmlFreeStreamCtxt	(xmlStreamCtxt *stream);
 XMLPUBFUN int
-			xmlStreamPushNode	(xmlStreamCtxtPtr stream,
+			xmlStreamPushNode	(xmlStreamCtxt *stream,
 						 const xmlChar *name,
 						 const xmlChar *ns,
 						 int nodeType);
 XMLPUBFUN int
-			xmlStreamPush		(xmlStreamCtxtPtr stream,
+			xmlStreamPush		(xmlStreamCtxt *stream,
 						 const xmlChar *name,
 						 const xmlChar *ns);
 XMLPUBFUN int
-			xmlStreamPushAttr	(xmlStreamCtxtPtr stream,
+			xmlStreamPushAttr	(xmlStreamCtxt *stream,
 						 const xmlChar *name,
 						 const xmlChar *ns);
 XMLPUBFUN int
-			xmlStreamPop		(xmlStreamCtxtPtr stream);
+			xmlStreamPop		(xmlStreamCtxt *stream);
 XMLPUBFUN int
-			xmlStreamWantsAnyNode	(xmlStreamCtxtPtr stream);
+			xmlStreamWantsAnyNode	(xmlStreamCtxt *stream);
 #ifdef __cplusplus
 }
 #endif
--- a/include/libxml/relaxng.h
+++ b/include/libxml/relaxng.h
@@ -124,93 +124,93 @@ XMLPUBFUN void
 /*
 * Interfaces for parsing.
 */
-XMLPUBFUN xmlRelaxNGParserCtxtPtr
+XMLPUBFUN xmlRelaxNGParserCtxt *
 		    xmlRelaxNGNewParserCtxt	(const char *URL);
-XMLPUBFUN xmlRelaxNGParserCtxtPtr
+XMLPUBFUN xmlRelaxNGParserCtxt *
 		    xmlRelaxNGNewMemParserCtxt	(const char *buffer,
 						 int size);
-XMLPUBFUN xmlRelaxNGParserCtxtPtr
-		    xmlRelaxNGNewDocParserCtxt	(xmlDocPtr doc);
+XMLPUBFUN xmlRelaxNGParserCtxt *
+		    xmlRelaxNGNewDocParserCtxt	(xmlDoc *doc);

 XMLPUBFUN int
-		    xmlRelaxParserSetFlag	(xmlRelaxNGParserCtxtPtr ctxt,
+		    xmlRelaxParserSetFlag	(xmlRelaxNGParserCtxt *ctxt,
 						 int flag);

 XMLPUBFUN void
-		    xmlRelaxNGFreeParserCtxt	(xmlRelaxNGParserCtxtPtr ctxt);
+		    xmlRelaxNGFreeParserCtxt	(xmlRelaxNGParserCtxt *ctxt);
 XMLPUBFUN void
-		    xmlRelaxNGSetParserErrors(xmlRelaxNGParserCtxtPtr ctxt,
+		    xmlRelaxNGSetParserErrors(xmlRelaxNGParserCtxt *ctxt,
 					 xmlRelaxNGValidityErrorFunc err,
 					 xmlRelaxNGValidityWarningFunc warn,
 					 void *ctx);
 XMLPUBFUN int
-		    xmlRelaxNGGetParserErrors(xmlRelaxNGParserCtxtPtr ctxt,
+		    xmlRelaxNGGetParserErrors(xmlRelaxNGParserCtxt *ctxt,
 					 xmlRelaxNGValidityErrorFunc *err,
 					 xmlRelaxNGValidityWarningFunc *warn,
 					 void **ctx);
 XMLPUBFUN void
 		    xmlRelaxNGSetParserStructuredErrors(
-					 xmlRelaxNGParserCtxtPtr ctxt,
+					 xmlRelaxNGParserCtxt *ctxt,
 					 xmlStructuredErrorFunc serror,
 					 void *ctx);
 XMLPUBFUN void
-		    xmlRelaxNGSetResourceLoader	(xmlRelaxNGParserCtxtPtr ctxt,
+		    xmlRelaxNGSetResourceLoader	(xmlRelaxNGParserCtxt *ctxt,
 						 xmlResourceLoader loader,
 						 void *vctxt);
-XMLPUBFUN xmlRelaxNGPtr
-		    xmlRelaxNGParse		(xmlRelaxNGParserCtxtPtr ctxt);
+XMLPUBFUN xmlRelaxNG *
+		    xmlRelaxNGParse		(xmlRelaxNGParserCtxt *ctxt);
 XMLPUBFUN void
-		    xmlRelaxNGFree		(xmlRelaxNGPtr schema);
+		    xmlRelaxNGFree		(xmlRelaxNG *schema);
 #ifdef LIBXML_OUTPUT_ENABLED
 XMLPUBFUN void
 		    xmlRelaxNGDump		(FILE *output,
-					 xmlRelaxNGPtr schema);
+					 xmlRelaxNG *schema);
 XMLPUBFUN void
 		    xmlRelaxNGDumpTree	(FILE * output,
-					 xmlRelaxNGPtr schema);
+					 xmlRelaxNG *schema);
 #endif /* LIBXML_OUTPUT_ENABLED */
 /*
 * Interfaces for validating
 */
 XMLPUBFUN void
-		    xmlRelaxNGSetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
+		    xmlRelaxNGSetValidErrors(xmlRelaxNGValidCtxt *ctxt,
 					 xmlRelaxNGValidityErrorFunc err,
 					 xmlRelaxNGValidityWarningFunc warn,
 					 void *ctx);
 XMLPUBFUN int
-		    xmlRelaxNGGetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
+		    xmlRelaxNGGetValidErrors(xmlRelaxNGValidCtxt *ctxt,
 					 xmlRelaxNGValidityErrorFunc *err,
 					 xmlRelaxNGValidityWarningFunc *warn,
 					 void **ctx);
 XMLPUBFUN void
-			xmlRelaxNGSetValidStructuredErrors(xmlRelaxNGValidCtxtPtr ctxt,
+			xmlRelaxNGSetValidStructuredErrors(xmlRelaxNGValidCtxt *ctxt,
 					  xmlStructuredErrorFunc serror, void *ctx);
-XMLPUBFUN xmlRelaxNGValidCtxtPtr
-		    xmlRelaxNGNewValidCtxt	(xmlRelaxNGPtr schema);
+XMLPUBFUN xmlRelaxNGValidCtxt *
+		    xmlRelaxNGNewValidCtxt	(xmlRelaxNG *schema);
 XMLPUBFUN void
-		    xmlRelaxNGFreeValidCtxt	(xmlRelaxNGValidCtxtPtr ctxt);
+		    xmlRelaxNGFreeValidCtxt	(xmlRelaxNGValidCtxt *ctxt);
 XMLPUBFUN int
-		    xmlRelaxNGValidateDoc	(xmlRelaxNGValidCtxtPtr ctxt,
-						 xmlDocPtr doc);
+		    xmlRelaxNGValidateDoc	(xmlRelaxNGValidCtxt *ctxt,
+						 xmlDoc *doc);
 /*
 * Interfaces for progressive validation when possible
 */
 XMLPUBFUN int
-		    xmlRelaxNGValidatePushElement	(xmlRelaxNGValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
-					 xmlNodePtr elem);
+		    xmlRelaxNGValidatePushElement	(xmlRelaxNGValidCtxt *ctxt,
+					 xmlDoc *doc,
+					 xmlNode *elem);
 XMLPUBFUN int
-		    xmlRelaxNGValidatePushCData	(xmlRelaxNGValidCtxtPtr ctxt,
+		    xmlRelaxNGValidatePushCData	(xmlRelaxNGValidCtxt *ctxt,
 					 const xmlChar *data,
 					 int len);
 XMLPUBFUN int
-		    xmlRelaxNGValidatePopElement	(xmlRelaxNGValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
-					 xmlNodePtr elem);
+		    xmlRelaxNGValidatePopElement	(xmlRelaxNGValidCtxt *ctxt,
+					 xmlDoc *doc,
+					 xmlNode *elem);
 XMLPUBFUN int
-		    xmlRelaxNGValidateFullElement	(xmlRelaxNGValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
-					 xmlNodePtr elem);
+		    xmlRelaxNGValidateFullElement	(xmlRelaxNGValidCtxt *ctxt,
+					 xmlDoc *doc,
+					 xmlNode *elem);

 #ifdef __cplusplus
 }
--- a/include/libxml/schemasInternals.h
+++ b/include/libxml/schemasInternals.h
@@ -159,7 +159,7 @@ typedef xmlSchemaAnnot *xmlSchemaAnnotPtr;
 */
 struct _xmlSchemaAnnot {
    struct _xmlSchemaAnnot *next;
-    xmlNodePtr content;         /* the annotation */
+    xmlNode *content;         /* the annotation */
 };

 /**
@@ -236,18 +236,18 @@ struct _xmlSchemaAttribute {
    const xmlChar *refNs; /* Deprecated; not used */
    const xmlChar *typeName; /* the local name of the type definition */
    const xmlChar *typeNs; /* the ns URI of the type definition */
-    xmlSchemaAnnotPtr annot;
+    xmlSchemaAnnot *annot;

-    xmlSchemaTypePtr base; /* Deprecated; not used */
+    xmlSchemaType *base; /* Deprecated; not used */
    int occurs; /* Deprecated; not used */
    const xmlChar *defValue; /* The initial value of the value constraint */
-    xmlSchemaTypePtr subtypes; /* the type definition */
-    xmlNodePtr node;
+    xmlSchemaType *subtypes; /* the type definition */
+    xmlNode *node;
    const xmlChar *targetNamespace;
    int flags;
    const xmlChar *refPrefix; /* Deprecated; not used */
-    xmlSchemaValPtr defVal; /* The compiled value constraint */
-    xmlSchemaAttributePtr refDecl; /* Deprecated; not used */
+    xmlSchemaVal *defVal; /* The compiled value constraint */
+    xmlSchemaAttribute *refDecl; /* Deprecated; not used */
 };

 typedef struct _xmlSchemaAttributeLink xmlSchemaAttributeLink;
@@ -284,14 +284,14 @@ typedef xmlSchemaWildcard *xmlSchemaWildcardPtr;
 struct _xmlSchemaWildcard {
    xmlSchemaTypeType type;        /* The kind of type */
    const xmlChar *id; /* Deprecated; not used */
-    xmlSchemaAnnotPtr annot;
-    xmlNodePtr node;
+    xmlSchemaAnnot *annot;
+    xmlNode *node;
    int minOccurs; /* Deprecated; not used */
    int maxOccurs; /* Deprecated; not used */
    int processContents;
    int any; /* Indicates if the ns constraint is of ##any */
-    xmlSchemaWildcardNsPtr nsSet; /* The list of allowed namespaces */
-    xmlSchemaWildcardNsPtr negNsSet; /* The negated namespace */
+    xmlSchemaWildcardNs *nsSet; /* The list of allowed namespaces */
+    xmlSchemaWildcardNs *negNsSet; /* The negated namespace */
    int flags;
 };

@@ -332,14 +332,14 @@ struct _xmlSchemaAttributeGroup {
    const xmlChar *id;
    const xmlChar *ref; /* Deprecated; not used */
    const xmlChar *refNs; /* Deprecated; not used */
-    xmlSchemaAnnotPtr annot;
+    xmlSchemaAnnot *annot;

-    xmlSchemaAttributePtr attributes; /* Deprecated; not used */
-    xmlNodePtr node;
+    xmlSchemaAttribute *attributes; /* Deprecated; not used */
+    xmlNode *node;
    int flags;
-    xmlSchemaWildcardPtr attributeWildcard;
+    xmlSchemaWildcard *attributeWildcard;
    const xmlChar *refPrefix; /* Deprecated; not used */
-    xmlSchemaAttributeGroupPtr refItem; /* Deprecated; not used */
+    xmlSchemaAttributeGroup *refItem; /* Deprecated; not used */
    const xmlChar *targetNamespace;
    void *attrUses;
 };
@@ -352,7 +352,7 @@ typedef xmlSchemaTypeLink *xmlSchemaTypeLinkPtr;
 */
 struct _xmlSchemaTypeLink {
    struct _xmlSchemaTypeLink *next;/* the next type link ... */
-    xmlSchemaTypePtr type;/* the linked type */
+    xmlSchemaType *type;/* the linked type */
 };

 typedef struct _xmlSchemaFacetLink xmlSchemaFacetLink;
@@ -362,7 +362,7 @@ typedef xmlSchemaFacetLink *xmlSchemaFacetLinkPtr;
 */
 struct _xmlSchemaFacetLink {
    struct _xmlSchemaFacetLink *next;/* the next facet link ... */
-    xmlSchemaFacetPtr facet;/* the linked facet */
+    xmlSchemaFacet *facet;/* the linked facet */
 };

 /**
@@ -509,10 +509,10 @@ struct _xmlSchemaType {
    const xmlChar *id ; /* Deprecated; not used */
    const xmlChar *ref; /* Deprecated; not used */
    const xmlChar *refNs; /* Deprecated; not used */
-    xmlSchemaAnnotPtr annot;
-    xmlSchemaTypePtr subtypes;
-    xmlSchemaAttributePtr attributes; /* Deprecated; not used */
-    xmlNodePtr node;
+    xmlSchemaAnnot *annot;
+    xmlSchemaType *subtypes;
+    xmlSchemaAttribute *attributes; /* Deprecated; not used */
+    xmlNode *node;
    int minOccurs; /* Deprecated; not used */
    int maxOccurs; /* Deprecated; not used */

@@ -520,19 +520,19 @@ struct _xmlSchemaType {
    xmlSchemaContentType contentType;
    const xmlChar *base; /* Base type's local name */
    const xmlChar *baseNs; /* Base type's target namespace */
-    xmlSchemaTypePtr baseType; /* The base type component */
-    xmlSchemaFacetPtr facets; /* Local facets */
+    xmlSchemaType *baseType; /* The base type component */
+    xmlSchemaFacet *facets; /* Local facets */
    struct _xmlSchemaType *redef; /* Deprecated; not used */
    int recurse; /* Obsolete */
-    xmlSchemaAttributeLinkPtr *attributeUses; /* Deprecated; not used */
-    xmlSchemaWildcardPtr attributeWildcard;
+    xmlSchemaAttributeLink **attributeUses; /* Deprecated; not used */
+    xmlSchemaWildcard *attributeWildcard;
    int builtInType; /* Type of built-in types. */
-    xmlSchemaTypeLinkPtr memberTypes; /* member-types if a union type. */
-    xmlSchemaFacetLinkPtr facetSet; /* All facets (incl. inherited) */
+    xmlSchemaTypeLink *memberTypes; /* member-types if a union type. */
+    xmlSchemaFacetLink *facetSet; /* All facets (incl. inherited) */
    const xmlChar *refPrefix; /* Deprecated; not used */
-    xmlSchemaTypePtr contentTypeDef; /* Used for the simple content of complex types.
+    xmlSchemaType *contentTypeDef; /* Used for the simple content of complex types.
                                        Could we use @subtypes for this? */
-    xmlRegexpPtr contModel; /* Holds the automaton of the content model */
+    xmlRegexp *contModel; /* Holds the automaton of the content model */
    const xmlChar *targetNamespace;
    void *attrUses;
 };
@@ -633,10 +633,10 @@ struct _xmlSchemaElement {
    const xmlChar *id; /* Deprecated; not used */
    const xmlChar *ref; /* Deprecated; not used */
    const xmlChar *refNs; /* Deprecated; not used */
-    xmlSchemaAnnotPtr annot;
-    xmlSchemaTypePtr subtypes; /* the type definition */
-    xmlSchemaAttributePtr attributes;
-    xmlNodePtr node;
+    xmlSchemaAnnot *annot;
+    xmlSchemaType *subtypes; /* the type definition */
+    xmlSchemaAttribute *attributes;
+    xmlNode *node;
    int minOccurs; /* Deprecated; not used */
    int maxOccurs; /* Deprecated; not used */

@@ -650,10 +650,10 @@ struct _xmlSchemaElement {
    const xmlChar *value; /* The original value of the value constraint. */
    struct _xmlSchemaElement *refDecl; /* This will now be used for the
                                          substitution group affiliation */
-    xmlRegexpPtr contModel; /* Obsolete for WXS, maybe used for RelaxNG */
+    xmlRegexp *contModel; /* Obsolete for WXS, maybe used for RelaxNG */
    xmlSchemaContentType contentType;
    const xmlChar *refPrefix; /* Deprecated; not used */
-    xmlSchemaValPtr defVal; /* The compiled value constraint. */
+    xmlSchemaVal *defVal; /* The compiled value constraint. */
    void *idcs; /* The identity-constraint defs */
 };

@@ -681,12 +681,12 @@ struct _xmlSchemaFacet {
    struct _xmlSchemaFacet *next;/* the next type if in a sequence ... */
    const xmlChar *value; /* The original value */
    const xmlChar *id; /* Obsolete */
-    xmlSchemaAnnotPtr annot;
-    xmlNodePtr node;
+    xmlSchemaAnnot *annot;
+    xmlNode *node;
    int fixed; /* XML_SCHEMAS_FACET_PRESERVE, etc. */
    int whitespace;
-    xmlSchemaValPtr val; /* The compiled value */
-    xmlRegexpPtr    regexp; /* The regex for patterns */
+    xmlSchemaVal *val; /* The compiled value */
+    xmlRegexp      *regexp; /* The regex for patterns */
 };

 typedef struct _xmlSchemaNotation xmlSchemaNotation;
@@ -697,7 +697,7 @@ typedef xmlSchemaNotation *xmlSchemaNotationPtr;
 struct _xmlSchemaNotation {
    xmlSchemaTypeType type; /* The kind of type */
    const xmlChar *name;
-    xmlSchemaAnnotPtr annot;
+    xmlSchemaAnnot *annot;
    const xmlChar *identifier;
    const xmlChar *targetNamespace;
 };
@@ -759,30 +759,30 @@ struct _xmlSchema {
    const xmlChar *targetNamespace; /* the target namespace */
    const xmlChar *version;
    const xmlChar *id; /* Obsolete */
-    xmlDocPtr doc;
-    xmlSchemaAnnotPtr annot;
+    xmlDoc *doc;
+    xmlSchemaAnnot *annot;
    int flags;

-    xmlHashTablePtr typeDecl;
-    xmlHashTablePtr attrDecl;
-    xmlHashTablePtr attrgrpDecl;
-    xmlHashTablePtr elemDecl;
-    xmlHashTablePtr notaDecl;
+    xmlHashTable *typeDecl;
+    xmlHashTable *attrDecl;
+    xmlHashTable *attrgrpDecl;
+    xmlHashTable *elemDecl;
+    xmlHashTable *notaDecl;

-    xmlHashTablePtr schemasImports;
+    xmlHashTable *schemasImports;

    void *_private;        /* unused by the library for users or bindings */
-    xmlHashTablePtr groupDecl;
-    xmlDictPtr      dict;
+    xmlHashTable *groupDecl;
+    xmlDict        *dict;
    void *includes;     /* the includes, this is opaque for now */
    int preserve;        /* whether to free the document */
    int counter; /* used to give anonymous components unique names */
-    xmlHashTablePtr idcDef; /* All identity-constraint defs. */
+    xmlHashTable *idcDef; /* All identity-constraint defs. */
    void *volatiles; /* Obsolete */
 };

-XMLPUBFUN void         xmlSchemaFreeType        (xmlSchemaTypePtr type);
-XMLPUBFUN void         xmlSchemaFreeWildcard(xmlSchemaWildcardPtr wildcard);
+XMLPUBFUN void         xmlSchemaFreeType        (xmlSchemaType *type);
+XMLPUBFUN void         xmlSchemaFreeWildcard(xmlSchemaWildcard *wildcard);

 #ifdef __cplusplus
 }
--- a/include/libxml/schematron.h
+++ b/include/libxml/schematron.h
@@ -81,70 +81,70 @@ typedef xmlSchematronValidCtxt *xmlSchematronValidCtxtPtr;
 /*
 * Interfaces for parsing.
 */
-XMLPUBFUN xmlSchematronParserCtxtPtr
+XMLPUBFUN xmlSchematronParserCtxt *
 	    xmlSchematronNewParserCtxt	(const char *URL);
-XMLPUBFUN xmlSchematronParserCtxtPtr
+XMLPUBFUN xmlSchematronParserCtxt *
 	    xmlSchematronNewMemParserCtxt(const char *buffer,
 					 int size);
-XMLPUBFUN xmlSchematronParserCtxtPtr
-	    xmlSchematronNewDocParserCtxt(xmlDocPtr doc);
+XMLPUBFUN xmlSchematronParserCtxt *
+	    xmlSchematronNewDocParserCtxt(xmlDoc *doc);
 XMLPUBFUN void
-	    xmlSchematronFreeParserCtxt	(xmlSchematronParserCtxtPtr ctxt);
+	    xmlSchematronFreeParserCtxt	(xmlSchematronParserCtxt *ctxt);
 /*****
 XMLPUBFUN void
-	    xmlSchematronSetParserErrors(xmlSchematronParserCtxtPtr ctxt,
+	    xmlSchematronSetParserErrors(xmlSchematronParserCtxt *ctxt,
 					 xmlSchematronValidityErrorFunc err,
 					 xmlSchematronValidityWarningFunc warn,
 					 void *ctx);
 XMLPUBFUN int
-		xmlSchematronGetParserErrors(xmlSchematronParserCtxtPtr ctxt,
+		xmlSchematronGetParserErrors(xmlSchematronParserCtxt *ctxt,
 					xmlSchematronValidityErrorFunc * err,
 					xmlSchematronValidityWarningFunc * warn,
 					void **ctx);
 XMLPUBFUN int
-		xmlSchematronIsValid	(xmlSchematronValidCtxtPtr ctxt);
+		xmlSchematronIsValid	(xmlSchematronValidCtxt *ctxt);
 *****/
-XMLPUBFUN xmlSchematronPtr
-	    xmlSchematronParse		(xmlSchematronParserCtxtPtr ctxt);
+XMLPUBFUN xmlSchematron *
+	    xmlSchematronParse		(xmlSchematronParserCtxt *ctxt);
 XMLPUBFUN void
-	    xmlSchematronFree		(xmlSchematronPtr schema);
+	    xmlSchematronFree		(xmlSchematron *schema);
 /*
 * Interfaces for validating
 */
 XMLPUBFUN void
 	    xmlSchematronSetValidStructuredErrors(
-	                                  xmlSchematronValidCtxtPtr ctxt,
+	                                  xmlSchematronValidCtxt *ctxt,
 					  xmlStructuredErrorFunc serror,
 					  void *ctx);
 /******
 XMLPUBFUN void
-	    xmlSchematronSetValidErrors	(xmlSchematronValidCtxtPtr ctxt,
+	    xmlSchematronSetValidErrors	(xmlSchematronValidCtxt *ctxt,
 					 xmlSchematronValidityErrorFunc err,
 					 xmlSchematronValidityWarningFunc warn,
 					 void *ctx);
 XMLPUBFUN int
-	    xmlSchematronGetValidErrors	(xmlSchematronValidCtxtPtr ctxt,
+	    xmlSchematronGetValidErrors	(xmlSchematronValidCtxt *ctxt,
 					 xmlSchematronValidityErrorFunc *err,
 					 xmlSchematronValidityWarningFunc *warn,
 					 void **ctx);
 XMLPUBFUN int
-	    xmlSchematronSetValidOptions(xmlSchematronValidCtxtPtr ctxt,
+	    xmlSchematronSetValidOptions(xmlSchematronValidCtxt *ctxt,
 					 int options);
 XMLPUBFUN int
-	    xmlSchematronValidCtxtGetOptions(xmlSchematronValidCtxtPtr ctxt);
+	    xmlSchematronValidCtxtGetOptions(xmlSchematronValidCtxt *ctxt);
 XMLPUBFUN int
-            xmlSchematronValidateOneElement (xmlSchematronValidCtxtPtr ctxt,
-			                 xmlNodePtr elem);
+            xmlSchematronValidateOneElement (xmlSchematronValidCtxt *ctxt,
+			                 xmlNode *elem);
 *******/

-XMLPUBFUN xmlSchematronValidCtxtPtr
-	    xmlSchematronNewValidCtxt	(xmlSchematronPtr schema,
+XMLPUBFUN xmlSchematronValidCtxt *
+	    xmlSchematronNewValidCtxt	(xmlSchematron *schema,
 					 int options);
 XMLPUBFUN void
-	    xmlSchematronFreeValidCtxt	(xmlSchematronValidCtxtPtr ctxt);
+	    xmlSchematronFreeValidCtxt	(xmlSchematronValidCtxt *ctxt);
 XMLPUBFUN int
-	    xmlSchematronValidateDoc	(xmlSchematronValidCtxtPtr ctxt,
-					 xmlDocPtr instance);
+	    xmlSchematronValidateDoc	(xmlSchematronValidCtxt *ctxt,
+					 xmlDoc *instance);

 #ifdef __cplusplus
 }
--- a/include/libxml/threads.h
+++ b/include/libxml/threads.h
@@ -35,23 +35,23 @@ typedef xmlRMutex *xmlRMutexPtr;
 XMLPUBFUN int
 			xmlCheckThreadLocalStorage(void);

-XMLPUBFUN xmlMutexPtr
+XMLPUBFUN xmlMutex *
 			xmlNewMutex	(void);
 XMLPUBFUN void
-			xmlMutexLock	(xmlMutexPtr tok);
+			xmlMutexLock	(xmlMutex *tok);
 XMLPUBFUN void
-			xmlMutexUnlock	(xmlMutexPtr tok);
+			xmlMutexUnlock	(xmlMutex *tok);
 XMLPUBFUN void
-			xmlFreeMutex	(xmlMutexPtr tok);
+			xmlFreeMutex	(xmlMutex *tok);

-XMLPUBFUN xmlRMutexPtr
+XMLPUBFUN xmlRMutex *
 			xmlNewRMutex	(void);
 XMLPUBFUN void
-			xmlRMutexLock	(xmlRMutexPtr tok);
+			xmlRMutexLock	(xmlRMutex *tok);
 XMLPUBFUN void
-			xmlRMutexUnlock	(xmlRMutexPtr tok);
+			xmlRMutexUnlock	(xmlRMutex *tok);
 XMLPUBFUN void
-			xmlFreeRMutex	(xmlRMutexPtr tok);
+			xmlFreeRMutex	(xmlRMutex *tok);

 /*
 * Library wide APIs.
--- a/include/libxml/tree.h
+++ b/include/libxml/tree.h
@@ -273,7 +273,7 @@ struct _xmlAttribute {
    /** default value */
    const xmlChar  *defaultValue;
    /** enumeration tree if any */
-    xmlEnumerationPtr       tree;
+    xmlEnumeration         *tree;
    /** namespace prefix if any */
    const xmlChar        *prefix;
    /** element name */
@@ -362,14 +362,14 @@ struct _xmlElement {
    /** element type */
    xmlElementTypeVal      etype;
    /** allowed element content */
-    xmlElementContentPtr content;
+    xmlElementContent *content;
    /** list of declared attributes */
-    xmlAttributePtr   attributes;
+    xmlAttribute     *attributes;
    /** namespace prefix if any */
    const xmlChar        *prefix;
 #ifdef LIBXML_REGEXP_ENABLED
    /** validating regexp */
-    xmlRegexpPtr       contModel;
+    xmlRegexp         *contModel;
 #else
    void	      *contModel;
 #endif
@@ -499,7 +499,7 @@ struct _xmlID {
    /* The ID name */
    const xmlChar    *value;
    /* The attribute holding it */
-    xmlAttrPtr        attr;
+    xmlAttr          *attr;
    /* The attribute if attr is not available */
    const xmlChar    *name;
    /* The line number if attr is not available */
@@ -517,7 +517,7 @@ typedef xmlRef *xmlRefPtr;
 struct _xmlRef {
    struct _xmlRef    *next;	/* next Ref */
    const xmlChar     *value;	/* The Ref name */
-    xmlAttrPtr        attr;	/* The attribute holding it */
+    xmlAttr          *attr;	/* The attribute holding it */
    const xmlChar    *name;	/* The attribute if attr is not available */
    int               lineno;	/* The line number if attr is not available */
 };
@@ -678,10 +678,10 @@ typedef xmlDOMWrapCtxt *xmlDOMWrapCtxtPtr;
 * @param node  the context node (element or attribute)
 * @param nsName  the requested namespace name
 * @param nsPrefix  the requested namespace prefix
- * @returns an xmlNsPtr or NULL in case of an error.
+ * @returns an xmlNs or NULL in case of an error.
 */
-typedef xmlNsPtr (*xmlDOMWrapAcquireNsFunction) (xmlDOMWrapCtxtPtr ctxt,
-						 xmlNodePtr node,
+typedef xmlNs *(*xmlDOMWrapAcquireNsFunction) (xmlDOMWrapCtxt *ctxt,
+						 xmlNode *node,
 						 const xmlChar *nsName,
 						 const xmlChar *nsPrefix);

@@ -700,7 +700,7 @@ struct _xmlDOMWrapCtxt {
    */
    void * namespaceMap;
    /*
-    * Use this one to acquire an xmlNsPtr intended for node->ns.
+    * Use this one to acquire an xmlNs intended for node->ns.
    * (Note that this is not intended for elem->nsDef).
    */
    xmlDOMWrapAcquireNsFunction getNsForNodeFunc;
@@ -711,14 +711,14 @@ struct _xmlDOMWrapCtxt {
 *
 * @param node  the current node
 */
-typedef void (*xmlRegisterNodeFunc) (xmlNodePtr node);
+typedef void (*xmlRegisterNodeFunc) (xmlNode *node);

 /**
 * Signature for the deregistration callback of a discarded node
 *
 * @param node  the current node
 */
-typedef void (*xmlDeregisterNodeFunc) (xmlNodePtr node);
+typedef void (*xmlDeregisterNodeFunc) (xmlNode *node);

 /**
 * Macro for compatibility naming layer with libxml1. Maps
@@ -788,147 +788,147 @@ XMLPUBFUN const xmlChar *
 /*
 * Creating/freeing new structures.
 */
-XMLPUBFUN xmlDtdPtr
-		xmlCreateIntSubset	(xmlDocPtr doc,
+XMLPUBFUN xmlDtd *
+		xmlCreateIntSubset	(xmlDoc *doc,
 					 const xmlChar *name,
 					 const xmlChar *ExternalID,
 					 const xmlChar *SystemID);
-XMLPUBFUN xmlDtdPtr
-		xmlNewDtd		(xmlDocPtr doc,
+XMLPUBFUN xmlDtd *
+		xmlNewDtd		(xmlDoc *doc,
 					 const xmlChar *name,
 					 const xmlChar *ExternalID,
 					 const xmlChar *SystemID);
-XMLPUBFUN xmlDtdPtr
+XMLPUBFUN xmlDtd *
 		xmlGetIntSubset		(const xmlDoc *doc);
 XMLPUBFUN void
-		xmlFreeDtd		(xmlDtdPtr cur);
-XMLPUBFUN xmlNsPtr
-		xmlNewNs		(xmlNodePtr node,
+		xmlFreeDtd		(xmlDtd *cur);
+XMLPUBFUN xmlNs *
+		xmlNewNs		(xmlNode *node,
 					 const xmlChar *href,
 					 const xmlChar *prefix);
 XMLPUBFUN void
-		xmlFreeNs		(xmlNsPtr cur);
+		xmlFreeNs		(xmlNs *cur);
 XMLPUBFUN void
-		xmlFreeNsList		(xmlNsPtr cur);
-XMLPUBFUN xmlDocPtr
+		xmlFreeNsList		(xmlNs *cur);
+XMLPUBFUN xmlDoc *
 		xmlNewDoc		(const xmlChar *version);
 XMLPUBFUN void
-		xmlFreeDoc		(xmlDocPtr cur);
-XMLPUBFUN xmlAttrPtr
-		xmlNewDocProp		(xmlDocPtr doc,
+		xmlFreeDoc		(xmlDoc *cur);
+XMLPUBFUN xmlAttr *
+		xmlNewDocProp		(xmlDoc *doc,
 					 const xmlChar *name,
 					 const xmlChar *value);
-XMLPUBFUN xmlAttrPtr
-		xmlNewProp		(xmlNodePtr node,
+XMLPUBFUN xmlAttr *
+		xmlNewProp		(xmlNode *node,
 					 const xmlChar *name,
 					 const xmlChar *value);
-XMLPUBFUN xmlAttrPtr
-		xmlNewNsProp		(xmlNodePtr node,
-					 xmlNsPtr ns,
+XMLPUBFUN xmlAttr *
+		xmlNewNsProp		(xmlNode *node,
+					 xmlNs *ns,
 					 const xmlChar *name,
 					 const xmlChar *value);
-XMLPUBFUN xmlAttrPtr
-		xmlNewNsPropEatName	(xmlNodePtr node,
-					 xmlNsPtr ns,
+XMLPUBFUN xmlAttr *
+		xmlNewNsPropEatName	(xmlNode *node,
+					 xmlNs *ns,
 					 xmlChar *name,
 					 const xmlChar *value);
 XMLPUBFUN void
-		xmlFreePropList		(xmlAttrPtr cur);
+		xmlFreePropList		(xmlAttr *cur);
 XMLPUBFUN void
-		xmlFreeProp		(xmlAttrPtr cur);
-XMLPUBFUN xmlAttrPtr
-		xmlCopyProp		(xmlNodePtr target,
-					 xmlAttrPtr cur);
-XMLPUBFUN xmlAttrPtr
-		xmlCopyPropList		(xmlNodePtr target,
-					 xmlAttrPtr cur);
-XMLPUBFUN xmlDtdPtr
-		xmlCopyDtd		(xmlDtdPtr dtd);
-XMLPUBFUN xmlDocPtr
-		xmlCopyDoc		(xmlDocPtr doc,
+		xmlFreeProp		(xmlAttr *cur);
+XMLPUBFUN xmlAttr *
+		xmlCopyProp		(xmlNode *target,
+					 xmlAttr *cur);
+XMLPUBFUN xmlAttr *
+		xmlCopyPropList		(xmlNode *target,
+					 xmlAttr *cur);
+XMLPUBFUN xmlDtd *
+		xmlCopyDtd		(xmlDtd *dtd);
+XMLPUBFUN xmlDoc *
+		xmlCopyDoc		(xmlDoc *doc,
 					 int recursive);
 /*
 * Creating new nodes.
 */
-XMLPUBFUN xmlNodePtr
-		xmlNewDocNode		(xmlDocPtr doc,
-					 xmlNsPtr ns,
+XMLPUBFUN xmlNode *
+		xmlNewDocNode		(xmlDoc *doc,
+					 xmlNs *ns,
 					 const xmlChar *name,
 					 const xmlChar *content);
-XMLPUBFUN xmlNodePtr
-		xmlNewDocNodeEatName	(xmlDocPtr doc,
-					 xmlNsPtr ns,
+XMLPUBFUN xmlNode *
+		xmlNewDocNodeEatName	(xmlDoc *doc,
+					 xmlNs *ns,
 					 xmlChar *name,
 					 const xmlChar *content);
-XMLPUBFUN xmlNodePtr
-		xmlNewNode		(xmlNsPtr ns,
+XMLPUBFUN xmlNode *
+		xmlNewNode		(xmlNs *ns,
 					 const xmlChar *name);
-XMLPUBFUN xmlNodePtr
-		xmlNewNodeEatName	(xmlNsPtr ns,
+XMLPUBFUN xmlNode *
+		xmlNewNodeEatName	(xmlNs *ns,
 					 xmlChar *name);
-XMLPUBFUN xmlNodePtr
-		xmlNewChild		(xmlNodePtr parent,
-					 xmlNsPtr ns,
+XMLPUBFUN xmlNode *
+		xmlNewChild		(xmlNode *parent,
+					 xmlNs *ns,
 					 const xmlChar *name,
 					 const xmlChar *content);
-XMLPUBFUN xmlNodePtr
+XMLPUBFUN xmlNode *
 		xmlNewDocText		(const xmlDoc *doc,
 					 const xmlChar *content);
-XMLPUBFUN xmlNodePtr
+XMLPUBFUN xmlNode *
 		xmlNewText		(const xmlChar *content);
-XMLPUBFUN xmlNodePtr
-		xmlNewDocPI		(xmlDocPtr doc,
+XMLPUBFUN xmlNode *
+		xmlNewDocPI		(xmlDoc *doc,
 					 const xmlChar *name,
 					 const xmlChar *content);
-XMLPUBFUN xmlNodePtr
+XMLPUBFUN xmlNode *
 		xmlNewPI		(const xmlChar *name,
 					 const xmlChar *content);
-XMLPUBFUN xmlNodePtr
-		xmlNewDocTextLen	(xmlDocPtr doc,
+XMLPUBFUN xmlNode *
+		xmlNewDocTextLen	(xmlDoc *doc,
 					 const xmlChar *content,
 					 int len);
-XMLPUBFUN xmlNodePtr
+XMLPUBFUN xmlNode *
 		xmlNewTextLen		(const xmlChar *content,
 					 int len);
-XMLPUBFUN xmlNodePtr
-		xmlNewDocComment	(xmlDocPtr doc,
+XMLPUBFUN xmlNode *
+		xmlNewDocComment	(xmlDoc *doc,
 					 const xmlChar *content);
-XMLPUBFUN xmlNodePtr
+XMLPUBFUN xmlNode *
 		xmlNewComment		(const xmlChar *content);
-XMLPUBFUN xmlNodePtr
-		xmlNewCDataBlock	(xmlDocPtr doc,
+XMLPUBFUN xmlNode *
+		xmlNewCDataBlock	(xmlDoc *doc,
 					 const xmlChar *content,
 					 int len);
-XMLPUBFUN xmlNodePtr
-		xmlNewCharRef		(xmlDocPtr doc,
+XMLPUBFUN xmlNode *
+		xmlNewCharRef		(xmlDoc *doc,
 					 const xmlChar *name);
-XMLPUBFUN xmlNodePtr
+XMLPUBFUN xmlNode *
 		xmlNewReference		(const xmlDoc *doc,
 					 const xmlChar *name);
-XMLPUBFUN xmlNodePtr
-		xmlCopyNode		(xmlNodePtr node,
+XMLPUBFUN xmlNode *
+		xmlCopyNode		(xmlNode *node,
 					 int recursive);
-XMLPUBFUN xmlNodePtr
-		xmlDocCopyNode		(xmlNodePtr node,
-					 xmlDocPtr doc,
+XMLPUBFUN xmlNode *
+		xmlDocCopyNode		(xmlNode *node,
+					 xmlDoc *doc,
 					 int recursive);
-XMLPUBFUN xmlNodePtr
-		xmlDocCopyNodeList	(xmlDocPtr doc,
-					 xmlNodePtr node);
-XMLPUBFUN xmlNodePtr
-		xmlCopyNodeList		(xmlNodePtr node);
-XMLPUBFUN xmlNodePtr
-		xmlNewTextChild		(xmlNodePtr parent,
-					 xmlNsPtr ns,
+XMLPUBFUN xmlNode *
+		xmlDocCopyNodeList	(xmlDoc *doc,
+					 xmlNode *node);
+XMLPUBFUN xmlNode *
+		xmlCopyNodeList		(xmlNode *node);
+XMLPUBFUN xmlNode *
+		xmlNewTextChild		(xmlNode *parent,
+					 xmlNs *ns,
 					 const xmlChar *name,
 					 const xmlChar *content);
-XMLPUBFUN xmlNodePtr
-		xmlNewDocRawNode	(xmlDocPtr doc,
-					 xmlNsPtr ns,
+XMLPUBFUN xmlNode *
+		xmlNewDocRawNode	(xmlDoc *doc,
+					 xmlNs *ns,
 					 const xmlChar *name,
 					 const xmlChar *content);
-XMLPUBFUN xmlNodePtr
-		xmlNewDocFragment	(xmlDocPtr doc);
+XMLPUBFUN xmlNode *
+		xmlNewDocFragment	(xmlDoc *doc);

 /*
 * Navigating.
@@ -937,9 +937,9 @@ XMLPUBFUN long
 		xmlGetLineNo		(const xmlNode *node);
 XMLPUBFUN xmlChar *
 		xmlGetNodePath		(const xmlNode *node);
-XMLPUBFUN xmlNodePtr
+XMLPUBFUN xmlNode *
 		xmlDocGetRootElement	(const xmlDoc *doc);
-XMLPUBFUN xmlNodePtr
+XMLPUBFUN xmlNode *
 		xmlGetLastChild		(const xmlNode *parent);
 XMLPUBFUN int
 		xmlNodeIsText		(const xmlNode *node);
@@ -949,86 +949,86 @@ XMLPUBFUN int
 /*
 * Changing the structure.
 */
-XMLPUBFUN xmlNodePtr
-		xmlDocSetRootElement	(xmlDocPtr doc,
-					 xmlNodePtr root);
+XMLPUBFUN xmlNode *
+		xmlDocSetRootElement	(xmlDoc *doc,
+					 xmlNode *root);
 XMLPUBFUN void
-		xmlNodeSetName		(xmlNodePtr cur,
+		xmlNodeSetName		(xmlNode *cur,
 					 const xmlChar *name);
-XMLPUBFUN xmlNodePtr
-		xmlAddChild		(xmlNodePtr parent,
-					 xmlNodePtr cur);
-XMLPUBFUN xmlNodePtr
-		xmlAddChildList		(xmlNodePtr parent,
-					 xmlNodePtr cur);
-XMLPUBFUN xmlNodePtr
-		xmlReplaceNode		(xmlNodePtr old,
-					 xmlNodePtr cur);
-XMLPUBFUN xmlNodePtr
-		xmlAddPrevSibling	(xmlNodePtr cur,
-					 xmlNodePtr elem);
-XMLPUBFUN xmlNodePtr
-		xmlAddSibling		(xmlNodePtr cur,
-					 xmlNodePtr elem);
-XMLPUBFUN xmlNodePtr
-		xmlAddNextSibling	(xmlNodePtr cur,
-					 xmlNodePtr elem);
+XMLPUBFUN xmlNode *
+		xmlAddChild		(xmlNode *parent,
+					 xmlNode *cur);
+XMLPUBFUN xmlNode *
+		xmlAddChildList		(xmlNode *parent,
+					 xmlNode *cur);
+XMLPUBFUN xmlNode *
+		xmlReplaceNode		(xmlNode *old,
+					 xmlNode *cur);
+XMLPUBFUN xmlNode *
+		xmlAddPrevSibling	(xmlNode *cur,
+					 xmlNode *elem);
+XMLPUBFUN xmlNode *
+		xmlAddSibling		(xmlNode *cur,
+					 xmlNode *elem);
+XMLPUBFUN xmlNode *
+		xmlAddNextSibling	(xmlNode *cur,
+					 xmlNode *elem);
 XMLPUBFUN void
-		xmlUnlinkNode		(xmlNodePtr cur);
-XMLPUBFUN xmlNodePtr
-		xmlTextMerge		(xmlNodePtr first,
-					 xmlNodePtr second);
+		xmlUnlinkNode		(xmlNode *cur);
+XMLPUBFUN xmlNode *
+		xmlTextMerge		(xmlNode *first,
+					 xmlNode *second);
 XMLPUBFUN int
-		xmlTextConcat		(xmlNodePtr node,
+		xmlTextConcat		(xmlNode *node,
 					 const xmlChar *content,
 					 int len);
 XMLPUBFUN void
-		xmlFreeNodeList		(xmlNodePtr cur);
+		xmlFreeNodeList		(xmlNode *cur);
 XMLPUBFUN void
-		xmlFreeNode		(xmlNodePtr cur);
+		xmlFreeNode		(xmlNode *cur);
 XMLPUBFUN int
-		xmlSetTreeDoc		(xmlNodePtr tree,
-					 xmlDocPtr doc);
+		xmlSetTreeDoc		(xmlNode *tree,
+					 xmlDoc *doc);
 XMLPUBFUN int
-		xmlSetListDoc		(xmlNodePtr list,
-					 xmlDocPtr doc);
+		xmlSetListDoc		(xmlNode *list,
+					 xmlDoc *doc);
 /*
 * Namespaces.
 */
-XMLPUBFUN xmlNsPtr
-		xmlSearchNs		(xmlDocPtr doc,
-					 xmlNodePtr node,
+XMLPUBFUN xmlNs *
+		xmlSearchNs		(xmlDoc *doc,
+					 xmlNode *node,
 					 const xmlChar *nameSpace);
-XMLPUBFUN xmlNsPtr
-		xmlSearchNsByHref	(xmlDocPtr doc,
-					 xmlNodePtr node,
+XMLPUBFUN xmlNs *
+		xmlSearchNsByHref	(xmlDoc *doc,
+					 xmlNode *node,
 					 const xmlChar *href);
 XMLPUBFUN int
 		xmlGetNsListSafe	(const xmlDoc *doc,
 					 const xmlNode *node,
-					 xmlNsPtr **out);
-XMLPUBFUN xmlNsPtr *
+					 xmlNs ***out);
+XMLPUBFUN xmlNs **
 		xmlGetNsList		(const xmlDoc *doc,
 					 const xmlNode *node);

 XMLPUBFUN void
-		xmlSetNs		(xmlNodePtr node,
-					 xmlNsPtr ns);
-XMLPUBFUN xmlNsPtr
-		xmlCopyNamespace	(xmlNsPtr cur);
-XMLPUBFUN xmlNsPtr
-		xmlCopyNamespaceList	(xmlNsPtr cur);
+		xmlSetNs		(xmlNode *node,
+					 xmlNs *ns);
+XMLPUBFUN xmlNs *
+		xmlCopyNamespace	(xmlNs *cur);
+XMLPUBFUN xmlNs *
+		xmlCopyNamespaceList	(xmlNs *cur);

 /*
 * Changing the content.
 */
-XMLPUBFUN xmlAttrPtr
-		xmlSetProp		(xmlNodePtr node,
+XMLPUBFUN xmlAttr *
+		xmlSetProp		(xmlNode *node,
 					 const xmlChar *name,
 					 const xmlChar *value);
-XMLPUBFUN xmlAttrPtr
-		xmlSetNsProp		(xmlNodePtr node,
-					 xmlNsPtr ns,
+XMLPUBFUN xmlAttr *
+		xmlSetNsProp		(xmlNode *node,
+					 xmlNs *ns,
 					 const xmlChar *name,
 					 const xmlChar *value);
 XMLPUBFUN int
@@ -1042,10 +1042,10 @@ XMLPUBFUN xmlChar *
 XMLPUBFUN xmlChar *
 		xmlGetProp		(const xmlNode *node,
 					 const xmlChar *name);
-XMLPUBFUN xmlAttrPtr
+XMLPUBFUN xmlAttr *
 		xmlHasProp		(const xmlNode *node,
 					 const xmlChar *name);
-XMLPUBFUN xmlAttrPtr
+XMLPUBFUN xmlAttr *
 		xmlHasNsProp		(const xmlNode *node,
 					 const xmlChar *name,
 					 const xmlChar *nameSpace);
@@ -1053,15 +1053,15 @@ XMLPUBFUN xmlChar *
 		xmlGetNsProp		(const xmlNode *node,
 					 const xmlChar *name,
 					 const xmlChar *nameSpace);
-XMLPUBFUN xmlNodePtr
+XMLPUBFUN xmlNode *
 		xmlStringGetNodeList	(const xmlDoc *doc,
 					 const xmlChar *value);
-XMLPUBFUN xmlNodePtr
+XMLPUBFUN xmlNode *
 		xmlStringLenGetNodeList	(const xmlDoc *doc,
 					 const xmlChar *value,
 					 int len);
 XMLPUBFUN xmlChar *
-		xmlNodeListGetString	(xmlDocPtr doc,
+		xmlNodeListGetString	(xmlDoc *doc,
 					 const xmlNode *list,
 					 int inLine);
 XMLPUBFUN xmlChar *
@@ -1069,27 +1069,27 @@ XMLPUBFUN xmlChar *
 					 const xmlNode *list,
 					 int inLine);
 XMLPUBFUN int
-		xmlNodeSetContent	(xmlNodePtr cur,
+		xmlNodeSetContent	(xmlNode *cur,
 					 const xmlChar *content);
 XMLPUBFUN int
-		xmlNodeSetContentLen	(xmlNodePtr cur,
+		xmlNodeSetContentLen	(xmlNode *cur,
 					 const xmlChar *content,
 					 int len);
 XMLPUBFUN int
-		xmlNodeAddContent	(xmlNodePtr cur,
+		xmlNodeAddContent	(xmlNode *cur,
 					 const xmlChar *content);
 XMLPUBFUN int
-		xmlNodeAddContentLen	(xmlNodePtr cur,
+		xmlNodeAddContentLen	(xmlNode *cur,
 					 const xmlChar *content,
 					 int len);
 XMLPUBFUN xmlChar *
 		xmlNodeGetContent	(const xmlNode *cur);

 XMLPUBFUN int
-		xmlNodeBufGetContent	(xmlBufferPtr buffer,
+		xmlNodeBufGetContent	(xmlBuffer *buffer,
 					 const xmlNode *cur);
 XMLPUBFUN int
-		xmlBufGetNodeContent	(xmlBufPtr buf,
+		xmlBufGetNodeContent	(xmlBuf *buf,
 					 const xmlNode *cur);

 XMLPUBFUN xmlChar *
@@ -1097,10 +1097,10 @@ XMLPUBFUN xmlChar *
 XMLPUBFUN int
 		xmlNodeGetSpacePreserve	(const xmlNode *cur);
 XMLPUBFUN int
-		xmlNodeSetLang		(xmlNodePtr cur,
+		xmlNodeSetLang		(xmlNode *cur,
 					 const xmlChar *lang);
 XMLPUBFUN int
-		xmlNodeSetSpacePreserve (xmlNodePtr cur,
+		xmlNodeSetSpacePreserve (xmlNode *cur,
 					 int val);
 XMLPUBFUN int
 		xmlNodeGetBaseSafe	(const xmlDoc *doc,
@@ -1110,26 +1110,26 @@ XMLPUBFUN xmlChar *
 		xmlNodeGetBase		(const xmlDoc *doc,
 					 const xmlNode *cur);
 XMLPUBFUN int
-		xmlNodeSetBase		(xmlNodePtr cur,
+		xmlNodeSetBase		(xmlNode *cur,
 					 const xmlChar *uri);

 /*
 * Removing content.
 */
 XMLPUBFUN int
-		xmlRemoveProp		(xmlAttrPtr cur);
+		xmlRemoveProp		(xmlAttr *cur);
 XMLPUBFUN int
-		xmlUnsetNsProp		(xmlNodePtr node,
-					 xmlNsPtr ns,
+		xmlUnsetNsProp		(xmlNode *node,
+					 xmlNs *ns,
 					 const xmlChar *name);
 XMLPUBFUN int
-		xmlUnsetProp		(xmlNodePtr node,
+		xmlUnsetProp		(xmlNode *node,
 					 const xmlChar *name);

 #ifdef LIBXML_OUTPUT_ENABLED
-XMLPUBFUN void xmlAttrSerializeTxtContent(xmlBufferPtr buf,
-					 xmlDocPtr doc,
-					 xmlAttrPtr attr,
+XMLPUBFUN void xmlAttrSerializeTxtContent(xmlBuffer *buf,
+					 xmlDoc *doc,
+					 xmlAttr *attr,
 					 const xmlChar *string);
 #endif /* LIBXML_OUTPUT_ENABLED */

@@ -1137,90 +1137,90 @@ XMLPUBFUN void xmlAttrSerializeTxtContent(xmlBufferPtr buf,
 * Namespace handling.
 */
 XMLPUBFUN int
-		xmlReconciliateNs	(xmlDocPtr doc,
-					 xmlNodePtr tree);
+		xmlReconciliateNs	(xmlDoc *doc,
+					 xmlNode *tree);

 #ifdef LIBXML_OUTPUT_ENABLED
 /*
 * Saving.
 */
 XMLPUBFUN void
-		xmlDocDumpFormatMemory	(xmlDocPtr cur,
+		xmlDocDumpFormatMemory	(xmlDoc *cur,
 					 xmlChar **mem,
 					 int *size,
 					 int format);
 XMLPUBFUN void
-		xmlDocDumpMemory	(xmlDocPtr cur,
+		xmlDocDumpMemory	(xmlDoc *cur,
 					 xmlChar **mem,
 					 int *size);
 XMLPUBFUN void
-		xmlDocDumpMemoryEnc	(xmlDocPtr out_doc,
+		xmlDocDumpMemoryEnc	(xmlDoc *out_doc,
 					 xmlChar **doc_txt_ptr,
 					 int * doc_txt_len,
 					 const char *txt_encoding);
 XMLPUBFUN void
-		xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc,
+		xmlDocDumpFormatMemoryEnc(xmlDoc *out_doc,
 					 xmlChar **doc_txt_ptr,
 					 int * doc_txt_len,
 					 const char *txt_encoding,
 					 int format);
 XMLPUBFUN int
 		xmlDocFormatDump	(FILE *f,
-					 xmlDocPtr cur,
+					 xmlDoc *cur,
 					 int format);
 XMLPUBFUN int
 		xmlDocDump		(FILE *f,
-					 xmlDocPtr cur);
+					 xmlDoc *cur);
 XMLPUBFUN void
 		xmlElemDump		(FILE *f,
-					 xmlDocPtr doc,
-					 xmlNodePtr cur);
+					 xmlDoc *doc,
+					 xmlNode *cur);
 XMLPUBFUN int
 		xmlSaveFile		(const char *filename,
-					 xmlDocPtr cur);
+					 xmlDoc *cur);
 XMLPUBFUN int
 		xmlSaveFormatFile	(const char *filename,
-					 xmlDocPtr cur,
+					 xmlDoc *cur,
 					 int format);
 XMLPUBFUN size_t
-		xmlBufNodeDump		(xmlBufPtr buf,
-					 xmlDocPtr doc,
-					 xmlNodePtr cur,
+		xmlBufNodeDump		(xmlBuf *buf,
+					 xmlDoc *doc,
+					 xmlNode *cur,
 					 int level,
 					 int format);
 XMLPUBFUN int
-		xmlNodeDump		(xmlBufferPtr buf,
-					 xmlDocPtr doc,
-					 xmlNodePtr cur,
+		xmlNodeDump		(xmlBuffer *buf,
+					 xmlDoc *doc,
+					 xmlNode *cur,
 					 int level,
 					 int format);

 XMLPUBFUN int
-		xmlSaveFileTo		(xmlOutputBufferPtr buf,
-					 xmlDocPtr cur,
+		xmlSaveFileTo		(xmlOutputBuffer *buf,
+					 xmlDoc *cur,
 					 const char *encoding);
 XMLPUBFUN int
-		xmlSaveFormatFileTo     (xmlOutputBufferPtr buf,
-					 xmlDocPtr cur,
+		xmlSaveFormatFileTo     (xmlOutputBuffer *buf,
+					 xmlDoc *cur,
 				         const char *encoding,
 				         int format);
 XMLPUBFUN void
-		xmlNodeDumpOutput	(xmlOutputBufferPtr buf,
-					 xmlDocPtr doc,
-					 xmlNodePtr cur,
+		xmlNodeDumpOutput	(xmlOutputBuffer *buf,
+					 xmlDoc *doc,
+					 xmlNode *cur,
 					 int level,
 					 int format,
 					 const char *encoding);

 XMLPUBFUN int
 		xmlSaveFormatFileEnc    (const char *filename,
-					 xmlDocPtr cur,
+					 xmlDoc *cur,
 					 const char *encoding,
 					 int format);

 XMLPUBFUN int
 		xmlSaveFileEnc		(const char *filename,
-					 xmlDocPtr cur,
+					 xmlDoc *cur,
 					 const char *encoding);

 #endif /* LIBXML_OUTPUT_ENABLED */
@@ -1237,7 +1237,7 @@ XMLPUBFUN int
 XMLPUBFUN int
 		xmlGetDocCompressMode	(const xmlDoc *doc);
 XMLPUBFUN void
-		xmlSetDocCompressMode	(xmlDocPtr doc,
+		xmlSetDocCompressMode	(xmlDoc *doc,
 					 int mode);
 XML_DEPRECATED
 XMLPUBFUN int
@@ -1249,33 +1249,33 @@ XMLPUBFUN void
 /*
 * DOM-wrapper helper functions.
 */
-XMLPUBFUN xmlDOMWrapCtxtPtr
+XMLPUBFUN xmlDOMWrapCtxt *
 		xmlDOMWrapNewCtxt	(void);
 XMLPUBFUN void
-		xmlDOMWrapFreeCtxt	(xmlDOMWrapCtxtPtr ctxt);
+		xmlDOMWrapFreeCtxt	(xmlDOMWrapCtxt *ctxt);
 XMLPUBFUN int
-	    xmlDOMWrapReconcileNamespaces(xmlDOMWrapCtxtPtr ctxt,
-					 xmlNodePtr elem,
+	    xmlDOMWrapReconcileNamespaces(xmlDOMWrapCtxt *ctxt,
+					 xmlNode *elem,
 					 int options);
 XMLPUBFUN int
-	    xmlDOMWrapAdoptNode		(xmlDOMWrapCtxtPtr ctxt,
-					 xmlDocPtr sourceDoc,
-					 xmlNodePtr node,
-					 xmlDocPtr destDoc,
-					 xmlNodePtr destParent,
+	    xmlDOMWrapAdoptNode		(xmlDOMWrapCtxt *ctxt,
+					 xmlDoc *sourceDoc,
+					 xmlNode *node,
+					 xmlDoc *destDoc,
+					 xmlNode *destParent,
 					 int options);
 XMLPUBFUN int
-	    xmlDOMWrapRemoveNode	(xmlDOMWrapCtxtPtr ctxt,
-					 xmlDocPtr doc,
-					 xmlNodePtr node,
+	    xmlDOMWrapRemoveNode	(xmlDOMWrapCtxt *ctxt,
+					 xmlDoc *doc,
+					 xmlNode *node,
 					 int options);
 XMLPUBFUN int
-	    xmlDOMWrapCloneNode		(xmlDOMWrapCtxtPtr ctxt,
-					 xmlDocPtr sourceDoc,
-					 xmlNodePtr node,
-					 xmlNodePtr *clonedNode,
-					 xmlDocPtr destDoc,
-					 xmlNodePtr destParent,
+	    xmlDOMWrapCloneNode		(xmlDOMWrapCtxt *ctxt,
+					 xmlDoc *sourceDoc,
+					 xmlNode *node,
+					 xmlNode **clonedNode,
+					 xmlDoc *destDoc,
+					 xmlNode *destParent,
 					 int deep,
 					 int options);

@@ -1284,15 +1284,15 @@ XMLPUBFUN int
 * traversal.
 */
 XMLPUBFUN unsigned long
-            xmlChildElementCount        (xmlNodePtr parent);
-XMLPUBFUN xmlNodePtr
-            xmlNextElementSibling       (xmlNodePtr node);
-XMLPUBFUN xmlNodePtr
-            xmlFirstElementChild        (xmlNodePtr parent);
-XMLPUBFUN xmlNodePtr
-            xmlLastElementChild         (xmlNodePtr parent);
-XMLPUBFUN xmlNodePtr
-            xmlPreviousElementSibling   (xmlNodePtr node);
+            xmlChildElementCount        (xmlNode *parent);
+XMLPUBFUN xmlNode *
+            xmlNextElementSibling       (xmlNode *node);
+XMLPUBFUN xmlNode *
+            xmlFirstElementChild        (xmlNode *parent);
+XMLPUBFUN xmlNode *
+            xmlLastElementChild         (xmlNode *parent);
+XMLPUBFUN xmlNode *
+            xmlPreviousElementSibling   (xmlNode *node);

 XML_DEPRECATED
 XMLPUBFUN xmlRegisterNodeFunc
@@ -1318,63 +1318,63 @@ XML_DEPRECATED
 XMLPUBFUN xmlBufferAllocationScheme
 		xmlGetBufferAllocationScheme(void);

-XMLPUBFUN xmlBufferPtr
+XMLPUBFUN xmlBuffer *
 		xmlBufferCreate		(void);
-XMLPUBFUN xmlBufferPtr
+XMLPUBFUN xmlBuffer *
 		xmlBufferCreateSize	(size_t size);
-XMLPUBFUN xmlBufferPtr
+XMLPUBFUN xmlBuffer *
 		xmlBufferCreateStatic	(void *mem,
 					 size_t size);
 XML_DEPRECATED
 XMLPUBFUN int
-		xmlBufferResize		(xmlBufferPtr buf,
+		xmlBufferResize		(xmlBuffer *buf,
 					 unsigned int size);
 XMLPUBFUN void
-		xmlBufferFree		(xmlBufferPtr buf);
+		xmlBufferFree		(xmlBuffer *buf);
 XMLPUBFUN int
 		xmlBufferDump		(FILE *file,
-					 xmlBufferPtr buf);
+					 xmlBuffer *buf);
 XMLPUBFUN int
-		xmlBufferAdd		(xmlBufferPtr buf,
+		xmlBufferAdd		(xmlBuffer *buf,
 					 const xmlChar *str,
 					 int len);
 XMLPUBFUN int
-		xmlBufferAddHead	(xmlBufferPtr buf,
+		xmlBufferAddHead	(xmlBuffer *buf,
 					 const xmlChar *str,
 					 int len);
 XMLPUBFUN int
-		xmlBufferCat		(xmlBufferPtr buf,
+		xmlBufferCat		(xmlBuffer *buf,
 					 const xmlChar *str);
 XMLPUBFUN int
-		xmlBufferCCat		(xmlBufferPtr buf,
+		xmlBufferCCat		(xmlBuffer *buf,
 					 const char *str);
 XML_DEPRECATED
 XMLPUBFUN int
-		xmlBufferShrink		(xmlBufferPtr buf,
+		xmlBufferShrink		(xmlBuffer *buf,
 					 unsigned int len);
 XML_DEPRECATED
 XMLPUBFUN int
-		xmlBufferGrow		(xmlBufferPtr buf,
+		xmlBufferGrow		(xmlBuffer *buf,
 					 unsigned int len);
 XMLPUBFUN void
-		xmlBufferEmpty		(xmlBufferPtr buf);
+		xmlBufferEmpty		(xmlBuffer *buf);
 XMLPUBFUN const xmlChar*
 		xmlBufferContent	(const xmlBuffer *buf);
 XMLPUBFUN xmlChar*
-		xmlBufferDetach         (xmlBufferPtr buf);
+		xmlBufferDetach         (xmlBuffer *buf);
 XMLPUBFUN void
-		xmlBufferSetAllocationScheme(xmlBufferPtr buf,
+		xmlBufferSetAllocationScheme(xmlBuffer *buf,
 					 xmlBufferAllocationScheme scheme);
 XMLPUBFUN int
 		xmlBufferLength		(const xmlBuffer *buf);
 XMLPUBFUN void
-		xmlBufferWriteCHAR	(xmlBufferPtr buf,
+		xmlBufferWriteCHAR	(xmlBuffer *buf,
 					 const xmlChar *string);
 XMLPUBFUN void
-		xmlBufferWriteChar	(xmlBufferPtr buf,
+		xmlBufferWriteChar	(xmlBuffer *buf,
 					 const char *string);
 XMLPUBFUN void
-		xmlBufferWriteQuotedString(xmlBufferPtr buf,
+		xmlBufferWriteQuotedString(xmlBuffer *buf,
 					 const xmlChar *string);

 /*
@@ -1382,9 +1382,9 @@ XMLPUBFUN void
 * mostly internally the bulk of the routines are internal in buf.h
 */
 XMLPUBFUN xmlChar*       xmlBufContent	(const xmlBuf* buf);
-XMLPUBFUN xmlChar*       xmlBufEnd      (xmlBufPtr buf);
-XMLPUBFUN size_t         xmlBufUse      (const xmlBufPtr buf);
-XMLPUBFUN size_t         xmlBufShrink	(xmlBufPtr buf, size_t len);
+XMLPUBFUN xmlChar*       xmlBufEnd      (xmlBuf *buf);
+XMLPUBFUN size_t         xmlBufUse      (xmlBuf *buf);
+XMLPUBFUN size_t         xmlBufShrink	(xmlBuf *buf, size_t len);

 #ifdef __cplusplus
 }
--- a/include/libxml/uri.h
+++ b/include/libxml/uri.h
@@ -48,12 +48,7 @@ struct _xmlURI {
    char *query_raw;	/* the query string (as it appears in the URI) */
 };

-/*
- * This function is in tree.h:
- * xmlChar *	xmlNodeGetBase	(xmlDocPtr doc,
- *                               xmlNodePtr cur);
- */
-XMLPUBFUN xmlURIPtr
+XMLPUBFUN xmlURI *
 		xmlCreateURI		(void);
 XMLPUBFUN int
 		xmlBuildURISafe		(const xmlChar *URI,
@@ -69,22 +64,22 @@ XMLPUBFUN int
 XMLPUBFUN xmlChar *
 		xmlBuildRelativeURI	(const xmlChar *URI,
 					 const xmlChar *base);
-XMLPUBFUN xmlURIPtr
+XMLPUBFUN xmlURI *
 		xmlParseURI		(const char *str);
 XMLPUBFUN int
 		xmlParseURISafe		(const char *str,
-					 xmlURIPtr *uri);
-XMLPUBFUN xmlURIPtr
+					 xmlURI **uri);
+XMLPUBFUN xmlURI *
 		xmlParseURIRaw		(const char *str,
 					 int raw);
 XMLPUBFUN int
-		xmlParseURIReference	(xmlURIPtr uri,
+		xmlParseURIReference	(xmlURI *uri,
 					 const char *str);
 XMLPUBFUN xmlChar *
-		xmlSaveUri		(xmlURIPtr uri);
+		xmlSaveUri		(xmlURI *uri);
 XMLPUBFUN void
 		xmlPrintURI		(FILE *stream,
-					 xmlURIPtr uri);
+					 xmlURI *uri);
 XMLPUBFUN xmlChar *
 		xmlURIEscapeStr         (const xmlChar *str,
 					 const xmlChar *list);
@@ -97,7 +92,7 @@ XMLPUBFUN int
 XMLPUBFUN xmlChar *
 		xmlURIEscape		(const xmlChar *str);
 XMLPUBFUN void
-		xmlFreeURI		(xmlURIPtr uri);
+		xmlFreeURI		(xmlURI *uri);
 XMLPUBFUN xmlChar*
 		xmlCanonicPath		(const xmlChar *path);
 XMLPUBFUN xmlChar*
--- a/include/libxml/valid.h
+++ b/include/libxml/valid.h
@@ -37,7 +37,7 @@ typedef xmlValidState *xmlValidStatePtr;
 /**
 * Report a validity error.
 *
- * @param ctx  user data (usually an xmlValidCtxtPtr)
+ * @param ctx  user data (usually an xmlValidCtxt)
 * @param msg  printf-like format string
 * @param ...  arguments to format
 */
@@ -48,7 +48,7 @@ typedef void (*xmlValidityErrorFunc) (void *ctx,
 /**
 * Report a validity warning.
 *
- * @param ctx  user data (usually an xmlValidCtxtPtr)
+ * @param ctx  user data (usually an xmlValidCtxt)
 * @param msg  printf-like format string
 * @param ...  arguments to format
 */
@@ -67,13 +67,13 @@ struct _xmlValidCtxt {
    xmlValidityWarningFunc warning;	/* the callback in case of warning */

    /* Node analysis stack used when validating within entities */
-    xmlNodePtr         node;          /* Current parsed Node */
+    xmlNode           *node;          /* Current parsed Node */
    int                nodeNr;        /* Depth of the parsing stack */
    int                nodeMax;       /* Max depth of the parsing stack */
-    xmlNodePtr        *nodeTab;       /* array of nodes */
+    xmlNode          **nodeTab;       /* array of nodes */

    unsigned int         flags;       /* internal flags */
-    xmlDocPtr              doc;       /* the document */
+    xmlDoc                *doc;       /* the document */
    int                  valid;       /* temporary validity check result */

    /* state state used for non-determinist content validation */
@@ -83,8 +83,8 @@ struct _xmlValidCtxt {
    xmlValidState     *vstateTab;     /* array of validation states */

 #ifdef LIBXML_REGEXP_ENABLED
-    xmlAutomataPtr            am;     /* the automata */
-    xmlAutomataStatePtr    state;     /* used to build the automata */
+    xmlAutomata              *am;     /* the automata */
+    xmlAutomataState      *state;     /* used to build the automata */
 #else
    void                     *am;
    void                  *state;
@@ -108,176 +108,176 @@ typedef xmlRefTable *xmlRefTablePtr;

 /* Notation */
 XML_DEPRECATED
-XMLPUBFUN xmlNotationPtr
-		xmlAddNotationDecl	(xmlValidCtxtPtr ctxt,
-					 xmlDtdPtr dtd,
+XMLPUBFUN xmlNotation *
+		xmlAddNotationDecl	(xmlValidCtxt *ctxt,
+					 xmlDtd *dtd,
 					 const xmlChar *name,
 					 const xmlChar *PublicID,
 					 const xmlChar *SystemID);
 XML_DEPRECATED
-XMLPUBFUN xmlNotationTablePtr
-		xmlCopyNotationTable	(xmlNotationTablePtr table);
+XMLPUBFUN xmlNotationTable *
+		xmlCopyNotationTable	(xmlNotationTable *table);
 XML_DEPRECATED
 XMLPUBFUN void
-		xmlFreeNotationTable	(xmlNotationTablePtr table);
+		xmlFreeNotationTable	(xmlNotationTable *table);
 #ifdef LIBXML_OUTPUT_ENABLED
 XML_DEPRECATED
 XMLPUBFUN void
-		xmlDumpNotationDecl	(xmlBufferPtr buf,
-					 xmlNotationPtr nota);
+		xmlDumpNotationDecl	(xmlBuffer *buf,
+					 xmlNotation *nota);
 /* XML_DEPRECATED, still used in lxml */
 XMLPUBFUN void
-		xmlDumpNotationTable	(xmlBufferPtr buf,
-					 xmlNotationTablePtr table);
+		xmlDumpNotationTable	(xmlBuffer *buf,
+					 xmlNotationTable *table);
 #endif /* LIBXML_OUTPUT_ENABLED */

 /* Element Content */
 XML_DEPRECATED
-XMLPUBFUN xmlElementContentPtr
+XMLPUBFUN xmlElementContent *
 		xmlNewElementContent	(const xmlChar *name,
 					 xmlElementContentType type);
 XML_DEPRECATED
-XMLPUBFUN xmlElementContentPtr
-		xmlCopyElementContent	(xmlElementContentPtr content);
+XMLPUBFUN xmlElementContent *
+		xmlCopyElementContent	(xmlElementContent *content);
 XML_DEPRECATED
 XMLPUBFUN void
-		xmlFreeElementContent	(xmlElementContentPtr cur);
+		xmlFreeElementContent	(xmlElementContent *cur);
 XML_DEPRECATED
-XMLPUBFUN xmlElementContentPtr
-		xmlNewDocElementContent	(xmlDocPtr doc,
+XMLPUBFUN xmlElementContent *
+		xmlNewDocElementContent	(xmlDoc *doc,
 					 const xmlChar *name,
 					 xmlElementContentType type);
 XML_DEPRECATED
-XMLPUBFUN xmlElementContentPtr
-		xmlCopyDocElementContent(xmlDocPtr doc,
-					 xmlElementContentPtr content);
+XMLPUBFUN xmlElementContent *
+		xmlCopyDocElementContent(xmlDoc *doc,
+					 xmlElementContent *content);
 XML_DEPRECATED
 XMLPUBFUN void
-		xmlFreeDocElementContent(xmlDocPtr doc,
-					 xmlElementContentPtr cur);
+		xmlFreeDocElementContent(xmlDoc *doc,
+					 xmlElementContent *cur);
 XML_DEPRECATED
 XMLPUBFUN void
 		xmlSnprintfElementContent(char *buf,
 					 int size,
-	                                 xmlElementContentPtr content,
+	                                 xmlElementContent *content,
 					 int englob);
 #ifdef LIBXML_OUTPUT_ENABLED
 XML_DEPRECATED
 XMLPUBFUN void
 		xmlSprintfElementContent(char *buf,
-	                                 xmlElementContentPtr content,
+	                                 xmlElementContent *content,
 					 int englob);
 #endif /* LIBXML_OUTPUT_ENABLED */

 /* Element */
 XML_DEPRECATED
-XMLPUBFUN xmlElementPtr
-		xmlAddElementDecl	(xmlValidCtxtPtr ctxt,
-					 xmlDtdPtr dtd,
+XMLPUBFUN xmlElement *
+		xmlAddElementDecl	(xmlValidCtxt *ctxt,
+					 xmlDtd *dtd,
 					 const xmlChar *name,
 					 xmlElementTypeVal type,
-					 xmlElementContentPtr content);
+					 xmlElementContent *content);
 XML_DEPRECATED
-XMLPUBFUN xmlElementTablePtr
-		xmlCopyElementTable	(xmlElementTablePtr table);
+XMLPUBFUN xmlElementTable *
+		xmlCopyElementTable	(xmlElementTable *table);
 XML_DEPRECATED
 XMLPUBFUN void
-		xmlFreeElementTable	(xmlElementTablePtr table);
+		xmlFreeElementTable	(xmlElementTable *table);
 #ifdef LIBXML_OUTPUT_ENABLED
 XML_DEPRECATED
 XMLPUBFUN void
-		xmlDumpElementTable	(xmlBufferPtr buf,
-					 xmlElementTablePtr table);
+		xmlDumpElementTable	(xmlBuffer *buf,
+					 xmlElementTable *table);
 XML_DEPRECATED
 XMLPUBFUN void
-		xmlDumpElementDecl	(xmlBufferPtr buf,
-					 xmlElementPtr elem);
+		xmlDumpElementDecl	(xmlBuffer *buf,
+					 xmlElement *elem);
 #endif /* LIBXML_OUTPUT_ENABLED */

 /* Enumeration */
 XML_DEPRECATED
-XMLPUBFUN xmlEnumerationPtr
+XMLPUBFUN xmlEnumeration *
 		xmlCreateEnumeration	(const xmlChar *name);
 /* XML_DEPRECATED, needed for custom attributeDecl SAX handler */
 XMLPUBFUN void
-		xmlFreeEnumeration	(xmlEnumerationPtr cur);
+		xmlFreeEnumeration	(xmlEnumeration *cur);
 XML_DEPRECATED
-XMLPUBFUN xmlEnumerationPtr
-		xmlCopyEnumeration	(xmlEnumerationPtr cur);
+XMLPUBFUN xmlEnumeration *
+		xmlCopyEnumeration	(xmlEnumeration *cur);

 /* Attribute */
 XML_DEPRECATED
-XMLPUBFUN xmlAttributePtr
-		xmlAddAttributeDecl	(xmlValidCtxtPtr ctxt,
-					 xmlDtdPtr dtd,
+XMLPUBFUN xmlAttribute *
+		xmlAddAttributeDecl	(xmlValidCtxt *ctxt,
+					 xmlDtd *dtd,
 					 const xmlChar *elem,
 					 const xmlChar *name,
 					 const xmlChar *ns,
 					 xmlAttributeType type,
 					 xmlAttributeDefault def,
 					 const xmlChar *defaultValue,
-					 xmlEnumerationPtr tree);
+					 xmlEnumeration *tree);
 XML_DEPRECATED
-XMLPUBFUN xmlAttributeTablePtr
-		xmlCopyAttributeTable  (xmlAttributeTablePtr table);
+XMLPUBFUN xmlAttributeTable *
+		xmlCopyAttributeTable  (xmlAttributeTable *table);
 XML_DEPRECATED
 XMLPUBFUN void
-		xmlFreeAttributeTable  (xmlAttributeTablePtr table);
+		xmlFreeAttributeTable  (xmlAttributeTable *table);
 #ifdef LIBXML_OUTPUT_ENABLED
 XML_DEPRECATED
 XMLPUBFUN void
-		xmlDumpAttributeTable  (xmlBufferPtr buf,
-					xmlAttributeTablePtr table);
+		xmlDumpAttributeTable  (xmlBuffer *buf,
+					xmlAttributeTable *table);
 XML_DEPRECATED
 XMLPUBFUN void
-		xmlDumpAttributeDecl   (xmlBufferPtr buf,
-					xmlAttributePtr attr);
+		xmlDumpAttributeDecl   (xmlBuffer *buf,
+					xmlAttribute *attr);
 #endif /* LIBXML_OUTPUT_ENABLED */

 /* IDs */
 XMLPUBFUN int
-		xmlAddIDSafe	       (xmlAttrPtr attr,
+		xmlAddIDSafe	       (xmlAttr *attr,
 					const xmlChar *value);
-XMLPUBFUN xmlIDPtr
-		xmlAddID	       (xmlValidCtxtPtr ctxt,
-					xmlDocPtr doc,
+XMLPUBFUN xmlID *
+		xmlAddID	       (xmlValidCtxt *ctxt,
+					xmlDoc *doc,
 					const xmlChar *value,
-					xmlAttrPtr attr);
+					xmlAttr *attr);
 XMLPUBFUN void
-		xmlFreeIDTable	       (xmlIDTablePtr table);
-XMLPUBFUN xmlAttrPtr
-		xmlGetID	       (xmlDocPtr doc,
+		xmlFreeIDTable	       (xmlIDTable *table);
+XMLPUBFUN xmlAttr *
+		xmlGetID	       (xmlDoc *doc,
 					const xmlChar *ID);
 XMLPUBFUN int
-		xmlIsID		       (xmlDocPtr doc,
-					xmlNodePtr elem,
-					xmlAttrPtr attr);
+		xmlIsID		       (xmlDoc *doc,
+					xmlNode *elem,
+					xmlAttr *attr);
 XMLPUBFUN int
-		xmlRemoveID	       (xmlDocPtr doc,
-					xmlAttrPtr attr);
+		xmlRemoveID	       (xmlDoc *doc,
+					xmlAttr *attr);

 /* IDREFs */
 XML_DEPRECATED
-XMLPUBFUN xmlRefPtr
-		xmlAddRef	       (xmlValidCtxtPtr ctxt,
-					xmlDocPtr doc,
+XMLPUBFUN xmlRef *
+		xmlAddRef	       (xmlValidCtxt *ctxt,
+					xmlDoc *doc,
 					const xmlChar *value,
-					xmlAttrPtr attr);
+					xmlAttr *attr);
 XML_DEPRECATED
 XMLPUBFUN void
-		xmlFreeRefTable	       (xmlRefTablePtr table);
+		xmlFreeRefTable	       (xmlRefTable *table);
 XML_DEPRECATED
 XMLPUBFUN int
-		xmlIsRef	       (xmlDocPtr doc,
-					xmlNodePtr elem,
-					xmlAttrPtr attr);
+		xmlIsRef	       (xmlDoc *doc,
+					xmlNode *elem,
+					xmlAttr *attr);
 XML_DEPRECATED
 XMLPUBFUN int
-		xmlRemoveRef	       (xmlDocPtr doc,
-					xmlAttrPtr attr);
+		xmlRemoveRef	       (xmlDoc *doc,
+					xmlAttr *attr);
 XML_DEPRECATED
-XMLPUBFUN xmlListPtr
-		xmlGetRefs	       (xmlDocPtr doc,
+XMLPUBFUN xmlList *
+		xmlGetRefs	       (xmlDoc *doc,
 					const xmlChar *ID);

 /**
@@ -285,114 +285,114 @@ XMLPUBFUN xmlListPtr
 */
 #ifdef LIBXML_VALID_ENABLED
 /* Allocate/Release Validation Contexts */
-XMLPUBFUN xmlValidCtxtPtr
+XMLPUBFUN xmlValidCtxt *
 		xmlNewValidCtxt(void);
 XMLPUBFUN void
-		xmlFreeValidCtxt(xmlValidCtxtPtr);
+		xmlFreeValidCtxt(xmlValidCtxt *);

 XML_DEPRECATED
 XMLPUBFUN int
-		xmlValidateRoot		(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc);
+		xmlValidateRoot		(xmlValidCtxt *ctxt,
+					 xmlDoc *doc);
 XML_DEPRECATED
 XMLPUBFUN int
-		xmlValidateElementDecl	(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
-		                         xmlElementPtr elem);
+		xmlValidateElementDecl	(xmlValidCtxt *ctxt,
+					 xmlDoc *doc,
+		                         xmlElement *elem);
 XML_DEPRECATED
 XMLPUBFUN xmlChar *
-		xmlValidNormalizeAttributeValue(xmlDocPtr doc,
-					 xmlNodePtr elem,
+		xmlValidNormalizeAttributeValue(xmlDoc *doc,
+					 xmlNode *elem,
 					 const xmlChar *name,
 					 const xmlChar *value);
 XML_DEPRECATED
 XMLPUBFUN xmlChar *
-		xmlValidCtxtNormalizeAttributeValue(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
-					 xmlNodePtr elem,
+		xmlValidCtxtNormalizeAttributeValue(xmlValidCtxt *ctxt,
+					 xmlDoc *doc,
+					 xmlNode *elem,
 					 const xmlChar *name,
 					 const xmlChar *value);
 XML_DEPRECATED
 XMLPUBFUN int
-		xmlValidateAttributeDecl(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
-		                         xmlAttributePtr attr);
+		xmlValidateAttributeDecl(xmlValidCtxt *ctxt,
+					 xmlDoc *doc,
+		                         xmlAttribute *attr);
 XML_DEPRECATED
 XMLPUBFUN int
 		xmlValidateAttributeValue(xmlAttributeType type,
 					 const xmlChar *value);
 XML_DEPRECATED
 XMLPUBFUN int
-		xmlValidateNotationDecl	(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
-		                         xmlNotationPtr nota);
+		xmlValidateNotationDecl	(xmlValidCtxt *ctxt,
+					 xmlDoc *doc,
+		                         xmlNotation *nota);
 XMLPUBFUN int
-		xmlValidateDtd		(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
-					 xmlDtdPtr dtd);
+		xmlValidateDtd		(xmlValidCtxt *ctxt,
+					 xmlDoc *doc,
+					 xmlDtd *dtd);
 XML_DEPRECATED
 XMLPUBFUN int
-		xmlValidateDtdFinal	(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc);
+		xmlValidateDtdFinal	(xmlValidCtxt *ctxt,
+					 xmlDoc *doc);
 XMLPUBFUN int
-		xmlValidateDocument	(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc);
+		xmlValidateDocument	(xmlValidCtxt *ctxt,
+					 xmlDoc *doc);
 XMLPUBFUN int
-		xmlValidateElement	(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
-					 xmlNodePtr elem);
+		xmlValidateElement	(xmlValidCtxt *ctxt,
+					 xmlDoc *doc,
+					 xmlNode *elem);
 XML_DEPRECATED
 XMLPUBFUN int
-		xmlValidateOneElement	(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
-		                         xmlNodePtr elem);
+		xmlValidateOneElement	(xmlValidCtxt *ctxt,
+					 xmlDoc *doc,
+		                         xmlNode *elem);
 XML_DEPRECATED
 XMLPUBFUN int
-		xmlValidateOneAttribute	(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
-					 xmlNodePtr	elem,
-					 xmlAttrPtr attr,
+		xmlValidateOneAttribute	(xmlValidCtxt *ctxt,
+					 xmlDoc *doc,
+					 xmlNode 	*elem,
+					 xmlAttr *attr,
 					 const xmlChar *value);
 XML_DEPRECATED
 XMLPUBFUN int
-		xmlValidateOneNamespace	(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
-					 xmlNodePtr elem,
+		xmlValidateOneNamespace	(xmlValidCtxt *ctxt,
+					 xmlDoc *doc,
+					 xmlNode *elem,
 					 const xmlChar *prefix,
-					 xmlNsPtr ns,
+					 xmlNs *ns,
 					 const xmlChar *value);
 XML_DEPRECATED
 XMLPUBFUN int
-		xmlValidateDocumentFinal(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc);
+		xmlValidateDocumentFinal(xmlValidCtxt *ctxt,
+					 xmlDoc *doc);
 XML_DEPRECATED
 XMLPUBFUN int
-		xmlValidateNotationUse	(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
+		xmlValidateNotationUse	(xmlValidCtxt *ctxt,
+					 xmlDoc *doc,
 					 const xmlChar *notationName);
 #endif /* LIBXML_VALID_ENABLED */

 XMLPUBFUN int
-		xmlIsMixedElement	(xmlDocPtr doc,
+		xmlIsMixedElement	(xmlDoc *doc,
 					 const xmlChar *name);
-XMLPUBFUN xmlAttributePtr
-		xmlGetDtdAttrDesc	(xmlDtdPtr dtd,
+XMLPUBFUN xmlAttribute *
+		xmlGetDtdAttrDesc	(xmlDtd *dtd,
 					 const xmlChar *elem,
 					 const xmlChar *name);
-XMLPUBFUN xmlAttributePtr
-		xmlGetDtdQAttrDesc	(xmlDtdPtr dtd,
+XMLPUBFUN xmlAttribute *
+		xmlGetDtdQAttrDesc	(xmlDtd *dtd,
 					 const xmlChar *elem,
 					 const xmlChar *name,
 					 const xmlChar *prefix);
-XMLPUBFUN xmlNotationPtr
-		xmlGetDtdNotationDesc	(xmlDtdPtr dtd,
+XMLPUBFUN xmlNotation *
+		xmlGetDtdNotationDesc	(xmlDtd *dtd,
 					 const xmlChar *name);
-XMLPUBFUN xmlElementPtr
-		xmlGetDtdQElementDesc	(xmlDtdPtr dtd,
+XMLPUBFUN xmlElement *
+		xmlGetDtdQElementDesc	(xmlDtd *dtd,
 					 const xmlChar *name,
 					 const xmlChar *prefix);
-XMLPUBFUN xmlElementPtr
-		xmlGetDtdElementDesc	(xmlDtdPtr dtd,
+XMLPUBFUN xmlElement *
+		xmlGetDtdElementDesc	(xmlDtd *dtd,
 					 const xmlChar *name);

 #ifdef LIBXML_VALID_ENABLED
@@ -423,25 +423,25 @@ XMLPUBFUN int
 */
 XML_DEPRECATED
 XMLPUBFUN int
-		xmlValidBuildContentModel(xmlValidCtxtPtr ctxt,
-					 xmlElementPtr elem);
+		xmlValidBuildContentModel(xmlValidCtxt *ctxt,
+					 xmlElement *elem);

 XML_DEPRECATED
 XMLPUBFUN int
-		xmlValidatePushElement	(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
-					 xmlNodePtr elem,
+		xmlValidatePushElement	(xmlValidCtxt *ctxt,
+					 xmlDoc *doc,
+					 xmlNode *elem,
 					 const xmlChar *qname);
 XML_DEPRECATED
 XMLPUBFUN int
-		xmlValidatePushCData	(xmlValidCtxtPtr ctxt,
+		xmlValidatePushCData	(xmlValidCtxt *ctxt,
 					 const xmlChar *data,
 					 int len);
 XML_DEPRECATED
 XMLPUBFUN int
-		xmlValidatePopElement	(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
-					 xmlNodePtr elem,
+		xmlValidatePopElement	(xmlValidCtxt *ctxt,
+					 xmlDoc *doc,
+					 xmlNode *elem,
 					 const xmlChar *qname);
 #endif /* LIBXML_REGEXP_ENABLED */

--- a/include/libxml/xinclude.h
+++ b/include/libxml/xinclude.h
@@ -75,46 +75,46 @@ typedef xmlXIncludeCtxt *xmlXIncludeCtxtPtr;
 * standalone processing
 */
 XMLPUBFUN int
-		xmlXIncludeProcess	(xmlDocPtr doc);
+		xmlXIncludeProcess	(xmlDoc *doc);
 XMLPUBFUN int
-		xmlXIncludeProcessFlags	(xmlDocPtr doc,
+		xmlXIncludeProcessFlags	(xmlDoc *doc,
 					 int flags);
 XMLPUBFUN int
-		xmlXIncludeProcessFlagsData(xmlDocPtr doc,
+		xmlXIncludeProcessFlagsData(xmlDoc *doc,
 					 int flags,
 					 void *data);
 XMLPUBFUN int
-                xmlXIncludeProcessTreeFlagsData(xmlNodePtr tree,
+                xmlXIncludeProcessTreeFlagsData(xmlNode *tree,
                                         int flags,
                                         void *data);
 XMLPUBFUN int
-		xmlXIncludeProcessTree	(xmlNodePtr tree);
+		xmlXIncludeProcessTree	(xmlNode *tree);
 XMLPUBFUN int
-		xmlXIncludeProcessTreeFlags(xmlNodePtr tree,
+		xmlXIncludeProcessTreeFlags(xmlNode *tree,
 					 int flags);
 /*
 * contextual processing
 */
-XMLPUBFUN xmlXIncludeCtxtPtr
-		xmlXIncludeNewContext	(xmlDocPtr doc);
+XMLPUBFUN xmlXIncludeCtxt *
+		xmlXIncludeNewContext	(xmlDoc *doc);
 XMLPUBFUN int
-		xmlXIncludeSetFlags	(xmlXIncludeCtxtPtr ctxt,
+		xmlXIncludeSetFlags	(xmlXIncludeCtxt *ctxt,
 					 int flags);
 XMLPUBFUN void
-		xmlXIncludeSetErrorHandler(xmlXIncludeCtxtPtr ctxt,
+		xmlXIncludeSetErrorHandler(xmlXIncludeCtxt *ctxt,
 					 xmlStructuredErrorFunc handler,
 					 void *data);
 XMLPUBFUN void
-		xmlXIncludeSetResourceLoader(xmlXIncludeCtxtPtr ctxt,
+		xmlXIncludeSetResourceLoader(xmlXIncludeCtxt *ctxt,
 					 xmlResourceLoader loader,
 					 void *data);
 XMLPUBFUN int
-		xmlXIncludeGetLastError	(xmlXIncludeCtxtPtr ctxt);
+		xmlXIncludeGetLastError	(xmlXIncludeCtxt *ctxt);
 XMLPUBFUN void
-		xmlXIncludeFreeContext	(xmlXIncludeCtxtPtr ctxt);
+		xmlXIncludeFreeContext	(xmlXIncludeCtxt *ctxt);
 XMLPUBFUN int
-		xmlXIncludeProcessNode	(xmlXIncludeCtxtPtr ctxt,
-					 xmlNodePtr tree);
+		xmlXIncludeProcessNode	(xmlXIncludeCtxt *ctxt,
+					 xmlNode *tree);
 #ifdef __cplusplus
 }
 #endif
--- a/include/libxml/xlink.h
+++ b/include/libxml/xlink.h
@@ -67,7 +67,7 @@ typedef enum {
 * @param ctx  user data pointer
 * @param node  the node to check
 */
-typedef void (*xlinkNodeDetectFunc) (void *ctx, xmlNodePtr node);
+typedef void (*xlinkNodeDetectFunc) (void *ctx, xmlNode *node);

 /*
 * The link detection module interact with the upper layers using
@@ -85,7 +85,7 @@ typedef void (*xlinkNodeDetectFunc) (void *ctx, xmlNodePtr node);
 */
 typedef void
 (*xlinkSimpleLinkFunk)	(void *ctx,
-			 xmlNodePtr node,
+			 xmlNode *node,
 			 const xlinkHRef href,
 			 const xlinkRole role,
 			 const xlinkTitle title);
@@ -109,7 +109,7 @@ typedef void
 */
 typedef void
 (*xlinkExtendedLinkFunk)(void *ctx,
-			 xmlNodePtr node,
+			 xmlNode *node,
 			 int nbLocators,
 			 const xlinkHRef *hrefs,
 			 const xlinkRole *roles,
@@ -136,7 +136,7 @@ typedef void
 */
 typedef void
 (*xlinkExtendedLinkSetFunk)	(void *ctx,
-				 xmlNodePtr node,
+				 xmlNode *node,
 				 int nbLocators,
 				 const xlinkHRef *hrefs,
 				 const xlinkRole *roles,
@@ -174,19 +174,19 @@ XMLPUBFUN void
 * Routines to set/get the default handlers.
 */
 XML_DEPRECATED
-XMLPUBFUN xlinkHandlerPtr
+XMLPUBFUN xlinkHandler *
 		xlinkGetDefaultHandler	(void);
 XML_DEPRECATED
 XMLPUBFUN void
-		xlinkSetDefaultHandler	(xlinkHandlerPtr handler);
+		xlinkSetDefaultHandler	(xlinkHandler *handler);

 /*
 * Link detection module itself.
 */
 XML_DEPRECATED
 XMLPUBFUN xlinkType
-		xlinkIsLink		(xmlDocPtr doc,
-					 xmlNodePtr node);
+		xlinkIsLink		(xmlDoc *doc,
+					 xmlNode *node);

 #ifdef __cplusplus
 }
--- a/include/libxml/xmlIO.h
+++ b/include/libxml/xmlIO.h
@@ -97,10 +97,10 @@ typedef int (*xmlOutputCloseCallback) (void * context);
 *
 * @param URI  the URI to read from
 * @param enc  the requested source encoding
- * @returns the new xmlParserInputBufferPtr in case of success or NULL if no
+ * @returns the new xmlParserInputBuffer in case of success or NULL if no
 *         method was found.
 */
-typedef xmlParserInputBufferPtr
+typedef xmlParserInputBuffer *
 (*xmlParserInputBufferCreateFilenameFunc)(const char *URI, xmlCharEncoding enc);

 /**
@@ -110,12 +110,12 @@ typedef xmlParserInputBufferPtr
 * @param URI  the URI to write to
 * @param encoder  the requested target encoding
 * @param compression  compression level
- * @returns the new xmlOutputBufferPtr in case of success or NULL if no
+ * @returns the new xmlOutputBuffer in case of success or NULL if no
 *         method was found.
 */
-typedef xmlOutputBufferPtr
+typedef xmlOutputBuffer *
 (*xmlOutputBufferCreateFilenameFunc)(const char *URI,
-        xmlCharEncodingHandlerPtr encoder, int compression);
+        xmlCharEncodingHandler *encoder, int compression);

 /**
 * Parser input buffer
@@ -128,10 +128,10 @@ struct _xmlParserInputBuffer {
    xmlInputReadCallback   readcallback;
    xmlInputCloseCallback  closecallback;

-    xmlCharEncodingHandlerPtr encoder; /* I18N conversions to UTF-8 */
+    xmlCharEncodingHandler *encoder; /* I18N conversions to UTF-8 */

-    xmlBufPtr buffer;    /* Local buffer encoded in UTF-8 */
-    xmlBufPtr raw;       /* if encoder != NULL buffer for raw input */
+    xmlBuf *buffer;    /* Local buffer encoded in UTF-8 */
+    xmlBuf *raw;       /* if encoder != NULL buffer for raw input */
    int	compressed;	    /* -1=unknown, 0=not compressed, 1=compressed */
    int error;
    unsigned long rawconsumed;/* amount consumed from raw */
@@ -147,10 +147,10 @@ struct _xmlOutputBuffer {
    xmlOutputWriteCallback  writecallback;
    xmlOutputCloseCallback  closecallback;

-    xmlCharEncodingHandlerPtr encoder; /* I18N conversions to UTF-8 */
+    xmlCharEncodingHandler *encoder; /* I18N conversions to UTF-8 */

-    xmlBufPtr buffer;    /* Local buffer encoded in UTF-8 or ISOLatin */
-    xmlBufPtr conv;      /* if encoder != NULL buffer for output */
+    xmlBuf *buffer;    /* Local buffer encoded in UTF-8 or ISOLatin */
+    xmlBuf *conv;      /* if encoder != NULL buffer for output */
    int written;            /* total number of byte written */
    int error;
 };
@@ -185,45 +185,45 @@ XMLPUBFUN int

 XMLPUBFUN void
 	xmlRegisterDefaultInputCallbacks	(void);
-XMLPUBFUN xmlParserInputBufferPtr
+XMLPUBFUN xmlParserInputBuffer *
 	xmlAllocParserInputBuffer		(xmlCharEncoding enc);

-XMLPUBFUN xmlParserInputBufferPtr
+XMLPUBFUN xmlParserInputBuffer *
 	xmlParserInputBufferCreateFilename	(const char *URI,
                                                 xmlCharEncoding enc);
 XML_DEPRECATED
-XMLPUBFUN xmlParserInputBufferPtr
+XMLPUBFUN xmlParserInputBuffer *
 	xmlParserInputBufferCreateFile		(FILE *file,
                                                 xmlCharEncoding enc);
-XMLPUBFUN xmlParserInputBufferPtr
+XMLPUBFUN xmlParserInputBuffer *
 	xmlParserInputBufferCreateFd		(int fd,
 	                                         xmlCharEncoding enc);
-XMLPUBFUN xmlParserInputBufferPtr
+XMLPUBFUN xmlParserInputBuffer *
 	xmlParserInputBufferCreateMem		(const char *mem, int size,
 	                                         xmlCharEncoding enc);
-XMLPUBFUN xmlParserInputBufferPtr
+XMLPUBFUN xmlParserInputBuffer *
 	xmlParserInputBufferCreateStatic	(const char *mem, int size,
 	                                         xmlCharEncoding enc);
-XMLPUBFUN xmlParserInputBufferPtr
+XMLPUBFUN xmlParserInputBuffer *
 	xmlParserInputBufferCreateIO		(xmlInputReadCallback   ioread,
 						 xmlInputCloseCallback  ioclose,
 						 void *ioctx,
 	                                         xmlCharEncoding enc);
 XML_DEPRECATED
 XMLPUBFUN int
-	xmlParserInputBufferRead		(xmlParserInputBufferPtr in,
+	xmlParserInputBufferRead		(xmlParserInputBuffer *in,
 						 int len);
 XML_DEPRECATED
 XMLPUBFUN int
-	xmlParserInputBufferGrow		(xmlParserInputBufferPtr in,
+	xmlParserInputBufferGrow		(xmlParserInputBuffer *in,
 						 int len);
 XML_DEPRECATED
 XMLPUBFUN int
-	xmlParserInputBufferPush		(xmlParserInputBufferPtr in,
+	xmlParserInputBufferPush		(xmlParserInputBuffer *in,
 						 int len,
 						 const char *buf);
 XMLPUBFUN void
-	xmlFreeParserInputBuffer		(xmlParserInputBufferPtr in);
+	xmlFreeParserInputBuffer		(xmlParserInputBuffer *in);
 XMLPUBFUN char *
 	xmlParserGetDirectory			(const char *filename);

@@ -233,7 +233,7 @@ XMLPUBFUN int
 						 xmlInputReadCallback readFunc,
 						 xmlInputCloseCallback closeFunc);

-XMLPUBFUN xmlParserInputBufferPtr
+XMLPUBFUN xmlParserInputBuffer *
 	__xmlParserInputBufferCreateFilename(const char *URI,
 						xmlCharEncoding enc);

@@ -247,54 +247,54 @@ XMLPUBFUN int
 	xmlPopOutputCallbacks			(void);
 XMLPUBFUN void
 	xmlRegisterDefaultOutputCallbacks(void);
-XMLPUBFUN xmlOutputBufferPtr
-	xmlAllocOutputBuffer		(xmlCharEncodingHandlerPtr encoder);
+XMLPUBFUN xmlOutputBuffer *
+	xmlAllocOutputBuffer		(xmlCharEncodingHandler *encoder);

-XMLPUBFUN xmlOutputBufferPtr
+XMLPUBFUN xmlOutputBuffer *
 	xmlOutputBufferCreateFilename	(const char *URI,
-					 xmlCharEncodingHandlerPtr encoder,
+					 xmlCharEncodingHandler *encoder,
 					 int compression);

-XMLPUBFUN xmlOutputBufferPtr
+XMLPUBFUN xmlOutputBuffer *
 	xmlOutputBufferCreateFile	(FILE *file,
-					 xmlCharEncodingHandlerPtr encoder);
+					 xmlCharEncodingHandler *encoder);

-XMLPUBFUN xmlOutputBufferPtr
-	xmlOutputBufferCreateBuffer	(xmlBufferPtr buffer,
-					 xmlCharEncodingHandlerPtr encoder);
+XMLPUBFUN xmlOutputBuffer *
+	xmlOutputBufferCreateBuffer	(xmlBuffer *buffer,
+					 xmlCharEncodingHandler *encoder);

-XMLPUBFUN xmlOutputBufferPtr
+XMLPUBFUN xmlOutputBuffer *
 	xmlOutputBufferCreateFd		(int fd,
-					 xmlCharEncodingHandlerPtr encoder);
+					 xmlCharEncodingHandler *encoder);

-XMLPUBFUN xmlOutputBufferPtr
+XMLPUBFUN xmlOutputBuffer *
 	xmlOutputBufferCreateIO		(xmlOutputWriteCallback   iowrite,
 					 xmlOutputCloseCallback  ioclose,
 					 void *ioctx,
-					 xmlCharEncodingHandlerPtr encoder);
+					 xmlCharEncodingHandler *encoder);

 /* Couple of APIs to get the output without digging into the buffers */
 XMLPUBFUN const xmlChar *
-        xmlOutputBufferGetContent       (xmlOutputBufferPtr out);
+        xmlOutputBufferGetContent       (xmlOutputBuffer *out);
 XMLPUBFUN size_t
-        xmlOutputBufferGetSize          (xmlOutputBufferPtr out);
+        xmlOutputBufferGetSize          (xmlOutputBuffer *out);

 XMLPUBFUN int
-	xmlOutputBufferWrite		(xmlOutputBufferPtr out,
+	xmlOutputBufferWrite		(xmlOutputBuffer *out,
 					 int len,
 					 const char *buf);
 XMLPUBFUN int
-	xmlOutputBufferWriteString	(xmlOutputBufferPtr out,
+	xmlOutputBufferWriteString	(xmlOutputBuffer *out,
 					 const char *str);
 XMLPUBFUN int
-	xmlOutputBufferWriteEscape	(xmlOutputBufferPtr out,
+	xmlOutputBufferWriteEscape	(xmlOutputBuffer *out,
 					 const xmlChar *str,
 					 xmlCharEncodingOutputFunc escaping);

 XMLPUBFUN int
-	xmlOutputBufferFlush		(xmlOutputBufferPtr out);
+	xmlOutputBufferFlush		(xmlOutputBuffer *out);
 XMLPUBFUN int
-	xmlOutputBufferClose		(xmlOutputBufferPtr out);
+	xmlOutputBufferClose		(xmlOutputBuffer *out);

 XMLPUBFUN int
 	xmlRegisterOutputCallbacks	(xmlOutputMatchCallback matchFunc,
@@ -302,22 +302,22 @@ XMLPUBFUN int
 					 xmlOutputWriteCallback writeFunc,
 					 xmlOutputCloseCallback closeFunc);

-XMLPUBFUN xmlOutputBufferPtr
+XMLPUBFUN xmlOutputBuffer *
 	__xmlOutputBufferCreateFilename(const char *URI,
-                              xmlCharEncodingHandlerPtr encoder,
+                              xmlCharEncodingHandler *encoder,
                              int compression);
 #endif /* LIBXML_OUTPUT_ENABLED */

 XML_DEPRECATED
-XMLPUBFUN xmlParserInputPtr
-	xmlCheckHTTPInput		(xmlParserCtxtPtr ctxt,
-					 xmlParserInputPtr ret);
+XMLPUBFUN xmlParserInput *
+	xmlCheckHTTPInput		(xmlParserCtxt *ctxt,
+					 xmlParserInput *ret);

 XML_DEPRECATED
-XMLPUBFUN xmlParserInputPtr
+XMLPUBFUN xmlParserInput *
 	xmlNoNetExternalEntityLoader	(const char *URL,
 					 const char *ID,
-					 xmlParserCtxtPtr ctxt);
+					 xmlParserCtxt *ctxt);

 XML_DEPRECATED
 XMLPUBFUN xmlChar *
--- a/include/libxml/xmlautomata.h
+++ b/include/libxml/xmlautomata.h
@@ -39,119 +39,119 @@ typedef xmlAutomataState *xmlAutomataStatePtr;
 * Building API
 */
 XML_DEPRECATED
-XMLPUBFUN xmlAutomataPtr
+XMLPUBFUN xmlAutomata *
 		    xmlNewAutomata		(void);
 XML_DEPRECATED
 XMLPUBFUN void
-		    xmlFreeAutomata		(xmlAutomataPtr am);
+		    xmlFreeAutomata		(xmlAutomata *am);

 XML_DEPRECATED
-XMLPUBFUN xmlAutomataStatePtr
-		    xmlAutomataGetInitState	(xmlAutomataPtr am);
+XMLPUBFUN xmlAutomataState *
+		    xmlAutomataGetInitState	(xmlAutomata *am);
 XML_DEPRECATED
 XMLPUBFUN int
-		    xmlAutomataSetFinalState	(xmlAutomataPtr am,
-						 xmlAutomataStatePtr state);
+		    xmlAutomataSetFinalState	(xmlAutomata *am,
+						 xmlAutomataState *state);
 XML_DEPRECATED
-XMLPUBFUN xmlAutomataStatePtr
-		    xmlAutomataNewState		(xmlAutomataPtr am);
+XMLPUBFUN xmlAutomataState *
+		    xmlAutomataNewState		(xmlAutomata *am);
 XML_DEPRECATED
-XMLPUBFUN xmlAutomataStatePtr
-		    xmlAutomataNewTransition	(xmlAutomataPtr am,
-						 xmlAutomataStatePtr from,
-						 xmlAutomataStatePtr to,
+XMLPUBFUN xmlAutomataState *
+		    xmlAutomataNewTransition	(xmlAutomata *am,
+						 xmlAutomataState *from,
+						 xmlAutomataState *to,
 						 const xmlChar *token,
 						 void *data);
 XML_DEPRECATED
-XMLPUBFUN xmlAutomataStatePtr
-		    xmlAutomataNewTransition2	(xmlAutomataPtr am,
-						 xmlAutomataStatePtr from,
-						 xmlAutomataStatePtr to,
+XMLPUBFUN xmlAutomataState *
+		    xmlAutomataNewTransition2	(xmlAutomata *am,
+						 xmlAutomataState *from,
+						 xmlAutomataState *to,
 						 const xmlChar *token,
 						 const xmlChar *token2,
 						 void *data);
 XML_DEPRECATED
-XMLPUBFUN xmlAutomataStatePtr
-                    xmlAutomataNewNegTrans	(xmlAutomataPtr am,
-						 xmlAutomataStatePtr from,
-						 xmlAutomataStatePtr to,
+XMLPUBFUN xmlAutomataState *
+                    xmlAutomataNewNegTrans	(xmlAutomata *am,
+						 xmlAutomataState *from,
+						 xmlAutomataState *to,
 						 const xmlChar *token,
 						 const xmlChar *token2,
 						 void *data);

 XML_DEPRECATED
-XMLPUBFUN xmlAutomataStatePtr
-		    xmlAutomataNewCountTrans	(xmlAutomataPtr am,
-						 xmlAutomataStatePtr from,
-						 xmlAutomataStatePtr to,
+XMLPUBFUN xmlAutomataState *
+		    xmlAutomataNewCountTrans	(xmlAutomata *am,
+						 xmlAutomataState *from,
+						 xmlAutomataState *to,
 						 const xmlChar *token,
 						 int min,
 						 int max,
 						 void *data);
 XML_DEPRECATED
-XMLPUBFUN xmlAutomataStatePtr
-		    xmlAutomataNewCountTrans2	(xmlAutomataPtr am,
-						 xmlAutomataStatePtr from,
-						 xmlAutomataStatePtr to,
+XMLPUBFUN xmlAutomataState *
+		    xmlAutomataNewCountTrans2	(xmlAutomata *am,
+						 xmlAutomataState *from,
+						 xmlAutomataState *to,
 						 const xmlChar *token,
 						 const xmlChar *token2,
 						 int min,
 						 int max,
 						 void *data);
 XML_DEPRECATED
-XMLPUBFUN xmlAutomataStatePtr
-		    xmlAutomataNewOnceTrans	(xmlAutomataPtr am,
-						 xmlAutomataStatePtr from,
-						 xmlAutomataStatePtr to,
+XMLPUBFUN xmlAutomataState *
+		    xmlAutomataNewOnceTrans	(xmlAutomata *am,
+						 xmlAutomataState *from,
+						 xmlAutomataState *to,
 						 const xmlChar *token,
 						 int min,
 						 int max,
 						 void *data);
 XML_DEPRECATED
-XMLPUBFUN xmlAutomataStatePtr
-		    xmlAutomataNewOnceTrans2	(xmlAutomataPtr am,
-						 xmlAutomataStatePtr from,
-						 xmlAutomataStatePtr to,
+XMLPUBFUN xmlAutomataState *
+		    xmlAutomataNewOnceTrans2	(xmlAutomata *am,
+						 xmlAutomataState *from,
+						 xmlAutomataState *to,
 						 const xmlChar *token,
 						 const xmlChar *token2,
 						 int min,
 						 int max,
 						 void *data);
 XML_DEPRECATED
-XMLPUBFUN xmlAutomataStatePtr
-		    xmlAutomataNewAllTrans	(xmlAutomataPtr am,
-						 xmlAutomataStatePtr from,
-						 xmlAutomataStatePtr to,
+XMLPUBFUN xmlAutomataState *
+		    xmlAutomataNewAllTrans	(xmlAutomata *am,
+						 xmlAutomataState *from,
+						 xmlAutomataState *to,
 						 int lax);
 XML_DEPRECATED
-XMLPUBFUN xmlAutomataStatePtr
-		    xmlAutomataNewEpsilon	(xmlAutomataPtr am,
-						 xmlAutomataStatePtr from,
-						 xmlAutomataStatePtr to);
+XMLPUBFUN xmlAutomataState *
+		    xmlAutomataNewEpsilon	(xmlAutomata *am,
+						 xmlAutomataState *from,
+						 xmlAutomataState *to);
 XML_DEPRECATED
-XMLPUBFUN xmlAutomataStatePtr
-		    xmlAutomataNewCountedTrans	(xmlAutomataPtr am,
-						 xmlAutomataStatePtr from,
-						 xmlAutomataStatePtr to,
+XMLPUBFUN xmlAutomataState *
+		    xmlAutomataNewCountedTrans	(xmlAutomata *am,
+						 xmlAutomataState *from,
+						 xmlAutomataState *to,
 						 int counter);
 XML_DEPRECATED
-XMLPUBFUN xmlAutomataStatePtr
-		    xmlAutomataNewCounterTrans	(xmlAutomataPtr am,
-						 xmlAutomataStatePtr from,
-						 xmlAutomataStatePtr to,
+XMLPUBFUN xmlAutomataState *
+		    xmlAutomataNewCounterTrans	(xmlAutomata *am,
+						 xmlAutomataState *from,
+						 xmlAutomataState *to,
 						 int counter);
 XML_DEPRECATED
 XMLPUBFUN int
-		    xmlAutomataNewCounter	(xmlAutomataPtr am,
+		    xmlAutomataNewCounter	(xmlAutomata *am,
 						 int min,
 						 int max);

 XML_DEPRECATED
 XMLPUBFUN struct _xmlRegexp *
-		    xmlAutomataCompile		(xmlAutomataPtr am);
+		    xmlAutomataCompile		(xmlAutomata *am);
 XML_DEPRECATED
 XMLPUBFUN int
-		    xmlAutomataIsDeterminist	(xmlAutomataPtr am);
+		    xmlAutomataIsDeterminist	(xmlAutomata *am);

 #ifdef __cplusplus
 }
--- a/include/libxml/xmlerror.h
+++ b/include/libxml/xmlerror.h
@@ -1024,10 +1024,10 @@ XMLPUBFUN const xmlError *
 XMLPUBFUN void
    xmlCtxtResetLastError	(void *ctx);
 XMLPUBFUN void
-    xmlResetError		(xmlErrorPtr err);
+    xmlResetError		(xmlError *err);
 XMLPUBFUN int
    xmlCopyError		(const xmlError *from,
-				 xmlErrorPtr to);
+				 xmlError *to);

 #ifdef __cplusplus
 }
--- a/include/libxml/xmlmodule.h
+++ b/include/libxml/xmlmodule.h
@@ -37,19 +37,19 @@ typedef enum {
 } xmlModuleOption;

 XML_DEPRECATED
-XMLPUBFUN xmlModulePtr xmlModuleOpen	(const char *filename,
+XMLPUBFUN xmlModule *xmlModuleOpen	(const char *filename,
 						 int options);

 XML_DEPRECATED
-XMLPUBFUN int xmlModuleSymbol		(xmlModulePtr module,
+XMLPUBFUN int xmlModuleSymbol		(xmlModule *module,
 						 const char* name,
 						 void **result);

 XML_DEPRECATED
-XMLPUBFUN int xmlModuleClose		(xmlModulePtr module);
+XMLPUBFUN int xmlModuleClose		(xmlModule *module);

 XML_DEPRECATED
-XMLPUBFUN int xmlModuleFree		(xmlModulePtr module);
+XMLPUBFUN int xmlModuleFree		(xmlModule *module);

 #ifdef __cplusplus
 }
--- a/include/libxml/xmlreader.h
+++ b/include/libxml/xmlreader.h
@@ -125,246 +125,246 @@ typedef xmlTextReader *xmlTextReaderPtr;
 /*
 * Constructors & Destructor
 */
-XMLPUBFUN xmlTextReaderPtr
-			xmlNewTextReader	(xmlParserInputBufferPtr input,
+XMLPUBFUN xmlTextReader *
+			xmlNewTextReader	(xmlParserInputBuffer *input,
 	                                         const char *URI);
-XMLPUBFUN xmlTextReaderPtr
+XMLPUBFUN xmlTextReader *
 			xmlNewTextReaderFilename(const char *URI);

 XMLPUBFUN void
-			xmlFreeTextReader	(xmlTextReaderPtr reader);
+			xmlFreeTextReader	(xmlTextReader *reader);

 XMLPUBFUN int
-            xmlTextReaderSetup(xmlTextReaderPtr reader,
-                   xmlParserInputBufferPtr input, const char *URL,
+            xmlTextReaderSetup(xmlTextReader *reader,
+                   xmlParserInputBuffer *input, const char *URL,
                   const char *encoding, int options);
 XMLPUBFUN void
-            xmlTextReaderSetMaxAmplification(xmlTextReaderPtr reader,
+            xmlTextReaderSetMaxAmplification(xmlTextReader *reader,
                   unsigned maxAmpl);
 XMLPUBFUN const xmlError *
-            xmlTextReaderGetLastError(xmlTextReaderPtr reader);
+            xmlTextReaderGetLastError(xmlTextReader *reader);

 /*
 * Iterators
 */
 XMLPUBFUN int
-			xmlTextReaderRead	(xmlTextReaderPtr reader);
+			xmlTextReaderRead	(xmlTextReader *reader);

 #ifdef LIBXML_WRITER_ENABLED
 XMLPUBFUN xmlChar *
-			xmlTextReaderReadInnerXml(xmlTextReaderPtr reader);
+			xmlTextReaderReadInnerXml(xmlTextReader *reader);

 XMLPUBFUN xmlChar *
-			xmlTextReaderReadOuterXml(xmlTextReaderPtr reader);
+			xmlTextReaderReadOuterXml(xmlTextReader *reader);
 #endif

 XMLPUBFUN xmlChar *
-			xmlTextReaderReadString	(xmlTextReaderPtr reader);
+			xmlTextReaderReadString	(xmlTextReader *reader);
 XMLPUBFUN int
-			xmlTextReaderReadAttributeValue(xmlTextReaderPtr reader);
+			xmlTextReaderReadAttributeValue(xmlTextReader *reader);

 /*
 * Attributes of the node
 */
 XMLPUBFUN int
-			xmlTextReaderAttributeCount(xmlTextReaderPtr reader);
+			xmlTextReaderAttributeCount(xmlTextReader *reader);
 XMLPUBFUN int
-			xmlTextReaderDepth	(xmlTextReaderPtr reader);
+			xmlTextReaderDepth	(xmlTextReader *reader);
 XMLPUBFUN int
-			xmlTextReaderHasAttributes(xmlTextReaderPtr reader);
+			xmlTextReaderHasAttributes(xmlTextReader *reader);
 XMLPUBFUN int
-			xmlTextReaderHasValue(xmlTextReaderPtr reader);
+			xmlTextReaderHasValue(xmlTextReader *reader);
 XMLPUBFUN int
-			xmlTextReaderIsDefault	(xmlTextReaderPtr reader);
+			xmlTextReaderIsDefault	(xmlTextReader *reader);
 XMLPUBFUN int
-			xmlTextReaderIsEmptyElement(xmlTextReaderPtr reader);
+			xmlTextReaderIsEmptyElement(xmlTextReader *reader);
 XMLPUBFUN int
-			xmlTextReaderNodeType	(xmlTextReaderPtr reader);
+			xmlTextReaderNodeType	(xmlTextReader *reader);
 XMLPUBFUN int
-			xmlTextReaderQuoteChar	(xmlTextReaderPtr reader);
+			xmlTextReaderQuoteChar	(xmlTextReader *reader);
 XMLPUBFUN int
-			xmlTextReaderReadState	(xmlTextReaderPtr reader);
+			xmlTextReaderReadState	(xmlTextReader *reader);
 XMLPUBFUN int
-                        xmlTextReaderIsNamespaceDecl(xmlTextReaderPtr reader);
+                        xmlTextReaderIsNamespaceDecl(xmlTextReader *reader);

 XMLPUBFUN const xmlChar *
-		    xmlTextReaderConstBaseUri	(xmlTextReaderPtr reader);
+		    xmlTextReaderConstBaseUri	(xmlTextReader *reader);
 XMLPUBFUN const xmlChar *
-		    xmlTextReaderConstLocalName	(xmlTextReaderPtr reader);
+		    xmlTextReaderConstLocalName	(xmlTextReader *reader);
 XMLPUBFUN const xmlChar *
-		    xmlTextReaderConstName	(xmlTextReaderPtr reader);
+		    xmlTextReaderConstName	(xmlTextReader *reader);
 XMLPUBFUN const xmlChar *
-		    xmlTextReaderConstNamespaceUri(xmlTextReaderPtr reader);
+		    xmlTextReaderConstNamespaceUri(xmlTextReader *reader);
 XMLPUBFUN const xmlChar *
-		    xmlTextReaderConstPrefix	(xmlTextReaderPtr reader);
+		    xmlTextReaderConstPrefix	(xmlTextReader *reader);
 XMLPUBFUN const xmlChar *
-		    xmlTextReaderConstXmlLang	(xmlTextReaderPtr reader);
+		    xmlTextReaderConstXmlLang	(xmlTextReader *reader);
 XMLPUBFUN const xmlChar *
-		    xmlTextReaderConstString	(xmlTextReaderPtr reader,
+		    xmlTextReaderConstString	(xmlTextReader *reader,
 						 const xmlChar *str);
 XMLPUBFUN const xmlChar *
-		    xmlTextReaderConstValue	(xmlTextReaderPtr reader);
+		    xmlTextReaderConstValue	(xmlTextReader *reader);

 /*
 * use the Const version of the routine for
 * better performance and simpler code
 */
 XMLPUBFUN xmlChar *
-			xmlTextReaderBaseUri	(xmlTextReaderPtr reader);
+			xmlTextReaderBaseUri	(xmlTextReader *reader);
 XMLPUBFUN xmlChar *
-			xmlTextReaderLocalName	(xmlTextReaderPtr reader);
+			xmlTextReaderLocalName	(xmlTextReader *reader);
 XMLPUBFUN xmlChar *
-			xmlTextReaderName	(xmlTextReaderPtr reader);
+			xmlTextReaderName	(xmlTextReader *reader);
 XMLPUBFUN xmlChar *
-			xmlTextReaderNamespaceUri(xmlTextReaderPtr reader);
+			xmlTextReaderNamespaceUri(xmlTextReader *reader);
 XMLPUBFUN xmlChar *
-			xmlTextReaderPrefix	(xmlTextReaderPtr reader);
+			xmlTextReaderPrefix	(xmlTextReader *reader);
 XMLPUBFUN xmlChar *
-			xmlTextReaderXmlLang	(xmlTextReaderPtr reader);
+			xmlTextReaderXmlLang	(xmlTextReader *reader);
 XMLPUBFUN xmlChar *
-			xmlTextReaderValue	(xmlTextReaderPtr reader);
+			xmlTextReaderValue	(xmlTextReader *reader);

 /*
 * Methods of the XmlTextReader
 */
 XMLPUBFUN int
-		    xmlTextReaderClose		(xmlTextReaderPtr reader);
+		    xmlTextReaderClose		(xmlTextReader *reader);
 XMLPUBFUN xmlChar *
-		    xmlTextReaderGetAttributeNo	(xmlTextReaderPtr reader,
+		    xmlTextReaderGetAttributeNo	(xmlTextReader *reader,
 						 int no);
 XMLPUBFUN xmlChar *
-		    xmlTextReaderGetAttribute	(xmlTextReaderPtr reader,
+		    xmlTextReaderGetAttribute	(xmlTextReader *reader,
 						 const xmlChar *name);
 XMLPUBFUN xmlChar *
-		    xmlTextReaderGetAttributeNs	(xmlTextReaderPtr reader,
+		    xmlTextReaderGetAttributeNs	(xmlTextReader *reader,
 						 const xmlChar *localName,
 						 const xmlChar *namespaceURI);
-XMLPUBFUN xmlParserInputBufferPtr
-		    xmlTextReaderGetRemainder	(xmlTextReaderPtr reader);
+XMLPUBFUN xmlParserInputBuffer *
+		    xmlTextReaderGetRemainder	(xmlTextReader *reader);
 XMLPUBFUN xmlChar *
-		    xmlTextReaderLookupNamespace(xmlTextReaderPtr reader,
+		    xmlTextReaderLookupNamespace(xmlTextReader *reader,
 						 const xmlChar *prefix);
 XMLPUBFUN int
-		    xmlTextReaderMoveToAttributeNo(xmlTextReaderPtr reader,
+		    xmlTextReaderMoveToAttributeNo(xmlTextReader *reader,
 						 int no);
 XMLPUBFUN int
-		    xmlTextReaderMoveToAttribute(xmlTextReaderPtr reader,
+		    xmlTextReaderMoveToAttribute(xmlTextReader *reader,
 						 const xmlChar *name);
 XMLPUBFUN int
-		    xmlTextReaderMoveToAttributeNs(xmlTextReaderPtr reader,
+		    xmlTextReaderMoveToAttributeNs(xmlTextReader *reader,
 						 const xmlChar *localName,
 						 const xmlChar *namespaceURI);
 XMLPUBFUN int
-		    xmlTextReaderMoveToFirstAttribute(xmlTextReaderPtr reader);
+		    xmlTextReaderMoveToFirstAttribute(xmlTextReader *reader);
 XMLPUBFUN int
-		    xmlTextReaderMoveToNextAttribute(xmlTextReaderPtr reader);
+		    xmlTextReaderMoveToNextAttribute(xmlTextReader *reader);
 XMLPUBFUN int
-		    xmlTextReaderMoveToElement	(xmlTextReaderPtr reader);
+		    xmlTextReaderMoveToElement	(xmlTextReader *reader);
 XMLPUBFUN int
-		    xmlTextReaderNormalization	(xmlTextReaderPtr reader);
+		    xmlTextReaderNormalization	(xmlTextReader *reader);
 XMLPUBFUN const xmlChar *
-		    xmlTextReaderConstEncoding  (xmlTextReaderPtr reader);
+		    xmlTextReaderConstEncoding  (xmlTextReader *reader);

 /*
 * Extensions
 */
 XMLPUBFUN int
-		    xmlTextReaderSetParserProp	(xmlTextReaderPtr reader,
+		    xmlTextReaderSetParserProp	(xmlTextReader *reader,
 						 int prop,
 						 int value);
 XMLPUBFUN int
-		    xmlTextReaderGetParserProp	(xmlTextReaderPtr reader,
+		    xmlTextReaderGetParserProp	(xmlTextReader *reader,
 						 int prop);
-XMLPUBFUN xmlNodePtr
-		    xmlTextReaderCurrentNode	(xmlTextReaderPtr reader);
+XMLPUBFUN xmlNode *
+		    xmlTextReaderCurrentNode	(xmlTextReader *reader);

 XMLPUBFUN int
-            xmlTextReaderGetParserLineNumber(xmlTextReaderPtr reader);
+            xmlTextReaderGetParserLineNumber(xmlTextReader *reader);

 XMLPUBFUN int
-            xmlTextReaderGetParserColumnNumber(xmlTextReaderPtr reader);
+            xmlTextReaderGetParserColumnNumber(xmlTextReader *reader);

-XMLPUBFUN xmlNodePtr
-		    xmlTextReaderPreserve	(xmlTextReaderPtr reader);
+XMLPUBFUN xmlNode *
+		    xmlTextReaderPreserve	(xmlTextReader *reader);
 #ifdef LIBXML_PATTERN_ENABLED
 XMLPUBFUN int
-		    xmlTextReaderPreservePattern(xmlTextReaderPtr reader,
+		    xmlTextReaderPreservePattern(xmlTextReader *reader,
 						 const xmlChar *pattern,
 						 const xmlChar **namespaces);
 #endif /* LIBXML_PATTERN_ENABLED */
-XMLPUBFUN xmlDocPtr
-		    xmlTextReaderCurrentDoc	(xmlTextReaderPtr reader);
-XMLPUBFUN xmlNodePtr
-		    xmlTextReaderExpand		(xmlTextReaderPtr reader);
+XMLPUBFUN xmlDoc *
+		    xmlTextReaderCurrentDoc	(xmlTextReader *reader);
+XMLPUBFUN xmlNode *
+		    xmlTextReaderExpand		(xmlTextReader *reader);
 XMLPUBFUN int
-		    xmlTextReaderNext		(xmlTextReaderPtr reader);
+		    xmlTextReaderNext		(xmlTextReader *reader);
 XMLPUBFUN int
-		    xmlTextReaderNextSibling	(xmlTextReaderPtr reader);
+		    xmlTextReaderNextSibling	(xmlTextReader *reader);
 XMLPUBFUN int
-		    xmlTextReaderIsValid	(xmlTextReaderPtr reader);
+		    xmlTextReaderIsValid	(xmlTextReader *reader);
 #ifdef LIBXML_RELAXNG_ENABLED
 XMLPUBFUN int
-		    xmlTextReaderRelaxNGValidate(xmlTextReaderPtr reader,
+		    xmlTextReaderRelaxNGValidate(xmlTextReader *reader,
 						 const char *rng);
 XMLPUBFUN int
-		    xmlTextReaderRelaxNGValidateCtxt(xmlTextReaderPtr reader,
-						 xmlRelaxNGValidCtxtPtr ctxt,
+		    xmlTextReaderRelaxNGValidateCtxt(xmlTextReader *reader,
+						 xmlRelaxNGValidCtxt *ctxt,
 						 int options);

 XMLPUBFUN int
-		    xmlTextReaderRelaxNGSetSchema(xmlTextReaderPtr reader,
-						 xmlRelaxNGPtr schema);
+		    xmlTextReaderRelaxNGSetSchema(xmlTextReader *reader,
+						 xmlRelaxNG *schema);
 #endif
 #ifdef LIBXML_SCHEMAS_ENABLED
 XMLPUBFUN int
-		    xmlTextReaderSchemaValidate	(xmlTextReaderPtr reader,
+		    xmlTextReaderSchemaValidate	(xmlTextReader *reader,
 						 const char *xsd);
 XMLPUBFUN int
-		    xmlTextReaderSchemaValidateCtxt(xmlTextReaderPtr reader,
-						 xmlSchemaValidCtxtPtr ctxt,
+		    xmlTextReaderSchemaValidateCtxt(xmlTextReader *reader,
+						 xmlSchemaValidCtxt *ctxt,
 						 int options);
 XMLPUBFUN int
-		    xmlTextReaderSetSchema	(xmlTextReaderPtr reader,
-						 xmlSchemaPtr schema);
+		    xmlTextReaderSetSchema	(xmlTextReader *reader,
+						 xmlSchema *schema);
 #endif
 XMLPUBFUN const xmlChar *
-		    xmlTextReaderConstXmlVersion(xmlTextReaderPtr reader);
+		    xmlTextReaderConstXmlVersion(xmlTextReader *reader);
 XMLPUBFUN int
-		    xmlTextReaderStandalone     (xmlTextReaderPtr reader);
+		    xmlTextReaderStandalone     (xmlTextReader *reader);


 /*
 * Index lookup
 */
 XMLPUBFUN long
-		xmlTextReaderByteConsumed	(xmlTextReaderPtr reader);
+		xmlTextReaderByteConsumed	(xmlTextReader *reader);

 /*
 * New more complete APIs for simpler creation and reuse of readers
 */
-XMLPUBFUN xmlTextReaderPtr
-		xmlReaderWalker		(xmlDocPtr doc);
-XMLPUBFUN xmlTextReaderPtr
+XMLPUBFUN xmlTextReader *
+		xmlReaderWalker		(xmlDoc *doc);
+XMLPUBFUN xmlTextReader *
 		xmlReaderForDoc		(const xmlChar * cur,
 					 const char *URL,
 					 const char *encoding,
 					 int options);
-XMLPUBFUN xmlTextReaderPtr
+XMLPUBFUN xmlTextReader *
 		xmlReaderForFile	(const char *filename,
 					 const char *encoding,
 					 int options);
-XMLPUBFUN xmlTextReaderPtr
+XMLPUBFUN xmlTextReader *
 		xmlReaderForMemory	(const char *buffer,
 					 int size,
 					 const char *URL,
 					 const char *encoding,
 					 int options);
-XMLPUBFUN xmlTextReaderPtr
+XMLPUBFUN xmlTextReader *
 		xmlReaderForFd		(int fd,
 					 const char *URL,
 					 const char *encoding,
 					 int options);
-XMLPUBFUN xmlTextReaderPtr
+XMLPUBFUN xmlTextReader *
 		xmlReaderForIO		(xmlInputReadCallback ioread,
 					 xmlInputCloseCallback ioclose,
 					 void *ioctx,
@@ -373,34 +373,34 @@ XMLPUBFUN xmlTextReaderPtr
 					 int options);

 XMLPUBFUN int
-		xmlReaderNewWalker	(xmlTextReaderPtr reader,
-					 xmlDocPtr doc);
+		xmlReaderNewWalker	(xmlTextReader *reader,
+					 xmlDoc *doc);
 XMLPUBFUN int
-		xmlReaderNewDoc		(xmlTextReaderPtr reader,
+		xmlReaderNewDoc		(xmlTextReader *reader,
 					 const xmlChar * cur,
 					 const char *URL,
 					 const char *encoding,
 					 int options);
 XMLPUBFUN int
-		xmlReaderNewFile	(xmlTextReaderPtr reader,
+		xmlReaderNewFile	(xmlTextReader *reader,
 					 const char *filename,
 					 const char *encoding,
 					 int options);
 XMLPUBFUN int
-		xmlReaderNewMemory	(xmlTextReaderPtr reader,
+		xmlReaderNewMemory	(xmlTextReader *reader,
 					 const char *buffer,
 					 int size,
 					 const char *URL,
 					 const char *encoding,
 					 int options);
 XMLPUBFUN int
-		xmlReaderNewFd		(xmlTextReaderPtr reader,
+		xmlReaderNewFd		(xmlTextReader *reader,
 					 int fd,
 					 const char *URL,
 					 const char *encoding,
 					 int options);
 XMLPUBFUN int
-		xmlReaderNewIO		(xmlTextReaderPtr reader,
+		xmlReaderNewIO		(xmlTextReader *reader,
 					 xmlInputReadCallback ioread,
 					 xmlInputCloseCallback ioclose,
 					 void *ioctx,
@@ -429,20 +429,20 @@ XMLPUBFUN int
 XMLPUBFUN xmlChar *
 	    xmlTextReaderLocatorBaseURI (xmlTextReaderLocatorPtr locator);
 XMLPUBFUN void
-	    xmlTextReaderSetErrorHandler(xmlTextReaderPtr reader,
+	    xmlTextReaderSetErrorHandler(xmlTextReader *reader,
 					 xmlTextReaderErrorFunc f,
 					 void *arg);
 XMLPUBFUN void
-	    xmlTextReaderSetStructuredErrorHandler(xmlTextReaderPtr reader,
+	    xmlTextReaderSetStructuredErrorHandler(xmlTextReader *reader,
 						   xmlStructuredErrorFunc f,
 						   void *arg);
 XMLPUBFUN void
-	    xmlTextReaderGetErrorHandler(xmlTextReaderPtr reader,
+	    xmlTextReaderGetErrorHandler(xmlTextReader *reader,
 					 xmlTextReaderErrorFunc *f,
 					 void **arg);

 XMLPUBFUN void
-	    xmlTextReaderSetResourceLoader(xmlTextReaderPtr reader,
+	    xmlTextReaderSetResourceLoader(xmlTextReader *reader,
 					   xmlResourceLoader loader,
 					   void *data);

--- a/include/libxml/xmlregexp.h
+++ b/include/libxml/xmlregexp.h
@@ -40,18 +40,18 @@ typedef xmlRegExecCtxt *xmlRegExecCtxtPtr;
 /*
 * The POSIX like API
 */
-XMLPUBFUN xmlRegexpPtr
+XMLPUBFUN xmlRegexp *
 		    xmlRegexpCompile	(const xmlChar *regexp);
-XMLPUBFUN void			 xmlRegFreeRegexp(xmlRegexpPtr regexp);
+XMLPUBFUN void			 xmlRegFreeRegexp(xmlRegexp *regexp);
 XMLPUBFUN int
-		    xmlRegexpExec	(xmlRegexpPtr comp,
+		    xmlRegexpExec	(xmlRegexp *comp,
 					 const xmlChar *value);
 XML_DEPRECATED
 XMLPUBFUN void
 		    xmlRegexpPrint	(FILE *output,
-					 xmlRegexpPtr regexp);
+					 xmlRegexp *regexp);
 XMLPUBFUN int
-		    xmlRegexpIsDeterminist(xmlRegexpPtr comp);
+		    xmlRegexpIsDeterminist(xmlRegexp *comp);

 /**
 * Callback function when doing a transition in the automata
@@ -61,7 +61,7 @@ XMLPUBFUN int
 * @param transdata  transition data
 * @param inputdata  input data
 */
-typedef void (*xmlRegExecCallbacks) (xmlRegExecCtxtPtr exec,
+typedef void (*xmlRegExecCallbacks) (xmlRegExecCtxt *exec,
 	                             const xmlChar *token,
 				     void *transdata,
 				     void *inputdata);
@@ -70,35 +70,35 @@ typedef void (*xmlRegExecCallbacks) (xmlRegExecCtxtPtr exec,
 * The progressive API
 */
 XML_DEPRECATED
-XMLPUBFUN xmlRegExecCtxtPtr
-		    xmlRegNewExecCtxt	(xmlRegexpPtr comp,
+XMLPUBFUN xmlRegExecCtxt *
+		    xmlRegNewExecCtxt	(xmlRegexp *comp,
 					 xmlRegExecCallbacks callback,
 					 void *data);
 XML_DEPRECATED
 XMLPUBFUN void
-		    xmlRegFreeExecCtxt	(xmlRegExecCtxtPtr exec);
+		    xmlRegFreeExecCtxt	(xmlRegExecCtxt *exec);
 XML_DEPRECATED
 XMLPUBFUN int
-		    xmlRegExecPushString(xmlRegExecCtxtPtr exec,
+		    xmlRegExecPushString(xmlRegExecCtxt *exec,
 					 const xmlChar *value,
 					 void *data);
 XML_DEPRECATED
 XMLPUBFUN int
-		    xmlRegExecPushString2(xmlRegExecCtxtPtr exec,
+		    xmlRegExecPushString2(xmlRegExecCtxt *exec,
 					 const xmlChar *value,
 					 const xmlChar *value2,
 					 void *data);

 XML_DEPRECATED
 XMLPUBFUN int
-		    xmlRegExecNextValues(xmlRegExecCtxtPtr exec,
+		    xmlRegExecNextValues(xmlRegExecCtxt *exec,
 					 int *nbval,
 					 int *nbneg,
 					 xmlChar **values,
 					 int *terminal);
 XML_DEPRECATED
 XMLPUBFUN int
-		    xmlRegExecErrInfo	(xmlRegExecCtxtPtr exec,
+		    xmlRegExecErrInfo	(xmlRegExecCtxt *exec,
 					 const xmlChar **string,
 					 int *nbval,
 					 int *nbneg,
--- a/include/libxml/xmlsave.h
+++ b/include/libxml/xmlsave.h
@@ -89,21 +89,21 @@ typedef enum {
 typedef struct _xmlSaveCtxt xmlSaveCtxt;
 typedef xmlSaveCtxt *xmlSaveCtxtPtr;

-XMLPUBFUN xmlSaveCtxtPtr
+XMLPUBFUN xmlSaveCtxt *
 		xmlSaveToFd		(int fd,
 					 const char *encoding,
 					 int options);
-XMLPUBFUN xmlSaveCtxtPtr
+XMLPUBFUN xmlSaveCtxt *
 		xmlSaveToFilename	(const char *filename,
 					 const char *encoding,
 					 int options);

-XMLPUBFUN xmlSaveCtxtPtr
-		xmlSaveToBuffer		(xmlBufferPtr buffer,
+XMLPUBFUN xmlSaveCtxt *
+		xmlSaveToBuffer		(xmlBuffer *buffer,
 					 const char *encoding,
 					 int options);

-XMLPUBFUN xmlSaveCtxtPtr
+XMLPUBFUN xmlSaveCtxt *
 		xmlSaveToIO		(xmlOutputWriteCallback iowrite,
 					 xmlOutputCloseCallback ioclose,
 					 void *ioctx,
@@ -111,28 +111,28 @@ XMLPUBFUN xmlSaveCtxtPtr
 					 int options);

 XMLPUBFUN long
-		xmlSaveDoc		(xmlSaveCtxtPtr ctxt,
-					 xmlDocPtr doc);
+		xmlSaveDoc		(xmlSaveCtxt *ctxt,
+					 xmlDoc *doc);
 XMLPUBFUN long
-		xmlSaveTree		(xmlSaveCtxtPtr ctxt,
-					 xmlNodePtr node);
+		xmlSaveTree		(xmlSaveCtxt *ctxt,
+					 xmlNode *node);

 XMLPUBFUN int
-		xmlSaveFlush		(xmlSaveCtxtPtr ctxt);
+		xmlSaveFlush		(xmlSaveCtxt *ctxt);
 XMLPUBFUN int
-		xmlSaveClose		(xmlSaveCtxtPtr ctxt);
+		xmlSaveClose		(xmlSaveCtxt *ctxt);
 XMLPUBFUN xmlParserErrors
-		xmlSaveFinish		(xmlSaveCtxtPtr ctxt);
+		xmlSaveFinish		(xmlSaveCtxt *ctxt);
 XMLPUBFUN int
-		xmlSaveSetIndentString	(xmlSaveCtxtPtr ctxt,
+		xmlSaveSetIndentString	(xmlSaveCtxt *ctxt,
 					 const char *indent);
 XML_DEPRECATED
 XMLPUBFUN int
-		xmlSaveSetEscape	(xmlSaveCtxtPtr ctxt,
+		xmlSaveSetEscape	(xmlSaveCtxt *ctxt,
 					 xmlCharEncodingOutputFunc escape);
 XML_DEPRECATED
 XMLPUBFUN int
-		xmlSaveSetAttrEscape	(xmlSaveCtxtPtr ctxt,
+		xmlSaveSetAttrEscape	(xmlSaveCtxt *ctxt,
 					 xmlCharEncodingOutputFunc escape);

 XML_DEPRECATED
--- a/include/libxml/xmlschemas.h
+++ b/include/libxml/xmlschemas.h
@@ -135,94 +135,94 @@ typedef int (*xmlSchemaValidityLocatorFunc) (void *ctx,
 /*
 * Interfaces for parsing.
 */
-XMLPUBFUN xmlSchemaParserCtxtPtr
+XMLPUBFUN xmlSchemaParserCtxt *
 	    xmlSchemaNewParserCtxt	(const char *URL);
-XMLPUBFUN xmlSchemaParserCtxtPtr
+XMLPUBFUN xmlSchemaParserCtxt *
 	    xmlSchemaNewMemParserCtxt	(const char *buffer,
 					 int size);
-XMLPUBFUN xmlSchemaParserCtxtPtr
-	    xmlSchemaNewDocParserCtxt	(xmlDocPtr doc);
+XMLPUBFUN xmlSchemaParserCtxt *
+	    xmlSchemaNewDocParserCtxt	(xmlDoc *doc);
 XMLPUBFUN void
-	    xmlSchemaFreeParserCtxt	(xmlSchemaParserCtxtPtr ctxt);
+	    xmlSchemaFreeParserCtxt	(xmlSchemaParserCtxt *ctxt);
 XMLPUBFUN void
-	    xmlSchemaSetParserErrors	(xmlSchemaParserCtxtPtr ctxt,
+	    xmlSchemaSetParserErrors	(xmlSchemaParserCtxt *ctxt,
 					 xmlSchemaValidityErrorFunc err,
 					 xmlSchemaValidityWarningFunc warn,
 					 void *ctx);
 XMLPUBFUN void
-	    xmlSchemaSetParserStructuredErrors(xmlSchemaParserCtxtPtr ctxt,
+	    xmlSchemaSetParserStructuredErrors(xmlSchemaParserCtxt *ctxt,
 					 xmlStructuredErrorFunc serror,
 					 void *ctx);
 XMLPUBFUN int
-	    xmlSchemaGetParserErrors	(xmlSchemaParserCtxtPtr ctxt,
+	    xmlSchemaGetParserErrors	(xmlSchemaParserCtxt *ctxt,
 					xmlSchemaValidityErrorFunc * err,
 					xmlSchemaValidityWarningFunc * warn,
 					void **ctx);
 XMLPUBFUN void
-	    xmlSchemaSetResourceLoader	(xmlSchemaParserCtxtPtr ctxt,
+	    xmlSchemaSetResourceLoader	(xmlSchemaParserCtxt *ctxt,
 					 xmlResourceLoader loader,
 					 void *data);
 XMLPUBFUN int
-	    xmlSchemaIsValid		(xmlSchemaValidCtxtPtr ctxt);
+	    xmlSchemaIsValid		(xmlSchemaValidCtxt *ctxt);

-XMLPUBFUN xmlSchemaPtr
-	    xmlSchemaParse		(xmlSchemaParserCtxtPtr ctxt);
+XMLPUBFUN xmlSchema *
+	    xmlSchemaParse		(xmlSchemaParserCtxt *ctxt);
 XMLPUBFUN void
-	    xmlSchemaFree		(xmlSchemaPtr schema);
+	    xmlSchemaFree		(xmlSchema *schema);
 #ifdef LIBXML_DEBUG_ENABLED
 XMLPUBFUN void
 	    xmlSchemaDump		(FILE *output,
-					 xmlSchemaPtr schema);
+					 xmlSchema *schema);
 #endif /* LIBXML_DEBUG_ENABLED */
 /*
 * Interfaces for validating
 */
 XMLPUBFUN void
-	    xmlSchemaSetValidErrors	(xmlSchemaValidCtxtPtr ctxt,
+	    xmlSchemaSetValidErrors	(xmlSchemaValidCtxt *ctxt,
 					 xmlSchemaValidityErrorFunc err,
 					 xmlSchemaValidityWarningFunc warn,
 					 void *ctx);
 XMLPUBFUN void
-	    xmlSchemaSetValidStructuredErrors(xmlSchemaValidCtxtPtr ctxt,
+	    xmlSchemaSetValidStructuredErrors(xmlSchemaValidCtxt *ctxt,
 					 xmlStructuredErrorFunc serror,
 					 void *ctx);
 XMLPUBFUN int
-	    xmlSchemaGetValidErrors	(xmlSchemaValidCtxtPtr ctxt,
+	    xmlSchemaGetValidErrors	(xmlSchemaValidCtxt *ctxt,
 					 xmlSchemaValidityErrorFunc *err,
 					 xmlSchemaValidityWarningFunc *warn,
 					 void **ctx);
 XMLPUBFUN int
-	    xmlSchemaSetValidOptions	(xmlSchemaValidCtxtPtr ctxt,
+	    xmlSchemaSetValidOptions	(xmlSchemaValidCtxt *ctxt,
 					 int options);
 XMLPUBFUN void
-            xmlSchemaValidateSetFilename(xmlSchemaValidCtxtPtr vctxt,
+            xmlSchemaValidateSetFilename(xmlSchemaValidCtxt *vctxt,
 	                                 const char *filename);
 XMLPUBFUN int
-	    xmlSchemaValidCtxtGetOptions(xmlSchemaValidCtxtPtr ctxt);
+	    xmlSchemaValidCtxtGetOptions(xmlSchemaValidCtxt *ctxt);

-XMLPUBFUN xmlSchemaValidCtxtPtr
-	    xmlSchemaNewValidCtxt	(xmlSchemaPtr schema);
+XMLPUBFUN xmlSchemaValidCtxt *
+	    xmlSchemaNewValidCtxt	(xmlSchema *schema);
 XMLPUBFUN void
-	    xmlSchemaFreeValidCtxt	(xmlSchemaValidCtxtPtr ctxt);
+	    xmlSchemaFreeValidCtxt	(xmlSchemaValidCtxt *ctxt);
 XMLPUBFUN int
-	    xmlSchemaValidateDoc	(xmlSchemaValidCtxtPtr ctxt,
-					 xmlDocPtr instance);
+	    xmlSchemaValidateDoc	(xmlSchemaValidCtxt *ctxt,
+					 xmlDoc *instance);
 XMLPUBFUN int
-            xmlSchemaValidateOneElement (xmlSchemaValidCtxtPtr ctxt,
-			                 xmlNodePtr elem);
+            xmlSchemaValidateOneElement (xmlSchemaValidCtxt *ctxt,
+			                 xmlNode *elem);
 XMLPUBFUN int
-	    xmlSchemaValidateStream	(xmlSchemaValidCtxtPtr ctxt,
-					 xmlParserInputBufferPtr input,
+	    xmlSchemaValidateStream	(xmlSchemaValidCtxt *ctxt,
+					 xmlParserInputBuffer *input,
 					 xmlCharEncoding enc,
 					 const xmlSAXHandler *sax,
 					 void *user_data);
 XMLPUBFUN int
-	    xmlSchemaValidateFile	(xmlSchemaValidCtxtPtr ctxt,
+	    xmlSchemaValidateFile	(xmlSchemaValidCtxt *ctxt,
 					 const char * filename,
 					 int options);

-XMLPUBFUN xmlParserCtxtPtr
-	    xmlSchemaValidCtxtGetParserCtxt(xmlSchemaValidCtxtPtr ctxt);
+XMLPUBFUN xmlParserCtxt *
+	    xmlSchemaValidCtxtGetParserCtxt(xmlSchemaValidCtxt *ctxt);

 /*
 * Interface to insert Schemas SAX validation in a SAX stream
@@ -230,16 +230,16 @@ XMLPUBFUN xmlParserCtxtPtr
 typedef struct _xmlSchemaSAXPlug xmlSchemaSAXPlugStruct;
 typedef xmlSchemaSAXPlugStruct *xmlSchemaSAXPlugPtr;

-XMLPUBFUN xmlSchemaSAXPlugPtr
-            xmlSchemaSAXPlug		(xmlSchemaValidCtxtPtr ctxt,
-					 xmlSAXHandlerPtr *sax,
+XMLPUBFUN xmlSchemaSAXPlugStruct *
+            xmlSchemaSAXPlug		(xmlSchemaValidCtxt *ctxt,
+					 xmlSAXHandler **sax,
 					 void **user_data);
 XMLPUBFUN int
-            xmlSchemaSAXUnplug		(xmlSchemaSAXPlugPtr plug);
+            xmlSchemaSAXUnplug		(xmlSchemaSAXPlugStruct *plug);


 XMLPUBFUN void
-            xmlSchemaValidateSetLocator	(xmlSchemaValidCtxtPtr vctxt,
+            xmlSchemaValidateSetLocator	(xmlSchemaValidCtxt *vctxt,
 					 xmlSchemaValidityLocatorFunc f,
 					 void *ctxt);

--- a/include/libxml/xmlschemastypes.h
+++ b/include/libxml/xmlschemastypes.h
@@ -41,114 +41,114 @@ XMLPUBFUN int
 XML_DEPRECATED
 XMLPUBFUN void
 		xmlSchemaCleanupTypes		(void);
-XMLPUBFUN xmlSchemaTypePtr
+XMLPUBFUN xmlSchemaType *
 		xmlSchemaGetPredefinedType	(const xmlChar *name,
 						 const xmlChar *ns);
 XMLPUBFUN int
-		xmlSchemaValidatePredefinedType	(xmlSchemaTypePtr type,
+		xmlSchemaValidatePredefinedType	(xmlSchemaType *type,
 						 const xmlChar *value,
-						 xmlSchemaValPtr *val);
+						 xmlSchemaVal **val);
 XMLPUBFUN int
-		xmlSchemaValPredefTypeNode	(xmlSchemaTypePtr type,
+		xmlSchemaValPredefTypeNode	(xmlSchemaType *type,
 						 const xmlChar *value,
-						 xmlSchemaValPtr *val,
-						 xmlNodePtr node);
+						 xmlSchemaVal **val,
+						 xmlNode *node);
 XMLPUBFUN int
-		xmlSchemaValidateFacet		(xmlSchemaTypePtr base,
-						 xmlSchemaFacetPtr facet,
+		xmlSchemaValidateFacet		(xmlSchemaType *base,
+						 xmlSchemaFacet *facet,
 						 const xmlChar *value,
-						 xmlSchemaValPtr val);
+						 xmlSchemaVal *val);
 XMLPUBFUN int
-		xmlSchemaValidateFacetWhtsp	(xmlSchemaFacetPtr facet,
+		xmlSchemaValidateFacetWhtsp	(xmlSchemaFacet *facet,
 						 xmlSchemaWhitespaceValueType fws,
 						 xmlSchemaValType valType,
 						 const xmlChar *value,
-						 xmlSchemaValPtr val,
+						 xmlSchemaVal *val,
 						 xmlSchemaWhitespaceValueType ws);
 XMLPUBFUN void
-		xmlSchemaFreeValue		(xmlSchemaValPtr val);
-XMLPUBFUN xmlSchemaFacetPtr
+		xmlSchemaFreeValue		(xmlSchemaVal *val);
+XMLPUBFUN xmlSchemaFacet *
 		xmlSchemaNewFacet		(void);
 XMLPUBFUN int
-		xmlSchemaCheckFacet		(xmlSchemaFacetPtr facet,
-						 xmlSchemaTypePtr typeDecl,
-						 xmlSchemaParserCtxtPtr ctxt,
+		xmlSchemaCheckFacet		(xmlSchemaFacet *facet,
+						 xmlSchemaType *typeDecl,
+						 xmlSchemaParserCtxt *ctxt,
 						 const xmlChar *name);
 XMLPUBFUN void
-		xmlSchemaFreeFacet		(xmlSchemaFacetPtr facet);
+		xmlSchemaFreeFacet		(xmlSchemaFacet *facet);
 XMLPUBFUN int
-		xmlSchemaCompareValues		(xmlSchemaValPtr x,
-						 xmlSchemaValPtr y);
-XMLPUBFUN xmlSchemaTypePtr
-    xmlSchemaGetBuiltInListSimpleTypeItemType	(xmlSchemaTypePtr type);
+		xmlSchemaCompareValues		(xmlSchemaVal *x,
+						 xmlSchemaVal *y);
+XMLPUBFUN xmlSchemaType *
+    xmlSchemaGetBuiltInListSimpleTypeItemType	(xmlSchemaType *type);
 XMLPUBFUN int
-    xmlSchemaValidateListSimpleTypeFacet	(xmlSchemaFacetPtr facet,
+    xmlSchemaValidateListSimpleTypeFacet	(xmlSchemaFacet *facet,
 						 const xmlChar *value,
 						 unsigned long actualLen,
 						 unsigned long *expectedLen);
-XMLPUBFUN xmlSchemaTypePtr
+XMLPUBFUN xmlSchemaType *
 		xmlSchemaGetBuiltInType		(xmlSchemaValType type);
 XMLPUBFUN int
-		xmlSchemaIsBuiltInTypeFacet	(xmlSchemaTypePtr type,
+		xmlSchemaIsBuiltInTypeFacet	(xmlSchemaType *type,
 						 int facetType);
 XMLPUBFUN xmlChar *
 		xmlSchemaCollapseString		(const xmlChar *value);
 XMLPUBFUN xmlChar *
 		xmlSchemaWhiteSpaceReplace	(const xmlChar *value);
 XMLPUBFUN unsigned long 
-		xmlSchemaGetFacetValueAsULong	(xmlSchemaFacetPtr facet);
+		xmlSchemaGetFacetValueAsULong	(xmlSchemaFacet *facet);
 XMLPUBFUN int
-		xmlSchemaValidateLengthFacet	(xmlSchemaTypePtr type,
-						 xmlSchemaFacetPtr facet,
+		xmlSchemaValidateLengthFacet	(xmlSchemaType *type,
+						 xmlSchemaFacet *facet,
 						 const xmlChar *value,
-						 xmlSchemaValPtr val,
+						 xmlSchemaVal *val,
 						 unsigned long *length);
 XMLPUBFUN int
-		xmlSchemaValidateLengthFacetWhtsp(xmlSchemaFacetPtr facet,
+		xmlSchemaValidateLengthFacetWhtsp(xmlSchemaFacet *facet,
 						  xmlSchemaValType valType,
 						  const xmlChar *value,
-						  xmlSchemaValPtr val,
+						  xmlSchemaVal *val,
 						  unsigned long *length,
 						  xmlSchemaWhitespaceValueType ws);
 XMLPUBFUN int
-		xmlSchemaValPredefTypeNodeNoNorm(xmlSchemaTypePtr type,
+		xmlSchemaValPredefTypeNodeNoNorm(xmlSchemaType *type,
 						 const xmlChar *value,
-						 xmlSchemaValPtr *val,
-						 xmlNodePtr node);
+						 xmlSchemaVal **val,
+						 xmlNode *node);
 XMLPUBFUN int
-		xmlSchemaGetCanonValue		(xmlSchemaValPtr val,
+		xmlSchemaGetCanonValue		(xmlSchemaVal *val,
 						 const xmlChar **retValue);
 XMLPUBFUN int
-		xmlSchemaGetCanonValueWhtsp	(xmlSchemaValPtr val,
+		xmlSchemaGetCanonValueWhtsp	(xmlSchemaVal *val,
 						 const xmlChar **retValue,
 						 xmlSchemaWhitespaceValueType ws);
 XMLPUBFUN int
-		xmlSchemaValueAppend		(xmlSchemaValPtr prev,
-						 xmlSchemaValPtr cur);
-XMLPUBFUN xmlSchemaValPtr
-		xmlSchemaValueGetNext		(xmlSchemaValPtr cur);
+		xmlSchemaValueAppend		(xmlSchemaVal *prev,
+						 xmlSchemaVal *cur);
+XMLPUBFUN xmlSchemaVal *
+		xmlSchemaValueGetNext		(xmlSchemaVal *cur);
 XMLPUBFUN const xmlChar *
-		xmlSchemaValueGetAsString	(xmlSchemaValPtr val);
+		xmlSchemaValueGetAsString	(xmlSchemaVal *val);
 XMLPUBFUN int
-		xmlSchemaValueGetAsBoolean	(xmlSchemaValPtr val);
-XMLPUBFUN xmlSchemaValPtr
+		xmlSchemaValueGetAsBoolean	(xmlSchemaVal *val);
+XMLPUBFUN xmlSchemaVal *
 		xmlSchemaNewStringValue		(xmlSchemaValType type,
 						 const xmlChar *value);
-XMLPUBFUN xmlSchemaValPtr
+XMLPUBFUN xmlSchemaVal *
 		xmlSchemaNewNOTATIONValue	(const xmlChar *name,
 						 const xmlChar *ns);
-XMLPUBFUN xmlSchemaValPtr
+XMLPUBFUN xmlSchemaVal *
 		xmlSchemaNewQNameValue		(const xmlChar *namespaceName,
 						 const xmlChar *localName);
 XMLPUBFUN int
-		xmlSchemaCompareValuesWhtsp	(xmlSchemaValPtr x,
+		xmlSchemaCompareValuesWhtsp	(xmlSchemaVal *x,
 						 xmlSchemaWhitespaceValueType xws,
-						 xmlSchemaValPtr y,
+						 xmlSchemaVal *y,
 						 xmlSchemaWhitespaceValueType yws);
-XMLPUBFUN xmlSchemaValPtr
-		xmlSchemaCopyValue		(xmlSchemaValPtr val);
+XMLPUBFUN xmlSchemaVal *
+		xmlSchemaCopyValue		(xmlSchemaVal *val);
 XMLPUBFUN xmlSchemaValType
-		xmlSchemaGetValType		(xmlSchemaValPtr val);
+		xmlSchemaGetValType		(xmlSchemaVal *val);

 #ifdef __cplusplus
 }
--- a/include/libxml/xmlwriter.h
+++ b/include/libxml/xmlwriter.h
@@ -32,20 +32,20 @@ extern "C" {
 /*
 * Constructors & Destructor
 */
-    XMLPUBFUN xmlTextWriterPtr
-        xmlNewTextWriter(xmlOutputBufferPtr out);
-    XMLPUBFUN xmlTextWriterPtr
+    XMLPUBFUN xmlTextWriter *
+        xmlNewTextWriter(xmlOutputBuffer *out);
+    XMLPUBFUN xmlTextWriter *
        xmlNewTextWriterFilename(const char *uri, int compression);
-    XMLPUBFUN xmlTextWriterPtr
-        xmlNewTextWriterMemory(xmlBufferPtr buf, int compression);
-    XMLPUBFUN xmlTextWriterPtr
-        xmlNewTextWriterPushParser(xmlParserCtxtPtr ctxt, int compression);
-    XMLPUBFUN xmlTextWriterPtr
-        xmlNewTextWriterDoc(xmlDocPtr * doc, int compression);
-    XMLPUBFUN xmlTextWriterPtr
-        xmlNewTextWriterTree(xmlDocPtr doc, xmlNodePtr node,
+    XMLPUBFUN xmlTextWriter *
+        xmlNewTextWriterMemory(xmlBuffer *buf, int compression);
+    XMLPUBFUN xmlTextWriter *
+        xmlNewTextWriterPushParser(xmlParserCtxt *ctxt, int compression);
+    XMLPUBFUN xmlTextWriter *
+        xmlNewTextWriterDoc(xmlDoc ** doc, int compression);
+    XMLPUBFUN xmlTextWriter *
+        xmlNewTextWriterTree(xmlDoc *doc, xmlNode *node,
                             int compression);
-    XMLPUBFUN void xmlFreeTextWriter(xmlTextWriterPtr writer);
+    XMLPUBFUN void xmlFreeTextWriter(xmlTextWriter *writer);

 /*
 * Functions
@@ -56,29 +56,29 @@ extern "C" {
 * Document
 */
    XMLPUBFUN int
-        xmlTextWriterStartDocument(xmlTextWriterPtr writer,
+        xmlTextWriterStartDocument(xmlTextWriter *writer,
                                   const char *version,
                                   const char *encoding,
                                   const char *standalone);
-    XMLPUBFUN int xmlTextWriterEndDocument(xmlTextWriterPtr
+    XMLPUBFUN int xmlTextWriterEndDocument(xmlTextWriter *
                                                   writer);

 /*
 * Comments
 */
-    XMLPUBFUN int xmlTextWriterStartComment(xmlTextWriterPtr
+    XMLPUBFUN int xmlTextWriterStartComment(xmlTextWriter *
                                                    writer);
-    XMLPUBFUN int xmlTextWriterEndComment(xmlTextWriterPtr writer);
+    XMLPUBFUN int xmlTextWriterEndComment(xmlTextWriter *writer);
    XMLPUBFUN int
-        xmlTextWriterWriteFormatComment(xmlTextWriterPtr writer,
+        xmlTextWriterWriteFormatComment(xmlTextWriter *writer,
                                        const char *format, ...)
 					LIBXML_ATTR_FORMAT(2,3);
    XMLPUBFUN int
-        xmlTextWriterWriteVFormatComment(xmlTextWriterPtr writer,
+        xmlTextWriterWriteVFormatComment(xmlTextWriter *writer,
                                         const char *format,
                                         va_list argptr)
 					 LIBXML_ATTR_FORMAT(2,0);
-    XMLPUBFUN int xmlTextWriterWriteComment(xmlTextWriterPtr
+    XMLPUBFUN int xmlTextWriterWriteComment(xmlTextWriter *
                                                    writer,
                                                    const xmlChar *
                                                    content);
@@ -87,54 +87,54 @@ extern "C" {
 * Elements
 */
    XMLPUBFUN int
-        xmlTextWriterStartElement(xmlTextWriterPtr writer,
+        xmlTextWriterStartElement(xmlTextWriter *writer,
                                  const xmlChar * name);
-    XMLPUBFUN int xmlTextWriterStartElementNS(xmlTextWriterPtr
+    XMLPUBFUN int xmlTextWriterStartElementNS(xmlTextWriter *
                                                      writer,
                                                      const xmlChar *
                                                      prefix,
                                                      const xmlChar * name,
                                                      const xmlChar *
                                                      namespaceURI);
-    XMLPUBFUN int xmlTextWriterEndElement(xmlTextWriterPtr writer);
-    XMLPUBFUN int xmlTextWriterFullEndElement(xmlTextWriterPtr
+    XMLPUBFUN int xmlTextWriterEndElement(xmlTextWriter *writer);
+    XMLPUBFUN int xmlTextWriterFullEndElement(xmlTextWriter *
                                                      writer);

 /*
 * Elements conveniency functions
 */
    XMLPUBFUN int
-        xmlTextWriterWriteFormatElement(xmlTextWriterPtr writer,
+        xmlTextWriterWriteFormatElement(xmlTextWriter *writer,
                                        const xmlChar * name,
                                        const char *format, ...)
 					LIBXML_ATTR_FORMAT(3,4);
    XMLPUBFUN int
-        xmlTextWriterWriteVFormatElement(xmlTextWriterPtr writer,
+        xmlTextWriterWriteVFormatElement(xmlTextWriter *writer,
                                         const xmlChar * name,
                                         const char *format,
                                         va_list argptr)
 					 LIBXML_ATTR_FORMAT(3,0);
-    XMLPUBFUN int xmlTextWriterWriteElement(xmlTextWriterPtr
+    XMLPUBFUN int xmlTextWriterWriteElement(xmlTextWriter *
                                                    writer,
                                                    const xmlChar * name,
                                                    const xmlChar *
                                                    content);
    XMLPUBFUN int
-        xmlTextWriterWriteFormatElementNS(xmlTextWriterPtr writer,
+        xmlTextWriterWriteFormatElementNS(xmlTextWriter *writer,
                                          const xmlChar * prefix,
                                          const xmlChar * name,
                                          const xmlChar * namespaceURI,
                                          const char *format, ...)
 					  LIBXML_ATTR_FORMAT(5,6);
    XMLPUBFUN int
-        xmlTextWriterWriteVFormatElementNS(xmlTextWriterPtr writer,
+        xmlTextWriterWriteVFormatElementNS(xmlTextWriter *writer,
                                           const xmlChar * prefix,
                                           const xmlChar * name,
                                           const xmlChar * namespaceURI,
                                           const char *format,
                                           va_list argptr)
 					   LIBXML_ATTR_FORMAT(5,0);
-    XMLPUBFUN int xmlTextWriterWriteElementNS(xmlTextWriterPtr
+    XMLPUBFUN int xmlTextWriterWriteElementNS(xmlTextWriter *
                                                      writer,
                                                      const xmlChar *
                                                      prefix,
@@ -148,37 +148,37 @@ extern "C" {
 * Text
 */
    XMLPUBFUN int
-        xmlTextWriterWriteFormatRaw(xmlTextWriterPtr writer,
+        xmlTextWriterWriteFormatRaw(xmlTextWriter *writer,
                                    const char *format, ...)
 				    LIBXML_ATTR_FORMAT(2,3);
    XMLPUBFUN int
-        xmlTextWriterWriteVFormatRaw(xmlTextWriterPtr writer,
+        xmlTextWriterWriteVFormatRaw(xmlTextWriter *writer,
                                     const char *format, va_list argptr)
 				     LIBXML_ATTR_FORMAT(2,0);
    XMLPUBFUN int
-        xmlTextWriterWriteRawLen(xmlTextWriterPtr writer,
+        xmlTextWriterWriteRawLen(xmlTextWriter *writer,
                                 const xmlChar * content, int len);
    XMLPUBFUN int
-        xmlTextWriterWriteRaw(xmlTextWriterPtr writer,
+        xmlTextWriterWriteRaw(xmlTextWriter *writer,
                              const xmlChar * content);
-    XMLPUBFUN int xmlTextWriterWriteFormatString(xmlTextWriterPtr
+    XMLPUBFUN int xmlTextWriterWriteFormatString(xmlTextWriter *
                                                         writer,
                                                         const char
                                                         *format, ...)
 							 LIBXML_ATTR_FORMAT(2,3);
-    XMLPUBFUN int xmlTextWriterWriteVFormatString(xmlTextWriterPtr
+    XMLPUBFUN int xmlTextWriterWriteVFormatString(xmlTextWriter *
                                                          writer,
                                                          const char
                                                          *format,
                                                          va_list argptr)
 							  LIBXML_ATTR_FORMAT(2,0);
-    XMLPUBFUN int xmlTextWriterWriteString(xmlTextWriterPtr writer,
+    XMLPUBFUN int xmlTextWriterWriteString(xmlTextWriter *writer,
                                                   const xmlChar *
                                                   content);
-    XMLPUBFUN int xmlTextWriterWriteBase64(xmlTextWriterPtr writer,
+    XMLPUBFUN int xmlTextWriterWriteBase64(xmlTextWriter *writer,
                                                   const char *data,
                                                   int start, int len);
-    XMLPUBFUN int xmlTextWriterWriteBinHex(xmlTextWriterPtr writer,
+    XMLPUBFUN int xmlTextWriterWriteBinHex(xmlTextWriter *writer,
                                                   const char *data,
                                                   int start, int len);

@@ -186,9 +186,9 @@ extern "C" {
 * Attributes
 */
    XMLPUBFUN int
-        xmlTextWriterStartAttribute(xmlTextWriterPtr writer,
+        xmlTextWriterStartAttribute(xmlTextWriter *writer,
                                    const xmlChar * name);
-    XMLPUBFUN int xmlTextWriterStartAttributeNS(xmlTextWriterPtr
+    XMLPUBFUN int xmlTextWriterStartAttributeNS(xmlTextWriter *
                                                        writer,
                                                        const xmlChar *
                                                        prefix,
@@ -196,44 +196,44 @@ extern "C" {
                                                        name,
                                                        const xmlChar *
                                                        namespaceURI);
-    XMLPUBFUN int xmlTextWriterEndAttribute(xmlTextWriterPtr
+    XMLPUBFUN int xmlTextWriterEndAttribute(xmlTextWriter *
                                                    writer);

 /*
 * Attributes conveniency functions
 */
    XMLPUBFUN int
-        xmlTextWriterWriteFormatAttribute(xmlTextWriterPtr writer,
+        xmlTextWriterWriteFormatAttribute(xmlTextWriter *writer,
                                          const xmlChar * name,
                                          const char *format, ...)
 					  LIBXML_ATTR_FORMAT(3,4);
    XMLPUBFUN int
-        xmlTextWriterWriteVFormatAttribute(xmlTextWriterPtr writer,
+        xmlTextWriterWriteVFormatAttribute(xmlTextWriter *writer,
                                           const xmlChar * name,
                                           const char *format,
                                           va_list argptr)
 					   LIBXML_ATTR_FORMAT(3,0);
-    XMLPUBFUN int xmlTextWriterWriteAttribute(xmlTextWriterPtr
+    XMLPUBFUN int xmlTextWriterWriteAttribute(xmlTextWriter *
                                                      writer,
                                                      const xmlChar * name,
                                                      const xmlChar *
                                                      content);
    XMLPUBFUN int
-        xmlTextWriterWriteFormatAttributeNS(xmlTextWriterPtr writer,
+        xmlTextWriterWriteFormatAttributeNS(xmlTextWriter *writer,
                                            const xmlChar * prefix,
                                            const xmlChar * name,
                                            const xmlChar * namespaceURI,
                                            const char *format, ...)
 					    LIBXML_ATTR_FORMAT(5,6);
    XMLPUBFUN int
-        xmlTextWriterWriteVFormatAttributeNS(xmlTextWriterPtr writer,
+        xmlTextWriterWriteVFormatAttributeNS(xmlTextWriter *writer,
                                             const xmlChar * prefix,
                                             const xmlChar * name,
                                             const xmlChar * namespaceURI,
                                             const char *format,
                                             va_list argptr)
 					     LIBXML_ATTR_FORMAT(5,0);
-    XMLPUBFUN int xmlTextWriterWriteAttributeNS(xmlTextWriterPtr
+    XMLPUBFUN int xmlTextWriterWriteAttributeNS(xmlTextWriter *
                                                        writer,
                                                        const xmlChar *
                                                        prefix,
@@ -248,25 +248,25 @@ extern "C" {
 * PI's
 */
    XMLPUBFUN int
-        xmlTextWriterStartPI(xmlTextWriterPtr writer,
+        xmlTextWriterStartPI(xmlTextWriter *writer,
                             const xmlChar * target);
-    XMLPUBFUN int xmlTextWriterEndPI(xmlTextWriterPtr writer);
+    XMLPUBFUN int xmlTextWriterEndPI(xmlTextWriter *writer);

 /*
 * PI conveniency functions
 */
    XMLPUBFUN int
-        xmlTextWriterWriteFormatPI(xmlTextWriterPtr writer,
+        xmlTextWriterWriteFormatPI(xmlTextWriter *writer,
                                   const xmlChar * target,
                                   const char *format, ...)
 				   LIBXML_ATTR_FORMAT(3,4);
    XMLPUBFUN int
-        xmlTextWriterWriteVFormatPI(xmlTextWriterPtr writer,
+        xmlTextWriterWriteVFormatPI(xmlTextWriter *writer,
                                    const xmlChar * target,
                                    const char *format, va_list argptr)
 				    LIBXML_ATTR_FORMAT(3,0);
    XMLPUBFUN int
-        xmlTextWriterWritePI(xmlTextWriterPtr writer,
+        xmlTextWriterWritePI(xmlTextWriter *writer,
                             const xmlChar * target,
                             const xmlChar * content);

@@ -278,53 +278,53 @@ extern "C" {
 /*
 * CDATA
 */
-    XMLPUBFUN int xmlTextWriterStartCDATA(xmlTextWriterPtr writer);
-    XMLPUBFUN int xmlTextWriterEndCDATA(xmlTextWriterPtr writer);
+    XMLPUBFUN int xmlTextWriterStartCDATA(xmlTextWriter *writer);
+    XMLPUBFUN int xmlTextWriterEndCDATA(xmlTextWriter *writer);

 /*
 * CDATA conveniency functions
 */
    XMLPUBFUN int
-        xmlTextWriterWriteFormatCDATA(xmlTextWriterPtr writer,
+        xmlTextWriterWriteFormatCDATA(xmlTextWriter *writer,
                                      const char *format, ...)
 				      LIBXML_ATTR_FORMAT(2,3);
    XMLPUBFUN int
-        xmlTextWriterWriteVFormatCDATA(xmlTextWriterPtr writer,
+        xmlTextWriterWriteVFormatCDATA(xmlTextWriter *writer,
                                       const char *format, va_list argptr)
 				       LIBXML_ATTR_FORMAT(2,0);
    XMLPUBFUN int
-        xmlTextWriterWriteCDATA(xmlTextWriterPtr writer,
+        xmlTextWriterWriteCDATA(xmlTextWriter *writer,
                                const xmlChar * content);

 /*
 * DTD
 */
    XMLPUBFUN int
-        xmlTextWriterStartDTD(xmlTextWriterPtr writer,
+        xmlTextWriterStartDTD(xmlTextWriter *writer,
                              const xmlChar * name,
                              const xmlChar * pubid,
                              const xmlChar * sysid);
-    XMLPUBFUN int xmlTextWriterEndDTD(xmlTextWriterPtr writer);
+    XMLPUBFUN int xmlTextWriterEndDTD(xmlTextWriter *writer);

 /*
 * DTD conveniency functions
 */
    XMLPUBFUN int
-        xmlTextWriterWriteFormatDTD(xmlTextWriterPtr writer,
+        xmlTextWriterWriteFormatDTD(xmlTextWriter *writer,
                                    const xmlChar * name,
                                    const xmlChar * pubid,
                                    const xmlChar * sysid,
                                    const char *format, ...)
 				    LIBXML_ATTR_FORMAT(5,6);
    XMLPUBFUN int
-        xmlTextWriterWriteVFormatDTD(xmlTextWriterPtr writer,
+        xmlTextWriterWriteVFormatDTD(xmlTextWriter *writer,
                                     const xmlChar * name,
                                     const xmlChar * pubid,
                                     const xmlChar * sysid,
                                     const char *format, va_list argptr)
 				     LIBXML_ATTR_FORMAT(5,0);
    XMLPUBFUN int
-        xmlTextWriterWriteDTD(xmlTextWriterPtr writer,
+        xmlTextWriterWriteDTD(xmlTextWriter *writer,
                              const xmlChar * name,
                              const xmlChar * pubid,
                              const xmlChar * sysid,
@@ -339,26 +339,26 @@ extern "C" {
 * DTD element definition
 */
    XMLPUBFUN int
-        xmlTextWriterStartDTDElement(xmlTextWriterPtr writer,
+        xmlTextWriterStartDTDElement(xmlTextWriter *writer,
                                     const xmlChar * name);
-    XMLPUBFUN int xmlTextWriterEndDTDElement(xmlTextWriterPtr
+    XMLPUBFUN int xmlTextWriterEndDTDElement(xmlTextWriter *
                                                     writer);

 /*
 * DTD element definition conveniency functions
 */
    XMLPUBFUN int
-        xmlTextWriterWriteFormatDTDElement(xmlTextWriterPtr writer,
+        xmlTextWriterWriteFormatDTDElement(xmlTextWriter *writer,
                                           const xmlChar * name,
                                           const char *format, ...)
 					   LIBXML_ATTR_FORMAT(3,4);
    XMLPUBFUN int
-        xmlTextWriterWriteVFormatDTDElement(xmlTextWriterPtr writer,
+        xmlTextWriterWriteVFormatDTDElement(xmlTextWriter *writer,
                                            const xmlChar * name,
                                            const char *format,
                                            va_list argptr)
 					    LIBXML_ATTR_FORMAT(3,0);
-    XMLPUBFUN int xmlTextWriterWriteDTDElement(xmlTextWriterPtr
+    XMLPUBFUN int xmlTextWriterWriteDTDElement(xmlTextWriter *
                                                       writer,
                                                       const xmlChar *
                                                       name,
@@ -369,26 +369,26 @@ extern "C" {
 * DTD attribute list definition
 */
    XMLPUBFUN int
-        xmlTextWriterStartDTDAttlist(xmlTextWriterPtr writer,
+        xmlTextWriterStartDTDAttlist(xmlTextWriter *writer,
                                     const xmlChar * name);
-    XMLPUBFUN int xmlTextWriterEndDTDAttlist(xmlTextWriterPtr
+    XMLPUBFUN int xmlTextWriterEndDTDAttlist(xmlTextWriter *
                                                     writer);

 /*
 * DTD attribute list definition conveniency functions
 */
    XMLPUBFUN int
-        xmlTextWriterWriteFormatDTDAttlist(xmlTextWriterPtr writer,
+        xmlTextWriterWriteFormatDTDAttlist(xmlTextWriter *writer,
                                           const xmlChar * name,
                                           const char *format, ...)
 					   LIBXML_ATTR_FORMAT(3,4);
    XMLPUBFUN int
-        xmlTextWriterWriteVFormatDTDAttlist(xmlTextWriterPtr writer,
+        xmlTextWriterWriteVFormatDTDAttlist(xmlTextWriter *writer,
                                            const xmlChar * name,
                                            const char *format,
                                            va_list argptr)
 					    LIBXML_ATTR_FORMAT(3,0);
-    XMLPUBFUN int xmlTextWriterWriteDTDAttlist(xmlTextWriterPtr
+    XMLPUBFUN int xmlTextWriterWriteDTDAttlist(xmlTextWriter *
                                                       writer,
                                                       const xmlChar *
                                                       name,
@@ -399,47 +399,47 @@ extern "C" {
 * DTD entity definition
 */
    XMLPUBFUN int
-        xmlTextWriterStartDTDEntity(xmlTextWriterPtr writer,
+        xmlTextWriterStartDTDEntity(xmlTextWriter *writer,
                                    int pe, const xmlChar * name);
-    XMLPUBFUN int xmlTextWriterEndDTDEntity(xmlTextWriterPtr
+    XMLPUBFUN int xmlTextWriterEndDTDEntity(xmlTextWriter *
                                                    writer);

 /*
 * DTD entity definition conveniency functions
 */
    XMLPUBFUN int
-        xmlTextWriterWriteFormatDTDInternalEntity(xmlTextWriterPtr writer,
+        xmlTextWriterWriteFormatDTDInternalEntity(xmlTextWriter *writer,
                                                  int pe,
                                                  const xmlChar * name,
                                                  const char *format, ...)
 						  LIBXML_ATTR_FORMAT(4,5);
    XMLPUBFUN int
-        xmlTextWriterWriteVFormatDTDInternalEntity(xmlTextWriterPtr writer,
+        xmlTextWriterWriteVFormatDTDInternalEntity(xmlTextWriter *writer,
                                                   int pe,
                                                   const xmlChar * name,
                                                   const char *format,
                                                   va_list argptr)
 						   LIBXML_ATTR_FORMAT(4,0);
    XMLPUBFUN int
-        xmlTextWriterWriteDTDInternalEntity(xmlTextWriterPtr writer,
+        xmlTextWriterWriteDTDInternalEntity(xmlTextWriter *writer,
                                            int pe,
                                            const xmlChar * name,
                                            const xmlChar * content);
    XMLPUBFUN int
-        xmlTextWriterWriteDTDExternalEntity(xmlTextWriterPtr writer,
+        xmlTextWriterWriteDTDExternalEntity(xmlTextWriter *writer,
                                            int pe,
                                            const xmlChar * name,
                                            const xmlChar * pubid,
                                            const xmlChar * sysid,
                                            const xmlChar * ndataid);
    XMLPUBFUN int
-        xmlTextWriterWriteDTDExternalEntityContents(xmlTextWriterPtr
+        xmlTextWriterWriteDTDExternalEntityContents(xmlTextWriter *
                                                    writer,
                                                    const xmlChar * pubid,
                                                    const xmlChar * sysid,
                                                    const xmlChar *
                                                    ndataid);
-    XMLPUBFUN int xmlTextWriterWriteDTDEntity(xmlTextWriterPtr
+    XMLPUBFUN int xmlTextWriterWriteDTDEntity(xmlTextWriter *
                                                      writer, int pe,
                                                      const xmlChar * name,
                                                      const xmlChar *
@@ -455,7 +455,7 @@ extern "C" {
 * DTD notation definition
 */
    XMLPUBFUN int
-        xmlTextWriterWriteDTDNotation(xmlTextWriterPtr writer,
+        xmlTextWriterWriteDTDNotation(xmlTextWriter *writer,
                                      const xmlChar * name,
                                      const xmlChar * pubid,
                                      const xmlChar * sysid);
@@ -464,20 +464,20 @@ extern "C" {
 * Indentation
 */
    XMLPUBFUN int
-        xmlTextWriterSetIndent(xmlTextWriterPtr writer, int indent);
+        xmlTextWriterSetIndent(xmlTextWriter *writer, int indent);
    XMLPUBFUN int
-        xmlTextWriterSetIndentString(xmlTextWriterPtr writer,
+        xmlTextWriterSetIndentString(xmlTextWriter *writer,
                                     const xmlChar * str);

    XMLPUBFUN int
-        xmlTextWriterSetQuoteChar(xmlTextWriterPtr writer, xmlChar quotechar);
+        xmlTextWriterSetQuoteChar(xmlTextWriter *writer, xmlChar quotechar);


 /*
 * misc
 */
-    XMLPUBFUN int xmlTextWriterFlush(xmlTextWriterPtr writer);
-    XMLPUBFUN int xmlTextWriterClose(xmlTextWriterPtr writer);
+    XMLPUBFUN int xmlTextWriterFlush(xmlTextWriter *writer);
+    XMLPUBFUN int xmlTextWriterClose(xmlTextWriter *writer);

 #ifdef __cplusplus
 }
--- a/include/libxml/xpath.h
+++ b/include/libxml/xpath.h
@@ -84,7 +84,7 @@ struct _xmlNodeSet {
    /** size of the array as allocated */
    int nodeMax;
    /** array of nodes in no particular order */
-    xmlNodePtr *nodeTab;
+    xmlNode **nodeTab;
 };

 /**
@@ -121,7 +121,7 @@ struct _xmlXPathObject {
    /** object type */
    xmlXPathObjectType type;
    /** node set */
-    xmlNodeSetPtr nodesetval;
+    xmlNodeSet *nodesetval;
    /** boolean */
    int boolval;
    /** number */
@@ -139,7 +139,7 @@ struct _xmlXPathObject {
 /*
 * unused
 */
-typedef int (*xmlXPathConvertFunc) (xmlXPathObjectPtr obj, int type);
+typedef int (*xmlXPathConvertFunc) (xmlXPathObject *obj, int type);
 typedef struct _xmlXPathType xmlXPathType;
 typedef xmlXPathType *xmlXPathTypePtr;
 struct _xmlXPathType {
@@ -154,13 +154,13 @@ typedef struct _xmlXPathVariable xmlXPathVariable;
 typedef xmlXPathVariable *xmlXPathVariablePtr;
 struct _xmlXPathVariable {
    const xmlChar       *name;		/* the variable name */
-    xmlXPathObjectPtr value;		/* the value */
+    xmlXPathObject *value;		/* the value */
 };

 /*
 * unused
 */
-typedef void (*xmlXPathEvalFunc)(xmlXPathParserContextPtr ctxt,
+typedef void (*xmlXPathEvalFunc)(xmlXPathParserContext *ctxt,
 	                         int nargs);
 typedef struct _xmlXPathFunct xmlXPathFunct;
 typedef xmlXPathFunct *xmlXPathFuncPtr;
@@ -172,8 +172,8 @@ struct _xmlXPathFunct {
 /*
 * unused
 */
-typedef xmlXPathObjectPtr (*xmlXPathAxisFunc) (xmlXPathParserContextPtr ctxt,
-				 xmlXPathObjectPtr cur);
+typedef xmlXPathObject *(*xmlXPathAxisFunc) (xmlXPathParserContext *ctxt,
+				 xmlXPathObject *cur);
 typedef struct _xmlXPathAxis xmlXPathAxis;
 typedef xmlXPathAxis *xmlXPathAxisPtr;
 struct _xmlXPathAxis {
@@ -192,7 +192,7 @@ struct _xmlXPathAxis {
 * @param nargs  the number of arguments
 */

-typedef void (*xmlXPathFunction) (xmlXPathParserContextPtr ctxt, int nargs);
+typedef void (*xmlXPathFunction) (xmlXPathParserContext *ctxt, int nargs);

 /*
 * Function and Variable Lookup.
@@ -207,7 +207,7 @@ typedef void (*xmlXPathFunction) (xmlXPathParserContextPtr ctxt, int nargs);
 * @param ns_uri  the namespace name hosting this variable
 * @returns the XPath object value or NULL if not found.
 */
-typedef xmlXPathObjectPtr (*xmlXPathVariableLookupFunc) (void *ctxt,
+typedef xmlXPathObject *(*xmlXPathVariableLookupFunc) (void *ctxt,
                                         const xmlChar *name,
                                         const xmlChar *ns_uri);

@@ -252,40 +252,40 @@ typedef xmlXPathFunction (*xmlXPathFuncLookupFunc) (void *ctxt,
 */
 struct _xmlXPathContext {
    /** The current document */
-    xmlDocPtr doc;
+    xmlDoc *doc;
    /** The current node */
-    xmlNodePtr node;
+    xmlNode *node;

    /* unused (hash table) */
    int nb_variables_unused;
    /* unused (hash table) */
    int max_variables_unused;
    /* Hash table of defined variables */
-    xmlHashTablePtr varHash;
+    xmlHashTable *varHash;

    /* number of defined types */
    int nb_types;
    /* max number of types */
    int max_types;
    /* Array of defined types */
-    xmlXPathTypePtr types;
+    xmlXPathType *types;

    /* unused (hash table) */
    int nb_funcs_unused;
    /* unused (hash table) */
    int max_funcs_unused;
    /* Hash table of defined funcs */
-    xmlHashTablePtr funcHash;
+    xmlHashTable *funcHash;

    /* number of defined axis */
    int nb_axis;
    /* max number of axis */
    int max_axis;
    /* Array of defined axis */
-    xmlXPathAxisPtr axis;
+    xmlXPathAxis *axis;

    /* Array of namespaces */
-    xmlNsPtr *namespaces;
+    xmlNs **namespaces;
    /* number of namespace in scope */
    int nsNr;
    /* function to free */
@@ -299,12 +299,12 @@ struct _xmlXPathContext {
    /* is this an XPointer context? */
    int xptr;
    /* for here() */
-    xmlNodePtr here;
+    xmlNode *here;
    /* for origin() */
-    xmlNodePtr origin;
+    xmlNode *origin;

    /* The namespaces hash table */
-    xmlHashTablePtr nsHash;
+    xmlHashTable *nsHash;
    /* variable lookup func */
    xmlXPathVariableLookupFunc varLookupFunc;
    /* variable lookup data */
@@ -324,7 +324,7 @@ struct _xmlXPathContext {
    void *funcLookupData;

    /* Array of temp namespaces */
-    xmlNsPtr *tmpNsList;
+    xmlNs **tmpNsList;
    /* number of namespaces in scope */
    int tmpNsNr;

@@ -335,10 +335,10 @@ struct _xmlXPathContext {
    /* the last error */
    xmlError lastError;
    /* the source node XSLT */
-    xmlNodePtr debugNode;
+    xmlNode *debugNode;

    /* dictionary if any */
-    xmlDictPtr dict;
+    xmlDict *dict;

    /** flags to control compilation */
    int flags;
@@ -373,22 +373,22 @@ struct _xmlXPathParserContext {
    int error;

    /** the evaluation context */
-    xmlXPathContextPtr  context;
+    xmlXPathContext    *context;
    /** the current value */
-    xmlXPathObjectPtr     value;
+    xmlXPathObject       *value;
    /* number of values stacked */
    int                 valueNr;
    /* max number of values stacked */
    int                valueMax;
    /* stack of values */
-    xmlXPathObjectPtr *valueTab;
+    xmlXPathObject **valueTab;

    /* the precompiled expression */
-    xmlXPathCompExprPtr comp;
+    xmlXPathCompExpr *comp;
    /* it this an XPointer expression */
    int xptr;
    /* used for walking preceding axis */
-    xmlNodePtr         ancestor;
+    xmlNode           *ancestor;

    /* always zero for compatibility */
    int              valueFrame;
@@ -426,7 +426,7 @@ XMLPUBVAR double xmlXPathNINF;
 *
 * @param ns  a node-set
 * @param index  index of a node in the set
- * @returns the xmlNodePtr at the given `index` in `ns` or NULL if
+ * @returns the xmlNode at the given `index` in `ns` or NULL if
 *         `index` is out of range (0 to length-1)
 */
 #define xmlXPathNodeSetItem(ns, index)				\
@@ -446,18 +446,18 @@ XMLPUBVAR double xmlXPathNINF;
 /** @endcond */

 XMLPUBFUN void
-		    xmlXPathFreeObject		(xmlXPathObjectPtr obj);
-XMLPUBFUN xmlNodeSetPtr
-		    xmlXPathNodeSetCreate	(xmlNodePtr val);
+		    xmlXPathFreeObject		(xmlXPathObject *obj);
+XMLPUBFUN xmlNodeSet *
+		    xmlXPathNodeSetCreate	(xmlNode *val);
 XMLPUBFUN void
-		    xmlXPathFreeNodeSetList	(xmlXPathObjectPtr obj);
+		    xmlXPathFreeNodeSetList	(xmlXPathObject *obj);
 XMLPUBFUN void
-		    xmlXPathFreeNodeSet		(xmlNodeSetPtr obj);
-XMLPUBFUN xmlXPathObjectPtr
-		    xmlXPathObjectCopy		(xmlXPathObjectPtr val);
+		    xmlXPathFreeNodeSet		(xmlNodeSet *obj);
+XMLPUBFUN xmlXPathObject *
+		    xmlXPathObjectCopy		(xmlXPathObject *val);
 XMLPUBFUN int
-		    xmlXPathCmpNodes		(xmlNodePtr node1,
-						 xmlNodePtr node2);
+		    xmlXPathCmpNodes		(xmlNode *node1,
+						 xmlNode *node2);
 /**
 * Conversion functions to basic types.
 */
@@ -466,52 +466,52 @@ XMLPUBFUN int
 XMLPUBFUN int
 		    xmlXPathCastStringToBoolean	(const xmlChar * val);
 XMLPUBFUN int
-		    xmlXPathCastNodeSetToBoolean(xmlNodeSetPtr ns);
+		    xmlXPathCastNodeSetToBoolean(xmlNodeSet *ns);
 XMLPUBFUN int
-		    xmlXPathCastToBoolean	(xmlXPathObjectPtr val);
+		    xmlXPathCastToBoolean	(xmlXPathObject *val);

 XMLPUBFUN double
 		    xmlXPathCastBooleanToNumber	(int val);
 XMLPUBFUN double
 		    xmlXPathCastStringToNumber	(const xmlChar * val);
 XMLPUBFUN double
-		    xmlXPathCastNodeToNumber	(xmlNodePtr node);
+		    xmlXPathCastNodeToNumber	(xmlNode *node);
 XMLPUBFUN double
-		    xmlXPathCastNodeSetToNumber	(xmlNodeSetPtr ns);
+		    xmlXPathCastNodeSetToNumber	(xmlNodeSet *ns);
 XMLPUBFUN double
-		    xmlXPathCastToNumber	(xmlXPathObjectPtr val);
+		    xmlXPathCastToNumber	(xmlXPathObject *val);

 XMLPUBFUN xmlChar *
 		    xmlXPathCastBooleanToString	(int val);
 XMLPUBFUN xmlChar *
 		    xmlXPathCastNumberToString	(double val);
 XMLPUBFUN xmlChar *
-		    xmlXPathCastNodeToString	(xmlNodePtr node);
+		    xmlXPathCastNodeToString	(xmlNode *node);
 XMLPUBFUN xmlChar *
-		    xmlXPathCastNodeSetToString	(xmlNodeSetPtr ns);
+		    xmlXPathCastNodeSetToString	(xmlNodeSet *ns);
 XMLPUBFUN xmlChar *
-		    xmlXPathCastToString	(xmlXPathObjectPtr val);
+		    xmlXPathCastToString	(xmlXPathObject *val);

-XMLPUBFUN xmlXPathObjectPtr
-		    xmlXPathConvertBoolean	(xmlXPathObjectPtr val);
-XMLPUBFUN xmlXPathObjectPtr
-		    xmlXPathConvertNumber	(xmlXPathObjectPtr val);
-XMLPUBFUN xmlXPathObjectPtr
-		    xmlXPathConvertString	(xmlXPathObjectPtr val);
+XMLPUBFUN xmlXPathObject *
+		    xmlXPathConvertBoolean	(xmlXPathObject *val);
+XMLPUBFUN xmlXPathObject *
+		    xmlXPathConvertNumber	(xmlXPathObject *val);
+XMLPUBFUN xmlXPathObject *
+		    xmlXPathConvertString	(xmlXPathObject *val);

 /**
 * Context handling.
 */
-XMLPUBFUN xmlXPathContextPtr
-		    xmlXPathNewContext		(xmlDocPtr doc);
+XMLPUBFUN xmlXPathContext *
+		    xmlXPathNewContext		(xmlDoc *doc);
 XMLPUBFUN void
-		    xmlXPathFreeContext		(xmlXPathContextPtr ctxt);
+		    xmlXPathFreeContext		(xmlXPathContext *ctxt);
 XMLPUBFUN void
-		    xmlXPathSetErrorHandler(xmlXPathContextPtr ctxt,
+		    xmlXPathSetErrorHandler(xmlXPathContext *ctxt,
 					    xmlStructuredErrorFunc handler,
 					    void *context);
 XMLPUBFUN int
-		    xmlXPathContextSetCache(xmlXPathContextPtr ctxt,
+		    xmlXPathContextSetCache(xmlXPathContext *ctxt,
 				            int active,
 					    int value,
 					    int options);
@@ -519,39 +519,39 @@ XMLPUBFUN int
 * Evaluation functions.
 */
 XMLPUBFUN long
-		    xmlXPathOrderDocElems	(xmlDocPtr doc);
+		    xmlXPathOrderDocElems	(xmlDoc *doc);
 XMLPUBFUN int
-		    xmlXPathSetContextNode	(xmlNodePtr node,
-						 xmlXPathContextPtr ctx);
-XMLPUBFUN xmlXPathObjectPtr
-		    xmlXPathNodeEval		(xmlNodePtr node,
+		    xmlXPathSetContextNode	(xmlNode *node,
+						 xmlXPathContext *ctx);
+XMLPUBFUN xmlXPathObject *
+		    xmlXPathNodeEval		(xmlNode *node,
 						 const xmlChar *str,
-						 xmlXPathContextPtr ctx);
-XMLPUBFUN xmlXPathObjectPtr
+						 xmlXPathContext *ctx);
+XMLPUBFUN xmlXPathObject *
 		    xmlXPathEval		(const xmlChar *str,
-						 xmlXPathContextPtr ctx);
-XMLPUBFUN xmlXPathObjectPtr
+						 xmlXPathContext *ctx);
+XMLPUBFUN xmlXPathObject *
 		    xmlXPathEvalExpression	(const xmlChar *str,
-						 xmlXPathContextPtr ctxt);
+						 xmlXPathContext *ctxt);
 XMLPUBFUN int
-		    xmlXPathEvalPredicate	(xmlXPathContextPtr ctxt,
-						 xmlXPathObjectPtr res);
+		    xmlXPathEvalPredicate	(xmlXPathContext *ctxt,
+						 xmlXPathObject *res);
 /**
 * Separate compilation/evaluation entry points.
 */
-XMLPUBFUN xmlXPathCompExprPtr
+XMLPUBFUN xmlXPathCompExpr *
 		    xmlXPathCompile		(const xmlChar *str);
-XMLPUBFUN xmlXPathCompExprPtr
-		    xmlXPathCtxtCompile		(xmlXPathContextPtr ctxt,
+XMLPUBFUN xmlXPathCompExpr *
+		    xmlXPathCtxtCompile		(xmlXPathContext *ctxt,
 						 const xmlChar *str);
-XMLPUBFUN xmlXPathObjectPtr
-		    xmlXPathCompiledEval	(xmlXPathCompExprPtr comp,
-						 xmlXPathContextPtr ctx);
+XMLPUBFUN xmlXPathObject *
+		    xmlXPathCompiledEval	(xmlXPathCompExpr *comp,
+						 xmlXPathContext *ctx);
 XMLPUBFUN int
-		    xmlXPathCompiledEvalToBoolean(xmlXPathCompExprPtr comp,
-						 xmlXPathContextPtr ctxt);
+		    xmlXPathCompiledEvalToBoolean(xmlXPathCompExpr *comp,
+						 xmlXPathContext *ctxt);
 XMLPUBFUN void
-		    xmlXPathFreeCompExpr	(xmlXPathCompExprPtr comp);
+		    xmlXPathFreeCompExpr	(xmlXPathCompExpr *comp);

 XML_DEPRECATED
 XMLPUBFUN void
--- a/include/libxml/xpathInternals.h
+++ b/include/libxml/xpathInternals.h
@@ -107,15 +107,15 @@ extern "C" {
 #define xmlXPathGetContextNode(ctxt)	((ctxt)->context->node)

 XMLPUBFUN int
-		xmlXPathPopBoolean	(xmlXPathParserContextPtr ctxt);
+		xmlXPathPopBoolean	(xmlXPathParserContext *ctxt);
 XMLPUBFUN double
-		xmlXPathPopNumber	(xmlXPathParserContextPtr ctxt);
+		xmlXPathPopNumber	(xmlXPathParserContext *ctxt);
 XMLPUBFUN xmlChar *
-		xmlXPathPopString	(xmlXPathParserContextPtr ctxt);
-XMLPUBFUN xmlNodeSetPtr
-		xmlXPathPopNodeSet	(xmlXPathParserContextPtr ctxt);
+		xmlXPathPopString	(xmlXPathParserContext *ctxt);
+XMLPUBFUN xmlNodeSet *
+		xmlXPathPopNodeSet	(xmlXPathParserContext *ctxt);
 XMLPUBFUN void *
-		xmlXPathPopExternal	(xmlXPathParserContextPtr ctxt);
+		xmlXPathPopExternal	(xmlXPathParserContext *ctxt);

 /**
 * Pushes the boolean `val` on the context stack.
@@ -309,7 +309,7 @@ XMLPUBFUN void *
 */

 XMLPUBFUN void
-	xmlXPathRegisterVariableLookup	(xmlXPathContextPtr ctxt,
+	xmlXPathRegisterVariableLookup	(xmlXPathContext *ctxt,
 					 xmlXPathVariableLookupFunc f,
 					 void *data);

@@ -318,7 +318,7 @@ XMLPUBFUN void
 */

 XMLPUBFUN void
-	    xmlXPathRegisterFuncLookup	(xmlXPathContextPtr ctxt,
+	    xmlXPathRegisterFuncLookup	(xmlXPathContext *ctxt,
 					 xmlXPathFuncLookupFunc f,
 					 void *funcCtxt);

@@ -326,72 +326,72 @@ XMLPUBFUN void
 * Error reporting.
 */
 XMLPUBFUN void
-		xmlXPatherror	(xmlXPathParserContextPtr ctxt,
+		xmlXPatherror	(xmlXPathParserContext *ctxt,
 				 const char *file,
 				 int line,
 				 int no);

 XMLPUBFUN void
-		xmlXPathErr	(xmlXPathParserContextPtr ctxt,
+		xmlXPathErr	(xmlXPathParserContext *ctxt,
 				 int error);

 #ifdef LIBXML_DEBUG_ENABLED
 XMLPUBFUN void
 		xmlXPathDebugDumpObject	(FILE *output,
-					 xmlXPathObjectPtr cur,
+					 xmlXPathObject *cur,
 					 int depth);
 XMLPUBFUN void
 	    xmlXPathDebugDumpCompExpr(FILE *output,
-					 xmlXPathCompExprPtr comp,
+					 xmlXPathCompExpr *comp,
 					 int depth);
 #endif
 /**
 * NodeSet handling.
 */
 XMLPUBFUN int
-		xmlXPathNodeSetContains		(xmlNodeSetPtr cur,
-						 xmlNodePtr val);
-XMLPUBFUN xmlNodeSetPtr
-		xmlXPathDifference		(xmlNodeSetPtr nodes1,
-						 xmlNodeSetPtr nodes2);
-XMLPUBFUN xmlNodeSetPtr
-		xmlXPathIntersection		(xmlNodeSetPtr nodes1,
-						 xmlNodeSetPtr nodes2);
+		xmlXPathNodeSetContains		(xmlNodeSet *cur,
+						 xmlNode *val);
+XMLPUBFUN xmlNodeSet *
+		xmlXPathDifference		(xmlNodeSet *nodes1,
+						 xmlNodeSet *nodes2);
+XMLPUBFUN xmlNodeSet *
+		xmlXPathIntersection		(xmlNodeSet *nodes1,
+						 xmlNodeSet *nodes2);

-XMLPUBFUN xmlNodeSetPtr
-		xmlXPathDistinctSorted		(xmlNodeSetPtr nodes);
-XMLPUBFUN xmlNodeSetPtr
-		xmlXPathDistinct		(xmlNodeSetPtr nodes);
+XMLPUBFUN xmlNodeSet *
+		xmlXPathDistinctSorted		(xmlNodeSet *nodes);
+XMLPUBFUN xmlNodeSet *
+		xmlXPathDistinct		(xmlNodeSet *nodes);

 XMLPUBFUN int
-		xmlXPathHasSameNodes		(xmlNodeSetPtr nodes1,
-						 xmlNodeSetPtr nodes2);
+		xmlXPathHasSameNodes		(xmlNodeSet *nodes1,
+						 xmlNodeSet *nodes2);

-XMLPUBFUN xmlNodeSetPtr
-		xmlXPathNodeLeadingSorted	(xmlNodeSetPtr nodes,
-						 xmlNodePtr node);
-XMLPUBFUN xmlNodeSetPtr
-		xmlXPathLeadingSorted		(xmlNodeSetPtr nodes1,
-						 xmlNodeSetPtr nodes2);
-XMLPUBFUN xmlNodeSetPtr
-		xmlXPathNodeLeading		(xmlNodeSetPtr nodes,
-						 xmlNodePtr node);
-XMLPUBFUN xmlNodeSetPtr
-		xmlXPathLeading			(xmlNodeSetPtr nodes1,
-						 xmlNodeSetPtr nodes2);
+XMLPUBFUN xmlNodeSet *
+		xmlXPathNodeLeadingSorted	(xmlNodeSet *nodes,
+						 xmlNode *node);
+XMLPUBFUN xmlNodeSet *
+		xmlXPathLeadingSorted		(xmlNodeSet *nodes1,
+						 xmlNodeSet *nodes2);
+XMLPUBFUN xmlNodeSet *
+		xmlXPathNodeLeading		(xmlNodeSet *nodes,
+						 xmlNode *node);
+XMLPUBFUN xmlNodeSet *
+		xmlXPathLeading			(xmlNodeSet *nodes1,
+						 xmlNodeSet *nodes2);

-XMLPUBFUN xmlNodeSetPtr
-		xmlXPathNodeTrailingSorted	(xmlNodeSetPtr nodes,
-						 xmlNodePtr node);
-XMLPUBFUN xmlNodeSetPtr
-		xmlXPathTrailingSorted		(xmlNodeSetPtr nodes1,
-						 xmlNodeSetPtr nodes2);
-XMLPUBFUN xmlNodeSetPtr
-		xmlXPathNodeTrailing		(xmlNodeSetPtr nodes,
-						 xmlNodePtr node);
-XMLPUBFUN xmlNodeSetPtr
-		xmlXPathTrailing		(xmlNodeSetPtr nodes1,
-						 xmlNodeSetPtr nodes2);
+XMLPUBFUN xmlNodeSet *
+		xmlXPathNodeTrailingSorted	(xmlNodeSet *nodes,
+						 xmlNode *node);
+XMLPUBFUN xmlNodeSet *
+		xmlXPathTrailingSorted		(xmlNodeSet *nodes1,
+						 xmlNodeSet *nodes2);
+XMLPUBFUN xmlNodeSet *
+		xmlXPathNodeTrailing		(xmlNodeSet *nodes,
+						 xmlNode *node);
+XMLPUBFUN xmlNodeSet *
+		xmlXPathTrailing		(xmlNodeSet *nodes1,
+						 xmlNodeSet *nodes2);


 /**
@@ -399,105 +399,105 @@ XMLPUBFUN xmlNodeSetPtr
 */

 XMLPUBFUN int
-		xmlXPathRegisterNs		(xmlXPathContextPtr ctxt,
+		xmlXPathRegisterNs		(xmlXPathContext *ctxt,
 						 const xmlChar *prefix,
 						 const xmlChar *ns_uri);
 XMLPUBFUN const xmlChar *
-		xmlXPathNsLookup		(xmlXPathContextPtr ctxt,
+		xmlXPathNsLookup		(xmlXPathContext *ctxt,
 						 const xmlChar *prefix);
 XMLPUBFUN void
-		xmlXPathRegisteredNsCleanup	(xmlXPathContextPtr ctxt);
+		xmlXPathRegisteredNsCleanup	(xmlXPathContext *ctxt);

 XMLPUBFUN int
-		xmlXPathRegisterFunc		(xmlXPathContextPtr ctxt,
+		xmlXPathRegisterFunc		(xmlXPathContext *ctxt,
 						 const xmlChar *name,
 						 xmlXPathFunction f);
 XMLPUBFUN int
-		xmlXPathRegisterFuncNS		(xmlXPathContextPtr ctxt,
+		xmlXPathRegisterFuncNS		(xmlXPathContext *ctxt,
 						 const xmlChar *name,
 						 const xmlChar *ns_uri,
 						 xmlXPathFunction f);
 XMLPUBFUN int
-		xmlXPathRegisterVariable	(xmlXPathContextPtr ctxt,
+		xmlXPathRegisterVariable	(xmlXPathContext *ctxt,
 						 const xmlChar *name,
-						 xmlXPathObjectPtr value);
+						 xmlXPathObject *value);
 XMLPUBFUN int
-		xmlXPathRegisterVariableNS	(xmlXPathContextPtr ctxt,
+		xmlXPathRegisterVariableNS	(xmlXPathContext *ctxt,
 						 const xmlChar *name,
 						 const xmlChar *ns_uri,
-						 xmlXPathObjectPtr value);
+						 xmlXPathObject *value);
 XMLPUBFUN xmlXPathFunction
-		xmlXPathFunctionLookup		(xmlXPathContextPtr ctxt,
+		xmlXPathFunctionLookup		(xmlXPathContext *ctxt,
 						 const xmlChar *name);
 XMLPUBFUN xmlXPathFunction
-		xmlXPathFunctionLookupNS	(xmlXPathContextPtr ctxt,
+		xmlXPathFunctionLookupNS	(xmlXPathContext *ctxt,
 						 const xmlChar *name,
 						 const xmlChar *ns_uri);
 XMLPUBFUN void
-		xmlXPathRegisteredFuncsCleanup	(xmlXPathContextPtr ctxt);
-XMLPUBFUN xmlXPathObjectPtr
-		xmlXPathVariableLookup		(xmlXPathContextPtr ctxt,
+		xmlXPathRegisteredFuncsCleanup	(xmlXPathContext *ctxt);
+XMLPUBFUN xmlXPathObject *
+		xmlXPathVariableLookup		(xmlXPathContext *ctxt,
 						 const xmlChar *name);
-XMLPUBFUN xmlXPathObjectPtr
-		xmlXPathVariableLookupNS	(xmlXPathContextPtr ctxt,
+XMLPUBFUN xmlXPathObject *
+		xmlXPathVariableLookupNS	(xmlXPathContext *ctxt,
 						 const xmlChar *name,
 						 const xmlChar *ns_uri);
 XMLPUBFUN void
-		xmlXPathRegisteredVariablesCleanup(xmlXPathContextPtr ctxt);
+		xmlXPathRegisteredVariablesCleanup(xmlXPathContext *ctxt);

 /**
 * Utilities to extend XPath.
 */
-XMLPUBFUN xmlXPathParserContextPtr
+XMLPUBFUN xmlXPathParserContext *
 		  xmlXPathNewParserContext	(const xmlChar *str,
-						 xmlXPathContextPtr ctxt);
+						 xmlXPathContext *ctxt);
 XMLPUBFUN void
-		xmlXPathFreeParserContext	(xmlXPathParserContextPtr ctxt);
+		xmlXPathFreeParserContext	(xmlXPathParserContext *ctxt);

-XMLPUBFUN xmlXPathObjectPtr
-		xmlXPathValuePop		(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN xmlXPathObject *
+		xmlXPathValuePop		(xmlXPathParserContext *ctxt);
 XMLPUBFUN int
-		xmlXPathValuePush		(xmlXPathParserContextPtr ctxt,
-						 xmlXPathObjectPtr value);
+		xmlXPathValuePush		(xmlXPathParserContext *ctxt,
+						 xmlXPathObject *value);

-XMLPUBFUN xmlXPathObjectPtr
+XMLPUBFUN xmlXPathObject *
 		xmlXPathNewString		(const xmlChar *val);
-XMLPUBFUN xmlXPathObjectPtr
+XMLPUBFUN xmlXPathObject *
 		xmlXPathNewCString		(const char *val);
-XMLPUBFUN xmlXPathObjectPtr
+XMLPUBFUN xmlXPathObject *
 		xmlXPathWrapString		(xmlChar *val);
-XMLPUBFUN xmlXPathObjectPtr
+XMLPUBFUN xmlXPathObject *
 		xmlXPathWrapCString		(char * val);
-XMLPUBFUN xmlXPathObjectPtr
+XMLPUBFUN xmlXPathObject *
 		xmlXPathNewFloat		(double val);
-XMLPUBFUN xmlXPathObjectPtr
+XMLPUBFUN xmlXPathObject *
 		xmlXPathNewBoolean		(int val);
-XMLPUBFUN xmlXPathObjectPtr
-		xmlXPathNewNodeSet		(xmlNodePtr val);
-XMLPUBFUN xmlXPathObjectPtr
-		xmlXPathNewValueTree		(xmlNodePtr val);
+XMLPUBFUN xmlXPathObject *
+		xmlXPathNewNodeSet		(xmlNode *val);
+XMLPUBFUN xmlXPathObject *
+		xmlXPathNewValueTree		(xmlNode *val);
 XMLPUBFUN int
-		xmlXPathNodeSetAdd		(xmlNodeSetPtr cur,
-						 xmlNodePtr val);
+		xmlXPathNodeSetAdd		(xmlNodeSet *cur,
+						 xmlNode *val);
 XMLPUBFUN int
-		xmlXPathNodeSetAddUnique	(xmlNodeSetPtr cur,
-						 xmlNodePtr val);
+		xmlXPathNodeSetAddUnique	(xmlNodeSet *cur,
+						 xmlNode *val);
 XMLPUBFUN int
-		xmlXPathNodeSetAddNs		(xmlNodeSetPtr cur,
-						 xmlNodePtr node,
-						 xmlNsPtr ns);
+		xmlXPathNodeSetAddNs		(xmlNodeSet *cur,
+						 xmlNode *node,
+						 xmlNs *ns);
 XMLPUBFUN void
-		xmlXPathNodeSetSort		(xmlNodeSetPtr set);
+		xmlXPathNodeSetSort		(xmlNodeSet *set);

 XMLPUBFUN void
-		xmlXPathRoot			(xmlXPathParserContextPtr ctxt);
+		xmlXPathRoot			(xmlXPathParserContext *ctxt);
 XML_DEPRECATED
 XMLPUBFUN void
-		xmlXPathEvalExpr		(xmlXPathParserContextPtr ctxt);
+		xmlXPathEvalExpr		(xmlXPathParserContext *ctxt);
 XMLPUBFUN xmlChar *
-		xmlXPathParseName		(xmlXPathParserContextPtr ctxt);
+		xmlXPathParseName		(xmlXPathParserContext *ctxt);
 XMLPUBFUN xmlChar *
-		xmlXPathParseNCName		(xmlXPathParserContextPtr ctxt);
+		xmlXPathParseNCName		(xmlXPathParserContext *ctxt);

 /*
 * Existing functions.
@@ -505,101 +505,101 @@ XMLPUBFUN xmlChar *
 XMLPUBFUN double
 		xmlXPathStringEvalNumber	(const xmlChar *str);
 XMLPUBFUN int
-		xmlXPathEvaluatePredicateResult (xmlXPathParserContextPtr ctxt,
-						 xmlXPathObjectPtr res);
+		xmlXPathEvaluatePredicateResult (xmlXPathParserContext *ctxt,
+						 xmlXPathObject *res);
 XMLPUBFUN void
-		xmlXPathRegisterAllFunctions	(xmlXPathContextPtr ctxt);
-XMLPUBFUN xmlNodeSetPtr
-		xmlXPathNodeSetMerge		(xmlNodeSetPtr val1,
-						 xmlNodeSetPtr val2);
+		xmlXPathRegisterAllFunctions	(xmlXPathContext *ctxt);
+XMLPUBFUN xmlNodeSet *
+		xmlXPathNodeSetMerge		(xmlNodeSet *val1,
+						 xmlNodeSet *val2);
 XMLPUBFUN void
-		xmlXPathNodeSetDel		(xmlNodeSetPtr cur,
-						 xmlNodePtr val);
+		xmlXPathNodeSetDel		(xmlNodeSet *cur,
+						 xmlNode *val);
 XMLPUBFUN void
-		xmlXPathNodeSetRemove		(xmlNodeSetPtr cur,
+		xmlXPathNodeSetRemove		(xmlNodeSet *cur,
 						 int val);
-XMLPUBFUN xmlXPathObjectPtr
-		xmlXPathNewNodeSetList		(xmlNodeSetPtr val);
-XMLPUBFUN xmlXPathObjectPtr
-		xmlXPathWrapNodeSet		(xmlNodeSetPtr val);
-XMLPUBFUN xmlXPathObjectPtr
+XMLPUBFUN xmlXPathObject *
+		xmlXPathNewNodeSetList		(xmlNodeSet *val);
+XMLPUBFUN xmlXPathObject *
+		xmlXPathWrapNodeSet		(xmlNodeSet *val);
+XMLPUBFUN xmlXPathObject *
 		xmlXPathWrapExternal		(void *val);

-XMLPUBFUN int xmlXPathEqualValues(xmlXPathParserContextPtr ctxt);
-XMLPUBFUN int xmlXPathNotEqualValues(xmlXPathParserContextPtr ctxt);
-XMLPUBFUN int xmlXPathCompareValues(xmlXPathParserContextPtr ctxt, int inf, int strict);
-XMLPUBFUN void xmlXPathValueFlipSign(xmlXPathParserContextPtr ctxt);
-XMLPUBFUN void xmlXPathAddValues(xmlXPathParserContextPtr ctxt);
-XMLPUBFUN void xmlXPathSubValues(xmlXPathParserContextPtr ctxt);
-XMLPUBFUN void xmlXPathMultValues(xmlXPathParserContextPtr ctxt);
-XMLPUBFUN void xmlXPathDivValues(xmlXPathParserContextPtr ctxt);
-XMLPUBFUN void xmlXPathModValues(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN int xmlXPathEqualValues(xmlXPathParserContext *ctxt);
+XMLPUBFUN int xmlXPathNotEqualValues(xmlXPathParserContext *ctxt);
+XMLPUBFUN int xmlXPathCompareValues(xmlXPathParserContext *ctxt, int inf, int strict);
+XMLPUBFUN void xmlXPathValueFlipSign(xmlXPathParserContext *ctxt);
+XMLPUBFUN void xmlXPathAddValues(xmlXPathParserContext *ctxt);
+XMLPUBFUN void xmlXPathSubValues(xmlXPathParserContext *ctxt);
+XMLPUBFUN void xmlXPathMultValues(xmlXPathParserContext *ctxt);
+XMLPUBFUN void xmlXPathDivValues(xmlXPathParserContext *ctxt);
+XMLPUBFUN void xmlXPathModValues(xmlXPathParserContext *ctxt);

 XMLPUBFUN int xmlXPathIsNodeType(const xmlChar *name);

 /*
 * Some of the axis navigation routines.
 */
-XMLPUBFUN xmlNodePtr xmlXPathNextSelf(xmlXPathParserContextPtr ctxt,
-			xmlNodePtr cur);
-XMLPUBFUN xmlNodePtr xmlXPathNextChild(xmlXPathParserContextPtr ctxt,
-			xmlNodePtr cur);
-XMLPUBFUN xmlNodePtr xmlXPathNextDescendant(xmlXPathParserContextPtr ctxt,
-			xmlNodePtr cur);
-XMLPUBFUN xmlNodePtr xmlXPathNextDescendantOrSelf(xmlXPathParserContextPtr ctxt,
-			xmlNodePtr cur);
-XMLPUBFUN xmlNodePtr xmlXPathNextParent(xmlXPathParserContextPtr ctxt,
-			xmlNodePtr cur);
-XMLPUBFUN xmlNodePtr xmlXPathNextAncestorOrSelf(xmlXPathParserContextPtr ctxt,
-			xmlNodePtr cur);
-XMLPUBFUN xmlNodePtr xmlXPathNextFollowingSibling(xmlXPathParserContextPtr ctxt,
-			xmlNodePtr cur);
-XMLPUBFUN xmlNodePtr xmlXPathNextFollowing(xmlXPathParserContextPtr ctxt,
-			xmlNodePtr cur);
-XMLPUBFUN xmlNodePtr xmlXPathNextNamespace(xmlXPathParserContextPtr ctxt,
-			xmlNodePtr cur);
-XMLPUBFUN xmlNodePtr xmlXPathNextAttribute(xmlXPathParserContextPtr ctxt,
-			xmlNodePtr cur);
-XMLPUBFUN xmlNodePtr xmlXPathNextPreceding(xmlXPathParserContextPtr ctxt,
-			xmlNodePtr cur);
-XMLPUBFUN xmlNodePtr xmlXPathNextAncestor(xmlXPathParserContextPtr ctxt,
-			xmlNodePtr cur);
-XMLPUBFUN xmlNodePtr xmlXPathNextPrecedingSibling(xmlXPathParserContextPtr ctxt,
-			xmlNodePtr cur);
+XMLPUBFUN xmlNode *xmlXPathNextSelf(xmlXPathParserContext *ctxt,
+			xmlNode *cur);
+XMLPUBFUN xmlNode *xmlXPathNextChild(xmlXPathParserContext *ctxt,
+			xmlNode *cur);
+XMLPUBFUN xmlNode *xmlXPathNextDescendant(xmlXPathParserContext *ctxt,
+			xmlNode *cur);
+XMLPUBFUN xmlNode *xmlXPathNextDescendantOrSelf(xmlXPathParserContext *ctxt,
+			xmlNode *cur);
+XMLPUBFUN xmlNode *xmlXPathNextParent(xmlXPathParserContext *ctxt,
+			xmlNode *cur);
+XMLPUBFUN xmlNode *xmlXPathNextAncestorOrSelf(xmlXPathParserContext *ctxt,
+			xmlNode *cur);
+XMLPUBFUN xmlNode *xmlXPathNextFollowingSibling(xmlXPathParserContext *ctxt,
+			xmlNode *cur);
+XMLPUBFUN xmlNode *xmlXPathNextFollowing(xmlXPathParserContext *ctxt,
+			xmlNode *cur);
+XMLPUBFUN xmlNode *xmlXPathNextNamespace(xmlXPathParserContext *ctxt,
+			xmlNode *cur);
+XMLPUBFUN xmlNode *xmlXPathNextAttribute(xmlXPathParserContext *ctxt,
+			xmlNode *cur);
+XMLPUBFUN xmlNode *xmlXPathNextPreceding(xmlXPathParserContext *ctxt,
+			xmlNode *cur);
+XMLPUBFUN xmlNode *xmlXPathNextAncestor(xmlXPathParserContext *ctxt,
+			xmlNode *cur);
+XMLPUBFUN xmlNode *xmlXPathNextPrecedingSibling(xmlXPathParserContext *ctxt,
+			xmlNode *cur);
 /*
 * The official core of XPath functions.
 */
-XMLPUBFUN void xmlXPathLastFunction(xmlXPathParserContextPtr ctxt, int nargs);
-XMLPUBFUN void xmlXPathPositionFunction(xmlXPathParserContextPtr ctxt, int nargs);
-XMLPUBFUN void xmlXPathCountFunction(xmlXPathParserContextPtr ctxt, int nargs);
-XMLPUBFUN void xmlXPathIdFunction(xmlXPathParserContextPtr ctxt, int nargs);
-XMLPUBFUN void xmlXPathLocalNameFunction(xmlXPathParserContextPtr ctxt, int nargs);
-XMLPUBFUN void xmlXPathNamespaceURIFunction(xmlXPathParserContextPtr ctxt, int nargs);
-XMLPUBFUN void xmlXPathStringFunction(xmlXPathParserContextPtr ctxt, int nargs);
-XMLPUBFUN void xmlXPathStringLengthFunction(xmlXPathParserContextPtr ctxt, int nargs);
-XMLPUBFUN void xmlXPathConcatFunction(xmlXPathParserContextPtr ctxt, int nargs);
-XMLPUBFUN void xmlXPathContainsFunction(xmlXPathParserContextPtr ctxt, int nargs);
-XMLPUBFUN void xmlXPathStartsWithFunction(xmlXPathParserContextPtr ctxt, int nargs);
-XMLPUBFUN void xmlXPathSubstringFunction(xmlXPathParserContextPtr ctxt, int nargs);
-XMLPUBFUN void xmlXPathSubstringBeforeFunction(xmlXPathParserContextPtr ctxt, int nargs);
-XMLPUBFUN void xmlXPathSubstringAfterFunction(xmlXPathParserContextPtr ctxt, int nargs);
-XMLPUBFUN void xmlXPathNormalizeFunction(xmlXPathParserContextPtr ctxt, int nargs);
-XMLPUBFUN void xmlXPathTranslateFunction(xmlXPathParserContextPtr ctxt, int nargs);
-XMLPUBFUN void xmlXPathNotFunction(xmlXPathParserContextPtr ctxt, int nargs);
-XMLPUBFUN void xmlXPathTrueFunction(xmlXPathParserContextPtr ctxt, int nargs);
-XMLPUBFUN void xmlXPathFalseFunction(xmlXPathParserContextPtr ctxt, int nargs);
-XMLPUBFUN void xmlXPathLangFunction(xmlXPathParserContextPtr ctxt, int nargs);
-XMLPUBFUN void xmlXPathNumberFunction(xmlXPathParserContextPtr ctxt, int nargs);
-XMLPUBFUN void xmlXPathSumFunction(xmlXPathParserContextPtr ctxt, int nargs);
-XMLPUBFUN void xmlXPathFloorFunction(xmlXPathParserContextPtr ctxt, int nargs);
-XMLPUBFUN void xmlXPathCeilingFunction(xmlXPathParserContextPtr ctxt, int nargs);
-XMLPUBFUN void xmlXPathRoundFunction(xmlXPathParserContextPtr ctxt, int nargs);
-XMLPUBFUN void xmlXPathBooleanFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void xmlXPathLastFunction(xmlXPathParserContext *ctxt, int nargs);
+XMLPUBFUN void xmlXPathPositionFunction(xmlXPathParserContext *ctxt, int nargs);
+XMLPUBFUN void xmlXPathCountFunction(xmlXPathParserContext *ctxt, int nargs);
+XMLPUBFUN void xmlXPathIdFunction(xmlXPathParserContext *ctxt, int nargs);
+XMLPUBFUN void xmlXPathLocalNameFunction(xmlXPathParserContext *ctxt, int nargs);
+XMLPUBFUN void xmlXPathNamespaceURIFunction(xmlXPathParserContext *ctxt, int nargs);
+XMLPUBFUN void xmlXPathStringFunction(xmlXPathParserContext *ctxt, int nargs);
+XMLPUBFUN void xmlXPathStringLengthFunction(xmlXPathParserContext *ctxt, int nargs);
+XMLPUBFUN void xmlXPathConcatFunction(xmlXPathParserContext *ctxt, int nargs);
+XMLPUBFUN void xmlXPathContainsFunction(xmlXPathParserContext *ctxt, int nargs);
+XMLPUBFUN void xmlXPathStartsWithFunction(xmlXPathParserContext *ctxt, int nargs);
+XMLPUBFUN void xmlXPathSubstringFunction(xmlXPathParserContext *ctxt, int nargs);
+XMLPUBFUN void xmlXPathSubstringBeforeFunction(xmlXPathParserContext *ctxt, int nargs);
+XMLPUBFUN void xmlXPathSubstringAfterFunction(xmlXPathParserContext *ctxt, int nargs);
+XMLPUBFUN void xmlXPathNormalizeFunction(xmlXPathParserContext *ctxt, int nargs);
+XMLPUBFUN void xmlXPathTranslateFunction(xmlXPathParserContext *ctxt, int nargs);
+XMLPUBFUN void xmlXPathNotFunction(xmlXPathParserContext *ctxt, int nargs);
+XMLPUBFUN void xmlXPathTrueFunction(xmlXPathParserContext *ctxt, int nargs);
+XMLPUBFUN void xmlXPathFalseFunction(xmlXPathParserContext *ctxt, int nargs);
+XMLPUBFUN void xmlXPathLangFunction(xmlXPathParserContext *ctxt, int nargs);
+XMLPUBFUN void xmlXPathNumberFunction(xmlXPathParserContext *ctxt, int nargs);
+XMLPUBFUN void xmlXPathSumFunction(xmlXPathParserContext *ctxt, int nargs);
+XMLPUBFUN void xmlXPathFloorFunction(xmlXPathParserContext *ctxt, int nargs);
+XMLPUBFUN void xmlXPathCeilingFunction(xmlXPathParserContext *ctxt, int nargs);
+XMLPUBFUN void xmlXPathRoundFunction(xmlXPathParserContext *ctxt, int nargs);
+XMLPUBFUN void xmlXPathBooleanFunction(xmlXPathParserContext *ctxt, int nargs);

 /**
 * Really internal functions
 */
-XMLPUBFUN void xmlXPathNodeSetFreeNs(xmlNsPtr ns);
+XMLPUBFUN void xmlXPathNodeSetFreeNs(xmlNs *ns);

 #ifdef __cplusplus
 }
--- a/include/libxml/xpointer.h
+++ b/include/libxml/xpointer.h
@@ -35,13 +35,13 @@ extern "C" {
 * Functions.
 */
 XML_DEPRECATED
-XMLPUBFUN xmlXPathContextPtr
-		    xmlXPtrNewContext		(xmlDocPtr doc,
-						 xmlNodePtr here,
-						 xmlNodePtr origin);
-XMLPUBFUN xmlXPathObjectPtr
+XMLPUBFUN xmlXPathContext *
+		    xmlXPtrNewContext		(xmlDoc *doc,
+						 xmlNode *here,
+						 xmlNode *origin);
+XMLPUBFUN xmlXPathObject *
 		    xmlXPtrEval			(const xmlChar *str,
-						 xmlXPathContextPtr ctx);
+						 xmlXPathContext *ctx);

 #ifdef __cplusplus
 }