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