Changeset 453

Timestamp:

10/25/09 11:36:48 (4 weeks ago)

Author:

cristy

Message:

 

Location:

ImageMagick/trunk

Files:

• coders/png.c (modified) (12 diffs)
• coders/tiff.c (modified) (3 diffs)
• magick/cache.c (modified) (10 diffs)
• magick/coder.c (modified) (8 diffs)
• magick/color.c (modified) (11 diffs)
• magick/configure.c (modified) (10 diffs)
• magick/constitute.c (modified) (8 diffs)
• magick/delegate.c (modified) (10 diffs)
• magick/deprecate.c (modified) (1 diff)
• magick/exception.c (modified) (9 diffs)
• magick/gem.c (modified) (1 diff)
• magick/image.c (modified) (2 diffs)
• magick/locale.c (modified) (8 diffs)
• magick/log.c (modified) (19 diffs)
• magick/magic.c (modified) (10 diffs)
• magick/magick.c (modified) (19 diffs)
• magick/memory.c (modified) (9 diffs)
• magick/mime.c (modified) (10 diffs)
• magick/module.c (modified) (9 diffs)
• magick/policy.c (modified) (12 diffs)
• magick/random.c (modified) (3 diffs)
• magick/registry.c (modified) (5 diffs)
• magick/resource.c (modified) (15 diffs)
• magick/semaphore.c (modified) (1 diff)
• magick/type.c (modified) (12 diffs)
• wand/wand.c (modified) (4 diffs)

ImageMagick/trunk/coders/png.c

@@ -1704 +1704 @@
 
 #if defined(PNG_SETJMP_NOT_THREAD_SAFE)
-  AcquireSemaphoreInfo(&png_semaphore);
+  LockSemaphoreInfo(png_semaphore);
 #endif
 
@@ -1749 +1749 @@
       png_destroy_read_struct(&ping,&ping_info,&end_info);
 #if defined(PNG_SETJMP_NOT_THREAD_SAFE)
-      RelinquishSemaphoreInfo(png_semaphore);
+      UnlockSemaphoreInfo(png_semaphore);
 #endif
       if (logging != MagickFalse)
@@ -2249 +2249 @@
       png_destroy_read_struct(&ping,&ping_info,&end_info);
 #if defined(PNG_SETJMP_NOT_THREAD_SAFE)
-      RelinquishSemaphoreInfo(png_semaphore);
+      UnlockSemaphoreInfo(png_semaphore);
 #endif
       if (logging != MagickFalse)
@@ -2280 +2280 @@
       png_destroy_read_struct(&ping,&ping_info,&end_info);
 #if defined(PNG_SETJMP_NOT_THREAD_SAFE)
-      RelinquishSemaphoreInfo(png_semaphore);
+      UnlockSemaphoreInfo(png_semaphore);
 #endif
       if (quantum_info != (QuantumInfo *) NULL)
@@ -2636 +2636 @@
       (void) SetImageBackgroundColor(image);
 #if defined(PNG_SETJMP_NOT_THREAD_SAFE)
-      RelinquishSemaphoreInfo(png_semaphore);
+      UnlockSemaphoreInfo(png_semaphore);
 #endif
       if (logging != MagickFalse)
@@ -2841 +2841 @@
   png_pixels=(unsigned char *) RelinquishMagickMemory(png_pixels);
 #if defined(PNG_SETJMP_NOT_THREAD_SAFE)
-  RelinquishSemaphoreInfo(png_semaphore);
+  UnlockSemaphoreInfo(png_semaphore);
 #endif
 
@@ -5945 +5945 @@
   entry->note=ConstantString(JNGNote);
   (void) RegisterMagickInfo(entry);
+#if defined(PNG_SETJMP_NOT_THREAD_SAFE)
+  png_semaphore=AllocateSemaphoreInfo();
+#endif
   return(MagickImageCoderSignature);
 }
@@ -5976 +5979 @@
   (void) UnregisterMagickInfo("JNG");
 #if defined(PNG_SETJMP_NOT_THREAD_SAFE)
-  AcquireSemaphoreInfo(&png_semaphore);
-  RelinquishSemaphoreInfo(png_semaphore);
   DestroySemaphoreInfo(&png_semaphore);
 #endif
@@ -6274 +6275 @@
 
 #if defined(PNG_SETJMP_NOT_THREAD_SAFE)
-  AcquireSemaphoreInfo(&png_semaphore);
+  LockSemaphoreInfo(png_semaphore);
 #endif
 
@@ -6321 +6322 @@
       png_destroy_write_struct(&ping,&ping_info);
 #if defined(PNG_SETJMP_NOT_THREAD_SAFE)
-      RelinquishSemaphoreInfo(png_semaphore);
+      UnlockSemaphoreInfo(png_semaphore);
 #endif
       return(MagickFalse);
@@ -7424 +7425 @@
         png_pixels=(unsigned char *) RelinquishMagickMemory(png_pixels);
 #if defined(PNG_SETJMP_NOT_THREAD_SAFE)
-      RelinquishSemaphoreInfo(png_semaphore);
+      UnlockSemaphoreInfo(png_semaphore);
 #endif
       return(MagickFalse);
@@ -7780 +7781 @@
 
 #if defined(PNG_SETJMP_NOT_THREAD_SAFE)
-  RelinquishSemaphoreInfo(png_semaphore);
+  UnlockSemaphoreInfo(png_semaphore);
 #endif
 

ImageMagick/trunk/coders/tiff.c

@@ -1660 +1660 @@
   MagickInfo
     *entry;
-
-  AcquireSemaphoreInfo(&tiff_semaphore);
+  
+  if (tiff_semaphore == (SemaphoreInfo *) NULL)
+    tiff_semaphore=AllocateSemaphoreInfo();
+  LockSemaphoreInfo(tiff_semaphore);
   if (instantiate_key == MagickFalse)
     {
@@ -1668 +1670 @@
       instantiate_key=MagickTrue;
     }
-  RelinquishSemaphoreInfo(tiff_semaphore);
+  UnlockSemaphoreInfo(tiff_semaphore);
   *version='\0';
 #if defined(TIFF_VERSION)
@@ -1783 +1785 @@
   (void) UnregisterMagickInfo("TIFF");
   (void) UnregisterMagickInfo("TIFF64");
-  AcquireSemaphoreInfo(&tiff_semaphore);
+  LockSemaphoreInfo(tiff_semaphore);
   if (instantiate_key != MagickFalse)
     if (MagickDeleteThreadKey(tiff_exception) == MagickFalse)
       ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   instantiate_key=MagickFalse;
-  RelinquishSemaphoreInfo(tiff_semaphore);
+  UnlockSemaphoreInfo(tiff_semaphore);
   DestroySemaphoreInfo(&tiff_semaphore);
 }

ImageMagick/trunk/magick/cache.c

@@ -205 +205 @@
     {
       AcquireSemaphoreInfo(&cache_semaphore);
+      LockSemaphoreInfo(cache_semaphore);
       if ((cache_resources == (SplayTreeInfo *) NULL) &&
           (instantiate_cache == MagickFalse))
@@ -212 +213 @@
           instantiate_cache=MagickTrue;
         }
-      RelinquishSemaphoreInfo(cache_semaphore);
+      UnlockSemaphoreInfo(cache_semaphore);
     }
   (void) AddValueToSplayTree(cache_resources,cache_info,cache_info);
@@ -284 +285 @@
 MagickExport MagickBooleanType CacheComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&cache_semaphore);
-  RelinquishSemaphoreInfo(cache_semaphore);
+  assert(cache_semaphore == (SemaphoreInfo *) NULL);
+  cache_semaphore=AllocateSemaphoreInfo();
   return(MagickTrue);
 }
@@ -309 +310 @@
 MagickExport void CacheComponentTerminus(void)
 {
-  AcquireSemaphoreInfo(&cache_semaphore);
+  if (cache_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&cache_semaphore);
+  LockSemaphoreInfo(cache_semaphore);
   if (cache_resources != (SplayTreeInfo *) NULL)
     cache_resources=DestroySplayTree(cache_resources);
   instantiate_cache=MagickFalse;
-  RelinquishSemaphoreInfo(cache_semaphore);
+  UnlockSemaphoreInfo(cache_semaphore);
   DestroySemaphoreInfo(&cache_semaphore);
 }
@@ -598 +601 @@
     status;
 
-  AcquireSemaphoreInfo(&cache_info->disk_semaphore);
+  LockSemaphoreInfo(cache_info->disk_semaphore);
   status=close(cache_info->file);
   cache_info->file=(-1);
   RelinquishMagickResource(FileResource,1);
-  RelinquishSemaphoreInfo(cache_info->disk_semaphore);
+  UnlockSemaphoreInfo(cache_info->disk_semaphore);
   return(status == -1 ? MagickFalse : MagickTrue);
 }
@@ -617 +620 @@
   if (GetMagickResource(FileResource) < GetMagickResourceLimit(FileResource))
     return;
-  AcquireSemaphoreInfo(&cache_semaphore);
+  LockSemaphoreInfo(cache_semaphore);
   if (cache_resources == (SplayTreeInfo *) NULL)
     {
-      RelinquishSemaphoreInfo(cache_semaphore);
+      UnlockSemaphoreInfo(cache_semaphore);
       return;
     }
@@ -646 +649 @@
   if (q != (CacheInfo *) NULL)
     (void) ClosePixelCacheOnDisk(q);  /* relinquish least recently used cache */
-  RelinquishSemaphoreInfo(cache_semaphore);
+  UnlockSemaphoreInfo(cache_semaphore);
 }
 
@@ -674 +677 @@
     Open pixel cache on disk.
   */
-  AcquireSemaphoreInfo(&cache_info->disk_semaphore);
+  LockSemaphoreInfo(cache_info->disk_semaphore);
   if (cache_info->file != -1)
     {
-      RelinquishSemaphoreInfo(cache_info->disk_semaphore);
+      UnlockSemaphoreInfo(cache_info->disk_semaphore);
       return(MagickTrue);  /* cache already open */
     }
@@ -711 +714 @@
   if (file == -1)
     {
-      RelinquishSemaphoreInfo(cache_info->disk_semaphore);
+      UnlockSemaphoreInfo(cache_info->disk_semaphore);
       return(MagickFalse);
     }
