GNU bug report logs - #12381
Assume C89 or later for math functions.

Previous Next

To add a comment to this bug, you must first unarchive it, by sending
a message to control AT debbugs.gnu.org, with unarchive 12381 in the body.
You can then email your comments to 12381 AT debbugs.gnu.org in the normal way.

Toggle the display of automated, internal messages from the tracker.

Message #5 received at submit <at> debbugs.gnu.org (full text, mbox):

From: Paul Eggert <eggert <at> cs.ucla.edu>
To: bug-gnu-emacs <at> gnu.org
Cc: Eli Zaretskii <eliz <at> gnu.org>
Subject: Assume C89 or later for math functions.
Date: Fri, 07 Sep 2012 13:22:38 -0700

In doing signal-handling cleanup I ran afoul of a lot of crufty old
floating-point code that hasn't been needed in Emacs for many years.
Since it's getting in the way of improving Emacs I plan to install
the following patch to clean out the cruft.  I don't think this
affects the Windows port but am CC'ing to Eli just in case.

=== modified file 'ChangeLog'
--- ChangeLog	2012-09-07 08:46:44 +0000
+++ ChangeLog	2012-09-07 20:19:01 +0000
@@ -1,5 +1,12 @@
 2012-09-07  Paul Eggert  <eggert <at> cs.ucla.edu>
 
