From d75a0a62b12c35ee85f786d5f8d155ab39909411 Mon Sep 17 00:00:00 2001 From: Ulrich Drepper Date: Sat, 7 Jan 2012 11:19:05 -0500 Subject: Remove IA-64 support --- sysdeps/ia64/fpu/libm_error.c | 4295 ----------------------------------------- 1 file changed, 4295 deletions(-) delete mode 100644 sysdeps/ia64/fpu/libm_error.c (limited to 'sysdeps/ia64/fpu/libm_error.c') diff --git a/sysdeps/ia64/fpu/libm_error.c b/sysdeps/ia64/fpu/libm_error.c deleted file mode 100644 index 8ef4bb5a73..0000000000 --- a/sysdeps/ia64/fpu/libm_error.c +++ /dev/null @@ -1,4295 +0,0 @@ -/* file: libm_error.c */ - - -// Copyright (c) 2000 - 2005, Intel Corporation -// All rights reserved. -// -// Contributed 2000 by the Intel Numerics Group, Intel Corporation -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// -// * Redistributions in binary form must reproduce the above copyright -// notice, this list of conditions and the following disclaimer in the -// documentation and/or other materials provided with the distribution. -// -// * The name of Intel Corporation may not be used to endorse or promote -// products derived from this software without specific prior written -// permission. - -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL OR ITS -// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, -// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY -// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR TORT (INCLUDING -// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// -// Intel Corporation is the author of this code, and requests that all -// problem reports or change requests be submitted to it directly at -// http://www.intel.com/software/products/opensource/libraries/num.htm. -// -// History -//============================================================== -// 2/02/00: Initial version -// 3/22/00: Updated to support flexible and dynamic error handling. -// 8/16/00: Changed all matherr function-calls to use the pmatherr -// function-pointers. -// 10/03/00: Corrected a scalb type. -// 11/28/00: Changed INPUT_XL to INPUT_XD for scalb_underflow case. -// 12/07/00: Added code to make scalbn error support equivalent to ldexp. -// 2/07/01: Added __declspec(align(16)) to long double constants to correct -// alignment problem. -// 4/23/01: Added code for remquo -// 6/07/01: Added code for fdim, lrint, lround, llrint, llround -// Deleted code for remquo -// 8/15/01: Added code for scalbln, nexttoward -// 12/10/01: Added code for erfc -// 12/27/01: Added code for degree argument functions -// 01/02/02: Added code for tand, cotd -// 01/15/02: Corrected SVID/XOPEN code for log1p, pow, and acosh -// 01/25/02: Corrected ISOC for lgamma and gamma to return EDOM for neg ints -// 01/28/02: Corrected SVID/XOPEN stderr message for log2 -// 05/20/02: Added code for cot -// 07/01/02: Added code for sinhcosh -// 10/04/02: Underflow detection in ISOC path redefined to -// be zero rather than tiny and inexact -// 12/06/02: Added code for annuity and compound -// 01/30/03: Corrected test for underflow in ISOC path to not set denormal -// 04/10/03: Corrected ISOC branch for gamma/lgamma to return ERANGE for neg ints. -// Added code for tgamma -// 04/11/03: Corrected POSIX/SVID/XOPEN branches for gamma/lgamma -// to return EDOM for neg ints. -// 09/08/03: Corrected XOPEN/SVID result for pow overflow with neg x, pos y. -// 10/14/03: Added ILP32 ifdef -// 12/12/03: Corrected XOPEN/SVID results for powf_zero_to_negative, -// powl_neg_to_non_integer, atan2f_zero, atan2df_zero, -// acoshf_lt_one, acosh_lt_one. -// 12/07/04: Cast name strings as char *. -// 12/08/04: Corrected POSIX behavior for atan2_zero, acos_gt_one, asin_gt_one, -// log_negative, log10_negative, log1p_negative, and log2_negative. -// Added SVID and XOPEN case log2l_zero. -// 12/13/04: Corrected POSIX behavior for exp2_overflow, exp2_underflow, -// exp10_overflow, exp10_underflow. Added ISOC to set errno for -// exp10_underflow. -// 12/14/04: Corrected POSIX behavior for nextafter_overflow, -// nextafter_underflow, nexttoward_overflow, nexttoward_underflow. -// Added ISOC to set errno for nextafter and nexttoward underflow. -// 12/15/04: Corrected POSIX behavior for exp, exp2, and exp10 underflow. -// 03/31/05: Added missing ALIGNIT statement to 6 float constants. - -#include -#include -#include -#include "libm_support.h" - -#ifdef _LIBC -# define pmatherr matherr -# define pmatherrf matherrf -# define pmatherrl matherrl -#else -_LIB_VERSION_TYPE -#if defined( __POSIX__ ) -_LIB_VERSIONIMF = _POSIX_; -#elif defined( __XOPEN__ ) -_LIB_VERSIONIMF = _XOPEN_; -#elif defined( __SVID__ ) -_LIB_VERSIONIMF = _SVID_; -#elif defined( __IEEE__ ) -_LIB_VERSIONIMF = _IEEE_; -#else -_LIB_VERSIONIMF = _ISOC_; -#endif - -/************************************************************/ -/* matherrX function pointers and setusermatherrX functions */ -/************************************************************/ -int (*pmatherrf)(struct exceptionf*) = MATHERR_F; -int (*pmatherr)(struct EXC_DECL_D*) = MATHERR_D; -int (*pmatherrl)(struct exceptionl*) = matherrl; - -void __libm_setusermatherrf( int(*user_merrf)(struct exceptionf*) ) -{ pmatherrf = ( (user_merrf==NULL)? (MATHERR_F) : (user_merrf) ); } - -void __libm_setusermatherr( int(*user_merr)(struct EXC_DECL_D*) ) -{ pmatherr = ( (user_merr==NULL)? (MATHERR_D) : (user_merr) ); } - -void __libm_setusermatherrl( int(*user_merrl)(struct exceptionl*) ) -{ pmatherrl = ( (user_merrl==NULL)? (matherrl) : (user_merrl) ); } - -#endif /* !_LIBC */ - -/***********************************************/ -/* error-handling function, libm_error_support */ -/***********************************************/ -void __libm_error_support(void *arg1,void *arg2,void *retval,error_types input_tag) -{ - -# ifdef __cplusplus -struct __exception exc; -# else -struct exception exc; -# endif - -struct exceptionf excf; -struct exceptionl excl; - -# ifdef __GNUC__ -#define ALIGNIT __attribute__ ((__aligned__ (16))) -# elif defined opensource -#define ALIGNIT -# else -#define ALIGNIT __declspec(align(16)) -# endif - -# ifdef SIZE_LONG_INT_64 -#define __INT_64__ signed long -# else -# if ILP32 -#define __INT_64__ signed long long -# else -#define __INT_64__ __int64 -# endif -# endif - - -#define STATIC static - -ALIGNIT -STATIC const char float_inf[4] = {0x00,0x00,0x80,0x7F}; -ALIGNIT -STATIC const char float_huge[4] = {0xFF,0xFF,0x7F,0x7F}; -ALIGNIT -STATIC const char float_zero[4] = {0x00,0x00,0x00,0x00}; -ALIGNIT -STATIC const char float_neg_inf[4] = {0x00,0x00,0x80,0xFF}; -ALIGNIT -STATIC const char float_neg_huge[4] = {0xFF,0xFF,0x7F,0xFF}; -ALIGNIT -STATIC const char float_neg_zero[4] = {0x00,0x00,0x00,0x80}; -ALIGNIT -STATIC const char double_inf[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0x7F}; -#ifndef _LIBC -ALIGNIT -STATIC const char double_huge[8] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xEF,0x7F}; -#endif -ALIGNIT -STATIC const char double_zero[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}; -ALIGNIT -STATIC const char double_neg_inf[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0xFF}; -#ifndef _LIBC -ALIGNIT -STATIC const char double_neg_huge[8] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xEF,0xFF}; -#endif -ALIGNIT -STATIC const char double_neg_zero[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80}; -ALIGNIT -STATIC const char long_double_inf[16] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0xFF,0x7F,0x00,0x00,0x00,0x00,0x00,0x00}; -ALIGNIT -#ifndef _LIBC -STATIC const char long_double_huge[16] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0x7F,0x00,0x00,0x00,0x00,0x00,0x00}; -#endif -ALIGNIT -STATIC const char long_double_zero[16] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}; -ALIGNIT -STATIC const char long_double_neg_inf[16] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0xFF,0xFF,0x00,0x00,0x00,0x00,0x00,0x00}; -ALIGNIT -#ifndef _LIBC -STATIC const char long_double_neg_huge[16] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0xFF,0x00,0x00,0x00,0x00,0x00,0x00}; -#endif -ALIGNIT -STATIC const char long_double_neg_zero[16] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x00,0x00,0x00}; - - -#define RETVAL_HUGE_VALL *(long double *)retval = *(long double *)long_double_inf -#define RETVAL_NEG_HUGE_VALL *(long double *)retval = *(long double *)long_double_neg_inf -#define RETVAL_HUGEL *(long double *)retval = (long double)*(float *)float_huge -#define RETVAL_NEG_HUGEL *(long double *)retval =(long double)*(float*)float_neg_huge - -#define RETVAL_HUGE_VALD *(double *)retval = *(double *) double_inf -#define RETVAL_NEG_HUGE_VALD *(double *)retval = *(double *) double_neg_inf -#define RETVAL_HUGED *(double *)retval = (double) *(float *)float_huge -#define RETVAL_NEG_HUGED *(double *)retval = (double) *(float *) float_neg_huge - -#define RETVAL_HUGE_VALF *(float *)retval = *(float *) float_inf -#define RETVAL_NEG_HUGE_VALF *(float *)retval = *(float *) float_neg_inf -#define RETVAL_HUGEF *(float *)retval = *(float *) float_huge -#define RETVAL_NEG_HUGEF *(float *)retval = *(float *) float_neg_huge - -#define ZEROL_VALUE *(long double *)long_double_zero -#define ZEROD_VALUE *(double *)double_zero -#define ZEROF_VALUE *(float *)float_zero - -#define RETVAL_ZEROL *(long double *)retval = *(long double *)long_double_zero -#define RETVAL_ZEROD *(double *)retval = *(double *)double_zero -#define RETVAL_ZEROF *(float *)retval = *(float *)float_zero - -#define RETVAL_NEG_ZEROL *(long double *)retval = *(long double *)long_double_neg_zero -#define RETVAL_NEG_ZEROD *(double *)retval = *(double *)double_neg_zero -#define RETVAL_NEG_ZEROF *(float *)retval = *(float *)float_neg_zero - -#define RETVAL_ONEL *(long double *)retval = (long double) 1.0 -#define RETVAL_ONED *(double *)retval = 1.0 -#define RETVAL_ONEF *(float *)retval = 1.0f - -#define NOT_MATHERRL excl.arg1=*(long double *)arg1;excl.arg2=*(long double *)arg2;excl.retval=*(long double *)retval;if(!pmatherrl(&excl)) -#define NOT_MATHERRD exc.arg1=*(double *)arg1;exc.arg2=*(double *)arg2;exc.retval=*(double *)retval;if(!pmatherr(&exc)) -#define NOT_MATHERRF excf.arg1=*(float *)arg1;excf.arg2=*(float *)arg2;excf.retval=*(float *)retval;if(!pmatherrf(&excf)) - -#define ifSVID if(_LIB_VERSIONIMF==_SVID_) - -#define NAMEL excl.name -#define NAMED exc.name -#define NAMEF excf.name - -// -// These should work OK for MS because they are ints - -// leading underbars are not necessary. -// - -#define DOMAIN 1 -#define SING 2 -#define OVERFLOW 3 -#define UNDERFLOW 4 -#define TLOSS 5 -#define PLOSS 6 - -#define SINGL excl.type = SING -#define DOMAINL excl.type = DOMAIN -#define OVERFLOWL excl.type = OVERFLOW -#define UNDERFLOWL excl.type = UNDERFLOW -#define TLOSSL excl.type = TLOSS -#define SINGD exc.type = SING -#define DOMAIND exc.type = DOMAIN -#define OVERFLOWD exc.type = OVERFLOW -#define UNDERFLOWD exc.type = UNDERFLOW -#define TLOSSD exc.type = TLOSS -#define SINGF excf.type = SING -#define DOMAINF excf.type = DOMAIN -#define OVERFLOWF excf.type = OVERFLOW -#define UNDERFLOWF excf.type = UNDERFLOW -#define TLOSSF excf.type = TLOSS - -#define INPUT_XL (excl.arg1=*(long double*)arg1) -#define INPUT_XD (exc.arg1=*(double*)arg1) -#define INPUT_XF (excf.arg1=*(float*)arg1) -#define INPUT_YL (excl.arg2=*(long double*)arg2) -#define INPUT_YD (exc.arg2=*(double*)arg2) -#define INPUT_YF (excf.arg2=*(float*)arg2) -#define INPUT_RESL (*(long double *)retval) -#define INPUT_RESD (*(double *)retval) -#define INPUT_RESF (*(float *)retval) -#define INPUT_RESI64 (*(__INT_64__ *)retval) - -#define WRITEL_LOG_ZERO fputs("logl: SING error\n",stderr) -#define WRITED_LOG_ZERO fputs("log: SING error\n",stderr) -#define WRITEF_LOG_ZERO fputs("logf: SING error\n",stderr) -#define WRITEL_LOG_NEGATIVE fputs("logl: DOMAIN error\n",stderr) -#define WRITED_LOG_NEGATIVE fputs("log: DOMAIN error\n",stderr) -#define WRITEF_LOG_NEGATIVE fputs("logf: DOMAIN error\n",stderr) -#define WRITEL_Y0_ZERO fputs("y0l: DOMAIN error\n",stderr) -#define WRITED_Y0_ZERO fputs("y0: DOMAIN error\n",stderr) -#define WRITEF_Y0_ZERO fputs("y0f: DOMAIN error\n",stderr) -#define WRITEL_Y0_NEGATIVE fputs("y0l: DOMAIN error\n",stderr) -#define WRITED_Y0_NEGATIVE fputs("y0: DOMAIN error\n",stderr) -#define WRITEF_Y0_NEGATIVE fputs("y0f: DOMAIN error\n",stderr) -#define WRITEL_Y1_ZERO fputs("y1l: DOMAIN error\n",stderr) -#define WRITED_Y1_ZERO fputs("y1: DOMAIN error\n",stderr) -#define WRITEF_Y1_ZERO fputs("y1f: DOMAIN error\n",stderr) -#define WRITEL_Y1_NEGATIVE fputs("y1l: DOMAIN error\n",stderr) -#define WRITED_Y1_NEGATIVE fputs("y1: DOMAIN error\n",stderr) -#define WRITEF_Y1_NEGATIVE fputs("y1f: DOMAIN error\n",stderr) -#define WRITEL_YN_ZERO fputs("ynl: DOMAIN error\n",stderr) -#define WRITED_YN_ZERO fputs("yn: DOMAIN error\n",stderr) -#define WRITEF_YN_ZERO fputs("ynf: DOMAIN error\n",stderr) -#define WRITEL_YN_NEGATIVE fputs("ynl: DOMAIN error\n",stderr) -#define WRITED_YN_NEGATIVE fputs("yn: DOMAIN error\n",stderr) -#define WRITEF_YN_NEGATIVE fputs("ynf: DOMAIN error\n",stderr) -#define WRITEL_LOG1P_ZERO fputs("log1pl: SING error\n",stderr) -#define WRITED_LOG1P_ZERO fputs("log1p: SING error\n",stderr) -#define WRITEF_LOG1P_ZERO fputs("log1pf: SING error\n",stderr) -#define WRITEL_LOG1P_NEGATIVE fputs("log1pl: DOMAIN error\n",stderr) -#define WRITED_LOG1P_NEGATIVE fputs("log1p: DOMAIN error\n",stderr) -#define WRITEF_LOG1P_NEGATIVE fputs("log1pf: DOMAIN error\n",stderr) -#define WRITEL_LOG10_ZERO fputs("log10l: SING error\n",stderr) -#define WRITED_LOG10_ZERO fputs("log10: SING error\n",stderr) -#define WRITEF_LOG10_ZERO fputs("log10f: SING error\n",stderr) -#define WRITEL_LOG10_NEGATIVE fputs("log10l: DOMAIN error\n",stderr) -#define WRITED_LOG10_NEGATIVE fputs("log10: DOMAIN error\n",stderr) -#define WRITEF_LOG10_NEGATIVE fputs("log10f: DOMAIN error\n",stderr) -#define WRITEL_LOG2_ZERO fputs("log2l: SING error\n",stderr) -#define WRITED_LOG2_ZERO fputs("log2: SING error\n",stderr) -#define WRITEF_LOG2_ZERO fputs("log2f: SING error\n",stderr) -#define WRITEL_LOG2_NEGATIVE fputs("log2l: DOMAIN error\n",stderr) -#define WRITED_LOG2_NEGATIVE fputs("log2: DOMAIN error\n",stderr) -#define WRITEF_LOG2_NEGATIVE fputs("log2f: DOMAIN error\n",stderr) -#define WRITEL_POW_ZERO_TO_ZERO fputs("powl(0,0): DOMAIN error\n",stderr) -#define WRITED_POW_ZERO_TO_ZERO fputs("pow(0,0): DOMAIN error\n",stderr) -#define WRITEF_POW_ZERO_TO_ZERO fputs("powf(0,0): DOMAIN error\n",stderr) -#define WRITEL_POW_ZERO_TO_NEGATIVE fputs("powl(0,negative): DOMAIN error\n",stderr) -#define WRITED_POW_ZERO_TO_NEGATIVE fputs("pow(0,negative): DOMAIN error\n",stderr) -#define WRITEF_POW_ZERO_TO_NEGATIVE fputs("powf(0,negative): DOMAIN error\n",stderr) -#define WRITEL_POW_NEG_TO_NON_INTEGER fputs("powl(negative,non-integer): DOMAIN error\n",stderr) -#define WRITED_POW_NEG_TO_NON_INTEGER fputs("pow(negative,non-integer): DOMAIN error\n",stderr) -#define WRITEF_POW_NEG_TO_NON_INTEGER fputs("powf(negative,non-integer): DOMAIN error\n",stderr) -#define WRITEL_ATAN2_ZERO_BY_ZERO fputs("atan2l: DOMAIN error\n",stderr) -#define WRITED_ATAN2_ZERO_BY_ZERO fputs("atan2: DOMAIN error\n",stderr) -#define WRITEF_ATAN2_ZERO_BY_ZERO fputs("atan2f: DOMAIN error\n",stderr) -#define WRITEL_SQRT fputs("sqrtl: DOMAIN error\n",stderr) -#define WRITED_SQRT fputs("sqrt: DOMAIN error\n",stderr) -#define WRITEF_SQRT fputs("sqrtf: DOMAIN error\n",stderr) -#define WRITEL_FMOD fputs("fmodl: DOMAIN error\n",stderr) -#define WRITED_FMOD fputs("fmod: DOMAIN error\n",stderr) -#define WRITEF_FMOD fputs("fmodf: DOMAIN error\n",stderr) -#define WRITEL_REM fputs("remainderl: DOMAIN error\n",stderr) -#define WRITED_REM fputs("remainder: DOMAIN error\n",stderr) -#define WRITEF_REM fputs("remainderf: DOMAIN error\n",stderr) -#define WRITEL_ACOS fputs("acosl: DOMAIN error\n",stderr) -#define WRITED_ACOS fputs("acos: DOMAIN error\n",stderr) -#define WRITEF_ACOS fputs("acosf: DOMAIN error\n",stderr) -#define WRITEL_ASIN fputs("asinl: DOMAIN error\n",stderr) -#define WRITED_ASIN fputs("asin: DOMAIN error\n",stderr) -#define WRITEF_ASIN fputs("asinf: DOMAIN error\n",stderr) -#define WRITEL_ACOSH fputs("acoshl: DOMAIN error\n",stderr) -#define WRITED_ACOSH fputs("acosh: DOMAIN error\n",stderr) -#define WRITEF_ACOSH fputs("acoshf: DOMAIN error\n",stderr) -#define WRITEL_ATANH_GT_ONE fputs("atanhl: DOMAIN error\n",stderr) -#define WRITED_ATANH_GT_ONE fputs("atanh: DOMAIN error\n",stderr) -#define WRITEF_ATANH_GT_ONE fputs("atanhf: DOMAIN error\n",stderr) -#define WRITEL_ATANH_EQ_ONE fputs("atanhl: SING error\n",stderr) -#define WRITED_ATANH_EQ_ONE fputs("atanh: SING error\n",stderr) -#define WRITEF_ATANH_EQ_ONE fputs("atanhf: SING error\n",stderr) -#define WRITEL_LGAMMA_NEGATIVE fputs("lgammal: SING error\n",stderr) -#define WRITED_LGAMMA_NEGATIVE fputs("lgamma: SING error\n",stderr) -#define WRITEF_LGAMMA_NEGATIVE fputs("lgammaf: SING error\n",stderr) -#define WRITEL_GAMMA_NEGATIVE fputs("gammal: SING error\n",stderr) -#define WRITED_GAMMA_NEGATIVE fputs("gamma: SING error\n",stderr) -#define WRITEF_GAMMA_NEGATIVE fputs("gammaf: SING error\n",stderr) -#define WRITEL_TGAMMA_NEGATIVE fputs("tgammal: SING error\n",stderr) -#define WRITED_TGAMMA_NEGATIVE fputs("tgamma: SING error\n",stderr) -#define WRITEF_TGAMMA_NEGATIVE fputs("tgammaf: SING error\n",stderr) -#define WRITEL_J0_TLOSS fputs("j0l: TLOSS error\n",stderr) -#define WRITEL_Y0_TLOSS fputs("y0l: TLOSS error\n",stderr) -#define WRITEL_J1_TLOSS fputs("j1l: TLOSS error\n",stderr) -#define WRITEL_Y1_TLOSS fputs("y1l: TLOSS error\n",stderr) -#define WRITEL_JN_TLOSS fputs("jnl: TLOSS error\n",stderr) -#define WRITEL_YN_TLOSS fputs("ynl: TLOSS error\n",stderr) -#define WRITED_J0_TLOSS fputs("j0: TLOSS error\n",stderr) -#define WRITED_Y0_TLOSS fputs("y0: TLOSS error\n",stderr) -#define WRITED_J1_TLOSS fputs("j1: TLOSS error\n",stderr) -#define WRITED_Y1_TLOSS fputs("y1: TLOSS error\n",stderr) -#define WRITED_JN_TLOSS fputs("jn: TLOSS error\n",stderr) -#define WRITED_YN_TLOSS fputs("yn: TLOSS error\n",stderr) -#define WRITEF_J0_TLOSS fputs("j0f: TLOSS error\n",stderr) -#define WRITEF_Y0_TLOSS fputs("y0f: TLOSS error\n",stderr) -#define WRITEF_J1_TLOSS fputs("j1f: TLOSS error\n",stderr) -#define WRITEF_Y1_TLOSS fputs("y1f: TLOSS error\n",stderr) -#define WRITEF_JN_TLOSS fputs("jnf: TLOSS error\n",stderr) -#define WRITEF_YN_TLOSS fputs("ynf: TLOSS error\n",stderr) -#define WRITEL_ACOSD fputs("acosdl: DOMAIN error\n",stderr) -#define WRITED_ACOSD fputs("acosd: DOMAIN error\n",stderr) -#define WRITEF_ACOSD fputs("acosdf: DOMAIN error\n",stderr) -#define WRITEL_ASIND fputs("asindl: DOMAIN error\n",stderr) -#define WRITED_ASIND fputs("asind: DOMAIN error\n",stderr) -#define WRITEF_ASIND fputs("asindf: DOMAIN error\n",stderr) -#define WRITEL_ATAN2D_ZERO_BY_ZERO fputs("atan2dl: DOMAIN error\n",stderr) -#define WRITED_ATAN2D_ZERO_BY_ZERO fputs("atan2d: DOMAIN error\n",stderr) -#define WRITEF_ATAN2D_ZERO_BY_ZERO fputs("atan2df: DOMAIN error\n",stderr) - - -/***********************/ -/* IEEE Path */ -/***********************/ -if(_LIB_VERSIONIMF==_IEEE_) return; - -/***********************/ -/* C9X Path */ -/***********************/ -else if(_LIB_VERSIONIMF==_ISOC_) -{ - switch(input_tag) - { - case logl_zero: - case log_zero: - case logf_zero: - case log10l_zero: - case log10_zero: - case log10f_zero: - case log2l_zero: - case log2_zero: - case log2f_zero: - case log1pl_zero: - case log1p_zero: - case log1pf_zero: - case powl_overflow: - case pow_overflow: - case powf_overflow: - case expl_overflow: - case exp_overflow: - case expf_overflow: - case exp2l_overflow: - case exp2_overflow: - case exp2f_overflow: - case exp10l_overflow: - case exp10_overflow: - case exp10f_overflow: - case expm1l_overflow: - case expm1_overflow: - case expm1f_overflow: - case hypotl_overflow: - case hypot_overflow: - case hypotf_overflow: - case sinhl_overflow: - case sinh_overflow: - case sinhf_overflow: - case atanhl_eq_one: - case atanh_eq_one: - case atanhf_eq_one: - case scalbl_overflow: - case scalb_overflow: - case scalbf_overflow: - case coshl_overflow: - case cosh_overflow: - case coshf_overflow: - case nextafterl_overflow: - case nextafter_overflow: - case nextafterf_overflow: - case nextafterl_underflow: - case nextafter_underflow: - case nextafterf_underflow: - case nexttowardl_overflow: - case nexttoward_overflow: - case nexttowardf_overflow: - case nexttowardl_underflow: - case nexttoward_underflow: - case nexttowardf_underflow: - case scalbnl_overflow: - case scalbn_overflow: - case scalbnf_overflow: - case scalblnl_overflow: - case scalbln_overflow: - case scalblnf_overflow: - case ldexpl_overflow: - case ldexp_overflow: - case ldexpf_overflow: - case lgammal_overflow: - case lgamma_overflow: - case lgammaf_overflow: - case gammal_overflow: - case gamma_overflow: - case gammaf_overflow: - case lgammal_negative: - case lgamma_negative: - case lgammaf_negative: - case gammal_negative: - case gamma_negative: - case gammaf_negative: - case ilogbl_zero: - case ilogb_zero: - case ilogbf_zero: - case fdiml_overflow: - case fdim_overflow: - case fdimf_overflow: - case llrintl_large: - case llrint_large: - case llrintf_large: - case llroundl_large: - case llround_large: - case llroundf_large: - case lrintl_large: - case lrint_large: - case lrintf_large: - case lroundl_large: - case lround_large: - case lroundf_large: - case tandl_overflow: - case tand_overflow: - case tandf_overflow: - case cotdl_overflow: - case cotd_overflow: - case cotdf_overflow: - case cotl_overflow: - case cot_overflow: - case cotf_overflow: - case sinhcoshl_overflow: - case sinhcosh_overflow: - case sinhcoshf_overflow: - case annuityl_overflow: - case annuity_overflow: - case annuityf_overflow: - case compoundl_overflow: - case compound_overflow: - case compoundf_overflow: - case tgammal_overflow: - case tgamma_overflow: - case tgammaf_overflow: - { - ERRNO_RANGE; break; - } - case powl_underflow: - case expl_underflow: - case exp10l_underflow: - case exp2l_underflow: - case scalbl_underflow: - case scalbnl_underflow: - case scalblnl_underflow: - case ldexpl_underflow: - case erfcl_underflow: - case annuityl_underflow: - case compoundl_underflow: - { - /* Test for zero by testing 64 significand bits for zero. An integer - test is needed so denormal flag is not set by a floating-point test */ - if ( INPUT_RESI64 == 0 ) ERRNO_RANGE; - break; - } - case pow_underflow: - case exp_underflow: - case exp10_underflow: - case exp2_underflow: - case scalb_underflow: - case scalbn_underflow: - case scalbln_underflow: - case ldexp_underflow: - case erfc_underflow: - case annuity_underflow: - case compound_underflow: - { - /* Test for zero by testing exp and significand bits for zero. An integer - test is needed so denormal flag is not set by a floating-point test */ - if ( (INPUT_RESI64 << 1) == 0 ) ERRNO_RANGE; - break; - } - case powf_underflow: - case expf_underflow: - case exp10f_underflow: - case exp2f_underflow: - case scalbf_underflow: - case scalbnf_underflow: - case scalblnf_underflow: - case ldexpf_underflow: - case erfcf_underflow: - case annuityf_underflow: - case compoundf_underflow: - { - /* Test for zero by testing exp and significand bits for zero. An integer - test is needed so denormal flag is not set by a floating-point test */ - if ( (INPUT_RESI64 << 33) == 0 ) ERRNO_RANGE; - break; - } - case logl_negative: - case log_negative: - case logf_negative: - case log10l_negative: - case log10_negative: - case log10f_negative: - case log2l_negative: - case log2_negative: - case log2f_negative: - case log1pl_negative: - case log1p_negative: - case log1pf_negative: - case sqrtl_negative: - case sqrt_negative: - case sqrtf_negative: - case atan2l_zero: - case atan2_zero: - case atan2f_zero: - case powl_zero_to_negative: - case powl_neg_to_non_integer: - case pow_zero_to_negative: - case pow_neg_to_non_integer: - case powf_zero_to_negative: - case powf_neg_to_non_integer: - case fmodl_by_zero: - case fmod_by_zero: - case fmodf_by_zero: - case atanhl_gt_one: - case atanh_gt_one: - case atanhf_gt_one: - case acosl_gt_one: - case acos_gt_one: - case acosf_gt_one: - case asinl_gt_one: - case asin_gt_one: - case asinf_gt_one: - case logbl_zero: - case logb_zero: - case logbf_zero: - case acoshl_lt_one: - case acosh_lt_one: - case acoshf_lt_one: - case y0l_zero: - case y0_zero: - case y0f_zero: - case y1l_zero: - case y1_zero: - case y1f_zero: - case ynl_zero: - case yn_zero: - case ynf_zero: - case y0l_negative: - case y0_negative: - case y0f_negative: - case y1l_negative: - case y1_negative: - case y1f_negative: - case ynl_negative: - case yn_negative: - case ynf_negative: - case acosdl_gt_one: - case acosd_gt_one: - case acosdf_gt_one: - case asindl_gt_one: - case asind_gt_one: - case asindf_gt_one: - case atan2dl_zero: - case atan2d_zero: - case atan2df_zero: - case annuityl_by_zero: - case annuity_by_zero: - case annuityf_by_zero: - case annuityl_less_m1: - case annuity_less_m1: - case annuityf_less_m1: - case compoundl_by_zero: - case compound_by_zero: - case compoundf_by_zero: - case compoundl_less_m1: - case compound_less_m1: - case compoundf_less_m1: - case tgammal_negative: - case tgamma_negative: - case tgammaf_negative: - { - ERRNO_DOMAIN; break; - } - default: - break; - } - return; -} - -/***********************/ -/* _POSIX_ Path */ -/***********************/ - -else if(_LIB_VERSIONIMF==_POSIX_) -{ -switch(input_tag) - { - case gammal_overflow: - case lgammal_overflow: - case tgammal_overflow: - { - RETVAL_HUGE_VALL; ERRNO_RANGE; break; - } - case gamma_overflow: - case lgamma_overflow: - case tgamma_overflow: - { - RETVAL_HUGE_VALD; ERRNO_RANGE; break; - } - case gammaf_overflow: - case lgammaf_overflow: - case tgammaf_overflow: - { - RETVAL_HUGE_VALF; ERRNO_RANGE; break; - } - case gammal_negative: - case gamma_negative: - case gammaf_negative: - case lgammal_negative: - case lgamma_negative: - case lgammaf_negative: - case tgammal_negative: - case tgamma_negative: - case tgammaf_negative: - { - ERRNO_DOMAIN; break; - } - case ldexpl_overflow: - case ldexpl_underflow: - case ldexp_overflow: - case ldexp_underflow: - case ldexpf_overflow: - case ldexpf_underflow: - case scalbnl_overflow: - case scalbnl_underflow: - case scalbn_overflow: - case scalbn_underflow: - case scalbnf_overflow: - case scalbnf_underflow: - case scalblnl_overflow: - case scalblnl_underflow: - case scalbln_overflow: - case scalbln_underflow: - case scalblnf_overflow: - case scalblnf_underflow: - case tandl_overflow: - case tand_overflow: - case tandf_overflow: - case cotdl_overflow: - case cotd_overflow: - case cotdf_overflow: - case cotl_overflow: - case cot_overflow: - case cotf_overflow: - case sinhcoshl_overflow: - case sinhcosh_overflow: - case sinhcoshf_overflow: - case nextafterl_overflow: - case nextafter_overflow: - case nextafterf_overflow: - case nextafterl_underflow: - case nextafter_underflow: - case nextafterf_underflow: - case nexttowardl_overflow: - case nexttoward_overflow: - case nexttowardf_overflow: - case nexttowardl_underflow: - case nexttoward_underflow: - case nexttowardf_underflow: - { - ERRNO_RANGE; break; - } - case atanhl_gt_one: - case atanhl_eq_one: - /* atanhl(|x| >= 1) */ - { - ERRNO_DOMAIN; break; - } - case atanh_gt_one: - case atanh_eq_one: - /* atanh(|x| >= 1) */ - { - ERRNO_DOMAIN; break; - } - case atanhf_gt_one: - case atanhf_eq_one: - /* atanhf(|x| >= 1) */ - { - ERRNO_DOMAIN; break; - } - case sqrtl_negative: - /* sqrtl(x < 0) */ - { - ERRNO_DOMAIN; break; - } - case sqrt_negative: - /* sqrt(x < 0) */ - { - ERRNO_DOMAIN; break; - } - case sqrtf_negative: - /* sqrtf(x < 0) */ - { - ERRNO_DOMAIN; break; - } - case y0l_zero: - case y1l_zero: - case ynl_zero: - /* y0l(0) */ - /* y1l(0) */ - /* ynl(0) */ - { - RETVAL_NEG_HUGE_VALL; ERRNO_DOMAIN; break; - } - case y0_zero: - case y1_zero: - case yn_zero: - /* y0(0) */ - /* y1(0) */ - /* yn(0) */ - { - RETVAL_NEG_HUGE_VALD; ERRNO_DOMAIN; break; - } - case y0f_zero: - case y1f_zero: - case ynf_zero: - /* y0f(0) */ - /* y1f(0) */ - /* ynf(0) */ - { - RETVAL_NEG_HUGE_VALF; ERRNO_DOMAIN; break; - } - case y0l_negative: - case y1l_negative: - case ynl_negative: - /* y0l(x < 0) */ - /* y1l(x < 0) */ - /* ynl(x < 0) */ - { -#ifndef _LIBC - RETVAL_NEG_HUGE_VALL; -#endif - ERRNO_DOMAIN; break; - } - case y0_negative: - case y1_negative: - case yn_negative: - /* y0(x < 0) */ - /* y1(x < 0) */ - /* yn(x < 0) */ - { - RETVAL_NEG_HUGE_VALD; ERRNO_DOMAIN; break; - } - case y0f_negative: - case y1f_negative: - case ynf_negative: - /* y0f(x < 0) */ - /* y1f(x < 0) */ - /* ynf(x < 0) */ - { - RETVAL_NEG_HUGE_VALF; ERRNO_DOMAIN; break; - } - case logl_zero: - case log1pl_zero: - case log10l_zero: - case log2l_zero: - /* logl(0) */ - /* log1pl(-1) */ - /* log10l(0) */ - /* log2l(0) */ - { - RETVAL_NEG_HUGE_VALL; ERRNO_RANGE; break; - } - case log_zero: - case log1p_zero: - case log10_zero: - case log2_zero: - /* log(0) */ - /* log1p(-1) */ - /* log10(0) */ - /* log2(0) */ - { - RETVAL_NEG_HUGE_VALD; ERRNO_RANGE; break; - } - case logf_zero: - case log1pf_zero: - case log10f_zero: - case log2f_zero: - /* logf(0) */ - /* log1pf(-1) */ - /* log10f(0) */ - /* log2f(0) */ - { - RETVAL_NEG_HUGE_VALF; ERRNO_RANGE; break; - } - case logl_negative: - case log1pl_negative: - case log10l_negative: - case log2l_negative: - /* logl(x < 0) */ - /* log1pl(x < -1) */ - /* log10l(x < 0) */ - /* log2l(x < 0) */ - { - ERRNO_DOMAIN; break; - } - case log_negative: - case log1p_negative: - case log10_negative: - case log2_negative: - /* log(x < 0) */ - /* log1p(x < -1) */ - /* log10(x < 0) */ - /* log2(x < 0) */ - { - ERRNO_DOMAIN; break; - } - case logf_negative: - case log1pf_negative: - case log10f_negative: - case log2f_negative: - /* logf(x < 0) */ - /* log1pf(x < -1) */ - /* log10f(x < 0) */ - /* log2f(x < 0) */ - { - ERRNO_DOMAIN; break; - } - case expl_overflow: - case exp10l_overflow: - case exp2l_overflow: - /* expl overflow */ - /* exp10l overflow */ - /* exp2l overflow */ - { - RETVAL_HUGE_VALL; ERRNO_RANGE; break; - } - case exp_overflow: - case exp10_overflow: - case exp2_overflow: - /* exp overflow */ - /* exp10 overflow */ - /* exp2 overflow */ - { - RETVAL_HUGE_VALD; ERRNO_RANGE; break; - } - case expf_overflow: - case exp10f_overflow: - case exp2f_overflow: - /* expf overflow */ - { - RETVAL_HUGE_VALF; ERRNO_RANGE; break; - } - case expl_underflow: - case exp10l_underflow: - case exp2l_underflow: - /* expl underflow */ - /* exp10l underflow */ - /* exp2l underflow */ - { - ERRNO_RANGE; break; - } - case exp_underflow: - case exp10_underflow: - case exp2_underflow: - /* exp underflow */ - /* exp10 underflow */ - /* exp2 underflow */ - { - ERRNO_RANGE; break; - } - case expf_underflow: - case exp10f_underflow: - case exp2f_underflow: - /* expf underflow */ - /* exp10f underflow */ - /* exp2f underflow */ - { - ERRNO_RANGE; break; - } - case j0l_gt_loss: - case y0l_gt_loss: - case j1l_gt_loss: - case y1l_gt_loss: - case jnl_gt_loss: - case ynl_gt_loss: - /* jn and yn doubl-extended> XLOSS */ - { - RETVAL_ZEROL; ERRNO_RANGE; break; - } - case j0_gt_loss: - case y0_gt_loss: - case j1_gt_loss: - case y1_gt_loss: - case jn_gt_loss: - case yn_gt_loss: - /* jn and yn double > XLOSS */ - { - RETVAL_ZEROD; ERRNO_RANGE; break; - } - case j0f_gt_loss: - case y0f_gt_loss: - case j1f_gt_loss: - case y1f_gt_loss: - case jnf_gt_loss: - case ynf_gt_loss: - /* j0n and y0n > XLOSS */ - { - RETVAL_ZEROF; ERRNO_RANGE; break; - } - case powl_zero_to_zero: - /* powl 0**0 */ - { - break; - } - case pow_zero_to_zero: - /* pow 0**0 */ - { - break; - } - case powf_zero_to_zero: - /* powf 0**0 */ - { - break; - } - case powl_overflow: - case annuityl_overflow: - case compoundl_overflow: - /* powl(x,y) overflow */ - { - if (INPUT_RESL < ZEROL_VALUE /*0*/) RETVAL_NEG_HUGE_VALL; - else RETVAL_HUGE_VALL; - ERRNO_RANGE; break; - } - case pow_overflow: - case annuity_overflow: - case compound_overflow: - /* pow(x,y) overflow */ - { - if (INPUT_RESD < ZEROD_VALUE /*0*/) RETVAL_NEG_HUGE_VALD; - else RETVAL_HUGE_VALD; - ERRNO_RANGE; break; - } - case powf_overflow: - case annuityf_overflow: - case compoundf_overflow: - /* powf(x,y) overflow */ - { - if (INPUT_RESF < ZEROF_VALUE /*0*/) RETVAL_NEG_HUGE_VALF; - else RETVAL_HUGE_VALF; - ERRNO_RANGE; break; - } - case powl_underflow: - case annuityl_underflow: - case compoundl_underflow: - /* powl(x,y) underflow */ - { - RETVAL_ZEROL; ERRNO_RANGE; break; - } - case pow_underflow: - case annuity_underflow: - case compound_underflow: - /* pow(x,y) underflow */ - { - RETVAL_ZEROD; ERRNO_RANGE; break; - } - case powf_underflow: - case annuityf_underflow: - case compoundf_underflow: - /* powf(x,y) underflow */ - { - RETVAL_ZEROF; ERRNO_RANGE; break; - } - case annuityl_by_zero: - case annuityl_less_m1: - case compoundl_by_zero: - case compoundl_less_m1: - case annuity_by_zero: - case annuity_less_m1: - case compound_by_zero: - case compound_less_m1: - case annuityf_by_zero: - case annuityf_less_m1: - case compoundf_by_zero: - case compoundf_less_m1: - { - ERRNO_DOMAIN; break; - } - case powl_zero_to_negative: - /* 0**neg */ - { - ERRNO_DOMAIN; break; - } - case pow_zero_to_negative: - /* 0**neg */ - { - ERRNO_DOMAIN; break; - } - case powf_zero_to_negative: - /* 0**neg */ - { - ERRNO_DOMAIN; break; - } - case powl_neg_to_non_integer: - /* neg**non_integral */ - { - ERRNO_DOMAIN; break; - } - case pow_neg_to_non_integer: - /* neg**non_integral */ - { - ERRNO_DOMAIN; break; - } - case powf_neg_to_non_integer: - /* neg**non-integral */ - { - ERRNO_DOMAIN; break; - } - case powl_nan_to_zero: - /* powl(NaN,0.0) */ - /* Special Error */ - { - break; - } - case pow_nan_to_zero: - /* pow(NaN,0.0) */ - { - break; - } - case powf_nan_to_zero: - /* powf(NaN,0.0) */ - { - break; - } - case atan2l_zero: - case atan2dl_zero: - /* atan2l(0,0) */ - /* atan2dl(0,0) */ - { - break; - } - case atan2_zero: - case atan2d_zero: - /* atan2(0,0) */ - /* atan2d(0,0) */ - { - break; - } - case atan2f_zero: - case atan2df_zero: - /* atan2f(0,0) */ - /* atan2df(0,0) */ - { - break; - } - case expm1l_overflow: - /* expm1 overflow */ - { - ERRNO_RANGE; break; - } - case expm1_overflow: - /* expm1 overflow */ - { - ERRNO_RANGE; break; - } - case expm1f_overflow: - /* expm1f overflow */ - { - ERRNO_RANGE; break; - } - case expm1l_underflow: - /* expm1 underflow */ - { - ERRNO_RANGE; break; - } - case expm1_underflow: - /* expm1 underflow */ - { - ERRNO_RANGE; break; - } - case expm1f_underflow: - /* expm1f underflow */ - { - ERRNO_RANGE; break; - } - case hypotl_overflow: - /* hypotl overflow */ - { - RETVAL_HUGE_VALL; ERRNO_RANGE; break; - } - case hypot_overflow: - /* hypot overflow */ - { - RETVAL_HUGE_VALD; ERRNO_RANGE; break; - } - case hypotf_overflow: - /* hypotf overflow */ - { - RETVAL_HUGE_VALF; ERRNO_RANGE; break; - } - case scalbl_underflow: - /* scalbl underflow */ - { - if (INPUT_XL < ZEROL_VALUE /*0*/) RETVAL_NEG_ZEROL; - else RETVAL_ZEROL; - ERRNO_RANGE; break; - } - case scalb_underflow: - /* scalb underflow */ - { - if (INPUT_XD < ZEROD_VALUE /*0*/) RETVAL_NEG_ZEROD; - else RETVAL_ZEROD; - ERRNO_RANGE; break; - } - case scalbf_underflow: - /* scalbf underflow */ - { - if (INPUT_XF < ZEROF_VALUE /*0*/) RETVAL_NEG_ZEROF; - else RETVAL_ZEROF; - ERRNO_RANGE; break; - } - case scalbl_overflow: - /* scalbl overflow */ - { - if (INPUT_XL < ZEROL_VALUE /*0*/) RETVAL_NEG_HUGE_VALL; - else RETVAL_HUGE_VALL; - ERRNO_RANGE; break; - } - case scalb_overflow: - /* scalb overflow */ - { - if (INPUT_XD < ZEROD_VALUE /*0*/) RETVAL_NEG_HUGE_VALD; - else RETVAL_HUGE_VALD; - ERRNO_RANGE; break; - } - case scalbf_overflow: - /* scalbf overflow */ - { - if (INPUT_XF < ZEROF_VALUE /*0*/) RETVAL_NEG_HUGE_VALF; - else RETVAL_HUGE_VALF; - ERRNO_RANGE; break; - } - case acoshl_lt_one: - /* acoshl(x < 1) */ - { - ERRNO_DOMAIN; break; - } - case acosh_lt_one: - /* acosh(x < 1) */ - { - ERRNO_DOMAIN; break; - } - case acoshf_lt_one: - /* acoshf(x < 1) */ - { - ERRNO_DOMAIN; break; - } - case acosl_gt_one: - case acosdl_gt_one: - /* acosl(x > 1) */ - /* acosdl(x > 1) */ - { - ERRNO_DOMAIN; break; - } - case acos_gt_one: - case acosd_gt_one: - /* acos(x > 1) */ - /* acosd(x > 1) */ - { - ERRNO_DOMAIN; break; - } - case acosf_gt_one: - case acosdf_gt_one: - /* acosf(x > 1) */ - /* acosdf(x > 1) */ - { - ERRNO_DOMAIN; break; - } - case asinl_gt_one: - case asindl_gt_one: - /* asinl(x > 1) */ - /* asindl(x > 1) */ - { - ERRNO_DOMAIN; break; - } - case asin_gt_one: - case asind_gt_one: - /* asin(x > 1) */ - /* asind(x > 1) */ - { - ERRNO_DOMAIN; break; - } - case asinf_gt_one: - case asindf_gt_one: - /* asinf(x > 1) */ - /* asindf(x > 1) */ - { - ERRNO_DOMAIN; break; - } - case remainderl_by_zero: - case fmodl_by_zero: - /* fmodl(x,0) */ - { - ERRNO_DOMAIN; break; - } - case remainder_by_zero: - case fmod_by_zero: - /* fmod(x,0) */ - { - ERRNO_DOMAIN; break; - } - case remainderf_by_zero: - case fmodf_by_zero: - /* fmodf(x,0) */ - { - ERRNO_DOMAIN; break; - } - case coshl_overflow: - /* coshl overflows */ - { - RETVAL_HUGE_VALL; ERRNO_RANGE; break; - } - case cosh_overflow: - /* cosh overflows */ - { - RETVAL_HUGE_VALD; ERRNO_RANGE; break; - } - case coshf_overflow: - /* coshf overflows */ - { - RETVAL_HUGE_VALF; ERRNO_RANGE; break; - } - case sinhl_overflow: - /* sinhl overflows */ - { - if (INPUT_XL > ZEROL_VALUE /*0*/) RETVAL_HUGE_VALL; - else RETVAL_NEG_HUGE_VALL; - ERRNO_RANGE; break; - } - case sinh_overflow: - /* sinh overflows */ - { - if (INPUT_XD > ZEROD_VALUE /*0*/) RETVAL_HUGE_VALD; - else RETVAL_NEG_HUGE_VALD; - ERRNO_RANGE; break; - } - case sinhf_overflow: - /* sinhf overflows */ - { - if (INPUT_XF > ZEROF_VALUE /*0*/) RETVAL_HUGE_VALF; - else RETVAL_NEG_HUGE_VALF; - ERRNO_RANGE; break; - } - case logbl_zero: - /* logbl(0) */ - { - ERRNO_DOMAIN; break; - } - case logb_zero: - /* logb(0) */ - { - ERRNO_DOMAIN; break; - } - case logbf_zero: - /* logbf(0) */ - { - ERRNO_DOMAIN; break; - } - case ilogbl_zero: - /* ilogbl(0) */ - { - ERRNO_RANGE; break; - } - case ilogb_zero: - /* ilogb(0) */ - { - ERRNO_RANGE; break; - } - case ilogbf_zero: - /* ilogbf(0) */ - { - ERRNO_RANGE; break; - } - default: - break; -} -return; -/* _POSIX_ */ -} - -/*******************************/ -/* __SVID__ and __XOPEN__ Path */ -/*******************************/ -else -{ - switch(input_tag) - { - case ldexpl_overflow: - case ldexpl_underflow: - case ldexp_overflow: - case ldexp_underflow: - case ldexpf_overflow: - case ldexpf_underflow: - case scalbnl_overflow: - case scalbnl_underflow: - case scalbn_overflow: - case scalbn_underflow: - case scalbnf_overflow: - case scalbnf_underflow: - case scalblnl_overflow: - case scalblnl_underflow: - case scalbln_overflow: - case scalbln_underflow: - case scalblnf_overflow: - case scalblnf_underflow: - case tandl_overflow: - case tand_overflow: - case tandf_overflow: - case cotdl_overflow: - case cotd_overflow: - case cotdf_overflow: - case cotl_overflow: - case cot_overflow: - case cotf_overflow: - case annuityl_overflow: - case annuityl_underflow: - case annuity_overflow: - case annuity_underflow: - case annuityf_overflow: - case annuityf_underflow: - case compoundl_overflow: - case compoundl_underflow: - case compound_overflow: - case compound_underflow: - case compoundf_overflow: - case compoundf_underflow: - { - ERRNO_RANGE; break; - } - case annuityl_by_zero: - case annuityl_less_m1: - case annuity_by_zero: - case annuity_less_m1: - case annuityf_by_zero: - case annuityf_less_m1: - case compoundl_by_zero: - case compoundl_less_m1: - case compound_by_zero: - case compound_less_m1: - case compoundf_by_zero: - case compoundf_less_m1: - { - ERRNO_DOMAIN; break; - } - case sqrtl_negative: - /* sqrtl(x < 0) */ - { - DOMAINL; NAMEL = (char *) "sqrtl"; - ifSVID - { - RETVAL_ZEROL; - NOT_MATHERRL - { - WRITEL_SQRT; - ERRNO_DOMAIN; - } - } - else - { /* NaN already computed */ - NOT_MATHERRL {ERRNO_DOMAIN;} - } - *(long double *)retval = excl.retval; - break; - } - case sqrt_negative: - /* sqrt(x < 0) */ - { - DOMAIND; NAMED = (char *) "sqrt"; - ifSVID - { - - RETVAL_ZEROD; - NOT_MATHERRD - { - WRITED_SQRT; - ERRNO_DOMAIN; - } - } - else - { /* NaN already computed */ - NOT_MATHERRD {ERRNO_DOMAIN;} - } - *(double *)retval = exc.retval; - break; - } - case sqrtf_negative: - /* sqrtf(x < 0) */ - { - DOMAINF; NAMEF = (char *) "sqrtf"; - ifSVID - { - RETVAL_ZEROF; - NOT_MATHERRF - { - WRITEF_SQRT; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRF {ERRNO_DOMAIN;} - } - *(float *)retval = excf.retval; - break; - } - case logl_zero: - /* logl(0) */ - { - SINGL; NAMEL = (char *) "logl"; - ifSVID - { - RETVAL_NEG_HUGEL; - NOT_MATHERRL - { - WRITEL_LOG_ZERO; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALL; - NOT_MATHERRL {ERRNO_DOMAIN;} - } - *(long double *)retval = excl.retval; - break; - } - case log_zero: - /* log(0) */ - { - SINGD; NAMED = (char *) "log"; - ifSVID - { - RETVAL_NEG_HUGED; - NOT_MATHERRD - { - WRITED_LOG_ZERO; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALD; - NOT_MATHERRD {ERRNO_DOMAIN;} - } - *(double *)retval = exc.retval; - break; - } - case logf_zero: - /* logf(0) */ - { - SINGF; NAMEF = (char *) "logf"; - ifSVID - { - RETVAL_NEG_HUGEF; - NOT_MATHERRF - { - WRITEF_LOG_ZERO; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALF; - NOT_MATHERRF {ERRNO_DOMAIN;} - } - *(float *)retval = excf.retval; - break; - } - - case logl_negative: - /* logl(x < 0) */ - { - DOMAINL; NAMEL = (char *) "logl"; - ifSVID - { - RETVAL_NEG_HUGEL; - NOT_MATHERRL - { - WRITEL_LOG_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALL; - NOT_MATHERRL {ERRNO_DOMAIN;} - } - *(long double *)retval = excl.retval; - break; - } - case log_negative: - /* log(x < 0) */ - { - DOMAIND; NAMED = (char *) "log"; - ifSVID - { - RETVAL_NEG_HUGED; - NOT_MATHERRD - { - WRITED_LOG_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALD; - NOT_MATHERRD {ERRNO_DOMAIN;} - } - *(double *)retval = exc.retval; - break; - } - case logf_negative: - /* logf(x < 0) */ - { - DOMAINF; NAMEF = (char *) "logf"; - ifSVID - { - RETVAL_NEG_HUGEF; - NOT_MATHERRF - { - WRITEF_LOG_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALF; - NOT_MATHERRF{ERRNO_DOMAIN;} - } - *(float *)retval = excf.retval; - break; - } - case log1pl_zero: - /* log1pl(-1) */ - { - SINGL; NAMEL = (char *) "log1pl"; - ifSVID - { - RETVAL_NEG_HUGEL; - NOT_MATHERRL - { - WRITEL_LOG1P_ZERO; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALL; - NOT_MATHERRL {ERRNO_DOMAIN;} - } - *(long double *)retval = excl.retval; - break; - } - case log1p_zero: - /* log1p(-1) */ - { - SINGD; NAMED = (char *) "log1p"; - ifSVID - { - RETVAL_NEG_HUGED; - NOT_MATHERRD - { - WRITED_LOG1P_ZERO; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALD; - NOT_MATHERRD {ERRNO_DOMAIN;} - } - *(double *)retval = exc.retval; - break; - } - case log1pf_zero: - /* log1pf(-1) */ - { - SINGF; NAMEF = (char *) "log1pf"; - ifSVID - { - RETVAL_NEG_HUGEF; - NOT_MATHERRF - { - WRITEF_LOG1P_ZERO; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALF; - NOT_MATHERRF {ERRNO_DOMAIN;} - } - *(float *)retval = excf.retval; - break; - } - case log1pl_negative: - /* log1pl(x < -1) */ - { - DOMAINL; NAMEL = (char *) "log1pl"; - ifSVID - { - RETVAL_NEG_HUGEL; - NOT_MATHERRL - { - WRITEL_LOG1P_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALL; - NOT_MATHERRL {ERRNO_DOMAIN;} - } - *(long double *)retval = excl.retval; - break; - } - case log1p_negative: - /* log1p(x < -1) */ - { - DOMAIND; NAMED = (char *) "log1p"; - ifSVID - { - RETVAL_NEG_HUGED; - NOT_MATHERRD - { - WRITED_LOG1P_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALD; - NOT_MATHERRD {ERRNO_DOMAIN;} - } - *(double *)retval = exc.retval; - break; - } - case log1pf_negative: - /* log1pf(x < -1) */ - { - DOMAINF; NAMEF = (char *) "log1pf"; - ifSVID - { - RETVAL_NEG_HUGEF; - NOT_MATHERRF - { - WRITEF_LOG1P_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALF; - NOT_MATHERRF {ERRNO_DOMAIN;} - } - *(float *)retval = excf.retval; - break; - } - case log10l_zero: - /* log10l(0) */ - { - SINGL; NAMEL = (char *) "log10l"; - ifSVID - { - RETVAL_NEG_HUGEL; - NOT_MATHERRL - { - WRITEL_LOG10_ZERO; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALL; - NOT_MATHERRL {ERRNO_DOMAIN;} - } - *(long double *)retval = excl.retval; - break; - } - case log10_zero: - /* log10(0) */ - { - SINGD; NAMED = (char *) "log10"; - ifSVID - { - RETVAL_NEG_HUGED; - NOT_MATHERRD - { - WRITED_LOG10_ZERO; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALD; - NOT_MATHERRD {ERRNO_DOMAIN;} - } - *(double *)retval = exc.retval; - break; - } - case log10f_zero: - /* log10f(0) */ - { - SINGF; NAMEF = (char *) "log10f"; - ifSVID - { - RETVAL_NEG_HUGEF; - NOT_MATHERRF - { - WRITEF_LOG10_ZERO; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALF; - NOT_MATHERRF {ERRNO_DOMAIN;} - } - *(float *)retval = excf.retval; - break; - } - case log10l_negative: - /* log10l(x < 0) */ - { - DOMAINL; NAMEL = (char *) "log10l"; - ifSVID - { - RETVAL_NEG_HUGEL; - NOT_MATHERRL - { - WRITEL_LOG10_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALL; - NOT_MATHERRL {ERRNO_DOMAIN;} - } - *(long double *)retval = excl.retval; - break; - } - case log10_negative: - /* log10(x < 0) */ - { - DOMAIND; NAMED = (char *) "log10"; - ifSVID - { - RETVAL_NEG_HUGED; - NOT_MATHERRD - { - WRITED_LOG10_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALD; - NOT_MATHERRD {ERRNO_DOMAIN;} - } - *(double *)retval = exc.retval; - break; - } - case log10f_negative: - /* log10f(x < 0) */ - { - DOMAINF; NAMEF = (char *) "log10f"; - ifSVID - { - RETVAL_NEG_HUGEF; - NOT_MATHERRF - { - WRITEF_LOG10_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALF; - NOT_MATHERRF {ERRNO_DOMAIN;} - } - *(float *)retval = excf.retval; - break; - } - case log2l_zero: - /* log2l(0) */ - { - SINGL; NAMEL = (char *) "log2l"; - ifSVID - { - RETVAL_NEG_HUGEL; - NOT_MATHERRL - { - WRITEL_LOG2_ZERO; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALL; - NOT_MATHERRL {ERRNO_DOMAIN;} - } - *(long double *)retval = excl.retval; - break; - } - case log2_zero: - /* log2(0) */ - { - SINGD; NAMED = (char *) "log2"; - ifSVID - { - RETVAL_NEG_HUGED; - NOT_MATHERRD - { - WRITED_LOG2_ZERO; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALD; - NOT_MATHERRD {ERRNO_DOMAIN;} - } - *(double *)retval = exc.retval; - break; - } - case log2f_zero: - /* log2f(0) */ - { - SINGF; NAMEF = (char *) "log2f"; - ifSVID - { - RETVAL_NEG_HUGEF; - NOT_MATHERRF - { - WRITEF_LOG2_ZERO; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALF; - NOT_MATHERRF {ERRNO_DOMAIN;} - } - *(float *)retval = excf.retval; - break; - } - case log2l_negative: - /* log2l(x < 0) */ - { - DOMAINL; NAMEL = (char *) "log2l"; - ifSVID - { - RETVAL_NEG_HUGEL; - NOT_MATHERRL - { - WRITEL_LOG2_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALL; - NOT_MATHERRL {ERRNO_DOMAIN;} - } - *(long double *)retval = excl.retval; - break; - } - case log2_negative: - /* log2(x < 0) */ - { - DOMAIND; NAMED = (char *) "log2"; - ifSVID - { - RETVAL_NEG_HUGED; - NOT_MATHERRD - { - WRITED_LOG2_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALD; - NOT_MATHERRD {ERRNO_DOMAIN;} - } - *(double *)retval = exc.retval; - break; - } - case log2f_negative: - /* log2f(x < 0) */ - { - DOMAINF; NAMEF = (char *) "log2f"; - ifSVID - { - RETVAL_NEG_HUGEF; - NOT_MATHERRF - { - WRITEF_LOG2_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALF; - NOT_MATHERRF {ERRNO_DOMAIN;} - } - *(float *)retval = excf.retval; - break; - } - case expl_overflow: - /* expl overflow */ - { - OVERFLOWL; NAMEL = (char *) "expl"; - ifSVID - { - RETVAL_HUGEL; - } - else - { - RETVAL_HUGE_VALL; - } - NOT_MATHERRL {ERRNO_RANGE;} - *(long double *)retval = excl.retval; - break; - } - case exp_overflow: - /* exp overflow */ - { - OVERFLOWD; NAMED = (char *) "exp"; - ifSVID - { - RETVAL_HUGED; - } - else - { - RETVAL_HUGE_VALD; - } - NOT_MATHERRD {ERRNO_RANGE;} - *(double *)retval = exc.retval; - break; - } - case expf_overflow: - /* expf overflow */ - { - OVERFLOWF; NAMEF = (char *) "expf"; - ifSVID - { - RETVAL_HUGEF; - } - else - { - RETVAL_HUGE_VALF; - } - NOT_MATHERRF {ERRNO_RANGE;} - *(float *)retval = excf.retval; - break; - } - case expl_underflow: - /* expl underflow */ - { - UNDERFLOWL; NAMEL = (char *) "expl"; RETVAL_ZEROL; - NOT_MATHERRL {ERRNO_RANGE;} - *(long double *)retval = excl.retval; - break; - } - case exp_underflow: - /* exp underflow */ - { - UNDERFLOWD; NAMED = (char *) "exp"; RETVAL_ZEROD; - NOT_MATHERRD {ERRNO_RANGE;} - *(double *)retval = exc.retval; - break; - } - case expf_underflow: - /* expf underflow */ - { - UNDERFLOWF; NAMEF = (char *) "expf"; RETVAL_ZEROF; - NOT_MATHERRF {ERRNO_RANGE;} - *(float *)retval = excf.retval; - break; - } - case powl_zero_to_zero: - /* powl 0**0 */ - { - DOMAINL; NAMEL = (char *) "powl"; - ifSVID - { - RETVAL_ZEROL; - NOT_MATHERRL - { - WRITEL_POW_ZERO_TO_ZERO; - ERRNO_DOMAIN; - } - *(long double *)retval = excl.retval; - } - else RETVAL_ONEL; - break; - } - case pow_zero_to_zero: - /* pow 0**0 */ - { - DOMAIND; NAMED = (char *) "pow"; - ifSVID - { - RETVAL_ZEROD; - NOT_MATHERRD - { - WRITED_POW_ZERO_TO_ZERO; - ERRNO_DOMAIN; - } - *(double *)retval = exc.retval; - } - else RETVAL_ONED; - break; - } - case powf_zero_to_zero: - /* powf 0**0 */ - { - DOMAINF; NAMEF = (char *) "powf"; - ifSVID - { - RETVAL_ZEROF; - NOT_MATHERRF - { - WRITEF_POW_ZERO_TO_ZERO; - ERRNO_DOMAIN; - } - *(float *)retval = excf.retval; - } - else RETVAL_ONEF; - break; - } - case powl_overflow: - /* powl(x,y) overflow */ - { - OVERFLOWL; NAMEL = (char *) "powl"; - ifSVID - { - if (INPUT_RESL < ZEROL_VALUE /*0*/) RETVAL_NEG_HUGEL; - else RETVAL_HUGEL; - } - else - { - if (INPUT_RESL < ZEROL_VALUE /*0*/) RETVAL_NEG_HUGE_VALL; - else RETVAL_HUGE_VALL; - } - NOT_MATHERRL {ERRNO_RANGE;} - *(long double *)retval = excl.retval; - break; - } - case pow_overflow: - /* pow(x,y) overflow */ - { - OVERFLOWD; NAMED = (char *) "pow"; - ifSVID - { - if (INPUT_RESD < ZEROD_VALUE /*0*/) RETVAL_NEG_HUGED; - else RETVAL_HUGED; - } - else - { - if (INPUT_RESD < ZEROD_VALUE /*0*/) RETVAL_NEG_HUGE_VALD; - else RETVAL_HUGE_VALD; - } - NOT_MATHERRD {ERRNO_RANGE;} - *(double *)retval = exc.retval; - break; - } - case powf_overflow: - /* powf(x,y) overflow */ - { - OVERFLOWF; NAMEF = (char *) "powf"; - ifSVID - { - if (INPUT_RESF < ZEROF_VALUE /*0*/) RETVAL_NEG_HUGEF; - else RETVAL_HUGEF; - } - else - { - if (INPUT_RESF < ZEROF_VALUE /*0*/) RETVAL_NEG_HUGE_VALF; - else RETVAL_HUGE_VALF; - } - NOT_MATHERRF {ERRNO_RANGE;} - *(float *)retval = excf.retval; - break; - } - case powl_underflow: - /* powl(x,y) underflow */ - { - UNDERFLOWL; NAMEL = (char *) "powl"; RETVAL_ZEROL; - NOT_MATHERRL {ERRNO_RANGE;} - *(long double *)retval = excl.retval; - break; - } - case pow_underflow: - /* pow(x,y) underflow */ - { - UNDERFLOWD; NAMED = (char *) "pow"; RETVAL_ZEROD; - NOT_MATHERRD {ERRNO_RANGE;} - *(double *)retval = exc.retval; - break; - } - case powf_underflow: - /* powf(x,y) underflow */ - { - UNDERFLOWF; NAMEF = (char *) "powf"; RETVAL_ZEROF; - NOT_MATHERRF {ERRNO_RANGE;} - *(float *)retval = excf.retval; - break; - } - case powl_zero_to_negative: - /* 0 to neg */ - { - DOMAINL; NAMEL = (char *) "powl"; - ifSVID - { - RETVAL_ZEROL; - NOT_MATHERRL - { - WRITEL_POW_ZERO_TO_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALL; - NOT_MATHERRL {ERRNO_DOMAIN;} - } - *(long double *)retval = excl.retval; - break; - } - case pow_zero_to_negative: - /* 0**neg */ - { - DOMAIND; NAMED = (char *) "pow"; - ifSVID - { - RETVAL_ZEROD; - NOT_MATHERRD - { - WRITED_POW_ZERO_TO_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALD; - NOT_MATHERRD {ERRNO_DOMAIN;} - } - *(double *)retval = exc.retval; - break; - } - case powf_zero_to_negative: - /* 0**neg */ - { - DOMAINF; NAMEF = (char *) "powf"; - ifSVID - { - RETVAL_ZEROF; - NOT_MATHERRF - { - WRITEF_POW_ZERO_TO_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALF; - NOT_MATHERRF {ERRNO_DOMAIN;} - } - *(float *)retval = excf.retval; - break; - } - case powl_neg_to_non_integer: - /* neg**non_integral */ - { - DOMAINL; NAMEL = (char *) "powl"; - ifSVID - { - RETVAL_ZEROL; - NOT_MATHERRL - { - WRITEL_POW_NEG_TO_NON_INTEGER; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRL {ERRNO_DOMAIN;} - } - *(long double *)retval = excl.retval; - break; - } - case pow_neg_to_non_integer: - /* neg**non_integral */ - { - DOMAIND; NAMED = (char *) "pow"; - ifSVID - { - RETVAL_ZEROD; - NOT_MATHERRD - { - WRITED_POW_NEG_TO_NON_INTEGER; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRD {ERRNO_DOMAIN;} - } - *(double *)retval = exc.retval; - break; - } - case powf_neg_to_non_integer: - /* neg**non-integral */ - { - DOMAINF; NAMEF = (char *) "powf"; - ifSVID - { - RETVAL_ZEROF; - NOT_MATHERRF - { - WRITEF_POW_NEG_TO_NON_INTEGER; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRF {ERRNO_DOMAIN;} - } - *(float *)retval = excf.retval; - break; - } - case powl_nan_to_zero: - /* pow(NaN,0.0) */ - /* Special Error */ - { - DOMAINL; NAMEL = (char *) "powl"; - *(long double *)retval = *(long double *)arg1; - NOT_MATHERRL {ERRNO_DOMAIN;} - *(long double *)retval = excl.retval; - break; - } - case pow_nan_to_zero: - /* pow(NaN,0.0) */ - /* Special Error */ - { - DOMAIND; NAMED = (char *) "pow"; - *(double *)retval = *(double *)arg1; - NOT_MATHERRD {ERRNO_DOMAIN;} - *(double *)retval = exc.retval; - break; - } - case powf_nan_to_zero: - /* powf(NaN,0.0) */ - /* Special Error */ - { - DOMAINF; NAMEF = (char *) "powf"; - *(float *)retval = *(float *)arg1; - NOT_MATHERRF {ERRNO_DOMAIN;} - *(float *)retval = excf.retval; - break; - } - case atan2l_zero: - /* atan2l(0.0,0.0) */ - { - DOMAINL; NAMEL = (char *) "atan2l"; - RETVAL_ZEROL; - NOT_MATHERRL - { - ifSVID - { - WRITEL_ATAN2_ZERO_BY_ZERO; - } - ERRNO_DOMAIN; - } - *(long double *)retval = excl.retval; - break; - } - case atan2_zero: - /* atan2(0.0,0.0) */ - { - DOMAIND; NAMED = (char *) "atan2"; - RETVAL_ZEROD; - NOT_MATHERRD - { - ifSVID - { - WRITED_ATAN2_ZERO_BY_ZERO; - } - ERRNO_DOMAIN; - } - *(double *)retval = exc.retval; - break; - } - case atan2f_zero: - /* atan2f(0.0,0.0) */ - { - DOMAINF; NAMEF = (char *) "atan2f"; - RETVAL_ZEROF; - NOT_MATHERRF - { - ifSVID - { - WRITEF_ATAN2_ZERO_BY_ZERO; - } - ERRNO_DOMAIN; - } - *(float *)retval = excf.retval; - break; - } - case atan2dl_zero: - /* atan2dl(0.0,0.0) */ - { - DOMAINL; NAMEL = (char *) "atan2dl"; - RETVAL_ZEROL; - NOT_MATHERRL - { - ifSVID - { - WRITEL_ATAN2D_ZERO_BY_ZERO; - } - ERRNO_DOMAIN; - } - *(long double *)retval = excl.retval; - break; - } - case atan2d_zero: - /* atan2d(0.0,0.0) */ - { - DOMAIND; NAMED = (char *) "atan2d"; - RETVAL_ZEROD; - NOT_MATHERRD - { - ifSVID - { - WRITED_ATAN2D_ZERO_BY_ZERO; - } - ERRNO_DOMAIN; - } - *(double *)retval = exc.retval; - break; - } - case atan2df_zero: - /* atan2df(0.0,0.0) */ - { - DOMAINF; NAMEF = (char *) "atan2df"; - RETVAL_ZEROF; - NOT_MATHERRF - { - ifSVID - { - WRITEF_ATAN2D_ZERO_BY_ZERO; - } - ERRNO_DOMAIN; - } - *(float *)retval = excf.retval; - break; - } - case expm1_overflow: - /* expm1(finite) overflow */ - /* Overflow is the only documented */ - /* special value. */ - { - ERRNO_RANGE; - break; - } - case expm1f_overflow: - /* expm1f(finite) overflow */ - { - ERRNO_RANGE; - break; - } - case expm1_underflow: - /* expm1(finite) underflow */ - /* Underflow is not documented */ - /* special value. */ - { - ERRNO_RANGE; - break; - } - case expm1f_underflow: - /* expm1f(finite) underflow */ - { - ERRNO_RANGE; - break; - } - case scalbl_underflow: - /* scalbl underflow */ - { - UNDERFLOWL; NAMEL = (char *) "scalbl"; - if (INPUT_XL < ZEROL_VALUE /*0.0L*/) RETVAL_NEG_ZEROL; - else RETVAL_ZEROL; - NOT_MATHERRL {ERRNO_RANGE;} - *(long double *)retval = excl.retval; - break; - } - case scalb_underflow: - /* scalb underflow */ - { - UNDERFLOWD; NAMED = (char *) "scalb"; - if (INPUT_XD < ZEROD_VALUE /*0.0*/) RETVAL_NEG_ZEROD; - else RETVAL_ZEROD; - NOT_MATHERRD {ERRNO_RANGE;} - *(double *)retval = exc.retval; - break; - } - case scalbf_underflow: - /* scalbf underflow */ - { - UNDERFLOWF; NAMEF = (char *) "scalbf"; - if (INPUT_XF < ZEROF_VALUE /*0.0*/) RETVAL_NEG_ZEROF; - else RETVAL_ZEROF; - NOT_MATHERRF {ERRNO_RANGE;} - *(float *)retval = excf.retval; - break; - } - case scalbl_overflow: - /* scalbl overflow */ - { - OVERFLOWL; NAMEL = (char *) "scalbl"; - if (INPUT_XL < ZEROL_VALUE /*0*/) RETVAL_NEG_HUGE_VALL; - else RETVAL_HUGE_VALL; - NOT_MATHERRL {ERRNO_RANGE;} - *(long double *)retval = excl.retval; - break; - } - case scalb_overflow: - /* scalb overflow */ - { - OVERFLOWD; NAMED = (char *) "scalb"; - if (INPUT_XD < ZEROD_VALUE /*0*/) RETVAL_NEG_HUGE_VALD; - else RETVAL_HUGE_VALD; - NOT_MATHERRD {ERRNO_RANGE;} - *(double *)retval = exc.retval; - break; - } - case scalbf_overflow: - /* scalbf overflow */ - { - OVERFLOWF; NAMEF = (char *) "scalbf"; - if (INPUT_XF < ZEROF_VALUE /*0*/) RETVAL_NEG_HUGE_VALF; - else RETVAL_HUGE_VALF; - NOT_MATHERRF {ERRNO_RANGE;} - *(float *)retval = excf.retval; - break; - } - case hypotl_overflow: - /* hypotl overflow */ - { - OVERFLOWL; NAMEL = (char *) "hypotl"; - ifSVID - { - RETVAL_HUGEL; - } - else - { - RETVAL_HUGE_VALL; - } - NOT_MATHERRL {ERRNO_RANGE;} - *(long double *)retval = excl.retval; - break; - } - case hypot_overflow: - /* hypot overflow */ - { - OVERFLOWD; NAMED = (char *) "hypot"; - ifSVID - { - RETVAL_HUGED; - } - else - { - RETVAL_HUGE_VALD; - } - NOT_MATHERRD {ERRNO_RANGE;} - *(double *)retval = exc.retval; - break; - } - case hypotf_overflow: - /* hypotf overflow */ - { - OVERFLOWF; NAMEF = (char *) "hypotf"; - ifSVID - { - RETVAL_HUGEF; - } - else - { - RETVAL_HUGE_VALF; - } - NOT_MATHERRF {ERRNO_RANGE;} - *(float *)retval = excf.retval; - break; - } - case acosl_gt_one: - /* acosl(x > 1) */ - { - DOMAINL; NAMEL = (char *) "acosl"; - RETVAL_ZEROL; - ifSVID - { - NOT_MATHERRL - { - WRITEL_ACOS; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRL {ERRNO_DOMAIN;} - } - *(long double *)retval = excl.retval; - break; - } - case acos_gt_one: - /* acos(x > 1) */ - { - DOMAIND; NAMED = (char *) "acos"; - RETVAL_ZEROD; - ifSVID - { - NOT_MATHERRD - { - WRITED_ACOS; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRD {ERRNO_DOMAIN;} - } - *(double *)retval = exc.retval; - break; - } - case acosf_gt_one: - /* acosf(x > 1) */ - { - DOMAINF; NAMEF = (char *) "acosf"; - RETVAL_ZEROF; - ifSVID - { - NOT_MATHERRF - { - WRITEF_ACOS; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRF {ERRNO_DOMAIN;} - } - *(float *)retval = excf.retval; - break; - } - case asinl_gt_one: - /* asinl(x > 1) */ - { - DOMAINL; NAMEL = (char *) "asinl"; - RETVAL_ZEROL; - ifSVID - { - NOT_MATHERRL - { - WRITEL_ASIN; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRL {ERRNO_DOMAIN;} - } - *(long double *)retval = excl.retval; - break; - } - case asin_gt_one: - /* asin(x > 1) */ - { - DOMAIND; NAMED = (char *) "asin"; - RETVAL_ZEROD; - ifSVID - { - NOT_MATHERRD - { - WRITED_ASIN; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRD {ERRNO_DOMAIN;} - } - *(double *)retval = exc.retval; - break; - } - case asinf_gt_one: - /* asinf(x > 1) */ - { - DOMAINF; NAMEF = (char *) "asinf"; - RETVAL_ZEROF; - ifSVID - { - NOT_MATHERRF - { - WRITEF_ASIN; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRF {ERRNO_DOMAIN;} - } - *(float *)retval = excf.retval; - break; - } - case acosdl_gt_one: - /* acosdl(x > 1) */ - { - DOMAINL; NAMEL = (char *) "acosdl"; - RETVAL_ZEROL; - ifSVID - { - NOT_MATHERRL - { - WRITEL_ACOSD; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRL {ERRNO_DOMAIN;} - } - *(long double *)retval = excl.retval; - break; - } - case acosd_gt_one: - /* acosd(x > 1) */ - { - DOMAIND; NAMED = (char *) "acosd"; - RETVAL_ZEROD; - ifSVID - { - NOT_MATHERRD - { - WRITED_ACOSD; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRD {ERRNO_DOMAIN;} - } - *(double *)retval = exc.retval; - break; - } - case acosdf_gt_one: - /* acosdf(x > 1) */ - { - DOMAINF; NAMEF = (char *) "acosdf"; - RETVAL_ZEROF; - ifSVID - { - NOT_MATHERRF - { - WRITEF_ACOSD; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRF {ERRNO_DOMAIN;} - } - *(float *)retval = excf.retval; - break; - } - case asindl_gt_one: - /* asindl(x > 1) */ - { - DOMAINL; NAMEL = (char *) "asindl"; - RETVAL_ZEROL; - ifSVID - { - NOT_MATHERRL - { - WRITEL_ASIND; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRL {ERRNO_DOMAIN;} - } - *(long double *)retval = excl.retval; - break; - } - case asind_gt_one: - /* asind(x > 1) */ - { - DOMAIND; NAMED = (char *) "asind"; - RETVAL_ZEROD; - ifSVID - { - NOT_MATHERRD - { - WRITED_ASIND; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRD {ERRNO_DOMAIN;} - } - *(double *)retval = exc.retval; - break; - } - case asindf_gt_one: - /* asindf(x > 1) */ - { - DOMAINF; NAMEF = (char *) "asindf"; - RETVAL_ZEROF; - ifSVID - { - NOT_MATHERRF - { - WRITEF_ASIND; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRF {ERRNO_DOMAIN;} - } - *(float *)retval = excf.retval; - break; - } - case coshl_overflow: - /* coshl overflow */ - { - OVERFLOWL; NAMEL = (char *) "coshl"; - ifSVID - { - RETVAL_HUGEL; - } - else - { - RETVAL_HUGE_VALL; - } - NOT_MATHERRL {ERRNO_RANGE;} - *(long double *)retval = excl.retval; - break; - } - case cosh_overflow: - /* cosh overflow */ - { - OVERFLOWD; NAMED = (char *) "cosh"; - ifSVID - { - RETVAL_HUGED; - } - else - { - RETVAL_HUGE_VALD; - } - NOT_MATHERRD {ERRNO_RANGE;} - *(double *)retval = exc.retval; - break; - } - case coshf_overflow: - /* coshf overflow */ - { - OVERFLOWF; NAMEF = (char *) "coshf"; - ifSVID - { - RETVAL_HUGEF; - } - else - { - RETVAL_HUGE_VALF; - } - NOT_MATHERRF {ERRNO_RANGE;} - *(float *)retval = excf.retval; - break; - } - case sinhl_overflow: - /* sinhl overflow */ - { - OVERFLOWL; NAMEL = (char *) "sinhl"; - ifSVID - { - if (INPUT_XL > ZEROL_VALUE /*0.0*/) RETVAL_HUGEL; - else RETVAL_NEG_HUGEL; - } - else - { - if (INPUT_XL > ZEROL_VALUE /*0.0*/) RETVAL_HUGE_VALL; - else RETVAL_NEG_HUGE_VALL; - } - NOT_MATHERRL {ERRNO_RANGE;} - *(long double *)retval = excl.retval; - break; - } - case sinh_overflow: - /* sinh overflow */ - { - OVERFLOWD; NAMED = (char *) "sinh"; - ifSVID - { - if (INPUT_XD > ZEROD_VALUE /*0.0*/) RETVAL_HUGED; - else RETVAL_NEG_HUGED; - } - else - { - if (INPUT_XD > ZEROD_VALUE /*0.0*/) RETVAL_HUGE_VALD; - else RETVAL_NEG_HUGE_VALD; - } - NOT_MATHERRD {ERRNO_RANGE;} - *(double *)retval = exc.retval; - break; - } - case sinhf_overflow: - /* sinhf overflow */ - { - OVERFLOWF; NAMEF = (char *) "sinhf"; - ifSVID - { - if (INPUT_XF > ZEROF_VALUE /*0.0*/) RETVAL_HUGEF; - else RETVAL_NEG_HUGEF; - } - else - { - if (INPUT_XF > ZEROF_VALUE /*0.0*/) RETVAL_HUGE_VALF; - else RETVAL_NEG_HUGE_VALF; - } - NOT_MATHERRF {ERRNO_RANGE;} - *(float *)retval = excf.retval; - break; - } - case acoshl_lt_one: - /* acoshl(x < 1) */ - { - DOMAINL; NAMEL = (char *) "acoshl"; - ifSVID - { - NOT_MATHERRL - { - WRITEL_ACOSH; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRL {ERRNO_DOMAIN;} - } - *(long double *)retval = excl.retval; - break; - } - case acosh_lt_one: - /* acosh(x < 1) */ - { - DOMAIND; NAMED = (char *) "acosh"; - ifSVID - { - NOT_MATHERRD - { - WRITED_ACOSH; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRD {ERRNO_DOMAIN;} - } - *(double *)retval = exc.retval; - break; - } - case acoshf_lt_one: - /* acoshf(x < 1) */ - { - DOMAINF; NAMEF = (char *) "acoshf"; - ifSVID - { - NOT_MATHERRF - { - WRITEF_ACOSH; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRF {ERRNO_DOMAIN;} - } - *(float *)retval = excf.retval; - break; - } - case atanhl_gt_one: - /* atanhl(|x| > 1) */ - { - DOMAINL; NAMEL = (char *) "atanhl"; - ifSVID - { - NOT_MATHERRL - { - WRITEL_ATANH_GT_ONE; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRL {ERRNO_DOMAIN;} - } - break; - } - case atanh_gt_one: - /* atanh(|x| > 1) */ - { - DOMAIND; NAMED = (char *) "atanh"; - ifSVID - { - NOT_MATHERRD - { - WRITED_ATANH_GT_ONE; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRD {ERRNO_DOMAIN;} - } - break; - } - case atanhf_gt_one: - /* atanhf(|x| > 1) */ - { - DOMAINF; NAMEF = (char *) "atanhf"; - ifSVID - { - NOT_MATHERRF - { - WRITEF_ATANH_GT_ONE; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRF {ERRNO_DOMAIN;} - } - break; - } - case atanhl_eq_one: - /* atanhl(|x| == 1) */ - { - SINGL; NAMEL = (char *) "atanhl"; - ifSVID - { - NOT_MATHERRL - { - WRITEL_ATANH_EQ_ONE; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRL {ERRNO_DOMAIN;} - } - break; - } - case atanh_eq_one: - /* atanh(|x| == 1) */ - { - SINGD; NAMED = (char *) "atanh"; - ifSVID - { - NOT_MATHERRD - { - WRITED_ATANH_EQ_ONE; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRD {ERRNO_DOMAIN;} - } - break; - } - case atanhf_eq_one: - /* atanhf(|x| == 1) */ - { - SINGF; NAMEF = (char *) "atanhf"; - ifSVID - { - NOT_MATHERRF - { - WRITEF_ATANH_EQ_ONE; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRF {ERRNO_DOMAIN;} - } - break; - } - case gammal_overflow: - /* gammal overflow */ - { - OVERFLOWL; NAMEL = (char *) "gammal"; - ifSVID - { - RETVAL_HUGEL; - } - else - { - RETVAL_HUGE_VALL; - } - NOT_MATHERRL {ERRNO_RANGE;} - *(long double *)retval = excl.retval; - break; - } - case gamma_overflow: - /* gamma overflow */ - { - OVERFLOWD; NAMED = (char *) "gamma"; - ifSVID - { - RETVAL_HUGED; - } - else - { - RETVAL_HUGE_VALD; - } - NOT_MATHERRD {ERRNO_RANGE;} - *(double *)retval = exc.retval; - break; - } - case gammaf_overflow: - /* gammaf overflow */ - { - OVERFLOWF; NAMEF = (char *) "gammaf"; - ifSVID - { - RETVAL_HUGEF; - } - else - { - RETVAL_HUGE_VALF; - } - NOT_MATHERRF {ERRNO_RANGE;} - *(float *)retval = excf.retval; - break; - } - case gammal_negative: - /* gammal -int or 0 */ - { - SINGL; NAMEL = (char *) "gammal"; - ifSVID - { - RETVAL_HUGEL; - NOT_MATHERRL - { - WRITEL_GAMMA_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_HUGE_VALL; - NOT_MATHERRL {ERRNO_DOMAIN;} - } - *(long double *)retval = excl.retval; - break; - } - case gamma_negative: - /* gamma -int or 0 */ - { - SINGD; NAMED = (char *) "gamma"; - ifSVID - { - RETVAL_HUGED; - NOT_MATHERRD - { - WRITED_GAMMA_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_HUGE_VALD; - NOT_MATHERRD {ERRNO_DOMAIN;} - } - *(double *)retval = exc.retval; - break; - } - case gammaf_negative: - /* gammaf -int or 0 */ - { - SINGF; NAMEF = (char *) "gammaf"; - ifSVID - { - RETVAL_HUGEF; - NOT_MATHERRF - { - WRITEF_GAMMA_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_HUGE_VALF; - NOT_MATHERRF {ERRNO_DOMAIN;} - } - *(float *)retval = excf.retval; - break; - } - case lgammal_overflow: - /* lgammal overflow */ - { - OVERFLOWL; NAMEL = (char *) "lgammal"; - ifSVID - { - RETVAL_HUGEL; - } - else - { - RETVAL_HUGE_VALL; - } - NOT_MATHERRL {ERRNO_RANGE;} - *(long double *)retval = excl.retval; - break; - } - case lgamma_overflow: - /* lgamma overflow */ - { - OVERFLOWD; NAMED = (char *) "lgamma"; - ifSVID - { - RETVAL_HUGED; - } - else - { - RETVAL_HUGE_VALD; - } - NOT_MATHERRD {ERRNO_RANGE;} - *(double *)retval = exc.retval; - break; - } - case lgammaf_overflow: - /* lgammaf overflow */ - { - OVERFLOWF; NAMEF = (char *) "lgammaf"; - ifSVID - { - RETVAL_HUGEF; - } - else - { - RETVAL_HUGE_VALF; - } - NOT_MATHERRF {ERRNO_RANGE;} - *(float *)retval = excf.retval; - break; - } - case lgammal_negative: - /* lgammal -int or 0 */ - { - SINGL; NAMEL = (char *) "lgammal"; - ifSVID - { - RETVAL_HUGEL; - NOT_MATHERRL - { - WRITEL_LGAMMA_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_HUGE_VALL; - NOT_MATHERRL {ERRNO_DOMAIN;} - } - *(long double *)retval = excl.retval; - break; - } - case lgamma_negative: - /* lgamma -int or 0 */ - { - SINGD; NAMED = (char *) "lgamma"; - ifSVID - { - RETVAL_HUGED; - NOT_MATHERRD - { - WRITED_LGAMMA_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_HUGE_VALD; - NOT_MATHERRD {ERRNO_DOMAIN;} - } - *(double *)retval = exc.retval; - break; - } - case lgammaf_negative: - /* lgammaf -int or 0 */ - { - SINGF; NAMEF = (char *) "lgammaf"; - ifSVID - { - RETVAL_HUGEF; - NOT_MATHERRF - { - WRITEF_LGAMMA_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_HUGE_VALF; - NOT_MATHERRF {ERRNO_DOMAIN;} - } - *(float *)retval = excf.retval; - break; - } - case tgammal_overflow: - /* tgammal overflow */ - { - OVERFLOWL; NAMEL = (char *) "tgammal"; - ifSVID - { - RETVAL_HUGEL; - } - else - { - RETVAL_HUGE_VALL; - } - NOT_MATHERRL {ERRNO_RANGE;} - *(long double *)retval = excl.retval; - break; - } - case tgamma_overflow: - /* tgamma overflow */ - { - OVERFLOWD; NAMED = (char *) "tgamma"; - ifSVID - { - RETVAL_HUGED; - } - else - { - RETVAL_HUGE_VALD; - } - NOT_MATHERRD {ERRNO_RANGE;} - *(double *)retval = exc.retval; - break; - } - case tgammaf_overflow: - /* tgammaf overflow */ - { - OVERFLOWF; NAMEF = (char *) "tgammaf"; - ifSVID - { - RETVAL_HUGEF; - } - else - { - RETVAL_HUGE_VALF; - } - NOT_MATHERRF {ERRNO_RANGE;} - *(float *)retval = excf.retval; - break; - } - case tgammal_negative: - /* tgammal -int or 0 */ - { - SINGL; NAMEL = (char *) "tgammal"; - ifSVID - { - NOT_MATHERRL - { - WRITEL_TGAMMA_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRL {ERRNO_DOMAIN;} - } - *(long double *)retval = excl.retval; - break; - } - case tgamma_negative: - /* tgamma -int or 0 */ - { - SINGD; NAMED = (char *) "tgamma"; - ifSVID - { - NOT_MATHERRD - { - WRITED_TGAMMA_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRD {ERRNO_DOMAIN;} - } - *(double *)retval = exc.retval; - break; - } - case tgammaf_negative: - /* tgammaf -int or 0 */ - { - SINGF; NAMEF = (char *) "tgammaf"; - ifSVID - { - NOT_MATHERRF - { - WRITEF_TGAMMA_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRF {ERRNO_DOMAIN;} - } - *(float *)retval = excf.retval; - break; - } - case j0l_gt_loss: - /* j0l > loss */ - { - TLOSSL; NAMEL = (char *) "j0l"; - RETVAL_ZEROL; - ifSVID - { - NOT_MATHERRL - { - WRITEL_J0_TLOSS; - ERRNO_RANGE; - } - } - else - { - NOT_MATHERRL {ERRNO_RANGE;} - } - *(long double *)retval = excl.retval; - break; - } - case j0_gt_loss: - /* j0 > loss */ - { - TLOSSD; NAMED = (char *) "j0"; - RETVAL_ZEROD; - ifSVID - { - NOT_MATHERRD - { - WRITED_J0_TLOSS; - ERRNO_RANGE; - } - } - else - { - NOT_MATHERRD {ERRNO_RANGE;} - } - *(double*)retval = exc.retval; - break; - } - case j0f_gt_loss: - /* j0f > loss */ - { - TLOSSF; NAMEF = (char *) "j0f"; - RETVAL_ZEROF; - ifSVID - { - NOT_MATHERRF - { - WRITEF_J0_TLOSS; - ERRNO_RANGE; - } - } - else - { - NOT_MATHERRF {ERRNO_RANGE;} - } - *(float*)retval = excf.retval; - break; - } - case j1l_gt_loss: - /* j1l > loss */ - { - TLOSSL; NAMEL = (char *) "j1l"; - RETVAL_ZEROL; - ifSVID - { - NOT_MATHERRL - { - WRITEL_J1_TLOSS; - ERRNO_RANGE; - } - } - else - { - NOT_MATHERRL {ERRNO_RANGE;} - } - *(long double *)retval = excl.retval; - break; - } - case j1_gt_loss: - /* j1 > loss */ - { - TLOSSD; NAMED = (char *) "j1"; - RETVAL_ZEROD; - ifSVID - { - NOT_MATHERRD - { - WRITED_J1_TLOSS; - ERRNO_RANGE; - } - } - else - { - NOT_MATHERRD {ERRNO_RANGE;} - } - *(double*)retval = exc.retval; - break; - } - case j1f_gt_loss: - /* j1f > loss */ - { - TLOSSF; NAMEF = (char *) "j1f"; - RETVAL_ZEROF; - ifSVID - { - NOT_MATHERRF - { - WRITEF_J1_TLOSS; - ERRNO_RANGE; - } - } - else - { - NOT_MATHERRF {ERRNO_RANGE;} - } - *(float*)retval = excf.retval; - break; - } - case jnl_gt_loss: - /* jnl > loss */ - { - TLOSSL; NAMEL = (char *) "jnl"; - RETVAL_ZEROL; - ifSVID - { - NOT_MATHERRL - { - WRITEL_JN_TLOSS; - ERRNO_RANGE; - } - } - else - { - NOT_MATHERRL {ERRNO_RANGE;} - } - *(long double *)retval = excl.retval; - break; - } - case jn_gt_loss: - /* jn > loss */ - { - TLOSSD; NAMED = (char *) "jn"; - RETVAL_ZEROD; - ifSVID - { - NOT_MATHERRD - { - WRITED_JN_TLOSS; - ERRNO_RANGE; - } - } - else - { - NOT_MATHERRD {ERRNO_RANGE;} - } - *(double*)retval = exc.retval; - break; - } - case jnf_gt_loss: - /* jnf > loss */ - { - TLOSSF; NAMEF = (char *) "jnf"; - RETVAL_ZEROF; - ifSVID - { - NOT_MATHERRF - { - WRITEF_JN_TLOSS; - ERRNO_RANGE; - } - } - else - { - NOT_MATHERRF {ERRNO_RANGE;} - } - *(float*)retval = excf.retval; - break; - } - case y0l_gt_loss: - /* y0l > loss */ - { - TLOSSL; NAMEL = (char *) "y0l"; - RETVAL_ZEROL; - ifSVID - { - NOT_MATHERRL - { - WRITEL_Y0_TLOSS; - ERRNO_RANGE; - } - } - else - { - NOT_MATHERRL {ERRNO_RANGE;} - } - *(long double *)retval = excl.retval; - break; - } - case y0_gt_loss: - /* y0 > loss */ - { - TLOSSD; NAMED = (char *) "y0"; - RETVAL_ZEROD; - ifSVID - { - NOT_MATHERRD - { - WRITED_Y0_TLOSS; - ERRNO_RANGE; - } - } - else - { - NOT_MATHERRD {ERRNO_RANGE;} - } - *(double*)retval = exc.retval; - break; - } - case y0f_gt_loss: - /* y0f > loss */ - { - TLOSSF; NAMEF = (char *) "y0f"; - RETVAL_ZEROF; - ifSVID - { - NOT_MATHERRF - { - WRITEF_Y0_TLOSS; - ERRNO_RANGE; - } - } - else - { - NOT_MATHERRF {ERRNO_RANGE;} - } - *(float*)retval = excf.retval; - break; - } - case y0l_zero: - /* y0l(0) */ - { - DOMAINL; NAMEL = (char *) "y0l"; - ifSVID - { - RETVAL_NEG_HUGEL; - NOT_MATHERRL - { - WRITEL_Y0_ZERO; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALL; - NOT_MATHERRL {ERRNO_DOMAIN;} - } - *(long double *)retval = excl.retval; - break; - } - case y0_zero: - /* y0(0) */ - { - DOMAIND; NAMED = (char *) "y0"; - ifSVID - { - RETVAL_NEG_HUGED; - NOT_MATHERRD - { - WRITED_Y0_ZERO; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALD; - NOT_MATHERRD {ERRNO_DOMAIN;} - } - *(double *)retval = exc.retval; - break; - } - case y0f_zero: - /* y0f(0) */ - { - DOMAINF; NAMEF = (char *) "y0f"; - ifSVID - { - RETVAL_NEG_HUGEF; - NOT_MATHERRF - { - WRITEF_Y0_ZERO; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALF; - NOT_MATHERRF {ERRNO_DOMAIN;} - } - *(float *)retval = excf.retval; - break; - } - case y1l_gt_loss: - /* y1l > loss */ - { - TLOSSL; NAMEL = (char *) "y1l"; - RETVAL_ZEROL; - ifSVID - { - NOT_MATHERRL - { - WRITEL_Y1_TLOSS; - ERRNO_RANGE; - } - } - else - { - NOT_MATHERRL {ERRNO_RANGE;} - } - *(long double *)retval = excl.retval; - break; - } - case y1_gt_loss: - /* y1 > loss */ - { - TLOSSD; NAMED = (char *) "y1"; - RETVAL_ZEROD; - ifSVID - { - NOT_MATHERRD - { - WRITED_Y1_TLOSS; - ERRNO_RANGE; - } - } - else - { - NOT_MATHERRD {ERRNO_RANGE;} - } - *(double*)retval = exc.retval; - break; - } - case y1f_gt_loss: - /* y1f > loss */ - { - TLOSSF; NAMEF = (char *) "y1f"; - RETVAL_ZEROF; - ifSVID - { - NOT_MATHERRF - { - WRITEF_Y1_TLOSS; - ERRNO_RANGE; - } - } - else - { - NOT_MATHERRF {ERRNO_RANGE;} - } - *(float*)retval = excf.retval; - break; - } - case y1l_zero: - /* y1l(0) */ - { - DOMAINL; NAMEL = (char *) "y1l"; - ifSVID - { - RETVAL_NEG_HUGEL; - NOT_MATHERRL - { - WRITEL_Y1_ZERO; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALL; - NOT_MATHERRL {ERRNO_DOMAIN;} - } - *(long double *)retval = excl.retval; - break; - } - case y1_zero: - /* y1(0) */ - { - DOMAIND; NAMED = (char *) "y1"; - ifSVID - { - RETVAL_NEG_HUGED; - NOT_MATHERRD - { - WRITED_Y1_ZERO; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALD; - NOT_MATHERRD {ERRNO_DOMAIN;} - } - *(double *)retval = exc.retval; - break; - } - case y1f_zero: - /* y1f(0) */ - { - DOMAINF; NAMEF = (char *) "y1f"; - ifSVID - { - RETVAL_NEG_HUGEF; - NOT_MATHERRF - { - WRITEF_Y1_ZERO; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALF; - NOT_MATHERRF {ERRNO_DOMAIN;} - } - *(float *)retval = excf.retval; - break; - } - case ynl_gt_loss: - /* ynl > loss */ - { - TLOSSL; NAMEL = (char *) "ynl"; - RETVAL_ZEROL; - ifSVID - { - NOT_MATHERRL - { - WRITEL_YN_TLOSS; - ERRNO_RANGE; - } - } - else - { - NOT_MATHERRL {ERRNO_RANGE;} - } - *(long double *)retval = excl.retval; - break; - } - case yn_gt_loss: - /* yn > loss */ - { - TLOSSD; NAMED = (char *) "yn"; - RETVAL_ZEROD; - ifSVID - { - NOT_MATHERRD - { - WRITED_YN_TLOSS; - ERRNO_RANGE; - } - } - else - { - NOT_MATHERRD {ERRNO_RANGE;} - } - *(double*)retval = exc.retval; - break; - } - case ynf_gt_loss: - /* ynf > loss */ - { - TLOSSF; NAMEF = (char *) "ynf"; - RETVAL_ZEROF; - ifSVID - { - NOT_MATHERRF - { - WRITEF_YN_TLOSS; - ERRNO_RANGE; - } - } - else - { - NOT_MATHERRF {ERRNO_RANGE;} - } - *(float*)retval = excf.retval; - break; - } - case ynl_zero: - /* ynl(0) */ - { - DOMAINL; NAMEL = (char *) "ynl"; - ifSVID - { - RETVAL_NEG_HUGEL; - NOT_MATHERRL - { - WRITEL_YN_ZERO; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALL; - NOT_MATHERRL {ERRNO_DOMAIN;} - } - *(long double *)retval = excl.retval; - break; - } - case yn_zero: - /* yn(0) */ - { - DOMAIND; NAMED = (char *) "yn"; - ifSVID - { - RETVAL_NEG_HUGED; - NOT_MATHERRD - { - WRITED_YN_ZERO; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALD; - NOT_MATHERRD {ERRNO_DOMAIN;} - } - *(double *)retval = exc.retval; - break; - } - case ynf_zero: - /* ynf(0) */ - { - DOMAINF; NAMEF = (char *) "ynf"; - ifSVID - { - RETVAL_NEG_HUGEF; - NOT_MATHERRF - { - WRITEF_YN_ZERO; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALF; - NOT_MATHERRF {ERRNO_DOMAIN;} - } - *(float *)retval = excf.retval; - break; - } - case y0l_negative: - /* y0l(x<0) */ - { - DOMAINL; NAMEL = (char *) "y0l"; - ifSVID - { - RETVAL_NEG_HUGEL; - NOT_MATHERRL - { - WRITEL_Y0_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALL; - NOT_MATHERRL {ERRNO_DOMAIN;} - } - *(long double *)retval = excl.retval; - break; - } - case y0_negative: - /* y0(x<0) */ - { - DOMAIND; NAMED = (char *) "y0"; - ifSVID - { - RETVAL_NEG_HUGED; - NOT_MATHERRD - { - WRITED_Y0_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALD; - NOT_MATHERRD {ERRNO_DOMAIN;} - } - *(double *)retval = exc.retval; - break; - } - case y0f_negative: - /* y0f(x<0) */ - { - DOMAINF; NAMEF = (char *) "y0f"; - ifSVID - { - RETVAL_NEG_HUGEF; - NOT_MATHERRF - { - WRITEF_Y0_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALF; - NOT_MATHERRF {ERRNO_DOMAIN;} - } - *(float *)retval = excf.retval; - break; - } - case y1l_negative: - /* y1l(x<0) */ - { - DOMAINL; NAMEL = (char *) "y1l"; - ifSVID - { - RETVAL_NEG_HUGEL; - NOT_MATHERRL - { - WRITEL_Y1_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALL; - NOT_MATHERRL {ERRNO_DOMAIN;} - } - *(long double *)retval = excl.retval; - break; - } - case y1_negative: - /* y1(x<0) */ - { - DOMAIND; NAMED = (char *) "y1"; - ifSVID - { - RETVAL_NEG_HUGED; - NOT_MATHERRD - { - WRITED_Y1_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALD; - NOT_MATHERRD {ERRNO_DOMAIN;} - } - *(double *)retval = exc.retval; - break; - } - case y1f_negative: - /* y1f(x<0) */ - { - DOMAINF; NAMEF = (char *) "y1f"; - ifSVID - { - RETVAL_NEG_HUGEF; - NOT_MATHERRF - { - WRITEF_Y1_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALF; - NOT_MATHERRF {ERRNO_DOMAIN;} - } - *(float *)retval = excf.retval; - break; - } - case ynl_negative: - /* ynl(x<0) */ - { - DOMAINL; NAMEL = (char *) "ynl"; - ifSVID - { - RETVAL_NEG_HUGEL; - NOT_MATHERRL - { - WRITEL_YN_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALL; - NOT_MATHERRL {ERRNO_DOMAIN;} - } - *(long double *)retval = excl.retval; - break; - } - case yn_negative: - /* yn(x<0) */ - { - DOMAIND; NAMED = (char *) "yn"; - ifSVID - { - RETVAL_NEG_HUGED; - NOT_MATHERRD - { - WRITED_YN_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALD; - NOT_MATHERRD {ERRNO_DOMAIN;} - } - *(double *)retval = exc.retval; - break; - } - case ynf_negative: - /* ynf(x<0) */ - { - DOMAINF; NAMEF = (char *) "ynf"; - ifSVID - { - RETVAL_NEG_HUGEF; - NOT_MATHERRF - { - WRITEF_YN_NEGATIVE; - ERRNO_DOMAIN; - } - } - else - { - RETVAL_NEG_HUGE_VALF; - NOT_MATHERRF {ERRNO_DOMAIN;} - } - *(float *)retval = excf.retval; - break; - } - case fmodl_by_zero: - /* fmodl(x,0) */ - { - DOMAINL; NAMEL = (char *) "fmodl"; - ifSVID - { - *(long double *)retval = *(long double *)arg1; - NOT_MATHERRL - { - WRITEL_FMOD; - ERRNO_DOMAIN; - } - } - else - { /* NaN already computed */ - NOT_MATHERRL {ERRNO_DOMAIN;} - } - *(long double *)retval = excl.retval; - break; - } - case fmod_by_zero: - /* fmod(x,0) */ - { - DOMAIND; NAMED = (char *) "fmod"; - ifSVID - { - *(double *)retval = *(double *)arg1; - NOT_MATHERRD - { - WRITED_FMOD; - ERRNO_DOMAIN; - } - } - else - { /* NaN already computed */ - NOT_MATHERRD {ERRNO_DOMAIN;} - } - *(double *)retval = exc.retval; - break; - } - case fmodf_by_zero: - /* fmodf(x,0) */ - { - DOMAINF; NAMEF = (char *) "fmodf"; - ifSVID - { - *(float *)retval = *(float *)arg1; - NOT_MATHERRF - { - WRITEF_FMOD; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRF {ERRNO_DOMAIN;} - } - *(float *)retval = excf.retval; - break; - } - case remainderl_by_zero: - /* remainderl(x,0) */ - { - DOMAINL; NAMEL = (char *) "remainderl"; - ifSVID - { - NOT_MATHERRL - { - WRITEL_REM; - ERRNO_DOMAIN; - } - } - else - { /* NaN already computed */ - NOT_MATHERRL {ERRNO_DOMAIN;} - } - *(long double *)retval = excl.retval; - break; - } - case remainder_by_zero: - /* remainder(x,0) */ - { - DOMAIND; NAMED = (char *) "remainder"; - ifSVID - { - NOT_MATHERRD - { - WRITED_REM; - ERRNO_DOMAIN; - } - } - else - { /* NaN already computed */ - NOT_MATHERRD {ERRNO_DOMAIN;} - } - *(double *)retval = exc.retval; - break; - } - case remainderf_by_zero: - /* remainderf(x,0) */ - { - DOMAINF; NAMEF = (char *) "remainderf"; - ifSVID - { - NOT_MATHERRF - { - WRITEF_REM; - ERRNO_DOMAIN; - } - } - else - { - NOT_MATHERRF {ERRNO_DOMAIN;} - } - *(float *)retval = excf.retval; - break; - } - default: - /* We don't want to abort () since SVID doesn't cover all math - library functions. */ - break; - } - return; - } -} -- cgit 1.4.1