@@ -717 +720 @@
   cache_info->file=file;
   cache_info->timestamp=time(0);
-  RelinquishSemaphoreInfo(cache_info->disk_semaphore);
+  UnlockSemaphoreInfo(cache_info->disk_semaphore);
   return(MagickTrue);
 }

ImageMagick/trunk/magick/coder.c

@@ -256 +256 @@
 MagickExport MagickBooleanType CoderComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&coder_semaphore);
-  RelinquishSemaphoreInfo(coder_semaphore);
+  assert(coder_semaphore == (SemaphoreInfo *) NULL);
+  coder_semaphore=AllocateSemaphoreInfo();
   return(MagickTrue);
 }
@@ -281 +281 @@
 MagickExport void CoderComponentTerminus(void)
 {
-  AcquireSemaphoreInfo(&coder_semaphore);
+  if (coder_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&coder_semaphore);
+  LockSemaphoreInfo(coder_semaphore);
   if (coder_list != (SplayTreeInfo *) NULL)
     coder_list=DestroySplayTree(coder_list);
   instantiate_coder=MagickFalse;
-  RelinquishSemaphoreInfo(coder_semaphore);
+  UnlockSemaphoreInfo(coder_semaphore);
   DestroySemaphoreInfo(&coder_semaphore);
 }
@@ -402 +404 @@
     Generate coder list.
   */
-  AcquireSemaphoreInfo(&coder_semaphore);
+  LockSemaphoreInfo(coder_semaphore);
   ResetSplayTreeIterator(coder_list);
   p=(const CoderInfo *) GetNextValueInSplayTree(coder_list);
@@ -412 +414 @@
     p=(const CoderInfo *) GetNextValueInSplayTree(coder_list);
   }
-  RelinquishSemaphoreInfo(coder_semaphore);
+  UnlockSemaphoreInfo(coder_semaphore);
   qsort((void *) coder_map,(size_t) i,sizeof(*coder_map),CoderInfoCompare);
   coder_map[i]=(CoderInfo *) NULL;
@@ -487 +489 @@
     Generate coder list.
   */
-  AcquireSemaphoreInfo(&coder_semaphore);
+  LockSemaphoreInfo(coder_semaphore);
   ResetSplayTreeIterator(coder_list);
   p=(const CoderInfo *) GetNextValueInSplayTree(coder_list);
@@ -497 +499 @@
     p=(const CoderInfo *) GetNextValueInSplayTree(coder_list);
   }
-  RelinquishSemaphoreInfo(coder_semaphore);
+  UnlockSemaphoreInfo(coder_semaphore);
   qsort((void *) coder_map,(size_t) i,sizeof(*coder_map),CoderCompare);
   coder_map[i]=(char *) NULL;
@@ -532 +534 @@
     {
       AcquireSemaphoreInfo(&coder_semaphore);
+      LockSemaphoreInfo(coder_semaphore);
       if ((coder_list == (SplayTreeInfo *) NULL) &&
           (instantiate_coder == MagickFalse))
@@ -538 +541 @@
           instantiate_coder=MagickTrue;
         }
-      RelinquishSemaphoreInfo(coder_semaphore);
+      UnlockSemaphoreInfo(coder_semaphore);
     }
   return(coder_list != (SplayTreeInfo *) NULL ? MagickTrue : MagickFalse);

ImageMagick/trunk/magick/color.c

@@ -817 +817 @@
 MagickExport MagickBooleanType ColorComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&color_semaphore);
-  RelinquishSemaphoreInfo(color_semaphore);
+  assert(color_semaphore == (SemaphoreInfo *) NULL);
+  color_semaphore=AllocateSemaphoreInfo();
   return(MagickTrue);
 }
@@ -860 +860 @@
 MagickExport void ColorComponentTerminus(void)
 {
-  AcquireSemaphoreInfo(&color_semaphore);
+  if (color_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&color_semaphore);
+  LockSemaphoreInfo(color_semaphore);
   if (color_list != (LinkedListInfo *) NULL)
     color_list=DestroyLinkedList(color_list,DestroyColorElement);
   instantiate_color=MagickFalse;
-  RelinquishSemaphoreInfo(color_semaphore);
+  UnlockSemaphoreInfo(color_semaphore);
   DestroySemaphoreInfo(&color_semaphore);
 }
@@ -933 +935 @@
     Search for color tag.
   */
-  AcquireSemaphoreInfo(&color_semaphore);
+  LockSemaphoreInfo(color_semaphore);
   ResetLinkedListIterator(color_list);
   p=(const ColorInfo *) GetNextValueInLinkedList(color_list);
@@ -948 +950 @@
     (void) InsertValueInLinkedList(color_list,0,
       RemoveElementByValueFromLinkedList(color_list,p));
-  RelinquishSemaphoreInfo(color_semaphore);
+  UnlockSemaphoreInfo(color_semaphore);
   return(p);
 }
@@ -1021 +1023 @@
       break;
   }
+  if ((pixel->colorspace == HSLColorspace) ||
+      (pixel->colorspace == HSBColorspace))
+    {
+      (void) FormatMagickString(component,MaxTextExtent,"%g%%",
+        (double) (100.0*QuantumScale*color));
+      (void) ConcatenateMagickString(tuple,component,MaxTextExtent);
+      return;
+    }
   if (compliance != SVGCompliance)
     {
@@ -1139 +1149 @@
     Generate color list.
   */
-  AcquireSemaphoreInfo(&color_semaphore);
+  LockSemaphoreInfo(color_semaphore);
   ResetLinkedListIterator(color_list);
   p=(const ColorInfo *) GetNextValueInLinkedList(color_list);
@@ -1149 +1159 @@
     p=(const ColorInfo *) GetNextValueInLinkedList(color_list);
   }
-  RelinquishSemaphoreInfo(color_semaphore);
+  UnlockSemaphoreInfo(color_semaphore);
   qsort((void *) colors,(size_t) i,sizeof(*colors),ColorInfoCompare);
   colors[i]=(ColorInfo *) NULL;
@@ -1232 +1242 @@
     Generate color list.
   */
-  AcquireSemaphoreInfo(&color_semaphore);
+  LockSemaphoreInfo(color_semaphore);
   ResetLinkedListIterator(color_list);
   p=(const ColorInfo *) GetNextValueInLinkedList(color_list);
@@ -1242 +1252 @@
     p=(const ColorInfo *) GetNextValueInLinkedList(color_list);
   }
-  RelinquishSemaphoreInfo(color_semaphore);
+  UnlockSemaphoreInfo(color_semaphore);
   qsort((void *) colors,(size_t) i,sizeof(*colors),ColorCompare);
   colors[i]=(char *) NULL;
@@ -1448 +1458 @@
     {
       AcquireSemaphoreInfo(&color_semaphore);
+      LockSemaphoreInfo(color_semaphore);
       if ((color_list == (LinkedListInfo *) NULL) &&
           (instantiate_color == MagickFalse))
@@ -1454 +1465 @@
           instantiate_color=MagickTrue;
         }
-      RelinquishSemaphoreInfo(color_semaphore);
+      UnlockSemaphoreInfo(color_semaphore);
     }
   return(color_list != (LinkedListInfo *) NULL ? MagickTrue : MagickFalse);

ImageMagick/trunk/magick/configure.c

@@ -115 +115 @@
 MagickExport MagickBooleanType ConfigureComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&configure_semaphore);
-  RelinquishSemaphoreInfo(configure_semaphore);
+  assert(configure_semaphore == (SemaphoreInfo *) NULL);
+  configure_semaphore=AllocateSemaphoreInfo();
   return(MagickTrue);
 }
@@ -160 +160 @@
 MagickExport void ConfigureComponentTerminus(void)
 {
-  AcquireSemaphoreInfo(&configure_semaphore);
+  if (configure_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&configure_semaphore);
+  LockSemaphoreInfo(configure_semaphore);
   if (configure_list != (LinkedListInfo *) NULL)
     configure_list=DestroyLinkedList(configure_list,DestroyConfigureElement);
   configure_list=(LinkedListInfo *) NULL;
   instantiate_configure=MagickFalse;
-  RelinquishSemaphoreInfo(configure_semaphore);
+  UnlockSemaphoreInfo(configure_semaphore);
   DestroySemaphoreInfo(&configure_semaphore);
 }
@@ -253 +255 @@
     Search for configure tag.
   */
-  AcquireSemaphoreInfo(&configure_semaphore);
+  LockSemaphoreInfo(configure_semaphore);
   ResetLinkedListIterator(configure_list);
   p=(const ConfigureInfo *) GetNextValueInLinkedList(configure_list);
@@ -265 +267 @@
     (void) InsertValueInLinkedList(configure_list,0,
       RemoveElementByValueFromLinkedList(configure_list,p));
-  RelinquishSemaphoreInfo(configure_semaphore);
+  UnlockSemaphoreInfo(configure_semaphore);
   return(p);
 }
@@ -349 +351 @@
     Generate configure list.
   */
-  AcquireSemaphoreInfo(&configure_semaphore);
+  LockSemaphoreInfo(configure_semaphore);
   ResetLinkedListIterator(configure_list);
   p=(const ConfigureInfo *) GetNextValueInLinkedList(configure_list);
@@ -359 +361 @@
     p=(const ConfigureInfo *) GetNextValueInLinkedList(configure_list);
   }
-  RelinquishSemaphoreInfo(configure_semaphore);
+  UnlockSemaphoreInfo(configure_semaphore);
   qsort((void *) options,(size_t) i,sizeof(*options),ConfigureInfoCompare);
   options[i]=(ConfigureInfo *) NULL;
@@ -436 +438 @@
   if (p == (const ConfigureInfo *) NULL)
     return((char **) NULL);
-  AcquireSemaphoreInfo(&configure_semaphore);
-  RelinquishSemaphoreInfo(configure_semaphore);
   options=(char **) AcquireQuantumMemory((size_t)
     GetNumberOfElementsInLinkedList(configure_list)+1UL,sizeof(*options));
   if (options == (char **) NULL)
     return((char **) NULL);
-  AcquireSemaphoreInfo(&configure_semaphore);
+  LockSemaphoreInfo(configure_semaphore);
   ResetLinkedListIterator(configure_list);
   p=(const ConfigureInfo *) GetNextValueInLinkedList(configure_list);
