<?xml version="1.0" encoding="iso-8859-1"?>
<!-- $Revision: 1.13 $ -->
<reference id="ref.errorfunc">
 <title>Gestion des erreurs</title>
 <titleabbrev>Gestion des erreurs</titleabbrev>
 <partintro>
  <para>
   Ces fonctions permettent de g&eacute;rer les erreurs, et de les enregistrer.
   Vous pouvez d&eacute;finir les r&egrave;gles de traitement des erreurs et 
   choisir la mani&egrave;re de les enregistrer : vous pouvez adapter le rapport
   d'erreurs &agrave; vos besoins.
  </para>
  <para>
   Avec les fonctions d'enregistrements, vous pouvez envoyer directement les
   rapports &agrave; d'autres machines (ou m&ecirc;me les envoyer par email
   &agrave; un pager), &agrave; l'historique syst&egrave;me, ou encore
   s&eacute;lectionner les erreurs les plus importantes et ne pas enregistrer
   les autres.
  </para>
  <para>
   La fonction de niveau d'erreur vous permet de personnaliser le niveau
   et le type d'erreur not&eacute; : depuis les inoffensives alertes jusqu'au
   erreurs personnalis&eacute;es retourn&eacute;es par les fonctions.
  </para>
 </partintro>
 <refentry id="function.error-log">
  <refnamediv>
   <refname>error_log</refname>
   <refpurpose>Envoie un message d'erreur quelque part</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>error_log</methodname>
     <methodparam><type>string</type><parameter>message</parameter></methodparam>
     <methodparam><type>int</type><parameter>message_type</parameter></methodparam>
     <methodparam choice="opt"><type>string</type><parameter>destination</parameter></methodparam>
     <methodparam choice="opt"><type>string</type><parameter>extra_headers</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>error_log</function> envoie un message d'erreur &agrave; 
    l'historique du serveur web, &agrave; un port <acronym>TCP</acronym> ou un
    fichier.
    <parameter>message</parameter> est le message d'erreur qui doit &ecirc;tre
    enregistr&eacute;. <parameter>message_type</parameter> indique o&ugrave; le
    message doit &ecirc;tre envoy&eacute; :
    <table>
     <title>Types de <function>error_log</function></title>
     <tgroup cols="2">
      <tbody>
       <row>
        <entry>0</entry>
        <entry>
         <parameter>message</parameter> est envoy&eacute; &agrave; l'historique
         PHP, qui est bas&eacute; sur l'historique syst&egrave;me ou un fichier,
         en fonction de la configuration de <link
         linkend="ini.error-log">error_log</link>.
        </entry>
       </row>
       <row>
        <entry>1</entry>
        <entry>
         <parameter>message</parameter> est envoy&eacute; par email &agrave;
         l'adresse <parameter>destination</parameter>. C'est le seul type qui
         utilise le quatri&egrave;me param&egrave;tre
         <parameter>extra_headers</parameter>.  Ce message
         utilise la m&ecirc;me fonction interne que <function>mail</function>.
        </entry>
       </row>
       <row>
        <entry>2</entry>
        <entry>
         <parameter>message</parameter> est envoy&eacute; par la connexion de
         debuggage PHP. Cette option n'est disponible que si l'option
         <link
         linkend="install.configure.enable-debugger">remote_debugging</link> a
         &eacute;t&eacute; d&eacute;sactiv&eacute;e. Dans ce cas, le
         param&egrave;tre <parameter>destination</parameter> sp&eacute;cifie
         l'h&ocirc;te ou l'adresse IP, et optionnellement le num&eacute;ro de
         port, de la socket qui recevra les informations de d&eacute;buggage.
        </entry>
       </row>
       <row>
        <entry>3</entry>
        <entry>
         <parameter>message</parameter> est ajout&eacute; au fichier
         <parameter>destination</parameter>.
        </entry>
       </row>
      </tbody>
     </tgroup>
    </table>
   </para>
   <warning>
   <para>
    Le d&eacute;buggage &agrave; distance via TCP/IP est une 
    fonctionnalit&eacute; PHP 3 qui <emphasis>n'est pas</emphasis> disponible en
    PHP 4.
   </para>
   </warning>
   <para>
    <example role="php">
     <title>Exemples avec <function>error_log</function></title>
     <programlisting role="php">
