Back to index

glibc  2.9
Defines | Functions | Variables
libm_error.c File Reference
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include "libm_support.h"

Go to the source code of this file.

Defines

#define ALIGNIT   __declspec(align(16))
#define __INT_64__   __int64
#define STATIC   static
#define RETVAL_HUGE_VALL   *(long double *)retval = *(long double *)long_double_inf
#define RETVAL_NEG_HUGE_VALL   *(long double *)retval = *(long double *)long_double_neg_inf
#define RETVAL_HUGEL   *(long double *)retval = (long double)*(float *)float_huge
#define RETVAL_NEG_HUGEL   *(long double *)retval =(long double)*(float*)float_neg_huge
#define RETVAL_HUGE_VALD   *(double *)retval = *(double *) double_inf
#define RETVAL_NEG_HUGE_VALD   *(double *)retval = *(double *) double_neg_inf
#define RETVAL_HUGED   *(double *)retval = (double) *(float *)float_huge
#define RETVAL_NEG_HUGED   *(double *)retval = (double) *(float *) float_neg_huge
#define RETVAL_HUGE_VALF   *(float *)retval = *(float *) float_inf
#define RETVAL_NEG_HUGE_VALF   *(float *)retval = *(float *) float_neg_inf
#define RETVAL_HUGEF   *(float *)retval = *(float *) float_huge
#define RETVAL_NEG_HUGEF   *(float *)retval = *(float *) float_neg_huge
#define ZEROL_VALUE   *(long double *)long_double_zero
#define ZEROD_VALUE   *(double *)double_zero
#define ZEROF_VALUE   *(float *)float_zero
#define RETVAL_ZEROL   *(long double *)retval = *(long double *)long_double_zero
#define RETVAL_ZEROD   *(double *)retval = *(double *)double_zero
#define RETVAL_ZEROF   *(float *)retval = *(float *)float_zero
#define RETVAL_NEG_ZEROL   *(long double *)retval = *(long double *)long_double_neg_zero
#define RETVAL_NEG_ZEROD   *(double *)retval = *(double *)double_neg_zero
#define RETVAL_NEG_ZEROF   *(float *)retval = *(float *)float_neg_zero
#define RETVAL_ONEL   *(long double *)retval = (long double) 1.0
#define RETVAL_ONED   *(double *)retval = 1.0
#define RETVAL_ONEF   *(float *)retval = 1.0f
#define NOT_MATHERRL   excl.arg1=*(long double *)arg1;excl.arg2=*(long double *)arg2;excl.retval=*(long double *)retval;if(!pmatherrl(&excl))
#define NOT_MATHERRD   exc.arg1=*(double *)arg1;exc.arg2=*(double *)arg2;exc.retval=*(double *)retval;if(!pmatherr(&exc))
#define NOT_MATHERRF   excf.arg1=*(float *)arg1;excf.arg2=*(float *)arg2;excf.retval=*(float *)retval;if(!pmatherrf(&excf))
#define ifSVID   if(_LIB_VERSIONIMF==_SVID_)
#define NAMEL   excl.name
#define NAMED   exc.name
#define NAMEF   excf.name
#define DOMAIN   1
#define SING   2
#define OVERFLOW   3
#define UNDERFLOW   4
#define TLOSS   5
#define PLOSS   6
#define SINGL   excl.type = SING
#define DOMAINL   excl.type = DOMAIN
#define OVERFLOWL   excl.type = OVERFLOW
#define UNDERFLOWL   excl.type = UNDERFLOW
#define TLOSSL   excl.type = TLOSS
#define SINGD   exc.type = SING
#define DOMAIND   exc.type = DOMAIN
#define OVERFLOWD   exc.type = OVERFLOW
#define UNDERFLOWD   exc.type = UNDERFLOW
#define TLOSSD   exc.type = TLOSS
#define SINGF   excf.type = SING
#define DOMAINF   excf.type = DOMAIN
#define OVERFLOWF   excf.type = OVERFLOW
#define UNDERFLOWF   excf.type = UNDERFLOW
#define TLOSSF   excf.type = TLOSS
#define INPUT_XL   (excl.arg1=*(long double*)arg1)
#define INPUT_XD   (exc.arg1=*(double*)arg1)
#define INPUT_XF   (excf.arg1=*(float*)arg1)
#define INPUT_YL   (excl.arg2=*(long double*)arg2)
#define INPUT_YD   (exc.arg2=*(double*)arg2)
#define INPUT_YF   (excf.arg2=*(float*)arg2)
#define INPUT_RESL   (*(long double *)retval)
#define INPUT_RESD   (*(double *)retval)
#define INPUT_RESF   (*(float *)retval)
#define INPUT_RESI64   (*(__INT_64__ *)retval)
#define WRITEL_LOG_ZERO   fputs("logl: SING error\n",stderr)
#define WRITED_LOG_ZERO   fputs("log: SING error\n",stderr)
#define WRITEF_LOG_ZERO   fputs("logf: SING error\n",stderr)
#define WRITEL_LOG_NEGATIVE   fputs("logl: DOMAIN error\n",stderr)
#define WRITED_LOG_NEGATIVE   fputs("log: DOMAIN error\n",stderr)
#define WRITEF_LOG_NEGATIVE   fputs("logf: DOMAIN error\n",stderr)
#define WRITEL_Y0_ZERO   fputs("y0l: DOMAIN error\n",stderr)
#define WRITED_Y0_ZERO   fputs("y0: DOMAIN error\n",stderr)
#define WRITEF_Y0_ZERO   fputs("y0f: DOMAIN error\n",stderr)
#define WRITEL_Y0_NEGATIVE   fputs("y0l: DOMAIN error\n",stderr)
#define WRITED_Y0_NEGATIVE   fputs("y0: DOMAIN error\n",stderr)
#define WRITEF_Y0_NEGATIVE   fputs("y0f: DOMAIN error\n",stderr)
#define WRITEL_Y1_ZERO   fputs("y1l: DOMAIN error\n",stderr)
#define WRITED_Y1_ZERO   fputs("y1: DOMAIN error\n",stderr)
#define WRITEF_Y1_ZERO   fputs("y1f: DOMAIN error\n",stderr)
#define WRITEL_Y1_NEGATIVE   fputs("y1l: DOMAIN error\n",stderr)
#define WRITED_Y1_NEGATIVE   fputs("y1: DOMAIN error\n",stderr)
#define WRITEF_Y1_NEGATIVE   fputs("y1f: DOMAIN error\n",stderr)
#define WRITEL_YN_ZERO   fputs("ynl: DOMAIN error\n",stderr)
#define WRITED_YN_ZERO   fputs("yn: DOMAIN error\n",stderr)
#define WRITEF_YN_ZERO   fputs("ynf: DOMAIN error\n",stderr)
#define WRITEL_YN_NEGATIVE   fputs("ynl: DOMAIN error\n",stderr)
#define WRITED_YN_NEGATIVE   fputs("yn: DOMAIN error\n",stderr)
#define WRITEF_YN_NEGATIVE   fputs("ynf: DOMAIN error\n",stderr)
#define WRITEL_LOG1P_ZERO   fputs("log1pl: SING error\n",stderr)
#define WRITED_LOG1P_ZERO   fputs("log1p: SING error\n",stderr)
#define WRITEF_LOG1P_ZERO   fputs("log1pf: SING error\n",stderr)
#define WRITEL_LOG1P_NEGATIVE   fputs("log1pl: DOMAIN error\n",stderr)
#define WRITED_LOG1P_NEGATIVE   fputs("log1p: DOMAIN error\n",stderr)
#define WRITEF_LOG1P_NEGATIVE   fputs("log1pf: DOMAIN error\n",stderr)
#define WRITEL_LOG10_ZERO   fputs("log10l: SING error\n",stderr)
#define WRITED_LOG10_ZERO   fputs("log10: SING error\n",stderr)
#define WRITEF_LOG10_ZERO   fputs("log10f: SING error\n",stderr)
#define WRITEL_LOG10_NEGATIVE   fputs("log10l: DOMAIN error\n",stderr)
#define WRITED_LOG10_NEGATIVE   fputs("log10: DOMAIN error\n",stderr)
#define WRITEF_LOG10_NEGATIVE   fputs("log10f: DOMAIN error\n",stderr)
#define WRITEL_LOG2_ZERO   fputs("log2l: SING error\n",stderr)
#define WRITED_LOG2_ZERO   fputs("log2: SING error\n",stderr)
#define WRITEF_LOG2_ZERO   fputs("log2f: SING error\n",stderr)
#define WRITEL_LOG2_NEGATIVE   fputs("log2l: DOMAIN error\n",stderr)
#define WRITED_LOG2_NEGATIVE   fputs("log2: DOMAIN error\n",stderr)
#define WRITEF_LOG2_NEGATIVE   fputs("log2f: DOMAIN error\n",stderr)
#define WRITEL_POW_ZERO_TO_ZERO   fputs("powl(0,0): DOMAIN error\n",stderr)
#define WRITED_POW_ZERO_TO_ZERO   fputs("pow(0,0): DOMAIN error\n",stderr)
#define WRITEF_POW_ZERO_TO_ZERO   fputs("powf(0,0): DOMAIN error\n",stderr)
#define WRITEL_POW_ZERO_TO_NEGATIVE   fputs("powl(0,negative): DOMAIN error\n",stderr)
#define WRITED_POW_ZERO_TO_NEGATIVE   fputs("pow(0,negative): DOMAIN error\n",stderr)
#define WRITEF_POW_ZERO_TO_NEGATIVE   fputs("powf(0,negative): DOMAIN error\n",stderr)
#define WRITEL_POW_NEG_TO_NON_INTEGER   fputs("powl(negative,non-integer): DOMAIN error\n",stderr)
#define WRITED_POW_NEG_TO_NON_INTEGER   fputs("pow(negative,non-integer): DOMAIN error\n",stderr)
#define WRITEF_POW_NEG_TO_NON_INTEGER   fputs("powf(negative,non-integer): DOMAIN error\n",stderr)
#define WRITEL_ATAN2_ZERO_BY_ZERO   fputs("atan2l: DOMAIN error\n",stderr)
#define WRITED_ATAN2_ZERO_BY_ZERO   fputs("atan2: DOMAIN error\n",stderr)
#define WRITEF_ATAN2_ZERO_BY_ZERO   fputs("atan2f: DOMAIN error\n",stderr)
#define WRITEL_SQRT   fputs("sqrtl: DOMAIN error\n",stderr)
#define WRITED_SQRT   fputs("sqrt: DOMAIN error\n",stderr)
#define WRITEF_SQRT   fputs("sqrtf: DOMAIN error\n",stderr)
#define WRITEL_FMOD   fputs("fmodl: DOMAIN error\n",stderr)
#define WRITED_FMOD   fputs("fmod: DOMAIN error\n",stderr)
#define WRITEF_FMOD   fputs("fmodf: DOMAIN error\n",stderr)
#define WRITEL_REM   fputs("remainderl: DOMAIN error\n",stderr)
#define WRITED_REM   fputs("remainder: DOMAIN error\n",stderr)
#define WRITEF_REM   fputs("remainderf: DOMAIN error\n",stderr)
#define WRITEL_ACOS   fputs("acosl: DOMAIN error\n",stderr)
#define WRITED_ACOS   fputs("acos: DOMAIN error\n",stderr)
#define WRITEF_ACOS   fputs("acosf: DOMAIN error\n",stderr)
#define WRITEL_ASIN   fputs("asinl: DOMAIN error\n",stderr)
#define WRITED_ASIN   fputs("asin: DOMAIN error\n",stderr)
#define WRITEF_ASIN   fputs("asinf: DOMAIN error\n",stderr)
#define WRITEL_ACOSH   fputs("acoshl: DOMAIN error\n",stderr)
#define WRITED_ACOSH   fputs("acosh: DOMAIN error\n",stderr)
#define WRITEF_ACOSH   fputs("acoshf: DOMAIN error\n",stderr)
#define WRITEL_ATANH_GT_ONE   fputs("atanhl: DOMAIN error\n",stderr)
#define WRITED_ATANH_GT_ONE   fputs("atanh: DOMAIN error\n",stderr)
#define WRITEF_ATANH_GT_ONE   fputs("atanhf: DOMAIN error\n",stderr)
#define WRITEL_ATANH_EQ_ONE   fputs("atanhl: SING error\n",stderr)
#define WRITED_ATANH_EQ_ONE   fputs("atanh: SING error\n",stderr)
#define WRITEF_ATANH_EQ_ONE   fputs("atanhf: SING error\n",stderr)
#define WRITEL_LGAMMA_NEGATIVE   fputs("lgammal: SING error\n",stderr)
#define WRITED_LGAMMA_NEGATIVE   fputs("lgamma: SING error\n",stderr)
#define WRITEF_LGAMMA_NEGATIVE   fputs("lgammaf: SING error\n",stderr)
#define WRITEL_GAMMA_NEGATIVE   fputs("gammal: SING error\n",stderr)
#define WRITED_GAMMA_NEGATIVE   fputs("gamma: SING error\n",stderr)
#define WRITEF_GAMMA_NEGATIVE   fputs("gammaf: SING error\n",stderr)
#define WRITEL_TGAMMA_NEGATIVE   fputs("tgammal: SING error\n",stderr)
#define WRITED_TGAMMA_NEGATIVE   fputs("tgamma: SING error\n",stderr)
#define WRITEF_TGAMMA_NEGATIVE   fputs("tgammaf: SING error\n",stderr)
#define WRITEL_J0_TLOSS   fputs("j0l: TLOSS error\n",stderr)
#define WRITEL_Y0_TLOSS   fputs("y0l: TLOSS error\n",stderr)
#define WRITEL_J1_TLOSS   fputs("j1l: TLOSS error\n",stderr)
#define WRITEL_Y1_TLOSS   fputs("y1l: TLOSS error\n",stderr)
#define WRITEL_JN_TLOSS   fputs("jnl: TLOSS error\n",stderr)
#define WRITEL_YN_TLOSS   fputs("ynl: TLOSS error\n",stderr)
#define WRITED_J0_TLOSS   fputs("j0: TLOSS error\n",stderr)
#define WRITED_Y0_TLOSS   fputs("y0: TLOSS error\n",stderr)
#define WRITED_J1_TLOSS   fputs("j1: TLOSS error\n",stderr)
#define WRITED_Y1_TLOSS   fputs("y1: TLOSS error\n",stderr)
#define WRITED_JN_TLOSS   fputs("jn: TLOSS error\n",stderr)
#define WRITED_YN_TLOSS   fputs("yn: TLOSS error\n",stderr)
#define WRITEF_J0_TLOSS   fputs("j0f: TLOSS error\n",stderr)
#define WRITEF_Y0_TLOSS   fputs("y0f: TLOSS error\n",stderr)
#define WRITEF_J1_TLOSS   fputs("j1f: TLOSS error\n",stderr)
#define WRITEF_Y1_TLOSS   fputs("y1f: TLOSS error\n",stderr)
#define WRITEF_JN_TLOSS   fputs("jnf: TLOSS error\n",stderr)
#define WRITEF_YN_TLOSS   fputs("ynf: TLOSS error\n",stderr)
#define WRITEL_ACOSD   fputs("acosdl: DOMAIN error\n",stderr)
#define WRITED_ACOSD   fputs("acosd: DOMAIN error\n",stderr)
#define WRITEF_ACOSD   fputs("acosdf: DOMAIN error\n",stderr)
#define WRITEL_ASIND   fputs("asindl: DOMAIN error\n",stderr)
#define WRITED_ASIND   fputs("asind: DOMAIN error\n",stderr)
#define WRITEF_ASIND   fputs("asindf: DOMAIN error\n",stderr)
#define WRITEL_ATAN2D_ZERO_BY_ZERO   fputs("atan2dl: DOMAIN error\n",stderr)
#define WRITED_ATAN2D_ZERO_BY_ZERO   fputs("atan2d: DOMAIN error\n",stderr)
#define WRITEF_ATAN2D_ZERO_BY_ZERO   fputs("atan2df: DOMAIN error\n",stderr)

Functions

void __libm_setusermatherrf (int(*user_merrf)(struct exceptionf *))
void __libm_setusermatherr (int(*user_merr)(struct EXC_DECL_D *))
void __libm_setusermatherrl (int(*user_merrl)(struct exceptionl *))
void __libm_error_support (void *arg1, void *arg2, void *retval, error_types input_tag)

Variables

_LIB_VERSION_TYPE _LIB_VERSIONIMF = _ISOC_
int(* pmatherrf )(struct exceptionf *) = MATHERR_F
int(* pmatherr )(struct EXC_DECL_D *) = MATHERR_D
int(* pmatherrl )(struct exceptionl *) = matherrl

Define Documentation