@@ -452 +452 @@
     p=(const ConfigureInfo *) GetNextValueInLinkedList(configure_list);
   }
-  RelinquishSemaphoreInfo(configure_semaphore);
+  UnlockSemaphoreInfo(configure_semaphore);
   qsort((void *) options,(size_t) i,sizeof(*options),ConfigureCompare);
   options[i]=(char *) NULL;
@@ -870 +870 @@
     {
       AcquireSemaphoreInfo(&configure_semaphore);
+      LockSemaphoreInfo(configure_semaphore);
       if ((configure_list == (LinkedListInfo *) NULL) &&
           (instantiate_configure == MagickFalse))
@@ -876 +877 @@
           instantiate_configure=MagickTrue;
         }
-      RelinquishSemaphoreInfo(configure_semaphore);
+      UnlockSemaphoreInfo(configure_semaphore);
     }
   return(configure_list != (LinkedListInfo *) NULL ? MagickTrue : MagickFalse);

ImageMagick/trunk/magick/constitute.c

@@ -95 +95 @@
 MagickExport MagickBooleanType ConstituteComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&constitute_semaphore);
-  RelinquishSemaphoreInfo(constitute_semaphore);
+  assert(constitute_semaphore == (SemaphoreInfo *) NULL);
+  constitute_semaphore=AllocateSemaphoreInfo();
   return(MagickTrue);
 }
@@ -120 +120 @@
 MagickExport void ConstituteComponentTerminus(void)
 {
-  if (constitute_semaphore != (SemaphoreInfo *) NULL)
-    DestroySemaphoreInfo(&constitute_semaphore);
+  if (constitute_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&constitute_semaphore);
+  DestroySemaphoreInfo(&constitute_semaphore);
 }
 
@@ -515 +516 @@
       thread_support=GetMagickThreadSupport(magick_info);
       if ((thread_support & DecoderThreadSupport) == 0)
-        AcquireSemaphoreInfo(&constitute_semaphore);
+        {
+          AcquireSemaphoreInfo(&constitute_semaphore);
+          LockSemaphoreInfo(constitute_semaphore);
+        }
       image=GetImageDecoder(magick_info)(read_info,exception);
       if ((thread_support & DecoderThreadSupport) == 0)
-        RelinquishSemaphoreInfo(constitute_semaphore);
+        UnlockSemaphoreInfo(constitute_semaphore);
     }
   else
@@ -547 +551 @@
       *read_info->filename='\0';
       if (GetDelegateThreadSupport(delegate_info) == MagickFalse)
-        AcquireSemaphoreInfo(&constitute_semaphore);
+        {
+          AcquireSemaphoreInfo(&constitute_semaphore);
+          LockSemaphoreInfo(constitute_semaphore);
+        }
       (void) InvokeDelegate(read_info,image,read_info->magick,(char *) NULL,
         exception);
       if (GetDelegateThreadSupport(delegate_info) == MagickFalse)
-        RelinquishSemaphoreInfo(constitute_semaphore);
+        UnlockSemaphoreInfo(constitute_semaphore);
       image=DestroyImageList(image);
       read_info->temporary=MagickTrue;
@@ -571 +578 @@
       thread_support=GetMagickThreadSupport(magick_info);
       if ((thread_support & DecoderThreadSupport) == 0)
-        AcquireSemaphoreInfo(&constitute_semaphore);
+        {
+          AcquireSemaphoreInfo(&constitute_semaphore);
+          LockSemaphoreInfo(constitute_semaphore);
+        }
       image=(Image *) (GetImageDecoder(magick_info))(read_info,exception);
       if ((thread_support & DecoderThreadSupport) == 0)
-        RelinquishSemaphoreInfo(constitute_semaphore);
+        UnlockSemaphoreInfo(constitute_semaphore);
     }
   if (read_info->temporary != MagickFalse)
@@ -1100 +1110 @@
       thread_support=GetMagickThreadSupport(magick_info);
       if ((thread_support & EncoderThreadSupport) == 0)
-        AcquireSemaphoreInfo(&constitute_semaphore);
+        {
+          AcquireSemaphoreInfo(&constitute_semaphore);
+          LockSemaphoreInfo(constitute_semaphore);
+        }
       status=GetImageEncoder(magick_info)(write_info,image);
       if ((thread_support & EncoderThreadSupport) == 0)
-        RelinquishSemaphoreInfo(constitute_semaphore);
+        UnlockSemaphoreInfo(constitute_semaphore);
     }
   else
@@ -1116 +1129 @@
           *write_info->filename='\0';
           if (GetDelegateThreadSupport(delegate_info) == MagickFalse)
-            AcquireSemaphoreInfo(&constitute_semaphore);
+            {
+              AcquireSemaphoreInfo(&constitute_semaphore);
+              LockSemaphoreInfo(constitute_semaphore);
+            }
           status=InvokeDelegate(write_info,image,(char *) NULL,
             write_info->magick,&image->exception);
           if (GetDelegateThreadSupport(delegate_info) == MagickFalse)
-            RelinquishSemaphoreInfo(constitute_semaphore);
+            UnlockSemaphoreInfo(constitute_semaphore);
           (void) CopyMagickString(image->filename,filename,MaxTextExtent);
         }
@@ -1147 +1163 @@
               thread_support=GetMagickThreadSupport(magick_info);
               if ((thread_support & EncoderThreadSupport) == 0)
-                AcquireSemaphoreInfo(&constitute_semaphore);
+                {
+                  AcquireSemaphoreInfo(&constitute_semaphore);
+                  LockSemaphoreInfo(constitute_semaphore);
+                }
               status=GetImageEncoder(magick_info)(write_info,image);
               if ((thread_support & EncoderThreadSupport) == 0)
-                RelinquishSemaphoreInfo(constitute_semaphore);
+                UnlockSemaphoreInfo(constitute_semaphore);
             }
         }

ImageMagick/trunk/magick/delegate.c

@@ -165 +165 @@
 MagickExport MagickBooleanType DelegateComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&delegate_semaphore);
-  RelinquishSemaphoreInfo(delegate_semaphore);
+  assert(delegate_semaphore == (SemaphoreInfo *) NULL);
+  delegate_semaphore=AllocateSemaphoreInfo();
   return(MagickTrue);
 }
@@ -210 +210 @@
 MagickExport void DelegateComponentTerminus(void)
 {
-  AcquireSemaphoreInfo(&delegate_semaphore);
+  if (delegate_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&delegate_semaphore);
+  LockSemaphoreInfo(delegate_semaphore);
   if (delegate_list != (LinkedListInfo *) NULL)
     delegate_list=DestroyLinkedList(delegate_list,DestroyDelegate);
   instantiate_delegate=MagickFalse;
-  RelinquishSemaphoreInfo(delegate_semaphore);
+  UnlockSemaphoreInfo(delegate_semaphore);
   DestroySemaphoreInfo(&delegate_semaphore);
 }
@@ -380 +382 @@
     Search for named delegate.
   */
-  AcquireSemaphoreInfo(&delegate_semaphore);
+  LockSemaphoreInfo(delegate_semaphore);
   ResetLinkedListIterator(delegate_list);
   p=(const DelegateInfo *) GetNextValueInLinkedList(delegate_list);
@@ -413 +415 @@
     (void) InsertValueInLinkedList(delegate_list,0,
       RemoveElementByValueFromLinkedList(delegate_list,p));
-  RelinquishSemaphoreInfo(delegate_semaphore);
+  UnlockSemaphoreInfo(delegate_semaphore);
   return(p);
 }
@@ -504 +506 @@
     Generate delegate list.
   */
-  AcquireSemaphoreInfo(&delegate_semaphore);
+  LockSemaphoreInfo(delegate_semaphore);
   ResetLinkedListIterator(delegate_list);
   p=(const DelegateInfo *) GetNextValueInLinkedList(delegate_list);
@@ -515 +517 @@
     p=(const DelegateInfo *) GetNextValueInLinkedList(delegate_list);
   }
-  RelinquishSemaphoreInfo(delegate_semaphore);
+  UnlockSemaphoreInfo(delegate_semaphore);
   qsort((void *) delegates,(size_t) i,sizeof(*delegates),DelegateInfoCompare);
   delegates[i]=(DelegateInfo *) NULL;
@@ -597 +599 @@
   if (delegates == (char **) NULL)
     return((char **) NULL);
-  AcquireSemaphoreInfo(&delegate_semaphore);
+  LockSemaphoreInfo(delegate_semaphore);
   ResetLinkedListIterator(delegate_list);
   p=(const DelegateInfo *) GetNextValueInLinkedList(delegate_list);
@@ -610 +612 @@
     p=(const DelegateInfo *) GetNextValueInLinkedList(delegate_list);
   }
-  RelinquishSemaphoreInfo(delegate_semaphore);
+  UnlockSemaphoreInfo(delegate_semaphore);
   qsort((void *) delegates,(size_t) i,sizeof(*delegates),DelegateCompare);
   delegates[i]=(char *) NULL;
@@ -708 +710 @@
     {
       AcquireSemaphoreInfo(&delegate_semaphore);
+      LockSemaphoreInfo(delegate_semaphore);
       if ((delegate_list == (LinkedListInfo *) NULL) &&
           (instantiate_delegate == MagickFalse))
@@ -714 +717 @@
           instantiate_delegate=MagickTrue;
         }
-      RelinquishSemaphoreInfo(delegate_semaphore);
+      UnlockSemaphoreInfo(delegate_semaphore);
     }
   return(delegate_list != (LinkedListInfo *) NULL ? MagickTrue : MagickFalse);

ImageMagick/trunk/magick/deprecate.c

@@ -3759 +3759 @@
 {
   (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.7");
-  RelinquishSemaphoreInfo(*semaphore_info);
+  UnlockSemaphoreInfo(*semaphore_info);
 }
 

ImageMagick/trunk/magick/exception.c

@@ -159 +159 @@
   if (exception->exceptions  == (void *) NULL)
     return;
-  AcquireSemaphoreInfo(&exception->semaphore);
+  LockSemaphoreInfo(exception->semaphore);
   p=(ExceptionInfo *) RemoveLastElementFromLinkedList((LinkedListInfo *)
     exception->exceptions);
@@ -171 +171 @@
   exception->reason=(char *) NULL;
   exception->description=(char *) NULL;
-  RelinquishSemaphoreInfo(exception->semaphore);
+  UnlockSemaphoreInfo(exception->semaphore);
   errno=0;
 }
