From: nsz Date: Sat, 10 Mar 2012 12:27:19 +0000 (+0100) Subject: tgmath.h improved return type with gcc X-Git-Url: http://nsz.repo.hu/git/?p=libm;a=commitdiff_plain;h=a8c7c8038b2e420020a9eef4a16afdac4ef03c74 tgmath.h improved return type with gcc --- diff --git a/include/tgmath.h b/include/tgmath.h index 6926d0f..e859252 100644 --- a/include/tgmath.h +++ b/include/tgmath.h @@ -2,8 +2,8 @@ #define _TGMATH_H /* -tgmath.h is broken: -with __GNUC__ the return type is wrong when all arguments are float [complex] +wrong when sizeof(double) == sizeof(long double) +with __GNUC__ the return type is broken in case of mixed float and int arguments without __GNUC__ the return type is always long double [complex] (imaginary type is not supported) */ @@ -11,12 +11,6 @@ without __GNUC__ the return type is always long double [complex] #include #include -#ifdef __GNUC__ -#define __RETCAST(x) (__typeof__((x))) -#else -#define __RETCAST(x) -#endif - #define __IS_FP(x) !!((1?1:(x))/2) #define __IS_CX(x) (__IS_FP(x) && sizeof(x) == sizeof((x)+I)) #define __IS_REAL(x) (__IS_FP(x) && 2*sizeof(x) == sizeof((x)+I)) @@ -28,57 +22,77 @@ without __GNUC__ the return type is always long double [complex] #define __DBLCX(x) (__IS_CX(x) && sizeof(x) == sizeof(double complex)) #define __LDBLCX(x) (__IS_CX(x) && sizeof(x) == sizeof(long double complex)) -#define __tg_real(fun, x) __RETCAST((x)+1.0)( \ +#ifdef __GNUC__ +/* typeof(x) if fp else double (using ?: with null pointers) */ +#define __RETCAST(x) (__typeof__(*( \ + 0 ? (__typeof__(0 ? (double *)0 : (void *)__IS_FP(x)))0 : \ + (__typeof__(0 ? (__typeof__(x) *)0 : (void *)!__IS_FP(x)))0 ))) +/* drop complex from the type of x */ +#define __TO_REAL(x) *( \ + 0 ? (__typeof__(0 ? (double *)0 : (void *)!__DBLCX(x)))0 : \ + 0 ? (__typeof__(0 ? (float *)0 : (void *)!__FLTCX(x)))0 : \ + 0 ? (__typeof__(0 ? (long double *)0 : (void *)!__LDBLCX(x)))0 : \ + (__typeof__(0 ? (__typeof__(x) *)0 : (void *)__IS_CX(x)))0 ) +#else +#define __RETCAST(x) +#endif + +#define __tg_real(fun, x) (__RETCAST(x)( \ __FLT(x) ? fun ## f (x) : \ __LDBL(x) ? fun ## l (x) : \ - fun(x) ) + fun(x) )) -#define __tg_real_2_1(fun, x, y) __RETCAST((x)+1.0)( \ +#define __tg_real_2_1(fun, x, y) (__RETCAST(x)( \ __FLT(x) ? fun ## f (x, y) : \ __LDBL(x) ? fun ## l (x, y) : \ - fun(x, y) ) + fun(x, y) )) -#define __tg_real_2(fun, x, y) __RETCAST((x)+(y)+1.0)( \ +#define __tg_real_2(fun, x, y) (__RETCAST((x)+(y))( \ __FLT(x) && __FLT(y) ? fun ## f (x, y) : \ __LDBL(x) || __LDBL(y) ? fun ## l (x, y) : \ - fun(x, y) ) + fun(x, y) )) + +#define __tg_complex(fun, x) (__RETCAST((x)+I)( \ + __FLTCX(x) || __FLT(x) ? fun ## f (x) : \ + __LDBLCX(x) || __LDBL(x) ? fun ## l (x) : \ + fun(x) )) -#define __tg_complex(fun, x) __RETCAST((x)+1.0+I)( \ +#define __tg_complex_retreal(fun, x) (__RETCAST(__TO_REAL(x))( \ __FLTCX(x) || __FLT(x) ? fun ## f (x) : \ __LDBLCX(x) || __LDBL(x) ? fun ## l (x) : \ - fun(x) ) + fun(x) )) -#define __tg_real_complex(fun, x) __RETCAST((x)+1.0)( \ +#define __tg_real_complex(fun, x) (__RETCAST(x)( \ __LDBLCX(x) ? c ## fun ## l (x) : \ __DBLCX(x) ? c ## fun (x) : \ __FLTCX(x) ? c ## fun ## f (x) : \ __FLT(x) ? fun ## f (x) : \ __LDBL(x) ? fun ## l (x) : \ - fun(x) ) + fun(x) )) /* special cases */ -#define __tg_real_remquo(x, y, z) __RETCAST((x)+(y)+1.0)( \ +#define __tg_real_remquo(x, y, z) (__RETCAST((x)+(y))( \ __FLT(x) && __FLT(y) ? remquof(x, y, z) : \ __LDBL(x) || __LDBL(y) ? remquol(x, y, z) : \ - remquo(x, y, z) ) + remquo(x, y, z) )) -#define __tg_real_fma(x, y, z) __RETCAST((x)+(y)+(z)+1.0)( \ +#define __tg_real_fma(x, y, z) (__RETCAST((x)+(y)+(z))( \ __FLT(x) && __FLT(y) && __FLT(z) ? fmaf(x, y, z) : \ __LDBL(x) || __LDBL(y) || __LDBL(z) ? fmal(x, y, z) : \ - fma(x, y, z) ) + fma(x, y, z) )) -#define __tg_real_complex_pow(x, y) __RETCAST((x)+(y)+1.0)( \ +#define __tg_real_complex_pow(x, y) (__RETCAST((x)+(y))( \ __LDBLCX(x) || __LDBLCX(y) ? cpowl(x, y) : \ __DBLCX(x) || __DBLCX(y) ? cpow(x, y) : \ __FLTCX(x) || __FLTCX(y) ? cpowf(x, y) : \ - __tg_real_2(pow, x, y) ) + __tg_real_2(pow, x, y) )) -#define __tg_real_complex_fabs(x) __RETCAST((x)+1.0)( \ +#define __tg_real_complex_fabs(x) (__RETCAST(__TO_REAL(x))( \ __LDBLCX(x) ? cabsl(x) : \ __DBLCX(x) ? cabs(x) : \ __FLTCX(x) ? cabsf(x) : \ - __tg_real(fabs, x) ) + __tg_real(fabs, x) )) /* tg functions */ @@ -89,16 +103,16 @@ without __GNUC__ the return type is always long double [complex] #define atan(x) __tg_real_complex(atan, (x)) #define atan2(x,y) __tg_real_2(atan2, (x), (y)) #define atanh(x) __tg_real_complex(atanh, (x)) -#define carg(x) __tg_complex(carg, (x)) +#define carg(x) __tg_complex_retreal(carg, (x)) #define cbrt(x) __tg_real(cbrt, (x)) #define ceil(x) __tg_real(ceil, (x)) -#define cimag(x) __tg_complex(cimag, (x)) +#define cimag(x) __tg_complex_retreal(cimag, (x)) #define conj(x) __tg_complex(conj, (x)) #define copysign(x,y) __tg_real_2(copysign, (x), (y)) #define cos(x) __tg_real_complex(cos, (x)) #define cosh(x) __tg_real_complex(cosh, (x)) #define cproj(x) __tg_complex(cproj, (x)) -#define creal(x) __tg_complex(creal, (x)) +#define creal(x) __tg_complex_retreal(creal, (x)) #define erf(x) __tg_real(erf, (x)) #define erfc(x) __tg_real(erfc, (x)) #define exp(x) __tg_real_complex(exp, (x))