/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
 */
/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include "libm.h"
#include "xpg6.h"	/* __xpg6 */
#include <stdio.h>
#include <float.h>		/* DBL_MAX, DBL_MIN */
#include <unistd.h>		/* write */
#if defined(__x86)
#include <ieeefp.h>
#undef	fp_class
#define	fp_class	fpclass
#define	fp_quiet	FP_QNAN
#endif
#include <errno.h>
#undef fflush
#include <sys/isa_defs.h>

/* INDENT OFF */
/*
 * Report libm exception error according to System V Interface Definition
 * (SVID).
 * Error mapping:
 *	1 -- acos(|x|>1)
 *	2 -- asin(|x|>1)
 *	3 -- atan2(+-0,+-0)
 *	4 -- hypot overflow
 *	5 -- cosh overflow
 *	6 -- exp overflow
 *	7 -- exp underflow
 *	8 -- y0(0)
 *	9 -- y0(-ve)
 *	10-- y1(0)
 *	11-- y1(-ve)
 *	12-- yn(0)
 *	13-- yn(-ve)
 *	14-- lgamma(finite) overflow
 *	15-- lgamma(-integer)
 *	16-- log(0)
 *	17-- log(x<0)
 *	18-- log10(0)
 *	19-- log10(x<0)
 *	20-- pow(0.0,0.0)
 *	21-- pow(x,y) overflow
 *	22-- pow(x,y) underflow
 *	23-- pow(0,negative)
 *	24-- pow(neg,non-integral)
 *	25-- sinh(finite) overflow
 *	26-- sqrt(negative)
 *	27-- fmod(x,0)
 *	28-- remainder(x,0)
 *	29-- acosh(x<1)
 *	30-- atanh(|x|>1)
 *	31-- atanh(|x|=1)
 *	32-- scalb overflow
 *	33-- scalb underflow
 *	34-- j0(|x|>X_TLOSS)
 *	35-- y0(x>X_TLOSS)
 *	36-- j1(|x|>X_TLOSS)
 *	37-- y1(x>X_TLOSS)
 *	38-- jn(|x|>X_TLOSS, n)
 *	39-- yn(x>X_TLOSS, n)
 *	40-- gamma(finite) overflow
 *	41-- gamma(-integer)
 *	42-- pow(NaN,0.0) return NaN for SVID/XOPEN
 *	43-- log1p(-1)
 *	44-- log1p(x<-1)
 *	45-- logb(0)
 *	46-- nextafter overflow
 *	47-- scalb(x,inf)
 */
/* INDENT ON */

static double setexception(int, double);

static const union {
	unsigned	x[2];
	double		d;
} C[] = {
#ifdef _LITTLE_ENDIAN
	{ 0xffffffff, 0x7fffffff },
	{ 0x54442d18, 0x400921fb },
#else
	{ 0x7fffffff, 0xffffffff },
	{ 0x400921fb, 0x54442d18 },
#endif
};

#define	NaN	C[0].d
#define	PI_RZ	C[1].d

#define	__HI(x)	((unsigned *)&x)[HIWORD]
#define	__LO(x)	((unsigned *)&x)[LOWORD]
#undef	Inf
#define	Inf	HUGE_VAL