@@ -207 +207 @@
   if (exception->exceptions  == (void *) NULL)
     return;
-  AcquireSemaphoreInfo(&exception->semaphore);
+  LockSemaphoreInfo(exception->semaphore);
   ResetLinkedListIterator((LinkedListInfo *) exception->exceptions);
   p=(const ExceptionInfo *) GetNextValueInLinkedList((LinkedListInfo *)
@@ -222 +222 @@
       exception->exceptions);
   }
-  RelinquishSemaphoreInfo(exception->semaphore);
+  UnlockSemaphoreInfo(exception->semaphore);
   ClearMagickException(exception);
 }
@@ -379 +379 @@
   assert(exception != (ExceptionInfo *) NULL);
   assert(exception->signature == MagickSignature);
-  AcquireSemaphoreInfo(&exception->semaphore);
+  LockSemaphoreInfo(exception->semaphore);
   exception->severity=UndefinedException;
   if (exception->exceptions != (void *) NULL)
@@ -387 +387 @@
   if (exception->relinquish != MagickFalse)
     exception->signature=(~MagickSignature);
-  RelinquishSemaphoreInfo(exception->semaphore);
+  UnlockSemaphoreInfo(exception->semaphore);
   DestroySemaphoreInfo(&exception->semaphore);
   if (relinquish != MagickFalse)
@@ -422 +422 @@
   exception->severity=UndefinedException;
   exception->exceptions=(void *) NewLinkedList(0);
+  exception->semaphore=AllocateSemaphoreInfo();
   exception->signature=MagickSignature;
 }
@@ -613 +614 @@
   if (relative->exceptions == (void *) NULL)
     return;
-  AcquireSemaphoreInfo(&exception->semaphore);
+  LockSemaphoreInfo(exception->semaphore);
   ResetLinkedListIterator((LinkedListInfo *) relative->exceptions);
   p=(const ExceptionInfo *) GetNextValueInLinkedList((LinkedListInfo *)
@@ -623 +624 @@
       relative->exceptions);
   }
-  RelinquishSemaphoreInfo(exception->semaphore);
+  UnlockSemaphoreInfo(exception->semaphore);
 }
 

ImageMagick/trunk/magick/gem.c

@@ -373 +373 @@
   if (delta == 0.0)
     return;
-  if (red == max)
-    *hue=((((max-blue)/6.0)+(delta/2.0))-(((max-green)/6.0)+(delta/2.0)))/delta;
+  if ((MagickRealType) red == max)
+    *hue=(double) ((green-(MagickRealType) blue)/delta);
   else
-    if (green == max)
-      *hue=(1.0/3.0)+((((max-red)/6.0)+(delta/2.0))-(((max-blue)/6.0)+
-        (delta/2.0)))/delta;
+    if ((MagickRealType) green == max)
+      *hue=(double) (2.0+(blue-(MagickRealType) red)/delta);
     else
-      if (blue == max)
-        *hue=(2.0/3.0)+((((max-green)/6.0)+(delta/2.0))-(((max-red)/6.0)+
-          (delta/2.0)))/delta;
+      *hue=(double) (4.0+(red-(MagickRealType) green)/delta);
+  *hue/=6.0;
   if (*hue < 0.0)
     *hue+=1.0;
-  if (*hue > 1.0)
-    *hue-=1.0;
 }
 

ImageMagick/trunk/magick/image.c

@@ -1628 +1628 @@
   if (image->debug != MagickFalse)
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
-  AcquireSemaphoreInfo(&image->semaphore);
+  LockSemaphoreInfo(image->semaphore);
   reference_count=image->reference_count;
-  RelinquishSemaphoreInfo(image->semaphore);
+  UnlockSemaphoreInfo(image->semaphore);
   return(reference_count);
 }
@@ -2067 +2067 @@
     return(MagickTrue);
   clone_image=CloneImage(*image,0,0,MagickTrue,exception);
-  AcquireSemaphoreInfo(&(*image)->semaphore);
+  LockSemaphoreInfo((*image)->semaphore);
   (*image)->reference_count--;
-  RelinquishSemaphoreInfo((*image)->semaphore);
+  UnlockSemaphoreInfo((*image)->semaphore);
   *image=clone_image;
   return(MagickTrue);

ImageMagick/trunk/magick/locale.c

@@ -255 +255 @@
     Generate locale list.
   */
-  AcquireSemaphoreInfo(&locale_semaphore);
+  LockSemaphoreInfo(locale_semaphore);
   ResetSplayTreeIterator(locale_list);
   p=(const LocaleInfo *) GetNextValueInSplayTree(locale_list);
@@ -265 +265 @@
     p=(const LocaleInfo *) GetNextValueInSplayTree(locale_list);
   }
-  RelinquishSemaphoreInfo(locale_semaphore);
+  UnlockSemaphoreInfo(locale_semaphore);
   qsort((void *) messages,(size_t) i,sizeof(*messages),LocaleInfoCompare);
   messages[i]=(LocaleInfo *) NULL;
@@ -343 +343 @@
   if (p == (const LocaleInfo *) NULL)
     return((char **) NULL);
-  AcquireSemaphoreInfo(&locale_semaphore);
-  RelinquishSemaphoreInfo(locale_semaphore);
   messages=(char **) AcquireQuantumMemory((size_t)
     GetNumberOfNodesInSplayTree(locale_list)+1UL,sizeof(*messages));
   if (messages == (char **) NULL)
     return((char **) NULL);
-  AcquireSemaphoreInfo(&locale_semaphore);
+  LockSemaphoreInfo(locale_semaphore);
   p=(const LocaleInfo *) GetNextValueInSplayTree(locale_list);
   for (i=0; p != (const LocaleInfo *) NULL; )
@@ -358 +356 @@
     p=(const LocaleInfo *) GetNextValueInSplayTree(locale_list);
   }
-  RelinquishSemaphoreInfo(locale_semaphore);
+  UnlockSemaphoreInfo(locale_semaphore);
   qsort((void *) messages,(size_t) i,sizeof(*messages),LocaleTagCompare);
   messages[i]=(char *) NULL;
@@ -553 +551 @@
     {
       AcquireSemaphoreInfo(&locale_semaphore);
+      LockSemaphoreInfo(locale_semaphore);
       if ((locale_list == (SplayTreeInfo *) NULL) &&
           (instantiate_locale == MagickFalse))
@@ -580 +579 @@
           instantiate_locale=MagickTrue;
         }
-      RelinquishSemaphoreInfo(locale_semaphore);
+      UnlockSemaphoreInfo(locale_semaphore);
     }
   return(locale_list != (SplayTreeInfo *) NULL ? MagickTrue : MagickFalse);
@@ -1049 +1048 @@
 MagickExport MagickBooleanType LocaleComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&locale_semaphore);
-  RelinquishSemaphoreInfo(locale_semaphore);
+  assert(locale_semaphore == (SemaphoreInfo *) NULL);
+  locale_semaphore=AllocateSemaphoreInfo();
   return(MagickTrue);
 }
@@ -1074 +1073 @@
 MagickExport void LocaleComponentTerminus(void)
 {
-  AcquireSemaphoreInfo(&locale_semaphore);
+  if (locale_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&locale_semaphore);
+  LockSemaphoreInfo(locale_semaphore);
   if (locale_list != (SplayTreeInfo *) NULL)
     locale_list=DestroySplayTree(locale_list);
   instantiate_locale=MagickFalse;
-  RelinquishSemaphoreInfo(locale_semaphore);
+  UnlockSemaphoreInfo(locale_semaphore);
   DestroySemaphoreInfo(&locale_semaphore);
 }

ImageMagick/trunk/magick/log.c

@@ -226 +226 @@
   log_info=GetLogInfo("*",exception);
   exception=DestroyExceptionInfo(exception);
-  AcquireSemaphoreInfo(&log_semaphore);
+  LockSemaphoreInfo(log_semaphore);
   if (log_info->file != (FILE *) NULL)
     {
@@ -234 +234 @@
       log_info->file=(FILE *) NULL;
     }
-  RelinquishSemaphoreInfo(log_semaphore);
+  UnlockSemaphoreInfo(log_semaphore);
 }
 
@@ -279 +279 @@
     Search for log tag.
   */
-  AcquireSemaphoreInfo(&log_semaphore);
+  LockSemaphoreInfo(log_semaphore);
   ResetLinkedListIterator(log_list);
   p=(LogInfo *) GetNextValueInLinkedList(log_list);
@@ -291 +291 @@
     (void) InsertValueInLinkedList(log_list,0,
       RemoveElementByValueFromLinkedList(log_list,p));
-  RelinquishSemaphoreInfo(log_semaphore);
+  UnlockSemaphoreInfo(log_semaphore);
   return(p);
 }
@@ -372 +372 @@
     Generate log list.
   */
-  AcquireSemaphoreInfo(&log_semaphore);
+  LockSemaphoreInfo(log_semaphore);
   ResetLinkedListIterator(log_list);
   p=(const LogInfo *) GetNextValueInLinkedList(log_list);
@@ -382 +382 @@
     p=(const LogInfo *) GetNextValueInLinkedList(log_list);
   }
-  RelinquishSemaphoreInfo(log_semaphore);
+  UnlockSemaphoreInfo(log_semaphore);
   qsort((void *) preferences,(size_t) i,sizeof(*preferences),LogInfoCompare);
   preferences[i]=(LogInfo *) NULL;
@@ -465 +465 @@
     Generate log list.
   */
-  AcquireSemaphoreInfo(&log_semaphore);
+  LockSemaphoreInfo(log_semaphore);
   ResetLinkedListIterator(log_list);
   p=(const LogInfo *) GetNextValueInLinkedList(log_list);
@@ -475 +475 @@
     p=(const LogInfo *) GetNextValueInLinkedList(log_list);
   }
-  RelinquishSemaphoreInfo(log_semaphore);
+  UnlockSemaphoreInfo(log_semaphore);
   qsort((void *) preferences,(size_t) i,sizeof(*preferences),LogCompare);
   preferences[i]=(char *) NULL;
