Trash shroud store. - fetchmail - [fork] set imap idle timeout to 600s, some servers don't follow rfc recommendations

diff options

author	Matthias Andree <matthias.andree@gmx.de>	2006-11-27 02:09:01 +0000
committer	Matthias Andree <matthias.andree@gmx.de>	2006-11-27 02:09:01 +0000
commit	c5cf37a81f295113478aa9271cef6f43bb9e7f15 (patch)
tree	7c4dba9428b7b782b31550c52cefa0ec1790b684 /pop3.c
parent	0e30e6abbd90d7e6cb43fbebad0753e88ae75bc8 (diff)
download	fetchmail-c5cf37a81f295113478aa9271cef6f43bb9e7f15.tar.gz fetchmail-c5cf37a81f295113478aa9271cef6f43bb9e7f15.tar.bz2 fetchmail-c5cf37a81f295113478aa9271cef6f43bb9e7f15.zip

Trash shroud store.

svn path=/branches/BRANCH_6-3/; revision=4965

Diffstat (limited to 'pop3.c')

0 files changed, 0 insertions, 0 deletions

/************************************************************************* * * $Id: trionan.c,v 1.33 2005/05/29 11:57:25 breese Exp $ * * Copyright (C) 2001 Bjorn Reese <breese@users.sourceforge.net> * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND * CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER. * ************************************************************************ * * Functions to handle special quantities in floating-point numbers * (that is, NaNs and infinity). They provide the capability to detect * and fabricate special quantities. * * Although written to be as portable as possible, it can never be * guaranteed to work on all platforms, as not all hardware supports * special quantities. * * The approach used here (approximately) is to: * * 1. Use C99 functionality when available. * 2. Use IEEE 754 bit-patterns if possible. * 3. Use platform-specific techniques. * ************************************************************************/ /************************************************************************* * Include files */ #include "triodef.h" #include "trionan.h" #include <math.h> #include <string.h> #include <limits.h> #if !defined(TRIO_PLATFORM_SYMBIAN) # include <float.h> #endif #if defined(TRIO_PLATFORM_UNIX) # include <signal.h> #endif #if defined(TRIO_COMPILER_DECC) # include <fp_class.h> #endif #include <assert.h> #if defined(TRIO_DOCUMENTATION) # include "doc/doc_nan.h" #endif /** @addtogroup SpecialQuantities @{ */ /************************************************************************* * Definitions */ #if !defined(TRIO_PUBLIC_NAN) # define TRIO_PUBLIC_NAN TRIO_PUBLIC #endif #if !defined(TRIO_PRIVATE_NAN) # define TRIO_PRIVATE_NAN TRIO_PRIVATE #endif #define TRIO_TRUE (1 == 1) #define TRIO_FALSE (0 == 1) /* * We must enable IEEE floating-point on Alpha */ #if defined(__alpha) && !defined(_IEEE_FP) # if defined(TRIO_COMPILER_DECC) # if defined(TRIO_PLATFORM_VMS) # error "Must be compiled with option /IEEE_MODE=UNDERFLOW_TO_ZERO/FLOAT=IEEE" # else # if !defined(_CFE) # error "Must be compiled with option -ieee" # endif # endif # else # if defined(TRIO_COMPILER_GCC) # error "Must be compiled with option -mieee" # endif # endif #endif /* __alpha && ! _IEEE_FP */ /* * In ANSI/IEEE 754-1985 64-bits double format numbers have the * following properties (amoungst others) * * o FLT_RADIX == 2: binary encoding * o DBL_MAX_EXP == 1024: 11 bits exponent, where one bit is used * to indicate special numbers (e.g. NaN and Infinity), so the * maximum exponent is 10 bits wide (2^10 == 1024). * o DBL_MANT_DIG == 53: The mantissa is 52 bits wide, but because * numbers are normalized the initial binary 1 is represented * implicitly (the so-called "hidden bit"), which leaves us with * the ability to represent 53 bits wide mantissa. */ #if defined(__STDC_IEC_559__) # define TRIO_IEEE_754 #else # if (FLT_RADIX - 0 == 2) && (DBL_MAX_EXP - 0 == 1024) && (DBL_MANT_DIG - 0 == 53) # define TRIO_IEEE_754 # endif #endif /* * Determine which fpclassify_and_sign() function to use. */ #if defined(TRIO_FUNC_FPCLASSIFY_AND_SIGNBIT) # if defined(PREDEF_STANDARD_C99) && defined(fpclassify) # define TRIO_FUNC_C99_FPCLASSIFY_AND_SIGNBIT # else # if defined(TRIO_COMPILER_DECC) # define TRIO_FUNC_DECC_FPCLASSIFY_AND_SIGNBIT # else # if defined(TRIO_COMPILER_VISUALC) || defined(TRIO_COMPILER_BORLAND) # define TRIO_FUNC_MS_FPCLASSIFY_AND_SIGNBIT # else # if defined(TRIO_COMPILER_HP) && defined(FP_PLUS_NORM) # define TRIO_FUNC_HP_FPCLASSIFY_AND_SIGNBIT # else # if defined(TRIO_COMPILER_XLC) && defined(FP_PLUS_NORM) # define TRIO_FUNC_XLC_FPCLASSIFY_AND_SIGNBIT # else # define TRIO_FUNC_INTERNAL_FPCLASSIFY_AND_SIGNBIT # endif # endif # endif # endif # endif #endif /* * Determine how to generate negative zero. */ #if defined(TRIO_FUNC_NZERO) # if defined(TRIO_IEEE_754) # define TRIO_NZERO_IEEE_754 # else # define TRIO_NZERO_FALLBACK # endif #endif /* * Determine how to generate positive infinity. */ #if defined(TRIO_FUNC_PINF) # if defined(INFINITY) && defined(__STDC_IEC_559__) # define TRIO_PINF_C99_MACRO # else # if defined(TRIO_IEEE_754) # define TRIO_PINF_IEEE_754 # else # define TRIO_PINF_FALLBACK # endif # endif #endif /* * Determine how to generate NaN. */ #if defined(TRIO_FUNC_NAN) # if defined(PREDEF_STANDARD_C99) && !defined(TRIO_COMPILER_DECC) # define TRIO_NAN_C99_FUNCTION # else # if defined(NAN) && defined(__STDC_IEC_559__) # define TRIO_NAN_C99_MACRO # else # if defined(TRIO_IEEE_754) # define TRIO_NAN_IEEE_754 # else # define TRIO_NAN_FALLBACK # endif # endif # endif #endif /* * Resolve internal dependencies. */ #if defined(TRIO_FUNC_INTERNAL_FPCLASSIFY_AND_SIGNBIT) # define TRIO_FUNC_INTERNAL_ISNAN # define TRIO_FUNC_INTERNAL_ISINF # if defined(TRIO_IEEE_754) # define TRIO_FUNC_INTERNAL_IS_SPECIAL_QUANTITY # define TRIO_FUNC_INTERNAL_IS_NEGATIVE # endif #endif #if defined(TRIO_NZERO_IEEE_754) \ || defined(TRIO_PINF_IEEE_754) \ || defined(TRIO_NAN_IEEE_754) # define TRIO_FUNC_INTERNAL_MAKE_DOUBLE #endif #if defined(TRIO_FUNC_INTERNAL_ISNAN) # if defined(PREDEF_STANDARD_XPG3) # define TRIO_INTERNAL_ISNAN_XPG3 # else # if defined(TRIO_IEEE_754) # define TRIO_INTERNAL_ISNAN_IEEE_754 # else # define TRIO_INTERNAL_ISNAN_FALLBACK # endif # endif #endif #if defined(TRIO_FUNC_INTERNAL_ISINF) # if defined(TRIO_IEEE_754) # define TRIO_INTERNAL_ISINF_IEEE_754 # else # define TRIO_INTERNAL_ISINF_FALLBACK # endif #endif /************************************************************************* * Constants */ #if !defined(TRIO_EMBED_NAN) static TRIO_CONST char rcsid[] = "@(#)$Id: trionan.c,v 1.33 2005/05/29 11:57:25 breese Exp $"; #endif #if defined(TRIO_FUNC_INTERNAL_MAKE_DOUBLE) \ || defined(TRIO_FUNC_INTERNAL_IS_SPECIAL_QUANTITY) \ || defined(TRIO_FUNC_INTERNAL_IS_NEGATIVE) /* * Endian-agnostic indexing macro. * * The value of internalEndianMagic, when converted into a 64-bit * integer, becomes 0x0706050403020100 (we could have used a 64-bit * integer value instead of a double, but not all platforms supports * that type). The value is automatically encoded with the correct * endianess by the compiler, which means that we can support any * kind of endianess. The individual bytes are then used as an index * for the IEEE 754 bit-patterns and masks. */ #define TRIO_DOUBLE_INDEX(x) (((unsigned char *)&internalEndianMagic)[7-(x)]) static TRIO_CONST double internalEndianMagic = 7.949928895127363e-275; #endif #if defined(TRIO_FUNC_INTERNAL_IS_SPECIAL_QUANTITY) /* Mask for the exponent */ static TRIO_CONST unsigned char ieee_754_exponent_mask[] = { 0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; /* Mask for the mantissa */ static TRIO_CONST unsigned char ieee_754_mantissa_mask[] = { 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; #endif #if defined(TRIO_FUNC_INTERNAL_IS_NEGATIVE) /* Mask for the sign bit */ static TRIO_CONST unsigned char ieee_754_sign_mask[] = { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; #endif #if defined(TRIO_NZERO_IEEE_754) /* Bit-pattern for negative zero */ static TRIO_CONST unsigned char ieee_754_negzero_array[] = { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; #endif #if defined(TRIO_PINF_IEEE_754) /* Bit-pattern for infinity */ static TRIO_CONST unsigned char ieee_754_infinity_array[] = { 0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; #endif #if defined(TRIO_NAN_IEEE_754) /* Bit-pattern for quiet NaN */ static TRIO_CONST unsigned char ieee_754_qnan_array[] = { 0x7F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; #endif /************************************************************************* * Internal functions */ /* * internal_make_double */ #if defined(TRIO_FUNC_INTERNAL_MAKE_DOUBLE) TRIO_PRIVATE_NAN double internal_make_double TRIO_ARGS1((values), TRIO_CONST unsigned char *values) { TRIO_VOLATILE double result; int i; for (i = 0; i < (int)sizeof(double); i++) { ((TRIO_VOLATILE unsigned char *)&result)[TRIO_DOUBLE_INDEX(i)] = values[i]; } return result; } #endif /* * internal_is_special_quantity */ #if defined(TRIO_FUNC_INTERNAL_IS_SPECIAL_QUANTITY) TRIO_PRIVATE_NAN int internal_is_special_quantity TRIO_ARGS2((number, has_mantissa), double number, int *has_mantissa) { unsigned int i; unsigned char current; int is_special_quantity = TRIO_TRUE; *has_mantissa = 0; for (i = 0; i < (unsigned int)sizeof(double); i++) { current = ((unsigned char *)&number)[TRIO_DOUBLE_INDEX(i)]; is_special_quantity &= ((current & ieee_754_exponent_mask[i]) == ieee_754_exponent_mask[i]); *has_mantissa |= (current & ieee_754_mantissa_mask[i]); } return is_special_quantity; } #endif /* * internal_is_negative */ #if defined(TRIO_FUNC_INTERNAL_IS_NEGATIVE) TRIO_PRIVATE_NAN int internal_is_negative TRIO_ARGS1((number), double number) { unsigned int i; int is_negative = TRIO_FALSE; for (i = 0; i < (unsigned int)sizeof(double); i++) { is_negative |= (((unsigned char *)&number)[TRIO_DOUBLE_INDEX(i)] & ieee_754_sign_mask[i]); } return is_negative; } #endif #if defined(TRIO_FUNC_C99_FPCLASSIFY_AND_SIGNBIT) TRIO_PRIVATE_NAN TRIO_INLINE int c99_fpclassify_and_signbit TRIO_ARGS2((number, is_negative), double number, int *is_negative) { *is_negative = signbit(number); switch (fpclassify(number)) { case FP_NAN: return TRIO_FP_NAN; case FP_INFINITE: return TRIO_FP_INFINITE; case FP_SUBNORMAL: return TRIO_FP_SUBNORMAL; case FP_ZERO: return TRIO_FP_ZERO; default: return TRIO_FP_NORMAL; } } #endif /* TRIO_FUNC_C99_FPCLASSIFY_AND_SIGNBIT */ #if defined(TRIO_FUNC_DECC_FPCLASSIFY_AND_SIGNBIT) TRIO_PRIVATE_NAN TRIO_INLINE int decc_fpclassify_and_signbit TRIO_ARGS2((number, is_negative), double number, int *is_negative) { switch (fp_class(number)) { case FP_QNAN: case FP_SNAN: *is_negative = TRIO_FALSE; /* NaN has no sign */ return TRIO_FP_NAN; case FP_POS_INF: *is_negative = TRIO_FALSE; return TRIO_FP_INFINITE; case FP_NEG_INF: *is_negative = TRIO_TRUE; return TRIO_FP_INFINITE; case FP_POS_DENORM: *is_negative = TRIO_FALSE; return TRIO_FP_SUBNORMAL; case FP_NEG_DENORM: *is_negative = TRIO_TRUE; return TRIO_FP_SUBNORMAL; case FP_POS_ZERO: *is_negative = TRIO_FALSE; return TRIO_FP_ZERO; case FP_NEG_ZERO: *is_negative = TRIO_TRUE; return TRIO_FP_ZERO; case FP_POS_NORM: *is_negative = TRIO_FALSE; return TRIO_FP_NORMAL; case FP_NEG_NORM: *is_negative = TRIO_TRUE; return TRIO_FP_NORMAL; default: *is_negative = (number < 0.0); return TRIO_FP_NORMAL; } } #endif /* TRIO_FUNC_DECC_FPCLASSIFY_AND_SIGNBIT */ #if defined(TRIO_FUNC_MS_FPCLASSIFY_AND_SIGNBIT) TRIO_PRIVATE_NAN int ms_fpclassify_and_signbit TRIO_ARGS2((number, is_negative), double number, int *is_negative) { int result; # if defined(TRIO_COMPILER_BORLAND) /* * The floating-point precision may be changed by the Borland _fpclass() * function, so we have to save and restore the floating-point control mask. */ unsigned int mask; /* Remember the old mask */ mask = _control87(0, 0); # endif switch (_fpclass(number)) { case _FPCLASS_QNAN: case _FPCLASS_SNAN: *is_negative = TRIO_FALSE; /* NaN has no sign */ result = TRIO_FP_NAN; break; case _FPCLASS_PINF: *is_negative = TRIO_FALSE; result = TRIO_FP_INFINITE; break; case _FPCLASS_NINF: *is_negative = TRIO_TRUE; result = TRIO_FP_INFINITE; break; case _FPCLASS_PD: *is_negative = TRIO_FALSE; result = TRIO_FP_SUBNORMAL; break; case _FPCLASS_ND: *is_negative = TRIO_TRUE; result = TRIO_FP_SUBNORMAL; break; case _FPCLASS_PZ: *is_negative = TRIO_FALSE; result = TRIO_FP_ZERO; break; case _FPCLASS_NZ: *is_negative = TRIO_TRUE; result = TRIO_FP_ZERO; break; case _FPCLASS_PN: *is_negative = TRIO_FALSE; result = TRIO_FP_NORMAL; break; case _FPCLASS_NN: *is_negative = TRIO_TRUE; result = TRIO_FP_NORMAL; break; default: *is_negative = (number < 0.0); result = TRIO_FP_NORMAL; break; } # if defined(TRIO_COMPILER_BORLAND) /* Restore the old precision */ (void)_control87(mask, MCW_PC); # endif return result; } #endif /* TRIO_FUNC_MS_FPCLASSIFY_AND_SIGNBIT */ #if defined(TRIO_FUNC_HP_FPCLASSIFY_AND_SIGNBIT) TRIO_PRIVATE_NAN TRIO_INLINE int hp_fpclassify_and_signbit TRIO_ARGS2((number, is_negative), double number, int *is_negative) { /* * HP-UX 9.x and 10.x have an fpclassify() function, that is different * from the C99 fpclassify() macro supported on HP-UX 11.x. */ switch (fpclassify(number)) { case FP_QNAN: case FP_SNAN: *is_negative = TRIO_FALSE; /* NaN has no sign */ return TRIO_FP_NAN; case FP_PLUS_INF: *is_negative = TRIO_FALSE; return TRIO_FP_INFINITE; case FP_MINUS_INF: *is_negative = TRIO_TRUE; return TRIO_FP_INFINITE; case FP_PLUS_DENORM: *is_negative = TRIO_FALSE; return TRIO_FP_SUBNORMAL; case FP_MINUS_DENORM: *is_negative = TRIO_TRUE; return TRIO_FP_SUBNORMAL; case FP_PLUS_ZERO: *is_negative = TRIO_FALSE; return TRIO_FP_ZERO; case FP_MINUS_ZERO: *is_negative = TRIO_TRUE; return TRIO_FP_ZERO; case FP_PLUS_NORM: *is_negative = TRIO_FALSE; return TRIO_FP_NORMAL; case FP_MINUS_NORM: *is_negative = TRIO_TRUE; return TRIO_FP_NORMAL; default: *is_negative = (number < 0.0); return TRIO_FP_NORMAL; } } #endif /* TRIO_FUNC_HP_FPCLASSIFY_AND_SIGNBIT */ #if defined(TRIO_FUNC_XLC_FPCLASSIFY_AND_SIGNBIT) TRIO_PRIVATE_NAN TRIO_INLINE int xlc_fpclassify_and_signbit TRIO_ARGS2((number, is_negative), double number, int *is_negative) { /* * AIX has class() for C, and _class() for C++ */ # if defined(__cplusplus) # define AIX_CLASS(n) _class(n) # else # define AIX_CLASS(n) class(n) # endif switch (AIX_CLASS(number)) { case FP_QNAN: case FP_SNAN: *is_negative = TRIO_FALSE; /* NaN has no sign */ return TRIO_FP_NAN; case FP_PLUS_INF: *is_negative = TRIO_FALSE; return TRIO_FP_INFINITE; case FP_MINUS_INF: *is_negative = TRIO_TRUE; return TRIO_FP_INFINITE; case FP_PLUS_DENORM: *is_negative = TRIO_FALSE; return TRIO_FP_SUBNORMAL; case FP_MINUS_DENORM: *is_negative = TRIO_TRUE; return TRIO_FP_SUBNORMAL; case FP_PLUS_ZERO: *is_negative = TRIO_FALSE; return TRIO_FP_ZERO; case FP_MINUS_ZERO: *is_negative = TRIO_TRUE; return TRIO_FP_ZERO; case FP_PLUS_NORM: *is_negative = TRIO_FALSE; return TRIO_FP_NORMAL; case FP_MINUS_NORM: *is_negative = TRIO_TRUE; return TRIO_FP_NORMAL; default: *is_negative = (number < 0.0); return TRIO_FP_NORMAL; } } #endif /* TRIO_FUNC_XLC_FPCLASSIFY_AND_SIGNBIT */ #if defined(TRIO_FUNC_INTERNAL_ISNAN) TRIO_PRIVATE_NAN TRIO_INLINE int internal_isnan TRIO_ARGS1((number), double number) { # if defined(TRIO_INTERNAL_ISNAN_XPG3) || defined(TRIO_PLATFORM_SYMBIAN) /* * XPG3 defines isnan() as a function. */ return isnan(number); # endif # if defined(TRIO_INTERNAL_ISNAN_IEEE_754) /* * Examine IEEE 754 bit-pattern. A NaN must have a special exponent * pattern, and a non-empty mantissa. */ int has_mantissa; int is_special_quantity; is_special_quantity = internal_is_special_quantity(number, &has_mantissa); return (is_special_quantity && has_mantissa); # endif # if defined(TRIO_INTERNAL_ISNAN_FALLBACK) /* * Fallback solution */ int status; double integral, fraction; # if defined(TRIO_PLATFORM_UNIX) void (*signal_handler)(int) = signal(SIGFPE, SIG_IGN); # endif status = (/* * NaN is the only number which does not compare to itself */ ((TRIO_VOLATILE double)number != (TRIO_VOLATILE double)number) || /* * Fallback solution if NaN compares to NaN */ ((number != 0.0) && (fraction = modf(number, &integral), integral == fraction))); # if defined(TRIO_PLATFORM_UNIX) signal(SIGFPE, signal_handler); # endif return status; # endif } #endif /* TRIO_FUNC_INTERNAL_ISNAN */ #if defined(TRIO_FUNC_INTERNAL_ISINF) TRIO_PRIVATE_NAN TRIO_INLINE int internal_isinf TRIO_ARGS1((number), double number) { # if defined(TRIO_PLATFORM_SYMBIAN) return isinf(number); # endif # if defined(TRIO_INTERNAL_ISINF_IEEE_754) /* * Examine IEEE 754 bit-pattern. Infinity must have a special exponent * pattern, and an empty mantissa. */ int has_mantissa; int is_special_quantity; is_special_quantity = internal_is_special_quantity(number, &has_mantissa); return (is_special_quantity && !has_mantissa) ? ((number < 0.0) ? -1 : 1) : 0; # endif # if defined(TRIO_INTERNAL_ISINF_FALLBACK) /* * Fallback solution. */ int status; # if defined(TRIO_PLATFORM_UNIX) void (*signal_handler)(int) = signal(SIGFPE, SIG_IGN); # endif double infinity = trio_pinf(); status = ((number == infinity) ? 1 : ((number == -infinity) ? -1 : 0)); # if defined(TRIO_PLATFORM_UNIX) signal(SIGFPE, signal_handler); # endif return status; # endif } #endif /* TRIO_FUNC_INTERNAL_ISINF */ /************************************************************************* * Public functions */ #if defined(TRIO_FUNC_FPCLASSIFY_AND_SIGNBIT) TRIO_PUBLIC_NAN int trio_fpclassify_and_signbit TRIO_ARGS2((number, is_negative), double number, int *is_negative) { /* The TRIO_FUNC_xxx_FPCLASSIFY_AND_SIGNBIT macros are mutually exclusive */ #if defined(TRIO_FUNC_C99_FPCLASSIFY_AND_SIGNBIT) return c99_fpclassify_and_signbit(number, is_negative); #endif #if defined(TRIO_FUNC_DECC_FPCLASSIFY_AND_SIGNBIT) return decc_fpclassify_and_signbit(number, is_negative); #endif #if defined(TRIO_FUNC_MS_FPCLASSIFY_AND_SIGNBIT) return ms_fpclassify_and_signbit(number, is_negative); #endif #if defined(TRIO_FUNC_HP_FPCLASSIFY_AND_SIGNBIT) return hp_fpclassify_and_signbit(number, is_negative); #endif #if defined(TRIO_FUNC_XLC_FPCLASSIFY_AND_SIGNBIT) return xlc_fpclassify_and_signbit(number, is_negative); #endif #if defined(TRIO_FUNC_INTERNAL_FPCLASSIFY_AND_SIGNBIT) /* * Fallback solution. */ int rc; if (number == 0.0) { /* * In IEEE 754 the sign of zero is ignored in comparisons, so we * have to handle this as a special case by examining the sign bit * directly. */ # if defined(TRIO_IEEE_754) *is_negative = internal_is_negative(number); # else *is_negative = TRIO_FALSE; /* FIXME */ # endif return TRIO_FP_ZERO; } if (internal_isnan(number)) { *is_negative = TRIO_FALSE; return TRIO_FP_NAN; } rc = internal_isinf(number); if (rc != 0) { *is_negative = (rc == -1); return TRIO_FP_INFINITE; } if ((number > 0.0) && (number < DBL_MIN)) { *is_negative = TRIO_FALSE; return TRIO_FP_SUBNORMAL; } if ((number < 0.0) && (number > -DBL_MIN)) { *is_negative = TRIO_TRUE; return TRIO_FP_SUBNORMAL; } *is_negative = (number < 0.0); return TRIO_FP_NORMAL; #endif } #endif /** Check for NaN. @param number An arbitrary floating-point number. @return Boolean value indicating whether or not the number is a NaN. */ #if defined(TRIO_FUNC_ISNAN) TRIO_PUBLIC_NAN int trio_isnan TRIO_ARGS1((number), double number) { int dummy; return (trio_fpclassify_and_signbit(number, &dummy) == TRIO_FP_NAN); } #endif /** Check for infinity. @param number An arbitrary floating-point number. @return 1 if positive infinity, -1 if negative infinity, 0 otherwise. */ #if defined(TRIO_FUNC_ISINF) TRIO_PUBLIC_NAN int trio_isinf TRIO_ARGS1((number), double number) { int is_negative; if (trio_fpclassify_and_signbit(number, &is_negative) == TRIO_FP_INFINITE) { return (is_negative) ? -1 : 1; } else { return 0; } } #endif /** Check for finity. @param number An arbitrary floating-point number. @return Boolean value indicating whether or not the number is a finite. */ #if defined(TRIO_FUNC_ISFINITE) TRIO_PUBLIC_NAN int trio_isfinite TRIO_ARGS1((number), double number) { int dummy; switch (trio_fpclassify_and_signbit(number, &dummy)) { case TRIO_FP_INFINITE: case TRIO_FP_NAN: return 0; default: return 1; } } #endif /** Examine the sign of a number. @param number An arbitrary floating-point number. @return Boolean value indicating whether or not the number has the sign bit set (i.e. is negative). */ #if defined(TRIO_FUNC_SIGNBIT) TRIO_PUBLIC_NAN int trio_signbit TRIO_ARGS1((number), double number) { int is_negative; (void)trio_fpclassify_and_signbit(number, &is_negative); return is_negative; } #endif /** Examine the class of a number. @param number An arbitrary floating-point number. @return Enumerable value indicating the class of @p number */ #if defined(TRIO_FUNC_FPCLASSIFY) TRIO_PUBLIC_NAN int trio_fpclassify TRIO_ARGS1((number), double number) { int dummy; return trio_fpclassify_and_signbit(number, &dummy); } #endif /** Generate negative zero. @return Floating-point representation of negative zero. */ #if defined(TRIO_FUNC_NZERO) TRIO_PUBLIC_NAN double trio_nzero(TRIO_NOARGS) { # if defined(TRIO_NZERO_IEEE_754) return internal_make_double(ieee_754_negzero_array); # endif # if defined(TRIO_NZERO_FALLBACK) TRIO_VOLATILE double zero = 0.0; return -zero; # endif } #endif /** Generate positive infinity. @return Floating-point representation of positive infinity. */ #if defined(TRIO_FUNC_PINF) TRIO_PUBLIC_NAN double trio_pinf(TRIO_NOARGS) { /* Cache the result */ static double pinf_value = 0.0; if (pinf_value == 0.0) { # if defined(TRIO_PINF_C99_MACRO) pinf_value = (double)INFINITY; # endif # if defined(TRIO_PINF_IEEE_754) pinf_value = internal_make_double(ieee_754_infinity_array); # endif # if defined(TRIO_PINF_FALLBACK) /* * If HUGE_VAL is different from DBL_MAX, then HUGE_VAL is used * as infinity. Otherwise we have to resort to an overflow * operation to generate infinity. */ # if defined(TRIO_PLATFORM_UNIX) void (*signal_handler)(int) = signal(SIGFPE, SIG_IGN); # endif pinf_value = HUGE_VAL; if (HUGE_VAL == DBL_MAX) { /* Force overflow */ pinf_value += HUGE_VAL; } # if defined(TRIO_PLATFORM_UNIX) signal(SIGFPE, signal_handler); # endif # endif } return pinf_value; } #endif /** Generate negative infinity. @return Floating-point value of negative infinity. */ #if defined(TRIO_FUNC_NINF) TRIO_PUBLIC_NAN double trio_ninf(TRIO_NOARGS) { static double ninf_value = 0.0; if (ninf_value == 0.0) { /* * Negative infinity is calculated by negating positive infinity, * which can be done because it is legal to do calculations on * infinity (for example, 1 / infinity == 0). */ ninf_value = -trio_pinf(); } return ninf_value; } #endif /** Generate NaN. @return Floating-point representation of NaN. */ #if defined(TRIO_FUNC_NAN) TRIO_PUBLIC_NAN double trio_nan(TRIO_NOARGS) { /* Cache the result */ static double nan_value = 0.0; if (nan_value == 0.0) { # if defined(TRIO_NAN_C99_FUNCTION) || defined(TRIO_PLATFORM_SYMBIAN) nan_value = nan(""); # endif # if defined(TRIO_NAN_C99_MACRO) nan_value = (double)NAN; # endif # if defined(TRIO_NAN_IEEE_754) nan_value = internal_make_double(ieee_754_qnan_array); # endif # if defined(TRIO_NAN_FALLBACK) /* * There are several ways to generate NaN. The one used here is * to divide infinity by infinity. I would have preferred to add * negative infinity to positive infinity, but that yields wrong * result (infinity) on FreeBSD. * * This may fail if the hardware does not support NaN, or if * the Invalid Operation floating-point exception is unmasked. */ # if defined(TRIO_PLATFORM_UNIX) void (*signal_handler)(int) = signal(SIGFPE, SIG_IGN); # endif nan_value = trio_pinf() / trio_pinf(); # if defined(TRIO_PLATFORM_UNIX) signal(SIGFPE, signal_handler); # endif # endif } return nan_value; } #endif /** @} SpecialQuantities */ /************************************************************************* * For test purposes. * * Add the following compiler option to include this test code. * * Unix : -DSTANDALONE * VMS : /DEFINE=(STANDALONE) */ #if defined(STANDALONE) # include <stdio.h> static TRIO_CONST char * getClassification TRIO_ARGS1((type), int type) { switch (type) { case TRIO_FP_INFINITE: return "FP_INFINITE"; case TRIO_FP_NAN: return "FP_NAN"; case TRIO_FP_NORMAL: return "FP_NORMAL"; case TRIO_FP_SUBNORMAL: return "FP_SUBNORMAL"; case TRIO_FP_ZERO: return "FP_ZERO"; default: return "FP_UNKNOWN"; } } static void print_class TRIO_ARGS2((prefix, number), TRIO_CONST char *prefix, double number) { printf("%-6s: %s %-15s %g\n", prefix, trio_signbit(number) ? "-" : "+", getClassification(trio_fpclassify(number)), number); } int main(TRIO_NOARGS) { double my_nan; double my_pinf; double my_ninf; # if defined(TRIO_PLATFORM_UNIX) void (*signal_handler) TRIO_PROTO((int)); # endif my_nan = trio_nan(); my_pinf = trio_pinf(); my_ninf = trio_ninf(); print_class("Nan", my_nan); print_class("PInf", my_pinf); print_class("NInf", my_ninf); print_class("PZero", 0.0); print_class("NZero", -0.0); print_class("PNorm", 1.0); print_class("NNorm", -1.0); print_class("PSub", 1.01e-307 - 1.00e-307); print_class("NSub", 1.00e-307 - 1.01e-307); printf("NaN : %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d, %2d)\n", my_nan, ((unsigned char *)&my_nan)[0], ((unsigned char *)&my_nan)[1], ((unsigned char *)&my_nan)[2], ((unsigned char *)&my_nan)[3], ((unsigned char *)&my_nan)[4], ((unsigned char *)&my_nan)[5], ((unsigned char *)&my_nan)[6], ((unsigned char *)&my_nan)[7], trio_isnan(my_nan), trio_isinf(my_nan), trio_isfinite(my_nan)); printf("PInf: %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d, %2d)\n", my_pinf, ((unsigned char *)&my_pinf)[0], ((unsigned char *)&my_pinf)[1], ((unsigned char *)&my_pinf)[2], ((unsigned char *)&my_pinf)[3], ((unsigned char *)&my_pinf)[4], ((unsigned char *)&my_pinf)[5], ((unsigned char *)&my_pinf)[6], ((unsigned char *)&my_pinf)[7], trio_isnan(my_pinf), trio_isinf(my_pinf), trio_isfinite(my_pinf)); printf("NInf: %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d, %2d)\n", my_ninf, ((unsigned char *)&my_ninf)[0], ((unsigned char *)&my_ninf)[1], ((unsigned char *)&my_ninf)[2], ((unsigned char *)&my_ninf)[3], ((unsigned char *)&my_ninf)[4], ((unsigned char *)&my_ninf)[5], ((unsigned char *)&my_ninf)[6], ((unsigned char *)&my_ninf)[7], trio_isnan(my_ninf), trio_isinf(my_ninf), trio_isfinite(my_ninf)); # if defined(TRIO_PLATFORM_UNIX) signal_handler = signal(SIGFPE, SIG_IGN); # endif my_pinf = DBL_MAX + DBL_MAX; my_ninf = -my_pinf; my_nan = my_pinf / my_pinf; # if defined(TRIO_PLATFORM_UNIX) signal(SIGFPE, signal_handler); # endif printf("NaN : %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d, %2d)\n", my_nan, ((unsigned char *)&my_nan)[0], ((unsigned char *)&my_nan)[1], ((unsigned char *)&my_nan)[2], ((unsigned char *)&my_nan)[3], ((unsigned char *)&my_nan)[4], ((unsigned char *)&my_nan)[5], ((unsigned char *)&my_nan)[6], ((unsigned char *)&my_nan)[7], trio_isnan(my_nan), trio_isinf(my_nan), trio_isfinite(my_nan)); printf("PInf: %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d, %2d)\n", my_pinf, ((unsigned char *)&my_pinf)[0], ((unsigned char *)&my_pinf)[1], ((unsigned char *)&my_pinf)[2], ((unsigned char *)&my_pinf)[3], ((unsigned char *)&my_pinf)[4], ((unsigned char *)&my_pinf)[5], ((unsigned char *)&my_pinf)[6], ((unsigned char *)&my_pinf)[7], trio_isnan(my_pinf), trio_isinf(my_pinf), trio_isfinite(my_pinf)); printf("NInf: %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d, %2d)\n", my_ninf, ((unsigned char *)&my_ninf)[0], ((unsigned char *)&my_ninf)[1], ((unsigned char *)&my_ninf)[2], ((unsigned char *)&my_ninf)[3], ((unsigned char *)&my_ninf)[4], ((unsigned char *)&my_ninf)[5], ((unsigned char *)&my_ninf)[6], ((unsigned char *)&my_ninf)[7], trio_isnan(my_ninf), trio_isinf(my_ninf), trio_isfinite(my_ninf)); return 0; } #endif


context:
space:
mode: