Use AcquireCriticalMemory.

diff --git a/MagickCore/blob.c b/MagickCore/blob.c
index a76669e13298d58dba1937ceaa4cc53ae43236b3..8b9ae41b0728ca944c5fc9d3d0fd570b89f2a4b2 100644 (file)
--- a/MagickCore/blob.c
+++ b/MagickCore/blob.c
@@ -59,6 +59,7 @@
 #include "MagickCore/log.h"
 #include "MagickCore/magick.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/nt-base-private.h"
 #include "MagickCore/option.h"
 #include "MagickCore/policy.h"
@@ -218,10 +219,8 @@ MagickExport CustomStreamInfo *AcquireCustomStreamInfo(
     *custom_stream;
 
   magick_unreferenced(exception);
-  custom_stream=(CustomStreamInfo *) AcquireMagickMemory(
+  custom_stream=(CustomStreamInfo *) AcquireCriticalMemory(
     sizeof(*custom_stream));
-  if (custom_stream == (CustomStreamInfo *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   (void) ResetMagickMemory(custom_stream,0,sizeof(*custom_stream));
   custom_stream->signature=MagickCoreSignature;
   return(custom_stream);
@@ -538,9 +537,7 @@ MagickExport BlobInfo *CloneBlobInfo(const BlobInfo *blob_info)
   BlobInfo
     *clone_info;
 
-  clone_info=(BlobInfo *) AcquireMagickMemory(sizeof(*clone_info));
-  if (clone_info == (BlobInfo *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+  clone_info=(BlobInfo *) AcquireCriticalMemory(sizeof(*clone_info));
   GetBlobInfo(clone_info);
   if (blob_info == (BlobInfo *) NULL)
     return(clone_info);

diff --git a/MagickCore/cache.c b/MagickCore/cache.c
index 585ef8a9df96d7fd4441358e066aec386bf03c3f..bc8eaf65f872235874bc82908c3934b3d4713bba 100644 (file)
--- a/MagickCore/cache.c
+++ b/MagickCore/cache.c
@@ -189,9 +189,7 @@ MagickPrivate Cache AcquirePixelCache(const size_t number_threads)
   char
     *value;
 
-  cache_info=(CacheInfo *) AcquireQuantumMemory(1,sizeof(*cache_info));
-  if (cache_info == (CacheInfo *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+  cache_info=(CacheInfo *) AcquireCriticalMemory(sizeof(*cache_info));
   (void) ResetMagickMemory(cache_info,0,sizeof(*cache_info));
   cache_info->type=UndefinedCache;
   cache_info->mode=IOMode;

diff --git a/MagickCore/cipher.c b/MagickCore/cipher.c
index 417b238664cb613eb309c8cd949cf5abdecc8adc..9083e5a8a17d65517125d81b4aa3f02fd2191260 100644 (file)
--- a/MagickCore/cipher.c
+++ b/MagickCore/cipher.c
@@ -48,6 +48,7 @@
 #include "MagickCore/linked-list.h"
 #include "MagickCore/list.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/monitor.h"
 #include "MagickCore/monitor-private.h"
 #include "MagickCore/property.h"
@@ -190,9 +191,7 @@ static AESInfo *AcquireAESInfo(void)
   AESInfo
     *aes_info;
 
-  aes_info=(AESInfo *) AcquireMagickMemory(sizeof(*aes_info));
-  if (aes_info == (AESInfo *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+  aes_info=(AESInfo *) AcquireCriticalMemory(sizeof(*aes_info));
   (void) ResetMagickMemory(aes_info,0,sizeof(*aes_info));
   aes_info->blocksize=AESBlocksize;
   aes_info->key=AcquireStringInfo(32);

diff --git a/MagickCore/coder.c b/MagickCore/coder.c
index 0c647d5e7ea0891da3729040f0c8ee7be6fdef6b..0eecfedf1bfb0bd94eb690fd481d0d20562c10a2 100644 (file)
--- a/MagickCore/coder.c
+++ b/MagickCore/coder.c
@@ -51,6 +51,7 @@
 #include "MagickCore/linked-list.h"
 #include "MagickCore/log.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/option.h"
 #include "MagickCore/semaphore.h"
 #include "MagickCore/string_.h"
@@ -898,9 +899,7 @@ static MagickBooleanType LoadCoderCache(SplayTreeInfo *cache,const char *xml,
         /*
           Coder element.
         */
-        coder_info=(CoderInfo *) AcquireMagickMemory(sizeof(*coder_info));
-        if (coder_info == (CoderInfo *) NULL)
-          ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+        coder_info=(CoderInfo *) AcquireCriticalMemory(sizeof(*coder_info));
         (void) ResetMagickMemory(coder_info,0,sizeof(*coder_info));
         coder_info->path=ConstantString(filename);
         coder_info->exempt=MagickFalse;

diff --git a/MagickCore/color.c b/MagickCore/color.c
index 5f938c8ed81abb8a5b439c55ddee4c1746ddc63e..df5735f8934a046d1aae52c4c178a6cf27bc4343 100644 (file)
--- a/MagickCore/color.c
+++ b/MagickCore/color.c
@@ -56,6 +56,7 @@
 #include "MagickCore/geometry.h"
 #include "MagickCore/image-private.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/monitor.h"
 #include "MagickCore/monitor-private.h"
 #include "MagickCore/option.h"
@@ -2100,9 +2101,7 @@ static MagickBooleanType LoadColorCache(LinkedListInfo *cache,const char *xml,
         /*
           Color element.
         */
-        color_info=(ColorInfo *) AcquireMagickMemory(sizeof(*color_info));
-        if (color_info == (ColorInfo *) NULL)
-          ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+        color_info=(ColorInfo *) AcquireCriticalMemory(sizeof(*color_info));
         (void) ResetMagickMemory(color_info,0,sizeof(*color_info));
         color_info->path=ConstantString(filename);
         color_info->exempt=MagickFalse;

diff --git a/MagickCore/configure.c b/MagickCore/configure.c
index a64123beef4827e391d3ecde053135152b78e1e6..52dd6ac9abc05e05809c867c69bca7f4d8111e0f 100644 (file)
--- a/MagickCore/configure.c
+++ b/MagickCore/configure.c
@@ -49,6 +49,7 @@
 #include "MagickCore/linked-list.h"
 #include "MagickCore/log.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/semaphore.h"
 #include "MagickCore/string_.h"
 #include "MagickCore/string-private.h"
@@ -1246,10 +1247,8 @@ static MagickBooleanType LoadConfigureCache(LinkedListInfo *cache,
         /*
           Configure element.
         */
-        configure_info=(ConfigureInfo *) AcquireMagickMemory(
+        configure_info=(ConfigureInfo *) AcquireCriticalMemory(
           sizeof(*configure_info));
-        if (configure_info == (ConfigureInfo *) NULL)
-          ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
         (void) ResetMagickMemory(configure_info,0,sizeof(*configure_info));
         configure_info->path=ConstantString(filename);
         configure_info->exempt=MagickFalse;

diff --git a/MagickCore/delegate.c b/MagickCore/delegate.c
index 535df8d5823b3c9b18bdb884b9cc8b238caa9fec..88fb7cfd9ae66964e2fdeb9ce5a387ade8248bc6 100644 (file)
--- a/MagickCore/delegate.c
+++ b/MagickCore/delegate.c
@@ -61,6 +61,7 @@
 #include "MagickCore/linked-list.h"
 #include "MagickCore/list.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/nt-base-private.h"
 #include "MagickCore/option.h"
 #include "MagickCore/policy.h"
@@ -2095,10 +2096,8 @@ static MagickBooleanType LoadDelegateCache(LinkedListInfo *cache,
         /*
           Delegate element.
         */
-        delegate_info=(DelegateInfo *) AcquireMagickMemory(
+        delegate_info=(DelegateInfo *) AcquireCriticalMemory(
           sizeof(*delegate_info));
-        if (delegate_info == (DelegateInfo *) NULL)
-          ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
         (void) ResetMagickMemory(delegate_info,0,sizeof(*delegate_info));
         delegate_info->path=ConstantString(filename);
         delegate_info->thread_support=MagickTrue;

diff --git a/MagickCore/distribute-cache.c b/MagickCore/distribute-cache.c
index e9ddcf40f0170993ee9992859a485e3a4918c0de..6fe3d6c5c9b1f409f5bcdc9ae7b566445345b14d 100644 (file)
--- a/MagickCore/distribute-cache.c
+++ b/MagickCore/distribute-cache.c
@@ -64,6 +64,7 @@
 #include "MagickCore/list.h"
 #include "MagickCore/locale_.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/nt-base-private.h"
 #include "MagickCore/pixel.h"
 #include "MagickCore/policy.h"
@@ -338,9 +339,8 @@ MagickPrivate DistributeCacheInfo *AcquireDistributeCacheInfo(
   /*
     Connect to the distributed pixel cache server.
   */
-  server_info=(DistributeCacheInfo *) AcquireMagickMemory(sizeof(*server_info));
-  if (server_info == (DistributeCacheInfo *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+  server_info=(DistributeCacheInfo *) AcquireCriticalMemory(
+    sizeof(*server_info));
   (void) ResetMagickMemory(server_info,0,sizeof(*server_info));
   server_info->signature=MagickCoreSignature;
   server_info->port=0;

diff --git a/MagickCore/draw.c b/MagickCore/draw.c
index a3a93a756b688d14c606c94a1c17320c987417d6..a31976117a8e9ec42905b7e039dda2927d44f1b8 100644 (file)
--- a/MagickCore/draw.c
+++ b/MagickCore/draw.c
@@ -68,6 +68,7 @@
 #include "MagickCore/image-private.h"
 #include "MagickCore/list.h"
 #include "MagickCore/log.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/monitor.h"
 #include "MagickCore/monitor-private.h"
 #include "MagickCore/option.h"
@@ -206,9 +207,7 @@ MagickExport DrawInfo *AcquireDrawInfo(void)
   DrawInfo
     *draw_info;
 
-  draw_info=(DrawInfo *) AcquireMagickMemory(sizeof(*draw_info));
-  if (draw_info == (DrawInfo *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+  draw_info=(DrawInfo *) AcquireCriticalMemory(sizeof(*draw_info));
   GetDrawInfo((ImageInfo *) NULL,draw_info);
   return(draw_info);
 }
@@ -249,9 +248,7 @@ MagickExport DrawInfo *CloneDrawInfo(const ImageInfo *image_info,
   ExceptionInfo
     *exception;
 
-  clone_info=(DrawInfo *) AcquireMagickMemory(sizeof(*clone_info));
-  if (clone_info == (DrawInfo *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+  clone_info=(DrawInfo *) AcquireCriticalMemory(sizeof(*clone_info));
   GetDrawInfo(image_info,clone_info);
   if (draw_info == (DrawInfo *) NULL)
     return(clone_info);

diff --git a/MagickCore/exception.c b/MagickCore/exception.c
index 5c7e1951a1092a4f25552b4e18c4e4422fced68c..420d4ce3299d3050936708440c26468d52355de2 100644 (file)
--- a/MagickCore/exception.c
+++ b/MagickCore/exception.c
@@ -49,6 +49,7 @@
 #include "MagickCore/log.h"
 #include "MagickCore/magick.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/string_.h"
 #include "MagickCore/utility.h"
 #include "MagickCore/utility-private.h"
@@ -109,9 +110,7 @@ MagickExport ExceptionInfo *AcquireExceptionInfo(void)
   ExceptionInfo
     *exception;
 
-  exception=(ExceptionInfo *) AcquireMagickMemory(sizeof(*exception));
-  if (exception == (ExceptionInfo *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+  exception=(ExceptionInfo *) AcquireCriticalMemory(sizeof(*exception));
   InitializeExceptionInfo(exception);
   exception->relinquish=MagickTrue;
   return(exception);
@@ -260,9 +259,7 @@ MagickExport ExceptionInfo *CloneExceptionInfo(ExceptionInfo *exception)
   ExceptionInfo
     *clone_exception;
 
-  clone_exception=(ExceptionInfo *) AcquireMagickMemory(sizeof(*exception));
-  if (clone_exception == (ExceptionInfo *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+  clone_exception=(ExceptionInfo *) AcquireCriticalMemory(sizeof(*exception));
   InitializeExceptionInfo(clone_exception);
   InheritException(clone_exception,exception);
   clone_exception->relinquish=MagickTrue;

diff --git a/MagickCore/fx.c b/MagickCore/fx.c
index c2edd84bea815f6e77ba96e55824f209dd4673a0..c2264b469a8cb6a8f1ffa61f8e6223cd1f66c4dc 100644 (file)
--- a/MagickCore/fx.c
+++ b/MagickCore/fx.c
@@ -71,6 +71,7 @@
 #include "MagickCore/image-private.h"
 #include "MagickCore/magick.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/monitor.h"
 #include "MagickCore/monitor-private.h"
 #include "MagickCore/option.h"
@@ -174,9 +175,7 @@ MagickPrivate FxInfo *AcquireFxInfo(const Image *images,const char *expression,
   register ssize_t
     i;
 
-  fx_info=(FxInfo *) AcquireMagickMemory(sizeof(*fx_info));
-  if (fx_info == (FxInfo *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+  fx_info=(FxInfo *) AcquireCriticalMemory(sizeof(*fx_info));
   (void) ResetMagickMemory(fx_info,0,sizeof(*fx_info));
   fx_info->exception=AcquireExceptionInfo();
   fx_info->images=images;

diff --git a/MagickCore/image-view.c b/MagickCore/image-view.c
index 2d092d6f2929bb10cc360af64c9fdbc21b483826..f26f2df676a48caa643f2f3e0661aa06ff7fb7f3 100644 (file)
--- a/MagickCore/image-view.c
+++ b/MagickCore/image-view.c
@@ -48,6 +48,7 @@
 #include "MagickCore/studio.h"
 #include "MagickCore/MagickCore.h"
 #include "MagickCore/exception-private.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/monitor-private.h"
 #include "MagickCore/thread-private.h"
 \f
@@ -107,9 +108,7 @@ MagickExport ImageView *CloneImageView(const ImageView *image_view)
 
   assert(image_view != (ImageView *) NULL);
   assert(image_view->signature == MagickCoreSignature);
-  clone_view=(ImageView *) AcquireMagickMemory(sizeof(*clone_view));
-  if (clone_view == (ImageView *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+  clone_view=(ImageView *) AcquireCriticalMemory(sizeof(*clone_view));
   (void) ResetMagickMemory(clone_view,0,sizeof(*clone_view));
   clone_view->description=ConstantString(image_view->description);
   clone_view->extent=image_view->extent;
@@ -720,9 +719,7 @@ MagickExport ImageView *NewImageView(Image *image,ExceptionInfo *exception)
 
   assert(image != (Image *) NULL);
   assert(image->signature == MagickCoreSignature);
-  image_view=(ImageView *) AcquireMagickMemory(sizeof(*image_view));
-  if (image_view == (ImageView *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+  image_view=(ImageView *) AcquireCriticalMemory(sizeof(*image_view));
   (void) ResetMagickMemory(image_view,0,sizeof(*image_view));
   image_view->description=ConstantString("ImageView");
   image_view->image=image;
@@ -776,9 +773,7 @@ MagickExport ImageView *NewImageViewRegion(Image *image,const ssize_t x,
 
   assert(image != (Image *) NULL);
   assert(image->signature == MagickCoreSignature);
-  image_view=(ImageView *) AcquireMagickMemory(sizeof(*image_view));
-  if (image_view == (ImageView *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+  image_view=(ImageView *) AcquireCriticalMemory(sizeof(*image_view));
   (void) ResetMagickMemory(image_view,0,sizeof(*image_view));
   image_view->description=ConstantString("ImageView");
   image_view->view=AcquireVirtualCacheView(image_view->image,exception);

diff --git a/MagickCore/image.c b/MagickCore/image.c
index c843faa7d42170a5b8087554c5b49087449471a7..d6a529f6237b80efe65b4ef72f9ba7b13f403d3a 100644 (file)
--- a/MagickCore/image.c
+++ b/MagickCore/image.c
@@ -75,6 +75,7 @@
 #include "MagickCore/magick.h"
 #include "MagickCore/magick-private.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/module.h"
 #include "MagickCore/monitor.h"
 #include "MagickCore/monitor-private.h"
@@ -166,9 +167,7 @@ MagickExport Image *AcquireImage(const ImageInfo *image_info,
     Allocate image structure.
   */
   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
-  image=(Image *) AcquireMagickMemory(sizeof(*image));
-  if (image == (Image *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+  image=(Image *) AcquireCriticalMemory(sizeof(*image));
   (void) ResetMagickMemory(image,0,sizeof(*image));
   /*
     Initialize Image structure.
@@ -344,9 +343,7 @@ MagickExport ImageInfo *AcquireImageInfo(void)
   ImageInfo
     *image_info;
 
-  image_info=(ImageInfo *) AcquireMagickMemory(sizeof(*image_info));
-  if (image_info == (ImageInfo *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+  image_info=(ImageInfo *) AcquireCriticalMemory(sizeof(*image_info));
   GetImageInfo(image_info);
   return(image_info);
 }

diff --git a/MagickCore/linked-list.c b/MagickCore/linked-list.c
index 66cc63c344a2ba180ffcc1e50182161f14e7eb44..496b002a87cae94ea874091edc2f574a44a90582 100644 (file)
--- a/MagickCore/linked-list.c
+++ b/MagickCore/linked-list.c
@@ -48,6 +48,7 @@
 #include "MagickCore/linked-list.h"\r
 #include "MagickCore/locale_.h"\r
 #include "MagickCore/memory_.h"\r
+#include "MagickCore/memory-private.h"\r
 #include "MagickCore/semaphore.h"\r
 #include "MagickCore/signature-private.h"\r
 #include "MagickCore/string_.h"\r
@@ -714,9 +715,7 @@ MagickExport LinkedListInfo *NewLinkedList(const size_t capacity)
   LinkedListInfo\r
     *list_info;\r
 \r
-  list_info=(LinkedListInfo *) AcquireMagickMemory(sizeof(*list_info));\r
-  if (list_info == (LinkedListInfo *) NULL)\r
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");\r
+  list_info=(LinkedListInfo *) AcquireCriticalMemory(sizeof(*list_info));\r
   (void) ResetMagickMemory(list_info,0,sizeof(*list_info));\r
   list_info->capacity=capacity == 0 ? (size_t) (~0) : capacity;\r
   list_info->elements=0;\r

diff --git a/MagickCore/locale.c b/MagickCore/locale.c
index acd6559885978464b2addec9caf790b4c19eff23..74cb084b99fd09d2c363d63d1196399ad7e115aa 100644 (file)
--- a/MagickCore/locale.c
+++ b/MagickCore/locale.c
@@ -51,6 +51,7 @@
 #include "MagickCore/locale-private.h"
 #include "MagickCore/log.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/nt-base-private.h"
 #include "MagickCore/semaphore.h"
 #include "MagickCore/splay-tree.h"
@@ -1326,9 +1327,7 @@ static MagickBooleanType LoadLocaleCache(SplayTreeInfo *cache,const char *xml,
           q--;
         (void) CopyMagickString(message,p,MagickMin((size_t) (q-p+2),
           MagickLocaleExtent));
-        locale_info=(LocaleInfo *) AcquireMagickMemory(sizeof(*locale_info));
-        if (locale_info == (LocaleInfo *) NULL)
-          ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+        locale_info=(LocaleInfo *) AcquireCriticalMemory(sizeof(*locale_info));
         (void) ResetMagickMemory(locale_info,0,sizeof(*locale_info));
         locale_info->path=ConstantString(filename);
         locale_info->tag=ConstantString(tag);

diff --git a/MagickCore/log.c b/MagickCore/log.c
index 39eba095cbfbf8160b07c4aab9e94659aeeb36a2..8d19d9a9c9c4140a8aa549c1b7fc36eb6be5492c 100644 (file)
--- a/MagickCore/log.c
+++ b/MagickCore/log.c
@@ -50,6 +50,7 @@
 #include "MagickCore/log.h"
 #include "MagickCore/log-private.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/nt-base-private.h"
 #include "MagickCore/option.h"
 #include "MagickCore/semaphore.h"
@@ -1528,9 +1529,7 @@ static MagickBooleanType LoadLogCache(LinkedListInfo *cache,const char *xml,
         /*
           Allocate memory for the log list.
         */
-        log_info=(LogInfo *) AcquireMagickMemory(sizeof(*log_info));
-        if (log_info == (LogInfo *) NULL)
-          ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+        log_info=(LogInfo *) AcquireCriticalMemory(sizeof(*log_info));
         (void) ResetMagickMemory(log_info,0,sizeof(*log_info));
         log_info->path=ConstantString(filename);
         GetTimerInfo((TimerInfo *) &log_info->timer);

diff --git a/MagickCore/magic.c b/MagickCore/magic.c
index ba861c00583be13bca10e34f708775e1913122ab..d1c4213cb2c1331da55d469409bcfd0b6cf5c3c1 100644 (file)
--- a/MagickCore/magic.c
+++ b/MagickCore/magic.c
@@ -50,6 +50,7 @@
 #include "MagickCore/magic.h"
 #include "MagickCore/magic-private.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/semaphore.h"
 #include "MagickCore/string_.h"
 #include "MagickCore/string-private.h"
@@ -929,9 +930,7 @@ static MagickBooleanType LoadMagicCache(LinkedListInfo *cache,const char *xml,
         /*
           Magic element.
         */
-        magic_info=(MagicInfo *) AcquireMagickMemory(sizeof(*magic_info));
-        if (magic_info == (MagicInfo *) NULL)
-          ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+        magic_info=(MagicInfo *) AcquireCriticalMemory(sizeof(*magic_info));
         (void) ResetMagickMemory(magic_info,0,sizeof(*magic_info));
         magic_info->path=ConstantString(filename);
         magic_info->exempt=MagickFalse;

diff --git a/MagickCore/magick.c b/MagickCore/magick.c
index 0a6ae99f98cbae484875065a6193d622c80944b1..0df76eace5e983b94a287d8e40492daab7be365a 100644 (file)
--- a/MagickCore/magick.c
+++ b/MagickCore/magick.c
@@ -61,6 +61,7 @@
 #include "MagickCore/magick.h"
 #include "MagickCore/magick-private.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/mime-private.h"
 #include "MagickCore/module.h"
 #include "MagickCore/module-private.h"
@@ -174,9 +175,7 @@ MagickExport MagickInfo *AcquireMagickInfo(const char *module,
   assert(name != (const char *) NULL);
   assert(description != (const char *) NULL);
   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",name);
-  magick_info=(MagickInfo *) AcquireMagickMemory(sizeof(*magick_info));
-  if (magick_info == (MagickInfo *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+  magick_info=(MagickInfo *) AcquireCriticalMemory(sizeof(*magick_info));
   (void) ResetMagickMemory(magick_info,0,sizeof(*magick_info));
   magick_info->module=ConstantString(module);
   magick_info->name=ConstantString(name);

diff --git a/MagickCore/mime.c b/MagickCore/mime.c
index a6dcf742d999e1ecdd2fc77467a5165d43e7fec1..40b86316688c84c918dffc7b6b5621a664aef359 100644 (file)
--- a/MagickCore/mime.c
+++ b/MagickCore/mime.c
@@ -46,6 +46,7 @@
 #include "MagickCore/exception-private.h"
 #include "MagickCore/linked-list.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/mime.h"
 #include "MagickCore/mime-private.h"
 #include "MagickCore/option.h"
@@ -859,9 +860,7 @@ static MagickBooleanType LoadMimeCache(LinkedListInfo *cache,const char *xml,
     /*
       Process mime element.
     */
-    mime_info=(MimeInfo *) AcquireMagickMemory(sizeof(*mime_info));
-    if (mime_info == (MimeInfo *) NULL)
-      ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+    mime_info=(MimeInfo *) AcquireCriticalMemory(sizeof(*mime_info));
     (void) ResetMagickMemory(mime_info,0,sizeof(*mime_info));
     mime_info->path=ConstantString(filename);
     mime_info->signature=MagickCoreSignature;

diff --git a/MagickCore/module.c b/MagickCore/module.c
index 24487e16acfc41685f55fed6fd1a5687703f513f..10ee4944166e18c4f21e769a90dfed91f731ee69 100644 (file)
--- a/MagickCore/module.c
+++ b/MagickCore/module.c
@@ -52,6 +52,7 @@
 #include "MagickCore/magic.h"
 #include "MagickCore/magick.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/module.h"
 #include "MagickCore/module-private.h"
 #include "MagickCore/nt-base-private.h"
@@ -140,9 +141,7 @@ MagickExport ModuleInfo *AcquireModuleInfo(const char *path,const char *tag)
   ModuleInfo
     *module_info;
 
-  module_info=(ModuleInfo *) AcquireMagickMemory(sizeof(*module_info));
-  if (module_info == (ModuleInfo *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+  module_info=(ModuleInfo *) AcquireCriticalMemory(sizeof(*module_info));
   (void) ResetMagickMemory(module_info,0,sizeof(*module_info));
   if (path != (const char *) NULL)
     module_info->path=ConstantString(path);

diff --git a/MagickCore/montage.c b/MagickCore/montage.c
index 7b64e667c76f2e3a60a52a6e2db7bb4f8849bd84..7df2de9612e7ce4ec93b5ca8f1378156cba44158 100644 (file)
--- a/MagickCore/montage.c
+++ b/MagickCore/montage.c
@@ -59,6 +59,7 @@
 #include "MagickCore/image-private.h"
 #include "MagickCore/list.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/monitor.h"
 #include "MagickCore/monitor-private.h"
 #include "MagickCore/montage.h"
@@ -106,9 +107,7 @@ MagickExport MontageInfo *CloneMontageInfo(const ImageInfo *image_info,
   MontageInfo
     *clone_info;
 
-  clone_info=(MontageInfo *) AcquireMagickMemory(sizeof(*clone_info));
-  if (clone_info == (MontageInfo *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+  clone_info=(MontageInfo *) AcquireCriticalMemory(sizeof(*clone_info));
   GetMontageInfo(image_info,clone_info);
   if (montage_info == (MontageInfo *) NULL)
     return(clone_info);

diff --git a/MagickCore/nt-feature.c b/MagickCore/nt-feature.c
index 7da3272fb6e3e3306beaf6461f4a0fddeb5efe5c..fc136de76f9018e0647641a1deab936f35fc1088 100644 (file)
--- a/MagickCore/nt-feature.c
+++ b/MagickCore/nt-feature.c
@@ -53,6 +53,7 @@
 #include "MagickCore/exception-private.h"
 #include "MagickCore/image-private.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/monitor.h"
 #include "MagickCore/monitor-private.h"
 #include "MagickCore/nt-base.h"
@@ -375,9 +376,7 @@ MagickExport MagickBooleanType NTAcquireTypeCache(SplayTreeInfo *type_cache,
           continue;
         *pos='\0'; /* Remove (TrueType) from string */
 
-        type_info=(TypeInfo *) AcquireMagickMemory(sizeof(*type_info));
-        if (type_info == (TypeInfo *) NULL)
-          ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+        type_info=(TypeInfo *) AcquireCriticalMemory(sizeof(*type_info));
         (void) ResetMagickMemory(type_info,0,sizeof(TypeInfo));
 
         type_info->path=ConstantString("Windows Fonts");

diff --git a/MagickCore/policy.c b/MagickCore/policy.c
index d8f60491a3dd3962f08bfe005023efdf3ad7c86c..3b90a95429ee0536d95ce05e7f6ac7a1730de2b0 100644 (file)
--- a/MagickCore/policy.c
+++ b/MagickCore/policy.c
@@ -47,6 +47,7 @@
 #include "MagickCore/exception.h"
 #include "MagickCore/exception-private.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/monitor.h"
 #include "MagickCore/monitor-private.h"
 #include "MagickCore/option.h"
@@ -864,9 +865,7 @@ static MagickBooleanType LoadPolicyCache(LinkedListInfo *cache,const char *xml,
         /*
           Policy element.
         */
-        policy_info=(PolicyInfo *) AcquireMagickMemory(sizeof(*policy_info));
-        if (policy_info == (PolicyInfo *) NULL)
-          ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+        policy_info=(PolicyInfo *) AcquireCriticalMemory(sizeof(*policy_info));
         (void) ResetMagickMemory(policy_info,0,sizeof(*policy_info));
         policy_info->path=ConstantString(filename);
         policy_info->exempt=MagickFalse;

diff --git a/MagickCore/quantize.c b/MagickCore/quantize.c
index 53259efca6210101f95e39d98404becd0fbf4269..540d1883c01d169e86a4f1929978502f4d880427 100644 (file)
--- a/MagickCore/quantize.c
+++ b/MagickCore/quantize.c
@@ -189,6 +189,7 @@
 #include "MagickCore/image-private.h"
 #include "MagickCore/list.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/monitor.h"
 #include "MagickCore/monitor-private.h"
 #include "MagickCore/option.h"
@@ -374,9 +375,7 @@ MagickExport QuantizeInfo *AcquireQuantizeInfo(const ImageInfo *image_info)
   QuantizeInfo
     *quantize_info;
 
-  quantize_info=(QuantizeInfo *) AcquireMagickMemory(sizeof(*quantize_info));
-  if (quantize_info == (QuantizeInfo *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+  quantize_info=(QuantizeInfo *) AcquireCriticalMemory(sizeof(*quantize_info));
   GetQuantizeInfo(quantize_info);
   if (image_info != (ImageInfo *) NULL)
     {
@@ -1044,9 +1043,7 @@ MagickExport QuantizeInfo *CloneQuantizeInfo(const QuantizeInfo *quantize_info)
   QuantizeInfo
     *clone_info;
 
-  clone_info=(QuantizeInfo *) AcquireMagickMemory(sizeof(*clone_info));
-  if (clone_info == (QuantizeInfo *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+  clone_info=(QuantizeInfo *) AcquireCriticalMemory(sizeof(*clone_info));
   GetQuantizeInfo(clone_info);
   if (quantize_info == (QuantizeInfo *) NULL)
     return(clone_info);

diff --git a/MagickCore/quantum.c b/MagickCore/quantum.c
index 84beb8c056d16004eeac393c495b55477853a00b..ab45ce37c9fe3f539c351afbcd79703c7d363839 100644 (file)
--- a/MagickCore/quantum.c
+++ b/MagickCore/quantum.c
@@ -55,6 +55,7 @@
 #include "MagickCore/list.h"
 #include "MagickCore/magick.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/monitor.h"
 #include "MagickCore/option.h"
 #include "MagickCore/pixel.h"
@@ -115,9 +116,7 @@ MagickExport QuantumInfo *AcquireQuantumInfo(const ImageInfo *image_info,
   QuantumInfo
     *quantum_info;
 
-  quantum_info=(QuantumInfo *) AcquireMagickMemory(sizeof(*quantum_info));
-  if (quantum_info == (QuantumInfo *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+  quantum_info=(QuantumInfo *) AcquireCriticalMemory(sizeof(*quantum_info));
   quantum_info->signature=MagickCoreSignature;
   GetQuantumInfo(image_info,quantum_info);
   if (image == (const Image *) NULL)

diff --git a/MagickCore/random.c b/MagickCore/random.c
index 644b753aea97d3c4c8c0843a9498f61eaf1dc4f2..7a010e7814ce1e2de2c337e5e33803b2141f8299 100644 (file)
--- a/MagickCore/random.c
+++ b/MagickCore/random.c
@@ -52,6 +52,7 @@
 #include "MagickCore/exception-private.h"
 #include "MagickCore/image-private.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/semaphore.h"
 #include "MagickCore/random_.h"
 #include "MagickCore/random-private.h"
@@ -173,9 +174,7 @@ MagickExport RandomInfo *AcquireRandomInfo(void)
     *key,
     *nonce;
 
-  random_info=(RandomInfo *) AcquireMagickMemory(sizeof(*random_info));
-  if (random_info == (RandomInfo *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+  random_info=(RandomInfo *) AcquireCriticalMemory(sizeof(*random_info));
   (void) ResetMagickMemory(random_info,0,sizeof(*random_info));
   random_info->signature_info=AcquireSignatureInfo();
   random_info->nonce=AcquireStringInfo(2*GetSignatureDigestsize(

diff --git a/MagickCore/resample.c b/MagickCore/resample.c
index 15969ff747bfe543fcb669634d16b818cc78792f..782eb98cdd732bd3d4273b8a6fa14635aba0e3af 100644 (file)
--- a/MagickCore/resample.c
+++ b/MagickCore/resample.c
@@ -52,6 +52,7 @@
 #include "MagickCore/log.h"
 #include "MagickCore/magick.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/pixel.h"
 #include "MagickCore/pixel-accessor.h"
 #include "MagickCore/quantum.h"
@@ -216,10 +217,8 @@ MagickExport ResampleFilter *AcquireResampleFilter(const Image *image,
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
   assert(exception != (ExceptionInfo *) NULL);
   assert(exception->signature == MagickCoreSignature);
-  resample_filter=(ResampleFilter *) AcquireMagickMemory(sizeof(
+  resample_filter=(ResampleFilter *) AcquireCriticalMemory(sizeof(
     *resample_filter));
-  if (resample_filter == (ResampleFilter *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   (void) ResetMagickMemory(resample_filter,0,sizeof(*resample_filter));
   resample_filter->exception=exception;
   resample_filter->image=ReferenceImage((Image *) image);

diff --git a/MagickCore/resize.c b/MagickCore/resize.c
index 3767980bc76f672db997bfbe44a9633d692f16b0..ab6b61a65130a315376673262125d1bc15392c6b 100644 (file)
--- a/MagickCore/resize.c
+++ b/MagickCore/resize.c
@@ -932,9 +932,7 @@ MagickPrivate ResizeFilter *AcquireResizeFilter(const Image *image,
   assert(UndefinedFilter < filter && filter < SentinelFilter);
   assert(exception != (ExceptionInfo *) NULL);
   assert(exception->signature == MagickCoreSignature);
-  resize_filter=(ResizeFilter *) AcquireMagickMemory(sizeof(*resize_filter));
-  if (resize_filter == (ResizeFilter *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+  resize_filter=(ResizeFilter *) AcquireCriticalMemory(sizeof(*resize_filter));
   (void) ResetMagickMemory(resize_filter,0,sizeof(*resize_filter));
   /*
     Defaults for the requested filter.

diff --git a/MagickCore/signature.c b/MagickCore/signature.c
index f36d3265c4d6d3c55d3006f3783ba95d89241fb7..b4a409a2f446d0475df28e78165c52ce91e5c85a 100644 (file)
--- a/MagickCore/signature.c
+++ b/MagickCore/signature.c
@@ -46,6 +46,7 @@
 #include "MagickCore/property.h"
 #include "MagickCore/image.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/pixel-accessor.h"
 #include "MagickCore/quantum.h"
 #include "MagickCore/quantum-private.h"
@@ -121,9 +122,7 @@ MagickPrivate SignatureInfo *AcquireSignatureInfo(void)
   unsigned long
     lsb_first;
 
-  signature_info=(SignatureInfo *) AcquireMagickMemory(sizeof(*signature_info));
-  if (signature_info == (SignatureInfo *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+  signature_info=(SignatureInfo *) AcquireCriticalMemory(sizeof(*signature_info));
   (void) ResetMagickMemory(signature_info,0,sizeof(*signature_info));
   signature_info->digestsize=SignatureDigestsize;
   signature_info->blocksize=SignatureBlocksize;

diff --git a/MagickCore/splay-tree.c b/MagickCore/splay-tree.c
index bb7c1f94324c3e3396cdb2bb577c7e615f702461..4380c3b204aa2e33b4d5626547deaf9433b263e2 100644 (file)
--- a/MagickCore/splay-tree.c
+++ b/MagickCore/splay-tree.c
@@ -54,6 +54,7 @@
 #include "MagickCore/locale_.h"
 #include "MagickCore/log.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/splay-tree.h"
 #include "MagickCore/semaphore.h"
 #include "MagickCore/string_.h"
@@ -1144,9 +1145,7 @@ MagickExport SplayTreeInfo *NewSplayTree(
   SplayTreeInfo
     *splay_tree;
 
-  splay_tree=(SplayTreeInfo *) AcquireMagickMemory(sizeof(*splay_tree));
-  if (splay_tree == (SplayTreeInfo *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+  splay_tree=(SplayTreeInfo *) AcquireCriticalMemory(sizeof(*splay_tree));
   (void) ResetMagickMemory(splay_tree,0,sizeof(*splay_tree));
   splay_tree->root=(NodeInfo *) NULL;
   splay_tree->compare=compare;

diff --git a/MagickCore/stream.c b/MagickCore/stream.c
index b068cd384a6cb69d76a0bc99fec6f214aad2955a..ae693a1060b9dd3bd267cc27850849ad7db0be60 100644 (file)
--- a/MagickCore/stream.c
+++ b/MagickCore/stream.c
@@ -162,9 +162,7 @@ MagickExport StreamInfo *AcquireStreamInfo(const ImageInfo *image_info,
   StreamInfo
     *stream_info;
 
-  stream_info=(StreamInfo *) AcquireMagickMemory(sizeof(*stream_info));
-  if (stream_info == (StreamInfo *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+  stream_info=(StreamInfo *) AcquireCriticalMemory(sizeof(*stream_info));
   (void) ResetMagickMemory(stream_info,0,sizeof(*stream_info));
   stream_info->pixels=(unsigned char *) MagickAssumeAligned(
     AcquireAlignedMemory(1,sizeof(*stream_info->pixels)));

diff --git a/MagickCore/string.c b/MagickCore/string.c
index d72e78f6bee1682df70ee5be97c6f35db8ff2a0e..8fe4ade5d5e90a93ddc65e9074191332df4027fb 100644 (file)
--- a/MagickCore/string.c
+++ b/MagickCore/string.c
@@ -49,6 +49,7 @@
 #include "MagickCore/locale_.h"
 #include "MagickCore/log.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/nt-base-private.h"
 #include "MagickCore/property.h"
 #include "MagickCore/resource_.h"
@@ -171,9 +172,7 @@ MagickExport StringInfo *AcquireStringInfo(const size_t length)
   StringInfo
     *string_info;
 
-  string_info=(StringInfo *) AcquireMagickMemory(sizeof(*string_info));
-  if (string_info == (StringInfo *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+  string_info=(StringInfo *) AcquireCriticalMemory(sizeof(*string_info));
   (void) ResetMagickMemory(string_info,0,sizeof(*string_info));
   string_info->signature=MagickCoreSignature;
   string_info->length=length;

diff --git a/MagickCore/threshold.c b/MagickCore/threshold.c
index 42350eb4c2c161610cd7cf24fda284e8130aab23..e2d2b3c996d86abe34de2b870f81ba436097ec66 100644 (file)
--- a/MagickCore/threshold.c
+++ b/MagickCore/threshold.c
@@ -64,6 +64,7 @@
 #include "MagickCore/list.h"
 #include "MagickCore/log.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/monitor.h"
 #include "MagickCore/monitor-private.h"
 #include "MagickCore/montage.h"
@@ -1379,9 +1380,7 @@ static ThresholdMap *GetThresholdMapFile(const char *xml,const char *filename,
       thresholds=DestroyXMLTree(thresholds);
       return(map);
     }
-  map=(ThresholdMap *) AcquireMagickMemory(sizeof(ThresholdMap));
-  if (map == (ThresholdMap *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"UnableToAcquireThresholdMap");
+  map=(ThresholdMap *) AcquireCriticalMemory(sizeof(*map));
   map->map_id=(char *) NULL;
   map->description=(char *) NULL;
   map->levels=(ssize_t *) NULL;

diff --git a/MagickCore/timer.c b/MagickCore/timer.c
index dd47567f3a2cdfec4846572f5b5038b1c095b36d..28afa5933a630a750da2017e4454212dfb0d2170 100644 (file)
--- a/MagickCore/timer.c
+++ b/MagickCore/timer.c
@@ -45,6 +45,7 @@
 #include "MagickCore/exception-private.h"
 #include "MagickCore/log.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/nt-base-private.h"
 #include "MagickCore/timer.h"
 \f
@@ -88,9 +89,7 @@ MagickExport TimerInfo *AcquireTimerInfo(void)
   TimerInfo
     *timer_info;
 
-  timer_info=(TimerInfo *) AcquireMagickMemory(sizeof(*timer_info));
-  if (timer_info == (TimerInfo *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"UnableToAcquireString");
+  timer_info=(TimerInfo *) AcquireCriticalMemory(sizeof(*timer_info));
   (void) ResetMagickMemory(timer_info,0,sizeof(*timer_info));
   timer_info->signature=MagickCoreSignature;
   GetTimerInfo(timer_info);

diff --git a/MagickCore/token.c b/MagickCore/token.c
index b3ea883a1120f02e67189faa074fe6202f63225a..c73bd63ad6790851a1c20055a78615f90515e969 100644 (file)
--- a/MagickCore/token.c
+++ b/MagickCore/token.c
@@ -45,6 +45,7 @@
 #include "MagickCore/exception-private.h"
 #include "MagickCore/image.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/string_.h"
 #include "MagickCore/string-private.h"
 #include "MagickCore/token.h"
@@ -96,9 +97,7 @@ MagickExport TokenInfo *AcquireTokenInfo(void)
   TokenInfo
     *token_info;
 
-  token_info=(TokenInfo *) AcquireMagickMemory(sizeof(*token_info));
-  if (token_info == (TokenInfo *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+  token_info=(TokenInfo *) AcquireCriticalMemory(sizeof(*token_info));
   token_info->signature=MagickCoreSignature;
   return(token_info);
 }

diff --git a/MagickCore/type.c b/MagickCore/type.c
index 80e73ceab0b7f9f3df34d78bf0c09f991c6ca736..18ac7d80ac38c4e81d00fd319835b7270b549fe3 100644 (file)
--- a/MagickCore/type.c
+++ b/MagickCore/type.c
@@ -50,6 +50,7 @@
 #include "MagickCore/linked-list.h"
 #include "MagickCore/log.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/nt-feature.h"
 #include "MagickCore/nt-base-private.h"
 #include "MagickCore/option.h"
@@ -1179,9 +1180,7 @@ static MagickBooleanType LoadTypeCache(SplayTreeInfo *cache,const char *xml,
         /*
           Type element.
         */
-        type_info=(TypeInfo *) AcquireMagickMemory(sizeof(*type_info));
-        if (type_info == (TypeInfo *) NULL)
-          ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+        type_info=(TypeInfo *) AcquireCriticalMemory(sizeof(*type_info));
         (void) ResetMagickMemory(type_info,0,sizeof(*type_info));
         type_info->path=ConstantString(filename);
         type_info->signature=MagickCoreSignature;

diff --git a/MagickCore/xml-tree.c b/MagickCore/xml-tree.c
index 919ac635019f011767eaa1fe8f104807ee6239dd..37eca69363721276e5cbfd21dbdc3f24c12b0964 100644 (file)
--- a/MagickCore/xml-tree.c
+++ b/MagickCore/xml-tree.c
@@ -55,6 +55,7 @@
 #include "MagickCore/image-private.h"
 #include "MagickCore/log.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/semaphore.h"
 #include "MagickCore/string_.h"
 #include "MagickCore/string-private.h"
@@ -1634,10 +1635,8 @@ static void ParseProcessingInstructions(XMLTreeRoot *root,char *xml,
     }
   if (root->processing_instructions[0] == (char **) NULL)
     {
-      root->processing_instructions=(char ***) AcquireMagickMemory(sizeof(
+      root->processing_instructions=(char ***) AcquireCriticalMemory(sizeof(
         *root->processing_instructions));
-      if (root->processing_instructions ==(char ***) NULL)
-        ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
       *root->processing_instructions=(char **) NULL;
     }
   i=0;

diff --git a/coders/jpeg.c b/coders/jpeg.c
index 3a5ac41fc974fe04f132d9beb77f906bb4f306bb..a24be919943c988e63af81a21457e62309f4ca44 100644 (file)
--- a/coders/jpeg.c
+++ b/coders/jpeg.c
@@ -66,6 +66,7 @@
 #include "MagickCore/log.h"
 #include "MagickCore/magick.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/module.h"
 #include "MagickCore/monitor.h"
 #include "MagickCore/monitor-private.h"
@@ -1769,10 +1770,7 @@ static QuantizationTable *GetQuantizationTable(const char *filename,
       xml=DestroyString(xml);
       return(table);
     }
-  table=(QuantizationTable *) AcquireMagickMemory(sizeof(*table));
-  if (table == (QuantizationTable *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,
-      "UnableToAcquireQuantizationTable");
+  table=(QuantizationTable *) AcquireCriticalMemory(sizeof(*table));
   table->slot=(char *) NULL;
   table->description=(char *) NULL;
   table->levels=(unsigned int *) NULL;

diff --git a/coders/svg.c b/coders/svg.c
index d7f6dec2c5f87372f6adc600f61673d8ac765ce2..3190b5cd5b4c747a72f8317e1219f54e628b0ceb 100644 (file)
--- a/coders/svg.c
+++ b/coders/svg.c
@@ -62,6 +62,7 @@
 #include "MagickCore/log.h"
 #include "MagickCore/magick.h"
 #include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
 #include "MagickCore/module.h"
 #include "MagickCore/monitor.h"
 #include "MagickCore/monitor-private.h"
@@ -267,9 +268,7 @@ static SVGInfo *AcquireSVGInfo(void)
     return((SVGInfo *) NULL);
   (void) ResetMagickMemory(svg_info,0,sizeof(*svg_info));
   svg_info->text=AcquireString("");
-  svg_info->scale=(double *) AcquireMagickMemory(sizeof(*svg_info->scale));
-  if (svg_info->scale == (double *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+  svg_info->scale=(double *) AcquireCriticalMemory(sizeof(*svg_info->scale));
   GetAffineMatrix(&svg_info->affine);
   svg_info->scale[0]=ExpandAffine(&svg_info->affine);
   return(svg_info);