Back to index

glibc  2.9
libm_error.c
Go to the documentation of this file.
00001 /* file: libm_error.c */
00002 
00003 
00004 // Copyright (c) 2000 - 2005, Intel Corporation
00005 // All rights reserved.
00006 //
00007 // Contributed 2000 by the Intel Numerics Group, Intel Corporation
00008 //
00009 // Redistribution and use in source and binary forms, with or without
00010 // modification, are permitted provided that the following conditions are
00011 // met:
00012 //
00013 // * Redistributions of source code must retain the above copyright
00014 // notice, this list of conditions and the following disclaimer.
00015 //
00016 // * Redistributions in binary form must reproduce the above copyright
00017 // notice, this list of conditions and the following disclaimer in the
00018 // documentation and/or other materials provided with the distribution.
00019 //
00020 // * The name of Intel Corporation may not be used to endorse or promote
00021 // products derived from this software without specific prior written
00022 // permission.
00023 
00024 //
00025 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
00026 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
00027 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
00028 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL OR ITS
00029 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
00030 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
00031 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
00032 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
00033 // OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR TORT (INCLUDING
00034 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
00035 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00036 //
00037 // Intel Corporation is the author of this code, and requests that all
00038 // problem reports or change requests be submitted to it directly at
00039 // http://www.intel.com/software/products/opensource/libraries/num.htm.
00040 //
00041 // History
00042 //==============================================================
00043 //  2/02/00: Initial version
00044 //  3/22/00: Updated to support flexible and dynamic error handling.
00045 //  8/16/00: Changed all matherr function-calls to use the pmatherr
00046 //           function-pointers.
00047 // 10/03/00: Corrected a scalb type.
00048 // 11/28/00: Changed INPUT_XL to INPUT_XD for scalb_underflow case.
00049 // 12/07/00: Added code to make scalbn error support equivalent to ldexp.
00050 //  2/07/01: Added __declspec(align(16)) to long double constants to correct
00051 //           alignment problem.
00052 //  4/23/01: Added code for remquo
00053 //  6/07/01: Added code for fdim, lrint, lround, llrint, llround
00054 //           Deleted code for remquo
00055 //  8/15/01: Added code for scalbln, nexttoward
00056 // 12/10/01: Added code for erfc
00057 // 12/27/01: Added code for degree argument functions
00058 // 01/02/02: Added code for tand, cotd
00059 // 01/15/02: Corrected SVID/XOPEN code for log1p, pow, and acosh
00060 // 01/25/02: Corrected ISOC for lgamma and gamma to return EDOM for neg ints
00061 // 01/28/02: Corrected SVID/XOPEN stderr message for log2
00062 // 05/20/02: Added code for cot
00063 // 07/01/02: Added code for sinhcosh
00064 // 10/04/02: Underflow detection in ISOC path redefined to
00065 //           be zero rather than tiny and inexact
00066 // 12/06/02: Added code for annuity and compound
00067 // 01/30/03: Corrected test for underflow in ISOC path to not set denormal
00068 // 04/10/03: Corrected ISOC branch for gamma/lgamma to return ERANGE for neg ints.
00069 //           Added code for tgamma
00070 // 04/11/03: Corrected POSIX/SVID/XOPEN branches for gamma/lgamma
00071 //           to return EDOM for neg ints.
00072 // 09/08/03: Corrected XOPEN/SVID result for pow overflow with neg x, pos y.
00073 // 10/14/03: Added ILP32 ifdef
00074 // 12/12/03: Corrected XOPEN/SVID results for powf_zero_to_negative,
00075 //           powl_neg_to_non_integer, atan2f_zero, atan2df_zero,
00076 //           acoshf_lt_one, acosh_lt_one.
00077 // 12/07/04: Cast name strings as char *.
00078 // 12/08/04: Corrected POSIX behavior for atan2_zero, acos_gt_one, asin_gt_one,
00079 //           log_negative, log10_negative, log1p_negative, and log2_negative.
00080 //           Added SVID and XOPEN case log2l_zero.
00081 // 12/13/04: Corrected POSIX behavior for exp2_overflow, exp2_underflow,
00082 //           exp10_overflow, exp10_underflow.  Added ISOC to set errno for
00083 //           exp10_underflow.
00084 // 12/14/04: Corrected POSIX behavior for nextafter_overflow,
00085 //           nextafter_underflow, nexttoward_overflow, nexttoward_underflow.
00086 //           Added ISOC to set errno for nextafter and nexttoward underflow.
00087 // 12/15/04: Corrected POSIX behavior for exp, exp2, and exp10 underflow.
00088 // 03/31/05: Added missing ALIGNIT statement to 6 float constants.
00089 
00090 #include <errno.h>
00091 #include <stdio.h>
00092 #include <stdlib.h>
00093 #include "libm_support.h"
00094 
00095 #ifdef _LIBC
00096 # define pmatherr matherr
00097 # define pmatherrf matherrf
00098 # define pmatherrl matherrl
00099 #else
00100 _LIB_VERSION_TYPE
00101 #if defined( __POSIX__ )
00102 _LIB_VERSIONIMF = _POSIX_;
00103 #elif defined( __XOPEN__ )
00104 _LIB_VERSIONIMF = _XOPEN_;
00105 #elif defined( __SVID__ )
00106 _LIB_VERSIONIMF = _SVID_;
00107 #elif defined( __IEEE__ )
00108 _LIB_VERSIONIMF = _IEEE_;
00109 #else
00110 _LIB_VERSIONIMF = _ISOC_;
00111 #endif
00112 
00113 /************************************************************/
00114 /* matherrX function pointers and setusermatherrX functions */
00115 /************************************************************/
00116 int (*pmatherrf)(struct exceptionf*) = MATHERR_F;
00117 int (*pmatherr)(struct EXC_DECL_D*) = MATHERR_D;
00118 int (*pmatherrl)(struct exceptionl*) = matherrl;
00119 
00120 void __libm_setusermatherrf( int(*user_merrf)(struct exceptionf*) )
00121 {   pmatherrf = ( (user_merrf==NULL)? (MATHERR_F) : (user_merrf) ); }
00122 
00123 void __libm_setusermatherr( int(*user_merr)(struct EXC_DECL_D*) )
00124 {   pmatherr = ( (user_merr==NULL)? (MATHERR_D) : (user_merr) );    }
00125 
00126 void __libm_setusermatherrl( int(*user_merrl)(struct exceptionl*) )
00127 {   pmatherrl = ( (user_merrl==NULL)? (matherrl) : (user_merrl) );  }
00128 
00129 #endif /* !_LIBC */
00130 
00131 /***********************************************/
00132 /* error-handling function, libm_error_support */
00133 /***********************************************/
00134 void __libm_error_support(void *arg1,void *arg2,void *retval,error_types input_tag)
00135 {
00136 
00137 # ifdef __cplusplus
00138 struct __exception exc;
00139 # else
00140 struct exception  exc;
00141 # endif
00142 
00143 struct exceptionf excf;
00144 struct exceptionl excl;
00145 
00146 # ifdef __GNUC__
00147 #define ALIGNIT __attribute__ ((__aligned__ (16)))
00148 # elif defined opensource
00149 #define ALIGNIT
00150 # else
00151 #define ALIGNIT __declspec(align(16))
00152 # endif
00153 
00154 # ifdef SIZE_LONG_INT_64
00155 #define __INT_64__ signed long
00156 # else
00157 # if ILP32
00158 #define __INT_64__ signed long long
00159 # else
00160 #define __INT_64__ __int64
00161 # endif
00162 # endif
00163 
00164 
00165 #define STATIC static
00166 
00167 ALIGNIT
00168 STATIC const char float_inf[4] = {0x00,0x00,0x80,0x7F};
00169 ALIGNIT
00170 STATIC const char float_huge[4] = {0xFF,0xFF,0x7F,0x7F};
00171 ALIGNIT
00172 STATIC const char float_zero[4] = {0x00,0x00,0x00,0x00};
00173 ALIGNIT
00174 STATIC const char float_neg_inf[4] = {0x00,0x00,0x80,0xFF};
00175 ALIGNIT
00176 STATIC const char float_neg_huge[4] = {0xFF,0xFF,0x7F,0xFF};
00177 ALIGNIT
00178 STATIC const char float_neg_zero[4] = {0x00,0x00,0x00,0x80};
00179 ALIGNIT
00180 STATIC const char double_inf[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0x7F};
00181 #ifndef _LIBC
00182 ALIGNIT
00183 STATIC const char double_huge[8] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xEF,0x7F};
00184 #endif
00185 ALIGNIT
00186 STATIC const char double_zero[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
00187 ALIGNIT
00188 STATIC const char double_neg_inf[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0xFF};
00189 #ifndef _LIBC
00190 ALIGNIT
00191 STATIC const char double_neg_huge[8] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xEF,0xFF};
00192 #endif
00193 ALIGNIT
00194 STATIC const char double_neg_zero[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80};
00195 ALIGNIT
00196 STATIC const char long_double_inf[16] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0xFF,0x7F,0x00,0x00,0x00,0x00,0x00,0x00};
00197 ALIGNIT
00198 #ifndef _LIBC
00199 STATIC const char long_double_huge[16] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0x7F,0x00,0x00,0x00,0x00,0x00,0x00};
00200 #endif
00201 ALIGNIT
00202 STATIC const char long_double_zero[16] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
00203 ALIGNIT
00204 STATIC const char long_double_neg_inf[16] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0xFF,0xFF,0x00,0x00,0x00,0x00,0x00,0x00};
00205 ALIGNIT
00206 #ifndef _LIBC
00207 STATIC const char long_double_neg_huge[16] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0xFF,0x00,0x00,0x00,0x00,0x00,0x00};
00208 #endif
00209 ALIGNIT
00210 STATIC const char long_double_neg_zero[16] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x00,0x00,0x00};
00211 
00212 
00213 #define RETVAL_HUGE_VALL *(long double *)retval =  *(long double *)long_double_inf
00214 #define RETVAL_NEG_HUGE_VALL *(long double *)retval = *(long double *)long_double_neg_inf
00215 #define RETVAL_HUGEL *(long double *)retval = (long double)*(float *)float_huge
00216 #define RETVAL_NEG_HUGEL *(long double *)retval =(long double)*(float*)float_neg_huge
00217 
00218 #define RETVAL_HUGE_VALD *(double *)retval = *(double *) double_inf
00219 #define RETVAL_NEG_HUGE_VALD *(double *)retval = *(double *) double_neg_inf
00220 #define RETVAL_HUGED *(double *)retval = (double) *(float *)float_huge
00221 #define RETVAL_NEG_HUGED *(double *)retval = (double) *(float *) float_neg_huge
00222 
00223 #define RETVAL_HUGE_VALF *(float *)retval =  *(float *) float_inf
00224 #define RETVAL_NEG_HUGE_VALF *(float *)retval = *(float *) float_neg_inf
00225 #define RETVAL_HUGEF *(float *)retval = *(float *) float_huge
00226 #define RETVAL_NEG_HUGEF *(float *)retval = *(float *) float_neg_huge
00227 
00228 #define ZEROL_VALUE *(long double *)long_double_zero
00229 #define ZEROD_VALUE *(double *)double_zero
00230 #define ZEROF_VALUE *(float *)float_zero
00231 
00232 #define RETVAL_ZEROL *(long double *)retval = *(long double *)long_double_zero
00233 #define RETVAL_ZEROD *(double *)retval = *(double *)double_zero
00234 #define RETVAL_ZEROF *(float *)retval = *(float *)float_zero
00235 
00236 #define RETVAL_NEG_ZEROL *(long double *)retval = *(long double *)long_double_neg_zero
00237 #define RETVAL_NEG_ZEROD *(double *)retval = *(double *)double_neg_zero
00238 #define RETVAL_NEG_ZEROF *(float *)retval = *(float *)float_neg_zero
00239 
00240 #define RETVAL_ONEL *(long double *)retval = (long double) 1.0
00241 #define RETVAL_ONED *(double *)retval = 1.0
00242 #define RETVAL_ONEF *(float *)retval = 1.0f
00243 
00244 #define NOT_MATHERRL excl.arg1=*(long double *)arg1;excl.arg2=*(long double *)arg2;excl.retval=*(long double *)retval;if(!pmatherrl(&excl))
00245 #define NOT_MATHERRD exc.arg1=*(double *)arg1;exc.arg2=*(double *)arg2;exc.retval=*(double *)retval;if(!pmatherr(&exc))
00246 #define NOT_MATHERRF excf.arg1=*(float *)arg1;excf.arg2=*(float *)arg2;excf.retval=*(float *)retval;if(!pmatherrf(&excf))
00247 
00248 #define ifSVID if(_LIB_VERSIONIMF==_SVID_)
00249 
00250 #define NAMEL excl.name
00251 #define NAMED exc.name
00252 #define NAMEF excf.name
00253 
00254 //
00255 // These should work OK for MS because they are ints -
00256 // leading underbars are not necessary.
00257 //
00258 
00259 #define DOMAIN          1
00260 #define SING            2
00261 #define OVERFLOW        3
00262 #define UNDERFLOW       4
00263 #define TLOSS           5
00264 #define PLOSS           6
00265 
00266 #define SINGL excl.type = SING
00267 #define DOMAINL excl.type = DOMAIN
00268 #define OVERFLOWL excl.type = OVERFLOW
00269 #define UNDERFLOWL excl.type = UNDERFLOW
00270 #define TLOSSL excl.type = TLOSS
00271 #define SINGD exc.type = SING
00272 #define DOMAIND exc.type = DOMAIN
00273 #define OVERFLOWD exc.type = OVERFLOW
00274 #define UNDERFLOWD exc.type = UNDERFLOW
00275 #define TLOSSD exc.type = TLOSS
00276 #define SINGF excf.type = SING
00277 #define DOMAINF excf.type = DOMAIN
00278 #define OVERFLOWF excf.type = OVERFLOW
00279 #define UNDERFLOWF excf.type = UNDERFLOW
00280 #define TLOSSF excf.type = TLOSS
00281 
00282 #define INPUT_XL (excl.arg1=*(long double*)arg1)
00283 #define INPUT_XD (exc.arg1=*(double*)arg1)
00284 #define INPUT_XF (excf.arg1=*(float*)arg1)
00285 #define INPUT_YL (excl.arg2=*(long double*)arg2)
00286 #define INPUT_YD (exc.arg2=*(double*)arg2)
00287 #define INPUT_YF (excf.arg2=*(float*)arg2)
00288 #define INPUT_RESL (*(long double *)retval)
00289 #define INPUT_RESD (*(double *)retval)
00290 #define INPUT_RESF (*(float *)retval)
00291 #define INPUT_RESI64 (*(__INT_64__ *)retval)
00292 
00293 #define WRITEL_LOG_ZERO fputs("logl: SING error\n",stderr)
00294 #define WRITED_LOG_ZERO fputs("log: SING error\n",stderr)
00295 #define WRITEF_LOG_ZERO fputs("logf: SING error\n",stderr)
00296 #define WRITEL_LOG_NEGATIVE fputs("logl: DOMAIN error\n",stderr)
00297 #define WRITED_LOG_NEGATIVE fputs("log: DOMAIN error\n",stderr)
00298 #define WRITEF_LOG_NEGATIVE fputs("logf: DOMAIN error\n",stderr)
00299 #define WRITEL_Y0_ZERO fputs("y0l: DOMAIN error\n",stderr)
00300 #define WRITED_Y0_ZERO fputs("y0: DOMAIN error\n",stderr)
00301 #define WRITEF_Y0_ZERO fputs("y0f: DOMAIN error\n",stderr)
00302 #define WRITEL_Y0_NEGATIVE fputs("y0l: DOMAIN error\n",stderr)
00303 #define WRITED_Y0_NEGATIVE fputs("y0: DOMAIN error\n",stderr)
00304 #define WRITEF_Y0_NEGATIVE fputs("y0f: DOMAIN error\n",stderr)
00305 #define WRITEL_Y1_ZERO fputs("y1l: DOMAIN error\n",stderr)
00306 #define WRITED_Y1_ZERO fputs("y1: DOMAIN error\n",stderr)
00307 #define WRITEF_Y1_ZERO fputs("y1f: DOMAIN error\n",stderr)
00308 #define WRITEL_Y1_NEGATIVE fputs("y1l: DOMAIN error\n",stderr)
00309 #define WRITED_Y1_NEGATIVE fputs("y1: DOMAIN error\n",stderr)
00310 #define WRITEF_Y1_NEGATIVE fputs("y1f: DOMAIN error\n",stderr)
00311 #define WRITEL_YN_ZERO fputs("ynl: DOMAIN error\n",stderr)
00312 #define WRITED_YN_ZERO fputs("yn: DOMAIN error\n",stderr)
00313 #define WRITEF_YN_ZERO fputs("ynf: DOMAIN error\n",stderr)
00314 #define WRITEL_YN_NEGATIVE fputs("ynl: DOMAIN error\n",stderr)
00315 #define WRITED_YN_NEGATIVE fputs("yn: DOMAIN error\n",stderr)
00316 #define WRITEF_YN_NEGATIVE fputs("ynf: DOMAIN error\n",stderr)
00317 #define WRITEL_LOG1P_ZERO fputs("log1pl: SING error\n",stderr)
00318 #define WRITED_LOG1P_ZERO fputs("log1p: SING error\n",stderr)
00319 #define WRITEF_LOG1P_ZERO fputs("log1pf: SING error\n",stderr)
00320 #define WRITEL_LOG1P_NEGATIVE fputs("log1pl: DOMAIN error\n",stderr)
00321 #define WRITED_LOG1P_NEGATIVE fputs("log1p: DOMAIN error\n",stderr)
00322 #define WRITEF_LOG1P_NEGATIVE fputs("log1pf: DOMAIN error\n",stderr)
00323 #define WRITEL_LOG10_ZERO fputs("log10l: SING error\n",stderr)
00324 #define WRITED_LOG10_ZERO fputs("log10: SING error\n",stderr)
00325 #define WRITEF_LOG10_ZERO fputs("log10f: SING error\n",stderr)
00326 #define WRITEL_LOG10_NEGATIVE fputs("log10l: DOMAIN error\n",stderr)
00327 #define WRITED_LOG10_NEGATIVE fputs("log10: DOMAIN error\n",stderr)
00328 #define WRITEF_LOG10_NEGATIVE fputs("log10f: DOMAIN error\n",stderr)
00329 #define WRITEL_LOG2_ZERO fputs("log2l: SING error\n",stderr)
00330 #define WRITED_LOG2_ZERO fputs("log2: SING error\n",stderr)
00331 #define WRITEF_LOG2_ZERO fputs("log2f: SING error\n",stderr)
00332 #define WRITEL_LOG2_NEGATIVE fputs("log2l: DOMAIN error\n",stderr)
00333 #define WRITED_LOG2_NEGATIVE fputs("log2: DOMAIN error\n",stderr)
00334 #define WRITEF_LOG2_NEGATIVE fputs("log2f: DOMAIN error\n",stderr)
00335 #define WRITEL_POW_ZERO_TO_ZERO fputs("powl(0,0): DOMAIN error\n",stderr)
00336 #define WRITED_POW_ZERO_TO_ZERO fputs("pow(0,0): DOMAIN error\n",stderr)
00337 #define WRITEF_POW_ZERO_TO_ZERO fputs("powf(0,0): DOMAIN error\n",stderr)
00338 #define WRITEL_POW_ZERO_TO_NEGATIVE fputs("powl(0,negative): DOMAIN error\n",stderr)
00339 #define WRITED_POW_ZERO_TO_NEGATIVE fputs("pow(0,negative): DOMAIN error\n",stderr)
00340 #define WRITEF_POW_ZERO_TO_NEGATIVE fputs("powf(0,negative): DOMAIN error\n",stderr)
00341 #define WRITEL_POW_NEG_TO_NON_INTEGER fputs("powl(negative,non-integer): DOMAIN error\n",stderr)
00342 #define WRITED_POW_NEG_TO_NON_INTEGER fputs("pow(negative,non-integer): DOMAIN error\n",stderr)
00343 #define WRITEF_POW_NEG_TO_NON_INTEGER fputs("powf(negative,non-integer): DOMAIN error\n",stderr)
00344 #define WRITEL_ATAN2_ZERO_BY_ZERO fputs("atan2l: DOMAIN error\n",stderr)
00345 #define WRITED_ATAN2_ZERO_BY_ZERO fputs("atan2: DOMAIN error\n",stderr)
00346 #define WRITEF_ATAN2_ZERO_BY_ZERO fputs("atan2f: DOMAIN error\n",stderr)
00347 #define WRITEL_SQRT fputs("sqrtl: DOMAIN error\n",stderr)
00348 #define WRITED_SQRT fputs("sqrt: DOMAIN error\n",stderr)
00349 #define WRITEF_SQRT fputs("sqrtf: DOMAIN error\n",stderr)
00350 #define WRITEL_FMOD fputs("fmodl: DOMAIN error\n",stderr)
00351 #define WRITED_FMOD fputs("fmod: DOMAIN error\n",stderr)
00352 #define WRITEF_FMOD fputs("fmodf: DOMAIN error\n",stderr)
00353 #define WRITEL_REM fputs("remainderl: DOMAIN error\n",stderr)
00354 #define WRITED_REM fputs("remainder: DOMAIN error\n",stderr)
00355 #define WRITEF_REM fputs("remainderf: DOMAIN error\n",stderr)
00356 #define WRITEL_ACOS fputs("acosl: DOMAIN error\n",stderr)
00357 #define WRITED_ACOS fputs("acos: DOMAIN error\n",stderr)
00358 #define WRITEF_ACOS fputs("acosf: DOMAIN error\n",stderr)
00359 #define WRITEL_ASIN fputs("asinl: DOMAIN error\n",stderr)
00360 #define WRITED_ASIN fputs("asin: DOMAIN error\n",stderr)
00361 #define WRITEF_ASIN fputs("asinf: DOMAIN error\n",stderr)
00362 #define WRITEL_ACOSH fputs("acoshl: DOMAIN error\n",stderr)
00363 #define WRITED_ACOSH fputs("acosh: DOMAIN error\n",stderr)
00364 #define WRITEF_ACOSH fputs("acoshf: DOMAIN error\n",stderr)
00365 #define WRITEL_ATANH_GT_ONE fputs("atanhl: DOMAIN error\n",stderr)
00366 #define WRITED_ATANH_GT_ONE fputs("atanh: DOMAIN error\n",stderr)
00367 #define WRITEF_ATANH_GT_ONE fputs("atanhf: DOMAIN error\n",stderr)
00368 #define WRITEL_ATANH_EQ_ONE fputs("atanhl: SING error\n",stderr)
00369 #define WRITED_ATANH_EQ_ONE fputs("atanh: SING error\n",stderr)
00370 #define WRITEF_ATANH_EQ_ONE fputs("atanhf: SING error\n",stderr)
00371 #define WRITEL_LGAMMA_NEGATIVE fputs("lgammal: SING error\n",stderr)
00372 #define WRITED_LGAMMA_NEGATIVE fputs("lgamma: SING error\n",stderr)
00373 #define WRITEF_LGAMMA_NEGATIVE fputs("lgammaf: SING error\n",stderr)
00374 #define WRITEL_GAMMA_NEGATIVE fputs("gammal: SING error\n",stderr)
00375 #define WRITED_GAMMA_NEGATIVE fputs("gamma: SING error\n",stderr)
00376 #define WRITEF_GAMMA_NEGATIVE fputs("gammaf: SING error\n",stderr)
00377 #define WRITEL_TGAMMA_NEGATIVE fputs("tgammal: SING error\n",stderr)
00378 #define WRITED_TGAMMA_NEGATIVE fputs("tgamma: SING error\n",stderr)
00379 #define WRITEF_TGAMMA_NEGATIVE fputs("tgammaf: SING error\n",stderr)
00380 #define WRITEL_J0_TLOSS  fputs("j0l: TLOSS error\n",stderr)
00381 #define WRITEL_Y0_TLOSS  fputs("y0l: TLOSS error\n",stderr)
00382 #define WRITEL_J1_TLOSS  fputs("j1l: TLOSS error\n",stderr)
00383 #define WRITEL_Y1_TLOSS  fputs("y1l: TLOSS error\n",stderr)
00384 #define WRITEL_JN_TLOSS  fputs("jnl: TLOSS error\n",stderr)
00385 #define WRITEL_YN_TLOSS  fputs("ynl: TLOSS error\n",stderr)
00386 #define WRITED_J0_TLOSS  fputs("j0: TLOSS error\n",stderr)
00387 #define WRITED_Y0_TLOSS  fputs("y0: TLOSS error\n",stderr)
00388 #define WRITED_J1_TLOSS  fputs("j1: TLOSS error\n",stderr)
00389 #define WRITED_Y1_TLOSS  fputs("y1: TLOSS error\n",stderr)
00390 #define WRITED_JN_TLOSS  fputs("jn: TLOSS error\n",stderr)
00391 #define WRITED_YN_TLOSS  fputs("yn: TLOSS error\n",stderr)
00392 #define WRITEF_J0_TLOSS  fputs("j0f: TLOSS error\n",stderr)
00393 #define WRITEF_Y0_TLOSS  fputs("y0f: TLOSS error\n",stderr)
00394 #define WRITEF_J1_TLOSS  fputs("j1f: TLOSS error\n",stderr)
00395 #define WRITEF_Y1_TLOSS  fputs("y1f: TLOSS error\n",stderr)
00396 #define WRITEF_JN_TLOSS  fputs("jnf: TLOSS error\n",stderr)
00397 #define WRITEF_YN_TLOSS  fputs("ynf: TLOSS error\n",stderr)
00398 #define WRITEL_ACOSD fputs("acosdl: DOMAIN error\n",stderr)
00399 #define WRITED_ACOSD fputs("acosd: DOMAIN error\n",stderr)
00400 #define WRITEF_ACOSD fputs("acosdf: DOMAIN error\n",stderr)
00401 #define WRITEL_ASIND fputs("asindl: DOMAIN error\n",stderr)
00402 #define WRITED_ASIND fputs("asind: DOMAIN error\n",stderr)
00403 #define WRITEF_ASIND fputs("asindf: DOMAIN error\n",stderr)
00404 #define WRITEL_ATAN2D_ZERO_BY_ZERO fputs("atan2dl: DOMAIN error\n",stderr)
00405 #define WRITED_ATAN2D_ZERO_BY_ZERO fputs("atan2d: DOMAIN error\n",stderr)
00406 #define WRITEF_ATAN2D_ZERO_BY_ZERO fputs("atan2df: DOMAIN error\n",stderr)
00407 
00408 
00409 /***********************/
00410 /* IEEE Path           */
00411 /***********************/
00412 if(_LIB_VERSIONIMF==_IEEE_) return;
00413 
00414 /***********************/
00415 /* C9X Path           */
00416 /***********************/
00417 else if(_LIB_VERSIONIMF==_ISOC_)
00418 {
00419   switch(input_tag)
00420   {
00421     case logl_zero:
00422     case log_zero:
00423     case logf_zero:
00424     case log10l_zero:
00425     case log10_zero:
00426     case log10f_zero:
00427     case log2l_zero:
00428     case log2_zero:
00429     case log2f_zero:
00430     case log1pl_zero:
00431     case log1p_zero:
00432     case log1pf_zero:
00433     case powl_overflow:
00434     case pow_overflow:
00435     case powf_overflow:
00436     case expl_overflow:
00437     case exp_overflow:
00438     case expf_overflow:
00439     case exp2l_overflow:
00440     case exp2_overflow:
00441     case exp2f_overflow:
00442     case exp10l_overflow:
00443     case exp10_overflow:
00444     case exp10f_overflow:
00445     case expm1l_overflow:
00446     case expm1_overflow:
00447     case expm1f_overflow:
00448     case hypotl_overflow:
00449     case hypot_overflow:
00450     case hypotf_overflow:
00451     case sinhl_overflow:
00452     case sinh_overflow:
00453     case sinhf_overflow:
00454     case atanhl_eq_one:
00455     case atanh_eq_one:
00456     case atanhf_eq_one:
00457     case scalbl_overflow:
00458     case scalb_overflow:
00459     case scalbf_overflow:
00460     case coshl_overflow:
00461     case cosh_overflow:
00462     case coshf_overflow:
00463     case nextafterl_overflow:
00464     case nextafter_overflow:
00465     case nextafterf_overflow:
00466     case nextafterl_underflow:
00467     case nextafter_underflow:
00468     case nextafterf_underflow:
00469     case nexttowardl_overflow:
00470     case nexttoward_overflow:
00471     case nexttowardf_overflow:
00472     case nexttowardl_underflow:
00473     case nexttoward_underflow:
00474     case nexttowardf_underflow:
00475     case scalbnl_overflow:
00476     case scalbn_overflow:
00477     case scalbnf_overflow:
00478     case scalblnl_overflow:
00479     case scalbln_overflow:
00480     case scalblnf_overflow:
00481     case ldexpl_overflow:
00482     case ldexp_overflow:
00483     case ldexpf_overflow:
00484     case lgammal_overflow:
00485     case lgamma_overflow:
00486     case lgammaf_overflow:
00487     case gammal_overflow:
00488     case gamma_overflow:
00489     case gammaf_overflow:
00490     case lgammal_negative:
00491     case lgamma_negative:
00492     case lgammaf_negative:
00493     case gammal_negative:
00494     case gamma_negative:
00495     case gammaf_negative:
00496     case ilogbl_zero:
00497     case ilogb_zero:
00498     case ilogbf_zero:
00499     case fdiml_overflow:
00500     case fdim_overflow:
00501     case fdimf_overflow:
00502     case llrintl_large:
00503     case llrint_large:
00504     case llrintf_large:
00505     case llroundl_large:
00506     case llround_large:
00507     case llroundf_large:
00508     case lrintl_large:
00509     case lrint_large:
00510     case lrintf_large:
00511     case lroundl_large:
00512     case lround_large:
00513     case lroundf_large:
00514     case tandl_overflow:
00515     case tand_overflow:
00516     case tandf_overflow:
00517     case cotdl_overflow:
00518     case cotd_overflow:
00519     case cotdf_overflow:
00520     case cotl_overflow:
00521     case cot_overflow:
00522     case cotf_overflow:
00523     case sinhcoshl_overflow:
00524     case sinhcosh_overflow:
00525     case sinhcoshf_overflow:
00526     case annuityl_overflow:
00527     case annuity_overflow:
00528     case annuityf_overflow:
00529     case compoundl_overflow:
00530     case compound_overflow:
00531     case compoundf_overflow:
00532     case tgammal_overflow:
00533     case tgamma_overflow:
00534     case tgammaf_overflow:
00535     {
00536          ERRNO_RANGE; break;
00537     }
00538     case powl_underflow:
00539     case expl_underflow:
00540     case exp10l_underflow:
00541     case exp2l_underflow:
00542     case scalbl_underflow:
00543     case scalbnl_underflow:
00544     case scalblnl_underflow:
00545     case ldexpl_underflow:
00546     case erfcl_underflow:
00547     case annuityl_underflow:
00548     case compoundl_underflow:
00549     {
00550        /* Test for zero by testing 64 significand bits for zero. An integer
00551           test is needed so denormal flag is not set by a floating-point test */
00552        if ( INPUT_RESI64 == 0 ) ERRNO_RANGE;
00553        break;
00554     }
00555     case pow_underflow:
00556     case exp_underflow:
00557     case exp10_underflow:
00558     case exp2_underflow:
00559     case scalb_underflow:
00560     case scalbn_underflow:
00561     case scalbln_underflow:
00562     case ldexp_underflow:
00563     case erfc_underflow:
00564     case annuity_underflow:
00565     case compound_underflow:
00566     {
00567        /* Test for zero by testing exp and significand bits for zero. An integer
00568           test is needed so denormal flag is not set by a floating-point test */
00569        if ( (INPUT_RESI64 << 1) == 0 ) ERRNO_RANGE;
00570        break;
00571     }
00572     case powf_underflow:
00573     case expf_underflow:
00574     case exp10f_underflow:
00575     case exp2f_underflow:
00576     case scalbf_underflow:
00577     case scalbnf_underflow:
00578     case scalblnf_underflow:
00579     case ldexpf_underflow:
00580     case erfcf_underflow:
00581     case annuityf_underflow:
00582     case compoundf_underflow:
00583     {
00584        /* Test for zero by testing exp and significand bits for zero. An integer
00585           test is needed so denormal flag is not set by a floating-point test */
00586        if ( (INPUT_RESI64 << 33) == 0 ) ERRNO_RANGE;
00587        break;
00588     }
00589     case logl_negative:
00590     case log_negative:
00591     case logf_negative:
00592     case log10l_negative:
00593     case log10_negative:
00594     case log10f_negative:
00595     case log2l_negative:
00596     case log2_negative:
00597     case log2f_negative:
00598     case log1pl_negative:
00599     case log1p_negative:
00600     case log1pf_negative:
00601     case sqrtl_negative:
00602     case sqrt_negative:
00603     case sqrtf_negative:
00604     case atan2l_zero:
00605     case atan2_zero:
00606     case atan2f_zero:
00607     case powl_zero_to_negative:
00608     case powl_neg_to_non_integer:
00609     case pow_zero_to_negative:
00610     case pow_neg_to_non_integer:
00611     case powf_zero_to_negative:
00612     case powf_neg_to_non_integer:
00613     case fmodl_by_zero:
00614     case fmod_by_zero:
00615     case fmodf_by_zero:
00616     case atanhl_gt_one:
00617     case atanh_gt_one:
00618     case atanhf_gt_one:
00619     case acosl_gt_one:
00620     case acos_gt_one:
00621     case acosf_gt_one:
00622     case asinl_gt_one:
00623     case asin_gt_one:
00624     case asinf_gt_one:
00625     case logbl_zero:
00626     case logb_zero:
00627     case logbf_zero:
00628     case acoshl_lt_one:
00629     case acosh_lt_one:
00630     case acoshf_lt_one:
00631     case y0l_zero:
00632     case y0_zero:
00633     case y0f_zero:
00634     case y1l_zero:
00635     case y1_zero:
00636     case y1f_zero:
00637     case ynl_zero:
00638     case yn_zero:
00639     case ynf_zero:
00640     case y0l_negative:
00641     case y0_negative:
00642     case y0f_negative:
00643     case y1l_negative:
00644     case y1_negative:
00645     case y1f_negative:
00646     case ynl_negative:
00647     case yn_negative:
00648     case ynf_negative:
00649     case acosdl_gt_one:
00650     case acosd_gt_one:
00651     case acosdf_gt_one:
00652     case asindl_gt_one:
00653     case asind_gt_one:
00654     case asindf_gt_one:
00655     case atan2dl_zero:
00656     case atan2d_zero:
00657     case atan2df_zero:
00658     case annuityl_by_zero:
00659     case annuity_by_zero:
00660     case annuityf_by_zero:
00661     case annuityl_less_m1:
00662     case annuity_less_m1:
00663     case annuityf_less_m1:
00664     case compoundl_by_zero:
00665     case compound_by_zero:
00666     case compoundf_by_zero:
00667     case compoundl_less_m1:
00668     case compound_less_m1:
00669     case compoundf_less_m1:
00670     case tgammal_negative:
00671     case tgamma_negative:
00672     case tgammaf_negative:
00673     {
00674          ERRNO_DOMAIN; break;
00675     }
00676     default:
00677       break;
00678    }
00679    return;
00680 }
00681 
00682 /***********************/
00683 /* _POSIX_ Path        */
00684 /***********************/
00685 
00686 else if(_LIB_VERSIONIMF==_POSIX_)
00687 {
00688 switch(input_tag)
00689   {
00690   case gammal_overflow:
00691   case lgammal_overflow:
00692   case tgammal_overflow:
00693   {
00694        RETVAL_HUGE_VALL; ERRNO_RANGE; break;
00695   }
00696   case gamma_overflow:
00697   case lgamma_overflow:
00698   case tgamma_overflow:
00699   {
00700        RETVAL_HUGE_VALD; ERRNO_RANGE; break;
00701   }
00702   case gammaf_overflow:
00703   case lgammaf_overflow:
00704   case tgammaf_overflow:
00705   {
00706        RETVAL_HUGE_VALF; ERRNO_RANGE; break;
00707   }
00708   case gammal_negative:
00709   case gamma_negative:
00710   case gammaf_negative:
00711   case lgammal_negative:
00712   case lgamma_negative:
00713   case lgammaf_negative:
00714   case tgammal_negative:
00715   case tgamma_negative:
00716   case tgammaf_negative:
00717   {
00718        ERRNO_DOMAIN; break;
00719   }
00720   case ldexpl_overflow:
00721   case ldexpl_underflow:
00722   case ldexp_overflow:
00723   case ldexp_underflow:
00724   case ldexpf_overflow:
00725   case ldexpf_underflow:
00726   case scalbnl_overflow:
00727   case scalbnl_underflow:
00728   case scalbn_overflow:
00729   case scalbn_underflow:
00730   case scalbnf_overflow:
00731   case scalbnf_underflow:
00732   case scalblnl_overflow:
00733   case scalblnl_underflow:
00734   case scalbln_overflow:
00735   case scalbln_underflow:
00736   case scalblnf_overflow:
00737   case scalblnf_underflow:
00738   case tandl_overflow:
00739   case tand_overflow:
00740   case tandf_overflow:
00741   case cotdl_overflow:
00742   case cotd_overflow:
00743   case cotdf_overflow:
00744   case cotl_overflow:
00745   case cot_overflow:
00746   case cotf_overflow:
00747   case sinhcoshl_overflow:
00748   case sinhcosh_overflow:
00749   case sinhcoshf_overflow:
00750   case nextafterl_overflow:
00751   case nextafter_overflow:
00752   case nextafterf_overflow:
00753   case nextafterl_underflow:
00754   case nextafter_underflow:
00755   case nextafterf_underflow:
00756   case nexttowardl_overflow:
00757   case nexttoward_overflow:
00758   case nexttowardf_overflow:
00759   case nexttowardl_underflow:
00760   case nexttoward_underflow:
00761   case nexttowardf_underflow:
00762   {
00763        ERRNO_RANGE; break;
00764   }
00765   case atanhl_gt_one:
00766   case atanhl_eq_one:
00767     /* atanhl(|x| >= 1) */
00768     {
00769        ERRNO_DOMAIN; break;
00770     }
00771   case atanh_gt_one:
00772   case atanh_eq_one:
00773     /* atanh(|x| >= 1) */
00774     {
00775        ERRNO_DOMAIN; break;
00776     }
00777   case atanhf_gt_one:
00778   case atanhf_eq_one:
00779     /* atanhf(|x| >= 1) */
00780     {
00781        ERRNO_DOMAIN; break;
00782     }
00783   case sqrtl_negative:
00784     /* sqrtl(x < 0) */
00785     {
00786        ERRNO_DOMAIN; break;
00787     }
00788   case sqrt_negative:
00789     /* sqrt(x < 0) */
00790     {
00791        ERRNO_DOMAIN; break;
00792     }
00793   case sqrtf_negative:
00794     /* sqrtf(x < 0) */
00795     {
00796        ERRNO_DOMAIN; break;
00797     }
00798   case y0l_zero:
00799   case y1l_zero:
00800   case ynl_zero:
00801     /* y0l(0) */
00802     /* y1l(0) */
00803     /* ynl(0) */
00804     {
00805        RETVAL_NEG_HUGE_VALL; ERRNO_DOMAIN; break;
00806     }
00807   case y0_zero:
00808   case y1_zero:
00809   case yn_zero:
00810     /* y0(0) */
00811     /* y1(0) */
00812     /* yn(0) */
00813     {
00814        RETVAL_NEG_HUGE_VALD; ERRNO_DOMAIN; break;
00815     }
00816   case y0f_zero:
00817   case y1f_zero:
00818   case ynf_zero:
00819     /* y0f(0) */
00820     /* y1f(0) */
00821     /* ynf(0) */
00822     {
00823        RETVAL_NEG_HUGE_VALF; ERRNO_DOMAIN; break;
00824     }
00825   case y0l_negative:
00826   case y1l_negative:
00827   case ynl_negative:
00828     /* y0l(x < 0) */
00829     /* y1l(x < 0) */
00830     /* ynl(x < 0) */
00831     {
00832 #ifndef _LIBC
00833        RETVAL_NEG_HUGE_VALL;
00834 #endif
00835        ERRNO_DOMAIN; break;
00836     }
00837   case y0_negative:
00838   case y1_negative:
00839   case yn_negative:
00840     /* y0(x < 0) */
00841     /* y1(x < 0) */
00842     /* yn(x < 0) */
00843     {
00844        RETVAL_NEG_HUGE_VALD; ERRNO_DOMAIN; break;
00845     }
00846   case y0f_negative:
00847   case y1f_negative:
00848   case ynf_negative:
00849     /* y0f(x < 0) */
00850     /* y1f(x < 0) */
00851     /* ynf(x < 0) */
00852     {
00853        RETVAL_NEG_HUGE_VALF; ERRNO_DOMAIN; break;
00854     }
00855   case logl_zero:
00856   case log1pl_zero:
00857   case log10l_zero:
00858   case log2l_zero:
00859     /* logl(0) */
00860     /* log1pl(-1) */
00861     /* log10l(0) */
00862     /* log2l(0) */
00863     {
00864        RETVAL_NEG_HUGE_VALL; ERRNO_RANGE; break;
00865     }
00866   case log_zero:
00867   case log1p_zero:
00868   case log10_zero:
00869   case log2_zero:
00870    /* log(0) */
00871    /* log1p(-1) */
00872    /* log10(0) */
00873    /* log2(0) */
00874     {
00875        RETVAL_NEG_HUGE_VALD; ERRNO_RANGE; break;
00876     }
00877   case logf_zero:
00878   case log1pf_zero:
00879   case log10f_zero:
00880   case log2f_zero:
00881     /* logf(0) */
00882     /* log1pf(-1) */
00883     /* log10f(0) */
00884     /* log2f(0) */
00885     {
00886        RETVAL_NEG_HUGE_VALF; ERRNO_RANGE; break;
00887     }
00888   case logl_negative:
00889   case log1pl_negative:
00890   case log10l_negative:
00891   case log2l_negative:
00892     /* logl(x < 0) */
00893     /* log1pl(x < -1) */
00894     /* log10l(x < 0) */
00895     /* log2l(x < 0) */
00896     {
00897        ERRNO_DOMAIN; break;
00898     }
00899   case log_negative:
00900   case log1p_negative:
00901   case log10_negative:
00902   case log2_negative:
00903     /* log(x < 0) */
00904     /* log1p(x < -1) */
00905     /* log10(x < 0) */
00906     /* log2(x < 0) */
00907     {
00908        ERRNO_DOMAIN; break;
00909     }
00910   case logf_negative:
00911   case log1pf_negative:
00912   case log10f_negative:
00913   case log2f_negative:
00914     /* logf(x < 0) */
00915     /* log1pf(x < -1) */
00916     /* log10f(x < 0) */
00917     /* log2f(x < 0) */
00918     {
00919        ERRNO_DOMAIN; break;
00920     }
00921   case expl_overflow:
00922   case exp10l_overflow:
00923   case exp2l_overflow:
00924     /* expl overflow */
00925     /* exp10l overflow */
00926     /* exp2l overflow */
00927     {
00928        RETVAL_HUGE_VALL; ERRNO_RANGE; break;
00929     }
00930   case exp_overflow:
00931   case exp10_overflow:
00932   case exp2_overflow:
00933     /* exp overflow */
00934     /* exp10 overflow */
00935     /* exp2 overflow */
00936     {
00937        RETVAL_HUGE_VALD; ERRNO_RANGE; break;
00938     }
00939   case expf_overflow:
00940   case exp10f_overflow:
00941   case exp2f_overflow:
00942     /* expf overflow */
00943     {
00944        RETVAL_HUGE_VALF; ERRNO_RANGE; break;
00945     }
00946   case expl_underflow:
00947   case exp10l_underflow:
00948   case exp2l_underflow:
00949     /* expl underflow */
00950     /* exp10l underflow */
00951     /* exp2l underflow */
00952     {
00953        ERRNO_RANGE; break;
00954     }
00955   case exp_underflow:
00956   case exp10_underflow:
00957   case exp2_underflow:
00958     /* exp underflow */
00959     /* exp10 underflow */
00960     /* exp2 underflow */
00961     {
00962        ERRNO_RANGE; break;
00963     }
00964   case expf_underflow:
00965   case exp10f_underflow:
00966   case exp2f_underflow:
00967     /* expf underflow */
00968     /* exp10f underflow */
00969     /* exp2f underflow */
00970     {
00971        ERRNO_RANGE; break;
00972     }
00973   case j0l_gt_loss:
00974   case y0l_gt_loss:
00975   case j1l_gt_loss:
00976   case y1l_gt_loss:
00977   case jnl_gt_loss:
00978   case ynl_gt_loss:
00979     /* jn and yn  doubl-extended> XLOSS */
00980     {
00981        RETVAL_ZEROL; ERRNO_RANGE; break;
00982     }
00983   case j0_gt_loss:
00984   case y0_gt_loss:
00985   case j1_gt_loss:
00986   case y1_gt_loss:
00987   case jn_gt_loss:
00988   case yn_gt_loss:
00989     /* jn and yn double > XLOSS */
00990     {
00991        RETVAL_ZEROD; ERRNO_RANGE; break;
00992     }
00993   case j0f_gt_loss:
00994   case y0f_gt_loss:
00995   case j1f_gt_loss:
00996   case y1f_gt_loss:
00997   case jnf_gt_loss:
00998   case ynf_gt_loss:
00999     /* j0n and y0n > XLOSS */
01000     {
01001        RETVAL_ZEROF; ERRNO_RANGE; break;
01002     }
01003   case powl_zero_to_zero:
01004     /* powl 0**0 */
01005     {
01006        break;
01007     }
01008   case pow_zero_to_zero:
01009     /* pow 0**0 */
01010     {
01011        break;
01012     }
01013   case powf_zero_to_zero:
01014     /* powf 0**0 */
01015     {
01016        break;
01017     }
01018   case powl_overflow:
01019   case annuityl_overflow:
01020   case compoundl_overflow:
01021     /* powl(x,y) overflow */
01022     {
01023        if (INPUT_RESL < ZEROL_VALUE /*0*/) RETVAL_NEG_HUGE_VALL;
01024        else RETVAL_HUGE_VALL;
01025        ERRNO_RANGE; break;
01026     }
01027   case pow_overflow:
01028   case annuity_overflow:
01029   case compound_overflow:
01030     /* pow(x,y) overflow */
01031     {
01032        if (INPUT_RESD < ZEROD_VALUE /*0*/) RETVAL_NEG_HUGE_VALD;
01033        else RETVAL_HUGE_VALD;
01034        ERRNO_RANGE; break;
01035     }
01036   case powf_overflow:
01037   case annuityf_overflow:
01038   case compoundf_overflow:
01039     /* powf(x,y) overflow */
01040     {
01041        if (INPUT_RESF < ZEROF_VALUE /*0*/) RETVAL_NEG_HUGE_VALF;
01042        else RETVAL_HUGE_VALF;
01043        ERRNO_RANGE; break;
01044     }
01045   case powl_underflow:
01046   case annuityl_underflow:
01047   case compoundl_underflow:
01048     /* powl(x,y) underflow */
01049     {
01050        RETVAL_ZEROL; ERRNO_RANGE; break;
01051     }
01052   case pow_underflow:
01053   case annuity_underflow:
01054   case compound_underflow:
01055     /* pow(x,y) underflow */
01056     {
01057        RETVAL_ZEROD; ERRNO_RANGE; break;
01058     }
01059   case powf_underflow:
01060   case annuityf_underflow:
01061   case compoundf_underflow:
01062     /* powf(x,y) underflow */
01063     {
01064        RETVAL_ZEROF; ERRNO_RANGE; break;
01065     }
01066   case annuityl_by_zero:
01067   case annuityl_less_m1:
01068   case compoundl_by_zero:
01069   case compoundl_less_m1:
01070   case annuity_by_zero:
01071   case annuity_less_m1:
01072   case compound_by_zero:
01073   case compound_less_m1:
01074   case annuityf_by_zero:
01075   case annuityf_less_m1:
01076   case compoundf_by_zero:
01077   case compoundf_less_m1:
01078     {
01079        ERRNO_DOMAIN; break;
01080     }
01081   case powl_zero_to_negative:
01082     /* 0**neg */
01083     {
01084        ERRNO_DOMAIN; break;
01085     }
01086   case pow_zero_to_negative:
01087     /* 0**neg */
01088     {
01089        ERRNO_DOMAIN; break;
01090     }
01091   case  powf_zero_to_negative:
01092     /* 0**neg */
01093     {
01094        ERRNO_DOMAIN; break;
01095     }
01096   case powl_neg_to_non_integer:
01097     /* neg**non_integral */
01098     {
01099        ERRNO_DOMAIN; break;
01100     }
01101   case pow_neg_to_non_integer:
01102     /* neg**non_integral */
01103     {
01104        ERRNO_DOMAIN; break;
01105     }
01106   case  powf_neg_to_non_integer:
01107     /* neg**non-integral */
01108     {
01109        ERRNO_DOMAIN; break;
01110     }
01111   case  powl_nan_to_zero:
01112     /* powl(NaN,0.0) */
01113     /* Special Error */
01114     {
01115        break;
01116     }
01117   case  pow_nan_to_zero:
01118     /* pow(NaN,0.0) */
01119     {
01120        break;
01121     }
01122   case  powf_nan_to_zero:
01123     /* powf(NaN,0.0) */
01124     {
01125        break;
01126     }
01127   case atan2l_zero:
01128   case atan2dl_zero:
01129     /* atan2l(0,0) */
01130     /* atan2dl(0,0) */
01131     {
01132        break;
01133     }
01134   case atan2_zero:
01135   case atan2d_zero:
01136     /* atan2(0,0) */
01137     /* atan2d(0,0) */
01138     {
01139        break;
01140     }
01141   case atan2f_zero:
01142   case atan2df_zero:
01143     /* atan2f(0,0) */
01144     /* atan2df(0,0) */
01145     {
01146        break;
01147     }
01148   case expm1l_overflow:
01149     /* expm1 overflow */
01150     {
01151        ERRNO_RANGE; break;
01152     }
01153   case expm1_overflow:
01154     /* expm1 overflow */
01155     {
01156        ERRNO_RANGE; break;
01157     }
01158   case expm1f_overflow:
01159     /* expm1f overflow */
01160     {
01161        ERRNO_RANGE; break;
01162     }
01163   case expm1l_underflow:
01164     /* expm1 underflow */
01165     {
01166        ERRNO_RANGE; break;
01167     }
01168   case expm1_underflow:
01169     /* expm1 underflow */
01170     {
01171        ERRNO_RANGE; break;
01172     }
01173   case expm1f_underflow:
01174     /* expm1f underflow */
01175     {
01176        ERRNO_RANGE; break;
01177     }
01178   case hypotl_overflow:
01179     /* hypotl overflow */
01180     {
01181        RETVAL_HUGE_VALL; ERRNO_RANGE; break;
01182     }
01183   case hypot_overflow:
01184     /* hypot overflow */
01185     {
01186        RETVAL_HUGE_VALD; ERRNO_RANGE; break;
01187     }
01188   case hypotf_overflow:
01189     /* hypotf overflow */
01190     {
01191        RETVAL_HUGE_VALF; ERRNO_RANGE; break;
01192     }
01193   case scalbl_underflow:
01194     /* scalbl underflow */
01195     {
01196        if (INPUT_XL < ZEROL_VALUE /*0*/) RETVAL_NEG_ZEROL;
01197        else RETVAL_ZEROL;
01198        ERRNO_RANGE; break;
01199     }
01200   case scalb_underflow:
01201     /* scalb underflow */
01202     {
01203        if (INPUT_XD < ZEROD_VALUE /*0*/) RETVAL_NEG_ZEROD;
01204        else RETVAL_ZEROD;
01205        ERRNO_RANGE; break;
01206     }
01207   case scalbf_underflow:
01208     /* scalbf underflow */
01209     {
01210        if (INPUT_XF < ZEROF_VALUE /*0*/) RETVAL_NEG_ZEROF;
01211        else RETVAL_ZEROF;
01212        ERRNO_RANGE; break;
01213     }
01214   case scalbl_overflow:
01215     /* scalbl overflow */
01216     {
01217        if (INPUT_XL < ZEROL_VALUE /*0*/) RETVAL_NEG_HUGE_VALL;
01218        else RETVAL_HUGE_VALL;
01219        ERRNO_RANGE; break;
01220     }
01221   case scalb_overflow:
01222     /* scalb overflow */
01223     {
01224        if (INPUT_XD < ZEROD_VALUE /*0*/) RETVAL_NEG_HUGE_VALD;
01225        else RETVAL_HUGE_VALD;
01226        ERRNO_RANGE; break;
01227     }
01228   case scalbf_overflow:
01229     /* scalbf overflow */
01230     {
01231        if (INPUT_XF < ZEROF_VALUE /*0*/) RETVAL_NEG_HUGE_VALF;
01232        else RETVAL_HUGE_VALF;
01233        ERRNO_RANGE; break;
01234     }
01235   case acoshl_lt_one:
01236     /* acoshl(x < 1) */
01237     {
01238        ERRNO_DOMAIN; break;
01239     }
01240   case acosh_lt_one:
01241     /* acosh(x < 1) */
01242     {
01243        ERRNO_DOMAIN; break;
01244     }
01245   case acoshf_lt_one:
01246     /* acoshf(x < 1) */
01247     {
01248         ERRNO_DOMAIN; break;
01249     }
01250   case acosl_gt_one:
01251   case acosdl_gt_one:
01252     /* acosl(x > 1) */
01253     /* acosdl(x > 1) */
01254     {
01255        ERRNO_DOMAIN; break;
01256     }
01257   case acos_gt_one:
01258   case acosd_gt_one:
01259     /* acos(x > 1) */
01260     /* acosd(x > 1) */
01261     {
01262        ERRNO_DOMAIN; break;
01263     }
01264   case acosf_gt_one:
01265   case acosdf_gt_one:
01266     /* acosf(x > 1) */
01267     /* acosdf(x > 1) */
01268     {
01269        ERRNO_DOMAIN; break;
01270     }
01271   case asinl_gt_one:
01272   case asindl_gt_one:
01273     /* asinl(x > 1) */
01274     /* asindl(x > 1) */
01275     {
01276        ERRNO_DOMAIN; break;
01277     }
01278   case asin_gt_one:
01279   case asind_gt_one:
01280     /* asin(x > 1) */
01281     /* asind(x > 1) */
01282     {
01283        ERRNO_DOMAIN; break;
01284     }
01285   case asinf_gt_one:
01286   case asindf_gt_one:
01287     /* asinf(x > 1) */
01288     /* asindf(x > 1) */
01289     {
01290        ERRNO_DOMAIN; break;
01291     }
01292   case remainderl_by_zero:
01293   case fmodl_by_zero:
01294     /* fmodl(x,0) */
01295     {
01296        ERRNO_DOMAIN; break;
01297     }
01298   case remainder_by_zero:
01299   case fmod_by_zero:
01300     /* fmod(x,0) */
01301     {
01302        ERRNO_DOMAIN; break;
01303     }
01304   case remainderf_by_zero:
01305   case fmodf_by_zero:
01306     /* fmodf(x,0) */
01307     {
01308        ERRNO_DOMAIN; break;
01309     }
01310   case coshl_overflow:
01311     /* coshl overflows */
01312     {
01313        RETVAL_HUGE_VALL; ERRNO_RANGE; break;
01314     }
01315   case cosh_overflow:
01316     /* cosh overflows */
01317     {
01318        RETVAL_HUGE_VALD; ERRNO_RANGE; break;
01319     }
01320   case coshf_overflow:
01321     /* coshf overflows */
01322     {
01323        RETVAL_HUGE_VALF; ERRNO_RANGE; break;
01324     }
01325   case sinhl_overflow:
01326     /* sinhl overflows */
01327     {
01328        if (INPUT_XL > ZEROL_VALUE /*0*/) RETVAL_HUGE_VALL;
01329        else RETVAL_NEG_HUGE_VALL;
01330        ERRNO_RANGE; break;
01331     }
01332   case sinh_overflow:
01333     /* sinh overflows */
01334     {
01335        if (INPUT_XD > ZEROD_VALUE /*0*/) RETVAL_HUGE_VALD;
01336        else RETVAL_NEG_HUGE_VALD;
01337        ERRNO_RANGE; break;
01338     }
01339   case sinhf_overflow:
01340     /* sinhf overflows */
01341     {
01342        if (INPUT_XF > ZEROF_VALUE /*0*/) RETVAL_HUGE_VALF;
01343        else RETVAL_NEG_HUGE_VALF;
01344        ERRNO_RANGE; break;
01345     }
01346   case logbl_zero:
01347    /* logbl(0) */
01348    {
01349       ERRNO_DOMAIN; break;
01350    }
01351   case logb_zero:
01352    /* logb(0) */
01353    {
01354       ERRNO_DOMAIN; break;
01355    }
01356   case logbf_zero:
01357    /* logbf(0) */
01358    {
01359       ERRNO_DOMAIN; break;
01360    }
01361   case ilogbl_zero:
01362    /* ilogbl(0) */
01363    {
01364       ERRNO_RANGE; break;
01365    }
01366   case ilogb_zero:
01367    /* ilogb(0) */
01368    {
01369       ERRNO_RANGE; break;
01370    }
01371   case ilogbf_zero:
01372    /* ilogbf(0) */
01373    {
01374       ERRNO_RANGE; break;
01375    }
01376   default:
01377     break;
01378 }
01379 return;
01380 /* _POSIX_ */
01381 }
01382 
01383 /*******************************/
01384 /* __SVID__ and __XOPEN__ Path */
01385 /*******************************/
01386 else
01387 {
01388   switch(input_tag)
01389   {
01390   case ldexpl_overflow:
01391   case ldexpl_underflow:
01392   case ldexp_overflow:
01393   case ldexp_underflow:
01394   case ldexpf_overflow:
01395   case ldexpf_underflow:
01396   case scalbnl_overflow:
01397   case scalbnl_underflow:
01398   case scalbn_overflow:
01399   case scalbn_underflow:
01400   case scalbnf_overflow:
01401   case scalbnf_underflow:
01402   case scalblnl_overflow:
01403   case scalblnl_underflow:
01404   case scalbln_overflow:
01405   case scalbln_underflow:
01406   case scalblnf_overflow:
01407   case scalblnf_underflow:
01408   case tandl_overflow:
01409   case tand_overflow:
01410   case tandf_overflow:
01411   case cotdl_overflow:
01412   case cotd_overflow:
01413   case cotdf_overflow:
01414   case cotl_overflow:
01415   case cot_overflow:
01416   case cotf_overflow:
01417   case annuityl_overflow:
01418   case annuityl_underflow:
01419   case annuity_overflow:
01420   case annuity_underflow:
01421   case annuityf_overflow:
01422   case annuityf_underflow:
01423   case compoundl_overflow:
01424   case compoundl_underflow:
01425   case compound_overflow:
01426   case compound_underflow:
01427   case compoundf_overflow:
01428   case compoundf_underflow:
01429   {
01430        ERRNO_RANGE; break;
01431   }
01432   case annuityl_by_zero:
01433   case annuityl_less_m1:
01434   case annuity_by_zero:
01435   case annuity_less_m1:
01436   case annuityf_by_zero:
01437   case annuityf_less_m1:
01438   case compoundl_by_zero:
01439   case compoundl_less_m1:
01440   case compound_by_zero:
01441   case compound_less_m1:
01442   case compoundf_by_zero:
01443   case compoundf_less_m1:
01444   {
01445        ERRNO_DOMAIN; break;
01446   }
01447   case sqrtl_negative:
01448     /* sqrtl(x < 0) */
01449     {
01450        DOMAINL; NAMEL = (char *) "sqrtl";
01451        ifSVID
01452        {
01453           RETVAL_ZEROL;
01454           NOT_MATHERRL
01455           {
01456             WRITEL_SQRT;
01457             ERRNO_DOMAIN;
01458           }
01459        }
01460        else
01461        { /* NaN already computed */
01462           NOT_MATHERRL {ERRNO_DOMAIN;}
01463        }
01464        *(long double *)retval = excl.retval;
01465        break;
01466     }
01467   case sqrt_negative:
01468     /* sqrt(x < 0) */
01469     {
01470        DOMAIND; NAMED = (char *) "sqrt";
01471        ifSVID
01472        {
01473 
01474          RETVAL_ZEROD;
01475          NOT_MATHERRD
01476          {
01477            WRITED_SQRT;
01478            ERRNO_DOMAIN;
01479          }
01480        }
01481        else
01482        { /* NaN already computed */
01483          NOT_MATHERRD {ERRNO_DOMAIN;}
01484        }
01485        *(double *)retval = exc.retval;
01486        break;
01487     }
01488   case sqrtf_negative:
01489     /* sqrtf(x < 0) */
01490     {
01491        DOMAINF; NAMEF = (char *) "sqrtf";
01492        ifSVID
01493        {
01494          RETVAL_ZEROF;
01495          NOT_MATHERRF
01496          {
01497            WRITEF_SQRT;
01498            ERRNO_DOMAIN;
01499          }
01500        }
01501        else
01502        {
01503          NOT_MATHERRF {ERRNO_DOMAIN;}
01504        }
01505        *(float *)retval = excf.retval;
01506        break;
01507     }
01508   case logl_zero:
01509     /* logl(0) */
01510     {
01511        SINGL; NAMEL = (char *) "logl";
01512        ifSVID
01513        {
01514          RETVAL_NEG_HUGEL;
01515          NOT_MATHERRL
01516          {
01517            WRITEL_LOG_ZERO;
01518            ERRNO_DOMAIN;
01519          }
01520        }
01521        else
01522        {
01523          RETVAL_NEG_HUGE_VALL;
01524          NOT_MATHERRL {ERRNO_DOMAIN;}
01525        }
01526        *(long double *)retval = excl.retval;
01527        break;
01528     }
01529   case log_zero:
01530     /* log(0) */
01531     {
01532        SINGD; NAMED = (char *) "log";
01533        ifSVID
01534        {
01535          RETVAL_NEG_HUGED;
01536          NOT_MATHERRD
01537          {
01538            WRITED_LOG_ZERO;
01539            ERRNO_DOMAIN;
01540          }
01541        }
01542        else
01543        {
01544          RETVAL_NEG_HUGE_VALD;
01545          NOT_MATHERRD {ERRNO_DOMAIN;}
01546        }
01547        *(double *)retval = exc.retval;
01548        break;
01549     }
01550   case logf_zero:
01551     /* logf(0) */
01552     {
01553        SINGF; NAMEF = (char *) "logf";
01554        ifSVID
01555        {
01556          RETVAL_NEG_HUGEF;
01557          NOT_MATHERRF
01558          {
01559             WRITEF_LOG_ZERO;
01560             ERRNO_DOMAIN;
01561          }
01562        }
01563        else
01564        {
01565          RETVAL_NEG_HUGE_VALF;
01566          NOT_MATHERRF {ERRNO_DOMAIN;}
01567        }
01568        *(float *)retval = excf.retval;
01569        break;
01570     }
01571 
01572   case logl_negative:
01573     /* logl(x < 0) */
01574     {
01575        DOMAINL; NAMEL = (char *) "logl";
01576        ifSVID
01577        {
01578          RETVAL_NEG_HUGEL;
01579          NOT_MATHERRL
01580          {
01581            WRITEL_LOG_NEGATIVE;
01582            ERRNO_DOMAIN;
01583          }
01584        }
01585        else
01586        {
01587          RETVAL_NEG_HUGE_VALL;
01588          NOT_MATHERRL {ERRNO_DOMAIN;}
01589        }
01590        *(long double *)retval = excl.retval;
01591        break;
01592     }
01593   case log_negative:
01594     /* log(x < 0) */
01595     {
01596        DOMAIND; NAMED = (char *) "log";
01597        ifSVID
01598        {
01599          RETVAL_NEG_HUGED;
01600          NOT_MATHERRD
01601          {
01602            WRITED_LOG_NEGATIVE;
01603            ERRNO_DOMAIN;
01604          }
01605        }
01606        else
01607        {
01608          RETVAL_NEG_HUGE_VALD;
01609          NOT_MATHERRD {ERRNO_DOMAIN;}
01610        }
01611        *(double *)retval = exc.retval;
01612        break;
01613     }
01614   case logf_negative:
01615     /* logf(x < 0) */
01616     {
01617        DOMAINF; NAMEF = (char *) "logf";
01618        ifSVID
01619        {
01620          RETVAL_NEG_HUGEF;
01621          NOT_MATHERRF
01622          {
01623            WRITEF_LOG_NEGATIVE;
01624            ERRNO_DOMAIN;
01625          }
01626        }
01627        else
01628        {
01629          RETVAL_NEG_HUGE_VALF;
01630          NOT_MATHERRF{ERRNO_DOMAIN;}
01631        }
01632        *(float *)retval = excf.retval;
01633        break;
01634     }
01635   case log1pl_zero:
01636     /* log1pl(-1) */
01637     {
01638        SINGL; NAMEL = (char *) "log1pl";
01639        ifSVID
01640        {
01641          RETVAL_NEG_HUGEL;
01642          NOT_MATHERRL
01643          {
01644            WRITEL_LOG1P_ZERO;
01645            ERRNO_DOMAIN;
01646          }
01647        }
01648        else
01649        {
01650          RETVAL_NEG_HUGE_VALL;
01651          NOT_MATHERRL {ERRNO_DOMAIN;}
01652        }
01653        *(long double *)retval = excl.retval;
01654        break;
01655     }
01656   case log1p_zero:
01657     /* log1p(-1) */
01658     {
01659        SINGD; NAMED = (char *) "log1p";
01660        ifSVID
01661        {
01662          RETVAL_NEG_HUGED;
01663          NOT_MATHERRD
01664          {
01665            WRITED_LOG1P_ZERO;
01666            ERRNO_DOMAIN;
01667          }
01668        }
01669        else
01670        {
01671          RETVAL_NEG_HUGE_VALD;
01672          NOT_MATHERRD {ERRNO_DOMAIN;}
01673        }
01674        *(double *)retval = exc.retval;
01675        break;
01676     }
01677   case log1pf_zero:
01678     /* log1pf(-1) */
01679     {
01680        SINGF; NAMEF = (char *) "log1pf";
01681        ifSVID
01682        {
01683          RETVAL_NEG_HUGEF;
01684          NOT_MATHERRF
01685          {
01686            WRITEF_LOG1P_ZERO;
01687            ERRNO_DOMAIN;
01688          }
01689        }
01690        else
01691        {
01692          RETVAL_NEG_HUGE_VALF;
01693          NOT_MATHERRF {ERRNO_DOMAIN;}
01694        }
01695        *(float *)retval = excf.retval;
01696        break;
01697     }
01698  case log1pl_negative:
01699    /* log1pl(x < -1) */
01700    {
01701       DOMAINL; NAMEL = (char *) "log1pl";
01702       ifSVID
01703       {
01704         RETVAL_NEG_HUGEL;
01705         NOT_MATHERRL
01706         {
01707           WRITEL_LOG1P_NEGATIVE;
01708           ERRNO_DOMAIN;
01709         }
01710       }
01711       else
01712       {
01713         RETVAL_NEG_HUGE_VALL;
01714         NOT_MATHERRL {ERRNO_DOMAIN;}
01715       }
01716       *(long double *)retval = excl.retval;
01717       break;
01718    }
01719  case log1p_negative:
01720    /* log1p(x < -1) */
01721    {
01722       DOMAIND; NAMED = (char *) "log1p";
01723       ifSVID
01724       {
01725         RETVAL_NEG_HUGED;
01726         NOT_MATHERRD
01727         {
01728           WRITED_LOG1P_NEGATIVE;
01729           ERRNO_DOMAIN;
01730         }
01731       }
01732       else
01733       {
01734         RETVAL_NEG_HUGE_VALD;
01735         NOT_MATHERRD {ERRNO_DOMAIN;}
01736       }
01737       *(double *)retval = exc.retval;
01738       break;
01739    }
01740  case log1pf_negative:
01741    /* log1pf(x < -1) */
01742    {
01743       DOMAINF; NAMEF = (char *) "log1pf";
01744       ifSVID
01745       {
01746         RETVAL_NEG_HUGEF;
01747         NOT_MATHERRF
01748         {
01749           WRITEF_LOG1P_NEGATIVE;
01750           ERRNO_DOMAIN;
01751         }
01752       }
01753       else
01754       {
01755         RETVAL_NEG_HUGE_VALF;
01756         NOT_MATHERRF {ERRNO_DOMAIN;}
01757       }
01758       *(float *)retval = excf.retval;
01759       break;
01760    }
01761   case log10l_zero:
01762     /* log10l(0) */
01763     {
01764        SINGL; NAMEL = (char *) "log10l";
01765        ifSVID
01766        {
01767          RETVAL_NEG_HUGEL;
01768          NOT_MATHERRL
01769          {
01770             WRITEL_LOG10_ZERO;
01771             ERRNO_DOMAIN;
01772          }
01773        }
01774        else
01775        {
01776          RETVAL_NEG_HUGE_VALL;
01777          NOT_MATHERRL {ERRNO_DOMAIN;}
01778        }
01779        *(long double *)retval = excl.retval;
01780        break;
01781     }
01782   case log10_zero:
01783     /* log10(0) */
01784     {
01785        SINGD; NAMED = (char *) "log10";
01786        ifSVID
01787        {
01788          RETVAL_NEG_HUGED;
01789          NOT_MATHERRD
01790          {
01791            WRITED_LOG10_ZERO;
01792            ERRNO_DOMAIN;
01793          }
01794        }
01795        else
01796        {
01797          RETVAL_NEG_HUGE_VALD;
01798          NOT_MATHERRD {ERRNO_DOMAIN;}
01799        }
01800        *(double *)retval = exc.retval;
01801        break;
01802     }
01803   case log10f_zero:
01804     /* log10f(0) */
01805     {
01806        SINGF; NAMEF = (char *) "log10f";
01807        ifSVID
01808        {
01809          RETVAL_NEG_HUGEF;
01810          NOT_MATHERRF
01811          {
01812           WRITEF_LOG10_ZERO;
01813           ERRNO_DOMAIN;
01814          }
01815        }
01816        else
01817        {
01818          RETVAL_NEG_HUGE_VALF;
01819          NOT_MATHERRF {ERRNO_DOMAIN;}
01820        }
01821        *(float *)retval = excf.retval;
01822        break;
01823     }
01824   case log10l_negative:
01825     /* log10l(x < 0) */
01826     {
01827        DOMAINL; NAMEL = (char *) "log10l";
01828        ifSVID
01829        {
01830          RETVAL_NEG_HUGEL;
01831          NOT_MATHERRL
01832          {
01833            WRITEL_LOG10_NEGATIVE;
01834            ERRNO_DOMAIN;
01835          }
01836        }
01837        else
01838        {
01839          RETVAL_NEG_HUGE_VALL;
01840          NOT_MATHERRL {ERRNO_DOMAIN;}
01841        }
01842        *(long double *)retval = excl.retval;
01843        break;
01844     }
01845   case log10_negative:
01846     /* log10(x < 0) */
01847     {
01848        DOMAIND; NAMED = (char *) "log10";
01849        ifSVID
01850        {
01851          RETVAL_NEG_HUGED;
01852          NOT_MATHERRD
01853          {
01854            WRITED_LOG10_NEGATIVE;
01855            ERRNO_DOMAIN;
01856          }
01857        }
01858        else
01859        {
01860          RETVAL_NEG_HUGE_VALD;
01861          NOT_MATHERRD {ERRNO_DOMAIN;}
01862        }
01863        *(double *)retval = exc.retval;
01864        break;
01865     }
01866   case log10f_negative:
01867     /* log10f(x < 0) */
01868     {
01869        DOMAINF; NAMEF = (char *) "log10f";
01870        ifSVID
01871        {
01872          RETVAL_NEG_HUGEF;
01873          NOT_MATHERRF
01874          {
01875            WRITEF_LOG10_NEGATIVE;
01876            ERRNO_DOMAIN;
01877          }
01878        }
01879        else
01880        {
01881          RETVAL_NEG_HUGE_VALF;
01882          NOT_MATHERRF {ERRNO_DOMAIN;}
01883        }
01884        *(float *)retval = excf.retval;
01885        break;
01886     }
01887   case log2l_zero:
01888     /* log2l(0) */
01889     {
01890        SINGL; NAMEL = (char *) "log2l";
01891        ifSVID
01892        {
01893          RETVAL_NEG_HUGEL;
01894          NOT_MATHERRL
01895          {
01896            WRITEL_LOG2_ZERO;
01897            ERRNO_DOMAIN;
01898          }
01899        }
01900        else
01901        {
01902          RETVAL_NEG_HUGE_VALL;
01903          NOT_MATHERRL {ERRNO_DOMAIN;}
01904        }
01905        *(long double *)retval = excl.retval;
01906        break;
01907     }
01908   case log2_zero:
01909     /* log2(0) */
01910     {
01911        SINGD; NAMED = (char *) "log2";
01912        ifSVID
01913        {
01914          RETVAL_NEG_HUGED;
01915          NOT_MATHERRD
01916          {
01917            WRITED_LOG2_ZERO;
01918            ERRNO_DOMAIN;
01919          }
01920        }
01921        else
01922        {
01923          RETVAL_NEG_HUGE_VALD;
01924          NOT_MATHERRD {ERRNO_DOMAIN;}
01925        }
01926        *(double *)retval = exc.retval;
01927        break;
01928     }
01929   case log2f_zero:
01930     /* log2f(0) */
01931     {
01932        SINGF; NAMEF = (char *) "log2f";
01933        ifSVID
01934        {
01935          RETVAL_NEG_HUGEF;
01936          NOT_MATHERRF
01937          {
01938           WRITEF_LOG2_ZERO;
01939           ERRNO_DOMAIN;
01940          }
01941        }
01942        else
01943        {
01944          RETVAL_NEG_HUGE_VALF;
01945          NOT_MATHERRF {ERRNO_DOMAIN;}
01946        }
01947        *(float *)retval = excf.retval;
01948        break;
01949     }
01950   case log2l_negative:
01951     /* log2l(x < 0) */
01952     {
01953        DOMAINL; NAMEL = (char *) "log2l";
01954        ifSVID
01955        {
01956          RETVAL_NEG_HUGEL;
01957          NOT_MATHERRL
01958          {
01959            WRITEL_LOG2_NEGATIVE;
01960            ERRNO_DOMAIN;
01961          }
01962        }
01963        else
01964        {
01965          RETVAL_NEG_HUGE_VALL;
01966          NOT_MATHERRL {ERRNO_DOMAIN;}
01967        }
01968        *(long double *)retval = excl.retval;
01969        break;
01970     }
01971   case log2_negative:
01972     /* log2(x < 0) */
01973     {
01974        DOMAIND; NAMED = (char *) "log2";
01975        ifSVID
01976        {
01977          RETVAL_NEG_HUGED;
01978          NOT_MATHERRD
01979          {
01980            WRITED_LOG2_NEGATIVE;
01981            ERRNO_DOMAIN;
01982          }
01983        }
01984        else
01985        {
01986          RETVAL_NEG_HUGE_VALD;
01987          NOT_MATHERRD {ERRNO_DOMAIN;}
01988        }
01989        *(double *)retval = exc.retval;
01990        break;
01991     }
01992   case log2f_negative:
01993     /* log2f(x < 0) */
01994     {
01995        DOMAINF; NAMEF = (char *) "log2f";
01996        ifSVID
01997        {
01998          RETVAL_NEG_HUGEF;
01999          NOT_MATHERRF
02000          {
02001            WRITEF_LOG2_NEGATIVE;
02002            ERRNO_DOMAIN;
02003          }
02004        }
02005        else
02006        {
02007          RETVAL_NEG_HUGE_VALF;
02008          NOT_MATHERRF {ERRNO_DOMAIN;}
02009        }
02010        *(float *)retval = excf.retval;
02011        break;
02012     }
02013   case expl_overflow:
02014     /* expl overflow */
02015     {
02016        OVERFLOWL; NAMEL = (char *) "expl";
02017        ifSVID
02018        {
02019          RETVAL_HUGEL;
02020        }
02021        else
02022        {
02023        RETVAL_HUGE_VALL;
02024        }
02025        NOT_MATHERRL {ERRNO_RANGE;}
02026        *(long double *)retval = excl.retval;
02027        break;
02028     }
02029   case exp_overflow:
02030     /* exp overflow */
02031     {
02032        OVERFLOWD; NAMED = (char *) "exp";
02033        ifSVID
02034        {
02035          RETVAL_HUGED;
02036        }
02037        else
02038        {
02039          RETVAL_HUGE_VALD;
02040        }
02041        NOT_MATHERRD {ERRNO_RANGE;}
02042        *(double *)retval = exc.retval;
02043        break;
02044     }
02045   case expf_overflow:
02046     /* expf overflow */
02047     {
02048        OVERFLOWF; NAMEF = (char *) "expf";
02049        ifSVID
02050        {
02051          RETVAL_HUGEF;
02052        }
02053        else
02054        {
02055          RETVAL_HUGE_VALF;
02056        }
02057        NOT_MATHERRF {ERRNO_RANGE;}
02058        *(float *)retval = excf.retval;
02059        break;
02060     }
02061   case expl_underflow:
02062     /* expl underflow */
02063     {
02064        UNDERFLOWL; NAMEL = (char *) "expl"; RETVAL_ZEROL;
02065        NOT_MATHERRL {ERRNO_RANGE;}
02066        *(long double *)retval = excl.retval;
02067        break;
02068     }
02069   case exp_underflow:
02070     /* exp underflow */
02071     {
02072        UNDERFLOWD; NAMED = (char *) "exp"; RETVAL_ZEROD;
02073        NOT_MATHERRD {ERRNO_RANGE;}
02074        *(double *)retval = exc.retval;
02075        break;
02076     }
02077   case expf_underflow:
02078     /* expf underflow */
02079     {
02080        UNDERFLOWF; NAMEF = (char *) "expf"; RETVAL_ZEROF;
02081        NOT_MATHERRF {ERRNO_RANGE;}
02082        *(float *)retval = excf.retval;
02083        break;
02084     }
02085   case powl_zero_to_zero:
02086     /* powl 0**0 */
02087     {
02088        DOMAINL; NAMEL = (char *) "powl";
02089        ifSVID
02090        {
02091          RETVAL_ZEROL;
02092          NOT_MATHERRL
02093          {
02094             WRITEL_POW_ZERO_TO_ZERO;
02095             ERRNO_DOMAIN;
02096          }
02097          *(long double *)retval = excl.retval;
02098        }
02099        else RETVAL_ONEL;
02100        break;
02101     }
02102   case pow_zero_to_zero:
02103     /* pow 0**0 */
02104     {
02105        DOMAIND; NAMED = (char *) "pow";
02106        ifSVID
02107        {
02108          RETVAL_ZEROD;
02109          NOT_MATHERRD
02110          {
02111             WRITED_POW_ZERO_TO_ZERO;
02112             ERRNO_DOMAIN;
02113          }
02114          *(double *)retval = exc.retval;
02115        }
02116        else RETVAL_ONED;
02117        break;
02118     }
02119   case powf_zero_to_zero:
02120     /* powf 0**0 */
02121     {
02122        DOMAINF; NAMEF = (char *) "powf";
02123        ifSVID
02124        {
02125          RETVAL_ZEROF;
02126          NOT_MATHERRF
02127          {
02128           WRITEF_POW_ZERO_TO_ZERO;
02129           ERRNO_DOMAIN;
02130          }
02131          *(float *)retval = excf.retval;
02132        }
02133        else RETVAL_ONEF;
02134        break;
02135     }
02136   case powl_overflow:
02137     /* powl(x,y) overflow */
02138     {
02139        OVERFLOWL; NAMEL = (char *) "powl";
02140        ifSVID
02141        {
02142          if (INPUT_RESL < ZEROL_VALUE /*0*/) RETVAL_NEG_HUGEL;
02143          else RETVAL_HUGEL;
02144        }
02145        else
02146        {
02147          if (INPUT_RESL < ZEROL_VALUE /*0*/) RETVAL_NEG_HUGE_VALL;
02148          else RETVAL_HUGE_VALL;
02149        }
02150        NOT_MATHERRL {ERRNO_RANGE;}
02151        *(long double *)retval = excl.retval;
02152        break;
02153     }
02154   case pow_overflow:
02155     /* pow(x,y) overflow */
02156     {
02157        OVERFLOWD; NAMED = (char *) "pow";
02158        ifSVID
02159        {
02160          if (INPUT_RESD < ZEROD_VALUE /*0*/) RETVAL_NEG_HUGED;
02161          else RETVAL_HUGED;
02162        }
02163        else
02164        {
02165          if (INPUT_RESD < ZEROD_VALUE /*0*/) RETVAL_NEG_HUGE_VALD;
02166          else RETVAL_HUGE_VALD;
02167        }
02168        NOT_MATHERRD {ERRNO_RANGE;}
02169        *(double *)retval = exc.retval;
02170        break;
02171     }
02172   case powf_overflow:
02173     /* powf(x,y) overflow */
02174     {
02175        OVERFLOWF; NAMEF = (char *) "powf";
02176        ifSVID
02177        {
02178          if (INPUT_RESF < ZEROF_VALUE /*0*/) RETVAL_NEG_HUGEF;
02179          else RETVAL_HUGEF;
02180        }
02181        else
02182        {
02183          if (INPUT_RESF < ZEROF_VALUE /*0*/) RETVAL_NEG_HUGE_VALF;
02184          else RETVAL_HUGE_VALF;
02185        }
02186        NOT_MATHERRF {ERRNO_RANGE;}
02187        *(float *)retval = excf.retval;
02188        break;
02189     }
02190   case powl_underflow:
02191     /* powl(x,y) underflow */
02192     {
02193        UNDERFLOWL; NAMEL = (char *) "powl"; RETVAL_ZEROL;
02194        NOT_MATHERRL {ERRNO_RANGE;}
02195        *(long double *)retval = excl.retval;
02196        break;
02197     }
02198   case pow_underflow:
02199     /* pow(x,y) underflow */
02200     {
02201        UNDERFLOWD; NAMED = (char *) "pow"; RETVAL_ZEROD;
02202        NOT_MATHERRD {ERRNO_RANGE;}
02203        *(double *)retval = exc.retval;
02204        break;
02205     }
02206   case powf_underflow:
02207     /* powf(x,y) underflow */
02208     {
02209        UNDERFLOWF; NAMEF = (char *) "powf"; RETVAL_ZEROF;
02210        NOT_MATHERRF {ERRNO_RANGE;}
02211        *(float *)retval = excf.retval;
02212        break;
02213     }
02214   case powl_zero_to_negative:
02215     /* 0 to neg */
02216     {
02217        DOMAINL; NAMEL = (char *) "powl";
02218        ifSVID
02219        {
02220          RETVAL_ZEROL;
02221          NOT_MATHERRL
02222          {
02223            WRITEL_POW_ZERO_TO_NEGATIVE;
02224            ERRNO_DOMAIN;
02225          }
02226        }
02227        else
02228        {
02229          RETVAL_NEG_HUGE_VALL;
02230          NOT_MATHERRL {ERRNO_DOMAIN;}
02231        }
02232        *(long double *)retval = excl.retval;
02233        break;
02234     }
02235   case pow_zero_to_negative:
02236     /* 0**neg */
02237     {
02238        DOMAIND; NAMED = (char *) "pow";
02239        ifSVID
02240        {
02241          RETVAL_ZEROD;
02242          NOT_MATHERRD
02243          {
02244            WRITED_POW_ZERO_TO_NEGATIVE;
02245            ERRNO_DOMAIN;
02246          }
02247        }
02248        else
02249        {
02250          RETVAL_NEG_HUGE_VALD;
02251          NOT_MATHERRD {ERRNO_DOMAIN;}
02252        }
02253        *(double *)retval = exc.retval;
02254        break;
02255     }
02256   case powf_zero_to_negative:
02257     /* 0**neg */
02258     {
02259        DOMAINF; NAMEF = (char *) "powf";
02260        ifSVID
02261        {
02262          RETVAL_ZEROF;
02263          NOT_MATHERRF
02264          {
02265             WRITEF_POW_ZERO_TO_NEGATIVE;
02266             ERRNO_DOMAIN;
02267          }
02268        }
02269        else
02270        {
02271          RETVAL_NEG_HUGE_VALF;
02272          NOT_MATHERRF {ERRNO_DOMAIN;}
02273        }
02274        *(float *)retval = excf.retval;
02275        break;
02276     }
02277   case powl_neg_to_non_integer:
02278     /* neg**non_integral */
02279     {
02280        DOMAINL; NAMEL = (char *) "powl";
02281        ifSVID
02282        {
02283          RETVAL_ZEROL;
02284          NOT_MATHERRL
02285          {
02286            WRITEL_POW_NEG_TO_NON_INTEGER;
02287            ERRNO_DOMAIN;
02288          }
02289        }
02290        else
02291        {
02292          NOT_MATHERRL {ERRNO_DOMAIN;}
02293        }
02294        *(long double *)retval = excl.retval;
02295        break;
02296     }
02297   case pow_neg_to_non_integer:
02298     /* neg**non_integral */
02299     {
02300        DOMAIND; NAMED = (char *) "pow";
02301        ifSVID
02302        {
02303          RETVAL_ZEROD;
02304          NOT_MATHERRD
02305          {
02306             WRITED_POW_NEG_TO_NON_INTEGER;
02307             ERRNO_DOMAIN;
02308          }
02309        }
02310        else
02311        {
02312          NOT_MATHERRD {ERRNO_DOMAIN;}
02313        }
02314        *(double *)retval = exc.retval;
02315        break;
02316     }
02317   case powf_neg_to_non_integer:
02318     /* neg**non-integral */
02319     {
02320        DOMAINF; NAMEF = (char *) "powf";
02321        ifSVID
02322        {
02323          RETVAL_ZEROF;
02324          NOT_MATHERRF
02325          {
02326             WRITEF_POW_NEG_TO_NON_INTEGER;
02327             ERRNO_DOMAIN;
02328          }
02329        }
02330        else
02331        {
02332          NOT_MATHERRF {ERRNO_DOMAIN;}
02333        }
02334        *(float *)retval = excf.retval;
02335        break;
02336     }
02337   case powl_nan_to_zero:
02338     /* pow(NaN,0.0) */
02339     /* Special Error */
02340     {
02341        DOMAINL; NAMEL = (char *) "powl";
02342        *(long double *)retval = *(long double *)arg1;
02343        NOT_MATHERRL {ERRNO_DOMAIN;}
02344        *(long double *)retval = excl.retval;
02345        break;
02346     }
02347   case pow_nan_to_zero:
02348     /* pow(NaN,0.0) */
02349     /* Special Error */
02350     {
02351        DOMAIND; NAMED = (char *) "pow";
02352        *(double *)retval = *(double *)arg1;
02353        NOT_MATHERRD {ERRNO_DOMAIN;}
02354        *(double *)retval = exc.retval;
02355        break;
02356     }
02357   case powf_nan_to_zero:
02358     /* powf(NaN,0.0) */
02359     /* Special Error */
02360     {
02361        DOMAINF; NAMEF = (char *) "powf";
02362        *(float *)retval = *(float *)arg1;
02363        NOT_MATHERRF {ERRNO_DOMAIN;}
02364        *(float *)retval = excf.retval;
02365        break;
02366     }
02367   case atan2l_zero:
02368     /* atan2l(0.0,0.0) */
02369     {
02370        DOMAINL; NAMEL = (char *) "atan2l";
02371        RETVAL_ZEROL;
02372        NOT_MATHERRL
02373        {
02374          ifSVID
02375          {
02376             WRITEL_ATAN2_ZERO_BY_ZERO;
02377          }
02378          ERRNO_DOMAIN;
02379        }
02380        *(long double *)retval = excl.retval;
02381        break;
02382     }
02383   case atan2_zero:
02384     /* atan2(0.0,0.0) */
02385     {
02386        DOMAIND; NAMED = (char *) "atan2";
02387        RETVAL_ZEROD;
02388        NOT_MATHERRD
02389        {
02390          ifSVID
02391          {
02392             WRITED_ATAN2_ZERO_BY_ZERO;
02393          }
02394          ERRNO_DOMAIN;
02395        }
02396        *(double *)retval = exc.retval;
02397        break;
02398     }
02399   case atan2f_zero:
02400     /* atan2f(0.0,0.0) */
02401     {
02402        DOMAINF; NAMEF = (char *) "atan2f";
02403        RETVAL_ZEROF;
02404        NOT_MATHERRF
02405        {
02406          ifSVID
02407          {
02408             WRITEF_ATAN2_ZERO_BY_ZERO;
02409          }
02410          ERRNO_DOMAIN;
02411        }
02412        *(float *)retval = excf.retval;
02413        break;
02414     }
02415   case atan2dl_zero:
02416     /* atan2dl(0.0,0.0) */
02417     {
02418        DOMAINL; NAMEL = (char *) "atan2dl";
02419        RETVAL_ZEROL;
02420        NOT_MATHERRL
02421        {
02422          ifSVID
02423          {
02424             WRITEL_ATAN2D_ZERO_BY_ZERO;
02425          }
02426          ERRNO_DOMAIN;
02427        }
02428        *(long double *)retval = excl.retval;
02429        break;
02430     }
02431   case atan2d_zero:
02432     /* atan2d(0.0,0.0) */
02433     {
02434        DOMAIND; NAMED = (char *) "atan2d";
02435        RETVAL_ZEROD;
02436        NOT_MATHERRD
02437        {
02438          ifSVID
02439          {
02440             WRITED_ATAN2D_ZERO_BY_ZERO;
02441          }
02442          ERRNO_DOMAIN;
02443        }
02444        *(double *)retval = exc.retval;
02445        break;
02446     }
02447   case atan2df_zero:
02448     /* atan2df(0.0,0.0) */
02449     {
02450        DOMAINF; NAMEF = (char *) "atan2df";
02451        RETVAL_ZEROF;
02452        NOT_MATHERRF
02453        {
02454          ifSVID
02455          {
02456             WRITEF_ATAN2D_ZERO_BY_ZERO;
02457          }
02458          ERRNO_DOMAIN;
02459        }
02460        *(float *)retval = excf.retval;
02461        break;
02462     }
02463   case expm1_overflow:
02464     /* expm1(finite) overflow */
02465     /* Overflow is the only documented */
02466     /* special value. */
02467     {
02468       ERRNO_RANGE;
02469       break;
02470     }
02471   case expm1f_overflow:
02472     /* expm1f(finite) overflow */
02473     {
02474       ERRNO_RANGE;
02475       break;
02476     }
02477   case expm1_underflow:
02478     /* expm1(finite) underflow */
02479     /* Underflow is not documented */
02480     /* special value. */
02481     {
02482       ERRNO_RANGE;
02483       break;
02484     }
02485   case expm1f_underflow:
02486     /* expm1f(finite) underflow */
02487     {
02488       ERRNO_RANGE;
02489       break;
02490     }
02491   case scalbl_underflow:
02492     /* scalbl underflow */
02493     {
02494        UNDERFLOWL; NAMEL = (char *) "scalbl";
02495        if (INPUT_XL < ZEROL_VALUE /*0.0L*/) RETVAL_NEG_ZEROL;
02496        else  RETVAL_ZEROL;
02497        NOT_MATHERRL {ERRNO_RANGE;}
02498        *(long double *)retval = excl.retval;
02499        break;
02500     }
02501   case scalb_underflow:
02502     /* scalb underflow */
02503     {
02504        UNDERFLOWD; NAMED = (char *) "scalb";
02505        if (INPUT_XD < ZEROD_VALUE /*0.0*/) RETVAL_NEG_ZEROD;
02506        else  RETVAL_ZEROD;
02507        NOT_MATHERRD {ERRNO_RANGE;}
02508        *(double *)retval = exc.retval;
02509        break;
02510     }
02511   case scalbf_underflow:
02512     /* scalbf underflow */
02513     {
02514        UNDERFLOWF; NAMEF = (char *) "scalbf";
02515        if (INPUT_XF < ZEROF_VALUE /*0.0*/) RETVAL_NEG_ZEROF;
02516        else  RETVAL_ZEROF;
02517        NOT_MATHERRF {ERRNO_RANGE;}
02518        *(float *)retval = excf.retval;
02519        break;
02520     }
02521   case scalbl_overflow:
02522     /* scalbl overflow */
02523     {
02524        OVERFLOWL; NAMEL = (char *) "scalbl";
02525        if (INPUT_XL < ZEROL_VALUE /*0*/) RETVAL_NEG_HUGE_VALL;
02526        else RETVAL_HUGE_VALL;
02527        NOT_MATHERRL {ERRNO_RANGE;}
02528        *(long double *)retval = excl.retval;
02529        break;
02530     }
02531   case scalb_overflow:
02532     /* scalb overflow */
02533     {
02534        OVERFLOWD; NAMED = (char *) "scalb";
02535        if (INPUT_XD < ZEROD_VALUE /*0*/) RETVAL_NEG_HUGE_VALD;
02536        else RETVAL_HUGE_VALD;
02537        NOT_MATHERRD {ERRNO_RANGE;}
02538        *(double *)retval = exc.retval;
02539        break;
02540     }
02541   case scalbf_overflow:
02542     /* scalbf overflow */
02543     {
02544        OVERFLOWF; NAMEF = (char *) "scalbf";
02545        if (INPUT_XF < ZEROF_VALUE /*0*/) RETVAL_NEG_HUGE_VALF;
02546        else RETVAL_HUGE_VALF;
02547        NOT_MATHERRF {ERRNO_RANGE;}
02548        *(float *)retval = excf.retval;
02549        break;
02550     }
02551   case hypotl_overflow:
02552     /* hypotl overflow */
02553     {
02554        OVERFLOWL; NAMEL = (char *) "hypotl";
02555        ifSVID
02556        {
02557          RETVAL_HUGEL;
02558        }
02559        else
02560        {
02561          RETVAL_HUGE_VALL;
02562        }
02563        NOT_MATHERRL {ERRNO_RANGE;}
02564        *(long double *)retval = excl.retval;
02565        break;
02566     }
02567   case hypot_overflow:
02568     /* hypot overflow */
02569     {
02570        OVERFLOWD; NAMED = (char *) "hypot";
02571        ifSVID
02572        {
02573          RETVAL_HUGED;
02574        }
02575        else
02576        {
02577          RETVAL_HUGE_VALD;
02578        }
02579        NOT_MATHERRD {ERRNO_RANGE;}
02580        *(double *)retval = exc.retval;
02581        break;
02582     }
02583   case hypotf_overflow:
02584     /* hypotf overflow */
02585     {
02586        OVERFLOWF; NAMEF = (char *) "hypotf";
02587        ifSVID
02588        {
02589          RETVAL_HUGEF;
02590        }
02591        else
02592        {
02593          RETVAL_HUGE_VALF;
02594        }
02595        NOT_MATHERRF {ERRNO_RANGE;}
02596        *(float *)retval = excf.retval;
02597        break;
02598     }
02599   case acosl_gt_one:
02600     /* acosl(x > 1) */
02601     {
02602        DOMAINL; NAMEL = (char *) "acosl";
02603        RETVAL_ZEROL;
02604        ifSVID
02605        {
02606          NOT_MATHERRL
02607          {
02608            WRITEL_ACOS;
02609            ERRNO_DOMAIN;
02610          }
02611        }
02612        else
02613        {
02614          NOT_MATHERRL {ERRNO_DOMAIN;}
02615        }
02616        *(long double *)retval = excl.retval;
02617        break;
02618     }
02619   case acos_gt_one:
02620     /* acos(x > 1) */
02621     {
02622        DOMAIND; NAMED = (char *) "acos";
02623        RETVAL_ZEROD;
02624        ifSVID
02625        {
02626          NOT_MATHERRD
02627          {
02628            WRITED_ACOS;
02629            ERRNO_DOMAIN;
02630          }
02631        }
02632        else
02633        {
02634          NOT_MATHERRD {ERRNO_DOMAIN;}
02635        }
02636        *(double *)retval = exc.retval;
02637        break;
02638     }
02639   case acosf_gt_one:
02640     /* acosf(x > 1) */
02641     {
02642        DOMAINF; NAMEF = (char *) "acosf";
02643        RETVAL_ZEROF;
02644        ifSVID
02645        {
02646          NOT_MATHERRF
02647          {
02648            WRITEF_ACOS;
02649            ERRNO_DOMAIN;
02650          }
02651        }
02652        else
02653        {
02654          NOT_MATHERRF {ERRNO_DOMAIN;}
02655        }
02656        *(float *)retval = excf.retval;
02657        break;
02658     }
02659   case asinl_gt_one:
02660     /* asinl(x > 1) */
02661     {
02662        DOMAINL; NAMEL = (char *) "asinl";
02663        RETVAL_ZEROL;
02664        ifSVID
02665        {
02666          NOT_MATHERRL
02667          {
02668            WRITEL_ASIN;
02669            ERRNO_DOMAIN;
02670          }
02671        }
02672        else
02673        {
02674          NOT_MATHERRL {ERRNO_DOMAIN;}
02675        }
02676        *(long double *)retval = excl.retval;
02677        break;
02678     }
02679   case asin_gt_one:
02680     /* asin(x > 1) */
02681     {
02682        DOMAIND; NAMED = (char *) "asin";
02683        RETVAL_ZEROD;
02684        ifSVID
02685        {
02686          NOT_MATHERRD
02687          {
02688            WRITED_ASIN;
02689            ERRNO_DOMAIN;
02690          }
02691        }
02692        else
02693        {
02694          NOT_MATHERRD {ERRNO_DOMAIN;}
02695        }
02696        *(double *)retval = exc.retval;
02697        break;
02698     }
02699   case asinf_gt_one:
02700     /* asinf(x > 1) */
02701     {
02702        DOMAINF; NAMEF = (char *) "asinf";
02703        RETVAL_ZEROF;
02704        ifSVID
02705        {
02706          NOT_MATHERRF
02707          {
02708             WRITEF_ASIN;
02709             ERRNO_DOMAIN;
02710          }
02711        }
02712        else
02713        {
02714          NOT_MATHERRF {ERRNO_DOMAIN;}
02715        }
02716        *(float *)retval = excf.retval;
02717        break;
02718     }
02719   case acosdl_gt_one:
02720     /* acosdl(x > 1) */
02721     {
02722        DOMAINL; NAMEL = (char *) "acosdl";
02723        RETVAL_ZEROL;
02724        ifSVID
02725        {
02726          NOT_MATHERRL
02727          {
02728            WRITEL_ACOSD;
02729            ERRNO_DOMAIN;
02730          }
02731        }
02732        else
02733        {
02734          NOT_MATHERRL {ERRNO_DOMAIN;}
02735        }
02736        *(long double *)retval = excl.retval;
02737        break;
02738     }
02739   case acosd_gt_one:
02740     /* acosd(x > 1) */
02741     {
02742        DOMAIND; NAMED = (char *) "acosd";
02743        RETVAL_ZEROD;
02744        ifSVID
02745        {
02746          NOT_MATHERRD
02747          {
02748            WRITED_ACOSD;
02749            ERRNO_DOMAIN;
02750          }
02751        }
02752        else
02753        {
02754          NOT_MATHERRD {ERRNO_DOMAIN;}
02755        }
02756        *(double *)retval = exc.retval;
02757        break;
02758     }
02759   case acosdf_gt_one:
02760     /* acosdf(x > 1) */
02761     {
02762        DOMAINF; NAMEF = (char *) "acosdf";
02763        RETVAL_ZEROF;
02764        ifSVID
02765        {
02766          NOT_MATHERRF
02767          {
02768            WRITEF_ACOSD;
02769            ERRNO_DOMAIN;
02770          }
02771        }
02772        else
02773        {
02774          NOT_MATHERRF {ERRNO_DOMAIN;}
02775        }
02776        *(float *)retval = excf.retval;
02777        break;
02778     }
02779   case asindl_gt_one:
02780     /* asindl(x > 1) */
02781     {
02782        DOMAINL; NAMEL = (char *) "asindl";
02783        RETVAL_ZEROL;
02784        ifSVID
02785        {
02786          NOT_MATHERRL
02787          {
02788            WRITEL_ASIND;
02789            ERRNO_DOMAIN;
02790          }
02791        }
02792        else
02793        {
02794          NOT_MATHERRL {ERRNO_DOMAIN;}
02795        }
02796        *(long double *)retval = excl.retval;
02797        break;
02798     }
02799   case asind_gt_one:
02800     /* asind(x > 1) */
02801     {
02802        DOMAIND; NAMED = (char *) "asind";
02803        RETVAL_ZEROD;
02804        ifSVID
02805        {
02806          NOT_MATHERRD
02807          {
02808            WRITED_ASIND;
02809            ERRNO_DOMAIN;
02810          }
02811        }
02812        else
02813        {
02814          NOT_MATHERRD {ERRNO_DOMAIN;}
02815        }
02816        *(double *)retval = exc.retval;
02817        break;
02818     }
02819   case asindf_gt_one:
02820     /* asindf(x > 1) */
02821     {
02822        DOMAINF; NAMEF = (char *) "asindf";
02823        RETVAL_ZEROF;
02824        ifSVID
02825        {
02826          NOT_MATHERRF
02827          {
02828             WRITEF_ASIND;
02829             ERRNO_DOMAIN;
02830          }
02831        }
02832        else
02833        {
02834          NOT_MATHERRF {ERRNO_DOMAIN;}
02835        }
02836        *(float *)retval = excf.retval;
02837        break;
02838     }
02839  case coshl_overflow:
02840    /* coshl overflow */
02841    {
02842       OVERFLOWL; NAMEL = (char *) "coshl";
02843       ifSVID
02844       {
02845         RETVAL_HUGEL;
02846       }
02847       else
02848       {
02849         RETVAL_HUGE_VALL;
02850       }
02851       NOT_MATHERRL {ERRNO_RANGE;}
02852       *(long double *)retval = excl.retval;
02853       break;
02854    }
02855  case cosh_overflow:
02856    /* cosh overflow */
02857    {
02858       OVERFLOWD; NAMED = (char *) "cosh";
02859       ifSVID
02860       {
02861         RETVAL_HUGED;
02862       }
02863       else
02864       {
02865         RETVAL_HUGE_VALD;
02866       }
02867       NOT_MATHERRD {ERRNO_RANGE;}
02868       *(double *)retval = exc.retval;
02869       break;
02870    }
02871  case coshf_overflow:
02872    /* coshf overflow */
02873    {
02874       OVERFLOWF; NAMEF = (char *) "coshf";
02875       ifSVID
02876       {
02877         RETVAL_HUGEF;
02878       }
02879       else
02880       {
02881         RETVAL_HUGE_VALF;
02882       }
02883       NOT_MATHERRF {ERRNO_RANGE;}
02884       *(float *)retval = excf.retval;
02885       break;
02886    }
02887  case sinhl_overflow:
02888    /* sinhl overflow */
02889    {
02890       OVERFLOWL; NAMEL = (char *) "sinhl";
02891       ifSVID
02892       {
02893         if (INPUT_XL > ZEROL_VALUE /*0.0*/) RETVAL_HUGEL;
02894         else RETVAL_NEG_HUGEL;
02895       }
02896       else
02897       {
02898         if (INPUT_XL > ZEROL_VALUE /*0.0*/) RETVAL_HUGE_VALL;
02899         else RETVAL_NEG_HUGE_VALL;
02900       }
02901       NOT_MATHERRL {ERRNO_RANGE;}
02902       *(long double *)retval = excl.retval;
02903       break;
02904    }
02905  case sinh_overflow:
02906    /* sinh overflow */
02907    {
02908       OVERFLOWD; NAMED = (char *) "sinh";
02909       ifSVID
02910       {
02911         if (INPUT_XD > ZEROD_VALUE /*0.0*/) RETVAL_HUGED;
02912         else RETVAL_NEG_HUGED;
02913       }
02914       else
02915       {
02916         if (INPUT_XD > ZEROD_VALUE /*0.0*/) RETVAL_HUGE_VALD;
02917         else RETVAL_NEG_HUGE_VALD;
02918       }
02919       NOT_MATHERRD {ERRNO_RANGE;}
02920       *(double *)retval = exc.retval;
02921       break;
02922    }
02923  case sinhf_overflow:
02924    /* sinhf overflow */
02925    {
02926       OVERFLOWF; NAMEF = (char *) "sinhf";
02927       ifSVID
02928       {
02929         if (INPUT_XF > ZEROF_VALUE /*0.0*/) RETVAL_HUGEF;
02930         else RETVAL_NEG_HUGEF;
02931       }
02932       else
02933       {
02934         if (INPUT_XF > ZEROF_VALUE /*0.0*/) RETVAL_HUGE_VALF;
02935         else RETVAL_NEG_HUGE_VALF;
02936       }
02937       NOT_MATHERRF {ERRNO_RANGE;}
02938       *(float *)retval = excf.retval;
02939       break;
02940    }
02941   case acoshl_lt_one:
02942     /* acoshl(x < 1) */
02943     {
02944        DOMAINL; NAMEL = (char *) "acoshl";
02945        ifSVID
02946        {
02947          NOT_MATHERRL
02948          {
02949            WRITEL_ACOSH;
02950            ERRNO_DOMAIN;
02951          }
02952        }
02953        else
02954        {
02955            NOT_MATHERRL {ERRNO_DOMAIN;}
02956        }
02957        *(long double *)retval = excl.retval;
02958        break;
02959     }
02960   case acosh_lt_one:
02961     /* acosh(x < 1) */
02962     {
02963        DOMAIND; NAMED = (char *) "acosh";
02964        ifSVID
02965        {
02966          NOT_MATHERRD
02967          {
02968           WRITED_ACOSH;
02969           ERRNO_DOMAIN;
02970          }
02971        }
02972        else
02973        {
02974           NOT_MATHERRD {ERRNO_DOMAIN;}
02975        }
02976        *(double *)retval = exc.retval;
02977        break;
02978     }
02979   case acoshf_lt_one:
02980     /* acoshf(x < 1) */
02981     {
02982        DOMAINF; NAMEF = (char *) "acoshf";
02983        ifSVID
02984        {
02985          NOT_MATHERRF
02986          {
02987            WRITEF_ACOSH;
02988            ERRNO_DOMAIN;
02989          }
02990        }
02991        else
02992        {
02993          NOT_MATHERRF {ERRNO_DOMAIN;}
02994        }
02995        *(float *)retval = excf.retval;
02996        break;
02997     }
02998   case atanhl_gt_one:
02999     /* atanhl(|x| > 1) */
03000     {
03001        DOMAINL; NAMEL = (char *) "atanhl";
03002        ifSVID
03003        {
03004          NOT_MATHERRL
03005          {
03006            WRITEL_ATANH_GT_ONE;
03007            ERRNO_DOMAIN;
03008          }
03009        }
03010        else
03011        {
03012          NOT_MATHERRL {ERRNO_DOMAIN;}
03013        }
03014        break;
03015     }
03016   case atanh_gt_one:
03017     /* atanh(|x| > 1) */
03018     {
03019        DOMAIND; NAMED = (char *) "atanh";
03020        ifSVID
03021        {
03022          NOT_MATHERRD
03023          {
03024            WRITED_ATANH_GT_ONE;
03025            ERRNO_DOMAIN;
03026          }
03027        }
03028        else
03029        {
03030          NOT_MATHERRD {ERRNO_DOMAIN;}
03031        }
03032        break;
03033     }
03034   case atanhf_gt_one:
03035     /* atanhf(|x| > 1) */
03036     {
03037        DOMAINF; NAMEF = (char *) "atanhf";
03038        ifSVID
03039        {
03040          NOT_MATHERRF
03041          {
03042            WRITEF_ATANH_GT_ONE;
03043            ERRNO_DOMAIN;
03044          }
03045        }
03046        else
03047        {
03048          NOT_MATHERRF {ERRNO_DOMAIN;}
03049        }
03050        break;
03051     }
03052   case atanhl_eq_one:
03053     /* atanhl(|x| == 1) */
03054     {
03055        SINGL; NAMEL = (char *) "atanhl";
03056        ifSVID
03057        {
03058          NOT_MATHERRL
03059          {
03060            WRITEL_ATANH_EQ_ONE;
03061            ERRNO_DOMAIN;
03062          }
03063        }
03064        else
03065        {
03066          NOT_MATHERRL {ERRNO_DOMAIN;}
03067        }
03068        break;
03069     }
03070   case atanh_eq_one:
03071     /* atanh(|x| == 1) */
03072     {
03073        SINGD; NAMED = (char *) "atanh";
03074        ifSVID
03075        {
03076          NOT_MATHERRD
03077          {
03078            WRITED_ATANH_EQ_ONE;
03079            ERRNO_DOMAIN;
03080          }
03081        }
03082        else
03083        {
03084        NOT_MATHERRD {ERRNO_DOMAIN;}
03085        }
03086        break;
03087     }
03088   case atanhf_eq_one:
03089     /* atanhf(|x| == 1) */
03090     {
03091        SINGF; NAMEF = (char *) "atanhf";
03092        ifSVID
03093        {
03094          NOT_MATHERRF
03095          {
03096            WRITEF_ATANH_EQ_ONE;
03097            ERRNO_DOMAIN;
03098          }
03099        }
03100        else
03101        {
03102          NOT_MATHERRF {ERRNO_DOMAIN;}
03103        }
03104        break;
03105     }
03106   case gammal_overflow:
03107     /* gammal overflow */
03108     {
03109        OVERFLOWL; NAMEL = (char *) "gammal";
03110        ifSVID
03111        {
03112          RETVAL_HUGEL;
03113        }
03114        else
03115        {
03116          RETVAL_HUGE_VALL;
03117        }
03118        NOT_MATHERRL {ERRNO_RANGE;}
03119        *(long double *)retval = excl.retval;
03120        break;
03121     }
03122   case gamma_overflow:
03123     /* gamma overflow */
03124     {
03125        OVERFLOWD; NAMED = (char *) "gamma";
03126        ifSVID
03127        {
03128          RETVAL_HUGED;
03129        }
03130          else
03131        {
03132          RETVAL_HUGE_VALD;
03133        }
03134        NOT_MATHERRD {ERRNO_RANGE;}
03135        *(double *)retval = exc.retval;
03136        break;
03137     }
03138   case gammaf_overflow:
03139     /* gammaf overflow */
03140     {
03141        OVERFLOWF; NAMEF = (char *) "gammaf";
03142        ifSVID
03143        {
03144          RETVAL_HUGEF;
03145        }
03146        else
03147        {
03148          RETVAL_HUGE_VALF;
03149        }
03150        NOT_MATHERRF {ERRNO_RANGE;}
03151        *(float *)retval = excf.retval;
03152        break;
03153     }
03154   case gammal_negative:
03155     /* gammal -int or 0 */
03156     {
03157        SINGL; NAMEL = (char *) "gammal";
03158        ifSVID
03159        {
03160          RETVAL_HUGEL;
03161          NOT_MATHERRL
03162          {
03163             WRITEL_GAMMA_NEGATIVE;
03164             ERRNO_DOMAIN;
03165          }
03166        }
03167        else
03168        {
03169          RETVAL_HUGE_VALL;
03170          NOT_MATHERRL {ERRNO_DOMAIN;}
03171        }
03172        *(long double *)retval = excl.retval;
03173        break;
03174     }
03175   case gamma_negative:
03176     /* gamma -int or 0 */
03177     {
03178        SINGD; NAMED = (char *) "gamma";
03179        ifSVID
03180        {
03181          RETVAL_HUGED;
03182          NOT_MATHERRD
03183          {
03184             WRITED_GAMMA_NEGATIVE;
03185             ERRNO_DOMAIN;
03186          }
03187        }
03188        else
03189        {
03190          RETVAL_HUGE_VALD;
03191          NOT_MATHERRD {ERRNO_DOMAIN;}
03192        }
03193        *(double *)retval = exc.retval;
03194        break;
03195     }
03196   case gammaf_negative:
03197     /* gammaf -int or 0 */
03198     {
03199        SINGF; NAMEF = (char *) "gammaf";
03200        ifSVID
03201        {
03202          RETVAL_HUGEF;
03203          NOT_MATHERRF
03204          {
03205             WRITEF_GAMMA_NEGATIVE;
03206             ERRNO_DOMAIN;
03207          }
03208        }
03209        else
03210        {
03211          RETVAL_HUGE_VALF;
03212          NOT_MATHERRF {ERRNO_DOMAIN;}
03213        }
03214        *(float *)retval = excf.retval;
03215        break;
03216     }
03217   case lgammal_overflow:
03218     /* lgammal overflow */
03219     {
03220        OVERFLOWL; NAMEL = (char *) "lgammal";
03221        ifSVID
03222        {
03223          RETVAL_HUGEL;
03224        }
03225        else
03226        {
03227          RETVAL_HUGE_VALL;
03228        }
03229        NOT_MATHERRL {ERRNO_RANGE;}
03230        *(long double *)retval = excl.retval;
03231        break;
03232     }
03233   case lgamma_overflow:
03234     /* lgamma overflow */
03235     {
03236        OVERFLOWD; NAMED = (char *) "lgamma";
03237        ifSVID
03238        {
03239          RETVAL_HUGED;
03240        }
03241        else
03242        {
03243          RETVAL_HUGE_VALD;
03244        }
03245        NOT_MATHERRD {ERRNO_RANGE;}
03246        *(double *)retval = exc.retval;
03247        break;
03248     }
03249   case lgammaf_overflow:
03250     /* lgammaf overflow */
03251     {
03252        OVERFLOWF; NAMEF = (char *) "lgammaf";
03253        ifSVID
03254        {
03255          RETVAL_HUGEF;
03256        }
03257        else
03258        {
03259          RETVAL_HUGE_VALF;
03260        }
03261        NOT_MATHERRF {ERRNO_RANGE;}
03262        *(float *)retval = excf.retval;
03263        break;
03264     }
03265   case lgammal_negative:
03266     /* lgammal -int or 0 */
03267     {
03268        SINGL; NAMEL = (char *) "lgammal";
03269        ifSVID
03270        {
03271          RETVAL_HUGEL;
03272          NOT_MATHERRL
03273          {
03274            WRITEL_LGAMMA_NEGATIVE;
03275            ERRNO_DOMAIN;
03276          }
03277        }
03278        else
03279        {
03280          RETVAL_HUGE_VALL;
03281          NOT_MATHERRL {ERRNO_DOMAIN;}
03282        }
03283        *(long double *)retval = excl.retval;
03284        break;
03285     }
03286   case lgamma_negative:
03287     /* lgamma -int or 0 */
03288     {
03289        SINGD; NAMED = (char *) "lgamma";
03290        ifSVID
03291        {
03292          RETVAL_HUGED;
03293          NOT_MATHERRD
03294          {
03295            WRITED_LGAMMA_NEGATIVE;
03296            ERRNO_DOMAIN;
03297          }
03298        }
03299        else
03300        {
03301          RETVAL_HUGE_VALD;
03302          NOT_MATHERRD {ERRNO_DOMAIN;}
03303        }
03304        *(double *)retval = exc.retval;
03305        break;
03306     }
03307   case lgammaf_negative:
03308     /* lgammaf -int or 0 */
03309     {
03310        SINGF; NAMEF = (char *) "lgammaf";
03311        ifSVID
03312        {
03313          RETVAL_HUGEF;
03314          NOT_MATHERRF
03315          {
03316            WRITEF_LGAMMA_NEGATIVE;
03317            ERRNO_DOMAIN;
03318          }
03319        }
03320        else
03321        {
03322          RETVAL_HUGE_VALF;
03323          NOT_MATHERRF {ERRNO_DOMAIN;}
03324        }
03325        *(float *)retval = excf.retval;
03326        break;
03327     }
03328   case tgammal_overflow:
03329     /* tgammal overflow */
03330     {
03331        OVERFLOWL; NAMEL = (char *) "tgammal";
03332        ifSVID
03333        {
03334          RETVAL_HUGEL;
03335        }
03336        else
03337        {
03338          RETVAL_HUGE_VALL;
03339        }
03340        NOT_MATHERRL {ERRNO_RANGE;}
03341        *(long double *)retval = excl.retval;
03342        break;
03343     }
03344   case tgamma_overflow:
03345     /* tgamma overflow */
03346     {
03347        OVERFLOWD; NAMED = (char *) "tgamma";
03348        ifSVID
03349        {
03350          RETVAL_HUGED;
03351        }
03352        else
03353        {
03354          RETVAL_HUGE_VALD;
03355        }
03356        NOT_MATHERRD {ERRNO_RANGE;}
03357        *(double *)retval = exc.retval;
03358        break;
03359     }
03360   case tgammaf_overflow:
03361     /* tgammaf overflow */
03362     {
03363        OVERFLOWF; NAMEF = (char *) "tgammaf";
03364        ifSVID
03365        {
03366          RETVAL_HUGEF;
03367        }
03368        else
03369        {
03370          RETVAL_HUGE_VALF;
03371        }
03372        NOT_MATHERRF {ERRNO_RANGE;}
03373        *(float *)retval = excf.retval;
03374        break;
03375     }
03376   case tgammal_negative:
03377     /* tgammal -int or 0 */
03378     {
03379        SINGL; NAMEL = (char *) "tgammal";
03380        ifSVID
03381        {
03382          NOT_MATHERRL
03383          {
03384            WRITEL_TGAMMA_NEGATIVE;
03385            ERRNO_DOMAIN;
03386          }
03387        }
03388        else
03389        {
03390          NOT_MATHERRL {ERRNO_DOMAIN;}
03391        }
03392        *(long double *)retval = excl.retval;
03393        break;
03394     }
03395   case tgamma_negative:
03396     /* tgamma -int or 0 */
03397     {
03398        SINGD; NAMED = (char *) "tgamma";
03399        ifSVID
03400        {
03401          NOT_MATHERRD
03402          {
03403            WRITED_TGAMMA_NEGATIVE;
03404            ERRNO_DOMAIN;
03405          }
03406        }
03407        else
03408        {
03409          NOT_MATHERRD {ERRNO_DOMAIN;}
03410        }
03411        *(double *)retval = exc.retval;
03412        break;
03413     }
03414   case tgammaf_negative:
03415     /* tgammaf -int or 0 */
03416     {
03417        SINGF; NAMEF = (char *) "tgammaf";
03418        ifSVID
03419        {
03420          NOT_MATHERRF
03421          {
03422            WRITEF_TGAMMA_NEGATIVE;
03423            ERRNO_DOMAIN;
03424          }
03425        }
03426        else
03427        {
03428          NOT_MATHERRF {ERRNO_DOMAIN;}
03429        }
03430        *(float *)retval = excf.retval;
03431        break;
03432     }
03433   case j0l_gt_loss:
03434     /* j0l > loss */
03435     {
03436        TLOSSL; NAMEL = (char *) "j0l";
03437        RETVAL_ZEROL;
03438        ifSVID
03439        {
03440          NOT_MATHERRL
03441          {
03442             WRITEL_J0_TLOSS;
03443             ERRNO_RANGE;
03444          }
03445        }
03446        else
03447        {
03448          NOT_MATHERRL {ERRNO_RANGE;}
03449        }
03450        *(long double *)retval = excl.retval;
03451        break;
03452     }
03453   case j0_gt_loss:
03454     /* j0 > loss */
03455     {
03456        TLOSSD; NAMED = (char *) "j0";
03457        RETVAL_ZEROD;
03458        ifSVID
03459        {
03460          NOT_MATHERRD
03461          {
03462             WRITED_J0_TLOSS;
03463             ERRNO_RANGE;
03464          }
03465        }
03466        else
03467        {
03468          NOT_MATHERRD {ERRNO_RANGE;}
03469        }
03470        *(double*)retval = exc.retval;
03471        break;
03472     }
03473   case j0f_gt_loss:
03474     /* j0f > loss */
03475     {
03476        TLOSSF; NAMEF = (char *) "j0f";
03477        RETVAL_ZEROF;
03478        ifSVID
03479        {
03480          NOT_MATHERRF
03481          {
03482             WRITEF_J0_TLOSS;
03483             ERRNO_RANGE;
03484          }
03485        }
03486        else
03487        {
03488          NOT_MATHERRF {ERRNO_RANGE;}
03489        }
03490        *(float*)retval = excf.retval;
03491        break;
03492     }
03493   case j1l_gt_loss:
03494     /* j1l > loss */
03495     {
03496        TLOSSL; NAMEL = (char *) "j1l";
03497        RETVAL_ZEROL;
03498        ifSVID
03499        {
03500          NOT_MATHERRL
03501          {
03502             WRITEL_J1_TLOSS;
03503             ERRNO_RANGE;
03504          }
03505        }
03506        else
03507        {
03508          NOT_MATHERRL {ERRNO_RANGE;}
03509        }
03510        *(long double *)retval = excl.retval;
03511        break;
03512     }
03513   case j1_gt_loss:
03514     /* j1 > loss */
03515     {
03516        TLOSSD; NAMED = (char *) "j1";
03517        RETVAL_ZEROD;
03518        ifSVID
03519        {
03520          NOT_MATHERRD
03521          {
03522             WRITED_J1_TLOSS;
03523             ERRNO_RANGE;
03524          }
03525        }
03526        else
03527        {
03528          NOT_MATHERRD {ERRNO_RANGE;}
03529        }
03530        *(double*)retval = exc.retval;
03531        break;
03532     }
03533   case j1f_gt_loss:
03534     /* j1f > loss */
03535     {
03536        TLOSSF; NAMEF = (char *) "j1f";
03537        RETVAL_ZEROF;
03538        ifSVID
03539        {
03540          NOT_MATHERRF
03541          {
03542             WRITEF_J1_TLOSS;
03543             ERRNO_RANGE;
03544          }
03545        }
03546        else
03547        {
03548          NOT_MATHERRF {ERRNO_RANGE;}
03549        }
03550        *(float*)retval = excf.retval;
03551        break;
03552     }
03553   case jnl_gt_loss:
03554     /* jnl > loss */
03555     {
03556        TLOSSL; NAMEL = (char *) "jnl";
03557        RETVAL_ZEROL;
03558        ifSVID
03559        {
03560          NOT_MATHERRL
03561          {
03562             WRITEL_JN_TLOSS;
03563             ERRNO_RANGE;
03564          }
03565        }
03566        else
03567        {
03568          NOT_MATHERRL {ERRNO_RANGE;}
03569        }
03570        *(long double *)retval = excl.retval;
03571        break;
03572     }
03573   case jn_gt_loss:
03574     /* jn > loss */
03575     {
03576        TLOSSD; NAMED = (char *) "jn";
03577        RETVAL_ZEROD;
03578        ifSVID
03579        {
03580          NOT_MATHERRD
03581          {
03582             WRITED_JN_TLOSS;
03583             ERRNO_RANGE;
03584          }
03585        }
03586        else
03587        {
03588          NOT_MATHERRD {ERRNO_RANGE;}
03589        }
03590        *(double*)retval = exc.retval;
03591        break;
03592     }
03593   case jnf_gt_loss:
03594     /* jnf > loss */
03595     {
03596        TLOSSF; NAMEF = (char *) "jnf";
03597        RETVAL_ZEROF;
03598        ifSVID
03599        {
03600          NOT_MATHERRF
03601          {
03602             WRITEF_JN_TLOSS;
03603             ERRNO_RANGE;
03604          }
03605        }
03606        else
03607        {
03608          NOT_MATHERRF {ERRNO_RANGE;}
03609        }
03610        *(float*)retval = excf.retval;
03611        break;
03612     }
03613   case y0l_gt_loss:
03614     /* y0l > loss */
03615     {
03616        TLOSSL; NAMEL = (char *) "y0l";
03617        RETVAL_ZEROL;
03618        ifSVID
03619        {
03620          NOT_MATHERRL
03621          {
03622             WRITEL_Y0_TLOSS;
03623             ERRNO_RANGE;
03624          }
03625        }
03626        else
03627        {
03628          NOT_MATHERRL {ERRNO_RANGE;}
03629        }
03630        *(long double *)retval = excl.retval;
03631        break;
03632     }
03633   case y0_gt_loss:
03634     /* y0 > loss */
03635     {
03636        TLOSSD; NAMED = (char *) "y0";
03637        RETVAL_ZEROD;
03638        ifSVID
03639        {
03640          NOT_MATHERRD
03641          {
03642             WRITED_Y0_TLOSS;
03643             ERRNO_RANGE;
03644          }
03645        }
03646        else
03647        {
03648          NOT_MATHERRD {ERRNO_RANGE;}
03649        }
03650        *(double*)retval = exc.retval;
03651        break;
03652     }
03653   case y0f_gt_loss:
03654     /* y0f > loss */
03655     {
03656        TLOSSF; NAMEF = (char *) "y0f";
03657        RETVAL_ZEROF;
03658        ifSVID
03659        {
03660          NOT_MATHERRF
03661          {
03662             WRITEF_Y0_TLOSS;
03663             ERRNO_RANGE;
03664          }
03665        }
03666        else
03667        {
03668          NOT_MATHERRF {ERRNO_RANGE;}
03669        }
03670        *(float*)retval = excf.retval;
03671        break;
03672     }
03673   case y0l_zero:
03674     /* y0l(0) */
03675     {
03676        DOMAINL; NAMEL = (char *) "y0l";
03677        ifSVID
03678        {
03679          RETVAL_NEG_HUGEL;
03680          NOT_MATHERRL
03681          {
03682            WRITEL_Y0_ZERO;
03683            ERRNO_DOMAIN;
03684          }
03685        }
03686        else
03687        {
03688          RETVAL_NEG_HUGE_VALL;
03689          NOT_MATHERRL {ERRNO_DOMAIN;}
03690        }
03691        *(long double *)retval = excl.retval;
03692        break;
03693     }
03694   case y0_zero:
03695     /* y0(0) */
03696     {
03697        DOMAIND; NAMED = (char *) "y0";
03698        ifSVID
03699        {
03700          RETVAL_NEG_HUGED;
03701          NOT_MATHERRD
03702          {
03703            WRITED_Y0_ZERO;
03704            ERRNO_DOMAIN;
03705          }
03706        }
03707        else
03708        {
03709          RETVAL_NEG_HUGE_VALD;
03710          NOT_MATHERRD {ERRNO_DOMAIN;}
03711        }
03712        *(double *)retval = exc.retval;
03713        break;
03714     }
03715   case y0f_zero:
03716     /* y0f(0) */
03717     {
03718        DOMAINF; NAMEF = (char *) "y0f";
03719        ifSVID
03720        {
03721          RETVAL_NEG_HUGEF;
03722          NOT_MATHERRF
03723          {
03724            WRITEF_Y0_ZERO;
03725            ERRNO_DOMAIN;
03726          }
03727        }
03728        else
03729        {
03730          RETVAL_NEG_HUGE_VALF;
03731          NOT_MATHERRF {ERRNO_DOMAIN;}
03732        }
03733        *(float *)retval = excf.retval;
03734        break;
03735     }
03736   case y1l_gt_loss:
03737     /* y1l > loss */
03738     {
03739        TLOSSL; NAMEL = (char *) "y1l";
03740        RETVAL_ZEROL;
03741        ifSVID
03742        {
03743          NOT_MATHERRL
03744          {
03745             WRITEL_Y1_TLOSS;
03746             ERRNO_RANGE;
03747          }
03748        }
03749        else
03750        {
03751          NOT_MATHERRL {ERRNO_RANGE;}
03752        }
03753        *(long double *)retval = excl.retval;
03754        break;
03755     }
03756   case y1_gt_loss:
03757     /* y1 > loss */
03758     {
03759        TLOSSD; NAMED = (char *) "y1";
03760        RETVAL_ZEROD;
03761        ifSVID
03762        {
03763          NOT_MATHERRD
03764          {
03765             WRITED_Y1_TLOSS;
03766             ERRNO_RANGE;
03767          }
03768        }
03769        else
03770        {
03771          NOT_MATHERRD {ERRNO_RANGE;}
03772        }
03773        *(double*)retval = exc.retval;
03774        break;
03775     }
03776   case y1f_gt_loss:
03777     /* y1f > loss */
03778     {
03779        TLOSSF; NAMEF = (char *) "y1f";
03780        RETVAL_ZEROF;
03781        ifSVID
03782        {
03783          NOT_MATHERRF
03784          {
03785             WRITEF_Y1_TLOSS;
03786             ERRNO_RANGE;
03787          }
03788        }
03789        else
03790        {
03791          NOT_MATHERRF {ERRNO_RANGE;}
03792        }
03793        *(float*)retval = excf.retval;
03794        break;
03795     }
03796   case y1l_zero:
03797     /* y1l(0) */
03798     {
03799        DOMAINL; NAMEL = (char *) "y1l";
03800        ifSVID
03801        {
03802          RETVAL_NEG_HUGEL;
03803          NOT_MATHERRL
03804          {
03805            WRITEL_Y1_ZERO;
03806            ERRNO_DOMAIN;
03807          }
03808        }
03809        else
03810        {
03811          RETVAL_NEG_HUGE_VALL;
03812          NOT_MATHERRL {ERRNO_DOMAIN;}
03813        }
03814        *(long double *)retval = excl.retval;
03815        break;
03816     }
03817   case y1_zero:
03818     /* y1(0) */
03819     {
03820        DOMAIND; NAMED = (char *) "y1";
03821        ifSVID
03822        {
03823          RETVAL_NEG_HUGED;
03824          NOT_MATHERRD
03825          {
03826            WRITED_Y1_ZERO;
03827            ERRNO_DOMAIN;
03828          }
03829        }
03830        else
03831        {
03832          RETVAL_NEG_HUGE_VALD;
03833          NOT_MATHERRD {ERRNO_DOMAIN;}
03834        }
03835        *(double *)retval = exc.retval;
03836        break;
03837     }
03838   case y1f_zero:
03839     /* y1f(0) */
03840     {
03841        DOMAINF; NAMEF = (char *) "y1f";
03842        ifSVID
03843        {
03844          RETVAL_NEG_HUGEF;
03845          NOT_MATHERRF
03846          {
03847            WRITEF_Y1_ZERO;
03848            ERRNO_DOMAIN;
03849          }
03850        }
03851        else
03852        {
03853          RETVAL_NEG_HUGE_VALF;
03854          NOT_MATHERRF {ERRNO_DOMAIN;}
03855        }
03856        *(float *)retval = excf.retval;
03857        break;
03858     }
03859   case ynl_gt_loss:
03860     /* ynl > loss */
03861     {
03862        TLOSSL; NAMEL = (char *) "ynl";
03863        RETVAL_ZEROL;
03864        ifSVID
03865        {
03866          NOT_MATHERRL
03867          {
03868             WRITEL_YN_TLOSS;
03869             ERRNO_RANGE;
03870          }
03871        }
03872        else
03873        {
03874          NOT_MATHERRL {ERRNO_RANGE;}
03875        }
03876        *(long double *)retval = excl.retval;
03877        break;
03878     }
03879   case yn_gt_loss:
03880     /* yn > loss */
03881     {
03882        TLOSSD; NAMED = (char *) "yn";
03883        RETVAL_ZEROD;
03884        ifSVID
03885        {
03886          NOT_MATHERRD
03887          {
03888             WRITED_YN_TLOSS;
03889             ERRNO_RANGE;
03890          }
03891        }
03892        else
03893        {
03894          NOT_MATHERRD {ERRNO_RANGE;}
03895        }
03896        *(double*)retval = exc.retval;
03897        break;
03898     }
03899   case ynf_gt_loss:
03900     /* ynf > loss */
03901     {
03902        TLOSSF; NAMEF = (char *) "ynf";
03903        RETVAL_ZEROF;
03904        ifSVID
03905        {
03906          NOT_MATHERRF
03907          {
03908             WRITEF_YN_TLOSS;
03909             ERRNO_RANGE;
03910          }
03911        }
03912        else
03913        {
03914          NOT_MATHERRF {ERRNO_RANGE;}
03915        }
03916        *(float*)retval = excf.retval;
03917        break;
03918     }
03919   case ynl_zero:
03920     /* ynl(0) */
03921     {
03922        DOMAINL; NAMEL = (char *) "ynl";
03923        ifSVID
03924        {
03925          RETVAL_NEG_HUGEL;
03926          NOT_MATHERRL
03927          {
03928            WRITEL_YN_ZERO;
03929            ERRNO_DOMAIN;
03930          }
03931        }
03932        else
03933        {
03934          RETVAL_NEG_HUGE_VALL;
03935          NOT_MATHERRL {ERRNO_DOMAIN;}
03936        }
03937        *(long double *)retval = excl.retval;
03938        break;
03939     }
03940   case yn_zero:
03941     /* yn(0) */
03942     {
03943        DOMAIND; NAMED = (char *) "yn";
03944        ifSVID
03945        {
03946          RETVAL_NEG_HUGED;
03947          NOT_MATHERRD
03948          {
03949            WRITED_YN_ZERO;
03950            ERRNO_DOMAIN;
03951          }
03952        }
03953        else
03954        {
03955          RETVAL_NEG_HUGE_VALD;
03956          NOT_MATHERRD {ERRNO_DOMAIN;}
03957        }
03958        *(double *)retval = exc.retval;
03959        break;
03960     }
03961   case ynf_zero:
03962     /* ynf(0) */
03963     {
03964        DOMAINF; NAMEF = (char *) "ynf";
03965        ifSVID
03966        {
03967          RETVAL_NEG_HUGEF;
03968          NOT_MATHERRF
03969          {
03970            WRITEF_YN_ZERO;
03971            ERRNO_DOMAIN;
03972          }
03973        }
03974        else
03975        {
03976          RETVAL_NEG_HUGE_VALF;
03977          NOT_MATHERRF {ERRNO_DOMAIN;}
03978        }
03979        *(float *)retval = excf.retval;
03980        break;
03981     }
03982   case y0l_negative:
03983     /* y0l(x<0) */
03984     {
03985        DOMAINL; NAMEL = (char *) "y0l";
03986        ifSVID
03987        {
03988          RETVAL_NEG_HUGEL;
03989          NOT_MATHERRL
03990          {
03991            WRITEL_Y0_NEGATIVE;
03992            ERRNO_DOMAIN;
03993          }
03994        }
03995        else
03996        {
03997          RETVAL_NEG_HUGE_VALL;
03998          NOT_MATHERRL {ERRNO_DOMAIN;}
03999        }
04000        *(long double *)retval = excl.retval;
04001        break;
04002     }
04003   case y0_negative:
04004     /* y0(x<0) */
04005     {
04006        DOMAIND; NAMED = (char *) "y0";
04007        ifSVID
04008        {
04009          RETVAL_NEG_HUGED;
04010          NOT_MATHERRD
04011          {
04012            WRITED_Y0_NEGATIVE;
04013            ERRNO_DOMAIN;
04014          }
04015        }
04016        else
04017        {
04018          RETVAL_NEG_HUGE_VALD;
04019          NOT_MATHERRD {ERRNO_DOMAIN;}
04020        }
04021        *(double *)retval = exc.retval;
04022        break;
04023     }
04024   case y0f_negative:
04025     /* y0f(x<0) */
04026     {
04027        DOMAINF; NAMEF = (char *) "y0f";
04028        ifSVID
04029        {
04030          RETVAL_NEG_HUGEF;
04031          NOT_MATHERRF
04032          {
04033            WRITEF_Y0_NEGATIVE;
04034            ERRNO_DOMAIN;
04035          }
04036        }
04037        else
04038        {
04039          RETVAL_NEG_HUGE_VALF;
04040          NOT_MATHERRF {ERRNO_DOMAIN;}
04041        }
04042        *(float *)retval = excf.retval;
04043        break;
04044     }
04045   case y1l_negative:
04046     /* y1l(x<0) */
04047     {
04048        DOMAINL; NAMEL = (char *) "y1l";
04049        ifSVID
04050        {
04051          RETVAL_NEG_HUGEL;
04052          NOT_MATHERRL
04053          {
04054            WRITEL_Y1_NEGATIVE;
04055            ERRNO_DOMAIN;
04056          }
04057        }
04058        else
04059        {
04060          RETVAL_NEG_HUGE_VALL;
04061          NOT_MATHERRL {ERRNO_DOMAIN;}
04062        }
04063        *(long double *)retval = excl.retval;
04064        break;
04065     }
04066   case y1_negative:
04067     /* y1(x<0) */
04068     {
04069        DOMAIND; NAMED = (char *) "y1";
04070        ifSVID
04071        {
04072          RETVAL_NEG_HUGED;
04073          NOT_MATHERRD
04074          {
04075            WRITED_Y1_NEGATIVE;
04076            ERRNO_DOMAIN;
04077          }
04078        }
04079        else
04080        {
04081          RETVAL_NEG_HUGE_VALD;
04082          NOT_MATHERRD {ERRNO_DOMAIN;}
04083        }
04084        *(double *)retval = exc.retval;
04085        break;
04086     }
04087   case y1f_negative:
04088     /* y1f(x<0) */
04089     {
04090        DOMAINF; NAMEF = (char *) "y1f";
04091        ifSVID
04092        {
04093          RETVAL_NEG_HUGEF;
04094          NOT_MATHERRF
04095          {
04096            WRITEF_Y1_NEGATIVE;
04097            ERRNO_DOMAIN;
04098          }
04099        }
04100        else
04101        {
04102          RETVAL_NEG_HUGE_VALF;
04103          NOT_MATHERRF {ERRNO_DOMAIN;}
04104        }
04105        *(float *)retval = excf.retval;
04106        break;
04107     }
04108   case ynl_negative:
04109     /* ynl(x<0) */
04110     {
04111        DOMAINL; NAMEL = (char *) "ynl";
04112        ifSVID
04113        {
04114          RETVAL_NEG_HUGEL;
04115          NOT_MATHERRL
04116          {
04117           WRITEL_YN_NEGATIVE;
04118           ERRNO_DOMAIN;
04119          }
04120        }
04121        else
04122        {
04123          RETVAL_NEG_HUGE_VALL;
04124          NOT_MATHERRL {ERRNO_DOMAIN;}
04125        }
04126        *(long double *)retval = excl.retval;
04127        break;
04128     }
04129   case yn_negative:
04130     /* yn(x<0) */
04131     {
04132        DOMAIND; NAMED = (char *) "yn";
04133        ifSVID
04134        {
04135          RETVAL_NEG_HUGED;
04136          NOT_MATHERRD
04137          {
04138            WRITED_YN_NEGATIVE;
04139            ERRNO_DOMAIN;
04140          }
04141        }
04142        else
04143        {
04144          RETVAL_NEG_HUGE_VALD;
04145          NOT_MATHERRD {ERRNO_DOMAIN;}
04146        }
04147        *(double *)retval = exc.retval;
04148        break;
04149     }
04150   case ynf_negative:
04151     /* ynf(x<0) */
04152     {
04153        DOMAINF; NAMEF = (char *) "ynf";
04154        ifSVID
04155        {
04156          RETVAL_NEG_HUGEF;
04157          NOT_MATHERRF
04158          {
04159            WRITEF_YN_NEGATIVE;
04160            ERRNO_DOMAIN;
04161          }
04162        }
04163        else
04164        {
04165          RETVAL_NEG_HUGE_VALF;
04166          NOT_MATHERRF {ERRNO_DOMAIN;}
04167        }
04168        *(float *)retval = excf.retval;
04169        break;
04170     }
04171   case fmodl_by_zero:
04172     /* fmodl(x,0) */
04173     {
04174        DOMAINL; NAMEL = (char *) "fmodl";
04175        ifSVID
04176        {
04177             *(long double *)retval = *(long double *)arg1;
04178             NOT_MATHERRL
04179             {
04180               WRITEL_FMOD;
04181               ERRNO_DOMAIN;
04182             }
04183        }
04184        else
04185        { /* NaN already computed */
04186             NOT_MATHERRL {ERRNO_DOMAIN;}
04187        }
04188        *(long double *)retval = excl.retval;
04189        break;
04190     }
04191   case fmod_by_zero:
04192     /* fmod(x,0) */
04193     {
04194        DOMAIND; NAMED = (char *) "fmod";
04195        ifSVID
04196        {
04197          *(double *)retval = *(double *)arg1;
04198          NOT_MATHERRD
04199          {
04200            WRITED_FMOD;
04201            ERRNO_DOMAIN;
04202          }
04203        }
04204        else
04205        { /* NaN already computed */
04206          NOT_MATHERRD {ERRNO_DOMAIN;}
04207        }
04208        *(double *)retval = exc.retval;
04209        break;
04210     }
04211   case fmodf_by_zero:
04212     /* fmodf(x,0) */
04213     {
04214        DOMAINF; NAMEF = (char *) "fmodf";
04215        ifSVID
04216        {
04217          *(float *)retval = *(float *)arg1;
04218          NOT_MATHERRF
04219          {
04220            WRITEF_FMOD;
04221            ERRNO_DOMAIN;
04222          }
04223        }
04224        else
04225        {
04226          NOT_MATHERRF {ERRNO_DOMAIN;}
04227        }
04228        *(float *)retval = excf.retval;
04229        break;
04230     }
04231   case remainderl_by_zero:
04232     /* remainderl(x,0) */
04233     {
04234        DOMAINL; NAMEL = (char *) "remainderl";
04235        ifSVID
04236        {
04237           NOT_MATHERRL
04238           {
04239             WRITEL_REM;
04240             ERRNO_DOMAIN;
04241           }
04242        }
04243        else
04244        { /* NaN already computed */
04245             NOT_MATHERRL {ERRNO_DOMAIN;}
04246        }
04247        *(long double *)retval = excl.retval;
04248        break;
04249     }
04250   case remainder_by_zero:
04251     /* remainder(x,0) */
04252     {
04253        DOMAIND; NAMED = (char *) "remainder";
04254        ifSVID
04255        {
04256          NOT_MATHERRD
04257          {
04258            WRITED_REM;
04259            ERRNO_DOMAIN;
04260          }
04261        }
04262        else
04263        { /* NaN already computed */
04264          NOT_MATHERRD {ERRNO_DOMAIN;}
04265        }
04266        *(double *)retval = exc.retval;
04267        break;
04268     }
04269   case remainderf_by_zero:
04270     /* remainderf(x,0) */
04271     {
04272        DOMAINF; NAMEF = (char *) "remainderf";
04273        ifSVID
04274        {
04275          NOT_MATHERRF
04276          {
04277            WRITEF_REM;
04278            ERRNO_DOMAIN;
04279          }
04280        }
04281        else
04282        {
04283          NOT_MATHERRF {ERRNO_DOMAIN;}
04284        }
04285        *(float *)retval = excf.retval;
04286        break;
04287     }
04288   default:
04289     /* We don't want to abort () since SVID doesn't cover all math
04290        library functions.  */
04291     break;
04292    }
04293    return;
04294    }
04295 }