MagickCore 6.9.13-51
Convert, Edit, Or Compose Bitmap Images
Loading...
Searching...
No Matches
xml-tree.c
1/*
2%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3% %
4% %
5% %
6% X X M M L %
7% X X MM MM L %
8% X M M M L %
9% X X M M L %
10% X X M M LLLLL %
11% %
12% TTTTT RRRR EEEEE EEEEE %
13% T R R E E %
14% T RRRR EEE EEE %
15% T R R E E %
16% T R R EEEEE EEEEE %
17% %
18% %
19% XML Tree Methods %
20% %
21% Software Design %
22% Cristy %
23% December 2004 %
24% %
25% %
26% Copyright 1999 ImageMagick Studio LLC, a non-profit organization %
27% dedicated to making software imaging solutions freely available. %
28% %
29% You may not use this file except in compliance with the License. You may %
30% obtain a copy of the License at %
31% %
32% https://imagemagick.org/license/ %
33% %
34% Unless required by applicable law or agreed to in writing, software %
35% distributed under the License is distributed on an "AS IS" BASIS, %
36% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
37% See the License for the specific language governing permissions and %
38% limitations under the License. %
39% %
40%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
41%
42% This module implements the standard handy xml-tree methods for storing and
43% retrieving nodes and attributes from an XML string.
44%
45*/
46␌
47/*
48 Include declarations.
49*/
50#include "magick/studio.h"
51#include "magick/blob.h"
52#include "magick/blob-private.h"
53#include "magick/exception.h"
54#include "magick/exception-private.h"
55#include "magick/image-private.h"
56#include "magick/log.h"
57#include "magick/memory_.h"
58#include "magick/semaphore.h"
59#include "magick/string_.h"
60#include "magick/string-private.h"
61#include "magick/token-private.h"
62#include "magick/utility.h"
63#include "magick/utility-private.h"
64#include "magick/xml-tree.h"
65#include "magick/xml-tree-private.h"
66␌
67/*
68 Define declarations.
69*/
70#define NumberPredefinedEntities 10
71#define XMLWhitespace "\t\r\n "
72␌
73/*
74 Typedef declarations.
75*/
76struct _XMLTreeInfo
77{
78 char
79 *tag,
80 **attributes,
81 *content;
82
83 size_t
84 offset;
85
86 XMLTreeInfo
87 *parent,
88 *next,
89 *sibling,
90 *ordered,
91 *child;
92
93 MagickBooleanType
94 debug;
95
96 SemaphoreInfo
97 *semaphore;
98
99 size_t
100 signature;
101};
102
103typedef struct _XMLTreeRoot
104 XMLTreeRoot;
105
106struct _XMLTreeRoot
107{
108 struct _XMLTreeInfo
109 root;
110
111 XMLTreeInfo
112 *node;
113
114 MagickBooleanType
115 standalone;
116
117 char
118 ***processing_instructions,
119 **entities,
120 ***attributes;
121
122 MagickBooleanType
123 debug;
124
125 SemaphoreInfo
126 *semaphore;
127
128 size_t
129 signature;
130};
131␌
132/*
133 Global declarations.
134*/
135static char
136 *sentinel[] = { (char *) NULL };
137␌
138/*
139%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
140% %
141% %
142% %
143% A d d C h i l d T o X M L T r e e %
144% %
145% %
146% %
147%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
148%
149% AddChildToXMLTree() adds a child tag at an offset relative to the start of
150% the parent tag's character content. Return the child tag.
151%
152% The format of the AddChildToXMLTree method is:
153%
154% XMLTreeInfo *AddChildToXMLTree(XMLTreeInfo *xml_info,const char *tag,
155% const size_t offset)
156%
157% A description of each parameter follows:
158%
159% o xml_info: the xml info.
160%
161% o tag: the tag.
162%
163% o offset: the tag offset.
164%
165*/
166MagickExport XMLTreeInfo *AddChildToXMLTree(XMLTreeInfo *xml_info,
167 const char *tag,const size_t offset)
168{
169 XMLTreeInfo
170 *child;
171
172 if (xml_info == (XMLTreeInfo *) NULL)
173 return((XMLTreeInfo *) NULL);
174 child=(XMLTreeInfo *) AcquireMagickMemory(sizeof(*child));
175 if (child == (XMLTreeInfo *) NULL)
176 return((XMLTreeInfo *) NULL);
177 (void) memset(child,0,sizeof(*child));
178 child->tag=ConstantString(tag);
179 child->attributes=sentinel;
180 child->content=ConstantString("");
181 child->debug=IsEventLogging();
182 child->signature=MagickCoreSignature;
183 return(InsertTagIntoXMLTree(xml_info,child,offset));
184}
185␌
186/*
187%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
188% %
189% %
190% %
191% A d d P a t h T o X M L T r e e %
192% %
193% %
194% %
195%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
196%
197% AddPathToXMLTree() adds a child tag at an offset relative to the start of
198% the parent tag's character content. This method returns the child tag.
199%
200% The format of the AddPathToXMLTree method is:
201%
202% XMLTreeInfo *AddPathToXMLTree(XMLTreeInfo *xml_info,const char *path,
203% const size_t offset)
204%
205% A description of each parameter follows:
206%
207% o xml_info: the xml info.
208%
209% o path: the path.
210%
211% o offset: the tag offset.
212%
213*/
214MagickExport XMLTreeInfo *AddPathToXMLTree(XMLTreeInfo *xml_info,
215 const char *path,const size_t offset)
216{
217 char
218 **components,
219 subnode[MaxTextExtent],
220 tag[MaxTextExtent];
221
222 size_t
223 number_components;
224
225 ssize_t
226 i,
227 j;
228
229 XMLTreeInfo
230 *child,
231 *node;
232
233 assert(xml_info != (XMLTreeInfo *) NULL);
234 assert((xml_info->signature == MagickCoreSignature) ||
235 (((XMLTreeRoot *) xml_info)->signature == MagickCoreSignature));
236 if (IsEventLogging() != MagickFalse)
237 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
238 node=xml_info;
239 components=GetPathComponents(path,&number_components);
240 if (components == (char **) NULL)
241 return((XMLTreeInfo *) NULL);
242 for (i=0; i < (ssize_t) number_components; i++)
243 {
244 GetPathComponent(components[i],SubimagePath,subnode);
245 GetPathComponent(components[i],CanonicalPath,tag);
246 child=GetXMLTreeChild(node,tag);
247 if (child == (XMLTreeInfo *) NULL)
248 child=AddChildToXMLTree(node,tag,offset);
249 node=child;
250 if (node == (XMLTreeInfo *) NULL)
251 break;
252 for (j=(ssize_t) StringToLong(subnode)-1; j > 0; j--)
253 {
254 node=GetXMLTreeOrdered(node);
255 if (node == (XMLTreeInfo *) NULL)
256 break;
257 }
258 if (node == (XMLTreeInfo *) NULL)
259 break;
260 components[i]=DestroyString(components[i]);
261 }
262 for ( ; i < (ssize_t) number_components; i++)
263 components[i]=DestroyString(components[i]);
264 components=(char **) RelinquishMagickMemory(components);
265 return(node);
266}
267␌
268/*
269%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
270% %
271% %
272% %
273% C a n o n i c a l X M L C o n t e n t %
274% %
275% %
276% %
277%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
278%
279% CanonicalXMLContent() converts text to canonical XML content by converting
280% to UTF-8, substituting predefined entities, wrapping as CDATA, or encoding
281% as base-64 as required.
282%
283% The format of the CanonicalXMLContent method is:
284%
285% char *CanonicalXMLContent(const char *content,
286% const MagickBooleanType pedantic)
287%
288% A description of each parameter follows:
289%
290% o content: the content.
291%
292% o pedantic: if true, replace newlines and tabs with their respective
293% entities.
294%
295*/
296MagickExport char *CanonicalXMLContent(const char *content,
297 const MagickBooleanType pedantic)
298{
299 char
300 *base64,
301 *canonical_content;
302
303 const unsigned char
304 *p;
305
306 size_t
307 extent,
308 length;
309
310 ssize_t
311 i;
312
313 unsigned char
314 *utf8;
315
316 utf8=ConvertLatin1ToUTF8((const unsigned char *) content);
317 if (utf8 == (unsigned char *) NULL)
318 return((char *) NULL);
319 for (p=utf8; *p != '\0'; p++)
320 if ((*p < 0x20) && (*p != 0x09) && (*p != 0x0a) && (*p != 0x0d))
321 break;
322 if (*p != '\0')
323 {
324 /*
325 String is binary, base64-encode it.
326 */
327 base64=Base64Encode(utf8,strlen((char *) utf8),&length);
328 utf8=(unsigned char *) RelinquishMagickMemory(utf8);
329 if (base64 == (char *) NULL)
330 return((char *) NULL);
331 canonical_content=AcquireString("<base64>");
332 (void) ConcatenateString(&canonical_content,base64);
333 base64=DestroyString(base64);
334 (void) ConcatenateString(&canonical_content,"</base64>");
335 return(canonical_content);
336 }
337 /*
338 Substitute predefined entities.
339 */
340 i=0;
341 canonical_content=AcquireString((char *) NULL);
342 extent=MaxTextExtent;
343 for (p=utf8; *p != '\0'; p++)
344 {
345 if ((i+MaxTextExtent) > (ssize_t) extent)
346 {
347 extent+=MaxTextExtent;
348 canonical_content=(char *) ResizeQuantumMemory(canonical_content,extent,
349 sizeof(*canonical_content));
350 if (canonical_content == (char *) NULL)
351 return(canonical_content);
352 }
353 switch (*p)
354 {
355 case '&':
356 {
357 i+=FormatLocaleString(canonical_content+i,extent,"&amp;");
358 break;
359 }
360 case '<':
361 {
362 i+=FormatLocaleString(canonical_content+i,extent,"&lt;");
363 break;
364 }
365 case '>':
366 {
367 i+=FormatLocaleString(canonical_content+i,extent,"&gt;");
368 break;
369 }
370 case '"':
371 {
372 i+=FormatLocaleString(canonical_content+i,extent,"&quot;");
373 break;
374 }
375 case '\n':
376 {
377 if (pedantic == MagickFalse)
378 {
379 canonical_content[i++]=(char) (*p);
380 break;
381 }
382 i+=FormatLocaleString(canonical_content+i,extent,"&#xA;");
383 break;
384 }
385 case '\t':
386 {
387 if (pedantic == MagickFalse)
388 {
389 canonical_content[i++]=(char) (*p);
390 break;
391 }
392 i+=FormatLocaleString(canonical_content+i,extent,"&#x9;");
393 break;
394 }
395 case '\r':
396 {
397 i+=FormatLocaleString(canonical_content+i,extent,"&#xD;");
398 break;
399 }
400 default:
401 {
402 canonical_content[i++]=(char) (*p);
403 break;
404 }
405 }
406 }
407 canonical_content[i]='\0';
408 utf8=(unsigned char *) RelinquishMagickMemory(utf8);
409 return(canonical_content);
410}
411␌
412/*
413%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
414% %
415% %
416% %
417% D e s t r o y X M L T r e e %
418% %
419% %
420% %
421%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
422%
423% DestroyXMLTree() destroys the xml-tree.
424%
425% The format of the DestroyXMLTree method is:
426%
427% XMLTreeInfo *DestroyXMLTree(XMLTreeInfo *xml_info)
428%
429% A description of each parameter follows:
430%
431% o xml_info: the xml info.
432%
433*/
434
435static XMLTreeInfo
436 *DestroyXMLTree_(XMLTreeInfo *,const size_t);
437
438static char **DestroyXMLTreeAttributes(char **attributes)
439{
440 ssize_t
441 i;
442
443 /*
444 Destroy a tag attribute list.
445 */
446 if ((attributes == (char **) NULL) || (attributes == sentinel))
447 return((char **) NULL);
448 for (i=0; attributes[i] != (char *) NULL; i+=2)
449 {
450 /*
451 Destroy attribute tag and value.
452 */
453 if (attributes[i] != (char *) NULL)
454 attributes[i]=DestroyString(attributes[i]);
455 if (attributes[i+1] != (char *) NULL)
456 attributes[i+1]=DestroyString(attributes[i+1]);
457 }
458 attributes=(char **) RelinquishMagickMemory(attributes);
459 return((char **) NULL);
460}
461
462static void DestroyXMLTreeChild(XMLTreeInfo *xml_info,
463 const size_t depth)
464{
465 XMLTreeInfo
466 *child,
467 *node;
468
469 child=xml_info->child;
470 while (child != (XMLTreeInfo *) NULL)
471 {
472 node=child;
473 child=node->child;
474 node->child=(XMLTreeInfo *) NULL;
475 (void) DestroyXMLTree_(node,depth+1);
476 }
477}
478
479static void DestroyXMLTreeOrdered(XMLTreeInfo *xml_info,
480 const size_t depth)
481{
482 XMLTreeInfo
483 *node,
484 *ordered;
485
486 ordered=xml_info->ordered;
487 while (ordered != (XMLTreeInfo *) NULL)
488 {
489 node=ordered;
490 ordered=node->ordered;
491 node->ordered=(XMLTreeInfo *) NULL;
492 (void) DestroyXMLTree_(node,depth+1);
493 }
494}
495
496static void DestroyXMLTreeRoot(XMLTreeInfo *xml_info)
497{
498 char
499 **attributes;
500
501 ssize_t
502 i,
503 j;
504
505 XMLTreeRoot
506 *root;
507
508 assert(xml_info != (XMLTreeInfo *) NULL);
509 assert((xml_info->signature == MagickCoreSignature) ||
510 (((XMLTreeRoot *) xml_info)->signature == MagickCoreSignature));
511 if (IsEventLogging() != MagickFalse)
512 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
513 if (xml_info->parent != (XMLTreeInfo *) NULL)
514 return;
515 /*
516 Free root tag allocations.
517 */
518 root=(XMLTreeRoot *) xml_info;
519 for (i=NumberPredefinedEntities; root->entities[i] != (char *) NULL; i+=2)
520 root->entities[i+1]=DestroyString(root->entities[i+1]);
521 root->entities=(char **) RelinquishMagickMemory(root->entities);
522 for (i=0; root->attributes[i] != (char **) NULL; i++)
523 {
524 attributes=root->attributes[i];
525 if (attributes[0] != (char *) NULL)
526 attributes[0]=DestroyString(attributes[0]);
527 for (j=1; attributes[j] != (char *) NULL; j+=3)
528 {
529 if (attributes[j] != (char *) NULL)
530 attributes[j]=DestroyString(attributes[j]);
531 if (attributes[j+1] != (char *) NULL)
532 attributes[j+1]=DestroyString(attributes[j+1]);
533 if (attributes[j+2] != (char *) NULL)
534 attributes[j+2]=DestroyString(attributes[j+2]);
535 }
536 attributes=(char **) RelinquishMagickMemory(attributes);
537 }
538 if (root->attributes[0] != (char **) NULL)
539 root->attributes=(char ***) RelinquishMagickMemory(root->attributes);
540 if (root->processing_instructions[0] != (char **) NULL)
541 {
542 for (i=0; root->processing_instructions[i] != (char **) NULL; i++)
543 {
544 for (j=0; root->processing_instructions[i][j] != (char *) NULL; j++)
545 root->processing_instructions[i][j]=DestroyString(
546 root->processing_instructions[i][j]);
547 root->processing_instructions[i][j+1]=DestroyString(
548 root->processing_instructions[i][j+1]);
549 root->processing_instructions[i]=(char **) RelinquishMagickMemory(
550 root->processing_instructions[i]);
551 }
552 root->processing_instructions=(char ***) RelinquishMagickMemory(
553 root->processing_instructions);
554 }
555}
556
557static XMLTreeInfo *DestroyXMLTree_(XMLTreeInfo *xml_info,
558 const size_t depth)
559{
560 assert(xml_info != (XMLTreeInfo *) NULL);
561 assert((xml_info->signature == MagickCoreSignature) ||
562 (((XMLTreeRoot *) xml_info)->signature == MagickCoreSignature));
563 if (IsEventLogging() != MagickFalse)
564 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
565 if (depth > MagickMaxRecursionDepth)
566 ThrowFatalException(ResourceLimitFatalError,
567 "MemoryAllocationFailed");
568 DestroyXMLTreeChild(xml_info,depth+1);
569 DestroyXMLTreeOrdered(xml_info,depth+1);
570 DestroyXMLTreeRoot(xml_info);
571 xml_info->attributes=DestroyXMLTreeAttributes(xml_info->attributes);
572 xml_info->content=DestroyString(xml_info->content);
573 xml_info->tag=DestroyString(xml_info->tag);
574 xml_info=(XMLTreeInfo *) RelinquishMagickMemory(xml_info);
575 return((XMLTreeInfo *) NULL);
576}
577
578MagickExport XMLTreeInfo *DestroyXMLTree(XMLTreeInfo *xml_info)
579{
580 return(DestroyXMLTree_(xml_info,0));
581}
582␌
583/*
584%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
585% %
586% %
587% %
588% F i l e T o X M L %
589% %
590% %
591% %
592%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
593%
594% FileToXML() returns the contents of a file as a XML string.
595%
596% The format of the FileToXML method is:
597%
598% char *FileToXML(const char *filename,const size_t extent)
599%
600% A description of each parameter follows:
601%
602% o filename: the filename.
603%
604% o extent: Maximum length of the string.
605%
606*/
607MagickPrivate char *FileToXML(const char *filename,const size_t extent)
608{
609 char
610 *xml;
611
612 int
613 file;
614
615 MagickOffsetType
616 offset;
617
618 size_t
619 i,
620 length;
621
622 ssize_t
623 count;
624
625 void
626 *map;
627
628 assert(filename != (const char *) NULL);
629 length=0;
630 file=fileno(stdin);
631 if (LocaleCompare(filename,"-") != 0)
632 file=open_utf8(filename,O_RDONLY | O_BINARY,0);
633 if (file == -1)
634 return((char *) NULL);
635 offset=(MagickOffsetType) lseek(file,0,SEEK_END);
636 count=0;
637 if ((file == fileno(stdin)) || (offset < 0) ||
638 (offset != (MagickOffsetType) ((ssize_t) offset)))
639 {
640 size_t
641 quantum;
642
643 struct stat
644 file_stats;
645
646 /*
647 Stream is not seekable.
648 */
649 offset=(MagickOffsetType) lseek(file,0,SEEK_SET);
650 quantum=(size_t) MagickMaxBufferExtent;
651 if ((fstat(file,&file_stats) == 0) && (file_stats.st_size > 0))
652 quantum=(size_t) MagickMin(file_stats.st_size,MagickMaxBufferExtent);
653 xml=(char *) AcquireQuantumMemory(quantum,sizeof(*xml));
654 for (i=0; xml != (char *) NULL; i+=count)
655 {
656 count=read(file,xml+i,quantum);
657 if (count <= 0)
658 {
659 count=0;
660 if (errno != EINTR)
661 break;
662 }
663 if (~((size_t) i) < (quantum+1))
664 {
665 xml=(char *) RelinquishMagickMemory(xml);
666 break;
667 }
668 xml=(char *) ResizeQuantumMemory(xml,i+quantum+1,sizeof(*xml));
669 if ((size_t) (i+count) >= extent)
670 break;
671 }
672 if (LocaleCompare(filename,"-") != 0)
673 file=close_utf8(file);
674 if (xml == (char *) NULL)
675 return((char *) NULL);
676 if (file == -1)
677 {
678 xml=(char *) RelinquishMagickMemory(xml);
679 return((char *) NULL);
680 }
681 length=(size_t) MagickMin(i+count,extent);
682 xml[length]='\0';
683 return(xml);
684 }
685 length=(size_t) MagickMin(offset,(MagickOffsetType) extent);
686 xml=(char *) NULL;
687 if (~length >= (MaxTextExtent-1))
688 xml=(char *) AcquireQuantumMemory(length+MaxTextExtent,sizeof(*xml));
689 if (xml == (char *) NULL)
690 {
691 file=close_utf8(file);
692 return((char *) NULL);
693 }
694 map=MapBlob(file,ReadMode,0,length);
695 if (map != (char *) NULL)
696 {
697 (void) memcpy(xml,map,length);
698 (void) UnmapBlob(map,length);
699 }
700 else
701 {
702 (void) lseek(file,0,SEEK_SET);
703 for (i=0; i < length; i+=count)
704 {
705 count=read(file,xml+i,(size_t) MagickMin(length-i,(size_t) MagickMaxBufferExtent));
706 if (count <= 0)
707 {
708 count=0;
709 if (errno != EINTR)
710 break;
711 }
712 }
713 if (i < length)
714 {
715 file=close_utf8(file)-1;
716 xml=(char *) RelinquishMagickMemory(xml);
717 return((char *) NULL);
718 }
719 }
720 xml[length]='\0';
721 if (LocaleCompare(filename,"-") != 0)
722 file=close_utf8(file);
723 if (file == -1)
724 xml=(char *) RelinquishMagickMemory(xml);
725 return(xml);
726}
727␌
728/*
729%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
730% %
731% %
732% %
733% G e t N e x t X M L T r e e T a g %
734% %
735% %
736% %
737%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
738%
739% GetNextXMLTreeTag() returns the next tag or NULL if not found.
740%
741% The format of the GetNextXMLTreeTag method is:
742%
743% XMLTreeInfo *GetNextXMLTreeTag(XMLTreeInfo *xml_info)
744%
745% A description of each parameter follows:
746%
747% o xml_info: the xml info.
748%
749*/
750MagickExport XMLTreeInfo *GetNextXMLTreeTag(XMLTreeInfo *xml_info)
751{
752 assert(xml_info != (XMLTreeInfo *) NULL);
753 assert((xml_info->signature == MagickCoreSignature) ||
754 (((XMLTreeRoot *) xml_info)->signature == MagickCoreSignature));
755 if (IsEventLogging() != MagickFalse)
756 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
757 return(xml_info->next);
758}
759␌
760/*
761%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
762% %
763% %
764% %
765% G e t X M L T r e e A t t r i b u t e %
766% %
767% %
768% %
769%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
770%
771% GetXMLTreeAttribute() returns the value of the attribute tag with the
772% specified tag if found, otherwise NULL.
773%
774% The format of the GetXMLTreeAttribute method is:
775%
776% const char *GetXMLTreeAttribute(XMLTreeInfo *xml_info,const char *tag)
777%
778% A description of each parameter follows:
779%
780% o xml_info: the xml info.
781%
782% o tag: the attribute tag.
783%
784*/
785MagickExport const char *GetXMLTreeAttribute(XMLTreeInfo *xml_info,
786 const char *tag)
787{
788 ssize_t
789 i,
790 j;
791
792 XMLTreeRoot
793 *root;
794
795 assert(xml_info != (XMLTreeInfo *) NULL);
796 assert((xml_info->signature == MagickCoreSignature) ||
797 (((XMLTreeRoot *) xml_info)->signature == MagickCoreSignature));
798 if (IsEventLogging() != MagickFalse)
799 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
800 if (xml_info->attributes == (char **) NULL)
801 return((const char *) NULL);
802 i=0;
803 while ((xml_info->attributes[i] != (char *) NULL) &&
804 (strcmp(xml_info->attributes[i],tag) != 0))
805 i+=2;
806 if (xml_info->attributes[i] != (char *) NULL)
807 return(xml_info->attributes[i+1]);
808 root=(XMLTreeRoot*) xml_info;
809 while (root->root.parent != (XMLTreeInfo *) NULL)
810 root=(XMLTreeRoot *) root->root.parent;
811 i=0;
812 while ((root->attributes[i] != (char **) NULL) &&
813 (strcmp(root->attributes[i][0],xml_info->tag) != 0))
814 i++;
815 if (root->attributes[i] == (char **) NULL)
816 return((const char *) NULL);
817 j=1;
818 while ((root->attributes[i][j] != (char *) NULL) &&
819 (strcmp(root->attributes[i][j],tag) != 0))
820 j+=3;
821 if (root->attributes[i][j] == (char *) NULL)
822 return((const char *) NULL);
823 return(root->attributes[i][j+1]);
824}
825␌
826/*
827%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
828% %
829% %
830% %
831% G e t X M L T r e e A t t r i b u t e s %
832% %
833% %
834% %
835%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
836%
837% GetXMLTreeAttributes() injects all attributes associated with the current
838% tag in the specified splay-tree.
839%
840% The format of the GetXMLTreeAttributes method is:
841%
842% MagickBooleanType GetXMLTreeAttributes(const XMLTreeInfo *xml_info,
843% SplayTreeInfo *attributes)
844%
845% A description of each parameter follows:
846%
847% o xml_info: the xml info.
848%
849% o attributes: the attribute splay-tree.
850%
851*/
852MagickExport MagickBooleanType GetXMLTreeAttributes(const XMLTreeInfo *xml_info,
853 SplayTreeInfo *attributes)
854{
855 ssize_t
856 i;
857
858 assert(xml_info != (XMLTreeInfo *) NULL);
859 assert((xml_info->signature == MagickCoreSignature) ||
860 (((const XMLTreeRoot *) xml_info)->signature == MagickCoreSignature));
861 assert(attributes != (SplayTreeInfo *) NULL);
862 if (IsEventLogging() != MagickFalse)
863 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
864 if (xml_info->attributes == (char **) NULL)
865 return(MagickTrue);
866 i=0;
867 while (xml_info->attributes[i] != (char *) NULL)
868 {
869 (void) AddValueToSplayTree(attributes,
870 ConstantString(xml_info->attributes[i]),
871 ConstantString(xml_info->attributes[i+1]));
872 i+=2;
873 }
874 return(MagickTrue);
875}
876␌
877/*
878%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
879% %
880% %
881% %
882% G e t X M L T r e e C h i l d %
883% %
884% %
885% %
886%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
887%
888% GetXMLTreeChild() returns the first child tag with the specified tag if
889% found, otherwise NULL.
890%
891% The format of the GetXMLTreeChild method is:
892%
893% XMLTreeInfo *GetXMLTreeChild(XMLTreeInfo *xml_info,const char *tag)
894%
895% A description of each parameter follows:
896%
897% o xml_info: the xml info.
898%
899*/
900MagickExport XMLTreeInfo *GetXMLTreeChild(XMLTreeInfo *xml_info,const char *tag)
901{
902 XMLTreeInfo
903 *child;
904
905 assert(xml_info != (XMLTreeInfo *) NULL);
906 assert((xml_info->signature == MagickCoreSignature) ||
907 (((XMLTreeRoot *) xml_info)->signature == MagickCoreSignature));
908 if (IsEventLogging() != MagickFalse)
909 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
910 child=xml_info->child;
911 if (tag != (const char *) NULL)
912 while ((child != (XMLTreeInfo *) NULL) && (strcmp(child->tag,tag) != 0))
913 child=child->sibling;
914 return(child);
915}
916␌
917/*
918%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
919% %
920% %
921% %
922% G e t X M L T r e e C o n t e n t %
923% %
924% %
925% %
926%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
927%
928% GetXMLTreeContent() returns any content associated with specified
929% xml-tree node.
930%
931% The format of the GetXMLTreeContent method is:
932%
933% const char *GetXMLTreeContent(XMLTreeInfo *xml_info)
934%
935% A description of each parameter follows:
936%
937% o xml_info: the xml info.
938%
939*/
940MagickExport const char *GetXMLTreeContent(XMLTreeInfo *xml_info)
941{
942 assert(xml_info != (XMLTreeInfo *) NULL);
943 assert((xml_info->signature == MagickCoreSignature) ||
944 (((XMLTreeRoot *) xml_info)->signature == MagickCoreSignature));
945 if (IsEventLogging() != MagickFalse)
946 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
947 return(xml_info->content);
948}
949␌
950/*
951%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
952% %
953% %
954% %
955% G e t X M L T r e e O r d e r e d %
956% %
957% %
958% %
959%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
960%
961% GetXMLTreeOrdered() returns the next ordered node if found, otherwise NULL.
962%
963% The format of the GetXMLTreeOrdered method is:
964%
965% XMLTreeInfo *GetXMLTreeOrdered(XMLTreeInfo *xml_info)
966%
967% A description of each parameter follows:
968%
969% o xml_info: the xml info.
970%
971*/
972MagickExport XMLTreeInfo *GetXMLTreeOrdered(XMLTreeInfo *xml_info)
973{
974 assert(xml_info != (XMLTreeInfo *) NULL);
975 assert((xml_info->signature == MagickCoreSignature) ||
976 (((XMLTreeRoot *) xml_info)->signature == MagickCoreSignature));
977 if (IsEventLogging() != MagickFalse)
978 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
979 return(xml_info->ordered);
980}
981␌
982/*
983%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
984% %
985% %
986% %
987% G e t X M L T r e e P a t h %
988% %
989% %
990% %
991%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
992%
993% GetXMLTreePath() traverses the XML-tree as defined by the specified path
994% and returns the node if found, otherwise NULL.
995%
996% The format of the GetXMLTreePath method is:
997%
998% XMLTreeInfo *GetXMLTreePath(XMLTreeInfo *xml_info,const char *path)
999%
1000% A description of each parameter follows:
1001%
1002% o xml_info: the xml info.
1003%
1004% o path: the path (e.g. property/elapsed-time).
1005%
1006*/
1007MagickExport XMLTreeInfo *GetXMLTreePath(XMLTreeInfo *xml_info,const char *path)
1008{
1009 char
1010 **components,
1011 subnode[MaxTextExtent],
1012 tag[MaxTextExtent];
1013
1014 size_t
1015 number_components;
1016
1017 ssize_t
1018 i,
1019 j;
1020
1021 XMLTreeInfo
1022 *node;
1023
1024 assert(xml_info != (XMLTreeInfo *) NULL);
1025 assert((xml_info->signature == MagickCoreSignature) ||
1026 (((XMLTreeRoot *) xml_info)->signature == MagickCoreSignature));
1027 if (IsEventLogging() != MagickFalse)
1028 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1029 node=xml_info;
1030 components=GetPathComponents(path,&number_components);
1031 if (components == (char **) NULL)
1032 return((XMLTreeInfo *) NULL);
1033 for (i=0; i < (ssize_t) number_components; i++)
1034 {
1035 GetPathComponent(components[i],SubimagePath,subnode);
1036 GetPathComponent(components[i],CanonicalPath,tag);
1037 node=GetXMLTreeChild(node,tag);
1038 if (node == (XMLTreeInfo *) NULL)
1039 break;
1040 for (j=(ssize_t) StringToLong(subnode)-1; j > 0; j--)
1041 {
1042 node=GetXMLTreeOrdered(node);
1043 if (node == (XMLTreeInfo *) NULL)
1044 break;
1045 }
1046 if (node == (XMLTreeInfo *) NULL)
1047 break;
1048 components[i]=DestroyString(components[i]);
1049 }
1050 for ( ; i < (ssize_t) number_components; i++)
1051 components[i]=DestroyString(components[i]);
1052 components=(char **) RelinquishMagickMemory(components);
1053 return(node);
1054}
1055␌
1056/*
1057%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1058% %
1059% %
1060% %
1061% G e t X M L T r e e P r o c e s s i n g I n s t r u c t i o n s %
1062% %
1063% %
1064% %
1065%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1066%
1067% GetXMLTreeProcessingInstructions() returns a null terminated array of
1068% processing instructions for the given target.
1069%
1070% The format of the GetXMLTreeProcessingInstructions method is:
1071%
1072% const char **GetXMLTreeProcessingInstructions(XMLTreeInfo *xml_info,
1073% const char *target)
1074%
1075% A description of each parameter follows:
1076%
1077% o xml_info: the xml info.
1078%
1079*/
1080MagickExport const char **GetXMLTreeProcessingInstructions(
1081 XMLTreeInfo *xml_info,const char *target)
1082{
1083 ssize_t
1084 i;
1085
1086 XMLTreeRoot
1087 *root;
1088
1089 assert(xml_info != (XMLTreeInfo *) NULL);
1090 assert((xml_info->signature == MagickCoreSignature) ||
1091 (((XMLTreeRoot *) xml_info)->signature == MagickCoreSignature));
1092 if (IsEventLogging() != MagickFalse)
1093 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1094 root=(XMLTreeRoot *) xml_info;
1095 while (root->root.parent != (XMLTreeInfo *) NULL)
1096 root=(XMLTreeRoot *) root->root.parent;
1097 i=0;
1098 while ((root->processing_instructions[i] != (char **) NULL) &&
1099 (strcmp(root->processing_instructions[i][0],target) != 0))
1100 i++;
1101 if (root->processing_instructions[i] == (char **) NULL)
1102 return((const char **) sentinel);
1103 return((const char **) (root->processing_instructions[i]+1));
1104}
1105␌
1106/*
1107%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1108% %
1109% %
1110% %
1111% G e t X M L T r e e S i b l i n g %
1112% %
1113% %
1114% %
1115%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1116%
1117% GetXMLTreeSibling() returns the node sibling if found, otherwise NULL.
1118%
1119% The format of the GetXMLTreeSibling method is:
1120%
1121% XMLTreeInfo *GetXMLTreeSibling(XMLTreeInfo *xml_info)
1122%
1123% A description of each parameter follows:
1124%
1125% o xml_info: the xml info.
1126%
1127*/
1128MagickExport XMLTreeInfo *GetXMLTreeSibling(XMLTreeInfo *xml_info)
1129{
1130 assert(xml_info != (XMLTreeInfo *) NULL);
1131 assert((xml_info->signature == MagickCoreSignature) ||
1132 (((XMLTreeRoot *) xml_info)->signature == MagickCoreSignature));
1133 if (IsEventLogging() != MagickFalse)
1134 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1135 return(xml_info->sibling);
1136}
1137␌
1138/*
1139%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1140% %
1141% %
1142% %
1143% G e t X M L T r e e T a g %
1144% %
1145% %
1146% %
1147%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1148%
1149% GetXMLTreeTag() returns the tag associated with specified xml-tree node.
1150%
1151% The format of the GetXMLTreeTag method is:
1152%
1153% const char *GetXMLTreeTag(XMLTreeInfo *xml_info)
1154%
1155% A description of each parameter follows:
1156%
1157% o xml_info: the xml info.
1158%
1159*/
1160MagickExport const char *GetXMLTreeTag(XMLTreeInfo *xml_info)
1161{
1162 assert(xml_info != (XMLTreeInfo *) NULL);
1163 assert((xml_info->signature == MagickCoreSignature) ||
1164 (((XMLTreeRoot *) xml_info)->signature == MagickCoreSignature));
1165 if (IsEventLogging() != MagickFalse)
1166 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1167 return(xml_info->tag);
1168}
1169␌
1170/*
1171%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1172% %
1173% %
1174% %
1175% I n s e r t I n t o T a g X M L T r e e %
1176% %
1177% %
1178% %
1179%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1180%
1181% InsertTagIntoXMLTree() inserts a tag at an offset relative to the start of
1182% the parent tag's character content. This method returns the child tag.
1183%
1184% The format of the InsertTagIntoXMLTree method is:
1185%
1186% XMLTreeInfo *InsertTagIntoXMLTree(XMLTreeInfo *xml_info,
1187% XMLTreeInfo *child,const size_t offset)
1188%
1189% A description of each parameter follows:
1190%
1191% o xml_info: the xml info.
1192%
1193% o child: the child tag.
1194%
1195% o offset: the tag offset.
1196%
1197*/
1198MagickExport XMLTreeInfo *InsertTagIntoXMLTree(XMLTreeInfo *xml_info,
1199 XMLTreeInfo *child,const size_t offset)
1200{
1201 XMLTreeInfo
1202 *head,
1203 *node,
1204 *previous;
1205
1206 child->ordered=(XMLTreeInfo *) NULL;
1207 child->sibling=(XMLTreeInfo *) NULL;
1208 child->next=(XMLTreeInfo *) NULL;
1209 child->offset=offset;
1210 child->parent=xml_info;
1211 if (xml_info->child == (XMLTreeInfo *) NULL)
1212 {
1213 xml_info->child=child;
1214 return(child);
1215 }
1216 head=xml_info->child;
1217 if (head->offset > offset)
1218 {
1219 child->ordered=head;
1220 xml_info->child=child;
1221 }
1222 else
1223 {
1224 node=head;
1225 while ((node->ordered != (XMLTreeInfo *) NULL) &&
1226 (node->ordered->offset <= offset))
1227 node=node->ordered;
1228 child->ordered=node->ordered;
1229 node->ordered=child;
1230 }
1231 previous=(XMLTreeInfo *) NULL;
1232 node=head;
1233 while ((node != (XMLTreeInfo *) NULL) && (strcmp(node->tag,child->tag) != 0))
1234 {
1235 previous=node;
1236 node=node->sibling;
1237 }
1238 if ((node != (XMLTreeInfo *) NULL) && (node->offset <= offset))
1239 {
1240 while ((node->next != (XMLTreeInfo *) NULL) &&
1241 (node->next->offset <= offset))
1242 node=node->next;
1243 child->next=node->next;
1244 node->next=child;
1245 }
1246 else
1247 {
1248 if ((previous != (XMLTreeInfo *) NULL) && (node != (XMLTreeInfo *) NULL))
1249 previous->sibling=node->sibling;
1250 child->next=node;
1251 previous=(XMLTreeInfo *) NULL;
1252 node=head;
1253 while ((node != (XMLTreeInfo *) NULL) && (node->offset <= offset))
1254 {
1255 previous=node;
1256 node=node->sibling;
1257 }
1258 child->sibling=node;
1259 if (previous != (XMLTreeInfo *) NULL)
1260 previous->sibling=child;
1261 }
1262 return(child);
1263}
1264␌
1265/*
1266%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1267% %
1268% %
1269% %
1270% N e w X M L T r e e %
1271% %
1272% %
1273% %
1274%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1275%
1276% NewXMLTree() returns a XMLTreeInfo xml-tree as defined by the specified
1277% XML string.
1278%
1279% The format of the NewXMLTree method is:
1280%
1281% XMLTreeInfo *NewXMLTree(const char *xml,ExceptionInfo *exception)
1282%
1283% A description of each parameter follows:
1284%
1285% o xml: A null-terminated XML string.
1286%
1287% o exception: return any errors or warnings in this structure.
1288%
1289*/
1290
1291static char *ConvertUTF16ToUTF8(const char *content,size_t *length)
1292{
1293 char
1294 *utf8;
1295
1296 int
1297 bits,
1298 byte,
1299 c,
1300 encoding;
1301
1302 size_t
1303 extent;
1304
1305 ssize_t
1306 i,
1307 j;
1308
1309 utf8=(char *) AcquireQuantumMemory(*length+1,sizeof(*utf8));
1310 if (utf8 == (char *) NULL)
1311 return((char *) NULL);
1312 encoding=(*content == '\xFE') ? 1 : (*content == '\xFF') ? 0 : -1;
1313 if (encoding == -1)
1314 {
1315 /*
1316 Already UTF-8.
1317 */
1318 (void) memcpy(utf8,content,*length*sizeof(*utf8));
1319 utf8[*length]='\0';
1320 return(utf8);
1321 }
1322 j=0;
1323 extent=(*length);
1324 for (i=2; i < (ssize_t) (*length-1); i+=2)
1325 {
1326 c=(encoding != 0) ? ((content[i] & 0xff) << 8) | (content[i+1] & 0xff) :
1327 ((content[i+1] & 0xff) << 8) | (content[i] & 0xff);
1328 if ((c >= 0xd800) && (c <= 0xdfff) && ((i+=2) < (ssize_t) (*length-1)))
1329 {
1330 byte=(encoding != 0) ? ((content[i] & 0xff) << 8) |
1331 (content[i+1] & 0xff) : ((content[i+1] & 0xff) << 8) |
1332 (content[i] & 0xff);
1333 c=(((c & 0x3ff) << 10) | (byte & 0x3ff))+0x10000;
1334 }
1335 if ((size_t) (j+MaxTextExtent) > extent)
1336 {
1337 extent=(size_t) j+MaxTextExtent;
1338 utf8=(char *) ResizeQuantumMemory(utf8,extent,sizeof(*utf8));
1339 if (utf8 == (char *) NULL)
1340 return(utf8);
1341 }
1342 if (c < 0x80)
1343 {
1344 utf8[j]=c;
1345 j++;
1346 continue;
1347 }
1348 /*
1349 Multi-byte UTF-8 sequence.
1350 */
1351 byte=c;
1352 for (bits=0; byte != 0; byte/=2)
1353 bits++;
1354 bits=(bits-2)/5;
1355 utf8[j++]=(0xFF << (7-bits)) | (c >> (6*bits));
1356 while (bits != 0)
1357 {
1358 bits--;
1359 utf8[j]=0x80 | ((c >> (6*bits)) & 0x3f);
1360 j++;
1361 }
1362 }
1363 *length=(size_t) j;
1364 utf8=(char *) ResizeQuantumMemory(utf8,(*length+1),sizeof(*utf8));
1365 if (utf8 != (char *) NULL)
1366 utf8[*length]='\0';
1367 return(utf8);
1368}
1369
1370static char *ParseEntities(char *xml,char **entities,int state)
1371{
1372 char
1373 *entity,
1374 *p,
1375 *q;
1376
1377 int
1378 byte,
1379 c;
1380
1381 size_t
1382 extent,
1383 length;
1384
1385 ssize_t
1386 i,
1387 offset;
1388
1389 /*
1390 Normalize line endings.
1391 */
1392 p=xml;
1393 q=xml;
1394 for ( ; *xml != '\0'; xml++)
1395 while (*xml == '\r')
1396 {
1397 *(xml++)='\n';
1398 if (*xml == '\n')
1399 (void) memmove(xml,xml+1,strlen(xml));
1400 }
1401 for (xml=p; ; )
1402 {
1403 while ((*xml != '\0') && (*xml != '&') && ((*xml != '%') ||
1404 (state != '%')) && (isspace((int) ((unsigned char) *xml)) == 0))
1405 xml++;
1406 if (*xml == '\0')
1407 break;
1408 /*
1409 States include:
1410 '&' for general entity decoding
1411 '%' for parameter entity decoding
1412 'c' for CDATA sections
1413 ' ' for attributes normalization
1414 '*' for non-CDATA attributes normalization
1415 */
1416 if ((state != 'c') && (strncmp(xml,"&#",2) == 0))
1417 {
1418 /*
1419 Character reference.
1420 */
1421 if (xml[2] != 'x')
1422 c=strtol(xml+2,&entity,10); /* base 10 */
1423 else
1424 c=strtol(xml+3,&entity,16); /* base 16 */
1425 if ((c == 0) || (*entity != ';'))
1426 {
1427 /*
1428 Not a character reference.
1429 */
1430 xml++;
1431 continue;
1432 }
1433 if (c < 0x80)
1434 *(xml++)=c;
1435 else
1436 {
1437 /*
1438 Multi-byte UTF-8 sequence.
1439 */
1440 byte=c;
1441 for (i=0; byte != 0; byte/=2)
1442 i++;
1443 i=(i-2)/5;
1444 *xml=(char) ((0xFF << (7-i)) | (c >> (6*i)));
1445 xml++;
1446 while (i != 0)
1447 {
1448 i--;
1449 *xml=(char) (0x80 | ((c >> (6*i)) & 0x3F));
1450 xml++;
1451 }
1452 }
1453 (void) memmove(xml,strchr(xml,';')+1,strlen(strchr(xml,';')));
1454 }
1455 else
1456 if (((*xml == '&') && ((state == '&') || (state == ' ') ||
1457 (state == '*'))) || ((state == '%') && (*xml == '%')))
1458 {
1459 /*
1460 Find entity in the list.
1461 */
1462 i=0;
1463 while ((entities[i] != (char *) NULL) &&
1464 (strncmp(xml+1,entities[i],strlen(entities[i])) != 0))
1465 i+=2;
1466 if (entities[i++] == (char *) NULL)
1467 xml++;
1468 else
1469 if (entities[i] != (char *) NULL)
1470 {
1471 /*
1472 Found a match.
1473 */
1474 length=strlen(entities[i]);
1475 entity=strchr(xml,';');
1476 if ((entity != (char *) NULL) &&
1477 ((length-1L) >= (size_t) (entity-xml)))
1478 {
1479 offset=(ssize_t) (xml-p);
1480 extent=(size_t) (offset+length+strlen(entity));
1481 if (p != q)
1482 {
1483 p=(char *) ResizeQuantumMemory(p,extent+1,sizeof(*p));
1484 if (p == (char *) NULL)
1485 ThrowFatalException(ResourceLimitFatalError,
1486 "MemoryAllocationFailed");
1487 p[extent]='\0';
1488 }
1489 else
1490 {
1491 char
1492 *extent_xml;
1493
1494 extent_xml=(char *) AcquireQuantumMemory(extent+1,
1495 sizeof(*extent_xml));
1496 if (extent_xml != (char *) NULL)
1497 {
1498 memset(extent_xml,0,extent*sizeof(*extent_xml));
1499 (void) CopyMagickString(extent_xml,p,extent*
1500 sizeof(*extent_xml));
1501 }
1502 p=extent_xml;
1503 }
1504 if (p == (char *) NULL)
1505 ThrowFatalException(ResourceLimitFatalError,
1506 "MemoryAllocationFailed");
1507 xml=p+offset;
1508 entity=strchr(xml,';');
1509 }
1510 if (entity != (char *) NULL)
1511 (void) memmove(xml+length,entity+1,strlen(entity));
1512 (void) memcpy(xml,entities[i],length);
1513 }
1514 }
1515 else
1516 if (((state == ' ') || (state == '*')) &&
1517 (isspace((int) ((unsigned char) *xml) != 0)))
1518 *(xml++)=' ';
1519 else
1520 xml++;
1521 }
1522 if (state == '*')
1523 {
1524
1525 /*
1526 Normalize spaces for non-CDATA attributes.
1527 */
1528 for (xml=p; *xml != '\0'; xml++)
1529 {
1530 char
1531 accept[] = " ";
1532
1533 i=(ssize_t) strspn(xml,accept);
1534 if (i != 0)
1535 (void) memmove(xml,xml+i,strlen(xml+i)+1);
1536 while ((*xml != '\0') && (*xml != ' '))
1537 xml++;
1538 if (*xml == '\0')
1539 break;
1540 }
1541 xml--;
1542 if ((xml >= p) && (*xml == ' '))
1543 *xml='\0';
1544 }
1545 return(p == q ? ConstantString(p) : p);
1546}
1547
1548static void ParseCharacterContent(XMLTreeRoot *root,char *xml,
1549 const size_t length,const char state)
1550{
1551 XMLTreeInfo
1552 *xml_info;
1553
1554 xml_info=root->node;
1555 if ((xml_info == (XMLTreeInfo *) NULL) || (xml_info->tag == (char *) NULL) ||
1556 (length == 0))
1557 return;
1558 xml[length]='\0';
1559 xml=ParseEntities(xml,root->entities,state);
1560 if ((xml_info->content != (char *) NULL) && (*xml_info->content != '\0'))
1561 {
1562 (void) ConcatenateString(&xml_info->content,xml);
1563 xml=DestroyString(xml);
1564 }
1565 else
1566 {
1567 if (xml_info->content != (char *) NULL)
1568 xml_info->content=DestroyString(xml_info->content);
1569 xml_info->content=xml;
1570 }
1571}
1572
1573static XMLTreeInfo *ParseCloseTag(XMLTreeRoot *root,char *tag,
1574 ExceptionInfo *exception)
1575{
1576 if ((root->node == (XMLTreeInfo *) NULL) ||
1577 (root->node->tag == (char *) NULL) || (strcmp(tag,root->node->tag) != 0))
1578 {
1579 (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
1580 "ParseError","unexpected closing tag </%s>",tag);
1581 return(&root->root);
1582 }
1583 root->node=root->node->parent;
1584 return((XMLTreeInfo *) NULL);
1585}
1586
1587static MagickBooleanType ValidateEntities(char *tag,char *xml,
1588 const size_t depth,char **entities)
1589{
1590 ssize_t
1591 i;
1592
1593 /*
1594 Check for circular entity references.
1595 */
1596 if (depth > MagickMaxRecursionDepth)
1597 return(MagickFalse);
1598 for ( ; ; xml++)
1599 {
1600 while ((*xml != '\0') && (*xml != '&'))
1601 xml++;
1602 if (*xml == '\0')
1603 return(MagickTrue);
1604 if (strncmp(xml+1,tag,strlen(tag)) == 0)
1605 return(MagickFalse);
1606 i=0;
1607 while ((entities[i] != (char *) NULL) &&
1608 (strncmp(entities[i],xml+1,strlen(entities[i])) == 0))
1609 i+=2;
1610 if ((entities[i] != (char *) NULL) &&
1611 (ValidateEntities(tag,entities[i+1],depth+1,entities) == 0))
1612 return(MagickFalse);
1613 }
1614}
1615
1616static void ParseProcessingInstructions(XMLTreeRoot *root,char *xml,
1617 size_t length)
1618{
1619 char
1620 *target;
1621
1622 ssize_t
1623 i,
1624 j;
1625
1626 target=xml;
1627 xml[length]='\0';
1628 xml+=strcspn(xml,XMLWhitespace);
1629 if (*xml != '\0')
1630 {
1631 *xml='\0';
1632 xml+=strspn(xml+1,XMLWhitespace)+1;
1633 }
1634 if (strcmp(target,"xml") == 0)
1635 {
1636 xml=strstr(xml,"standalone");
1637 if ((xml != (char *) NULL) &&
1638 (strncmp(xml+strspn(xml+10,XMLWhitespace "='\"")+10,"yes",3) == 0))
1639 root->standalone=MagickTrue;
1640 return;
1641 }
1642 if (root->processing_instructions[0] == (char **) NULL)
1643 {
1644 root->processing_instructions=(char ***) AcquireMagickMemory(sizeof(
1645 *root->processing_instructions));
1646 if (root->processing_instructions ==(char ***) NULL)
1647 ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
1648 *root->processing_instructions=(char **) NULL;
1649 }
1650 i=0;
1651 while ((root->processing_instructions[i] != (char **) NULL) &&
1652 (strcmp(target,root->processing_instructions[i][0]) != 0))
1653 i++;
1654 if (root->processing_instructions[i] == (char **) NULL)
1655 {
1656 root->processing_instructions=(char ***) ResizeQuantumMemory(
1657 root->processing_instructions,(size_t) (i+2),
1658 sizeof(*root->processing_instructions));
1659 if (root->processing_instructions == (char ***) NULL)
1660 ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
1661 root->processing_instructions[i]=(char **) AcquireQuantumMemory(3,
1662 sizeof(**root->processing_instructions));
1663 if (root->processing_instructions[i] == (char **) NULL)
1664 ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
1665 root->processing_instructions[i+1]=(char **) NULL;
1666 root->processing_instructions[i][0]=ConstantString(target);
1667 root->processing_instructions[i][1]=(char *)
1668 root->processing_instructions[i+1];
1669 root->processing_instructions[i+1]=(char **) NULL;
1670 root->processing_instructions[i][2]=ConstantString("");
1671 }
1672 j=1;
1673 while (root->processing_instructions[i][j] != (char *) NULL)
1674 j++;
1675 root->processing_instructions[i]=(char **) ResizeQuantumMemory(
1676 root->processing_instructions[i],(size_t) (j+3),
1677 sizeof(**root->processing_instructions));
1678 if (root->processing_instructions[i] == (char **) NULL)
1679 ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
1680 root->processing_instructions[i][j+2]=(char *) ResizeQuantumMemory(
1681 root->processing_instructions[i][j+1],(size_t) (j+1),
1682 sizeof(***root->processing_instructions));
1683 if (root->processing_instructions[i][j+2] == (char *) NULL)
1684 ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
1685 (void) CopyMagickString(root->processing_instructions[i][j+2]+j-1,
1686 root->root.tag != (char *) NULL ? ">" : "<",2);
1687 root->processing_instructions[i][j]=ConstantString(xml);
1688 root->processing_instructions[i][j+1]=(char *) NULL;
1689}
1690
1691static MagickBooleanType ParseInternalDoctype(XMLTreeRoot *root,char *xml,
1692 size_t length,ExceptionInfo *exception)
1693{
1694 char
1695 *c,
1696 **entities,
1697 *n,
1698 **predefined_entities,
1699 q,
1700 *t,
1701 *v;
1702
1703 ssize_t
1704 i,
1705 j;
1706
1707 n=(char *) NULL;
1708 predefined_entities=(char **) AcquireMagickMemory(sizeof(sentinel));
1709 if (predefined_entities == (char **) NULL)
1710 ThrowFatalException(ResourceLimitError,"MemoryAllocationFailed");
1711 (void) memcpy(predefined_entities,sentinel,sizeof(sentinel));
1712 for (xml[length]='\0'; xml != (char *) NULL; )
1713 {
1714 while ((*xml != '\0') && (*xml != '<') && (*xml != '%'))
1715 xml++;
1716 if (*xml == '\0')
1717 break;
1718 if ((strlen(xml) > 9) && (strncmp(xml,"<!ENTITY",8) == 0))
1719 {
1720 /*
1721 Parse entity definitions.
1722 */
1723 if (strspn(xml+8,XMLWhitespace) == 0)
1724 break;
1725 xml+=strspn(xml+8,XMLWhitespace)+8;
1726 c=xml;
1727 n=xml+strspn(xml,XMLWhitespace "%");
1728 if ((isalpha((int) ((unsigned char) *n)) == 0) && (*n != '_'))
1729 break;
1730 xml=n+strcspn(n,XMLWhitespace);
1731 if (*xml == '\0')
1732 break;
1733 *xml=';';
1734 v=xml+strspn(xml+1,XMLWhitespace)+1;
1735 q=(*v);
1736 v++;
1737 if ((q != '"') && (q != '\''))
1738 {
1739 /*
1740 Skip externals.
1741 */
1742 xml=strchr(xml,'>');
1743 continue;
1744 }
1745 entities=(*c == '%') ? predefined_entities : root->entities;
1746 for (i=0; entities[i] != (char *) NULL; i++) ;
1747 entities=(char **) ResizeQuantumMemory(entities,(size_t) (i+3),
1748 sizeof(*entities));
1749 if (entities == (char **) NULL)
1750 ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
1751 if (*c == '%')
1752 predefined_entities=entities;
1753 else
1754 root->entities=entities;
1755 xml++;
1756 *xml='\0';
1757 xml=strchr(v,q);
1758 if (xml != (char *) NULL)
1759 {
1760 *xml='\0';
1761 xml++;
1762 }
1763 entities[i+1]=ParseEntities(v,predefined_entities,'%');
1764 entities[i+2]=(char *) NULL;
1765 if (ValidateEntities(n,entities[i+1],0,entities) != MagickFalse)
1766 entities[i]=n;
1767 else
1768 {
1769 if (entities[i+1] != v)
1770 entities[i+1]=DestroyString(entities[i+1]);
1771 (void) ThrowMagickException(exception,GetMagickModule(),
1772 OptionWarning,"ParseError","circular entity declaration &%s",n);
1773 predefined_entities=(char **) RelinquishMagickMemory(
1774 predefined_entities);
1775 return(MagickFalse);
1776 }
1777 }
1778 else
1779 if (strncmp(xml,"<!ATTLIST",9) == 0)
1780 {
1781 /*
1782 Parse default attributes.
1783 */
1784 t=xml+strspn(xml+9,XMLWhitespace)+9;
1785 if (*t == '\0')
1786 {
1787 (void) ThrowMagickException(exception,GetMagickModule(),
1788 OptionWarning,"ParseError","unclosed <!ATTLIST");
1789 predefined_entities=(char **) RelinquishMagickMemory(
1790 predefined_entities);
1791 return(MagickFalse);
1792 }
1793 xml=t+strcspn(t,XMLWhitespace ">");
1794 if (*xml == '>')
1795 continue;
1796 *xml='\0';
1797 i=0;
1798 while ((root->attributes[i] != (char **) NULL) &&
1799 (n != (char *) NULL) &&
1800 (strcmp(n,root->attributes[i][0]) != 0))
1801 i++;
1802 while ((*(n=xml+strspn(xml+1,XMLWhitespace)+1) != '\0') &&
1803 (*n != '>'))
1804 {
1805 xml=n+strcspn(n,XMLWhitespace);
1806 if (*xml != '\0')
1807 *xml='\0';
1808 else
1809 {
1810 (void) ThrowMagickException(exception,GetMagickModule(),
1811 OptionWarning,"ParseError","malformed <!ATTLIST");
1812 predefined_entities=(char **) RelinquishMagickMemory(
1813 predefined_entities);
1814 return(MagickFalse);
1815 }
1816 xml+=strspn(xml+1,XMLWhitespace)+1;
1817 c=(char *) (strncmp(xml,"CDATA",5) != 0 ? "*" : " ");
1818 if (strncmp(xml,"NOTATION",8) == 0)
1819 xml+=strspn(xml+8,XMLWhitespace)+8;
1820 xml=(*xml == '(') ? strchr(xml,')') : xml+
1821 strcspn(xml,XMLWhitespace);
1822 if (xml == (char *) NULL)
1823 {
1824 (void) ThrowMagickException(exception,GetMagickModule(),
1825 OptionWarning,"ParseError","malformed <!ATTLIST");
1826 predefined_entities=(char **) RelinquishMagickMemory(
1827 predefined_entities);
1828 return(MagickFalse);
1829 }
1830 xml+=strspn(xml,XMLWhitespace ")");
1831 if (strncmp(xml,"#FIXED",6) == 0)
1832 xml+=strspn(xml+6,XMLWhitespace)+6;
1833 if (*xml == '#')
1834 {
1835 xml+=strcspn(xml,XMLWhitespace ">")-1;
1836 if (*c == ' ')
1837 continue;
1838 v=(char *) NULL;
1839 }
1840 else
1841 if (((*xml == '"') || (*xml == '\'')) &&
1842 ((xml=strchr(v=xml+1,*xml)) != (char *) NULL))
1843 *xml='\0';
1844 else
1845 {
1846 (void) ThrowMagickException(exception,GetMagickModule(),
1847 OptionWarning,"ParseError","malformed <!ATTLIST");
1848 predefined_entities=(char **) RelinquishMagickMemory(
1849 predefined_entities);
1850 return(MagickFalse);
1851 }
1852 if (root->attributes[i] == (char **) NULL)
1853 {
1854 /*
1855 New attribute tag.
1856 */
1857 if (i == 0)
1858 root->attributes=(char ***) AcquireQuantumMemory(2,
1859 sizeof(*root->attributes));
1860 else
1861 root->attributes=(char ***) ResizeQuantumMemory(
1862 root->attributes,(size_t) (i+2),
1863 sizeof(*root->attributes));
1864 if (root->attributes == (char ***) NULL)
1865 ThrowFatalException(ResourceLimitFatalError,
1866 "MemoryAllocationFailed");
1867 root->attributes[i]=(char **) AcquireQuantumMemory(2,
1868 sizeof(**root->attributes));
1869 if (root->attributes[i] == (char **) NULL)
1870 ThrowFatalException(ResourceLimitFatalError,
1871 "MemoryAllocationFailed");
1872 root->attributes[i][0]=ConstantString(t);
1873 root->attributes[i][1]=(char *) NULL;
1874 root->attributes[i+1]=(char **) NULL;
1875 }
1876 for (j=1; root->attributes[i][j] != (char *) NULL; j+=3) ;
1877 root->attributes[i]=(char **) ResizeQuantumMemory(
1878 root->attributes[i],(size_t) (j+4),sizeof(**root->attributes));
1879 if (root->attributes[i] == (char **) NULL)
1880 ThrowFatalException(ResourceLimitFatalError,
1881 "MemoryAllocationFailed");
1882 root->attributes[i][j+3]=(char *) NULL;
1883 root->attributes[i][j+2]=ConstantString(c);
1884 root->attributes[i][j+1]=(char *) NULL;
1885 if (v != (char *) NULL)
1886 root->attributes[i][j+1]=ParseEntities(v,root->entities,*c);
1887 root->attributes[i][j]=ConstantString(n);
1888 }
1889 }
1890 else
1891 if (strncmp(xml, "<!--", 4) == 0)
1892 xml=strstr(xml+4,"-->");
1893 else
1894 if (strncmp(xml,"<?", 2) == 0)
1895 {
1896 c=xml+2;
1897 xml=strstr(c,"?>");
1898 if (xml != (char *) NULL)
1899 {
1900 ParseProcessingInstructions(root,c,(size_t) (xml-c));
1901 xml++;
1902 }
1903 }
1904 else
1905 if (*xml == '<')
1906 xml=strchr(xml,'>');
1907 else
1908 if ((*(xml++) == '%') && (root->standalone == MagickFalse))
1909 break;
1910 }
1911 predefined_entities=(char **) RelinquishMagickMemory(predefined_entities);
1912 return(MagickTrue);
1913}
1914
1915static void ParseOpenTag(XMLTreeRoot *root,char *tag,char **attributes)
1916{
1917 XMLTreeInfo
1918 *xml_info;
1919
1920 xml_info=root->node;
1921 if (xml_info->tag == (char *) NULL)
1922 xml_info->tag=ConstantString(tag);
1923 else
1924 xml_info=AddChildToXMLTree(xml_info,tag,strlen(xml_info->content));
1925 if (xml_info != (XMLTreeInfo *) NULL)
1926 xml_info->attributes=attributes;
1927 root->node=xml_info;
1928}
1929
1930static const char
1931 *skip_tags[3] =
1932 {
1933 "rdf:Bag",
1934 "rdf:Seq",
1935 (const char *) NULL
1936 };
1937
1938static inline MagickBooleanType IsSkipTag(const char *tag)
1939{
1940 ssize_t
1941 i;
1942
1943 i=0;
1944 while (skip_tags[i] != (const char *) NULL)
1945 {
1946 if (LocaleCompare(tag,skip_tags[i]) == 0)
1947 return(MagickTrue);
1948 i++;
1949 }
1950 return(MagickFalse);
1951}
1952
1953MagickExport XMLTreeInfo *NewXMLTree(const char *xml,ExceptionInfo *exception)
1954{
1955 char
1956 **attribute,
1957 **attributes,
1958 *p,
1959 *tag,
1960 *utf8;
1961
1962 int
1963 c,
1964 terminal;
1965
1966 MagickBooleanType
1967 status;
1968
1969 size_t
1970 ignore_depth,
1971 length;
1972
1973 ssize_t
1974 i,
1975 j,
1976 l;
1977
1978 XMLTreeRoot
1979 *root;
1980
1981 /*
1982 Convert xml-string to UTF8.
1983 */
1984 if ((xml == (const char *) NULL) || (strlen(xml) == 0))
1985 {
1986 (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
1987 "ParseError","root tag missing");
1988 return((XMLTreeInfo *) NULL);
1989 }
1990 root=(XMLTreeRoot *) NewXMLTreeTag((char *) NULL);
1991 length=strlen(xml);
1992 utf8=ConvertUTF16ToUTF8(xml,&length);
1993 if (utf8 == (char *) NULL)
1994 {
1995 (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
1996 "ParseError","UTF16 to UTF8 failed");
1997 return((XMLTreeInfo *) NULL);
1998 }
1999 if (length == 0)
2000 {
2001 utf8=DestroyString(utf8);
2002 (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
2003 "ParseError","root tag missing");
2004 return((XMLTreeInfo *) NULL);
2005 }
2006 terminal=utf8[length-1];
2007 utf8[length-1]='\0';
2008 p=utf8;
2009 while ((*p != '\0') && (*p != '<'))
2010 p++;
2011 if (*p == '\0')
2012 {
2013 (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
2014 "ParseError","root tag missing");
2015 utf8=DestroyString(utf8);
2016 return((XMLTreeInfo *) NULL);
2017 }
2018 attribute=(char **) NULL;
2019 l=0;
2020 ignore_depth=0;
2021 for (p++; ; p++)
2022 {
2023 attributes=(char **) sentinel;
2024 tag=p;
2025 c=(*p);
2026 if ((isalpha((int) ((unsigned char) *p)) !=0) || (*p == '_') ||
2027 (*p == ':') || (c < '\0'))
2028 {
2029 /*
2030 Tag.
2031 */
2032 if (root->node == (XMLTreeInfo *) NULL)
2033 {
2034 (void) ThrowMagickException(exception,GetMagickModule(),
2035 OptionWarning,"ParseError","root tag missing");
2036 utf8=DestroyString(utf8);
2037 return(&root->root);
2038 }
2039 p+=(ptrdiff_t) strcspn(p,XMLWhitespace "/>");
2040 while (isspace((int) ((unsigned char) *p)) != 0)
2041 *p++='\0';
2042 if (((isalpha((int) ((unsigned char) *p)) != 0) || (*p == '_')) &&
2043 (ignore_depth == 0))
2044 {
2045 if ((*p != '\0') && (*p != '/') && (*p != '>'))
2046 {
2047 /*
2048 Find tag in default attributes list.
2049 */
2050 i=0;
2051 while ((root->attributes[i] != (char **) NULL) &&
2052 (strcmp(root->attributes[i][0],tag) != 0))
2053 i++;
2054 attribute=root->attributes[i];
2055 }
2056 for (l=0; (*p != '\0') && (*p != '/') && (*p != '>'); l+=2)
2057 {
2058 /*
2059 Attribute.
2060 */
2061 if (l == 0)
2062 attributes=(char **) AcquireQuantumMemory(4,
2063 sizeof(*attributes));
2064 else
2065 attributes=(char **) ResizeQuantumMemory(attributes,
2066 (size_t) (l+4),sizeof(*attributes));
2067 if (attributes == (char **) NULL)
2068 {
2069 (void) ThrowMagickException(exception,GetMagickModule(),
2070 ResourceLimitError,"MemoryAllocationFailed","`%s'","");
2071 utf8=DestroyString(utf8);
2072 return(&root->root);
2073 }
2074 attributes[l+2]=(char *) NULL;
2075 attributes[l+1]=(char *) NULL;
2076 attributes[l]=p;
2077 p+=(ptrdiff_t) strcspn(p,XMLWhitespace "=/>");
2078 if ((*p != '=') && (isspace((int) ((unsigned char) *p)) == 0))
2079 attributes[l]=ConstantString("");
2080 else
2081 {
2082 *p++='\0';
2083 p+=(ptrdiff_t) strspn(p,XMLWhitespace "=");
2084 c=(*p);
2085 if ((c == '"') || (c == '\''))
2086 {
2087 /*
2088 Attributes value.
2089 */
2090 p++;
2091 attributes[l+1]=p;
2092 while ((*p != '\0') && (*p != c))
2093 p++;
2094 if (*p != '\0')
2095 *p++='\0';
2096 else
2097 {
2098 attributes[l]=ConstantString("");
2099 attributes[l+1]=ConstantString("");
2100 (void) DestroyXMLTreeAttributes(attributes);
2101 (void) ThrowMagickException(exception,
2102 GetMagickModule(),OptionWarning,"ParseError",
2103 "missing %c",c);
2104 utf8=DestroyString(utf8);
2105 return(&root->root);
2106 }
2107 j=1;
2108 while ((attribute != (char **) NULL) &&
2109 (attribute[j] != (char *) NULL) &&
2110 (strcmp(attribute[j],attributes[l]) != 0))
2111 j+=3;
2112 attributes[l+1]=ParseEntities(attributes[l+1],
2113 root->entities,(attribute != (char **) NULL) &&
2114 (attribute[j] != (char *) NULL) ? *attribute[j+2] :
2115 ' ');
2116 }
2117 attributes[l]=ConstantString(attributes[l]);
2118 }
2119 while (isspace((int) ((unsigned char) *p)) != 0)
2120 p++;
2121 }
2122 }
2123 else
2124 {
2125 while((*p != '\0') && (*p != '/') && (*p != '>'))
2126 p++;
2127 }
2128 if (*p == '/')
2129 {
2130 /*
2131 Self closing tag.
2132 */
2133 *p++='\0';
2134 if (((*p != '\0') && (*p != '>')) ||
2135 ((*p == '\0') && (terminal != '>')))
2136 {
2137 if (l != 0)
2138 (void) DestroyXMLTreeAttributes(attributes);
2139 (void) ThrowMagickException(exception,GetMagickModule(),
2140 OptionWarning,"ParseError","missing >");
2141 utf8=DestroyString(utf8);
2142 return(&root->root);
2143 }
2144 if ((ignore_depth != 0) || (IsSkipTag(tag) != MagickFalse))
2145 (void) DestroyXMLTreeAttributes(attributes);
2146 else
2147 {
2148 ParseOpenTag(root,tag,attributes);
2149 (void) ParseCloseTag(root,tag,exception);
2150 }
2151 }
2152 else
2153 {
2154 c=(*p);
2155 if ((*p == '>') || ((*p == '\0') && (terminal == '>')))
2156 {
2157 *p='\0';
2158 if ((ignore_depth == 0) && (IsSkipTag(tag) == MagickFalse))
2159 ParseOpenTag(root,tag,attributes);
2160 else
2161 {
2162 ignore_depth++;
2163 (void) DestroyXMLTreeAttributes(attributes);
2164 }
2165 *p=c;
2166 }
2167 else
2168 {
2169 if (l != 0)
2170 (void) DestroyXMLTreeAttributes(attributes);
2171 (void) ThrowMagickException(exception,GetMagickModule(),
2172 OptionWarning,"ParseError","missing >");
2173 utf8=DestroyString(utf8);
2174 return(&root->root);
2175 }
2176 }
2177 }
2178 else
2179 if (*p == '/')
2180 {
2181 /*
2182 Close tag.
2183 */
2184 tag=p+1;
2185 p+=(ptrdiff_t) strcspn(tag,XMLWhitespace ">")+1;
2186 c=(*p);
2187 if ((c == '\0') && (terminal != '>'))
2188 {
2189 (void) ThrowMagickException(exception,GetMagickModule(),
2190 OptionWarning,"ParseError","missing >");
2191 utf8=DestroyString(utf8);
2192 return(&root->root);
2193 }
2194 *p='\0';
2195 if ((ignore_depth == 0) &&
2196 (ParseCloseTag(root,tag,exception) != (XMLTreeInfo *) NULL))
2197 {
2198 utf8=DestroyString(utf8);
2199 return(&root->root);
2200 }
2201 if (ignore_depth > 0)
2202 ignore_depth--;
2203 *p=c;
2204 if (isspace((int) ((unsigned char) *p)) != 0)
2205 p+=(ptrdiff_t) strspn(p,XMLWhitespace);
2206 }
2207 else
2208 if (strncmp(p,"!--",3) == 0)
2209 {
2210 /*
2211 Comment.
2212 */
2213 p=strstr(p+3,"--");
2214 if ((p == (char *) NULL) || ((*(p+=2) != '>') && (*p != '\0')) ||
2215 ((*p == '\0') && (terminal != '>')))
2216 {
2217 (void) ThrowMagickException(exception,GetMagickModule(),
2218 OptionWarning,"ParseError","unclosed <!--");
2219 utf8=DestroyString(utf8);
2220 return(&root->root);
2221 }
2222 }
2223 else
2224 if (strncmp(p,"![CDATA[",8) == 0)
2225 {
2226 /*
2227 Cdata.
2228 */
2229 p=strstr(p,"]]>");
2230 if (p != (char *) NULL)
2231 {
2232 p+=(ptrdiff_t) 2;
2233 if (ignore_depth == 0)
2234 ParseCharacterContent(root,tag+8,(size_t) (p-tag-10),'c');
2235 }
2236 else
2237 {
2238 (void) ThrowMagickException(exception,GetMagickModule(),
2239 OptionWarning,"ParseError","unclosed <![CDATA[");
2240 utf8=DestroyString(utf8);
2241 return(&root->root);
2242 }
2243 }
2244 else
2245 if (strncmp(p,"!DOCTYPE",8) == 0)
2246 {
2247 /*
2248 DTD.
2249 */
2250 for (l=0; (*p != '\0') && (((l == 0) && (*p != '>')) ||
2251 ((l != 0) && ((*p != ']') ||
2252 (*(p+strspn(p+1,XMLWhitespace)+1) != '>'))));
2253 l=(ssize_t) ((*p == '[') ? 1 : l))
2254 p+=(ptrdiff_t) strcspn(p+1,"[]>")+1;
2255 if ((*p == '\0') && (terminal != '>'))
2256 {
2257 (void) ThrowMagickException(exception,GetMagickModule(),
2258 OptionWarning,"ParseError","unclosed <!DOCTYPE");
2259 utf8=DestroyString(utf8);
2260 return(&root->root);
2261 }
2262 if (l != 0)
2263 tag=strchr(tag,'[')+1;
2264 if (l != 0)
2265 {
2266 status=ParseInternalDoctype(root,tag,(size_t) (p-tag),
2267 exception);
2268 if (status == MagickFalse)
2269 {
2270 utf8=DestroyString(utf8);
2271 return(&root->root);
2272 }
2273 p++;
2274 }
2275 }
2276 else
2277 if (*p == '?')
2278 {
2279 /*
2280 Processing instructions.
2281 */
2282 do
2283 {
2284 p=strchr(p,'?');
2285 if (p == (char *) NULL)
2286 break;
2287 p++;
2288 } while ((*p != '\0') && (*p != '>'));
2289 if ((p == (char *) NULL) || ((*p == '\0') &&
2290 (terminal != '>')))
2291 {
2292 (void) ThrowMagickException(exception,GetMagickModule(),
2293 OptionWarning,"ParseError","unclosed <?");
2294 utf8=DestroyString(utf8);
2295 return(&root->root);
2296 }
2297 ParseProcessingInstructions(root,tag+1,(size_t) (p-tag-2));
2298 }
2299 else
2300 {
2301 (void) ThrowMagickException(exception,GetMagickModule(),
2302 OptionWarning,"ParseError","unexpected <");
2303 utf8=DestroyString(utf8);
2304 return(&root->root);
2305 }
2306 if ((p == (char *) NULL) || (*p == '\0'))
2307 break;
2308 *p++='\0';
2309 tag=p;
2310 if ((*p != '\0') && (*p != '<'))
2311 {
2312 /*
2313 Tag character content.
2314 */
2315 while ((*p != '\0') && (*p != '<'))
2316 p++;
2317 if (*p == '\0')
2318 break;
2319 if (ignore_depth == 0)
2320 ParseCharacterContent(root,tag,(size_t) (p-tag),'&');
2321 }
2322 else
2323 if (*p == '\0')
2324 break;
2325 }
2326 utf8=DestroyString(utf8);
2327 if (root->node == (XMLTreeInfo *) NULL)
2328 return(&root->root);
2329 if (root->node->tag == (char *) NULL)
2330 {
2331 (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
2332 "ParseError","root tag missing");
2333 return(&root->root);
2334 }
2335 (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
2336 "ParseError","unclosed tag: `%s'",root->node->tag);
2337 return(&root->root);
2338}
2339␌
2340/*
2341%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2342% %
2343% %
2344% %
2345% N e w X M L T r e e T a g %
2346% %
2347% %
2348% %
2349%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2350%
2351% NewXMLTreeTag() returns a new empty xml structure for the xml-tree tag.
2352%
2353% The format of the NewXMLTreeTag method is:
2354%
2355% XMLTreeInfo *NewXMLTreeTag(const char *tag)
2356%
2357% A description of each parameter follows:
2358%
2359% o tag: the tag.
2360%
2361*/
2362MagickExport XMLTreeInfo *NewXMLTreeTag(const char *tag)
2363{
2364 static const char
2365 *predefined_entities[NumberPredefinedEntities+1] =
2366 {
2367 "lt;", "&#60;", "gt;", "&#62;", "quot;", "&#34;",
2368 "apos;", "&#39;", "amp;", "&#38;", (char *) NULL
2369 };
2370
2371 XMLTreeRoot
2372 *root;
2373
2374 root=(XMLTreeRoot *) AcquireCriticalMemory(sizeof(*root));
2375 (void) memset(root,0,sizeof(*root));
2376 root->root.tag=(char *) NULL;
2377 if (tag != (char *) NULL)
2378 root->root.tag=ConstantString(tag);
2379 root->node=(&root->root);
2380 root->root.content=ConstantString("");
2381 root->entities=(char **) AcquireCriticalMemory(sizeof(predefined_entities));
2382 (void) memcpy(root->entities,predefined_entities,sizeof(predefined_entities));
2383 root->root.attributes=sentinel;
2384 root->attributes=(char ***) root->root.attributes;
2385 root->processing_instructions=(char ***) root->root.attributes;
2386 root->debug=IsEventLogging();
2387 root->signature=MagickCoreSignature;
2388 return(&root->root);
2389}
2390␌
2391/*
2392%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2393% %
2394% %
2395% %
2396% P r u n e T a g F r o m X M L T r e e %
2397% %
2398% %
2399% %
2400%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2401%
2402% PruneTagFromXMLTree() prunes a tag from the xml-tree along with all its
2403% subtags.
2404%
2405% The format of the PruneTagFromXMLTree method is:
2406%
2407% XMLTreeInfo *PruneTagFromXMLTree(XMLTreeInfo *xml_info)
2408%
2409% A description of each parameter follows:
2410%
2411% o xml_info: the xml info.
2412%
2413*/
2414MagickExport XMLTreeInfo *PruneTagFromXMLTree(XMLTreeInfo *xml_info)
2415{
2416 XMLTreeInfo
2417 *node;
2418
2419 assert(xml_info != (XMLTreeInfo *) NULL);
2420 assert((xml_info->signature == MagickCoreSignature) ||
2421 (((XMLTreeRoot *) xml_info)->signature == MagickCoreSignature));
2422 if (IsEventLogging() != MagickFalse)
2423 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2424 if (xml_info->next != (XMLTreeInfo *) NULL)
2425 xml_info->next->sibling=xml_info->sibling;
2426 if (xml_info->parent != (XMLTreeInfo *) NULL)
2427 {
2428 node=xml_info->parent->child;
2429 if (node == xml_info)
2430 xml_info->parent->child=xml_info->ordered;
2431 else
2432 {
2433 while (node->ordered != xml_info)
2434 node=node->ordered;
2435 node->ordered=node->ordered->ordered;
2436 node=xml_info->parent->child;
2437 if (strcmp(node->tag,xml_info->tag) != 0)
2438 {
2439 while (strcmp(node->sibling->tag,xml_info->tag) != 0)
2440 node=node->sibling;
2441 if (node->sibling != xml_info)
2442 node=node->sibling;
2443 else
2444 node->sibling=(xml_info->next != (XMLTreeInfo *) NULL) ?
2445 xml_info->next : node->sibling->sibling;
2446 }
2447 while ((node->next != (XMLTreeInfo *) NULL) &&
2448 (node->next != xml_info))
2449 node=node->next;
2450 if (node->next != (XMLTreeInfo *) NULL)
2451 node->next=node->next->next;
2452 }
2453 }
2454 xml_info->ordered=(XMLTreeInfo *) NULL;
2455 xml_info->sibling=(XMLTreeInfo *) NULL;
2456 xml_info->next=(XMLTreeInfo *) NULL;
2457 return(xml_info);
2458}
2459␌
2460/*
2461%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2462% %
2463% %
2464% %
2465% S e t X M L T r e e A t t r i b u t e %
2466% %
2467% %
2468% %
2469%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2470%
2471% SetXMLTreeAttribute() sets the tag attributes or adds a new attribute if not
2472% found. A value of NULL removes the specified attribute.
2473%
2474% The format of the SetXMLTreeAttribute method is:
2475%
2476% XMLTreeInfo *SetXMLTreeAttribute(XMLTreeInfo *xml_info,const char *tag,
2477% const char *value)
2478%
2479% A description of each parameter follows:
2480%
2481% o xml_info: the xml info.
2482%
2483% o tag: The attribute tag.
2484%
2485% o value: The attribute value.
2486%
2487*/
2488MagickExport XMLTreeInfo *SetXMLTreeAttribute(XMLTreeInfo *xml_info,
2489 const char *tag,const char *value)
2490{
2491 ssize_t
2492 i,
2493 j;
2494
2495 assert(xml_info != (XMLTreeInfo *) NULL);
2496 assert((xml_info->signature == MagickCoreSignature) ||
2497 (((XMLTreeRoot *) xml_info)->signature == MagickCoreSignature));
2498 if (IsEventLogging() != MagickFalse)
2499 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2500 i=0;
2501 while ((xml_info->attributes[i] != (char *) NULL) &&
2502 (strcmp(xml_info->attributes[i],tag) != 0))
2503 i+=2;
2504 if (xml_info->attributes[i] == (char *) NULL)
2505 {
2506 /*
2507 Add new attribute tag.
2508 */
2509 if (value == (const char *) NULL)
2510 return(xml_info);
2511 if (xml_info->attributes != sentinel)
2512 xml_info->attributes=(char **) ResizeQuantumMemory(
2513 xml_info->attributes,(size_t) (i+4),sizeof(*xml_info->attributes));
2514 else
2515 {
2516 xml_info->attributes=(char **) AcquireQuantumMemory(4,
2517 sizeof(*xml_info->attributes));
2518 if (xml_info->attributes != (char **) NULL)
2519 xml_info->attributes[1]=ConstantString("");
2520 }
2521 if (xml_info->attributes == (char **) NULL)
2522 ThrowFatalException(ResourceLimitFatalError,"UnableToAcquireString");
2523 xml_info->attributes[i]=ConstantString(tag);
2524 xml_info->attributes[i+2]=(char *) NULL;
2525 (void) strlen(xml_info->attributes[i+1]);
2526 }
2527 /*
2528 Add new value to an existing attribute.
2529 */
2530 for (j=i; xml_info->attributes[j] != (char *) NULL; j+=2) ;
2531 if (xml_info->attributes[i+1] != (char *) NULL)
2532 xml_info->attributes[i+1]=DestroyString(xml_info->attributes[i+1]);
2533 if (value != (const char *) NULL)
2534 {
2535 xml_info->attributes[i+1]=ConstantString(value);
2536 return(xml_info);
2537 }
2538 if (xml_info->attributes[i] != (char *) NULL)
2539 xml_info->attributes[i]=DestroyString(xml_info->attributes[i]);
2540 (void) memmove(xml_info->attributes+i,xml_info->attributes+i+2,
2541 (size_t) (j-i)*sizeof(*xml_info->attributes));
2542 xml_info->attributes=(char **) ResizeQuantumMemory(xml_info->attributes,
2543 (size_t) (j+2),sizeof(*xml_info->attributes));
2544 if (xml_info->attributes == (char **) NULL)
2545 ThrowFatalException(ResourceLimitFatalError,"UnableToAcquireString");
2546 j-=2;
2547 (void) memmove(xml_info->attributes[j+1]+(i/2),xml_info->attributes[j+1]+
2548 (i/2)+1,(size_t) (((j+2)/2)-(i/2))*sizeof(**xml_info->attributes));
2549 return(xml_info);
2550}
2551␌
2552/*
2553%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2554% %
2555% %
2556% %
2557% S e t X M L T r e e C o n t e n t %
2558% %
2559% %
2560% %
2561%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2562%
2563% SetXMLTreeContent() sets the character content for the given tag and
2564% returns the tag.
2565%
2566% The format of the SetXMLTreeContent method is:
2567%
2568% XMLTreeInfo *SetXMLTreeContent(XMLTreeInfo *xml_info,
2569% const char *content)
2570%
2571% A description of each parameter follows:
2572%
2573% o xml_info: the xml info.
2574%
2575% o content: The content.
2576%
2577*/
2578MagickExport XMLTreeInfo *SetXMLTreeContent(XMLTreeInfo *xml_info,
2579 const char *content)
2580{
2581 assert(xml_info != (XMLTreeInfo *) NULL);
2582 assert((xml_info->signature == MagickCoreSignature) ||
2583 (((XMLTreeRoot *) xml_info)->signature == MagickCoreSignature));
2584 if (IsEventLogging() != MagickFalse)
2585 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2586 if (xml_info->content != (char *) NULL)
2587 xml_info->content=DestroyString(xml_info->content);
2588 xml_info->content=(char *) ConstantString(content);
2589 return(xml_info);
2590}
2591␌
2592/*
2593%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2594% %
2595% %
2596% %
2597% X M L T r e e I n f o T o X M L %
2598% %
2599% %
2600% %
2601%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2602%
2603% XMLTreeInfoToXML() converts an xml-tree to an XML string.
2604%
2605% The format of the XMLTreeInfoToXML method is:
2606%
2607% char *XMLTreeInfoToXML(XMLTreeInfo *xml_info)
2608%
2609% A description of each parameter follows:
2610%
2611% o xml_info: the xml info.
2612%
2613*/
2614
2615static char *EncodePredefinedEntities(const char *source,ssize_t offset,
2616 char **destination,size_t *length,size_t *extent,MagickBooleanType pedantic)
2617{
2618 char
2619 *canonical_content;
2620
2621 if (offset < 0)
2622 canonical_content=CanonicalXMLContent(source,pedantic);
2623 else
2624 {
2625 char
2626 *content;
2627
2628 content=AcquireString(source);
2629 content[offset]='\0';
2630 canonical_content=CanonicalXMLContent(content,pedantic);
2631 content=DestroyString(content);
2632 }
2633 if (canonical_content == (char *) NULL)
2634 return(*destination);
2635 if ((*length+strlen(canonical_content)+MaxTextExtent) > *extent)
2636 {
2637 *extent=(*length)+strlen(canonical_content)+MaxTextExtent;
2638 *destination=(char *) ResizeQuantumMemory(*destination,*extent,
2639 sizeof(**destination));
2640 if (*destination == (char *) NULL)
2641 return(*destination);
2642 }
2643 *length+=FormatLocaleString(*destination+(*length),*extent,"%s",
2644 canonical_content);
2645 canonical_content=DestroyString(canonical_content);
2646 return(*destination);
2647}
2648
2649static char *XMLTreeTagToXML(XMLTreeInfo *xml_info,char **source,size_t *length,
2650 size_t *extent,size_t start,char ***attributes)
2651{
2652 char
2653 *content;
2654
2655 const char
2656 *attribute;
2657
2658 size_t
2659 offset;
2660
2661 ssize_t
2662 i,
2663 j;
2664
2665 content=(char *) "";
2666 if (xml_info->parent != (XMLTreeInfo *) NULL)
2667 content=xml_info->parent->content;
2668 offset=0;
2669 *source=EncodePredefinedEntities(content+start,(ssize_t) (xml_info->offset-
2670 start),source,length,extent,MagickFalse);
2671 if ((*length+strlen(xml_info->tag)+MaxTextExtent) > *extent)
2672 {
2673 *extent=(*length)+strlen(xml_info->tag)+MaxTextExtent;
2674 *source=(char *) ResizeQuantumMemory(*source,*extent,sizeof(**source));
2675 if (*source == (char *) NULL)
2676 return(*source);
2677 }
2678 *length+=FormatLocaleString(*source+(*length),*extent,"<%s",xml_info->tag);
2679 for (i=0; xml_info->attributes[i]; i+=2)
2680 {
2681 attribute=GetXMLTreeAttribute(xml_info,xml_info->attributes[i]);
2682 if (attribute != xml_info->attributes[i+1])
2683 continue;
2684 if ((*length+strlen(xml_info->attributes[i])+MaxTextExtent) > *extent)
2685 {
2686 *extent=(*length)+strlen(xml_info->attributes[i])+MaxTextExtent;
2687 *source=(char *) ResizeQuantumMemory(*source,*extent,sizeof(**source));
2688 if (*source == (char *) NULL)
2689 return((char *) NULL);
2690 }
2691 *length+=FormatLocaleString(*source+(*length),*extent," %s=\"",
2692 xml_info->attributes[i]);
2693 (void) EncodePredefinedEntities(xml_info->attributes[i+1],-1,source,length,
2694 extent,MagickTrue);
2695 *length+=FormatLocaleString(*source+(*length),*extent,"\"");
2696 }
2697 i=0;
2698 while ((attributes[i] != (char **) NULL) &&
2699 (strcmp(attributes[i][0],xml_info->tag) != 0))
2700 i++;
2701 j=1;
2702 while ((attributes[i] != (char **) NULL) &&
2703 (attributes[i][j] != (char *) NULL))
2704 {
2705 if ((attributes[i][j+1] == (char *) NULL) ||
2706 (GetXMLTreeAttribute(xml_info,attributes[i][j]) != attributes[i][j+1]))
2707 {
2708 j+=3;
2709 continue;
2710 }
2711 if ((*length+strlen(attributes[i][j])+MaxTextExtent) > *extent)
2712 {
2713 *extent=(*length)+strlen(attributes[i][j])+MaxTextExtent;
2714 *source=(char *) ResizeQuantumMemory(*source,*extent,sizeof(**source));
2715 if (*source == (char *) NULL)
2716 return((char *) NULL);
2717 }
2718 *length+=FormatLocaleString(*source+(*length),*extent," %s=\"",
2719 attributes[i][j]);
2720 (void) EncodePredefinedEntities(attributes[i][j+1],-1,source,length,extent,
2721 MagickTrue);
2722 *length+=FormatLocaleString(*source+(*length),*extent,"\"");
2723 j+=3;
2724 }
2725 *length+=FormatLocaleString(*source+(*length),*extent,*xml_info->content ?
2726 ">" : "/>");
2727 if (xml_info->child != (XMLTreeInfo *) NULL)
2728 *source=XMLTreeTagToXML(xml_info->child,source,length,extent,0,attributes);
2729 else
2730 *source=EncodePredefinedEntities(xml_info->content,-1,source,length,extent,
2731 MagickFalse);
2732 if ((*length+strlen(xml_info->tag)+MaxTextExtent) > *extent)
2733 {
2734 *extent=(*length)+strlen(xml_info->tag)+MaxTextExtent;
2735 *source=(char *) ResizeQuantumMemory(*source,*extent,sizeof(**source));
2736 if (*source == (char *) NULL)
2737 return((char *) NULL);
2738 }
2739 if (*xml_info->content != '\0')
2740 *length+=FormatLocaleString(*source+(*length),*extent,"</%s>",
2741 xml_info->tag);
2742 while ((offset < xml_info->offset) && (content[offset] != '\0'))
2743 offset++;
2744 if (xml_info->ordered != (XMLTreeInfo *) NULL)
2745 content=XMLTreeTagToXML(xml_info->ordered,source,length,extent,offset,
2746 attributes);
2747 else
2748 content=EncodePredefinedEntities(content+offset,-1,source,length,extent,
2749 MagickFalse);
2750 return(content);
2751}
2752
2753MagickExport char *XMLTreeInfoToXML(XMLTreeInfo *xml_info)
2754{
2755 char
2756 *p,
2757 *q,
2758 *xml;
2759
2760 size_t
2761 extent,
2762 length;
2763
2764 ssize_t
2765 i,
2766 j,
2767 k;
2768
2769 XMLTreeInfo
2770 *ordered,
2771 *parent;
2772
2773 XMLTreeRoot
2774 *root;
2775
2776 assert(xml_info != (XMLTreeInfo *) NULL);
2777 assert((xml_info->signature == MagickCoreSignature) ||
2778 (((XMLTreeRoot *) xml_info)->signature == MagickCoreSignature));
2779 if (IsEventLogging() != MagickFalse)
2780 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2781 if (xml_info->tag == (char *) NULL)
2782 return((char *) NULL);
2783 xml=AcquireString((char *) NULL);
2784 length=0;
2785 extent=MaxTextExtent;
2786 root=(XMLTreeRoot *) xml_info;
2787 while (root->root.parent != (XMLTreeInfo *) NULL)
2788 root=(XMLTreeRoot *) root->root.parent;
2789 parent=xml_info->parent;
2790 if (parent == (XMLTreeInfo *) NULL)
2791 for (i=0; root->processing_instructions[i] != (char **) NULL; i++)
2792 {
2793 /*
2794 Pre-root processing instructions.
2795 */
2796 for (k=2; root->processing_instructions[i][k-1]; k++) ;
2797 p=root->processing_instructions[i][1];
2798 for (j=1; p != (char *) NULL; j++)
2799 {
2800 if (root->processing_instructions[i][k][j-1] == '>')
2801 {
2802 p=root->processing_instructions[i][j];
2803 continue;
2804 }
2805 q=root->processing_instructions[i][0];
2806 if ((length+strlen(p)+strlen(q)+MaxTextExtent) > extent)
2807 {
2808 extent=length+strlen(p)+strlen(q)+MaxTextExtent;
2809 xml=(char *) ResizeQuantumMemory(xml,extent,sizeof(*xml));
2810 if (xml == (char *) NULL)
2811 return(xml);
2812 }
2813 length+=FormatLocaleString(xml+length,extent,"<?%s%s%s?>\n",q,
2814 *p != '\0' ? " " : "",p);
2815 p=root->processing_instructions[i][j];
2816 }
2817 }
2818 ordered=xml_info->ordered;
2819 xml_info->parent=(XMLTreeInfo *) NULL;
2820 xml_info->ordered=(XMLTreeInfo *) NULL;
2821 xml=XMLTreeTagToXML(xml_info,&xml,&length,&extent,0,root->attributes);
2822 xml_info->parent=parent;
2823 xml_info->ordered=ordered;
2824 if (parent == (XMLTreeInfo *) NULL)
2825 for (i=0; root->processing_instructions[i] != (char **) NULL; i++)
2826 {
2827 /*
2828 Post-root processing instructions.
2829 */
2830 for (k=2; root->processing_instructions[i][k-1]; k++) ;
2831 p=root->processing_instructions[i][1];
2832 for (j=1; p != (char *) NULL; j++)
2833 {
2834 if (root->processing_instructions[i][k][j-1] == '<')
2835 {
2836 p=root->processing_instructions[i][j];
2837 continue;
2838 }
2839 q=root->processing_instructions[i][0];
2840 if ((length+strlen(p)+strlen(q)+MaxTextExtent) > extent)
2841 {
2842 extent=length+strlen(p)+strlen(q)+MaxTextExtent;
2843 xml=(char *) ResizeQuantumMemory(xml,extent,sizeof(*xml));
2844 if (xml == (char *) NULL)
2845 return(xml);
2846 }
2847 length+=FormatLocaleString(xml+length,extent,"\n<?%s%s%s?>",q,
2848 *p != '\0' ? " " : "",p);
2849 p=root->processing_instructions[i][j];
2850 }
2851 }
2852 return((char *) ResizeQuantumMemory(xml,length+1,sizeof(*xml)));
2853}
_XMLTreeInfo
Definition xml-tree.c:77
_XMLTreeRoot
Definition xml-tree.c:107