@@ -532 +532 @@
     {
       AcquireSemaphoreInfo(&log_semaphore);
+      LockSemaphoreInfo(log_semaphore);
       if ((log_list == (LinkedListInfo *) NULL) &&
           (instantiate_log == MagickFalse))
@@ -538 +539 @@
           instantiate_log=MagickTrue;
         }
-      RelinquishSemaphoreInfo(log_semaphore);
+      UnlockSemaphoreInfo(log_semaphore);
     }
   return(log_list != (LinkedListInfo *) NULL ? MagickTrue : MagickFalse);
@@ -683 +684 @@
 MagickExport MagickBooleanType LogComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&log_semaphore);
-  RelinquishSemaphoreInfo(log_semaphore);
+  assert(log_semaphore == (SemaphoreInfo *) NULL);
+  log_semaphore=AllocateSemaphoreInfo();
   return(MagickTrue);
 }
@@ -735 +736 @@
 MagickExport void LogComponentTerminus(void)
 {
-  AcquireSemaphoreInfo(&log_semaphore);
+  if (log_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&log_semaphore);
+  LockSemaphoreInfo(log_semaphore);
   if (log_list != (LinkedListInfo *) NULL)
     log_list=DestroyLinkedList(log_list,DestroyLogElement);
   instantiate_log=MagickFalse;
-  RelinquishSemaphoreInfo(log_semaphore);
+  UnlockSemaphoreInfo(log_semaphore);
   DestroySemaphoreInfo(&log_semaphore);
 }
@@ -1124 +1127 @@
   log_info=(LogInfo *) GetLogInfo("*",exception);
   exception=DestroyExceptionInfo(exception);
-  AcquireSemaphoreInfo(&log_semaphore);
+  LockSemaphoreInfo(log_semaphore);
   if ((log_info->event_mask & type) == 0)
     {
-      RelinquishSemaphoreInfo(log_semaphore);
+      UnlockSemaphoreInfo(log_semaphore);
       return(MagickTrue);
     }
@@ -1142 +1145 @@
     {
       (void) ContinueTimer((TimerInfo *) &log_info->timer);
-      RelinquishSemaphoreInfo(log_semaphore);
+      UnlockSemaphoreInfo(log_semaphore);
       return(MagickFalse);
     }
@@ -1185 +1188 @@
             {
               (void) ContinueTimer((TimerInfo *) &log_info->timer);
-              RelinquishSemaphoreInfo(log_semaphore);
+              UnlockSemaphoreInfo(log_semaphore);
               return(MagickFalse);
             }
@@ -1193 +1196 @@
           if (log_info->file == (FILE *) NULL)
             {
-              RelinquishSemaphoreInfo(log_semaphore);
+              UnlockSemaphoreInfo(log_semaphore);
               return(MagickFalse);
             }
@@ -1219 +1222 @@
   text=(char  *) RelinquishMagickMemory(text);
   (void) ContinueTimer((TimerInfo *) &log_info->timer);
-  RelinquishSemaphoreInfo(log_semaphore);
+  UnlockSemaphoreInfo(log_semaphore);
   return(MagickTrue);
 }
@@ -1682 +1685 @@
   exception=DestroyExceptionInfo(exception);
   option=ParseMagickOption(MagickLogEventOptions,MagickTrue,events);
-  AcquireSemaphoreInfo(&log_semaphore);
+  LockSemaphoreInfo(log_semaphore);
   log_info=(LogInfo *) GetValueFromLinkedList(log_list,0);
   log_info->event_mask=(LogEventType) option;
   if (option == -1)
     log_info->event_mask=UndefinedEvents;
-  RelinquishSemaphoreInfo(log_semaphore);
+  UnlockSemaphoreInfo(log_semaphore);
   return(log_info->event_mask);
 }
@@ -1724 +1727 @@
   log_info=(LogInfo *) GetLogInfo("*",exception);
   exception=DestroyExceptionInfo(exception);
-  AcquireSemaphoreInfo(&log_semaphore);
+  LockSemaphoreInfo(log_semaphore);
   if (log_info->format != (char *) NULL)
     log_info->format=DestroyString(log_info->format);
   log_info->format=ConstantString(format);
-  RelinquishSemaphoreInfo(log_semaphore);
+  UnlockSemaphoreInfo(log_semaphore);
 }
 

ImageMagick/trunk/magick/magic.c

@@ -260 +260 @@
     Search for magic tag.
   */
-  AcquireSemaphoreInfo(&magic_semaphore);
+  LockSemaphoreInfo(magic_semaphore);
   ResetLinkedListIterator(magic_list);
   p=(const MagicInfo *) GetNextValueInLinkedList(magic_list);
@@ -274 +274 @@
     (void) InsertValueInLinkedList(magic_list,0,
       RemoveElementByValueFromLinkedList(magic_list,p));
-  RelinquishSemaphoreInfo(magic_semaphore);
+  UnlockSemaphoreInfo(magic_semaphore);
   return(p);
 }
@@ -357 +357 @@
     Generate magic list.
   */
-  AcquireSemaphoreInfo(&magic_semaphore);
+  LockSemaphoreInfo(magic_semaphore);
   ResetLinkedListIterator(magic_list);
   p=(const MagicInfo *) GetNextValueInLinkedList(magic_list);
@@ -367 +367 @@
     p=(const MagicInfo *) GetNextValueInLinkedList(magic_list);
   }
-  RelinquishSemaphoreInfo(magic_semaphore);
+  UnlockSemaphoreInfo(magic_semaphore);
   qsort((void *) aliases,(size_t) i,sizeof(*aliases),MagicInfoCompare);
   aliases[i]=(MagicInfo *) NULL;
@@ -449 +449 @@
   if (aliases == (char **) NULL)
     return((char **) NULL);
-  AcquireSemaphoreInfo(&magic_semaphore);
+  LockSemaphoreInfo(magic_semaphore);
   ResetLinkedListIterator(magic_list);
   p=(const MagicInfo *) GetNextValueInLinkedList(magic_list);
@@ -459 +459 @@
     p=(const MagicInfo *) GetNextValueInLinkedList(magic_list);
   }
-  RelinquishSemaphoreInfo(magic_semaphore);
+  UnlockSemaphoreInfo(magic_semaphore);
   qsort((void *) aliases,(size_t) i,sizeof(*aliases),MagicCompare);
   aliases[i]=(char *) NULL;
@@ -524 +524 @@
     {
       AcquireSemaphoreInfo(&magic_semaphore);
+      LockSemaphoreInfo(magic_semaphore);
       if ((magic_list == (LinkedListInfo *) NULL) &&
           (instantiate_magic == MagickFalse))
@@ -530 +531 @@
           instantiate_magic=MagickTrue;
         }
-      RelinquishSemaphoreInfo(magic_semaphore);
+      UnlockSemaphoreInfo(magic_semaphore);
     }
   return(magic_list != (LinkedListInfo *) NULL ? MagickTrue : MagickFalse);
@@ -1011 +1012 @@
 MagickExport MagickBooleanType MagicComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&magic_semaphore);
-  RelinquishSemaphoreInfo(magic_semaphore);
+  assert(magic_semaphore == (SemaphoreInfo *) NULL);
+  magic_semaphore=AllocateSemaphoreInfo();
   return(MagickTrue);
 }
@@ -1058 +1059 @@
 MagickExport void MagicComponentTerminus(void)
 {
-  AcquireSemaphoreInfo(&magic_semaphore);
+  if (magic_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&magic_semaphore);
+  LockSemaphoreInfo(magic_semaphore);
   if (magic_list != (LinkedListInfo *) NULL)
     magic_list=DestroyLinkedList(magic_list,DestroyMagicElement);
   instantiate_magic=MagickFalse;
-  RelinquishSemaphoreInfo(magic_semaphore);
+  UnlockSemaphoreInfo(magic_semaphore);
   DestroySemaphoreInfo(&magic_semaphore);
 }

ImageMagick/trunk/magick/magick.c

@@ -229 +229 @@
     return(MagickFalse);
   status=MagickFalse;
-  AcquireSemaphoreInfo(&magick_semaphore);
+  LockSemaphoreInfo(magick_semaphore);
   ResetSplayTreeIterator(magick_list);
   p=(const MagickInfo *) GetNextValueInSplayTree(magick_list);
@@ -243 +243 @@
     p=(const MagickInfo *) GetNextValueInSplayTree(magick_list);
   }
-  RelinquishSemaphoreInfo(magick_semaphore);
+  UnlockSemaphoreInfo(magick_semaphore);
   return(status);
 }
@@ -413 +413 @@
         (void) OpenModules(exception);
 #endif
-      AcquireSemaphoreInfo(&magick_semaphore);
+      LockSemaphoreInfo(magick_semaphore);
       ResetSplayTreeIterator(magick_list);
       p=(const MagickInfo *) GetNextValueInSplayTree(magick_list);
-      RelinquishSemaphoreInfo(magick_semaphore);
+      UnlockSemaphoreInfo(magick_semaphore);
       return(p);
     }
@@ -422 +422 @@
     Find name in list.
   */
-  AcquireSemaphoreInfo(&magick_semaphore);
+  LockSemaphoreInfo(magick_semaphore);
   ResetSplayTreeIterator(magick_list);
   p=(const MagickInfo *) GetNextValueInSplayTree(magick_list);
@@ -446 +446 @@
     }
 #endif
-  RelinquishSemaphoreInfo(magick_semaphore);
+  UnlockSemaphoreInfo(magick_semaphore);
   return(p);
 }
@@ -527 +527 @@
     Generate magick list.
   */
-  AcquireSemaphoreInfo(&magick_semaphore);
+  LockSemaphoreInfo(magick_semaphore);
   ResetSplayTreeIterator(magick_list);
   p=(const MagickInfo *) GetNextValueInSplayTree(magick_list);
@@ -537 +537 @@
     p=(const MagickInfo *) GetNextValueInSplayTree(magick_list);
   }
-  RelinquishSemaphoreInfo(magick_semaphore);
+  UnlockSemaphoreInfo(magick_semaphore);
   qsort((void *) formats,(size_t) i,sizeof(*formats),MagickInfoCompare);
   formats[i]=(MagickInfo *) NULL;
@@ -617 +617 @@
   if (formats == (char **) NULL)
     return((char **) NULL);
-  AcquireSemaphoreInfo(&magick_semaphore);
+  LockSemaphoreInfo(magick_semaphore);
   ResetSplayTreeIterator(magick_list);
   p=(const MagickInfo *) GetNextValueInSplayTree(magick_list);