&lt;?php
// Envoi une notification par l'historique du serveur, si la connexion &agrave; la base
// de donn&eacute;es est impossible.
if (!Ora_Logon ($username, $password)) {
    error_log ("Base Oracle indisponible!", 0);
}
// Indiquer &agrave; l'administrateur, par email, qu'il n'y a plus de FOO
if (!($foo = allocate_new_foo()) {
    error_log ("Aya!, Il ne reste plus de FOO disponibles!", 1,
               "operateur@mondomaine.com");
}
// D'autres mani&egrave;res d'appeler error_log():
error_log ("Grosse bourde!", 2, "127.0.0.1:7000");
error_log ("Grosse bourde!", 2, "loghost");
error_log ("Grosse bourde!", 3, "/var/tmp/my-errors.log");
?&gt;
     </programlisting>
    </example>
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.error-reporting">
  <refnamediv>
   <refname>error_reporting</refname>
   <refpurpose>Fixe le niveau de rapport d'erreurs PHP</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>error_reporting</methodname>
     <methodparam choice="opt"><type>int</type><parameter>level</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>error_reporting</function> fixe le niveau de rapport d'erreur PHP
    et retourne l'ancienne valeur. Le niveau d'erreur peut &ecirc;tre un champs
    de bits, ou une constante. L'utilisation des constantes est vivement
    recommand&eacute;e, pour assurer une compatibilit&eacute; maximale avec
    les futures versions. Au fur et &agrave; mesure que de nouveaux niveaux
    d'erreurs sont cr&eacute;&eacute;s, l'intervalle de validit&eacute; des niveaux
    &eacute;volue, et les anciennes valeurs n'ont plus les m&ecirc;mes significations.
    <example role="php">
     <title>Exemple de modification de niveau d'erreur</title>
     <programlisting role="php">
error_reporting (55);   // En PHP 3, &eacute;quivalent &agrave; E_ALL ^ E_NOTICE
/* ...en PHP 4, '55' signifie (E_ERROR | E_WARNING | E_PARSE |
E_CORE_ERROR | E_CORE_WARNING) */
error_reporting (2039); // PHP 4 &eacute;quivalent &agrave; E_ALL ^ E_NOTICE
error_reporting (E_ALL ^ E_NOTICE); // La m&ecirc;me signification en PHP 3 et 4
     </programlisting>
    </example>
    Suivez les liens de chaque valeur interne pour conna&icirc;tre leur signification :
    <table>
     <title>Constantes avec <function>error_reporting</function></title>
     <tgroup cols="2">
      <thead>
      <row>
       <entry>constante</entry>
       <entry>valeur</entry>
      </row>
      </thead>
      <tbody>
       <row>
        <entry>1</entry>
        <entry>
         <link linkend="internal.e-error">E_ERROR</link>
        </entry>
       </row>
       <row>
        <entry>2</entry>
        <entry>
         <link linkend="internal.e-warning">E_WARNING</link>
        </entry>
       </row>
       <row>
        <entry>4</entry>
        <entry>
         <link linkend="internal.e-parse">E_PARSE</link>
        </entry>
       </row>
       <row>
        <entry>8</entry>
        <entry>
         <link linkend="internal.e-notice">E_NOTICE</link>
        </entry>
       </row>
       <row>
        <entry>16</entry>
        <entry>
         <link linkend="internal.e-core-error">E_CORE_ERROR</link>
        </entry>
       </row>
       <row>
        <entry>32</entry>
        <entry>
         <link linkend="internal.e-core-warning">E_CORE_WARNING</link>
        </entry>
       </row>
       <row>
        <entry>64</entry>
        <entry>
         <link linkend="internal.e-compile-error">E_COMPILE_ERROR</link>
        </entry>
       </row>
       <row>
        <entry>128</entry>
        <entry>
         <link linkend="internal.e-compile-warning">E_COMPILE_WARNING</link>
        </entry>
       </row>
       <row>
        <entry>256</entry>
        <entry>
         <link linkend="internal.e-user-error">E_USER_ERROR</link>
        </entry>
       </row>
       <row>
        <entry>512</entry>
        <entry>
         <link linkend="internal.e-user-warning">E_USER_WARNING</link>
        </entry>
       </row>
       <row>
        <entry>1024</entry>
        <entry>
         <link linkend="internal.e-user-error">E_USER_NOTICE</link>
        </entry>
       </row>
      </tbody>
     </tgroup>
    </table>
   </para>
   <para>
    <example role="php">
     <title>Exemples avec <function>error_reporting</function></title>
     <programlisting role="php">
error_reporting(0);
/* Emp&ecirc;che tout affichage d'erreur */
error_reporting(7); // Ancienne syntaxe PHP 2/3
error_reporting(E_ERROR | E_WARNING | E_PARSE); // Nouvelle syntaxe PHP 3/4
/* Utilisation appropri&eacute;e pour les erreurs courantes d'ex&eacute;cution */
error_reporting(15); // Ancienne syntaxe, PHP 2/3
error_reporting(E_ERROR | E_WARNING | E_PARSE | E_NOTICE); // Nouvelle syntaxe PHP 3/4
/*  Utilisation appropri&eacute;e pour les erreurs courantes de d&eacute;veloppement
 (variables non initialis&eacute;es..)*/
error_reporting(63); // Ancienne syntaxe, PHP 2/3
error_reporting(E_ALL); // Nouvelle syntaxe PHP 3/4
/* rapporte toutes les erreurs PHP*/
      </programlisting>
     </example>
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.restore-error-handler">
   <refnamediv>
    <refname>restore_error_handler</refname>
    <refpurpose>
     R&eacute;active l'ancienne fonction de gestion des erreurs
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>void</type><methodname>restore_error_handler</methodname>
      <void/>
     </methodsynopsis>
    <para>
     Utilis&eacute;e apr&egrave;s avoir modifi&eacute; la fonction de gestion
     des erreurs, gr&acirc;ce &agrave; <function>set_error_handler</function>,
     <function>restore_error_handler</function> permet de r&eacute;utiliser
     l'ancienne version de gestion des erreurs (qui peut &ecirc;tre la
     fonction PHP par d&eacute;faut, ou une autre fonction utilisateur).
    </para>
    <para>
     Voir aussi 
     <function>error_reporting</function>,
     <function>set_error_handler</function>,
     <function>trigger_error</function> et 
     <function>user_error</function>
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.set-error-handler">
   <refnamediv>
    <refname>set_error_handler</refname>
    <refpurpose>
     Choisi une fonction utilisateur comme gestionnaire d'erreurs
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>string</type><methodname>set_error_handler</methodname>
      <methodparam><type>string</type><parameter>error_handler</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>set_error_handler</function> choisit la fonction utilisateur
     <parameter>error_handler</parameter> pour g&eacute;rer
     les erreurs dans un script. Retourne un pointeur sur l'ancienne fonction
     de gestion des erreurs (si il y en avait une), ou &false;, en cas d'erreur.
     <function>set_error_handler</function> sert &agrave; d&eacute;finir votre
     propre gestionnaire d'erreurs, qui prendra en charge leur traitement durant
     l'ex&eacute;cution d'un script. Cela peut &ecirc;tre utile lorsque vous
     devez rep&eacute;rer des erreurs critiques lors d'un nettoyage de bases, ou
     bien si vous souhaitez g&eacute;n&eacute;rer une erreur dans certaines
     conditions (avec <function>trigger_error</function>).
    </para>
    <para>
     La fonction utilisateur doit accepter deux arguments : le code de l'erreur,
     et une cha&icirc;ne d&eacute;crivant l'erreur. L'exemple ci dessous montre
     le traitement d'exceptions en d&eacute;clenchant des erreurs, et en les
     g&eacute;rant avec une fonction utilisateur :
     <example>
      <title>
       Traitement des erreurs avec <function>set_error_handler</function> et
       <function>trigger_error</function>
      </title>
      <programlisting role="php">
