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