@@ -627 +627 @@
     p=(const MagickInfo *) GetNextValueInSplayTree(magick_list);
   }
-  RelinquishSemaphoreInfo(magick_semaphore);
+  UnlockSemaphoreInfo(magick_semaphore);
   qsort((void *) formats,(size_t) i,sizeof(*formats),MagickCompare);
   formats[i]=(char *) NULL;
@@ -777 +777 @@
     {
       AcquireSemaphoreInfo(&magick_semaphore);
+      LockSemaphoreInfo(magick_semaphore);
       if ((magick_list == (SplayTreeInfo *) NULL) &&
           (instantiate_magick == MagickFalse))
@@ -818 +819 @@
           instantiate_magick=MagickTrue;
         }
-      RelinquishSemaphoreInfo(magick_semaphore);
+      UnlockSemaphoreInfo(magick_semaphore);
     }
   return(magick_list != (SplayTreeInfo *) NULL ? MagickTrue : MagickFalse);
@@ -1030 +1031 @@
 MagickExport MagickBooleanType MagickComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&magick_semaphore);
-  RelinquishSemaphoreInfo(magick_semaphore);
+  assert(magick_semaphore == (SemaphoreInfo *) NULL);
+  magick_semaphore=AllocateSemaphoreInfo();
   return(MagickTrue);
 }
@@ -1055 +1056 @@
 MagickExport void MagickComponentTerminus(void)
 {
-  AcquireSemaphoreInfo(&magick_semaphore);
+  if (magick_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&magick_semaphore);
+  LockSemaphoreInfo(magick_semaphore);
   if (magick_list != (SplayTreeInfo *) NULL)
     magick_list=DestroySplayTree(magick_list);
   instantiate_magick=MagickFalse;
-  RelinquishSemaphoreInfo(magick_semaphore);
+  UnlockSemaphoreInfo(magick_semaphore);
   DestroySemaphoreInfo(&magick_semaphore);
 }
@@ -1262 +1265 @@
     Instantiate magick resources.
   */
+  (void) ConfigureComponentGenesis();
   (void) PolicyComponentGenesis();
   (void) CacheComponentGenesis();
@@ -1275 +1279 @@
   (void) ColorComponentGenesis();
   (void) TypeComponentGenesis();
-  (void) ConfigureComponentGenesis();
   (void) MimeComponentGenesis();
   (void) ConstituteComponentGenesis();
@@ -1306 +1309 @@
   ConstituteComponentTerminus();
   MimeComponentTerminus();
-  ConfigureComponentTerminus();
   TypeComponentTerminus();
   ColorComponentTerminus();
@@ -1326 +1328 @@
   CacheComponentTerminus();
   PolicyComponentTerminus();
+  ConfigureComponentTerminus();
   RandomComponentTerminus();
   LocaleComponentTerminus();
@@ -1462 +1465 @@
   if (GetNumberOfNodesInSplayTree(magick_list) == 0)
     return(MagickFalse);
-  AcquireSemaphoreInfo(&magick_semaphore);
+  LockSemaphoreInfo(magick_semaphore);
   ResetSplayTreeIterator(magick_list);
   p=(const MagickInfo *) GetNextValueInSplayTree(magick_list);
@@ -1472 +1475 @@
   }
   status=DeleteNodeByValueFromSplayTree(magick_list,p);
-  RelinquishSemaphoreInfo(magick_semaphore);
+  UnlockSemaphoreInfo(magick_semaphore);
   return(status);
 }

ImageMagick/trunk/magick/memory.c

@@ -392 +392 @@
   if (free_segments == (DataSegmentInfo *) NULL)
     {
-      AcquireSemaphoreInfo(&memory_semaphore);
+      LockSemaphoreInfo(memory_semaphore);
       if (free_segments == (DataSegmentInfo *) NULL)
         {
@@ -412 +412 @@
           free_segments=(&memory_info.segment_pool[0]);
         }
-      RelinquishSemaphoreInfo(memory_semaphore);
-    }
-  AcquireSemaphoreInfo(&memory_semaphore);
+      UnlockSemaphoreInfo(memory_semaphore);
+    }
+  LockSemaphoreInfo(memory_semaphore);
   memory=AcquireBlock(size == 0 ? 1UL : size);
   if (memory == (void *) NULL)
@@ -421 +421 @@
         memory=AcquireBlock(size == 0 ? 1UL : size);
     }
-  RelinquishSemaphoreInfo(memory_semaphore);
+  UnlockSemaphoreInfo(memory_semaphore);
 #endif
   return(memory);
@@ -547 +547 @@
     i;
 
-  AcquireSemaphoreInfo(&memory_semaphore);
-  RelinquishSemaphoreInfo(memory_semaphore);
+  LockSemaphoreInfo(memory_semaphore);
+  UnlockSemaphoreInfo(memory_semaphore);
   for (i=0; i < (long) memory_info.number_segments; i++)
     if (memory_info.segments[i]->mapped == MagickFalse)
@@ -743 +743 @@
   assert((SizeOfBlock(memory) % (4*sizeof(size_t))) == 0);
   assert((*BlockHeader(NextBlock(memory)) & PreviousBlockBit) != 0);
-  AcquireSemaphoreInfo(&memory_semaphore);
+  LockSemaphoreInfo(memory_semaphore);
   if ((*BlockHeader(memory) & PreviousBlockBit) == 0)
     {
@@ -774 +774 @@
   *BlockHeader(NextBlock(memory))&=(~PreviousBlockBit);
   InsertFreeBlock(memory,AllocationPolicy(SizeOfBlock(memory)));
-  RelinquishSemaphoreInfo(memory_semaphore);
+  UnlockSemaphoreInfo(memory_semaphore);
 #endif
   return((void *) NULL);
@@ -871 +871 @@
     memory=RelinquishMagickMemory(memory);
 #else
-  AcquireSemaphoreInfo(&memory_semaphore);
+  LockSemaphoreInfo(memory_semaphore);
   block=ResizeBlock(memory,size == 0 ? 1UL : size);
   if (block == (void *) NULL)
@@ -877 +877 @@
       if (ExpandHeap(size == 0 ? 1UL : size) == MagickFalse)
         {
-          RelinquishSemaphoreInfo(memory_semaphore);
+          UnlockSemaphoreInfo(memory_semaphore);
           memory=RelinquishMagickMemory(memory);
           ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
@@ -884 +884 @@
       assert(block != (void *) NULL);
     }
-  RelinquishSemaphoreInfo(memory_semaphore);
+  UnlockSemaphoreInfo(memory_semaphore);
   memory=RelinquishMagickMemory(memory);
 #endif

ImageMagick/trunk/magick/mime.c

@@ -201 +201 @@
   mime_info=(const MimeInfo *) NULL;
   lsb_first=1;
-  AcquireSemaphoreInfo(&mime_semaphore);
+  LockSemaphoreInfo(mime_semaphore);
   ResetLinkedListIterator(mime_list);
   p=(const MimeInfo *) GetNextValueInLinkedList(mime_list);
@@ -325 +325 @@
     (void) InsertValueInLinkedList(mime_list,0,
       RemoveElementByValueFromLinkedList(mime_list,p));
-  RelinquishSemaphoreInfo(mime_semaphore);
+  UnlockSemaphoreInfo(mime_semaphore);
   return(mime_info);
 }
@@ -409 +409 @@
     Generate mime list.
   */
-  AcquireSemaphoreInfo(&mime_semaphore);
+  LockSemaphoreInfo(mime_semaphore);
   ResetLinkedListIterator(mime_list);
   p=(const MimeInfo *) GetNextValueInLinkedList(mime_list);
@@ -419 +419 @@
     p=(const MimeInfo *) GetNextValueInLinkedList(mime_list);
   }
-  RelinquishSemaphoreInfo(mime_semaphore);
+  UnlockSemaphoreInfo(mime_semaphore);
   qsort((void *) aliases,(size_t) i,sizeof(*aliases),MimeInfoCompare);
   aliases[i]=(MimeInfo *) NULL;
@@ -501 +501 @@
   if (aliases == (char **) NULL)
     return((char **) NULL);
-  AcquireSemaphoreInfo(&mime_semaphore);
+  LockSemaphoreInfo(mime_semaphore);
   ResetLinkedListIterator(mime_list);
   p=(const MimeInfo *) GetNextValueInLinkedList(mime_list);
@@ -511 +511 @@
     p=(const MimeInfo *) GetNextValueInLinkedList(mime_list);
   }
-  RelinquishSemaphoreInfo(mime_semaphore);
+  UnlockSemaphoreInfo(mime_semaphore);
   qsort((void *) aliases,(size_t) i,sizeof(*aliases),MimeCompare);
   aliases[i]=(char *) NULL;
@@ -606 +606 @@
     {
       AcquireSemaphoreInfo(&mime_semaphore);
+      LockSemaphoreInfo(mime_semaphore);
       if ((mime_list == (LinkedListInfo *) NULL) &&
           (instantiate_mime == MagickFalse))
@@ -612 +613 @@
           instantiate_mime=MagickTrue;
         }
-      RelinquishSemaphoreInfo(mime_semaphore);
+      UnlockSemaphoreInfo(mime_semaphore);
     }
   return(mime_list != (LinkedListInfo *) NULL ? MagickTrue : MagickFalse);
@@ -1051 +1052 @@
 MagickExport MagickBooleanType MimeComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&mime_semaphore);
-  RelinquishSemaphoreInfo(mime_semaphore);
+  assert(mime_semaphore == (SemaphoreInfo *) NULL);
+  mime_semaphore=AllocateSemaphoreInfo();
   return(MagickTrue);
 }
@@ -1097 +1098 @@
 MagickExport void MimeComponentTerminus(void)
 {
-  AcquireSemaphoreInfo(&mime_semaphore);
+  if (mime_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&mime_semaphore);
+  LockSemaphoreInfo(mime_semaphore);
   if (mime_list != (LinkedListInfo *) NULL)
     mime_list=DestroyLinkedList(mime_list,DestroyMimeElement);
   instantiate_mime=MagickFalse;
-  RelinquishSemaphoreInfo(mime_semaphore);
+  UnlockSemaphoreInfo(mime_semaphore);
   DestroySemaphoreInfo(&mime_semaphore);
 }

