Changeset 460

Show
Ignore:
Timestamp:
10/25/09 14:29:37 (4 weeks ago)
Author:
cristy
Message:
 
Location:
ImageMagick/trunk
Files:
23 modified

Legend:

Unmodified
Added
Removed

  • ImageMagick/trunk/coders/png.c

    r453 r460  
    17041704 
    17051705#if defined(PNG_SETJMP_NOT_THREAD_SAFE) 
    1706   LockSemaphoreInfo(png_semaphore); 
     1706  (void) LockSemaphoreInfo(png_semaphore); 
    17071707#endif 
    17081708 
    … …  
    17491749      png_destroy_read_struct(&ping,&ping_info,&end_info); 
    17501750#if defined(PNG_SETJMP_NOT_THREAD_SAFE) 
    1751       UnlockSemaphoreInfo(png_semaphore); 
     1751      (void) UnlockSemaphoreInfo(png_semaphore); 
    17521752#endif 
    17531753      if (logging != MagickFalse) 
    … …  
    22492249      png_destroy_read_struct(&ping,&ping_info,&end_info); 
    22502250#if defined(PNG_SETJMP_NOT_THREAD_SAFE) 
    2251       UnlockSemaphoreInfo(png_semaphore); 
     2251      (void) UnlockSemaphoreInfo(png_semaphore); 
    22522252#endif 
    22532253      if (logging != MagickFalse) 
    … …  
    22802280      png_destroy_read_struct(&ping,&ping_info,&end_info); 
    22812281#if defined(PNG_SETJMP_NOT_THREAD_SAFE) 
    2282       UnlockSemaphoreInfo(png_semaphore); 
     2282      (void) UnlockSemaphoreInfo(png_semaphore); 
    22832283#endif 
    22842284      if (quantum_info != (QuantumInfo *) NULL) 
    … …  
    26362636      (void) SetImageBackgroundColor(image); 
    26372637#if defined(PNG_SETJMP_NOT_THREAD_SAFE) 
    2638       UnlockSemaphoreInfo(png_semaphore); 
     2638      (void) UnlockSemaphoreInfo(png_semaphore); 
    26392639#endif 
    26402640      if (logging != MagickFalse) 
    … …  
    28412841  png_pixels=(unsigned char *) RelinquishMagickMemory(png_pixels); 
    28422842#if defined(PNG_SETJMP_NOT_THREAD_SAFE) 
    2843   UnlockSemaphoreInfo(png_semaphore); 
     2843  (void) UnlockSemaphoreInfo(png_semaphore); 
    28442844#endif 
    28452845 
    … …  
    62756275 
    62766276#if defined(PNG_SETJMP_NOT_THREAD_SAFE) 
    6277   LockSemaphoreInfo(png_semaphore); 
     6277  (void) LockSemaphoreInfo(png_semaphore); 
    62786278#endif 
    62796279 
    … …  
    63226322      png_destroy_write_struct(&ping,&ping_info); 
    63236323#if defined(PNG_SETJMP_NOT_THREAD_SAFE) 
    6324       UnlockSemaphoreInfo(png_semaphore); 
     6324      (void) UnlockSemaphoreInfo(png_semaphore); 
    63256325#endif 
    63266326      return(MagickFalse); 
    … …  
    74257425        png_pixels=(unsigned char *) RelinquishMagickMemory(png_pixels); 
    74267426#if defined(PNG_SETJMP_NOT_THREAD_SAFE) 
    7427       UnlockSemaphoreInfo(png_semaphore); 
     7427      (void) UnlockSemaphoreInfo(png_semaphore); 
    74287428#endif 
    74297429      return(MagickFalse); 
    … …  
    77817781 
    77827782#if defined(PNG_SETJMP_NOT_THREAD_SAFE) 
    7783   UnlockSemaphoreInfo(png_semaphore); 
     7783  (void) UnlockSemaphoreInfo(png_semaphore); 
    77847784#endif 
    77857785 

  • ImageMagick/trunk/coders/tiff.c

    r453 r460  
    16631663  if (tiff_semaphore == (SemaphoreInfo *) NULL) 
    16641664    tiff_semaphore=AllocateSemaphoreInfo(); 
    1665   LockSemaphoreInfo(tiff_semaphore); 
     1665  (void) LockSemaphoreInfo(tiff_semaphore); 
    16661666  if (instantiate_key == MagickFalse) 
    16671667    { 
    … …  
    16701670      instantiate_key=MagickTrue; 
    16711671    } 
    1672   UnlockSemaphoreInfo(tiff_semaphore); 
     1672  (void) UnlockSemaphoreInfo(tiff_semaphore); 
    16731673  *version='\0'; 
    16741674#if defined(TIFF_VERSION) 
    … …  
    17851785  (void) UnregisterMagickInfo("TIFF"); 
    17861786  (void) UnregisterMagickInfo("TIFF64"); 
    1787   LockSemaphoreInfo(tiff_semaphore); 
     1787  (void) LockSemaphoreInfo(tiff_semaphore); 
    17881788  if (instantiate_key != MagickFalse) 
    17891789    if (MagickDeleteThreadKey(tiff_exception) == MagickFalse) 
    17901790      ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed"); 
    17911791  instantiate_key=MagickFalse; 
    1792   UnlockSemaphoreInfo(tiff_semaphore); 
     1792  (void) UnlockSemaphoreInfo(tiff_semaphore); 
    17931793  DestroySemaphoreInfo(&tiff_semaphore); 
    17941794} 

  • ImageMagick/trunk/magick/cache.c

    r455 r460  
    206206      if (cache_semaphore == (SemaphoreInfo *) NULL) 
    207207        AcquireSemaphoreInfo(&cache_semaphore); 
    208       LockSemaphoreInfo(cache_semaphore); 
     208      (void) LockSemaphoreInfo(cache_semaphore); 
    209209      if ((cache_resources == (SplayTreeInfo *) NULL) && 
    210210          (instantiate_cache == MagickFalse)) 
    … …  
    214214          instantiate_cache=MagickTrue; 
    215215        } 
    216       UnlockSemaphoreInfo(cache_semaphore); 
     216      (void) UnlockSemaphoreInfo(cache_semaphore); 
    217217    } 
    218218  (void) AddValueToSplayTree(cache_resources,cache_info,cache_info); 
    … …  
    313313  if (cache_semaphore == (SemaphoreInfo *) NULL) 
    314314    AcquireSemaphoreInfo(&cache_semaphore); 
    315   LockSemaphoreInfo(cache_semaphore); 
     315  (void) LockSemaphoreInfo(cache_semaphore); 
    316316  if (cache_resources != (SplayTreeInfo *) NULL) 
    317317    cache_resources=DestroySplayTree(cache_resources); 
    318318  instantiate_cache=MagickFalse; 
    319   UnlockSemaphoreInfo(cache_semaphore); 
     319  (void) UnlockSemaphoreInfo(cache_semaphore); 
    320320  DestroySemaphoreInfo(&cache_semaphore); 
    321321} 
    … …  
    602602    status; 
    603603 
    604   LockSemaphoreInfo(cache_info->disk_semaphore); 
     604  (void) LockSemaphoreInfo(cache_info->disk_semaphore); 
    605605  status=close(cache_info->file); 
    606606  cache_info->file=(-1); 
    607607  RelinquishMagickResource(FileResource,1); 
    608   UnlockSemaphoreInfo(cache_info->disk_semaphore); 
     608  (void) UnlockSemaphoreInfo(cache_info->disk_semaphore); 
    609609  return(status == -1 ? MagickFalse : MagickTrue); 
    610610} 
    … …  
    621621  if (GetMagickResource(FileResource) < GetMagickResourceLimit(FileResource)) 
    622622    return; 
    623   LockSemaphoreInfo(cache_semaphore); 
     623  (void) LockSemaphoreInfo(cache_semaphore); 
    624624  if (cache_resources == (SplayTreeInfo *) NULL) 
    625625    { 
    626       UnlockSemaphoreInfo(cache_semaphore); 
     626      (void) UnlockSemaphoreInfo(cache_semaphore); 
    627627      return; 
    628628    } 
    … …  
    650650  if (q != (CacheInfo *) NULL) 
    651651    (void) ClosePixelCacheOnDisk(q);  /* relinquish least recently used cache */ 
    652   UnlockSemaphoreInfo(cache_semaphore); 
     652  (void) UnlockSemaphoreInfo(cache_semaphore); 
    653653} 
    654654 
    … …  
    678678    Open pixel cache on disk. 
    679679  */ 
    680   LockSemaphoreInfo(cache_info->disk_semaphore); 
     680  (void) LockSemaphoreInfo(cache_info->disk_semaphore); 
    681681  if (cache_info->file != -1) 
    682682    { 
    683       UnlockSemaphoreInfo(cache_info->disk_semaphore); 
     683      (void) UnlockSemaphoreInfo(cache_info->disk_semaphore); 
    684684      return(MagickTrue);  /* cache already open */ 
    685685    } 
    … …  
    715715  if (file == -1) 
    716716    { 
    717       UnlockSemaphoreInfo(cache_info->disk_semaphore); 
     717      (void) UnlockSemaphoreInfo(cache_info->disk_semaphore); 
    718718      return(MagickFalse); 
    719719    } 
    … …  
    721721  cache_info->file=file; 
    722722  cache_info->timestamp=time(0); 
    723   UnlockSemaphoreInfo(cache_info->disk_semaphore); 
     723  (void) UnlockSemaphoreInfo(cache_info->disk_semaphore); 
    724724  return(MagickTrue); 
    725725} 

  • ImageMagick/trunk/magick/coder.c

    r455 r460  
    283283  if (coder_semaphore == (SemaphoreInfo *) NULL) 
    284284    AcquireSemaphoreInfo(&coder_semaphore); 
    285   LockSemaphoreInfo(coder_semaphore); 
     285  (void) LockSemaphoreInfo(coder_semaphore); 
    286286  if (coder_list != (SplayTreeInfo *) NULL) 
    287287    coder_list=DestroySplayTree(coder_list); 
    288288  instantiate_coder=MagickFalse; 
    289   UnlockSemaphoreInfo(coder_semaphore); 
     289  (void) UnlockSemaphoreInfo(coder_semaphore); 
    290290  DestroySemaphoreInfo(&coder_semaphore); 
    291291} 
    … …  
    404404    Generate coder list. 
    405405  */ 
    406   LockSemaphoreInfo(coder_semaphore); 
     406  (void) LockSemaphoreInfo(coder_semaphore); 
    407407  ResetSplayTreeIterator(coder_list); 
    408408  p=(const CoderInfo *) GetNextValueInSplayTree(coder_list); 
    … …  
    414414    p=(const CoderInfo *) GetNextValueInSplayTree(coder_list); 
    415415  } 
    416   UnlockSemaphoreInfo(coder_semaphore); 
     416  (void) UnlockSemaphoreInfo(coder_semaphore); 
    417417  qsort((void *) coder_map,(size_t) i,sizeof(*coder_map),CoderInfoCompare); 
    418418  coder_map[i]=(CoderInfo *) NULL; 
    … …  
    489489    Generate coder list. 
    490490  */ 
    491   LockSemaphoreInfo(coder_semaphore); 
     491  (void) LockSemaphoreInfo(coder_semaphore); 
    492492  ResetSplayTreeIterator(coder_list); 
    493493  p=(const CoderInfo *) GetNextValueInSplayTree(coder_list); 
    … …  
    499499    p=(const CoderInfo *) GetNextValueInSplayTree(coder_list); 
    500500  } 
    501   UnlockSemaphoreInfo(coder_semaphore); 
     501  (void) UnlockSemaphoreInfo(coder_semaphore); 
    502502  qsort((void *) coder_map,(size_t) i,sizeof(*coder_map),CoderCompare); 
    503503  coder_map[i]=(char *) NULL; 
    … …  
    535535      if (coder_semaphore == (SemaphoreInfo *) NULL) 
    536536        AcquireSemaphoreInfo(&coder_semaphore); 
    537       LockSemaphoreInfo(coder_semaphore); 
     537      (void) LockSemaphoreInfo(coder_semaphore); 
    538538      if ((coder_list == (SplayTreeInfo *) NULL) && 
    539539          (instantiate_coder == MagickFalse)) 
    … …  
    542542          instantiate_coder=MagickTrue; 
    543543        } 
    544       UnlockSemaphoreInfo(coder_semaphore); 
     544      (void) UnlockSemaphoreInfo(coder_semaphore); 
    545545    } 
    546546  return(coder_list != (SplayTreeInfo *) NULL ? MagickTrue : MagickFalse); 

  • ImageMagick/trunk/magick/color.c

    r455 r460  
    862862  if (color_semaphore == (SemaphoreInfo *) NULL) 
    863863    AcquireSemaphoreInfo(&color_semaphore); 
    864   LockSemaphoreInfo(color_semaphore); 
     864  (void) LockSemaphoreInfo(color_semaphore); 
    865865  if (color_list != (LinkedListInfo *) NULL) 
    866866    color_list=DestroyLinkedList(color_list,DestroyColorElement); 
    867867  instantiate_color=MagickFalse; 
    868   UnlockSemaphoreInfo(color_semaphore); 
     868  (void) UnlockSemaphoreInfo(color_semaphore); 
    869869  DestroySemaphoreInfo(&color_semaphore); 
    870870} 
    … …  
    935935    Search for color tag. 
    936936  */ 
    937   LockSemaphoreInfo(color_semaphore); 
     937  (void) LockSemaphoreInfo(color_semaphore); 
    938938  ResetLinkedListIterator(color_list); 
    939939  p=(const ColorInfo *) GetNextValueInLinkedList(color_list); 
    … …  
    950950    (void) InsertValueInLinkedList(color_list,0, 
    951951      RemoveElementByValueFromLinkedList(color_list,p)); 
    952   UnlockSemaphoreInfo(color_semaphore); 
     952  (void) UnlockSemaphoreInfo(color_semaphore); 
    953953  return(p); 
    954954} 
    … …  
    11491149    Generate color list. 
    11501150  */ 
    1151   LockSemaphoreInfo(color_semaphore); 
     1151  (void) LockSemaphoreInfo(color_semaphore); 
    11521152  ResetLinkedListIterator(color_list); 
    11531153  p=(const ColorInfo *) GetNextValueInLinkedList(color_list); 
    … …  
    11591159    p=(const ColorInfo *) GetNextValueInLinkedList(color_list); 
    11601160  } 
    1161   UnlockSemaphoreInfo(color_semaphore); 
     1161  (void) UnlockSemaphoreInfo(color_semaphore); 
    11621162  qsort((void *) colors,(size_t) i,sizeof(*colors),ColorInfoCompare); 
    11631163  colors[i]=(ColorInfo *) NULL; 
    … …  
    12421242    Generate color list. 
    12431243  */ 
    1244   LockSemaphoreInfo(color_semaphore); 
     1244  (void) LockSemaphoreInfo(color_semaphore); 
    12451245  ResetLinkedListIterator(color_list); 
    12461246  p=(const ColorInfo *) GetNextValueInLinkedList(color_list); 
    … …  
    12521252    p=(const ColorInfo *) GetNextValueInLinkedList(color_list); 
    12531253  } 
    1254   UnlockSemaphoreInfo(color_semaphore); 
     1254  (void) UnlockSemaphoreInfo(color_semaphore); 
    12551255  qsort((void *) colors,(size_t) i,sizeof(*colors),ColorCompare); 
    12561256  colors[i]=(char *) NULL; 
    … …  
    14591459      if (color_semaphore == (SemaphoreInfo *) NULL) 
    14601460        AcquireSemaphoreInfo(&color_semaphore); 
    1461       LockSemaphoreInfo(color_semaphore); 
     1461      (void) LockSemaphoreInfo(color_semaphore); 
    14621462      if ((color_list == (LinkedListInfo *) NULL) && 
    14631463          (instantiate_color == MagickFalse)) 
    … …  
    14661466          instantiate_color=MagickTrue; 
    14671467        } 
    1468       UnlockSemaphoreInfo(color_semaphore); 
     1468      (void) UnlockSemaphoreInfo(color_semaphore); 
    14691469    } 
    14701470  return(color_list != (LinkedListInfo *) NULL ? MagickTrue : MagickFalse); 

  • ImageMagick/trunk/magick/configure.c

    r455 r460  
    162162  if (configure_semaphore == (SemaphoreInfo *) NULL) 
    163163    AcquireSemaphoreInfo(&configure_semaphore); 
    164   LockSemaphoreInfo(configure_semaphore); 
     164  (void) LockSemaphoreInfo(configure_semaphore); 
    165165  if (configure_list != (LinkedListInfo *) NULL) 
    166166    configure_list=DestroyLinkedList(configure_list,DestroyConfigureElement); 
    167167  configure_list=(LinkedListInfo *) NULL; 
    168168  instantiate_configure=MagickFalse; 
    169   UnlockSemaphoreInfo(configure_semaphore); 
     169  (void) UnlockSemaphoreInfo(configure_semaphore); 
    170170  DestroySemaphoreInfo(&configure_semaphore); 
    171171} 
    … …  
    255255    Search for configure tag. 
    256256  */ 
    257   LockSemaphoreInfo(configure_semaphore); 
     257  (void) LockSemaphoreInfo(configure_semaphore); 
    258258  ResetLinkedListIterator(configure_list); 
    259259  p=(const ConfigureInfo *) GetNextValueInLinkedList(configure_list); 
    … …  
    267267    (void) InsertValueInLinkedList(configure_list,0, 
    268268      RemoveElementByValueFromLinkedList(configure_list,p)); 
    269   UnlockSemaphoreInfo(configure_semaphore); 
     269  (void) UnlockSemaphoreInfo(configure_semaphore); 
    270270  return(p); 
    271271} 
    … …  
    351351    Generate configure list. 
    352352  */ 
    353   LockSemaphoreInfo(configure_semaphore); 
     353  (void) LockSemaphoreInfo(configure_semaphore); 
    354354  ResetLinkedListIterator(configure_list); 
    355355  p=(const ConfigureInfo *) GetNextValueInLinkedList(configure_list); 
    … …  
    361361    p=(const ConfigureInfo *) GetNextValueInLinkedList(configure_list); 
    362362  } 
    363   UnlockSemaphoreInfo(configure_semaphore); 
     363  (void) UnlockSemaphoreInfo(configure_semaphore); 
    364364  qsort((void *) options,(size_t) i,sizeof(*options),ConfigureInfoCompare); 
    365365  options[i]=(ConfigureInfo *) NULL; 
    … …  
    442442  if (options == (char **) NULL) 
    443443    return((char **) NULL); 
    444   LockSemaphoreInfo(configure_semaphore); 
     444  (void) LockSemaphoreInfo(configure_semaphore); 
    445445  ResetLinkedListIterator(configure_list); 
    446446  p=(const ConfigureInfo *) GetNextValueInLinkedList(configure_list); 
    … …  
    452452    p=(const ConfigureInfo *) GetNextValueInLinkedList(configure_list); 
    453453  } 
    454   UnlockSemaphoreInfo(configure_semaphore); 
     454  (void) UnlockSemaphoreInfo(configure_semaphore); 
    455455  qsort((void *) options,(size_t) i,sizeof(*options),ConfigureCompare); 
    456456  options[i]=(char *) NULL; 
    … …  
    871871      if (configure_semaphore == (SemaphoreInfo *) NULL) 
    872872        AcquireSemaphoreInfo(&configure_semaphore); 
    873       LockSemaphoreInfo(configure_semaphore); 
     873      (void) LockSemaphoreInfo(configure_semaphore); 
    874874      if ((configure_list == (LinkedListInfo *) NULL) && 
    875875          (instantiate_configure == MagickFalse)) 
    … …  
    878878          instantiate_configure=MagickTrue; 
    879879        } 
    880       UnlockSemaphoreInfo(configure_semaphore); 
     880      (void) UnlockSemaphoreInfo(configure_semaphore); 
    881881    } 
    882882  return(configure_list != (LinkedListInfo *) NULL ? MagickTrue : MagickFalse); 

  • ImageMagick/trunk/magick/constitute.c

    r455 r460  
    518518      thread_support=GetMagickThreadSupport(magick_info); 
    519519      if ((thread_support & DecoderThreadSupport) == 0) 
    520         LockSemaphoreInfo(constitute_semaphore); 
     520        (void) LockSemaphoreInfo(constitute_semaphore); 
    521521      image=GetImageDecoder(magick_info)(read_info,exception); 
    522522      if ((thread_support & DecoderThreadSupport) == 0) 
    523         UnlockSemaphoreInfo(constitute_semaphore); 
     523        (void) UnlockSemaphoreInfo(constitute_semaphore); 
    524524    } 
    525525  else 
    … …  
    550550      *read_info->filename='\0'; 
    551551      if (GetDelegateThreadSupport(delegate_info) == MagickFalse) 
    552         LockSemaphoreInfo(constitute_semaphore); 
     552        (void) LockSemaphoreInfo(constitute_semaphore); 
    553553      (void) InvokeDelegate(read_info,image,read_info->magick,(char *) NULL, 
    554554        exception); 
    555555      if (GetDelegateThreadSupport(delegate_info) == MagickFalse) 
    556         UnlockSemaphoreInfo(constitute_semaphore); 
     556        (void) UnlockSemaphoreInfo(constitute_semaphore); 
    557557      image=DestroyImageList(image); 
    558558      read_info->temporary=MagickTrue; 
    … …  
    574574      thread_support=GetMagickThreadSupport(magick_info); 
    575575      if ((thread_support & DecoderThreadSupport) == 0) 
    576         LockSemaphoreInfo(constitute_semaphore); 
     576        (void) LockSemaphoreInfo(constitute_semaphore); 
    577577      image=(Image *) (GetImageDecoder(magick_info))(read_info,exception); 
    578578      if ((thread_support & DecoderThreadSupport) == 0) 
    579         UnlockSemaphoreInfo(constitute_semaphore); 
     579        (void) UnlockSemaphoreInfo(constitute_semaphore); 
    580580    } 
    581581  if (read_info->temporary != MagickFalse) 
    … …  
    11051105      thread_support=GetMagickThreadSupport(magick_info); 
    11061106      if ((thread_support & EncoderThreadSupport) == 0) 
    1107         LockSemaphoreInfo(constitute_semaphore); 
     1107        (void) LockSemaphoreInfo(constitute_semaphore); 
    11081108      status=GetImageEncoder(magick_info)(write_info,image); 
    11091109      if ((thread_support & EncoderThreadSupport) == 0) 
    1110         UnlockSemaphoreInfo(constitute_semaphore); 
     1110        (void) UnlockSemaphoreInfo(constitute_semaphore); 
    11111111    } 
    11121112  else 
    … …  
    11211121          *write_info->filename='\0'; 
    11221122          if (GetDelegateThreadSupport(delegate_info) == MagickFalse) 
    1123             LockSemaphoreInfo(constitute_semaphore); 
     1123            (void) LockSemaphoreInfo(constitute_semaphore); 
    11241124          status=InvokeDelegate(write_info,image,(char *) NULL, 
    11251125            write_info->magick,&image->exception); 
    11261126          if (GetDelegateThreadSupport(delegate_info) == MagickFalse) 
    1127             UnlockSemaphoreInfo(constitute_semaphore); 
     1127            (void) UnlockSemaphoreInfo(constitute_semaphore); 
    11281128          (void) CopyMagickString(image->filename,filename,MaxTextExtent); 
    11291129        } 
    … …  
    11521152              thread_support=GetMagickThreadSupport(magick_info); 
    11531153              if ((thread_support & EncoderThreadSupport) == 0) 
    1154                 LockSemaphoreInfo(constitute_semaphore); 
     1154                (void) LockSemaphoreInfo(constitute_semaphore); 
    11551155              status=GetImageEncoder(magick_info)(write_info,image); 
    11561156              if ((thread_support & EncoderThreadSupport) == 0) 
    1157                 UnlockSemaphoreInfo(constitute_semaphore); 
     1157                (void) UnlockSemaphoreInfo(constitute_semaphore); 
    11581158            } 
    11591159        } 

  • ImageMagick/trunk/magick/delegate.c

    r455 r460  
    212212  if (delegate_semaphore == (SemaphoreInfo *) NULL) 
    213213    AcquireSemaphoreInfo(&delegate_semaphore); 
    214   LockSemaphoreInfo(delegate_semaphore); 
     214  (void) LockSemaphoreInfo(delegate_semaphore); 
    215215  if (delegate_list != (LinkedListInfo *) NULL) 
    216216    delegate_list=DestroyLinkedList(delegate_list,DestroyDelegate); 
    217217  instantiate_delegate=MagickFalse; 
    218   UnlockSemaphoreInfo(delegate_semaphore); 
     218  (void) UnlockSemaphoreInfo(delegate_semaphore); 
    219219  DestroySemaphoreInfo(&delegate_semaphore); 
    220220} 
    … …  
    382382    Search for named delegate. 
    383383  */ 
    384   LockSemaphoreInfo(delegate_semaphore); 
     384  (void) LockSemaphoreInfo(delegate_semaphore); 
    385385  ResetLinkedListIterator(delegate_list); 
    386386  p=(const DelegateInfo *) GetNextValueInLinkedList(delegate_list); 
    … …  
    415415    (void) InsertValueInLinkedList(delegate_list,0, 
    416416      RemoveElementByValueFromLinkedList(delegate_list,p)); 
    417   UnlockSemaphoreInfo(delegate_semaphore); 
     417  (void) UnlockSemaphoreInfo(delegate_semaphore); 
    418418  return(p); 
    419419} 
    … …  
    506506    Generate delegate list. 
    507507  */ 
    508   LockSemaphoreInfo(delegate_semaphore); 
     508  (void) LockSemaphoreInfo(delegate_semaphore); 
    509509  ResetLinkedListIterator(delegate_list); 
    510510  p=(const DelegateInfo *) GetNextValueInLinkedList(delegate_list); 
    … …  
    517517    p=(const DelegateInfo *) GetNextValueInLinkedList(delegate_list); 
    518518  } 
    519   UnlockSemaphoreInfo(delegate_semaphore); 
     519  (void) UnlockSemaphoreInfo(delegate_semaphore); 
    520520  qsort((void *) delegates,(size_t) i,sizeof(*delegates),DelegateInfoCompare); 
    521521  delegates[i]=(DelegateInfo *) NULL; 
    … …  
    599599  if (delegates == (char **) NULL) 
    600600    return((char **) NULL); 
    601   LockSemaphoreInfo(delegate_semaphore); 
     601  (void) LockSemaphoreInfo(delegate_semaphore); 
    602602  ResetLinkedListIterator(delegate_list); 
    603603  p=(const DelegateInfo *) GetNextValueInLinkedList(delegate_list); 
    … …  
    612612    p=(const DelegateInfo *) GetNextValueInLinkedList(delegate_list); 
    613613  } 
    614   UnlockSemaphoreInfo(delegate_semaphore); 
     614  (void) UnlockSemaphoreInfo(delegate_semaphore); 
    615615  qsort((void *) delegates,(size_t) i,sizeof(*delegates),DelegateCompare); 
    616616  delegates[i]=(char *) NULL; 
    … …  
    711711      if (delegate_semaphore == (SemaphoreInfo *) NULL) 
    712712        AcquireSemaphoreInfo(&delegate_semaphore); 
    713       LockSemaphoreInfo(delegate_semaphore); 
     713      (void) LockSemaphoreInfo(delegate_semaphore); 
    714714      if ((delegate_list == (LinkedListInfo *) NULL) && 
    715715          (instantiate_delegate == MagickFalse)) 
    … …  
    718718          instantiate_delegate=MagickTrue; 
    719719        } 
    720       UnlockSemaphoreInfo(delegate_semaphore); 
     720      (void) UnlockSemaphoreInfo(delegate_semaphore); 
    721721    } 
    722722  return(delegate_list != (LinkedListInfo *) NULL ? MagickTrue : MagickFalse); 

  • ImageMagick/trunk/magick/deprecate.c

    r453 r460  
    37593759{ 
    37603760  (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.7"); 
    3761   UnlockSemaphoreInfo(*semaphore_info); 
     3761  (void) UnlockSemaphoreInfo(*semaphore_info); 
    37623762} 
    37633763 

  • ImageMagick/trunk/magick/exception.c

    r453 r460  
    159159  if (exception->exceptions  == (void *) NULL) 
    160160    return; 
    161   LockSemaphoreInfo(exception->semaphore); 
     161  (void) LockSemaphoreInfo(exception->semaphore); 
    162162  p=(ExceptionInfo *) RemoveLastElementFromLinkedList((LinkedListInfo *) 
    163163    exception->exceptions); 
    … …  
    171171  exception->reason=(char *) NULL; 
    172172  exception->description=(char *) NULL; 
    173   UnlockSemaphoreInfo(exception->semaphore); 
     173  (void) UnlockSemaphoreInfo(exception->semaphore); 
    174174  errno=0; 
    175175} 
    … …  
    207207  if (exception->exceptions  == (void *) NULL) 
    208208    return; 
    209   LockSemaphoreInfo(exception->semaphore); 
     209  (void) LockSemaphoreInfo(exception->semaphore); 
    210210  ResetLinkedListIterator((LinkedListInfo *) exception->exceptions); 
    211211  p=(const ExceptionInfo *) GetNextValueInLinkedList((LinkedListInfo *) 
    … …  
    222222      exception->exceptions); 
    223223  } 
    224   UnlockSemaphoreInfo(exception->semaphore); 
     224  (void) UnlockSemaphoreInfo(exception->semaphore); 
    225225  ClearMagickException(exception); 
    226226} 
    … …  
    379379  assert(exception != (ExceptionInfo *) NULL); 
    380380  assert(exception->signature == MagickSignature); 
    381   LockSemaphoreInfo(exception->semaphore); 
     381  (void) LockSemaphoreInfo(exception->semaphore); 
    382382  exception->severity=UndefinedException; 
    383383  if (exception->exceptions != (void *) NULL) 
    … …  
    387387  if (exception->relinquish != MagickFalse) 
    388388    exception->signature=(~MagickSignature); 
    389   UnlockSemaphoreInfo(exception->semaphore); 
     389  (void) UnlockSemaphoreInfo(exception->semaphore); 
    390390  DestroySemaphoreInfo(&exception->semaphore); 
    391391  if (relinquish != MagickFalse) 
    … …  
    614614  if (relative->exceptions == (void *) NULL) 
    615615    return; 
    616   LockSemaphoreInfo(exception->semaphore); 
     616  (void) LockSemaphoreInfo(exception->semaphore); 
    617617  ResetLinkedListIterator((LinkedListInfo *) relative->exceptions); 
    618618  p=(const ExceptionInfo *) GetNextValueInLinkedList((LinkedListInfo *) 
    … …  
    624624      relative->exceptions); 
    625625  } 
    626   UnlockSemaphoreInfo(exception->semaphore); 
     626  (void) UnlockSemaphoreInfo(exception->semaphore); 
    627627} 
    628628 

  • ImageMagick/trunk/magick/image.c

    r453 r460  
    16281628  if (image->debug != MagickFalse) 
    16291629    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); 
    1630   LockSemaphoreInfo(image->semaphore); 
     1630  (void) LockSemaphoreInfo(image->semaphore); 
    16311631  reference_count=image->reference_count; 
    1632   UnlockSemaphoreInfo(image->semaphore); 
     1632  (void) UnlockSemaphoreInfo(image->semaphore); 
    16331633  return(reference_count); 
    16341634} 
    … …  
    20672067    return(MagickTrue); 
    20682068  clone_image=CloneImage(*image,0,0,MagickTrue,exception); 
    2069   LockSemaphoreInfo((*image)->semaphore); 
     2069  (void) LockSemaphoreInfo((*image)->semaphore); 
    20702070  (*image)->reference_count--; 
    2071   UnlockSemaphoreInfo((*image)->semaphore); 
     2071  (void) UnlockSemaphoreInfo((*image)->semaphore); 
    20722072  *image=clone_image; 
    20732073  return(MagickTrue); 

  • ImageMagick/trunk/magick/locale.c

    r455 r460  
    255255    Generate locale list. 
    256256  */ 
    257   LockSemaphoreInfo(locale_semaphore); 
     257  (void) LockSemaphoreInfo(locale_semaphore); 
    258258  ResetSplayTreeIterator(locale_list); 
    259259  p=(const LocaleInfo *) GetNextValueInSplayTree(locale_list); 
    … …  
    265265    p=(const LocaleInfo *) GetNextValueInSplayTree(locale_list); 
    266266  } 
    267   UnlockSemaphoreInfo(locale_semaphore); 
     267  (void) UnlockSemaphoreInfo(locale_semaphore); 
    268268  qsort((void *) messages,(size_t) i,sizeof(*messages),LocaleInfoCompare); 
    269269  messages[i]=(LocaleInfo *) NULL; 
    … …  
    347347  if (messages == (char **) NULL) 
    348348    return((char **) NULL); 
    349   LockSemaphoreInfo(locale_semaphore); 
     349  (void) LockSemaphoreInfo(locale_semaphore); 
    350350  p=(const LocaleInfo *) GetNextValueInSplayTree(locale_list); 
    351351  for (i=0; p != (const LocaleInfo *) NULL; ) 
    … …  
    356356    p=(const LocaleInfo *) GetNextValueInSplayTree(locale_list); 
    357357  } 
    358   UnlockSemaphoreInfo(locale_semaphore); 
     358  (void) UnlockSemaphoreInfo(locale_semaphore); 
    359359  qsort((void *) messages,(size_t) i,sizeof(*messages),LocaleTagCompare); 
    360360  messages[i]=(char *) NULL; 
    … …  
    552552      if (locale_semaphore == (SemaphoreInfo *) NULL) 
    553553        AcquireSemaphoreInfo(&locale_semaphore); 
    554       LockSemaphoreInfo(locale_semaphore); 
     554      (void) LockSemaphoreInfo(locale_semaphore); 
    555555      if ((locale_list == (SplayTreeInfo *) NULL) && 
    556556          (instantiate_locale == MagickFalse)) 
    … …  
    580580          instantiate_locale=MagickTrue; 
    581581        } 
    582       UnlockSemaphoreInfo(locale_semaphore); 
     582      (void) UnlockSemaphoreInfo(locale_semaphore); 
    583583    } 
    584584  return(locale_list != (SplayTreeInfo *) NULL ? MagickTrue : MagickFalse); 
    … …  
    10761076  if (locale_semaphore == (SemaphoreInfo *) NULL) 
    10771077    AcquireSemaphoreInfo(&locale_semaphore); 
    1078   LockSemaphoreInfo(locale_semaphore); 
     1078  (void) LockSemaphoreInfo(locale_semaphore); 
    10791079  if (locale_list != (SplayTreeInfo *) NULL) 
    10801080    locale_list=DestroySplayTree(locale_list); 
    10811081  instantiate_locale=MagickFalse; 
    1082   UnlockSemaphoreInfo(locale_semaphore); 
     1082  (void) UnlockSemaphoreInfo(locale_semaphore); 
    10831083  DestroySemaphoreInfo(&locale_semaphore); 
    10841084} 

  • ImageMagick/trunk/magick/log.c

    r455 r460  
    226226  log_info=GetLogInfo("*",exception); 
    227227  exception=DestroyExceptionInfo(exception); 
    228   LockSemaphoreInfo(log_semaphore); 
     228  (void) LockSemaphoreInfo(log_semaphore); 
    229229  if (log_info->file != (FILE *) NULL) 
    230230    { 
    … …  
    234234      log_info->file=(FILE *) NULL; 
    235235    } 
    236   UnlockSemaphoreInfo(log_semaphore); 
     236  (void) UnlockSemaphoreInfo(log_semaphore); 
    237237} 
    238238 
    … …  
    279279    Search for log tag. 
    280280  */ 
    281   LockSemaphoreInfo(log_semaphore); 
     281  (void) LockSemaphoreInfo(log_semaphore); 
    282282  ResetLinkedListIterator(log_list); 
    283283  p=(LogInfo *) GetNextValueInLinkedList(log_list); 
    … …  
    291291    (void) InsertValueInLinkedList(log_list,0, 
    292292      RemoveElementByValueFromLinkedList(log_list,p)); 
    293   UnlockSemaphoreInfo(log_semaphore); 
     293  (void) UnlockSemaphoreInfo(log_semaphore); 
    294294  return(p); 
    295295} 
    … …  
    372372    Generate log list. 
    373373  */ 
    374   LockSemaphoreInfo(log_semaphore); 
     374  (void) LockSemaphoreInfo(log_semaphore); 
    375375  ResetLinkedListIterator(log_list); 
    376376  p=(const LogInfo *) GetNextValueInLinkedList(log_list); 
    … …  
    382382    p=(const LogInfo *) GetNextValueInLinkedList(log_list); 
    383383  } 
    384   UnlockSemaphoreInfo(log_semaphore); 
     384  (void) UnlockSemaphoreInfo(log_semaphore); 
    385385  qsort((void *) preferences,(size_t) i,sizeof(*preferences),LogInfoCompare); 
    386386  preferences[i]=(LogInfo *) NULL; 
    … …  
    465465    Generate log list. 
    466466  */ 
    467   LockSemaphoreInfo(log_semaphore); 
     467  (void) LockSemaphoreInfo(log_semaphore); 
    468468  ResetLinkedListIterator(log_list); 
    469469  p=(const LogInfo *) GetNextValueInLinkedList(log_list); 
    … …  
    475475    p=(const LogInfo *) GetNextValueInLinkedList(log_list); 
    476476  } 
    477   UnlockSemaphoreInfo(log_semaphore); 
     477  (void) UnlockSemaphoreInfo(log_semaphore); 
    478478  qsort((void *) preferences,(size_t) i,sizeof(*preferences),LogCompare); 
    479479  preferences[i]=(char *) NULL; 
    … …  
    533533      if (log_semaphore == (SemaphoreInfo *) NULL) 
    534534        AcquireSemaphoreInfo(&log_semaphore); 
    535       LockSemaphoreInfo(log_semaphore); 
     535      (void) LockSemaphoreInfo(log_semaphore); 
    536536      if ((log_list == (LinkedListInfo *) NULL) && 
    537537          (instantiate_log == MagickFalse)) 
    … …  
    540540          instantiate_log=MagickTrue; 
    541541        } 
    542       UnlockSemaphoreInfo(log_semaphore); 
     542      (void) UnlockSemaphoreInfo(log_semaphore); 
    543543    } 
    544544  return(log_list != (LinkedListInfo *) NULL ? MagickTrue : MagickFalse); 
    … …  
    739739  if (log_semaphore == (SemaphoreInfo *) NULL) 
    740740    AcquireSemaphoreInfo(&log_semaphore); 
    741   LockSemaphoreInfo(log_semaphore); 
     741  (void) LockSemaphoreInfo(log_semaphore); 
    742742  if (log_list != (LinkedListInfo *) NULL) 
    743743    log_list=DestroyLinkedList(log_list,DestroyLogElement); 
    744744  instantiate_log=MagickFalse; 
    745   UnlockSemaphoreInfo(log_semaphore); 
     745  (void) UnlockSemaphoreInfo(log_semaphore); 
    746746  DestroySemaphoreInfo(&log_semaphore); 
    747747} 
    … …  
    11281128  log_info=(LogInfo *) GetLogInfo("*",exception); 
    11291129  exception=DestroyExceptionInfo(exception); 
    1130   LockSemaphoreInfo(log_semaphore); 
     1130  (void) LockSemaphoreInfo(log_semaphore); 
    11311131  if ((log_info->event_mask & type) == 0) 
    11321132    { 
    1133       UnlockSemaphoreInfo(log_semaphore); 
     1133      (void) UnlockSemaphoreInfo(log_semaphore); 
    11341134      return(MagickTrue); 
    11351135    } 
    … …  
    11461146    { 
    11471147      (void) ContinueTimer((TimerInfo *) &log_info->timer); 
    1148       UnlockSemaphoreInfo(log_semaphore); 
     1148      (void) UnlockSemaphoreInfo(log_semaphore); 
    11491149      return(MagickFalse); 
    11501150    } 
    … …  
    11891189            { 
    11901190              (void) ContinueTimer((TimerInfo *) &log_info->timer); 
    1191               UnlockSemaphoreInfo(log_semaphore); 
     1191              (void) UnlockSemaphoreInfo(log_semaphore); 
    11921192              return(MagickFalse); 
    11931193            } 
    … …  
    11971197          if (log_info->file == (FILE *) NULL) 
    11981198            { 
    1199               UnlockSemaphoreInfo(log_semaphore); 
     1199              (void) UnlockSemaphoreInfo(log_semaphore); 
    12001200              return(MagickFalse); 
    12011201            } 
    … …  
    12231223  text=(char  *) RelinquishMagickMemory(text); 
    12241224  (void) ContinueTimer((TimerInfo *) &log_info->timer); 
    1225   UnlockSemaphoreInfo(log_semaphore); 
     1225  (void) UnlockSemaphoreInfo(log_semaphore); 
    12261226  return(MagickTrue); 
    12271227} 
    … …  
    16861686  exception=DestroyExceptionInfo(exception); 
    16871687  option=ParseMagickOption(MagickLogEventOptions,MagickTrue,events); 
    1688   LockSemaphoreInfo(log_semaphore); 
     1688  (void) LockSemaphoreInfo(log_semaphore); 
    16891689  log_info=(LogInfo *) GetValueFromLinkedList(log_list,0); 
    16901690  log_info->event_mask=(LogEventType) option; 
    16911691  if (option == -1) 
    16921692    log_info->event_mask=UndefinedEvents; 
    1693   UnlockSemaphoreInfo(log_semaphore); 
     1693  (void) UnlockSemaphoreInfo(log_semaphore); 
    16941694  return(log_info->event_mask); 
    16951695} 
    … …  
    17281728  log_info=(LogInfo *) GetLogInfo("*",exception); 
    17291729  exception=DestroyExceptionInfo(exception); 
    1730   LockSemaphoreInfo(log_semaphore); 
     1730  (void) LockSemaphoreInfo(log_semaphore); 
    17311731  if (log_info->format != (char *) NULL) 
    17321732    log_info->format=DestroyString(log_info->format); 
    17331733  log_info->format=ConstantString(format); 
    1734   UnlockSemaphoreInfo(log_semaphore); 
     1734  (void) UnlockSemaphoreInfo(log_semaphore); 
    17351735} 
    17361736 

  • ImageMagick/trunk/magick/magic.c

    r455 r460  
    260260    Search for magic tag. 
    261261  */ 
    262   LockSemaphoreInfo(magic_semaphore); 
     262  (void) LockSemaphoreInfo(magic_semaphore); 
    263263  ResetLinkedListIterator(magic_list); 
    264264  p=(const MagicInfo *) GetNextValueInLinkedList(magic_list); 
    … …  
    274274    (void) InsertValueInLinkedList(magic_list,0, 
    275275      RemoveElementByValueFromLinkedList(magic_list,p)); 
    276   UnlockSemaphoreInfo(magic_semaphore); 
     276  (void) UnlockSemaphoreInfo(magic_semaphore); 
    277277  return(p); 
    278278} 
    … …  
    357357    Generate magic list. 
    358358  */ 
    359   LockSemaphoreInfo(magic_semaphore); 
     359  (void) LockSemaphoreInfo(magic_semaphore); 
    360360  ResetLinkedListIterator(magic_list); 
    361361  p=(const MagicInfo *) GetNextValueInLinkedList(magic_list); 
    … …  
    367367    p=(const MagicInfo *) GetNextValueInLinkedList(magic_list); 
    368368  } 
    369   UnlockSemaphoreInfo(magic_semaphore); 
     369  (void) UnlockSemaphoreInfo(magic_semaphore); 
    370370  qsort((void *) aliases,(size_t) i,sizeof(*aliases),MagicInfoCompare); 
    371371  aliases[i]=(MagicInfo *) NULL; 
    … …  
    449449  if (aliases == (char **) NULL) 
    450450    return((char **) NULL); 
    451   LockSemaphoreInfo(magic_semaphore); 
     451  (void) LockSemaphoreInfo(magic_semaphore); 
    452452  ResetLinkedListIterator(magic_list); 
    453453  p=(const MagicInfo *) GetNextValueInLinkedList(magic_list); 
    … …  
    459459    p=(const MagicInfo *) GetNextValueInLinkedList(magic_list); 
    460460  } 
    461   UnlockSemaphoreInfo(magic_semaphore); 
     461  (void) UnlockSemaphoreInfo(magic_semaphore); 
    462462  qsort((void *) aliases,(size_t) i,sizeof(*aliases),MagicCompare); 
    463463  aliases[i]=(char *) NULL; 
    … …  
    525525      if (magic_semaphore == (SemaphoreInfo *) NULL) 
    526526        AcquireSemaphoreInfo(&magic_semaphore); 
    527       LockSemaphoreInfo(magic_semaphore); 
     527      (void) LockSemaphoreInfo(magic_semaphore); 
    528528      if ((magic_list == (LinkedListInfo *) NULL) && 
    529529          (instantiate_magic == MagickFalse)) 
    … …  
    532532          instantiate_magic=MagickTrue; 
    533533        } 
    534       UnlockSemaphoreInfo(magic_semaphore); 
     534      (void) UnlockSemaphoreInfo(magic_semaphore); 
    535535    } 
    536536  return(magic_list != (LinkedListInfo *) NULL ? MagickTrue : MagickFalse); 
    … …  
    10621062  if (magic_semaphore == (SemaphoreInfo *) NULL) 
    10631063    AcquireSemaphoreInfo(&magic_semaphore); 
    1064   LockSemaphoreInfo(magic_semaphore); 
     1064  (void) LockSemaphoreInfo(magic_semaphore); 
    10651065  if (magic_list != (LinkedListInfo *) NULL) 
    10661066    magic_list=DestroyLinkedList(magic_list,DestroyMagicElement); 
    10671067  instantiate_magic=MagickFalse; 
    1068   UnlockSemaphoreInfo(magic_semaphore); 
     1068  (void) UnlockSemaphoreInfo(magic_semaphore); 
    10691069  DestroySemaphoreInfo(&magic_semaphore); 
    10701070} 

  • ImageMagick/trunk/magick/magick.c

    r455 r460  
    229229    return(MagickFalse); 
    230230  status=MagickFalse; 
    231   LockSemaphoreInfo(magick_semaphore); 
     231  (void) LockSemaphoreInfo(magick_semaphore); 
    232232  ResetSplayTreeIterator(magick_list); 
    233233  p=(const MagickInfo *) GetNextValueInSplayTree(magick_list); 
    … …  
    243243    p=(const MagickInfo *) GetNextValueInSplayTree(magick_list); 
    244244  } 
    245   UnlockSemaphoreInfo(magick_semaphore); 
     245  (void) UnlockSemaphoreInfo(magick_semaphore); 
    246246  return(status); 
    247247} 
    … …  
    413413        (void) OpenModules(exception); 
    414414#endif 
    415       LockSemaphoreInfo(magick_semaphore); 
     415      (void) LockSemaphoreInfo(magick_semaphore); 
    416416      ResetSplayTreeIterator(magick_list); 
    417417      p=(const MagickInfo *) GetNextValueInSplayTree(magick_list); 
    418       UnlockSemaphoreInfo(magick_semaphore); 
     418      (void) UnlockSemaphoreInfo(magick_semaphore); 
    419419      return(p); 
    420420    } 
    … …  
    422422    Find name in list. 
    423423  */ 
    424   LockSemaphoreInfo(magick_semaphore); 
     424  (void) LockSemaphoreInfo(magick_semaphore); 
    425425  ResetSplayTreeIterator(magick_list); 
    426426  p=(const MagickInfo *) GetNextValueInSplayTree(magick_list); 
    … …  
    446446    } 
    447447#endif 
    448   UnlockSemaphoreInfo(magick_semaphore); 
     448  (void) UnlockSemaphoreInfo(magick_semaphore); 
    449449  return(p); 
    450450} 
    … …  
    527527    Generate magick list. 
    528528  */ 
    529   LockSemaphoreInfo(magick_semaphore); 
     529  (void) LockSemaphoreInfo(magick_semaphore); 
    530530  ResetSplayTreeIterator(magick_list); 
    531531  p=(const MagickInfo *) GetNextValueInSplayTree(magick_list); 
    … …  
    537537    p=(const MagickInfo *) GetNextValueInSplayTree(magick_list); 
    538538  } 
    539   UnlockSemaphoreInfo(magick_semaphore); 
     539  (void) UnlockSemaphoreInfo(magick_semaphore); 
    540540  qsort((void *) formats,(size_t) i,sizeof(*formats),MagickInfoCompare); 
    541541  formats[i]=(MagickInfo *) NULL; 
    … …  
    617617  if (formats == (char **) NULL) 
    618618    return((char **) NULL); 
    619   LockSemaphoreInfo(magick_semaphore); 
     619  (void) LockSemaphoreInfo(magick_semaphore); 
    620620  ResetSplayTreeIterator(magick_list); 
    621621  p=(const MagickInfo *) GetNextValueInSplayTree(magick_list); 
    … …  
    627627    p=(const MagickInfo *) GetNextValueInSplayTree(magick_list); 
    628628  } 
    629   UnlockSemaphoreInfo(magick_semaphore); 
     629  (void) UnlockSemaphoreInfo(magick_semaphore); 
    630630  qsort((void *) formats,(size_t) i,sizeof(*formats),MagickCompare); 
    631631  formats[i]=(char *) NULL; 
    … …  
    778778      if (magick_semaphore == (SemaphoreInfo *) NULL) 
    779779        AcquireSemaphoreInfo(&magick_semaphore); 
    780       LockSemaphoreInfo(magick_semaphore); 
     780      (void) LockSemaphoreInfo(magick_semaphore); 
    781781      if ((magick_list == (SplayTreeInfo *) NULL) && 
    782782          (instantiate_magick == MagickFalse)) 
    … …  
    820820          instantiate_magick=MagickTrue; 
    821821        } 
    822       UnlockSemaphoreInfo(magick_semaphore); 
     822      (void) UnlockSemaphoreInfo(magick_semaphore); 
    823823    } 
    824824  return(magick_list != (SplayTreeInfo *) NULL ? MagickTrue : MagickFalse); 
    … …  
    10591059  if (magick_semaphore == (SemaphoreInfo *) NULL) 
    10601060    AcquireSemaphoreInfo(&magick_semaphore); 
    1061   LockSemaphoreInfo(magick_semaphore); 
     1061  (void) LockSemaphoreInfo(magick_semaphore); 
    10621062  if (magick_list != (SplayTreeInfo *) NULL) 
    10631063    magick_list=DestroySplayTree(magick_list); 
    10641064  instantiate_magick=MagickFalse; 
    1065   UnlockSemaphoreInfo(magick_semaphore); 
     1065  (void) UnlockSemaphoreInfo(magick_semaphore); 
    10661066  DestroySemaphoreInfo(&magick_semaphore); 
    10671067} 
    … …  
    14661466  if (GetNumberOfNodesInSplayTree(magick_list) == 0) 
    14671467    return(MagickFalse); 
    1468   LockSemaphoreInfo(magick_semaphore); 
     1468  (void) LockSemaphoreInfo(magick_semaphore); 
    14691469  ResetSplayTreeIterator(magick_list); 
    14701470  p=(const MagickInfo *) GetNextValueInSplayTree(magick_list); 
    … …  
    14761476  } 
    14771477  status=DeleteNodeByValueFromSplayTree(magick_list,p); 
    1478   UnlockSemaphoreInfo(magick_semaphore); 
     1478  (void) UnlockSemaphoreInfo(magick_semaphore); 
    14791479  return(status); 
    14801480} 

  • ImageMagick/trunk/magick/memory.c

    r453 r460  
    392392  if (free_segments == (DataSegmentInfo *) NULL) 
    393393    { 
    394       LockSemaphoreInfo(memory_semaphore); 
     394      (void) LockSemaphoreInfo(memory_semaphore); 
    395395      if (free_segments == (DataSegmentInfo *) NULL) 
    396396        { 
    … …  
    412412          free_segments=(&memory_info.segment_pool[0]); 
    413413        } 
    414       UnlockSemaphoreInfo(memory_semaphore); 
    415     } 
    416   LockSemaphoreInfo(memory_semaphore); 
     414      (void) UnlockSemaphoreInfo(memory_semaphore); 
     415    } 
     416  (void) LockSemaphoreInfo(memory_semaphore); 
    417417  memory=AcquireBlock(size == 0 ? 1UL : size); 
    418418  if (memory == (void *) NULL) 
    … …  
    421421        memory=AcquireBlock(size == 0 ? 1UL : size); 
    422422    } 
    423   UnlockSemaphoreInfo(memory_semaphore); 
     423  (void) UnlockSemaphoreInfo(memory_semaphore); 
    424424#endif 
    425425  return(memory); 
    … …  
    547547    i; 
    548548 
    549   LockSemaphoreInfo(memory_semaphore); 
    550   UnlockSemaphoreInfo(memory_semaphore); 
     549  (void) LockSemaphoreInfo(memory_semaphore); 
     550  (void) UnlockSemaphoreInfo(memory_semaphore); 
    551551  for (i=0; i < (long) memory_info.number_segments; i++) 
    552552    if (memory_info.segments[i]->mapped == MagickFalse) 
    … …  
    743743  assert((SizeOfBlock(memory) % (4*sizeof(size_t))) == 0); 
    744744  assert((*BlockHeader(NextBlock(memory)) & PreviousBlockBit) != 0); 
    745   LockSemaphoreInfo(memory_semaphore); 
     745  (void) LockSemaphoreInfo(memory_semaphore); 
    746746  if ((*BlockHeader(memory) & PreviousBlockBit) == 0) 
    747747    { 
    … …  
    774774  *BlockHeader(NextBlock(memory))&=(~PreviousBlockBit); 
    775775  InsertFreeBlock(memory,AllocationPolicy(SizeOfBlock(memory))); 
    776   UnlockSemaphoreInfo(memory_semaphore); 
     776  (void) UnlockSemaphoreInfo(memory_semaphore); 
    777777#endif 
    778778  return((void *) NULL); 
    … …  
    871871    memory=RelinquishMagickMemory(memory); 
    872872#else 
    873   LockSemaphoreInfo(memory_semaphore); 
     873  (void) LockSemaphoreInfo(memory_semaphore); 
    874874  block=ResizeBlock(memory,size == 0 ? 1UL : size); 
    875875  if (block == (void *) NULL) 
    … …  
    877877      if (ExpandHeap(size == 0 ? 1UL : size) == MagickFalse) 
    878878        { 
    879           UnlockSemaphoreInfo(memory_semaphore); 
     879          (void) UnlockSemaphoreInfo(memory_semaphore); 
    880880          memory=RelinquishMagickMemory(memory); 
    881881          ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed"); 
    … …  
    884884      assert(block != (void *) NULL); 
    885885    } 
    886   UnlockSemaphoreInfo(memory_semaphore); 
     886  (void) UnlockSemaphoreInfo(memory_semaphore); 
    887887  memory=RelinquishMagickMemory(memory); 
    888888#endif 

  • ImageMagick/trunk/magick/mime.c

    r455 r460  
    201201  mime_info=(const MimeInfo *) NULL; 
    202202  lsb_first=1; 
    203   LockSemaphoreInfo(mime_semaphore); 
     203  (void) LockSemaphoreInfo(mime_semaphore); 
    204204  ResetLinkedListIterator(mime_list); 
    205205  p=(const MimeInfo *) GetNextValueInLinkedList(mime_list); 
    … …  
    325325    (void) InsertValueInLinkedList(mime_list,0, 
    326326      RemoveElementByValueFromLinkedList(mime_list,p)); 
    327   UnlockSemaphoreInfo(mime_semaphore); 
     327  (void) UnlockSemaphoreInfo(mime_semaphore); 
    328328  return(mime_info); 
    329329} 
    … …  
    409409    Generate mime list. 
    410410  */ 
    411   LockSemaphoreInfo(mime_semaphore); 
     411  (void) LockSemaphoreInfo(mime_semaphore); 
    412412  ResetLinkedListIterator(mime_list); 
    413413  p=(const MimeInfo *) GetNextValueInLinkedList(mime_list); 
    … …  
    419419    p=(const MimeInfo *) GetNextValueInLinkedList(mime_list); 
    420420  } 
    421   UnlockSemaphoreInfo(mime_semaphore); 
     421  (void) UnlockSemaphoreInfo(mime_semaphore); 
    422422  qsort((void *) aliases,(size_t) i,sizeof(*aliases),MimeInfoCompare); 
    423423  aliases[i]=(MimeInfo *) NULL; 
    … …  
    501501  if (aliases == (char **) NULL) 
    502502    return((char **) NULL); 
    503   LockSemaphoreInfo(mime_semaphore); 
     503  (void) LockSemaphoreInfo(mime_semaphore); 
    504504  ResetLinkedListIterator(mime_list); 
    505505  p=(const MimeInfo *) GetNextValueInLinkedList(mime_list); 
    … …  
    511511    p=(const MimeInfo *) GetNextValueInLinkedList(mime_list); 
    512512  } 
    513   UnlockSemaphoreInfo(mime_semaphore); 
     513  (void) UnlockSemaphoreInfo(mime_semaphore); 
    514514  qsort((void *) aliases,(size_t) i,sizeof(*aliases),MimeCompare); 
    515515  aliases[i]=(char *) NULL; 
    … …  
    607607      if (mime_semaphore == (SemaphoreInfo *) NULL) 
    608608        AcquireSemaphoreInfo(&mime_semaphore); 
    609       LockSemaphoreInfo(mime_semaphore); 
     609      (void) LockSemaphoreInfo(mime_semaphore); 
    610610      if ((mime_list == (LinkedListInfo *) NULL) && 
    611611          (instantiate_mime == MagickFalse)) 
    … …  
    614614          instantiate_mime=MagickTrue; 
    615615        } 
    616       UnlockSemaphoreInfo(mime_semaphore); 
     616      (void) UnlockSemaphoreInfo(mime_semaphore); 
    617617    } 
    618618  return(mime_list != (LinkedListInfo *) NULL ? MagickTrue : MagickFalse); 
    … …  
    11011101  if (mime_semaphore == (SemaphoreInfo *) NULL) 
    11021102    AcquireSemaphoreInfo(&mime_semaphore); 
    1103   LockSemaphoreInfo(mime_semaphore); 
     1103  (void) LockSemaphoreInfo(mime_semaphore); 
    11041104  if (mime_list != (LinkedListInfo *) NULL) 
    11051105    mime_list=DestroyLinkedList(mime_list,DestroyMimeElement); 
    11061106  instantiate_mime=MagickFalse; 
    1107   UnlockSemaphoreInfo(mime_semaphore); 
     1107  (void) UnlockSemaphoreInfo(mime_semaphore); 
    11081108  DestroySemaphoreInfo(&mime_semaphore); 
    11091109} 

  • ImageMagick/trunk/magick/module.c

    r455 r460  
    176176    Destroy magick modules. 
    177177  */ 
    178   LockSemaphoreInfo(module_semaphore); 
     178  (void) LockSemaphoreInfo(module_semaphore); 
    179179#if defined(MAGICKCORE_MODULES_SUPPORT) 
    180180  if (module_list != (SplayTreeInfo *) NULL) 
    … …  
    184184#endif 
    185185  instantiate_module=MagickFalse; 
    186   UnlockSemaphoreInfo(module_semaphore); 
     186  (void) UnlockSemaphoreInfo(module_semaphore); 
    187187} 
    188188 
    … …  
    233233        (void) OpenModules(exception); 
    234234#endif 
    235       LockSemaphoreInfo(module_semaphore); 
     235      (void) LockSemaphoreInfo(module_semaphore); 
    236236      ResetSplayTreeIterator(module_list); 
    237237      p=(ModuleInfo *) GetNextValueInSplayTree(module_list); 
    238       UnlockSemaphoreInfo(module_semaphore); 
     238      (void) UnlockSemaphoreInfo(module_semaphore); 
    239239      return(p); 
    240240    } 
    … …  
    320320    Generate module list. 
    321321  */ 
    322   LockSemaphoreInfo(module_semaphore); 
     322  (void) LockSemaphoreInfo(module_semaphore); 
    323323  ResetSplayTreeIterator(module_list); 
    324324  p=(const ModuleInfo *) GetNextValueInSplayTree(module_list); 
    … …  
    330330    p=(const ModuleInfo *) GetNextValueInSplayTree(module_list); 
    331331  } 
    332   UnlockSemaphoreInfo(module_semaphore); 
     332  (void) UnlockSemaphoreInfo(module_semaphore); 
    333333  qsort((void *) modules,(size_t) i,sizeof(*modules),ModuleInfoCompare); 
    334334  modules[i]=(ModuleInfo *) NULL; 
    … …  
    850850      if (module_semaphore == (SemaphoreInfo *) NULL) 
    851851        AcquireSemaphoreInfo(&module_semaphore); 
    852       LockSemaphoreInfo(module_semaphore); 
     852      (void) LockSemaphoreInfo(module_semaphore); 
    853853      if ((module_list == (SplayTreeInfo *) NULL) && 
    854854          (instantiate_module == MagickFalse)) 
    … …  
    876876          instantiate_module=MagickTrue; 
    877877        } 
    878       UnlockSemaphoreInfo(module_semaphore); 
     878      (void) UnlockSemaphoreInfo(module_semaphore); 
    879879    } 
    880880  return(module_list != (SplayTreeInfo *) NULL ? MagickTrue : MagickFalse); 

  • ImageMagick/trunk/magick/policy.c

    r455 r460  
    193193    Search for policy tag. 
    194194  */ 
    195   LockSemaphoreInfo(policy_semaphore); 
     195  (void) LockSemaphoreInfo(policy_semaphore); 
    196196  ResetLinkedListIterator(policy_list); 
    197197  p=(PolicyInfo *) GetNextValueInLinkedList(policy_list); 
    … …  
    208208    (void) InsertValueInLinkedList(policy_list,0, 
    209209      RemoveElementByValueFromLinkedList(policy_list,p)); 
    210   UnlockSemaphoreInfo(policy_semaphore); 
     210  (void) UnlockSemaphoreInfo(policy_semaphore); 
    211211  return(p); 
    212212} 
    … …  
    268268    Generate policy list. 
    269269  */ 
    270   LockSemaphoreInfo(policy_semaphore); 
     270  (void) LockSemaphoreInfo(policy_semaphore); 
    271271  ResetLinkedListIterator(policy_list); 
    272272  p=(const PolicyInfo *) GetNextValueInLinkedList(policy_list); 
    … …  
    278278    p=(const PolicyInfo *) GetNextValueInLinkedList(policy_list); 
    279279  } 
    280   UnlockSemaphoreInfo(policy_semaphore); 
     280  (void) UnlockSemaphoreInfo(policy_semaphore); 
    281281  policies[i]=(PolicyInfo *) NULL; 
    282282  *number_policies=(unsigned long) i; 
    … …  
    340340    Generate policy list. 
    341341  */ 
    342   LockSemaphoreInfo(policy_semaphore); 
     342  (void) LockSemaphoreInfo(policy_semaphore); 
    343343  ResetLinkedListIterator(policy_list); 
    344344  p=(const PolicyInfo *) GetNextValueInLinkedList(policy_list); 
    … …  
    350350    p=(const PolicyInfo *) GetNextValueInLinkedList(policy_list); 
    351351  } 
    352   UnlockSemaphoreInfo(policy_semaphore); 
     352  (void) UnlockSemaphoreInfo(policy_semaphore); 
    353353  policies[i]=(char *) NULL; 
    354354  *number_policies=(unsigned long) i; 
    … …  
    431431      if (policy_semaphore == (SemaphoreInfo *) NULL) 
    432432        AcquireSemaphoreInfo(&policy_semaphore); 
    433       LockSemaphoreInfo(policy_semaphore); 
     433      (void) LockSemaphoreInfo(policy_semaphore); 
    434434      if ((policy_list == (LinkedListInfo *) NULL) && 
    435435          (instantiate_policy == MagickFalse)) 
    … …  
    438438          instantiate_policy=MagickTrue; 
    439439        } 
    440       UnlockSemaphoreInfo(policy_semaphore); 
     440      (void) UnlockSemaphoreInfo(policy_semaphore); 
    441441    } 
    442442  return(policy_list != (LinkedListInfo *) NULL ? MagickTrue : MagickFalse); 
    … …  
    496496    return(MagickTrue); 
    497497  authorized=MagickTrue; 
    498   LockSemaphoreInfo(policy_semaphore); 
     498  (void) LockSemaphoreInfo(policy_semaphore); 
    499499  ResetLinkedListIterator(policy_list); 
    500500  p=(PolicyInfo *) GetNextValueInLinkedList(policy_list); 
    … …  
    516516    p=(PolicyInfo *) GetNextValueInLinkedList(policy_list); 
    517517  } 
    518   UnlockSemaphoreInfo(policy_semaphore); 
     518  (void) UnlockSemaphoreInfo(policy_semaphore); 
    519519  return(authorized); 
    520520} 
    … …  
    10161016  if (policy_semaphore == (SemaphoreInfo *) NULL) 
    10171017    AcquireSemaphoreInfo(&policy_semaphore); 
    1018   LockSemaphoreInfo(policy_semaphore); 
     1018  (void) LockSemaphoreInfo(policy_semaphore); 
    10191019  if (policy_list != (LinkedListInfo *) NULL) 
    10201020    policy_list=DestroyLinkedList(policy_list,DestroyPolicyElement); 
    10211021  instantiate_policy=MagickFalse; 
    1022   UnlockSemaphoreInfo(policy_semaphore); 
     1022  (void) UnlockSemaphoreInfo(policy_semaphore); 
    10231023  DestroySemaphoreInfo(&policy_semaphore); 
    10241024} 

  • ImageMagick/trunk/magick/registry.c

    r455 r460  
    327327  if (registry_semaphore == (SemaphoreInfo *) NULL) 
    328328    AcquireSemaphoreInfo(&registry_semaphore); 
    329   LockSemaphoreInfo(registry_semaphore); 
     329  (void) LockSemaphoreInfo(registry_semaphore); 
    330330  if (IsEventLogging() != MagickFalse) 
    331331    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"..."); 
    … …  
    333333    registry=DestroySplayTree(registry); 
    334334  instantiate_registry=MagickFalse; 
    335   UnlockSemaphoreInfo(registry_semaphore); 
     335  (void) UnlockSemaphoreInfo(registry_semaphore); 
    336336  DestroySemaphoreInfo(&registry_semaphore); 
    337337} 
    … …  
    528528      if (registry_semaphore == (SemaphoreInfo *) NULL) 
    529529        AcquireSemaphoreInfo(&registry_semaphore); 
    530       LockSemaphoreInfo(registry_semaphore); 
     530      (void) LockSemaphoreInfo(registry_semaphore); 
    531531      if ((registry == (SplayTreeInfo *) NULL) && 
    532532          (instantiate_registry == MagickFalse)) 
    … …  
    536536          instantiate_registry=MagickTrue; 
    537537        } 
    538       UnlockSemaphoreInfo(registry_semaphore); 
     538      (void) UnlockSemaphoreInfo(registry_semaphore); 
    539539    } 
    540540  status=AddValueToSplayTree(registry,ConstantString(key),registry_info); 

  • ImageMagick/trunk/magick/resource.c

    r453 r460  
    162162  if (resource_semaphore == (SemaphoreInfo *) NULL) 
    163163    AcquireSemaphoreInfo(&resource_semaphore); 
    164   LockSemaphoreInfo(resource_semaphore); 
     164  (void) LockSemaphoreInfo(resource_semaphore); 
    165165  switch (type) 
    166166  { 
    … …  
    256256      break; 
    257257  } 
    258   UnlockSemaphoreInfo(resource_semaphore); 
     258  (void) UnlockSemaphoreInfo(resource_semaphore); 
    259259  (void) LogMagickEvent(ResourceEvent,GetMagickModule(),"%s: %s/%s/%s", 
    260260    MagickOptionToMnemonic(MagickResourceOptions,(long) type),resource_request, 
    … …  
    472472  if (resource_semaphore == (SemaphoreInfo *) NULL) 
    473473    AcquireSemaphoreInfo(&resource_semaphore); 
    474   LockSemaphoreInfo(resource_semaphore); 
     474  (void) LockSemaphoreInfo(resource_semaphore); 
    475475  if (temporary_resources == (SplayTreeInfo *) NULL) 
    476476    temporary_resources=NewSplayTree(CompareSplayTreeString, 
    477477      RelinquishMagickMemory,DestroyTemporaryResources); 
    478   UnlockSemaphoreInfo(resource_semaphore); 
     478  (void) UnlockSemaphoreInfo(resource_semaphore); 
    479479  resource=ConstantString(path); 
    480480  (void) AddValueToSplayTree(temporary_resources,resource,resource); 
    … …  
    510510 
    511511  resource=0; 
    512   LockSemaphoreInfo(resource_semaphore); 
     512  (void) LockSemaphoreInfo(resource_semaphore); 
    513513  switch (type) 
    514514  { 
    … …  
    551551      break; 
    552552  } 
    553   UnlockSemaphoreInfo(resource_semaphore); 
     553  (void) UnlockSemaphoreInfo(resource_semaphore); 
    554554  return(resource); 
    555555} 
    … …  
    585585  if (resource_semaphore == (SemaphoreInfo *) NULL) 
    586586    AcquireSemaphoreInfo(&resource_semaphore); 
    587   LockSemaphoreInfo(resource_semaphore); 
     587  (void) LockSemaphoreInfo(resource_semaphore); 
    588588  switch (type) 
    589589  { 
    … …  
    626626      break; 
    627627  } 
    628   UnlockSemaphoreInfo(resource_semaphore); 
     628  (void) UnlockSemaphoreInfo(resource_semaphore); 
    629629  return(resource); 
    630630} 
    … …  
    669669  if (resource_semaphore == (SemaphoreInfo *) NULL) 
    670670    AcquireSemaphoreInfo(&resource_semaphore); 
    671   LockSemaphoreInfo(resource_semaphore); 
     671  (void) LockSemaphoreInfo(resource_semaphore); 
    672672  (void) FormatMagickSize(resource_info.area_limit,area_limit); 
    673673  (void) FormatMagickSize(resource_info.memory_limit,memory_limit); 
    … …  
    686686    disk_limit,(unsigned long) resource_info.thread_limit,time_limit); 
    687687  (void) fflush(file); 
    688   UnlockSemaphoreInfo(resource_semaphore); 
     688  (void) UnlockSemaphoreInfo(resource_semaphore); 
    689689  return(MagickTrue); 
    690690} 
    … …  
    726726  if (resource_semaphore == (SemaphoreInfo *) NULL) 
    727727    AcquireSemaphoreInfo(&resource_semaphore); 
    728   LockSemaphoreInfo(resource_semaphore); 
     728  (void) LockSemaphoreInfo(resource_semaphore); 
    729729  switch (type) 
    730730  { 
    … …  
    791791      break; 
    792792  } 
    793   UnlockSemaphoreInfo(resource_semaphore); 
     793  (void) UnlockSemaphoreInfo(resource_semaphore); 
    794794  (void) LogMagickEvent(ResourceEvent,GetMagickModule(),"%s: %s/%s/%s", 
    795795    MagickOptionToMnemonic(MagickResourceOptions,(long) type),resource_request, 
    … …  
    10261026  if (resource_semaphore == (SemaphoreInfo *) NULL) 
    10271027    AcquireSemaphoreInfo(&resource_semaphore); 
    1028   LockSemaphoreInfo(resource_semaphore); 
     1028  (void) LockSemaphoreInfo(resource_semaphore); 
    10291029  if (temporary_resources != (SplayTreeInfo *) NULL) 
    10301030    temporary_resources=DestroySplayTree(temporary_resources); 
    10311031  if (random_info != (RandomInfo *) NULL) 
    10321032    random_info=DestroyRandomInfo(random_info); 
    1033   UnlockSemaphoreInfo(resource_semaphore); 
     1033  (void) UnlockSemaphoreInfo(resource_semaphore); 
    10341034  DestroySemaphoreInfo(&resource_semaphore); 
    10351035} 
    … …  
    10651065  if (resource_semaphore == (SemaphoreInfo *) NULL) 
    10661066    AcquireSemaphoreInfo(&resource_semaphore); 
    1067   LockSemaphoreInfo(resource_semaphore); 
     1067  (void) LockSemaphoreInfo(resource_semaphore); 
    10681068  switch (type) 
    10691069  { 
    … …  
    11071107      break; 
    11081108  } 
    1109   UnlockSemaphoreInfo(resource_semaphore); 
     1109  (void) UnlockSemaphoreInfo(resource_semaphore); 
    11101110  return(MagickTrue); 
    11111111} 

  • ImageMagick/trunk/magick/type.c

    r455 r460  
    271271  if (type_list == (SplayTreeInfo *) NULL) 
    272272    return((TypeInfo *) NULL); 
    273   LockSemaphoreInfo(type_semaphore); 
     273  (void) LockSemaphoreInfo(type_semaphore); 
    274274  ResetSplayTreeIterator(type_list); 
    275275  type_info=(const TypeInfo *) NULL; 
    … …  
    316316    break; 
    317317  } 
    318   UnlockSemaphoreInfo(type_semaphore); 
     318  (void) UnlockSemaphoreInfo(type_semaphore); 
    319319  if (type_info != (const TypeInfo *) NULL) 
    320320    return(type_info); 
    … …  
    323323  */ 
    324324  max_score=0; 
    325   LockSemaphoreInfo(type_semaphore); 
     325  (void) LockSemaphoreInfo(type_semaphore); 
    326326  ResetSplayTreeIterator(type_list); 
    327327  p=(const TypeInfo *) GetNextValueInSplayTree(type_list); 
    … …  
    375375    p=(const TypeInfo *) GetNextValueInSplayTree(type_list); 
    376376  } 
    377   UnlockSemaphoreInfo(type_semaphore); 
     377  (void) UnlockSemaphoreInfo(type_semaphore); 
    378378  if (type_info != (const TypeInfo *) NULL) 
    379379    return(type_info); 
    … …  
    486486    Generate type list. 
    487487  */ 
    488   LockSemaphoreInfo(type_semaphore); 
     488  (void) LockSemaphoreInfo(type_semaphore); 
    489489  ResetSplayTreeIterator(type_list); 
    490490  p=(const TypeInfo *) GetNextValueInSplayTree(type_list); 
    … …  
    496496    p=(const TypeInfo *) GetNextValueInSplayTree(type_list); 
    497497  } 
    498   UnlockSemaphoreInfo(type_semaphore); 
     498  (void) UnlockSemaphoreInfo(type_semaphore); 
    499499  qsort((void *) fonts,(size_t) i,sizeof(*fonts),TypeInfoCompare); 
    500500  fonts[i]=(TypeInfo *) NULL; 
    … …  
    579579    Generate type list. 
    580580  */ 
    581   LockSemaphoreInfo(type_semaphore); 
     581  (void) LockSemaphoreInfo(type_semaphore); 
    582582  ResetSplayTreeIterator(type_list); 
    583583  p=(const TypeInfo *) GetNextValueInSplayTree(type_list); 
    … …  
    589589    p=(const TypeInfo *) GetNextValueInSplayTree(type_list); 
    590590  } 
    591   UnlockSemaphoreInfo(type_semaphore); 
     591  (void) UnlockSemaphoreInfo(type_semaphore); 
    592592  qsort((void *) fonts,(size_t) i,sizeof(*fonts),TypeCompare); 
    593593  fonts[i]=(char *) NULL; 
    … …  
    774774      if (type_semaphore == (SemaphoreInfo *) NULL) 
    775775        AcquireSemaphoreInfo(&type_semaphore); 
    776       LockSemaphoreInfo(type_semaphore); 
     776      (void) LockSemaphoreInfo(type_semaphore); 
    777777      if ((type_list == (SplayTreeInfo *) NULL) && 
    778778          (instantiate_type == MagickFalse)) 
    … …  
    787787          instantiate_type=MagickTrue; 
    788788        } 
    789       UnlockSemaphoreInfo(type_semaphore); 
     789      (void) UnlockSemaphoreInfo(type_semaphore); 
    790790    } 
    791791  return(type_list != (SplayTreeInfo *) NULL ? MagickTrue : MagickFalse); 
    … …  
    13721372  if (type_semaphore == (SemaphoreInfo *) NULL) 
    13731373    AcquireSemaphoreInfo(&type_semaphore); 
    1374   LockSemaphoreInfo(type_semaphore); 
     1374  (void) LockSemaphoreInfo(type_semaphore); 
    13751375  if (type_list != (SplayTreeInfo *) NULL) 
    13761376    type_list=DestroySplayTree(type_list); 
    13771377  instantiate_type=MagickFalse; 
    1378   UnlockSemaphoreInfo(type_semaphore); 
     1378  (void) UnlockSemaphoreInfo(type_semaphore); 
    13791379  DestroySemaphoreInfo(&type_semaphore); 
    13801380} 

  • ImageMagick/trunk/wand/wand.c

    r453 r460  
    7979  if (wand_semaphore == (SemaphoreInfo *) NULL) 
    8080    AcquireSemaphoreInfo(&wand_semaphore); 
    81   LockSemaphoreInfo(wand_semaphore); 
     81  (void) LockSemaphoreInfo(wand_semaphore); 
    8282  if ((wand_ids == (SplayTreeInfo *) NULL) && (instantiate_wand == MagickFalse)) 
    8383    { 
    … …  
    8888  id++; 
    8989  (void) AddValueToSplayTree(wand_ids,(const void *) id,(const void *) id); 
    90   UnlockSemaphoreInfo(wand_semaphore); 
     90  (void) UnlockSemaphoreInfo(wand_semaphore); 
    9191  return(id); 
    9292} 
    … …  
    114114WandExport void DestroyWandIds(void) 
    115115{ 
    116   LockSemaphoreInfo(wand_semaphore); 
     116  (void) LockSemaphoreInfo(wand_semaphore); 
    117117  if (wand_ids != (SplayTreeInfo *) NULL) 
    118118    wand_ids=DestroySplayTree(wand_ids); 
    119119  instantiate_wand=MagickFalse; 
    120   UnlockSemaphoreInfo(wand_semaphore); 
     120  (void) UnlockSemaphoreInfo(wand_semaphore); 
    121121  DestroySemaphoreInfo(&wand_semaphore); 
    122122} 
    … …  
    146146WandExport void RelinquishWandId(const unsigned long id) 
    147147{ 
    148   LockSemaphoreInfo(wand_semaphore); 
     148  (void) LockSemaphoreInfo(wand_semaphore); 
    149149  if (wand_ids != (SplayTreeInfo *) NULL) 
    150150    (void) DeleteNodeByValueFromSplayTree(wand_ids,(const void *) id); 
    151   UnlockSemaphoreInfo(wand_semaphore); 
     151  (void) UnlockSemaphoreInfo(wand_semaphore); 
    152152}