Télécharger ang Class Debug

Sources PHP Tableaux (Array) Tests
> Téléchargez > Développement Web > PHP > Sources PHP
Avatar de gene69
Membre Expert
Mise à jour le : 20/08/2011  ·   Licence : GPL  ·   Téléchargé 24 fois   ·   16 Ko  +
Présentation
  • utilisez un autoloader de classe pour vous simplifier la vie
  • j'utilise ça preque exclusivement en version statique, pour faire des sites spaghettis
  • Debug::var_dump()
  • Debug::here() si vous utilisez des output buffer (ob_start)
  • Debug::printStack()
  • Debug::describeState()
  • c'est documenté pour phpdocumentor (enfin la partie la plus utile = statique )
  • s'active et se desactive partout sans pb de visibilité avec Debug::$inhibit
  • fonctionne dans le shell Debug::outputHTML



je suis pointilleux pour le coté GPL2. je répond au message par MP si vous trouvez un bug (dans la classe, pas dans votre code).
Téléchargement :
Télécharger 






		
  1. <?php
  2. /**
  3.  * @package framework
  4.  * @author Pierre-Emmanuel Périllon
  5.  * @license GPL2
  6.  *
  7.  *      This program is free software; you can redistribute it and/or modify
  8.  *      it under the terms of the GNU General Public License as published by
  9.  *      the Free Software Foundation; either version 2 of the License, or
  10.  *      (at your option) any later version.
  11.  *
  12.  *      This program is distributed in the hope that it will be useful,
  13.  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.  *      GNU General Public License for more details.
  16.  *
  17.  *      You should have received a copy of the GNU General Public License
  18.  *      along with this program; if not, write to the Free Software
  19.  *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  20.  *      MA 02110-1301, USA.
  21.  **/
  22. /**
  23.  * @see __autoload()
  24.  * */
  25. require_once('autoload.inc.php');
  26. /**
  27.  * @package framework
  28.  */
  29. //class DebugException extends MyException{};
  30.  
  31. /**
  32.  * This class allow to print lots of debug info in different context (with static method)
  33.  * and allow to debug $_SESSION by initialising $_SESSION = new Debug();
  34.  * @package framework
  35.  */
  36. class Debug  extends  ArrayObject implements Serializable
  37. {
  38.  
  39. 	/**
  40. 	 * @var boolean inhibe le fonctionnement de la classe lorsqu'à vrai.
  41. 	 * */
  42. 	static $inhibit;
  43.  
  44. 	/**
  45. 	 * @var this is a filename where i can up ArrayObject info
  46. 	 * */
  47. 	static $debug_outup;
  48.  
  49. 	/**
  50. 	 * @var ressource this is a file
  51. 	 * */
  52. 	private $fp;
  53.  
  54. 	/**
  55. 	 * @var string identifiant unique de l'objet.
  56. 	 * */
  57. 	private $uid;
  58.  
  59. 	/*****/
  60. 	static $outputHTML = true;
  61.  
  62.  
  63. 	/* Méthodes */
  64. 	function __construct ( )
  65. 	{
  66. 		$this->init();
  67. 		$this->writeLog(__FUNCTION__);
  68. 		parent::__construct();
  69. 	}
  70.  
  71.  
  72.  
  73. 	function __destruct(  )
  74. 	{
  75. 		$this->writeLog(__FUNCTION__);
  76. 		if ( is_resource( $this->fp ) )
  77. 		{
  78. 			fclose($this->fp);
  79. 		}
  80. 		$this->fp = null;
  81. 	}
  82.  
  83.  
  84. 	function __toString()
  85. 	{
  86. 		return $this->uid;
  87. 	}
  88.  
  89. 	function append ( $value )
  90. 	{
  91. 		$this->writeLog(__FUNCTION__);
  92. 		parent::append($values);
  93. 	}
  94.  
  95. 	function asort ()
  96. 	{
  97. 		$this->writeLog(__FUNCTION__);
  98. 		parent::asort();
  99. 	}
  100.  
  101. 	//function count ( )
  102.  
  103. 	function  exchangeArray (&$input )
  104. 	{
  105. 		$this->writeLog(__FUNCTION__);
  106. 		return  parent::exchangeArray ( $input );
  107. 	}
  108. 	//function  getFlags ( void )
  109. 	//function  getIterator ( void )
  110. 	//function  getIteratorClass ( void )
  111.  
  112. 	function init()
  113. 	{
  114. 		if ( !empty(self::$debug_outup ) )
  115. 		{
  116. 			$this->fp = fopen( self::$debug_outup, 'a' );
  117. 			if ( $this->fp  === false )
  118. 			{
  119. 				throw new Exception("ne peut ouvrir le fichier de log");
  120. 			}
  121. 		}
  122. 		else
  123. 		{
  124. 			$this->fp = null;
  125. 		}
  126. 		$this->uid = uniqid('#');
  127. 	}
  128.  
  129. 	function  ksort ( )
  130. 	{
  131. 		$this->writeLog(__FUNCTION__);
  132. 		parent::ksort();
  133. 	}
  134.  
  135. 	function  natcasesort ( )
  136. 	{
  137. 		$this->writeLog(__FUNCTION__);
  138. 		parent::natcasesort ( );
  139. 	}
  140.  
  141. 	function  natsort (  )
  142. 	{
  143. 		$this->writeLog(__FUNCTION__);
  144. 		parent::natsort ( );
  145. 	}
  146.  
  147. //	function  offsetExists ( mixed $index )
  148. //	function offsetGet ( mixed $index )
  149.  
  150. 	function offsetSet (   $index ,   $newval )
  151. 	{
  152. 		$this->writeLog(__FUNCTION__ , serialize($index).'=>'.serialize($newval) );
  153. 		return parent::offsetSet(  $index ,  $newval);
  154. 	}
  155.  
  156. 	function offsetUnset ( $index )
  157. 	{
  158. 		$this->writeLog(__FUNCTION__, $index );
  159. 		parent::offsetUnset ( $index );
  160. 	}
  161.  
  162.  
  163. 	function serialize ( )
  164. 	{
  165. 		$this->writeLog(__FUNCTION__);
  166. 		return serialize($this->getArrayCopy());
  167. 	}
  168.  
  169. //	function setFlags ( int $flags )
  170. //	function setIteratorClass ( string $iterator_class )
  171.  
  172. 	function uasort (  $cmp_function )
  173. 	{
  174. 		$this->writeLog(__FUNCTION__);
  175. 		parent:: uasort( );
  176. 	}
  177.  
  178. 	function uksort (  $cmp_function )
  179. 	{
  180. 		$this->writeLog(__FUNCTION__);
  181. 		parent:: uksort (   );
  182. 	}
  183.  
  184.  
  185. 	/**
  186. 	 * ce serrait tres beau si ça marchait comme ça.
  187. 	 * */
  188. 	function unserialize ( $serialized )
  189. 	{
  190. 		unserialize( $serialized);
  191. 		$this->init();
  192. 		$this->writeLog(__FUNCTION__);
  193. 	}
  194.  
  195.  
  196.  
  197. 	/***
  198. 	 * tue le script en cours.
  199. 	 *
  200. 	 * @access public
  201. 	 * @static
  202. 	 * @return void
  203. 	 * @uses Debug::getCaller()
  204. 	***/
  205. 	static public function kill()
  206. 	{
  207. 		if ( self::$inhibit ) return ;
  208.  
  209. 		echo '
  210. <!-- SCRIPT KILLED !!! -->
  211. ',$tmp = self::getCaller(),'
  212. <!-- will kown unload outputBuffer -->
  213. ';
  214.  
  215. 		$buff = array();
  216. 		while( ob_get_level() > 1 )
  217. 		{
  218. 			echo '
  219. <!-- new Buffer -->
  221. 		}
  222. 		echo '<!-- SCRIPT KILLED !!!
  223. ' ,$tmp ,'
  224. -->';
  226. 	}
  227.  
  228.  
  229. 	static function describeState( $e = null )
  230. 	{
  231. 		Debug::printCaller(1);
  232. 		echo '
  233. <div>
  234. 	<strong>Informations</strong>
  235. 	<p>
  236. 	Généré à ',date('r'),' <br />
  237. 	have fun! The script is runned by php version ',phpversion(),'</p>
  238. 	<strong>Exception</strong>
  239. 	<pre>',is_null($e)?'no exception':htmlspecialchars($e),'</pre>
  240. 	<strong>Input: Session</strong>
  241. 	<pre>',htmlspecialchars( isset($_SESSION)	?print_r($_SESSION,true):'no session' ),'</pre>
  242. 	<strong>Input: GET</strong>
  243. 	<pre>',htmlspecialchars(count($_GET)	?print_r($_GET,true):'no GET'),'</pre>
  244. 	<strong>Input: POST</strong>
  245. 	<pre>',htmlspecialchars(count($_POST)	?print_r($_POST,true):'no POST'),'</pre>
  246. 	<strong>Input: FILE</strong>
  247. 	<pre>',htmlspecialchars(isset($_FILES)	?print_r($_FILES,true):'no files received'),'</pre>
  248. 	<strong>Input: COOKIE</strong>
  249. 	<pre>',htmlspecialchars(count($_COOKIE)	?print_r($_COOKIE,true):'no coockies'),'</pre>
  250. 	<strong>Input: Included files</strong>
  251. 	<pre>',print_r(get_included_files(),true),'</pre>
  252. </div>';
  253.  
  254. 	}
  255.  
  256. 	/**
  257. 	 * renvoie la pile d'appel purgée des appels internes dans la classe.
  258. 	 * @static
  259. 	 * @uses Debug::ignoreDebugCall()
  260. 	 * @return array
  261. 	 */
  262. 	static public function debug_backtrace()
  263. 	{
  265. 		self::ignoreDebugCall($x);
  266. 		return $x;
  267. 	}
  268.  
  269. 	/***
  270. 	 * renvoie une chaine formatée en xhtml qui contient le nom de la
  271. 	 * fonction dans la pile d'appel à la profondeur passée en paramettre.
  272. 	 * attention, cette pile est dépourvue des appels internes à la classe.
  273. 	 * @static
  274. 	 * @access public
  275. 	 * @param  integer $i  (optionnel) profondeur supplementaire
  276. 	 * @uses Debug::printCaller()
  277. 	 * @return string
  278. 	 */
  279. 	static public function getCaller($i = 0)
  280. 	{
  282. 		self::printCaller($i);
  283. 		return ob_get_clean();
  284. 	}
  285.  
  286. 	/**
  287. 	 * revoie une pile formatée en xhtml pour affichage
  288. 	 * @static
  289. 	 * @access private
  290. 	 * @param boolean $full
  291. 	 * @uses Debug::$inhibit
  292. 	 * @uses Debug::ignoreDebugCall()
  293. 	 * @uses Debug::printStackLine()
  294. 	 * @uses Debug::var_dump()
  295. 	 **/
  296. 	static function getStack( $full = false)
  297. 	{
  298. 		if ( self::$inhibit ) return ;
  299.  
  300. 		$tab = debug_backtrace();
  301. 		self::ignoreDebugCall($tab);
  302.  
  304. 	//		($tab);
  305. 		if ( self::$outputHTML )
  306. 		{
  307. 			echo "<ol class=\"debugStack\">\n";
  308. 		}
  309. 		foreach( $tab as  $y => $x )
  310. 		{
  311. 			//on se moque pas mal des appels à l'intérieur de la classe
  312. 			//Ceci dit c'est + pratique de tester le fichier que la classe.
  313. 			echo self::$outputHTML?'<li>':"\t";
  314. 			self::printStackLine($x);
  315. 			if ( $full )
  316. 			{
  317. 				self::var_dump($x, false);
  318. 			}
  319. 			echo self::$outputHTML?'</li>':"\n";
  320. 		}
  321. 		if ( self::$outputHTML )
  322. 		{
  323. 			echo "</ol>\n";
  324. 		}
  325. 		return ob_get_clean();
  326. 	}
  327.  
  328. 	/**
  329. 	 * affiche immédiatement (en option ou pas) ou est le script en
  330. 	 * s'affranchissant des éventuels tampons de capture de sortie
  331. 	 * @static
  332. 	 * @param mixed $msg affiche le contenu d'une variable (avec le type, via serialize)
  333. 	 * @param boolean $unloadBuffer si vrai s'affranchir des ob_start
  334. 	 * @uses Debug::unloadOutBuffer()
  335. 	 * @uses Debug::printStackLine()
  336. 	 * @uses Debug::reloadOutBuffer()
  337. 	 * @return void
  338. 	 * */
  339. 	static public function here( $msg = null, $unloadBuffer = true )
  340. 	{
  341. 		if ( self::$inhibit ) return ;
  342.  
  343. 		if ( $unloadBuffer ) $buffer = self::unloadOutBuffer();
  344. 		$tab = debug_backtrace();
  345. 		self::printNewLine();
  346. 		self::printStackLine($tab[0]);
  347. 		echo ' param = ',serialize($msg);
  348. 		self::printNewLine();
  349. 		if ( $unloadBuffer ) self::reloadOutBuffer($buffer);
  350. 	}
  351.  
  352. 	static protected function printNewLine()
  353. 	{
  354. 		echo self::$outputHTML ?'<br/>':"\n";
  355. 	}
  356.  
  357.  
  358. 	/**
  359. 	 * enlève les appels interne à à la pile d'un bactrace
  360. 	 * @static
  361. 	 * @access protected
  362. 	 * @param array $tab
  363. 	 * @return void
  364. 	 * */
  365. 	static protected function ignoreDebugCall(&$tab )
  366. 	{
  367. 		while (
  368. 			( isset($tab[1], $tab[0]['file']) and $tab[0]['file'] === __FILE__  )
  369. 			or
  370. 			( !isset($tab[0]['file']) and   isset($tab[1]['file']) ) ) // le cas du serialize
  371. 		{
  372. 			array_shift($tab);
  373. 		}
  374. 	}
  375.  
  376. 	/**
  377. 	 * affiche la ligne et le fichier responsable de l'appel à cette fonction
  378. 	 * @static
  379. 	 * @param integer $i profondeur supplémentaire, si trop grand l'appel du bas de la pile
  380. 	 * @uses Debug::ignoreDebugCall()
  381. 	 * @uses Debug::printStackLine()
  382. 	 * @uses  self::$inhibit()
  383. 	 * return void
  384. 	 * */
  385. 	static public function printCaller($i = 0)
  386. 	{
  387. 		if ( self::$inhibit ) return ;
  388. 		$tab = debug_backtrace();
  389. 		self::ignoreDebugCall($tab);
  390.  
  391. 		if ( isset( $tab[$i] ) )
  392. 		{
  393. 			self::printStackLine($tab[$i]);
  394. 		}
  395. 		else
  396. 		{
  397. 			self::printStackLine(end($tab));
  398. 		}
  399. 	}
  400.  
  401. 	function printSimpleBackTrace($full = false)
  402. 	{
  403. 		if ( self::$inhibit ) return ;
  404. 		$tab = debug_backtrace();
  405. 		self::ignoreDebugCall($tab);
  406. 		foreach( $tab as $tmp )
  407. 		{
  408. 			foreach( $tmp as $k => $v )
  409. 			{
  410. 				echo " ",$k,'=>';
  411. 				if ( !$full and $k !== 'object' )
  412. 				{
  413. 					echo $v;
  414. 				}
  415. 				else
  416. 				{
  417. 					echo gettype($v);
  418. 				}
  419. 			}
  420. 			self::printNewLine();
  421. 		}
  422. 	}
  423.  
  424. 	/***
  425. 	 * affiche une exception en html, css embeded
  426. 	 * @static
  427. 	 * @uses Debug::printExceptionHTML()
  428. 	 * @uses Debug::printExceptionTXT()
  429. 	 * @uses Debug::$inhibit
  430. 	 * @return void
  431. 	 * */
  432. 	static public function printException(Exception $e)
  433. 	{
  434. 		if ( self::$inhibit ) return ;
  435. 		self::$outputHTML?printExceptionHTML($e):printExceptionTXT($e);
  436. 	}
  437.  
  438. 	/***
  439. 	 * affiche une exception en html, css embeded
  440. 	 * @static
  441. 	 * @uses Debug::printStackLinkHTML()
  442. 	 * @uses Exception::getFile()
  443. 	 * @uses Exception::getLine()
  444. 	 * @uses Exception::getTraceAsString()
  445. 	 * @return void
  446. 	 * */
  447. 	static protected function printExceptionHTML(&$e)
  448. 	{
  449. 		echo '
  450. <pre style="color:red" class="debugStack">
  451. <b>',get_class($e),':</b>', $e->getMessage(),'
  452. 	Exception lancée dans';
  453. 	self::printStackLinkHTML( $e->getFile(), $e->getLine() );
  454. 	echo "\n\t",str_replace("\n","\n\t",$e->getTraceAsString()),
  455. '</pre>';
  456. 	}
  457.  
  458. 	/***
  459. 	 * affiche une exception en html, css embeded
  460. 	 * @static
  461. 	 * @uses Exception::getFile()
  462. 	 * @uses Exception::getLine()
  463. 	 * @uses Exception::getTraceAsString()
  464. 	 * @return void
  465. 	 * */
  466. 	static protected function printExceptionTXT(&$e)
  467. 	{
  468. 		echo '
  469. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  470. ',get_class($e),': ', $e->getMessage(),'
  471. Exception lancée dans', $e->getFile(),':', $e->getLine(),'
  472. ',str_replace("\n","\n\t",$e->getTraceAsString()),'
  473. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  474. ';
  475. 	}
  476.  
  477.  
  478.  
  479.  
  480.  
  481.  
  482.  
  483. 	/***
  484. 	 * affiche l'état de la pile dans le flux, utilise des css du site.
  485. 	 * @static
  486. 	 * @access public
  487. 	 * @return void
  488. 	 * @uses Debug::$inhibit
  489. 	 * @uses Debug::getStack()
  490. 	 * */
  491. 	static public function printStack($full = false)
  492. 	{
  493. 		if ( self::$inhibit ) return ;
  494. 		echo self::getStack($full);
  495. 	}
  496.  
  497. 	/**
  498. 	 * affiche une ligne de pile d'appel
  499. 	 * @param array $x une ligne de backtrace
  500. 	 * @access protected
  501. 	 * @static
  502. 	 * @return void
  503. 	 * @uses Debug::printStackLinkHTMLHTML()
  504. 	 * @uses Debug::printStackLineTXT()
  505. 	 * */
  506. 	static protected function printStackLine($x)
  507. 	{
  508. 		if ( self::$outputHTML )
  509. 		{
  510. 			self::printStackLineHTML($x);
  511. 		}
  512. 		else
  513. 		{
  514. 			self::printStackLineTXT($x);
  515. 		}
  516. 	}
  517.  
  518. 	static protected function printStackLineHTML($x)
  519. 	{
  520. 		if ( isset($x['class']) )
  521. 		{
  522. 			$class = $x['class'].$x['type'];
  523. 		}
  524. 		else
  525. 		{
  526. 			$class = null;
  527. 		}
  528. 		if ( isset( $x['file'] )  )
  529. 		{
  530. 			echo '<b>',$class,$x['function'],'</b> appelé en ';
  531. 			self::printStackLinkHTML($x['file'], $x['line']);
  532. 		}
  533. 		else if ( isset( $x['args'] ) )
  534. 		{
  535. 			echo '<b>',$class,$x['function'],'</b> appelé en callback';
  536. 			if ( isset($x['args'][0],$x['args'][1]) )
  537. 			{
  538. 				echo ' depuis ';
  539. 				self::printStackLinkHTML(
  540. 					$x['args'][0],
  541. 					$x['args'][1]);
  542. 			}
  543. 		}
  544. 		else
  545. 		{
  546. 			echo '<b>',$class,$x['function'],'</b>';
  547. 		}
  548. 		echo ' ( OB:',ob_get_level(),' )';
  549. 		return true;
  550. 	}
  551.  
  552.  
  553. 	static protected function printStackLineTXT($x)
  554. 	{
  555. 		if ( isset($x['class']) )
  556. 		{
  557. 			$class = $x['class'].$x['type'];
  558. 		}
  559. 		else
  560. 		{
  561. 			$class = null;
  562. 		}
  563. 		if ( isset( $x['file'] )  )
  564. 		{
  565. 			echo $class,$x['function'],' appelé en ',$x['file'],':',$x['line'];
  566. 		}
  567. 		else if ( isset( $x['args'] ) )
  568. 		{
  569. 			echo $class,$x['function'],' appelé en callback';
  570. 			if ( isset($x['args'][0],$x['args'][1]) )
  571. 			{
  572. 				echo ' depuis ',$x['args'][0],':',$x['args'][1];
  573. 			}
  574. 		}
  575. 		else
  576. 		{
  577. 			echo $class,$x['function'];
  578. 		}
  579. 		echo ' ( OB:',ob_get_level(),' ) ';
  580. 		return true;
  581. 	}
  582.  
  583.  
  584.  
  585.  
  586.  
  587.  
  588. 	/**
  589. 	 * cree le p'tit lien dans la pile pour aller vers ma doc sur BddSql
  590. 	 * @access protected
  591. 	 * @static
  592. 	 * @uses Debug::uri2url()
  593. 	 * @uses SourceCode::$param
  594. 	 * @param filename $file
  595. 	 * @param integer $line
  596. 	 * @return void
  597. 	 * */
  598. 	static protected function printStackLinkHTML($file, $line)
  599. 	{
  600. 		echo '<a href="',self::uri2url($file),'?',SourceCode::$param,
  601. 		'#line',$line,'" title="voir le code">',$file,'</a>:',$line;
  602. 	}
  603.  
  604. 	/**
  605. 	 * recrée une pile de outputBuffer à partir d'un tableau de chaine
  606. 	 * @static
  607. 	 * @param $array le contenu à remettre en buffer.
  608. 	 * @uses Debug::$inhibit
  609. 	 * @see self::unloadOutBuffer()
  610. 	 * */
  611. 	static public function reloadOutBuffer($buff)
  612. 	{
  613. 		if ( self::$inhibit ) return ;
  614.  
  615. 		$n = count($buff) - 1;
  616. 		for( $it = $n ; $it >= 0 ; $it--)
  617. 		{
  619. 			echo $buff[$it];
  620. 			unset($buff[$it]);
  621. 		}
  622. 	}
  623.  
  624. 	/**
  625. 	 * dépile les outputbuffer vers un tableau
  626. 	 * @static
  627. 	 * @uses Debug::$inhibit
  628. 	 * @return array
  629. 	 * @see self::reloadOutBuffer()
  630. 	 * */
  631. 	static public function unloadOutBuffer()
  632. 	{
  633. 		if ( self::$inhibit ) return ;
  634.  
  635. 		$buff = array();
  636. 		while( ob_get_level() > 1 )
  637. 		{
  638. 			$buff[]=ob_get_clean();
  639. 		}
  640. 		return $buff;
  641. 	}
  642.  
  643. 	/***
  644. 	 * replace un nom de fichier local en ce qu'il devrait être sur le web
  645. 	 * pet'te que ça marche pas.
  646. 	 * @param filename $file
  647. 	 * @return string
  648. 	 * */
  649. 	static protected function uri2url( $file )
  650. 	{
  651. 		$hide[] = '/var/www';
  652. 		$hide[] = $_SERVER['DOCUMENT_ROOT'];
  653. 		return str_replace($hide,'http://'.$_SERVER['SERVER_NAME'], $file);
  654. 	}
  655.  
  656.  
  657.    /***
  658.     * Affiche la définition et les valeurs d'un objet (type inconnu)
  659.     * @param $mixed $objet
  660.     * @param boolean $here
  661.     * @uses Debug::ignoreDebugCall()
  662.     * @uses Debug::printStackLine(
  663.     * */
  664. 	static public function var_dump ($objet, $here = true)
  665. 	{
  666. 		if ( self::$inhibit) return;
  668. 		var_dump($objet);
  669. 		$dump = ob_get_clean();
  670. 		if ( self::$outputHTML )
  671. 		{
  672. 			echo '<pre style="background-color:WhiteSmoke;color:gray">';
  673. 		}
  674. 		if ( $here )
  675. 		{
  677. 			self::ignoreDebugCall($x);
  678. 			self::printStackLine($x[0]);
  679. 		}
  680. 		echo "\n";
  681. 		if ( self::$outputHTML )
  682. 		{
  683. 			echo htmlspecialchars($dump),
  684. 			'</pre>';
  685. 		}
  686. 	}
  687.  
  688.  
  689. 	/***
  690. 	 * affiche les stats d'utilisation de la mémoire.
  691. 	 * */
  692. 	static public function printMemoryUsage()
  693. 	{
  694. 		//Let's do some exotic piece of code...
  695. 		function calculerTailleUniteOctets($taille)
  696. 		{
  697. 			if ( $taille < 1024 )
  698. 			{
  699. 				return  $taille.' O';
  700. 			}
  701. 			else if (  $taille  < 1048576 )
  702. 			{
  703. 				return  round($taille/1024.0 , 1).' Ko';
  704. 			}
  705. 			else if (  $taille < 1073741824 /*2^30*/ )
  706. 			{
  707. 				return round($taille/ 1048576.0 , 1).' Mo';
  708. 			}
  709. 			else if ( $taille < 1099511627776 )
  710. 			{
  711. 				return round($taille/1073741824.0 , 1).' Go';
  712. 			}
  713. 			else //1125899906842624
  714. 			{
  715. 				return  round($taille/1099511627776.0 , 1).' To';
  716. 			}
  717. 		}
  718.  
  719. 		if ( self::$inhibit ) return ;
  720. 		global $start_time;
  723.  
  724. 		echo ( self::$outputHTML )?'
  725. <pre style="background-color:WhiteSmoke;color:gray">
  726. ':'
  727. ------------------------------------------------------------------------
  728. ';
  729.  
  730. 		echo
  731. 		'memory usage (current): ',$n,' - ',calculerTailleUniteOctets($n),"\n",
  732. 		'memory usage (peak): ',$m,' - ',calculerTailleUniteOctets($m),"\n",
  733. 		'memory max allowed: ',ini_get('memory_limit'),"\n",
  734. 		'execution time: ',round(microtime(true) - $start_time, 5)," s \n",
  735. 		'execution time allowed: ',ini_get('max_execution_time')," s \n";
  736.  
  737. 		echo self::$outputHTML ? '
  738. </pre>
  739. ':'
  740. ------------------------------------------------------------------------
  741. ';
  742. 	}
  743.  
  744.  
  745.  
  746.  
  747. 	/**
  748. 	 * @param string $action
  749. 	 * */
  750. 	protected function writeLog($action, $option = null)
  751. 	{
  752. 		if (  is_resource($this->fp) )
  753. 		{
  754. 			fwrite( $this->fp, $this->uid."\t".$action."\t".strip_tags(self::getCaller(0))."\t".$option."\n" );
  755. 			fflush( $this->fp );
  756. 		}
  757. 	}
  758.  
  759. }
  760. Debug::$debug_outup = 'DEBUG_ARRAY.log';
  761. Debug::$inhibit = false;


Poster une réponse Retrouver la discussion sur le forum

Avatar de gene69 gene69
Membre Expert
le 18/08/2011
ligne 600 vous lisez "SourceCode::$param" c'est une classe publiée ici.

il y a une démo ici.


Developpez.com décline toute responsabilité quant à l'utilisation des différents éléments téléchargés.

Connexion

Identifiant
Mot de passe
S'inscrireMot de passe oublié ?
 
 
Developpez.com

Nous contacter

Participez

Informations légales

 
Services

Forum PHP

Blogs

Hébergement

 
Partenaires

Hébergement Web