int main(int argc, char **argv)
{
char
*xml;
const char
*acronym,
*data_type,
*description,
*endian,
*mask,
*mime_type,
*offset,
*pattern,
*priority,
*match_type,
*value;
ExceptionInfo
*exception;
size_t
length;
static char
*doc_type =
{
"<!DOCTYPE mimemap [\n"
" <!ELEMENT mimemap (mime+)>\n"
" <!ELEMENT mime (#PCDATA)>\n"
" <!ATTLIST mime type CDATA #REQUIRED>\n"
" <!ATTLIST mime acronym CDATA #IMPLIED>\n"
" <!ATTLIST mime description CDATA #IMPLIED>\n"
" <!ATTLIST mime pattern CDATA #IMPLIED>\n"
" <!ATTLIST mime offset CDATA #IMPLIED>\n"
" <!ATTLIST mime data-type (string|byte|short|ssize_t) #IMPLIED>\n"
" <!ATTLIST mime endian (lsb|msb) #IMPLIED>\n"
" <!ATTLIST mime magic CDATA #IMPLIED>\n"
" <!ATTLIST mime mask CDATA #IMPLIED>\n"
" <!ATTLIST mime priority CDATA #IMPLIED>\n"
"]>"
};
XMLTreeInfo
*comment,
*expanded_acronym,
*glob,
*magic,
*match,
*type,
*xml_info;
if (argc != 2)
return(fprintf(stderr,"usage: %s xml-file\n", argv[0]));
exception=AcquireExceptionInfo();
xml=(char *) FileToBlob(argv[1],~0UL,&length,exception);
if (xml == (char *) NULL)
return(fprintf(stderr,"%s: unable to read file\n",argv[1]));
xml_info=NewXMLTree(xml,exception);
xml=(char *) RelinquishWizardMemory(xml);
if (xml_info == (XMLTreeInfo *) NULL)
return(fprintf(stderr,"%s: unable to parse xml-file\n",argv[1]));
(void) printf("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
(void) printf("%s\n",doc_type);
(void) printf("<mimemap>\n");
type=GetXMLTreeChild(xml_info,"mime-type");
while (type != (XMLTreeInfo *) NULL)
{
mime_type=GetXMLTreeAttribute(type,"type");
acronym=(const char *) NULL;
expanded_acronym=GetXMLTreeChild(type,"acronym");
if (expanded_acronym != (XMLTreeInfo *) NULL)
acronym=GetXMLTreeContent(expanded_acronym);
expanded_acronym=GetXMLTreeChild(type,"expanded-acronym");
description=(const char *) NULL;
comment=GetXMLTreeChild(type,"comment");
if (comment != (XMLTreeInfo *) NULL)
description=GetXMLTreeContent(comment);
if (expanded_acronym != (XMLTreeInfo *) NULL)
description=GetXMLTreeContent(expanded_acronym);
magic=GetXMLTreeChild(type,"magic");
priority=(char *) NULL;
match=(XMLTreeInfo *) NULL;
if (magic != (XMLTreeInfo *) NULL)
{
priority=GetXMLTreeAttribute(magic,"priority");
match=GetXMLTreeChild(magic,"match");
}
while (match != (XMLTreeInfo *) NULL)
{
value=(char *) NULL;
match_type=(char *) NULL;
mask=(char *) NULL;
offset=(char *) NULL;
if (match != (XMLTreeInfo *) NULL)
{
value=GetXMLTreeAttribute(match,"value");
match_type=GetXMLTreeAttribute(match,"type");
offset=GetXMLTreeAttribute(match,"offset");
mask=GetXMLTreeAttribute(match,"mask");
}
(void) printf(" <mime");
if (mime_type != (const char *) NULL)
(void) printf(" type=\"%s\"",mime_type);
if (description != (const char *) NULL)
(void) printf(" description=\"%s\"",description);
if (match_type != (const char *) NULL)
{
data_type="string";
endian="undefined";
if (strncmp(match_type,"little",6) == 0)
endian="LSB";
if (strncmp(match_type,"big",3) == 0)
endian="MSB";
if (strcmp(match_type,"byte") == 0)
data_type="byte";
if (strcmp(match_type+strlen(match_type)-2,"16") == 0)
data_type="short";
if (strcmp(match_type+strlen(match_type)-2,"32") == 0)
data_type="ssize_t";
(void) printf(" data-type=\"%s\"",data_type);
if (strcmp(endian,"undefined") != 0)
(void) printf(" endian=\"%s\"",endian);
}
if (offset != (const char *) NULL)
(void) printf(" offset=\"%s\"",offset);
if (mask != (const char *) NULL)
(void) printf(" mask=\"%s\"",mask);
if (value != (const char *) NULL)
{
char
*magic;
magic=AcquireString(value);
SubstituteString(&magic,"<","<");
SubstituteString(&magic,">",">");
SubstituteString(&magic,"\"",""");
(void) printf(" magic=\"%s\"",magic);
magic=(char *) RelinquishWizardMemory(magic);
}
if (priority != (const char *) NULL)
(void) printf(" priority=\"%s\"",priority);
(void) printf(" />\n");
match=GetNextXMLTreeTag(match);
}
glob=GetXMLTreeChild(type,"glob");
while (glob != (XMLTreeInfo *) NULL)
{
pattern=GetXMLTreeAttribute(glob,"pattern");
value=(char *) NULL;
if (match)
value=GetXMLTreeAttribute(match,"value");
(void) printf(" <mime");
if (mime_type != (const char *) NULL)
(void) printf(" type=\"%s\"",mime_type);
if (acronym != (const char *) NULL)
(void) printf(" acronym=\"%s\"",acronym);
if (description != (const char *) NULL)
(void) printf(" description=\"%s\"",description);
(void) printf(" priority=\"100\"");
if (pattern != (const char *) NULL)
(void) printf(" pattern=\"%s\"",pattern);
(void) printf(" />\n");
glob=GetNextXMLTreeTag(glob);
}
type=GetNextXMLTreeTag(type);
}
(void) printf("</mimemap>\n");
xml=XMLTreeInfoToXML(xml_info);
(void) fprintf(stderr,"%s\n",xml);
xml=(char *) RelinquishWizardMemory(xml);
DestroyXMLTree(xml_info);
exception=DestroyExceptionInfo(exception);
return(0);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
+ L o a d M i m e C a c h e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% LoadMimeCache() loads the mime configurations which provides a mapping
% between mime attributes and a mime name.
%
% The format of the LoadMimeCache method is:
%
% MagickBooleanType LoadMimeCache(LinkedListInfo *cache,const char *xml,
% const char *filename,const size_t depth,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o xml: The mime list in XML format.
%
% o filename: The mime list filename.
%
% o depth: depth of <include /> statements.
%
% o exception: return any errors or warnings in this structure.
%
*/
static MagickBooleanType LoadMimeCache(LinkedListInfo *cache,const char *xml,
const char *filename,const size_t depth,ExceptionInfo *exception)
{
const char
*attribute;
MimeInfo
*mime_info = (MimeInfo *) NULL;
MagickStatusType
status;
XMLTreeInfo
*mime,
*mime_map,
*include;
/*
Load the mime map file.
*/
(void) LogMagickEvent(ConfigureEvent,GetMagickModule(),
"Loading mime map \"%s\" ...",filename);
if (xml == (const char *) NULL)
return(MagickFalse);
mime_map=NewXMLTree(xml,exception);
if (mime_map == (XMLTreeInfo *) NULL)
return(MagickFalse);
status=MagickTrue;
include=GetXMLTreeChild(mime_map,"include");
while (include != (XMLTreeInfo *) NULL)
{
/*
Process include element.
*/
attribute=GetXMLTreeAttribute(include,"file");
if (attribute != (const char *) NULL)
{
if (depth > 200)
(void) ThrowMagickException(exception,GetMagickModule(),
ConfigureError,"IncludeElementNestedTooDeeply","`%s'",filename);
else
{
char
path[MagickPathExtent],
*file_xml;
GetPathComponent(filename,HeadPath,path);
if (*path != '\0')
(void) ConcatenateMagickString(path,DirectorySeparator,
MagickPathExtent);
if (*attribute == *DirectorySeparator)
(void) CopyMagickString(path,attribute,MagickPathExtent);
else
(void) ConcatenateMagickString(path,attribute,MagickPathExtent);
file_xml=FileToXML(path,~0UL);
if (file_xml != (char *) NULL)
{
status&=LoadMimeCache(cache,file_xml,path,depth+1,exception);
file_xml=DestroyString(file_xml);
}
}
}
include=GetNextXMLTreeTag(include);
}
mime=GetXMLTreeChild(mime_map,"mime");
while (mime != (XMLTreeInfo *) NULL)
{
/*
Process mime element.
*/
mime_info=(MimeInfo *) AcquireCriticalMemory(sizeof(*mime_info));
(void) ResetMagickMemory(mime_info,0,sizeof(*mime_info));
mime_info->path=ConstantString(filename);
mime_info->signature=MagickCoreSignature;
attribute=GetXMLTreeAttribute(mime,"data-type");
if (attribute != (const char *) NULL)
mime_info->data_type=(DataType) ParseCommandOption(MagickDataTypeOptions,
MagickTrue,attribute);
attribute=GetXMLTreeAttribute(mime,"description");
if (attribute != (const char *) NULL)
mime_info->description=ConstantString(attribute);
attribute=GetXMLTreeAttribute(mime,"endian");
if (attribute != (const char *) NULL)
mime_info->endian=(EndianType) ParseCommandOption(MagickEndianOptions,
MagickTrue,attribute);
attribute=GetXMLTreeAttribute(mime,"magic");
if (attribute != (const char *) NULL)
{
char
*token;
const char
*p;
register unsigned char
*q;
token=AcquireString(attribute);
(void) SubstituteString((char **) &token,"<","<");
(void) SubstituteString((char **) &token,"&","&");
(void) SubstituteString((char **) &token,""","\"");
mime_info->magic=(unsigned char *) AcquireString(token);
q=mime_info->magic;
for (p=token; *p != '\0'; )
{
if (*p == '\\')
{
p++;
if (isdigit((int) ((unsigned char) *p)) != 0)
{
char
*end;
*q++=(unsigned char) strtol(p,&end,8);
p+=(end-p);
mime_info->length++;
continue;
}
switch (*p)
{
case 'b': *q='\b'; break;
case 'f': *q='\f'; break;
case 'n': *q='\n'; break;
case 'r': *q='\r'; break;
case 't': *q='\t'; break;
case 'v': *q='\v'; break;
case 'a': *q='a'; break;
case '?': *q='\?'; break;
default: *q=(unsigned char) (*p); break;
}
p++;
q++;
mime_info->length++;
continue;
}
*q++=(unsigned char) (*p++);
mime_info->length++;
}
token=DestroyString(token);
if (mime_info->data_type != StringData)
mime_info->value=(ssize_t) strtoul((char *) mime_info->magic,
(char **) NULL,0);
}
attribute=GetXMLTreeAttribute(mime,"mask");
if (attribute != (const char *) NULL)
mime_info->mask=(ssize_t) strtoul(attribute,(char **) NULL,0);
attribute=GetXMLTreeAttribute(mime,"offset");
if (attribute != (const char *) NULL)
{
char
*c;
mime_info->offset=(MagickOffsetType) strtol(attribute,&c,0);
if (*c == ':')
mime_info->extent=(size_t) strtol(c+1,(char **) NULL,0);
}
attribute=GetXMLTreeAttribute(mime,"pattern");
if (attribute != (const char *) NULL)
mime_info->pattern=ConstantString(attribute);
attribute=GetXMLTreeAttribute(mime,"priority");
if (attribute != (const char *) NULL)
mime_info->priority=(ssize_t) strtol(attribute,(char **) NULL,0);
attribute=GetXMLTreeAttribute(mime,"stealth");
if (attribute != (const char *) NULL)
mime_info->stealth=IsStringTrue(attribute);
attribute=GetXMLTreeAttribute(mime,"type");
if (attribute != (const char *) NULL)
mime_info->type=ConstantString(attribute);
status=AppendValueToLinkedList(cache,mime_info);
if (status == MagickFalse)
(void) ThrowMagickException(exception,GetMagickModule(),
ResourceLimitError,"MemoryAllocationFailed","`%s'",filename);
mime=GetNextXMLTreeTag(mime);
}
mime_map=DestroyXMLTree(mime_map);
return(status != 0 ? MagickTrue : MagickFalse);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% R e a d D N G I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ReadDNGImage() reads an binary file in the Digital Negative format and
% returns it. It allocates the memory necessary for the new Image structure
% and returns a pointer to the new image.
%
% The format of the ReadDNGImage method is:
%
% Image *ReadDNGImage(const ImageInfo *image_info,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image_info: the image info.
%
% o exception: return any errors or warnings in this structure.
%
*/
static Image *ReadDNGImage(const ImageInfo *image_info,ExceptionInfo *exception)
{
ExceptionInfo
*sans_exception;
Image
*image;
ImageInfo
*read_info;
MagickBooleanType
status;
/*
Open image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
image=AcquireImage(image_info);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
{
image=DestroyImageList(image);
return((Image *) NULL);
}
(void) CloseBlob(image);
(void) DestroyImageList(image);
/*
Convert DNG to PPM with delegate.
*/
image=AcquireImage(image_info);
read_info=CloneImageInfo(image_info);
(void) InvokeDelegate(read_info,image,"dng:decode",(char *) NULL,exception);
image=DestroyImage(image);
(void) FormatMagickString(read_info->filename,MaxTextExtent,"%s.png",
read_info->unique);
sans_exception=AcquireExceptionInfo();
image=ReadImage(read_info,sans_exception);
sans_exception=DestroyExceptionInfo(sans_exception);
if (image == (Image *) NULL)
{
(void) FormatMagickString(read_info->filename,MaxTextExtent,"%s.ppm",
read_info->unique);
image=ReadImage(read_info,exception);
}
(void) RelinquishUniqueFileResource(read_info->filename);
if (image != (Image *) NULL)
{
char
filename[MaxTextExtent],
*xml;
ExceptionInfo
*sans;
(void) CopyMagickString(image->magick,read_info->magick,MaxTextExtent);
(void) FormatMagickString(filename,MaxTextExtent,"%s.ufraw",
read_info->unique);
sans=AcquireExceptionInfo();
xml=FileToString(filename,MaxTextExtent,sans);
(void) RelinquishUniqueFileResource(filename);
if (xml != (char *) NULL)
{
XMLTreeInfo
*ufraw;
/*
Inject
*/
ufraw=NewXMLTree(xml,sans);
if (ufraw != (XMLTreeInfo *) NULL)
{
char
*content,
property[MaxTextExtent];
const char
*tag;
XMLTreeInfo
*next;
if (image->properties == (void *) NULL)
((Image *) image)->properties=NewSplayTree(
CompareSplayTreeString,RelinquishMagickMemory,
RelinquishMagickMemory);
next=GetXMLTreeChild(ufraw,(const char *) NULL);
while (next != (XMLTreeInfo *) NULL)
{
tag=GetXMLTreeTag(next);
if (tag == (char *) NULL)
tag="unknown";
(void) FormatMagickString(property,MaxTextExtent,"dng:%s",tag);
content=ConstantString(GetXMLTreeContent(next));
StripString(content);
if ((LocaleCompare(tag,"log") != 0) &&
(LocaleCompare(tag,"InputFilename") != 0) &&
(LocaleCompare(tag,"OutputFilename") != 0) &&
(LocaleCompare(tag,"OutputType") != 0) &&
(strlen(content) != 0))
(void) AddValueToSplayTree((SplayTreeInfo *)
((Image *) image)->properties,ConstantString(property),
content);
next=GetXMLTreeSibling(next);
}
ufraw=DestroyXMLTree(ufraw);
}
xml=DestroyString(xml);
}
sans=DestroyExceptionInfo(sans);
}
read_info=DestroyImageInfo(read_info);
return(image);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
+ L o a d M a g i c L i s t %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% LoadMagicList() loads the magic configuration file which provides a mapping
% between magic attributes and a magic name.
%
% The format of the LoadMagicList method is:
%
% MagickBooleanType LoadMagicList(const char *xml,const char *filename,
% const unsigned long depth,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o xml: The magic list in XML format.
%
% o filename: The magic list filename.
%
% o depth: depth of <include /> statements.
%
% o exception: Return any errors or warnings in this structure.
%
*/
static MagickBooleanType LoadMagicList(const char *xml,const char *filename,
const unsigned long depth,ExceptionInfo *exception)
{
const char
*attribute;
MagicInfo
*magic_info = (MagicInfo *) NULL;
MagickBooleanType
status;
XMLTreeInfo
*magic,
*magic_map,
*include;
/*
Load the magic map file.
*/
(void) LogMagickEvent(ConfigureEvent,GetMagickModule(),
"Loading magic map \"%s\" ...",filename);
if (xml == (const char *) NULL)
return(MagickFalse);
if (magic_list == (LinkedListInfo *) NULL)
{
magic_list=NewLinkedList(0);
if (magic_list == (LinkedListInfo *) NULL)
{
ThrowFileException(exception,ResourceLimitError,
"MemoryAllocationFailed",filename);
return(MagickFalse);
}
}
magic_map=NewXMLTree(xml,exception);
if (magic_map == (XMLTreeInfo *) NULL)
return(MagickFalse);
status=MagickTrue;
include=GetXMLTreeChild(magic_map,"include");
while (include != (XMLTreeInfo *) NULL)
{
/*
Process include element.
*/
attribute=GetXMLTreeAttribute(include,"file");
if (attribute != (const char *) NULL)
{
if (depth > 200)
(void) ThrowMagickException(exception,GetMagickModule(),
ConfigureError,"IncludeElementNestedTooDeeply","`%s'",filename);
else
{
char
path[MaxTextExtent],
*xml;
GetPathComponent(filename,HeadPath,path);
if (*path != '\0')
(void) ConcatenateMagickString(path,DirectorySeparator,
MaxTextExtent);
(void) ConcatenateMagickString(path,attribute,MaxTextExtent);
xml=FileToString(path,~0,exception);
if (xml != (char *) NULL)
{
status=LoadMagicList(xml,path,depth+1,exception);
xml=DestroyString(xml);
}
}
}
include=GetNextXMLTreeTag(include);
}
magic=GetXMLTreeChild(magic_map,"magic");
while (magic != (XMLTreeInfo *) NULL)
{
const char
*attribute;
/*
Process magic element.
*/
magic_info=(MagicInfo *) AcquireMagickMemory(sizeof(*magic_info));
if (magic_info == (MagicInfo *) NULL)
ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
(void) ResetMagickMemory(magic_info,0,sizeof(*magic_info));
magic_info->path=ConstantString(filename);
magic_info->signature=MagickSignature;
attribute=GetXMLTreeAttribute(magic,"name");
if (attribute != (const char *) NULL)
magic_info->name=ConstantString(attribute);
attribute=GetXMLTreeAttribute(magic,"offset");
if (attribute != (const char *) NULL)
magic_info->offset=(MagickOffsetType) atol(attribute);
attribute=GetXMLTreeAttribute(magic,"stealth");
if (attribute != (const char *) NULL)
magic_info->stealth=IsMagickTrue(attribute);
attribute=GetXMLTreeAttribute(magic,"target");
if (attribute != (const char *) NULL)
{
const char
*p;
register unsigned char
*q;
magic_info->target=ConstantString(attribute);
magic_info->magic=(unsigned char *) ConstantString(attribute);
q=magic_info->magic;
for (p=magic_info->target; *p != '\0'; )
{
if (*p == '\\')
{
p++;
if (isdigit((int) ((unsigned char) *p)) != 0)
{
char
*end;
*q++=(unsigned char) strtol(p,&end,8);
p+=(end-p);
magic_info->length++;
continue;
}
switch (*p)
{
case 'b': *q='\b'; break;
case 'f': *q='\f'; break;
case 'n': *q='\n'; break;
case 'r': *q='\r'; break;
case 't': *q='\t'; break;
case 'v': *q='\v'; break;
case 'a': *q='a'; break;
case '?': *q='\?'; break;
default: *q=(unsigned char) (*p); break;
}
p++;
q++;
magic_info->length++;
continue;
}
*q++=(unsigned char) (*p++);
magic_info->length++;
}
}
status=AppendValueToLinkedList(magic_list,magic_info);
if (status == MagickFalse)
(void) ThrowMagickException(exception,GetMagickModule(),
ResourceLimitError,"MemoryAllocationFailed","`%s'",filename);
magic=GetNextXMLTreeTag(magic);
}
magic_map=DestroyXMLTree(magic_map);
return(status);
}
static MagickBooleanType LoadCoderList(const char *xml,const char *filename,
const unsigned long depth,ExceptionInfo *exception)
{
CoderInfo
*coder_info = (CoderInfo *) NULL;
const char
*attribute;
MagickBooleanType
status;
XMLTreeInfo
*coder,
*coder_map,
*include;
/*
Load the coder map file.
*/
(void) LogMagickEvent(ConfigureEvent,GetMagickModule(),
"Loading coder map \"%s\" ...",filename);
if (xml == (const char *) NULL)
return(MagickFalse);
if (coder_list == (SplayTreeInfo *) NULL)
{
coder_list=NewSplayTree(CompareSplayTreeString,(void *(*)(void *)) NULL,
DestroyCoderNode);
if (coder_list == (SplayTreeInfo *) NULL)
{
(void) ThrowMagickException(exception,GetMagickModule(),
ResourceLimitError,"MemoryAllocationFailed","`%s'",filename);
return(MagickFalse);
}
}
coder_map=NewXMLTree(xml,exception);
if (coder_map == (XMLTreeInfo *) NULL)
return(MagickFalse);
status=MagickTrue;
include=GetXMLTreeChild(coder_map,"include");
while (include != (XMLTreeInfo *) NULL)
{
/*
Process include element.
*/
attribute=GetXMLTreeAttribute(include,"file");
if (attribute != (const char *) NULL)
{
if (depth > 200)
(void) ThrowMagickException(exception,GetMagickModule(),
ConfigureError,"IncludeElementNestedTooDeeply","`%s'",attribute);
else
{
char
path[MaxTextExtent],
*xml;
GetPathComponent(filename,HeadPath,path);
if (*path != '\0')
(void) ConcatenateMagickString(path,DirectorySeparator,
MaxTextExtent);
(void) ConcatenateMagickString(path,attribute,MaxTextExtent);
xml=FileToString(path,~0,exception);
if (xml != (char *) NULL)
{
status=LoadCoderList(xml,path,depth+1,exception);
xml=DestroyString(xml);
}
}
}
include=GetNextXMLTreeTag(include);
}
coder=GetXMLTreeChild(coder_map,"coder");
while (coder != (XMLTreeInfo *) NULL)
{
/*
Process coder element.
*/
coder_info=(CoderInfo *) AcquireMagickMemory(sizeof(*coder_info));
if (coder_info == (CoderInfo *) NULL)
ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
(void) ResetMagickMemory(coder_info,0,sizeof(*coder_info));
coder_info->path=ConstantString(filename);
coder_info->signature=MagickSignature;
attribute=GetXMLTreeAttribute(coder,"magick");
if (attribute != (const char *) NULL)
coder_info->magick=ConstantString(attribute);
attribute=GetXMLTreeAttribute(coder,"name");
if (attribute != (const char *) NULL)
coder_info->name=ConstantString(attribute);
attribute=GetXMLTreeAttribute(coder,"stealth");
if (attribute != (const char *) NULL)
coder_info->stealth=IsMagickTrue(attribute);
status=AddValueToSplayTree(coder_list,coder_info->magick,coder_info);
if (status == MagickFalse)
(void) ThrowMagickException(exception,GetMagickModule(),
ResourceLimitError,"MemoryAllocationFailed","`%s'",filename);
coder=GetNextXMLTreeTag(coder);
}
coder_map=DestroyXMLTree(coder_map);
return(status);
}
static MagickBooleanType LoadLocaleList(const char *xml,const char *filename,
const char *locale,const unsigned long depth,ExceptionInfo *exception)
{
const char
*attribute;
MagickBooleanType
status;
XMLTreeInfo
*include,
**components,
*locale_map;
/*
Load the locale map file.
*/
(void) LogMagickEvent(ConfigureEvent,GetMagickModule(),
"Loading locale map \"%s\" ...",filename);
if (xml == (const char *) NULL)
return(MagickFalse);
if (locale_list == (SplayTreeInfo *) NULL)
{
locale_list=NewSplayTree(CompareSplayTreeString,(void *(*)(void *)) NULL,
DestroyLocaleNode);
if (locale_list == (SplayTreeInfo *) NULL)
{
ThrowFileException(exception,ResourceLimitError,
"MemoryAllocationFailed",filename);
return(MagickFalse);
}
}
locale_map=NewXMLTree(xml,exception);
if (locale_map == (XMLTreeInfo *) NULL)
return(MagickFalse);
include=GetXMLTreeChild(locale_map,"include");
while (include != (XMLTreeInfo *) NULL)
{
/*
Process include element.
*/
attribute=GetXMLTreeAttribute(include,"locale");
if ((attribute != (const char *) NULL) &&
(LocaleCompare(locale,attribute) != 0))
{
include=GetNextXMLTreeTag(include);
continue;
}
attribute=GetXMLTreeAttribute(include,"file");
if (attribute != (const char *) NULL)
{
if (depth > MaxRecursionDepth)
(void) ThrowMagickException(exception,GetMagickModule(),
ConfigureError,"IncludeElementNestedTooDeeply","`%s'",filename);
else
{
char
path[MaxTextExtent],
*xml;
GetPathComponent(filename,HeadPath,path);
if (*path != '\0')
(void) ConcatenateMagickString(path,DirectorySeparator,
MaxTextExtent);
(void) ConcatenateMagickString(path,attribute,MaxTextExtent);
xml=FileToString(path,~0,exception);
if (xml != (char *) NULL)
{
status=LoadLocaleList(xml,path,locale,depth+1,exception);
xml=DestroyString(xml);
}
}
}
include=GetNextXMLTreeTag(include);
}
components=(XMLTreeInfo **) AcquireQuantumMemory(MaxRecursionDepth,
sizeof(*components));
if (components == (XMLTreeInfo **) NULL)
{
locale_map=DestroyXMLTree(locale_map);
ThrowFileException(exception,ResourceLimitError,
"MemoryAllocationFailed",filename);
return(MagickFalse);
}
status=TraverseLocaleMap(filename,components,locale_map,0,exception);
components=(XMLTreeInfo **) RelinquishMagickMemory(components);
locale_map=DestroyXMLTree(locale_map);
return(status);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
+ L o a d C o n f i g u r e L i s t %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% LoadConfigureCache() loads the configure configurations which provides a
% mapping between configure attributes and a configure name.
%
% The format of the LoadConfigureCache method is:
%
% WizardBooleanType LoadConfigureCache(LinkedListInfo *configure_cache,
% const char *xml,const char *filename,const size_t depth,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o xml: The configure list in XML format.
%
% o filename: The configure list filename.
%
% o depth: depth of <include /> statements.
%
% o exception: Return any errors or warnings in this structure.
%
*/
static WizardBooleanType LoadConfigureCache(LinkedListInfo *configure_cache,
const char *xml,const char *filename,const size_t depth,
ExceptionInfo *exception)
{
const char
*attribute;
ConfigureInfo
*configure_info = (ConfigureInfo *) NULL;
WizardStatusType
status;
XMLTreeInfo
*configure,
*configure_map,
*include;
/*
Load the configure map file.
*/
(void) LogWizardEvent(ConfigureEvent,GetWizardModule(),
"Loading configure map \"%s\" ...",filename);
if (xml == (const char *) NULL)
return(WizardFalse);
configure_map=NewXMLTree(xml,exception);
if (configure_map == (XMLTreeInfo *) NULL)
return(WizardFalse);
status=WizardFalse;
include=GetXMLTreeChild(configure_map,"include");
while (include != (XMLTreeInfo *) NULL)
{
/*
Process include element.
*/
attribute=GetXMLTreeAttribute(include,"file");
if (attribute != (const char *) NULL)
{
if (depth > 200)
(void) ThrowWizardException(exception,GetWizardModule(),
ConfigureError,"include element nested too deeply `%s'",filename);
else
{
char
path[WizardPathExtent],
*xml;
GetPathComponent(filename,HeadPath,path);
if (*path != '\0')
(void) ConcatenateWizardString(path,DirectorySeparator,
WizardPathExtent);
(void) ConcatenateWizardString(path,attribute,WizardPathExtent);
xml=FileToXML(path,~0UL);
status&=LoadConfigureCache(configure_cache,xml,path,depth+1,
exception);
xml=(char *) RelinquishWizardMemory(xml);
}
}
include=GetNextXMLTreeTag(include);
}
configure=GetXMLTreeChild(configure_map,"configure");
while (configure != (XMLTreeInfo *) NULL)
{
const char
*attribute;
/*
Process configure element.
*/
configure_info=(ConfigureInfo *) AcquireWizardMemory(
sizeof(*configure_info));
if (configure_info == (ConfigureInfo *) NULL)
ThrowFatalException(ResourceFatalError,"memory allocation failed `%s`");
(void) ResetWizardMemory(configure_info,0,sizeof(*configure_info));
configure_info->path=ConstantString(filename);
configure_info->exempt=WizardFalse;
configure_info->signature=WizardSignature;
attribute=GetXMLTreeAttribute(configure,"name");
if (attribute != (const char *) NULL)
configure_info->name=ConstantString(attribute);
attribute=GetXMLTreeAttribute(configure,"stealth");
if (attribute != (const char *) NULL)
configure_info->stealth=IsWizardTrue(attribute);
attribute=GetXMLTreeAttribute(configure,"value");
if (attribute != (const char *) NULL)
configure_info->value=ConstantString(attribute);
status=AppendValueToLinkedList(configure_cache,configure_info);
if (status == WizardFalse)
(void) ThrowWizardException(exception,GetWizardModule(),
ResourceFatalError,"memory allocation failed `%s`",strerror(errno));
configure=GetNextXMLTreeTag(configure);
}
configure_map=DestroyXMLTree(configure_map);
return(status != 0 ? WizardTrue : WizardFalse);
}
static MagickBooleanType LoadTypeList(const char *xml,const char *filename,
const unsigned long depth,ExceptionInfo *exception)
{
char
font_path[MaxTextExtent];
const char
*attribute;
TypeInfo
*type_info = (TypeInfo *) NULL;
MagickBooleanType
status;
XMLTreeInfo
*type,
*type_map,
*include;
/*
Load the type map file.
*/
(void) LogMagickEvent(ConfigureEvent,GetMagickModule(),
"Loading type map \"%s\" ...",filename);
if (xml == (const char *) NULL)
return(MagickFalse);
if (type_list == (SplayTreeInfo *) NULL)
{
type_list=NewSplayTree(CompareSplayTreeString,(void *(*)(void *)) NULL,
DestroyTypeNode);
if (type_list == (SplayTreeInfo *) NULL)
{
ThrowFileException(exception,ResourceLimitError,
"MemoryAllocationFailed",filename);
return(MagickFalse);
}
}
type_map=NewXMLTree(xml,exception);
if (type_map == (XMLTreeInfo *) NULL)
return(MagickFalse);
status=MagickTrue;
include=GetXMLTreeChild(type_map,"include");
while (include != (XMLTreeInfo *) NULL)
{
/*
Process include element.
*/
attribute=GetXMLTreeAttribute(include,"file");
if (attribute != (const char *) NULL)
{
if (depth > 200)
(void) ThrowMagickException(exception,GetMagickModule(),
ConfigureError,"IncludeElementNestedTooDeeply","`%s'",attribute);
else
{
char
path[MaxTextExtent],
*xml;
ExceptionInfo
*sans_exception;
GetPathComponent(filename,HeadPath,path);
if (*path != '\0')
(void) ConcatenateMagickString(path,DirectorySeparator,
MaxTextExtent);
(void) ConcatenateMagickString(path,attribute,MaxTextExtent);
sans_exception=AcquireExceptionInfo();
xml=FileToString(path,~0,sans_exception);
sans_exception=DestroyExceptionInfo(sans_exception);
if (xml != (char *) NULL)
{
status=LoadTypeList(xml,path,depth+1,exception);
xml=DestroyString(xml);
}
}
}
include=GetNextXMLTreeTag(include);
}
*font_path='\0';
#if defined(__WINDOWS__)
if (NTGhostscriptFonts(font_path,MaxTextExtent-2))
(void) ConcatenateMagickString(font_path,DirectorySeparator,MaxTextExtent);
#endif
type=GetXMLTreeChild(type_map,"type");
while (type != (XMLTreeInfo *) NULL)
{
/*
Process type element.
*/
type_info=(TypeInfo *) AcquireMagickMemory(sizeof(*type_info));
if (type_info == (TypeInfo *) NULL)
ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
(void) ResetMagickMemory(type_info,0,sizeof(*type_info));
type_info->path=ConstantString(filename);
type_info->signature=MagickSignature;
attribute=GetXMLTreeAttribute(type,"encoding");
if (attribute != (const char *) NULL)
type_info->encoding=ConstantString(attribute);
attribute=GetXMLTreeAttribute(type,"face");
if (attribute != (const char *) NULL)
type_info->face=(unsigned long) atol(attribute);
attribute=GetXMLTreeAttribute(type,"family");
if (attribute != (const char *) NULL)
type_info->family=ConstantString(attribute);
attribute=GetXMLTreeAttribute(type,"format");
if (attribute != (const char *) NULL)
type_info->format=ConstantString(attribute);
attribute=GetXMLTreeAttribute(type,"foundry");
if (attribute != (const char *) NULL)
type_info->foundry=ConstantString(attribute);
attribute=GetXMLTreeAttribute(type,"fullname");
if (attribute != (const char *) NULL)
type_info->description=ConstantString(attribute);
attribute=GetXMLTreeAttribute(type,"glyphs");
if (attribute != (const char *) NULL)
{
char
*path;
path=ConstantString(attribute);
#if defined(__WINDOWS__)
if (strchr(path,'@') != (char *) NULL)
(void) SubstituteString(&path,"@ghostscript_font_path@",font_path);
#endif
type_info->glyphs=path;
}
attribute=GetXMLTreeAttribute(type,"metrics");
if (attribute != (const char *) NULL)
{
char
*path;
path=ConstantString(attribute);
#if defined(__WINDOWS__)
if (strchr(path,'@') != (char *) NULL)
(void) SubstituteString(&path,"@ghostscript_font_path@",font_path);
#endif
type_info->metrics=path;
}
attribute=GetXMLTreeAttribute(type,"name");
if (attribute != (const char *) NULL)
type_info->name=ConstantString(attribute);
attribute=GetXMLTreeAttribute(type,"stealth");
if (attribute != (const char *) NULL)
type_info->stealth=IsMagickTrue(attribute);
attribute=GetXMLTreeAttribute(type,"stretch");
if (attribute != (const char *) NULL)
type_info->stretch=(StretchType) ParseMagickOption(MagickStretchOptions,
MagickFalse,attribute);
attribute=GetXMLTreeAttribute(type,"style");
if (attribute != (const char *) NULL)
type_info->style=(StyleType) ParseMagickOption(MagickStyleOptions,
MagickFalse,attribute);
attribute=GetXMLTreeAttribute(type,"weight");
if (attribute != (const char *) NULL)
{
type_info->weight=(unsigned long) atol(attribute);
if (LocaleCompare(attribute,"bold") == 0)
type_info->weight=700;
if (LocaleCompare(attribute,"normal") == 0)
type_info->weight=400;
}
status=AddValueToSplayTree(type_list,type_info->name,type_info);
if (status == MagickFalse)
(void) ThrowMagickException(exception,GetMagickModule(),
ResourceLimitError,"MemoryAllocationFailed","`%s'",filename);
type=GetNextXMLTreeTag(type);
}
type_map=DestroyXMLTree(type_map);
return(status);
}