#define __INT_64__   __int64
#define ALIGNIT   __declspec(align(16))
#define DOMAIN   1
#define DOMAIND   exc.type = DOMAIN
#define DOMAINF   excf.type = DOMAIN
#define DOMAINL   excl.type = DOMAIN
#define ifSVID   if(_LIB_VERSIONIMF==_SVID_)
#define INPUT_RESD   (*(double *)retval)
#define INPUT_RESF   (*(float *)retval)
#define INPUT_RESI64   (*(__INT_64__ *)retval)
#define INPUT_RESL   (*(long double *)retval)
#define INPUT_XD   (exc.arg1=*(double*)arg1)
#define INPUT_XF   (excf.arg1=*(float*)arg1)
#define INPUT_XL   (excl.arg1=*(long double*)arg1)
#define INPUT_YD   (exc.arg2=*(double*)arg2)
#define INPUT_YF   (excf.arg2=*(float*)arg2)
#define INPUT_YL   (excl.arg2=*(long double*)arg2)
#define NAMED   exc.name
#define NAMEF   excf.name
#define NAMEL   excl.name
#define NOT_MATHERRD   exc.arg1=*(double *)arg1;exc.arg2=*(double *)arg2;exc.retval=*(double *)retval;if(!pmatherr(&exc))
#define NOT_MATHERRF   excf.arg1=*(float *)arg1;excf.arg2=*(float *)arg2;excf.retval=*(float *)retval;if(!pmatherrf(&excf))
#define NOT_MATHERRL   excl.arg1=*(long double *)arg1;excl.arg2=*(long double *)arg2;excl.retval=*(long double *)retval;if(!pmatherrl(&excl))
#define OVERFLOW   3
#define OVERFLOWD   exc.type = OVERFLOW
#define OVERFLOWF   excf.type = OVERFLOW
#define OVERFLOWL   excl.type = OVERFLOW
#define PLOSS   6
#define RETVAL_HUGE_VALD   *(double *)retval = *(double *) double_inf
#define RETVAL_HUGE_VALF   *(float *)retval = *(float *) float_inf
#define RETVAL_HUGE_VALL   *(long double *)retval = *(long double *)long_double_inf
#define RETVAL_HUGED   *(double *)retval = (double) *(float *)float_huge
#define RETVAL_HUGEF   *(float *)retval = *(float *) float_huge
#define RETVAL_HUGEL   *(long double *)retval = (long double)*(float *)float_huge
#define RETVAL_NEG_HUGE_VALD   *(double *)retval = *(double *) double_neg_inf
#define RETVAL_NEG_HUGE_VALF   *(float *)retval = *(float *) float_neg_inf
#define RETVAL_NEG_HUGE_VALL   *(long double *)retval = *(long double *)long_double_neg_inf
#define RETVAL_NEG_HUGED   *(double *)retval = (double) *(float *) float_neg_huge
#define RETVAL_NEG_HUGEF   *(float *)retval = *(float *) float_neg_huge
#define RETVAL_NEG_HUGEL   *(long double *)retval =(long double)*(float*)float_neg_huge
#define RETVAL_NEG_ZEROD   *(double *)retval = *(double *)double_neg_zero
#define RETVAL_NEG_ZEROF   *(float *)retval = *(float *)float_neg_zero
#define RETVAL_NEG_ZEROL   *(long double *)retval = *(long double *)long_double_neg_zero
#define RETVAL_ONED   *(double *)retval = 1.0
#define RETVAL_ONEF   *(float *)retval = 1.0f
#define RETVAL_ONEL   *(long double *)retval = (long double) 1.0
#define RETVAL_ZEROD   *(double *)retval = *(double *)double_zero
#define RETVAL_ZEROF   *(float *)retval = *(float *)float_zero
#define RETVAL_ZEROL   *(long double *)retval = *(long double *)long_double_zero
#define SING   2
#define SINGD   exc.type = SING
#define SINGF   excf.type = SING
#define SINGL   excl.type = SING
#define STATIC   static
#define TLOSS   5
#define TLOSSD   exc.type = TLOSS
#define TLOSSF   excf.type = TLOSS
#define TLOSSL   excl.type = TLOSS
#define UNDERFLOW   4
#define UNDERFLOWD   exc.type = UNDERFLOW
#define UNDERFLOWF   excf.type = UNDERFLOW
#define UNDERFLOWL   excl.type = UNDERFLOW
#define WRITED_ACOS   fputs("acos: DOMAIN error\n",stderr)
#define WRITED_ACOSD   fputs("acosd: DOMAIN error\n",stderr)
#define WRITED_ACOSH   fputs("acosh: DOMAIN error\n",stderr)
#define WRITED_ASIN   fputs("asin: DOMAIN error\n",stderr)
#define WRITED_ASIND   fputs("asind: DOMAIN error\n",stderr)
#define WRITED_ATAN2_ZERO_BY_ZERO   fputs("atan2: DOMAIN error\n",stderr)
#define WRITED_ATAN2D_ZERO_BY_ZERO   fputs("atan2d: DOMAIN error\n",stderr)
#define WRITED_ATANH_EQ_ONE   fputs("atanh: SING error\n",stderr)
#define WRITED_ATANH_GT_ONE   fputs("atanh: DOMAIN error\n",stderr)
#define WRITED_FMOD   fputs("fmod: DOMAIN error\n",stderr)
#define WRITED_GAMMA_NEGATIVE   fputs("gamma: SING error\n",stderr)
#define WRITED_J0_TLOSS   fputs("j0: TLOSS error\n",stderr)
#define WRITED_J1_TLOSS   fputs("j1: TLOSS error\n",stderr)
#define WRITED_JN_TLOSS   fputs("jn: TLOSS error\n",stderr)
#define WRITED_LGAMMA_NEGATIVE   fputs("lgamma: SING error\n",stderr)
#define WRITED_LOG10_NEGATIVE   fputs("log10: DOMAIN error\n",stderr)
#define WRITED_LOG10_ZERO   fputs("log10: SING error\n",stderr)
#define WRITED_LOG1P_NEGATIVE   fputs("log1p: DOMAIN error\n",stderr)
#define WRITED_LOG1P_ZERO   fputs("log1p: SING error\n",stderr)
#define WRITED_LOG2_NEGATIVE   fputs("log2: DOMAIN error\n",stderr)
#define WRITED_LOG2_ZERO   fputs("log2: SING error\n",stderr)
#define WRITED_LOG_NEGATIVE   fputs("log: DOMAIN error\n",stderr)
#define WRITED_LOG_ZERO   fputs("log: SING error\n",stderr)
#define WRITED_POW_NEG_TO_NON_INTEGER   fputs("pow(negative,non-integer): DOMAIN error\n",stderr)
#define WRITED_POW_ZERO_TO_NEGATIVE   fputs("pow(0,negative): DOMAIN error\n",stderr)
#define WRITED_POW_ZERO_TO_ZERO   fputs("pow(0,0): DOMAIN error\n",stderr)
#define WRITED_REM   fputs("remainder: DOMAIN error\n",stderr)
#define WRITED_SQRT   fputs("sqrt: DOMAIN error\n",stderr)
#define WRITED_TGAMMA_NEGATIVE   fputs("tgamma: SING error\n",stderr)
#define WRITED_Y0_NEGATIVE   fputs("y0: DOMAIN error\n",stderr)
#define WRITED_Y0_TLOSS   fputs("y0: TLOSS error\n",stderr)
#define WRITED_Y0_ZERO   fputs("y0: DOMAIN error\n",stderr)
#define WRITED_Y1_NEGATIVE   fputs("y1: DOMAIN error\n",stderr)
#define WRITED_Y1_TLOSS   fputs("y1: TLOSS error\n",stderr)
#define WRITED_Y1_ZERO   fputs("y1: DOMAIN error\n",stderr)
#define WRITED_YN_NEGATIVE   fputs("yn: DOMAIN error\n",stderr)
#define WRITED_YN_TLOSS   fputs("yn: TLOSS error\n",stderr)
#define WRITED_YN_ZERO   fputs("yn: DOMAIN error\n",stderr)
#define WRITEF_ACOS   fputs("acosf: DOMAIN error\n",stderr)
#define WRITEF_ACOSD   fputs("acosdf: DOMAIN error\n",stderr)
#define WRITEF_ACOSH   fputs("acoshf: DOMAIN error\n",stderr)
#define WRITEF_ASIN   fputs("asinf: DOMAIN error\n",stderr)
#define WRITEF_ASIND   fputs("asindf: DOMAIN error\n",stderr)
#define WRITEF_ATAN2_ZERO_BY_ZERO   fputs("atan2f: DOMAIN error\n",stderr)
#define WRITEF_ATAN2D_ZERO_BY_ZERO   fputs("atan2df: DOMAIN error\n",stderr)
#define WRITEF_ATANH_EQ_ONE   fputs("atanhf: SING error\n",stderr)
#define WRITEF_ATANH_GT_ONE   fputs("atanhf: DOMAIN error\n",stderr)
#define WRITEF_FMOD   fputs("fmodf: DOMAIN error\n",stderr)
#define WRITEF_GAMMA_NEGATIVE   fputs("gammaf: SING error\n",stderr)
#define WRITEF_J0_TLOSS   fputs("j0f: TLOSS error\n",stderr)
#define WRITEF_J1_TLOSS   fputs("j1f: TLOSS error\n",stderr)
#define WRITEF_JN_TLOSS   fputs("jnf: TLOSS error\n",stderr)
#define WRITEF_LGAMMA_NEGATIVE   fputs("lgammaf: SING error\n",stderr)
#define WRITEF_LOG10_NEGATIVE   fputs("log10f: DOMAIN error\n",stderr)
#define WRITEF_LOG10_ZERO   fputs("log10f: SING error\n",stderr)
#define WRITEF_LOG1P_NEGATIVE   fputs("log1pf: DOMAIN error\n",stderr)
#define WRITEF_LOG1P_ZERO   fputs("log1pf: SING error\n",stderr)
#define WRITEF_LOG2_NEGATIVE   fputs("log2f: DOMAIN error\n",stderr)
#define WRITEF_LOG2_ZERO   fputs("log2f: SING error\n",stderr)
#define WRITEF_LOG_NEGATIVE   fputs("logf: DOMAIN error\n",stderr)
#define WRITEF_LOG_ZERO   fputs("logf: SING error\n",stderr)
#define WRITEF_POW_NEG_TO_NON_INTEGER   fputs("powf(negative,non-integer): DOMAIN error\n",stderr)
#define WRITEF_POW_ZERO_TO_NEGATIVE   fputs("powf(0,negative): DOMAIN error\n",stderr)
#define WRITEF_POW_ZERO_TO_ZERO   fputs("powf(0,0): DOMAIN error\n",stderr)
#define WRITEF_REM   fputs("remainderf: DOMAIN error\n",stderr)
#define WRITEF_SQRT   fputs("sqrtf: DOMAIN error\n",stderr)
#define WRITEF_TGAMMA_NEGATIVE   fputs("tgammaf: SING error\n",stderr)
#define WRITEF_Y0_NEGATIVE   fputs("y0f: DOMAIN error\n",stderr)
#define WRITEF_Y0_TLOSS   fputs("y0f: TLOSS error\n",stderr)
#define WRITEF_Y0_ZERO   fputs("y0f: DOMAIN error\n",stderr)
#define WRITEF_Y1_NEGATIVE   fputs("y1f: DOMAIN error\n",stderr)
#define WRITEF_Y1_TLOSS   fputs("y1f: TLOSS error\n",stderr)
#define WRITEF_Y1_ZERO   fputs("y1f: DOMAIN error\n",stderr)
#define WRITEF_YN_NEGATIVE   fputs("ynf: DOMAIN error\n",stderr)
#define WRITEF_YN_TLOSS   fputs("ynf: TLOSS error\n",stderr)
#define WRITEF_YN_ZERO   fputs("ynf: DOMAIN error\n",stderr)
#define WRITEL_ACOS   fputs("acosl: DOMAIN error\n",stderr)
#define WRITEL_ACOSD   fputs("acosdl: DOMAIN error\n",stderr)
#define WRITEL_ACOSH   fputs("acoshl: DOMAIN error\n",stderr)
#define WRITEL_ASIN   fputs("asinl: DOMAIN error\n",stderr)
#define WRITEL_ASIND   fputs("asindl: DOMAIN error\n",stderr)
#define WRITEL_ATAN2_ZERO_BY_ZERO   fputs("atan2l: DOMAIN error\n",stderr)
#define WRITEL_ATAN2D_ZERO_BY_ZERO   fputs("atan2dl: DOMAIN error\n",stderr)
#define WRITEL_ATANH_EQ_ONE   fputs("atanhl: SING error\n",stderr)
#define WRITEL_ATANH_GT_ONE   fputs("atanhl: DOMAIN error\n",stderr)
#define WRITEL_FMOD   fputs("fmodl: DOMAIN error\n",stderr)
#define WRITEL_GAMMA_NEGATIVE   fputs("gammal: SING error\n",stderr)
#define WRITEL_J0_TLOSS   fputs("j0l: TLOSS error\n",stderr)
#define WRITEL_J1_TLOSS   fputs("j1l: TLOSS error\n",stderr)
#define WRITEL_JN_TLOSS   fputs("jnl: TLOSS error\n",stderr)
#define WRITEL_LGAMMA_NEGATIVE   fputs("lgammal: SING error\n",stderr)
#define WRITEL_LOG10_NEGATIVE   fputs("log10l: DOMAIN error\n",stderr)
#define WRITEL_LOG10_ZERO   fputs("log10l: SING error\n",stderr)
#define WRITEL_LOG1P_NEGATIVE   fputs("log1pl: DOMAIN error\n",stderr)
#define WRITEL_LOG1P_ZERO   fputs("log1pl: SING error\n",stderr)
#define WRITEL_LOG2_NEGATIVE   fputs("log2l: DOMAIN error\n",stderr)
#define WRITEL_LOG2_ZERO   fputs("log2l: SING error\n",stderr)
#define WRITEL_LOG_NEGATIVE   fputs("logl: DOMAIN error\n",stderr)
#define WRITEL_LOG_ZERO   fputs("logl: SING error\n",stderr)
#define WRITEL_POW_NEG_TO_NON_INTEGER   fputs("powl(negative,non-integer): DOMAIN error\n",stderr)
#define WRITEL_POW_ZERO_TO_NEGATIVE   fputs("powl(0,negative): DOMAIN error\n",stderr)
#define WRITEL_POW_ZERO_TO_ZERO   fputs("powl(0,0): DOMAIN error\n",stderr)
#define WRITEL_REM   fputs("remainderl: DOMAIN error\n",stderr)
#define WRITEL_SQRT   fputs("sqrtl: DOMAIN error\n",stderr)
#define WRITEL_TGAMMA_NEGATIVE   fputs("tgammal: SING error\n",stderr)
#define WRITEL_Y0_NEGATIVE   fputs("y0l: DOMAIN error\n",stderr)
#define WRITEL_Y0_TLOSS   fputs("y0l: TLOSS error\n",stderr)
#define WRITEL_Y0_ZERO   fputs("y0l: DOMAIN error\n",stderr)
#define WRITEL_Y1_NEGATIVE   fputs("y1l: DOMAIN error\n",stderr)
#define WRITEL_Y1_TLOSS   fputs("y1l: TLOSS error\n",stderr)
#define WRITEL_Y1_ZERO   fputs("y1l: DOMAIN error\n",stderr)
#define WRITEL_YN_NEGATIVE   fputs("ynl: DOMAIN error\n",stderr)
#define WRITEL_YN_TLOSS   fputs("ynl: TLOSS error\n",stderr)
#define WRITEL_YN_ZERO   fputs("ynl: DOMAIN error\n",stderr)
#define ZEROD_VALUE   *(double *)double_zero
#define ZEROF_VALUE   *(float *)float_zero
#define ZEROL_VALUE   *(long double *)long_double_zero

Function Documentation

void __libm_error_support ( void *  arg1,
void *  arg2,
void *  retval,
error_types  input_tag 
)

Definition at line 134 of file libm_error.c.

{

# ifdef __cplusplus
struct __exception exc;
# else
struct exception  exc;
# endif

struct exceptionf excf;
struct exceptionl excl;

# ifdef __GNUC__
#define ALIGNIT __attribute__ ((__aligned__ (16)))
# elif defined opensource
#define ALIGNIT
# else
#define ALIGNIT __declspec(align(16))
# endif

# ifdef SIZE_LONG_INT_64
#define __INT_64__ signed long
# else
# if ILP32
#define __INT_64__ signed long long
# else
#define __INT_64__ __int64
# endif
# endif


#define STATIC static

ALIGNIT
STATIC const char float_inf[4] = {0x00,0x00,0x80,0x7F};
ALIGNIT
STATIC const char float_huge[4] = {0xFF,0xFF,0x7F,0x7F};
ALIGNIT
STATIC const char float_zero[4] = {0x00,0x00,0x00,0x00};
ALIGNIT
STATIC const char float_neg_inf[4] = {0x00,0x00,0x80,0xFF};
ALIGNIT
STATIC const char float_neg_huge[4] = {0xFF,0xFF,0x7F,0xFF};
ALIGNIT
STATIC const char float_neg_zero[4] = {0x00,0x00,0x00,0x80};
ALIGNIT
STATIC const char double_inf[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0x7F};
#ifndef _LIBC
ALIGNIT
STATIC const char double_huge[8] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xEF,0x7F};
#endif
ALIGNIT
STATIC const char double_zero[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
ALIGNIT
STATIC const char double_neg_inf[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0xFF};
#ifndef _LIBC
ALIGNIT
STATIC const char double_neg_huge[8] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xEF,0xFF};
#endif
ALIGNIT
STATIC const char double_neg_zero[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80};
ALIGNIT
STATIC const char long_double_inf[16] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0xFF,0x7F,0x00,0x00,0x00,0x00,0x00,0x00};
ALIGNIT
#ifndef _LIBC
STATIC const char long_double_huge[16] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0x7F,0x00,0x00,0x00,0x00,0x00,0x00};
#endif
ALIGNIT
STATIC const char long_double_zero[16] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
ALIGNIT
STATIC const char long_double_neg_inf[16] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0xFF,0xFF,0x00,0x00,0x00,0x00,0x00,0x00};
ALIGNIT
#ifndef _LIBC
STATIC const char long_double_neg_huge[16] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0xFF,0x00,0x00,0x00,0x00,0x00,0x00};
#endif
ALIGNIT
STATIC const char long_double_neg_zero[16] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x00,0x00,0x00};


#define RETVAL_HUGE_VALL *(long double *)retval =  *(long double *)long_double_inf
#define RETVAL_NEG_HUGE_VALL *(long double *)retval = *(long double *)long_double_neg_inf
#define RETVAL_HUGEL *(long double *)retval = (long double)*(float *)float_huge
#define RETVAL_NEG_HUGEL *(long double *)retval =(long double)*(float*)float_neg_huge