+	Assume C89 or later for math functions.
+	* configure.ac (frexp, fmod): Remove checks for these functions,
+	as we now assume them.
+	(FLOAT_CHECK_DOMAIN, HAVE_INVERSE_HYPERBOLIC, NO_MATHERR)
+	(HAVE_EXCEPTION):
+	Remove; no longer needed.
+
 	More signal-handler cleanup (Bug#12327).
 	* configure.ac (FLOAT_CHECK_DOMAIN): Comment fix (Bug#12327).
 

=== modified file 'admin/CPP-DEFINES'
--- admin/CPP-DEFINES	2012-09-04 17:34:54 +0000
+++ admin/CPP-DEFINES	2012-09-07 20:04:44 +0000
@@ -107,7 +107,6 @@
 EMACS_CONFIG_OPTIONS
 EMACS_INT
 EMACS_UINT
-FLOAT_CHECK_DOMAIN
 GC_MARK_SECONDARY_STACK
 GC_MARK_STACK
 GC_SETJMP_WORKS
@@ -158,12 +157,10 @@
 HAVE_ENVIRON_DECL
 HAVE_EUIDACCESS
 HAVE_FCNTL_H
-HAVE_FMOD
 HAVE_FORK
 HAVE_FPATHCONF
 HAVE_FREEIFADDRS
 HAVE_FREETYPE
-HAVE_FREXP
 HAVE_FSEEKO
 HAVE_FSYNC
 HAVE_FUTIMENS
@@ -217,7 +214,6 @@
 HAVE_IMAGEMAGICK
 HAVE_INET_SOCKETS
 HAVE_INTTYPES_H
-HAVE_INVERSE_HYPERBOLIC
 HAVE_JPEG
 HAVE_KERBEROSIV_DES_H
 HAVE_KERBEROSIV_KRB_H
@@ -429,7 +425,6 @@
 MAXPATHLEN
 NLIST_STRUCT
 NO_EDITRES
-NO_MATHERR
 NO_TERMIO
 NSIG
 NSIG_MINIMUM

=== modified file 'admin/ChangeLog'
--- admin/ChangeLog	2012-09-04 17:34:54 +0000
+++ admin/ChangeLog	2012-09-07 20:04:44 +0000
@@ -1,3 +1,9 @@
+2012-09-07  Paul Eggert  <eggert <at> cs.ucla.edu>
+
+	Assume C89 or later for math functions.
+	* CPP-DEFINES (HAVE_FMOD, HAVE_FREXP, FLOAT_CHECK_DOMAIN)
+	(HAVE_INVERSE_HYPERBOLIC, NO_MATHERR): Remove.
+
 2012-09-04  Paul Eggert  <eggert <at> cs.ucla.edu>
 
 	Simplify redefinition of 'abort' (Bug#12316).

=== modified file 'configure.ac'
--- configure.ac	2012-09-07 08:46:44 +0000
+++ configure.ac	2012-09-07 20:19:01 +0000
@@ -1302,17 +1302,6 @@
   	   [Define to 1 if `speed_t' is declared by <termios.h>.])
 fi
 
-AC_CACHE_CHECK(for struct exception, emacs_cv_struct_exception,
-AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <math.h>]],
-[[static struct exception x; x.arg1 = x.arg2 = x.retval; x.name = ""; x.type = 1;]])],
-  emacs_cv_struct_exception=yes, emacs_cv_struct_exception=no))
-HAVE_EXCEPTION=$emacs_cv_struct_exception
-dnl Define on Darwin so emacs symbols will not conflict with those
-dnl in the System framework.  Otherwise -prebind will not work.
-if test $emacs_cv_struct_exception != yes || test $opsys = darwin; then
-  AC_DEFINE(NO_MATHERR, 1, [Define to 1 if you don't have struct exception in math.h.])
-fi
-
 AC_CHECK_HEADERS_ONCE(sys/socket.h)
 AC_CHECK_HEADERS(net/if.h, , , [AC_INCLUDES_DEFAULT
 #if HAVE_SYS_SOCKET_H
@@ -2781,7 +2770,7 @@
 
 AC_CHECK_FUNCS(gethostname \
 closedir getrusage get_current_dir_name \
-lrand48 logb frexp fmod cbrt setsid \
+lrand48 logb cbrt setsid \
 fpathconf select euidaccess getpagesize setlocale \
 utimes getrlimit setrlimit setpgid getcwd shutdown getaddrinfo \
 __fpending strsignal setitimer \
@@ -3211,12 +3200,6 @@
   so that Emacs can tell instantly when you try to modify a file that
   someone else has modified in his/her Emacs.])
 
-AH_TEMPLATE(FLOAT_CHECK_DOMAIN, [Define if the float library doesn't
-  handle errors by either setting errno, or signaling SIGFPE.])
-
-AH_TEMPLATE(HAVE_INVERSE_HYPERBOLIC, [Define if you have the functions
-  acosh, asinh, and atanh.])
-
 dnl Everybody supports this, except MS.
 dnl Seems like the kind of thing we should be testing for, though.
 ## Note: PTYs are broken on darwin <6.  Use at your own risk.

=== modified file 'src/ChangeLog'
--- src/ChangeLog	2012-09-07 14:45:28 +0000
+++ src/ChangeLog	2012-09-07 19:15:12 +0000
@@ -1,3 +1,35 @@
+2012-09-07  Paul Eggert  <eggert <at> cs.ucla.edu>
+
+	Assume C89 or later for math functions.
+	This simplifies the code, and makes it a bit smaller and faster,
+	and (most important) makes it easier to clean up signal handling
+	since we can stop worring about floating-point exceptions in
+	library code.  That was a problem before C89, but the problem
+	went away many years ago on all practical Emacs targets.
+	* data.c, image.c, lread.c, print.c:
+	Don't include <math.h>; no longer needed.
+	* data.c, floatfns.c (IEEE_FLOATING_POINT): Don't worry that it
+	might be autoconfigured, as that never happens.
+	* data.c (fmod):
+	* doprnt.c (DBL_MAX_10_EXP):
+	* print.c (DBL_DIG):
+	Remove.  C89 or later always defines these.
+	* floatfns.c (HAVE_MATHERR, FLOAT_CHECK_ERRNO, FLOAT_CHECK_DOMAIN)
+	(in_float, float_error_arg, float_error_arg2, float_error_fn_name)
+	(arith_error, domain_error, domain_error2):
+	Remove all this pre-C89 cruft.  Do not include <errno.h> as that's
+	no longer needed -- we simply return what C returns.  All uses removed.
+	(IN_FLOAT, IN_FLOAT2): Remove.  All uses replaced with
+	the wrapped code.
+	(FLOAT_TO_INT, FLOAT_TO_INT2, range_error, range_error2):
+	Remove.  All uses expanded, as these macros are no longer used
+	more than once and are now more trouble than they're worth.
+	(Ftan): Use tan, not sin / cos.
+	(Flogb): Assume C89 frexp.
+	(fmod_float): Assume C89 fmod.
+	(matherr) [HAVE_MATHERR]: Remove; no longer needed.
+	(init_floatfns): Remove.  All uses removed.
+
 2012-09-07  Chong Yidong  <cyd <at> gnu.org>
 
 	* textprop.c (Fget_text_property): Minor doc fix (Bug#12323).

=== modified file 'src/data.c'
--- src/data.c	2012-09-07 14:15:59 +0000
+++ src/data.c	2012-09-07 19:15:12 +0000
@@ -36,17 +36,12 @@
 #include "keymap.h"
 
 #include <float.h>
-/* If IEEE_FLOATING_POINT isn't defined, default it from FLT_*.  */
-#ifndef IEEE_FLOATING_POINT
 #if (FLT_RADIX == 2 && FLT_MANT_DIG == 24 \
      && FLT_MIN_EXP == -125 && FLT_MAX_EXP == 128)
 #define IEEE_FLOATING_POINT 1
 #else
 #define IEEE_FLOATING_POINT 0
 #endif
-#endif
-
-#include <math.h>
 
 Lisp_Object Qnil, Qt, Qquote, Qlambda, Qunbound;
 static Lisp_Object Qsubr;
@@ -2737,28 +2732,6 @@
   return val;
 }
 
-#ifndef HAVE_FMOD
-double
-fmod (double f1, double f2)
-{
-  double r = f1;
-
-  if (f2 < 0.0)
-    f2 = -f2;
-
-  /* If the magnitude of the result exceeds that of the divisor, or
-     the sign of the result does not agree with that of the dividend,
-     iterate with the reduced value.  This does not yield a
-     particularly accurate result, but at least it will be in the
-     range promised by fmod.  */
-  do
-    r -= f2 * floor (r / f2);
-  while (f2 <= (r < 0 ? -r : r) || ((r < 0) != (f1 < 0) && ! isnan (r)));
-
-  return r;
-}
-#endif /* ! HAVE_FMOD */
-
 DEFUN ("mod", Fmod, Smod, 2, 2, 0,
        doc: /* Return X modulo Y.
 The result falls between zero (inclusive) and Y (exclusive).

=== modified file 'src/doprnt.c'
--- src/doprnt.c	2012-08-16 21:58:44 +0000
+++ src/doprnt.c	2012-09-07 19:15:12 +0000
@@ -114,10 +114,6 @@
    another macro.  */
 #include "character.h"
 
-#ifndef DBL_MAX_10_EXP
-#define DBL_MAX_10_EXP 308 /* IEEE double */
-#endif
-
 /* Generate output from a format-spec FORMAT,
    terminated at position FORMAT_END.
    (*FORMAT_END is not part of the format, but must exist and be readable.)

=== modified file 'src/emacs.c'
--- src/emacs.c	2012-09-07 08:55:03 +0000
+++ src/emacs.c	2012-09-07 19:15:12 +0000
@@ -1587,7 +1587,6 @@
   init_fringe ();
 #endif /* HAVE_WINDOW_SYSTEM */
   init_macros ();
-  init_floatfns ();
   init_window ();
   init_font ();
 

=== modified file 'src/floatfns.c'
--- src/floatfns.c	2012-09-07 08:46:44 +0000
+++ src/floatfns.c	2012-09-07 19:15:12 +0000
@@ -22,26 +22,9 @@
 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 
-/* ANSI C requires only these float functions:
+/* C89 requires only these math.h functions:
    acos, asin, atan, atan2, ceil, cos, cosh, exp, fabs, floor, fmod,
    frexp, ldexp, log, log10, modf, pow, sin, sinh, sqrt, tan, tanh.
-
-   Define HAVE_INVERSE_HYPERBOLIC if you have acosh, asinh, and atanh.
-   Define HAVE_CBRT if you have cbrt.
-   Define HAVE_RINT if you have a working rint.
-   If you don't define these, then the appropriate routines will be simulated.
-
-   Define HAVE_MATHERR if on a system supporting the SysV matherr callback.
-   (This should happen automatically.)
-
-   Define FLOAT_CHECK_ERRNO if the float library routines set errno.
-   This has no effect if HAVE_MATHERR is defined.
-
-   Define FLOAT_CHECK_DOMAIN if the float library doesn't handle errors by
-   either setting errno, or signaling SIGFPE.  Otherwise, domain and
-   range checking will happen before calling the float routines.  This has
-   no effect if HAVE_MATHERR is defined (since matherr will be called when
-   a domain error occurs.)
  */
 
 #include <config.h>
@@ -50,15 +33,12 @@
 #include "syssignal.h"
 
 #include <float.h>
-/* If IEEE_FLOATING_POINT isn't defined, default it from FLT_*. */
-#ifndef IEEE_FLOATING_POINT
 #if (FLT_RADIX == 2 && FLT_MANT_DIG == 24 \
      && FLT_MIN_EXP == -125 && FLT_MAX_EXP == 128)
 #define IEEE_FLOATING_POINT 1
 #else
 #define IEEE_FLOATING_POINT 0
 #endif
-#endif
 
 #include <math.h>
 
@@ -67,120 +47,6 @@
 extern double logb (double);
 #endif /* not HPUX and HAVE_LOGB and no logb macro */
 
-#if defined (DOMAIN) && defined (SING) && defined (OVERFLOW)
-    /* If those are defined, then this is probably a `matherr' machine. */
-# ifndef HAVE_MATHERR
-#  define HAVE_MATHERR
-# endif
-#endif
-
-#ifdef NO_MATHERR
-#undef HAVE_MATHERR
-#endif
-
-#ifdef HAVE_MATHERR
-# ifdef FLOAT_CHECK_ERRNO
-#  undef FLOAT_CHECK_ERRNO
-# endif
-# ifdef FLOAT_CHECK_DOMAIN
-#  undef FLOAT_CHECK_DOMAIN
-# endif
-#endif
-
-#ifndef NO_FLOAT_CHECK_ERRNO
-#define FLOAT_CHECK_ERRNO
-#endif
-
-#ifdef FLOAT_CHECK_ERRNO
-# include <errno.h>
-#endif
-
-/* True while executing in floating point.
-   This tells float_error what to do.  */
-
-static bool in_float;
-
-/* If an argument is out of range for a mathematical function,
-   here is the actual argument value to use in the error message.
-   These variables are used only across the floating point library call
-   so there is no need to staticpro them.  */
-
-static Lisp_Object float_error_arg, float_error_arg2;
-
-static const char *float_error_fn_name;
-
-/* Evaluate the floating point expression D, recording NUM
-   as the original argument for error messages.
-   D is normally an assignment expression.
-   Handle errors which may result in signals or may set errno.
-
-   Note that float_error may be declared to return void, so you can't
-   just cast the zero after the colon to (void) to make the types
-   check properly.  */
-
-#ifdef FLOAT_CHECK_ERRNO
-#define IN_FLOAT(d, name, num)				\
-  do {							\
-    float_error_arg = num;				\
-    float_error_fn_name = name;				\
-    in_float = 1; errno = 0; (d); in_float = 0;		\
-    switch (errno) {					\
-    case 0: break;					\
-    case EDOM:	 domain_error (float_error_fn_name, float_error_arg);	\
-    case ERANGE: range_error (float_error_fn_name, float_error_arg);	\
-    default:	 arith_error (float_error_fn_name, float_error_arg);	\
-    }							\
-  } while (0)
-#define IN_FLOAT2(d, name, num, num2)			\
-  do {							\
-    float_error_arg = num;				\
-    float_error_arg2 = num2;				\
-    float_error_fn_name = name;				\
-    in_float = 1; errno = 0; (d); in_float = 0;		\
-    switch (errno) {					\
-    case 0: break;					\
-    case EDOM:	 domain_error (float_error_fn_name, float_error_arg);	\
-    case ERANGE: range_error (float_error_fn_name, float_error_arg);	\
-    default:	 arith_error (float_error_fn_name, float_error_arg);	\
-    }							\
-  } while (0)
-#else
-#define IN_FLOAT(d, name, num) (in_float = 1, (d), in_float = 0)
-#define IN_FLOAT2(d, name, num, num2) (in_float = 1, (d), in_float = 0)
-#endif
-
-/* Convert float to Lisp_Int if it fits, else signal a range error
-   using the given arguments.  */
-#define FLOAT_TO_INT(x, i, name, num)					\
-  do									\
-    {									\
-      if (FIXNUM_OVERFLOW_P (x))					\
-	range_error (name, num);					\
-      XSETINT (i,  (EMACS_INT)(x));					\
-    }									\
-  while (0)
-#define FLOAT_TO_INT2(x, i, name, num1, num2)				\
-  do									\
-    {									\
-      if (FIXNUM_OVERFLOW_P (x))					\
-	range_error2 (name, num1, num2);				\
-      XSETINT (i,  (EMACS_INT)(x));					\
-    }									\
-  while (0)
-
-#define arith_error(op,arg) \
-  xsignal2 (Qarith_error, build_string ((op)), (arg))
-#define range_error(op,arg) \
-  xsignal2 (Qrange_error, build_string ((op)), (arg))
-#define range_error2(op,a1,a2) \
-  xsignal3 (Qrange_error, build_string ((op)), (a1), (a2))
-#define domain_error(op,arg) \
-  xsignal2 (Qdomain_error, build_string ((op)), (arg))
-#ifdef FLOAT_CHECK_DOMAIN
-#define domain_error2(op,a1,a2) \
-  xsignal3 (Qdomain_error, build_string ((op)), (a1), (a2))
-#endif
-
 /* Extract a Lisp number as a `double', or signal an error.  */
 
 double
@@ -197,27 +63,19 @@
 
 DEFUN ("acos", Facos, Sacos, 1, 1, 0,
        doc: /* Return the inverse cosine of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
-#ifdef FLOAT_CHECK_DOMAIN
-  if (d > 1.0 || d < -1.0)
-    domain_error ("acos", arg);
-#endif
-  IN_FLOAT (d = acos (d), "acos", arg);
+  d = acos (d);
   return make_float (d);
 }
 
 DEFUN ("asin", Fasin, Sasin, 1, 1, 0,
        doc: /* Return the inverse sine of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
-#ifdef FLOAT_CHECK_DOMAIN
-  if (d > 1.0 || d < -1.0)
-    domain_error ("asin", arg);
-#endif
-  IN_FLOAT (d = asin (d), "asin", arg);
+  d = asin (d);
   return make_float (d);
 }
 
@@ -227,50 +85,44 @@
 If two arguments Y and X are given, return the inverse tangent of Y
 divided by X, i.e. the angle in radians between the vector (X, Y)
 and the x-axis.  */)
-  (register Lisp_Object y, Lisp_Object x)
+  (Lisp_Object y, Lisp_Object x)
 {
   double d = extract_float (y);
 
   if (NILP (x))
-    IN_FLOAT (d = atan (d), "atan", y);
+    d = atan (d);
   else
     {
       double d2 = extract_float (x);
-
-      IN_FLOAT2 (d = atan2 (d, d2), "atan", y, x);
+      d = atan2 (d, d2);
     }
   return make_float (d);
 }
 
 DEFUN ("cos", Fcos, Scos, 1, 1, 0,
        doc: /* Return the cosine of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
-  IN_FLOAT (d = cos (d), "cos", arg);
+  d = cos (d);
   return make_float (d);
 }
 
 DEFUN ("sin", Fsin, Ssin, 1, 1, 0,
        doc: /* Return the sine of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
-  IN_FLOAT (d = sin (d), "sin", arg);
+  d = sin (d);
   return make_float (d);
 }
 
 DEFUN ("tan", Ftan, Stan, 1, 1, 0,
        doc: /* Return the tangent of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
-  double c = cos (d);
-#ifdef FLOAT_CHECK_DOMAIN
-  if (c == 0.0)
-    domain_error ("tan", arg);
-#endif
-  IN_FLOAT (d = sin (d) / c, "tan", arg);
+  d = tan (d);
   return make_float (d);
 }
 
@@ -341,61 +193,61 @@
 
 DEFUN ("bessel-j0", Fbessel_j0, Sbessel_j0, 1, 1, 0,
        doc: /* Return the bessel function j0 of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
-  IN_FLOAT (d = j0 (d), "bessel-j0", arg);
+  d = j0 (d);
   return make_float (d);
 }
 
 DEFUN ("bessel-j1", Fbessel_j1, Sbessel_j1, 1, 1, 0,
        doc: /* Return the bessel function j1 of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
-  IN_FLOAT (d = j1 (d), "bessel-j1", arg);
+  d = j1 (d);
   return make_float (d);
 }
 
 DEFUN ("bessel-jn", Fbessel_jn, Sbessel_jn, 2, 2, 0,
        doc: /* Return the order N bessel function output jn of ARG.
 The first arg (the order) is truncated to an integer.  */)
-  (register Lisp_Object n, Lisp_Object arg)
+  (Lisp_Object n, Lisp_Object arg)
 {
   int i1 = extract_float (n);
   double f2 = extract_float (arg);
 
-  IN_FLOAT (f2 = jn (i1, f2), "bessel-jn", n);
+  f2 = jn (i1, f2);
   return make_float (f2);
 }
 
 DEFUN ("bessel-y0", Fbessel_y0, Sbessel_y0, 1, 1, 0,
        doc: /* Return the bessel function y0 of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
-  IN_FLOAT (d = y0 (d), "bessel-y0", arg);
+  d = y0 (d);
   return make_float (d);
 }
 
 DEFUN ("bessel-y1", Fbessel_y1, Sbessel_y1, 1, 1, 0,
        doc: /* Return the bessel function y1 of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
-  IN_FLOAT (d = y1 (d), "bessel-y0", arg);
+  d = y1 (d);
   return make_float (d);
 }
 
 DEFUN ("bessel-yn", Fbessel_yn, Sbessel_yn, 2, 2, 0,
        doc: /* Return the order N bessel function output yn of ARG.
 The first arg (the order) is truncated to an integer.  */)
-  (register Lisp_Object n, Lisp_Object arg)
+  (Lisp_Object n, Lisp_Object arg)
 {
   int i1 = extract_float (n);
   double f2 = extract_float (arg);
 
-  IN_FLOAT (f2 = yn (i1, f2), "bessel-yn", n);
+  f2 = yn (i1, f2);
   return make_float (f2);
 }
 
@@ -405,43 +257,43 @@
 
 DEFUN ("erf", Ferf, Serf, 1, 1, 0,
        doc: /* Return the mathematical error function of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
-  IN_FLOAT (d = erf (d), "erf", arg);
+  d = erf (d);
   return make_float (d);
 }
 
 DEFUN ("erfc", Ferfc, Serfc, 1, 1, 0,
        doc: /* Return the complementary error function of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
-  IN_FLOAT (d = erfc (d), "erfc", arg);
+  d = erfc (d);
   return make_float (d);
 }
 
 DEFUN ("log-gamma", Flog_gamma, Slog_gamma, 1, 1, 0,
        doc: /* Return the log gamma of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
-  IN_FLOAT (d = lgamma (d), "log-gamma", arg);
+  d = lgamma (d);
   return make_float (d);
 }
 
 DEFUN ("cube-root", Fcube_root, Scube_root, 1, 1, 0,
        doc: /* Return the cube root of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
 #ifdef HAVE_CBRT
-  IN_FLOAT (d = cbrt (d), "cube-root", arg);
+  d = cbrt (d);
 #else
   if (d >= 0.0)
-    IN_FLOAT (d = pow (d, 1.0/3.0), "cube-root", arg);
+    d = pow (d, 1.0/3.0);
   else
-    IN_FLOAT (d = -pow (-d, 1.0/3.0), "cube-root", arg);
+    d = -pow (-d, 1.0/3.0);
 #endif
   return make_float (d);
 }
@@ -450,23 +302,16 @@
 
 DEFUN ("exp", Fexp, Sexp, 1, 1, 0,
        doc: /* Return the exponential base e of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
-#ifdef FLOAT_CHECK_DOMAIN
-  if (d > 709.7827)   /* Assume IEEE doubles here */
-    range_error ("exp", arg);
-  else if (d < -709.0)
-    return make_float (0.0);
-  else
-#endif
-    IN_FLOAT (d = exp (d), "exp", arg);
+  d = exp (d);
   return make_float (d);
 }
 
 DEFUN ("expt", Fexpt, Sexpt, 2, 2, 0,
        doc: /* Return the exponential ARG1 ** ARG2.  */)
-  (register Lisp_Object arg1, Lisp_Object arg2)
+  (Lisp_Object arg1, Lisp_Object arg2)
 {
   double f1, f2, f3;
 
@@ -495,72 +340,46 @@
     }
   f1 = FLOATP (arg1) ? XFLOAT_DATA (arg1) : XINT (arg1);
   f2 = FLOATP (arg2) ? XFLOAT_DATA (arg2) : XINT (arg2);
-  /* Really should check for overflow, too */
-  if (f1 == 0.0 && f2 == 0.0)
-    f1 = 1.0;
-#ifdef FLOAT_CHECK_DOMAIN
-  else if ((f1 == 0.0 && f2 < 0.0) || (f1 < 0 && f2 != floor (f2)))
-    domain_error2 ("expt", arg1, arg2);
-#endif
-  IN_FLOAT2 (f3 = pow (f1, f2), "expt", arg1, arg2);
-  /* Check for overflow in the result.  */
-  if (f1 != 0.0 && f3 == 0.0)
-    range_error ("expt", arg1);
+  f3 = pow (f1, f2);
   return make_float (f3);
 }
 
 DEFUN ("log", Flog, Slog, 1, 2, 0,
        doc: /* Return the natural logarithm of ARG.
 If the optional argument BASE is given, return log ARG using that base.  */)
-  (register Lisp_Object arg, Lisp_Object base)
+  (Lisp_Object arg, Lisp_Object base)
 {
   double d = extract_float (arg);
 
-#ifdef FLOAT_CHECK_DOMAIN
-  if (d <= 0.0)
-    domain_error2 ("log", arg, base);
-#endif
   if (NILP (base))
-    IN_FLOAT (d = log (d), "log", arg);
+    d = log (d);
   else
     {
       double b = extract_float (base);
 
-#ifdef FLOAT_CHECK_DOMAIN
-      if (b <= 0.0 || b == 1.0)
-	domain_error2 ("log", arg, base);
-#endif
       if (b == 10.0)
-	IN_FLOAT2 (d = log10 (d), "log", arg, base);
+	d = log10 (d);
       else
-	IN_FLOAT2 (d = log (d) / log (b), "log", arg, base);
+	d = log (d) / log (b);
     }
   return make_float (d);
 }
 
 DEFUN ("log10", Flog10, Slog10, 1, 1, 0,
        doc: /* Return the logarithm base 10 of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
-#ifdef FLOAT_CHECK_DOMAIN
-  if (d <= 0.0)
-    domain_error ("log10", arg);
-#endif
-  IN_FLOAT (d = log10 (d), "log10", arg);
+  d = log10 (d);
   return make_float (d);
 }
 
 DEFUN ("sqrt", Fsqrt, Ssqrt, 1, 1, 0,
        doc: /* Return the square root of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
-#ifdef FLOAT_CHECK_DOMAIN
-  if (d < 0.0)
-    domain_error ("sqrt", arg);
-#endif
-  IN_FLOAT (d = sqrt (d), "sqrt", arg);
+  d = sqrt (d);
   return make_float (d);
 }
 
@@ -568,83 +387,55 @@
 
 DEFUN ("acosh", Facosh, Sacosh, 1, 1, 0,
        doc: /* Return the inverse hyperbolic cosine of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
-#ifdef FLOAT_CHECK_DOMAIN
-  if (d < 1.0)
-    domain_error ("acosh", arg);
-#endif
-#ifdef HAVE_INVERSE_HYPERBOLIC
-  IN_FLOAT (d = acosh (d), "acosh", arg);
-#else
-  IN_FLOAT (d = log (d + sqrt (d*d - 1.0)), "acosh", arg);
-#endif
+  d = acosh (d);
   return make_float (d);
 }
 
 DEFUN ("asinh", Fasinh, Sasinh, 1, 1, 0,
        doc: /* Return the inverse hyperbolic sine of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
-#ifdef HAVE_INVERSE_HYPERBOLIC
-  IN_FLOAT (d = asinh (d), "asinh", arg);
-#else
-  IN_FLOAT (d = log (d + sqrt (d*d + 1.0)), "asinh", arg);
-#endif
+  d = asinh (d);
   return make_float (d);
 }
 
 DEFUN ("atanh", Fatanh, Satanh, 1, 1, 0,
        doc: /* Return the inverse hyperbolic tangent of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
-#ifdef FLOAT_CHECK_DOMAIN
-  if (d >= 1.0 || d <= -1.0)
-    domain_error ("atanh", arg);
-#endif
-#ifdef HAVE_INVERSE_HYPERBOLIC
-  IN_FLOAT (d = atanh (d), "atanh", arg);
-#else
-  IN_FLOAT (d = 0.5 * log ((1.0 + d) / (1.0 - d)), "atanh", arg);
-#endif
+  d = atanh (d);
   return make_float (d);
 }
 
 DEFUN ("cosh", Fcosh, Scosh, 1, 1, 0,
        doc: /* Return the hyperbolic cosine of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
-#ifdef FLOAT_CHECK_DOMAIN
-  if (d > 710.0 || d < -710.0)
-    range_error ("cosh", arg);
-#endif
-  IN_FLOAT (d = cosh (d), "cosh", arg);
+  d = cosh (d);
   return make_float (d);
 }
 
 DEFUN ("sinh", Fsinh, Ssinh, 1, 1, 0,
        doc: /* Return the hyperbolic sine of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
-#ifdef FLOAT_CHECK_DOMAIN
-  if (d > 710.0 || d < -710.0)
-    range_error ("sinh", arg);
-#endif
-  IN_FLOAT (d = sinh (d), "sinh", arg);
+  d = sinh (d);
   return make_float (d);
 }
 
 DEFUN ("tanh", Ftanh, Stanh, 1, 1, 0,
        doc: /* Return the hyperbolic tangent of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
-  IN_FLOAT (d = tanh (d), "tanh", arg);
+  d = tanh (d);
   return make_float (d);
 }
 #endif
@@ -689,33 +480,11 @@
   else
     {
 #ifdef HAVE_LOGB
-      IN_FLOAT (value = logb (f), "logb", arg);
+      value = logb (f);
 #else
-#ifdef HAVE_FREXP
       int ivalue;
-      IN_FLOAT (frexp (f, &ivalue), "logb", arg);
+      frexp (f, &ivalue);
       value = ivalue - 1;
-#else
-      int i;
-      double d;
-      if (f < 0.0)
-	f = -f;
-      value = -1;
-      while (f < 0.5)
-	{
-	  for (i = 1, d = 0.5; d * d >= f; i += i)
-	    d *= d;
-	  f /= d;
-	  value -= i;
-	}
-      while (f >= 1.0)
-	{
-	  for (i = 1, d = 2.0; d * d <= f; i += i)
-	    d *= d;
-	  f /= d;
-	  value += i;
-	}
-#endif
 #endif
     }
   XSETINT (val, value);
@@ -748,8 +517,10 @@
 	  if (! IEEE_FLOATING_POINT && f2 == 0)
 	    xsignal0 (Qarith_error);
 
-	  IN_FLOAT2 (f1 = (*double_round) (f1 / f2), name, arg, divisor);
-	  FLOAT_TO_INT2 (f1, arg, name, arg, divisor);
+	  f1 = (*double_round) (f1 / f2);
+	  if (FIXNUM_OVERFLOW_P (f1))
+	    xsignal3 (Qrange_error, build_string (name), arg, divisor);
+	  arg = make_number (f1);
 	  return arg;
 	}
 
@@ -765,10 +536,10 @@
 
   if (FLOATP (arg))
     {
-      double d;
-
-      IN_FLOAT (d = (*double_round) (XFLOAT_DATA (arg)), name, arg);
-      FLOAT_TO_INT (d, arg, name, arg);
+      double d = (*double_round) (XFLOAT_DATA (arg));
+      if (FIXNUM_OVERFLOW_P (d))
+	xsignal2 (Qrange_error, build_string (name), arg);
+      arg = make_number (d);
     }
 
   return arg;
@@ -885,97 +656,57 @@
   f1 = FLOATP (x) ? XFLOAT_DATA (x) : XINT (x);
   f2 = FLOATP (y) ? XFLOAT_DATA (y) : XINT (y);
 
-  if (! IEEE_FLOATING_POINT && f2 == 0)
-    xsignal0 (Qarith_error);
+  f1 = fmod (f1, f2);
 
   /* If the "remainder" comes out with the wrong sign, fix it.  */
-  IN_FLOAT2 ((f1 = fmod (f1, f2),
-	      f1 = (f2 < 0 ? f1 > 0 : f1 < 0) ? f1 + f2 : f1),
-	     "mod", x, y);
+  if (f2 < 0 ? 0 < f1 : f1 < 0)
+    f1 += f2;
+
   return make_float (f1);
 }
 
-/* It's not clear these are worth adding.  */
-
 DEFUN ("fceiling", Ffceiling, Sfceiling, 1, 1, 0,
        doc: /* Return the smallest integer no less than ARG, as a float.
 \(Round toward +inf.\)  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
-  IN_FLOAT (d = ceil (d), "fceiling", arg);
+  d = ceil (d);
   return make_float (d);
 }
 
 DEFUN ("ffloor", Fffloor, Sffloor, 1, 1, 0,
        doc: /* Return the largest integer no greater than ARG, as a float.
 \(Round towards -inf.\)  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
-  IN_FLOAT (d = floor (d), "ffloor", arg);
+  d = floor (d);
   return make_float (d);
 }
 
 DEFUN ("fround", Ffround, Sfround, 1, 1, 0,
        doc: /* Return the nearest integer to ARG, as a float.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
-  IN_FLOAT (d = emacs_rint (d), "fround", arg);
+  d = emacs_rint (d);
   return make_float (d);
 }
 
 DEFUN ("ftruncate", Fftruncate, Sftruncate, 1, 1, 0,
        doc: /* Truncate a floating point number to an integral float value.
 Rounds the value toward zero.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
   if (d >= 0.0)
-    IN_FLOAT (d = floor (d), "ftruncate", arg);
+    d = floor (d);
   else
-    IN_FLOAT (d = ceil (d), "ftruncate", arg);
+    d = ceil (d);
   return make_float (d);
 }
 
-#ifdef HAVE_MATHERR
-int
-matherr (struct exception *x)
-{
-  Lisp_Object args;
-  const char *name = x->name;
-
-  if (! in_float)
-    /* Not called from emacs-lisp float routines; do the default thing. */
-    return 0;
-  if (!strcmp (x->name, "pow"))
-    name = "expt";
-
-  args
-    = Fcons (build_string (name),
-	     Fcons (make_float (x->arg1),
-		    ((!strcmp (name, "log") || !strcmp (name, "pow"))
-		     ? Fcons (make_float (x->arg2), Qnil)
-		     : Qnil)));
-  switch (x->type)
-    {
-    case DOMAIN:	xsignal (Qdomain_error, args);		break;
-    case SING:		xsignal (Qsingularity_error, args);	break;
-    case OVERFLOW:	xsignal (Qoverflow_error, args);	break;
-    case UNDERFLOW:	xsignal (Qunderflow_error, args);	break;
-    default:		xsignal (Qarith_error, args);		break;
-    }
-  return (1);	/* don't set errno or print a message */
-}
-#endif /* HAVE_MATHERR */
-
-void
-init_floatfns (void)
-{
-  in_float = 0;
-}
-
 void
 syms_of_floatfns (void)
 {

=== modified file 'src/image.c'
--- src/image.c	2012-09-04 17:34:54 +0000
+++ src/image.c	2012-09-07 19:15:12 +0000
@@ -19,7 +19,6 @@
 
 #include <config.h>
 #include <stdio.h>
-#include <math.h>
 #include <unistd.h>
 
 #ifdef HAVE_PNG

=== modified file 'src/lisp.h'
--- src/lisp.h	2012-09-07 08:46:44 +0000
+++ src/lisp.h	2012-09-07 19:15:12 +0000
@@ -2687,7 +2687,6 @@
 
 /* Defined in floatfns.c */
 extern double extract_float (Lisp_Object);
-extern void init_floatfns (void);
 extern void syms_of_floatfns (void);
 extern Lisp_Object fmod_float (Lisp_Object x, Lisp_Object y);
 

=== modified file 'src/lread.c'
--- src/lread.c	2012-09-04 17:40:25 +0000
+++ src/lread.c	2012-09-07 19:15:12 +0000
@@ -50,7 +50,6 @@
 #endif
 
 #include <unistd.h>
-#include <math.h>
 
 #ifdef HAVE_SETLOCALE
 #include <locale.h>

=== modified file 'src/print.c'
--- src/print.c	2012-09-04 17:34:54 +0000
+++ src/print.c	2012-09-07 19:15:12 +0000
@@ -45,15 +45,9 @@
 
 static Lisp_Object Qfloat_output_format;
 
-#include <math.h>
 #include <float.h>
 #include <ftoastr.h>
 
-/* Default to values appropriate for IEEE floating point.  */
-#ifndef DBL_DIG
-#define DBL_DIG 15
-#endif
-
 /* Avoid actual stack overflow in print.  */
 static ptrdiff_t print_depth;
 

Message #10 received at submit <at> debbugs.gnu.org (full text, mbox):

From: Eli Zaretskii <eliz <at> gnu.org>
To: Paul Eggert <eggert <at> cs.ucla.edu>
Cc: bug-gnu-emacs <at> gnu.org
Subject: Re: Assume C89 or later for math functions.
Date: Sat, 08 Sep 2012 10:07:55 +0300

> Date: Fri, 07 Sep 2012 13:22:38 -0700
> From: Paul Eggert <eggert <at> cs.ucla.edu>
> CC: Eli Zaretskii <eliz <at> gnu.org>
> 
> In doing signal-handling cleanup I ran afoul of a lot of crufty old
> floating-point code that hasn't been needed in Emacs for many years.
> Since it's getting in the way of improving Emacs I plan to install
> the following patch to clean out the cruft.  I don't think this
> affects the Windows port but am CC'ing to Eli just in case.

You missed msdos/*.inp scripts.  sed2v2.inp does define
FLOAT_CHECK_DOMAIN for the MSDOS port (although I'm not sure the DOS
port needs this nowadays, see below).

> +2012-09-07  Paul Eggert  <eggert <at> cs.ucla.edu>
> +
> +	Assume C89 or later for math functions.
> +	This simplifies the code, and makes it a bit smaller and faster,
> +	and (most important) makes it easier to clean up signal handling
> +	since we can stop worring about floating-point exceptions in
> +	library code.  That was a problem before C89, but the problem
> +	went away many years ago on all practical Emacs targets.
> +	* data.c, image.c, lread.c, print.c:
> +	Don't include <math.h>; no longer needed.
> +	* data.c, floatfns.c (IEEE_FLOATING_POINT): Don't worry that it
> +	might be autoconfigured, as that never happens.
> +	* data.c (fmod):
> +	* doprnt.c (DBL_MAX_10_EXP):
> +	* print.c (DBL_DIG):
> +	Remove.  C89 or later always defines these.
> +	* floatfns.c (HAVE_MATHERR, FLOAT_CHECK_ERRNO, FLOAT_CHECK_DOMAIN)
> +	(in_float, float_error_arg, float_error_arg2, float_error_fn_name)
> +	(arith_error, domain_error, domain_error2):
> +	Remove all this pre-C89 cruft.  Do not include <errno.h> as that's
> +	no longer needed -- we simply return what C returns.  All uses removed.
> +	(IN_FLOAT, IN_FLOAT2): Remove.  All uses replaced with
> +	the wrapped code.
> +	(FLOAT_TO_INT, FLOAT_TO_INT2, range_error, range_error2):
> +	Remove.  All uses expanded, as these macros are no longer used
> +	more than once and are now more trouble than they're worth.
> +	(Ftan): Use tan, not sin / cos.
> +	(Flogb): Assume C89 frexp.
> +	(fmod_float): Assume C89 fmod.
> +	(matherr) [HAVE_MATHERR]: Remove; no longer needed.
> +	(init_floatfns): Remove.  All uses removed.

I think we should discuss this first.  Issues that I consider
non-trivial are:

 . Are we sure all supported systems implement the math functions as
   assumed by this patch?  I'd suggest reviewing the results of
   running the configure script on *BSD systems, on AIX, and on old
   Solaris, before making the decision.

 . Do we really want to remove a possibility of signaling an error on
   EDOM and ERANGE?  Right now, this is a configure-time option, but
   the proposed patch removes it forever.  (For that matter, is it TRT
   for Emacs to silently continue with HUGE_VAL etc., disregarding
   errors in math functions?)

 . The pieces related to 'matherr' might still be needed on platforms
   which provide that function.  I don't remember the details, but
   AFAIR the default version of that function may print an error
   message, which I think we need to prevent.

 . Last, but not least: what exactly does the patch assume about the
   math library functions?  Those assumptions are not spelled out in
   the log entries; without them, it's hard to reason about the
   possible implications of the change.  E.g., the log entry says "we
   can stop worrying about floating-point exceptions in library code",
   but AFAIK you _can_ build a C89 program that will generate SIGFPE
   in library functions.  Maybe I don't understand what exactly is
   meant by "floating-point exceptions".

Message #13 received at 12381 <at> debbugs.gnu.org (full text, mbox):

From: Paul Eggert <eggert <at> cs.ucla.edu>
To: Eli Zaretskii <eliz <at> gnu.org>
Cc: 12381 <at> debbugs.gnu.org
Subject: Re: Assume C89 or later for math functions.
Date: Sat, 08 Sep 2012 08:31:21 -0700

On 09/08/2012 12:07 AM, Eli Zaretskii wrote:

>    Maybe I don't understand what exactly is
>    meant by "floating-point exceptions".

Long ago, before IEEE floating point took over, it was common for
floating point arithmetic to trap when there was an overflow,
causing a C signal, on the theory that this made debugging easier,
or software more reliable, or both.

The IEEE model is different.  It provides exceptional values for
overflow and the like, instead of traps or signals.  This is true even
for floating point exceptions in library functions.  There is a
run-time option that causes exceptions to trap instead, but that
option is off by default, and it's not always supported, and almost
nobody uses it even when it is supported because it's a pain to use
and it's rarely exercised and it tends to be buggy.

So, on current hardware, which is invariably IEEE these days (even on
IBM mainframes!), this issue has not been a problem for many years.
David Golderg's classic paper on the topic
<http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html>
already presented the issue as settled back in 1991, and the
fundamentals haven't changed since then.

>  . Are we sure all supported systems implement the math functions as
>    assumed by this patch?

Yes.  I've already checked that, by looking at the gnulib
documentation for the two functions now assumed (fmod, frexp).  All
the platforms you mention (plus a lot of older and more-obscure
platforms) have them.

>  . Do we really want to remove a possibility of signaling an error on
>    EDOM and ERANGE?

Yes we do.  Nobody configures Emacs that way (it's not documented
anywhere), and there's a good reason: it hasn't been needed for
decades.

>    is it TRT for Emacs to silently continue with HUGE_VAL etc.,
>    disregarding errors in math functions?

Yes, it's clearly the right thing.  It's how Emacs behaves for "+" and
"*", and how Emacs has behave for math functions on GNU platforms, for
many years.  It's the standard behavior, and it's what users expect.

>  . The pieces related to 'matherr' might still be needed on platforms
>    which provide that function....  AFAIR the default version of that
>    function may print an error message, which I think we need to prevent.

matherr was a problem back in the 1980s, but it's been obsolete for
decades.  Platforms that still provide it have it as an SVID option
that is disabled by default, because it was clearly a mistake.  SVID
itself is long dead -- the last SVID spec was published in 1995, and
it's possible that matherr was even gone from SVID by then (the spec
is so old that I can't view it on my Ubuntu machine).

SVID has been supplanted by POSIX, which does not allow the matherr
behavior.  Emacs does not enable the obsolete SVID option on any
platform, so it's fine.

>  . Last, but not least: what exactly does the patch assume about the
>    math library functions?

I think you've pretty much covered the issues.

>    AFAIK you _can_ build a C89 program that will generate SIGFPE
>    in library functions.

That's not a problem in practice, because Emacs does not enable the
optional flags that cause these traps on current porting targets.

Message #16 received at 12381 <at> debbugs.gnu.org (full text, mbox):

From: Eli Zaretskii <eliz <at> gnu.org>
To: Paul Eggert <eggert <at> cs.ucla.edu>, Ken Brown <kbrown <at> cornell.edu>
Cc: 12381 <at> debbugs.gnu.org
Subject: Re: Assume C89 or later for math functions.
Date: Sat, 08 Sep 2012 18:58:07 +0300

> Date: Sat, 08 Sep 2012 08:31:21 -0700
> From: Paul Eggert <eggert <at> cs.ucla.edu>
> CC: 12381 <at> debbugs.gnu.org
> 
> The IEEE model is different.  It provides exceptional values for
> overflow and the like, instead of traps or signals.  This is true even
> for floating point exceptions in library functions.  There is a
> run-time option that causes exceptions to trap instead, but that
> option is off by default, and it's not always supported, and almost
> nobody uses it even when it is supported because it's a pain to use
> and it's rarely exercised and it tends to be buggy.

AFAIK, Posix and the latest C standards provide fenv.h header and
several functions there, which are in a way a return to the exceptions
model.  So maybe we should use those facilities, where available, to
optionally signal an error, instead of wiping this feature out
completely.

> >  . Do we really want to remove a possibility of signaling an error on
> >    EDOM and ERANGE?
> 
> Yes we do.  Nobody configures Emacs that way (it's not documented
> anywhere), and there's a good reason: it hasn't been needed for
> decades.

But couldn't this be a useful debugging option, like -DGLYPH_DEBUG=1 ?

> >  . The pieces related to 'matherr' might still be needed on platforms
> >    which provide that function....  AFAIR the default version of that
> >    function may print an error message, which I think we need to prevent.
> 
> matherr was a problem back in the 1980s, but it's been obsolete for
> decades.  Platforms that still provide it have it as an SVID option
> that is disabled by default, because it was clearly a mistake.

I'm not sure this is so universally correct.  E.g., what about Cygwin?
Ken, can you tell?  AFAIR, Cygwin uses fdlibm, which used to invoke
matherr by default.

> SVID has been supplanted by POSIX, which does not allow the matherr
> behavior.  Emacs does not enable the obsolete SVID option on any
> platform, so it's fine.

Perhaps you forget that Emacs supports a few non-Posix or marginally
Posix platforms.  E.g., in the MS-Windows and MS-DOS ports, I can
cause FP exception to trigger SIGFPE at run time with a single
function call.  I'm sure glibc has a similar facility as well.

Message #19 received at 12381 <at> debbugs.gnu.org (full text, mbox):

From: Ken Brown <kbrown <at> cornell.edu>
To: Eli Zaretskii <eliz <at> gnu.org>
Cc: Paul Eggert <eggert <at> cs.ucla.edu>, 12381 <at> debbugs.gnu.org
Subject: Re: Assume C89 or later for math functions.
Date: Sat, 08 Sep 2012 13:20:00 -0400

On 9/8/2012 11:58 AM, Eli Zaretskii wrote:
>> Date: Sat, 08 Sep 2012 08:31:21 -0700
>> From: Paul Eggert <eggert <at> cs.ucla.edu>
>> CC: 12381 <at> debbugs.gnu.org

>> matherr was a problem back in the 1980s, but it's been obsolete for
>> decades.  Platforms that still provide it have it as an SVID option
>> that is disabled by default, because it was clearly a mistake.
>
> I'm not sure this is so universally correct.  E.g., what about Cygwin?
> Ken, can you tell?  AFAIR, Cygwin uses fdlibm, which used to invoke
> matherr by default.

Sorry, but this discussion is over my head.  Is there a C program I 
could run that would answer your question?

Ken

Message #22 received at 12381 <at> debbugs.gnu.org (full text, mbox):

From: Paul Eggert <eggert <at> cs.ucla.edu>
To: Eli Zaretskii <eliz <at> gnu.org>
Cc: 12381 <at> debbugs.gnu.org, Ken Brown <kbrown <at> cornell.edu>
Subject: Re: Assume C89 or later for math functions.
Date: Sat, 08 Sep 2012 12:01:25 -0700

On 09/08/2012 08:58 AM, Eli Zaretskii wrote:>

> couldn't this be a useful debugging option

Yes, it might be useful to have a feature to enable IEEE traps,
on platforms that support IEEE traps.  But that would be a new
Emacs feature, and a different and independent patch.

> I can cause FP exception to trigger SIGFPE at run time with a
> single function call.  I'm sure glibc has a similar facility as well.

Sure, glibc and many other systems have such facilities.
But they're optional, and Emacs currently does not use them.
If Emacs enabled them, that would be the new feature mentioned above.

> what about Cygwin?

Cygwin is like glibc.  matherr exists to support ancient
applications, but it's present only for SVID compatibility, and
it's normally disabled so Emacs doesn't use it.  I just now
checked the source.

Message #25 received at 12381 <at> debbugs.gnu.org (full text, mbox):

From: Paul Eggert <eggert <at> cs.ucla.edu>
To: Ken Brown <kbrown <at> cornell.edu>
Cc: Eli Zaretskii <eliz <at> gnu.org>, 12381 <at> debbugs.gnu.org
Subject: Re: Assume C89 or later for math functions.
Date: Sat, 08 Sep 2012 12:05:32 -0700

On 09/08/2012 10:20 AM, Ken Brown wrote:
> Is there a C program I could run that would answer your question?

Sure, run this:

#include <math.h>
int main (void)
{
  return pow (0, 0) != 1;
}

If the matherr problem is present, the program will
print something on stderr, coming from the library.
If not, the program will exit silently.  On Ubuntu
it exits with status 0, which is what POSIX requires,
though pow's exact return value doesn't really matter
here -- the point is that pow should not write to stderr.

Message #28 received at 12381 <at> debbugs.gnu.org (full text, mbox):

From: Ken Brown <kbrown <at> cornell.edu>
To: Paul Eggert <eggert <at> cs.ucla.edu>
Cc: Eli Zaretskii <eliz <at> gnu.org>, 12381 <at> debbugs.gnu.org
Subject: Re: Assume C89 or later for math functions.
Date: Sat, 08 Sep 2012 15:46:13 -0400

On 9/8/2012 3:05 PM, Paul Eggert wrote:
> On 09/08/2012 10:20 AM, Ken Brown wrote:
>> Is there a C program I could run that would answer your question?
>
> Sure, run this:
>
> #include <math.h>
> int main (void)
> {
>    return pow (0, 0) != 1;
> }
>
> If the matherr problem is present, the program will
> print something on stderr, coming from the library.
> If not, the program will exit silently.  On Ubuntu
> it exits with status 0, which is what POSIX requires,
> though pow's exact return value doesn't really matter
> here -- the point is that pow should not write to stderr.

Thanks.  The Cygwin behavior is the same as what you described for 
Ubuntu.  Nothing is written to stderr, and the exit status is 0.

Ken

Message #33 received at 12381-done <at> debbugs.gnu.org (full text, mbox):

From: Paul Eggert <eggert <at> cs.ucla.edu>
To: Ken Brown <kbrown <at> cornell.edu>
Cc: Eli Zaretskii <eliz <at> gnu.org>, 12381-done <at> debbugs.gnu.org
Subject: Re: Assume C89 or later for math functions.
Date: Sun, 09 Sep 2012 10:10:37 -0700

On 09/08/2012 12:46 PM, Ken Brown wrote:
> The Cygwin behavior is the same as what you described for Ubuntu.
> Nothing is written to stderr, and the exit status is 0.

Thanks for checking; I merged and pushed the patch as trunk
bzr 109956 and am marking this as done.  msdos/sed2v2.inp and
nt/config.nt still mention FLOAT_CHECK_DOMAIN; although this
shouldn't hurt it can be removed as part of routine maintenance
on the Microsoft side.

Message #36 received at 12381 <at> debbugs.gnu.org (full text, mbox):

From: Paul Eggert <eggert <at> cs.ucla.edu>
To: 12381 <at> debbugs.gnu.org
Cc: Eli Zaretskii <eliz <at> gnu.org>
Subject: Re: Assume C89 or later for math functions.
Date: Mon, 10 Sep 2012 19:30:39 -0700

I installed a further mop-up patch for this, mostly
documentation fixes, as trunk bzr 109974.  I don't
think this affects the Microsoft ports.

Previous Next

GNU bug tracking system
Copyright (C) 1999 Darren O. Benham, 1997,2003 nCipher Corporation Ltd, 1994-97 Ian Jackson.