home *** CD-ROM | disk | FTP | other *** search
/ C Programming Starter Kit 2.0 / SamsPublishing-CProgrammingStarterKit-v2.0-Win31.iso / bc45 / wild16.pak / MATHERRL.C < prev    next >
C/C++ Source or Header  |  1997-07-23  |  5KB  |  146 lines
  1. /*------------------------------------------------------------------------
  2.  * filename - matherrl.c
  3.  *
  4.  * function(s)
  5.  *        _matherrl - user-modifiable long double math error handler
  6.  *-----------------------------------------------------------------------*/
  7.  
  8. /*
  9.  *      C/C++ Run Time Library - Version 6.5
  10.  *
  11.  *      Copyright (c) 1987, 1994 by Borland International
  12.  *      All Rights Reserved.
  13.  *
  14.  */
  15.  
  16.  
  17. #include <math.h>
  18.  
  19. #ifdef _Windows
  20. #include <_win.h>
  21. #endif
  22.  
  23. #ifdef  UNIX__matherrl
  24. #include <stdio.h>
  25. #include <process.h>
  26.  
  27. char *whyS [] =
  28. {
  29.     "argument domain error",
  30.     "argument singularity ",
  31.     "overflow range error ",
  32.     "underflow range error",
  33.     "total loss of significance",
  34.     "partial loss of significance"
  35. };
  36.  
  37. /*------------------------------------------------------------------------*
  38.  
  39. Name            _matherrl - user-modifiable long double math error handler
  40.  
  41. Usage           #include <math.h>
  42.                 int _matherrl(struct _exceptionl *e);
  43.  
  44. Prototype in    math.h
  45.  
  46. Description     When  exceptions are  detected in  the long double math
  47.                 library then a call is made to __matherrl() with all of
  48.                 the available information.
  49.  
  50.                 That function does very little, except to map the exception
  51.                 "why"  into either  ERANGE or  EDOMAIN in  errno. Its  main
  52.                 purpose is  to act as  a focal point  for changes in  error
  53.                 handling.
  54.  
  55.                 For example,  if you were  writing a spreadsheet  you might
  56.                 replace  this function with one which pops up an error
  57.                 window explaining something like:
  58.  
  59.                         "logl (-2.0) caused domain error, in cell J7"
  60.  
  61.                 and then longjmp() to a  reset state in the spreadsheet and
  62.                 await the next command from the user.
  63.  
  64.                 The default version  of Turbo C's _matherrl routine masks
  65.                 underflow and precision errors; others errors are considered
  66.                 fatal.  It serves as a hook that you can replace when
  67.                 writing your own math error handling routine.
  68.  
  69.                 The rationale for masking underflow and precision errors
  70.                 is that these are not errors according to the ANSI C spec.
  71.                 Consequently, you will get
  72.                         expl(-1000) = 0
  73.                         sinl(1e100) = NAN
  74.                 without any error or warning, even though there is a total
  75.                 loss of precision in both cases.  You can trap these errors
  76.                 by modifying _matherrl.
  77.  
  78.                 The possible errors are
  79.                         DOMAIN, SING, OVERFLOW, UNDERFLOW, TLOSS, PLOSS
  80.                 and listed in <math.h>.  As explained above, UNDERFLOW and
  81.                 TLOSS are masked by the default _matherrl.  PLOSS is not
  82.                 supported by TC and is not generated by any library functions.
  83.                 The remaining errors, DOMAIN, SING, and OVERFLOW, are fatal
  84.                 with the default _matherrl.
  85.  
  86.                 You  can  modify  _matherrl  to  be  a  custom error handling
  87.                 routine (such as one that catches and resolves certain type
  88.                 of  errors); the  modified _matherrl  should return  0 if  it
  89.                 failed to resolve  the error, or non-zero if  the error was
  90.                 resolved. When _matherrl returns non-zero, no  error message
  91.                 is printed, and errno is not changed.
  92.  
  93.                 The  important thing  is  that  we  don't  know what error
  94.                 handling you want, but you are assured that all errors will
  95.                 arrive at  _matherrl() with all  the information you  need to
  96.                 design a custom format.
  97.  
  98. Return value    The default return  value for _matherrl is simply  0.
  99.                 _matherrl can also modify  e->retval, which propagates through
  100.                 __matherrl back to the original caller.
  101.  
  102.                 When _matherrl returns 0, (indicating that it was not able to
  103.                 resolve the error) __matherrl sets  errno and prints an error
  104.                 message.
  105.  
  106.                 When _matherrl returns non-zero, (indicating that it was able
  107.                 to resolve the error) errno is not set and no messages are
  108.                 printed.
  109.  
  110. *-------------------------------------------------------------------------*/
  111. int _FARFUNC _matherrl (struct _exceptionl *e)
  112. {
  113. #ifdef _Windows
  114.     char errMsg[ 80 ];
  115.     sprintf (errMsg,
  116.         "%s (%8Lg,%8Lg): %s\n", e->name, e->arg1, e->arg2, whyS [e->type - 1]);
  117.     _errorExitBox( errMsg, 1 );
  118. #else
  119.     fprintf (stderr,
  120.         "%s (%8Lg,%8Lg): %s\n", e->name, e->arg1, e->arg2, whyS [e->type - 1]);
  121.  
  122.     exit (1);
  123. #endif
  124. }
  125. #else
  126.  
  127. int _FARFUNC _matherrl(struct _exceptionl *e)
  128. {
  129.         if (e->type == UNDERFLOW)
  130.         {
  131.                 /* flush underflow to 0 */
  132.                 e->retval = 0;
  133.                 return 1;
  134.         }
  135.         if (e->type == TLOSS)
  136.         {
  137.                 /* total loss of precision, but ignore the problem */
  138.                 return 1;
  139.         }
  140.         /* all other errors are fatal */
  141.         return 0;
  142. }
  143.  
  144.  
  145. #endif
  146.