#define RETVAL_HUGE_VALD *(double *)retval = *(double *) double_inf
#define RETVAL_NEG_HUGE_VALD *(double *)retval = *(double *) double_neg_inf
#define RETVAL_HUGED *(double *)retval = (double) *(float *)float_huge
#define RETVAL_NEG_HUGED *(double *)retval = (double) *(float *) float_neg_huge

#define RETVAL_HUGE_VALF *(float *)retval =  *(float *) float_inf
#define RETVAL_NEG_HUGE_VALF *(float *)retval = *(float *) float_neg_inf
#define RETVAL_HUGEF *(float *)retval = *(float *) float_huge
#define RETVAL_NEG_HUGEF *(float *)retval = *(float *) float_neg_huge

#define ZEROL_VALUE *(long double *)long_double_zero
#define ZEROD_VALUE *(double *)double_zero
#define ZEROF_VALUE *(float *)float_zero

#define RETVAL_ZEROL *(long double *)retval = *(long double *)long_double_zero
#define RETVAL_ZEROD *(double *)retval = *(double *)double_zero
#define RETVAL_ZEROF *(float *)retval = *(float *)float_zero

#define RETVAL_NEG_ZEROL *(long double *)retval = *(long double *)long_double_neg_zero
#define RETVAL_NEG_ZEROD *(double *)retval = *(double *)double_neg_zero
#define RETVAL_NEG_ZEROF *(float *)retval = *(float *)float_neg_zero

#define RETVAL_ONEL *(long double *)retval = (long double) 1.0
#define RETVAL_ONED *(double *)retval = 1.0
#define RETVAL_ONEF *(float *)retval = 1.0f

#define NOT_MATHERRL excl.arg1=*(long double *)arg1;excl.arg2=*(long double *)arg2;excl.retval=*(long double *)retval;if(!pmatherrl(&excl))
#define NOT_MATHERRD exc.arg1=*(double *)arg1;exc.arg2=*(double *)arg2;exc.retval=*(double *)retval;if(!pmatherr(&exc))
#define NOT_MATHERRF excf.arg1=*(float *)arg1;excf.arg2=*(float *)arg2;excf.retval=*(float *)retval;if(!pmatherrf(&excf))

#define ifSVID if(_LIB_VERSIONIMF==_SVID_)

#define NAMEL excl.name
#define NAMED exc.name
#define NAMEF excf.name

//
// These should work OK for MS because they are ints -
// leading underbars are not necessary.
//

#define DOMAIN          1
#define SING            2
#define OVERFLOW        3
#define UNDERFLOW       4
#define TLOSS           5
#define PLOSS           6

#define SINGL excl.type = SING
#define DOMAINL excl.type = DOMAIN
#define OVERFLOWL excl.type = OVERFLOW
#define UNDERFLOWL excl.type = UNDERFLOW
#define TLOSSL excl.type = TLOSS
#define SINGD exc.type = SING
#define DOMAIND exc.type = DOMAIN
#define OVERFLOWD exc.type = OVERFLOW
#define UNDERFLOWD exc.type = UNDERFLOW
#define TLOSSD exc.type = TLOSS
#define SINGF excf.type = SING
#define DOMAINF excf.type = DOMAIN
#define OVERFLOWF excf.type = OVERFLOW
#define UNDERFLOWF excf.type = UNDERFLOW
#define TLOSSF excf.type = TLOSS

#define INPUT_XL (excl.arg1=*(long double*)arg1)
#define INPUT_XD (exc.arg1=*(double*)arg1)
#define INPUT_XF (excf.arg1=*(float*)arg1)
#define INPUT_YL (excl.arg2=*(long double*)arg2)
#define INPUT_YD (exc.arg2=*(double*)arg2)
#define INPUT_YF (excf.arg2=*(float*)arg2)
#define INPUT_RESL (*(long double *)retval)
#define INPUT_RESD (*(double *)retval)
#define INPUT_RESF (*(float *)retval)
#define INPUT_RESI64 (*(__INT_64__ *)retval)

#define WRITEL_LOG_ZERO fputs("logl: SING error\n",stderr)
#define WRITED_LOG_ZERO fputs("log: SING error\n",stderr)
#define WRITEF_LOG_ZERO fputs("logf: SING error\n",stderr)
#define WRITEL_LOG_NEGATIVE fputs("logl: DOMAIN error\n",stderr)
#define WRITED_LOG_NEGATIVE fputs("log: DOMAIN error\n",stderr)
#define WRITEF_LOG_NEGATIVE fputs("logf: DOMAIN error\n",stderr)
#define WRITEL_Y0_ZERO fputs("y0l: DOMAIN error\n",stderr)
#define WRITED_Y0_ZERO fputs("y0: DOMAIN error\n",stderr)
#define WRITEF_Y0_ZERO fputs("y0f: DOMAIN error\n",stderr)
#define WRITEL_Y0_NEGATIVE fputs("y0l: DOMAIN error\n",stderr)
#define WRITED_Y0_NEGATIVE fputs("y0: DOMAIN error\n",stderr)
#define WRITEF_Y0_NEGATIVE fputs("y0f: DOMAIN error\n",stderr)
#define WRITEL_Y1_ZERO fputs("y1l: DOMAIN error\n",stderr)
#define WRITED_Y1_ZERO fputs("y1: DOMAIN error\n",stderr)
#define WRITEF_Y1_ZERO fputs("y1f: DOMAIN error\n",stderr)
#define WRITEL_Y1_NEGATIVE fputs("y1l: DOMAIN error\n",stderr)
#define WRITED_Y1_NEGATIVE fputs("y1: DOMAIN error\n",stderr)
#define WRITEF_Y1_NEGATIVE fputs("y1f: DOMAIN error\n",stderr)
#define WRITEL_YN_ZERO fputs("ynl: DOMAIN error\n",stderr)
#define WRITED_YN_ZERO fputs("yn: DOMAIN error\n",stderr)
#define WRITEF_YN_ZERO fputs("ynf: DOMAIN error\n",stderr)
#define WRITEL_YN_NEGATIVE fputs("ynl: DOMAIN error\n",stderr)
#define WRITED_YN_NEGATIVE fputs("yn: DOMAIN error\n",stderr)
#define WRITEF_YN_NEGATIVE fputs("ynf: DOMAIN error\n",stderr)
#define WRITEL_LOG1P_ZERO fputs("log1pl: SING error\n",stderr)
#define WRITED_LOG1P_ZERO fputs("log1p: SING error\n",stderr)
#define WRITEF_LOG1P_ZERO fputs("log1pf: SING error\n",stderr)
#define WRITEL_LOG1P_NEGATIVE fputs("log1pl: DOMAIN error\n",stderr)
#define WRITED_LOG1P_NEGATIVE fputs("log1p: DOMAIN error\n",stderr)
#define WRITEF_LOG1P_NEGATIVE fputs("log1pf: DOMAIN error\n",stderr)
#define WRITEL_LOG10_ZERO fputs("log10l: SING error\n",stderr)
#define WRITED_LOG10_ZERO fputs("log10: SING error\n",stderr)
#define WRITEF_LOG10_ZERO fputs("log10f: SING error\n",stderr)
#define WRITEL_LOG10_NEGATIVE fputs("log10l: DOMAIN error\n",stderr)
#define WRITED_LOG10_NEGATIVE fputs("log10: DOMAIN error\n",stderr)
#define WRITEF_LOG10_NEGATIVE fputs("log10f: DOMAIN error\n",stderr)
#define WRITEL_LOG2_ZERO fputs("log2l: SING error\n",stderr)
#define WRITED_LOG2_ZERO fputs("log2: SING error\n",stderr)
#define WRITEF_LOG2_ZERO fputs("log2f: SING error\n",stderr)
#define WRITEL_LOG2_NEGATIVE fputs("log2l: DOMAIN error\n",stderr)
#define WRITED_LOG2_NEGATIVE fputs("log2: DOMAIN error\n",stderr)
#define WRITEF_LOG2_NEGATIVE fputs("log2f: DOMAIN error\n",stderr)
#define WRITEL_POW_ZERO_TO_ZERO fputs("powl(0,0): DOMAIN error\n",stderr)
#define WRITED_POW_ZERO_TO_ZERO fputs("pow(0,0): DOMAIN error\n",stderr)
#define WRITEF_POW_ZERO_TO_ZERO fputs("powf(0,0): DOMAIN error\n",stderr)
#define WRITEL_POW_ZERO_TO_NEGATIVE fputs("powl(0,negative): DOMAIN error\n",stderr)
#define WRITED_POW_ZERO_TO_NEGATIVE fputs("pow(0,negative): DOMAIN error\n",stderr)
#define WRITEF_POW_ZERO_TO_NEGATIVE fputs("powf(0,negative): DOMAIN error\n",stderr)
#define WRITEL_POW_NEG_TO_NON_INTEGER fputs("powl(negative,non-integer): DOMAIN error\n",stderr)
#define WRITED_POW_NEG_TO_NON_INTEGER fputs("pow(negative,non-integer): DOMAIN error\n",stderr)
#define WRITEF_POW_NEG_TO_NON_INTEGER fputs("powf(negative,non-integer): DOMAIN error\n",stderr)
#define WRITEL_ATAN2_ZERO_BY_ZERO fputs("atan2l: DOMAIN error\n",stderr)
#define WRITED_ATAN2_ZERO_BY_ZERO fputs("atan2: DOMAIN error\n",stderr)
#define WRITEF_ATAN2_ZERO_BY_ZERO fputs("atan2f: DOMAIN error\n",stderr)
#define WRITEL_SQRT fputs("sqrtl: DOMAIN error\n",stderr)
#define WRITED_SQRT fputs("sqrt: DOMAIN error\n",stderr)
#define WRITEF_SQRT fputs("sqrtf: DOMAIN error\n",stderr)
#define WRITEL_FMOD fputs("fmodl: DOMAIN error\n",stderr)
#define WRITED_FMOD fputs("fmod: DOMAIN error\n",stderr)
#define WRITEF_FMOD fputs("fmodf: DOMAIN error\n",stderr)
#define WRITEL_REM fputs("remainderl: DOMAIN error\n",stderr)
#define WRITED_REM fputs("remainder: DOMAIN error\n",stderr)
#define WRITEF_REM fputs("remainderf: DOMAIN error\n",stderr)
#define WRITEL_ACOS fputs("acosl: DOMAIN error\n",stderr)
#define WRITED_ACOS fputs("acos: DOMAIN error\n",stderr)
#define WRITEF_ACOS fputs("acosf: DOMAIN error\n",stderr)
#define WRITEL_ASIN fputs("asinl: DOMAIN error\n",stderr)
#define WRITED_ASIN fputs("asin: DOMAIN error\n",stderr)
#define WRITEF_ASIN fputs("asinf: DOMAIN error\n",stderr)
#define WRITEL_ACOSH fputs("acoshl: DOMAIN error\n",stderr)
#define WRITED_ACOSH fputs("acosh: DOMAIN error\n",stderr)
#define WRITEF_ACOSH fputs("acoshf: DOMAIN error\n",stderr)
#define WRITEL_ATANH_GT_ONE fputs("atanhl: DOMAIN error\n",stderr)
#define WRITED_ATANH_GT_ONE fputs("atanh: DOMAIN error\n",stderr)
#define WRITEF_ATANH_GT_ONE fputs("atanhf: DOMAIN error\n",stderr)
#define WRITEL_ATANH_EQ_ONE fputs("atanhl: SING error\n",stderr)
#define WRITED_ATANH_EQ_ONE fputs("atanh: SING error\n",stderr)
#define WRITEF_ATANH_EQ_ONE fputs("atanhf: SING error\n",stderr)
#define WRITEL_LGAMMA_NEGATIVE fputs("lgammal: SING error\n",stderr)
#define WRITED_LGAMMA_NEGATIVE fputs("lgamma: SING error\n",stderr)
#define WRITEF_LGAMMA_NEGATIVE fputs("lgammaf: SING error\n",stderr)
#define WRITEL_GAMMA_NEGATIVE fputs("gammal: SING error\n",stderr)
#define WRITED_GAMMA_NEGATIVE fputs("gamma: SING error\n",stderr)
#define WRITEF_GAMMA_NEGATIVE fputs("gammaf: SING error\n",stderr)
#define WRITEL_TGAMMA_NEGATIVE fputs("tgammal: SING error\n",stderr)
#define WRITED_TGAMMA_NEGATIVE fputs("tgamma: SING error\n",stderr)
#define WRITEF_TGAMMA_NEGATIVE fputs("tgammaf: SING error\n",stderr)
#define WRITEL_J0_TLOSS  fputs("j0l: TLOSS error\n",stderr)
#define WRITEL_Y0_TLOSS  fputs("y0l: TLOSS error\n",stderr)
#define WRITEL_J1_TLOSS  fputs("j1l: TLOSS error\n",stderr)
#define WRITEL_Y1_TLOSS  fputs("y1l: TLOSS error\n",stderr)
#define WRITEL_JN_TLOSS  fputs("jnl: TLOSS error\n",stderr)
#define WRITEL_YN_TLOSS  fputs("ynl: TLOSS error\n",stderr)
#define WRITED_J0_TLOSS  fputs("j0: TLOSS error\n",stderr)
#define WRITED_Y0_TLOSS  fputs("y0: TLOSS error\n",stderr)
#define WRITED_J1_TLOSS  fputs("j1: TLOSS error\n",stderr)
#define WRITED_Y1_TLOSS  fputs("y1: TLOSS error\n",stderr)
#define WRITED_JN_TLOSS  fputs("jn: TLOSS error\n",stderr)
#define WRITED_YN_TLOSS  fputs("yn: TLOSS error\n",stderr)
#define WRITEF_J0_TLOSS  fputs("j0f: TLOSS error\n",stderr)
#define WRITEF_Y0_TLOSS  fputs("y0f: TLOSS error\n",stderr)
#define WRITEF_J1_TLOSS  fputs("j1f: TLOSS error\n",stderr)
#define WRITEF_Y1_TLOSS  fputs("y1f: TLOSS error\n",stderr)
#define WRITEF_JN_TLOSS  fputs("jnf: TLOSS error\n",stderr)
#define WRITEF_YN_TLOSS  fputs("ynf: TLOSS error\n",stderr)
#define WRITEL_ACOSD fputs("acosdl: DOMAIN error\n",stderr)
#define WRITED_ACOSD fputs("acosd: DOMAIN error\n",stderr)
#define WRITEF_ACOSD fputs("acosdf: DOMAIN error\n",stderr)
#define WRITEL_ASIND fputs("asindl: DOMAIN error\n",stderr)
#define WRITED_ASIND fputs("asind: DOMAIN error\n",stderr)
#define WRITEF_ASIND fputs("asindf: DOMAIN error\n",stderr)
#define WRITEL_ATAN2D_ZERO_BY_ZERO fputs("atan2dl: DOMAIN error\n",stderr)
#define WRITED_ATAN2D_ZERO_BY_ZERO fputs("atan2d: DOMAIN error\n",stderr)
#define WRITEF_ATAN2D_ZERO_BY_ZERO fputs("atan2df: DOMAIN error\n",stderr)


/***********************/
/* IEEE Path           */
/***********************/
if(_LIB_VERSIONIMF==_IEEE_) return;

