From e03dd5bd6432354587bf393705b28a7be9e8597c Mon Sep 17 00:00:00 2001 From: Glenn Randers-Pehrson Date: Sun, 16 Jan 2011 00:38:30 -0600 Subject: [PATCH] [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 | 4 ++ CHANGES | 4 ++ png.c | 167 +++++++++++++++++++++++++++---------------------------- 3 files changed, 91 insertions(+), 84 deletions(-) diff --git a/ANNOUNCE b/ANNOUNCE index 488c4ed2b..289e8089f 100644 --- a/ANNOUNCE +++ b/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 diff --git a/CHANGES b/CHANGES index b49287fc8..d7cc99ff1 100644 --- a/CHANGES +++ b/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 diff --git a/png.c b/png.c index a71a9fd5c..65d4b8075 100644 --- a/png.c +++ b/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;