[devel] Prefixed variable names index, div, exp, gamma with "png_"

to avoid "shadow" warnings.  Revised png_fixed() in png.c to avoid compiler
warning about reaching the end without returning anything.

ANNOUNCE

@@ -49,6 +49,10 @@ Version 1.5.1beta04 [January 16, 2011]
     macros such as png_memset() are no longer accessible by applications.
   Corrected pngvalid gamma test "sample" function to access all of the color
     samples of each pixel, instead of sampling the red channel three times.
+  Prefixed variable names index, div, exp, gamma with "png_" to avoid "shadow"
+    warnings.
+  Revised png_fixed() in png.c to avoid compiler warning about reaching the
+    end without returning anything.
 
 Send comments/corrections/commendations to png-mng-implement at lists.sf.net:
 (subscription required; visit

CHANGES

@@ -3165,6 +3165,10 @@ Version 1.5.1beta04 [January 16, 2011]
     macros such as png_memset() are no longer accessible by applications.
   Corrected pngvalid gamma test "sample" function to access all of the color
     samples of each pixel, instead of sampling the red channel three times.
+  Prefixed variable names index, div, exp, gamma with "png_" to avoid "shadow"
+    warnings.
+  Revised png_fixed() in png.c to avoid compiler warning about reaching the
+    end without returning anything.
 
 Send comments/corrections/commendations to png-mng-implement at lists.sf.net
 (subscription required; visit

png.c

@@ -555,13 +555,13 @@ png_get_copyright(png_structp png_ptr)
 #else
 #  ifdef __STDC__
    return PNG_STRING_NEWLINE \
-     "libpng version 1.5.1beta04 - January 15, 2011" PNG_STRING_NEWLINE \
+     "libpng version 1.5.1beta04 - January 16, 2011" PNG_STRING_NEWLINE \
      "Copyright (c) 1998-2011 Glenn Randers-Pehrson" PNG_STRING_NEWLINE \
      "Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \
      "Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \
      PNG_STRING_NEWLINE;
 #  else
-      return "libpng version 1.5.1beta04 - January 15, 2011\
+      return "libpng version 1.5.1beta04 - January 16, 2011\
       Copyright (c) 1998-2011 Glenn Randers-Pehrson\
       Copyright (c) 1996-1997 Andreas Dilger\
       Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.";
@@ -1031,10 +1031,10 @@ int
 png_check_fp_string(png_const_charp string, png_size_t size)
 {
    int        state=0;
-   png_size_t index=0;
+   png_size_t png_index=0;
 
-   return png_check_fp_number(string, size, &state, &index) &&
-      (index == size || string[index] == 0);
+   return png_check_fp_number(string, size, &state, &png_index) &&
+      (png_index == size || string[png_index] == 0);
 }
 #endif /* pCAL or sCAL */
 
@@ -1108,46 +1108,46 @@ png_ascii_from_fp(png_structp png_ptr, png_charp ascii, png_size_t size,
 
       if (fp >= DBL_MIN && fp <= DBL_MAX)
       {
-         int exp;       /* A base 10 exponent */
-         double base;   /* 10^exp */
+         int png_exp;       /* A base 10 exponent */
+         double base;   /* 10^png_exp */
 
          /* First extract a base 10 exponent of the number,
           * the calculation below rounds down when converting
           * from base 2 to base 10 (multiply by log10(2) -
-          * 0.3010, but 77/256 is 0.3008, so exp needs to
+          * 0.3010, but 77/256 is 0.3008, so png_exp needs to
           * be increased.  Note that the arithmetic shift
           * performs a floor() unlike C arithmetic - using a
           * C multiply would break the following for negative
           * exponents.
           */
-         (void)frexp(fp, &exp); /* exponent to base 2 */
+         (void)frexp(fp, &png_exp); /* exponent to base 2 */
 
-         exp = (exp * 77) >> 8; /* <= exponent to base 10 */
+         png_exp = (png_exp * 77) >> 8; /* <= exponent to base 10 */
 
          /* Avoid underflow here. */
-         base = png_pow10(exp); /* May underflow */
+         base = png_pow10(png_exp); /* May underflow */
 
          while (base < DBL_MIN || base < fp)
          {
             /* And this may overflow. */
-            double test = png_pow10(exp+1);
+            double test = png_pow10(png_exp+1);
 
             if (test <= DBL_MAX)
-               ++exp, base = test;
+               ++png_exp, base = test;
 
             else
                break;
          }
 
-         /* Normalize fp and correct exp, after this fp is in the
-          * range [.1,1) and exp is both the exponent and the digit
+         /* Normalize fp and correct png_exp, after this fp is in the
+          * range [.1,1) and png_exp is both the exponent and the digit
           * *before* which the decimal point should be inserted
           * (starting with 0 for the first digit).  Note that this
-          * works even if 10^exp is out of range because of the
+          * works even if 10^png_exp is out of range because of the
           * test on DBL_MAX above.
           */
          fp /= base;
-         while (fp >= 1) fp /= 10, ++exp;
+         while (fp >= 1) fp /= 10, ++png_exp;
 
          /* Because of the code above fp may, at this point, be
           * less than .1, this is ok because the code below can
@@ -1162,10 +1162,10 @@ png_ascii_from_fp(png_structp png_ptr, png_charp ascii, png_size_t size,
             /* Allow up to two leading zeros - this will not lengthen
              * the number compared to using E-n.
              */
-            if (exp < 0 && exp > -3) /* PLUS 3 TOTAL 4 */
+            if (png_exp < 0 && png_exp > -3) /* PLUS 3 TOTAL 4 */
             {
-               czero = -exp; /* PLUS 2 digits: TOTAL 3 */
-               exp = 0;      /* Dot added below before first output. */
+               czero = -png_exp; /* PLUS 2 digits: TOTAL 3 */
+               png_exp = 0;      /* Dot added below before first output. */
             }
             else
                czero = 0;    /* No zeros to add */
@@ -1207,17 +1207,17 @@ png_ascii_from_fp(png_structp png_ptr, png_charp ascii, png_size_t size,
                         {
                            int ch = *--ascii;
 
-                           if (exp != (-1))
-                              ++exp;
+                           if (png_exp != (-1))
+                              ++png_exp;
 
                            else if (ch == 46)
                            {
                               ch = *--ascii, ++size;
-                              /* Advance exp to '1', so that the
+                              /* Advance png_exp to '1', so that the
                                * decimal point happens after the
                                * previous digit.
                                */
-                              exp = 1;
+                              png_exp = 1;
                            }
 
                            --cdigits;
@@ -1230,7 +1230,7 @@ png_ascii_from_fp(png_structp png_ptr, png_charp ascii, png_size_t size,
                          */
                         if (d > 9)  /* cdigits == 0 */
                         {
-                           if (exp == (-1))
+                           if (png_exp == (-1))
                            {
                               /* Leading decimal point (plus zeros?), if
                                * we lose the decimal point here it must
@@ -1239,14 +1239,14 @@ png_ascii_from_fp(png_structp png_ptr, png_charp ascii, png_size_t size,
                               int ch = *--ascii;
 
                               if (ch == 46)
-                                 ++size, exp = 1;
+                                 ++size, png_exp = 1;
 
-                              /* Else lost a leading zero, so 'exp' is
+                              /* Else lost a leading zero, so 'png_exp' is
                                * still ok at (-1)
                                */
                            }
                            else
-                              ++exp;
+                              ++png_exp;
 
                            /* In all cases we output a '1' */
                            d = 1;
@@ -1269,23 +1269,23 @@ png_ascii_from_fp(png_structp png_ptr, png_charp ascii, png_size_t size,
 
                   while (czero > 0)
                   {
-                     /* exp == (-1) means we just output the decimal
-                      * place - after the DP don't adjust 'exp' any
+                     /* png_exp == (-1) means we just output the decimal
+                      * place - after the DP don't adjust 'png_exp' any
                       * more!
                       */
-                     if (exp != (-1))
+                     if (png_exp != (-1))
                      {
-                        if (exp == 0) *ascii++ = 46, --size;
+                        if (png_exp == 0) *ascii++ = 46, --size;
                         /* PLUS 1: TOTAL 4 */
-                        --exp;
+                        --png_exp;
                      }
                      *ascii++ = 48, --czero;
                   }
 
-                  if (exp != (-1))
+                  if (png_exp != (-1))
                   {
-                     if (exp == 0) *ascii++ = 46, --size; /* counted above */
-                     --exp;
+                     if (png_exp == 0) *ascii++ = 46, --size; /* counted above */
+                     --png_exp;
                   }
                   *ascii++ = (char)(48 + (int)d), ++cdigits;
                }
@@ -1296,12 +1296,12 @@ png_ascii_from_fp(png_structp png_ptr, png_charp ascii, png_size_t size,
 
             /* Check for an exponent, if we don't need one we are
              * done and just need to terminate the string.  At
-             * this point exp==(-1) is effectively if flag - it got
+             * this point png_exp==(-1) is effectively if flag - it got
              * to '-1' because of the decrement after outputing
              * the decimal point above (the exponent required is
              * *not* -1!)
              */
-            if (exp >= (-1) && exp <= 2)
+            if (png_exp >= (-1) && png_exp <= 2)
             {
                /* The following only happens if we didn't output the
                 * leading zeros above for negative exponent, so this
@@ -1310,7 +1310,7 @@ png_ascii_from_fp(png_structp png_ptr, png_charp ascii, png_size_t size,
                 * zeros were *not* output, so this doesn't increase
                 * the output count.
                 */
-               while (--exp >= 0) *ascii++ = 48;
+               while (--png_exp >= 0) *ascii++ = 48;
 
                *ascii = 0;
 
@@ -1329,18 +1329,18 @@ png_ascii_from_fp(png_structp png_ptr, png_charp ascii, png_size_t size,
             size -= cdigits;
 
             *ascii++ = 69, --size;    /* 'E': PLUS 1 TOTAL 2+precision*/
-            if (exp < 0)
+            if (png_exp < 0)
             {
                *ascii++ = 45, --size; /* '-': PLUS 1 TOTAL 3+precision */
-               exp = -exp;
+               png_exp = -png_exp;
             }
 
             cdigits = 0;
 
-            while (exp > 0)
+            while (png_exp > 0)
             {
-               exponent[cdigits++] = (char)(48 + exp % 10);
-               exp /= 10;
+               exponent[cdigits++] = (char)(48 + png_exp % 10);
+               png_exp /= 10;
             }
 
             /* Need another size check here for the exponent digits, so
@@ -1459,11 +1459,10 @@ png_fixed(png_structp png_ptr, double fp, png_const_charp text)
 {
    double r = floor(100000 * fp + .5);
 
-   if (r <= 2147483647. && r >= -2147483648.)
-      return (png_fixed_point)r;
+   if (r > 2147483647. || r < -2147483648.)
+      png_fixed_error(png_ptr, text);
 
-   png_fixed_error(png_ptr, text);
-   /*NOT REACHED*/
+   return (png_fixed_point)r;
 }
 #endif
 
@@ -1477,10 +1476,10 @@ png_fixed(png_structp png_ptr, double fp, png_const_charp text)
  */
 int
 png_muldiv(png_fixed_point_p res, png_fixed_point a, png_int_32 times,
-    png_int_32 div)
+    png_int_32 png_div)
 {
-   /* Return a * times / div, rounded. */
-   if (div != 0)
+   /* Return a * times / png_div, rounded. */
+   if (png_div != 0)
    {
       if (a == 0 || times == 0)
       {
@@ -1492,7 +1491,7 @@ png_muldiv(png_fixed_point_p res, png_fixed_point a, png_int_32 times,
 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
          double r = a;
          r *= times;
-         r /= div;
+         r /= png_div;
          r = floor(r+.5);
 
          /* A png_fixed_point is a 32 bit integer. */
@@ -1516,10 +1515,10 @@ png_muldiv(png_fixed_point_p res, png_fixed_point a, png_int_32 times,
          else
             T = times;
 
-         if (div < 0)
-            negative = !negative, D = -div;
+         if (png_div < 0)
+            negative = !negative, D = -png_div;
          else
-            D = div;
+            D = png_div;
 
          /* Following can't overflow because the arguments only
           * have 31 bits each, however the result may be 32 bits.
@@ -1596,11 +1595,11 @@ png_muldiv(png_fixed_point_p res, png_fixed_point a, png_int_32 times,
  */
 png_fixed_point
 png_muldiv_warn(png_structp png_ptr, png_fixed_point a, png_int_32 times,
-    png_int_32 div)
+    png_int_32 png_div)
 {
    png_fixed_point result;
 
-   if (png_muldiv(&result, a, times, div))
+   if (png_muldiv(&result, a, times, png_div))
       return result;
 
    png_warning(png_ptr, "fixed point overflow ignored");
@@ -1987,10 +1986,10 @@ png_exp(png_fixed_point x)
 }
 
 static png_byte
-png_exp8bit(png_fixed_point log)
+exp8bit(png_fixed_point log)
 {
    /* Get a 32 bit value: */
-   png_uint_32 x = png_exp(log);
+   png_uint_32 x = exp(log);
 
    /* Convert the 32 bit value to 0..255 by multiplying by 256-1, note that the
     * second, rounding, step can't overflow because of the first, subtraction,
@@ -2001,10 +2000,10 @@ png_exp8bit(png_fixed_point log)
 }
 
 static png_uint_16
-png_exp16bit(png_fixed_point log)
+exp16bit(png_fixed_point log)
 {
    /* Get a 32 bit value: */
-   png_uint_32 x = png_exp(log);
+   png_uint_32 x = exp(log);
 
    /* Convert the 32 bit value to 0..65535 by multiplying by 65536-1: */
    x -= x >> 16;
@@ -2013,19 +2012,19 @@ png_exp16bit(png_fixed_point log)
 #endif /* FLOATING_ARITHMETIC */
 
 png_byte
-png_gamma_8bit_correct(unsigned int value, png_fixed_point gamma)
+png_gamma_8bit_correct(unsigned int value, png_fixed_point png_gamma)
 {
    if (value > 0 && value < 255)
    {
 #     ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
-         double r = floor(255*pow(value/255.,gamma*.00001)+.5);
+         double r = floor(255*pow(value/255.,png_gamma*.00001)+.5);
          return (png_byte)r;
 #     else
          png_int_32 log = png_log8bit(value);
          png_fixed_point res;
 
-         if (png_muldiv(&res, gamma, log, PNG_FP_1))
-            return png_exp8bit(res);
+         if (png_muldiv(&res, png_gamma, log, PNG_FP_1))
+            return exp8bit(res);
 
          /* Overflow. */
          value = 0;
@@ -2036,19 +2035,19 @@ png_gamma_8bit_correct(unsigned int value, png_fixed_point gamma)
 }
 
 png_uint_16
-png_gamma_16bit_correct(unsigned int value, png_fixed_point gamma)
+png_gamma_16bit_correct(unsigned int value, png_fixed_point png_gamma)
 {
    if (value > 0 && value < 65535)
    {
 #     ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
-         double r = floor(65535*pow(value/65535.,gamma*.00001)+.5);
+         double r = floor(65535*pow(value/65535.,png_gamma*.00001)+.5);
          return (png_uint_16)r;
 #     else
          png_int_32 log = png_log16bit(value);
          png_fixed_point res;
 
-         if (png_muldiv(&res, gamma, log, PNG_FP_1))
-            return png_exp16bit(res);
+         if (png_muldiv(&res, png_gamma, log, PNG_FP_1))
+            return exp16bit(res);
 
          /* Overflow. */
          value = 0;
@@ -2065,23 +2064,23 @@ png_gamma_16bit_correct(unsigned int value, png_fixed_point gamma)
  */
 png_uint_16 /* PRIVATE */
 png_gamma_correct(png_structp png_ptr, unsigned int value,
-    png_fixed_point gamma)
+    png_fixed_point png_gamma)
 {
    if (png_ptr->bit_depth == 8)
-      return png_gamma_8bit_correct(value, gamma);
+      return png_gamma_8bit_correct(value, png_gamma);
 
    else
-      return png_gamma_16bit_correct(value, gamma);
+      return png_gamma_16bit_correct(value, png_gamma);
 }
 
 /* This is the shared test on whether a gamma value is 'significant' - whether
  * it is worth doing gamma correction.
  */
 int /* PRIVATE */
-png_gamma_significant(png_fixed_point gamma)
+png_gamma_significant(png_fixed_point png_gamma)
 {
-   return gamma < PNG_FP_1 - PNG_GAMMA_THRESHOLD_FIXED ||
-       gamma > PNG_FP_1 + PNG_GAMMA_THRESHOLD_FIXED;
+   return png_gamma < PNG_FP_1 - PNG_GAMMA_THRESHOLD_FIXED ||
+       png_gamma > PNG_FP_1 + PNG_GAMMA_THRESHOLD_FIXED;
 }
 
 /* Internal function to build a single 16 bit table - the table consists of
@@ -2094,7 +2093,7 @@ png_gamma_significant(png_fixed_point gamma)
  */
 static void
 png_build_16bit_table(png_structp png_ptr, png_uint_16pp *ptable,
-   PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma)
+   PNG_CONST unsigned int shift, PNG_CONST png_fixed_point png_gamma)
 {
    /* Various values derived from 'shift': */
    PNG_CONST unsigned int num = 1U << (8U - shift);
@@ -2113,7 +2112,7 @@ png_build_16bit_table(png_structp png_ptr, png_uint_16pp *ptable,
       /* The 'threshold' test is repeated here because it can arise for one of
        * the 16 bit tables even if the others don't hit it.
        */
-      if (png_gamma_significant(gamma))
+      if (png_gamma_significant(png_gamma))
       {
          /* The old code would overflow at the end and this would cause the
           * 'pow' function to return a result >1, resulting in an
@@ -2129,13 +2128,13 @@ png_build_16bit_table(png_structp png_ptr, png_uint_16pp *ptable,
             png_uint_32 ig = (j << (8-shift)) + i;
 #           ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
                /* Inline the 'max' scaling operation: */
-               double d = floor(65535*pow(ig/(double)max, gamma*.00001)+.5);
+               double d = floor(65535*pow(ig/(double)max, png_gamma*.00001)+.5);
                sub_table[j] = (png_uint_16)d;
 #           else
                if (shift)
                   ig = (ig * 65535U + max_by_2)/max;
 
-               sub_table[j] = png_gamma_16bit_correct(ig, gamma);
+               sub_table[j] = png_gamma_16bit_correct(ig, png_gamma);
 #           endif
          }
       }
@@ -2162,7 +2161,7 @@ png_build_16bit_table(png_structp png_ptr, png_uint_16pp *ptable,
  */
 static void
 png_build_16to8_table(png_structp png_ptr, png_uint_16pp *ptable,
-   PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma)
+   PNG_CONST unsigned int shift, PNG_CONST png_fixed_point png_gamma)
 {
    PNG_CONST unsigned int num = 1U << (8U - shift);
    PNG_CONST unsigned int max = (1U << (16U - shift))-1U;
@@ -2203,7 +2202,7 @@ png_build_16to8_table(png_structp png_ptr, png_uint_16pp *ptable,
       png_uint_16 out = (png_uint_16)(i * 257U); /* 16 bit output value */
 
       /* Find the boundary value in 16 bits: */
-      png_uint_32 bound = png_gamma_16bit_correct(out+128U, gamma);
+      png_uint_32 bound = png_gamma_16bit_correct(out+128U, png_gamma);
 
       /* Adjust (round) to (16-shift) bits: */
       bound = (bound * max + 32768U)/65535U + 1U;
@@ -2229,13 +2228,13 @@ png_build_16to8_table(png_structp png_ptr, png_uint_16pp *ptable,
  */
 static void
 png_build_8bit_table(png_structp png_ptr, png_bytepp ptable,
-   PNG_CONST png_fixed_point gamma)
+   PNG_CONST png_fixed_point png_gamma)
 {
    unsigned int i;
    png_bytep table = *ptable = (png_bytep)png_malloc(png_ptr, 256);
 
-   if (png_gamma_significant(gamma)) for (i=0; i<256; i++)
-      table[i] = png_gamma_8bit_correct(i, gamma);
+   if (png_gamma_significant(png_gamma)) for (i=0; i<256; i++)
+      table[i] = png_gamma_8bit_correct(i, png_gamma);
 
    else for (i=0; i<256; ++i)
       table[i] = (png_byte)i;