tgmath fixes, better return type handling

diff --git a/include/tgmath.h b/include/tgmath.h
index bdfef62..09edf49 100644 (file)
--- a/include/tgmath.h
+++ b/include/tgmath.h
@@ -2,72 +2,79 @@
 #define _TGMATH_H
 
 /*
-tgmath.h is broken: return type is wrong
-(always the highest conversion rank type: long double [complex])
+tgmath.h is broken:
+with __GNUC__ the return type is wrong when all arguments are float [complex]
+without __GNUC__ the return type is always long double [complex]
 (imaginary type is not supported)
 */
 
 #include <math.h>
 #include <complex.h>
 
+#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))
-
-#define __FLT(x) (__IS_REAL((x)) && sizeof((x)) == sizeof(float))
-#define __LDBL(x) (__IS_REAL((x)) && sizeof((x)) == sizeof(long double))
-
-#define __FLTCX(x) (__IS_CX(x) && sizeof((x)) == sizeof(float 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) ( \
-       __FLT(x) ? __fun ## f (x) : \
-       __LDBL(x) ? __fun ## l (x) : \
-       __fun(x) )
-
-#define __tg_real_2_1(__fun, x, y) ( \
-       __FLT(x) ? __fun ## f (x, y) : \
-       __LDBL(x) ? __fun ## l (x, y) : \
-       __fun(x, y) )
-
-#define __tg_real_2(__fun, x, y) ( \
-       __FLT(x)  && __FLT(y) ? __fun ## f (x, y) : \
-       __LDBL(x) || __LDBL(y) ? __fun ## l (x, y) : \
-       __fun(x, y) )
-
-#define __tg_complex(__fun, x) ( \
-       __FLTCX(x) || __FLT(x) ? __fun ## f (x) : \
-       __LDBLCX(x) || __LDBL(x) ? __fun ## l (x) : \
-       __fun(x) )
-
-#define __tg_real_complex(__fun, 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) )
+#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))
+
+#define __FLT(x) (__IS_REAL(x) && sizeof(x) == sizeof(float))
+#define __LDBL(x) (__IS_REAL(x) && sizeof(x) == sizeof(long double))
+
+#define __FLTCX(x) (__IS_CX(x) && sizeof(x) == sizeof(float 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)( \
+       __FLT(x) ? fun ## f (x) : \
+       __LDBL(x) ? fun ## l (x) : \
+       fun(x) )
+
+#define __tg_real_2_1(fun, x, y) __RETCAST((x)+1.0)( \
+       __FLT(x) ? fun ## f (x, y) : \
+       __LDBL(x) ? fun ## l (x, y) : \
+       fun(x, y) )
+
+#define __tg_real_2(fun, x, y) __RETCAST((x)+(y)+1.0)( \
+       __FLT(x)  && __FLT(y) ? fun ## f (x, y) : \
+       __LDBL(x) || __LDBL(y) ? fun ## l (x, y) : \
+       fun(x, y) )
+
+#define __tg_complex(fun, x) __RETCAST((x)+1.0+I)( \
+       __FLTCX(x) || __FLT(x) ? fun ## f (x) : \
+       __LDBLCX(x) || __LDBL(x) ? fun ## l (x) : \
+       fun(x) )
+
+#define __tg_real_complex(fun, x) __RETCAST((x)+1.0)( \
+       __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) )
 
 /* special cases */
 
-#define __tg_real_remquo(x, y, z) ( \
+#define __tg_real_remquo(x, y, z) __RETCAST((x)+(y)+1.0)( \
        __FLT(x)  && __FLT(y) ? remquof(x, y, z) : \
        __LDBL(x) || __LDBL(y) ? remquol(x, y, z) : \
        remquo(x, y, z) )
 
-#define __tg_real_fma(x, y, z) ( \
+#define __tg_real_fma(x, y, z) __RETCAST((x)+(y)+(z)+1.0)( \
        __FLT(x) && __FLT(y) && __FLT(z) ? fmaf(x, y, z) : \
        __LDBL(x) || __LDBL(y) || __LDBL(z) ? fmal(x, y, z) : \
        fma(x, y, z) )
 
-#define __tg_real_complex_pow(x, y) ( \
+#define __tg_real_complex_pow(x, y) __RETCAST((x)+(y)+1.0)( \
        __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) )
 
-#define __tg_real_complex_fabs(x) ( \
+#define __tg_real_complex_fabs(x) __RETCAST((x)+1.0)( \
        __LDBLCX(x) ? cabsl(x) : \
        __DBLCX(x) ? cabs(x) : \
        __FLTCX(x) ? cabsf(x) : \