(no commit message)

diff --git a/coders/avs.c b/coders/avs.c
index c72650f03cdf96e610867d64c4a34e94120d638f..f706bec7117e8ec994b856dfc214a84419be0911 100644 (file)
--- a/coders/avs.c
+++ b/coders/avs.c
@@ -187,7 +187,7 @@ static Image *ReadAVSImage(const ImageInfo *image_info,ExceptionInfo *exception)
       if (SyncAuthenticPixels(image,exception) == MagickFalse)
         break;
       if ((image->previous == (Image *) NULL) &&
-          (SetImageProgress(image,LoadImageTag,y,image->rows) == MagickFalse))
+          (SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,image->rows) == MagickFalse))
         break;
     }
     pixels=(unsigned char *) RelinquishMagickMemory(pixels);

diff --git a/coders/jpeg.c b/coders/jpeg.c
index ca358cccac3e75341f2daf922627889bb8b3620f..8c6232639f34694f961758ca0ac1fa2412392f41 100644 (file)
--- a/coders/jpeg.c
+++ b/coders/jpeg.c
@@ -624,13 +624,13 @@ static void SkipInputData(j_decompress_ptr cinfo,long number_bytes)
   if (number_bytes <= 0)
     return;
   source=(SourceManager *) cinfo->src;
-  while (number_bytes > (ssize_t) source->manager.bytes_in_buffer)
+  while (number_bytes > (long) source->manager.bytes_in_buffer)
   {
     number_bytes-=(long) source->manager.bytes_in_buffer;
     (void) FillInputBuffer(cinfo);
   }
-  source->manager.next_input_byte+=(size_t) number_bytes;
-  source->manager.bytes_in_buffer-=(size_t) number_bytes;
+  source->manager.next_input_byte+=number_bytes;
+  source->manager.bytes_in_buffer-=number_bytes;
 }
 
 static void TerminateSource(j_decompress_ptr cinfo)
@@ -954,7 +954,7 @@ static Image *ReadJPEGImage(const ImageInfo *image_info,
   for (i=1; i < 16; i++)
     if ((i != 2) && (i != 13) && (i != 14))
       jpeg_set_marker_processor(&jpeg_info,(int) (JPEG_APP0+i),ReadProfile);
-  i=jpeg_read_header(&jpeg_info,MagickTrue);
+  i=(ssize_t) jpeg_read_header(&jpeg_info,MagickTrue);
   if ((image_info->colorspace == YCbCrColorspace) ||
       (image_info->colorspace == Rec601YCbCrColorspace) ||
       (image_info->colorspace == Rec709YCbCrColorspace))
@@ -1277,7 +1277,7 @@ static Image *ReadJPEGImage(const ImageInfo *image_info,
           }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)
       break;