ImageMagick/trunk/magick/module.c

@@ -176 +176 @@
     Destroy magick modules.
   */
-  AcquireSemaphoreInfo(&module_semaphore);
+  LockSemaphoreInfo(module_semaphore);
 #if defined(MAGICKCORE_MODULES_SUPPORT)
   if (module_list != (SplayTreeInfo *) NULL)
@@ -184 +184 @@
 #endif
   instantiate_module=MagickFalse;
-  RelinquishSemaphoreInfo(module_semaphore);
+  UnlockSemaphoreInfo(module_semaphore);
 }
 
@@ -233 +233 @@
         (void) OpenModules(exception);
 #endif
-      AcquireSemaphoreInfo(&module_semaphore);
+      LockSemaphoreInfo(module_semaphore);
       ResetSplayTreeIterator(module_list);
       p=(ModuleInfo *) GetNextValueInSplayTree(module_list);
-      RelinquishSemaphoreInfo(module_semaphore);
+      UnlockSemaphoreInfo(module_semaphore);
       return(p);
     }
@@ -320 +320 @@
     Generate module list.
   */
-  AcquireSemaphoreInfo(&module_semaphore);
+  LockSemaphoreInfo(module_semaphore);
   ResetSplayTreeIterator(module_list);
   p=(const ModuleInfo *) GetNextValueInSplayTree(module_list);
@@ -330 +330 @@
     p=(const ModuleInfo *) GetNextValueInSplayTree(module_list);
   }
-  RelinquishSemaphoreInfo(module_semaphore);
+  UnlockSemaphoreInfo(module_semaphore);
   qsort((void *) modules,(size_t) i,sizeof(*modules),ModuleInfoCompare);
   modules[i]=(ModuleInfo *) NULL;
@@ -849 +849 @@
     {
       AcquireSemaphoreInfo(&module_semaphore);
+      LockSemaphoreInfo(module_semaphore);
       if ((module_list == (SplayTreeInfo *) NULL) &&
           (instantiate_module == MagickFalse))
@@ -874 +875 @@
           instantiate_module=MagickTrue;
         }
-      RelinquishSemaphoreInfo(module_semaphore);
+      UnlockSemaphoreInfo(module_semaphore);
     }
   return(module_list != (SplayTreeInfo *) NULL ? MagickTrue : MagickFalse);
@@ -1106 +1107 @@
     *exception;
 
+  assert(module_semaphore == (SemaphoreInfo *) NULL);
+  module_semaphore=AllocateSemaphoreInfo();
   exception=AcquireExceptionInfo();
   InitializeModuleList(exception);
@@ -1132 +1135 @@
 MagickExport void ModuleComponentTerminus(void)
 {
+  if (module_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&module_semaphore);
   DestroyModuleList();
   DestroySemaphoreInfo(&module_semaphore);

ImageMagick/trunk/magick/policy.c

@@ -193 +193 @@
     Search for policy tag.
   */
-  AcquireSemaphoreInfo(&policy_semaphore);
+  LockSemaphoreInfo(policy_semaphore);
   ResetLinkedListIterator(policy_list);
   p=(PolicyInfo *) GetNextValueInLinkedList(policy_list);
@@ -208 +208 @@
     (void) InsertValueInLinkedList(policy_list,0,
       RemoveElementByValueFromLinkedList(policy_list,p));
-  RelinquishSemaphoreInfo(policy_semaphore);
+  UnlockSemaphoreInfo(policy_semaphore);
   return(p);
 }
@@ -268 +268 @@
     Generate policy list.
   */
-  AcquireSemaphoreInfo(&policy_semaphore);
+  LockSemaphoreInfo(policy_semaphore);
   ResetLinkedListIterator(policy_list);
   p=(const PolicyInfo *) GetNextValueInLinkedList(policy_list);
@@ -278 +278 @@
     p=(const PolicyInfo *) GetNextValueInLinkedList(policy_list);
   }
-  RelinquishSemaphoreInfo(policy_semaphore);
+  UnlockSemaphoreInfo(policy_semaphore);
   policies[i]=(PolicyInfo *) NULL;
   *number_policies=(unsigned long) i;
@@ -340 +340 @@
     Generate policy list.
   */
-  AcquireSemaphoreInfo(&policy_semaphore);
+  LockSemaphoreInfo(policy_semaphore);
   ResetLinkedListIterator(policy_list);
   p=(const PolicyInfo *) GetNextValueInLinkedList(policy_list);
@@ -350 +350 @@
     p=(const PolicyInfo *) GetNextValueInLinkedList(policy_list);
   }
-  RelinquishSemaphoreInfo(policy_semaphore);
+  UnlockSemaphoreInfo(policy_semaphore);
   policies[i]=(char *) NULL;
   *number_policies=(unsigned long) i;
@@ -430 +430 @@
     {
       AcquireSemaphoreInfo(&policy_semaphore);
+      LockSemaphoreInfo(policy_semaphore);
       if ((policy_list == (LinkedListInfo *) NULL) &&
           (instantiate_policy == MagickFalse))
@@ -436 +437 @@
           instantiate_policy=MagickTrue;
         }
-      RelinquishSemaphoreInfo(policy_semaphore);
+      UnlockSemaphoreInfo(policy_semaphore);
     }
   return(policy_list != (LinkedListInfo *) NULL ? MagickTrue : MagickFalse);
@@ -494 +495 @@
     return(MagickTrue);
   authorized=MagickTrue;
-  AcquireSemaphoreInfo(&policy_semaphore);
+  LockSemaphoreInfo(policy_semaphore);
   ResetLinkedListIterator(policy_list);
   p=(PolicyInfo *) GetNextValueInLinkedList(policy_list);
@@ -514 +515 @@
     p=(PolicyInfo *) GetNextValueInLinkedList(policy_list);
   }
-  RelinquishSemaphoreInfo(policy_semaphore);
+  UnlockSemaphoreInfo(policy_semaphore);
   return(authorized);
 }
@@ -965 +966 @@
 MagickExport MagickBooleanType PolicyComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&policy_semaphore);
-  RelinquishSemaphoreInfo(policy_semaphore);
+  assert(policy_semaphore == (SemaphoreInfo *) NULL);
+  policy_semaphore=AllocateSemaphoreInfo();
   return(MagickTrue);
 }
@@ -1012 +1013 @@
 MagickExport void PolicyComponentTerminus(void)
 {
-  AcquireSemaphoreInfo(&policy_semaphore);
+  if (policy_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&policy_semaphore);
+  LockSemaphoreInfo(policy_semaphore);
   if (policy_list != (LinkedListInfo *) NULL)
     policy_list=DestroyLinkedList(policy_list,DestroyPolicyElement);
   instantiate_policy=MagickFalse;
-  RelinquishSemaphoreInfo(policy_semaphore);
+  UnlockSemaphoreInfo(policy_semaphore);
   DestroySemaphoreInfo(&policy_semaphore);
 }

ImageMagick/trunk/magick/random.c

@@ -690 +690 @@
 %                                                                             %
 %                                                                             %
-+   R a n d o m C o m p o n e n t G e n e s i s                                %
++   R a n d o m C o m p o n e n t G e n e s i s                               %
 %                                                                             %
 %                                                                             %
@@ -705 +705 @@
 MagickExport MagickBooleanType RandomComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&random_semaphore);
-  RelinquishSemaphoreInfo(random_semaphore);
+  assert(random_semaphore == (SemaphoreInfo *) NULL);
+  random_semaphore=AllocateSemaphoreInfo();
   return(MagickTrue);
 }
@@ -730 +730 @@
 MagickExport void RandomComponentTerminus(void)
 {
-  AcquireSemaphoreInfo(&random_semaphore);
-  (void) UnlockSemaphoreInfo(random_semaphore);
+  if (random_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&random_semaphore);
   DestroySemaphoreInfo(&random_semaphore);
 }

ImageMagick/trunk/magick/registry.c

@@ -300 +300 @@
 MagickExport MagickBooleanType RegistryComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&registry_semaphore);
-  RelinquishSemaphoreInfo(registry_semaphore);
+  assert(registry_semaphore == (SemaphoreInfo *) NULL);
+  registry_semaphore=AllocateSemaphoreInfo();
   return(MagickTrue);
 }
@@ -325 +325 @@
 MagickExport void RegistryComponentTerminus(void)
 {
-  AcquireSemaphoreInfo(&registry_semaphore);
+  if (registry_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&registry_semaphore);
+  LockSemaphoreInfo(registry_semaphore);
   if (IsEventLogging() != MagickFalse)
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
@@ -331 +333 @@
     registry=DestroySplayTree(registry);
   instantiate_registry=MagickFalse;
-  RelinquishSemaphoreInfo(registry_semaphore);
+  UnlockSemaphoreInfo(registry_semaphore);
   DestroySemaphoreInfo(&registry_semaphore);
 }
@@ -525 +527 @@
     {
       AcquireSemaphoreInfo(&registry_semaphore);
+      LockSemaphoreInfo(registry_semaphore);
       if ((registry == (SplayTreeInfo *) NULL) &&
           (instantiate_registry == MagickFalse))
@@ -532 +535 @@
           instantiate_registry=MagickTrue;
         }
-      RelinquishSemaphoreInfo(registry_semaphore);
+      UnlockSemaphoreInfo(registry_semaphore);
     }
   status=AddValueToSplayTree(registry,ConstantString(key),registry_info);

ImageMagick/trunk/magick/resource.c

@@ -160 +160 @@
   status=MagickFalse;
   (void) FormatMagickSize(size,resource_request);
-  AcquireSemaphoreInfo(&resource_semaphore);
+  if (resource_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&resource_semaphore);
+  LockSemaphoreInfo(resource_semaphore);
   switch (type)
   {
@@ -254 +256 @@
       break;
   }