&lt;?php
// red&eacute;finit les constantes utilisateurs - PHP 4 seulement
define (FATAL,E_USER_ERROR);
define (ERROR,E_USER_WARNING);
define (WARNING,E_USER_NOTICE);
// Fixe le niveau de rapport d'erreur pour ce script
error_reporting  (FATAL + ERROR + WARNING);
// Fonction de traitement des erreurs
function myErrorHandler ($errno, $errstr) {
    switch ($errno) {
    case FATAL:
    echo &quot;&lt;B&gt;FATAL&lt;/B&gt; [$errno] $errstr&lt;br&gt;\n&quot;;
    echo &quot;  Erreur fatale &agrave; la ligne &quot;.__LINE__.&quot; du fichier &quot;.__FILE__;
    echo &quot;, PHP &quot;.PHP_VERSION.&quot; (&quot;.PHP_OS.&quot;)&lt;br&gt;\n&quot;;
    echo &quot;Aborting...&lt;br&gt;\n&quot;;
    exit -1;
    break;
    case ERROR:
    echo &quot;&lt;B&gt;ERREUR&lt;/B&gt; [$errno] $errstr&lt;br&gt;\n&quot;;
    break;
    case WARNING:
    echo &quot;&lt;B&gt;ALERTE&lt;/B&gt; [$errno] $errstr&lt;br&gt;\n&quot;;
    break;
    default:
    echo &quot;Erreur inconnue de type : [$errno] $errstr&lt;br&gt;\n&quot;;
    break;
    }
}
// fonction qui teste la gestion d'erreur
function scale_by_log ($vect, $scale) {
    if ( !is_numeric($scale) || $scale &lt;= 0 )
    trigger_error(&quot;log(x) pour x &lt;= 0 est ind&eacute;fini, vous avez pass&eacute;: scale = $scale&quot;,
      FATAL);
    if (!is_array($vect)) {
    trigger_error(&quot;Vecteur d'entr&eacute;e incorrect : un tableau de valeurs est attendu : &quot;, ERROR);
    return null;
    }
    for ($i=0; $i&lt;count($vect); $i++) {
    if (!is_numeric($vect[$i]))
    trigger_error(&quot;La valeur &agrave; la position $i n'est pas un nombre. On utilise 0 (z&eacute;ro) &agrave; la place&quot;,
      WARNING);
    $temp[$i] = log($scale) * $vect[$i];
    }
    return $temp;
}
// Ancienne fonction de traitement des erreurs
$old_error_handler = set_error_handler(&quot;myErrorHandler&quot;);
// G&eacute;n&eacute;ration de quelques erreurs : d&eacute;finition d'un tableau avec des &eacute;l&eacute;ments non num&eacute;riques
echo &quot;vector a\n&quot;;
$a = array(2,3,&quot;foo&quot;,5.5,43.3,21.11);
print_r($a);
// d&eacute;finition d'un deuxi&egrave;me table &agrave; probl&egrave;me
echo &quot;----\nvector b - a alerte (b = log(PI) * a)\n&quot;;
$b = scale_by_log($a, M_PI);
print_r($b);
// Ceci est un probl&egrave;me, on passe une cha&icirc;ne &agrave; la place d'un tableau
echo &quot;----\nvector c - une erreur\n&quot;;
$c = scale_by_log(&quot;not array&quot;,2.3);
var_dump($c);
// Ceci est critique : le tableau contient des valeurs n&eacute;gatives
echo &quot;----\nvector d - fatal error\n&quot;;
$d = scale_by_log($a, -2.5);
?&gt;
     </programlisting>
    </example>
    L'&eacute;x&eacute;cution du script devrait donner ceci :
    <informalexample>
     <programlisting>
vector a
Array
(
    [0] =&gt; 2
    [1] =&gt; 3
    [2] =&gt; foo
    [3] =&gt; 5.5
    [4] =&gt; 43.3
    [5] =&gt; 21.11
)
----
vector b - une alerte (b = log(PI) * a)
&lt;B&gt;WARNING&lt;/B&gt; [1024] La valeur &agrave; la position 2 n'est pas un nombre. On utilise 0 (z&eacute;ro) &agrave; la place&lt;br&gt;
Array
(
    [0] =&gt; 2.2894597716988
    [1] =&gt; 3.4341896575482
    [2] =&gt; 0
    [3] =&gt; 6.2960143721717
    [4] =&gt; 49.566804057279
    [5] =&gt; 24.165247890281
)
----
vector c - an error
&lt;B&gt;ERROR&lt;/B&gt; [512] Vecteur d'entr&eacute;e incorrect : un tableau de valeur est attendu&lt;br&gt;
NULL
----
vector d - fatal error
&lt;B&gt;FATAL&lt;/B&gt; [256] log(x) de x &lt;= 0 est ind&eacute;fini : scale = -2.5&lt;br&gt;
Erreur fatale &agrave; la ligne 16 du fichier trigger_error.php, PHP 4.0.1pl2 (Linux)&lt;br&gt;
Annulation du script....&lt;br&gt;
     </programlisting>
    </informalexample>
   </para>
   <para>
    Il faut se rappeler que la fonction standard de traitement des erreurs
    de PHP est alors compl&egrave;tement ignor&eacute;e.
    <function>error_reporting</function>
    n'aura plus d'effet, et votre fonction de gestion des
    erreurs sera toujours appel&eacute;e. Vous pourrez toujours lire la valeur
    de l'erreur courante de <function>error_reporting</function> et
    faire r&eacute;agir la fonction de gestion des erreurs en fonction.
    Cette remarque est notamment valable si la commande a &eacute;t&eacute;
    pr&eacute;fix&eacute;e par <link linkend="language.operators.errorcontrol">&#64;</link>
    (0 sera retourn&eacute;).
   </para>
   <para>
    Notez aussi qu'il est alors confi&eacute; &agrave; cette fonction de
    terminer le script (<function>die</function>) si n&eacute;cessaire. Si la
    fonction de gestion des erreurs se termine normalement, l'ex&eacute;cution
    du script se poursuivra avec l'ex&eacute;cution de la prochaine commande.
   </para>
   <para>
    Voir aussi 
    <function>error_reporting</function>,
    <function>restore_error_handler</function>,
    <function>trigger_error</function> et 
    <function>user_error</function>
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.trigger-error">
  <refnamediv>
   <refname>trigger_error</refname>
   <refpurpose>
    D&eacute;clenche une erreur utilisateur
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>void</type><methodname>trigger_error</methodname>
     <methodparam><type>string</type><parameter>error_msg</parameter></methodparam>
     <methodparam choice="opt"><type>int</type><parameter>error_type</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>trigger_error</function> est utilis&eacute; pour d&eacute;clencher
    une erreur utilisateur. Elle peut aussi &ecirc;tre utilis&eacute;e en
    conjonction avec un gestionnaire d'erreur interne, ou un gestionnaire
    d'erreurs utilisateur qui a &eacute;t&eacute; choisi comme gestionnaire
    d'erreur avec <function>set_error_handler</function>.
   </para>
   <para>
    <function>trigger_error</function> est pratique lorsque vous devez
     g&eacute;n&eacute;rer une r&eacute;ponse particuli&egrave;re lors de
     l'ex&eacute;cution. Par exemple :
    <informalexample>
     <programlisting role="php">
&lt;?php
if (assert ($divisor == 0))
   trigger_error ("Impossible de diviser par z&eacute;ro", E_USER_ERROR);
?&gt;
     </programlisting>
    </informalexample>
    <note>
     <para>
      Voir aussi 
      <function>set_error_handler</function> pour illustration.
     </para>
    </note>
   </para>
   <para>
    Voir aussi 
    <function>error_reporting</function>,
    <function>set_error_handler</function>,
    <function>restore_error_handler</function> et
    <function>user_error</function>
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.user-error">
  <refnamediv>
   <refname>user_error</refname>
   <refpurpose>
    G&eacute;n&egrave;re un message d'erreur utilisateur
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>void</type><methodname>user_error</methodname>
     <methodparam><type>string</type><parameter>error_msg</parameter></methodparam>
     <methodparam choice="opt"><type>int</type><parameter>error_type</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>user_error</function> est un alias de la fonction
    <function>trigger_error</function>.
   </para>
   <para>
    Voir aussi 
    <function>error_reporting</function>,
    <function>set_error_handler</function>,
    <function>restore_error_handler</function> et 
    <function>trigger_error</function>.
   </para>
  </refsect1>
 </refentry>
</reference>
<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
indent-tabs-mode:nil
sgml-parent-document:nil
sgml-default-dtd-file:"../../manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
-->