/***********************/
/* C9X Path           */
/***********************/
else if(_LIB_VERSIONIMF==_ISOC_)
{
  switch(input_tag)
  {
    case logl_zero:
    case log_zero:
    case logf_zero:
    case log10l_zero:
    case log10_zero:
    case log10f_zero:
    case log2l_zero:
    case log2_zero:
    case log2f_zero:
    case log1pl_zero:
    case log1p_zero:
    case log1pf_zero:
    case powl_overflow:
    case pow_overflow:
    case powf_overflow:
    case expl_overflow:
    case exp_overflow:
    case expf_overflow:
    case exp2l_overflow:
    case exp2_overflow:
    case exp2f_overflow:
    case exp10l_overflow:
    case exp10_overflow:
    case exp10f_overflow:
    case expm1l_overflow:
    case expm1_overflow:
    case expm1f_overflow:
    case hypotl_overflow:
    case hypot_overflow:
    case hypotf_overflow:
    case sinhl_overflow:
    case sinh_overflow:
    case sinhf_overflow:
    case atanhl_eq_one:
    case atanh_eq_one:
    case atanhf_eq_one:
    case scalbl_overflow:
    case scalb_overflow:
    case scalbf_overflow:
    case coshl_overflow:
    case cosh_overflow:
    case coshf_overflow:
    case nextafterl_overflow:
    case nextafter_overflow:
    case nextafterf_overflow:
    case nextafterl_underflow:
    case nextafter_underflow:
    case nextafterf_underflow:
    case nexttowardl_overflow:
    case nexttoward_overflow:
    case nexttowardf_overflow:
    case nexttowardl_underflow:
    case nexttoward_underflow:
    case nexttowardf_underflow:
    case scalbnl_overflow:
    case scalbn_overflow:
    case scalbnf_overflow:
    case scalblnl_overflow:
    case scalbln_overflow:
    case scalblnf_overflow:
    case ldexpl_overflow:
    case ldexp_overflow:
    case ldexpf_overflow:
    case lgammal_overflow:
    case lgamma_overflow:
    case lgammaf_overflow:
    case gammal_overflow:
    case gamma_overflow:
    case gammaf_overflow:
    case lgammal_negative:
    case lgamma_negative:
    case lgammaf_negative:
    case gammal_negative:
    case gamma_negative:
    case gammaf_negative:
    case ilogbl_zero:
    case ilogb_zero:
    case ilogbf_zero:
    case fdiml_overflow:
    case fdim_overflow:
    case fdimf_overflow:
    case llrintl_large:
    case llrint_large:
    case llrintf_large:
    case llroundl_large:
    case llround_large:
    case llroundf_large:
    case lrintl_large:
    case lrint_large:
    case lrintf_large:
    case lroundl_large:
    case lround_large:
    case lroundf_large:
    case tandl_overflow:
    case tand_overflow:
    case tandf_overflow:
    case cotdl_overflow:
    case cotd_overflow:
    case cotdf_overflow:
    case cotl_overflow:
    case cot_overflow:
    case cotf_overflow:
    case sinhcoshl_overflow:
    case sinhcosh_overflow:
    case sinhcoshf_overflow:
    case annuityl_overflow:
    case annuity_overflow:
    case annuityf_overflow:
    case compoundl_overflow:
    case compound_overflow:
    case compoundf_overflow:
    case tgammal_overflow:
    case tgamma_overflow:
    case tgammaf_overflow:
    {
         ERRNO_RANGE; break;
    }
    case powl_underflow:
    case expl_underflow:
    case exp10l_underflow:
    case exp2l_underflow:
    case scalbl_underflow:
    case scalbnl_underflow:
    case scalblnl_underflow:
    case ldexpl_underflow:
    case erfcl_underflow:
    case annuityl_underflow:
    case compoundl_underflow:
    {
       /* Test for zero by testing 64 significand bits for zero. An integer
          test is needed so denormal flag is not set by a floating-point test */
       if ( INPUT_RESI64 == 0 ) ERRNO_RANGE;
       break;
    }
    case pow_underflow:
    case exp_underflow:
    case exp10_underflow:
    case exp2_underflow:
    case scalb_underflow:
    case scalbn_underflow:
    case scalbln_underflow:
    case ldexp_underflow:
    case erfc_underflow:
    case annuity_underflow:
    case compound_underflow:
    {
       /* Test for zero by testing exp and significand bits for zero. An integer
          test is needed so denormal flag is not set by a floating-point test */
       if ( (INPUT_RESI64 << 1) == 0 ) ERRNO_RANGE;
       break;
    }
    case powf_underflow:
    case expf_underflow:
    case exp10f_underflow:
    case exp2f_underflow:
    case scalbf_underflow:
    case scalbnf_underflow:
    case scalblnf_underflow:
    case ldexpf_underflow:
    case erfcf_underflow:
    case annuityf_underflow:
    case compoundf_underflow:
    {
       /* Test for zero by testing exp and significand bits for zero. An integer
          test is needed so denormal flag is not set by a floating-point test */
       if ( (INPUT_RESI64 << 33) == 0 ) ERRNO_RANGE;
       break;
    }
    case logl_negative:
    case log_negative:
    case logf_negative:
    case log10l_negative:
    case log10_negative:
    case log10f_negative:
    case log2l_negative:
    case log2_negative:
    case log2f_negative:
    case log1pl_negative:
    case log1p_negative:
    case log1pf_negative:
    case sqrtl_negative:
    case sqrt_negative:
    case sqrtf_negative:
    case atan2l_zero:
    case atan2_zero:
    case atan2f_zero:
    case powl_zero_to_negative:
    case powl_neg_to_non_integer:
    case pow_zero_to_negative:
    case pow_neg_to_non_integer:
    case powf_zero_to_negative:
    case powf_neg_to_non_integer:
    case fmodl_by_zero:
    case fmod_by_zero:
    case fmodf_by_zero:
    case atanhl_gt_one:
    case atanh_gt_one:
    case atanhf_gt_one:
    case acosl_gt_one:
    case acos_gt_one:
    case acosf_gt_one:
    case asinl_gt_one:
    case asin_gt_one:
    case asinf_gt_one:
    case logbl_zero:
    case logb_zero:
    case logbf_zero:
    case acoshl_lt_one:
    case acosh_lt_one:
    case acoshf_lt_one:
    case y0l_zero:
    case y0_zero:
    case y0f_zero:
    case y1l_zero:
    case y1_zero:
    case y1f_zero:
    case ynl_zero:
    case yn_zero:
    case ynf_zero:
    case y0l_negative:
    case y0_negative:
    case y0f_negative:
    case y1l_negative:
    case y1_negative:
    case y1f_negative:
    case ynl_negative:
    case yn_negative:
    case ynf_negative:
    case acosdl_gt_one:
    case acosd_gt_one:
    case acosdf_gt_one:
    case asindl_gt_one:
    case asind_gt_one:
    case asindf_gt_one:
    case atan2dl_zero:
    case atan2d_zero:
    case atan2df_zero:
    case annuityl_by_zero:
    case annuity_by_zero:
    case annuityf_by_zero:
    case annuityl_less_m1:
    case annuity_less_m1:
    case annuityf_less_m1:
    case compoundl_by_zero:
    case compound_by_zero:
    case compoundf_by_zero:
    case compoundl_less_m1:
    case compound_less_m1:
    case compoundf_less_m1:
    case tgammal_negative:
    case tgamma_negative:
    case tgammaf_negative:
    {
         ERRNO_DOMAIN; break;
    }
    default:
      break;
   }
   return;
}

/***********************/
/* _POSIX_ Path        */
/***********************/

else if(_LIB_VERSIONIMF==_POSIX_)
{
switch(input_tag)
  {
  case gammal_overflow:
  case lgammal_overflow:
  case tgammal_overflow:
  {
       RETVAL_HUGE_VALL; ERRNO_RANGE; break;
  }
  case gamma_overflow:
  case lgamma_overflow:
  case tgamma_overflow:
  {
       RETVAL_HUGE_VALD; ERRNO_RANGE; break;
  }
  case gammaf_overflow:
  case lgammaf_overflow:
  case tgammaf_overflow:
  {
       RETVAL_HUGE_VALF; ERRNO_RANGE; break;
  }
  case gammal_negative:
  case gamma_negative:
  case gammaf_negative:
  case lgammal_negative:
  case lgamma_negative:
  case lgammaf_negative:
  case tgammal_negative:
  case tgamma_negative:
  case tgammaf_negative:
  {
       ERRNO_DOMAIN; break;
  }
  case ldexpl_overflow:
  case ldexpl_underflow:
  case ldexp_overflow:
  case ldexp_underflow:
  case ldexpf_overflow:
  case ldexpf_underflow:
  case scalbnl_overflow:
  case scalbnl_underflow:
  case scalbn_overflow:
  case scalbn_underflow:
  case scalbnf_overflow:
  case scalbnf_underflow:
  case scalblnl_overflow:
  case scalblnl_underflow:
  case scalbln_overflow:
  case scalbln_underflow:
  case scalblnf_overflow:
  case scalblnf_underflow:
  case tandl_overflow:
  case tand_overflow:
  case tandf_overflow:
  case cotdl_overflow:
  case cotd_overflow:
  case cotdf_overflow:
  case cotl_overflow:
  case cot_overflow:
  case cotf_overflow:
  case sinhcoshl_overflow:
  case sinhcosh_overflow:
  case sinhcoshf_overflow:
  case nextafterl_overflow:
  case nextafter_overflow:
  case nextafterf_overflow:
  case nextafterl_underflow:
  case nextafter_underflow:
  case nextafterf_underflow:
  case nexttowardl_overflow:
  case nexttoward_overflow:
  case nexttowardf_overflow:
  case nexttowardl_underflow:
  case nexttoward_underflow:
  case nexttowardf_underflow:
  {
       ERRNO_RANGE; break;
  }
  case atanhl_gt_one:
  case atanhl_eq_one:
    /* atanhl(|x| >= 1) */
    {
       ERRNO_DOMAIN; break;
    }
  case atanh_gt_one:
  case atanh_eq_one:
    /* atanh(|x| >= 1) */
    {
       ERRNO_DOMAIN; break;
    }
  case atanhf_gt_one:
  case atanhf_eq_one:
    /* atanhf(|x| >= 1) */
    {
       ERRNO_DOMAIN; break;
    }
  case sqrtl_negative:
    /* sqrtl(x < 0) */
    {
       ERRNO_DOMAIN; break;
    }
  case sqrt_negative:
    /* sqrt(x < 0) */
    {
       ERRNO_DOMAIN; break;
    }
  case sqrtf_negative:
    /* sqrtf(x < 0) */
    {
       ERRNO_DOMAIN; break;
    }
  case y0l_zero:
  case y1l_zero:
  case ynl_zero:
    /* y0l(0) */
    /* y1l(0) */
    /* ynl(0) */
    {
       RETVAL_NEG_HUGE_VALL; ERRNO_DOMAIN; break;
    }
  case y0_zero:
  case y1_zero:
  case yn_zero:
    /* y0(0) */
    /* y1(0) */
    /* yn(0) */
    {
       RETVAL_NEG_HUGE_VALD; ERRNO_DOMAIN; break;
    }
  case y0f_zero:
  case y1f_zero:
  case ynf_zero:
    /* y0f(0) */
    /* y1f(0) */
    /* ynf(0) */
    {
       RETVAL_NEG_HUGE_VALF; ERRNO_DOMAIN; break;
    }
  case y0l_negative:
  case y1l_negative:
  case ynl_negative:
    /* y0l(x < 0) */
    /* y1l(x < 0) */
    /* ynl(x < 0) */
    {
#ifndef _LIBC
       RETVAL_NEG_HUGE_VALL;
#endif
       ERRNO_DOMAIN; break;
    }
  case y0_negative:
  case y1_negative:
  case yn_negative:
    /* y0(x < 0) */
    /* y1(x < 0) */
    /* yn(x < 0) */
    {
       RETVAL_NEG_HUGE_VALD; ERRNO_DOMAIN; break;
    }
  case y0f_negative:
  case y1f_negative:
  case ynf_negative:
    /* y0f(x < 0) */
    /* y1f(x < 0) */
    /* ynf(x < 0) */
    {
       RETVAL_NEG_HUGE_VALF; ERRNO_DOMAIN; break;
    }
  case logl_zero:
  case log1pl_zero:
  case log10l_zero:
  case log2l_zero:
    /* logl(0) */
    /* log1pl(-1) */
    /* log10l(0) */
    /* log2l(0) */
    {
       RETVAL_NEG_HUGE_VALL; ERRNO_RANGE; break;
    }
  case log_zero:
  case log1p_zero:
  case log10_zero:
  case log2_zero:
   /* log(0) */
   /* log1p(-1) */
   /* log10(0) */
   /* log2(0) */
    {
       RETVAL_NEG_HUGE_VALD; ERRNO_RANGE; break;
    }
  case logf_zero:
  case log1pf_zero:
  case log10f_zero:
  case log2f_zero:
    /* logf(0) */
    /* log1pf(-1) */
    /* log10f(0) */
    /* log2f(0) */
    {
       RETVAL_NEG_HUGE_VALF; ERRNO_RANGE; break;
    }
  case logl_negative:
  case log1pl_negative:
  case log10l_negative:
  case log2l_negative:
    /* logl(x < 0) */
    /* log1pl(x < -1) */
    /* log10l(x < 0) */
    /* log2l(x < 0) */
    {
       ERRNO_DOMAIN; break;
    }
  case log_negative:
  case log1p_negative:
  case log10_negative:
  case log2_negative:
    /* log(x < 0) */
    /* log1p(x < -1) */
    /* log10(x < 0) */
    /* log2(x < 0) */
    {
       ERRNO_DOMAIN; break;
    }
  case logf_negative:
  case log1pf_negative:
  case log10f_negative:
  case log2f_negative:
    /* logf(x < 0) */
    /* log1pf(x < -1) */
    /* log10f(x < 0) */
    /* log2f(x < 0) */
    {
       ERRNO_DOMAIN; break;
    }
  case expl_overflow:
  case exp10l_overflow:
  case exp2l_overflow:
    /* expl overflow */
    /* exp10l overflow */
    /* exp2l overflow */
    {
       RETVAL_HUGE_VALL; ERRNO_RANGE; break;
    }
  case exp_overflow:
  case exp10_overflow:
  case exp2_overflow:
    /* exp overflow */
    /* exp10 overflow */
    /* exp2 overflow */
    {
       RETVAL_HUGE_VALD; ERRNO_RANGE; break;
    }
  case expf_overflow:
  case exp10f_overflow:
  case exp2f_overflow:
    /* expf overflow */
    {
       RETVAL_HUGE_VALF; ERRNO_RANGE; break;
    }
  case expl_underflow:
  case exp10l_underflow:
  case exp2l_underflow:
    /* expl underflow */
    /* exp10l underflow */
    /* exp2l underflow */
    {
       ERRNO_RANGE; break;
    }
  case exp_underflow:
  case exp10_underflow:
  case exp2_underflow:
    /* exp underflow */
    /* exp10 underflow */
    /* exp2 underflow */
    {
       ERRNO_RANGE; break;
    }
  case expf_underflow:
  case exp10f_underflow:
  case exp2f_underflow:
    /* expf underflow */
    /* exp10f underflow */
    /* exp2f underflow */
    {
       ERRNO_RANGE; break;
    }
  case j0l_gt_loss:
  case y0l_gt_loss:
  case j1l_gt_loss:
  case y1l_gt_loss:
  case jnl_gt_loss:
  case ynl_gt_loss:
    /* jn and yn  doubl-extended> XLOSS */
    {
       RETVAL_ZEROL; ERRNO_RANGE; break;
    }
  case j0_gt_loss:
  case y0_gt_loss:
  case j1_gt_loss:
  case y1_gt_loss:
  case jn_gt_loss:
  case yn_gt_loss:
    /* jn and yn double > XLOSS */
    {
       RETVAL_ZEROD; ERRNO_RANGE; break;
    }
  case j0f_gt_loss:
  case y0f_gt_loss:
  case j1f_gt_loss:
  case y1f_gt_loss:
  case jnf_gt_loss:
  case ynf_gt_loss:
    /* j0n and y0n > XLOSS */
    {
       RETVAL_ZEROF; ERRNO_RANGE; break;
    }
  case powl_zero_to_zero:
    /* powl 0**0 */
    {
       break;
    }
  case pow_zero_to_zero:
    /* pow 0**0 */
    {
       break;
    }
  case powf_zero_to_zero:
    /* powf 0**0 */
    {
       break;
    }
  case powl_overflow:
  case annuityl_overflow:
  case compoundl_overflow:
    /* powl(x,y) overflow */
    {
       if (INPUT_RESL < ZEROL_VALUE /*0*/) RETVAL_NEG_HUGE_VALL;
       else RETVAL_HUGE_VALL;
       ERRNO_RANGE; break;
    }
  case pow_overflow:
  case annuity_overflow:
  case compound_overflow:
    /* pow(x,y) overflow */
    {
       if (INPUT_RESD < ZEROD_VALUE /*0*/) RETVAL_NEG_HUGE_VALD;
       else RETVAL_HUGE_VALD;
       ERRNO_RANGE; break;
    }
  case powf_overflow:
  case annuityf_overflow:
  case compoundf_overflow:
    /* powf(x,y) overflow */
    {
       if (INPUT_RESF < ZEROF_VALUE /*0*/) RETVAL_NEG_HUGE_VALF;
       else RETVAL_HUGE_VALF;
       ERRNO_RANGE; break;
    }
  case powl_underflow:
  case annuityl_underflow:
  case compoundl_underflow:
    /* powl(x,y) underflow */
    {
       RETVAL_ZEROL; ERRNO_RANGE; break;
    }
  case pow_underflow:
  case annuity_underflow:
  case compound_underflow:
    /* pow(x,y) underflow */
    {
       RETVAL_ZEROD; ERRNO_RANGE; break;
    }
  case powf_underflow:
  case annuityf_underflow:
  case compoundf_underflow:
    /* powf(x,y) underflow */
    {
       RETVAL_ZEROF; ERRNO_RANGE; break;
    }
  case annuityl_by_zero:
  case annuityl_less_m1:
  case compoundl_by_zero:
  case compoundl_less_m1:
  case annuity_by_zero:
  case annuity_less_m1:
  case compound_by_zero:
  case compound_less_m1:
  case annuityf_by_zero:
  case annuityf_less_m1:
  case compoundf_by_zero:
  case compoundf_less_m1:
    {
       ERRNO_DOMAIN; break;
    }
  case powl_zero_to_negative:
    /* 0**neg */
    {
       ERRNO_DOMAIN; break;
    }
  case pow_zero_to_negative:
    /* 0**neg */
    {
       ERRNO_DOMAIN; break;
    }
  case  powf_zero_to_negative:
    /* 0**neg */
    {
       ERRNO_DOMAIN; break;
    }
  case powl_neg_to_non_integer:
    /* neg**non_integral */
    {
       ERRNO_DOMAIN; break;
    }
  case pow_neg_to_non_integer:
    /* neg**non_integral */
    {
       ERRNO_DOMAIN; break;
    }
  case  powf_neg_to_non_integer:
    /* neg**non-integral */
    {
       ERRNO_DOMAIN; break;
    }
  case  powl_nan_to_zero:
    /* powl(NaN,0.0) */
    /* Special Error */
    {
       break;
    }
  case  pow_nan_to_zero:
    /* pow(NaN,0.0) */
    {
       break;
    }
  case  powf_nan_to_zero:
    /* powf(NaN,0.0) */
    {
       break;
    }
  case atan2l_zero:
  case atan2dl_zero:
    /* atan2l(0,0) */
    /* atan2dl(0,0) */
    {
       break;
    }
  case atan2_zero:
  case atan2d_zero:
    /* atan2(0,0) */
    /* atan2d(0,0) */
    {
       break;
    }
  case atan2f_zero:
  case atan2df_zero:
    /* atan2f(0,0) */
    /* atan2df(0,0) */
    {
       break;
    }
  case expm1l_overflow:
    /* expm1 overflow */
    {
       ERRNO_RANGE; break;
    }
  case expm1_overflow:
    /* expm1 overflow */
    {
       ERRNO_RANGE; break;
    }
  case expm1f_overflow:
    /* expm1f overflow */
    {
       ERRNO_RANGE; break;
    }
  case expm1l_underflow:
    /* expm1 underflow */
    {
       ERRNO_RANGE; break;
    }
  case expm1_underflow:
    /* expm1 underflow */
    {
       ERRNO_RANGE; break;
    }
  case expm1f_underflow:
    /* expm1f underflow */
    {
       ERRNO_RANGE; break;
    }
  case hypotl_overflow:
    /* hypotl overflow */
    {
       RETVAL_HUGE_VALL; ERRNO_RANGE; break;
    }
  case hypot_overflow:
    /* hypot overflow */
    {
       RETVAL_HUGE_VALD; ERRNO_RANGE; break;
    }
  case hypotf_overflow:
    /* hypotf overflow */
    {
       RETVAL_HUGE_VALF; ERRNO_RANGE; break;
    }
  case scalbl_underflow:
    /* scalbl underflow */
    {
       if (INPUT_XL < ZEROL_VALUE /*0*/) RETVAL_NEG_ZEROL;
       else RETVAL_ZEROL;
       ERRNO_RANGE; break;
    }
  case scalb_underflow:
    /* scalb underflow */
    {
       if (INPUT_XD < ZEROD_VALUE /*0*/) RETVAL_NEG_ZEROD;
       else RETVAL_ZEROD;
       ERRNO_RANGE; break;
    }
  case scalbf_underflow:
    /* scalbf underflow */
    {
       if (INPUT_XF < ZEROF_VALUE /*0*/) RETVAL_NEG_ZEROF;
       else RETVAL_ZEROF;
       ERRNO_RANGE; break;
    }
  case scalbl_overflow:
    /* scalbl overflow */
    {
       if (INPUT_XL < ZEROL_VALUE /*0*/) RETVAL_NEG_HUGE_VALL;
       else RETVAL_HUGE_VALL;
       ERRNO_RANGE; break;
    }
  case scalb_overflow:
    /* scalb overflow */
    {
       if (INPUT_XD < ZEROD_VALUE /*0*/) RETVAL_NEG_HUGE_VALD;
       else RETVAL_HUGE_VALD;
       ERRNO_RANGE; break;
    }
  case scalbf_overflow:
    /* scalbf overflow */
    {
       if (INPUT_XF < ZEROF_VALUE /*0*/) RETVAL_NEG_HUGE_VALF;
       else RETVAL_HUGE_VALF;
       ERRNO_RANGE; break;
    }
  case acoshl_lt_one:
    /* acoshl(x < 1) */
    {
       ERRNO_DOMAIN; break;
    }
  case acosh_lt_one:
    /* acosh(x < 1) */
    {
       ERRNO_DOMAIN; break;
    }
  case acoshf_lt_one:
    /* acoshf(x < 1) */
    {
        ERRNO_DOMAIN; break;
    }
  case acosl_gt_one:
  case acosdl_gt_one:
    /* acosl(x > 1) */
    /* acosdl(x > 1) */
    {
       ERRNO_DOMAIN; break;
    }
  case acos_gt_one:
  case acosd_gt_one:
    /* acos(x > 1) */
    /* acosd(x > 1) */
    {
       ERRNO_DOMAIN; break;
    }
  case acosf_gt_one:
  case acosdf_gt_one:
    /* acosf(x > 1) */
    /* acosdf(x > 1) */
    {
       ERRNO_DOMAIN; break;
    }
  case asinl_gt_one:
  case asindl_gt_one:
    /* asinl(x > 1) */
    /* asindl(x > 1) */
    {
       ERRNO_DOMAIN; break;
    }
  case asin_gt_one:
  case asind_gt_one:
    /* asin(x > 1) */
    /* asind(x > 1) */
    {
       ERRNO_DOMAIN; break;
    }
  case asinf_gt_one:
  case asindf_gt_one:
    /* asinf(x > 1) */
    /* asindf(x > 1) */
    {
       ERRNO_DOMAIN; break;
    }
  case remainderl_by_zero:
  case fmodl_by_zero:
    /* fmodl(x,0) */
    {
       ERRNO_DOMAIN; break;
    }
  case remainder_by_zero:
  case fmod_by_zero:
    /* fmod(x,0) */
    {
       ERRNO_DOMAIN; break;
    }
  case remainderf_by_zero:
  case fmodf_by_zero:
    /* fmodf(x,0) */
    {
       ERRNO_DOMAIN; break;
    }
  case coshl_overflow:
    /* coshl overflows */
    {
       RETVAL_HUGE_VALL; ERRNO_RANGE; break;
    }
  case cosh_overflow:
    /* cosh overflows */
    {
       RETVAL_HUGE_VALD; ERRNO_RANGE; break;
    }
  case coshf_overflow:
    /* coshf overflows */
    {
       RETVAL_HUGE_VALF; ERRNO_RANGE; break;
    }
  case sinhl_overflow:
    /* sinhl overflows */
    {
       if (INPUT_XL > ZEROL_VALUE /*0*/) RETVAL_HUGE_VALL;
       else RETVAL_NEG_HUGE_VALL;
       ERRNO_RANGE; break;
    }
  case sinh_overflow:
    /* sinh overflows */
    {
       if (INPUT_XD > ZEROD_VALUE /*0*/) RETVAL_HUGE_VALD;
       else RETVAL_NEG_HUGE_VALD;
       ERRNO_RANGE; break;
    }
  case sinhf_overflow:
    /* sinhf overflows */
    {
       if (INPUT_XF > ZEROF_VALUE /*0*/) RETVAL_HUGE_VALF;
       else RETVAL_NEG_HUGE_VALF;
       ERRNO_RANGE; break;
    }
  case logbl_zero:
   /* logbl(0) */
   {
      ERRNO_DOMAIN; break;
   }
  case logb_zero:
   /* logb(0) */
   {
      ERRNO_DOMAIN; break;
   }
  case logbf_zero:
   /* logbf(0) */
   {
      ERRNO_DOMAIN; break;
   }
  case ilogbl_zero:
   /* ilogbl(0) */
   {
      ERRNO_RANGE; break;
   }
  case ilogb_zero:
   /* ilogb(0) */
   {
      ERRNO_RANGE; break;
   }
  case ilogbf_zero:
   /* ilogbf(0) */
   {
      ERRNO_RANGE; break;
   }
  default:
    break;
}
return;
/* _POSIX_ */
}

