C / C++ / MFC

Source Filter
      |
CSampleGrabber Filter -- Application -- Texture -- Direct3D Surface
      |
Null Renderer

/* --------------------------------------------------------------------- */
/*
**  Note: The purpose of the arrays is to prevent
**      multiple copys of error strings being used.
*/
int matherr( struct exception *except )
{
    char t = *(_User.def.name);
    int endx=-1, sndx=-1, n = _User.def.nargs;
    char *str[2] = { "is","caused" };
    char *errors[6] =
    {
        "outside the domain",            /* 0 */
        "an illegal value",              /* 1 */
        "overflow",                      /* 2 */
        "underflow",                     /* 3 */
        "partial loss of significance",  /* 4 */
        "total loss of significance",    /* 5 */
    };
    switch( except->type )
    {
        case DOMAIN:    endx = 0 ; sndx = 0 ; break ;
        case SING:      endx = 1 ; sndx = 0 ; break ;
        case OVERFLOW:  endx = 2 ; sndx = 1 ; break ;
        case UNDERFLOW: endx = 3 ; sndx = 1 ; break ;
        case PLOSS:     endx = 4 ; sndx = 1 ; break ;
        case TLOSS:     endx = 5 ; sndx = 1 ; break ;
    }
    if( t && endx>-1 && sndx>-1)
    {
        /* if there is only one argument it has to have caused the error */
        /***** REMOVE THIS FOR "GRAPHIT" ERROR PRINTING ******************
        if( n == 1 )
            _Error( "math","'%s': %G %s %s",
                    _User.def.name,except->arg1,str[sndx],errors[endx] );
        else
        ******************************************************************/
            _Error( "math","'%s': argument %s %s",
                    _User.def.name,str[sndx],errors[endx] );
    }
    else _Error( "math",errors[endx] );
    return 1;
}
/* --------------------------------------------------------------------- */

#include <float.h>
#include <signal.h>
static void fphandler( int sig, int num );

static char *_FpeErrors[10] =
{
    "invalid number",                   /* 0 */
    "denormal",                         /* 1 */
    "divide by zero",                   /* 2 */
    "overflow",                         /* 3 */
    "underflow",                        /* 4 */
    "inexact",                          /* 5 */
    "unemulated",                       /* 6 */
    "square root of negative number",   /* 7 */
    "stack underflow",                  /* 8 */
    "unknown",                          /* 9 */
};

void p_setfperror(void)
{
    /* Set up floating-point error handler. */
    if( signal( SIGFPE, fphandler ) == SIG_ERR )
        _Error( "p_setfperror","could not set floating point error handler" );
    else _FpeSet = 1;
}

/* Handles SIGFPE (floating-point error) interrupt. */
static void fphandler( int sig, int fperr )
{
    int ndx;
    /* Initialize floating-point package. */
    _fpreset();

    /* This function my be causing a stack underflow */
    /* Stop multiple _FpeMsg setting */
    if( _Error_Flag > -1 )
    {
        switch( fperr )
        {
            case FPE_INVALID:           ndx = 0; break;
            case FPE_DENORMAL:          ndx = 1; break;
            case FPE_ZERODIVIDE:        ndx = 2; break;
            case FPE_OVERFLOW:          ndx = 3; break;
            case FPE_UNDERFLOW:         ndx = 4; break;
            case FPE_INEXACT:           ndx = 5; break;
            case FPE_UNEMULATED:        ndx = 6; break;
            case FPE_SQRTNEG:           ndx = 7; break;
            case FPE_STACKUNDERFLOW:    ndx = 8; break;
            default:                    ndx = 9;
        }
        _FpeMsg = _FpeErrors[ndx];
    }
    _Error_Flag = -1;
}