revamped the XML debugging module and prepare for a new checking mode

* configure.in debugXML.c include/libxml/xmlversion.h.in
  include/libxml/xmlwin32version.h.in: revamped the XML debugging
  module and prepare for a new checking mode
Daniel

1 files changed, 951 insertions, 647 deletions

diff --git a/debugXML.c b/debugXML.c
index bb6560af..19804414 100644
--- a/debugXML.c
+++ b/debugXML.c
@@ -34,1045 +34,1349 @@
 #include <libxml/relaxng.h>
 #endif
 
-/**
- * xmlDebugDumpString:
- * @output:  the FILE * for the output
- * @str:  the string
- *
- * Dumps informations about the string, shorten it if necessary
- */
-void
-xmlDebugDumpString(FILE * output, const xmlChar * str)
+typedef struct _xmlDebugCtxt xmlDebugCtxt;
+typedef xmlDebugCtxt *xmlDebugCtxtPtr;
+struct _xmlDebugCtxt {
+    FILE *output;               /* the output file */
+    char shift[101];            /* used for indenting */
+    int depth;                  /* current depth */
+    xmlDocPtr doc;              /* current document */
+    int check;                  /* do just checkings */
+};
+
+static void xmlCtxtDumpNodeList(xmlDebugCtxtPtr ctxt, xmlNodePtr node);
+
+static void
+xmlCtxtDumpInitCtxt(xmlDebugCtxtPtr ctxt)
 {
     int i;
 
-    if (output == NULL)
-	output = stdout;
+    ctxt->depth = 0;
+    ctxt->check = 0;
+    ctxt->output = stdout;
+    for (i = 0; i < 100; i++)
+        ctxt->shift[i] = ' ';
+    ctxt->shift[100] = 0;
+}
+
+static void
+xmlCtxtDumpSpaces(xmlDebugCtxtPtr ctxt)
+{
+    if (ctxt->check)
+        return;
+    if ((ctxt->output != NULL) && (ctxt->depth > 0)) {
+        if (ctxt->depth < 50)
+            fprintf(ctxt->output, &ctxt->shift[100 - 2 * ctxt->depth]);
+        else
+            fprintf(ctxt->output, ctxt->shift);
+    }
+}
+
+static void
+xmlCtxtDumpString(xmlDebugCtxtPtr ctxt, const xmlChar * str)
+{
+    int i;
+
+    if (ctxt->check)
+        return;
+    /* TODO: check UTF8 content of the string */
     if (str == NULL) {
-        fprintf(output, "(NULL)");
+        fprintf(ctxt->output, "(NULL)");
         return;
     }
     for (i = 0; i < 40; i++)
         if (str[i] == 0)
             return;
         else if (IS_BLANK_CH(str[i]))
-            fputc(' ', output);
+            fputc(' ', ctxt->output);
         else if (str[i] >= 0x80)
-            fprintf(output, "#%X", str[i]);
+            fprintf(ctxt->output, "#%X", str[i]);
         else
-            fputc(str[i], output);
-    fprintf(output, "...");
+            fputc(str[i], ctxt->output);
+    fprintf(ctxt->output, "...");
 }
 
 static void
