TRACE DES ERREURS EN PHP

<?php
 // TestError.php
//                            "/*#V5__",   0 //debut commentaire  si (V4)
//	                           "/*#V5*/",   1 //debut instruction  si (V5)
//                            "/*#V4*/",   2 //fin   commentaire  si (V4)
//                            "/*#V4__",   3 //debut commentaire  si (V5)
//                            "/*#V*/",    4 //fin instruction et fin commentaire   si (V4) ou (V5)
// POUR PASSER EN VERSION 5 (plus utile que réaliser un programme qui génère du code
//                           en fonction des #IFDEF et autres
//
//si version 5 le constructeur doit etre __construct($Name1,$Value1)
//             le destructeur doit etre __destruct()
//             le constructeur et le destructeur V4 sont acceptés
//              les variables sont soit 'var', 'private', 'protected'
//              si "private"   les variables ne sont accessibles que dans la classe
//              si "protected" les variables sont accessibles par les classes dérivées
//              si "var"    les variables sont toujours accessibles
//si version 4 le constructeur  doit avoir le meme nom que la class ex: NameClass()
//             le destructeur doit avoir le meme nom que la class précédéavec '_' ex: _NameClass()
//             les variables sont toutes 'var'
// DefError_V#     # est soit 4 ou 5
//SI !isset($_SERVER['SERVER_NAME']) || $_SERVER['SERVER_NAME'] === 'localhost' => Le script est lancé avec PHPEdit
 //DANS CE CAS LA DIRECTIVE 'include_path' contient les path des fichiers
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
class Obj_Trace
{
 /*#V5*/  static private /*#V4__  var /*#V*/ $TraceNameFile = "Trace.log";
 /*#V5*/  static public  /*#V4__  var /*#V*/ $TraceHandle = 0;
 /*#V5*/  static public  /*#V4__  var /*#V*/ $TraceStatus = TRUE;
 //---------------------------------------------------------------------------
 /*#V5*/ static /*#V*/ function OpenFileTrace()
 {  /*#V5*/ self::$TraceHandle /*#V4__ $this->TraceHandle /*#V*/ =
                     fopen(/*#V5*/ self::$TraceNameFile /*#V4__ $this->TraceFullNameFile /*#V*/ ,"at");
    if (! /*#V5*/ self::$TraceHandle /*#V4__ $this->TraceHandle /*#V*/)
    {  /*#V5*/ self::$TraceStatus /*#V4__ $this->TraceStatus /*#V*/ = FALSE;
       trigger_error("File '"./*#V5*/ self::$TraceNameFile /*#V4__ $this->TraceFullNameFile /*#V*/.
                      "' ne peut être ouvert en mode append!", _FATAL_ERROR_);
    }
 }
 //---------------------------------------------------------------------------
 /*#V5*/ static /*#V*/ function CloseFileTrace()
 {  if (/*#V5*/ self::$TraceStatus /*#V4__ $this->TraceStatus /*#V*/ === TRUE)
       fclose(/*#V5*/ self::$TraceHandle /*#V4__ $this->TraceHandle /*#V*/);
 }
 //---------------------------------------------------------------------------
 /*#V5*/ static /*#V*/ function WriteLineTrace($Line)
 {  if (/*#V5*/ self::$TraceStatus /*#V4__ $this->TraceStatus /*#V*/ === TRUE)
    {  if (($Size = fwrite (/*#V5*/ self::$TraceHandle /*#V4__ $this->TraceHandle /*#V*/ , $Line, strlen($Line))) <= 0)
       {  /*#V5*/ self::$TraceStatus /*#V4__ $this->TraceStatus /*#V*/ = FALSE;
          trigger_error("'"./*#V5*/ self::$TraceNameFile /*#V4__ $this->TraceFullNameFile /*#V*/.
                      "' ne peut être écrit!", _FATAL_ERROR_);
       }
    }
 }
 //---------------------------------------------------------------------------
 /*#V5*/ static /*#V*/ function GetVar($Line, $Var, $bFirst = FALSE)
 {   switch (gettype($Var))
     {
     case 'integer':
     case 'double':
          return $Var;
     case 'string':
          return '"'.str_replace( array("\x00", "\x0a", "\x0d", "\x1a", "\x09"),
                       array('\0', '\n', '\r', '\Z', '\t'), $Var ).'"';
     case 'array':
          $VarNew = $Var;
     case 'object':
          if ($bFirst === TRUE)
          {  $LineCurrent = (gettype($Var) === 'object') ?
                 $Line."object '".get_class($Var)."' [" : $Line."array (";
             /*#V5*/ self::WriteLineTrace( /*#V4__ $this->WriteLineTrace( /*#V*/ $LineCurrent);
          }
          if (gettype($Var) === 'object')
          {  // TEST SI OBJECT CONTIENT LA METHODE 'MyGetArray' qui permet
             // l'accès aux variables private, protected et public avec leurs noms
             // SOIT   if (is_callable(array($Var,"MyGetArray")))
             //  bool  is_callable ( mixed   var , bool   syntax_only , string   callable_name )
             //  is_callable vérifie qu'une variable peut être appelée comme fonction.
             //  Cette fonction peut vérifier qu'une variable contient un nom de fonction valide,
             //  ou bien qu'elle contient un tableau, avec un objet et un nom de méthode.

             // SOIT   if (in_array("MyGetArray",get_class_methods($Var)))
             //  array get_class_methods(string class_name )
             //  get_class_methods retourne un tableau contenant les noms des méthodes de la classe class_name.
             // ON ESSAYE LES DEUX CAR get_class_methods peut etre infructueux
             if (in_array("MyGetArray",get_class_methods($Var)))
             {  $VarNew = $Var->MyGetArray(); }
             else
             {  if (is_callable(array($Var,"MyGetArray")))
                {  $VarNew = $Var->MyGetArray();  }
                else
                {  //NE RETOURNE QUE LES ATTRIBUTS 'PUBLIC'
                   $VarNew = get_object_vars($Var);
                }
             }
          }
          $Line = $Line. "    ";
          foreach($VarNew as $Key => $Val)
          {  $LineCurrent = $Line;
             $LineCurrent .= /*#V5*/ self::GetVar( /*#V4__ $this->GetVar( /*#V*/ $Line, $Key)." => ";
             if (!is_object($Val) && !is_array($Val))
             {  $LineCurrent .= /*#V5*/ self::GetVar( /*#V4__ $this->GetVar( /*#V*/  $Line, $Val);
                /*#V5*/ self::WriteLineTrace( /*#V4__ $this->WriteLineTrace( /*#V*/  $LineCurrent);
             }
             else
             {
                $LineCurrent .= (is_array($Val))? "array (" : "object '".get_class($Val)."' [";
                /*#V5*/ self::WriteLineTrace( /*#V4__ $this->WriteLineTrace( /*#V*/  $LineCurrent);
                /*#V5*/ self::GetVar( /*#V4__ $this->GetVar( /*#V*/  $Line, $Val);
             }
          }
          if (is_array($Var) || is_object($Var))
          {  $LineCurrent = (is_array($Var)) ? " )" : " ]";
             /*#V5*/ self::WriteLineTrace( /*#V4__ $this->WriteLineTrace( /*#V*/  $LineCurrent);
          }
          return;
     case 'resource':
          return "Resource(".strstr($Var, "#").")";
     case 'boolean':
          return $Var ? "True" : "False";
     case 'NULL':
          return "null";
     default:
          return "Unknown";
     }
 }
 //---------------------------------------------------------------------------
 /* PROBLEME AVEC PHPEDIT bug
   + function: unknown (  )
   ++'dbg_eval()' => line : 1
   ++ function: MonitoringError (
   ++            8
   ++            "Undefined variable: this"
   ++            "dbg_eval()"
   ++            1
   ++            array (
 */
 /*#V5*/ static /*#V*/ function WriteTrace($BackTrace, $NumError, $StringError, $Script, $Ligne)
 {
    $bBugError = FALSE;
    /*#V5*/ self::OpenFileTrace( /*#V4__ $this->OpenFileTrace( /*#V*/ );
    if (isset($_SERVER['SERVER_NAME']) && $_SERVER['SERVER_NAME'] !== 'localhost')
    {  $Line = "\n\n".Date("d/m/Y H:i:s");
       /*#V5*/ self::WriteLineTrace( /*#V4__ $this->WriteLineTrace( /*#V*/ $Line);
    }
    $Line ="";
    for ( $bBugError = FALSE, $Space = "", $i = count($BackTrace) - 1; $i >= 0 && $bBugError === FALSE ; $i--)
    {  $Space .= "+";
       $Line = "\n".$Space;
       $LineMatrice = $Line;
       if (isset($BackTrace[$i]["file"]))
          $Line .= "'".$BackTrace[$i]["file"]."'";
       if (isset($BackTrace[$i]["line"]))
          $Line .= " => line : ".$BackTrace[$i]["line"];
       if ($Line != $LineMatrice)
       {  if (strtolower($BackTrace[$i]["file"]) === "dbg_eval()" && $BackTrace[$i]["line"] === 1)
          {  $bBugError = TRUE;
             $Line .= " [bug avec PhpEdit1-8]";
          }
          /*#V5*/ self::WriteLineTrace( /*#V4__ $this->WriteLineTrace( /*#V*/ $Line);
          if ($bBugError === TRUE)
             continue;
       }
       $Function ="";
       if (isset($BackTrace[$i]["function"]))
       {  $Function = $BackTrace[$i]["function"];
          if ( $Function == 'include' || $Function == 'require' ||
               $Function == 'include_once' || $Function == 'require_once' )
             $Function = "";
       }
       if ($Function === "")
          continue;
       if (strtolower($Function) === "monitoringerror")
          break;
       $Line = $LineMatrice;
       $Line .= " function: ".$Function ." ( ";
       /*#V5*/ self::WriteLineTrace( /*#V4__ $this->WriteLineTrace( /*#V*/ $Line);
       if(isset( $BackTrace[$i]['args'][0]))
       {  $Virgule = " ";
          foreach( $BackTrace[$i]['args'] as $Arg )
          {  if (empty($Arg) && $Arg !== 0)
                continue;
             $Line = $LineMatrice."           ";
             $Line .= $Virgule./*#V5*/ self::GetVar( /*#V4__ $this->GetVar( /*#V*/ $Line, $Arg, TRUE);
             $Virgule = ",";
             /*#V5*/ self::WriteLineTrace( /*#V4__ $this->WriteLineTrace( /*#V*/ $Line);
          }
       }
       $Line = $LineMatrice."           ".")";
       /*#V5*/ self::WriteLineTrace( /*#V4__ $this->WriteLineTrace( /*#V*/ $Line);
    }
    $Line = "\n Error: ".$NumError." '".$StringError."' on script '".$Script."' line :".$Ligne;
    /*#V5*/ self::WriteLineTrace( /*#V4__ $this->WriteLineTrace( /*#V*/ $Line);    
    /*#V5*/ self::CloseFileTrace( /*#V4__ $this->CloseFileTrace( /*#V*/ );
    return $bBugError;
 }
 //---------------------------------------------------------------------------
}
//--------------------------------------------------------------------------------------------
//TRAITEMENT DES ERREURS
  define ("_FATAL_ERROR_",   E_USER_ERROR);
  define ("_WARNING_ERROR_", E_USER_WARNING);
  define ("_ALERT_ERROR_",   E_USER_NOTICE);

 // Creation objet ExObj_Trace en place de la class static Obj_Trace pour compatibilite avec php 4
 /*#V4__ $ExObj_Trace = new Obj_Trace; /*#V*/
  error_reporting (_FATAL_ERROR_ | _WARNING_ERROR_ | _ALERT_ERROR_);
  $ErrorMonitoring = set_error_handler("MonitoringError");
