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 (at) 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 */ 3264