-xmlDebugDumpDtdNode(FILE *output, xmlDtdPtr dtd, int depth) {
-    int i;
-    char shift[100];
-
-    for (i = 0;((i < depth) && (i < 25));i++)
-        shift[2 * i] = shift[2 * i + 1] = ' ';
-    shift[2 * i] = shift[2 * i + 1] = 0;
-
-    fprintf(output, shift);
+xmlCtxtDumpDtdNode(xmlDebugCtxtPtr ctxt, xmlDtdPtr dtd)
+{
+    xmlCtxtDumpSpaces(ctxt);
 
     if (dtd == NULL) {
-	fprintf(output, "DTD node is NULL\n");
-	return;
+        if (!ctxt->check)
+            fprintf(ctxt->output, "DTD node is NULL\n");
+        return;
     }
 
     if (dtd->type != XML_DTD_NODE) {
-	fprintf(output, "PBM: not a DTD\n");
-	return;
+        fprintf(ctxt->output, "PBM: not a DTD\n");
+        return;
+    }
+    if (!ctxt->check) {
+        if (dtd->name != NULL)
+            fprintf(ctxt->output, "DTD(%s)", (char *) dtd->name);
+        else
+            fprintf(ctxt->output, "DTD");
+        if (dtd->ExternalID != NULL)
+            fprintf(ctxt->output, ", PUBLIC %s", (char *) dtd->ExternalID);
+        if (dtd->SystemID != NULL)
+            fprintf(ctxt->output, ", SYSTEM %s", (char *) dtd->SystemID);
+        fprintf(ctxt->output, "\n");
     }
-    if (dtd->name != NULL)
-	fprintf(output, "DTD(%s)", (char *)dtd->name);
-    else
-	fprintf(output, "DTD");
-    if (dtd->ExternalID != NULL)
-	fprintf(output, ", PUBLIC %s", (char *)dtd->ExternalID);
-    if (dtd->SystemID != NULL)
-	fprintf(output, ", SYSTEM %s", (char *)dtd->SystemID);
-    fprintf(output, "\n");
     /*
      * Do a bit of checking
      */
     if (dtd->parent == NULL)
-	fprintf(output, "PBM: DTD has no parent\n");
+        fprintf(ctxt->output, "PBM: DTD has no parent\n");
     if (dtd->doc == NULL)
-	fprintf(output, "PBM: DTD has no doc\n");
+        fprintf(ctxt->output, "PBM: DTD has no doc\n");
     if ((dtd->parent != NULL) && (dtd->doc != dtd->parent->doc))
-	fprintf(output, "PBM: DTD doc differs from parent's one\n");
+        fprintf(ctxt->output, "PBM: DTD doc differs from parent's one\n");
     if (dtd->prev == NULL) {
-	if ((dtd->parent != NULL) && (dtd->parent->children != (xmlNodePtr)dtd))
-	    fprintf(output, "PBM: DTD has no prev and not first of list\n");
+        if ((dtd->parent != NULL)
+            && (dtd->parent->children != (xmlNodePtr) dtd))
+            fprintf(ctxt->output,
+                    "PBM: DTD has no prev and not first of list\n");
     } else {
-	if (dtd->prev->next != (xmlNodePtr) dtd)
-	    fprintf(output, "PBM: DTD prev->next : back link wrong\n");
+        if (dtd->prev->next != (xmlNodePtr) dtd)
+            fprintf(ctxt->output,
+                    "PBM: DTD prev->next : back link wrong\n");
     }
     if (dtd->next == NULL) {
-	if ((dtd->parent != NULL) && (dtd->parent->last != (xmlNodePtr) dtd))
-	    fprintf(output, "PBM: DTD has no next and not last of list\n");
+        if ((dtd->parent != NULL)
+            && (dtd->parent->last != (xmlNodePtr) dtd))
+            fprintf(ctxt->output,
+                    "PBM: DTD has no next and not last of list\n");
     } else {
-	if (dtd->next->prev != (xmlNodePtr) dtd)
-	    fprintf(output, "PBM: DTD next->prev : forward link wrong\n");
+        if (dtd->next->prev != (xmlNodePtr) dtd)
+            fprintf(ctxt->output,
+                    "PBM: DTD next->prev : forward link wrong\n");
     }
 }
 
 static void
-xmlDebugDumpAttrDecl(FILE *output, xmlAttributePtr attr, int depth) {
-    int i;
-    char shift[100];
-
-    for (i = 0;((i < depth) && (i < 25));i++)
-        shift[2 * i] = shift[2 * i + 1] = ' ';
-    shift[2 * i] = shift[2 * i + 1] = 0;
-
-    fprintf(output, shift);
+xmlCtxtDumpAttrDecl(xmlDebugCtxtPtr ctxt, xmlAttributePtr attr)
+{
+    xmlCtxtDumpSpaces(ctxt);
 
     if (attr == NULL) {
-	fprintf(output, "Attribute declaration is NULL\n");
-	return;
+        if (!ctxt->check)
+            fprintf(ctxt->output, "Attribute declaration is NULL\n");
+        return;
     }
     if (attr->type != XML_ATTRIBUTE_DECL) {
-	fprintf(output, "PBM: not a Attr\n");
-	return;
-    }
-    if (attr->name != NULL)
-	fprintf(output, "ATTRDECL(%s)", (char *)attr->name);
-    else
-	fprintf(output, "PBM ATTRDECL noname!!!");
-    if (attr->elem != NULL)
-	fprintf(output, " for %s", (char *)attr->elem);
-    else
-	fprintf(output, " PBM noelem!!!");
-    switch (attr->atype) {
-        case XML_ATTRIBUTE_CDATA:
-	    fprintf(output, " CDATA");
-	    break;
-        case XML_ATTRIBUTE_ID:
-	    fprintf(output, " ID");
-	    break;
-        case XML_ATTRIBUTE_IDREF:
-	    fprintf(output, " IDREF");
-	    break;
-        case XML_ATTRIBUTE_IDREFS:
-	    fprintf(output, " IDREFS");
-	    break;
-        case XML_ATTRIBUTE_ENTITY:
-	    fprintf(output, " ENTITY");
-	    break;
-        case XML_ATTRIBUTE_ENTITIES:
-	    fprintf(output, " ENTITIES");
-	    break;
-        case XML_ATTRIBUTE_NMTOKEN:
-	    fprintf(output, " NMTOKEN");
-	    break;
-        case XML_ATTRIBUTE_NMTOKENS:
-	    fprintf(output, " NMTOKENS");
-	    break;
-        case XML_ATTRIBUTE_ENUMERATION:
-	    fprintf(output, " ENUMERATION");
-	    break;
-        case XML_ATTRIBUTE_NOTATION:
-	    fprintf(output, " NOTATION ");
-	    break;
+        fprintf(ctxt->output, "PBM: not a Attr\n");
+        return;
     }
-    if (attr->tree != NULL) {
-	int indx;
-	xmlEnumerationPtr cur = attr->tree;
+    if (attr->name != NULL) {
+        if (!ctxt->check)
+            fprintf(ctxt->output, "ATTRDECL(%s)", (char *) attr->name);
+    } else
+        fprintf(ctxt->output, "PBM ATTRDECL noname!!!");
+    if (attr->elem != NULL) {
+        if (!ctxt->check)
+            fprintf(ctxt->output, " for %s", (char *) attr->elem);
+    } else
+        fprintf(ctxt->output, " PBM noelem!!!");
+    if (!ctxt->check) {
+        switch (attr->atype) {
+            case XML_ATTRIBUTE_CDATA:
+                fprintf(ctxt->output, " CDATA");
+                break;
+            case XML_ATTRIBUTE_ID:
+                fprintf(ctxt->output, " ID");
+                break;
+            case XML_ATTRIBUTE_IDREF:
+                fprintf(ctxt->output, " IDREF");
+                break;
+            case XML_ATTRIBUTE_IDREFS:
+                fprintf(ctxt->output, " IDREFS");
+                break;
+            case XML_ATTRIBUTE_ENTITY:
+                fprintf(ctxt->output, " ENTITY");
+                break;
+            case XML_ATTRIBUTE_ENTITIES:
+                fprintf(ctxt->output, " ENTITIES");
+                break;
+            case XML_ATTRIBUTE_NMTOKEN:
+                fprintf(ctxt->output, " NMTOKEN");
+                break;
+            case XML_ATTRIBUTE_NMTOKENS:
+                fprintf(ctxt->output, " NMTOKENS");
+                break;
+            case XML_ATTRIBUTE_ENUMERATION:
+                fprintf(ctxt->output, " ENUMERATION");
+                break;
+            case XML_ATTRIBUTE_NOTATION:
+                fprintf(ctxt->output, " NOTATION ");
+                break;
+        }
+        if (attr->tree != NULL) {
+            int indx;
+            xmlEnumerationPtr cur = attr->tree;
 
-	for (indx = 0;indx < 5; indx++) {
-	    if (indx != 0)
-		fprintf(output, "|%s", (char *)cur->name);
-	    else
-		fprintf(output, " (%s", (char *)cur->name);
-	    cur = cur->next;
-	    if (cur == NULL) break;
-	}
-	if (cur == NULL)
-	    fprintf(output, ")");
-	else
-	    fprintf(output, "...)");
-    }
-    switch (attr->def) {
-        case XML_ATTRIBUTE_NONE:
-	    break;
-        case XML_ATTRIBUTE_REQUIRED:
-	    fprintf(output, " REQUIRED");
-	    break;
-        case XML_ATTRIBUTE_IMPLIED:
-	    fprintf(output, " IMPLIED");
-	    break;
-        case XML_ATTRIBUTE_FIXED:
-	    fprintf(output, " FIXED");
-	    break;
-    }
-    if (attr->defaultValue != NULL) {
-	fprintf(output, "\"");
-	xmlDebugDumpString(output, attr->defaultValue);
-	fprintf(output, "\"");
+            for (indx = 0; indx < 5; indx++) {
+                if (indx != 0)
+                    fprintf(ctxt->output, "|%s", (char *) cur->name);
+                else
+                    fprintf(ctxt->output, " (%s", (char *) cur->name);
+                cur = cur->next;
+                if (cur == NULL)
+                    break;
+            }
+            if (cur == NULL)
+                fprintf(ctxt->output, ")");
+            else
+                fprintf(ctxt->output, "...)");
+        }
+        switch (attr->def) {
+            case XML_ATTRIBUTE_NONE:
+                break;
+            case XML_ATTRIBUTE_REQUIRED:
+                fprintf(ctxt->output, " REQUIRED");
+                break;
+            case XML_ATTRIBUTE_IMPLIED:
+                fprintf(ctxt->output, " IMPLIED");
+                break;
+            case XML_ATTRIBUTE_FIXED:
+                fprintf(ctxt->output, " FIXED");
+                break;
+        }
+        if (attr->defaultValue != NULL) {
+            fprintf(ctxt->output, "\"");
+            xmlCtxtDumpString(ctxt, attr->defaultValue);
+            fprintf(ctxt->output, "\"");
+        }
+        fprintf(ctxt->output, "\n");
     }
-    fprintf(output, "\n");
 
     /*
      * Do a bit of checking
      */
     if (attr->parent == NULL)
-	fprintf(output, "PBM: Attr has no parent\n");
+        fprintf(ctxt->output, "PBM: Attr has no parent\n");
     if (attr->doc == NULL)
-	fprintf(output, "PBM: Attr has no doc\n");
+        fprintf(ctxt->output, "PBM: Attr has no doc\n");
     if ((attr->parent != NULL) && (attr->doc != attr->parent->doc))
-	fprintf(output, "PBM: Attr doc differs from parent's one\n");
+        fprintf(ctxt->output, "PBM: Attr doc differs from parent's one\n");
     if (attr->prev == NULL) {
-	if ((attr->parent != NULL) && (attr->parent->children != (xmlNodePtr)attr))
-	    fprintf(output, "PBM: Attr has no prev and not first of list\n");
+        if ((attr->parent != NULL)
+            && (attr->parent->children != (xmlNodePtr) attr))
+            fprintf(ctxt->output,
+                    "PBM: Attr has no prev and not first of list\n");
     } else {
-	if (attr->prev->next != (xmlNodePtr) attr)
-	    fprintf(output, "PBM: Attr prev->next : back link wrong\n");
+        if (attr->prev->next != (xmlNodePtr) attr)
+            fprintf(ctxt->output,
+                    "PBM: Attr prev->next : back link wrong\n");
     }
     if (attr->next == NULL) {
-	if ((attr->parent != NULL) && (attr->parent->last != (xmlNodePtr) attr))
-	    fprintf(output, "PBM: Attr has no next and not last of list\n");
+        if ((attr->parent != NULL)
+            && (attr->parent->last != (xmlNodePtr) attr))
+            fprintf(ctxt->output,
+                    "PBM: Attr has no next and not last of list\n");
     } else {
-	if (attr->next->prev != (xmlNodePtr) attr)
-	    fprintf(output, "PBM: Attr next->prev : forward link wrong\n");
+        if (attr->next->prev != (xmlNodePtr) attr)
+            fprintf(ctxt->output,
+                    "PBM: Attr next->prev : forward link wrong\n");
     }
 }
 
 static void
-xmlDebugDumpElemDecl(FILE *output, xmlElementPtr elem, int depth) {
-    int i;
-    char shift[100];
-
-    for (i = 0;((i < depth) && (i < 25));i++)
-        shift[2 * i] = shift[2 * i + 1] = ' ';
-    shift[2 * i] = shift[2 * i + 1] = 0;
-
-    fprintf(output, shift);
+xmlCtxtDumpElemDecl(xmlDebugCtxtPtr ctxt, xmlElementPtr elem)
+{
+    xmlCtxtDumpSpaces(ctxt);
 
     if (elem == NULL) {
-	fprintf(output, "Element declaration is NULL\n");
-	return;
+        if (!ctxt->check)
+            fprintf(ctxt->output, "Element declaration is NULL\n");
+        return;
     }
     if (elem->type != XML_ELEMENT_DECL) {
-	fprintf(output, "PBM: not a Elem\n");
-	return;
+        fprintf(ctxt->output, "PBM: not a Elem\n");
+        return;
     }
     if (elem->name != NULL) {
-	fprintf(output, "ELEMDECL(");
-	xmlDebugDumpString(output, elem->name);
-	fprintf(output, ")");
+        if (!ctxt->check) {
+            fprintf(ctxt->output, "ELEMDECL(");
+            xmlCtxtDumpString(ctxt, elem->name);
+            fprintf(ctxt->output, ")");
+        }
     } else
-	fprintf(output, "PBM ELEMDECL noname!!!");
-    switch (elem->etype) {
-	case XML_ELEMENT_TYPE_UNDEFINED: 
-	    fprintf(output, ", UNDEFINED");
-	    break;
-	case XML_ELEMENT_TYPE_EMPTY: 
-	    fprintf(output, ", EMPTY");
-	    break;
-	case XML_ELEMENT_TYPE_ANY: 
-	    fprintf(output, ", ANY");
-	    break;
-	case XML_ELEMENT_TYPE_MIXED: 
-	    fprintf(output, ", MIXED ");
-	    break;
-	case XML_ELEMENT_TYPE_ELEMENT: 
-	    fprintf(output, ", MIXED ");
-	    break;
-    }
-    if ((elem->type != XML_ELEMENT_NODE) &&
-	(elem->content != NULL)) {
-	char buf[5001];
+        fprintf(ctxt->output, "PBM ELEMDECL noname!!!");
+    if (!ctxt->check) {
+        switch (elem->etype) {
+            case XML_ELEMENT_TYPE_UNDEFINED:
+                fprintf(ctxt->output, ", UNDEFINED");
+                break;
+            case XML_ELEMENT_TYPE_EMPTY:
+                fprintf(ctxt->output, ", EMPTY");
+                break;
+            case XML_ELEMENT_TYPE_ANY:
+                fprintf(ctxt->output, ", ANY");
+                break;
+            case XML_ELEMENT_TYPE_MIXED:
+                fprintf(ctxt->output, ", MIXED ");
+                break;
+            case XML_ELEMENT_TYPE_ELEMENT:
+                fprintf(ctxt->output, ", MIXED ");
+                break;
+        }
+        if ((elem->type != XML_ELEMENT_NODE) && (elem->content != NULL)) {
+            char buf[5001];
 
-	buf[0] = 0;
-	xmlSnprintfElementContent(buf, 5000, elem->content, 1);
-	buf[5000] = 0;
-	fprintf(output, "%s", buf);
+            buf[0] = 0;
+            xmlSnprintfElementContent(buf, 5000, elem->content, 1);
+            buf[5000] = 0;
+            fprintf(ctxt->output, "%s", buf);
+        }
+        fprintf(ctxt->output, "\n");
     }
-    fprintf(output, "\n");
 
     /*
      * Do a bit of checking
      */
     if (elem->parent == NULL)
-	fprintf(output, "PBM: Elem has no parent\n");
+        fprintf(ctxt->output, "PBM: Elem has no parent\n");
     if (elem->doc == NULL)
-	fprintf(output, "PBM: Elem has no doc\n");
+        fprintf(ctxt->output, "PBM: Elem has no doc\n");
     if ((elem->parent != NULL) && (elem->doc != elem->parent->doc))
-	fprintf(output, "PBM: Elem doc differs from parent's one\n");
+        fprintf(ctxt->output, "PBM: Elem doc differs from parent's one\n");
     if (elem->prev == NULL) {
-	if ((elem->parent != NULL) && (elem->parent->children != (xmlNodePtr)elem))
-	    fprintf(output, "PBM: Elem has no prev and not first of list\n");
+        if ((elem->parent != NULL)
+            && (elem->parent->children != (xmlNodePtr) elem))
+            fprintf(ctxt->output,
+                    "PBM: Elem has no prev and not first of list\n");
     } else {
-	if (elem->prev->next != (xmlNodePtr) elem)
-	    fprintf(output, "PBM: Elem prev->next : back link wrong\n");
+        if (elem->prev->next != (xmlNodePtr) elem)
+            fprintf(ctxt->output,
+                    "PBM: Elem prev->next : back link wrong\n");
     }
     if (elem->next == NULL) {
-	if ((elem->parent != NULL) && (elem->parent->last != (xmlNodePtr) elem))
-	    fprintf(output, "PBM: Elem has no next and not last of list\n");
+        if ((elem->parent != NULL)
+            && (elem->parent->last != (xmlNodePtr) elem))
+            fprintf(ctxt->output,
+                    "PBM: Elem has no next and not last of list\n");
     } else {
-	if (elem->next->prev != (xmlNodePtr) elem)
-	    fprintf(output, "PBM: Elem next->prev : forward link wrong\n");
+        if (elem->next->prev != (xmlNodePtr) elem)
+            fprintf(ctxt->output,
+                    "PBM: Elem next->prev : forward link wrong\n");
     }
 }
 
 static void
-xmlDebugDumpEntityDecl(FILE *output, xmlEntityPtr ent, int depth) {
-    int i;
-    char shift[100];
-
-    for (i = 0;((i < depth) && (i < 25));i++)
-        shift[2 * i] = shift[2 * i + 1] = ' ';
-    shift[2 * i] = shift[2 * i + 1] = 0;
-
-    fprintf(output, shift);
+xmlCtxtDumpEntityDecl(xmlDebugCtxtPtr ctxt, xmlEntityPtr ent)
+{
+    xmlCtxtDumpSpaces(ctxt);
 
     if (ent == NULL) {
-	fprintf(output, "Entity declaration is NULL\n");
-	return;
+        if (!ctxt->check)
+            fprintf(ctxt->output, "Entity declaration is NULL\n");
+        return;
     }
     if (ent->type != XML_ENTITY_DECL) {
-	fprintf(output, "PBM: not a Entity decl\n");
-	return;
+        fprintf(ctxt->output, "PBM: not a Entity decl\n");
+        return;
     }
     if (ent->name != NULL) {
-	fprintf(output, "ENTITYDECL(");
-	xmlDebugDumpString(output, ent->name);
-	fprintf(output, ")");
+        if (!ctxt->check) {
+            fprintf(ctxt->output, "ENTITYDECL(");
+            xmlCtxtDumpString(ctxt, ent->name);
+            fprintf(ctxt->output, ")");
+        }
     } else
-	fprintf(output, "PBM ENTITYDECL noname!!!");
-    switch (ent->etype) {
-	case XML_INTERNAL_GENERAL_ENTITY: 
-	    fprintf(output, ", internal\n");
-	    break;
-	case XML_EXTERNAL_GENERAL_PARSED_ENTITY: 
-	    fprintf(output, ", external parsed\n");
-	    break;
-	case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY: 
-	    fprintf(output, ", unparsed\n");
-	    break;
-	case XML_INTERNAL_PARAMETER_ENTITY: 
-	    fprintf(output, ", parameter\n");
-	    break;
-	case XML_EXTERNAL_PARAMETER_ENTITY: 
-	    fprintf(output, ", external parameter\n");
-	    break;
-	case XML_INTERNAL_PREDEFINED_ENTITY: 
-	    fprintf(output, ", predefined\n");
-	    break;
-    }
-    if (ent->ExternalID) {
-        fprintf(output, shift);
-        fprintf(output, " ExternalID=%s\n", (char *)ent->ExternalID);
-    }
-    if (ent->SystemID) {
-        fprintf(output, shift);
-        fprintf(output, " SystemID=%s\n", (char *)ent->SystemID);
-    }
-    if (ent->URI != NULL) {
-        fprintf(output, shift);
-        fprintf(output, " URI=%s\n", (char *)ent->URI);
-    }
-    if (ent->content) {
-        fprintf(output, shift);
-	fprintf(output, " content=");
-	xmlDebugDumpString(output, ent->content);
-	fprintf(output, "\n");
+        fprintf(ctxt->output, "PBM ENTITYDECL noname!!!");
+    if (!ctxt->check) {
+        switch (ent->etype) {
+            case XML_INTERNAL_GENERAL_ENTITY:
+                fprintf(ctxt->output, ", internal\n");
+                break;
+            case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
+                fprintf(ctxt->output, ", external parsed\n");
+                break;
+            case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
+                fprintf(ctxt->output, ", unparsed\n");
+                break;
+            case XML_INTERNAL_PARAMETER_ENTITY:
+                fprintf(ctxt->output, ", parameter\n");
+                break;
+            case XML_EXTERNAL_PARAMETER_ENTITY:
+                fprintf(ctxt->output, ", external parameter\n");
+                break;
+            case XML_INTERNAL_PREDEFINED_ENTITY:
+                fprintf(ctxt->output, ", predefined\n");
+                break;
+        }
+        if (ent->ExternalID) {
+            xmlCtxtDumpSpaces(ctxt);
+            fprintf(ctxt->output, " ExternalID=%s\n",
+                    (char *) ent->ExternalID);
+        }
+        if (ent->SystemID) {
+            xmlCtxtDumpSpaces(ctxt);
+            fprintf(ctxt->output, " SystemID=%s\n",
+                    (char *) ent->SystemID);
+        }
+        if (ent->URI != NULL) {
+            xmlCtxtDumpSpaces(ctxt);
+            fprintf(ctxt->output, " URI=%s\n", (char *) ent->URI);
+        }
+        if (ent->content) {
+            xmlCtxtDumpSpaces(ctxt);
+            fprintf(ctxt->output, " content=");
+            xmlCtxtDumpString(ctxt, ent->content);
+            fprintf(ctxt->output, "\n");
+        }
     }
 
     /*
      * Do a bit of checking
      */
     if (ent->parent == NULL)
-	fprintf(output, "PBM: Ent has no parent\n");
+        fprintf(ctxt->output, "PBM: Ent has no parent\n");
     if (ent->doc == NULL)
-	fprintf(output, "PBM: Ent has no doc\n");
+        fprintf(ctxt->output, "PBM: Ent has no doc\n");
     if ((ent->parent != NULL) && (ent->doc != ent->parent->doc))
-	fprintf(output, "PBM: Ent doc differs from parent's one\n");
+        fprintf(ctxt->output, "PBM: Ent doc differs from parent's one\n");
     if (ent->prev == NULL) {
-	if ((ent->parent != NULL) && (ent->parent->children != (xmlNodePtr)ent))
-	    fprintf(output, "PBM: Ent has no prev and not first of list\n");
+        if ((ent->parent != NULL)
+            && (ent->parent->children != (xmlNodePtr) ent))
+            fprintf(ctxt->output,
+                    "PBM: Ent has no prev and not first of list\n");
     } else {
-	if (ent->prev->next != (xmlNodePtr) ent)
-	    fprintf(output, "PBM: Ent prev->next : back link wrong\n");
+        if (ent->prev->next != (xmlNodePtr) ent)
+            fprintf(ctxt->output,
+                    "PBM: Ent prev->next : back link wrong\n");
     }
     if (ent->next == NULL) {
-	if ((ent->parent != NULL) && (ent->parent->last != (xmlNodePtr) ent))
-	    fprintf(output, "PBM: Ent has no next and not last of list\n");
+        if ((ent->parent != NULL)
+            && (ent->parent->last != (xmlNodePtr) ent))
+            fprintf(ctxt->output,
+                    "PBM: Ent has no next and not last of list\n");
     } else {
-	if (ent->next->prev != (xmlNodePtr) ent)
-	    fprintf(output, "PBM: Ent next->prev : forward link wrong\n");
+        if (ent->next->prev != (xmlNodePtr) ent)
+            fprintf(ctxt->output,
+                    "PBM: Ent next->prev : forward link wrong\n");
     }
 }
 
 static void
-xmlDebugDumpNamespace(FILE *output, xmlNsPtr ns, int depth) {
-    int i;
-    char shift[100];
-
-    for (i = 0;((i < depth) && (i < 25));i++)
-        shift[2 * i] = shift[2 * i + 1] = ' ';
-    shift[2 * i] = shift[2 * i + 1] = 0;
-
-    fprintf(output, shift);
+xmlCtxtDumpNamespace(xmlDebugCtxtPtr ctxt, xmlNsPtr ns)
+{
+    xmlCtxtDumpSpaces(ctxt);
 
     if (ns == NULL) {
-	fprintf(output, "namespace node is NULL\n");
-	return;
+        if (!ctxt->check)
+            fprintf(ctxt->output, "namespace node is NULL\n");
+        return;
     }
     if (ns->type != XML_NAMESPACE_DECL) {
-        fprintf(output, "invalid namespace node %d\n", (char *)ns->type);
-	return;
+        fprintf(ctxt->output, "invalid namespace type %d\n", ns->type);
+        return;
     }
     if (ns->href == NULL) {
-	if (ns->prefix != NULL)
-	    fprintf(output, "incomplete namespace %s href=NULL\n",
-	    	(char *)ns->prefix);
-	else
-	    fprintf(output, "incomplete default namespace href=NULL\n");
+        if (ns->prefix != NULL)
+            fprintf(ctxt->output,
+                    "PBM: incomplete namespace %s href=NULL\n",
+                    (char *) ns->prefix);
+        else
+            fprintf(ctxt->output,
+                    "PBM: incomplete default namespace href=NULL\n");
     } else {
-	if (ns->prefix != NULL)
-	    fprintf(output, "namespace %s href=", (char *)ns->prefix);
-	else
-	    fprintf(output, "default namespace href=");
-
-	xmlDebugDumpString(output, ns->href);
-	fprintf(output, "\n");
+        if (!ctxt->check) {
+            if (ns->prefix != NULL)
+                fprintf(ctxt->output, "namespace %s href=",
+                        (char *) ns->prefix);
+            else
+                fprintf(ctxt->output, "default namespace href=");
+
+            xmlCtxtDumpString(ctxt, ns->href);
+            fprintf(ctxt->output, "\n");
+        }
     }
 }
 
 static void
-xmlDebugDumpNamespaceList(FILE *output, xmlNsPtr ns, int depth) {
+xmlCtxtDumpNamespaceList(xmlDebugCtxtPtr ctxt, xmlNsPtr ns)
+{
     while (ns != NULL) {
-        xmlDebugDumpNamespace(output, ns, depth);
-	ns = ns->next;
+        xmlCtxtDumpNamespace(ctxt, ns);
+        ns = ns->next;
     }
 }
 
 static void
-xmlDebugDumpEntity(FILE *output, xmlEntityPtr ent, int depth) {
-    int i;
-    char shift[100];
-
-    for (i = 0;((i < depth) && (i < 25));i++)
-        shift[2 * i] = shift[2 * i + 1] = ' ';
-    shift[2 * i] = shift[2 * i + 1] = 0;
+xmlCtxtDumpEntity(xmlDebugCtxtPtr ctxt, xmlEntityPtr ent)
+{
+    xmlCtxtDumpSpaces(ctxt);
 
-    fprintf(output, shift);
-    
     if (ent == NULL) {
-	fprintf(output, "Entity is NULL\n");
-	return;
-    }
-    switch (ent->etype) {
-        case XML_INTERNAL_GENERAL_ENTITY:
-	    fprintf(output, "INTERNAL_GENERAL_ENTITY ");
-	    break;
-        case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
-	    fprintf(output, "EXTERNAL_GENERAL_PARSED_ENTITY ");
-	    break;
-        case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
-	    fprintf(output, "EXTERNAL_GENERAL_UNPARSED_ENTITY ");
-	    break;
-        case XML_INTERNAL_PARAMETER_ENTITY:
-	    fprintf(output, "INTERNAL_PARAMETER_ENTITY ");
-	    break;
-        case XML_EXTERNAL_PARAMETER_ENTITY:
-	    fprintf(output, "EXTERNAL_PARAMETER_ENTITY ");
-	    break;
-	default:
-	    fprintf(output, "ENTITY_%d ! ", (char *)ent->etype);
-    }
-    fprintf(output, "%s\n", ent->name);
-    if (ent->ExternalID) {
-        fprintf(output, shift);
-        fprintf(output, "ExternalID=%s\n", (char *)ent->ExternalID);
-    }
-    if (ent->SystemID) {
-        fprintf(output, shift);
-        fprintf(output, "SystemID=%s\n", (char *)ent->SystemID);
-    }
-    if (ent->URI) {
-        fprintf(output, shift);
-        fprintf(output, "URI=%s\n", (char *)ent->URI);
+        if (!ctxt->check)
+            fprintf(ctxt->output, "Entity is NULL\n");
+        return;
     }
-    if (ent->content) {
-        fprintf(output, shift);
-	fprintf(output, "content=");
-	xmlDebugDumpString(output, ent->content);
-	fprintf(output, "\n");
+    if (!ctxt->check) {
+        switch (ent->etype) {
+            case XML_INTERNAL_GENERAL_ENTITY:
+                fprintf(ctxt->output, "INTERNAL_GENERAL_ENTITY ");
+                break;
+            case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
+                fprintf(ctxt->output, "EXTERNAL_GENERAL_PARSED_ENTITY ");
+                break;
+            case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
+                fprintf(ctxt->output, "EXTERNAL_GENERAL_UNPARSED_ENTITY ");
+                break;
+            case XML_INTERNAL_PARAMETER_ENTITY:
+                fprintf(ctxt->output, "INTERNAL_PARAMETER_ENTITY ");
+                break;
+            case XML_EXTERNAL_PARAMETER_ENTITY:
+                fprintf(ctxt->output, "EXTERNAL_PARAMETER_ENTITY ");
+                break;
+            default:
+                fprintf(ctxt->output, "ENTITY_%d ! ", (int) ent->etype);
+        }
+        fprintf(ctxt->output, "%s\n", ent->name);
+        if (ent->ExternalID) {
+            xmlCtxtDumpSpaces(ctxt);
+            fprintf(ctxt->output, "ExternalID=%s\n",
+                    (char *) ent->ExternalID);
+        }
+        if (ent->SystemID) {
+            xmlCtxtDumpSpaces(ctxt);
+            fprintf(ctxt->output, "SystemID=%s\n", (char *) ent->SystemID);
+        }
+        if (ent->URI) {
+            xmlCtxtDumpSpaces(ctxt);
+            fprintf(ctxt->output, "URI=%s\n", (char *) ent->URI);
+        }
+        if (ent->content) {
+            xmlCtxtDumpSpaces(ctxt);
+            fprintf(ctxt->output, "content=");
+            xmlCtxtDumpString(ctxt, ent->content);
+            fprintf(ctxt->output, "\n");
+        }
     }
 }
 
 /**
- * xmlDebugDumpAttr:
+ * xmlCtxtDumpAttr:
  * @output:  the FILE * for the output
  * @attr:  the attribute
  * @depth:  the indentation level.
  *
  * Dumps debug information for the attribute
  */
-void
-xmlDebugDumpAttr(FILE *output, xmlAttrPtr attr, int depth) {
-    int i;
-    char shift[100];
-
-    for (i = 0;((i < depth) && (i < 25));i++)
-        shift[2 * i] = shift[2 * i + 1] = ' ';
-    shift[2 * i] = shift[2 * i + 1] = 0;
+static void
+xmlCtxtDumpAttr(xmlDebugCtxtPtr ctxt, xmlAttrPtr attr)
+{
+    xmlCtxtDumpSpaces(ctxt);
 
-    fprintf(output, shift);
-    
     if (attr == NULL) {
-	fprintf(output, "Attr is NULL");
-	return;
+        if (!ctxt->check)
+            fprintf(ctxt->output, "Attr is NULL");
+        return;
+    }
+    if (!ctxt->check) {
+        fprintf(ctxt->output, "ATTRIBUTE ");
+        xmlCtxtDumpString(ctxt, attr->name);
+        fprintf(ctxt->output, "\n");
+        if (attr->children != NULL) {
+            ctxt->depth++;
+            xmlCtxtDumpNodeList(ctxt, attr->children);
+            ctxt->depth--;
+        }
     }
-    fprintf(output, "ATTRIBUTE ");
-    xmlDebugDumpString(output, attr->name);
-    fprintf(output, "\n");
-    if (attr->children != NULL) 
-        xmlDebugDumpNodeList(output, attr->children, depth + 1);
 
     /*
      * Do a bit of checking
      */
     if (attr->parent == NULL)
-	fprintf(output, "PBM: Attr has no parent\n");
+        fprintf(ctxt->output, "PBM: Attr has no parent\n");
     if (attr->doc == NULL)
-	fprintf(output, "PBM: Attr has no doc\n");
+        fprintf(ctxt->output, "PBM: Attr has no doc\n");
     if ((attr->parent != NULL) && (attr->doc != attr->parent->doc))
-	fprintf(output, "PBM: Attr doc differs from parent's one\n");
+        fprintf(ctxt->output, "PBM: Attr doc differs from parent's one\n");
     if (attr->prev == NULL) {
-	if ((attr->parent != NULL) && (attr->parent->properties != attr))
-	    fprintf(output, "PBM: Attr has no prev and not first of list\n");
+        if ((attr->parent != NULL) && (attr->parent->properties != attr))
+            fprintf(ctxt->output,
+                    "PBM: Attr has no prev and not first of list\n");
     } else {
-	if (attr->prev->next != attr)
-	    fprintf(output, "PBM: Attr prev->next : back link wrong\n");
+        if (attr->prev->next != attr)
+            fprintf(ctxt->output,
+                    "PBM: Attr prev->next : back link wrong\n");
     }
     if (attr->next != NULL) {
-	if (attr->next->prev != attr)
-	    fprintf(output, "PBM: Attr next->prev : forward link wrong\n");
+        if (attr->next->prev != attr)
+            fprintf(ctxt->output,
+                    "PBM: Attr next->prev : forward link wrong\n");
     }
 }
 
 /**
- * xmlDebugDumpAttrList:
+ * xmlCtxtDumpAttrList:
  * @output:  the FILE * for the output
  * @attr:  the attribute list
  * @depth:  the indentation level.
  *
  * Dumps debug information for the attribute list
  */
-void
-xmlDebugDumpAttrList(FILE * output, xmlAttrPtr attr, int depth)
+static void
+xmlCtxtDumpAttrList(xmlDebugCtxtPtr ctxt, xmlAttrPtr attr)
 {
-    if (output == NULL)
-	output = stdout;
     while (attr != NULL) {
-        xmlDebugDumpAttr(output, attr, depth);
+        xmlCtxtDumpAttr(ctxt, attr);
         attr = attr->next;
     }
 }
 
 /**
- * xmlDebugDumpOneNode:
+ * xmlCtxtDumpOneNode:
  * @output:  the FILE * for the output
  * @node:  the node
  * @depth:  the indentation level.
  *
  * Dumps debug information for the element node, it is not recursive
  */
-void
-xmlDebugDumpOneNode(FILE * output, xmlNodePtr node, int depth)
+static void
+xmlCtxtDumpOneNode(xmlDebugCtxtPtr ctxt, xmlNodePtr node)
 {
-    int i;
-    char shift[100];
-
-    if (output == NULL)
-	output = stdout;
-    for (i = 0; ((i < depth) && (i < 25)); i++)
-        shift[2 * i] = shift[2 * i + 1] = ' ';
-    shift[2 * i] = shift[2 * i + 1] = 0;
-
     if (node == NULL) {
-	fprintf(output, shift);
-	fprintf(output, "node is NULL\n");
-	return;
+        if (!ctxt->check) {
+            xmlCtxtDumpSpaces(ctxt);
+            fprintf(ctxt->output, "node is NULL\n");
+        }
+        return;
     }
     switch (node->type) {
         case XML_ELEMENT_NODE:
-            fprintf(output, shift);
-            fprintf(output, "ELEMENT ");
-            if ((node->ns != NULL) && (node->ns->prefix != NULL)) {
-                xmlDebugDumpString(output, node->ns->prefix);
-                fprintf(output, ":");
+            if (!ctxt->check) {
+                xmlCtxtDumpSpaces(ctxt);
+                fprintf(ctxt->output, "ELEMENT ");
+                if ((node->ns != NULL) && (node->ns->prefix != NULL)) {
+                    xmlCtxtDumpString(ctxt, node->ns->prefix);
+                    fprintf(ctxt->output, ":");
+                }
+                xmlCtxtDumpString(ctxt, node->name);
+                fprintf(ctxt->output, "\n");
             }
-            xmlDebugDumpString(output, node->name);
-            fprintf(output, "\n");
             break;
         case XML_ATTRIBUTE_NODE:
-            fprintf(output, shift);
-            fprintf(output, "Error, ATTRIBUTE found here\n");
+            if (!ctxt->check)
+                xmlCtxtDumpSpaces(ctxt);
+            fprintf(ctxt->output, "Error, ATTRIBUTE found here\n");
             break;
         case XML_TEXT_NODE:
-            fprintf(output, shift);
-	    if (node->name == (const xmlChar *) xmlStringTextNoenc)
-		fprintf(output, "TEXT no enc\n");
-	    else
-		fprintf(output, "TEXT\n");
+            if (!ctxt->check) {
+                xmlCtxtDumpSpaces(ctxt);
+                if (node->name == (const xmlChar *) xmlStringTextNoenc)
+                    fprintf(ctxt->output, "TEXT no enc\n");
+                else
+                    fprintf(ctxt->output, "TEXT\n");
+            }
             break;
         case XML_CDATA_SECTION_NODE:
-            fprintf(output, shift);
-            fprintf(output, "CDATA_SECTION\n");
+            if (!ctxt->check) {
+                xmlCtxtDumpSpaces(ctxt);
+                fprintf(ctxt->output, "CDATA_SECTION\n");
+            }
             break;
         case XML_ENTITY_REF_NODE:
-            fprintf(output, shift);
-            fprintf(output, "ENTITY_REF(%s)\n", (char *)node->name);
+            if (!ctxt->check) {
+                xmlCtxtDumpSpaces(ctxt);
+                fprintf(ctxt->output, "ENTITY_REF(%s)\n",
+                        (char *) node->name);
+            }
             break;
         case XML_ENTITY_NODE:
-            fprintf(output, shift);
-            fprintf(output, "ENTITY\n");
+            if (!ctxt->check) {
+                xmlCtxtDumpSpaces(ctxt);
+                fprintf(ctxt->output, "ENTITY\n");
+            }
             break;
         case XML_PI_NODE:
-            fprintf(output, shift);
-            fprintf(output, "PI %s\n", (char *)node->name);
+            if (!ctxt->check) {
+                xmlCtxtDumpSpaces(ctxt);
+                fprintf(ctxt->output, "PI %s\n", (char *) node->name);
+            }
             break;
         case XML_COMMENT_NODE:
-            fprintf(output, shift);
-            fprintf(output, "COMMENT\n");
+            if (!ctxt->check) {
+                xmlCtxtDumpSpaces(ctxt);
+                fprintf(ctxt->output, "COMMENT\n");
+            }
             break;
         case XML_DOCUMENT_NODE:
         case XML_HTML_DOCUMENT_NODE:
-            fprintf(output, shift);
-            fprintf(output, "Error, DOCUMENT found here\n");
+            if (!ctxt->check) {
+                xmlCtxtDumpSpaces(ctxt);
+            }
+            fprintf(ctxt->output, "PBM: DOCUMENT found here\n");
             break;
         case XML_DOCUMENT_TYPE_NODE:
-            fprintf(output, shift);
-            fprintf(output, "DOCUMENT_TYPE\n");
+            if (!ctxt->check) {
+                xmlCtxtDumpSpaces(ctxt);
+                fprintf(ctxt->output, "DOCUMENT_TYPE\n");
+            }
             break;
         case XML_DOCUMENT_FRAG_NODE:
-            fprintf(output, shift);
-            fprintf(output, "DOCUMENT_FRAG\n");
+            if (!ctxt->check) {
+                xmlCtxtDumpSpaces(ctxt);
+                fprintf(ctxt->output, "DOCUMENT_FRAG\n");
+            }
             break;
         case XML_NOTATION_NODE:
-            fprintf(output, shift);
-            fprintf(output, "NOTATION\n");
+            if (!ctxt->check) {
+                xmlCtxtDumpSpaces(ctxt);
+                fprintf(ctxt->output, "NOTATION\n");
+            }
             break;
         case XML_DTD_NODE:
-            xmlDebugDumpDtdNode(output, (xmlDtdPtr) node, depth);
+            xmlCtxtDumpDtdNode(ctxt, (xmlDtdPtr) node);
             return;
         case XML_ELEMENT_DECL:
-            xmlDebugDumpElemDecl(output, (xmlElementPtr) node, depth);
+            xmlCtxtDumpElemDecl(ctxt, (xmlElementPtr) node);
             return;
         case XML_ATTRIBUTE_DECL:
-            xmlDebugDumpAttrDecl(output, (xmlAttributePtr) node, depth);
+            xmlCtxtDumpAttrDecl(ctxt, (xmlAttributePtr) node);
             return;
         case XML_ENTITY_DECL:
-            xmlDebugDumpEntityDecl(output, (xmlEntityPtr) node, depth);
+            xmlCtxtDumpEntityDecl(ctxt, (xmlEntityPtr) node);
             return;
         case XML_NAMESPACE_DECL:
-            xmlDebugDumpNamespace(output, (xmlNsPtr) node, depth);
+            xmlCtxtDumpNamespace(ctxt, (xmlNsPtr) node);
             return;
         case XML_XINCLUDE_START:
-            fprintf(output, shift);
-            fprintf(output, "INCLUDE START\n");
+            if (!ctxt->check) {
+                xmlCtxtDumpSpaces(ctxt);
+                fprintf(ctxt->output, "INCLUDE START\n");
+            }
             return;
         case XML_XINCLUDE_END:
-            fprintf(output, shift);
-            fprintf(output, "INCLUDE END\n");
+            if (!ctxt->check) {
+                xmlCtxtDumpSpaces(ctxt);
+                fprintf(ctxt->output, "INCLUDE END\n");
+            }
             return;
         default:
-            fprintf(output, shift);
-            fprintf(output, "NODE_%d !!!\n", (char *)node->type);
+            if (!ctxt->check)
+                xmlCtxtDumpSpaces(ctxt);
+            fprintf(ctxt->output, "PBM: NODE_%d !!!\n", node->type);
             return;
     }
     if (node->doc == NULL) {
-        fprintf(output, shift);
-        fprintf(output, "doc == NULL !!!\n");
+        if (!ctxt->check) {
+            xmlCtxtDumpSpaces(ctxt);
+        }
+        fprintf(ctxt->output, "PBM: doc == NULL !!!\n");
     }
+    ctxt->depth++;
     if (node->nsDef != NULL)
-        xmlDebugDumpNamespaceList(output, node->nsDef, depth + 1);
+        xmlCtxtDumpNamespaceList(ctxt, node->nsDef);
     if (node->properties != NULL)
-        xmlDebugDumpAttrList(output, node->properties, depth + 1);
+        xmlCtxtDumpAttrList(ctxt, node->properties);
     if (node->type != XML_ENTITY_REF_NODE) {
         if ((node->type != XML_ELEMENT_NODE) && (node->content != NULL)) {
-            shift[2 * i] = shift[2 * i + 1] = ' ';
-            shift[2 * i + 2] = shift[2 * i + 3] = 0;
-            fprintf(output, shift);
-            fprintf(output, "content=");
-            xmlDebugDumpString(output, node->content);
-            fprintf(output, "\n");
+            if (!ctxt->check) {
+                xmlCtxtDumpSpaces(ctxt);
+                fprintf(ctxt->output, "content=");
+                xmlCtxtDumpString(ctxt, node->content);
+                fprintf(ctxt->output, "\n");
+            }
         }
     } else {
         xmlEntityPtr ent;
 
         ent = xmlGetDocEntity(node->doc, node->name);
         if (ent != NULL)
-            xmlDebugDumpEntity(output, ent, depth + 1);
+            xmlCtxtDumpEntity(ctxt, ent);
     }
+    ctxt->depth--;
+
     /*
      * Do a bit of checking
      */
     if (node->parent == NULL)
-        fprintf(output, "PBM: Node has no parent\n");
+        fprintf(ctxt->output, "PBM: Node has no parent\n");
     if (node->doc == NULL)
-        fprintf(output, "PBM: Node has no doc\n");
+        fprintf(ctxt->output, "PBM: Node has no doc\n");
     if ((node->parent != NULL) && (node->doc != node->parent->doc))
-        fprintf(output, "PBM: Node doc differs from parent's one\n");
+        fprintf(ctxt->output, "PBM: Node doc differs from parent's one\n");
     if (node->prev == NULL) {
         if ((node->parent != NULL) && (node->parent->children != node))
-            fprintf(output,
+            fprintf(ctxt->output,
                     "PBM: Node has no prev and not first of list\n");
     } else {
         if (node->prev->next != node)
-            fprintf(output, "PBM: Node prev->next : back link wrong\n");
+            fprintf(ctxt->output,
+                    "PBM: Node prev->next : back link wrong\n");
     }
     if (node->next == NULL) {
         if ((node->parent != NULL) && (node->parent->last != node))
-            fprintf(output,
+            fprintf(ctxt->output,
                     "PBM: Node has no next and not last of list\n");
     } else {
         if (node->next->prev != node)
-            fprintf(output, "PBM: Node next->prev : forward link wrong\n");
+            fprintf(ctxt->output,
+                    "PBM: Node next->prev : forward link wrong\n");
     }
 }
 
 /**
- * xmlDebugDumpNode:
+ * xmlCtxtDumpNode:
  * @output:  the FILE * for the output
  * @node:  the node
  * @depth:  the indentation level.
  *
  * Dumps debug information for the element node, it is recursive
  */
-void
-xmlDebugDumpNode(FILE * output, xmlNodePtr node, int depth)
+static void
+xmlCtxtDumpNode(xmlDebugCtxtPtr ctxt, xmlNodePtr node)
 {
-    if (output == NULL)
-	output = stdout;
     if (node == NULL) {
-	int i;
-	char shift[100];
-    	
-	for (i = 0; ((i < depth) && (i < 25)); i++)
-	    shift[2 * i] = shift[2 * i + 1] = ' ';
-	shift[2 * i] = shift[2 * i + 1] = 0;
-	
-	fprintf(output, shift);
-	fprintf(output, "node is NULL\n");
-	return;
-    }	
-    xmlDebugDumpOneNode(output, node, depth);
-    if ((node->children != NULL) && (node->type != XML_ENTITY_REF_NODE))
-        xmlDebugDumpNodeList(output, node->children, depth + 1);
+        if (!ctxt->check) {
+            xmlCtxtDumpSpaces(ctxt);
+            fprintf(ctxt->output, "node is NULL\n");
+        }
+        return;
+    }
+    xmlCtxtDumpOneNode(ctxt, node);
+    if ((node->children != NULL) && (node->type != XML_ENTITY_REF_NODE)) {
+        ctxt->depth++;
+        xmlCtxtDumpNodeList(ctxt, node->children);
+        ctxt->depth--;
+    }
 }
 
 /**
- * xmlDebugDumpNodeList:
+ * xmlCtxtDumpNodeList:
  * @output:  the FILE * for the output
  * @node:  the node list
  * @depth:  the indentation level.
  *
  * Dumps debug information for the list of element node, it is recursive
  */
-void
-xmlDebugDumpNodeList(FILE * output, xmlNodePtr node, int depth)
+static void
+xmlCtxtDumpNodeList(xmlDebugCtxtPtr ctxt, xmlNodePtr node)
 {
-    if (output == NULL)
-	output = stdout;
     while (node != NULL) {
-        xmlDebugDumpNode(output, node, depth);
+        xmlCtxtDumpNode(ctxt, node);
         node = node->next;
     }
 }
 
 
 /**
- * xmlDebugDumpDocumentHead:
+ * xmlCtxtDumpDocumentHead:
  * @output:  the FILE * for the output
  * @doc:  the document
  *
  * Dumps debug information cncerning the document, not recursive
  */
-void
-xmlDebugDumpDocumentHead(FILE * output, xmlDocPtr doc)
+static void
+xmlCtxtDumpDocumentHead(xmlDebugCtxtPtr ctxt, xmlDocPtr doc)
 {
-    if (output == NULL)
-        output = stdout;
     if (doc == NULL) {
-        fprintf(output, "DOCUMENT == NULL !\n");
+        if (!ctxt->check)
+            fprintf(ctxt->output, "DOCUMENT == NULL !\n");
         return;
     }
 
     switch (doc->type) {
         case XML_ELEMENT_NODE:
-            fprintf(output, "Error, ELEMENT found here ");
+            fprintf(ctxt->output, "Error, ELEMENT found here ");
             break;
         case XML_ATTRIBUTE_NODE:
-            fprintf(output, "Error, ATTRIBUTE found here\n");
+            fprintf(ctxt->output, "Error, ATTRIBUTE found here\n");
             break;
         case XML_TEXT_NODE:
-            fprintf(output, "Error, TEXT\n");
+            fprintf(ctxt->output, "Error, TEXT\n");
             break;
         case XML_CDATA_SECTION_NODE:
-            fprintf(output, "Error, CDATA_SECTION\n");
+            fprintf(ctxt->output, "Error, CDATA_SECTION\n");
             break;
         case XML_ENTITY_REF_NODE:
-            fprintf(output, "Error, ENTITY_REF\n");
+            fprintf(ctxt->output, "Error, ENTITY_REF\n");
             break;
         case XML_ENTITY_NODE:
-            fprintf(output, "Error, ENTITY\n");
+            fprintf(ctxt->output, "Error, ENTITY\n");
             break;
         case XML_PI_NODE:
-            fprintf(output, "Error, PI\n");
+            fprintf(ctxt->output, "Error, PI\n");
             break;
         case XML_COMMENT_NODE:
-            fprintf(output, "Error, COMMENT\n");
+            fprintf(ctxt->output, "Error, COMMENT\n");
             break;
         case XML_DOCUMENT_NODE:
-            fprintf(output, "DOCUMENT\n");
+            fprintf(ctxt->output, "DOCUMENT\n");
             break;
         case XML_HTML_DOCUMENT_NODE:
-            fprintf(output, "HTML DOCUMENT\n");
+            fprintf(ctxt->output, "HTML DOCUMENT\n");
             break;
         case XML_DOCUMENT_TYPE_NODE:
-            fprintf(output, "Error, DOCUMENT_TYPE\n");
+            fprintf(ctxt->output, "Error, DOCUMENT_TYPE\n");
             break;
         case XML_DOCUMENT_FRAG_NODE:
-            fprintf(output, "Error, DOCUMENT_FRAG\n");
+            fprintf(ctxt->output, "Error, DOCUMENT_FRAG\n");
             break;
         case XML_NOTATION_NODE:
-            fprintf(output, "Error, NOTATION\n");
+            fprintf(ctxt->output, "Error, NOTATION\n");
             break;
         default:
-            fprintf(output, "NODE_%d\n", (char *)doc->type);
-    }
-    if (doc->name != NULL) {
-        fprintf(output, "name=");
-        xmlDebugDumpString(output, BAD_CAST doc->name);
-        fprintf(output, "\n");
-    }
-    if (doc->version != NULL) {
-        fprintf(output, "version=");
-        xmlDebugDumpString(output, doc->version);
-        fprintf(output, "\n");
-    }
-    if (doc->encoding != NULL) {
-        fprintf(output, "encoding=");
-        xmlDebugDumpString(output, doc->encoding);
-        fprintf(output, "\n");
-    }
-    if (doc->URL != NULL) {
-        fprintf(output, "URL=");
-        xmlDebugDumpString(output, doc->URL);
-        fprintf(output, "\n");
-    }
-    if (doc->standalone)
-        fprintf(output, "standalone=true\n");
+            fprintf(ctxt->output, "NODE_%d\n", doc->type);
+    }
+    if (!ctxt->check) {
+        if (doc->name != NULL) {
+            fprintf(ctxt->output, "name=");
+            xmlCtxtDumpString(ctxt, BAD_CAST doc->name);
+            fprintf(ctxt->output, "\n");
+        }
+        if (doc->version != NULL) {
+            fprintf(ctxt->output, "version=");
+            xmlCtxtDumpString(ctxt, doc->version);
+            fprintf(ctxt->output, "\n");
+        }
+        if (doc->encoding != NULL) {
+            fprintf(ctxt->output, "encoding=");
+            xmlCtxtDumpString(ctxt, doc->encoding);
+            fprintf(ctxt->output, "\n");
+        }
+        if (doc->URL != NULL) {
+            fprintf(ctxt->output, "URL=");
+            xmlCtxtDumpString(ctxt, doc->URL);
+            fprintf(ctxt->output, "\n");
+        }
+        if (doc->standalone)
+            fprintf(ctxt->output, "standalone=true\n");
+    }
     if (doc->oldNs != NULL)
-        xmlDebugDumpNamespaceList(output, doc->oldNs, 0);
+        xmlCtxtDumpNamespaceList(ctxt, doc->oldNs);
 }
 
 /**
- * xmlDebugDumpDocument:
+ * xmlCtxtDumpDocument:
  * @output:  the FILE * for the output
  * @doc:  the document
  *
  * Dumps debug information for the document, it's recursive
  */
-void
-xmlDebugDumpDocument(FILE * output, xmlDocPtr doc)
+static void
+xmlCtxtDumpDocument(xmlDebugCtxtPtr ctxt, xmlDocPtr doc)
 {
-    if (output == NULL)
-        output = stdout;
     if (doc == NULL) {
-        fprintf(output, "DOCUMENT == NULL !\n");
+        if (!ctxt->check)
+            fprintf(ctxt->output, "DOCUMENT == NULL !\n");
         return;
     }
-    xmlDebugDumpDocumentHead(output, doc);
+    xmlCtxtDumpDocumentHead(ctxt, doc);
     if (((doc->type == XML_DOCUMENT_NODE) ||
-         (doc->type == XML_HTML_DOCUMENT_NODE)) && (doc->children != NULL))
-        xmlDebugDumpNodeList(output, doc->children, 1);
-}
-
-/**
- * xmlDebugDumpDTD:
- * @output:  the FILE * for the output
- * @dtd:  the DTD
- *
- * Dumps debug information for the DTD
- */
-void
-xmlDebugDumpDTD(FILE * output, xmlDtdPtr dtd)
-{
-    if (output == NULL)
-	output = stdout;
-    if (dtd == NULL) {
-	fprintf(output, "DTD is NULL\n");
-        return;
-    }
-    if (dtd->type != XML_DTD_NODE) {
-        fprintf(output, "PBM: not a DTD\n");
-        return;
-    }
-    if (dtd->name != NULL)
-        fprintf(output, "DTD(%s)", (char *)dtd->name);
-    else
-        fprintf(output, "DTD");
-    if (dtd->ExternalID != NULL)
-        fprintf(output, ", PUBLIC %s", (char *)dtd->ExternalID);
-    if (dtd->SystemID != NULL)
-        fprintf(output, ", SYSTEM %s", (char *)dtd->SystemID);
-    fprintf(output, "\n");
-    /*
-     * Do a bit of checking
-     */
-    if ((dtd->parent != NULL) && (dtd->doc != dtd->parent->doc))
-        fprintf(output, "PBM: DTD doc differs from parent's one\n");
-    if (dtd->prev == NULL) {
-        if ((dtd->parent != NULL)
-            && (dtd->parent->children != (xmlNodePtr) dtd))
-            fprintf(output,
-                    "PBM: DTD has no prev and not first of list\n");
-    } else {
-        if (dtd->prev->next != (xmlNodePtr) dtd)
-            fprintf(output, "PBM: DTD prev->next : back link wrong\n");
+         (doc->type == XML_HTML_DOCUMENT_NODE))
+        && (doc->children != NULL)) {
+        ctxt->depth++;
+        xmlCtxtDumpNodeList(ctxt, doc->children);
+        ctxt->depth--;
     }
-    if (dtd->next == NULL) {
-        if ((dtd->parent != NULL)
-            && (dtd->parent->last != (xmlNodePtr) dtd))
-            fprintf(output, "PBM: DTD has no next and not last of list\n");
-    } else {
-        if (dtd->next->prev != (xmlNodePtr) dtd)
-            fprintf(output, "PBM: DTD next->prev : forward link wrong\n");
-    }
-    if (dtd->children == NULL)
-        fprintf(output, "    DTD is empty\n");
-    else
-        xmlDebugDumpNodeList(output, dtd->children, 1);
 }
 
 static void
-xmlDebugDumpEntityCallback(xmlEntityPtr cur, FILE *output) {
+xmlCtxtDumpEntityCallback(xmlEntityPtr cur, xmlDebugCtxtPtr ctxt)
+{
     if (cur == NULL) {
-	fprintf(output, "Entity is NULL");
-	return;
+        if (!ctxt->check)
+            fprintf(ctxt->output, "Entity is NULL");
+        return;
+    }
+    if (!ctxt->check) {
+        fprintf(ctxt->output, "%s : ", (char *) cur->name);
+        switch (cur->etype) {
+            case XML_INTERNAL_GENERAL_ENTITY:
+                fprintf(ctxt->output, "INTERNAL GENERAL, ");
+                break;
+            case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
+                fprintf(ctxt->output, "EXTERNAL PARSED, ");
+                break;
+            case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
+                fprintf(ctxt->output, "EXTERNAL UNPARSED, ");
+                break;
+            case XML_INTERNAL_PARAMETER_ENTITY:
+                fprintf(ctxt->output, "INTERNAL PARAMETER, ");
+                break;
+            case XML_EXTERNAL_PARAMETER_ENTITY:
+                fprintf(ctxt->output, "EXTERNAL PARAMETER, ");
+                break;
+            default:
+                fprintf(ctxt->output, "UNKNOWN TYPE %d", cur->etype);
+        }
+        if (cur->ExternalID != NULL)
+            fprintf(ctxt->output, "ID \"%s\"", (char *) cur->ExternalID);
+        if (cur->SystemID != NULL)
+            fprintf(ctxt->output, "SYSTEM \"%s\"", (char *) cur->SystemID);
+        if (cur->orig != NULL)
+            fprintf(ctxt->output, "\n orig \"%s\"", (char *) cur->orig);
+        if ((cur->type != XML_ELEMENT_NODE) && (cur->content != NULL))
+            fprintf(ctxt->output, "\n content \"%s\"",
+                    (char *) cur->content);
+        fprintf(ctxt->output, "\n");
     }
-    fprintf(output, "%s : ", (char *)cur->name);
-    switch (cur->etype) {
-	case XML_INTERNAL_GENERAL_ENTITY:
-	    fprintf(output, "INTERNAL GENERAL, ");
-	    break;
-	case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
-	    fprintf(output, "EXTERNAL PARSED, ");
-	    break;
-	case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
-	    fprintf(output, "EXTERNAL UNPARSED, ");
-	    break;
-	case XML_INTERNAL_PARAMETER_ENTITY:
-	    fprintf(output, "INTERNAL PARAMETER, ");
-	    break;
-	case XML_EXTERNAL_PARAMETER_ENTITY:
-	    fprintf(output, "EXTERNAL PARAMETER, ");
-	    break;
-	default:
-	    fprintf(output, "UNKNOWN TYPE %d",
-		    (char *)cur->etype);
-    }
-    if (cur->ExternalID != NULL) 
-	fprintf(output, "ID \"%s\"", (char *)cur->ExternalID);
-    if (cur->SystemID != NULL)
-	fprintf(output, "SYSTEM \"%s\"", (char *)cur->SystemID);
-    if (cur->orig != NULL)
-	fprintf(output, "\n orig \"%s\"", (char *)cur->orig);
-    if ((cur->type != XML_ELEMENT_NODE) &&
-	(cur->content != NULL))
-	fprintf(output, "\n content \"%s\"", (char *)cur->content);
-    fprintf(output, "\n");	
 }
 
 /**
- * xmlDebugDumpEntities:
+ * xmlCtxtDumpEntities:
  * @output:  the FILE * for the output
  * @doc:  the document
  *
  * Dumps debug information for all the entities in use by the document
  */
-void
-xmlDebugDumpEntities(FILE * output, xmlDocPtr doc)
+static void
+xmlCtxtDumpEntities(xmlDebugCtxtPtr ctxt, xmlDocPtr doc)
 {
-    if (output == NULL)
-        output = stdout;
     if (doc == NULL) {
-        fprintf(output, "DOCUMENT == NULL !\n");
+        if (!ctxt->check)
+            fprintf(ctxt->output, "DOCUMENT == NULL !\n");
         return;
     }
 
     switch (doc->type) {
         case XML_ELEMENT_NODE:
-            fprintf(output, "Error, ELEMENT found here ");
+            fprintf(ctxt->output, "Error, ELEMENT found here ");
             break;
         case XML_ATTRIBUTE_NODE:
-            fprintf(output, "Error, ATTRIBUTE found here\n");
+            fprintf(ctxt->output, "Error, ATTRIBUTE found here\n");
             break;
         case XML_TEXT_NODE:
-            fprintf(output, "Error, TEXT\n");
+            fprintf(ctxt->output, "Error, TEXT\n");
             break;
         case XML_CDATA_SECTION_NODE:
-            fprintf(output, "Error, CDATA_SECTION\n");
+            fprintf(ctxt->output, "Error, CDATA_SECTION\n");
             break;
         case XML_ENTITY_REF_NODE:
-            fprintf(output, "Error, ENTITY_REF\n");
+            fprintf(ctxt->output, "Error, ENTITY_REF\n");
             break;
         case XML_ENTITY_NODE:
-            fprintf(output, "Error, ENTITY\n");
+            fprintf(ctxt->output, "Error, ENTITY\n");
             break;
         case XML_PI_NODE:
-            fprintf(output, "Error, PI\n");
+            fprintf(ctxt->output, "Error, PI\n");
             break;
         case XML_COMMENT_NODE:
-            fprintf(output, "Error, COMMENT\n");
+            fprintf(ctxt->output, "Error, COMMENT\n");
             break;
         case XML_DOCUMENT_NODE:
-            fprintf(output, "DOCUMENT\n");
+            fprintf(ctxt->output, "DOCUMENT\n");
             break;
         case XML_HTML_DOCUMENT_NODE:
-            fprintf(output, "HTML DOCUMENT\n");
+            fprintf(ctxt->output, "HTML DOCUMENT\n");
             break;
         case XML_DOCUMENT_TYPE_NODE:
-            fprintf(output, "Error, DOCUMENT_TYPE\n");
+            fprintf(ctxt->output, "Error, DOCUMENT_TYPE\n");
             break;
         case XML_DOCUMENT_FRAG_NODE:
-            fprintf(output, "Error, DOCUMENT_FRAG\n");
+            fprintf(ctxt->output, "Error, DOCUMENT_FRAG\n");
             break;
         case XML_NOTATION_NODE:
-            fprintf(output, "Error, NOTATION\n");
+            fprintf(ctxt->output, "Error, NOTATION\n");
             break;
         default:
-            fprintf(output, "NODE_%d\n", (char *)doc->type);
+            fprintf(ctxt->output, "NODE_%d\n", doc->type);
     }
     if ((doc->intSubset != NULL) && (doc->intSubset->entities != NULL)) {
         xmlEntitiesTablePtr table = (xmlEntitiesTablePtr)
             doc->intSubset->entities;
 
-        fprintf(output, "Entities in internal subset\n");
-        xmlHashScan(table, (xmlHashScanner) xmlDebugDumpEntityCallback,
-                    output);
+        if (!ctxt->check)
+            fprintf(ctxt->output, "Entities in internal subset\n");
+        xmlHashScan(table, (xmlHashScanner) xmlCtxtDumpEntityCallback,
+                    ctxt);
     } else
-        fprintf(output, "No entities in internal subset\n");
+        fprintf(ctxt->output, "No entities in internal subset\n");
     if ((doc->extSubset != NULL) && (doc->extSubset->entities != NULL)) {
         xmlEntitiesTablePtr table = (xmlEntitiesTablePtr)
             doc->extSubset->entities;
 
-        fprintf(output, "Entities in external subset\n");
-        xmlHashScan(table, (xmlHashScanner) xmlDebugDumpEntityCallback,
-                    output);
-    } else
-        fprintf(output, "No entities in external subset\n");
+        if (!ctxt->check)
+            fprintf(ctxt->output, "Entities in external subset\n");
+        xmlHashScan(table, (xmlHashScanner) xmlCtxtDumpEntityCallback,
+                    ctxt);
+    } else if (!ctxt->check)
+        fprintf(ctxt->output, "No entities in external subset\n");
+}
+
+/**
+ * xmlCtxtDumpDTD:
+ * @output:  the FILE * for the output
+ * @dtd:  the DTD
+ *
+ * Dumps debug information for the DTD
+ */
+static void
+xmlCtxtDumpDTD(xmlDebugCtxtPtr ctxt, xmlDtdPtr dtd)
+{
+    if (dtd == NULL) {
+        if (!ctxt->check)
+            fprintf(ctxt->output, "DTD is NULL\n");
+        return;
+    }
+    if (dtd->type != XML_DTD_NODE) {
+        fprintf(ctxt->output, "PBM: not a DTD\n");
+        return;
+    }
+    if (!ctxt->check) {
+        if (dtd->name != NULL)
+            fprintf(ctxt->output, "DTD(%s)", (char *) dtd->name);
+        else
+            fprintf(ctxt->output, "DTD");
+        if (dtd->ExternalID != NULL)
+            fprintf(ctxt->output, ", PUBLIC %s", (char *) dtd->ExternalID);
+        if (dtd->SystemID != NULL)
+            fprintf(ctxt->output, ", SYSTEM %s", (char *) dtd->SystemID);
+        fprintf(ctxt->output, "\n");
+    }
+    /*
+     * Do a bit of checking
+     */
+    if ((dtd->parent != NULL) && (dtd->doc != dtd->parent->doc))
+        fprintf(ctxt->output, "PBM: DTD doc differs from parent's one\n");
+    if (dtd->prev == NULL) {
+        if ((dtd->parent != NULL)
+            && (dtd->parent->children != (xmlNodePtr) dtd))
+            fprintf(ctxt->output,
+                    "PBM: DTD has no prev and not first of list\n");
+    } else {
+        if (dtd->prev->next != (xmlNodePtr) dtd)
+            fprintf(ctxt->output,
+                    "PBM: DTD prev->next : back link wrong\n");
+    }
+    if (dtd->next == NULL) {
+        if ((dtd->parent != NULL)
+            && (dtd->parent->last != (xmlNodePtr) dtd))
+            fprintf(ctxt->output,
+                    "PBM: DTD has no next and not last of list\n");
+    } else {
+        if (dtd->next->prev != (xmlNodePtr) dtd)
+            fprintf(ctxt->output,
+                    "PBM: DTD next->prev : forward link wrong\n");
+    }
+    if (dtd->children == NULL)
+        fprintf(ctxt->output, "    DTD is empty\n");
+    else {
+        ctxt->depth++;
+        xmlCtxtDumpNodeList(ctxt, dtd->children);
+        ctxt->depth--;
+    }
+}
+/************************************************************************
+ *									*
+ *			Public entry points				*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlDebugDumpString:
+ * @output:  the FILE * for the output
+ * @str:  the string
+ *
+ * Dumps informations about the string, shorten it if necessary
+ */
+void
+xmlDebugDumpString(FILE * output, const xmlChar * str)
+{
+    int i;
+
+    if (output == NULL)
+	output = stdout;
+    if (str == NULL) {
+        fprintf(output, "(NULL)");
+        return;
+    }
+    for (i = 0; i < 40; i++)
+        if (str[i] == 0)
+            return;
+        else if (IS_BLANK_CH(str[i]))
+            fputc(' ', output);
+        else if (str[i] >= 0x80)
+            fprintf(output, "#%X", str[i]);
+        else
+            fputc(str[i], output);
+    fprintf(output, "...");
+}
+
+/**
+ * xmlDebugDumpAttr:
+ * @output:  the FILE * for the output
+ * @attr:  the attribute
+ * @depth:  the indentation level.
+ *
+ * Dumps debug information for the attribute
+ */
+void
+xmlDebugDumpAttr(FILE *output, xmlAttrPtr attr, int depth) {
+    xmlDebugCtxt ctxt;
+
+    xmlCtxtDumpInitCtxt(&ctxt);
+    ctxt.output = output;
+    ctxt.depth = depth;
+    xmlCtxtDumpAttr(&ctxt, attr);
+}
+
+
+/**
+ * xmlDebugDumpEntities:
+ * @output:  the FILE * for the output
+ * @doc:  the document
+ *
+ * Dumps debug information for all the entities in use by the document
+ */
+void
+xmlDebugDumpEntities(FILE * output, xmlDocPtr doc)
+{
+    xmlDebugCtxt ctxt;
+
+    xmlCtxtDumpInitCtxt(&ctxt);
+    ctxt.output = output;
+    xmlCtxtDumpEntities(&ctxt, doc);
+}
+
+/**
+ * xmlDebugDumpAttrList:
+ * @output:  the FILE * for the output
+ * @attr:  the attribute list
+ * @depth:  the indentation level.
+ *
+ * Dumps debug information for the attribute list
+ */
+void
+xmlDebugDumpAttrList(FILE * output, xmlAttrPtr attr, int depth)
+{
+    xmlDebugCtxt ctxt;
+
+    xmlCtxtDumpInitCtxt(&ctxt);
+    ctxt.output = output;
+    ctxt.depth = depth;
+    xmlCtxtDumpAttrList(&ctxt, attr);
+}
+
+/**
+ * xmlDebugDumpOneNode:
+ * @output:  the FILE * for the output
+ * @node:  the node
+ * @depth:  the indentation level.
+ *
+ * Dumps debug information for the element node, it is not recursive
+ */
+void
+xmlDebugDumpOneNode(FILE * output, xmlNodePtr node, int depth)
+{
+    xmlDebugCtxt ctxt;
+
+    xmlCtxtDumpInitCtxt(&ctxt);
+    ctxt.output = output;
+    ctxt.depth = depth;
+    xmlCtxtDumpOneNode(&ctxt, node);
+}
+
+/**
+ * xmlDebugDumpNode:
+ * @output:  the FILE * for the output
+ * @node:  the node
+ * @depth:  the indentation level.
+ *
+ * Dumps debug information for the element node, it is recursive
+ */
+void
+xmlDebugDumpNode(FILE * output, xmlNodePtr node, int depth)
+{
+    xmlDebugCtxt ctxt;
+
+    if (output == NULL)
+	output = stdout;
+    xmlCtxtDumpInitCtxt(&ctxt);
+    ctxt.output = output;
+    ctxt.depth = depth;
+    xmlCtxtDumpNode(&ctxt, node);
+}
+
+/**
+ * xmlDebugDumpNodeList:
+ * @output:  the FILE * for the output
+ * @node:  the node list
+ * @depth:  the indentation level.
+ *
+ * Dumps debug information for the list of element node, it is recursive
+ */
+void
+xmlDebugDumpNodeList(FILE * output, xmlNodePtr node, int depth)
+{
+    xmlDebugCtxt ctxt;
+
+    if (output == NULL)
+	output = stdout;
+    xmlCtxtDumpInitCtxt(&ctxt);
+    ctxt.output = output;
+    ctxt.depth = depth;
+    xmlCtxtDumpNodeList(&ctxt, node);
+}
+
+/**
+ * xmlDebugDumpDocumentHead:
+ * @output:  the FILE * for the output
+ * @doc:  the document
+ *
+ * Dumps debug information cncerning the document, not recursive
+ */
+void
+xmlDebugDumpDocumentHead(FILE * output, xmlDocPtr doc)
+{
+    xmlDebugCtxt ctxt;
+
+    if (output == NULL)
+	output = stdout;
+    xmlCtxtDumpInitCtxt(&ctxt);
+    ctxt.output = output;
+    xmlCtxtDumpDocumentHead(&ctxt, doc);
+}
+
+/**
+ * xmlDebugDumpDocument:
+ * @output:  the FILE * for the output
+ * @doc:  the document
+ *
+ * Dumps debug information for the document, it's recursive
+ */
+void
+xmlDebugDumpDocument(FILE * output, xmlDocPtr doc)
+{
+    xmlDebugCtxt ctxt;
+
+    if (output == NULL)
+	output = stdout;
+    xmlCtxtDumpInitCtxt(&ctxt);
+    ctxt.output = output;
+    xmlCtxtDumpDocument(&ctxt, doc);
 }
 
 /**
+ * xmlDebugDumpDTD:
+ * @output:  the FILE * for the output
+ * @dtd:  the DTD
+ *
+ * Dumps debug information for the DTD
+ */
+void
+xmlDebugDumpDTD(FILE * output, xmlDtdPtr dtd)
+{
+    xmlDebugCtxt ctxt;
+
+    if (output == NULL)
+	output = stdout;
+    xmlCtxtDumpInitCtxt(&ctxt);
+    ctxt.output = output;
+    xmlCtxtDumpDTD(&ctxt, dtd);
+}
+
+/************************************************************************
+ *									*
+ *			Helpers for Shell				*
+ *									*
+ ************************************************************************/
+
+/**
  * xmlLsCountNode:
  * @node:  the node to count
  *