improved <fenv.h> standards conformance

Author: ZERICO2005

src/libc/fenv.c

@@ -3,24 +3,58 @@
 const fenv_t __fe_dfl_env = FE_TONEAREST;
 fenv_t __fe_cur_env = __fe_dfl_env;
 
-extern inline int feclearexcept(int __excepts);
-
-extern inline int fegetexceptflag(fexcept_t *__flagp, int __excepts);
-
-extern inline int feraiseexcept(int __excepts);
-
-extern inline int fesetexceptflag(const fexcept_t *__flagp, int __excepts);
-
-extern inline int fetestexcept(int __excepts);
-
-extern inline int fegetround(void);
-
-extern inline int fesetround(int __rounding_mode);
-
-extern inline int fegetenv(fenv_t *__envp);
-
-extern inline int feholdexcept(fenv_t *__envp);
-
-extern inline int fesetenv(const fenv_t *__envp);
-
-extern inline int feupdateenv(const fenv_t *__envp);
+#undef feclearexcept
+#undef fegetexceptflag
+#undef feraiseexcept
+#undef fesetexceptflag
+#undef fetestexcept
+#undef fegetround
+#undef fesetround
+#undef fegetenv
+#undef feholdexcept
+#undef fesetenv
+#undef feupdateenv
+
+int feclearexcept(int __excepts) {
+    return __feclearexcept(__excepts);
+}
+
+int fegetexceptflag(fexcept_t *__flagp, int __excepts) {
+    return __fegetexceptflag(__flagp, __excepts);
+}
+
+int feraiseexcept(int __excepts) {
+    return __feraiseexcept(__excepts);
+}
+
+int fesetexceptflag(const fexcept_t *__flagp, int __excepts) {
+    return __fesetexceptflag(__flagp, __excepts);
+}
+
+int fetestexcept(int __excepts) {
+    return __fetestexcept(__excepts);
+}
+
+int fegetround(void) {
+    return __fegetround();
+}
+
+int fesetround(int __rounding_mode) {
+    return __fesetround(__rounding_mode);
+}
+
+int fegetenv(fenv_t *__envp) {
+    return __fegetenv(__envp);
+}
+
+int feholdexcept(fenv_t *__envp) {
+    return __feholdexcept(__envp);
+}
+
+int fesetenv(const fenv_t *__envp) {
+    return __fesetenv(__envp);
+}
+
+int feupdateenv(const fenv_t *__envp) {
+    return __feupdateenv(__envp);
+}

src/libc/include/fenv.h

@@ -34,52 +34,171 @@ typedef unsigned char fexcept_t;
 extern const fenv_t __fe_dfl_env;
 #define FE_DFL_ENV (&__fe_dfl_env)
 
-__BEGIN_DECLS
+//------------------------------------------------------------------------------
+// functions
+//------------------------------------------------------------------------------
 