-    if (SetImageProgress(image,LoadImageTag,y,image->rows) == MagickFalse)
+    if (SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,image->rows) == MagickFalse)
       break;
   }
   /*

diff --git a/coders/miff.c b/coders/miff.c
index 1bf55e16ac30cc10469d0f85b7c7998ab9120bf5..27d78b1eb3922b9325052e0349849333705e8613 100644 (file)
--- a/coders/miff.c
+++ b/coders/miff.c
@@ -244,7 +244,7 @@ static void PushRunlengthPacket(Image *image,const unsigned char *pixels,
         }
         case 32:
         {
-          size_t
+          unsigned int
             quantum;
 
           if (image->matte != MagickFalse)
@@ -316,7 +316,7 @@ static void PushRunlengthPacket(Image *image,const unsigned char *pixels,
     }
     case 32:
     {
-      size_t
+      unsigned int
         quantum;
 
       p=PushLongPixel(MSBEndian,p,&quantum);
@@ -1145,7 +1145,7 @@ static Image *ReadMIFFImage(const ImageInfo *image_info,
               }
               case 32:
               {
-                size_t
+                unsigned int
                   pixel;
 
                 for (i=0; i < (ssize_t) image->colors; i++)
@@ -1554,7 +1554,7 @@ static unsigned char *PopRunlengthPacket(Image *image,unsigned char *pixels,
       {
         case 32:
         {
-          size_t
+          unsigned int
             value;
 
           if (image->matte != MagickFalse)
@@ -1599,7 +1599,7 @@ static unsigned char *PopRunlengthPacket(Image *image,unsigned char *pixels,
   {
     case 32:
     {
-      size_t
+      unsigned int
         value;
 
       value=ScaleQuantumToLong(pixel.red);
@@ -1820,7 +1820,7 @@ static MagickBooleanType WriteMIFFImage(const ImageInfo *image_info,
     (void) FormatMagickString(buffer,MaxTextExtent,
       "class=%s  colors=%lu  matte=%s\n",MagickOptionToMnemonic(
       MagickClassOptions,image->storage_class),(unsigned long) image->colors,
-      MagickOptionToMnemonic(MagickBooleanOptions,(long) image->matte));
+      MagickOptionToMnemonic(MagickBooleanOptions,(ssize_t) image->matte));
     (void) WriteBlobString(image,buffer);
     (void) FormatMagickString(buffer,MaxTextExtent,"columns=%lu  rows=%lu  "
       "depth=%lu\n",(unsigned long) image->columns,(unsigned long) image->rows,
@@ -2083,7 +2083,7 @@ static MagickBooleanType WriteMIFFImage(const ImageInfo *image_info,
               ThrowWriterException(CorruptImageError,"ImageDepthNotSupported");
             case 32:
             {
-              register size_t
+              register unsigned int
                 pixel;
 
               pixel=ScaleQuantumToLong(image->colormap[i].red);

diff --git a/coders/mpc.c b/coders/mpc.c
index 6ea33c39ad90c3ce7c5fec781c2200cea9e6f1e2..0d59278195e6aa374d90f5ff0c9898eab97ec005 100644 (file)
--- a/coders/mpc.c
+++ b/coders/mpc.c
@@ -871,7 +871,7 @@ static Image *ReadMPCImage(const ImageInfo *image_info,ExceptionInfo *exception)
               }
               case 32:
               {
-                size_t
+                unsigned int
                   pixel;
 
                 for (i=0; i < (ssize_t) image->colors; i++)
@@ -1082,8 +1082,7 @@ static MagickBooleanType WriteMPCImage(const ImageInfo *image_info,Image *image)
     (void) FormatMagickString(buffer,MaxTextExtent,
       "class=%s  colors=%lu  matte=%s\n",MagickOptionToMnemonic(
       MagickClassOptions,image->storage_class),(unsigned long) image->colors,
-      MagickOptionToMnemonic(MagickBooleanOptions,(unsigned long)
-      image->matte));
+      MagickOptionToMnemonic(MagickBooleanOptions,(ssize_t) image->matte));
     (void) WriteBlobString(image,buffer);
     (void) FormatMagickString(buffer,MaxTextExtent,
       "columns=%lu  rows=%lu  depth=%lu\n",(unsigned long) image->columns,
@@ -1351,7 +1350,7 @@ static MagickBooleanType WriteMPCImage(const ImageInfo *image_info,Image *image)
               ThrowWriterException(CorruptImageError,"ImageDepthNotSupported");
             case 32:
             {
-              size_t
+              unsigned int
                 pixel;
 
               pixel=ScaleQuantumToLong(image->colormap[i].red);

diff --git a/coders/xpm.c b/coders/xpm.c
index 45f8152c4e24eb97f957a263f08d854eecdcf598..a3bc383991d5f77ba97239c0dddb9f239fb3a8ba 100644 (file)
--- a/coders/xpm.c
+++ b/coders/xpm.c
@@ -667,7 +667,7 @@ static MagickBooleanType WritePICONImage(const ImageInfo *image_info,
   exception=(&image->exception);
   if (picon->storage_class == PseudoClass)
     {
-      CompressImageColormap(picon);
+      (void) CompressImageColormap(picon);
       if (picon->matte != MagickFalse)
         transparent=MagickTrue;
     }
@@ -805,7 +805,8 @@ static MagickBooleanType WritePICONImage(const ImageInfo *image_info,
     (void) FormatMagickString(buffer,MaxTextExtent,"\"%s\n",
       y == (ssize_t) (picon->rows-1) ? "" : ",");
     (void) WriteBlobString(image,buffer);
-    status=SetImageProgress(image,SaveImageTag,y,picon->rows);
+    status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+      picon->rows);
     if (status == MagickFalse)
       break;
   }
@@ -1036,7 +1037,8 @@ static MagickBooleanType WriteXPMImage(const ImageInfo *image_info,Image *image)
     (void) WriteBlobString(image,buffer);
     if (image->previous == (Image *) NULL)
       {
-        status=SetImageProgress(image,SaveImageTag,y,image->rows);
+        status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+          image->rows);
         if (status == MagickFalse)
           break;
       }

diff --git a/magick/blob.c b/magick/blob.c
index 932d8004d9e226727e1fa456958838714f26bb56..5c0073b20da7394062065b9357ae9aeb9c4f586b 100644 (file)
--- a/magick/blob.c
+++ b/magick/blob.c
@@ -2918,12 +2918,12 @@ MagickExport unsigned int ReadBlobLong(Image *image)
 %                                                                             %
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %
-%  ReadBlobLongLong() reads a ssize_t value as a 64-bit quantity in the byte-order
-%  specified by the endian member of the image structure.
+%  ReadBlobLongLong() reads a long long value as a 64-bit quantity in the
+%  byte-order specified by the endian member of the image structure.
 %
-%  The format of the ReadBlobLong method is:
+%  The format of the ReadBlobLongLong method is:
 %
-%      MagickSizeType ReadBlobLong(Image *image)
+%      MagickSizeType ReadBlobLongLong(Image *image)
 %
 %  A description of each parameter follows.
 %

diff --git a/magick/pixel.h b/magick/pixel.h
index 593ba128f4fed4df51056af21f32bfd1c940418a..8ee871c5b1a11e3712c37f1a1a6d9be0b7e0190b 100644 (file)
--- a/magick/pixel.h
+++ b/magick/pixel.h
@@ -80,7 +80,7 @@ typedef struct _DoublePixelPacket
 
 typedef struct _LongPixelPacket
 {
-  size_t
+  unsigned int
     red,
     green,
     blue,

diff --git a/magick/quantum-export.c b/magick/quantum-export.c
index 9b2eacd929a3eaf5595990ccc6aeba1b01703ed4..f1e21d9e833871204c948e3fae1ea0db3504a749 100644 (file)
--- a/magick/quantum-export.c
+++ b/magick/quantum-export.c
@@ -178,26 +178,26 @@ static inline unsigned char *PopQuantumPixel(QuantumState *quantum_state,
   register ssize_t
     i;
 
-  register size_t
+  register unsigned int
     quantum_bits;
 
   if (quantum_state->bits == 0UL)
-    quantum_state->bits=8UL;
+    quantum_state->bits=8U;
   for (i=(ssize_t) depth; i > 0L; )
   {
-    quantum_bits=(size_t) i;
+    quantum_bits=(unsigned int) i;
     if (quantum_bits > quantum_state->bits)
       quantum_bits=quantum_state->bits;
     i-=(ssize_t) quantum_bits;
     if (quantum_state->bits == 8)
       *pixels='\0';
     quantum_state->bits-=quantum_bits;
-    *pixels|=(((pixel >> i) &~ ((~0UL) << quantum_bits)) <<
+    *pixels|=(((pixel >> i) &~ ((~0U) << quantum_bits)) <<
       quantum_state->bits);
     if (quantum_state->bits == 0UL)
       {
         pixels++;
-        quantum_state->bits=8UL;
+        quantum_state->bits=8U;
       }
   }
   return(pixels);
@@ -212,22 +212,22 @@ static inline unsigned char *PopQuantumLongPixel(QuantumState *quantum_state,
   size_t
     quantum_bits;
 
-  if (quantum_state->bits == 0UL)
-    quantum_state->bits=32UL;
+  if (quantum_state->bits == 0U)
+    quantum_state->bits=32U;
   for (i=(ssize_t) depth; i > 0; )
   {
     quantum_bits=(size_t) i;
     if (quantum_bits > quantum_state->bits)
       quantum_bits=quantum_state->bits;
     quantum_state->pixel|=(((pixel >> (depth-i)) &
-      quantum_state->mask[quantum_bits]) << (32UL-quantum_state->bits));
+      quantum_state->mask[quantum_bits]) << (32U-quantum_state->bits));
     i-=(ssize_t) quantum_bits;
     quantum_state->bits-=quantum_bits;
     if (quantum_state->bits == 0U)
       {
         pixels=PopLongPixel(quantum_state->endian,quantum_state->pixel,pixels);
         quantum_state->pixel=0U;
-        quantum_state->bits=32UL;
+        quantum_state->bits=32U;
       }
   }
   return(pixels);
@@ -460,7 +460,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
             }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopLongPixel(endian,(size_t) indexes[x],q);
+            q=PopLongPixel(endian,(unsigned int) indexes[x],q);
             q+=quantum_info->pad;
           }
           break;
@@ -614,7 +614,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         case 32:
         {
-          register size_t
+          register unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -634,7 +634,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
             }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopLongPixel(endian,(size_t) indexes[x],q);
+            q=PopLongPixel(endian,(unsigned int) indexes[x],q);
             pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
               GetOpacityPixelComponent(p)));
             q=PopLongPixel(endian,pixel,q);
@@ -775,12 +775,12 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
           range=GetQuantumRange(image->depth);
           if (quantum_info->pack == MagickFalse)
             {
-              register size_t
+              register unsigned int
                 pixel;
 
               for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
               {
-                pixel=(size_t) (
+                pixel=(unsigned int) (
                   ScaleQuantumToAny(PixelIntensityToQuantum(p+2),range) << 22 |
                   ScaleQuantumToAny(PixelIntensityToQuantum(p+1),range) << 12 |
                   ScaleQuantumToAny(PixelIntensityToQuantum(p+0),range) << 2);
@@ -861,7 +861,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         case 32:
         {
-          register size_t
+          register unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1047,7 +1047,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         case 32:
         {
-          register size_t
+          register unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1161,7 +1161,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         case 32:
         {
-          register size_t
+          register unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1258,7 +1258,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         case 32:
         {
-          register size_t
+          register unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1355,7 +1355,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         case 32:
         {
-          register size_t
+          register unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1453,7 +1453,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         case 32:
         {
-          register size_t
+          register unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1558,7 +1558,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         case 32:
         {
-          register size_t
+          register unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1659,7 +1659,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         case 32:
         {
-          register size_t
+          register unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1728,7 +1728,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         case 10:
         {
-          register size_t
+          register unsigned int
             pixel;
 
           range=GetQuantumRange(image->depth);
@@ -1736,7 +1736,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
             {
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
-                pixel=(size_t) (ScaleQuantumToAny(p->red,range) << 22 |
+                pixel=(unsigned int) (ScaleQuantumToAny(p->red,range) << 22 |
                   ScaleQuantumToAny(p->green,range) << 12 |
                   ScaleQuantumToAny(p->blue,range) << 2);
                 q=PopLongPixel(endian,pixel,q);
@@ -1749,11 +1749,11 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
             {
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
-                pixel=(size_t) ScaleQuantumToAny(p->red,range);
+                pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
-                pixel=(size_t) ScaleQuantumToAny(p->green,range);
+                pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
-                pixel=(size_t) ScaleQuantumToAny(p->blue,range);
+                pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
                 p++;
                 q+=quantum_info->pad;
@@ -1762,11 +1762,11 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
             }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            pixel=(size_t) ScaleQuantumToAny(p->red,range);
+            pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
-            pixel=(size_t) ScaleQuantumToAny(p->green,range);
+            pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
-            pixel=(size_t) ScaleQuantumToAny(p->blue,range);
+            pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
             p++;
             q+=quantum_info->pad;
@@ -1775,7 +1775,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         case 12:
         {
-          register size_t
+          register unsigned int
             pixel;
 
           range=GetQuantumRange(image->depth);
@@ -1788,17 +1788,17 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
                   default:
                   case 0:
                   {
-                    pixel=(size_t) ScaleQuantumToAny(p->red,range);
+                    pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
                     break;
                   }
                   case 1:
                   {
-                    pixel=(size_t) ScaleQuantumToAny(p->green,range);
+                    pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
                     break;
                   }
                   case 2:
                   {
-                    pixel=(size_t) ScaleQuantumToAny(p->blue,range);
+                    pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
                     p++;
                     break;
                   }
@@ -1809,17 +1809,17 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
                   default:
                   case 0:
                   {
-                    pixel=(size_t) ScaleQuantumToAny(p->red,range);
+                    pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
                     break;
                   }
                   case 1:
                   {
-                    pixel=(size_t) ScaleQuantumToAny(p->green,range);
+                    pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
                     break;
                   }
                   case 2:
                   {
-                    pixel=(size_t) ScaleQuantumToAny(p->blue,range);
+                    pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
                     p++;
                     break;
                   }
@@ -1834,17 +1834,17 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
                   default:
                   case 0:
                   {
-                    pixel=(size_t) ScaleQuantumToAny(p->red,range);
+                    pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
                     break;
                   }
                   case 1:
                   {
-                    pixel=(size_t) ScaleQuantumToAny(p->green,range);
+                    pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
                     break;
                   }
                   case 2:
                   {
-                    pixel=(size_t) ScaleQuantumToAny(p->blue,range);
+                    pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
                     p++;
                     break;
                   }
@@ -1860,11 +1860,11 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
             {
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
-                pixel=(size_t) ScaleQuantumToAny(p->red,range);
+                pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
-                pixel=(size_t) ScaleQuantumToAny(p->green,range);
+                pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
-                pixel=(size_t) ScaleQuantumToAny(p->blue,range);
+                pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
                 p++;
                 q+=quantum_info->pad;
@@ -1873,11 +1873,11 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
             }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            pixel=(size_t) ScaleQuantumToAny(p->red,range);
+            pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
-            pixel=(size_t) ScaleQuantumToAny(p->green,range);
+            pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
-            pixel=(size_t) ScaleQuantumToAny(p->blue,range);
+            pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
             p++;
             q+=quantum_info->pad;
@@ -1922,7 +1922,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         case 32:
         {
-          register size_t
+          register unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -2012,7 +2012,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         case 10:
         {
-          register size_t
+          register unsigned int
             pixel;
 
           range=GetQuantumRange(image->depth);
@@ -2075,13 +2075,13 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
             {
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
-                pixel=(size_t) ScaleQuantumToAny(p->red,range);
+                pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
-                pixel=(size_t) ScaleQuantumToAny(p->green,range);
+                pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
-                pixel=(size_t) ScaleQuantumToAny(p->blue,range);
+                pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
-                pixel=(size_t) ScaleQuantumToAny((Quantum) (QuantumRange-
+                pixel=(unsigned int) ScaleQuantumToAny((Quantum) (QuantumRange-
                   p->opacity),range);
                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
                 p++;
@@ -2091,13 +2091,13 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
             }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            pixel=(size_t) ScaleQuantumToAny(p->red,range);
+            pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
-            pixel=(size_t) ScaleQuantumToAny(p->green,range);
+            pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
-            pixel=(size_t) ScaleQuantumToAny(p->blue,range);
+            pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
-            pixel=(size_t) ScaleQuantumToAny((Quantum) (QuantumRange-
+            pixel=(unsigned int) ScaleQuantumToAny((Quantum) (QuantumRange-
               p->opacity),range);
             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
             p++;
@@ -2148,7 +2148,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         case 32:
         {
-          register size_t
+          register unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -2296,7 +2296,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         case 32:
         {
-          register size_t
+          register unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -2446,7 +2446,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         case 32:
         {
-          register size_t
+          register unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -2540,7 +2540,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
       register ssize_t
         i;
 
-      register size_t
+      register unsigned int
         pixel;
 
       size_t
@@ -2580,12 +2580,12 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
                   cbcr[i]=(Quantum) quantum;
                   n++;
                 }
-                pixel=(size_t) ((size_t) (cbcr[1]) << 22 |
+                pixel=(unsigned int) ((size_t) (cbcr[1]) << 22 |
                   (size_t) (cbcr[0]) << 12 |
                   (size_t) (cbcr[2]) << 2);
                 q=PopLongPixel(endian,pixel,q);
                 p++;
-                pixel=(size_t) ((size_t) (cbcr[3]) << 22 |
+                pixel=(unsigned int) ((size_t) (cbcr[3]) << 22 |
                   (size_t) (cbcr[0]) << 12 |
                   (size_t) (cbcr[2]) << 2);
                 q=PopLongPixel(endian,pixel,q);

diff --git a/magick/quantum-import.c b/magick/quantum-import.c
index 4722c422c4aacc225fea613f37b3f4037f6ac49a..465589c068368d46712dff363ada2f12af43c933 100644 (file)
--- a/magick/quantum-import.c
+++ b/magick/quantum-import.c
@@ -193,7 +193,7 @@ static inline const unsigned char *PushFloatPixel(
 
 static inline const unsigned char *PushQuantumPixel(
   QuantumState *quantum_state,const size_t depth,
-  const unsigned char *pixels,size_t *quantum)
+  const unsigned char *pixels,unsigned int *quantum)
 {
   register ssize_t
     i;
@@ -207,7 +207,7 @@ static inline const unsigned char *PushQuantumPixel(
     if (quantum_state->bits == 0UL)
       {
         quantum_state->pixel=(*pixels++);
-        quantum_state->bits=8UL;
+        quantum_state->bits=8U;
       }
     quantum_bits=(size_t) i;
     if (quantum_bits > quantum_state->bits)
@@ -215,14 +215,14 @@ static inline const unsigned char *PushQuantumPixel(
     i-=(ssize_t) quantum_bits;
     quantum_state->bits-=quantum_bits;
     *quantum=(*quantum << quantum_bits) | ((quantum_state->pixel >>
-      quantum_state->bits) &~ ((~0UL) << quantum_bits));
+      quantum_state->bits) &~ ((~0U) << quantum_bits));
   }
   return(pixels);
 }
 
 static inline const unsigned char *PushQuantumLongPixel(
   QuantumState *quantum_state,const size_t depth,
-  const unsigned char *pixels,size_t *quantum)
+  const unsigned char *pixels,unsigned int *quantum)
 {
   register ssize_t
     i;
@@ -237,12 +237,12 @@ static inline const unsigned char *PushQuantumLongPixel(
       {
         pixels=PushLongPixel(quantum_state->endian,pixels,
           &quantum_state->pixel);
-        quantum_state->bits=32UL;
+        quantum_state->bits=32U;
       }
     quantum_bits=(size_t) i;
     if (quantum_bits > quantum_state->bits)
       quantum_bits=quantum_state->bits;
-    *quantum|=(((quantum_state->pixel >> (32UL-quantum_state->bits)) &
+    *quantum|=(((quantum_state->pixel >> (32U-quantum_state->bits)) &
       quantum_state->mask[quantum_bits]) << (depth-i));
     i-=(ssize_t) quantum_bits;
     quantum_state->bits-=quantum_bits;
@@ -284,7 +284,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
   size_t
     extent;
 
-  size_t
+  unsigned int
     pixel;
 
   assert(image != (Image *) NULL);
@@ -435,7 +435,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          size_t
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -628,7 +628,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          size_t
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -980,7 +980,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          size_t
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1190,7 +1190,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          size_t
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1311,7 +1311,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          size_t
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1416,7 +1416,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          size_t
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1521,7 +1521,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          size_t
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1625,7 +1625,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          size_t
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1732,7 +1732,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          size_t
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1830,7 +1830,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               }
               break;
             }
-          if (quantum_info->quantum == 32UL)
+          if (quantum_info->quantum == 32U)
             {
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
@@ -1939,7 +1939,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
                 p++;
               break;
             }
-          if (quantum_info->quantum == 32UL)
+          if (quantum_info->quantum == 32U)
             {
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
@@ -2003,7 +2003,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          size_t
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -2216,7 +2216,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          size_t
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -2370,7 +2370,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          size_t
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -2532,7 +2532,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          size_t
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)

diff --git a/magick/quantum-private.h b/magick/quantum-private.h
index dd8b76d1171b2dcfde0dd5abae87cd071c39e263..2af9439f90fdb8966c160121c7ab565ad85ec8e1 100644 (file)
--- a/magick/quantum-private.h
+++ b/magick/quantum-private.h
@@ -34,11 +34,11 @@ typedef struct _QuantumState
     scale,
     inverse_scale;
 
-  size_t
+  unsigned int
     pixel,
     bits;
 
-  const size_t
+  const unsigned int
     *mask;
 } QuantumState;
 
@@ -84,8 +84,11 @@ struct _QuantumInfo
 
 static inline MagickSizeType GetQuantumRange(const size_t depth)
 {
-  return((MagickSizeType) ((MagickULLConstant(1) << (depth-1))+
-    ((MagickULLConstant(1) << (depth-1))-1)));
+  MagickSizeType
+    one;
+
+  one=1;
+  return((MagickSizeType) ((one << (depth-1))+((one << (depth-1))-1)));
 }
 
 static inline float HalfToSinglePrecision(const unsigned short half)
@@ -179,15 +182,15 @@ static inline Quantum HDRIClampToQuantum(const MagickRealType value)
 static inline void InitializeQuantumState(const QuantumInfo *quantum_info,
   const EndianType endian,QuantumState *quantum_state)
 {
-  static const size_t mask[32] =
+  static const unsigned int mask[32] =
   {
-    0x00000000UL, 0x00000001UL, 0x00000003UL, 0x00000007UL, 0x0000000fUL,
-    0x0000001fUL, 0x0000003fUL, 0x0000007fUL, 0x000000ffUL, 0x000001ffUL,
-    0x000003ffUL, 0x000007ffUL, 0x00000fffUL, 0x00001fffUL, 0x00003fffUL,
-    0x00007fffUL, 0x0000ffffUL, 0x0001ffffUL, 0x0003ffffUL, 0x0007ffffUL,
-    0x000fffffUL, 0x001fffffUL, 0x003fffffUL, 0x007fffffUL, 0x00ffffffUL,
-    0x01ffffffUL, 0x03ffffffUL, 0x07ffffffUL, 0x0fffffffUL, 0x1fffffffUL,
-    0x3fffffffUL, 0x7fffffffUL
+    0x00000000U, 0x00000001U, 0x00000003U, 0x00000007U, 0x0000000fU,
+    0x0000001fU, 0x0000003fU, 0x0000007fU, 0x000000ffU, 0x000001ffU,
+    0x000003ffU, 0x000007ffU, 0x00000fffU, 0x00001fffU, 0x00003fffU,
+    0x00007fffU, 0x0000ffffU, 0x0001ffffU, 0x0003ffffU, 0x0007ffffU,
+    0x000fffffU, 0x001fffffU, 0x003fffffU, 0x007fffffU, 0x00ffffffU,
+    0x01ffffffU, 0x03ffffffU, 0x07ffffffU, 0x0fffffffU, 0x1fffffffU,
+    0x3fffffffU, 0x7fffffffU
   };
 
   quantum_state->endian=endian;
@@ -196,8 +199,8 @@ static inline void InitializeQuantumState(const QuantumInfo *quantum_info,
   quantum_state->inverse_scale=1.0;
   if (quantum_state->scale != 0.0)
     quantum_state->inverse_scale/=quantum_state->scale;
-  quantum_state->pixel=0UL;
-  quantum_state->bits=0UL;
+  quantum_state->pixel=0U;
+  quantum_state->bits=0U;
   quantum_state->mask=mask;
 }
 
@@ -209,7 +212,7 @@ static inline unsigned char *PopCharPixel(const unsigned char pixel,
 }
 
 static inline unsigned char *PopLongPixel(const EndianType endian,
-  const size_t pixel,unsigned char *pixels)
+  const unsigned int pixel,unsigned char *pixels)
 {
   register unsigned int
     quantum;
@@ -256,7 +259,7 @@ static inline const unsigned char *PushCharPixel(const unsigned char *pixels,
 }
 
 static inline const unsigned char *PushLongPixel(const EndianType endian,
-  const unsigned char *pixels,size_t *pixel)
+  const unsigned char *pixels,unsigned int *pixel)
 {
   register unsigned int
     quantum;
@@ -275,7 +278,7 @@ static inline const unsigned char *PushLongPixel(const EndianType endian,
       quantum|=(unsigned int) (*pixels++ << 16);
       quantum|=(unsigned int) (*pixels++ << 24);
     }
-  *pixel=(size_t) (quantum & 0xffffffff);
+  *pixel=(unsigned int) (quantum & 0xffffffff);
   return(pixels);
 }
 
@@ -321,7 +324,7 @@ static inline Quantum ScaleCharToQuantum(const unsigned char value)
   return((Quantum) value);
 }
 
-static inline Quantum ScaleLongToQuantum(const size_t value)
+static inline Quantum ScaleLongToQuantum(const unsigned int value)
 {
 #if !defined(MAGICKCORE_HDRI_SUPPORT)
   return((Quantum) ((value+8421504UL)/16843009UL));
@@ -343,29 +346,29 @@ static inline Quantum ScaleMapToQuantum(const MagickRealType value)
 #endif
 }
 
-static inline size_t ScaleQuantumToLong(const Quantum quantum)
+static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
 {
 #if !defined(MAGICKCORE_HDRI_SUPPORT)
-  return((size_t) (16843009UL*quantum));
+  return((unsigned int) (16843009UL*quantum));
 #else
   if (quantum <= 0.0)
     return(0UL);
   if ((16843009.0*quantum) >= 4294967295.0)
     return(4294967295UL);
-  return((size_t) (16843009.0*quantum+0.5));
+  return((unsigned int) (16843009.0*quantum+0.5));
 #endif
 }
 
-static inline size_t ScaleQuantumToMap(const Quantum quantum)
+static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
 {
   if (quantum >= (Quantum) MaxMap)
-    return((size_t) MaxMap);
+    return((unsigned int) MaxMap);
 #if !defined(MAGICKCORE_HDRI_SUPPORT)
-  return((size_t) quantum);
+  return((unsigned int) quantum);
 #else
   if (quantum < 0.0)
     return(0UL);
-  return((size_t) (quantum+0.5));
+  return((unsigned int) (quantum+0.5));
 #endif
 }
 
@@ -400,7 +403,7 @@ static inline Quantum ScaleCharToQuantum(const unsigned char value)
 #endif
 }
 
-static inline Quantum ScaleLongToQuantum(const size_t value)
+static inline Quantum ScaleLongToQuantum(const unsigned int value)
 {
 #if !defined(MAGICKCORE_HDRI_SUPPORT)
   return((Quantum) ((value+MagickULLConstant(32768))/
@@ -423,29 +426,29 @@ static inline Quantum ScaleMapToQuantum(const MagickRealType value)
 #endif
 }
 
-static inline size_t ScaleQuantumToLong(const Quantum quantum)
+static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
 {
 #if !defined(MAGICKCORE_HDRI_SUPPORT)
-  return((size_t) (65537UL*quantum));
+  return((unsigned int) (65537UL*quantum));
 #else
   if (quantum <= 0.0)
     return(0UL);
   if ((65537.0*quantum) >= 4294967295.0)
     return(4294967295UL);
-  return((size_t) (65537.0*quantum+0.5));
+  return((unsigned int) (65537.0*quantum+0.5));
 #endif
 }
 
-static inline size_t ScaleQuantumToMap(const Quantum quantum)
+static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
 {
   if (quantum >= (Quantum) MaxMap)
-    return((size_t) MaxMap);
+    return((unsigned int) MaxMap);
 #if !defined(MAGICKCORE_HDRI_SUPPORT)
-  return((size_t) quantum);
+  return((unsigned int) quantum);
 #else
   if (quantum < 0.0)
     return(0UL);
-  return((size_t) (quantum+0.5));
+  return((unsigned int) (quantum+0.5));
 #endif
 }
 
@@ -476,7 +479,7 @@ static inline Quantum ScaleCharToQuantum(const unsigned char value)
 #endif
 }
 
-static inline Quantum ScaleLongToQuantum(const size_t value)
+static inline Quantum ScaleLongToQuantum(const unsigned int value)
 {
   return((Quantum) value);
 }
@@ -494,26 +497,26 @@ static inline Quantum ScaleMapToQuantum(const MagickRealType value)
 #endif
 }
 
-static inline size_t ScaleQuantumToLong(const Quantum quantum)
+static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
 {
 #if !defined(MAGICKCORE_HDRI_SUPPORT)
-  return((size_t) quantum);
+  return((unsigned int) quantum);
 #else
-  return((size_t) (quantum+0.5));
+  return((unsigned int) (quantum+0.5));
 #endif
 }
 
-static inline size_t ScaleQuantumToMap(const Quantum quantum)
+static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
 {
   if (quantum < 0.0)
     return(0UL);
   if ((quantum/65537) >= (Quantum) MaxMap)
-    return((size_t) MaxMap);
+    return((unsigned int) MaxMap);
 #if !defined(MAGICKCORE_HDRI_SUPPORT)
-  return((size_t) ((quantum+MagickULLConstant(32768))/
+  return((unsigned int) ((quantum+MagickULLConstant(32768))/
     MagickULLConstant(65537)));
 #else
-  return((size_t) (quantum/65537.0+0.5));
+  return((unsigned int) (quantum/65537.0+0.5));
 #endif
 }
 
@@ -545,7 +548,7 @@ static inline Quantum ScaleCharToQuantum(const unsigned char value)
   return((Quantum) (72340172838076673.0*value));
 }
 
-static inline Quantum ScaleLongToQuantum(const size_t value)
+static inline Quantum ScaleLongToQuantum(const unsigned int value)
 {
   return((Quantum) (4294967297.0*value));
 }
@@ -559,18 +562,18 @@ static inline Quantum ScaleMapToQuantum(const MagickRealType value)
   return((Quantum) (281479271743489.0*value));
 }
 
-static inline size_t ScaleQuantumToLong(const Quantum quantum)
+static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
 {
-  return((size_t) (quantum/4294967297.0+0.5));
+  return((unsigned int) (quantum/4294967297.0+0.5));
 }
 
-static inline size_t ScaleQuantumToMap(const Quantum quantum)
+static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
 {
   if (quantum <= 0.0)
     return(0UL);
   if ((quantum/281479271743489.0) >= MaxMap)
-    return((size_t) MaxMap);
-  return((size_t) (quantum/281479271743489.0+0.5));
+    return((unsigned int) MaxMap);
+  return((unsigned int) (quantum/281479271743489.0+0.5));
 }
 
 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
@@ -625,13 +628,13 @@ static inline unsigned short SinglePrecisionToHalf(const float value)
   significand=map.fixed_point & 0x007fffff;
   if (exponent <= 0)
     {
-      ssize_t
+      int
         shift;
 
       if (exponent < -10)
         return((unsigned short) sign_bit);
       significand=significand | 0x00800000;
-      shift=(ssize_t) (14-exponent);
+      shift=(int) (14-exponent);
       significand=(unsigned int) ((significand+((1 << (shift-1))-1)+
         ((significand >> shift) & 0x01)) >> shift);
       return((unsigned short) (sign_bit | significand));
@@ -660,7 +663,7 @@ static inline unsigned short SinglePrecisionToHalf(const float value)
       float
         alpha;
 
-      register ssize_t
+      register int
         i;
 
       /*