]> git.ipfire.org Git - thirdparty/glibc.git/blame - sysdeps/ia64/fpu/libm_error.c
projects / thirdparty / glibc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Obsolete matherr, _LIB_VERSION, libieee.a.
[thirdparty/glibc.git] / sysdeps / ia64 / fpu / libm_error.c
CommitLineData
d5efd131
MF		 1/* file: libm_error.c */
2
3
4// Copyright (c) 2000 - 2005, Intel Corporation
5// All rights reserved.
6//
7// Contributed 2000 by the Intel Numerics Group, Intel Corporation
8//
9// Redistribution and use in source and binary forms, with or without
10// modification, are permitted provided that the following conditions are
11// met:
12//
13// * Redistributions of source code must retain the above copyright
14// notice, this list of conditions and the following disclaimer.
15//
16// * Redistributions in binary form must reproduce the above copyright
17// notice, this list of conditions and the following disclaimer in the
18// documentation and/or other materials provided with the distribution.
19//
20// * The name of Intel Corporation may not be used to endorse or promote
21// products derived from this software without specific prior written
22// permission.
23
24//
25// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
26// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
27// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
28// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL OR ITS
29// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
30// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
32// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
33// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR TORT (INCLUDING
34// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36//
37// Intel Corporation is the author of this code, and requests that all
38// problem reports or change requests be submitted to it directly at
39// http://www.intel.com/software/products/opensource/libraries/num.htm.
40//
41// History
42//==============================================================
43// 2/02/00: Initial version
44// 3/22/00: Updated to support flexible and dynamic error handling.
45// 8/16/00: Changed all matherr function-calls to use the pmatherr
46// function-pointers.
47// 10/03/00: Corrected a scalb type.
48// 11/28/00: Changed INPUT_XL to INPUT_XD for scalb_underflow case.
49// 12/07/00: Added code to make scalbn error support equivalent to ldexp.
50// 2/07/01: Added __declspec(align(16)) to long double constants to correct
51// alignment problem.
52// 4/23/01: Added code for remquo
53// 6/07/01: Added code for fdim, lrint, lround, llrint, llround
54// Deleted code for remquo
55// 8/15/01: Added code for scalbln, nexttoward
56// 12/10/01: Added code for erfc
57// 12/27/01: Added code for degree argument functions
58// 01/02/02: Added code for tand, cotd
59// 01/15/02: Corrected SVID/XOPEN code for log1p, pow, and acosh
60// 01/25/02: Corrected ISOC for lgamma and gamma to return EDOM for neg ints
61// 01/28/02: Corrected SVID/XOPEN stderr message for log2
62// 05/20/02: Added code for cot
63// 07/01/02: Added code for sinhcosh
64// 10/04/02: Underflow detection in ISOC path redefined to
65// be zero rather than tiny and inexact
66// 12/06/02: Added code for annuity and compound
67// 01/30/03: Corrected test for underflow in ISOC path to not set denormal
68// 04/10/03: Corrected ISOC branch for gamma/lgamma to return ERANGE for neg ints.
69// Added code for tgamma
70// 04/11/03: Corrected POSIX/SVID/XOPEN branches for gamma/lgamma
71// to return EDOM for neg ints.
72// 09/08/03: Corrected XOPEN/SVID result for pow overflow with neg x, pos y.
73// 10/14/03: Added ILP32 ifdef
74// 12/12/03: Corrected XOPEN/SVID results for powf_zero_to_negative,
75// powl_neg_to_non_integer, atan2f_zero, atan2df_zero,
76// acoshf_lt_one, acosh_lt_one.
77// 12/07/04: Cast name strings as char *.
78// 12/08/04: Corrected POSIX behavior for atan2_zero, acos_gt_one, asin_gt_one,
79// log_negative, log10_negative, log1p_negative, and log2_negative.
80// Added SVID and XOPEN case log2l_zero.
81// 12/13/04: Corrected POSIX behavior for exp2_overflow, exp2_underflow,
82// exp10_overflow, exp10_underflow. Added ISOC to set errno for
83// exp10_underflow.
84// 12/14/04: Corrected POSIX behavior for nextafter_overflow,
85// nextafter_underflow, nexttoward_overflow, nexttoward_underflow.
86// Added ISOC to set errno for nextafter and nexttoward underflow.
87// 12/15/04: Corrected POSIX behavior for exp, exp2, and exp10 underflow.
88// 03/31/05: Added missing ALIGNIT statement to 6 float constants.
89
90#include <errno.h>
91#include <stdio.h>
92#include <stdlib.h>
93#include "libm_support.h"
813378e9 94#include <math-svid-compat.h>
d5efd131
MF		 95
96#ifdef _LIBC
97# define pmatherr matherr
98# define pmatherrf matherrf
99# define pmatherrl matherrl
813378e9
JM		 100# if LIBM_SVID_COMPAT
101compat_symbol_reference (libm, matherrf, matherrf, GLIBC_2_2_3);
102compat_symbol_reference (libm, matherrl, matherrl, GLIBC_2_2_3);
103# else
104# define matherrf(EXC) ((void) (EXC), 0)
105# define matherrl(EXC) ((void) (EXC), 0)
106# endif
d5efd131
MF		 107#else
108_LIB_VERSION_TYPE
109#if defined( __POSIX__ )
110_LIB_VERSIONIMF = _POSIX_;
111#elif defined( __XOPEN__ )
112_LIB_VERSIONIMF = _XOPEN_;
113#elif defined( __SVID__ )
114_LIB_VERSIONIMF = _SVID_;
115#elif defined( __IEEE__ )
116_LIB_VERSIONIMF = _IEEE_;
117#else
118_LIB_VERSIONIMF = _ISOC_;
119#endif
120
121/************************************************************/
122/* matherrX function pointers and setusermatherrX functions */
123/************************************************************/
124int (*pmatherrf)(struct exceptionf*) = MATHERR_F;
125int (*pmatherr)(struct EXC_DECL_D*) = MATHERR_D;
126int (*pmatherrl)(struct exceptionl*) = matherrl;
127
128void __libm_setusermatherrf( int(*user_merrf)(struct exceptionf*) )
129{ pmatherrf = ( (user_merrf==NULL)? (MATHERR_F) : (user_merrf) ); }
130
131void __libm_setusermatherr( int(*user_merr)(struct EXC_DECL_D*) )
132{ pmatherr = ( (user_merr==NULL)? (MATHERR_D) : (user_merr) ); }
133
134void __libm_setusermatherrl( int(*user_merrl)(struct exceptionl*) )
135{ pmatherrl = ( (user_merrl==NULL)? (matherrl) : (user_merrl) ); }
136
137#endif /* !_LIBC */
138
139/***********************************************/
140/* error-handling function, libm_error_support */
141/***********************************************/
142void __libm_error_support(void *arg1,void *arg2,void *retval,error_types input_tag)
143{
144
145# ifdef __cplusplus
146struct __exception exc;
147# else
148struct exception exc;
149# endif
150
151struct exceptionf excf;
152struct exceptionl excl;
153
154# ifdef __GNUC__
155#define ALIGNIT __attribute__ ((__aligned__ (16)))
156# elif defined opensource
157#define ALIGNIT
158# else
159#define ALIGNIT __declspec(align(16))
160# endif
161
162# ifdef SIZE_LONG_INT_64
163#define __INT_64__ signed long
164# else
165# if ILP32
166#define __INT_64__ signed long long
167# else
168#define __INT_64__ __int64
169# endif
170# endif
171
172
a186dc91
MF		 173#define _DECL_NUM(type, prefix, var, bytes...) \
174 ALIGNIT static const union { \
175 const char _bytes[sizeof (type)]; \
176 const type num; \
177 } prefix ## var = { \
178 ._bytes = bytes, \
179 }
180
181#define DECL_FLOAT(var, bytes...) \
182 _DECL_NUM (float, float_, var, ##bytes)
183
184DECL_FLOAT(inf, {0x00,0x00,0x80,0x7F});
185DECL_FLOAT(huge, {0xFF,0xFF,0x7F,0x7F});
186DECL_FLOAT(zero, {0x00,0x00,0x00,0x00});
187DECL_FLOAT(neg_inf, {0x00,0x00,0x80,0xFF});
188DECL_FLOAT(neg_huge, {0xFF,0xFF,0x7F,0xFF});
189DECL_FLOAT(neg_zero, {0x00,0x00,0x00,0x80});
190
191#define DECL_DOUBLE(var, bytes...) \
192 _DECL_NUM (double, double_, var, ##bytes)
193
194DECL_DOUBLE(inf, {0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0x7F});
d5efd131 195#ifndef _LIBC
a186dc91 196DECL_DOUBLE(huge, {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xEF,0x7F});
d5efd131 197#endif
a186dc91
MF		 198DECL_DOUBLE(zero, {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00});
199DECL_DOUBLE(neg_inf, {0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0xFF});
d5efd131 200#ifndef _LIBC
a186dc91 201DECL_DOUBLE(neg_huge, {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xEF,0xFF});
d5efd131 202#endif
a186dc91
MF		 203DECL_DOUBLE(neg_zero, {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80});
204
205#define DECL_LONG_DOUBLE(var, bytes...) \
206 _DECL_NUM (long double, long_double_, var, ##bytes)
207
208DECL_LONG_DOUBLE(inf, {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0xFF,0x7F,0x00,0x00,0x00,0x00,0x00,0x00});
d5efd131 209#ifndef _LIBC
a186dc91 210DECL_LONG_DOUBLE(huge, {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0x7F,0x00,0x00,0x00,0x00,0x00,0x00});
d5efd131 211#endif
a186dc91
MF		 212DECL_LONG_DOUBLE(zero, {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00});
213DECL_LONG_DOUBLE(neg_inf, {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0xFF,0xFF,0x00,0x00,0x00,0x00,0x00,0x00});
d5efd131 214#ifndef _LIBC
a186dc91 215DECL_LONG_DOUBLE(neg_huge, {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0xFF,0x00,0x00,0x00,0x00,0x00,0x00});
d5efd131 216#endif
a186dc91 217DECL_LONG_DOUBLE(neg_zero, {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x00,0x00,0x00});
d5efd131
MF		 218
219
a186dc91
MF		 220#define RETVAL_HUGE_VALL *(long double *)retval = long_double_inf.num
221#define RETVAL_NEG_HUGE_VALL *(long double *)retval = long_double_neg_inf.num
222#define RETVAL_HUGEL *(long double *)retval = (long double)float_huge.num
223#define RETVAL_NEG_HUGEL *(long double *)retval = (long double)float_neg_huge.num
d5efd131 224
a186dc91
MF		 225#define RETVAL_HUGE_VALD *(double *)retval = double_inf.num
226#define RETVAL_NEG_HUGE_VALD *(double *)retval = double_neg_inf.num
227#define RETVAL_HUGED *(double *)retval = (double)float_huge.num
228#define RETVAL_NEG_HUGED *(double *)retval = (double)float_neg_huge.num
d5efd131 229
a186dc91
MF		 230#define RETVAL_HUGE_VALF *(float *)retval = float_inf.num
231#define RETVAL_NEG_HUGE_VALF *(float *)retval = float_neg_inf.num
232#define RETVAL_HUGEF *(float *)retval = float_huge.num
233#define RETVAL_NEG_HUGEF *(float *)retval = float_neg_huge.num
d5efd131 234
a186dc91
MF		 235#define ZEROL_VALUE long_double_zero.num
236#define ZEROD_VALUE double_zero.num
237#define ZEROF_VALUE float_zero.num
d5efd131 238
a186dc91
MF		 239#define RETVAL_ZEROL *(long double *)retval = long_double_zero.num
240#define RETVAL_ZEROD *(double *)retval = double_zero.num
241#define RETVAL_ZEROF *(float *)retval = float_zero.num
d5efd131 242
a186dc91
MF		 243#define RETVAL_NEG_ZEROL *(long double *)retval = long_double_neg_zero.num
244#define RETVAL_NEG_ZEROD *(double *)retval = double_neg_zero.num
245#define RETVAL_NEG_ZEROF *(float *)retval = float_neg_zero.num
d5efd131
MF		 246
247#define RETVAL_ONEL *(long double *)retval = (long double) 1.0
248#define RETVAL_ONED *(double *)retval = 1.0
249#define RETVAL_ONEF *(float *)retval = 1.0f
250
251#define NOT_MATHERRL excl.arg1=*(long double *)arg1;excl.arg2=*(long double *)arg2;excl.retval=*(long double *)retval;if(!pmatherrl(&excl))
252#define NOT_MATHERRD exc.arg1=*(double *)arg1;exc.arg2=*(double *)arg2;exc.retval=*(double *)retval;if(!pmatherr(&exc))
253#define NOT_MATHERRF excf.arg1=*(float *)arg1;excf.arg2=*(float *)arg2;excf.retval=*(float *)retval;if(!pmatherrf(&excf))
254
255#define ifSVID if(_LIB_VERSIONIMF==_SVID_)
256
257#define NAMEL excl.name
258#define NAMED exc.name
259#define NAMEF excf.name
260
261//
262// These should work OK for MS because they are ints -
263// leading underbars are not necessary.
264//
265
266#define DOMAIN 1
267#define SING 2
268#define OVERFLOW 3
269#define UNDERFLOW 4
270#define TLOSS 5
271#define PLOSS 6
272
273#define SINGL excl.type = SING
274#define DOMAINL excl.type = DOMAIN
275#define OVERFLOWL excl.type = OVERFLOW
276#define UNDERFLOWL excl.type = UNDERFLOW
277#define TLOSSL excl.type = TLOSS
278#define SINGD exc.type = SING
279#define DOMAIND exc.type = DOMAIN
280#define OVERFLOWD exc.type = OVERFLOW
281#define UNDERFLOWD exc.type = UNDERFLOW
282#define TLOSSD exc.type = TLOSS
283#define SINGF excf.type = SING
284#define DOMAINF excf.type = DOMAIN
285#define OVERFLOWF excf.type = OVERFLOW
286#define UNDERFLOWF excf.type = UNDERFLOW
287#define TLOSSF excf.type = TLOSS
288
289#define INPUT_XL (excl.arg1=*(long double*)arg1)
290#define INPUT_XD (exc.arg1=*(double*)arg1)
291#define INPUT_XF (excf.arg1=*(float*)arg1)
292#define INPUT_YL (excl.arg2=*(long double*)arg2)
293#define INPUT_YD (exc.arg2=*(double*)arg2)
294#define INPUT_YF (excf.arg2=*(float*)arg2)
295#define INPUT_RESL (*(long double *)retval)
296#define INPUT_RESD (*(double *)retval)
297#define INPUT_RESF (*(float *)retval)
298#define INPUT_RESI64 (*(__INT_64__ *)retval)
299
300#define WRITEL_LOG_ZERO fputs("logl: SING error\n",stderr)
301#define WRITED_LOG_ZERO fputs("log: SING error\n",stderr)
302#define WRITEF_LOG_ZERO fputs("logf: SING error\n",stderr)
303#define WRITEL_LOG_NEGATIVE fputs("logl: DOMAIN error\n",stderr)
304#define WRITED_LOG_NEGATIVE fputs("log: DOMAIN error\n",stderr)
305#define WRITEF_LOG_NEGATIVE fputs("logf: DOMAIN error\n",stderr)
306#define WRITEL_Y0_ZERO fputs("y0l: DOMAIN error\n",stderr)
307#define WRITED_Y0_ZERO fputs("y0: DOMAIN error\n",stderr)
308#define WRITEF_Y0_ZERO fputs("y0f: DOMAIN error\n",stderr)
309#define WRITEL_Y0_NEGATIVE fputs("y0l: DOMAIN error\n",stderr)
310#define WRITED_Y0_NEGATIVE fputs("y0: DOMAIN error\n",stderr)
311#define WRITEF_Y0_NEGATIVE fputs("y0f: DOMAIN error\n",stderr)
312#define WRITEL_Y1_ZERO fputs("y1l: DOMAIN error\n",stderr)
313#define WRITED_Y1_ZERO fputs("y1: DOMAIN error\n",stderr)
314#define WRITEF_Y1_ZERO fputs("y1f: DOMAIN error\n",stderr)
315#define WRITEL_Y1_NEGATIVE fputs("y1l: DOMAIN error\n",stderr)
316#define WRITED_Y1_NEGATIVE fputs("y1: DOMAIN error\n",stderr)
317#define WRITEF_Y1_NEGATIVE fputs("y1f: DOMAIN error\n",stderr)
318#define WRITEL_YN_ZERO fputs("ynl: DOMAIN error\n",stderr)
319#define WRITED_YN_ZERO fputs("yn: DOMAIN error\n",stderr)
320#define WRITEF_YN_ZERO fputs("ynf: DOMAIN error\n",stderr)
321#define WRITEL_YN_NEGATIVE fputs("ynl: DOMAIN error\n",stderr)
322#define WRITED_YN_NEGATIVE fputs("yn: DOMAIN error\n",stderr)
323#define WRITEF_YN_NEGATIVE fputs("ynf: DOMAIN error\n",stderr)
324#define WRITEL_LOG1P_ZERO fputs("log1pl: SING error\n",stderr)
325#define WRITED_LOG1P_ZERO fputs("log1p: SING error\n",stderr)
326#define WRITEF_LOG1P_ZERO fputs("log1pf: SING error\n",stderr)
327#define WRITEL_LOG1P_NEGATIVE fputs("log1pl: DOMAIN error\n",stderr)
328#define WRITED_LOG1P_NEGATIVE fputs("log1p: DOMAIN error\n",stderr)
329#define WRITEF_LOG1P_NEGATIVE fputs("log1pf: DOMAIN error\n",stderr)
330#define WRITEL_LOG10_ZERO fputs("log10l: SING error\n",stderr)
331#define WRITED_LOG10_ZERO fputs("log10: SING error\n",stderr)
332#define WRITEF_LOG10_ZERO fputs("log10f: SING error\n",stderr)
333#define WRITEL_LOG10_NEGATIVE fputs("log10l: DOMAIN error\n",stderr)
334#define WRITED_LOG10_NEGATIVE fputs("log10: DOMAIN error\n",stderr)
335#define WRITEF_LOG10_NEGATIVE fputs("log10f: DOMAIN error\n",stderr)
336#define WRITEL_LOG2_ZERO fputs("log2l: SING error\n",stderr)
337#define WRITED_LOG2_ZERO fputs("log2: SING error\n",stderr)
338#define WRITEF_LOG2_ZERO fputs("log2f: SING error\n",stderr)
339#define WRITEL_LOG2_NEGATIVE fputs("log2l: DOMAIN error\n",stderr)
340#define WRITED_LOG2_NEGATIVE fputs("log2: DOMAIN error\n",stderr)
341#define WRITEF_LOG2_NEGATIVE fputs("log2f: DOMAIN error\n",stderr)
342#define WRITEL_POW_ZERO_TO_ZERO fputs("powl(0,0): DOMAIN error\n",stderr)
343#define WRITED_POW_ZERO_TO_ZERO fputs("pow(0,0): DOMAIN error\n",stderr)
344#define WRITEF_POW_ZERO_TO_ZERO fputs("powf(0,0): DOMAIN error\n",stderr)
345#define WRITEL_POW_ZERO_TO_NEGATIVE fputs("powl(0,negative): DOMAIN error\n",stderr)
346#define WRITED_POW_ZERO_TO_NEGATIVE fputs("pow(0,negative): DOMAIN error\n",stderr)
347#define WRITEF_POW_ZERO_TO_NEGATIVE fputs("powf(0,negative): DOMAIN error\n",stderr)
348#define WRITEL_POW_NEG_TO_NON_INTEGER fputs("powl(negative,non-integer): DOMAIN error\n",stderr)
349#define WRITED_POW_NEG_TO_NON_INTEGER fputs("pow(negative,non-integer): DOMAIN error\n",stderr)
350#define WRITEF_POW_NEG_TO_NON_INTEGER fputs("powf(negative,non-integer): DOMAIN error\n",stderr)
351#define WRITEL_ATAN2_ZERO_BY_ZERO fputs("atan2l: DOMAIN error\n",stderr)
352#define WRITED_ATAN2_ZERO_BY_ZERO fputs("atan2: DOMAIN error\n",stderr)
353#define WRITEF_ATAN2_ZERO_BY_ZERO fputs("atan2f: DOMAIN error\n",stderr)
354#define WRITEL_SQRT fputs("sqrtl: DOMAIN error\n",stderr)
355#define WRITED_SQRT fputs("sqrt: DOMAIN error\n",stderr)
356#define WRITEF_SQRT fputs("sqrtf: DOMAIN error\n",stderr)
357#define WRITEL_FMOD fputs("fmodl: DOMAIN error\n",stderr)
358#define WRITED_FMOD fputs("fmod: DOMAIN error\n",stderr)
359#define WRITEF_FMOD fputs("fmodf: DOMAIN error\n",stderr)
360#define WRITEL_REM fputs("remainderl: DOMAIN error\n",stderr)
361#define WRITED_REM fputs("remainder: DOMAIN error\n",stderr)
362#define WRITEF_REM fputs("remainderf: DOMAIN error\n",stderr)
363#define WRITEL_ACOS fputs("acosl: DOMAIN error\n",stderr)
364#define WRITED_ACOS fputs("acos: DOMAIN error\n",stderr)
365#define WRITEF_ACOS fputs("acosf: DOMAIN error\n",stderr)
366#define WRITEL_ASIN fputs("asinl: DOMAIN error\n",stderr)
367#define WRITED_ASIN fputs("asin: DOMAIN error\n",stderr)
368#define WRITEF_ASIN fputs("asinf: DOMAIN error\n",stderr)
369#define WRITEL_ACOSH fputs("acoshl: DOMAIN error\n",stderr)
370#define WRITED_ACOSH fputs("acosh: DOMAIN error\n",stderr)
371#define WRITEF_ACOSH fputs("acoshf: DOMAIN error\n",stderr)
372#define WRITEL_ATANH_GT_ONE fputs("atanhl: DOMAIN error\n",stderr)
373#define WRITED_ATANH_GT_ONE fputs("atanh: DOMAIN error\n",stderr)
374#define WRITEF_ATANH_GT_ONE fputs("atanhf: DOMAIN error\n",stderr)
375#define WRITEL_ATANH_EQ_ONE fputs("atanhl: SING error\n",stderr)
376#define WRITED_ATANH_EQ_ONE fputs("atanh: SING error\n",stderr)
377#define WRITEF_ATANH_EQ_ONE fputs("atanhf: SING error\n",stderr)
378#define WRITEL_LGAMMA_NEGATIVE fputs("lgammal: SING error\n",stderr)
379#define WRITED_LGAMMA_NEGATIVE fputs("lgamma: SING error\n",stderr)
380#define WRITEF_LGAMMA_NEGATIVE fputs("lgammaf: SING error\n",stderr)
381#define WRITEL_GAMMA_NEGATIVE fputs("gammal: SING error\n",stderr)
382#define WRITED_GAMMA_NEGATIVE fputs("gamma: SING error\n",stderr)
383#define WRITEF_GAMMA_NEGATIVE fputs("gammaf: SING error\n",stderr)
384#define WRITEL_TGAMMA_NEGATIVE fputs("tgammal: SING error\n",stderr)
385#define WRITED_TGAMMA_NEGATIVE fputs("tgamma: SING error\n",stderr)
386#define WRITEF_TGAMMA_NEGATIVE fputs("tgammaf: SING error\n",stderr)
387#define WRITEL_J0_TLOSS fputs("j0l: TLOSS error\n",stderr)
388#define WRITEL_Y0_TLOSS fputs("y0l: TLOSS error\n",stderr)
389#define WRITEL_J1_TLOSS fputs("j1l: TLOSS error\n",stderr)
390#define WRITEL_Y1_TLOSS fputs("y1l: TLOSS error\n",stderr)
391#define WRITEL_JN_TLOSS fputs("jnl: TLOSS error\n",stderr)
392#define WRITEL_YN_TLOSS fputs("ynl: TLOSS error\n",stderr)
393#define WRITED_J0_TLOSS fputs("j0: TLOSS error\n",stderr)
394#define WRITED_Y0_TLOSS fputs("y0: TLOSS error\n",stderr)
395#define WRITED_J1_TLOSS fputs("j1: TLOSS error\n",stderr)
396#define WRITED_Y1_TLOSS fputs("y1: TLOSS error\n",stderr)
397#define WRITED_JN_TLOSS fputs("jn: TLOSS error\n",stderr)
398#define WRITED_YN_TLOSS fputs("yn: TLOSS error\n",stderr)
399#define WRITEF_J0_TLOSS fputs("j0f: TLOSS error\n",stderr)
400#define WRITEF_Y0_TLOSS fputs("y0f: TLOSS error\n",stderr)
401#define WRITEF_J1_TLOSS fputs("j1f: TLOSS error\n",stderr)
402#define WRITEF_Y1_TLOSS fputs("y1f: TLOSS error\n",stderr)
403#define WRITEF_JN_TLOSS fputs("jnf: TLOSS error\n",stderr)
404#define WRITEF_YN_TLOSS fputs("ynf: TLOSS error\n",stderr)
405#define WRITEL_ACOSD fputs("acosdl: DOMAIN error\n",stderr)
406#define WRITED_ACOSD fputs("acosd: DOMAIN error\n",stderr)
407#define WRITEF_ACOSD fputs("acosdf: DOMAIN error\n",stderr)
408#define WRITEL_ASIND fputs("asindl: DOMAIN error\n",stderr)
409#define WRITED_ASIND fputs("asind: DOMAIN error\n",stderr)
410#define WRITEF_ASIND fputs("asindf: DOMAIN error\n",stderr)
411#define WRITEL_ATAN2D_ZERO_BY_ZERO fputs("atan2dl: DOMAIN error\n",stderr)
412#define WRITED_ATAN2D_ZERO_BY_ZERO fputs("atan2d: DOMAIN error\n",stderr)
413#define WRITEF_ATAN2D_ZERO_BY_ZERO fputs("atan2df: DOMAIN error\n",stderr)
414
415
416/***********************/
417/* IEEE Path */
418/***********************/
419if(_LIB_VERSIONIMF==_IEEE_) return;
420
421/***********************/
422/* C9X Path */
423/***********************/
424else if(_LIB_VERSIONIMF==_ISOC_)
425{
426 switch(input_tag)
427 {
428 case logl_zero:
429 case log_zero:
430 case logf_zero:
431 case log10l_zero:
432 case log10_zero:
433 case log10f_zero:
434 case log2l_zero:
435 case log2_zero:
436 case log2f_zero:
437 case log1pl_zero:
438 case log1p_zero:
439 case log1pf_zero:
440 case powl_overflow:
441 case pow_overflow:
442 case powf_overflow:
443 case expl_overflow:
444 case exp_overflow:
445 case expf_overflow:
446 case exp2l_overflow:
447 case exp2_overflow:
448 case exp2f_overflow:
449 case exp10l_overflow:
450 case exp10_overflow:
451 case exp10f_overflow:
452 case expm1l_overflow:
453 case expm1_overflow:
454 case expm1f_overflow:
455 case hypotl_overflow:
456 case hypot_overflow:
457 case hypotf_overflow:
458 case sinhl_overflow:
459 case sinh_overflow:
460 case sinhf_overflow:
461 case atanhl_eq_one:
462 case atanh_eq_one:
463 case atanhf_eq_one:
464 case scalbl_overflow:
465 case scalb_overflow:
466 case scalbf_overflow:
467 case coshl_overflow:
468 case cosh_overflow:
469 case coshf_overflow:
470 case nextafterl_overflow:
471 case nextafter_overflow:
472 case nextafterf_overflow:
473 case nextafterl_underflow:
474 case nextafter_underflow:
475 case nextafterf_underflow:
476 case nexttowardl_overflow:
477 case nexttoward_overflow:
478 case nexttowardf_overflow:
479 case nexttowardl_underflow:
480 case nexttoward_underflow:
481 case nexttowardf_underflow:
482 case scalbnl_overflow:
483 case scalbn_overflow:
484 case scalbnf_overflow:
485 case scalblnl_overflow:
486 case scalbln_overflow:
487 case scalblnf_overflow:
488 case ldexpl_overflow:
489 case ldexp_overflow:
490 case ldexpf_overflow:
491 case lgammal_overflow:
492 case lgamma_overflow:
493 case lgammaf_overflow:
494 case gammal_overflow:
495 case gamma_overflow:
496 case gammaf_overflow:
497 case lgammal_negative:
498 case lgamma_negative:
499 case lgammaf_negative:
500 case gammal_negative:
501 case gamma_negative:
502 case gammaf_negative:
503 case ilogbl_zero:
504 case ilogb_zero:
505 case ilogbf_zero:
506 case fdiml_overflow:
507 case fdim_overflow:
508 case fdimf_overflow:
509 case llrintl_large:
510 case llrint_large:
511 case llrintf_large:
512 case llroundl_large:
513 case llround_large:
514 case llroundf_large:
515 case lrintl_large:
516 case lrint_large:
517 case lrintf_large:
518 case lroundl_large:
519 case lround_large:
520 case lroundf_large:
521 case tandl_overflow:
522 case tand_overflow:
523 case tandf_overflow:
524 case cotdl_overflow:
525 case cotd_overflow:
526 case cotdf_overflow:
527 case cotl_overflow:
528 case cot_overflow:
529 case cotf_overflow:
530 case sinhcoshl_overflow:
531 case sinhcosh_overflow:
532 case sinhcoshf_overflow:
533 case annuityl_overflow:
534 case annuity_overflow:
535 case annuityf_overflow:
536 case compoundl_overflow:
537 case compound_overflow:
538 case compoundf_overflow:
539 case tgammal_overflow:
540 case tgamma_overflow:
541 case tgammaf_overflow:
542 {
543 ERRNO_RANGE; break;
544 }
545 case powl_underflow:
546 case expl_underflow:
547 case exp10l_underflow:
548 case exp2l_underflow:
549 case scalbl_underflow:
550 case scalbnl_underflow:
551 case scalblnl_underflow:
552 case ldexpl_underflow:
553 case erfcl_underflow:
554 case annuityl_underflow:
555 case compoundl_underflow:
556 {
557 /* Test for zero by testing 64 significand bits for zero. An integer
558 test is needed so denormal flag is not set by a floating-point test */
559 if ( INPUT_RESI64 == 0 ) ERRNO_RANGE;
560 break;
561 }
562 case pow_underflow:
563 case exp_underflow:
564 case exp10_underflow:
565 case exp2_underflow:
566 case scalb_underflow:
567 case scalbn_underflow:
568 case scalbln_underflow:
569 case ldexp_underflow:
570 case erfc_underflow:
571 case annuity_underflow:
572 case compound_underflow:
573 {
574 /* Test for zero by testing exp and significand bits for zero. An integer
575 test is needed so denormal flag is not set by a floating-point test */
576 if ( (INPUT_RESI64 << 1) == 0 ) ERRNO_RANGE;
577 break;
578 }
579 case powf_underflow:
580 case expf_underflow:
581 case exp10f_underflow:
582 case exp2f_underflow:
583 case scalbf_underflow:
584 case scalbnf_underflow:
585 case scalblnf_underflow:
586 case ldexpf_underflow:
587 case erfcf_underflow:
588 case annuityf_underflow:
589 case compoundf_underflow:
590 {
591 /* Test for zero by testing exp and significand bits for zero. An integer
592 test is needed so denormal flag is not set by a floating-point test */
593 if ( (INPUT_RESI64 << 33) == 0 ) ERRNO_RANGE;
594 break;
595 }
596 case logl_negative:
597 case log_negative:
598 case logf_negative:
599 case log10l_negative:
600 case log10_negative:
601 case log10f_negative:
602 case log2l_negative:
603 case log2_negative:
604 case log2f_negative:
605 case log1pl_negative:
606 case log1p_negative:
607 case log1pf_negative:
608 case sqrtl_negative:
609 case sqrt_negative:
610 case sqrtf_negative:
611 case atan2l_zero:
612 case atan2_zero:
613 case atan2f_zero:
614 case powl_zero_to_negative:
615 case powl_neg_to_non_integer:
616 case pow_zero_to_negative:
617 case pow_neg_to_non_integer:
618 case powf_zero_to_negative:
619 case powf_neg_to_non_integer:
620 case fmodl_by_zero:
621 case fmod_by_zero:
622 case fmodf_by_zero:
623 case atanhl_gt_one:
624 case atanh_gt_one:
625 case atanhf_gt_one:
626 case acosl_gt_one:
627 case acos_gt_one:
628 case acosf_gt_one:
629 case asinl_gt_one:
630 case asin_gt_one:
631 case asinf_gt_one:
632 case logbl_zero:
633 case logb_zero:
634 case logbf_zero:
635 case acoshl_lt_one:
636 case acosh_lt_one:
637 case acoshf_lt_one:
638 case y0l_zero:
639 case y0_zero:
640 case y0f_zero:
641 case y1l_zero:
642 case y1_zero:
643 case y1f_zero:
644 case ynl_zero:
645 case yn_zero:
646 case ynf_zero:
647 case y0l_negative:
648 case y0_negative:
649 case y0f_negative:
650 case y1l_negative:
651 case y1_negative:
652 case y1f_negative:
653 case ynl_negative:
654 case yn_negative:
655 case ynf_negative:
656 case acosdl_gt_one:
657 case acosd_gt_one:
658 case acosdf_gt_one:
659 case asindl_gt_one:
660 case asind_gt_one:
661 case asindf_gt_one:
662 case atan2dl_zero:
663 case atan2d_zero:
664 case atan2df_zero:
665 case annuityl_by_zero:
666 case annuity_by_zero:
667 case annuityf_by_zero:
668 case annuityl_less_m1:
669 case annuity_less_m1:
670 case annuityf_less_m1:
671 case compoundl_by_zero:
672 case compound_by_zero:
673 case compoundf_by_zero:
674 case compoundl_less_m1:
675 case compound_less_m1:
676 case compoundf_less_m1:
677 case tgammal_negative:
678 case tgamma_negative:
679 case tgammaf_negative:
680 {
681 ERRNO_DOMAIN; break;
682 }
683 default:
684 break;
685 }
686 return;
687}
688
689/***********************/
690/* _POSIX_ Path */
691/***********************/
692
693else if(_LIB_VERSIONIMF==_POSIX_)
694{
695switch(input_tag)
696 {
697 case gammal_overflow:
698 case lgammal_overflow:
699 case tgammal_overflow:
700 {
701 RETVAL_HUGE_VALL; ERRNO_RANGE; break;
702 }
703 case gamma_overflow:
704 case lgamma_overflow:
705 case tgamma_overflow:
706 {
707 RETVAL_HUGE_VALD; ERRNO_RANGE; break;
708 }
709 case gammaf_overflow:
710 case lgammaf_overflow:
711 case tgammaf_overflow:
712 {
713 RETVAL_HUGE_VALF; ERRNO_RANGE; break;
714 }
715 case gammal_negative:
716 case gamma_negative:
717 case gammaf_negative:
718 case lgammal_negative:
719 case lgamma_negative:
720 case lgammaf_negative:
721 case tgammal_negative:
722 case tgamma_negative:
723 case tgammaf_negative:
724 {
725 ERRNO_DOMAIN; break;
726 }
727 case ldexpl_overflow:
728 case ldexpl_underflow:
729 case ldexp_overflow:
730 case ldexp_underflow:
731 case ldexpf_overflow:
732 case ldexpf_underflow:
733 case scalbnl_overflow:
734 case scalbnl_underflow:
735 case scalbn_overflow:
736 case scalbn_underflow:
737 case scalbnf_overflow:
738 case scalbnf_underflow:
739 case scalblnl_overflow:
740 case scalblnl_underflow:
741 case scalbln_overflow:
742 case scalbln_underflow:
743 case scalblnf_overflow:
744 case scalblnf_underflow:
745 case tandl_overflow:
746 case tand_overflow:
747 case tandf_overflow:
748 case cotdl_overflow:
749 case cotd_overflow:
750 case cotdf_overflow:
751 case cotl_overflow:
752 case cot_overflow:
753 case cotf_overflow:
754 case sinhcoshl_overflow:
755 case sinhcosh_overflow:
756 case sinhcoshf_overflow:
757 case nextafterl_overflow:
758 case nextafter_overflow:
759 case nextafterf_overflow:
760 case nextafterl_underflow:
761 case nextafter_underflow:
762 case nextafterf_underflow:
763 case nexttowardl_overflow:
764 case nexttoward_overflow:
765 case nexttowardf_overflow:
766 case nexttowardl_underflow:
767 case nexttoward_underflow:
768 case nexttowardf_underflow:
769 {
770 ERRNO_RANGE; break;
771 }
772 case atanhl_gt_one:
773 case atanhl_eq_one:
774 /* atanhl(|x| >= 1) */
775 {
776 ERRNO_DOMAIN; break;
777 }
778 case atanh_gt_one:
779 case atanh_eq_one:
780 /* atanh(|x| >= 1) */
781 {
782 ERRNO_DOMAIN; break;
783 }
784 case atanhf_gt_one:
785 case atanhf_eq_one:
786 /* atanhf(|x| >= 1) */
787 {
788 ERRNO_DOMAIN; break;
789 }
790 case sqrtl_negative:
791 /* sqrtl(x < 0) */
792 {
793 ERRNO_DOMAIN; break;
794 }
795 case sqrt_negative:
796 /* sqrt(x < 0) */
797 {
798 ERRNO_DOMAIN; break;
799 }
800 case sqrtf_negative:
801 /* sqrtf(x < 0) */
802 {
803 ERRNO_DOMAIN; break;
804 }
805 case y0l_zero:
806 case y1l_zero:
807 case ynl_zero:
808 /* y0l(0) */
809 /* y1l(0) */
810 /* ynl(0) */
811 {
812 RETVAL_NEG_HUGE_VALL; ERRNO_DOMAIN; break;
813 }
814 case y0_zero:
815 case y1_zero:
816 case yn_zero:
817 /* y0(0) */
818 /* y1(0) */
819 /* yn(0) */
820 {
821 RETVAL_NEG_HUGE_VALD; ERRNO_DOMAIN; break;
822 }
823 case y0f_zero:
824 case y1f_zero:
825 case ynf_zero:
826 /* y0f(0) */
827 /* y1f(0) */
828 /* ynf(0) */
829 {
830 RETVAL_NEG_HUGE_VALF; ERRNO_DOMAIN; break;
831 }
832 case y0l_negative:
833 case y1l_negative:
834 case ynl_negative:
835 /* y0l(x < 0) */
836 /* y1l(x < 0) */
837 /* ynl(x < 0) */
838 {
839#ifndef _LIBC
840 RETVAL_NEG_HUGE_VALL;
841#endif
842 ERRNO_DOMAIN; break;
843 }
844 case y0_negative:
845 case y1_negative:
846 case yn_negative:
847 /* y0(x < 0) */
848 /* y1(x < 0) */
849 /* yn(x < 0) */
850 {
851 RETVAL_NEG_HUGE_VALD; ERRNO_DOMAIN; break;
852 }
853 case y0f_negative:
854 case y1f_negative:
855 case ynf_negative:
856 /* y0f(x < 0) */
857 /* y1f(x < 0) */
858 /* ynf(x < 0) */
859 {
860 RETVAL_NEG_HUGE_VALF; ERRNO_DOMAIN; break;
861 }
862 case logl_zero:
863 case log1pl_zero:
864 case log10l_zero:
865 case log2l_zero:
866 /* logl(0) */
867 /* log1pl(-1) */
868 /* log10l(0) */
869 /* log2l(0) */
870 {
871 RETVAL_NEG_HUGE_VALL; ERRNO_RANGE; break;
872 }
873 case log_zero:
874 case log1p_zero:
875 case log10_zero:
876 case log2_zero:
877 /* log(0) */
878 /* log1p(-1) */
879 /* log10(0) */
880 /* log2(0) */
881 {
882 RETVAL_NEG_HUGE_VALD; ERRNO_RANGE; break;
883 }
884 case logf_zero:
885 case log1pf_zero:
886 case log10f_zero:
887 case log2f_zero:
888 /* logf(0) */
889 /* log1pf(-1) */
890 /* log10f(0) */
891 /* log2f(0) */
892 {
893 RETVAL_NEG_HUGE_VALF; ERRNO_RANGE; break;
894 }
895 case logl_negative:
896 case log1pl_negative:
897 case log10l_negative:
898 case log2l_negative:
899 /* logl(x < 0) */
900 /* log1pl(x < -1) */
901 /* log10l(x < 0) */
902 /* log2l(x < 0) */
903 {
904 ERRNO_DOMAIN; break;
905 }
906 case log_negative:
907 case log1p_negative:
908 case log10_negative:
909 case log2_negative:
910 /* log(x < 0) */
911 /* log1p(x < -1) */
912 /* log10(x < 0) */
913 /* log2(x < 0) */
914 {
915 ERRNO_DOMAIN; break;
916 }
917 case logf_negative:
918 case log1pf_negative:
919 case log10f_negative:
920 case log2f_negative:
921 /* logf(x < 0) */
922 /* log1pf(x < -1) */
923 /* log10f(x < 0) */
924 /* log2f(x < 0) */
925 {
926 ERRNO_DOMAIN; break;
927 }
928 case expl_overflow:
929 case exp10l_overflow:
930 case exp2l_overflow:
931 /* expl overflow */
932 /* exp10l overflow */
933 /* exp2l overflow */
934 {
935 RETVAL_HUGE_VALL; ERRNO_RANGE; break;
936 }
937 case exp_overflow:
938 case exp10_overflow:
939 case exp2_overflow:
940 /* exp overflow */
941 /* exp10 overflow */
942 /* exp2 overflow */
943 {
944 RETVAL_HUGE_VALD; ERRNO_RANGE; break;
945 }
946 case expf_overflow:
947 case exp10f_overflow:
948 case exp2f_overflow:
949 /* expf overflow */
950 {
951 RETVAL_HUGE_VALF; ERRNO_RANGE; break;
952 }
953 case expl_underflow:
954 case exp10l_underflow:
955 case exp2l_underflow:
956 /* expl underflow */
957 /* exp10l underflow */
958 /* exp2l underflow */
959 {
960 ERRNO_RANGE; break;
961 }
962 case exp_underflow:
963 case exp10_underflow:
964 case exp2_underflow:
965 /* exp underflow */
966 /* exp10 underflow */
967 /* exp2 underflow */
968 {
969 ERRNO_RANGE; break;
970 }
971 case expf_underflow:
972 case exp10f_underflow:
973 case exp2f_underflow:
974 /* expf underflow */
975 /* exp10f underflow */
976 /* exp2f underflow */
977 {
978 ERRNO_RANGE; break;
979 }
980 case j0l_gt_loss:
981 case y0l_gt_loss:
982 case j1l_gt_loss:
983 case y1l_gt_loss:
984 case jnl_gt_loss:
985 case ynl_gt_loss:
986 /* jn and yn doubl-extended> XLOSS */
987 {
988 RETVAL_ZEROL; ERRNO_RANGE; break;
989 }
990 case j0_gt_loss:
991 case y0_gt_loss:
992 case j1_gt_loss:
993 case y1_gt_loss:
994 case jn_gt_loss:
995 case yn_gt_loss:
996 /* jn and yn double > XLOSS */
997 {
998 RETVAL_ZEROD; ERRNO_RANGE; break;
999 }
1000 case j0f_gt_loss:
1001 case y0f_gt_loss:
1002 case j1f_gt_loss:
1003 case y1f_gt_loss:
1004 case jnf_gt_loss:
1005 case ynf_gt_loss:
1006 /* j0n and y0n > XLOSS */
1007 {
1008 RETVAL_ZEROF; ERRNO_RANGE; break;
1009 }
1010 case powl_zero_to_zero:
1011 /* powl 0**0 */
1012 {
1013 break;
1014 }
1015 case pow_zero_to_zero:
1016 /* pow 0**0 */
1017 {
1018 break;
1019 }
1020 case powf_zero_to_zero:
1021 /* powf 0**0 */
1022 {
1023 break;
1024 }
1025 case powl_overflow:
1026 case annuityl_overflow:
1027 case compoundl_overflow:
1028 /* powl(x,y) overflow */
1029 {
1030 if (INPUT_RESL < ZEROL_VALUE /*0*/) RETVAL_NEG_HUGE_VALL;
1031 else RETVAL_HUGE_VALL;
1032 ERRNO_RANGE; break;
1033 }
1034 case pow_overflow:
1035 case annuity_overflow:
1036 case compound_overflow:
1037 /* pow(x,y) overflow */
1038 {
1039 if (INPUT_RESD < ZEROD_VALUE /*0*/) RETVAL_NEG_HUGE_VALD;
1040 else RETVAL_HUGE_VALD;
1041 ERRNO_RANGE; break;
1042 }
1043 case powf_overflow:
1044 case annuityf_overflow:
1045 case compoundf_overflow:
1046 /* powf(x,y) overflow */
1047 {
1048 if (INPUT_RESF < ZEROF_VALUE /*0*/) RETVAL_NEG_HUGE_VALF;
1049 else RETVAL_HUGE_VALF;
1050 ERRNO_RANGE; break;
1051 }
1052 case powl_underflow:
1053 case annuityl_underflow:
1054 case compoundl_underflow:
1055 /* powl(x,y) underflow */
1056 {
1057 RETVAL_ZEROL; ERRNO_RANGE; break;
1058 }
1059 case pow_underflow:
1060 case annuity_underflow:
1061 case compound_underflow:
1062 /* pow(x,y) underflow */
1063 {
1064 RETVAL_ZEROD; ERRNO_RANGE; break;
1065 }
1066 case powf_underflow:
1067 case annuityf_underflow:
1068 case compoundf_underflow:
1069 /* powf(x,y) underflow */
1070 {
1071 RETVAL_ZEROF; ERRNO_RANGE; break;
1072 }
1073 case annuityl_by_zero:
1074 case annuityl_less_m1:
1075 case compoundl_by_zero:
1076 case compoundl_less_m1:
1077 case annuity_by_zero:
1078 case annuity_less_m1:
1079 case compound_by_zero:
1080 case compound_less_m1:
1081 case annuityf_by_zero:
1082 case annuityf_less_m1:
1083 case compoundf_by_zero:
1084 case compoundf_less_m1:
1085 {
1086 ERRNO_DOMAIN; break;
1087 }
1088 case powl_zero_to_negative:
1089 /* 0**neg */
1090 {
1091 ERRNO_DOMAIN; break;
1092 }
1093 case pow_zero_to_negative:
1094 /* 0**neg */
1095 {
1096 ERRNO_DOMAIN; break;
1097 }
1098 case powf_zero_to_negative:
1099 /* 0**neg */
1100 {
1101 ERRNO_DOMAIN; break;
1102 }
1103 case powl_neg_to_non_integer:
1104 /* neg**non_integral */
1105 {
1106 ERRNO_DOMAIN; break;
1107 }
1108 case pow_neg_to_non_integer:
1109 /* neg**non_integral */
1110 {
1111 ERRNO_DOMAIN; break;
1112 }
1113 case powf_neg_to_non_integer:
1114 /* neg**non-integral */
1115 {
1116 ERRNO_DOMAIN; break;
1117 }
1118 case powl_nan_to_zero:
1119 /* powl(NaN,0.0) */
1120 /* Special Error */
1121 {
1122 break;
1123 }
1124 case pow_nan_to_zero:
1125 /* pow(NaN,0.0) */
1126 {
1127 break;
1128 }
1129 case powf_nan_to_zero:
1130 /* powf(NaN,0.0) */
1131 {
1132 break;
1133 }
1134 case atan2l_zero:
1135 case atan2dl_zero:
1136 /* atan2l(0,0) */
1137 /* atan2dl(0,0) */
1138 {
1139 break;
1140 }
1141 case atan2_zero:
1142 case atan2d_zero:
1143 /* atan2(0,0) */
1144 /* atan2d(0,0) */
1145 {
1146 break;
1147 }
1148 case atan2f_zero:
1149 case atan2df_zero:
1150 /* atan2f(0,0) */
1151 /* atan2df(0,0) */
1152 {
1153 break;
1154 }
1155 case expm1l_overflow:
1156 /* expm1 overflow */
1157 {
1158 ERRNO_RANGE; break;
1159 }
1160 case expm1_overflow:
1161 /* expm1 overflow */
1162 {
1163 ERRNO_RANGE; break;
1164 }
1165 case expm1f_overflow:
1166 /* expm1f overflow */
1167 {
1168 ERRNO_RANGE; break;
1169 }
1170 case expm1l_underflow:
1171 /* expm1 underflow */
1172 {
1173 ERRNO_RANGE; break;
1174 }
1175 case expm1_underflow:
1176 /* expm1 underflow */
1177 {
1178 ERRNO_RANGE; break;
1179 }
1180 case expm1f_underflow:
1181 /* expm1f underflow */
1182 {
1183 ERRNO_RANGE; break;
1184 }
1185 case hypotl_overflow:
1186 /* hypotl overflow */
1187 {
1188 RETVAL_HUGE_VALL; ERRNO_RANGE; break;
1189 }
1190 case hypot_overflow:
1191 /* hypot overflow */
1192 {
1193 RETVAL_HUGE_VALD; ERRNO_RANGE; break;
1194 }
1195 case hypotf_overflow:
1196 /* hypotf overflow */
1197 {
1198 RETVAL_HUGE_VALF; ERRNO_RANGE; break;
1199 }
1200 case scalbl_underflow:
1201 /* scalbl underflow */
1202 {
1203 if (INPUT_XL < ZEROL_VALUE /*0*/) RETVAL_NEG_ZEROL;
1204 else RETVAL_ZEROL;
1205 ERRNO_RANGE; break;
1206 }
1207 case scalb_underflow:
1208 /* scalb underflow */
1209 {
1210 if (INPUT_XD < ZEROD_VALUE /*0*/) RETVAL_NEG_ZEROD;
1211 else RETVAL_ZEROD;
1212 ERRNO_RANGE; break;
1213 }
1214 case scalbf_underflow:
1215 /* scalbf underflow */
1216 {
1217 if (INPUT_XF < ZEROF_VALUE /*0*/) RETVAL_NEG_ZEROF;
1218 else RETVAL_ZEROF;
1219 ERRNO_RANGE; break;
1220 }
1221 case scalbl_overflow:
1222 /* scalbl overflow */
1223 {
1224 if (INPUT_XL < ZEROL_VALUE /*0*/) RETVAL_NEG_HUGE_VALL;
1225 else RETVAL_HUGE_VALL;
1226 ERRNO_RANGE; break;
1227 }
1228 case scalb_overflow:
1229 /* scalb overflow */
1230 {
1231 if (INPUT_XD < ZEROD_VALUE /*0*/) RETVAL_NEG_HUGE_VALD;
1232 else RETVAL_HUGE_VALD;
1233 ERRNO_RANGE; break;
1234 }
1235 case scalbf_overflow:
1236 /* scalbf overflow */
1237 {
1238 if (INPUT_XF < ZEROF_VALUE /*0*/) RETVAL_NEG_HUGE_VALF;
1239 else RETVAL_HUGE_VALF;
1240 ERRNO_RANGE; break;
1241 }
1242 case acoshl_lt_one:
1243 /* acoshl(x < 1) */
1244 {
1245 ERRNO_DOMAIN; break;
1246 }
1247 case acosh_lt_one:
1248 /* acosh(x < 1) */
1249 {
1250 ERRNO_DOMAIN; break;
1251 }
1252 case acoshf_lt_one:
1253 /* acoshf(x < 1) */
1254 {
1255 ERRNO_DOMAIN; break;
1256 }
1257 case acosl_gt_one:
1258 case acosdl_gt_one:
1259 /* acosl(x > 1) */
1260 /* acosdl(x > 1) */
1261 {
1262 ERRNO_DOMAIN; break;
1263 }
1264 case acos_gt_one:
1265 case acosd_gt_one:
1266 /* acos(x > 1) */
1267 /* acosd(x > 1) */
1268 {
1269 ERRNO_DOMAIN; break;
1270 }
1271 case acosf_gt_one:
1272 case acosdf_gt_one:
1273 /* acosf(x > 1) */
1274 /* acosdf(x > 1) */
1275 {
1276 ERRNO_DOMAIN; break;
1277 }
1278 case asinl_gt_one:
1279 case asindl_gt_one:
1280 /* asinl(x > 1) */
1281 /* asindl(x > 1) */
1282 {
1283 ERRNO_DOMAIN; break;
1284 }
1285 case asin_gt_one:
1286 case asind_gt_one:
1287 /* asin(x > 1) */
1288 /* asind(x > 1) */
1289 {
1290 ERRNO_DOMAIN; break;
1291 }
1292 case asinf_gt_one:
1293 case asindf_gt_one:
1294 /* asinf(x > 1) */
1295 /* asindf(x > 1) */
1296 {
1297 ERRNO_DOMAIN; break;
1298 }
1299 case remainderl_by_zero:
1300 case fmodl_by_zero:
1301 /* fmodl(x,0) */
1302 {
1303 ERRNO_DOMAIN; break;
1304 }
1305 case remainder_by_zero:
1306 case fmod_by_zero:
1307 /* fmod(x,0) */
1308 {
1309 ERRNO_DOMAIN; break;
1310 }
1311 case remainderf_by_zero:
1312 case fmodf_by_zero:
1313 /* fmodf(x,0) */
1314 {
1315 ERRNO_DOMAIN; break;
1316 }
1317 case coshl_overflow:
1318 /* coshl overflows */
1319 {
1320 RETVAL_HUGE_VALL; ERRNO_RANGE; break;
1321 }
1322 case cosh_overflow:
1323 /* cosh overflows */
1324 {
1325 RETVAL_HUGE_VALD; ERRNO_RANGE; break;
1326 }
1327 case coshf_overflow:
1328 /* coshf overflows */
1329 {
1330 RETVAL_HUGE_VALF; ERRNO_RANGE; break;
1331 }
1332 case sinhl_overflow:
1333 /* sinhl overflows */
1334 {
1335 if (INPUT_XL > ZEROL_VALUE /*0*/) RETVAL_HUGE_VALL;
1336 else RETVAL_NEG_HUGE_VALL;
1337 ERRNO_RANGE; break;
1338 }
1339 case sinh_overflow:
1340 /* sinh overflows */
1341 {
1342 if (INPUT_XD > ZEROD_VALUE /*0*/) RETVAL_HUGE_VALD;
1343 else RETVAL_NEG_HUGE_VALD;
1344 ERRNO_RANGE; break;
1345 }
1346 case sinhf_overflow:
1347 /* sinhf overflows */
1348 {
1349 if (INPUT_XF > ZEROF_VALUE /*0*/) RETVAL_HUGE_VALF;
1350 else RETVAL_NEG_HUGE_VALF;
1351 ERRNO_RANGE; break;
1352 }
1353 case logbl_zero:
1354 /* logbl(0) */
1355 {
1356 ERRNO_DOMAIN; break;
1357 }
1358 case logb_zero:
1359 /* logb(0) */
1360 {
1361 ERRNO_DOMAIN; break;
1362 }
1363 case logbf_zero:
1364 /* logbf(0) */
1365 {
1366 ERRNO_DOMAIN; break;
1367 }
1368 case ilogbl_zero:
1369 /* ilogbl(0) */
1370 {
1371 ERRNO_RANGE; break;
1372 }
1373 case ilogb_zero:
1374 /* ilogb(0) */
1375 {
1376 ERRNO_RANGE; break;
1377 }
1378 case ilogbf_zero:
1379 /* ilogbf(0) */
1380 {
1381 ERRNO_RANGE; break;
1382 }
1383 default:
1384 break;
1385}
1386return;
1387/* _POSIX_ */
1388}
1389
1390/*******************************/
1391/* __SVID__ and __XOPEN__ Path */
1392/*******************************/
1393else
1394{
1395 switch(input_tag)
1396 {
1397 case ldexpl_overflow:
1398 case ldexpl_underflow:
1399 case ldexp_overflow:
1400 case ldexp_underflow:
1401 case ldexpf_overflow:
1402 case ldexpf_underflow:
1403 case scalbnl_overflow:
1404 case scalbnl_underflow:
1405 case scalbn_overflow:
1406 case scalbn_underflow:
1407 case scalbnf_overflow:
1408 case scalbnf_underflow:
1409 case scalblnl_overflow:
1410 case scalblnl_underflow:
1411 case scalbln_overflow:
1412 case scalbln_underflow:
1413 case scalblnf_overflow:
1414 case scalblnf_underflow:
1415 case tandl_overflow:
1416 case tand_overflow:
1417 case tandf_overflow:
1418 case cotdl_overflow:
1419 case cotd_overflow:
1420 case cotdf_overflow:
1421 case cotl_overflow:
1422 case cot_overflow:
1423 case cotf_overflow:
1424 case annuityl_overflow:
1425 case annuityl_underflow:
1426 case annuity_overflow:
1427 case annuity_underflow:
1428 case annuityf_overflow:
1429 case annuityf_underflow:
1430 case compoundl_overflow:
1431 case compoundl_underflow:
1432 case compound_overflow:
1433 case compound_underflow:
1434 case compoundf_overflow:
1435 case compoundf_underflow:
1436 {
1437 ERRNO_RANGE; break;
1438 }
1439 case annuityl_by_zero:
1440 case annuityl_less_m1:
1441 case annuity_by_zero:
1442 case annuity_less_m1:
1443 case annuityf_by_zero:
1444 case annuityf_less_m1:
1445 case compoundl_by_zero:
1446 case compoundl_less_m1:
1447 case compound_by_zero:
1448 case compound_less_m1:
1449 case compoundf_by_zero:
1450 case compoundf_less_m1:
1451 {
1452 ERRNO_DOMAIN; break;
1453 }
1454 case sqrtl_negative:
1455 /* sqrtl(x < 0) */
1456 {
1457 DOMAINL; NAMEL = (char *) "sqrtl";
1458 ifSVID
1459 {
1460 RETVAL_ZEROL;
1461 NOT_MATHERRL
1462 {
1463 WRITEL_SQRT;
1464 ERRNO_DOMAIN;
1465 }
1466 }
1467 else
1468 { /* NaN already computed */
1469 NOT_MATHERRL {ERRNO_DOMAIN;}
1470 }
1471 *(long double *)retval = excl.retval;
1472 break;
1473 }
1474 case sqrt_negative:
1475 /* sqrt(x < 0) */
1476 {
1477 DOMAIND; NAMED = (char *) "sqrt";
1478 ifSVID
1479 {
1480
1481 RETVAL_ZEROD;
1482 NOT_MATHERRD
1483 {
1484 WRITED_SQRT;
1485 ERRNO_DOMAIN;
1486 }
1487 }
1488 else
1489 { /* NaN already computed */
1490 NOT_MATHERRD {ERRNO_DOMAIN;}
1491 }
1492 *(double *)retval = exc.retval;
1493 break;
1494 }
1495 case sqrtf_negative:
1496 /* sqrtf(x < 0) */
1497 {
1498 DOMAINF; NAMEF = (char *) "sqrtf";
1499 ifSVID
1500 {
1501 RETVAL_ZEROF;
1502 NOT_MATHERRF
1503 {
1504 WRITEF_SQRT;
1505 ERRNO_DOMAIN;
1506 }
1507 }
1508 else
1509 {
1510 NOT_MATHERRF {ERRNO_DOMAIN;}
1511 }
1512 *(float *)retval = excf.retval;
1513 break;
1514 }
1515 case logl_zero:
1516 /* logl(0) */
1517 {
1518 SINGL; NAMEL = (char *) "logl";
1519 ifSVID
1520 {
1521 RETVAL_NEG_HUGEL;
1522 NOT_MATHERRL
1523 {
1524 WRITEL_LOG_ZERO;
1525 ERRNO_DOMAIN;
1526 }
1527 }
1528 else
1529 {
1530 RETVAL_NEG_HUGE_VALL;
1531 NOT_MATHERRL {ERRNO_DOMAIN;}
1532 }
1533 *(long double *)retval = excl.retval;
1534 break;
1535 }
1536 case log_zero:
1537 /* log(0) */
1538 {
1539 SINGD; NAMED = (char *) "log";
1540 ifSVID
1541 {
1542 RETVAL_NEG_HUGED;
1543 NOT_MATHERRD
1544 {
1545 WRITED_LOG_ZERO;
1546 ERRNO_DOMAIN;
1547 }
1548 }
1549 else
1550 {
1551 RETVAL_NEG_HUGE_VALD;
1552 NOT_MATHERRD {ERRNO_DOMAIN;}
1553 }
1554 *(double *)retval = exc.retval;
1555 break;
1556 }
1557 case logf_zero:
1558 /* logf(0) */
1559 {
1560 SINGF; NAMEF = (char *) "logf";
1561 ifSVID
1562 {
1563 RETVAL_NEG_HUGEF;
1564 NOT_MATHERRF
1565 {
1566 WRITEF_LOG_ZERO;
1567 ERRNO_DOMAIN;
1568 }
1569 }
1570 else
1571 {
1572 RETVAL_NEG_HUGE_VALF;
1573 NOT_MATHERRF {ERRNO_DOMAIN;}
1574 }
1575 *(float *)retval = excf.retval;
1576 break;
1577 }
1578
1579 case logl_negative:
1580 /* logl(x < 0) */
1581 {
1582 DOMAINL; NAMEL = (char *) "logl";
1583 ifSVID
1584 {
1585 RETVAL_NEG_HUGEL;
1586 NOT_MATHERRL
1587 {
1588 WRITEL_LOG_NEGATIVE;
1589 ERRNO_DOMAIN;
1590 }
1591 }
1592 else
1593 {
1594 RETVAL_NEG_HUGE_VALL;
1595 NOT_MATHERRL {ERRNO_DOMAIN;}
1596 }
1597 *(long double *)retval = excl.retval;
1598 break;
1599 }
1600 case log_negative:
1601 /* log(x < 0) */
1602 {
1603 DOMAIND; NAMED = (char *) "log";
1604 ifSVID
1605 {
1606 RETVAL_NEG_HUGED;
1607 NOT_MATHERRD
1608 {
1609 WRITED_LOG_NEGATIVE;
1610 ERRNO_DOMAIN;
1611 }
1612 }
1613 else
1614 {
1615 RETVAL_NEG_HUGE_VALD;
1616 NOT_MATHERRD {ERRNO_DOMAIN;}
1617 }
1618 *(double *)retval = exc.retval;
1619 break;
1620 }
1621 case logf_negative:
1622 /* logf(x < 0) */
1623 {
1624 DOMAINF; NAMEF = (char *) "logf";
1625 ifSVID
1626 {
1627 RETVAL_NEG_HUGEF;
1628 NOT_MATHERRF
1629 {
1630 WRITEF_LOG_NEGATIVE;
1631 ERRNO_DOMAIN;
1632 }
1633 }
1634 else
1635 {
1636 RETVAL_NEG_HUGE_VALF;
1637 NOT_MATHERRF{ERRNO_DOMAIN;}
1638 }
1639 *(float *)retval = excf.retval;
1640 break;
1641 }
1642 case log1pl_zero:
1643 /* log1pl(-1) */
1644 {
1645 SINGL; NAMEL = (char *) "log1pl";
1646 ifSVID
1647 {
1648 RETVAL_NEG_HUGEL;
1649 NOT_MATHERRL
1650 {
1651 WRITEL_LOG1P_ZERO;
1652 ERRNO_DOMAIN;
1653 }
1654 }
1655 else
1656 {
1657 RETVAL_NEG_HUGE_VALL;
1658 NOT_MATHERRL {ERRNO_DOMAIN;}
1659 }
1660 *(long double *)retval = excl.retval;
1661 break;
1662 }
1663 case log1p_zero:
1664 /* log1p(-1) */
1665 {
1666 SINGD; NAMED = (char *) "log1p";
1667 ifSVID
1668 {
1669 RETVAL_NEG_HUGED;
1670 NOT_MATHERRD
1671 {
1672 WRITED_LOG1P_ZERO;
1673 ERRNO_DOMAIN;
1674 }
1675 }
1676 else
1677 {
1678 RETVAL_NEG_HUGE_VALD;
1679 NOT_MATHERRD {ERRNO_DOMAIN;}
1680 }
1681 *(double *)retval = exc.retval;
1682 break;
1683 }
1684 case log1pf_zero:
1685 /* log1pf(-1) */
1686 {
1687 SINGF; NAMEF = (char *) "log1pf";
1688 ifSVID
1689 {
1690 RETVAL_NEG_HUGEF;
1691 NOT_MATHERRF
1692 {
1693 WRITEF_LOG1P_ZERO;
1694 ERRNO_DOMAIN;
1695 }
1696 }
1697 else
1698 {
1699 RETVAL_NEG_HUGE_VALF;
1700 NOT_MATHERRF {ERRNO_DOMAIN;}
1701 }
1702 *(float *)retval = excf.retval;
1703 break;
1704 }
1705 case log1pl_negative:
1706 /* log1pl(x < -1) */
1707 {
1708 DOMAINL; NAMEL = (char *) "log1pl";
1709 ifSVID
1710 {
1711 RETVAL_NEG_HUGEL;
1712 NOT_MATHERRL
1713 {
1714 WRITEL_LOG1P_NEGATIVE;
1715 ERRNO_DOMAIN;
1716 }
1717 }
1718 else
1719 {
1720 RETVAL_NEG_HUGE_VALL;
1721 NOT_MATHERRL {ERRNO_DOMAIN;}
1722 }
1723 *(long double *)retval = excl.retval;
1724 break;
1725 }
1726 case log1p_negative:
1727 /* log1p(x < -1) */
1728 {
1729 DOMAIND; NAMED = (char *) "log1p";
1730 ifSVID
1731 {
1732 RETVAL_NEG_HUGED;
1733 NOT_MATHERRD
1734 {
1735 WRITED_LOG1P_NEGATIVE;
1736 ERRNO_DOMAIN;
1737 }
1738 }
1739 else
1740 {
1741 RETVAL_NEG_HUGE_VALD;
1742 NOT_MATHERRD {ERRNO_DOMAIN;}
1743 }
1744 *(double *)retval = exc.retval;
1745 break;
1746 }
1747 case log1pf_negative:
1748 /* log1pf(x < -1) */
1749 {
1750 DOMAINF; NAMEF = (char *) "log1pf";
1751 ifSVID
1752 {
1753 RETVAL_NEG_HUGEF;
1754 NOT_MATHERRF
1755 {
1756 WRITEF_LOG1P_NEGATIVE;
1757 ERRNO_DOMAIN;
1758 }
1759 }
1760 else
1761 {
1762 RETVAL_NEG_HUGE_VALF;
1763 NOT_MATHERRF {ERRNO_DOMAIN;}
1764 }
1765 *(float *)retval = excf.retval;
1766 break;
1767 }
1768 case log10l_zero:
1769 /* log10l(0) */
1770 {
1771 SINGL; NAMEL = (char *) "log10l";
1772 ifSVID
1773 {
1774 RETVAL_NEG_HUGEL;
1775 NOT_MATHERRL
1776 {
1777 WRITEL_LOG10_ZERO;
1778 ERRNO_DOMAIN;
1779 }
1780 }
1781 else
1782 {
1783 RETVAL_NEG_HUGE_VALL;
1784 NOT_MATHERRL {ERRNO_DOMAIN;}
1785 }
1786 *(long double *)retval = excl.retval;
1787 break;
1788 }
1789 case log10_zero:
1790 /* log10(0) */
1791 {
1792 SINGD; NAMED = (char *) "log10";
1793 ifSVID
1794 {
1795 RETVAL_NEG_HUGED;
1796 NOT_MATHERRD
1797 {
1798 WRITED_LOG10_ZERO;
1799 ERRNO_DOMAIN;
1800 }
1801 }
1802 else
1803 {
1804 RETVAL_NEG_HUGE_VALD;
1805 NOT_MATHERRD {ERRNO_DOMAIN;}
1806 }
1807 *(double *)retval = exc.retval;
1808 break;
1809 }
1810 case log10f_zero:
1811 /* log10f(0) */
1812 {
1813 SINGF; NAMEF = (char *) "log10f";
1814 ifSVID
1815 {
1816 RETVAL_NEG_HUGEF;
1817 NOT_MATHERRF
1818 {
1819 WRITEF_LOG10_ZERO;
1820 ERRNO_DOMAIN;
1821 }
1822 }
1823 else
1824 {
1825 RETVAL_NEG_HUGE_VALF;
1826 NOT_MATHERRF {ERRNO_DOMAIN;}
1827 }
1828 *(float *)retval = excf.retval;
1829 break;
1830 }
1831 case log10l_negative:
1832 /* log10l(x < 0) */
1833 {
1834 DOMAINL; NAMEL = (char *) "log10l";
1835 ifSVID
1836 {
1837 RETVAL_NEG_HUGEL;
1838 NOT_MATHERRL
1839 {
1840 WRITEL_LOG10_NEGATIVE;
1841 ERRNO_DOMAIN;
1842 }
1843 }
1844 else
1845 {
1846 RETVAL_NEG_HUGE_VALL;
1847 NOT_MATHERRL {ERRNO_DOMAIN;}
1848 }
1849 *(long double *)retval = excl.retval;
1850 break;
1851 }
1852 case log10_negative:
1853 /* log10(x < 0) */
1854 {
1855 DOMAIND; NAMED = (char *) "log10";
1856 ifSVID
1857 {
1858 RETVAL_NEG_HUGED;
1859 NOT_MATHERRD
1860 {
1861 WRITED_LOG10_NEGATIVE;
1862 ERRNO_DOMAIN;
1863 }
1864 }
1865 else
1866 {
1867 RETVAL_NEG_HUGE_VALD;
1868 NOT_MATHERRD {ERRNO_DOMAIN;}
1869 }
1870 *(double *)retval = exc.retval;
1871 break;
1872 }
1873 case log10f_negative:
1874 /* log10f(x < 0) */
1875 {
1876 DOMAINF; NAMEF = (char *) "log10f";
1877 ifSVID
1878 {
1879 RETVAL_NEG_HUGEF;
1880 NOT_MATHERRF
1881 {
1882 WRITEF_LOG10_NEGATIVE;
1883 ERRNO_DOMAIN;
1884 }
1885 }
1886 else
1887 {
1888 RETVAL_NEG_HUGE_VALF;
1889 NOT_MATHERRF {ERRNO_DOMAIN;}
1890 }
1891 *(float *)retval = excf.retval;
1892 break;
1893 }
1894 case log2l_zero:
1895 /* log2l(0) */
1896 {
1897 SINGL; NAMEL = (char *) "log2l";
1898 ifSVID
1899 {
1900 RETVAL_NEG_HUGEL;
1901 NOT_MATHERRL
1902 {
1903 WRITEL_LOG2_ZERO;
1904 ERRNO_DOMAIN;
1905 }
1906 }
1907 else
1908 {
1909 RETVAL_NEG_HUGE_VALL;
1910 NOT_MATHERRL {ERRNO_DOMAIN;}
1911 }
1912 *(long double *)retval = excl.retval;
1913 break;
1914 }
1915 case log2_zero:
1916 /* log2(0) */
1917 {
1918 SINGD; NAMED = (char *) "log2";
1919 ifSVID
1920 {
1921 RETVAL_NEG_HUGED;
1922 NOT_MATHERRD
1923 {
1924 WRITED_LOG2_ZERO;
1925 ERRNO_DOMAIN;
1926 }
1927 }
1928 else
1929 {
1930 RETVAL_NEG_HUGE_VALD;
1931 NOT_MATHERRD {ERRNO_DOMAIN;}
1932 }
1933 *(double *)retval = exc.retval;
1934 break;
1935 }
1936 case log2f_zero:
1937 /* log2f(0) */
1938 {
1939 SINGF; NAMEF = (char *) "log2f";
1940 ifSVID
1941 {
1942 RETVAL_NEG_HUGEF;
1943 NOT_MATHERRF
1944 {
1945 WRITEF_LOG2_ZERO;
1946 ERRNO_DOMAIN;
1947 }
1948 }
1949 else
1950 {
1951 RETVAL_NEG_HUGE_VALF;
1952 NOT_MATHERRF {ERRNO_DOMAIN;}
1953 }
1954 *(float *)retval = excf.retval;
1955 break;
1956 }
1957 case log2l_negative:
1958 /* log2l(x < 0) */
1959 {
1960 DOMAINL; NAMEL = (char *) "log2l";
1961 ifSVID
1962 {
1963 RETVAL_NEG_HUGEL;
1964 NOT_MATHERRL
1965 {
1966 WRITEL_LOG2_NEGATIVE;
1967 ERRNO_DOMAIN;
1968 }
1969 }
1970 else
1971 {
1972 RETVAL_NEG_HUGE_VALL;
1973 NOT_MATHERRL {ERRNO_DOMAIN;}
1974 }
1975 *(long double *)retval = excl.retval;
1976 break;
1977 }
1978 case log2_negative:
1979 /* log2(x < 0) */
1980 {
1981 DOMAIND; NAMED = (char *) "log2";
1982 ifSVID
1983 {
1984 RETVAL_NEG_HUGED;
1985 NOT_MATHERRD
1986 {
1987 WRITED_LOG2_NEGATIVE;
1988 ERRNO_DOMAIN;
1989 }
1990 }
1991 else
1992 {
1993 RETVAL_NEG_HUGE_VALD;
1994 NOT_MATHERRD {ERRNO_DOMAIN;}
1995 }
1996 *(double *)retval = exc.retval;
1997 break;
1998 }
1999 case log2f_negative:
2000 /* log2f(x < 0) */
2001 {
2002 DOMAINF; NAMEF = (char *) "log2f";
2003 ifSVID
2004 {
2005 RETVAL_NEG_HUGEF;
2006 NOT_MATHERRF
2007 {
2008 WRITEF_LOG2_NEGATIVE;
2009 ERRNO_DOMAIN;
2010 }
2011 }
2012 else
2013 {
2014 RETVAL_NEG_HUGE_VALF;
2015 NOT_MATHERRF {ERRNO_DOMAIN;}
2016 }
2017 *(float *)retval = excf.retval;
2018 break;
2019 }
2020 case expl_overflow:
2021 /* expl overflow */
2022 {
2023 OVERFLOWL; NAMEL = (char *) "expl";
2024 ifSVID
2025 {
2026 RETVAL_HUGEL;
2027 }
2028 else
2029 {
2030 RETVAL_HUGE_VALL;
2031 }
2032 NOT_MATHERRL {ERRNO_RANGE;}
2033 *(long double *)retval = excl.retval;
2034 break;
2035 }
2036 case exp_overflow:
2037 /* exp overflow */
2038 {
2039 OVERFLOWD; NAMED = (char *) "exp";
2040 ifSVID
2041 {
2042 RETVAL_HUGED;
2043 }
2044 else
2045 {
2046 RETVAL_HUGE_VALD;
2047 }
2048 NOT_MATHERRD {ERRNO_RANGE;}
2049 *(double *)retval = exc.retval;
2050 break;
2051 }
2052 case expf_overflow:
2053 /* expf overflow */
2054 {
2055 OVERFLOWF; NAMEF = (char *) "expf";
2056 ifSVID
2057 {
2058 RETVAL_HUGEF;
2059 }
2060 else
2061 {
2062 RETVAL_HUGE_VALF;
2063 }
2064 NOT_MATHERRF {ERRNO_RANGE;}
2065 *(float *)retval = excf.retval;
2066 break;
2067 }
2068 case expl_underflow:
2069 /* expl underflow */
2070 {
2071 UNDERFLOWL; NAMEL = (char *) "expl"; RETVAL_ZEROL;
2072 NOT_MATHERRL {ERRNO_RANGE;}
2073 *(long double *)retval = excl.retval;
2074 break;
2075 }
2076 case exp_underflow:
2077 /* exp underflow */
2078 {
2079 UNDERFLOWD; NAMED = (char *) "exp"; RETVAL_ZEROD;
2080 NOT_MATHERRD {ERRNO_RANGE;}
2081 *(double *)retval = exc.retval;
2082 break;
2083 }
2084 case expf_underflow:
2085 /* expf underflow */
2086 {
2087 UNDERFLOWF; NAMEF = (char *) "expf"; RETVAL_ZEROF;
2088 NOT_MATHERRF {ERRNO_RANGE;}
2089 *(float *)retval = excf.retval;
2090 break;
2091 }
2092 case powl_zero_to_zero:
2093 /* powl 0**0 */
2094 {
2095 DOMAINL; NAMEL = (char *) "powl";
2096 ifSVID
2097 {
2098 RETVAL_ZEROL;
2099 NOT_MATHERRL
2100 {
2101 WRITEL_POW_ZERO_TO_ZERO;
2102 ERRNO_DOMAIN;
2103 }
2104 *(long double *)retval = excl.retval;
2105 }
2106 else RETVAL_ONEL;
2107 break;
2108 }
2109 case pow_zero_to_zero:
2110 /* pow 0**0 */
2111 {
2112 DOMAIND; NAMED = (char *) "pow";
2113 ifSVID
2114 {
2115 RETVAL_ZEROD;
2116 NOT_MATHERRD
2117 {
2118 WRITED_POW_ZERO_TO_ZERO;
2119 ERRNO_DOMAIN;
2120 }
2121 *(double *)retval = exc.retval;
2122 }
2123 else RETVAL_ONED;
2124 break;
2125 }
2126 case powf_zero_to_zero:
2127 /* powf 0**0 */
2128 {
2129 DOMAINF; NAMEF = (char *) "powf";
2130 ifSVID
2131 {
2132 RETVAL_ZEROF;
2133 NOT_MATHERRF
2134 {
2135 WRITEF_POW_ZERO_TO_ZERO;
2136 ERRNO_DOMAIN;
2137 }
2138 *(float *)retval = excf.retval;
2139 }
2140 else RETVAL_ONEF;
2141 break;
2142 }
2143 case powl_overflow:
2144 /* powl(x,y) overflow */
2145 {
2146 OVERFLOWL; NAMEL = (char *) "powl";
2147 ifSVID
2148 {
2149 if (INPUT_RESL < ZEROL_VALUE /*0*/) RETVAL_NEG_HUGEL;
2150 else RETVAL_HUGEL;
2151 }
2152 else
2153 {
2154 if (INPUT_RESL < ZEROL_VALUE /*0*/) RETVAL_NEG_HUGE_VALL;
2155 else RETVAL_HUGE_VALL;
2156 }
2157 NOT_MATHERRL {ERRNO_RANGE;}
2158 *(long double *)retval = excl.retval;
2159 break;
2160 }
2161 case pow_overflow:
2162 /* pow(x,y) overflow */
2163 {
2164 OVERFLOWD; NAMED = (char *) "pow";
2165 ifSVID
2166 {
2167 if (INPUT_RESD < ZEROD_VALUE /*0*/) RETVAL_NEG_HUGED;
2168 else RETVAL_HUGED;
2169 }
2170 else
2171 {
2172 if (INPUT_RESD < ZEROD_VALUE /*0*/) RETVAL_NEG_HUGE_VALD;
2173 else RETVAL_HUGE_VALD;
2174 }
2175 NOT_MATHERRD {ERRNO_RANGE;}
2176 *(double *)retval = exc.retval;
2177 break;
2178 }
2179 case powf_overflow:
2180 /* powf(x,y) overflow */
2181 {
2182 OVERFLOWF; NAMEF = (char *) "powf";
2183 ifSVID
2184 {
2185 if (INPUT_RESF < ZEROF_VALUE /*0*/) RETVAL_NEG_HUGEF;
2186 else RETVAL_HUGEF;
2187 }
2188 else
2189 {
2190 if (INPUT_RESF < ZEROF_VALUE /*0*/) RETVAL_NEG_HUGE_VALF;
2191 else RETVAL_HUGE_VALF;
2192 }
2193 NOT_MATHERRF {ERRNO_RANGE;}
2194 *(float *)retval = excf.retval;
2195 break;
2196 }
2197 case powl_underflow:
2198 /* powl(x,y) underflow */
2199 {
2200 UNDERFLOWL; NAMEL = (char *) "powl"; RETVAL_ZEROL;
2201 NOT_MATHERRL {ERRNO_RANGE;}
2202 *(long double *)retval = excl.retval;
2203 break;
2204 }
2205 case pow_underflow:
2206 /* pow(x,y) underflow */
2207 {
2208 UNDERFLOWD; NAMED = (char *) "pow"; RETVAL_ZEROD;
2209 NOT_MATHERRD {ERRNO_RANGE;}
2210 *(double *)retval = exc.retval;
2211 break;
2212 }
2213 case powf_underflow:
2214 /* powf(x,y) underflow */
2215 {
2216 UNDERFLOWF; NAMEF = (char *) "powf"; RETVAL_ZEROF;
2217 NOT_MATHERRF {ERRNO_RANGE;}
2218 *(float *)retval = excf.retval;
2219 break;
2220 }
2221 case powl_zero_to_negative:
2222 /* 0 to neg */
2223 {
2224 DOMAINL; NAMEL = (char *) "powl";
2225 ifSVID
2226 {
2227 RETVAL_ZEROL;
2228 NOT_MATHERRL
2229 {
2230 WRITEL_POW_ZERO_TO_NEGATIVE;
2231 ERRNO_DOMAIN;
2232 }
2233 }
2234 else
2235 {
2236 RETVAL_NEG_HUGE_VALL;
2237 NOT_MATHERRL {ERRNO_DOMAIN;}
2238 }
2239 *(long double *)retval = excl.retval;
2240 break;
2241 }
2242 case pow_zero_to_negative:
2243 /* 0**neg */
2244 {
2245 DOMAIND; NAMED = (char *) "pow";
2246 ifSVID
2247 {
2248 RETVAL_ZEROD;
2249 NOT_MATHERRD
2250 {
2251 WRITED_POW_ZERO_TO_NEGATIVE;
2252 ERRNO_DOMAIN;
2253 }
2254 }
2255 else
2256 {
2257 RETVAL_NEG_HUGE_VALD;
2258 NOT_MATHERRD {ERRNO_DOMAIN;}
2259 }
2260 *(double *)retval = exc.retval;
2261 break;
2262 }
2263 case powf_zero_to_negative:
2264 /* 0**neg */
2265 {
2266 DOMAINF; NAMEF = (char *) "powf";
2267 ifSVID
2268 {
2269 RETVAL_ZEROF;
2270 NOT_MATHERRF
2271 {
2272 WRITEF_POW_ZERO_TO_NEGATIVE;
2273 ERRNO_DOMAIN;
2274 }
2275 }
2276 else
2277 {
2278 RETVAL_NEG_HUGE_VALF;
2279 NOT_MATHERRF {ERRNO_DOMAIN;}
2280 }
2281 *(float *)retval = excf.retval;
2282 break;
2283 }
2284 case powl_neg_to_non_integer:
2285 /* neg**non_integral */
2286 {
2287 DOMAINL; NAMEL = (char *) "powl";
2288 ifSVID
2289 {
2290 RETVAL_ZEROL;
2291 NOT_MATHERRL
2292 {
2293 WRITEL_POW_NEG_TO_NON_INTEGER;
2294 ERRNO_DOMAIN;
2295 }
2296 }
2297 else
2298 {
2299 NOT_MATHERRL {ERRNO_DOMAIN;}
2300 }
2301 *(long double *)retval = excl.retval;
2302 break;
2303 }
2304 case pow_neg_to_non_integer:
2305 /* neg**non_integral */
2306 {
2307 DOMAIND; NAMED = (char *) "pow";
2308 ifSVID
2309 {
2310 RETVAL_ZEROD;
2311 NOT_MATHERRD
2312 {
2313 WRITED_POW_NEG_TO_NON_INTEGER;
2314 ERRNO_DOMAIN;
2315 }
2316 }
2317 else
2318 {
2319 NOT_MATHERRD {ERRNO_DOMAIN;}
2320 }
2321 *(double *)retval = exc.retval;
2322 break;
2323 }
2324 case powf_neg_to_non_integer:
2325 /* neg**non-integral */
2326 {
2327 DOMAINF; NAMEF = (char *) "powf";
2328 ifSVID
2329 {
2330 RETVAL_ZEROF;
2331 NOT_MATHERRF
2332 {
2333 WRITEF_POW_NEG_TO_NON_INTEGER;
2334 ERRNO_DOMAIN;
2335 }
2336 }
2337 else
2338 {
2339 NOT_MATHERRF {ERRNO_DOMAIN;}
2340 }
2341 *(float *)retval = excf.retval;
2342 break;
2343 }
2344 case powl_nan_to_zero:
2345 /* pow(NaN,0.0) */
2346 /* Special Error */
2347 {
2348 DOMAINL; NAMEL = (char *) "powl";
2349 *(long double *)retval = *(long double *)arg1;
2350 NOT_MATHERRL {ERRNO_DOMAIN;}
2351 *(long double *)retval = excl.retval;
2352 break;
2353 }
2354 case pow_nan_to_zero:
2355 /* pow(NaN,0.0) */
2356 /* Special Error */
2357 {
2358 DOMAIND; NAMED = (char *) "pow";
2359 *(double *)retval = *(double *)arg1;
2360 NOT_MATHERRD {ERRNO_DOMAIN;}
2361 *(double *)retval = exc.retval;
2362 break;
2363 }
2364 case powf_nan_to_zero:
2365 /* powf(NaN,0.0) */
2366 /* Special Error */
2367 {
2368 DOMAINF; NAMEF = (char *) "powf";
2369 *(float *)retval = *(float *)arg1;
2370 NOT_MATHERRF {ERRNO_DOMAIN;}
2371 *(float *)retval = excf.retval;
2372 break;
2373 }
2374 case atan2l_zero:
2375 /* atan2l(0.0,0.0) */
2376 {
2377 DOMAINL; NAMEL = (char *) "atan2l";
2378 RETVAL_ZEROL;
2379 NOT_MATHERRL
2380 {
2381 ifSVID
2382 {
2383 WRITEL_ATAN2_ZERO_BY_ZERO;
2384 }
2385 ERRNO_DOMAIN;
2386 }
2387 *(long double *)retval = excl.retval;
2388 break;
2389 }
2390 case atan2_zero:
2391 /* atan2(0.0,0.0) */
2392 {
2393 DOMAIND; NAMED = (char *) "atan2";
2394 RETVAL_ZEROD;
2395 NOT_MATHERRD
2396 {
2397 ifSVID
2398 {
2399 WRITED_ATAN2_ZERO_BY_ZERO;
2400 }
2401 ERRNO_DOMAIN;
2402 }
2403 *(double *)retval = exc.retval;
2404 break;
2405 }
2406 case atan2f_zero:
2407 /* atan2f(0.0,0.0) */
2408 {
2409 DOMAINF; NAMEF = (char *) "atan2f";
2410 RETVAL_ZEROF;
2411 NOT_MATHERRF
2412 {
2413 ifSVID
2414 {
2415 WRITEF_ATAN2_ZERO_BY_ZERO;
2416 }
2417 ERRNO_DOMAIN;
2418 }
2419 *(float *)retval = excf.retval;
2420 break;
2421 }
2422 case atan2dl_zero:
2423 /* atan2dl(0.0,0.0) */
2424 {
2425 DOMAINL; NAMEL = (char *) "atan2dl";
2426 RETVAL_ZEROL;
2427 NOT_MATHERRL
2428 {
2429 ifSVID
2430 {
2431 WRITEL_ATAN2D_ZERO_BY_ZERO;
2432 }
2433 ERRNO_DOMAIN;
2434 }
2435 *(long double *)retval = excl.retval;
2436 break;
2437 }
2438 case atan2d_zero:
2439 /* atan2d(0.0,0.0) */
2440 {
2441 DOMAIND; NAMED = (char *) "atan2d";
2442 RETVAL_ZEROD;
2443 NOT_MATHERRD
2444 {
2445 ifSVID
2446 {
2447 WRITED_ATAN2D_ZERO_BY_ZERO;
2448 }
2449 ERRNO_DOMAIN;
2450 }
2451 *(double *)retval = exc.retval;
2452 break;
2453 }
2454 case atan2df_zero:
2455 /* atan2df(0.0,0.0) */
2456 {
2457 DOMAINF; NAMEF = (char *) "atan2df";
2458 RETVAL_ZEROF;
2459 NOT_MATHERRF
2460 {
2461 ifSVID
2462 {
2463 WRITEF_ATAN2D_ZERO_BY_ZERO;
2464 }
2465 ERRNO_DOMAIN;
2466 }
2467 *(float *)retval = excf.retval;
2468 break;
2469 }
2470 case expm1_overflow:
2471 /* expm1(finite) overflow */
2472 /* Overflow is the only documented */
2473 /* special value. */
2474 {
2475 ERRNO_RANGE;
2476 break;
2477 }
2478 case expm1f_overflow:
2479 /* expm1f(finite) overflow */
2480 {
2481 ERRNO_RANGE;
2482 break;
2483 }
2484 case expm1_underflow:
2485 /* expm1(finite) underflow */
2486 /* Underflow is not documented */
2487 /* special value. */
2488 {
2489 ERRNO_RANGE;
2490 break;
2491 }
2492 case expm1f_underflow:
2493 /* expm1f(finite) underflow */
2494 {
2495 ERRNO_RANGE;
2496 break;
2497 }
2498 case scalbl_underflow:
2499 /* scalbl underflow */
2500 {
2501 UNDERFLOWL; NAMEL = (char *) "scalbl";
2502 if (INPUT_XL < ZEROL_VALUE /*0.0L*/) RETVAL_NEG_ZEROL;
2503 else RETVAL_ZEROL;
2504 NOT_MATHERRL {ERRNO_RANGE;}
2505 *(long double *)retval = excl.retval;
2506 break;
2507 }
2508 case scalb_underflow:
2509 /* scalb underflow */
2510 {
2511 UNDERFLOWD; NAMED = (char *) "scalb";
2512 if (INPUT_XD < ZEROD_VALUE /*0.0*/) RETVAL_NEG_ZEROD;
2513 else RETVAL_ZEROD;
2514 NOT_MATHERRD {ERRNO_RANGE;}
2515 *(double *)retval = exc.retval;
2516 break;
2517 }
2518 case scalbf_underflow:
2519 /* scalbf underflow */
2520 {
2521 UNDERFLOWF; NAMEF = (char *) "scalbf";
2522 if (INPUT_XF < ZEROF_VALUE /*0.0*/) RETVAL_NEG_ZEROF;
2523 else RETVAL_ZEROF;
2524 NOT_MATHERRF {ERRNO_RANGE;}
2525 *(float *)retval = excf.retval;
2526 break;
2527 }
2528 case scalbl_overflow:
2529 /* scalbl overflow */
2530 {
2531 OVERFLOWL; NAMEL = (char *) "scalbl";
2532 if (INPUT_XL < ZEROL_VALUE /*0*/) RETVAL_NEG_HUGE_VALL;
2533 else RETVAL_HUGE_VALL;
2534 NOT_MATHERRL {ERRNO_RANGE;}
2535 *(long double *)retval = excl.retval;
2536 break;
2537 }
2538 case scalb_overflow:
2539 /* scalb overflow */
2540 {
2541 OVERFLOWD; NAMED = (char *) "scalb";
2542 if (INPUT_XD < ZEROD_VALUE /*0*/) RETVAL_NEG_HUGE_VALD;
2543 else RETVAL_HUGE_VALD;
2544 NOT_MATHERRD {ERRNO_RANGE;}
2545 *(double *)retval = exc.retval;
2546 break;
2547 }
2548 case scalbf_overflow:
2549 /* scalbf overflow */
2550 {
2551 OVERFLOWF; NAMEF = (char *) "scalbf";
2552 if (INPUT_XF < ZEROF_VALUE /*0*/) RETVAL_NEG_HUGE_VALF;
2553 else RETVAL_HUGE_VALF;
2554 NOT_MATHERRF {ERRNO_RANGE;}
2555 *(float *)retval = excf.retval;
2556 break;
2557 }
2558 case hypotl_overflow:
2559 /* hypotl overflow */
2560 {
2561 OVERFLOWL; NAMEL = (char *) "hypotl";
2562 ifSVID
2563 {
2564 RETVAL_HUGEL;
2565 }
2566 else
2567 {
2568 RETVAL_HUGE_VALL;
2569 }
2570 NOT_MATHERRL {ERRNO_RANGE;}
2571 *(long double *)retval = excl.retval;
2572 break;
2573 }
2574 case hypot_overflow:
2575 /* hypot overflow */
2576 {
2577 OVERFLOWD; NAMED = (char *) "hypot";
2578 ifSVID
2579 {
2580 RETVAL_HUGED;
2581 }
2582 else
2583 {
2584 RETVAL_HUGE_VALD;
2585 }
2586 NOT_MATHERRD {ERRNO_RANGE;}
2587 *(double *)retval = exc.retval;
2588 break;
2589 }
2590 case hypotf_overflow:
2591 /* hypotf overflow */
2592 {
2593 OVERFLOWF; NAMEF = (char *) "hypotf";
2594 ifSVID
2595 {
2596 RETVAL_HUGEF;
2597 }
2598 else
2599 {
2600 RETVAL_HUGE_VALF;
2601 }
2602 NOT_MATHERRF {ERRNO_RANGE;}
2603 *(float *)retval = excf.retval;
2604 break;
2605 }
2606 case acosl_gt_one:
2607 /* acosl(x > 1) */
2608 {
2609 DOMAINL; NAMEL = (char *) "acosl";
2610 RETVAL_ZEROL;
2611 ifSVID
2612 {
2613 NOT_MATHERRL
2614 {
2615 WRITEL_ACOS;
2616 ERRNO_DOMAIN;
2617 }
2618 }
2619 else
2620 {
2621 NOT_MATHERRL {ERRNO_DOMAIN;}
2622 }
2623 *(long double *)retval = excl.retval;
2624 break;
2625 }
2626 case acos_gt_one:
2627 /* acos(x > 1) */
2628 {
2629 DOMAIND; NAMED = (char *) "acos";
2630 RETVAL_ZEROD;
2631 ifSVID
2632 {
2633 NOT_MATHERRD
2634 {
2635 WRITED_ACOS;
2636 ERRNO_DOMAIN;
2637 }
2638 }
2639 else
2640 {
2641 NOT_MATHERRD {ERRNO_DOMAIN;}
2642 }
2643 *(double *)retval = exc.retval;
2644 break;
2645 }
2646 case acosf_gt_one:
2647 /* acosf(x > 1) */
2648 {
2649 DOMAINF; NAMEF = (char *) "acosf";
2650 RETVAL_ZEROF;
2651 ifSVID
2652 {
2653 NOT_MATHERRF
2654 {
2655 WRITEF_ACOS;
2656 ERRNO_DOMAIN;
2657 }
2658 }
2659 else
2660 {
2661 NOT_MATHERRF {ERRNO_DOMAIN;}
2662 }
2663 *(float *)retval = excf.retval;
2664 break;
2665 }
2666 case asinl_gt_one:
2667 /* asinl(x > 1) */
2668 {
2669 DOMAINL; NAMEL = (char *) "asinl";
2670 RETVAL_ZEROL;
2671 ifSVID
2672 {
2673 NOT_MATHERRL
2674 {
2675 WRITEL_ASIN;
2676 ERRNO_DOMAIN;
2677 }
2678 }
2679 else
2680 {
2681 NOT_MATHERRL {ERRNO_DOMAIN;}
2682 }
2683 *(long double *)retval = excl.retval;
2684 break;
2685 }
2686 case asin_gt_one:
2687 /* asin(x > 1) */
2688 {
2689 DOMAIND; NAMED = (char *) "asin";
2690 RETVAL_ZEROD;
2691 ifSVID
2692 {
2693 NOT_MATHERRD
2694 {
2695 WRITED_ASIN;
2696 ERRNO_DOMAIN;
2697 }
2698 }
2699 else
2700 {
2701 NOT_MATHERRD {ERRNO_DOMAIN;}
2702 }
2703 *(double *)retval = exc.retval;
2704 break;
2705 }
2706 case asinf_gt_one:
2707 /* asinf(x > 1) */
2708 {
2709 DOMAINF; NAMEF = (char *) "asinf";
2710 RETVAL_ZEROF;
2711 ifSVID
2712 {
2713 NOT_MATHERRF
2714 {
2715 WRITEF_ASIN;
2716 ERRNO_DOMAIN;
2717 }
2718 }
2719 else
2720 {
2721 NOT_MATHERRF {ERRNO_DOMAIN;}
2722 }
2723 *(float *)retval = excf.retval;
2724 break;
2725 }
2726 case acosdl_gt_one:
2727 /* acosdl(x > 1) */
2728 {
2729 DOMAINL; NAMEL = (char *) "acosdl";
2730 RETVAL_ZEROL;
2731 ifSVID
2732 {
2733 NOT_MATHERRL
2734 {
2735 WRITEL_ACOSD;
2736 ERRNO_DOMAIN;
2737 }
2738 }
2739 else
2740 {
2741 NOT_MATHERRL {ERRNO_DOMAIN;}
2742 }
2743 *(long double *)retval = excl.retval;
2744 break;
2745 }
2746 case acosd_gt_one:
2747 /* acosd(x > 1) */
2748 {
2749 DOMAIND; NAMED = (char *) "acosd";
2750 RETVAL_ZEROD;
2751 ifSVID
2752 {
2753 NOT_MATHERRD
2754 {
2755 WRITED_ACOSD;
2756 ERRNO_DOMAIN;
2757 }
2758 }
2759 else
2760 {
2761 NOT_MATHERRD {ERRNO_DOMAIN;}
2762 }
2763 *(double *)retval = exc.retval;
2764 break;
2765 }
2766 case acosdf_gt_one:
2767 /* acosdf(x > 1) */
2768 {
2769 DOMAINF; NAMEF = (char *) "acosdf";
2770 RETVAL_ZEROF;
2771 ifSVID
2772 {
2773 NOT_MATHERRF
2774 {
2775 WRITEF_ACOSD;
2776 ERRNO_DOMAIN;
2777 }
2778 }
2779 else
2780 {
2781 NOT_MATHERRF {ERRNO_DOMAIN;}
2782 }
2783 *(float *)retval = excf.retval;
2784 break;
2785 }
2786 case asindl_gt_one:
2787 /* asindl(x > 1) */
2788 {
2789 DOMAINL; NAMEL = (char *) "asindl";
2790 RETVAL_ZEROL;
2791 ifSVID
2792 {
2793 NOT_MATHERRL
2794 {
2795 WRITEL_ASIND;
2796 ERRNO_DOMAIN;
2797 }
2798 }
2799 else
2800 {
2801 NOT_MATHERRL {ERRNO_DOMAIN;}
2802 }
2803 *(long double *)retval = excl.retval;
2804 break;
2805 }
2806 case asind_gt_one:
2807 /* asind(x > 1) */
2808 {
2809 DOMAIND; NAMED = (char *) "asind";
2810 RETVAL_ZEROD;
2811 ifSVID
2812 {
2813 NOT_MATHERRD
2814 {
2815 WRITED_ASIND;
2816 ERRNO_DOMAIN;
2817 }
2818 }
2819 else
2820 {
2821 NOT_MATHERRD {ERRNO_DOMAIN;}
2822 }
2823 *(double *)retval = exc.retval;
2824 break;
2825 }
2826 case asindf_gt_one:
2827 /* asindf(x > 1) */
2828 {
2829 DOMAINF; NAMEF = (char *) "asindf";
2830 RETVAL_ZEROF;
2831 ifSVID
2832 {
2833 NOT_MATHERRF
2834 {
2835 WRITEF_ASIND;
2836 ERRNO_DOMAIN;
2837 }
2838 }
2839 else
2840 {
2841 NOT_MATHERRF {ERRNO_DOMAIN;}
2842 }
2843 *(float *)retval = excf.retval;
2844 break;
2845 }
2846 case coshl_overflow:
2847 /* coshl overflow */
2848 {
2849 OVERFLOWL; NAMEL = (char *) "coshl";
2850 ifSVID
2851 {
2852 RETVAL_HUGEL;
2853 }
2854 else
2855 {
2856 RETVAL_HUGE_VALL;
2857 }
2858 NOT_MATHERRL {ERRNO_RANGE;}
2859 *(long double *)retval = excl.retval;
2860 break;
2861 }
2862 case cosh_overflow:
2863 /* cosh overflow */
2864 {
2865 OVERFLOWD; NAMED = (char *) "cosh";
2866 ifSVID
2867 {
2868 RETVAL_HUGED;
2869 }
2870 else
2871 {
2872 RETVAL_HUGE_VALD;
2873 }
2874 NOT_MATHERRD {ERRNO_RANGE;}
2875 *(double *)retval = exc.retval;
2876 break;
2877 }
2878 case coshf_overflow:
2879 /* coshf overflow */
2880 {
2881 OVERFLOWF; NAMEF = (char *) "coshf";
2882 ifSVID
2883 {
2884 RETVAL_HUGEF;
2885 }
2886 else
2887 {
2888 RETVAL_HUGE_VALF;
2889 }
2890 NOT_MATHERRF {ERRNO_RANGE;}
2891 *(float *)retval = excf.retval;
2892 break;
2893 }
2894 case sinhl_overflow:
2895 /* sinhl overflow */
2896 {
2897 OVERFLOWL; NAMEL = (char *) "sinhl";
2898 ifSVID
2899 {
2900 if (INPUT_XL > ZEROL_VALUE /*0.0*/) RETVAL_HUGEL;
2901 else RETVAL_NEG_HUGEL;
2902 }
2903 else
2904 {
2905 if (INPUT_XL > ZEROL_VALUE /*0.0*/) RETVAL_HUGE_VALL;
2906 else RETVAL_NEG_HUGE_VALL;
2907 }
2908 NOT_MATHERRL {ERRNO_RANGE;}
2909 *(long double *)retval = excl.retval;
2910 break;
2911 }
2912 case sinh_overflow:
2913 /* sinh overflow */
2914 {
2915 OVERFLOWD; NAMED = (char *) "sinh";
2916 ifSVID
2917 {
2918 if (INPUT_XD > ZEROD_VALUE /*0.0*/) RETVAL_HUGED;
2919 else RETVAL_NEG_HUGED;
2920 }
2921 else
2922 {
2923 if (INPUT_XD > ZEROD_VALUE /*0.0*/) RETVAL_HUGE_VALD;
2924 else RETVAL_NEG_HUGE_VALD;
2925 }
2926 NOT_MATHERRD {ERRNO_RANGE;}
2927 *(double *)retval = exc.retval;
2928 break;
2929 }
2930 case sinhf_overflow:
2931 /* sinhf overflow */
2932 {
2933 OVERFLOWF; NAMEF = (char *) "sinhf";
2934 ifSVID
2935 {
2936 if (INPUT_XF > ZEROF_VALUE /*0.0*/) RETVAL_HUGEF;
2937 else RETVAL_NEG_HUGEF;
2938 }
2939 else
2940 {
2941 if (INPUT_XF > ZEROF_VALUE /*0.0*/) RETVAL_HUGE_VALF;
2942 else RETVAL_NEG_HUGE_VALF;
2943 }
2944 NOT_MATHERRF {ERRNO_RANGE;}
2945 *(float *)retval = excf.retval;
2946 break;
2947 }
2948 case acoshl_lt_one:
2949 /* acoshl(x < 1) */
2950 {
2951 DOMAINL; NAMEL = (char *) "acoshl";
2952 ifSVID
2953 {
2954 NOT_MATHERRL
2955 {
2956 WRITEL_ACOSH;
2957 ERRNO_DOMAIN;
2958 }
2959 }
2960 else
2961 {
2962 NOT_MATHERRL {ERRNO_DOMAIN;}
2963 }
2964 *(long double *)retval = excl.retval;
2965 break;
2966 }
2967 case acosh_lt_one:
2968 /* acosh(x < 1) */
2969 {
2970 DOMAIND; NAMED = (char *) "acosh";
2971 ifSVID
2972 {
2973 NOT_MATHERRD
2974 {
2975 WRITED_ACOSH;
2976 ERRNO_DOMAIN;
2977 }
2978 }
2979 else
2980 {
2981 NOT_MATHERRD {ERRNO_DOMAIN;}
2982 }
2983 *(double *)retval = exc.retval;
2984 break;
2985 }
2986 case acoshf_lt_one:
2987 /* acoshf(x < 1) */
2988 {
2989 DOMAINF; NAMEF = (char *) "acoshf";
2990 ifSVID
2991 {
2992 NOT_MATHERRF
2993 {
2994 WRITEF_ACOSH;
2995 ERRNO_DOMAIN;
2996 }
2997 }
2998 else
2999 {
3000 NOT_MATHERRF {ERRNO_DOMAIN;}
3001 }
3002 *(float *)retval = excf.retval;
3003 break;
3004 }
3005 case atanhl_gt_one:
3006 /* atanhl(|x| > 1) */
3007 {
3008 DOMAINL; NAMEL = (char *) "atanhl";
3009 ifSVID
3010 {
3011 NOT_MATHERRL
3012 {
3013 WRITEL_ATANH_GT_ONE;
3014 ERRNO_DOMAIN;
3015 }
3016 }
3017 else
3018 {
3019 NOT_MATHERRL {ERRNO_DOMAIN;}
3020 }
3021 break;
3022 }
3023 case atanh_gt_one:
3024 /* atanh(|x| > 1) */
3025 {
3026 DOMAIND; NAMED = (char *) "atanh";
3027 ifSVID
3028 {
3029 NOT_MATHERRD
3030 {
3031 WRITED_ATANH_GT_ONE;
3032 ERRNO_DOMAIN;
3033 }
3034 }
3035 else
3036 {
3037 NOT_MATHERRD {ERRNO_DOMAIN;}
3038 }
3039 break;
3040 }
3041 case atanhf_gt_one:
3042 /* atanhf(|x| > 1) */
3043 {
3044 DOMAINF; NAMEF = (char *) "atanhf";
3045 ifSVID
3046 {
3047 NOT_MATHERRF
3048 {
3049 WRITEF_ATANH_GT_ONE;
3050 ERRNO_DOMAIN;
3051 }
3052 }
3053 else
3054 {
3055 NOT_MATHERRF {ERRNO_DOMAIN;}
3056 }
3057 break;
3058 }
3059 case atanhl_eq_one:
3060 /* atanhl(|x| == 1) */
3061 {
3062 SINGL; NAMEL = (char *) "atanhl";
3063 ifSVID
3064 {
3065 NOT_MATHERRL
3066 {
3067 WRITEL_ATANH_EQ_ONE;
3068 ERRNO_DOMAIN;
3069 }
3070 }
3071 else
3072 {
3073 NOT_MATHERRL {ERRNO_DOMAIN;}
3074 }
3075 break;
3076 }
3077 case atanh_eq_one:
3078 /* atanh(|x| == 1) */
3079 {
3080 SINGD; NAMED = (char *) "atanh";
3081 ifSVID
3082 {
3083 NOT_MATHERRD
3084 {
3085 WRITED_ATANH_EQ_ONE;
3086 ERRNO_DOMAIN;
3087 }
3088 }
3089 else
3090 {
3091 NOT_MATHERRD {ERRNO_DOMAIN;}
3092 }
3093 break;
3094 }
3095 case atanhf_eq_one:
3096 /* atanhf(|x| == 1) */
3097 {
3098 SINGF; NAMEF = (char *) "atanhf";
3099 ifSVID
3100 {
3101 NOT_MATHERRF
3102 {
3103 WRITEF_ATANH_EQ_ONE;
3104 ERRNO_DOMAIN;
3105 }
3106 }
3107 else
3108 {
3109 NOT_MATHERRF {ERRNO_DOMAIN;}
3110 }
3111 break;
3112 }
3113 case gammal_overflow:
3114 /* gammal overflow */
3115 {
3116 OVERFLOWL; NAMEL = (char *) "gammal";
3117 ifSVID
3118 {
3119 RETVAL_HUGEL;
3120 }
3121 else
3122 {
3123 RETVAL_HUGE_VALL;
3124 }
3125 NOT_MATHERRL {ERRNO_RANGE;}
3126 *(long double *)retval = excl.retval;
3127 break;
3128 }
3129 case gamma_overflow:
3130 /* gamma overflow */
3131 {
3132 OVERFLOWD; NAMED = (char *) "gamma";
3133 ifSVID
3134 {
3135 RETVAL_HUGED;
3136 }
3137 else
3138 {
3139 RETVAL_HUGE_VALD;
3140 }
3141 NOT_MATHERRD {ERRNO_RANGE;}
3142 *(double *)retval = exc.retval;
3143 break;
3144 }
3145 case gammaf_overflow:
3146 /* gammaf overflow */
3147 {
3148 OVERFLOWF; NAMEF = (char *) "gammaf";
3149 ifSVID
3150 {
3151 RETVAL_HUGEF;
3152 }
3153 else
3154 {
3155 RETVAL_HUGE_VALF;
3156 }
3157 NOT_MATHERRF {ERRNO_RANGE;}
3158 *(float *)retval = excf.retval;
3159 break;
3160 }
3161 case gammal_negative:
3162 /* gammal -int or 0 */
3163 {
3164 SINGL; NAMEL = (char *) "gammal";
3165 ifSVID
3166 {
3167 RETVAL_HUGEL;
3168 NOT_MATHERRL
3169 {
3170 WRITEL_GAMMA_NEGATIVE;
3171 ERRNO_DOMAIN;
3172 }
3173 }
3174 else
3175 {
3176 RETVAL_HUGE_VALL;
3177 NOT_MATHERRL {ERRNO_DOMAIN;}
3178 }
3179 *(long double *)retval = excl.retval;
3180 break;
3181 }
3182 case gamma_negative:
3183 /* gamma -int or 0 */
3184 {
3185 SINGD; NAMED = (char *) "gamma";
3186 ifSVID
3187 {
3188 RETVAL_HUGED;
3189 NOT_MATHERRD
3190 {
3191 WRITED_GAMMA_NEGATIVE;
3192 ERRNO_DOMAIN;
3193 }
3194 }
3195 else
3196 {
3197 RETVAL_HUGE_VALD;
3198 NOT_MATHERRD {ERRNO_DOMAIN;}
3199 }
3200 *(double *)retval = exc.retval;
3201 break;
3202 }
3203 case gammaf_negative:
3204 /* gammaf -int or 0 */
3205 {
3206 SINGF; NAMEF = (char *) "gammaf";
3207 ifSVID
3208 {
3209 RETVAL_HUGEF;
3210 NOT_MATHERRF
3211 {
3212 WRITEF_GAMMA_NEGATIVE;
3213 ERRNO_DOMAIN;
3214 }
3215 }
3216 else
3217 {
3218 RETVAL_HUGE_VALF;
3219 NOT_MATHERRF {ERRNO_DOMAIN;}
3220 }
3221 *(float *)retval = excf.retval;
3222 break;
3223 }
3224 case lgammal_overflow:
3225 /* lgammal overflow */
3226 {
3227 OVERFLOWL; NAMEL = (char *) "lgammal";
3228 ifSVID
3229 {
3230 RETVAL_HUGEL;
3231 }
3232 else
3233 {
3234 RETVAL_HUGE_VALL;
3235 }
3236 NOT_MATHERRL {ERRNO_RANGE;}
3237 *(long double *)retval = excl.retval;
3238 break;
3239 }
3240 case lgamma_overflow:
3241 /* lgamma overflow */
3242 {
3243 OVERFLOWD; NAMED = (char *) "lgamma";
3244 ifSVID
3245 {
3246 RETVAL_HUGED;
3247 }
3248 else
3249 {
3250 RETVAL_HUGE_VALD;
3251 }
3252 NOT_MATHERRD {ERRNO_RANGE;}
3253 *(double *)retval = exc.retval;
3254 break;
3255 }
3256 case lgammaf_overflow:
3257 /* lgammaf overflow */
3258 {
3259 OVERFLOWF; NAMEF = (char *) "lgammaf";
3260 ifSVID
3261 {
3262 RETVAL_HUGEF;
3263 }
3264 else
3265 {
3266 RETVAL_HUGE_VALF;
3267 }
3268 NOT_MATHERRF {ERRNO_RANGE;}
3269 *(float *)retval = excf.retval;
3270 break;
3271 }
3272 case lgammal_negative:
3273 /* lgammal -int or 0 */
3274 {
3275 SINGL; NAMEL = (char *) "lgammal";
3276 ifSVID
3277 {
3278 RETVAL_HUGEL;
3279 NOT_MATHERRL
3280 {
3281 WRITEL_LGAMMA_NEGATIVE;
3282 ERRNO_DOMAIN;
3283 }
3284 }
3285 else
3286 {
3287 RETVAL_HUGE_VALL;
3288 NOT_MATHERRL {ERRNO_DOMAIN;}
3289 }
3290 *(long double *)retval = excl.retval;
3291 break;
3292 }
3293 case lgamma_negative:
3294 /* lgamma -int or 0 */
3295 {
3296 SINGD; NAMED = (char *) "lgamma";
3297 ifSVID
3298 {
3299 RETVAL_HUGED;
3300 NOT_MATHERRD
3301 {
3302 WRITED_LGAMMA_NEGATIVE;
3303 ERRNO_DOMAIN;
3304 }
3305 }
3306 else
3307 {
3308 RETVAL_HUGE_VALD;
3309 NOT_MATHERRD {ERRNO_DOMAIN;}
3310 }
3311 *(double *)retval = exc.retval;
3312 break;
3313 }
3314 case lgammaf_negative:
3315 /* lgammaf -int or 0 */
3316 {
3317 SINGF; NAMEF = (char *) "lgammaf";
3318 ifSVID
3319 {
3320 RETVAL_HUGEF;
3321 NOT_MATHERRF
3322 {
3323 WRITEF_LGAMMA_NEGATIVE;
3324 ERRNO_DOMAIN;
3325 }
3326 }
3327 else
3328 {
3329 RETVAL_HUGE_VALF;
3330 NOT_MATHERRF {ERRNO_DOMAIN;}
3331 }
3332 *(float *)retval = excf.retval;
3333 break;
3334 }
3335 case tgammal_overflow:
3336 /* tgammal overflow */
3337 {
3338 OVERFLOWL; NAMEL = (char *) "tgammal";
3339 ifSVID
3340 {
3341 RETVAL_HUGEL;
3342 }
3343 else
3344 {
3345 RETVAL_HUGE_VALL;
3346 }
3347 NOT_MATHERRL {ERRNO_RANGE;}
3348 *(long double *)retval = excl.retval;
3349 break;
3350 }
3351 case tgamma_overflow:
3352 /* tgamma overflow */
3353 {
3354 OVERFLOWD; NAMED = (char *) "tgamma";
3355 ifSVID
3356 {
3357 RETVAL_HUGED;
3358 }
3359 else
3360 {
3361 RETVAL_HUGE_VALD;
3362 }
3363 NOT_MATHERRD {ERRNO_RANGE;}
3364 *(double *)retval = exc.retval;
3365 break;
3366 }
3367 case tgammaf_overflow:
3368 /* tgammaf overflow */
3369 {
3370 OVERFLOWF; NAMEF = (char *) "tgammaf";
3371 ifSVID
3372 {
3373 RETVAL_HUGEF;
3374 }
3375 else
3376 {
3377 RETVAL_HUGE_VALF;
3378 }
3379 NOT_MATHERRF {ERRNO_RANGE;}
3380 *(float *)retval = excf.retval;
3381 break;
3382 }
3383 case tgammal_negative:
3384 /* tgammal -int or 0 */
3385 {
3386 SINGL; NAMEL = (char *) "tgammal";
3387 ifSVID
3388 {
3389 NOT_MATHERRL
3390 {
3391 WRITEL_TGAMMA_NEGATIVE;
3392 ERRNO_DOMAIN;
3393 }
3394 }
3395 else
3396 {
3397 NOT_MATHERRL {ERRNO_DOMAIN;}
3398 }
3399 *(long double *)retval = excl.retval;
3400 break;
3401 }
3402 case tgamma_negative:
3403 /* tgamma -int or 0 */
3404 {
3405 SINGD; NAMED = (char *) "tgamma";
3406 ifSVID
3407 {
3408 NOT_MATHERRD
3409 {
3410 WRITED_TGAMMA_NEGATIVE;
3411 ERRNO_DOMAIN;
3412 }
3413 }
3414 else
3415 {
3416 NOT_MATHERRD {ERRNO_DOMAIN;}
3417 }
3418 *(double *)retval = exc.retval;
3419 break;
3420 }
3421 case tgammaf_negative:
3422 /* tgammaf -int or 0 */
3423 {
3424 SINGF; NAMEF = (char *) "tgammaf";
3425 ifSVID
3426 {
3427 NOT_MATHERRF
3428 {
3429 WRITEF_TGAMMA_NEGATIVE;
3430 ERRNO_DOMAIN;
3431 }
3432 }
3433 else
3434 {
3435 NOT_MATHERRF {ERRNO_DOMAIN;}
3436 }
3437 *(float *)retval = excf.retval;
3438 break;
3439 }
3440 case j0l_gt_loss:
3441 /* j0l > loss */
3442 {
3443 TLOSSL; NAMEL = (char *) "j0l";
3444 RETVAL_ZEROL;
3445 ifSVID
3446 {
3447 NOT_MATHERRL
3448 {
3449 WRITEL_J0_TLOSS;
3450 ERRNO_RANGE;
3451 }
3452 }
3453 else
3454 {
3455 NOT_MATHERRL {ERRNO_RANGE;}
3456 }
3457 *(long double *)retval = excl.retval;
3458 break;
3459 }
3460 case j0_gt_loss:
3461 /* j0 > loss */
3462 {
3463 TLOSSD; NAMED = (char *) "j0";
3464 RETVAL_ZEROD;
3465 ifSVID
3466 {
3467 NOT_MATHERRD
3468 {
3469 WRITED_J0_TLOSS;
3470 ERRNO_RANGE;
3471 }
3472 }
3473 else
3474 {
3475 NOT_MATHERRD {ERRNO_RANGE;}
3476 }
3477 *(double*)retval = exc.retval;
3478 break;
3479 }
3480 case j0f_gt_loss:
3481 /* j0f > loss */
3482 {
3483 TLOSSF; NAMEF = (char *) "j0f";
3484 RETVAL_ZEROF;
3485 ifSVID
3486 {
3487 NOT_MATHERRF
3488 {
3489 WRITEF_J0_TLOSS;
3490 ERRNO_RANGE;
3491 }
3492 }
3493 else
3494 {
3495 NOT_MATHERRF {ERRNO_RANGE;}
3496 }
3497 *(float*)retval = excf.retval;
3498 break;
3499 }
3500 case j1l_gt_loss:
3501 /* j1l > loss */
3502 {
3503 TLOSSL; NAMEL = (char *) "j1l";
3504 RETVAL_ZEROL;
3505 ifSVID
3506 {
3507 NOT_MATHERRL
3508 {
3509 WRITEL_J1_TLOSS;
3510 ERRNO_RANGE;
3511 }
3512 }
3513 else
3514 {
3515 NOT_MATHERRL {ERRNO_RANGE;}
3516 }
3517 *(long double *)retval = excl.retval;
3518 break;
3519 }
3520 case j1_gt_loss:
3521 /* j1 > loss */
3522 {
3523 TLOSSD; NAMED = (char *) "j1";
3524 RETVAL_ZEROD;
3525 ifSVID
3526 {
3527 NOT_MATHERRD
3528 {
3529 WRITED_J1_TLOSS;
3530 ERRNO_RANGE;
3531 }
3532 }
3533 else
3534 {
3535 NOT_MATHERRD {ERRNO_RANGE;}
3536 }
3537 *(double*)retval = exc.retval;
3538 break;
3539 }
3540 case j1f_gt_loss:
3541 /* j1f > loss */
3542 {
3543 TLOSSF; NAMEF = (char *) "j1f";
3544 RETVAL_ZEROF;
3545 ifSVID
3546 {
3547 NOT_MATHERRF
3548 {
3549 WRITEF_J1_TLOSS;
3550 ERRNO_RANGE;
3551 }
3552 }
3553 else
3554 {
3555 NOT_MATHERRF {ERRNO_RANGE;}
3556 }
3557 *(float*)retval = excf.retval;
3558 break;
3559 }
3560 case jnl_gt_loss:
3561 /* jnl > loss */
3562 {
3563 TLOSSL; NAMEL = (char *) "jnl";
3564 RETVAL_ZEROL;
3565 ifSVID
3566 {
3567 NOT_MATHERRL
3568 {
3569 WRITEL_JN_TLOSS;
3570 ERRNO_RANGE;
3571 }
3572 }
3573 else
3574 {
3575 NOT_MATHERRL {ERRNO_RANGE;}
3576 }
3577 *(long double *)retval = excl.retval;
3578 break;
3579 }
3580 case jn_gt_loss:
3581 /* jn > loss */
3582 {
3583 TLOSSD; NAMED = (char *) "jn";
3584 RETVAL_ZEROD;
3585 ifSVID
3586 {
3587 NOT_MATHERRD
3588 {
3589 WRITED_JN_TLOSS;
3590 ERRNO_RANGE;
3591 }
3592 }
3593 else
3594 {
3595 NOT_MATHERRD {ERRNO_RANGE;}
3596 }
3597 *(double*)retval = exc.retval;
3598 break;
3599 }
3600 case jnf_gt_loss:
3601 /* jnf > loss */
3602 {
3603 TLOSSF; NAMEF = (char *) "jnf";
3604 RETVAL_ZEROF;
3605 ifSVID
3606 {
3607 NOT_MATHERRF
3608 {
3609 WRITEF_JN_TLOSS;
3610 ERRNO_RANGE;
3611 }
3612 }
3613 else
3614 {
3615 NOT_MATHERRF {ERRNO_RANGE;}
3616 }
3617 *(float*)retval = excf.retval;
3618 break;
3619 }
3620 case y0l_gt_loss:
3621 /* y0l > loss */
3622 {
3623 TLOSSL; NAMEL = (char *) "y0l";
3624 RETVAL_ZEROL;
3625 ifSVID
3626 {
3627 NOT_MATHERRL
3628 {
3629 WRITEL_Y0_TLOSS;
3630 ERRNO_RANGE;
3631 }
3632 }
3633 else
3634 {
3635 NOT_MATHERRL {ERRNO_RANGE;}
3636 }
3637 *(long double *)retval = excl.retval;
3638 break;
3639 }
3640 case y0_gt_loss:
3641 /* y0 > loss */
3642 {
3643 TLOSSD; NAMED = (char *) "y0";
3644 RETVAL_ZEROD;
3645 ifSVID
3646 {
3647 NOT_MATHERRD
3648 {
3649 WRITED_Y0_TLOSS;
3650 ERRNO_RANGE;
3651 }
3652 }
3653 else
3654 {
3655 NOT_MATHERRD {ERRNO_RANGE;}
3656 }
3657 *(double*)retval = exc.retval;
3658 break;
3659 }
3660 case y0f_gt_loss:
3661 /* y0f > loss */
3662 {
3663 TLOSSF; NAMEF = (char *) "y0f";
3664 RETVAL_ZEROF;
3665 ifSVID
3666 {
3667 NOT_MATHERRF
3668 {
3669 WRITEF_Y0_TLOSS;
3670 ERRNO_RANGE;
3671 }
3672 }
3673 else
3674 {
3675 NOT_MATHERRF {ERRNO_RANGE;}
3676 }
3677 *(float*)retval = excf.retval;
3678 break;
3679 }
3680 case y0l_zero:
3681 /* y0l(0) */
3682 {
3683 DOMAINL; NAMEL = (char *) "y0l";
3684 ifSVID
3685 {
3686 RETVAL_NEG_HUGEL;
3687 NOT_MATHERRL
3688 {
3689 WRITEL_Y0_ZERO;
3690 ERRNO_DOMAIN;
3691 }
3692 }
3693 else
3694 {
3695 RETVAL_NEG_HUGE_VALL;
3696 NOT_MATHERRL {ERRNO_DOMAIN;}
3697 }
3698 *(long double *)retval = excl.retval;
3699 break;
3700 }
3701 case y0_zero:
3702 /* y0(0) */
3703 {
3704 DOMAIND; NAMED = (char *) "y0";
3705 ifSVID
3706 {
3707 RETVAL_NEG_HUGED;
3708 NOT_MATHERRD
3709 {
3710 WRITED_Y0_ZERO;
3711 ERRNO_DOMAIN;
3712 }
3713 }
3714 else
3715 {
3716 RETVAL_NEG_HUGE_VALD;
3717 NOT_MATHERRD {ERRNO_DOMAIN;}
3718 }
3719 *(double *)retval = exc.retval;
3720 break;
3721 }
3722 case y0f_zero:
3723 /* y0f(0) */
3724 {
3725 DOMAINF; NAMEF = (char *) "y0f";
3726 ifSVID
3727 {
3728 RETVAL_NEG_HUGEF;
3729 NOT_MATHERRF
3730 {
3731 WRITEF_Y0_ZERO;
3732 ERRNO_DOMAIN;
3733 }
3734 }
3735 else
3736 {
3737 RETVAL_NEG_HUGE_VALF;
3738 NOT_MATHERRF {ERRNO_DOMAIN;}
3739 }
3740 *(float *)retval = excf.retval;
3741 break;
3742 }
3743 case y1l_gt_loss:
3744 /* y1l > loss */
3745 {
3746 TLOSSL; NAMEL = (char *) "y1l";
3747 RETVAL_ZEROL;
3748 ifSVID
3749 {
3750 NOT_MATHERRL
3751 {
3752 WRITEL_Y1_TLOSS;
3753 ERRNO_RANGE;
3754 }
3755 }
3756 else
3757 {
3758 NOT_MATHERRL {ERRNO_RANGE;}
3759 }
3760 *(long double *)retval = excl.retval;
3761 break;
3762 }
3763 case y1_gt_loss:
3764 /* y1 > loss */
3765 {
3766 TLOSSD; NAMED = (char *) "y1";
3767 RETVAL_ZEROD;
3768 ifSVID
3769 {
3770 NOT_MATHERRD
3771 {
3772 WRITED_Y1_TLOSS;
3773 ERRNO_RANGE;
3774 }
3775 }
3776 else
3777 {
3778 NOT_MATHERRD {ERRNO_RANGE;}
3779 }
3780 *(double*)retval = exc.retval;
3781 break;
3782 }
3783 case y1f_gt_loss:
3784 /* y1f > loss */
3785 {
3786 TLOSSF; NAMEF = (char *) "y1f";
3787 RETVAL_ZEROF;
3788 ifSVID
3789 {
3790 NOT_MATHERRF
3791 {
3792 WRITEF_Y1_TLOSS;
3793 ERRNO_RANGE;
3794 }
3795 }
3796 else
3797 {
3798 NOT_MATHERRF {ERRNO_RANGE;}
3799 }
3800 *(float*)retval = excf.retval;
3801 break;
3802 }
3803 case y1l_zero:
3804 /* y1l(0) */
3805 {
3806 DOMAINL; NAMEL = (char *) "y1l";
3807 ifSVID
3808 {
3809 RETVAL_NEG_HUGEL;
3810 NOT_MATHERRL
3811 {
3812 WRITEL_Y1_ZERO;
3813 ERRNO_DOMAIN;
3814 }
3815 }
3816 else
3817 {
3818 RETVAL_NEG_HUGE_VALL;
3819 NOT_MATHERRL {ERRNO_DOMAIN;}
3820 }
3821 *(long double *)retval = excl.retval;
3822 break;
3823 }
3824 case y1_zero:
3825 /* y1(0) */
3826 {
3827 DOMAIND; NAMED = (char *) "y1";
3828 ifSVID
3829 {
3830 RETVAL_NEG_HUGED;
3831 NOT_MATHERRD
3832 {
3833 WRITED_Y1_ZERO;
3834 ERRNO_DOMAIN;
3835 }
3836 }
3837 else
3838 {
3839 RETVAL_NEG_HUGE_VALD;
3840 NOT_MATHERRD {ERRNO_DOMAIN;}
3841 }
3842 *(double *)retval = exc.retval;
3843 break;
3844 }
3845 case y1f_zero:
3846 /* y1f(0) */
3847 {
3848 DOMAINF; NAMEF = (char *) "y1f";
3849 ifSVID
3850 {
3851 RETVAL_NEG_HUGEF;
3852 NOT_MATHERRF
3853 {
3854 WRITEF_Y1_ZERO;
3855 ERRNO_DOMAIN;
3856 }
3857 }
3858 else
3859 {
3860 RETVAL_NEG_HUGE_VALF;
3861 NOT_MATHERRF {ERRNO_DOMAIN;}
3862 }
3863 *(float *)retval = excf.retval;
3864 break;
3865 }
3866 case ynl_gt_loss:
3867 /* ynl > loss */
3868 {
3869 TLOSSL; NAMEL = (char *) "ynl";
3870 RETVAL_ZEROL;
3871 ifSVID
3872 {
3873 NOT_MATHERRL
3874 {
3875 WRITEL_YN_TLOSS;
3876 ERRNO_RANGE;
3877 }
3878 }
3879 else
3880 {
3881 NOT_MATHERRL {ERRNO_RANGE;}
3882 }
3883 *(long double *)retval = excl.retval;
3884 break;
3885 }
3886 case yn_gt_loss:
3887 /* yn > loss */
3888 {
3889 TLOSSD; NAMED = (char *) "yn";
3890 RETVAL_ZEROD;
3891 ifSVID
3892 {
3893 NOT_MATHERRD
3894 {
3895 WRITED_YN_TLOSS;
3896 ERRNO_RANGE;
3897 }
3898 }
3899 else
3900 {
3901 NOT_MATHERRD {ERRNO_RANGE;}
3902 }
3903 *(double*)retval = exc.retval;
3904 break;
3905 }
3906 case ynf_gt_loss:
3907 /* ynf > loss */
3908 {
3909 TLOSSF; NAMEF = (char *) "ynf";
3910 RETVAL_ZEROF;
3911 ifSVID
3912 {
3913 NOT_MATHERRF
3914 {
3915 WRITEF_YN_TLOSS;
3916 ERRNO_RANGE;
3917 }
3918 }
3919 else
3920 {
3921 NOT_MATHERRF {ERRNO_RANGE;}
3922 }
3923 *(float*)retval = excf.retval;
3924 break;
3925 }
3926 case ynl_zero:
3927 /* ynl(0) */
3928 {
3929 DOMAINL; NAMEL = (char *) "ynl";
3930 ifSVID
3931 {
3932 RETVAL_NEG_HUGEL;
3933 NOT_MATHERRL
3934 {
3935 WRITEL_YN_ZERO;
3936 ERRNO_DOMAIN;
3937 }
3938 }
3939 else
3940 {
3941 RETVAL_NEG_HUGE_VALL;
3942 NOT_MATHERRL {ERRNO_DOMAIN;}
3943 }
3944 *(long double *)retval = excl.retval;
3945 break;
3946 }
3947 case yn_zero:
3948 /* yn(0) */
3949 {
3950 DOMAIND; NAMED = (char *) "yn";
3951 ifSVID
3952 {
3953 RETVAL_NEG_HUGED;
3954 NOT_MATHERRD
3955 {
3956 WRITED_YN_ZERO;
3957 ERRNO_DOMAIN;
3958 }
3959 }
3960 else
3961 {
3962 RETVAL_NEG_HUGE_VALD;
3963 NOT_MATHERRD {ERRNO_DOMAIN;}
3964 }
3965 *(double *)retval = exc.retval;
3966 break;
3967 }
3968 case ynf_zero:
3969 /* ynf(0) */
3970 {
3971 DOMAINF; NAMEF = (char *) "ynf";
3972 ifSVID
3973 {
3974 RETVAL_NEG_HUGEF;
3975 NOT_MATHERRF
3976 {
3977 WRITEF_YN_ZERO;
3978 ERRNO_DOMAIN;
3979 }
3980 }
3981 else
3982 {
3983 RETVAL_NEG_HUGE_VALF;
3984 NOT_MATHERRF {ERRNO_DOMAIN;}
3985 }
3986 *(float *)retval = excf.retval;
3987 break;
3988 }
3989 case y0l_negative:
3990 /* y0l(x<0) */
3991 {
3992 DOMAINL; NAMEL = (char *) "y0l";
3993 ifSVID
3994 {
3995 RETVAL_NEG_HUGEL;
3996 NOT_MATHERRL
3997 {
3998 WRITEL_Y0_NEGATIVE;
3999 ERRNO_DOMAIN;
4000 }
4001 }
4002 else
4003 {
4004 RETVAL_NEG_HUGE_VALL;
4005 NOT_MATHERRL {ERRNO_DOMAIN;}
4006 }
4007 *(long double *)retval = excl.retval;
4008 break;
4009 }
4010 case y0_negative:
4011 /* y0(x<0) */
4012 {
4013 DOMAIND; NAMED = (char *) "y0";
4014 ifSVID
4015 {
4016 RETVAL_NEG_HUGED;
4017 NOT_MATHERRD
4018 {
4019 WRITED_Y0_NEGATIVE;
4020 ERRNO_DOMAIN;
4021 }
4022 }
4023 else
4024 {
4025 RETVAL_NEG_HUGE_VALD;
4026 NOT_MATHERRD {ERRNO_DOMAIN;}
4027 }
4028 *(double *)retval = exc.retval;
4029 break;
4030 }
4031 case y0f_negative:
4032 /* y0f(x<0) */
4033 {
4034 DOMAINF; NAMEF = (char *) "y0f";
4035 ifSVID
4036 {
4037 RETVAL_NEG_HUGEF;
4038 NOT_MATHERRF
4039 {
4040 WRITEF_Y0_NEGATIVE;
4041 ERRNO_DOMAIN;
4042 }
4043 }
4044 else
4045 {
4046 RETVAL_NEG_HUGE_VALF;
4047 NOT_MATHERRF {ERRNO_DOMAIN;}
4048 }
4049 *(float *)retval = excf.retval;
4050 break;
4051 }
4052 case y1l_negative:
4053 /* y1l(x<0) */
4054 {
4055 DOMAINL; NAMEL = (char *) "y1l";
4056 ifSVID
4057 {
4058 RETVAL_NEG_HUGEL;
4059 NOT_MATHERRL
4060 {
4061 WRITEL_Y1_NEGATIVE;
4062 ERRNO_DOMAIN;
4063 }
4064 }
4065 else
4066 {
4067 RETVAL_NEG_HUGE_VALL;
4068 NOT_MATHERRL {ERRNO_DOMAIN;}
4069 }
4070 *(long double *)retval = excl.retval;
4071 break;
4072 }
4073 case y1_negative:
4074 /* y1(x<0) */
4075 {
4076 DOMAIND; NAMED = (char *) "y1";
4077 ifSVID
4078 {
4079 RETVAL_NEG_HUGED;
4080 NOT_MATHERRD
4081 {
4082 WRITED_Y1_NEGATIVE;
4083 ERRNO_DOMAIN;
4084 }
4085 }
4086 else
4087 {
4088 RETVAL_NEG_HUGE_VALD;
4089 NOT_MATHERRD {ERRNO_DOMAIN;}
4090 }
4091 *(double *)retval = exc.retval;
4092 break;
4093 }
4094 case y1f_negative:
4095 /* y1f(x<0) */
4096 {
4097 DOMAINF; NAMEF = (char *) "y1f";
4098 ifSVID
4099 {
4100 RETVAL_NEG_HUGEF;
4101 NOT_MATHERRF
4102 {
4103 WRITEF_Y1_NEGATIVE;
4104 ERRNO_DOMAIN;
4105 }
4106 }
4107 else
4108 {
4109 RETVAL_NEG_HUGE_VALF;
4110 NOT_MATHERRF {ERRNO_DOMAIN;}
4111 }
4112 *(float *)retval = excf.retval;
4113 break;
4114 }
4115 case ynl_negative:
4116 /* ynl(x<0) */
4117 {
4118 DOMAINL; NAMEL = (char *) "ynl";
4119 ifSVID
4120 {
4121 RETVAL_NEG_HUGEL;
4122 NOT_MATHERRL
4123 {
4124 WRITEL_YN_NEGATIVE;
4125 ERRNO_DOMAIN;
4126 }
4127 }
4128 else
4129 {
4130 RETVAL_NEG_HUGE_VALL;
4131 NOT_MATHERRL {ERRNO_DOMAIN;}
4132 }
4133 *(long double *)retval = excl.retval;
4134 break;
4135 }
4136 case yn_negative:
4137 /* yn(x<0) */
4138 {
4139 DOMAIND; NAMED = (char *) "yn";
4140 ifSVID
4141 {
4142 RETVAL_NEG_HUGED;
4143 NOT_MATHERRD
4144 {
4145 WRITED_YN_NEGATIVE;
4146 ERRNO_DOMAIN;
4147 }
4148 }
4149 else
4150 {
4151 RETVAL_NEG_HUGE_VALD;
4152 NOT_MATHERRD {ERRNO_DOMAIN;}
4153 }
4154 *(double *)retval = exc.retval;
4155 break;
4156 }
4157 case ynf_negative:
4158 /* ynf(x<0) */
4159 {
4160 DOMAINF; NAMEF = (char *) "ynf";
4161 ifSVID
4162 {
4163 RETVAL_NEG_HUGEF;
4164 NOT_MATHERRF
4165 {
4166 WRITEF_YN_NEGATIVE;
4167 ERRNO_DOMAIN;
4168 }
4169 }
4170 else
4171 {
4172 RETVAL_NEG_HUGE_VALF;
4173 NOT_MATHERRF {ERRNO_DOMAIN;}
4174 }
4175 *(float *)retval = excf.retval;
4176 break;
4177 }
4178 case fmodl_by_zero:
4179 /* fmodl(x,0) */
4180 {
4181 DOMAINL; NAMEL = (char *) "fmodl";
4182 ifSVID
4183 {
4184 *(long double *)retval = *(long double *)arg1;
4185 NOT_MATHERRL
4186 {
4187 WRITEL_FMOD;
4188 ERRNO_DOMAIN;
4189 }
4190 }
4191 else
4192 { /* NaN already computed */
4193 NOT_MATHERRL {ERRNO_DOMAIN;}
4194 }
4195 *(long double *)retval = excl.retval;
4196 break;
4197 }
4198 case fmod_by_zero:
4199 /* fmod(x,0) */
4200 {
4201 DOMAIND; NAMED = (char *) "fmod";
4202 ifSVID
4203 {
4204 *(double *)retval = *(double *)arg1;
4205 NOT_MATHERRD
4206 {
4207 WRITED_FMOD;
4208 ERRNO_DOMAIN;
4209 }
4210 }
4211 else
4212 { /* NaN already computed */
4213 NOT_MATHERRD {ERRNO_DOMAIN;}
4214 }
4215 *(double *)retval = exc.retval;
4216 break;
4217 }
4218 case fmodf_by_zero:
4219 /* fmodf(x,0) */
4220 {
4221 DOMAINF; NAMEF = (char *) "fmodf";
4222 ifSVID
4223 {
4224 *(float *)retval = *(float *)arg1;
4225 NOT_MATHERRF
4226 {
4227 WRITEF_FMOD;
4228 ERRNO_DOMAIN;
4229 }
4230 }
4231 else
4232 {
4233 NOT_MATHERRF {ERRNO_DOMAIN;}
4234 }
4235 *(float *)retval = excf.retval;
4236 break;
4237 }
4238 case remainderl_by_zero:
4239 /* remainderl(x,0) */
4240 {
4241 DOMAINL; NAMEL = (char *) "remainderl";
4242 ifSVID
4243 {
4244 NOT_MATHERRL
4245 {
4246 WRITEL_REM;
4247 ERRNO_DOMAIN;
4248 }
4249 }
4250 else
4251 { /* NaN already computed */
4252 NOT_MATHERRL {ERRNO_DOMAIN;}
4253 }
4254 *(long double *)retval = excl.retval;
4255 break;
4256 }
4257 case remainder_by_zero:
4258 /* remainder(x,0) */
4259 {
4260 DOMAIND; NAMED = (char *) "remainder";
4261 ifSVID
4262 {
4263 NOT_MATHERRD
4264 {
4265 WRITED_REM;
4266 ERRNO_DOMAIN;
4267 }
4268 }
4269 else
4270 { /* NaN already computed */
4271 NOT_MATHERRD {ERRNO_DOMAIN;}
4272 }
4273 *(double *)retval = exc.retval;
4274 break;
4275 }
4276 case remainderf_by_zero:
4277 /* remainderf(x,0) */
4278 {
4279 DOMAINF; NAMEF = (char *) "remainderf";
4280 ifSVID
4281 {
4282 NOT_MATHERRF
4283 {
4284 WRITEF_REM;
4285 ERRNO_DOMAIN;
4286 }
4287 }
4288 else
4289 {
4290 NOT_MATHERRF {ERRNO_DOMAIN;}
4291 }
4292 *(float *)retval = excf.retval;
4293 break;
4294 }
4295 default:
4296 /* We don't want to abort () since SVID doesn't cover all math
4297 library functions. */
4298 break;
4299 }
4300 return;
4301 }
4302}
A mirror of the official glibc repository