-inline int feclearexcept(int __excepts) {
+static inline __attribute__((__always_inline__))
+int __feclearexcept(int __excepts) {
     return (__fe_cur_env &= ~((__excepts) & FE_ALL_EXCEPT), 0);
 }
 
-inline int fegetexceptflag(fexcept_t *__flagp, int __excepts) {
+static inline __attribute__((__always_inline__))
+int __fegetexceptflag(fexcept_t *__flagp, int __excepts) {
     return (*(__flagp) = __fe_cur_env & (__excepts) & FE_ALL_EXCEPT, 0);
 }
 
-inline int feraiseexcept(int __excepts) {
+static inline __attribute__((__always_inline__))
+int __feraiseexcept(int __excepts) {
     return (__fe_cur_env |= (__excepts) & FE_ALL_EXCEPT, 0);
 }
 
-inline int fesetexceptflag(const fexcept_t *__flagp, int __excepts) {
+static inline __attribute__((__always_inline__))
+int __fesetexceptflag(const fexcept_t *__flagp, int __excepts) {
     return (__fe_cur_env = (__fe_cur_env & ~((__excepts) & FE_ALL_EXCEPT)) | (*(__flagp) & (__excepts) & FE_ALL_EXCEPT), 0);
 }
 
-inline int fetestexcept(int __excepts) {
+static inline __attribute__((__always_inline__))
+int __fetestexcept(int __excepts) {
     return (__fe_cur_env & (__excepts) & FE_ALL_EXCEPT);
 }
 
-inline int fegetround(void) {
+static inline __attribute__((__always_inline__))
+int __fegetround(void) {
     return (__fe_cur_env & 3);
 }
 
-inline int fesetround(int __rounding_mode) {
+static inline __attribute__((__always_inline__))
+int __fesetround(int __rounding_mode) {
     return (__fe_cur_env = (__fe_cur_env & ~3) | ((__rounding_mode) & 3), 0);
 }
 
-inline int fegetenv(fenv_t *__envp) {
+static inline __attribute__((__always_inline__))
+int __fegetenv(fenv_t *__envp) {
     return (*(__envp) = __fe_cur_env, 0);
 }
 
-inline int feholdexcept(fenv_t *__envp) {
+static inline __attribute__((__always_inline__))
+int __feholdexcept(fenv_t *__envp) {
     return (*(__envp) = __fe_cur_env, __fe_cur_env &= ~FE_ALL_EXCEPT, 0);
 }
 
-inline int fesetenv(const fenv_t *__envp) {
+static inline __attribute__((__always_inline__))
+int __fesetenv(const fenv_t *__envp) {
     return (__fe_cur_env = *(__envp), 0);
 }
 
-inline int feupdateenv(const fenv_t *__envp) {
+static inline __attribute__((__always_inline__))
+int __feupdateenv(const fenv_t *__envp) {
     return (__fe_cur_env = (__fe_cur_env & FE_ALL_EXCEPT) | *(__envp), 0);
 }
 
+//------------------------------------------------------------------------------
+// prototypes
+//------------------------------------------------------------------------------
+
+__BEGIN_DECLS
+
+int feclearexcept(int __excepts) __NOEXCEPT;
+
+int fegetexceptflag(fexcept_t *__flagp, int __excepts) __NOEXCEPT;
+
+int feraiseexcept(int __excepts) __NOEXCEPT;
+
+int fesetexceptflag(const fexcept_t *__flagp, int __excepts) __NOEXCEPT;
+
+int fetestexcept(int __excepts) __NOEXCEPT_PURE;
+
+int fegetround(void) __NOEXCEPT_PURE;
+
+int fesetround(int __rounding_mode) __NOEXCEPT;
+
+int fegetenv(fenv_t *__envp) __NOEXCEPT;
+
+int feholdexcept(fenv_t *__envp) __NOEXCEPT;
+
+int fesetenv(const fenv_t *__envp) __NOEXCEPT;
+
+int feupdateenv(const fenv_t *__envp) __NOEXCEPT;
+
+#ifdef __cplusplus
+
+inline int feclearexcept(int __excepts) __NOEXCEPT {
+    return __feclearexcept(__excepts);
+}
+
+inline int fegetexceptflag(fexcept_t *__flagp, int __excepts) __NOEXCEPT {
+    return __fegetexceptflag(__flagp, __excepts);
+}
+
+inline int feraiseexcept(int __excepts) __NOEXCEPT {
+    return __feraiseexcept(__excepts);
+}
+
+inline int fesetexceptflag(const fexcept_t *__flagp, int __excepts) __NOEXCEPT {
+    return __fesetexceptflag(__flagp, __excepts);
+}
+
+inline int fetestexcept(int __excepts) __NOEXCEPT {
+    return __fetestexcept(__excepts);
+}
+
+inline int fegetround(void) __NOEXCEPT {
+    return __fegetround();
+}
+
+inline int fesetround(int __rounding_mode) __NOEXCEPT {
+    return __fesetround(__rounding_mode);
+}
+
+inline int fegetenv(fenv_t *__envp) __NOEXCEPT {
+    return __fegetenv(__envp);
+}
+
+inline int feholdexcept(fenv_t *__envp) __NOEXCEPT {
+    return __feholdexcept(__envp);
+}
+
+inline int fesetenv(const fenv_t *__envp) __NOEXCEPT {
+    return __fesetenv(__envp);
+}
+
+inline int feupdateenv(const fenv_t *__envp) __NOEXCEPT {
+    return __feupdateenv(__envp);
+}
+
+#endif /* __cplusplus */
+
 __END_DECLS
 
+//------------------------------------------------------------------------------
+// macros
+//------------------------------------------------------------------------------
+
+#ifndef __cplusplus
+
+#define feclearexcept(excepts) __feclearexcept(excepts)
+
+#define fegetexceptflag(flagp, excepts) __fegetexceptflag(flagp, excepts)
+
+#define feraiseexcept(excepts) __feraiseexcept(excepts)
+
+#define fesetexceptflag(flagp, excepts) __fesetexceptflag(flagp, excepts)
+
+#define fetestexcept(excepts) __fetestexcept(excepts)
+
+#define fegetround() __fegetround()
+
+#define fesetround(rounding_mode) __fesetround(rounding_mode)
+
+#define fegetenv(envp) __fegetenv(envp)
+
+#define feholdexcept(envp) __feholdexcept(envp)
+
+#define fesetenv(envp) __fesetenv(envp)
+
+#define feupdateenv(envp) __feupdateenv(envp)
+
+#endif /* __cplusplus */
+
 #endif /* _FENV_H */