`_fpieee_flt`

Article
04/03/2023

Appelle un gestionnaire d'interruptions défini par l'utilisateur pour les exceptions à virgule flottante IEEE.

Syntaxe

int _fpieee_flt(
   unsigned long excCode,
   struct _EXCEPTION_POINTERS *excInfo,
   int handler(_FPIEEE_RECORD *)
);

Paramètres

excCode
Code d’exception.

excInfo
Pointeur désignant la structure d’informations sur les exceptions Windows NT.

handler
Pointeur vers la routine du gestionnaire d'interruptions IEEE de l'utilisateur.

Valeur retournée

La valeur de retour de _fpieee_flt est la valeur retournée par handler. Ainsi, la routine de filtre IEEE peut être utilisée dans la clause d'exception d'un mécanisme de gestion structurée des exceptions (SEH).

Notes

La fonction _fpieee_flt appelle un gestionnaire d'interruptions défini par l'utilisateur pour les exceptions à virgule flottante IEEE et lui fournit toutes les informations pertinentes. Cette routine sert de filtre d'exception dans le mécanisme SEH, qui appelle votre propre gestionnaire d'exceptions IEEE si nécessaire.

La structure _FPIEEE_RECORD, définie dans Fpieee.h, contient des informations concernant une exception à virgule flottante IEEE. Cette structure est passée au gestionnaire d'interruptions défini par l'utilisateur par _fpieee_flt.

Champ _FPIEEE_RECORD	Description
`RoundingMode` `Precision`	Ces `unsigned int` champs contiennent des informations sur l’environnement à virgule flottante au moment où l’exception s’est produite.
`Operation`	Ce `unsigned int` champ indique le type d’opération qui a provoqué l’interruption. Si le type est une comparaison (`_FpCodeCompare`), vous pouvez fournir l’une des valeurs spéciales `_FPIEEE_COMPARE_RESULT` (telles que définies dans Fpieee.h) dans le champ Result.Value . Le type de conversion (`_FpCodeConvert`) indique que l'interruption s'est produite pendant une opération de conversion à virgule flottante. Vous pouvez examiner les types `Operand1` et `Result` pour déterminer le type de conversion tenté.
`Operand1` `Operand2` `Result`	Ces `_FPIEEE_VALUE` structures indiquent les types et valeurs des résultats proposés et des opérandes. Chaque structure contient les champs suivants : `OperandValid` - Indicateur indiquant si la valeur de réponse est valide. `Format` - Type de données de la valeur correspondante. Le type de format peut être retourné même si la valeur correspondante n’est pas valide. `Value` - Valeur de données de résultat ou d’opérande.
`Cause` `Enable` `Status`	`_FPIEEE_EXCEPTION_FLAGS` contient un champ de bits pour chaque type d’exception à virgule flottante. Il existe une correspondance entre ces champs et les arguments utilisés pour masquer les exceptions fournies à `_controlfp`. La signification exacte de chaque bit dépend du contexte : `Cause` - Chaque bit défini indique l’exception particulière qui a été levée. `Enable` - Chaque bit défini indique que l’exception particulière est actuellement masquée. `Status` - Chaque bit défini indique que l’exception particulière est actuellement en attente, ce qui inclut les exceptions qui n’ont pas été levées parce qu’elles ont été masquées par `_controlfp`.

Les exceptions en attente désactivées sont déclenchées lorsque vous les activez. Ces exceptions peuvent entraîner un comportement non défini lors de l’utilisation _fpieee_flt en tant que filtre d’exception. Appelez _clearfp toujours avant d’activer des exceptions à virgule flottante.

Spécifications

Fonction	En-tête requis
`_fpieee_flt`	<fpieee.h>

Pour plus d’informations sur la compatibilité, consultez Compatibility.

Exemple

// crt_fpieee.c
// This program demonstrates the implementation of
// a user-defined floating-point exception handler using the
// _fpieee_flt function.

#include <fpieee.h>
#include <excpt.h>
#include <float.h>
#include <stddef.h>

int fpieee_handler( _FPIEEE_RECORD * );

int fpieee_handler( _FPIEEE_RECORD *pieee )
{
   // user-defined ieee trap handler routine:
   // there is one handler for all
   // IEEE exceptions

   // Assume the user wants all invalid
   // operations to return 0.

   if ((pieee->Cause.InvalidOperation) &&
       (pieee->Result.Format == _FpFormatFp32))
   {
        pieee->Result.Value.Fp32Value = 0.0F;

        return EXCEPTION_CONTINUE_EXECUTION;
   }
   else
      return EXCEPTION_EXECUTE_HANDLER;
}

#define _EXC_MASK    \
    _EM_UNDERFLOW  + \
    _EM_OVERFLOW   + \
    _EM_ZERODIVIDE + \
    _EM_INEXACT

int main( void )
{
   // ...

   __try {
      // unmask invalid operation exception
      _controlfp_s(NULL, _EXC_MASK, _MCW_EM);

      // code that may generate
      // fp exceptions goes here
   }
   __except ( _fpieee_flt( GetExceptionCode(),
                GetExceptionInformation(),
                fpieee_handler ) ){

      // code that gets control

      // if fpieee_handler returns
      // EXCEPTION_EXECUTE_HANDLER goes here

   }

   // ...
}

Voir aussi

Prise en charge des fonctions mathématiques et à virgule flottante
_control87, , _controlfp__control87_2
_controlfp_s

Partager via