% November 1998 %
% %
% %
-% Copyright 1999-2010 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization %
% dedicated to making software imaging solutions freely available. %
% %
% You may not use this file except in compliance with the License. You may %
Include declarations.
*/
#include "magick/studio.h"
+#include "magick/annotate.h"
#include "magick/blob.h"
+#include "magick/blob-private.h"
#include "magick/cache.h"
#include "magick/coder.h"
#include "magick/client.h"
#include "magick/memory_.h"
#include "magick/mime.h"
#include "magick/module.h"
-#if defined(__WINDOWS__)
+#if defined(MAGICKCORE_WINDOWS_SUPPORT)
# include "magick/nt-feature.h"
#endif
#include "magick/random_.h"
#include "magick/resource_.h"
#include "magick/policy.h"
#include "magick/semaphore.h"
+#include "magick/semaphore-private.h"
#include "magick/signature-private.h"
#include "magick/splay-tree.h"
#include "magick/string_.h"
+#include "magick/string-private.h"
#include "magick/thread_.h"
#include "magick/thread-private.h"
#include "magick/token.h"
*magick_list = (SplayTreeInfo *) NULL;
static volatile MagickBooleanType
- instantiate_magick = MagickFalse; /* double-checked locking pattern */
+ instantiate_magick = MagickFalse,
+ instantiate_magickcore = MagickFalse;
\f
/*
Forward declarations.
if (p == (const MagickInfo *) NULL)
return(MagickFalse);
status=MagickFalse;
- (void) LockSemaphoreInfo(magick_semaphore);
+ LockSemaphoreInfo(magick_semaphore);
ResetSplayTreeIterator(magick_list);
p=(const MagickInfo *) GetNextValueInSplayTree(magick_list);
while (p != (const MagickInfo *) NULL)
}
p=(const MagickInfo *) GetNextValueInSplayTree(magick_list);
}
- (void) UnlockSemaphoreInfo(magick_semaphore);
+ UnlockSemaphoreInfo(magick_semaphore);
return(status);
}
\f
if (LocaleCompare(name,"*") == 0)
(void) OpenModules(exception);
#endif
- (void) LockSemaphoreInfo(magick_semaphore);
+ LockSemaphoreInfo(magick_semaphore);
ResetSplayTreeIterator(magick_list);
p=(const MagickInfo *) GetNextValueInSplayTree(magick_list);
- (void) UnlockSemaphoreInfo(magick_semaphore);
+ UnlockSemaphoreInfo(magick_semaphore);
return(p);
}
/*
Find name in list.
*/
- (void) LockSemaphoreInfo(magick_semaphore);
+ LockSemaphoreInfo(magick_semaphore);
ResetSplayTreeIterator(magick_list);
p=(const MagickInfo *) GetNextValueInSplayTree(magick_list);
while (p != (const MagickInfo *) NULL)
}
}
#endif
- (void) UnlockSemaphoreInfo(magick_semaphore);
+ UnlockSemaphoreInfo(magick_semaphore);
return(p);
}
\f
% The format of the GetMagickInfoList function is:
%
% const MagickInfo **GetMagickInfoList(const char *pattern,
-% unsigned long *number_formats,ExceptionInfo *exception)
+% size_t *number_formats,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
#endif
MagickExport const MagickInfo **GetMagickInfoList(const char *pattern,
- unsigned long *number_formats,ExceptionInfo *exception)
+ size_t *number_formats,ExceptionInfo *exception)
{
const MagickInfo
**formats;
register const MagickInfo
*p;
- register long
+ register ssize_t
i;
/*
*/
assert(pattern != (char *) NULL);
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",pattern);
- assert(number_formats != (unsigned long *) NULL);
+ assert(number_formats != (size_t *) NULL);
*number_formats=0;
p=GetMagickInfo("*",exception);
if (p == (const MagickInfo *) NULL)
/*
Generate magick list.
*/
- (void) LockSemaphoreInfo(magick_semaphore);
+ LockSemaphoreInfo(magick_semaphore);
ResetSplayTreeIterator(magick_list);
p=(const MagickInfo *) GetNextValueInSplayTree(magick_list);
for (i=0; p != (const MagickInfo *) NULL; )
formats[i++]=p;
p=(const MagickInfo *) GetNextValueInSplayTree(magick_list);
}
- (void) UnlockSemaphoreInfo(magick_semaphore);
+ UnlockSemaphoreInfo(magick_semaphore);
qsort((void *) formats,(size_t) i,sizeof(*formats),MagickInfoCompare);
formats[i]=(MagickInfo *) NULL;
- *number_formats=(unsigned long) i;
+ *number_formats=(size_t) i;
return(formats);
}
\f
%
% The format of the GetMagickList function is:
%
-% char **GetMagickList(const char *pattern,unsigned long *number_formats,
+% char **GetMagickList(const char *pattern,size_t *number_formats,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
#endif
MagickExport char **GetMagickList(const char *pattern,
- unsigned long *number_formats,ExceptionInfo *exception)
+ size_t *number_formats,ExceptionInfo *exception)
{
char
**formats;
register const MagickInfo
*p;
- register long
+ register ssize_t
i;
/*
*/
assert(pattern != (char *) NULL);
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",pattern);
- assert(number_formats != (unsigned long *) NULL);
+ assert(number_formats != (size_t *) NULL);
*number_formats=0;
p=GetMagickInfo("*",exception);
if (p == (const MagickInfo *) NULL)
GetNumberOfNodesInSplayTree(magick_list)+1UL,sizeof(*formats));
if (formats == (char **) NULL)
return((char **) NULL);
- (void) LockSemaphoreInfo(magick_semaphore);
+ LockSemaphoreInfo(magick_semaphore);
ResetSplayTreeIterator(magick_list);
p=(const MagickInfo *) GetNextValueInSplayTree(magick_list);
for (i=0; p != (const MagickInfo *) NULL; )
formats[i++]=ConstantString(p->name);
p=(const MagickInfo *) GetNextValueInSplayTree(magick_list);
}
- (void) UnlockSemaphoreInfo(magick_semaphore);
+ UnlockSemaphoreInfo(magick_semaphore);
qsort((void *) formats,(size_t) i,sizeof(*formats),MagickCompare);
formats[i]=(char *) NULL;
- *number_formats=(unsigned long) i;
+ *number_formats=(size_t) i;
return(formats);
}
\f
% %
% %
% %
-+ G e t M a g i c k E n d i a n S u p p o r t %
+% G e t M a g i c k P r e c i s i o n %
+% %
+% %
+% %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+% GetMagickPrecision() returns the maximum number of significant digits to be
+% printed.
+%
+% The format of the GetMagickPrecision method is:
+%
+% int GetMagickPrecision(void)
+%
+*/
+MagickExport int GetMagickPrecision(void)
+{
+#define MagickPrecision 6
+
+ (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
+ if (SetMagickPrecision(0) == 0)
+ {
+ char
+ *limit;
+
+ (void) SetMagickPrecision(MagickPrecision);
+ limit=GetEnvironmentValue("MAGICK_PRECISION");
+ if (limit == (char *) NULL)
+ limit=GetPolicyValue("precision");
+ if (limit != (char *) NULL)
+ {
+ (void) SetMagickPrecision(StringToInteger(limit));
+ limit=DestroyString(limit);
+ }
+ }
+ return(SetMagickPrecision(0));
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% %
+% %
+% %
++ G e t M a g i c k R a w S u p p o r t %
% %
% %
% %
{
if (magick_semaphore == (SemaphoreInfo *) NULL)
AcquireSemaphoreInfo(&magick_semaphore);
- (void) LockSemaphoreInfo(magick_semaphore);
+ LockSemaphoreInfo(magick_semaphore);
if ((magick_list == (SplayTreeInfo *) NULL) &&
(instantiate_magick == MagickFalse))
{
#endif
instantiate_magick=MagickTrue;
}
- (void) UnlockSemaphoreInfo(magick_semaphore);
+ UnlockSemaphoreInfo(magick_semaphore);
}
return(magick_list != (SplayTreeInfo *) NULL ? MagickTrue : MagickFalse);
}
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% IsMagickConflict() returns MagickTrue if the image format is not a valid
-% image format or conflicts with a logical drive (.e.g. X:).
+% IsMagickConflict() returns MagickTrue if the image format conflicts with a
+% logical drive (.e.g. X:).
%
% The format of the IsMagickConflict method is:
%
*/
MagickExport MagickBooleanType IsMagickConflict(const char *magick)
{
- const DelegateInfo
- *delegate_info;
-
- const MagickInfo
- *magick_info;
-
- ExceptionInfo
- *exception;
-
assert(magick != (char *) NULL);
- exception=AcquireExceptionInfo();
- magick_info=GetMagickInfo(magick,exception);
- delegate_info=GetDelegateInfo(magick,(char *) NULL,exception);
- if (delegate_info == (const DelegateInfo *) NULL)
- delegate_info=GetDelegateInfo((char *) NULL,magick,exception);
- exception=DestroyExceptionInfo(exception);
- if ((magick_info == (const MagickInfo *) NULL) &&
- (delegate_info == (const DelegateInfo *) NULL))
- return(MagickTrue);
#if defined(macintosh)
return(MACIsMagickConflict(magick));
#elif defined(vms)
return(VMSIsMagickConflict(magick));
-#elif defined(__WINDOWS__)
+#elif defined(MAGICKCORE_WINDOWS_SUPPORT)
return(NTIsMagickConflict(magick));
#else
return(MagickFalse);
const MagickInfo
**magick_info;
- long
- j;
-
- register long
+ register ssize_t
i;
- unsigned long
+ size_t
number_formats;
+ ssize_t
+ j;
+
if (file == (FILE *) NULL)
file=stdout;
magick_info=GetMagickInfoList("*",&number_formats,exception);
return(MagickFalse);
ClearMagickException(exception);
#if !defined(MAGICKCORE_MODULES_SUPPORT)
- (void) fprintf(file," Format Mode Description\n");
+ (void) FormatLocaleFile(file," Format Mode Description\n");
#else
- (void) fprintf(file," Format Module Mode Description\n");
+ (void) FormatLocaleFile(file," Format Module Mode Description\n");
#endif
- (void) fprintf(file,"--------------------------------------------------------"
+ (void) FormatLocaleFile(file,
+ "--------------------------------------------------------"
"-----------------------\n");
- for (i=0; i < (long) number_formats; i++)
+ for (i=0; i < (ssize_t) number_formats; i++)
{
if (magick_info[i]->stealth != MagickFalse)
continue;
- (void) fprintf(file,"%9s%c ",magick_info[i]->name != (char *) NULL ?
- magick_info[i]->name : "",
+ (void) FormatLocaleFile(file,"%9s%c ",
+ magick_info[i]->name != (char *) NULL ? magick_info[i]->name : "",
magick_info[i]->blob_support != MagickFalse ? '*' : ' ');
#if defined(MAGICKCORE_MODULES_SUPPORT)
{
(void) CopyMagickString(module,magick_info[i]->module,MaxTextExtent);
(void) ConcatenateMagickString(module," ",MaxTextExtent);
module[9]='\0';
- (void) fprintf(file,"%9s ",module);
+ (void) FormatLocaleFile(file,"%9s ",module);
}
#endif
- (void) fprintf(file,"%c%c%c ",magick_info[i]->decoder ? 'r' : '-',
+ (void) FormatLocaleFile(file,"%c%c%c ",magick_info[i]->decoder ? 'r' : '-',
magick_info[i]->encoder ? 'w' : '-',magick_info[i]->encoder != NULL &&
magick_info[i]->adjoin != MagickFalse ? '+' : '-');
if (magick_info[i]->description != (char *) NULL)
- (void) fprintf(file," %s",magick_info[i]->description);
+ (void) FormatLocaleFile(file," %s",magick_info[i]->description);
if (magick_info[i]->version != (char *) NULL)
- (void) fprintf(file," (%s)",magick_info[i]->version);
- (void) fprintf(file,"\n");
+ (void) FormatLocaleFile(file," (%s)",magick_info[i]->version);
+ (void) FormatLocaleFile(file,"\n");
if (magick_info[i]->note != (char *) NULL)
{
char
{
for (j=0; text[j] != (char *) NULL; j++)
{
- (void) fprintf(file," %s\n",text[j]);
+ (void) FormatLocaleFile(file," %s\n",text[j]);
text[j]=DestroyString(text[j]);
}
text=(char **) RelinquishMagickMemory(text);
}
}
}
- (void) fprintf(file,"\n* native blob support\n");
- (void) fprintf(file,"r read support\n");
- (void) fprintf(file,"w write support\n");
- (void) fprintf(file,"+ support for multiple images\n");
+ (void) FormatLocaleFile(file,"\n* native blob support\n");
+ (void) FormatLocaleFile(file,"r read support\n");
+ (void) FormatLocaleFile(file,"w write support\n");
+ (void) FormatLocaleFile(file,"+ support for multiple images\n");
(void) fflush(file);
magick_info=(const MagickInfo **) RelinquishMagickMemory((void *)
magick_info);
{
if (magick_semaphore == (SemaphoreInfo *) NULL)
AcquireSemaphoreInfo(&magick_semaphore);
- (void) LockSemaphoreInfo(magick_semaphore);
+ LockSemaphoreInfo(magick_semaphore);
if (magick_list != (SplayTreeInfo *) NULL)
magick_list=DestroySplayTree(magick_list);
instantiate_magick=MagickFalse;
- (void) UnlockSemaphoreInfo(magick_semaphore);
+ UnlockSemaphoreInfo(magick_semaphore);
DestroySemaphoreInfo(&magick_semaphore);
}
\f
if (signal_handlers[signal_number] != MagickSignalHandler)
raise(signal_number);
#endif
+#if defined(SIGQUIT)
+ if (signal_number == SIGQUIT)
+ abort();
+#endif
+#if defined(SIGABRT)
+ if (signal_number == SIGABRT)
+ abort();
+#endif
+#if defined(SIGFPE)
+ if (signal_number == SIGFPE)
+ abort();
+#endif
+#if defined(SIGXCPU)
+ if (signal_number == SIGXCPU)
+ abort();
+#endif
+#if defined(SIGXFSZ)
+ if (signal_number == SIGXFSZ)
+ abort();
+#endif
+#if defined(SIGSEGV)
+ if (signal_number == SIGSEGV)
+ abort();
+#endif
#if !defined(MAGICKCORE_HAVE__EXIT)
exit(signal_number);
#else
if (signal_number == SIGHUP)
exit(signal_number);
#endif
-#if defined(SIGINT) && !defined(__WINDOWS__)
+#if defined(SIGINT) && !defined(MAGICKCORE_WINDOWS_SUPPORT)
if (signal_number == SIGINT)
exit(signal_number);
#endif
if (signal_number == SIGTERM)
exit(signal_number);
#endif
- _exit(signal_number);
+ _exit(signal_number); /* do not invoke registered atexit() methods */
#endif
}
/*
Initialize the Magick environment.
*/
- (void) setlocale(LC_ALL,"");
- (void) setlocale(LC_NUMERIC,"C");
+ LockMagickMutex();
+ if (instantiate_magickcore != MagickFalse)
+ {
+ UnlockMagickMutex();
+ return;
+ }
(void) SemaphoreComponentGenesis();
(void) LogComponentGenesis();
(void) LocaleComponentGenesis();
(void) SetLogEventMask(events);
events=DestroyString(events);
}
-#if defined(__WINDOWS__)
+#if defined(MAGICKCORE_WINDOWS_SUPPORT)
#if defined(_DEBUG) && !defined(__BORLANDC__) && !defined(__MINGW32__)
if (IsEventLogging() != MagickFalse)
{
if (signal_handlers[SIGABRT] == (SignalHandler *) NULL)
signal_handlers[SIGABRT]=RegisterMagickSignalHandler(SIGABRT);
#endif
+#if defined(SIGSEGV)
+ if (signal_handlers[SIGSEGV] == (SignalHandler *) NULL)
+ signal_handlers[SIGSEGV]=RegisterMagickSignalHandler(SIGSEGV);
+#endif
#if defined(SIGFPE)
if (signal_handlers[SIGFPE] == (SignalHandler *) NULL)
signal_handlers[SIGFPE]=RegisterMagickSignalHandler(SIGFPE);
if (signal_handlers[SIGHUP] == (SignalHandler *) NULL)
signal_handlers[SIGHUP]=RegisterMagickSignalHandler(SIGHUP);
#endif
-#if defined(SIGINT) && !defined(__WINDOWS__)
+#if defined(SIGINT) && !defined(MAGICKCORE_WINDOWS_SUPPORT)
if (signal_handlers[SIGINT] == (SignalHandler *) NULL)
signal_handlers[SIGINT]=RegisterMagickSignalHandler(SIGINT);
#endif
(void) TypeComponentGenesis();
(void) MimeComponentGenesis();
(void) ConstituteComponentGenesis();
+ (void) AnnotateComponentGenesis();
+#if defined(MAGICKCORE_X11_DELEGATE)
(void) XComponentGenesis();
+#endif
+ instantiate_magickcore=MagickTrue;
+ UnlockMagickMutex();
}
\f
/*
*/
MagickExport void MagickCoreTerminus(void)
{
+ LockMagickMutex();
+ if (instantiate_magickcore == MagickFalse)
+ {
+ UnlockMagickMutex();
+ return;
+ }
#if defined(MAGICKCORE_X11_DELEGATE)
XComponentTerminus();
#endif
+ AnnotateComponentTerminus();
ConstituteComponentTerminus();
MimeComponentTerminus();
TypeComponentTerminus();
ColorComponentTerminus();
-#if defined(__WINDOWS__)
+#if defined(MAGICKCORE_WINDOWS_SUPPORT)
NTGhostscriptUnLoadDLL();
#endif
MagicComponentTerminus();
LocaleComponentTerminus();
LogComponentTerminus();
SemaphoreComponentTerminus();
- instantiate_magick=MagickFalse;
+ instantiate_magickcore=MagickFalse;
+ UnlockMagickMutex();
}
\f
/*
assert(name != (const char *) NULL);
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",name);
- magick_info=(MagickInfo *) AcquireAlignedMemory(1,sizeof(*magick_info));
+ magick_info=(MagickInfo *) AcquireMagickMemory(sizeof(*magick_info));
if (magick_info == (MagickInfo *) NULL)
ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
(void) ResetMagickMemory(magick_info,0,sizeof(*magick_info));
% %
% %
% %
+% S e t M a g i c k P r e c i s i o n %
+% %
+% %
+% %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+% SetMagickPrecision() sets the maximum number of significant digits to be
+% printed and returns it.
+%
+% The format of the SetMagickPrecision method is:
+%
+% int SetMagickPrecision(const int precision)
+%
+% A description of each parameter follows:
+%
+% o precision: set the maximum number of significant digits to be printed.
+%
+*/
+MagickExport int SetMagickPrecision(const int precision)
+{
+ static int
+ magick_precision = 0;
+
+ (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
+ if (precision != 0)
+ magick_precision=precision;
+ return(magick_precision);
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% %
+% %
+% %
+ U n r e g i s t e r M a g i c k I n f o %
% %
% %
return(MagickFalse);
if (GetNumberOfNodesInSplayTree(magick_list) == 0)
return(MagickFalse);
- (void) LockSemaphoreInfo(magick_semaphore);
+ LockSemaphoreInfo(magick_semaphore);
ResetSplayTreeIterator(magick_list);
p=(const MagickInfo *) GetNextValueInSplayTree(magick_list);
while (p != (const MagickInfo *) NULL)
p=(const MagickInfo *) GetNextValueInSplayTree(magick_list);
}
status=DeleteNodeByValueFromSplayTree(magick_list,p);
- (void) UnlockSemaphoreInfo(magick_semaphore);
+ UnlockSemaphoreInfo(magick_semaphore);
return(status);
}
projects / imagemagick / blobdiff