/*******************************/
/* __SVID__ and __XOPEN__ Path */
/*******************************/
else
{
  switch(input_tag)
  {
  case ldexpl_overflow:
  case ldexpl_underflow:
  case ldexp_overflow:
  case ldexp_underflow:
  case ldexpf_overflow:
  case ldexpf_underflow:
  case scalbnl_overflow:
  case scalbnl_underflow:
  case scalbn_overflow:
  case scalbn_underflow:
  case scalbnf_overflow:
  case scalbnf_underflow:
  case scalblnl_overflow:
  case scalblnl_underflow:
  case scalbln_overflow:
  case scalbln_underflow:
  case scalblnf_overflow:
  case scalblnf_underflow:
  case tandl_overflow:
  case tand_overflow:
  case tandf_overflow:
  case cotdl_overflow:
  case cotd_overflow:
  case cotdf_overflow:
  case cotl_overflow:
  case cot_overflow:
  case cotf_overflow:
  case annuityl_overflow:
  case annuityl_underflow:
  case annuity_overflow:
  case annuity_underflow:
  case annuityf_overflow:
  case annuityf_underflow:
  case compoundl_overflow:
  case compoundl_underflow:
  case compound_overflow:
  case compound_underflow:
  case compoundf_overflow:
  case compoundf_underflow:
  {
       ERRNO_RANGE; break;
  }
  case annuityl_by_zero:
  case annuityl_less_m1:
  case annuity_by_zero:
  case annuity_less_m1:
  case annuityf_by_zero:
  case annuityf_less_m1:
  case compoundl_by_zero:
  case compoundl_less_m1:
  case compound_by_zero:
  case compound_less_m1:
  case compoundf_by_zero:
  case compoundf_less_m1:
  {
       ERRNO_DOMAIN; break;
  }
  case sqrtl_negative:
    /* sqrtl(x < 0) */
    {
       DOMAINL; NAMEL = (char *) "sqrtl";
       ifSVID
       {
          RETVAL_ZEROL;
          NOT_MATHERRL
          {
            WRITEL_SQRT;
            ERRNO_DOMAIN;
          }
       }
       else
       { /* NaN already computed */
          NOT_MATHERRL {ERRNO_DOMAIN;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case sqrt_negative:
    /* sqrt(x < 0) */
    {
       DOMAIND; NAMED = (char *) "sqrt";
       ifSVID
       {

         RETVAL_ZEROD;
         NOT_MATHERRD
         {
           WRITED_SQRT;
           ERRNO_DOMAIN;
         }
       }
       else
       { /* NaN already computed */
         NOT_MATHERRD {ERRNO_DOMAIN;}
       }
       *(double *)retval = exc.retval;
       break;
    }
  case sqrtf_negative:
    /* sqrtf(x < 0) */
    {
       DOMAINF; NAMEF = (char *) "sqrtf";
       ifSVID
       {
         RETVAL_ZEROF;
         NOT_MATHERRF
         {
           WRITEF_SQRT;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         NOT_MATHERRF {ERRNO_DOMAIN;}
       }
       *(float *)retval = excf.retval;
       break;
    }
  case logl_zero:
    /* logl(0) */
    {
       SINGL; NAMEL = (char *) "logl";
       ifSVID
       {
         RETVAL_NEG_HUGEL;
         NOT_MATHERRL
         {
           WRITEL_LOG_ZERO;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALL;
         NOT_MATHERRL {ERRNO_DOMAIN;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case log_zero:
    /* log(0) */
    {
       SINGD; NAMED = (char *) "log";
       ifSVID
       {
         RETVAL_NEG_HUGED;
         NOT_MATHERRD
         {
           WRITED_LOG_ZERO;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALD;
         NOT_MATHERRD {ERRNO_DOMAIN;}
       }
       *(double *)retval = exc.retval;
       break;
    }
  case logf_zero:
    /* logf(0) */
    {
       SINGF; NAMEF = (char *) "logf";
       ifSVID
       {
         RETVAL_NEG_HUGEF;
         NOT_MATHERRF
         {
            WRITEF_LOG_ZERO;
            ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALF;
         NOT_MATHERRF {ERRNO_DOMAIN;}
       }
       *(float *)retval = excf.retval;
       break;
    }

  case logl_negative:
    /* logl(x < 0) */
    {
       DOMAINL; NAMEL = (char *) "logl";
       ifSVID
       {
         RETVAL_NEG_HUGEL;
         NOT_MATHERRL
         {
           WRITEL_LOG_NEGATIVE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALL;
         NOT_MATHERRL {ERRNO_DOMAIN;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case log_negative:
    /* log(x < 0) */
    {
       DOMAIND; NAMED = (char *) "log";
       ifSVID
       {
         RETVAL_NEG_HUGED;
         NOT_MATHERRD
         {
           WRITED_LOG_NEGATIVE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALD;
         NOT_MATHERRD {ERRNO_DOMAIN;}
       }
       *(double *)retval = exc.retval;
       break;
    }
  case logf_negative:
    /* logf(x < 0) */
    {
       DOMAINF; NAMEF = (char *) "logf";
       ifSVID
       {
         RETVAL_NEG_HUGEF;
         NOT_MATHERRF
         {
           WRITEF_LOG_NEGATIVE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALF;
         NOT_MATHERRF{ERRNO_DOMAIN;}
       }
       *(float *)retval = excf.retval;
       break;
    }
  case log1pl_zero:
    /* log1pl(-1) */
    {
       SINGL; NAMEL = (char *) "log1pl";
       ifSVID
       {
         RETVAL_NEG_HUGEL;
         NOT_MATHERRL
         {
           WRITEL_LOG1P_ZERO;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALL;
         NOT_MATHERRL {ERRNO_DOMAIN;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case log1p_zero:
    /* log1p(-1) */
    {
       SINGD; NAMED = (char *) "log1p";
       ifSVID
       {
         RETVAL_NEG_HUGED;
         NOT_MATHERRD
         {
           WRITED_LOG1P_ZERO;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALD;
         NOT_MATHERRD {ERRNO_DOMAIN;}
       }
       *(double *)retval = exc.retval;
       break;
    }
  case log1pf_zero:
    /* log1pf(-1) */
    {
       SINGF; NAMEF = (char *) "log1pf";
       ifSVID
       {
         RETVAL_NEG_HUGEF;
         NOT_MATHERRF
         {
           WRITEF_LOG1P_ZERO;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALF;
         NOT_MATHERRF {ERRNO_DOMAIN;}
       }
       *(float *)retval = excf.retval;
       break;
    }
 case log1pl_negative:
   /* log1pl(x < -1) */
   {
      DOMAINL; NAMEL = (char *) "log1pl";
      ifSVID
      {
        RETVAL_NEG_HUGEL;
        NOT_MATHERRL
        {
          WRITEL_LOG1P_NEGATIVE;
          ERRNO_DOMAIN;
        }
      }
      else
      {
        RETVAL_NEG_HUGE_VALL;
        NOT_MATHERRL {ERRNO_DOMAIN;}
      }
      *(long double *)retval = excl.retval;
      break;
   }
 case log1p_negative:
   /* log1p(x < -1) */
   {
      DOMAIND; NAMED = (char *) "log1p";
      ifSVID
      {
        RETVAL_NEG_HUGED;
        NOT_MATHERRD
        {
          WRITED_LOG1P_NEGATIVE;
          ERRNO_DOMAIN;
        }
      }
      else
      {
        RETVAL_NEG_HUGE_VALD;
        NOT_MATHERRD {ERRNO_DOMAIN;}
      }
      *(double *)retval = exc.retval;
      break;
   }
 case log1pf_negative:
   /* log1pf(x < -1) */
   {
      DOMAINF; NAMEF = (char *) "log1pf";
      ifSVID
      {
        RETVAL_NEG_HUGEF;
        NOT_MATHERRF
        {
          WRITEF_LOG1P_NEGATIVE;
          ERRNO_DOMAIN;
        }
      }
      else
      {
        RETVAL_NEG_HUGE_VALF;
        NOT_MATHERRF {ERRNO_DOMAIN;}
      }
      *(float *)retval = excf.retval;
      break;
   }
  case log10l_zero:
    /* log10l(0) */
    {
       SINGL; NAMEL = (char *) "log10l";
       ifSVID
       {
         RETVAL_NEG_HUGEL;
         NOT_MATHERRL
         {
            WRITEL_LOG10_ZERO;
            ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALL;
         NOT_MATHERRL {ERRNO_DOMAIN;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case log10_zero:
    /* log10(0) */
    {
       SINGD; NAMED = (char *) "log10";
       ifSVID
       {
         RETVAL_NEG_HUGED;
         NOT_MATHERRD
         {
           WRITED_LOG10_ZERO;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALD;
         NOT_MATHERRD {ERRNO_DOMAIN;}
       }
       *(double *)retval = exc.retval;
       break;
    }
  case log10f_zero:
    /* log10f(0) */
    {
       SINGF; NAMEF = (char *) "log10f";
       ifSVID
       {
         RETVAL_NEG_HUGEF;
         NOT_MATHERRF
         {
          WRITEF_LOG10_ZERO;
          ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALF;
         NOT_MATHERRF {ERRNO_DOMAIN;}
       }
       *(float *)retval = excf.retval;
       break;
    }
  case log10l_negative:
    /* log10l(x < 0) */
    {
       DOMAINL; NAMEL = (char *) "log10l";
       ifSVID
       {
         RETVAL_NEG_HUGEL;
         NOT_MATHERRL
         {
           WRITEL_LOG10_NEGATIVE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALL;
         NOT_MATHERRL {ERRNO_DOMAIN;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case log10_negative:
    /* log10(x < 0) */
    {
       DOMAIND; NAMED = (char *) "log10";
       ifSVID
       {
         RETVAL_NEG_HUGED;
         NOT_MATHERRD
         {
           WRITED_LOG10_NEGATIVE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALD;
         NOT_MATHERRD {ERRNO_DOMAIN;}
       }
       *(double *)retval = exc.retval;
       break;
    }
  case log10f_negative:
    /* log10f(x < 0) */
    {
       DOMAINF; NAMEF = (char *) "log10f";
       ifSVID
       {
         RETVAL_NEG_HUGEF;
         NOT_MATHERRF
         {
           WRITEF_LOG10_NEGATIVE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALF;
         NOT_MATHERRF {ERRNO_DOMAIN;}
       }
       *(float *)retval = excf.retval;
       break;
    }
  case log2l_zero:
    /* log2l(0) */
    {
       SINGL; NAMEL = (char *) "log2l";
       ifSVID
       {
         RETVAL_NEG_HUGEL;
         NOT_MATHERRL
         {
           WRITEL_LOG2_ZERO;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALL;
         NOT_MATHERRL {ERRNO_DOMAIN;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case log2_zero:
    /* log2(0) */
    {
       SINGD; NAMED = (char *) "log2";
       ifSVID
       {
         RETVAL_NEG_HUGED;
         NOT_MATHERRD
         {
           WRITED_LOG2_ZERO;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALD;
         NOT_MATHERRD {ERRNO_DOMAIN;}
       }
       *(double *)retval = exc.retval;
       break;
    }
  case log2f_zero:
    /* log2f(0) */
    {
       SINGF; NAMEF = (char *) "log2f";
       ifSVID
       {
         RETVAL_NEG_HUGEF;
         NOT_MATHERRF
         {
          WRITEF_LOG2_ZERO;
          ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALF;
         NOT_MATHERRF {ERRNO_DOMAIN;}
       }
       *(float *)retval = excf.retval;
       break;
    }
  case log2l_negative:
    /* log2l(x < 0) */
    {
       DOMAINL; NAMEL = (char *) "log2l";
       ifSVID
       {
         RETVAL_NEG_HUGEL;
         NOT_MATHERRL
         {
           WRITEL_LOG2_NEGATIVE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALL;
         NOT_MATHERRL {ERRNO_DOMAIN;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case log2_negative:
    /* log2(x < 0) */
    {
       DOMAIND; NAMED = (char *) "log2";
       ifSVID
       {
         RETVAL_NEG_HUGED;
         NOT_MATHERRD
         {
           WRITED_LOG2_NEGATIVE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALD;
         NOT_MATHERRD {ERRNO_DOMAIN;}
       }
       *(double *)retval = exc.retval;
       break;
    }
  case log2f_negative:
    /* log2f(x < 0) */
    {
       DOMAINF; NAMEF = (char *) "log2f";
       ifSVID
       {
         RETVAL_NEG_HUGEF;
         NOT_MATHERRF
         {
           WRITEF_LOG2_NEGATIVE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALF;
         NOT_MATHERRF {ERRNO_DOMAIN;}
       }
       *(float *)retval = excf.retval;
       break;
    }
  case expl_overflow:
    /* expl overflow */
    {
       OVERFLOWL; NAMEL = (char *) "expl";
       ifSVID
       {
         RETVAL_HUGEL;
       }
       else
       {
       RETVAL_HUGE_VALL;
       }
       NOT_MATHERRL {ERRNO_RANGE;}
       *(long double *)retval = excl.retval;
       break;
    }
  case exp_overflow:
    /* exp overflow */
    {
       OVERFLOWD; NAMED = (char *) "exp";
       ifSVID
       {
         RETVAL_HUGED;
       }
       else
       {
         RETVAL_HUGE_VALD;
       }
       NOT_MATHERRD {ERRNO_RANGE;}
       *(double *)retval = exc.retval;
       break;
    }
  case expf_overflow:
    /* expf overflow */
    {
       OVERFLOWF; NAMEF = (char *) "expf";
       ifSVID
       {
         RETVAL_HUGEF;
       }
       else
       {
         RETVAL_HUGE_VALF;
       }
       NOT_MATHERRF {ERRNO_RANGE;}
       *(float *)retval = excf.retval;
       break;
    }
  case expl_underflow:
    /* expl underflow */
    {
       UNDERFLOWL; NAMEL = (char *) "expl"; RETVAL_ZEROL;
       NOT_MATHERRL {ERRNO_RANGE;}
       *(long double *)retval = excl.retval;
       break;
    }
  case exp_underflow:
    /* exp underflow */
    {
       UNDERFLOWD; NAMED = (char *) "exp"; RETVAL_ZEROD;
       NOT_MATHERRD {ERRNO_RANGE;}
       *(double *)retval = exc.retval;
       break;
    }
  case expf_underflow:
    /* expf underflow */
    {
       UNDERFLOWF; NAMEF = (char *) "expf"; RETVAL_ZEROF;
       NOT_MATHERRF {ERRNO_RANGE;}
       *(float *)retval = excf.retval;
       break;
    }
  case powl_zero_to_zero:
    /* powl 0**0 */
    {
       DOMAINL; NAMEL = (char *) "powl";
       ifSVID
       {
         RETVAL_ZEROL;
         NOT_MATHERRL
         {
            WRITEL_POW_ZERO_TO_ZERO;
            ERRNO_DOMAIN;
         }
         *(long double *)retval = excl.retval;
       }
       else RETVAL_ONEL;
       break;
    }
  case pow_zero_to_zero:
    /* pow 0**0 */
    {
       DOMAIND; NAMED = (char *) "pow";
       ifSVID
       {
         RETVAL_ZEROD;
         NOT_MATHERRD
         {
            WRITED_POW_ZERO_TO_ZERO;
            ERRNO_DOMAIN;
         }
         *(double *)retval = exc.retval;
       }
       else RETVAL_ONED;
       break;
    }
  case powf_zero_to_zero:
    /* powf 0**0 */
    {
       DOMAINF; NAMEF = (char *) "powf";
       ifSVID
       {
         RETVAL_ZEROF;
         NOT_MATHERRF
         {
          WRITEF_POW_ZERO_TO_ZERO;
          ERRNO_DOMAIN;
         }
         *(float *)retval = excf.retval;
       }
       else RETVAL_ONEF;
       break;
    }
  case powl_overflow:
    /* powl(x,y) overflow */
    {
       OVERFLOWL; NAMEL = (char *) "powl";
       ifSVID
       {
         if (INPUT_RESL < ZEROL_VALUE /*0*/) RETVAL_NEG_HUGEL;
         else RETVAL_HUGEL;
       }
       else
       {
         if (INPUT_RESL < ZEROL_VALUE /*0*/) RETVAL_NEG_HUGE_VALL;
         else RETVAL_HUGE_VALL;
       }
       NOT_MATHERRL {ERRNO_RANGE;}
       *(long double *)retval = excl.retval;
       break;
    }
  case pow_overflow:
    /* pow(x,y) overflow */
    {
       OVERFLOWD; NAMED = (char *) "pow";
       ifSVID
       {
         if (INPUT_RESD < ZEROD_VALUE /*0*/) RETVAL_NEG_HUGED;
         else RETVAL_HUGED;
       }
       else
       {
         if (INPUT_RESD < ZEROD_VALUE /*0*/) RETVAL_NEG_HUGE_VALD;
         else RETVAL_HUGE_VALD;
       }
       NOT_MATHERRD {ERRNO_RANGE;}
       *(double *)retval = exc.retval;
       break;
    }
  case powf_overflow:
    /* powf(x,y) overflow */
    {
       OVERFLOWF; NAMEF = (char *) "powf";
       ifSVID
       {
         if (INPUT_RESF < ZEROF_VALUE /*0*/) RETVAL_NEG_HUGEF;
         else RETVAL_HUGEF;
       }
       else
       {
         if (INPUT_RESF < ZEROF_VALUE /*0*/) RETVAL_NEG_HUGE_VALF;
         else RETVAL_HUGE_VALF;
       }
       NOT_MATHERRF {ERRNO_RANGE;}
       *(float *)retval = excf.retval;
       break;
    }
  case powl_underflow:
    /* powl(x,y) underflow */
    {
       UNDERFLOWL; NAMEL = (char *) "powl"; RETVAL_ZEROL;
       NOT_MATHERRL {ERRNO_RANGE;}
       *(long double *)retval = excl.retval;
       break;
    }
  case pow_underflow:
    /* pow(x,y) underflow */
    {
       UNDERFLOWD; NAMED = (char *) "pow"; RETVAL_ZEROD;
       NOT_MATHERRD {ERRNO_RANGE;}
       *(double *)retval = exc.retval;
       break;
    }
  case powf_underflow:
    /* powf(x,y) underflow */
    {
       UNDERFLOWF; NAMEF = (char *) "powf"; RETVAL_ZEROF;
       NOT_MATHERRF {ERRNO_RANGE;}
       *(float *)retval = excf.retval;
       break;
    }
  case powl_zero_to_negative:
    /* 0 to neg */
    {
       DOMAINL; NAMEL = (char *) "powl";
       ifSVID
       {
         RETVAL_ZEROL;
         NOT_MATHERRL
         {
           WRITEL_POW_ZERO_TO_NEGATIVE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALL;
         NOT_MATHERRL {ERRNO_DOMAIN;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case pow_zero_to_negative:
    /* 0**neg */
    {
       DOMAIND; NAMED = (char *) "pow";
       ifSVID
       {
         RETVAL_ZEROD;
         NOT_MATHERRD
         {
           WRITED_POW_ZERO_TO_NEGATIVE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALD;
         NOT_MATHERRD {ERRNO_DOMAIN;}
       }
       *(double *)retval = exc.retval;
       break;
    }
  case powf_zero_to_negative:
    /* 0**neg */
    {
       DOMAINF; NAMEF = (char *) "powf";
       ifSVID
       {
         RETVAL_ZEROF;
         NOT_MATHERRF
         {
            WRITEF_POW_ZERO_TO_NEGATIVE;
            ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALF;
         NOT_MATHERRF {ERRNO_DOMAIN;}
       }
       *(float *)retval = excf.retval;
       break;
    }
  case powl_neg_to_non_integer:
    /* neg**non_integral */
    {
       DOMAINL; NAMEL = (char *) "powl";
       ifSVID
       {
         RETVAL_ZEROL;
         NOT_MATHERRL
         {
           WRITEL_POW_NEG_TO_NON_INTEGER;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         NOT_MATHERRL {ERRNO_DOMAIN;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case pow_neg_to_non_integer:
    /* neg**non_integral */
    {
       DOMAIND; NAMED = (char *) "pow";
       ifSVID
       {
         RETVAL_ZEROD;
         NOT_MATHERRD
         {
            WRITED_POW_NEG_TO_NON_INTEGER;
            ERRNO_DOMAIN;
         }
       }
       else
       {
         NOT_MATHERRD {ERRNO_DOMAIN;}
       }
       *(double *)retval = exc.retval;
       break;
    }
  case powf_neg_to_non_integer:
    /* neg**non-integral */
    {
       DOMAINF; NAMEF = (char *) "powf";
       ifSVID
       {
         RETVAL_ZEROF;
         NOT_MATHERRF
         {
            WRITEF_POW_NEG_TO_NON_INTEGER;
            ERRNO_DOMAIN;
         }
       }
       else
       {
         NOT_MATHERRF {ERRNO_DOMAIN;}
       }
       *(float *)retval = excf.retval;
       break;
    }
  case powl_nan_to_zero:
    /* pow(NaN,0.0) */
    /* Special Error */
    {
       DOMAINL; NAMEL = (char *) "powl";
       *(long double *)retval = *(long double *)arg1;
       NOT_MATHERRL {ERRNO_DOMAIN;}
       *(long double *)retval = excl.retval;
       break;
    }
  case pow_nan_to_zero:
    /* pow(NaN,0.0) */
    /* Special Error */
    {
       DOMAIND; NAMED = (char *) "pow";
       *(double *)retval = *(double *)arg1;
       NOT_MATHERRD {ERRNO_DOMAIN;}
       *(double *)retval = exc.retval;
       break;
    }
  case powf_nan_to_zero:
    /* powf(NaN,0.0) */
    /* Special Error */
    {
       DOMAINF; NAMEF = (char *) "powf";
       *(float *)retval = *(float *)arg1;
       NOT_MATHERRF {ERRNO_DOMAIN;}
       *(float *)retval = excf.retval;
       break;
    }
  case atan2l_zero:
    /* atan2l(0.0,0.0) */
    {
       DOMAINL; NAMEL = (char *) "atan2l";
       RETVAL_ZEROL;
       NOT_MATHERRL
       {
         ifSVID
         {
            WRITEL_ATAN2_ZERO_BY_ZERO;
         }
         ERRNO_DOMAIN;
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case atan2_zero:
    /* atan2(0.0,0.0) */
    {
       DOMAIND; NAMED = (char *) "atan2";
       RETVAL_ZEROD;
       NOT_MATHERRD
       {
         ifSVID
         {
            WRITED_ATAN2_ZERO_BY_ZERO;
         }
         ERRNO_DOMAIN;
       }
       *(double *)retval = exc.retval;
       break;
    }
  case atan2f_zero:
    /* atan2f(0.0,0.0) */
    {
       DOMAINF; NAMEF = (char *) "atan2f";
       RETVAL_ZEROF;
       NOT_MATHERRF
       {
         ifSVID
         {
            WRITEF_ATAN2_ZERO_BY_ZERO;
         }
         ERRNO_DOMAIN;
       }
       *(float *)retval = excf.retval;
       break;
    }
  case atan2dl_zero:
    /* atan2dl(0.0,0.0) */
    {
       DOMAINL; NAMEL = (char *) "atan2dl";
       RETVAL_ZEROL;
       NOT_MATHERRL
       {
         ifSVID
         {
            WRITEL_ATAN2D_ZERO_BY_ZERO;
         }
         ERRNO_DOMAIN;
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case atan2d_zero:
    /* atan2d(0.0,0.0) */
    {
       DOMAIND; NAMED = (char *) "atan2d";
       RETVAL_ZEROD;
       NOT_MATHERRD
       {
         ifSVID
         {
            WRITED_ATAN2D_ZERO_BY_ZERO;
         }
         ERRNO_DOMAIN;
       }
       *(double *)retval = exc.retval;
       break;
    }
  case atan2df_zero:
    /* atan2df(0.0,0.0) */
    {
       DOMAINF; NAMEF = (char *) "atan2df";
       RETVAL_ZEROF;
       NOT_MATHERRF
       {
         ifSVID
         {
            WRITEF_ATAN2D_ZERO_BY_ZERO;
         }
         ERRNO_DOMAIN;
       }
       *(float *)retval = excf.retval;
       break;
    }
  case expm1_overflow:
    /* expm1(finite) overflow */
    /* Overflow is the only documented */
    /* special value. */
    {
      ERRNO_RANGE;
      break;
    }
  case expm1f_overflow:
    /* expm1f(finite) overflow */
    {
      ERRNO_RANGE;
      break;
    }
  case expm1_underflow:
    /* expm1(finite) underflow */
    /* Underflow is not documented */
    /* special value. */
    {
      ERRNO_RANGE;
      break;
    }
  case expm1f_underflow:
    /* expm1f(finite) underflow */
    {
      ERRNO_RANGE;
      break;
    }
  case scalbl_underflow:
    /* scalbl underflow */
    {
       UNDERFLOWL; NAMEL = (char *) "scalbl";
       if (INPUT_XL < ZEROL_VALUE /*0.0L*/) RETVAL_NEG_ZEROL;
       else  RETVAL_ZEROL;
       NOT_MATHERRL {ERRNO_RANGE;}
       *(long double *)retval = excl.retval;
       break;
    }
  case scalb_underflow:
    /* scalb underflow */
    {
       UNDERFLOWD; NAMED = (char *) "scalb";
       if (INPUT_XD < ZEROD_VALUE /*0.0*/) RETVAL_NEG_ZEROD;
       else  RETVAL_ZEROD;
       NOT_MATHERRD {ERRNO_RANGE;}
       *(double *)retval = exc.retval;
       break;
    }
  case scalbf_underflow:
    /* scalbf underflow */
    {
       UNDERFLOWF; NAMEF = (char *) "scalbf";
       if (INPUT_XF < ZEROF_VALUE /*0.0*/) RETVAL_NEG_ZEROF;
       else  RETVAL_ZEROF;
       NOT_MATHERRF {ERRNO_RANGE;}
       *(float *)retval = excf.retval;
       break;
    }
  case scalbl_overflow:
    /* scalbl overflow */
    {
       OVERFLOWL; NAMEL = (char *) "scalbl";
       if (INPUT_XL < ZEROL_VALUE /*0*/) RETVAL_NEG_HUGE_VALL;
       else RETVAL_HUGE_VALL;
       NOT_MATHERRL {ERRNO_RANGE;}
       *(long double *)retval = excl.retval;
       break;
    }
  case scalb_overflow:
    /* scalb overflow */
    {
       OVERFLOWD; NAMED = (char *) "scalb";
       if (INPUT_XD < ZEROD_VALUE /*0*/) RETVAL_NEG_HUGE_VALD;
       else RETVAL_HUGE_VALD;
       NOT_MATHERRD {ERRNO_RANGE;}
       *(double *)retval = exc.retval;
       break;
    }
  case scalbf_overflow:
    /* scalbf overflow */
    {
       OVERFLOWF; NAMEF = (char *) "scalbf";
       if (INPUT_XF < ZEROF_VALUE /*0*/) RETVAL_NEG_HUGE_VALF;
       else RETVAL_HUGE_VALF;
       NOT_MATHERRF {ERRNO_RANGE;}
       *(float *)retval = excf.retval;
       break;
    }
  case hypotl_overflow:
    /* hypotl overflow */
    {
       OVERFLOWL; NAMEL = (char *) "hypotl";
       ifSVID
       {
         RETVAL_HUGEL;
       }
       else
       {
         RETVAL_HUGE_VALL;
       }
       NOT_MATHERRL {ERRNO_RANGE;}
       *(long double *)retval = excl.retval;
       break;
    }
  case hypot_overflow:
    /* hypot overflow */
    {
       OVERFLOWD; NAMED = (char *) "hypot";
       ifSVID
       {
         RETVAL_HUGED;
       }
       else
       {
         RETVAL_HUGE_VALD;
       }
       NOT_MATHERRD {ERRNO_RANGE;}
       *(double *)retval = exc.retval;
       break;
    }
  case hypotf_overflow:
    /* hypotf overflow */
    {
       OVERFLOWF; NAMEF = (char *) "hypotf";
       ifSVID
       {
         RETVAL_HUGEF;
       }
       else
       {
         RETVAL_HUGE_VALF;
       }
       NOT_MATHERRF {ERRNO_RANGE;}
       *(float *)retval = excf.retval;
       break;
    }
  case acosl_gt_one:
    /* acosl(x > 1) */
    {
       DOMAINL; NAMEL = (char *) "acosl";
       RETVAL_ZEROL;
       ifSVID
       {
         NOT_MATHERRL
         {
           WRITEL_ACOS;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         NOT_MATHERRL {ERRNO_DOMAIN;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case acos_gt_one:
    /* acos(x > 1) */
    {
       DOMAIND; NAMED = (char *) "acos";
       RETVAL_ZEROD;
       ifSVID
       {
         NOT_MATHERRD
         {
           WRITED_ACOS;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         NOT_MATHERRD {ERRNO_DOMAIN;}
       }
       *(double *)retval = exc.retval;
       break;
    }
  case acosf_gt_one:
    /* acosf(x > 1) */
    {
       DOMAINF; NAMEF = (char *) "acosf";
       RETVAL_ZEROF;
       ifSVID
       {
         NOT_MATHERRF
         {
           WRITEF_ACOS;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         NOT_MATHERRF {ERRNO_DOMAIN;}
       }
       *(float *)retval = excf.retval;
       break;
    }
  case asinl_gt_one:
    /* asinl(x > 1) */
    {
       DOMAINL; NAMEL = (char *) "asinl";
       RETVAL_ZEROL;
       ifSVID
       {
         NOT_MATHERRL
         {
           WRITEL_ASIN;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         NOT_MATHERRL {ERRNO_DOMAIN;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case asin_gt_one:
    /* asin(x > 1) */
    {
       DOMAIND; NAMED = (char *) "asin";
       RETVAL_ZEROD;
       ifSVID
       {
         NOT_MATHERRD
         {
           WRITED_ASIN;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         NOT_MATHERRD {ERRNO_DOMAIN;}
       }
       *(double *)retval = exc.retval;
       break;
    }
  case asinf_gt_one:
    /* asinf(x > 1) */
    {
       DOMAINF; NAMEF = (char *) "asinf";
       RETVAL_ZEROF;
       ifSVID
       {
         NOT_MATHERRF
         {
            WRITEF_ASIN;
            ERRNO_DOMAIN;
         }
       }
       else
       {
         NOT_MATHERRF {ERRNO_DOMAIN;}
       }
       *(float *)retval = excf.retval;
       break;
    }
  case acosdl_gt_one:
    /* acosdl(x > 1) */
    {
       DOMAINL; NAMEL = (char *) "acosdl";
       RETVAL_ZEROL;
       ifSVID
       {
         NOT_MATHERRL
         {
           WRITEL_ACOSD;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         NOT_MATHERRL {ERRNO_DOMAIN;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case acosd_gt_one:
    /* acosd(x > 1) */
    {
       DOMAIND; NAMED = (char *) "acosd";
       RETVAL_ZEROD;
       ifSVID
       {
         NOT_MATHERRD
         {
           WRITED_ACOSD;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         NOT_MATHERRD {ERRNO_DOMAIN;}
       }
       *(double *)retval = exc.retval;
       break;
    }
  case acosdf_gt_one:
    /* acosdf(x > 1) */
    {
       DOMAINF; NAMEF = (char *) "acosdf";
       RETVAL_ZEROF;
       ifSVID
       {
         NOT_MATHERRF
         {
           WRITEF_ACOSD;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         NOT_MATHERRF {ERRNO_DOMAIN;}
       }
       *(float *)retval = excf.retval;
       break;
    }
  case asindl_gt_one:
    /* asindl(x > 1) */
    {
       DOMAINL; NAMEL = (char *) "asindl";
       RETVAL_ZEROL;
       ifSVID
       {
         NOT_MATHERRL
         {
           WRITEL_ASIND;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         NOT_MATHERRL {ERRNO_DOMAIN;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case asind_gt_one:
    /* asind(x > 1) */
    {
       DOMAIND; NAMED = (char *) "asind";
       RETVAL_ZEROD;
       ifSVID
       {
         NOT_MATHERRD
         {
           WRITED_ASIND;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         NOT_MATHERRD {ERRNO_DOMAIN;}
       }
       *(double *)retval = exc.retval;
       break;
    }
  case asindf_gt_one:
    /* asindf(x > 1) */
    {
       DOMAINF; NAMEF = (char *) "asindf";
       RETVAL_ZEROF;
       ifSVID
       {
         NOT_MATHERRF
         {
            WRITEF_ASIND;
            ERRNO_DOMAIN;
         }
       }
       else
       {
         NOT_MATHERRF {ERRNO_DOMAIN;}
       }
       *(float *)retval = excf.retval;
       break;
    }
 case coshl_overflow:
   /* coshl overflow */
   {
      OVERFLOWL; NAMEL = (char *) "coshl";
      ifSVID
      {
        RETVAL_HUGEL;
      }
      else
      {
        RETVAL_HUGE_VALL;
      }
      NOT_MATHERRL {ERRNO_RANGE;}
      *(long double *)retval = excl.retval;
      break;
   }
 case cosh_overflow:
   /* cosh overflow */
   {
      OVERFLOWD; NAMED = (char *) "cosh";
      ifSVID
      {
        RETVAL_HUGED;
      }
      else
      {
        RETVAL_HUGE_VALD;
      }
      NOT_MATHERRD {ERRNO_RANGE;}
      *(double *)retval = exc.retval;
      break;
   }
 case coshf_overflow:
   /* coshf overflow */
   {
      OVERFLOWF; NAMEF = (char *) "coshf";
      ifSVID
      {
        RETVAL_HUGEF;
      }
      else
      {
        RETVAL_HUGE_VALF;
      }
      NOT_MATHERRF {ERRNO_RANGE;}
      *(float *)retval = excf.retval;
      break;
   }
 case sinhl_overflow:
   /* sinhl overflow */
   {
      OVERFLOWL; NAMEL = (char *) "sinhl";
      ifSVID
      {
        if (INPUT_XL > ZEROL_VALUE /*0.0*/) RETVAL_HUGEL;
        else RETVAL_NEG_HUGEL;
      }
      else
      {
        if (INPUT_XL > ZEROL_VALUE /*0.0*/) RETVAL_HUGE_VALL;
        else RETVAL_NEG_HUGE_VALL;
      }
      NOT_MATHERRL {ERRNO_RANGE;}
      *(long double *)retval = excl.retval;
      break;
   }
 case sinh_overflow:
   /* sinh overflow */
   {
      OVERFLOWD; NAMED = (char *) "sinh";
      ifSVID
      {
        if (INPUT_XD > ZEROD_VALUE /*0.0*/) RETVAL_HUGED;
        else RETVAL_NEG_HUGED;
      }
      else
      {
        if (INPUT_XD > ZEROD_VALUE /*0.0*/) RETVAL_HUGE_VALD;
        else RETVAL_NEG_HUGE_VALD;
      }
      NOT_MATHERRD {ERRNO_RANGE;}
      *(double *)retval = exc.retval;
      break;
   }
 case sinhf_overflow:
   /* sinhf overflow */
   {
      OVERFLOWF; NAMEF = (char *) "sinhf";
      ifSVID
      {
        if (INPUT_XF > ZEROF_VALUE /*0.0*/) RETVAL_HUGEF;
        else RETVAL_NEG_HUGEF;
      }
      else
      {
        if (INPUT_XF > ZEROF_VALUE /*0.0*/) RETVAL_HUGE_VALF;
        else RETVAL_NEG_HUGE_VALF;
      }
      NOT_MATHERRF {ERRNO_RANGE;}
      *(float *)retval = excf.retval;
      break;
   }
  case acoshl_lt_one:
    /* acoshl(x < 1) */
    {
       DOMAINL; NAMEL = (char *) "acoshl";
       ifSVID
       {
         NOT_MATHERRL
         {
           WRITEL_ACOSH;
           ERRNO_DOMAIN;
         }
       }
       else
       {
           NOT_MATHERRL {ERRNO_DOMAIN;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case acosh_lt_one:
    /* acosh(x < 1) */
    {
       DOMAIND; NAMED = (char *) "acosh";
       ifSVID
       {
         NOT_MATHERRD
         {
          WRITED_ACOSH;
          ERRNO_DOMAIN;
         }
       }
       else
       {
          NOT_MATHERRD {ERRNO_DOMAIN;}
       }
       *(double *)retval = exc.retval;
       break;
    }
  case acoshf_lt_one:
    /* acoshf(x < 1) */
    {
       DOMAINF; NAMEF = (char *) "acoshf";
       ifSVID
       {
         NOT_MATHERRF
         {
           WRITEF_ACOSH;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         NOT_MATHERRF {ERRNO_DOMAIN;}
       }
       *(float *)retval = excf.retval;
       break;
    }
  case atanhl_gt_one:
    /* atanhl(|x| > 1) */
    {
       DOMAINL; NAMEL = (char *) "atanhl";
       ifSVID
       {
         NOT_MATHERRL
         {
           WRITEL_ATANH_GT_ONE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         NOT_MATHERRL {ERRNO_DOMAIN;}
       }
       break;
    }
  case atanh_gt_one:
    /* atanh(|x| > 1) */
    {
       DOMAIND; NAMED = (char *) "atanh";
       ifSVID
       {
         NOT_MATHERRD
         {
           WRITED_ATANH_GT_ONE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         NOT_MATHERRD {ERRNO_DOMAIN;}
       }
       break;
    }
  case atanhf_gt_one:
    /* atanhf(|x| > 1) */
    {
       DOMAINF; NAMEF = (char *) "atanhf";
       ifSVID
       {
         NOT_MATHERRF
         {
           WRITEF_ATANH_GT_ONE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         NOT_MATHERRF {ERRNO_DOMAIN;}
       }
       break;
    }
  case atanhl_eq_one:
    /* atanhl(|x| == 1) */
    {
       SINGL; NAMEL = (char *) "atanhl";
       ifSVID
       {
         NOT_MATHERRL
         {
           WRITEL_ATANH_EQ_ONE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         NOT_MATHERRL {ERRNO_DOMAIN;}
       }
       break;
    }
  case atanh_eq_one:
    /* atanh(|x| == 1) */
    {
       SINGD; NAMED = (char *) "atanh";
       ifSVID
       {
         NOT_MATHERRD
         {
           WRITED_ATANH_EQ_ONE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
       NOT_MATHERRD {ERRNO_DOMAIN;}
       }
       break;
    }
  case atanhf_eq_one:
    /* atanhf(|x| == 1) */
    {
       SINGF; NAMEF = (char *) "atanhf";
       ifSVID
       {
         NOT_MATHERRF
         {
           WRITEF_ATANH_EQ_ONE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         NOT_MATHERRF {ERRNO_DOMAIN;}
       }
       break;
    }
  case gammal_overflow:
    /* gammal overflow */
    {
       OVERFLOWL; NAMEL = (char *) "gammal";
       ifSVID
       {
         RETVAL_HUGEL;
       }
       else
       {
         RETVAL_HUGE_VALL;
       }
       NOT_MATHERRL {ERRNO_RANGE;}
       *(long double *)retval = excl.retval;
       break;
    }
  case gamma_overflow:
    /* gamma overflow */
    {
       OVERFLOWD; NAMED = (char *) "gamma";
       ifSVID
       {
         RETVAL_HUGED;
       }
         else
       {
         RETVAL_HUGE_VALD;
       }
       NOT_MATHERRD {ERRNO_RANGE;}
       *(double *)retval = exc.retval;
       break;
    }
  case gammaf_overflow:
    /* gammaf overflow */
    {
       OVERFLOWF; NAMEF = (char *) "gammaf";
       ifSVID
       {
         RETVAL_HUGEF;
       }
       else
       {
         RETVAL_HUGE_VALF;
       }
       NOT_MATHERRF {ERRNO_RANGE;}
       *(float *)retval = excf.retval;
       break;
    }
  case gammal_negative:
    /* gammal -int or 0 */
    {
       SINGL; NAMEL = (char *) "gammal";
       ifSVID
       {
         RETVAL_HUGEL;
         NOT_MATHERRL
         {
            WRITEL_GAMMA_NEGATIVE;
            ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_HUGE_VALL;
         NOT_MATHERRL {ERRNO_DOMAIN;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case gamma_negative:
    /* gamma -int or 0 */
    {
       SINGD; NAMED = (char *) "gamma";
       ifSVID
       {
         RETVAL_HUGED;
         NOT_MATHERRD
         {
            WRITED_GAMMA_NEGATIVE;
            ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_HUGE_VALD;
         NOT_MATHERRD {ERRNO_DOMAIN;}
       }
       *(double *)retval = exc.retval;
       break;
    }
  case gammaf_negative:
    /* gammaf -int or 0 */
    {
       SINGF; NAMEF = (char *) "gammaf";
       ifSVID
       {
         RETVAL_HUGEF;
         NOT_MATHERRF
         {
            WRITEF_GAMMA_NEGATIVE;
            ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_HUGE_VALF;
         NOT_MATHERRF {ERRNO_DOMAIN;}
       }
       *(float *)retval = excf.retval;
       break;
    }
  case lgammal_overflow:
    /* lgammal overflow */
    {
       OVERFLOWL; NAMEL = (char *) "lgammal";
       ifSVID
       {
         RETVAL_HUGEL;
       }
       else
       {
         RETVAL_HUGE_VALL;
       }
       NOT_MATHERRL {ERRNO_RANGE;}
       *(long double *)retval = excl.retval;
       break;
    }
  case lgamma_overflow:
    /* lgamma overflow */
    {
       OVERFLOWD; NAMED = (char *) "lgamma";
       ifSVID
       {
         RETVAL_HUGED;
       }
       else
       {
         RETVAL_HUGE_VALD;
       }
       NOT_MATHERRD {ERRNO_RANGE;}
       *(double *)retval = exc.retval;
       break;
    }
  case lgammaf_overflow:
    /* lgammaf overflow */
    {
       OVERFLOWF; NAMEF = (char *) "lgammaf";
       ifSVID
       {
         RETVAL_HUGEF;
       }
       else
       {
         RETVAL_HUGE_VALF;
       }
       NOT_MATHERRF {ERRNO_RANGE;}
       *(float *)retval = excf.retval;
       break;
    }
  case lgammal_negative:
    /* lgammal -int or 0 */
    {
       SINGL; NAMEL = (char *) "lgammal";
       ifSVID
       {
         RETVAL_HUGEL;
         NOT_MATHERRL
         {
           WRITEL_LGAMMA_NEGATIVE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_HUGE_VALL;
         NOT_MATHERRL {ERRNO_DOMAIN;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case lgamma_negative:
    /* lgamma -int or 0 */
    {
       SINGD; NAMED = (char *) "lgamma";
       ifSVID
       {
         RETVAL_HUGED;
         NOT_MATHERRD
         {
           WRITED_LGAMMA_NEGATIVE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_HUGE_VALD;
         NOT_MATHERRD {ERRNO_DOMAIN;}
       }
       *(double *)retval = exc.retval;
       break;
    }
  case lgammaf_negative:
    /* lgammaf -int or 0 */
    {
       SINGF; NAMEF = (char *) "lgammaf";
       ifSVID
       {
         RETVAL_HUGEF;
         NOT_MATHERRF
         {
           WRITEF_LGAMMA_NEGATIVE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_HUGE_VALF;
         NOT_MATHERRF {ERRNO_DOMAIN;}
       }
       *(float *)retval = excf.retval;
       break;
    }
  case tgammal_overflow:
    /* tgammal overflow */
    {
       OVERFLOWL; NAMEL = (char *) "tgammal";
       ifSVID
       {
         RETVAL_HUGEL;
       }
       else
       {
         RETVAL_HUGE_VALL;
       }
       NOT_MATHERRL {ERRNO_RANGE;}
       *(long double *)retval = excl.retval;
       break;
    }
  case tgamma_overflow:
    /* tgamma overflow */
    {
       OVERFLOWD; NAMED = (char *) "tgamma";
       ifSVID
       {
         RETVAL_HUGED;
       }
       else
       {
         RETVAL_HUGE_VALD;
       }
       NOT_MATHERRD {ERRNO_RANGE;}
       *(double *)retval = exc.retval;
       break;
    }
  case tgammaf_overflow:
    /* tgammaf overflow */
    {
       OVERFLOWF; NAMEF = (char *) "tgammaf";
       ifSVID
       {
         RETVAL_HUGEF;
       }
       else
       {
         RETVAL_HUGE_VALF;
       }
       NOT_MATHERRF {ERRNO_RANGE;}
       *(float *)retval = excf.retval;
       break;
    }
  case tgammal_negative:
    /* tgammal -int or 0 */
    {
       SINGL; NAMEL = (char *) "tgammal";
       ifSVID
       {
         NOT_MATHERRL
         {
           WRITEL_TGAMMA_NEGATIVE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         NOT_MATHERRL {ERRNO_DOMAIN;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case tgamma_negative:
    /* tgamma -int or 0 */
    {
       SINGD; NAMED = (char *) "tgamma";
       ifSVID
       {
         NOT_MATHERRD
         {
           WRITED_TGAMMA_NEGATIVE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         NOT_MATHERRD {ERRNO_DOMAIN;}
       }
       *(double *)retval = exc.retval;
       break;
    }
  case tgammaf_negative:
    /* tgammaf -int or 0 */
    {
       SINGF; NAMEF = (char *) "tgammaf";
       ifSVID
       {
         NOT_MATHERRF
         {
           WRITEF_TGAMMA_NEGATIVE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         NOT_MATHERRF {ERRNO_DOMAIN;}
       }
       *(float *)retval = excf.retval;
       break;
    }
  case j0l_gt_loss:
    /* j0l > loss */
    {
       TLOSSL; NAMEL = (char *) "j0l";
       RETVAL_ZEROL;
       ifSVID
       {
         NOT_MATHERRL
         {
            WRITEL_J0_TLOSS;
            ERRNO_RANGE;
         }
       }
       else
       {
         NOT_MATHERRL {ERRNO_RANGE;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case j0_gt_loss:
    /* j0 > loss */
    {
       TLOSSD; NAMED = (char *) "j0";
       RETVAL_ZEROD;
       ifSVID
       {
         NOT_MATHERRD
         {
            WRITED_J0_TLOSS;
            ERRNO_RANGE;
         }
       }
       else
       {
         NOT_MATHERRD {ERRNO_RANGE;}
       }
       *(double*)retval = exc.retval;
       break;
    }
  case j0f_gt_loss:
    /* j0f > loss */
    {
       TLOSSF; NAMEF = (char *) "j0f";
       RETVAL_ZEROF;
       ifSVID
       {
         NOT_MATHERRF
         {
            WRITEF_J0_TLOSS;
            ERRNO_RANGE;
         }
       }
       else
       {
         NOT_MATHERRF {ERRNO_RANGE;}
       }
       *(float*)retval = excf.retval;
       break;
    }
  case j1l_gt_loss:
    /* j1l > loss */
    {
       TLOSSL; NAMEL = (char *) "j1l";
       RETVAL_ZEROL;
       ifSVID
       {
         NOT_MATHERRL
         {
            WRITEL_J1_TLOSS;
            ERRNO_RANGE;
         }
       }
       else
       {
         NOT_MATHERRL {ERRNO_RANGE;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case j1_gt_loss:
    /* j1 > loss */
    {
       TLOSSD; NAMED = (char *) "j1";
       RETVAL_ZEROD;
       ifSVID
       {
         NOT_MATHERRD
         {
            WRITED_J1_TLOSS;
            ERRNO_RANGE;
         }
       }
       else
       {
         NOT_MATHERRD {ERRNO_RANGE;}
       }
       *(double*)retval = exc.retval;
       break;
    }
  case j1f_gt_loss:
    /* j1f > loss */
    {
       TLOSSF; NAMEF = (char *) "j1f";
       RETVAL_ZEROF;
       ifSVID
       {
         NOT_MATHERRF
         {
            WRITEF_J1_TLOSS;
            ERRNO_RANGE;
         }
       }
       else
       {
         NOT_MATHERRF {ERRNO_RANGE;}
       }
       *(float*)retval = excf.retval;
       break;
    }
  case jnl_gt_loss:
    /* jnl > loss */
    {
       TLOSSL; NAMEL = (char *) "jnl";
       RETVAL_ZEROL;
       ifSVID
       {
         NOT_MATHERRL
         {
            WRITEL_JN_TLOSS;
            ERRNO_RANGE;
         }
       }
       else
       {
         NOT_MATHERRL {ERRNO_RANGE;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case jn_gt_loss:
    /* jn > loss */
    {
       TLOSSD; NAMED = (char *) "jn";
       RETVAL_ZEROD;
       ifSVID
       {
         NOT_MATHERRD
         {
            WRITED_JN_TLOSS;
            ERRNO_RANGE;
         }
       }
       else
       {
         NOT_MATHERRD {ERRNO_RANGE;}
       }
       *(double*)retval = exc.retval;
       break;
    }
  case jnf_gt_loss:
    /* jnf > loss */
    {
       TLOSSF; NAMEF = (char *) "jnf";
       RETVAL_ZEROF;
       ifSVID
       {
         NOT_MATHERRF
         {
            WRITEF_JN_TLOSS;
            ERRNO_RANGE;
         }
       }
       else
       {
         NOT_MATHERRF {ERRNO_RANGE;}
       }
       *(float*)retval = excf.retval;
       break;
    }
  case y0l_gt_loss:
    /* y0l > loss */
    {
       TLOSSL; NAMEL = (char *) "y0l";
       RETVAL_ZEROL;
       ifSVID
       {
         NOT_MATHERRL
         {
            WRITEL_Y0_TLOSS;
            ERRNO_RANGE;
         }
       }
       else
       {
         NOT_MATHERRL {ERRNO_RANGE;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case y0_gt_loss:
    /* y0 > loss */
    {
       TLOSSD; NAMED = (char *) "y0";
       RETVAL_ZEROD;
       ifSVID
       {
         NOT_MATHERRD
         {
            WRITED_Y0_TLOSS;
            ERRNO_RANGE;
         }
       }
       else
       {
         NOT_MATHERRD {ERRNO_RANGE;}
       }
       *(double*)retval = exc.retval;
       break;
    }
  case y0f_gt_loss:
    /* y0f > loss */
    {
       TLOSSF; NAMEF = (char *) "y0f";
       RETVAL_ZEROF;
       ifSVID
       {
         NOT_MATHERRF
         {
            WRITEF_Y0_TLOSS;
            ERRNO_RANGE;
         }
       }
       else
       {
         NOT_MATHERRF {ERRNO_RANGE;}
       }
       *(float*)retval = excf.retval;
       break;
    }
  case y0l_zero:
    /* y0l(0) */
    {
       DOMAINL; NAMEL = (char *) "y0l";
       ifSVID
       {
         RETVAL_NEG_HUGEL;
         NOT_MATHERRL
         {
           WRITEL_Y0_ZERO;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALL;
         NOT_MATHERRL {ERRNO_DOMAIN;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case y0_zero:
    /* y0(0) */
    {
       DOMAIND; NAMED = (char *) "y0";
       ifSVID
       {
         RETVAL_NEG_HUGED;
         NOT_MATHERRD
         {
           WRITED_Y0_ZERO;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALD;
         NOT_MATHERRD {ERRNO_DOMAIN;}
       }
       *(double *)retval = exc.retval;
       break;
    }
  case y0f_zero:
    /* y0f(0) */
    {
       DOMAINF; NAMEF = (char *) "y0f";
       ifSVID
       {
         RETVAL_NEG_HUGEF;
         NOT_MATHERRF
         {
           WRITEF_Y0_ZERO;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALF;
         NOT_MATHERRF {ERRNO_DOMAIN;}
       }
       *(float *)retval = excf.retval;
       break;
    }
  case y1l_gt_loss:
    /* y1l > loss */
    {
       TLOSSL; NAMEL = (char *) "y1l";
       RETVAL_ZEROL;
       ifSVID
       {
         NOT_MATHERRL
         {
            WRITEL_Y1_TLOSS;
            ERRNO_RANGE;
         }
       }
       else
       {
         NOT_MATHERRL {ERRNO_RANGE;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case y1_gt_loss:
    /* y1 > loss */
    {
       TLOSSD; NAMED = (char *) "y1";
       RETVAL_ZEROD;
       ifSVID
       {
         NOT_MATHERRD
         {
            WRITED_Y1_TLOSS;
            ERRNO_RANGE;
         }
       }
       else
       {
         NOT_MATHERRD {ERRNO_RANGE;}
       }
       *(double*)retval = exc.retval;
       break;
    }
  case y1f_gt_loss:
    /* y1f > loss */
    {
       TLOSSF; NAMEF = (char *) "y1f";
       RETVAL_ZEROF;
       ifSVID
       {
         NOT_MATHERRF
         {
            WRITEF_Y1_TLOSS;
            ERRNO_RANGE;
         }
       }
       else
       {
         NOT_MATHERRF {ERRNO_RANGE;}
       }
       *(float*)retval = excf.retval;
       break;
    }
  case y1l_zero:
    /* y1l(0) */
    {
       DOMAINL; NAMEL = (char *) "y1l";
       ifSVID
       {
         RETVAL_NEG_HUGEL;
         NOT_MATHERRL
         {
           WRITEL_Y1_ZERO;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALL;
         NOT_MATHERRL {ERRNO_DOMAIN;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case y1_zero:
    /* y1(0) */
    {
       DOMAIND; NAMED = (char *) "y1";
       ifSVID
       {
         RETVAL_NEG_HUGED;
         NOT_MATHERRD
         {
           WRITED_Y1_ZERO;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALD;
         NOT_MATHERRD {ERRNO_DOMAIN;}
       }
       *(double *)retval = exc.retval;
       break;
    }
  case y1f_zero:
    /* y1f(0) */
    {
       DOMAINF; NAMEF = (char *) "y1f";
       ifSVID
       {
         RETVAL_NEG_HUGEF;
         NOT_MATHERRF
         {
           WRITEF_Y1_ZERO;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALF;
         NOT_MATHERRF {ERRNO_DOMAIN;}
       }
       *(float *)retval = excf.retval;
       break;
    }
  case ynl_gt_loss:
    /* ynl > loss */
    {
       TLOSSL; NAMEL = (char *) "ynl";
       RETVAL_ZEROL;
       ifSVID
       {
         NOT_MATHERRL
         {
            WRITEL_YN_TLOSS;
            ERRNO_RANGE;
         }
       }
       else
       {
         NOT_MATHERRL {ERRNO_RANGE;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case yn_gt_loss:
    /* yn > loss */
    {
       TLOSSD; NAMED = (char *) "yn";
       RETVAL_ZEROD;
       ifSVID
       {
         NOT_MATHERRD
         {
            WRITED_YN_TLOSS;
            ERRNO_RANGE;
         }
       }
       else
       {
         NOT_MATHERRD {ERRNO_RANGE;}
       }
       *(double*)retval = exc.retval;
       break;
    }
  case ynf_gt_loss:
    /* ynf > loss */
    {
       TLOSSF; NAMEF = (char *) "ynf";
       RETVAL_ZEROF;
       ifSVID
       {
         NOT_MATHERRF
         {
            WRITEF_YN_TLOSS;
            ERRNO_RANGE;
         }
       }
       else
       {
         NOT_MATHERRF {ERRNO_RANGE;}
       }
       *(float*)retval = excf.retval;
       break;
    }
  case ynl_zero:
    /* ynl(0) */
    {
       DOMAINL; NAMEL = (char *) "ynl";
       ifSVID
       {
         RETVAL_NEG_HUGEL;
         NOT_MATHERRL
         {
           WRITEL_YN_ZERO;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALL;
         NOT_MATHERRL {ERRNO_DOMAIN;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case yn_zero:
    /* yn(0) */
    {
       DOMAIND; NAMED = (char *) "yn";
       ifSVID
       {
         RETVAL_NEG_HUGED;
         NOT_MATHERRD
         {
           WRITED_YN_ZERO;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALD;
         NOT_MATHERRD {ERRNO_DOMAIN;}
       }
       *(double *)retval = exc.retval;
       break;
    }
  case ynf_zero:
    /* ynf(0) */
    {
       DOMAINF; NAMEF = (char *) "ynf";
       ifSVID
       {
         RETVAL_NEG_HUGEF;
         NOT_MATHERRF
         {
           WRITEF_YN_ZERO;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALF;
         NOT_MATHERRF {ERRNO_DOMAIN;}
       }
       *(float *)retval = excf.retval;
       break;
    }
  case y0l_negative:
    /* y0l(x<0) */
    {
       DOMAINL; NAMEL = (char *) "y0l";
       ifSVID
       {
         RETVAL_NEG_HUGEL;
         NOT_MATHERRL
         {
           WRITEL_Y0_NEGATIVE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALL;
         NOT_MATHERRL {ERRNO_DOMAIN;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case y0_negative:
    /* y0(x<0) */
    {
       DOMAIND; NAMED = (char *) "y0";
       ifSVID
       {
         RETVAL_NEG_HUGED;
         NOT_MATHERRD
         {
           WRITED_Y0_NEGATIVE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALD;
         NOT_MATHERRD {ERRNO_DOMAIN;}
       }
       *(double *)retval = exc.retval;
       break;
    }
  case y0f_negative:
    /* y0f(x<0) */
    {
       DOMAINF; NAMEF = (char *) "y0f";
       ifSVID
       {
         RETVAL_NEG_HUGEF;
         NOT_MATHERRF
         {
           WRITEF_Y0_NEGATIVE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALF;
         NOT_MATHERRF {ERRNO_DOMAIN;}
       }
       *(float *)retval = excf.retval;
       break;
    }
  case y1l_negative:
    /* y1l(x<0) */
    {
       DOMAINL; NAMEL = (char *) "y1l";
       ifSVID
       {
         RETVAL_NEG_HUGEL;
         NOT_MATHERRL
         {
           WRITEL_Y1_NEGATIVE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALL;
         NOT_MATHERRL {ERRNO_DOMAIN;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case y1_negative:
    /* y1(x<0) */
    {
       DOMAIND; NAMED = (char *) "y1";
       ifSVID
       {
         RETVAL_NEG_HUGED;
         NOT_MATHERRD
         {
           WRITED_Y1_NEGATIVE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALD;
         NOT_MATHERRD {ERRNO_DOMAIN;}
       }
       *(double *)retval = exc.retval;
       break;
    }
  case y1f_negative:
    /* y1f(x<0) */
    {
       DOMAINF; NAMEF = (char *) "y1f";
       ifSVID
       {
         RETVAL_NEG_HUGEF;
         NOT_MATHERRF
         {
           WRITEF_Y1_NEGATIVE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALF;
         NOT_MATHERRF {ERRNO_DOMAIN;}
       }
       *(float *)retval = excf.retval;
       break;
    }
  case ynl_negative:
    /* ynl(x<0) */
    {
       DOMAINL; NAMEL = (char *) "ynl";
       ifSVID
       {
         RETVAL_NEG_HUGEL;
         NOT_MATHERRL
         {
          WRITEL_YN_NEGATIVE;
          ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALL;
         NOT_MATHERRL {ERRNO_DOMAIN;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case yn_negative:
    /* yn(x<0) */
    {
       DOMAIND; NAMED = (char *) "yn";
       ifSVID
       {
         RETVAL_NEG_HUGED;
         NOT_MATHERRD
         {
           WRITED_YN_NEGATIVE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALD;
         NOT_MATHERRD {ERRNO_DOMAIN;}
       }
       *(double *)retval = exc.retval;
       break;
    }
  case ynf_negative:
    /* ynf(x<0) */
    {
       DOMAINF; NAMEF = (char *) "ynf";
       ifSVID
       {
         RETVAL_NEG_HUGEF;
         NOT_MATHERRF
         {
           WRITEF_YN_NEGATIVE;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         RETVAL_NEG_HUGE_VALF;
         NOT_MATHERRF {ERRNO_DOMAIN;}
       }
       *(float *)retval = excf.retval;
       break;
    }
  case fmodl_by_zero:
    /* fmodl(x,0) */
    {
       DOMAINL; NAMEL = (char *) "fmodl";
       ifSVID
       {
            *(long double *)retval = *(long double *)arg1;
            NOT_MATHERRL
            {
              WRITEL_FMOD;
              ERRNO_DOMAIN;
            }
       }
       else
       { /* NaN already computed */
            NOT_MATHERRL {ERRNO_DOMAIN;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case fmod_by_zero:
    /* fmod(x,0) */
    {
       DOMAIND; NAMED = (char *) "fmod";
       ifSVID
       {
         *(double *)retval = *(double *)arg1;
         NOT_MATHERRD
         {
           WRITED_FMOD;
           ERRNO_DOMAIN;
         }
       }
       else
       { /* NaN already computed */
         NOT_MATHERRD {ERRNO_DOMAIN;}
       }
       *(double *)retval = exc.retval;
       break;
    }
  case fmodf_by_zero:
    /* fmodf(x,0) */
    {
       DOMAINF; NAMEF = (char *) "fmodf";
       ifSVID
       {
         *(float *)retval = *(float *)arg1;
         NOT_MATHERRF
         {
           WRITEF_FMOD;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         NOT_MATHERRF {ERRNO_DOMAIN;}
       }
       *(float *)retval = excf.retval;
       break;
    }
  case remainderl_by_zero:
    /* remainderl(x,0) */
    {
       DOMAINL; NAMEL = (char *) "remainderl";
       ifSVID
       {
          NOT_MATHERRL
          {
            WRITEL_REM;
            ERRNO_DOMAIN;
          }
       }
       else
       { /* NaN already computed */
            NOT_MATHERRL {ERRNO_DOMAIN;}
       }
       *(long double *)retval = excl.retval;
       break;
    }
  case remainder_by_zero:
    /* remainder(x,0) */
    {
       DOMAIND; NAMED = (char *) "remainder";
       ifSVID
       {
         NOT_MATHERRD
         {
           WRITED_REM;
           ERRNO_DOMAIN;
         }
       }
       else
       { /* NaN already computed */
         NOT_MATHERRD {ERRNO_DOMAIN;}
       }
       *(double *)retval = exc.retval;
       break;
    }
  case remainderf_by_zero:
    /* remainderf(x,0) */
    {
       DOMAINF; NAMEF = (char *) "remainderf";
       ifSVID
       {
         NOT_MATHERRF
         {
           WRITEF_REM;
           ERRNO_DOMAIN;
         }
       }
       else
       {
         NOT_MATHERRF {ERRNO_DOMAIN;}
       }
       *(float *)retval = excf.retval;
       break;
    }
  default:
    /* We don't want to abort () since SVID doesn't cover all math
       library functions.  */
    break;
   }
   return;
   }
}
void __libm_setusermatherr ( int(*)(struct EXC_DECL_D *)  user_merr)

Definition at line 123 of file libm_error.c.

{   pmatherr = ( (user_merr==NULL)? (MATHERR_D) : (user_merr) );    }

Here is the call graph for this function:

void __libm_setusermatherrf ( int(*)(struct exceptionf *)  user_merrf)

Definition at line 120 of file libm_error.c.

{   pmatherrf = ( (user_merrf==NULL)? (MATHERR_F) : (user_merrf) ); }

Here is the call graph for this function:

void __libm_setusermatherrl ( int(*)(struct exceptionl *)  user_merrl)

Definition at line 126 of file libm_error.c.

{   pmatherrl = ( (user_merrl==NULL)? (matherrl) : (user_merrl) );  }

Here is the call graph for this function:


Variable Documentation

Definition at line 110 of file libm_error.c.

int(* pmatherr)(struct EXC_DECL_D *) = MATHERR_D

Definition at line 117 of file libm_error.c.

Definition at line 116 of file libm_error.c.

int(* pmatherrl)(struct exceptionl *) = matherrl

Definition at line 118 of file libm_error.c.