/*
 ini_set ('track_errors', TRUE);
 ini_set ( "display_errors","off");
 ini_set ( "log_errors","on");
 ini_set ( "log_error_max_len","1024");
 ini_set ( "track_errors","off");
 ini_set ( "error_log","./log/php-error.log");
*/
//--------------------------------------------------------------------------------------------
 function MonitoringError($NumError, $MsgError, $Script, $Line)
 {
    $StringError =  "<u>Numéro :</u> ".$NumError."<u> Message :</u> ".$MsgError
                 . "<br><u>Fichier :</u> ".$Script."<u> line :</u> ". $Line;

    $BackTrace = debug_backtrace();
    if ( /*#V5*/ Obj_Trace::$TraceStatus /*#V4__ $GLOBALS["ExObj_Trace"]->TraceStatus /*#V*/ === TRUE)
    {  $bBugError = /*#V5*/ Obj_Trace::WriteTrace( /*#V4__ $GLOBALS["ExObj_Trace"]->WriteTrace( /*#V*/
             $BackTrace, $NumError, $MsgError, $Script, $Line);
       if ($bBugError === TRUE)
          return;
    }
    switch ($NumError)
    {
       case _FATAL_ERROR_:
         echo "<h3 style='color:#FF0000'>Erreur <i>E_USER_ERROR</i> :</h3>".$StringError;
         exit -1;
         break;

       case _WARNING_ERROR_:
         echo "<h3 style='color:#FF0000'>Erreur <i>E_USER_WARNING</i> :</h3>".$StringError;
         break;

       case _ALERT_ERROR_:
         echo "<br> Erreur <i>E_USER_NOTICE</i>  :".$StringError;
         break;

       default:
         echo "<h3 style='color:#FF0000'>Erreur inconnue :</h3>".$StringError;
         break;
    }
 }
