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