Annotation of embedaddon/libxml2/debugXML.c, revision 1.1
1.1 ! misho 1: /*
! 2: * debugXML.c : This is a set of routines used for debugging the tree
! 3: * produced by the XML parser.
! 4: *
! 5: * See Copyright for the status of this software.
! 6: *
! 7: * Daniel Veillard <daniel@veillard.com>
! 8: */
! 9:
! 10: #define IN_LIBXML
! 11: #include "libxml.h"
! 12: #ifdef LIBXML_DEBUG_ENABLED
! 13:
! 14: #include <string.h>
! 15: #ifdef HAVE_STDLIB_H
! 16: #include <stdlib.h>
! 17: #endif
! 18: #ifdef HAVE_STRING_H
! 19: #include <string.h>
! 20: #endif
! 21: #include <libxml/xmlmemory.h>
! 22: #include <libxml/tree.h>
! 23: #include <libxml/parser.h>
! 24: #include <libxml/parserInternals.h>
! 25: #include <libxml/valid.h>
! 26: #include <libxml/debugXML.h>
! 27: #include <libxml/HTMLtree.h>
! 28: #include <libxml/HTMLparser.h>
! 29: #include <libxml/xmlerror.h>
! 30: #include <libxml/globals.h>
! 31: #include <libxml/xpathInternals.h>
! 32: #include <libxml/uri.h>
! 33: #ifdef LIBXML_SCHEMAS_ENABLED
! 34: #include <libxml/relaxng.h>
! 35: #endif
! 36:
! 37: #define DUMP_TEXT_TYPE 1
! 38:
! 39: typedef struct _xmlDebugCtxt xmlDebugCtxt;
! 40: typedef xmlDebugCtxt *xmlDebugCtxtPtr;
! 41: struct _xmlDebugCtxt {
! 42: FILE *output; /* the output file */
! 43: char shift[101]; /* used for indenting */
! 44: int depth; /* current depth */
! 45: xmlDocPtr doc; /* current document */
! 46: xmlNodePtr node; /* current node */
! 47: xmlDictPtr dict; /* the doc dictionnary */
! 48: int check; /* do just checkings */
! 49: int errors; /* number of errors found */
! 50: int nodict; /* if the document has no dictionnary */
! 51: int options; /* options */
! 52: };
! 53:
! 54: static void xmlCtxtDumpNodeList(xmlDebugCtxtPtr ctxt, xmlNodePtr node);
! 55:
! 56: static void
! 57: xmlCtxtDumpInitCtxt(xmlDebugCtxtPtr ctxt)
! 58: {
! 59: int i;
! 60:
! 61: ctxt->depth = 0;
! 62: ctxt->check = 0;
! 63: ctxt->errors = 0;
! 64: ctxt->output = stdout;
! 65: ctxt->doc = NULL;
! 66: ctxt->node = NULL;
! 67: ctxt->dict = NULL;
! 68: ctxt->nodict = 0;
! 69: ctxt->options = 0;
! 70: for (i = 0; i < 100; i++)
! 71: ctxt->shift[i] = ' ';
! 72: ctxt->shift[100] = 0;
! 73: }
! 74:
! 75: static void
! 76: xmlCtxtDumpCleanCtxt(xmlDebugCtxtPtr ctxt ATTRIBUTE_UNUSED)
! 77: {
! 78: /* remove the ATTRIBUTE_UNUSED when this is added */
! 79: }
! 80:
! 81: /**
! 82: * xmlNsCheckScope:
! 83: * @node: the node
! 84: * @ns: the namespace node
! 85: *
! 86: * Check that a given namespace is in scope on a node.
! 87: *
! 88: * Returns 1 if in scope, -1 in case of argument error,
! 89: * -2 if the namespace is not in scope, and -3 if not on
! 90: * an ancestor node.
! 91: */
! 92: static int
! 93: xmlNsCheckScope(xmlNodePtr node, xmlNsPtr ns)
! 94: {
! 95: xmlNsPtr cur;
! 96:
! 97: if ((node == NULL) || (ns == NULL))
! 98: return(-1);
! 99:
! 100: if ((node->type != XML_ELEMENT_NODE) &&
! 101: (node->type != XML_ATTRIBUTE_NODE) &&
! 102: (node->type != XML_DOCUMENT_NODE) &&
! 103: (node->type != XML_TEXT_NODE) &&
! 104: (node->type != XML_HTML_DOCUMENT_NODE) &&
! 105: (node->type != XML_XINCLUDE_START))
! 106: return(-2);
! 107:
! 108: while ((node != NULL) &&
! 109: ((node->type == XML_ELEMENT_NODE) ||
! 110: (node->type == XML_ATTRIBUTE_NODE) ||
! 111: (node->type == XML_TEXT_NODE) ||
! 112: (node->type == XML_XINCLUDE_START))) {
! 113: if ((node->type == XML_ELEMENT_NODE) ||
! 114: (node->type == XML_XINCLUDE_START)) {
! 115: cur = node->nsDef;
! 116: while (cur != NULL) {
! 117: if (cur == ns)
! 118: return(1);
! 119: if (xmlStrEqual(cur->prefix, ns->prefix))
! 120: return(-2);
! 121: cur = cur->next;
! 122: }
! 123: }
! 124: node = node->parent;
! 125: }
! 126: /* the xml namespace may be declared on the document node */
! 127: if ((node != NULL) &&
! 128: ((node->type == XML_DOCUMENT_NODE) ||
! 129: (node->type == XML_HTML_DOCUMENT_NODE))) {
! 130: xmlNsPtr oldNs = ((xmlDocPtr) node)->oldNs;
! 131: if (oldNs == ns)
! 132: return(1);
! 133: }
! 134: return(-3);
! 135: }
! 136:
! 137: static void
! 138: xmlCtxtDumpSpaces(xmlDebugCtxtPtr ctxt)
! 139: {
! 140: if (ctxt->check)
! 141: return;
! 142: if ((ctxt->output != NULL) && (ctxt->depth > 0)) {
! 143: if (ctxt->depth < 50)
! 144: fprintf(ctxt->output, "%s", &ctxt->shift[100 - 2 * ctxt->depth]);
! 145: else
! 146: fprintf(ctxt->output, "%s", ctxt->shift);
! 147: }
! 148: }
! 149:
! 150: /**
! 151: * xmlDebugErr:
! 152: * @ctxt: a debug context
! 153: * @error: the error code
! 154: *
! 155: * Handle a debug error.
! 156: */
! 157: static void
! 158: xmlDebugErr(xmlDebugCtxtPtr ctxt, int error, const char *msg)
! 159: {
! 160: ctxt->errors++;
! 161: __xmlRaiseError(NULL, NULL, NULL,
! 162: NULL, ctxt->node, XML_FROM_CHECK,
! 163: error, XML_ERR_ERROR, NULL, 0,
! 164: NULL, NULL, NULL, 0, 0,
! 165: "%s", msg);
! 166: }
! 167: static void
! 168: xmlDebugErr2(xmlDebugCtxtPtr ctxt, int error, const char *msg, int extra)
! 169: {
! 170: ctxt->errors++;
! 171: __xmlRaiseError(NULL, NULL, NULL,
! 172: NULL, ctxt->node, XML_FROM_CHECK,
! 173: error, XML_ERR_ERROR, NULL, 0,
! 174: NULL, NULL, NULL, 0, 0,
! 175: msg, extra);
! 176: }
! 177: static void
! 178: xmlDebugErr3(xmlDebugCtxtPtr ctxt, int error, const char *msg, const char *extra)
! 179: {
! 180: ctxt->errors++;
! 181: __xmlRaiseError(NULL, NULL, NULL,
! 182: NULL, ctxt->node, XML_FROM_CHECK,
! 183: error, XML_ERR_ERROR, NULL, 0,
! 184: NULL, NULL, NULL, 0, 0,
! 185: msg, extra);
! 186: }
! 187:
! 188: /**
! 189: * xmlCtxtNsCheckScope:
! 190: * @ctxt: the debugging context
! 191: * @node: the node
! 192: * @ns: the namespace node
! 193: *
! 194: * Report if a given namespace is is not in scope.
! 195: */
! 196: static void
! 197: xmlCtxtNsCheckScope(xmlDebugCtxtPtr ctxt, xmlNodePtr node, xmlNsPtr ns)
! 198: {
! 199: int ret;
! 200:
! 201: ret = xmlNsCheckScope(node, ns);
! 202: if (ret == -2) {
! 203: if (ns->prefix == NULL)
! 204: xmlDebugErr(ctxt, XML_CHECK_NS_SCOPE,
! 205: "Reference to default namespace not in scope\n");
! 206: else
! 207: xmlDebugErr3(ctxt, XML_CHECK_NS_SCOPE,
! 208: "Reference to namespace '%s' not in scope\n",
! 209: (char *) ns->prefix);
! 210: }
! 211: if (ret == -3) {
! 212: if (ns->prefix == NULL)
! 213: xmlDebugErr(ctxt, XML_CHECK_NS_ANCESTOR,
! 214: "Reference to default namespace not on ancestor\n");
! 215: else
! 216: xmlDebugErr3(ctxt, XML_CHECK_NS_ANCESTOR,
! 217: "Reference to namespace '%s' not on ancestor\n",
! 218: (char *) ns->prefix);
! 219: }
! 220: }
! 221:
! 222: /**
! 223: * xmlCtxtCheckString:
! 224: * @ctxt: the debug context
! 225: * @str: the string
! 226: *
! 227: * Do debugging on the string, currently it just checks the UTF-8 content
! 228: */
! 229: static void
! 230: xmlCtxtCheckString(xmlDebugCtxtPtr ctxt, const xmlChar * str)
! 231: {
! 232: if (str == NULL) return;
! 233: if (ctxt->check) {
! 234: if (!xmlCheckUTF8(str)) {
! 235: xmlDebugErr3(ctxt, XML_CHECK_NOT_UTF8,
! 236: "String is not UTF-8 %s", (const char *) str);
! 237: }
! 238: }
! 239: }
! 240:
! 241: /**
! 242: * xmlCtxtCheckName:
! 243: * @ctxt: the debug context
! 244: * @name: the name
! 245: *
! 246: * Do debugging on the name, for example the dictionnary status and
! 247: * conformance to the Name production.
! 248: */
! 249: static void
! 250: xmlCtxtCheckName(xmlDebugCtxtPtr ctxt, const xmlChar * name)
! 251: {
! 252: if (ctxt->check) {
! 253: if (name == NULL) {
! 254: xmlDebugErr(ctxt, XML_CHECK_NO_NAME, "Name is NULL");
! 255: return;
! 256: }
! 257: if (xmlValidateName(name, 0)) {
! 258: xmlDebugErr3(ctxt, XML_CHECK_NOT_NCNAME,
! 259: "Name is not an NCName '%s'", (const char *) name);
! 260: }
! 261: if ((ctxt->dict != NULL) &&
! 262: (!xmlDictOwns(ctxt->dict, name)) &&
! 263: ((ctxt->doc == NULL) ||
! 264: ((ctxt->doc->parseFlags & (XML_PARSE_SAX1 | XML_PARSE_NODICT)) == 0))) {
! 265: xmlDebugErr3(ctxt, XML_CHECK_OUTSIDE_DICT,
! 266: "Name is not from the document dictionnary '%s'",
! 267: (const char *) name);
! 268: }
! 269: }
! 270: }
! 271:
! 272: static void
! 273: xmlCtxtGenericNodeCheck(xmlDebugCtxtPtr ctxt, xmlNodePtr node) {
! 274: xmlDocPtr doc;
! 275: xmlDictPtr dict;
! 276:
! 277: doc = node->doc;
! 278:
! 279: if (node->parent == NULL)
! 280: xmlDebugErr(ctxt, XML_CHECK_NO_PARENT,
! 281: "Node has no parent\n");
! 282: if (node->doc == NULL) {
! 283: xmlDebugErr(ctxt, XML_CHECK_NO_DOC,
! 284: "Node has no doc\n");
! 285: dict = NULL;
! 286: } else {
! 287: dict = doc->dict;
! 288: if ((dict == NULL) && (ctxt->nodict == 0)) {
! 289: #if 0
! 290: /* desactivated right now as it raises too many errors */
! 291: if (doc->type == XML_DOCUMENT_NODE)
! 292: xmlDebugErr(ctxt, XML_CHECK_NO_DICT,
! 293: "Document has no dictionnary\n");
! 294: #endif
! 295: ctxt->nodict = 1;
! 296: }
! 297: if (ctxt->doc == NULL)
! 298: ctxt->doc = doc;
! 299:
! 300: if (ctxt->dict == NULL) {
! 301: ctxt->dict = dict;
! 302: }
! 303: }
! 304: if ((node->parent != NULL) && (node->doc != node->parent->doc) &&
! 305: (!xmlStrEqual(node->name, BAD_CAST "pseudoroot")))
! 306: xmlDebugErr(ctxt, XML_CHECK_WRONG_DOC,
! 307: "Node doc differs from parent's one\n");
! 308: if (node->prev == NULL) {
! 309: if (node->type == XML_ATTRIBUTE_NODE) {
! 310: if ((node->parent != NULL) &&
! 311: (node != (xmlNodePtr) node->parent->properties))
! 312: xmlDebugErr(ctxt, XML_CHECK_NO_PREV,
! 313: "Attr has no prev and not first of attr list\n");
! 314:
! 315: } else if ((node->parent != NULL) && (node->parent->children != node))
! 316: xmlDebugErr(ctxt, XML_CHECK_NO_PREV,
! 317: "Node has no prev and not first of parent list\n");
! 318: } else {
! 319: if (node->prev->next != node)
! 320: xmlDebugErr(ctxt, XML_CHECK_WRONG_PREV,
! 321: "Node prev->next : back link wrong\n");
! 322: }
! 323: if (node->next == NULL) {
! 324: if ((node->parent != NULL) && (node->type != XML_ATTRIBUTE_NODE) &&
! 325: (node->parent->last != node) &&
! 326: (node->parent->type == XML_ELEMENT_NODE))
! 327: xmlDebugErr(ctxt, XML_CHECK_NO_NEXT,
! 328: "Node has no next and not last of parent list\n");
! 329: } else {
! 330: if (node->next->prev != node)
! 331: xmlDebugErr(ctxt, XML_CHECK_WRONG_NEXT,
! 332: "Node next->prev : forward link wrong\n");
! 333: if (node->next->parent != node->parent)
! 334: xmlDebugErr(ctxt, XML_CHECK_WRONG_PARENT,
! 335: "Node next->prev : forward link wrong\n");
! 336: }
! 337: if (node->type == XML_ELEMENT_NODE) {
! 338: xmlNsPtr ns;
! 339:
! 340: ns = node->nsDef;
! 341: while (ns != NULL) {
! 342: xmlCtxtNsCheckScope(ctxt, node, ns);
! 343: ns = ns->next;
! 344: }
! 345: if (node->ns != NULL)
! 346: xmlCtxtNsCheckScope(ctxt, node, node->ns);
! 347: } else if (node->type == XML_ATTRIBUTE_NODE) {
! 348: if (node->ns != NULL)
! 349: xmlCtxtNsCheckScope(ctxt, node, node->ns);
! 350: }
! 351:
! 352: if ((node->type != XML_ELEMENT_NODE) &&
! 353: (node->type != XML_ATTRIBUTE_NODE) &&
! 354: (node->type != XML_ELEMENT_DECL) &&
! 355: (node->type != XML_ATTRIBUTE_DECL) &&
! 356: (node->type != XML_DTD_NODE) &&
! 357: (node->type != XML_ELEMENT_DECL) &&
! 358: (node->type != XML_HTML_DOCUMENT_NODE) &&
! 359: (node->type != XML_DOCUMENT_NODE)) {
! 360: if (node->content != NULL)
! 361: xmlCtxtCheckString(ctxt, (const xmlChar *) node->content);
! 362: }
! 363: switch (node->type) {
! 364: case XML_ELEMENT_NODE:
! 365: case XML_ATTRIBUTE_NODE:
! 366: xmlCtxtCheckName(ctxt, node->name);
! 367: break;
! 368: case XML_TEXT_NODE:
! 369: if ((node->name == xmlStringText) ||
! 370: (node->name == xmlStringTextNoenc))
! 371: break;
! 372: /* some case of entity substitution can lead to this */
! 373: if ((ctxt->dict != NULL) &&
! 374: (node->name == xmlDictLookup(ctxt->dict, BAD_CAST "nbktext",
! 375: 7)))
! 376: break;
! 377:
! 378: xmlDebugErr3(ctxt, XML_CHECK_WRONG_NAME,
! 379: "Text node has wrong name '%s'",
! 380: (const char *) node->name);
! 381: break;
! 382: case XML_COMMENT_NODE:
! 383: if (node->name == xmlStringComment)
! 384: break;
! 385: xmlDebugErr3(ctxt, XML_CHECK_WRONG_NAME,
! 386: "Comment node has wrong name '%s'",
! 387: (const char *) node->name);
! 388: break;
! 389: case XML_PI_NODE:
! 390: xmlCtxtCheckName(ctxt, node->name);
! 391: break;
! 392: case XML_CDATA_SECTION_NODE:
! 393: if (node->name == NULL)
! 394: break;
! 395: xmlDebugErr3(ctxt, XML_CHECK_NAME_NOT_NULL,
! 396: "CData section has non NULL name '%s'",
! 397: (const char *) node->name);
! 398: break;
! 399: case XML_ENTITY_REF_NODE:
! 400: case XML_ENTITY_NODE:
! 401: case XML_DOCUMENT_TYPE_NODE:
! 402: case XML_DOCUMENT_FRAG_NODE:
! 403: case XML_NOTATION_NODE:
! 404: case XML_DTD_NODE:
! 405: case XML_ELEMENT_DECL:
! 406: case XML_ATTRIBUTE_DECL:
! 407: case XML_ENTITY_DECL:
! 408: case XML_NAMESPACE_DECL:
! 409: case XML_XINCLUDE_START:
! 410: case XML_XINCLUDE_END:
! 411: #ifdef LIBXML_DOCB_ENABLED
! 412: case XML_DOCB_DOCUMENT_NODE:
! 413: #endif
! 414: case XML_DOCUMENT_NODE:
! 415: case XML_HTML_DOCUMENT_NODE:
! 416: break;
! 417: }
! 418: }
! 419:
! 420: static void
! 421: xmlCtxtDumpString(xmlDebugCtxtPtr ctxt, const xmlChar * str)
! 422: {
! 423: int i;
! 424:
! 425: if (ctxt->check) {
! 426: return;
! 427: }
! 428: /* TODO: check UTF8 content of the string */
! 429: if (str == NULL) {
! 430: fprintf(ctxt->output, "(NULL)");
! 431: return;
! 432: }
! 433: for (i = 0; i < 40; i++)
! 434: if (str[i] == 0)
! 435: return;
! 436: else if (IS_BLANK_CH(str[i]))
! 437: fputc(' ', ctxt->output);
! 438: else if (str[i] >= 0x80)
! 439: fprintf(ctxt->output, "#%X", str[i]);
! 440: else
! 441: fputc(str[i], ctxt->output);
! 442: fprintf(ctxt->output, "...");
! 443: }
! 444:
! 445: static void
! 446: xmlCtxtDumpDtdNode(xmlDebugCtxtPtr ctxt, xmlDtdPtr dtd)
! 447: {
! 448: xmlCtxtDumpSpaces(ctxt);
! 449:
! 450: if (dtd == NULL) {
! 451: if (!ctxt->check)
! 452: fprintf(ctxt->output, "DTD node is NULL\n");
! 453: return;
! 454: }
! 455:
! 456: if (dtd->type != XML_DTD_NODE) {
! 457: xmlDebugErr(ctxt, XML_CHECK_NOT_DTD,
! 458: "Node is not a DTD");
! 459: return;
! 460: }
! 461: if (!ctxt->check) {
! 462: if (dtd->name != NULL)
! 463: fprintf(ctxt->output, "DTD(%s)", (char *) dtd->name);
! 464: else
! 465: fprintf(ctxt->output, "DTD");
! 466: if (dtd->ExternalID != NULL)
! 467: fprintf(ctxt->output, ", PUBLIC %s", (char *) dtd->ExternalID);
! 468: if (dtd->SystemID != NULL)
! 469: fprintf(ctxt->output, ", SYSTEM %s", (char *) dtd->SystemID);
! 470: fprintf(ctxt->output, "\n");
! 471: }
! 472: /*
! 473: * Do a bit of checking
! 474: */
! 475: xmlCtxtGenericNodeCheck(ctxt, (xmlNodePtr) dtd);
! 476: }
! 477:
! 478: static void
! 479: xmlCtxtDumpAttrDecl(xmlDebugCtxtPtr ctxt, xmlAttributePtr attr)
! 480: {
! 481: xmlCtxtDumpSpaces(ctxt);
! 482:
! 483: if (attr == NULL) {
! 484: if (!ctxt->check)
! 485: fprintf(ctxt->output, "Attribute declaration is NULL\n");
! 486: return;
! 487: }
! 488: if (attr->type != XML_ATTRIBUTE_DECL) {
! 489: xmlDebugErr(ctxt, XML_CHECK_NOT_ATTR_DECL,
! 490: "Node is not an attribute declaration");
! 491: return;
! 492: }
! 493: if (attr->name != NULL) {
! 494: if (!ctxt->check)
! 495: fprintf(ctxt->output, "ATTRDECL(%s)", (char *) attr->name);
! 496: } else
! 497: xmlDebugErr(ctxt, XML_CHECK_NO_NAME,
! 498: "Node attribute declaration has no name");
! 499: if (attr->elem != NULL) {
! 500: if (!ctxt->check)
! 501: fprintf(ctxt->output, " for %s", (char *) attr->elem);
! 502: } else
! 503: xmlDebugErr(ctxt, XML_CHECK_NO_ELEM,
! 504: "Node attribute declaration has no element name");
! 505: if (!ctxt->check) {
! 506: switch (attr->atype) {
! 507: case XML_ATTRIBUTE_CDATA:
! 508: fprintf(ctxt->output, " CDATA");
! 509: break;
! 510: case XML_ATTRIBUTE_ID:
! 511: fprintf(ctxt->output, " ID");
! 512: break;
! 513: case XML_ATTRIBUTE_IDREF:
! 514: fprintf(ctxt->output, " IDREF");
! 515: break;
! 516: case XML_ATTRIBUTE_IDREFS:
! 517: fprintf(ctxt->output, " IDREFS");
! 518: break;
! 519: case XML_ATTRIBUTE_ENTITY:
! 520: fprintf(ctxt->output, " ENTITY");
! 521: break;
! 522: case XML_ATTRIBUTE_ENTITIES:
! 523: fprintf(ctxt->output, " ENTITIES");
! 524: break;
! 525: case XML_ATTRIBUTE_NMTOKEN:
! 526: fprintf(ctxt->output, " NMTOKEN");
! 527: break;
! 528: case XML_ATTRIBUTE_NMTOKENS:
! 529: fprintf(ctxt->output, " NMTOKENS");
! 530: break;
! 531: case XML_ATTRIBUTE_ENUMERATION:
! 532: fprintf(ctxt->output, " ENUMERATION");
! 533: break;
! 534: case XML_ATTRIBUTE_NOTATION:
! 535: fprintf(ctxt->output, " NOTATION ");
! 536: break;
! 537: }
! 538: if (attr->tree != NULL) {
! 539: int indx;
! 540: xmlEnumerationPtr cur = attr->tree;
! 541:
! 542: for (indx = 0; indx < 5; indx++) {
! 543: if (indx != 0)
! 544: fprintf(ctxt->output, "|%s", (char *) cur->name);
! 545: else
! 546: fprintf(ctxt->output, " (%s", (char *) cur->name);
! 547: cur = cur->next;
! 548: if (cur == NULL)
! 549: break;
! 550: }
! 551: if (cur == NULL)
! 552: fprintf(ctxt->output, ")");
! 553: else
! 554: fprintf(ctxt->output, "...)");
! 555: }
! 556: switch (attr->def) {
! 557: case XML_ATTRIBUTE_NONE:
! 558: break;
! 559: case XML_ATTRIBUTE_REQUIRED:
! 560: fprintf(ctxt->output, " REQUIRED");
! 561: break;
! 562: case XML_ATTRIBUTE_IMPLIED:
! 563: fprintf(ctxt->output, " IMPLIED");
! 564: break;
! 565: case XML_ATTRIBUTE_FIXED:
! 566: fprintf(ctxt->output, " FIXED");
! 567: break;
! 568: }
! 569: if (attr->defaultValue != NULL) {
! 570: fprintf(ctxt->output, "\"");
! 571: xmlCtxtDumpString(ctxt, attr->defaultValue);
! 572: fprintf(ctxt->output, "\"");
! 573: }
! 574: fprintf(ctxt->output, "\n");
! 575: }
! 576:
! 577: /*
! 578: * Do a bit of checking
! 579: */
! 580: xmlCtxtGenericNodeCheck(ctxt, (xmlNodePtr) attr);
! 581: }
! 582:
! 583: static void
! 584: xmlCtxtDumpElemDecl(xmlDebugCtxtPtr ctxt, xmlElementPtr elem)
! 585: {
! 586: xmlCtxtDumpSpaces(ctxt);
! 587:
! 588: if (elem == NULL) {
! 589: if (!ctxt->check)
! 590: fprintf(ctxt->output, "Element declaration is NULL\n");
! 591: return;
! 592: }
! 593: if (elem->type != XML_ELEMENT_DECL) {
! 594: xmlDebugErr(ctxt, XML_CHECK_NOT_ELEM_DECL,
! 595: "Node is not an element declaration");
! 596: return;
! 597: }
! 598: if (elem->name != NULL) {
! 599: if (!ctxt->check) {
! 600: fprintf(ctxt->output, "ELEMDECL(");
! 601: xmlCtxtDumpString(ctxt, elem->name);
! 602: fprintf(ctxt->output, ")");
! 603: }
! 604: } else
! 605: xmlDebugErr(ctxt, XML_CHECK_NO_NAME,
! 606: "Element declaration has no name");
! 607: if (!ctxt->check) {
! 608: switch (elem->etype) {
! 609: case XML_ELEMENT_TYPE_UNDEFINED:
! 610: fprintf(ctxt->output, ", UNDEFINED");
! 611: break;
! 612: case XML_ELEMENT_TYPE_EMPTY:
! 613: fprintf(ctxt->output, ", EMPTY");
! 614: break;
! 615: case XML_ELEMENT_TYPE_ANY:
! 616: fprintf(ctxt->output, ", ANY");
! 617: break;
! 618: case XML_ELEMENT_TYPE_MIXED:
! 619: fprintf(ctxt->output, ", MIXED ");
! 620: break;
! 621: case XML_ELEMENT_TYPE_ELEMENT:
! 622: fprintf(ctxt->output, ", MIXED ");
! 623: break;
! 624: }
! 625: if ((elem->type != XML_ELEMENT_NODE) && (elem->content != NULL)) {
! 626: char buf[5001];
! 627:
! 628: buf[0] = 0;
! 629: xmlSnprintfElementContent(buf, 5000, elem->content, 1);
! 630: buf[5000] = 0;
! 631: fprintf(ctxt->output, "%s", buf);
! 632: }
! 633: fprintf(ctxt->output, "\n");
! 634: }
! 635:
! 636: /*
! 637: * Do a bit of checking
! 638: */
! 639: xmlCtxtGenericNodeCheck(ctxt, (xmlNodePtr) elem);
! 640: }
! 641:
! 642: static void
! 643: xmlCtxtDumpEntityDecl(xmlDebugCtxtPtr ctxt, xmlEntityPtr ent)
! 644: {
! 645: xmlCtxtDumpSpaces(ctxt);
! 646:
! 647: if (ent == NULL) {
! 648: if (!ctxt->check)
! 649: fprintf(ctxt->output, "Entity declaration is NULL\n");
! 650: return;
! 651: }
! 652: if (ent->type != XML_ENTITY_DECL) {
! 653: xmlDebugErr(ctxt, XML_CHECK_NOT_ENTITY_DECL,
! 654: "Node is not an entity declaration");
! 655: return;
! 656: }
! 657: if (ent->name != NULL) {
! 658: if (!ctxt->check) {
! 659: fprintf(ctxt->output, "ENTITYDECL(");
! 660: xmlCtxtDumpString(ctxt, ent->name);
! 661: fprintf(ctxt->output, ")");
! 662: }
! 663: } else
! 664: xmlDebugErr(ctxt, XML_CHECK_NO_NAME,
! 665: "Entity declaration has no name");
! 666: if (!ctxt->check) {
! 667: switch (ent->etype) {
! 668: case XML_INTERNAL_GENERAL_ENTITY:
! 669: fprintf(ctxt->output, ", internal\n");
! 670: break;
! 671: case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
! 672: fprintf(ctxt->output, ", external parsed\n");
! 673: break;
! 674: case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
! 675: fprintf(ctxt->output, ", unparsed\n");
! 676: break;
! 677: case XML_INTERNAL_PARAMETER_ENTITY:
! 678: fprintf(ctxt->output, ", parameter\n");
! 679: break;
! 680: case XML_EXTERNAL_PARAMETER_ENTITY:
! 681: fprintf(ctxt->output, ", external parameter\n");
! 682: break;
! 683: case XML_INTERNAL_PREDEFINED_ENTITY:
! 684: fprintf(ctxt->output, ", predefined\n");
! 685: break;
! 686: }
! 687: if (ent->ExternalID) {
! 688: xmlCtxtDumpSpaces(ctxt);
! 689: fprintf(ctxt->output, " ExternalID=%s\n",
! 690: (char *) ent->ExternalID);
! 691: }
! 692: if (ent->SystemID) {
! 693: xmlCtxtDumpSpaces(ctxt);
! 694: fprintf(ctxt->output, " SystemID=%s\n",
! 695: (char *) ent->SystemID);
! 696: }
! 697: if (ent->URI != NULL) {
! 698: xmlCtxtDumpSpaces(ctxt);
! 699: fprintf(ctxt->output, " URI=%s\n", (char *) ent->URI);
! 700: }
! 701: if (ent->content) {
! 702: xmlCtxtDumpSpaces(ctxt);
! 703: fprintf(ctxt->output, " content=");
! 704: xmlCtxtDumpString(ctxt, ent->content);
! 705: fprintf(ctxt->output, "\n");
! 706: }
! 707: }
! 708:
! 709: /*
! 710: * Do a bit of checking
! 711: */
! 712: xmlCtxtGenericNodeCheck(ctxt, (xmlNodePtr) ent);
! 713: }
! 714:
! 715: static void
! 716: xmlCtxtDumpNamespace(xmlDebugCtxtPtr ctxt, xmlNsPtr ns)
! 717: {
! 718: xmlCtxtDumpSpaces(ctxt);
! 719:
! 720: if (ns == NULL) {
! 721: if (!ctxt->check)
! 722: fprintf(ctxt->output, "namespace node is NULL\n");
! 723: return;
! 724: }
! 725: if (ns->type != XML_NAMESPACE_DECL) {
! 726: xmlDebugErr(ctxt, XML_CHECK_NOT_NS_DECL,
! 727: "Node is not a namespace declaration");
! 728: return;
! 729: }
! 730: if (ns->href == NULL) {
! 731: if (ns->prefix != NULL)
! 732: xmlDebugErr3(ctxt, XML_CHECK_NO_HREF,
! 733: "Incomplete namespace %s href=NULL\n",
! 734: (char *) ns->prefix);
! 735: else
! 736: xmlDebugErr(ctxt, XML_CHECK_NO_HREF,
! 737: "Incomplete default namespace href=NULL\n");
! 738: } else {
! 739: if (!ctxt->check) {
! 740: if (ns->prefix != NULL)
! 741: fprintf(ctxt->output, "namespace %s href=",
! 742: (char *) ns->prefix);
! 743: else
! 744: fprintf(ctxt->output, "default namespace href=");
! 745:
! 746: xmlCtxtDumpString(ctxt, ns->href);
! 747: fprintf(ctxt->output, "\n");
! 748: }
! 749: }
! 750: }
! 751:
! 752: static void
! 753: xmlCtxtDumpNamespaceList(xmlDebugCtxtPtr ctxt, xmlNsPtr ns)
! 754: {
! 755: while (ns != NULL) {
! 756: xmlCtxtDumpNamespace(ctxt, ns);
! 757: ns = ns->next;
! 758: }
! 759: }
! 760:
! 761: static void
! 762: xmlCtxtDumpEntity(xmlDebugCtxtPtr ctxt, xmlEntityPtr ent)
! 763: {
! 764: xmlCtxtDumpSpaces(ctxt);
! 765:
! 766: if (ent == NULL) {
! 767: if (!ctxt->check)
! 768: fprintf(ctxt->output, "Entity is NULL\n");
! 769: return;
! 770: }
! 771: if (!ctxt->check) {
! 772: switch (ent->etype) {
! 773: case XML_INTERNAL_GENERAL_ENTITY:
! 774: fprintf(ctxt->output, "INTERNAL_GENERAL_ENTITY ");
! 775: break;
! 776: case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
! 777: fprintf(ctxt->output, "EXTERNAL_GENERAL_PARSED_ENTITY ");
! 778: break;
! 779: case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
! 780: fprintf(ctxt->output, "EXTERNAL_GENERAL_UNPARSED_ENTITY ");
! 781: break;
! 782: case XML_INTERNAL_PARAMETER_ENTITY:
! 783: fprintf(ctxt->output, "INTERNAL_PARAMETER_ENTITY ");
! 784: break;
! 785: case XML_EXTERNAL_PARAMETER_ENTITY:
! 786: fprintf(ctxt->output, "EXTERNAL_PARAMETER_ENTITY ");
! 787: break;
! 788: default:
! 789: fprintf(ctxt->output, "ENTITY_%d ! ", (int) ent->etype);
! 790: }
! 791: fprintf(ctxt->output, "%s\n", ent->name);
! 792: if (ent->ExternalID) {
! 793: xmlCtxtDumpSpaces(ctxt);
! 794: fprintf(ctxt->output, "ExternalID=%s\n",
! 795: (char *) ent->ExternalID);
! 796: }
! 797: if (ent->SystemID) {
! 798: xmlCtxtDumpSpaces(ctxt);
! 799: fprintf(ctxt->output, "SystemID=%s\n", (char *) ent->SystemID);
! 800: }
! 801: if (ent->URI) {
! 802: xmlCtxtDumpSpaces(ctxt);
! 803: fprintf(ctxt->output, "URI=%s\n", (char *) ent->URI);
! 804: }
! 805: if (ent->content) {
! 806: xmlCtxtDumpSpaces(ctxt);
! 807: fprintf(ctxt->output, "content=");
! 808: xmlCtxtDumpString(ctxt, ent->content);
! 809: fprintf(ctxt->output, "\n");
! 810: }
! 811: }
! 812: }
! 813:
! 814: /**
! 815: * xmlCtxtDumpAttr:
! 816: * @output: the FILE * for the output
! 817: * @attr: the attribute
! 818: * @depth: the indentation level.
! 819: *
! 820: * Dumps debug information for the attribute
! 821: */
! 822: static void
! 823: xmlCtxtDumpAttr(xmlDebugCtxtPtr ctxt, xmlAttrPtr attr)
! 824: {
! 825: xmlCtxtDumpSpaces(ctxt);
! 826:
! 827: if (attr == NULL) {
! 828: if (!ctxt->check)
! 829: fprintf(ctxt->output, "Attr is NULL");
! 830: return;
! 831: }
! 832: if (!ctxt->check) {
! 833: fprintf(ctxt->output, "ATTRIBUTE ");
! 834: xmlCtxtDumpString(ctxt, attr->name);
! 835: fprintf(ctxt->output, "\n");
! 836: if (attr->children != NULL) {
! 837: ctxt->depth++;
! 838: xmlCtxtDumpNodeList(ctxt, attr->children);
! 839: ctxt->depth--;
! 840: }
! 841: }
! 842: if (attr->name == NULL)
! 843: xmlDebugErr(ctxt, XML_CHECK_NO_NAME,
! 844: "Attribute has no name");
! 845:
! 846: /*
! 847: * Do a bit of checking
! 848: */
! 849: xmlCtxtGenericNodeCheck(ctxt, (xmlNodePtr) attr);
! 850: }
! 851:
! 852: /**
! 853: * xmlCtxtDumpAttrList:
! 854: * @output: the FILE * for the output
! 855: * @attr: the attribute list
! 856: * @depth: the indentation level.
! 857: *
! 858: * Dumps debug information for the attribute list
! 859: */
! 860: static void
! 861: xmlCtxtDumpAttrList(xmlDebugCtxtPtr ctxt, xmlAttrPtr attr)
! 862: {
! 863: while (attr != NULL) {
! 864: xmlCtxtDumpAttr(ctxt, attr);
! 865: attr = attr->next;
! 866: }
! 867: }
! 868:
! 869: /**
! 870: * xmlCtxtDumpOneNode:
! 871: * @output: the FILE * for the output
! 872: * @node: the node
! 873: * @depth: the indentation level.
! 874: *
! 875: * Dumps debug information for the element node, it is not recursive
! 876: */
! 877: static void
! 878: xmlCtxtDumpOneNode(xmlDebugCtxtPtr ctxt, xmlNodePtr node)
! 879: {
! 880: if (node == NULL) {
! 881: if (!ctxt->check) {
! 882: xmlCtxtDumpSpaces(ctxt);
! 883: fprintf(ctxt->output, "node is NULL\n");
! 884: }
! 885: return;
! 886: }
! 887: ctxt->node = node;
! 888:
! 889: switch (node->type) {
! 890: case XML_ELEMENT_NODE:
! 891: if (!ctxt->check) {
! 892: xmlCtxtDumpSpaces(ctxt);
! 893: fprintf(ctxt->output, "ELEMENT ");
! 894: if ((node->ns != NULL) && (node->ns->prefix != NULL)) {
! 895: xmlCtxtDumpString(ctxt, node->ns->prefix);
! 896: fprintf(ctxt->output, ":");
! 897: }
! 898: xmlCtxtDumpString(ctxt, node->name);
! 899: fprintf(ctxt->output, "\n");
! 900: }
! 901: break;
! 902: case XML_ATTRIBUTE_NODE:
! 903: if (!ctxt->check)
! 904: xmlCtxtDumpSpaces(ctxt);
! 905: fprintf(ctxt->output, "Error, ATTRIBUTE found here\n");
! 906: xmlCtxtGenericNodeCheck(ctxt, node);
! 907: return;
! 908: case XML_TEXT_NODE:
! 909: if (!ctxt->check) {
! 910: xmlCtxtDumpSpaces(ctxt);
! 911: if (node->name == (const xmlChar *) xmlStringTextNoenc)
! 912: fprintf(ctxt->output, "TEXT no enc");
! 913: else
! 914: fprintf(ctxt->output, "TEXT");
! 915: if (ctxt->options & DUMP_TEXT_TYPE) {
! 916: if (node->content == (xmlChar *) &(node->properties))
! 917: fprintf(ctxt->output, " compact\n");
! 918: else if (xmlDictOwns(ctxt->dict, node->content) == 1)
! 919: fprintf(ctxt->output, " interned\n");
! 920: else
! 921: fprintf(ctxt->output, "\n");
! 922: } else
! 923: fprintf(ctxt->output, "\n");
! 924: }
! 925: break;
! 926: case XML_CDATA_SECTION_NODE:
! 927: if (!ctxt->check) {
! 928: xmlCtxtDumpSpaces(ctxt);
! 929: fprintf(ctxt->output, "CDATA_SECTION\n");
! 930: }
! 931: break;
! 932: case XML_ENTITY_REF_NODE:
! 933: if (!ctxt->check) {
! 934: xmlCtxtDumpSpaces(ctxt);
! 935: fprintf(ctxt->output, "ENTITY_REF(%s)\n",
! 936: (char *) node->name);
! 937: }
! 938: break;
! 939: case XML_ENTITY_NODE:
! 940: if (!ctxt->check) {
! 941: xmlCtxtDumpSpaces(ctxt);
! 942: fprintf(ctxt->output, "ENTITY\n");
! 943: }
! 944: break;
! 945: case XML_PI_NODE:
! 946: if (!ctxt->check) {
! 947: xmlCtxtDumpSpaces(ctxt);
! 948: fprintf(ctxt->output, "PI %s\n", (char *) node->name);
! 949: }
! 950: break;
! 951: case XML_COMMENT_NODE:
! 952: if (!ctxt->check) {
! 953: xmlCtxtDumpSpaces(ctxt);
! 954: fprintf(ctxt->output, "COMMENT\n");
! 955: }
! 956: break;
! 957: case XML_DOCUMENT_NODE:
! 958: case XML_HTML_DOCUMENT_NODE:
! 959: if (!ctxt->check) {
! 960: xmlCtxtDumpSpaces(ctxt);
! 961: }
! 962: fprintf(ctxt->output, "Error, DOCUMENT found here\n");
! 963: xmlCtxtGenericNodeCheck(ctxt, node);
! 964: return;
! 965: case XML_DOCUMENT_TYPE_NODE:
! 966: if (!ctxt->check) {
! 967: xmlCtxtDumpSpaces(ctxt);
! 968: fprintf(ctxt->output, "DOCUMENT_TYPE\n");
! 969: }
! 970: break;
! 971: case XML_DOCUMENT_FRAG_NODE:
! 972: if (!ctxt->check) {
! 973: xmlCtxtDumpSpaces(ctxt);
! 974: fprintf(ctxt->output, "DOCUMENT_FRAG\n");
! 975: }
! 976: break;
! 977: case XML_NOTATION_NODE:
! 978: if (!ctxt->check) {
! 979: xmlCtxtDumpSpaces(ctxt);
! 980: fprintf(ctxt->output, "NOTATION\n");
! 981: }
! 982: break;
! 983: case XML_DTD_NODE:
! 984: xmlCtxtDumpDtdNode(ctxt, (xmlDtdPtr) node);
! 985: return;
! 986: case XML_ELEMENT_DECL:
! 987: xmlCtxtDumpElemDecl(ctxt, (xmlElementPtr) node);
! 988: return;
! 989: case XML_ATTRIBUTE_DECL:
! 990: xmlCtxtDumpAttrDecl(ctxt, (xmlAttributePtr) node);
! 991: return;
! 992: case XML_ENTITY_DECL:
! 993: xmlCtxtDumpEntityDecl(ctxt, (xmlEntityPtr) node);
! 994: return;
! 995: case XML_NAMESPACE_DECL:
! 996: xmlCtxtDumpNamespace(ctxt, (xmlNsPtr) node);
! 997: return;
! 998: case XML_XINCLUDE_START:
! 999: if (!ctxt->check) {
! 1000: xmlCtxtDumpSpaces(ctxt);
! 1001: fprintf(ctxt->output, "INCLUDE START\n");
! 1002: }
! 1003: return;
! 1004: case XML_XINCLUDE_END:
! 1005: if (!ctxt->check) {
! 1006: xmlCtxtDumpSpaces(ctxt);
! 1007: fprintf(ctxt->output, "INCLUDE END\n");
! 1008: }
! 1009: return;
! 1010: default:
! 1011: if (!ctxt->check)
! 1012: xmlCtxtDumpSpaces(ctxt);
! 1013: xmlDebugErr2(ctxt, XML_CHECK_UNKNOWN_NODE,
! 1014: "Unknown node type %d\n", node->type);
! 1015: return;
! 1016: }
! 1017: if (node->doc == NULL) {
! 1018: if (!ctxt->check) {
! 1019: xmlCtxtDumpSpaces(ctxt);
! 1020: }
! 1021: fprintf(ctxt->output, "PBM: doc == NULL !!!\n");
! 1022: }
! 1023: ctxt->depth++;
! 1024: if ((node->type == XML_ELEMENT_NODE) && (node->nsDef != NULL))
! 1025: xmlCtxtDumpNamespaceList(ctxt, node->nsDef);
! 1026: if ((node->type == XML_ELEMENT_NODE) && (node->properties != NULL))
! 1027: xmlCtxtDumpAttrList(ctxt, node->properties);
! 1028: if (node->type != XML_ENTITY_REF_NODE) {
! 1029: if ((node->type != XML_ELEMENT_NODE) && (node->content != NULL)) {
! 1030: if (!ctxt->check) {
! 1031: xmlCtxtDumpSpaces(ctxt);
! 1032: fprintf(ctxt->output, "content=");
! 1033: xmlCtxtDumpString(ctxt, node->content);
! 1034: fprintf(ctxt->output, "\n");
! 1035: }
! 1036: }
! 1037: } else {
! 1038: xmlEntityPtr ent;
! 1039:
! 1040: ent = xmlGetDocEntity(node->doc, node->name);
! 1041: if (ent != NULL)
! 1042: xmlCtxtDumpEntity(ctxt, ent);
! 1043: }
! 1044: ctxt->depth--;
! 1045:
! 1046: /*
! 1047: * Do a bit of checking
! 1048: */
! 1049: xmlCtxtGenericNodeCheck(ctxt, node);
! 1050: }
! 1051:
! 1052: /**
! 1053: * xmlCtxtDumpNode:
! 1054: * @output: the FILE * for the output
! 1055: * @node: the node
! 1056: * @depth: the indentation level.
! 1057: *
! 1058: * Dumps debug information for the element node, it is recursive
! 1059: */
! 1060: static void
! 1061: xmlCtxtDumpNode(xmlDebugCtxtPtr ctxt, xmlNodePtr node)
! 1062: {
! 1063: if (node == NULL) {
! 1064: if (!ctxt->check) {
! 1065: xmlCtxtDumpSpaces(ctxt);
! 1066: fprintf(ctxt->output, "node is NULL\n");
! 1067: }
! 1068: return;
! 1069: }
! 1070: xmlCtxtDumpOneNode(ctxt, node);
! 1071: if ((node->type != XML_NAMESPACE_DECL) &&
! 1072: (node->children != NULL) && (node->type != XML_ENTITY_REF_NODE)) {
! 1073: ctxt->depth++;
! 1074: xmlCtxtDumpNodeList(ctxt, node->children);
! 1075: ctxt->depth--;
! 1076: }
! 1077: }
! 1078:
! 1079: /**
! 1080: * xmlCtxtDumpNodeList:
! 1081: * @output: the FILE * for the output
! 1082: * @node: the node list
! 1083: * @depth: the indentation level.
! 1084: *
! 1085: * Dumps debug information for the list of element node, it is recursive
! 1086: */
! 1087: static void
! 1088: xmlCtxtDumpNodeList(xmlDebugCtxtPtr ctxt, xmlNodePtr node)
! 1089: {
! 1090: while (node != NULL) {
! 1091: xmlCtxtDumpNode(ctxt, node);
! 1092: node = node->next;
! 1093: }
! 1094: }
! 1095:
! 1096: static void
! 1097: xmlCtxtDumpDocHead(xmlDebugCtxtPtr ctxt, xmlDocPtr doc)
! 1098: {
! 1099: if (doc == NULL) {
! 1100: if (!ctxt->check)
! 1101: fprintf(ctxt->output, "DOCUMENT == NULL !\n");
! 1102: return;
! 1103: }
! 1104: ctxt->node = (xmlNodePtr) doc;
! 1105:
! 1106: switch (doc->type) {
! 1107: case XML_ELEMENT_NODE:
! 1108: xmlDebugErr(ctxt, XML_CHECK_FOUND_ELEMENT,
! 1109: "Misplaced ELEMENT node\n");
! 1110: break;
! 1111: case XML_ATTRIBUTE_NODE:
! 1112: xmlDebugErr(ctxt, XML_CHECK_FOUND_ATTRIBUTE,
! 1113: "Misplaced ATTRIBUTE node\n");
! 1114: break;
! 1115: case XML_TEXT_NODE:
! 1116: xmlDebugErr(ctxt, XML_CHECK_FOUND_TEXT,
! 1117: "Misplaced TEXT node\n");
! 1118: break;
! 1119: case XML_CDATA_SECTION_NODE:
! 1120: xmlDebugErr(ctxt, XML_CHECK_FOUND_CDATA,
! 1121: "Misplaced CDATA node\n");
! 1122: break;
! 1123: case XML_ENTITY_REF_NODE:
! 1124: xmlDebugErr(ctxt, XML_CHECK_FOUND_ENTITYREF,
! 1125: "Misplaced ENTITYREF node\n");
! 1126: break;
! 1127: case XML_ENTITY_NODE:
! 1128: xmlDebugErr(ctxt, XML_CHECK_FOUND_ENTITY,
! 1129: "Misplaced ENTITY node\n");
! 1130: break;
! 1131: case XML_PI_NODE:
! 1132: xmlDebugErr(ctxt, XML_CHECK_FOUND_PI,
! 1133: "Misplaced PI node\n");
! 1134: break;
! 1135: case XML_COMMENT_NODE:
! 1136: xmlDebugErr(ctxt, XML_CHECK_FOUND_COMMENT,
! 1137: "Misplaced COMMENT node\n");
! 1138: break;
! 1139: case XML_DOCUMENT_NODE:
! 1140: if (!ctxt->check)
! 1141: fprintf(ctxt->output, "DOCUMENT\n");
! 1142: break;
! 1143: case XML_HTML_DOCUMENT_NODE:
! 1144: if (!ctxt->check)
! 1145: fprintf(ctxt->output, "HTML DOCUMENT\n");
! 1146: break;
! 1147: case XML_DOCUMENT_TYPE_NODE:
! 1148: xmlDebugErr(ctxt, XML_CHECK_FOUND_DOCTYPE,
! 1149: "Misplaced DOCTYPE node\n");
! 1150: break;
! 1151: case XML_DOCUMENT_FRAG_NODE:
! 1152: xmlDebugErr(ctxt, XML_CHECK_FOUND_FRAGMENT,
! 1153: "Misplaced FRAGMENT node\n");
! 1154: break;
! 1155: case XML_NOTATION_NODE:
! 1156: xmlDebugErr(ctxt, XML_CHECK_FOUND_NOTATION,
! 1157: "Misplaced NOTATION node\n");
! 1158: break;
! 1159: default:
! 1160: xmlDebugErr2(ctxt, XML_CHECK_UNKNOWN_NODE,
! 1161: "Unknown node type %d\n", doc->type);
! 1162: }
! 1163: }
! 1164:
! 1165: /**
! 1166: * xmlCtxtDumpDocumentHead:
! 1167: * @output: the FILE * for the output
! 1168: * @doc: the document
! 1169: *
! 1170: * Dumps debug information cncerning the document, not recursive
! 1171: */
! 1172: static void
! 1173: xmlCtxtDumpDocumentHead(xmlDebugCtxtPtr ctxt, xmlDocPtr doc)
! 1174: {
! 1175: if (doc == NULL) return;
! 1176: xmlCtxtDumpDocHead(ctxt, doc);
! 1177: if (!ctxt->check) {
! 1178: if (doc->name != NULL) {
! 1179: fprintf(ctxt->output, "name=");
! 1180: xmlCtxtDumpString(ctxt, BAD_CAST doc->name);
! 1181: fprintf(ctxt->output, "\n");
! 1182: }
! 1183: if (doc->version != NULL) {
! 1184: fprintf(ctxt->output, "version=");
! 1185: xmlCtxtDumpString(ctxt, doc->version);
! 1186: fprintf(ctxt->output, "\n");
! 1187: }
! 1188: if (doc->encoding != NULL) {
! 1189: fprintf(ctxt->output, "encoding=");
! 1190: xmlCtxtDumpString(ctxt, doc->encoding);
! 1191: fprintf(ctxt->output, "\n");
! 1192: }
! 1193: if (doc->URL != NULL) {
! 1194: fprintf(ctxt->output, "URL=");
! 1195: xmlCtxtDumpString(ctxt, doc->URL);
! 1196: fprintf(ctxt->output, "\n");
! 1197: }
! 1198: if (doc->standalone)
! 1199: fprintf(ctxt->output, "standalone=true\n");
! 1200: }
! 1201: if (doc->oldNs != NULL)
! 1202: xmlCtxtDumpNamespaceList(ctxt, doc->oldNs);
! 1203: }
! 1204:
! 1205: /**
! 1206: * xmlCtxtDumpDocument:
! 1207: * @output: the FILE * for the output
! 1208: * @doc: the document
! 1209: *
! 1210: * Dumps debug information for the document, it's recursive
! 1211: */
! 1212: static void
! 1213: xmlCtxtDumpDocument(xmlDebugCtxtPtr ctxt, xmlDocPtr doc)
! 1214: {
! 1215: if (doc == NULL) {
! 1216: if (!ctxt->check)
! 1217: fprintf(ctxt->output, "DOCUMENT == NULL !\n");
! 1218: return;
! 1219: }
! 1220: xmlCtxtDumpDocumentHead(ctxt, doc);
! 1221: if (((doc->type == XML_DOCUMENT_NODE) ||
! 1222: (doc->type == XML_HTML_DOCUMENT_NODE))
! 1223: && (doc->children != NULL)) {
! 1224: ctxt->depth++;
! 1225: xmlCtxtDumpNodeList(ctxt, doc->children);
! 1226: ctxt->depth--;
! 1227: }
! 1228: }
! 1229:
! 1230: static void
! 1231: xmlCtxtDumpEntityCallback(xmlEntityPtr cur, xmlDebugCtxtPtr ctxt)
! 1232: {
! 1233: if (cur == NULL) {
! 1234: if (!ctxt->check)
! 1235: fprintf(ctxt->output, "Entity is NULL");
! 1236: return;
! 1237: }
! 1238: if (!ctxt->check) {
! 1239: fprintf(ctxt->output, "%s : ", (char *) cur->name);
! 1240: switch (cur->etype) {
! 1241: case XML_INTERNAL_GENERAL_ENTITY:
! 1242: fprintf(ctxt->output, "INTERNAL GENERAL, ");
! 1243: break;
! 1244: case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
! 1245: fprintf(ctxt->output, "EXTERNAL PARSED, ");
! 1246: break;
! 1247: case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
! 1248: fprintf(ctxt->output, "EXTERNAL UNPARSED, ");
! 1249: break;
! 1250: case XML_INTERNAL_PARAMETER_ENTITY:
! 1251: fprintf(ctxt->output, "INTERNAL PARAMETER, ");
! 1252: break;
! 1253: case XML_EXTERNAL_PARAMETER_ENTITY:
! 1254: fprintf(ctxt->output, "EXTERNAL PARAMETER, ");
! 1255: break;
! 1256: default:
! 1257: xmlDebugErr2(ctxt, XML_CHECK_ENTITY_TYPE,
! 1258: "Unknown entity type %d\n", cur->etype);
! 1259: }
! 1260: if (cur->ExternalID != NULL)
! 1261: fprintf(ctxt->output, "ID \"%s\"", (char *) cur->ExternalID);
! 1262: if (cur->SystemID != NULL)
! 1263: fprintf(ctxt->output, "SYSTEM \"%s\"", (char *) cur->SystemID);
! 1264: if (cur->orig != NULL)
! 1265: fprintf(ctxt->output, "\n orig \"%s\"", (char *) cur->orig);
! 1266: if ((cur->type != XML_ELEMENT_NODE) && (cur->content != NULL))
! 1267: fprintf(ctxt->output, "\n content \"%s\"",
! 1268: (char *) cur->content);
! 1269: fprintf(ctxt->output, "\n");
! 1270: }
! 1271: }
! 1272:
! 1273: /**
! 1274: * xmlCtxtDumpEntities:
! 1275: * @output: the FILE * for the output
! 1276: * @doc: the document
! 1277: *
! 1278: * Dumps debug information for all the entities in use by the document
! 1279: */
! 1280: static void
! 1281: xmlCtxtDumpEntities(xmlDebugCtxtPtr ctxt, xmlDocPtr doc)
! 1282: {
! 1283: if (doc == NULL) return;
! 1284: xmlCtxtDumpDocHead(ctxt, doc);
! 1285: if ((doc->intSubset != NULL) && (doc->intSubset->entities != NULL)) {
! 1286: xmlEntitiesTablePtr table = (xmlEntitiesTablePtr)
! 1287: doc->intSubset->entities;
! 1288:
! 1289: if (!ctxt->check)
! 1290: fprintf(ctxt->output, "Entities in internal subset\n");
! 1291: xmlHashScan(table, (xmlHashScanner) xmlCtxtDumpEntityCallback,
! 1292: ctxt);
! 1293: } else
! 1294: fprintf(ctxt->output, "No entities in internal subset\n");
! 1295: if ((doc->extSubset != NULL) && (doc->extSubset->entities != NULL)) {
! 1296: xmlEntitiesTablePtr table = (xmlEntitiesTablePtr)
! 1297: doc->extSubset->entities;
! 1298:
! 1299: if (!ctxt->check)
! 1300: fprintf(ctxt->output, "Entities in external subset\n");
! 1301: xmlHashScan(table, (xmlHashScanner) xmlCtxtDumpEntityCallback,
! 1302: ctxt);
! 1303: } else if (!ctxt->check)
! 1304: fprintf(ctxt->output, "No entities in external subset\n");
! 1305: }
! 1306:
! 1307: /**
! 1308: * xmlCtxtDumpDTD:
! 1309: * @output: the FILE * for the output
! 1310: * @dtd: the DTD
! 1311: *
! 1312: * Dumps debug information for the DTD
! 1313: */
! 1314: static void
! 1315: xmlCtxtDumpDTD(xmlDebugCtxtPtr ctxt, xmlDtdPtr dtd)
! 1316: {
! 1317: if (dtd == NULL) {
! 1318: if (!ctxt->check)
! 1319: fprintf(ctxt->output, "DTD is NULL\n");
! 1320: return;
! 1321: }
! 1322: xmlCtxtDumpDtdNode(ctxt, dtd);
! 1323: if (dtd->children == NULL)
! 1324: fprintf(ctxt->output, " DTD is empty\n");
! 1325: else {
! 1326: ctxt->depth++;
! 1327: xmlCtxtDumpNodeList(ctxt, dtd->children);
! 1328: ctxt->depth--;
! 1329: }
! 1330: }
! 1331:
! 1332: /************************************************************************
! 1333: * *
! 1334: * Public entry points for dump *
! 1335: * *
! 1336: ************************************************************************/
! 1337:
! 1338: /**
! 1339: * xmlDebugDumpString:
! 1340: * @output: the FILE * for the output
! 1341: * @str: the string
! 1342: *
! 1343: * Dumps informations about the string, shorten it if necessary
! 1344: */
! 1345: void
! 1346: xmlDebugDumpString(FILE * output, const xmlChar * str)
! 1347: {
! 1348: int i;
! 1349:
! 1350: if (output == NULL)
! 1351: output = stdout;
! 1352: if (str == NULL) {
! 1353: fprintf(output, "(NULL)");
! 1354: return;
! 1355: }
! 1356: for (i = 0; i < 40; i++)
! 1357: if (str[i] == 0)
! 1358: return;
! 1359: else if (IS_BLANK_CH(str[i]))
! 1360: fputc(' ', output);
! 1361: else if (str[i] >= 0x80)
! 1362: fprintf(output, "#%X", str[i]);
! 1363: else
! 1364: fputc(str[i], output);
! 1365: fprintf(output, "...");
! 1366: }
! 1367:
! 1368: /**
! 1369: * xmlDebugDumpAttr:
! 1370: * @output: the FILE * for the output
! 1371: * @attr: the attribute
! 1372: * @depth: the indentation level.
! 1373: *
! 1374: * Dumps debug information for the attribute
! 1375: */
! 1376: void
! 1377: xmlDebugDumpAttr(FILE *output, xmlAttrPtr attr, int depth) {
! 1378: xmlDebugCtxt ctxt;
! 1379:
! 1380: if (output == NULL) return;
! 1381: xmlCtxtDumpInitCtxt(&ctxt);
! 1382: ctxt.output = output;
! 1383: ctxt.depth = depth;
! 1384: xmlCtxtDumpAttr(&ctxt, attr);
! 1385: xmlCtxtDumpCleanCtxt(&ctxt);
! 1386: }
! 1387:
! 1388:
! 1389: /**
! 1390: * xmlDebugDumpEntities:
! 1391: * @output: the FILE * for the output
! 1392: * @doc: the document
! 1393: *
! 1394: * Dumps debug information for all the entities in use by the document
! 1395: */
! 1396: void
! 1397: xmlDebugDumpEntities(FILE * output, xmlDocPtr doc)
! 1398: {
! 1399: xmlDebugCtxt ctxt;
! 1400:
! 1401: if (output == NULL) return;
! 1402: xmlCtxtDumpInitCtxt(&ctxt);
! 1403: ctxt.output = output;
! 1404: xmlCtxtDumpEntities(&ctxt, doc);
! 1405: xmlCtxtDumpCleanCtxt(&ctxt);
! 1406: }
! 1407:
! 1408: /**
! 1409: * xmlDebugDumpAttrList:
! 1410: * @output: the FILE * for the output
! 1411: * @attr: the attribute list
! 1412: * @depth: the indentation level.
! 1413: *
! 1414: * Dumps debug information for the attribute list
! 1415: */
! 1416: void
! 1417: xmlDebugDumpAttrList(FILE * output, xmlAttrPtr attr, int depth)
! 1418: {
! 1419: xmlDebugCtxt ctxt;
! 1420:
! 1421: if (output == NULL) return;
! 1422: xmlCtxtDumpInitCtxt(&ctxt);
! 1423: ctxt.output = output;
! 1424: ctxt.depth = depth;
! 1425: xmlCtxtDumpAttrList(&ctxt, attr);
! 1426: xmlCtxtDumpCleanCtxt(&ctxt);
! 1427: }
! 1428:
! 1429: /**
! 1430: * xmlDebugDumpOneNode:
! 1431: * @output: the FILE * for the output
! 1432: * @node: the node
! 1433: * @depth: the indentation level.
! 1434: *
! 1435: * Dumps debug information for the element node, it is not recursive
! 1436: */
! 1437: void
! 1438: xmlDebugDumpOneNode(FILE * output, xmlNodePtr node, int depth)
! 1439: {
! 1440: xmlDebugCtxt ctxt;
! 1441:
! 1442: if (output == NULL) return;
! 1443: xmlCtxtDumpInitCtxt(&ctxt);
! 1444: ctxt.output = output;
! 1445: ctxt.depth = depth;
! 1446: xmlCtxtDumpOneNode(&ctxt, node);
! 1447: xmlCtxtDumpCleanCtxt(&ctxt);
! 1448: }
! 1449:
! 1450: /**
! 1451: * xmlDebugDumpNode:
! 1452: * @output: the FILE * for the output
! 1453: * @node: the node
! 1454: * @depth: the indentation level.
! 1455: *
! 1456: * Dumps debug information for the element node, it is recursive
! 1457: */
! 1458: void
! 1459: xmlDebugDumpNode(FILE * output, xmlNodePtr node, int depth)
! 1460: {
! 1461: xmlDebugCtxt ctxt;
! 1462:
! 1463: if (output == NULL)
! 1464: output = stdout;
! 1465: xmlCtxtDumpInitCtxt(&ctxt);
! 1466: ctxt.output = output;
! 1467: ctxt.depth = depth;
! 1468: xmlCtxtDumpNode(&ctxt, node);
! 1469: xmlCtxtDumpCleanCtxt(&ctxt);
! 1470: }
! 1471:
! 1472: /**
! 1473: * xmlDebugDumpNodeList:
! 1474: * @output: the FILE * for the output
! 1475: * @node: the node list
! 1476: * @depth: the indentation level.
! 1477: *
! 1478: * Dumps debug information for the list of element node, it is recursive
! 1479: */
! 1480: void
! 1481: xmlDebugDumpNodeList(FILE * output, xmlNodePtr node, int depth)
! 1482: {
! 1483: xmlDebugCtxt ctxt;
! 1484:
! 1485: if (output == NULL)
! 1486: output = stdout;
! 1487: xmlCtxtDumpInitCtxt(&ctxt);
! 1488: ctxt.output = output;
! 1489: ctxt.depth = depth;
! 1490: xmlCtxtDumpNodeList(&ctxt, node);
! 1491: xmlCtxtDumpCleanCtxt(&ctxt);
! 1492: }
! 1493:
! 1494: /**
! 1495: * xmlDebugDumpDocumentHead:
! 1496: * @output: the FILE * for the output
! 1497: * @doc: the document
! 1498: *
! 1499: * Dumps debug information cncerning the document, not recursive
! 1500: */
! 1501: void
! 1502: xmlDebugDumpDocumentHead(FILE * output, xmlDocPtr doc)
! 1503: {
! 1504: xmlDebugCtxt ctxt;
! 1505:
! 1506: if (output == NULL)
! 1507: output = stdout;
! 1508: xmlCtxtDumpInitCtxt(&ctxt);
! 1509: ctxt.options |= DUMP_TEXT_TYPE;
! 1510: ctxt.output = output;
! 1511: xmlCtxtDumpDocumentHead(&ctxt, doc);
! 1512: xmlCtxtDumpCleanCtxt(&ctxt);
! 1513: }
! 1514:
! 1515: /**
! 1516: * xmlDebugDumpDocument:
! 1517: * @output: the FILE * for the output
! 1518: * @doc: the document
! 1519: *
! 1520: * Dumps debug information for the document, it's recursive
! 1521: */
! 1522: void
! 1523: xmlDebugDumpDocument(FILE * output, xmlDocPtr doc)
! 1524: {
! 1525: xmlDebugCtxt ctxt;
! 1526:
! 1527: if (output == NULL)
! 1528: output = stdout;
! 1529: xmlCtxtDumpInitCtxt(&ctxt);
! 1530: ctxt.options |= DUMP_TEXT_TYPE;
! 1531: ctxt.output = output;
! 1532: xmlCtxtDumpDocument(&ctxt, doc);
! 1533: xmlCtxtDumpCleanCtxt(&ctxt);
! 1534: }
! 1535:
! 1536: /**
! 1537: * xmlDebugDumpDTD:
! 1538: * @output: the FILE * for the output
! 1539: * @dtd: the DTD
! 1540: *
! 1541: * Dumps debug information for the DTD
! 1542: */
! 1543: void
! 1544: xmlDebugDumpDTD(FILE * output, xmlDtdPtr dtd)
! 1545: {
! 1546: xmlDebugCtxt ctxt;
! 1547:
! 1548: if (output == NULL)
! 1549: output = stdout;
! 1550: xmlCtxtDumpInitCtxt(&ctxt);
! 1551: ctxt.options |= DUMP_TEXT_TYPE;
! 1552: ctxt.output = output;
! 1553: xmlCtxtDumpDTD(&ctxt, dtd);
! 1554: xmlCtxtDumpCleanCtxt(&ctxt);
! 1555: }
! 1556:
! 1557: /************************************************************************
! 1558: * *
! 1559: * Public entry points for checkings *
! 1560: * *
! 1561: ************************************************************************/
! 1562:
! 1563: /**
! 1564: * xmlDebugCheckDocument:
! 1565: * @output: the FILE * for the output
! 1566: * @doc: the document
! 1567: *
! 1568: * Check the document for potential content problems, and output
! 1569: * the errors to @output
! 1570: *
! 1571: * Returns the number of errors found
! 1572: */
! 1573: int
! 1574: xmlDebugCheckDocument(FILE * output, xmlDocPtr doc)
! 1575: {
! 1576: xmlDebugCtxt ctxt;
! 1577:
! 1578: if (output == NULL)
! 1579: output = stdout;
! 1580: xmlCtxtDumpInitCtxt(&ctxt);
! 1581: ctxt.output = output;
! 1582: ctxt.check = 1;
! 1583: xmlCtxtDumpDocument(&ctxt, doc);
! 1584: xmlCtxtDumpCleanCtxt(&ctxt);
! 1585: return(ctxt.errors);
! 1586: }
! 1587:
! 1588: /************************************************************************
! 1589: * *
! 1590: * Helpers for Shell *
! 1591: * *
! 1592: ************************************************************************/
! 1593:
! 1594: /**
! 1595: * xmlLsCountNode:
! 1596: * @node: the node to count
! 1597: *
! 1598: * Count the children of @node.
! 1599: *
! 1600: * Returns the number of children of @node.
! 1601: */
! 1602: int
! 1603: xmlLsCountNode(xmlNodePtr node) {
! 1604: int ret = 0;
! 1605: xmlNodePtr list = NULL;
! 1606:
! 1607: if (node == NULL)
! 1608: return(0);
! 1609:
! 1610: switch (node->type) {
! 1611: case XML_ELEMENT_NODE:
! 1612: list = node->children;
! 1613: break;
! 1614: case XML_DOCUMENT_NODE:
! 1615: case XML_HTML_DOCUMENT_NODE:
! 1616: #ifdef LIBXML_DOCB_ENABLED
! 1617: case XML_DOCB_DOCUMENT_NODE:
! 1618: #endif
! 1619: list = ((xmlDocPtr) node)->children;
! 1620: break;
! 1621: case XML_ATTRIBUTE_NODE:
! 1622: list = ((xmlAttrPtr) node)->children;
! 1623: break;
! 1624: case XML_TEXT_NODE:
! 1625: case XML_CDATA_SECTION_NODE:
! 1626: case XML_PI_NODE:
! 1627: case XML_COMMENT_NODE:
! 1628: if (node->content != NULL) {
! 1629: ret = xmlStrlen(node->content);
! 1630: }
! 1631: break;
! 1632: case XML_ENTITY_REF_NODE:
! 1633: case XML_DOCUMENT_TYPE_NODE:
! 1634: case XML_ENTITY_NODE:
! 1635: case XML_DOCUMENT_FRAG_NODE:
! 1636: case XML_NOTATION_NODE:
! 1637: case XML_DTD_NODE:
! 1638: case XML_ELEMENT_DECL:
! 1639: case XML_ATTRIBUTE_DECL:
! 1640: case XML_ENTITY_DECL:
! 1641: case XML_NAMESPACE_DECL:
! 1642: case XML_XINCLUDE_START:
! 1643: case XML_XINCLUDE_END:
! 1644: ret = 1;
! 1645: break;
! 1646: }
! 1647: for (;list != NULL;ret++)
! 1648: list = list->next;
! 1649: return(ret);
! 1650: }
! 1651:
! 1652: /**
! 1653: * xmlLsOneNode:
! 1654: * @output: the FILE * for the output
! 1655: * @node: the node to dump
! 1656: *
! 1657: * Dump to @output the type and name of @node.
! 1658: */
! 1659: void
! 1660: xmlLsOneNode(FILE *output, xmlNodePtr node) {
! 1661: if (output == NULL) return;
! 1662: if (node == NULL) {
! 1663: fprintf(output, "NULL\n");
! 1664: return;
! 1665: }
! 1666: switch (node->type) {
! 1667: case XML_ELEMENT_NODE:
! 1668: fprintf(output, "-");
! 1669: break;
! 1670: case XML_ATTRIBUTE_NODE:
! 1671: fprintf(output, "a");
! 1672: break;
! 1673: case XML_TEXT_NODE:
! 1674: fprintf(output, "t");
! 1675: break;
! 1676: case XML_CDATA_SECTION_NODE:
! 1677: fprintf(output, "C");
! 1678: break;
! 1679: case XML_ENTITY_REF_NODE:
! 1680: fprintf(output, "e");
! 1681: break;
! 1682: case XML_ENTITY_NODE:
! 1683: fprintf(output, "E");
! 1684: break;
! 1685: case XML_PI_NODE:
! 1686: fprintf(output, "p");
! 1687: break;
! 1688: case XML_COMMENT_NODE:
! 1689: fprintf(output, "c");
! 1690: break;
! 1691: case XML_DOCUMENT_NODE:
! 1692: fprintf(output, "d");
! 1693: break;
! 1694: case XML_HTML_DOCUMENT_NODE:
! 1695: fprintf(output, "h");
! 1696: break;
! 1697: case XML_DOCUMENT_TYPE_NODE:
! 1698: fprintf(output, "T");
! 1699: break;
! 1700: case XML_DOCUMENT_FRAG_NODE:
! 1701: fprintf(output, "F");
! 1702: break;
! 1703: case XML_NOTATION_NODE:
! 1704: fprintf(output, "N");
! 1705: break;
! 1706: case XML_NAMESPACE_DECL:
! 1707: fprintf(output, "n");
! 1708: break;
! 1709: default:
! 1710: fprintf(output, "?");
! 1711: }
! 1712: if (node->type != XML_NAMESPACE_DECL) {
! 1713: if (node->properties != NULL)
! 1714: fprintf(output, "a");
! 1715: else
! 1716: fprintf(output, "-");
! 1717: if (node->nsDef != NULL)
! 1718: fprintf(output, "n");
! 1719: else
! 1720: fprintf(output, "-");
! 1721: }
! 1722:
! 1723: fprintf(output, " %8d ", xmlLsCountNode(node));
! 1724:
! 1725: switch (node->type) {
! 1726: case XML_ELEMENT_NODE:
! 1727: if (node->name != NULL)
! 1728: fprintf(output, "%s", (const char *) node->name);
! 1729: break;
! 1730: case XML_ATTRIBUTE_NODE:
! 1731: if (node->name != NULL)
! 1732: fprintf(output, "%s", (const char *) node->name);
! 1733: break;
! 1734: case XML_TEXT_NODE:
! 1735: if (node->content != NULL) {
! 1736: xmlDebugDumpString(output, node->content);
! 1737: }
! 1738: break;
! 1739: case XML_CDATA_SECTION_NODE:
! 1740: break;
! 1741: case XML_ENTITY_REF_NODE:
! 1742: if (node->name != NULL)
! 1743: fprintf(output, "%s", (const char *) node->name);
! 1744: break;
! 1745: case XML_ENTITY_NODE:
! 1746: if (node->name != NULL)
! 1747: fprintf(output, "%s", (const char *) node->name);
! 1748: break;
! 1749: case XML_PI_NODE:
! 1750: if (node->name != NULL)
! 1751: fprintf(output, "%s", (const char *) node->name);
! 1752: break;
! 1753: case XML_COMMENT_NODE:
! 1754: break;
! 1755: case XML_DOCUMENT_NODE:
! 1756: break;
! 1757: case XML_HTML_DOCUMENT_NODE:
! 1758: break;
! 1759: case XML_DOCUMENT_TYPE_NODE:
! 1760: break;
! 1761: case XML_DOCUMENT_FRAG_NODE:
! 1762: break;
! 1763: case XML_NOTATION_NODE:
! 1764: break;
! 1765: case XML_NAMESPACE_DECL: {
! 1766: xmlNsPtr ns = (xmlNsPtr) node;
! 1767:
! 1768: if (ns->prefix == NULL)
! 1769: fprintf(output, "default -> %s", (char *)ns->href);
! 1770: else
! 1771: fprintf(output, "%s -> %s", (char *)ns->prefix,
! 1772: (char *)ns->href);
! 1773: break;
! 1774: }
! 1775: default:
! 1776: if (node->name != NULL)
! 1777: fprintf(output, "%s", (const char *) node->name);
! 1778: }
! 1779: fprintf(output, "\n");
! 1780: }
! 1781:
! 1782: /**
! 1783: * xmlBoolToText:
! 1784: * @boolval: a bool to turn into text
! 1785: *
! 1786: * Convenient way to turn bool into text
! 1787: *
! 1788: * Returns a pointer to either "True" or "False"
! 1789: */
! 1790: const char *
! 1791: xmlBoolToText(int boolval)
! 1792: {
! 1793: if (boolval)
! 1794: return("True");
! 1795: else
! 1796: return("False");
! 1797: }
! 1798:
! 1799: #ifdef LIBXML_XPATH_ENABLED
! 1800: /****************************************************************
! 1801: * *
! 1802: * The XML shell related functions *
! 1803: * *
! 1804: ****************************************************************/
! 1805:
! 1806:
! 1807:
! 1808: /*
! 1809: * TODO: Improvement/cleanups for the XML shell
! 1810: * - allow to shell out an editor on a subpart
! 1811: * - cleanup function registrations (with help) and calling
! 1812: * - provide registration routines
! 1813: */
! 1814:
! 1815: /**
! 1816: * xmlShellPrintXPathError:
! 1817: * @errorType: valid xpath error id
! 1818: * @arg: the argument that cause xpath to fail
! 1819: *
! 1820: * Print the xpath error to libxml default error channel
! 1821: */
! 1822: void
! 1823: xmlShellPrintXPathError(int errorType, const char *arg)
! 1824: {
! 1825: const char *default_arg = "Result";
! 1826:
! 1827: if (!arg)
! 1828: arg = default_arg;
! 1829:
! 1830: switch (errorType) {
! 1831: case XPATH_UNDEFINED:
! 1832: xmlGenericError(xmlGenericErrorContext,
! 1833: "%s: no such node\n", arg);
! 1834: break;
! 1835:
! 1836: case XPATH_BOOLEAN:
! 1837: xmlGenericError(xmlGenericErrorContext,
! 1838: "%s is a Boolean\n", arg);
! 1839: break;
! 1840: case XPATH_NUMBER:
! 1841: xmlGenericError(xmlGenericErrorContext,
! 1842: "%s is a number\n", arg);
! 1843: break;
! 1844: case XPATH_STRING:
! 1845: xmlGenericError(xmlGenericErrorContext,
! 1846: "%s is a string\n", arg);
! 1847: break;
! 1848: case XPATH_POINT:
! 1849: xmlGenericError(xmlGenericErrorContext,
! 1850: "%s is a point\n", arg);
! 1851: break;
! 1852: case XPATH_RANGE:
! 1853: xmlGenericError(xmlGenericErrorContext,
! 1854: "%s is a range\n", arg);
! 1855: break;
! 1856: case XPATH_LOCATIONSET:
! 1857: xmlGenericError(xmlGenericErrorContext,
! 1858: "%s is a range\n", arg);
! 1859: break;
! 1860: case XPATH_USERS:
! 1861: xmlGenericError(xmlGenericErrorContext,
! 1862: "%s is user-defined\n", arg);
! 1863: break;
! 1864: case XPATH_XSLT_TREE:
! 1865: xmlGenericError(xmlGenericErrorContext,
! 1866: "%s is an XSLT value tree\n", arg);
! 1867: break;
! 1868: }
! 1869: #if 0
! 1870: xmlGenericError(xmlGenericErrorContext,
! 1871: "Try casting the result string function (xpath builtin)\n",
! 1872: arg);
! 1873: #endif
! 1874: }
! 1875:
! 1876:
! 1877: #ifdef LIBXML_OUTPUT_ENABLED
! 1878: /**
! 1879: * xmlShellPrintNodeCtxt:
! 1880: * @ctxt : a non-null shell context
! 1881: * @node : a non-null node to print to the output FILE
! 1882: *
! 1883: * Print node to the output FILE
! 1884: */
! 1885: static void
! 1886: xmlShellPrintNodeCtxt(xmlShellCtxtPtr ctxt,xmlNodePtr node)
! 1887: {
! 1888: FILE *fp;
! 1889:
! 1890: if (!node)
! 1891: return;
! 1892: if (ctxt == NULL)
! 1893: fp = stdout;
! 1894: else
! 1895: fp = ctxt->output;
! 1896:
! 1897: if (node->type == XML_DOCUMENT_NODE)
! 1898: xmlDocDump(fp, (xmlDocPtr) node);
! 1899: else if (node->type == XML_ATTRIBUTE_NODE)
! 1900: xmlDebugDumpAttrList(fp, (xmlAttrPtr) node, 0);
! 1901: else
! 1902: xmlElemDump(fp, node->doc, node);
! 1903:
! 1904: fprintf(fp, "\n");
! 1905: }
! 1906:
! 1907: /**
! 1908: * xmlShellPrintNode:
! 1909: * @node : a non-null node to print to the output FILE
! 1910: *
! 1911: * Print node to the output FILE
! 1912: */
! 1913: void
! 1914: xmlShellPrintNode(xmlNodePtr node)
! 1915: {
! 1916: xmlShellPrintNodeCtxt(NULL, node);
! 1917: }
! 1918: #endif /* LIBXML_OUTPUT_ENABLED */
! 1919:
! 1920: /**
! 1921: * xmlShellPrintXPathResultCtxt:
! 1922: * @ctxt: a valid shell context
! 1923: * @list: a valid result generated by an xpath evaluation
! 1924: *
! 1925: * Prints result to the output FILE
! 1926: */
! 1927: static void
! 1928: xmlShellPrintXPathResultCtxt(xmlShellCtxtPtr ctxt,xmlXPathObjectPtr list)
! 1929: {
! 1930: if (!ctxt)
! 1931: return;
! 1932:
! 1933: if (list != NULL) {
! 1934: switch (list->type) {
! 1935: case XPATH_NODESET:{
! 1936: #ifdef LIBXML_OUTPUT_ENABLED
! 1937: int indx;
! 1938:
! 1939: if (list->nodesetval) {
! 1940: for (indx = 0; indx < list->nodesetval->nodeNr;
! 1941: indx++) {
! 1942: xmlShellPrintNodeCtxt(ctxt,
! 1943: list->nodesetval->nodeTab[indx]);
! 1944: }
! 1945: } else {
! 1946: xmlGenericError(xmlGenericErrorContext,
! 1947: "Empty node set\n");
! 1948: }
! 1949: break;
! 1950: #else
! 1951: xmlGenericError(xmlGenericErrorContext,
! 1952: "Node set\n");
! 1953: #endif /* LIBXML_OUTPUT_ENABLED */
! 1954: }
! 1955: case XPATH_BOOLEAN:
! 1956: xmlGenericError(xmlGenericErrorContext,
! 1957: "Is a Boolean:%s\n",
! 1958: xmlBoolToText(list->boolval));
! 1959: break;
! 1960: case XPATH_NUMBER:
! 1961: xmlGenericError(xmlGenericErrorContext,
! 1962: "Is a number:%0g\n", list->floatval);
! 1963: break;
! 1964: case XPATH_STRING:
! 1965: xmlGenericError(xmlGenericErrorContext,
! 1966: "Is a string:%s\n", list->stringval);
! 1967: break;
! 1968:
! 1969: default:
! 1970: xmlShellPrintXPathError(list->type, NULL);
! 1971: }
! 1972: }
! 1973: }
! 1974:
! 1975: /**
! 1976: * xmlShellPrintXPathResult:
! 1977: * @list: a valid result generated by an xpath evaluation
! 1978: *
! 1979: * Prints result to the output FILE
! 1980: */
! 1981: void
! 1982: xmlShellPrintXPathResult(xmlXPathObjectPtr list)
! 1983: {
! 1984: xmlShellPrintXPathResultCtxt(NULL, list);
! 1985: }
! 1986:
! 1987: /**
! 1988: * xmlShellList:
! 1989: * @ctxt: the shell context
! 1990: * @arg: unused
! 1991: * @node: a node
! 1992: * @node2: unused
! 1993: *
! 1994: * Implements the XML shell function "ls"
! 1995: * Does an Unix like listing of the given node (like a directory)
! 1996: *
! 1997: * Returns 0
! 1998: */
! 1999: int
! 2000: xmlShellList(xmlShellCtxtPtr ctxt,
! 2001: char *arg ATTRIBUTE_UNUSED, xmlNodePtr node,
! 2002: xmlNodePtr node2 ATTRIBUTE_UNUSED)
! 2003: {
! 2004: xmlNodePtr cur;
! 2005: if (!ctxt)
! 2006: return (0);
! 2007: if (node == NULL) {
! 2008: fprintf(ctxt->output, "NULL\n");
! 2009: return (0);
! 2010: }
! 2011: if ((node->type == XML_DOCUMENT_NODE) ||
! 2012: (node->type == XML_HTML_DOCUMENT_NODE)) {
! 2013: cur = ((xmlDocPtr) node)->children;
! 2014: } else if (node->type == XML_NAMESPACE_DECL) {
! 2015: xmlLsOneNode(ctxt->output, node);
! 2016: return (0);
! 2017: } else if (node->children != NULL) {
! 2018: cur = node->children;
! 2019: } else {
! 2020: xmlLsOneNode(ctxt->output, node);
! 2021: return (0);
! 2022: }
! 2023: while (cur != NULL) {
! 2024: xmlLsOneNode(ctxt->output, cur);
! 2025: cur = cur->next;
! 2026: }
! 2027: return (0);
! 2028: }
! 2029:
! 2030: /**
! 2031: * xmlShellBase:
! 2032: * @ctxt: the shell context
! 2033: * @arg: unused
! 2034: * @node: a node
! 2035: * @node2: unused
! 2036: *
! 2037: * Implements the XML shell function "base"
! 2038: * dumps the current XML base of the node
! 2039: *
! 2040: * Returns 0
! 2041: */
! 2042: int
! 2043: xmlShellBase(xmlShellCtxtPtr ctxt,
! 2044: char *arg ATTRIBUTE_UNUSED, xmlNodePtr node,
! 2045: xmlNodePtr node2 ATTRIBUTE_UNUSED)
! 2046: {
! 2047: xmlChar *base;
! 2048: if (!ctxt)
! 2049: return 0;
! 2050: if (node == NULL) {
! 2051: fprintf(ctxt->output, "NULL\n");
! 2052: return (0);
! 2053: }
! 2054:
! 2055: base = xmlNodeGetBase(node->doc, node);
! 2056:
! 2057: if (base == NULL) {
! 2058: fprintf(ctxt->output, " No base found !!!\n");
! 2059: } else {
! 2060: fprintf(ctxt->output, "%s\n", base);
! 2061: xmlFree(base);
! 2062: }
! 2063: return (0);
! 2064: }
! 2065:
! 2066: #ifdef LIBXML_TREE_ENABLED
! 2067: /**
! 2068: * xmlShellSetBase:
! 2069: * @ctxt: the shell context
! 2070: * @arg: the new base
! 2071: * @node: a node
! 2072: * @node2: unused
! 2073: *
! 2074: * Implements the XML shell function "setbase"
! 2075: * change the current XML base of the node
! 2076: *
! 2077: * Returns 0
! 2078: */
! 2079: static int
! 2080: xmlShellSetBase(xmlShellCtxtPtr ctxt ATTRIBUTE_UNUSED,
! 2081: char *arg ATTRIBUTE_UNUSED, xmlNodePtr node,
! 2082: xmlNodePtr node2 ATTRIBUTE_UNUSED)
! 2083: {
! 2084: xmlNodeSetBase(node, (xmlChar*) arg);
! 2085: return (0);
! 2086: }
! 2087: #endif
! 2088:
! 2089: #ifdef LIBXML_XPATH_ENABLED
! 2090: /**
! 2091: * xmlShellRegisterNamespace:
! 2092: * @ctxt: the shell context
! 2093: * @arg: a string in prefix=nsuri format
! 2094: * @node: unused
! 2095: * @node2: unused
! 2096: *
! 2097: * Implements the XML shell function "setns"
! 2098: * register/unregister a prefix=namespace pair
! 2099: * on the XPath context
! 2100: *
! 2101: * Returns 0 on success and a negative value otherwise.
! 2102: */
! 2103: static int
! 2104: xmlShellRegisterNamespace(xmlShellCtxtPtr ctxt, char *arg,
! 2105: xmlNodePtr node ATTRIBUTE_UNUSED, xmlNodePtr node2 ATTRIBUTE_UNUSED)
! 2106: {
! 2107: xmlChar* nsListDup;
! 2108: xmlChar* prefix;
! 2109: xmlChar* href;
! 2110: xmlChar* next;
! 2111:
! 2112: nsListDup = xmlStrdup((xmlChar *) arg);
! 2113: next = nsListDup;
! 2114: while(next != NULL) {
! 2115: /* skip spaces */
! 2116: /*while((*next) == ' ') next++;*/
! 2117: if((*next) == '\0') break;
! 2118:
! 2119: /* find prefix */
! 2120: prefix = next;
! 2121: next = (xmlChar*)xmlStrchr(next, '=');
! 2122: if(next == NULL) {
! 2123: fprintf(ctxt->output, "setns: prefix=[nsuri] required\n");
! 2124: xmlFree(nsListDup);
! 2125: return(-1);
! 2126: }
! 2127: *(next++) = '\0';
! 2128:
! 2129: /* find href */
! 2130: href = next;
! 2131: next = (xmlChar*)xmlStrchr(next, ' ');
! 2132: if(next != NULL) {
! 2133: *(next++) = '\0';
! 2134: }
! 2135:
! 2136: /* do register namespace */
! 2137: if(xmlXPathRegisterNs(ctxt->pctxt, prefix, href) != 0) {
! 2138: fprintf(ctxt->output,"Error: unable to register NS with prefix=\"%s\" and href=\"%s\"\n", prefix, href);
! 2139: xmlFree(nsListDup);
! 2140: return(-1);
! 2141: }
! 2142: }
! 2143:
! 2144: xmlFree(nsListDup);
! 2145: return(0);
! 2146: }
! 2147: /**
! 2148: * xmlShellRegisterRootNamespaces:
! 2149: * @ctxt: the shell context
! 2150: * @arg: unused
! 2151: * @node: the root element
! 2152: * @node2: unused
! 2153: *
! 2154: * Implements the XML shell function "setrootns"
! 2155: * which registers all namespaces declarations found on the root element.
! 2156: *
! 2157: * Returns 0 on success and a negative value otherwise.
! 2158: */
! 2159: static int
! 2160: xmlShellRegisterRootNamespaces(xmlShellCtxtPtr ctxt, char *arg ATTRIBUTE_UNUSED,
! 2161: xmlNodePtr root, xmlNodePtr node2 ATTRIBUTE_UNUSED)
! 2162: {
! 2163: xmlNsPtr ns;
! 2164:
! 2165: if ((root == NULL) || (root->type != XML_ELEMENT_NODE) ||
! 2166: (root->nsDef == NULL) || (ctxt == NULL) || (ctxt->pctxt == NULL))
! 2167: return(-1);
! 2168: ns = root->nsDef;
! 2169: while (ns != NULL) {
! 2170: if (ns->prefix == NULL)
! 2171: xmlXPathRegisterNs(ctxt->pctxt, BAD_CAST "defaultns", ns->href);
! 2172: else
! 2173: xmlXPathRegisterNs(ctxt->pctxt, ns->prefix, ns->href);
! 2174: ns = ns->next;
! 2175: }
! 2176: return(0);
! 2177: }
! 2178: #endif
! 2179:
! 2180: /**
! 2181: * xmlShellGrep:
! 2182: * @ctxt: the shell context
! 2183: * @arg: the string or regular expression to find
! 2184: * @node: a node
! 2185: * @node2: unused
! 2186: *
! 2187: * Implements the XML shell function "grep"
! 2188: * dumps informations about the node (namespace, attributes, content).
! 2189: *
! 2190: * Returns 0
! 2191: */
! 2192: static int
! 2193: xmlShellGrep(xmlShellCtxtPtr ctxt ATTRIBUTE_UNUSED,
! 2194: char *arg, xmlNodePtr node, xmlNodePtr node2 ATTRIBUTE_UNUSED)
! 2195: {
! 2196: if (!ctxt)
! 2197: return (0);
! 2198: if (node == NULL)
! 2199: return (0);
! 2200: if (arg == NULL)
! 2201: return (0);
! 2202: #ifdef LIBXML_REGEXP_ENABLED
! 2203: if ((xmlStrchr((xmlChar *) arg, '?')) ||
! 2204: (xmlStrchr((xmlChar *) arg, '*')) ||
! 2205: (xmlStrchr((xmlChar *) arg, '.')) ||
! 2206: (xmlStrchr((xmlChar *) arg, '['))) {
! 2207: }
! 2208: #endif
! 2209: while (node != NULL) {
! 2210: if (node->type == XML_COMMENT_NODE) {
! 2211: if (xmlStrstr(node->content, (xmlChar *) arg)) {
! 2212:
! 2213: fprintf(ctxt->output, "%s : ", xmlGetNodePath(node));
! 2214: xmlShellList(ctxt, NULL, node, NULL);
! 2215: }
! 2216: } else if (node->type == XML_TEXT_NODE) {
! 2217: if (xmlStrstr(node->content, (xmlChar *) arg)) {
! 2218:
! 2219: fprintf(ctxt->output, "%s : ", xmlGetNodePath(node->parent));
! 2220: xmlShellList(ctxt, NULL, node->parent, NULL);
! 2221: }
! 2222: }
! 2223:
! 2224: /*
! 2225: * Browse the full subtree, deep first
! 2226: */
! 2227:
! 2228: if ((node->type == XML_DOCUMENT_NODE) ||
! 2229: (node->type == XML_HTML_DOCUMENT_NODE)) {
! 2230: node = ((xmlDocPtr) node)->children;
! 2231: } else if ((node->children != NULL)
! 2232: && (node->type != XML_ENTITY_REF_NODE)) {
! 2233: /* deep first */
! 2234: node = node->children;
! 2235: } else if (node->next != NULL) {
! 2236: /* then siblings */
! 2237: node = node->next;
! 2238: } else {
! 2239: /* go up to parents->next if needed */
! 2240: while (node != NULL) {
! 2241: if (node->parent != NULL) {
! 2242: node = node->parent;
! 2243: }
! 2244: if (node->next != NULL) {
! 2245: node = node->next;
! 2246: break;
! 2247: }
! 2248: if (node->parent == NULL) {
! 2249: node = NULL;
! 2250: break;
! 2251: }
! 2252: }
! 2253: }
! 2254: }
! 2255: return (0);
! 2256: }
! 2257:
! 2258: /**
! 2259: * xmlShellDir:
! 2260: * @ctxt: the shell context
! 2261: * @arg: unused
! 2262: * @node: a node
! 2263: * @node2: unused
! 2264: *
! 2265: * Implements the XML shell function "dir"
! 2266: * dumps informations about the node (namespace, attributes, content).
! 2267: *
! 2268: * Returns 0
! 2269: */
! 2270: int
! 2271: xmlShellDir(xmlShellCtxtPtr ctxt ATTRIBUTE_UNUSED,
! 2272: char *arg ATTRIBUTE_UNUSED, xmlNodePtr node,
! 2273: xmlNodePtr node2 ATTRIBUTE_UNUSED)
! 2274: {
! 2275: if (!ctxt)
! 2276: return (0);
! 2277: if (node == NULL) {
! 2278: fprintf(ctxt->output, "NULL\n");
! 2279: return (0);
! 2280: }
! 2281: if ((node->type == XML_DOCUMENT_NODE) ||
! 2282: (node->type == XML_HTML_DOCUMENT_NODE)) {
! 2283: xmlDebugDumpDocumentHead(ctxt->output, (xmlDocPtr) node);
! 2284: } else if (node->type == XML_ATTRIBUTE_NODE) {
! 2285: xmlDebugDumpAttr(ctxt->output, (xmlAttrPtr) node, 0);
! 2286: } else {
! 2287: xmlDebugDumpOneNode(ctxt->output, node, 0);
! 2288: }
! 2289: return (0);
! 2290: }
! 2291:
! 2292: /**
! 2293: * xmlShellSetContent:
! 2294: * @ctxt: the shell context
! 2295: * @value: the content as a string
! 2296: * @node: a node
! 2297: * @node2: unused
! 2298: *
! 2299: * Implements the XML shell function "dir"
! 2300: * dumps informations about the node (namespace, attributes, content).
! 2301: *
! 2302: * Returns 0
! 2303: */
! 2304: static int
! 2305: xmlShellSetContent(xmlShellCtxtPtr ctxt ATTRIBUTE_UNUSED,
! 2306: char *value, xmlNodePtr node,
! 2307: xmlNodePtr node2 ATTRIBUTE_UNUSED)
! 2308: {
! 2309: xmlNodePtr results;
! 2310: xmlParserErrors ret;
! 2311:
! 2312: if (!ctxt)
! 2313: return (0);
! 2314: if (node == NULL) {
! 2315: fprintf(ctxt->output, "NULL\n");
! 2316: return (0);
! 2317: }
! 2318: if (value == NULL) {
! 2319: fprintf(ctxt->output, "NULL\n");
! 2320: return (0);
! 2321: }
! 2322:
! 2323: ret = xmlParseInNodeContext(node, value, strlen(value), 0, &results);
! 2324: if (ret == XML_ERR_OK) {
! 2325: if (node->children != NULL) {
! 2326: xmlFreeNodeList(node->children);
! 2327: node->children = NULL;
! 2328: node->last = NULL;
! 2329: }
! 2330: xmlAddChildList(node, results);
! 2331: } else {
! 2332: fprintf(ctxt->output, "failed to parse content\n");
! 2333: }
! 2334: return (0);
! 2335: }
! 2336:
! 2337: #ifdef LIBXML_SCHEMAS_ENABLED
! 2338: /**
! 2339: * xmlShellRNGValidate:
! 2340: * @ctxt: the shell context
! 2341: * @schemas: the path to the Relax-NG schemas
! 2342: * @node: a node
! 2343: * @node2: unused
! 2344: *
! 2345: * Implements the XML shell function "relaxng"
! 2346: * validating the instance against a Relax-NG schemas
! 2347: *
! 2348: * Returns 0
! 2349: */
! 2350: static int
! 2351: xmlShellRNGValidate(xmlShellCtxtPtr sctxt, char *schemas,
! 2352: xmlNodePtr node ATTRIBUTE_UNUSED,
! 2353: xmlNodePtr node2 ATTRIBUTE_UNUSED)
! 2354: {
! 2355: xmlRelaxNGPtr relaxngschemas;
! 2356: xmlRelaxNGParserCtxtPtr ctxt;
! 2357: xmlRelaxNGValidCtxtPtr vctxt;
! 2358: int ret;
! 2359:
! 2360: ctxt = xmlRelaxNGNewParserCtxt(schemas);
! 2361: xmlRelaxNGSetParserErrors(ctxt,
! 2362: (xmlRelaxNGValidityErrorFunc) fprintf,
! 2363: (xmlRelaxNGValidityWarningFunc) fprintf,
! 2364: stderr);
! 2365: relaxngschemas = xmlRelaxNGParse(ctxt);
! 2366: xmlRelaxNGFreeParserCtxt(ctxt);
! 2367: if (relaxngschemas == NULL) {
! 2368: xmlGenericError(xmlGenericErrorContext,
! 2369: "Relax-NG schema %s failed to compile\n", schemas);
! 2370: return(-1);
! 2371: }
! 2372: vctxt = xmlRelaxNGNewValidCtxt(relaxngschemas);
! 2373: xmlRelaxNGSetValidErrors(vctxt,
! 2374: (xmlRelaxNGValidityErrorFunc) fprintf,
! 2375: (xmlRelaxNGValidityWarningFunc) fprintf,
! 2376: stderr);
! 2377: ret = xmlRelaxNGValidateDoc(vctxt, sctxt->doc);
! 2378: if (ret == 0) {
! 2379: fprintf(stderr, "%s validates\n", sctxt->filename);
! 2380: } else if (ret > 0) {
! 2381: fprintf(stderr, "%s fails to validate\n", sctxt->filename);
! 2382: } else {
! 2383: fprintf(stderr, "%s validation generated an internal error\n",
! 2384: sctxt->filename);
! 2385: }
! 2386: xmlRelaxNGFreeValidCtxt(vctxt);
! 2387: if (relaxngschemas != NULL)
! 2388: xmlRelaxNGFree(relaxngschemas);
! 2389: return(0);
! 2390: }
! 2391: #endif
! 2392:
! 2393: #ifdef LIBXML_OUTPUT_ENABLED
! 2394: /**
! 2395: * xmlShellCat:
! 2396: * @ctxt: the shell context
! 2397: * @arg: unused
! 2398: * @node: a node
! 2399: * @node2: unused
! 2400: *
! 2401: * Implements the XML shell function "cat"
! 2402: * dumps the serialization node content (XML or HTML).
! 2403: *
! 2404: * Returns 0
! 2405: */
! 2406: int
! 2407: xmlShellCat(xmlShellCtxtPtr ctxt, char *arg ATTRIBUTE_UNUSED,
! 2408: xmlNodePtr node, xmlNodePtr node2 ATTRIBUTE_UNUSED)
! 2409: {
! 2410: if (!ctxt)
! 2411: return (0);
! 2412: if (node == NULL) {
! 2413: fprintf(ctxt->output, "NULL\n");
! 2414: return (0);
! 2415: }
! 2416: if (ctxt->doc->type == XML_HTML_DOCUMENT_NODE) {
! 2417: #ifdef LIBXML_HTML_ENABLED
! 2418: if (node->type == XML_HTML_DOCUMENT_NODE)
! 2419: htmlDocDump(ctxt->output, (htmlDocPtr) node);
! 2420: else
! 2421: htmlNodeDumpFile(ctxt->output, ctxt->doc, node);
! 2422: #else
! 2423: if (node->type == XML_DOCUMENT_NODE)
! 2424: xmlDocDump(ctxt->output, (xmlDocPtr) node);
! 2425: else
! 2426: xmlElemDump(ctxt->output, ctxt->doc, node);
! 2427: #endif /* LIBXML_HTML_ENABLED */
! 2428: } else {
! 2429: if (node->type == XML_DOCUMENT_NODE)
! 2430: xmlDocDump(ctxt->output, (xmlDocPtr) node);
! 2431: else
! 2432: xmlElemDump(ctxt->output, ctxt->doc, node);
! 2433: }
! 2434: fprintf(ctxt->output, "\n");
! 2435: return (0);
! 2436: }
! 2437: #endif /* LIBXML_OUTPUT_ENABLED */
! 2438:
! 2439: /**
! 2440: * xmlShellLoad:
! 2441: * @ctxt: the shell context
! 2442: * @filename: the file name
! 2443: * @node: unused
! 2444: * @node2: unused
! 2445: *
! 2446: * Implements the XML shell function "load"
! 2447: * loads a new document specified by the filename
! 2448: *
! 2449: * Returns 0 or -1 if loading failed
! 2450: */
! 2451: int
! 2452: xmlShellLoad(xmlShellCtxtPtr ctxt, char *filename,
! 2453: xmlNodePtr node ATTRIBUTE_UNUSED,
! 2454: xmlNodePtr node2 ATTRIBUTE_UNUSED)
! 2455: {
! 2456: xmlDocPtr doc;
! 2457: int html = 0;
! 2458:
! 2459: if ((ctxt == NULL) || (filename == NULL)) return(-1);
! 2460: if (ctxt->doc != NULL)
! 2461: html = (ctxt->doc->type == XML_HTML_DOCUMENT_NODE);
! 2462:
! 2463: if (html) {
! 2464: #ifdef LIBXML_HTML_ENABLED
! 2465: doc = htmlParseFile(filename, NULL);
! 2466: #else
! 2467: fprintf(ctxt->output, "HTML support not compiled in\n");
! 2468: doc = NULL;
! 2469: #endif /* LIBXML_HTML_ENABLED */
! 2470: } else {
! 2471: doc = xmlReadFile(filename,NULL,0);
! 2472: }
! 2473: if (doc != NULL) {
! 2474: if (ctxt->loaded == 1) {
! 2475: xmlFreeDoc(ctxt->doc);
! 2476: }
! 2477: ctxt->loaded = 1;
! 2478: #ifdef LIBXML_XPATH_ENABLED
! 2479: xmlXPathFreeContext(ctxt->pctxt);
! 2480: #endif /* LIBXML_XPATH_ENABLED */
! 2481: xmlFree(ctxt->filename);
! 2482: ctxt->doc = doc;
! 2483: ctxt->node = (xmlNodePtr) doc;
! 2484: #ifdef LIBXML_XPATH_ENABLED
! 2485: ctxt->pctxt = xmlXPathNewContext(doc);
! 2486: #endif /* LIBXML_XPATH_ENABLED */
! 2487: ctxt->filename = (char *) xmlCanonicPath((xmlChar *) filename);
! 2488: } else
! 2489: return (-1);
! 2490: return (0);
! 2491: }
! 2492:
! 2493: #ifdef LIBXML_OUTPUT_ENABLED
! 2494: /**
! 2495: * xmlShellWrite:
! 2496: * @ctxt: the shell context
! 2497: * @filename: the file name
! 2498: * @node: a node in the tree
! 2499: * @node2: unused
! 2500: *
! 2501: * Implements the XML shell function "write"
! 2502: * Write the current node to the filename, it saves the serialization
! 2503: * of the subtree under the @node specified
! 2504: *
! 2505: * Returns 0 or -1 in case of error
! 2506: */
! 2507: int
! 2508: xmlShellWrite(xmlShellCtxtPtr ctxt, char *filename, xmlNodePtr node,
! 2509: xmlNodePtr node2 ATTRIBUTE_UNUSED)
! 2510: {
! 2511: if (node == NULL)
! 2512: return (-1);
! 2513: if ((filename == NULL) || (filename[0] == 0)) {
! 2514: return (-1);
! 2515: }
! 2516: #ifdef W_OK
! 2517: if (access((char *) filename, W_OK)) {
! 2518: xmlGenericError(xmlGenericErrorContext,
! 2519: "Cannot write to %s\n", filename);
! 2520: return (-1);
! 2521: }
! 2522: #endif
! 2523: switch (node->type) {
! 2524: case XML_DOCUMENT_NODE:
! 2525: if (xmlSaveFile((char *) filename, ctxt->doc) < -1) {
! 2526: xmlGenericError(xmlGenericErrorContext,
! 2527: "Failed to write to %s\n", filename);
! 2528: return (-1);
! 2529: }
! 2530: break;
! 2531: case XML_HTML_DOCUMENT_NODE:
! 2532: #ifdef LIBXML_HTML_ENABLED
! 2533: if (htmlSaveFile((char *) filename, ctxt->doc) < 0) {
! 2534: xmlGenericError(xmlGenericErrorContext,
! 2535: "Failed to write to %s\n", filename);
! 2536: return (-1);
! 2537: }
! 2538: #else
! 2539: if (xmlSaveFile((char *) filename, ctxt->doc) < -1) {
! 2540: xmlGenericError(xmlGenericErrorContext,
! 2541: "Failed to write to %s\n", filename);
! 2542: return (-1);
! 2543: }
! 2544: #endif /* LIBXML_HTML_ENABLED */
! 2545: break;
! 2546: default:{
! 2547: FILE *f;
! 2548:
! 2549: f = fopen((char *) filename, "w");
! 2550: if (f == NULL) {
! 2551: xmlGenericError(xmlGenericErrorContext,
! 2552: "Failed to write to %s\n", filename);
! 2553: return (-1);
! 2554: }
! 2555: xmlElemDump(f, ctxt->doc, node);
! 2556: fclose(f);
! 2557: }
! 2558: }
! 2559: return (0);
! 2560: }
! 2561:
! 2562: /**
! 2563: * xmlShellSave:
! 2564: * @ctxt: the shell context
! 2565: * @filename: the file name (optional)
! 2566: * @node: unused
! 2567: * @node2: unused
! 2568: *
! 2569: * Implements the XML shell function "save"
! 2570: * Write the current document to the filename, or it's original name
! 2571: *
! 2572: * Returns 0 or -1 in case of error
! 2573: */
! 2574: int
! 2575: xmlShellSave(xmlShellCtxtPtr ctxt, char *filename,
! 2576: xmlNodePtr node ATTRIBUTE_UNUSED,
! 2577: xmlNodePtr node2 ATTRIBUTE_UNUSED)
! 2578: {
! 2579: if ((ctxt == NULL) || (ctxt->doc == NULL))
! 2580: return (-1);
! 2581: if ((filename == NULL) || (filename[0] == 0))
! 2582: filename = ctxt->filename;
! 2583: if (filename == NULL)
! 2584: return (-1);
! 2585: #ifdef W_OK
! 2586: if (access((char *) filename, W_OK)) {
! 2587: xmlGenericError(xmlGenericErrorContext,
! 2588: "Cannot save to %s\n", filename);
! 2589: return (-1);
! 2590: }
! 2591: #endif
! 2592: switch (ctxt->doc->type) {
! 2593: case XML_DOCUMENT_NODE:
! 2594: if (xmlSaveFile((char *) filename, ctxt->doc) < 0) {
! 2595: xmlGenericError(xmlGenericErrorContext,
! 2596: "Failed to save to %s\n", filename);
! 2597: }
! 2598: break;
! 2599: case XML_HTML_DOCUMENT_NODE:
! 2600: #ifdef LIBXML_HTML_ENABLED
! 2601: if (htmlSaveFile((char *) filename, ctxt->doc) < 0) {
! 2602: xmlGenericError(xmlGenericErrorContext,
! 2603: "Failed to save to %s\n", filename);
! 2604: }
! 2605: #else
! 2606: if (xmlSaveFile((char *) filename, ctxt->doc) < 0) {
! 2607: xmlGenericError(xmlGenericErrorContext,
! 2608: "Failed to save to %s\n", filename);
! 2609: }
! 2610: #endif /* LIBXML_HTML_ENABLED */
! 2611: break;
! 2612: default:
! 2613: xmlGenericError(xmlGenericErrorContext,
! 2614: "To save to subparts of a document use the 'write' command\n");
! 2615: return (-1);
! 2616:
! 2617: }
! 2618: return (0);
! 2619: }
! 2620: #endif /* LIBXML_OUTPUT_ENABLED */
! 2621:
! 2622: #ifdef LIBXML_VALID_ENABLED
! 2623: /**
! 2624: * xmlShellValidate:
! 2625: * @ctxt: the shell context
! 2626: * @dtd: the DTD URI (optional)
! 2627: * @node: unused
! 2628: * @node2: unused
! 2629: *
! 2630: * Implements the XML shell function "validate"
! 2631: * Validate the document, if a DTD path is provided, then the validation
! 2632: * is done against the given DTD.
! 2633: *
! 2634: * Returns 0 or -1 in case of error
! 2635: */
! 2636: int
! 2637: xmlShellValidate(xmlShellCtxtPtr ctxt, char *dtd,
! 2638: xmlNodePtr node ATTRIBUTE_UNUSED,
! 2639: xmlNodePtr node2 ATTRIBUTE_UNUSED)
! 2640: {
! 2641: xmlValidCtxt vctxt;
! 2642: int res = -1;
! 2643:
! 2644: if ((ctxt == NULL) || (ctxt->doc == NULL)) return(-1);
! 2645: vctxt.userData = stderr;
! 2646: vctxt.error = (xmlValidityErrorFunc) fprintf;
! 2647: vctxt.warning = (xmlValidityWarningFunc) fprintf;
! 2648:
! 2649: if ((dtd == NULL) || (dtd[0] == 0)) {
! 2650: res = xmlValidateDocument(&vctxt, ctxt->doc);
! 2651: } else {
! 2652: xmlDtdPtr subset;
! 2653:
! 2654: subset = xmlParseDTD(NULL, (xmlChar *) dtd);
! 2655: if (subset != NULL) {
! 2656: res = xmlValidateDtd(&vctxt, ctxt->doc, subset);
! 2657:
! 2658: xmlFreeDtd(subset);
! 2659: }
! 2660: }
! 2661: return (res);
! 2662: }
! 2663: #endif /* LIBXML_VALID_ENABLED */
! 2664:
! 2665: /**
! 2666: * xmlShellDu:
! 2667: * @ctxt: the shell context
! 2668: * @arg: unused
! 2669: * @tree: a node defining a subtree
! 2670: * @node2: unused
! 2671: *
! 2672: * Implements the XML shell function "du"
! 2673: * show the structure of the subtree under node @tree
! 2674: * If @tree is null, the command works on the current node.
! 2675: *
! 2676: * Returns 0 or -1 in case of error
! 2677: */
! 2678: int
! 2679: xmlShellDu(xmlShellCtxtPtr ctxt,
! 2680: char *arg ATTRIBUTE_UNUSED, xmlNodePtr tree,
! 2681: xmlNodePtr node2 ATTRIBUTE_UNUSED)
! 2682: {
! 2683: xmlNodePtr node;
! 2684: int indent = 0, i;
! 2685:
! 2686: if (!ctxt)
! 2687: return (-1);
! 2688:
! 2689: if (tree == NULL)
! 2690: return (-1);
! 2691: node = tree;
! 2692: while (node != NULL) {
! 2693: if ((node->type == XML_DOCUMENT_NODE) ||
! 2694: (node->type == XML_HTML_DOCUMENT_NODE)) {
! 2695: fprintf(ctxt->output, "/\n");
! 2696: } else if (node->type == XML_ELEMENT_NODE) {
! 2697: for (i = 0; i < indent; i++)
! 2698: fprintf(ctxt->output, " ");
! 2699: fprintf(ctxt->output, "%s\n", node->name);
! 2700: } else {
! 2701: }
! 2702:
! 2703: /*
! 2704: * Browse the full subtree, deep first
! 2705: */
! 2706:
! 2707: if ((node->type == XML_DOCUMENT_NODE) ||
! 2708: (node->type == XML_HTML_DOCUMENT_NODE)) {
! 2709: node = ((xmlDocPtr) node)->children;
! 2710: } else if ((node->children != NULL)
! 2711: && (node->type != XML_ENTITY_REF_NODE)) {
! 2712: /* deep first */
! 2713: node = node->children;
! 2714: indent++;
! 2715: } else if ((node != tree) && (node->next != NULL)) {
! 2716: /* then siblings */
! 2717: node = node->next;
! 2718: } else if (node != tree) {
! 2719: /* go up to parents->next if needed */
! 2720: while (node != tree) {
! 2721: if (node->parent != NULL) {
! 2722: node = node->parent;
! 2723: indent--;
! 2724: }
! 2725: if ((node != tree) && (node->next != NULL)) {
! 2726: node = node->next;
! 2727: break;
! 2728: }
! 2729: if (node->parent == NULL) {
! 2730: node = NULL;
! 2731: break;
! 2732: }
! 2733: if (node == tree) {
! 2734: node = NULL;
! 2735: break;
! 2736: }
! 2737: }
! 2738: /* exit condition */
! 2739: if (node == tree)
! 2740: node = NULL;
! 2741: } else
! 2742: node = NULL;
! 2743: }
! 2744: return (0);
! 2745: }
! 2746:
! 2747: /**
! 2748: * xmlShellPwd:
! 2749: * @ctxt: the shell context
! 2750: * @buffer: the output buffer
! 2751: * @node: a node
! 2752: * @node2: unused
! 2753: *
! 2754: * Implements the XML shell function "pwd"
! 2755: * Show the full path from the root to the node, if needed building
! 2756: * thumblers when similar elements exists at a given ancestor level.
! 2757: * The output is compatible with XPath commands.
! 2758: *
! 2759: * Returns 0 or -1 in case of error
! 2760: */
! 2761: int
! 2762: xmlShellPwd(xmlShellCtxtPtr ctxt ATTRIBUTE_UNUSED, char *buffer,
! 2763: xmlNodePtr node, xmlNodePtr node2 ATTRIBUTE_UNUSED)
! 2764: {
! 2765: xmlChar *path;
! 2766:
! 2767: if ((node == NULL) || (buffer == NULL))
! 2768: return (-1);
! 2769:
! 2770: path = xmlGetNodePath(node);
! 2771: if (path == NULL)
! 2772: return (-1);
! 2773:
! 2774: /*
! 2775: * This test prevents buffer overflow, because this routine
! 2776: * is only called by xmlShell, in which the second argument is
! 2777: * 500 chars long.
! 2778: * It is a dirty hack before a cleaner solution is found.
! 2779: * Documentation should mention that the second argument must
! 2780: * be at least 500 chars long, and could be stripped if too long.
! 2781: */
! 2782: snprintf(buffer, 499, "%s", path);
! 2783: buffer[499] = '0';
! 2784: xmlFree(path);
! 2785:
! 2786: return (0);
! 2787: }
! 2788:
! 2789: /**
! 2790: * xmlShell:
! 2791: * @doc: the initial document
! 2792: * @filename: the output buffer
! 2793: * @input: the line reading function
! 2794: * @output: the output FILE*, defaults to stdout if NULL
! 2795: *
! 2796: * Implements the XML shell
! 2797: * This allow to load, validate, view, modify and save a document
! 2798: * using a environment similar to a UNIX commandline.
! 2799: */
! 2800: void
! 2801: xmlShell(xmlDocPtr doc, char *filename, xmlShellReadlineFunc input,
! 2802: FILE * output)
! 2803: {
! 2804: char prompt[500] = "/ > ";
! 2805: char *cmdline = NULL, *cur;
! 2806: char command[100];
! 2807: char arg[400];
! 2808: int i;
! 2809: xmlShellCtxtPtr ctxt;
! 2810: xmlXPathObjectPtr list;
! 2811:
! 2812: if (doc == NULL)
! 2813: return;
! 2814: if (filename == NULL)
! 2815: return;
! 2816: if (input == NULL)
! 2817: return;
! 2818: if (output == NULL)
! 2819: output = stdout;
! 2820: ctxt = (xmlShellCtxtPtr) xmlMalloc(sizeof(xmlShellCtxt));
! 2821: if (ctxt == NULL)
! 2822: return;
! 2823: ctxt->loaded = 0;
! 2824: ctxt->doc = doc;
! 2825: ctxt->input = input;
! 2826: ctxt->output = output;
! 2827: ctxt->filename = (char *) xmlStrdup((xmlChar *) filename);
! 2828: ctxt->node = (xmlNodePtr) ctxt->doc;
! 2829:
! 2830: #ifdef LIBXML_XPATH_ENABLED
! 2831: ctxt->pctxt = xmlXPathNewContext(ctxt->doc);
! 2832: if (ctxt->pctxt == NULL) {
! 2833: xmlFree(ctxt);
! 2834: return;
! 2835: }
! 2836: #endif /* LIBXML_XPATH_ENABLED */
! 2837: while (1) {
! 2838: if (ctxt->node == (xmlNodePtr) ctxt->doc)
! 2839: snprintf(prompt, sizeof(prompt), "%s > ", "/");
! 2840: else if ((ctxt->node != NULL) && (ctxt->node->name))
! 2841: snprintf(prompt, sizeof(prompt), "%s > ", ctxt->node->name);
! 2842: else
! 2843: snprintf(prompt, sizeof(prompt), "? > ");
! 2844: prompt[sizeof(prompt) - 1] = 0;
! 2845:
! 2846: /*
! 2847: * Get a new command line
! 2848: */
! 2849: cmdline = ctxt->input(prompt);
! 2850: if (cmdline == NULL)
! 2851: break;
! 2852:
! 2853: /*
! 2854: * Parse the command itself
! 2855: */
! 2856: cur = cmdline;
! 2857: while ((*cur == ' ') || (*cur == '\t'))
! 2858: cur++;
! 2859: i = 0;
! 2860: while ((*cur != ' ') && (*cur != '\t') &&
! 2861: (*cur != '\n') && (*cur != '\r')) {
! 2862: if (*cur == 0)
! 2863: break;
! 2864: command[i++] = *cur++;
! 2865: }
! 2866: command[i] = 0;
! 2867: if (i == 0)
! 2868: continue;
! 2869:
! 2870: /*
! 2871: * Parse the argument
! 2872: */
! 2873: while ((*cur == ' ') || (*cur == '\t'))
! 2874: cur++;
! 2875: i = 0;
! 2876: while ((*cur != '\n') && (*cur != '\r') && (*cur != 0)) {
! 2877: if (*cur == 0)
! 2878: break;
! 2879: arg[i++] = *cur++;
! 2880: }
! 2881: arg[i] = 0;
! 2882:
! 2883: /*
! 2884: * start interpreting the command
! 2885: */
! 2886: if (!strcmp(command, "exit"))
! 2887: break;
! 2888: if (!strcmp(command, "quit"))
! 2889: break;
! 2890: if (!strcmp(command, "bye"))
! 2891: break;
! 2892: if (!strcmp(command, "help")) {
! 2893: fprintf(ctxt->output, "\tbase display XML base of the node\n");
! 2894: fprintf(ctxt->output, "\tsetbase URI change the XML base of the node\n");
! 2895: fprintf(ctxt->output, "\tbye leave shell\n");
! 2896: fprintf(ctxt->output, "\tcat [node] display node or current node\n");
! 2897: fprintf(ctxt->output, "\tcd [path] change directory to path or to root\n");
! 2898: fprintf(ctxt->output, "\tdir [path] dumps informations about the node (namespace, attributes, content)\n");
! 2899: fprintf(ctxt->output, "\tdu [path] show the structure of the subtree under path or the current node\n");
! 2900: fprintf(ctxt->output, "\texit leave shell\n");
! 2901: fprintf(ctxt->output, "\thelp display this help\n");
! 2902: fprintf(ctxt->output, "\tfree display memory usage\n");
! 2903: fprintf(ctxt->output, "\tload [name] load a new document with name\n");
! 2904: fprintf(ctxt->output, "\tls [path] list contents of path or the current directory\n");
! 2905: fprintf(ctxt->output, "\tset xml_fragment replace the current node content with the fragment parsed in context\n");
! 2906: #ifdef LIBXML_XPATH_ENABLED
! 2907: fprintf(ctxt->output, "\txpath expr evaluate the XPath expression in that context and print the result\n");
! 2908: fprintf(ctxt->output, "\tsetns nsreg register a namespace to a prefix in the XPath evaluation context\n");
! 2909: fprintf(ctxt->output, "\t format for nsreg is: prefix=[nsuri] (i.e. prefix= unsets a prefix)\n");
! 2910: fprintf(ctxt->output, "\tsetrootns register all namespace found on the root element\n");
! 2911: fprintf(ctxt->output, "\t the default namespace if any uses 'defaultns' prefix\n");
! 2912: #endif /* LIBXML_XPATH_ENABLED */
! 2913: fprintf(ctxt->output, "\tpwd display current working directory\n");
! 2914: fprintf(ctxt->output, "\tquit leave shell\n");
! 2915: #ifdef LIBXML_OUTPUT_ENABLED
! 2916: fprintf(ctxt->output, "\tsave [name] save this document to name or the original name\n");
! 2917: fprintf(ctxt->output, "\twrite [name] write the current node to the filename\n");
! 2918: #endif /* LIBXML_OUTPUT_ENABLED */
! 2919: #ifdef LIBXML_VALID_ENABLED
! 2920: fprintf(ctxt->output, "\tvalidate check the document for errors\n");
! 2921: #endif /* LIBXML_VALID_ENABLED */
! 2922: #ifdef LIBXML_SCHEMAS_ENABLED
! 2923: fprintf(ctxt->output, "\trelaxng rng validate the document agaisnt the Relax-NG schemas\n");
! 2924: #endif
! 2925: fprintf(ctxt->output, "\tgrep string search for a string in the subtree\n");
! 2926: #ifdef LIBXML_VALID_ENABLED
! 2927: } else if (!strcmp(command, "validate")) {
! 2928: xmlShellValidate(ctxt, arg, NULL, NULL);
! 2929: #endif /* LIBXML_VALID_ENABLED */
! 2930: } else if (!strcmp(command, "load")) {
! 2931: xmlShellLoad(ctxt, arg, NULL, NULL);
! 2932: #ifdef LIBXML_SCHEMAS_ENABLED
! 2933: } else if (!strcmp(command, "relaxng")) {
! 2934: xmlShellRNGValidate(ctxt, arg, NULL, NULL);
! 2935: #endif
! 2936: #ifdef LIBXML_OUTPUT_ENABLED
! 2937: } else if (!strcmp(command, "save")) {
! 2938: xmlShellSave(ctxt, arg, NULL, NULL);
! 2939: } else if (!strcmp(command, "write")) {
! 2940: if ((arg == NULL) || (arg[0] == 0))
! 2941: xmlGenericError(xmlGenericErrorContext,
! 2942: "Write command requires a filename argument\n");
! 2943: else
! 2944: xmlShellWrite(ctxt, arg, ctxt->node, NULL);
! 2945: #endif /* LIBXML_OUTPUT_ENABLED */
! 2946: } else if (!strcmp(command, "grep")) {
! 2947: xmlShellGrep(ctxt, arg, ctxt->node, NULL);
! 2948: } else if (!strcmp(command, "free")) {
! 2949: if (arg[0] == 0) {
! 2950: xmlMemShow(ctxt->output, 0);
! 2951: } else {
! 2952: int len = 0;
! 2953:
! 2954: sscanf(arg, "%d", &len);
! 2955: xmlMemShow(ctxt->output, len);
! 2956: }
! 2957: } else if (!strcmp(command, "pwd")) {
! 2958: char dir[500];
! 2959:
! 2960: if (!xmlShellPwd(ctxt, dir, ctxt->node, NULL))
! 2961: fprintf(ctxt->output, "%s\n", dir);
! 2962: } else if (!strcmp(command, "du")) {
! 2963: xmlShellDu(ctxt, NULL, ctxt->node, NULL);
! 2964: } else if (!strcmp(command, "base")) {
! 2965: xmlShellBase(ctxt, NULL, ctxt->node, NULL);
! 2966: } else if (!strcmp(command, "set")) {
! 2967: xmlShellSetContent(ctxt, arg, ctxt->node, NULL);
! 2968: #ifdef LIBXML_XPATH_ENABLED
! 2969: } else if (!strcmp(command, "setns")) {
! 2970: if (arg[0] == 0) {
! 2971: xmlGenericError(xmlGenericErrorContext,
! 2972: "setns: prefix=[nsuri] required\n");
! 2973: } else {
! 2974: xmlShellRegisterNamespace(ctxt, arg, NULL, NULL);
! 2975: }
! 2976: } else if (!strcmp(command, "setrootns")) {
! 2977: xmlNodePtr root;
! 2978:
! 2979: root = xmlDocGetRootElement(ctxt->doc);
! 2980: xmlShellRegisterRootNamespaces(ctxt, NULL, root, NULL);
! 2981: } else if (!strcmp(command, "xpath")) {
! 2982: if (arg[0] == 0) {
! 2983: xmlGenericError(xmlGenericErrorContext,
! 2984: "xpath: expression required\n");
! 2985: } else {
! 2986: ctxt->pctxt->node = ctxt->node;
! 2987: list = xmlXPathEval((xmlChar *) arg, ctxt->pctxt);
! 2988: xmlXPathDebugDumpObject(ctxt->output, list, 0);
! 2989: xmlXPathFreeObject(list);
! 2990: }
! 2991: #endif /* LIBXML_XPATH_ENABLED */
! 2992: #ifdef LIBXML_TREE_ENABLED
! 2993: } else if (!strcmp(command, "setbase")) {
! 2994: xmlShellSetBase(ctxt, arg, ctxt->node, NULL);
! 2995: #endif
! 2996: } else if ((!strcmp(command, "ls")) || (!strcmp(command, "dir"))) {
! 2997: int dir = (!strcmp(command, "dir"));
! 2998:
! 2999: if (arg[0] == 0) {
! 3000: if (dir)
! 3001: xmlShellDir(ctxt, NULL, ctxt->node, NULL);
! 3002: else
! 3003: xmlShellList(ctxt, NULL, ctxt->node, NULL);
! 3004: } else {
! 3005: ctxt->pctxt->node = ctxt->node;
! 3006: #ifdef LIBXML_XPATH_ENABLED
! 3007: ctxt->pctxt->node = ctxt->node;
! 3008: list = xmlXPathEval((xmlChar *) arg, ctxt->pctxt);
! 3009: #else
! 3010: list = NULL;
! 3011: #endif /* LIBXML_XPATH_ENABLED */
! 3012: if (list != NULL) {
! 3013: switch (list->type) {
! 3014: case XPATH_UNDEFINED:
! 3015: xmlGenericError(xmlGenericErrorContext,
! 3016: "%s: no such node\n", arg);
! 3017: break;
! 3018: case XPATH_NODESET:{
! 3019: int indx;
! 3020:
! 3021: if (list->nodesetval == NULL)
! 3022: break;
! 3023:
! 3024: for (indx = 0;
! 3025: indx < list->nodesetval->nodeNr;
! 3026: indx++) {
! 3027: if (dir)
! 3028: xmlShellDir(ctxt, NULL,
! 3029: list->nodesetval->
! 3030: nodeTab[indx], NULL);
! 3031: else
! 3032: xmlShellList(ctxt, NULL,
! 3033: list->nodesetval->
! 3034: nodeTab[indx], NULL);
! 3035: }
! 3036: break;
! 3037: }
! 3038: case XPATH_BOOLEAN:
! 3039: xmlGenericError(xmlGenericErrorContext,
! 3040: "%s is a Boolean\n", arg);
! 3041: break;
! 3042: case XPATH_NUMBER:
! 3043: xmlGenericError(xmlGenericErrorContext,
! 3044: "%s is a number\n", arg);
! 3045: break;
! 3046: case XPATH_STRING:
! 3047: xmlGenericError(xmlGenericErrorContext,
! 3048: "%s is a string\n", arg);
! 3049: break;
! 3050: case XPATH_POINT:
! 3051: xmlGenericError(xmlGenericErrorContext,
! 3052: "%s is a point\n", arg);
! 3053: break;
! 3054: case XPATH_RANGE:
! 3055: xmlGenericError(xmlGenericErrorContext,
! 3056: "%s is a range\n", arg);
! 3057: break;
! 3058: case XPATH_LOCATIONSET:
! 3059: xmlGenericError(xmlGenericErrorContext,
! 3060: "%s is a range\n", arg);
! 3061: break;
! 3062: case XPATH_USERS:
! 3063: xmlGenericError(xmlGenericErrorContext,
! 3064: "%s is user-defined\n", arg);
! 3065: break;
! 3066: case XPATH_XSLT_TREE:
! 3067: xmlGenericError(xmlGenericErrorContext,
! 3068: "%s is an XSLT value tree\n",
! 3069: arg);
! 3070: break;
! 3071: }
! 3072: #ifdef LIBXML_XPATH_ENABLED
! 3073: xmlXPathFreeObject(list);
! 3074: #endif
! 3075: } else {
! 3076: xmlGenericError(xmlGenericErrorContext,
! 3077: "%s: no such node\n", arg);
! 3078: }
! 3079: ctxt->pctxt->node = NULL;
! 3080: }
! 3081: } else if (!strcmp(command, "cd")) {
! 3082: if (arg[0] == 0) {
! 3083: ctxt->node = (xmlNodePtr) ctxt->doc;
! 3084: } else {
! 3085: #ifdef LIBXML_XPATH_ENABLED
! 3086: ctxt->pctxt->node = ctxt->node;
! 3087: list = xmlXPathEval((xmlChar *) arg, ctxt->pctxt);
! 3088: #else
! 3089: list = NULL;
! 3090: #endif /* LIBXML_XPATH_ENABLED */
! 3091: if (list != NULL) {
! 3092: switch (list->type) {
! 3093: case XPATH_UNDEFINED:
! 3094: xmlGenericError(xmlGenericErrorContext,
! 3095: "%s: no such node\n", arg);
! 3096: break;
! 3097: case XPATH_NODESET:
! 3098: if (list->nodesetval != NULL) {
! 3099: if (list->nodesetval->nodeNr == 1) {
! 3100: ctxt->node = list->nodesetval->nodeTab[0];
! 3101: if ((ctxt->node != NULL) &&
! 3102: (ctxt->node->type ==
! 3103: XML_NAMESPACE_DECL)) {
! 3104: xmlGenericError(xmlGenericErrorContext,
! 3105: "cannot cd to namespace\n");
! 3106: ctxt->node = NULL;
! 3107: }
! 3108: } else
! 3109: xmlGenericError(xmlGenericErrorContext,
! 3110: "%s is a %d Node Set\n",
! 3111: arg,
! 3112: list->nodesetval->nodeNr);
! 3113: } else
! 3114: xmlGenericError(xmlGenericErrorContext,
! 3115: "%s is an empty Node Set\n",
! 3116: arg);
! 3117: break;
! 3118: case XPATH_BOOLEAN:
! 3119: xmlGenericError(xmlGenericErrorContext,
! 3120: "%s is a Boolean\n", arg);
! 3121: break;
! 3122: case XPATH_NUMBER:
! 3123: xmlGenericError(xmlGenericErrorContext,
! 3124: "%s is a number\n", arg);
! 3125: break;
! 3126: case XPATH_STRING:
! 3127: xmlGenericError(xmlGenericErrorContext,
! 3128: "%s is a string\n", arg);
! 3129: break;
! 3130: case XPATH_POINT:
! 3131: xmlGenericError(xmlGenericErrorContext,
! 3132: "%s is a point\n", arg);
! 3133: break;
! 3134: case XPATH_RANGE:
! 3135: xmlGenericError(xmlGenericErrorContext,
! 3136: "%s is a range\n", arg);
! 3137: break;
! 3138: case XPATH_LOCATIONSET:
! 3139: xmlGenericError(xmlGenericErrorContext,
! 3140: "%s is a range\n", arg);
! 3141: break;
! 3142: case XPATH_USERS:
! 3143: xmlGenericError(xmlGenericErrorContext,
! 3144: "%s is user-defined\n", arg);
! 3145: break;
! 3146: case XPATH_XSLT_TREE:
! 3147: xmlGenericError(xmlGenericErrorContext,
! 3148: "%s is an XSLT value tree\n",
! 3149: arg);
! 3150: break;
! 3151: }
! 3152: #ifdef LIBXML_XPATH_ENABLED
! 3153: xmlXPathFreeObject(list);
! 3154: #endif
! 3155: } else {
! 3156: xmlGenericError(xmlGenericErrorContext,
! 3157: "%s: no such node\n", arg);
! 3158: }
! 3159: ctxt->pctxt->node = NULL;
! 3160: }
! 3161: #ifdef LIBXML_OUTPUT_ENABLED
! 3162: } else if (!strcmp(command, "cat")) {
! 3163: if (arg[0] == 0) {
! 3164: xmlShellCat(ctxt, NULL, ctxt->node, NULL);
! 3165: } else {
! 3166: ctxt->pctxt->node = ctxt->node;
! 3167: #ifdef LIBXML_XPATH_ENABLED
! 3168: ctxt->pctxt->node = ctxt->node;
! 3169: list = xmlXPathEval((xmlChar *) arg, ctxt->pctxt);
! 3170: #else
! 3171: list = NULL;
! 3172: #endif /* LIBXML_XPATH_ENABLED */
! 3173: if (list != NULL) {
! 3174: switch (list->type) {
! 3175: case XPATH_UNDEFINED:
! 3176: xmlGenericError(xmlGenericErrorContext,
! 3177: "%s: no such node\n", arg);
! 3178: break;
! 3179: case XPATH_NODESET:{
! 3180: int indx;
! 3181:
! 3182: if (list->nodesetval == NULL)
! 3183: break;
! 3184:
! 3185: for (indx = 0;
! 3186: indx < list->nodesetval->nodeNr;
! 3187: indx++) {
! 3188: if (i > 0)
! 3189: fprintf(ctxt->output, " -------\n");
! 3190: xmlShellCat(ctxt, NULL,
! 3191: list->nodesetval->
! 3192: nodeTab[indx], NULL);
! 3193: }
! 3194: break;
! 3195: }
! 3196: case XPATH_BOOLEAN:
! 3197: xmlGenericError(xmlGenericErrorContext,
! 3198: "%s is a Boolean\n", arg);
! 3199: break;
! 3200: case XPATH_NUMBER:
! 3201: xmlGenericError(xmlGenericErrorContext,
! 3202: "%s is a number\n", arg);
! 3203: break;
! 3204: case XPATH_STRING:
! 3205: xmlGenericError(xmlGenericErrorContext,
! 3206: "%s is a string\n", arg);
! 3207: break;
! 3208: case XPATH_POINT:
! 3209: xmlGenericError(xmlGenericErrorContext,
! 3210: "%s is a point\n", arg);
! 3211: break;
! 3212: case XPATH_RANGE:
! 3213: xmlGenericError(xmlGenericErrorContext,
! 3214: "%s is a range\n", arg);
! 3215: break;
! 3216: case XPATH_LOCATIONSET:
! 3217: xmlGenericError(xmlGenericErrorContext,
! 3218: "%s is a range\n", arg);
! 3219: break;
! 3220: case XPATH_USERS:
! 3221: xmlGenericError(xmlGenericErrorContext,
! 3222: "%s is user-defined\n", arg);
! 3223: break;
! 3224: case XPATH_XSLT_TREE:
! 3225: xmlGenericError(xmlGenericErrorContext,
! 3226: "%s is an XSLT value tree\n",
! 3227: arg);
! 3228: break;
! 3229: }
! 3230: #ifdef LIBXML_XPATH_ENABLED
! 3231: xmlXPathFreeObject(list);
! 3232: #endif
! 3233: } else {
! 3234: xmlGenericError(xmlGenericErrorContext,
! 3235: "%s: no such node\n", arg);
! 3236: }
! 3237: ctxt->pctxt->node = NULL;
! 3238: }
! 3239: #endif /* LIBXML_OUTPUT_ENABLED */
! 3240: } else {
! 3241: xmlGenericError(xmlGenericErrorContext,
! 3242: "Unknown command %s\n", command);
! 3243: }
! 3244: free(cmdline); /* not xmlFree here ! */
! 3245: cmdline = NULL;
! 3246: }
! 3247: #ifdef LIBXML_XPATH_ENABLED
! 3248: xmlXPathFreeContext(ctxt->pctxt);
! 3249: #endif /* LIBXML_XPATH_ENABLED */
! 3250: if (ctxt->loaded) {
! 3251: xmlFreeDoc(ctxt->doc);
! 3252: }
! 3253: if (ctxt->filename != NULL)
! 3254: xmlFree(ctxt->filename);
! 3255: xmlFree(ctxt);
! 3256: if (cmdline != NULL)
! 3257: free(cmdline); /* not xmlFree here ! */
! 3258: }
! 3259:
! 3260: #endif /* LIBXML_XPATH_ENABLED */
! 3261: #define bottom_debugXML
! 3262: #include "elfgcchack.h"
! 3263: #endif /* LIBXML_DEBUG_ENABLED */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to debugXML.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2