//--------------------------------------------------------------------------------------------
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//Cette class permet de voir tous les attributs de la classe (private, protected et public
class Obj_GetObject
{
 /*#V5*/ public    /*#V4__ var /*#V*/ $bGetObject;

  //Constructeur necessaire sinon peut provoquer une erreur
   function /*#V5*/   __construct( /*#V4__ Obj_GetObject( /*#V*/ )
   {  $this->bGetObject = TRUE;    }

   //permet de voir meme les private et les protected
   /*#V5*/  public /*#V*/ function MyGetArray()
   {
      return get_object_vars($this);
   }

}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
class TestErreur extends Obj_GetObject
{
   private $a1;
   private $a2;
   private $a3;

   function /*#V5*/   __construct( /*#V4__ Obj_GetObject( /*#V*/ )
   {  // -----  APPEL CONSTRUCTEUR Obj_GetObject -----
      /*#V5*/ parent::__construct( /*#V4__ parent::Obj_GetObject( /*#V*/);
      $this->a1 = 200;
      $this->a2 = 300;
      $this->a3 = array ("un"=> 1, "deux"=>2);
   }
   /*#V5*/  private /*#V*/function Un($var)
   {  $this->a1/=$var;
   }
   /*#V5*/  private /*#V*/function Deux($var)
   {  $this->a1+=$var;
      $this->Un($var);
   }
   /*#V5*/  public /*#V*/function Trois($var)
   {  $this->Deux($var);
   }
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
function Calcul($V,$W)
{
   $V->Trois($W);
}

//test
$Obj = new TestErreur;
Calcul($Obj,0);
?>