double
_SVID_libm_err(double x, double y, int type) {
	struct exception	exc;
	double			t, w, ieee_retval = 0;
	enum version		lib_version = _lib_version;
	int			iy;

	/* force libm_ieee behavior in SUSv3 mode */
	if ((__xpg6 & _C99SUSv3_math_errexcept) != 0)
		lib_version = libm_ieee;
	if (lib_version == c_issue_4) {
		(void) fflush(stdout);
	}
	exc.arg1 = x;
	exc.arg2 = y;
	switch (type) {
	case 1:
		/* acos(|x|>1) */
		exc.type = DOMAIN;
		exc.name = "acos";
		ieee_retval = setexception(3, 1.0);
		exc.retval = 0.0;
		if (lib_version == strict_ansi) {
			errno = EDOM;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, "acos: DOMAIN error\n", 19);
			}
			errno = EDOM;
		}
		break;
	case 2:
		/* asin(|x|>1) */
		exc.type = DOMAIN;
		exc.name = "asin";
		exc.retval = 0.0;
		ieee_retval = setexception(3, 1.0);
		if (lib_version == strict_ansi) {
			errno = EDOM;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, "asin: DOMAIN error\n", 19);
			}
			errno = EDOM;
		}
		break;
	case 3:
		/* atan2(+-0,+-0) */
		exc.arg1 = y;
		exc.arg2 = x;
		exc.type = DOMAIN;
		exc.name = "atan2";
		ieee_retval = copysign(1.0, x) == 1.0 ? y :
			copysign(PI_RZ + DBL_MIN, y);
		exc.retval = 0.0;
		if (lib_version == strict_ansi) {
			errno = EDOM;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, "atan2: DOMAIN error\n", 20);
			}
			errno = EDOM;
		}
		break;
	case 4:
		/* hypot(finite,finite) overflow */
		exc.type = OVERFLOW;
		exc.name = "hypot";
		ieee_retval = Inf;
		if (lib_version == c_issue_4)
			exc.retval = HUGE;
		else
			exc.retval = HUGE_VAL;
		if (lib_version == strict_ansi)
			errno = ERANGE;
		else if (!matherr(&exc))
			errno = ERANGE;
		break;
	case 5:
		/* cosh(finite) overflow */
		exc.type = OVERFLOW;
		exc.name = "cosh";
		ieee_retval = setexception(2, 1.0);
		if (lib_version == c_issue_4)
			exc.retval = HUGE;
		else
			exc.retval = HUGE_VAL;
		if (lib_version == strict_ansi)
			errno = ERANGE;
		else if (!matherr(&exc))
			errno = ERANGE;
		break;
	case 6:
		/* exp(finite) overflow */
		exc.type = OVERFLOW;
		exc.name = "exp";
		ieee_retval = setexception(2, 1.0);
		if (lib_version == c_issue_4)
			exc.retval = HUGE;
		else
			exc.retval = HUGE_VAL;
		if (lib_version == strict_ansi)
			errno = ERANGE;
		else if (!matherr(&exc))
			errno = ERANGE;
		break;
	case 7:
		/* exp(finite) underflow */
		exc.type = UNDERFLOW;
		exc.name = "exp";
		ieee_retval = setexception(1, 1.0);
		exc.retval = 0.0;
		if (lib_version == strict_ansi)
			errno = ERANGE;
		else if (!matherr(&exc))
			errno = ERANGE;
		break;
	case 8:
		/* y0(0) = -inf */
		exc.type = DOMAIN;	/* should be SING for IEEE */
		exc.name = "y0";
		ieee_retval = setexception(0, -1.0);
		if (lib_version == c_issue_4)
			exc.retval = -HUGE;
		else
			exc.retval = -HUGE_VAL;
		if (lib_version == strict_ansi) {
			errno = EDOM;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, "y0: DOMAIN error\n", 17);
			}
			errno = EDOM;
		}
		break;
	case 9:
		/* y0(x<0) = NaN */
		exc.type = DOMAIN;
		exc.name = "y0";
		ieee_retval = setexception(3, 1.0);
		if (lib_version == c_issue_4)
			exc.retval = -HUGE;
		else
			exc.retval = -HUGE_VAL;
		if (lib_version == strict_ansi) {
			errno = EDOM;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, "y0: DOMAIN error\n", 17);
			}
			errno = EDOM;
		}
		break;
	case 10:
		/* y1(0) = -inf */
		exc.type = DOMAIN;	/* should be SING for IEEE */
		exc.name = "y1";
		ieee_retval = setexception(0, -1.0);
		if (lib_version == c_issue_4)
			exc.retval = -HUGE;
		else
			exc.retval = -HUGE_VAL;
		if (lib_version == strict_ansi) {
			errno = EDOM;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, "y1: DOMAIN error\n", 17);
			}
			errno = EDOM;
		}
		break;
	case 11:
		/* y1(x<0) = NaN */
		exc.type = DOMAIN;
		exc.name = "y1";
		ieee_retval = setexception(3, 1.0);
		if (lib_version == c_issue_4)
			exc.retval = -HUGE;
		else
			exc.retval = -HUGE_VAL;
		if (lib_version == strict_ansi) {
			errno = EDOM;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, "y1: DOMAIN error\n", 17);
			}
			errno = EDOM;
		}
		break;
	case 12:
		/* yn(n,0) = -inf */
		exc.type = DOMAIN;	/* should be SING for IEEE */
		exc.name = "yn";
		ieee_retval = setexception(0, -1.0);
		if (lib_version == c_issue_4)
			exc.retval = -HUGE;
		else
			exc.retval = -HUGE_VAL;
		if (lib_version == strict_ansi) {
			errno = EDOM;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, "yn: DOMAIN error\n", 17);
			}
			errno = EDOM;
		}
		break;
	case 13:
		/* yn(x<0) = NaN */
		exc.type = DOMAIN;
		exc.name = "yn";
		ieee_retval = setexception(3, 1.0);
		if (lib_version == c_issue_4)
			exc.retval = -HUGE;
		else
			exc.retval = -HUGE_VAL;
		if (lib_version == strict_ansi) {
			errno = EDOM;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, "yn: DOMAIN error\n", 17);
			}
			errno = EDOM;
		}
		break;
	case 14:
		/* lgamma(finite) overflow */
		exc.type = OVERFLOW;
		exc.name = "lgamma";
		ieee_retval = setexception(2, 1.0);
		if (lib_version == c_issue_4)
			exc.retval = HUGE;
		else
			exc.retval = HUGE_VAL;
		if (lib_version == strict_ansi)
			errno = ERANGE;
		else if (!matherr(&exc))
			errno = ERANGE;
		break;
	case 15:
		/* lgamma(-integer) or lgamma(0) */
		exc.type = SING;
		exc.name = "lgamma";
		ieee_retval = setexception(0, 1.0);
		if (lib_version == c_issue_4)
			exc.retval = HUGE;
		else
			exc.retval = HUGE_VAL;
		if (lib_version == strict_ansi) {
			errno = EDOM;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, "lgamma: SING error\n", 19);
			}
			errno = EDOM;
		}
		break;
	case 16:
		/* log(0) */
		exc.type = SING;
		exc.name = "log";
		ieee_retval = setexception(0, -1.0);
		if (lib_version == c_issue_4)
			exc.retval = -HUGE;
		else
			exc.retval = -HUGE_VAL;
		if (lib_version == strict_ansi) {
			errno = ERANGE;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, "log: SING error\n", 16);
				errno = EDOM;
			} else {
				errno = ERANGE;
			}
		}
		break;
	case 17:
		/* log(x<0) */
		exc.type = DOMAIN;
		exc.name = "log";
		ieee_retval = setexception(3, 1.0);
		if (lib_version == c_issue_4)
			exc.retval = -HUGE;
		else
			exc.retval = -HUGE_VAL;
		if (lib_version == strict_ansi) {
			errno = EDOM;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, "log: DOMAIN error\n", 18);
			}
			errno = EDOM;
		}
		break;
	case 18:
		/* log10(0) */
		exc.type = SING;
		exc.name = "log10";
		ieee_retval = setexception(0, -1.0);
		if (lib_version == c_issue_4)
			exc.retval = -HUGE;
		else
			exc.retval = -HUGE_VAL;
		if (lib_version == strict_ansi) {
			errno = ERANGE;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, "log10: SING error\n", 18);
				errno = EDOM;
			} else {
				errno = ERANGE;
			}
		}
		break;
	case 19:
		/* log10(x<0) */
		exc.type = DOMAIN;
		exc.name = "log10";
		ieee_retval = setexception(3, 1.0);
		if (lib_version == c_issue_4)
			exc.retval = -HUGE;
		else
			exc.retval = -HUGE_VAL;
		if (lib_version == strict_ansi) {
			errno = EDOM;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, "log10: DOMAIN error\n", 20);
			}
			errno = EDOM;
		}
		break;
	case 20:
		/* pow(0.0,0.0) */
		/* error only if lib_version == c_issue_4 */
		exc.type = DOMAIN;
		exc.name = "pow";
		exc.retval = 0.0;
		ieee_retval = 1.0;
		if (lib_version != c_issue_4) {
			exc.retval = 1.0;
		} else if (!matherr(&exc)) {
			(void) write(2, "pow(0,0): DOMAIN error\n", 23);
			errno = EDOM;
		}
		break;
	case 21:
		/* pow(x,y) overflow */
		exc.type = OVERFLOW;
		exc.name = "pow";
		exc.retval = (lib_version == c_issue_4)? HUGE : HUGE_VAL;
		if (signbit(x)) {
			t = rint(y);
			if (t == y) {
				w = rint(0.5 * y);
				if (t != w + w)	{	/* y is odd */
					exc.retval = -exc.retval;
				}
			}
		}
		ieee_retval = setexception(2, exc.retval);
		if (lib_version == strict_ansi)
			errno = ERANGE;
		else if (!matherr(&exc))
			errno = ERANGE;
		break;
	case 22:
		/* pow(x,y) underflow */
		exc.type = UNDERFLOW;
		exc.name = "pow";
		exc.retval = 0.0;
		if (signbit(x)) {
			t = rint(y);
			if (t == y) {
				w = rint(0.5 * y);
				if (t != w + w)	/* y is odd */
					exc.retval = -exc.retval;
			}
		}
		ieee_retval = setexception(1, exc.retval);
		if (lib_version == strict_ansi)
			errno = ERANGE;
		else if (!matherr(&exc))
			errno = ERANGE;
		break;
	case 23:
		/* (+-0)**neg */
		exc.type = DOMAIN;
		exc.name = "pow";
		ieee_retval = setexception(0, 1.0);
		{
			int ahy, k, j, yisint, ly, hx;
			/* INDENT OFF */
			/*
			 * determine if y is an odd int when x = -0
			 * yisint = 0       ... y is not an integer
			 * yisint = 1       ... y is an odd int
			 * yisint = 2       ... y is an even int
			 */
			/* INDENT ON */
			hx  = __HI(x);
			ahy = __HI(y)&0x7fffffff;
			ly  = __LO(y);

			yisint = 0;
			if (ahy >= 0x43400000) {
				yisint = 2;	/* even integer y */
			} else if (ahy >= 0x3ff00000) {
				k = (ahy >> 20) - 0x3ff;	/* exponent */
				if (k > 20) {
					j = ly >> (52 - k);
					if ((j << (52 - k)) == ly)
						yisint = 2 - (j & 1);
				} else if (ly == 0) {
					j = ahy >> (20 - k);
					if ((j << (20 - k)) == ahy)
						yisint = 2 - (j & 1);
				}
			}
			if (hx < 0 && yisint == 1)
				ieee_retval = -ieee_retval;
		}
		if (lib_version == c_issue_4)
			exc.retval = 0.0;
		else
			exc.retval = -HUGE_VAL;
		if (lib_version == strict_ansi) {
			errno = EDOM;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, "pow(0,neg): DOMAIN error\n",
				    25);
			}
			errno = EDOM;
		}
		break;
	case 24:
		/* neg**non-integral */
		exc.type = DOMAIN;
		exc.name = "pow";
		ieee_retval = setexception(3, 1.0);
		if (lib_version == c_issue_4)
			exc.retval = 0.0;
		else
			exc.retval = ieee_retval;	/* X/Open allow NaN */
		if (lib_version == strict_ansi) {
			errno = EDOM;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2,
				    "neg**non-integral: DOMAIN error\n", 32);
			}
			errno = EDOM;
		}
		break;
	case 25:
		/* sinh(finite) overflow */
		exc.type = OVERFLOW;
		exc.name = "sinh";
		ieee_retval = copysign(Inf, x);
		if (lib_version == c_issue_4)
			exc.retval = x > 0.0 ? HUGE : -HUGE;
		else
			exc.retval = x > 0.0 ? HUGE_VAL : -HUGE_VAL;
		if (lib_version == strict_ansi)
			errno = ERANGE;
		else if (!matherr(&exc))
			errno = ERANGE;
		break;
	case 26:
		/* sqrt(x<0) */
		exc.type = DOMAIN;
		exc.name = "sqrt";
		ieee_retval = setexception(3, 1.0);
		if (lib_version == c_issue_4)
			exc.retval = 0.0;
		else
			exc.retval = ieee_retval;	/* quiet NaN */
		if (lib_version == strict_ansi) {
			errno = EDOM;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, "sqrt: DOMAIN error\n", 19);
			}
			errno = EDOM;
		}
		break;
	case 27:
		/* fmod(x,0) */
		exc.type = DOMAIN;
		exc.name = "fmod";
		if (fp_class(x) == fp_quiet)
			ieee_retval = NaN;
		else
			ieee_retval = setexception(3, 1.0);
		if (lib_version == c_issue_4)
			exc.retval = x;
		else
			exc.retval = ieee_retval;
		if (lib_version == strict_ansi) {
			errno = EDOM;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, "fmod:  DOMAIN error\n", 20);
			}
			errno = EDOM;
		}
		break;
	case 28:
		/* remainder(x,0) */
		exc.type = DOMAIN;
		exc.name = "remainder";
		if (fp_class(x) == fp_quiet)
			ieee_retval = NaN;
		else
			ieee_retval = setexception(3, 1.0);
		exc.retval = NaN;
		if (lib_version == strict_ansi) {
			errno = EDOM;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, "remainder: DOMAIN error\n",
				    24);
			}
			errno = EDOM;
		}
		break;
	case 29:
		/* acosh(x<1) */
		exc.type = DOMAIN;
		exc.name = "acosh";
		ieee_retval = setexception(3, 1.0);
		exc.retval = NaN;
		if (lib_version == strict_ansi) {
			errno = EDOM;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, "acosh: DOMAIN error\n", 20);
			}
			errno = EDOM;
		}
		break;
	case 30:
		/* atanh(|x|>1) */
		exc.type = DOMAIN;
		exc.name = "atanh";
		ieee_retval = setexception(3, 1.0);
		exc.retval = NaN;
		if (lib_version == strict_ansi) {
			errno = EDOM;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, "atanh: DOMAIN error\n", 20);
			}
			errno = EDOM;
		}
		break;
	case 31:
		/* atanh(|x|=1) */
		exc.type = SING;
		exc.name = "atanh";
		ieee_retval = setexception(0, x);
		exc.retval = ieee_retval;
		if (lib_version == strict_ansi) {
			errno = ERANGE;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, "atanh: SING error\n", 18);
				errno = EDOM;
			} else {
				errno = ERANGE;
			}
		}
		break;
	case 32:
		/* scalb overflow; SVID also returns +-HUGE_VAL */
		exc.type = OVERFLOW;
		exc.name = "scalb";
		ieee_retval = setexception(2, x);
		exc.retval = x > 0.0 ? HUGE_VAL : -HUGE_VAL;
		if (lib_version == strict_ansi)
			errno = ERANGE;
		else if (!matherr(&exc))
			errno = ERANGE;
		break;
	case 33:
		/* scalb underflow */
		exc.type = UNDERFLOW;
		exc.name = "scalb";
		ieee_retval = setexception(1, x);
		exc.retval = ieee_retval;	/* +-0.0 */
		if (lib_version == strict_ansi)
			errno = ERANGE;
		else if (!matherr(&exc))
			errno = ERANGE;
		break;
	case 34:
		/* j0(|x|>X_TLOSS) */
		exc.type = TLOSS;
		exc.name = "j0";
		exc.retval = 0.0;
		ieee_retval = y;
		if (lib_version == strict_ansi) {
			errno = ERANGE;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, exc.name, 2);
				(void) write(2, ": TLOSS error\n", 14);
			}
			errno = ERANGE;
		}
		break;
	case 35:
		/* y0(x>X_TLOSS) */
		exc.type = TLOSS;
		exc.name = "y0";
		exc.retval = 0.0;
		ieee_retval = y;
		if (lib_version == strict_ansi) {
			errno = ERANGE;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, exc.name, 2);
				(void) write(2, ": TLOSS error\n", 14);
			}
			errno = ERANGE;
		}
		break;
	case 36:
		/* j1(|x|>X_TLOSS) */
		exc.type = TLOSS;
		exc.name = "j1";
		exc.retval = 0.0;
		ieee_retval = y;
		if (lib_version == strict_ansi) {
			errno = ERANGE;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, exc.name, 2);
				(void) write(2, ": TLOSS error\n", 14);
			}
			errno = ERANGE;
		}
		break;
	case 37:
		/* y1(x>X_TLOSS) */
		exc.type = TLOSS;
		exc.name = "y1";
		exc.retval = 0.0;
		ieee_retval = y;
		if (lib_version == strict_ansi) {
			errno = ERANGE;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, exc.name, 2);
				(void) write(2, ": TLOSS error\n", 14);
			}
			errno = ERANGE;
		}
		break;
	case 38:
		/* jn(|x|>X_TLOSS) */
		/* incorrect ieee value: ieee should never be here */
		exc.type = TLOSS;
		exc.name = "jn";
		exc.retval = 0.0;
		ieee_retval = 0.0;	/* shall not be used */
		if (lib_version == strict_ansi) {
			errno = ERANGE;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, exc.name, 2);
				(void) write(2, ": TLOSS error\n", 14);
			}
			errno = ERANGE;
		}
		break;
	case 39:
		/* yn(x>X_TLOSS) */
		/* incorrect ieee value: ieee should never be here */
		exc.type = TLOSS;
		exc.name = "yn";
		exc.retval = 0.0;
		ieee_retval = 0.0;	/* shall not be used */
		if (lib_version == strict_ansi) {
			errno = ERANGE;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, exc.name, 2);
				(void) write(2, ": TLOSS error\n", 14);
			}
			errno = ERANGE;
		}
		break;
	case 40:
		/* gamma(finite) overflow */
		exc.type = OVERFLOW;
		exc.name = "gamma";
		ieee_retval = setexception(2, 1.0);
		if (lib_version == c_issue_4)
			exc.retval = HUGE;
		else
			exc.retval = HUGE_VAL;
		if (lib_version == strict_ansi)
			errno = ERANGE;
		else if (!matherr(&exc))
			errno = ERANGE;
		break;
	case 41:
		/* gamma(-integer) or gamma(0) */
		exc.type = SING;
		exc.name = "gamma";
		ieee_retval = setexception(0, 1.0);
		if (lib_version == c_issue_4)
			exc.retval = HUGE;
		else
			exc.retval = HUGE_VAL;
		if (lib_version == strict_ansi) {
			errno = EDOM;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, "gamma: SING error\n", 18);
			}
			errno = EDOM;
		}
		break;
	case 42:
		/* pow(NaN,0.0) */
		/* error if lib_version == c_issue_4 or ansi_1 */
		exc.type = DOMAIN;
		exc.name = "pow";
		exc.retval = x;
		ieee_retval = 1.0;
		if (lib_version == strict_ansi) {
			exc.retval = 1.0;
		} else if (!matherr(&exc)) {
			if ((lib_version == c_issue_4) || (lib_version == ansi_1))
				errno = EDOM;
		}
		break;
	case 43:
		/* log1p(-1) */
		exc.type = SING;
		exc.name = "log1p";
		ieee_retval = setexception(0, -1.0);
		if (lib_version == c_issue_4)
			exc.retval = -HUGE;
		else
			exc.retval = -HUGE_VAL;
		if (lib_version == strict_ansi) {
			errno = ERANGE;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, "log1p: SING error\n", 18);
				errno = EDOM;
			} else {
				errno = ERANGE;
			}
		}
		break;
	case 44:
		/* log1p(x<-1) */
		exc.type = DOMAIN;
		exc.name = "log1p";
		ieee_retval = setexception(3, 1.0);
		exc.retval = ieee_retval;
		if (lib_version == strict_ansi) {
			errno = EDOM;
		} else if (!matherr(&exc)) {
			if (lib_version == c_issue_4) {
				(void) write(2, "log1p: DOMAIN error\n", 20);
			}
			errno = EDOM;
		}
		break;
	case 45:
		/* logb(0) */
		exc.type = DOMAIN;
		exc.name = "logb";
		ieee_retval = setexception(0, -1.0);
		exc.retval = -HUGE_VAL;
		if (lib_version == strict_ansi)
			errno = EDOM;
		else if (!matherr(&exc))
			errno = EDOM;
		break;
	case 46:
		/* nextafter overflow */
		exc.type = OVERFLOW;
		exc.name = "nextafter";
		/*
		 * The value as returned by setexception is +/-DBL_MAX in
		 * round-to-{zero,-/+Inf} mode respectively, which is not
		 * usable.
		 */
		(void) setexception(2, x);
		ieee_retval = x > 0 ? Inf : -Inf;
		exc.retval = x > 0 ? HUGE_VAL : -HUGE_VAL;
		if (lib_version == strict_ansi)
			errno = ERANGE;
		else if (!matherr(&exc))
			errno = ERANGE;
		break;
	case 47:
		/* scalb(x,inf) */
		iy = ((int *)&y)[HIWORD];
		if (lib_version == c_issue_4)
			/* SVID3: ERANGE in all cases */
			errno = ERANGE;
		else if ((x == 0.0 && iy > 0) || (!finite(x) && iy < 0))
			/* EDOM for scalb(0,+inf) or scalb(inf,-inf) */
			errno = EDOM;
		exc.retval = ieee_retval = ((iy < 0)? x / -y : x * y);
		break;
	}
	switch (lib_version) {
	case c_issue_4:
	case ansi_1:
	case strict_ansi:
		return (exc.retval);
		/* NOTREACHED */
	default:
		return (ieee_retval);
	}
	/* NOTREACHED */
}

static double
setexception(int n, double x) {
	/*
	 * n =
	 * 0	division by zero
	 * 1	underflow
	 * 2	overflow
	 * 3	invalid
	 */
	volatile double one = 1.0, zero = 0.0, retv;

	switch (n) {
	case 0:		/* division by zero */
		retv = copysign(one / zero, x);
		break;
	case 1:		/* underflow */
		retv = DBL_MIN * copysign(DBL_MIN, x);
		break;
	case 2:		/* overflow */
		retv = DBL_MAX * copysign(DBL_MAX, x);
		break;
	case 3:		/* invalid */
		retv = zero * Inf;	/* for Cheetah */
		break;
	}
	return (retv);
}