-  RelinquishSemaphoreInfo(resource_semaphore);
+  UnlockSemaphoreInfo(resource_semaphore);
   (void) LogMagickEvent(ResourceEvent,GetMagickModule(),"%s: %s/%s/%s",
     MagickOptionToMnemonic(MagickResourceOptions,(long) type),resource_request,
@@ -468 +470 @@
   if (file == -1)
     return(file);
-  AcquireSemaphoreInfo(&resource_semaphore);
+  if (resource_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&resource_semaphore);
+  LockSemaphoreInfo(resource_semaphore);
   if (temporary_resources == (SplayTreeInfo *) NULL)
     temporary_resources=NewSplayTree(CompareSplayTreeString,
       RelinquishMagickMemory,DestroyTemporaryResources);
-  RelinquishSemaphoreInfo(resource_semaphore);
+  UnlockSemaphoreInfo(resource_semaphore);
   resource=ConstantString(path);
   (void) AddValueToSplayTree(temporary_resources,resource,resource);
@@ -506 +510 @@
 
   resource=0;
-  AcquireSemaphoreInfo(&resource_semaphore);
+  LockSemaphoreInfo(resource_semaphore);
   switch (type)
   {
@@ -547 +551 @@
       break;
   }
-  RelinquishSemaphoreInfo(resource_semaphore);
+  UnlockSemaphoreInfo(resource_semaphore);
   return(resource);
 }
@@ -579 +583 @@
 
   resource=0;
-  AcquireSemaphoreInfo(&resource_semaphore);
+  if (resource_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&resource_semaphore);
+  LockSemaphoreInfo(resource_semaphore);
   switch (type)
   {
@@ -620 +626 @@
       break;
   }
-  RelinquishSemaphoreInfo(resource_semaphore);
+  UnlockSemaphoreInfo(resource_semaphore);
   return(resource);
 }
@@ -661 +667 @@
   if (file == (const FILE *) NULL)
     file=stdout;
-  AcquireSemaphoreInfo(&resource_semaphore);
+  if (resource_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&resource_semaphore);
+  LockSemaphoreInfo(resource_semaphore);
   (void) FormatMagickSize(resource_info.area_limit,area_limit);
   (void) FormatMagickSize(resource_info.memory_limit,memory_limit);
@@ -678 +686 @@
     disk_limit,(unsigned long) resource_info.thread_limit,time_limit);
   (void) fflush(file);
-  RelinquishSemaphoreInfo(resource_semaphore);
+  UnlockSemaphoreInfo(resource_semaphore);
   return(MagickTrue);
 }
@@ -716 +724 @@
 
   (void) FormatMagickSize(size,resource_request);
-  AcquireSemaphoreInfo(&resource_semaphore);
+  if (resource_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&resource_semaphore);
+  LockSemaphoreInfo(resource_semaphore);
   switch (type)
   {
@@ -781 +791 @@
       break;
   }
-  RelinquishSemaphoreInfo(resource_semaphore);
+  UnlockSemaphoreInfo(resource_semaphore);
   (void) LogMagickEvent(ResourceEvent,GetMagickModule(),"%s: %s/%s/%s",
     MagickOptionToMnemonic(MagickResourceOptions,(long) type),resource_request,
@@ -893 +903 @@
     Set Magick resource limits.
   */
-  AcquireSemaphoreInfo(&resource_semaphore);
-  RelinquishSemaphoreInfo(resource_semaphore);
+  assert(resource_semaphore == (SemaphoreInfo *) NULL);
+  resource_semaphore=AllocateSemaphoreInfo();
   pagesize=GetMagickPageSize();
   pages=(-1);
@@ -1014 +1024 @@
 MagickExport void ResourceComponentTerminus(void)
 {
-  AcquireSemaphoreInfo(&resource_semaphore);
+  if (resource_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&resource_semaphore);
+  LockSemaphoreInfo(resource_semaphore);
   if (temporary_resources != (SplayTreeInfo *) NULL)
     temporary_resources=DestroySplayTree(temporary_resources);
   if (random_info != (RandomInfo *) NULL)
     random_info=DestroyRandomInfo(random_info);
-  RelinquishSemaphoreInfo(resource_semaphore);
+  UnlockSemaphoreInfo(resource_semaphore);
   DestroySemaphoreInfo(&resource_semaphore);
 }
@@ -1051 +1063 @@
   const MagickSizeType limit)
 {
-  AcquireSemaphoreInfo(&resource_semaphore);
+  if (resource_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&resource_semaphore);
+  LockSemaphoreInfo(resource_semaphore);
   switch (type)
   {
@@ -1093 +1107 @@
       break;
   }
-  RelinquishSemaphoreInfo(resource_semaphore);
+  UnlockSemaphoreInfo(resource_semaphore);
   return(MagickTrue);
 }

ImageMagick/trunk/magick/semaphore.c

@@ -119 +119 @@
     *semaphore_info=AllocateSemaphoreInfo();
   UnlockMagickMutex();
-  (void) LockSemaphoreInfo(*semaphore_info);
 }
 

ImageMagick/trunk/magick/type.c

@@ -271 +271 @@
   if (type_list == (SplayTreeInfo *) NULL)
     return((TypeInfo *) NULL);
-  AcquireSemaphoreInfo(&type_semaphore);
+  LockSemaphoreInfo(type_semaphore);
   ResetSplayTreeIterator(type_list);
   type_info=(const TypeInfo *) NULL;
@@ -316 +316 @@
     break;
   }
-  RelinquishSemaphoreInfo(type_semaphore);
+  UnlockSemaphoreInfo(type_semaphore);
   if (type_info != (const TypeInfo *) NULL)
     return(type_info);
@@ -323 +323 @@
   */
   max_score=0;
-  AcquireSemaphoreInfo(&type_semaphore);
+  LockSemaphoreInfo(type_semaphore);
   ResetSplayTreeIterator(type_list);
   p=(const TypeInfo *) GetNextValueInSplayTree(type_list);
@@ -375 +375 @@
     p=(const TypeInfo *) GetNextValueInSplayTree(type_list);
   }
-  RelinquishSemaphoreInfo(type_semaphore);
+  UnlockSemaphoreInfo(type_semaphore);
   if (type_info != (const TypeInfo *) NULL)
     return(type_info);
@@ -486 +486 @@
     Generate type list.
   */
-  AcquireSemaphoreInfo(&type_semaphore);
+  LockSemaphoreInfo(type_semaphore);
   ResetSplayTreeIterator(type_list);
   p=(const TypeInfo *) GetNextValueInSplayTree(type_list);
@@ -496 +496 @@
     p=(const TypeInfo *) GetNextValueInSplayTree(type_list);
   }
-  RelinquishSemaphoreInfo(type_semaphore);
+  UnlockSemaphoreInfo(type_semaphore);
   qsort((void *) fonts,(size_t) i,sizeof(*fonts),TypeInfoCompare);
   fonts[i]=(TypeInfo *) NULL;
@@ -579 +579 @@
     Generate type list.
   */
-  AcquireSemaphoreInfo(&type_semaphore);
+  LockSemaphoreInfo(type_semaphore);
   ResetSplayTreeIterator(type_list);
   p=(const TypeInfo *) GetNextValueInSplayTree(type_list);
@@ -589 +589 @@
     p=(const TypeInfo *) GetNextValueInSplayTree(type_list);
   }
-  RelinquishSemaphoreInfo(type_semaphore);
+  UnlockSemaphoreInfo(type_semaphore);
   qsort((void *) fonts,(size_t) i,sizeof(*fonts),TypeCompare);
   fonts[i]=(char *) NULL;
@@ -773 +773 @@
     {
       AcquireSemaphoreInfo(&type_semaphore);
+      LockSemaphoreInfo(type_semaphore);
       if ((type_list == (SplayTreeInfo *) NULL) &&
           (instantiate_type == MagickFalse))
@@ -785 +786 @@
           instantiate_type=MagickTrue;
         }
-      RelinquishSemaphoreInfo(type_semaphore);
+      UnlockSemaphoreInfo(type_semaphore);
     }
   return(type_list != (SplayTreeInfo *) NULL ? MagickTrue : MagickFalse);
@@ -1343 +1344 @@
 MagickExport MagickBooleanType TypeComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&type_semaphore);
-  RelinquishSemaphoreInfo(type_semaphore);
+  assert(type_semaphore == (SemaphoreInfo *) NULL);
+  type_semaphore=AllocateSemaphoreInfo();
   return(MagickTrue);
 }
@@ -1368 +1369 @@
 MagickExport void TypeComponentTerminus(void)
 {
-  AcquireSemaphoreInfo(&type_semaphore);
+  if (type_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&type_semaphore);
+  LockSemaphoreInfo(type_semaphore);
   if (type_list != (SplayTreeInfo *) NULL)
     type_list=DestroySplayTree(type_list);
   instantiate_type=MagickFalse;
-  RelinquishSemaphoreInfo(type_semaphore);
+  UnlockSemaphoreInfo(type_semaphore);
   DestroySemaphoreInfo(&type_semaphore);
 }

ImageMagick/trunk/wand/wand.c

@@ -77 +77 @@
     id = 0;
 
-  AcquireSemaphoreInfo(&wand_semaphore);
+  if (wand_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&wand_semaphore);
+  LockSemaphoreInfo(wand_semaphore);
   if ((wand_ids == (SplayTreeInfo *) NULL) && (instantiate_wand == MagickFalse))
     {
@@ -86 +88 @@
   id++;
   (void) AddValueToSplayTree(wand_ids,(const void *) id,(const void *) id);
-  RelinquishSemaphoreInfo(wand_semaphore);
+  UnlockSemaphoreInfo(wand_semaphore);
   return(id);
 }
@@ -112 +114 @@
 WandExport void DestroyWandIds(void)
 {
-  AcquireSemaphoreInfo(&wand_semaphore);
+  LockSemaphoreInfo(wand_semaphore);
   if (wand_ids != (SplayTreeInfo *) NULL)
     wand_ids=DestroySplayTree(wand_ids);
   instantiate_wand=MagickFalse;
-  RelinquishSemaphoreInfo(wand_semaphore);
+  UnlockSemaphoreInfo(wand_semaphore);
   DestroySemaphoreInfo(&wand_semaphore);
 }
@@ -144 +146 @@
 WandExport void RelinquishWandId(const unsigned long id)
 {
-  AcquireSemaphoreInfo(&wand_semaphore);
+  LockSemaphoreInfo(wand_semaphore);
   if (wand_ids != (SplayTreeInfo *) NULL)
     (void) DeleteNodeByValueFromSplayTree(wand_ids,(const void *) id);
-  RelinquishSemaphoreInfo(wand_semaphore);
+  UnlockSemaphoreInfo(wand_semaphore);
 }