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