AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-12-23 11:20:07 +00:00
Code Issues Packages Projects Releases Wiki Activity
51e15247c3
glibc/sysdeps/ia64/fpu/libm_error.c
Mike Frysinger c70a4b1db0 ia64: relocate out of ports/ subdir
2014-02-16 01:12:38 -05:00

4295 lines
95 KiB
C
Raw Blame History

/* 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 <errno.h>
#include <stdio.h>
#include <stdlib.h>
#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 _DECL_NUM(type, prefix, var, bytes...) \
ALIGNIT static const union { \
const char _bytes[sizeof (type)]; \
const type num; \
} prefix ## var = { \
._bytes = bytes, \
}
#define DECL_FLOAT(var, bytes...) \
_DECL_NUM (float, float_, var, ##bytes)
DECL_FLOAT(inf, {0x00,0x00,0x80,0x7F});
DECL_FLOAT(huge, {0xFF,0xFF,0x7F,0x7F});
DECL_FLOAT(zero, {0x00,0x00,0x00,0x00});
DECL_FLOAT(neg_inf, {0x00,0x00,0x80,0xFF});
DECL_FLOAT(neg_huge, {0xFF,0xFF,0x7F,0xFF});
DECL_FLOAT(neg_zero, {0x00,0x00,0x00,0x80});
#define DECL_DOUBLE(var, bytes...) \
_DECL_NUM (double, double_, var, ##bytes)
DECL_DOUBLE(inf, {0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0x7F});
#ifndef _LIBC
DECL_DOUBLE(huge, {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xEF,0x7F});
#endif
DECL_DOUBLE(zero, {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00});
DECL_DOUBLE(neg_inf, {0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0xFF});
#ifndef _LIBC
DECL_DOUBLE(neg_huge, {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xEF,0xFF});
#endif
DECL_DOUBLE(neg_zero, {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80});
#define DECL_LONG_DOUBLE(var, bytes...) \
_DECL_NUM (long double, long_double_, var, ##bytes)
DECL_LONG_DOUBLE(inf, {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0xFF,0x7F,0x00,0x00,0x00,0x00,0x00,0x00});
#ifndef _LIBC
DECL_LONG_DOUBLE(huge, {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0x7F,0x00,0x00,0x00,0x00,0x00,0x00});
#endif
DECL_LONG_DOUBLE(zero, {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00});
DECL_LONG_DOUBLE(neg_inf, {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0xFF,0xFF,0x00,0x00,0x00,0x00,0x00,0x00});
#ifndef _LIBC
DECL_LONG_DOUBLE(neg_huge, {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0xFF,0x00,0x00,0x00,0x00,0x00,0x00});
#endif
DECL_LONG_DOUBLE(neg_zero, {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_inf.num
#define RETVAL_NEG_HUGE_VALL *(long double *)retval = long_double_neg_inf.num
#define RETVAL_HUGEL *(long double *)retval = (long double)float_huge.num
#define RETVAL_NEG_HUGEL *(long double *)retval = (long double)float_neg_huge.num
#define RETVAL_HUGE_VALD *(double *)retval = double_inf.num
#define RETVAL_NEG_HUGE_VALD *(double *)retval = double_neg_inf.num
#define RETVAL_HUGED *(double *)retval = (double)float_huge.num
#define RETVAL_NEG_HUGED *(double *)retval = (double)float_neg_huge.num
#define RETVAL_HUGE_VALF *(float *)retval = float_inf.num
#define RETVAL_NEG_HUGE_VALF *(float *)retval = float_neg_inf.num
#define RETVAL_HUGEF *(float *)retval = float_huge.num
#define RETVAL_NEG_HUGEF *(float *)retval = float_neg_huge.num
#define ZEROL_VALUE long_double_zero.num
#define ZEROD_VALUE double_zero.num
#define ZEROF_VALUE float_zero.num
#define RETVAL_ZEROL *(long double *)retval = long_double_zero.num
#define RETVAL_ZEROD *(double *)retval = double_zero.num
#define RETVAL_ZEROF *(float *)retval = float_zero.num
#define RETVAL_NEG_ZEROL *(long double *)retval = long_double_neg_zero.num
#define RETVAL_NEG_ZEROD *(double *)retval = double_neg_zero.num
#define RETVAL_NEG_ZEROF *(float *)retval = float_neg_zero.num
#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;
}
}
Reference in New Issue View Git Blame Copy Permalink