[PHP5] PHP DEBUGGER ET HELPER

<?php
/**
* CLASS odebugger
*
* @author : johan <barbier_johan@hotmail.com>
*/
class odebugger {

	/**
	* private (string) sAssertion
	* Check if error comes from an essertion or not, if yes, will contain the filename of the evaluated script
	*/
	private $sAssertion = null;
	/**
	* private (string) sLang
	* localization string
	*/
	private $sLang = 'EN';

	/**
	* private (int) iNbLines
	* Number of lines displayed before and after the line of the error
	*/
	private $iNbLines = 2;

	/**
	* private (array) aOptions
	* Options array
	*/
	private $aOptions = array (
		'REALTIME' => true,
		'LOG_FILE' => true,
		'ERROR' => true,
		'EXCEPTION' => true,
		'LOGUNIQUE' => true
		);

	/**
	* private (string) sTemplateHTML
	* HTML template file for the realtime log
	*/
	private $sTemplateHTML = 'default';
	/**
	* private (string) sTemplateCSS
	* CSS template file for the realtime log
	*/
	private $sTemplateCSS = 'default';
	/**
	* private (string) sTemplateHTMLLOG
	* HTML template file for the whole log file
	*/
	private $sTemplateHTMLLOG = 'default_log';
	/**
	* private (string) sTemplateCSSLOG
	* CSS template file for the whole log file
	*/
	private $sTemplateCSSLOG = 'default_log';
	/**
	* private (string) sXmlPath
	* XML locales folder
	*/
	private $sXmlPath = 'xml';
	/**
	* private (string) sLogPath
	* LOGS folder
	*/
	private $sLogPath = 'logs';
	/**
	* private (string) sTplPath
	* Templates folder
	*/
	private $sTplPath = 'templates';
	/**
	* private (string) sCssPath
	* CSS folder
	*/
	private $sCssPath = 'css';
	/**
	* private (string) sCurDir
	* Current directory of the script
	*/
	private $sCurDir = '';

	/**
	* private (string) sCurId
	* Current file unique id
	*/
	private $sCurId = '';

	/**
	* private (object) oXMLDOC
	* XML LOG Object (DOMDocument object)
	*/
	private $oXMLDOC = null;
	/**
	* private (object) oXMLROOT
	* XML LOG root Object (DOMDocument object)
	*/
	private $oXMLROOT = null;
	/**
	* private (object) oCurrentNode
	* Current node Object (DOMDocument object)
	*/
	private $oCurrentNode = null;

	/**
	* private (array) aCanBeSet
	* class properties that can be set via odebugger::__set()
	*/
	private $aCanBeSet = array (
		'LINES' => 'iNbLines',
		'REALTIME' => "aOptions['REALTIME']",
		'LOGFILE' => "aOptions['LOG_FILE']",
		'HTML' => 'sTemplateHTML',
		'CSS' => 'sTemplateCSS',
		'HTMLLOG' => 'sTemplateHTMLLOG',
		'CSSLOG' => 'sTemplateCSSLOG',
		'ERROR' => "aOptions['ERROR']",
		'EXCEPTION' => "aOptions['EXCEPTION']",
		'DISABLE' => "aEnabled",
		'ENABLE' => "aEnabled",
		'LOGUNIQUE' => "aOptions['LOGUNIQUE']",
		);

	/**
	* private (object) oXMLTYPES
	* XML DOMDocument object with the list of error types and their translation
	*/
	private $oXMLTYPES = null;

	/**
	* private (object) oXMLERRORS
	* XML DOMDocument object with the list of errors and their translation
	*/
	private $oXMLERRORS = null;

	/**
	* private (array) aIndex
	* replacement array for the templates
	*/
	private $aIndex = array (
		0 => array (
			'{DATE_TITRE}',
			'{DATE_VALUE}'
			),
		1 => array (
			'{TYPE_TITRE}',
			'{TYPE_VALUE}'
			),
		2 => array (
			'{MSG_TITRE}',
			'{MSG_VALUE}'
			),
		3 => array (
			'{FILE_TITRE}',
			'{FILE_VALUE}'
			),
		4 => array (
			'{LINE_TITRE}',
			'{LINE_VALUE}'
			),
		5 => array (
			'{MEM_TITRE}',
			'{MEM_VALUE}'
			),
		6 => array (
			'{TRANS_TITRE}',
			'{TRANS_VALUE}'
			),
		7 => array (
			'{SUGG_TITRE}',
			'{SUGG_VALUE}'
			),
		8 => array (
			'{CONTEXT_TITRE}',
			'{CONTEXT_VALUE}'
			),
		9 => array (
			'{SOURCE_TITRE}',
			'{SOURCE_VALUE}'
			),
		100 => '{TOTAL_STATS}',
		101 => '{PHP_VERSION}'
		);

	/**
	* private (array) aEnabled
	* array of enabled/disabled Error Levels.
	*/
	private $aEnabled = array (
		E_ERROR => true,
		E_WARNING => true,
		E_PARSE => true,
		E_NOTICE => true,
		E_CORE_ERROR => true,
		E_CORE_WARNING => true,
		E_COMPILE_ERROR => true,
		E_COMPILE_WARNING => true,
		E_USER_ERROR => true,
		E_USER_WARNING => true,
		E_USER_NOTICE => true,
		E_STRICT => true,
		E_ALL => true
		);

	private $aReplace = array (
		'&nbsp;' => '&#160',
		'>' => '&gt;',
		'<' => '&lt;',
		'&' => '&amp;'
		);

	/**
	* public function __construct ()
	* contsructor
	* sets the error_reporting to 0
	* gets the localization dir
	* import all the xml files
	* set the error handler
	* @Param (string) sLang : the localization used
	*/
	public function __construct ($sLang = 'EN', $aOptions = array ('XMLPATH' => null, 'LOGPATH' => null, 'TEMPLATEPATH' => null, 'CSSPATH' => null)) {
		@error_reporting (0);
		if (function_exists ('date_default_timezone_get')) {
			$TZ = date_default_timezone_get ();
			date_default_timezone_set ($TZ);
		}
		if (isset ($aOptions['XMLPATH']) && !is_null ($aOptions['XMLPATH']) && file_exists ($aOptions['XMLPATH'])) {
			$this -> sXmlPath = $aOptions['XMLPATH'];
		}
		if (isset ($aOptions['LOGPATH']) && !is_null ($aOptions['LOGPATH']) && file_exists ($aOptions['LOGPATH'])) {
			$this -> sLogPath = $aOptions['LOGPATH'];
		}
		if (isset ($aOptions['TEMPLATEPATH']) && !is_null ($aOptions['TEMPLATEPATH']) && file_exists ($aOptions['TEMPLATEPATH'])) {
			$this -> sTplPath = $aOptions['TEMPLATEPATH'];
		}
		if (isset ($aOptions['CSSPATH']) && !is_null ($aOptions['CSSPATH']) && file_exists ($aOptions['CSSPATH'])) {
			$this -> sCssPath = $aOptions['CSSPATH'];
		}
		$aLnDir = scandir ($this -> sXmlPath);
		if (in_array ($sLang, $aLnDir)) {
			$this -> sLang = $sLang;
		}

		set_error_handler (array ($this, 'myErrorHandler'));
		set_exception_handler (array ($this, 'myExceptionHandler'));
	}

	private function createLog () {
		if (false === $this -> aOptions['LOGUNIQUE']) {
			$this -> sCurId = date ('Ymd');
		} else {
			$this -> sCurId = date ('Ymd').'_'.uniqid ();
		}
		$sTemp = dirname (__FILE__);
		$aTemp = preg_split('#/|\\\\#', $sTemp);
		array_pop ($aTemp);
		$this -> sCurDir = implode ('/', $aTemp).'/';
		$this -> oXMLERRORS = new DOMDocument;
		$this -> oXMLERRORS -> load ($this -> sXmlPath.'/'.$this -> sLang.'/errors.xml');
		$this -> oXMLTYPES = new DOMDocument;
		$this -> oXMLTYPES -> load ($this -> sXmlPath.'/'.$this -> sLang.'/types.xml');
		if (!is_dir ($this -> sLogPath)) {
			@mkdir ($this -> sLogPath, 0744);
		}
		if (file_exists ($this -> sLogPath.'/'.$this -> sCurId.'_error_log.xml')) {
			$this -> oXMLDOC = DOMDocument::load ($this -> sLogPath.'/'.$this -> sCurId.'_error_log.xml');
			$this -> oXMLROOT = $this -> oXMLDOC -> documentElement;
		} else {
			$this -> oXMLDOC = new DOMDocument ('1.0', 'utf-8');
			$root = $this -> oXMLDOC -> createElement ('ERRORLOG');
			$this -> oXMLROOT = $this -> oXMLDOC -> appendChild ($root);
		}
	}
	/**
	* public function checkCode ()
	* use the assert () function to get the errors in a given string, or a given file
	* @Param (string) sString : the string with the PHP code to evaluate, or the file to evaluate. Usually, it will come from a file via file_get_contents () for example
	* @Return : false if given parameter is not a string.
	*/
	public function checkCode ($sCode) {
		if (file_exists ($sCode)) {
			$sString = file_get_contents ($sCode);
			$this -> sAssertion = $sCode;
		} elseif (!is_string ($sCode)) {
			return false;
		} else {
			$sString = $sCode;
		}
		$sString = str_replace (array ('<?php', '<?', '?>'), '', $sString);
		assert_options(ASSERT_ACTIVE, 1);
		assert_options(ASSERT_WARNING, 0);
		assert_options(ASSERT_QUIET_EVAL, 1);
		//assert_options (ASSERT_CALLBACK, array ($this, 'myAssertHandler')); Waiting a bit to improve this part
		assert ($sString);
		assert_options(ASSERT_ACTIVE, 0);
		return true;
	}

	/**
	* public function myAssertHandler ()
	* activate the assertion. Right now, does nothing...and is not used.
	* @Param (string) file : the file from which comes the code
	* @Param (int) line : the error line
	* @Param (string) code : the error code
	* @Return : true
	*/
	/*
	public function myAssertHandler ($file, $line, $code){
		return true;
	}
	*/
	/**
	* private function checkErrorMessage ()
	* try to find the correct trsnalation and suggestion from a given error message
	* @Param (string) sMsg : the PHP error message
	* @Return (array) aTempArr : array with the translation and the suggestion found
	*/
	private function checkErrorMessage ($sMsg) {
		//$iLength = strlen ($sMsg);
		$xpath = new DOMXPath($this -> oXMLERRORS);
		$sQueryLabel = '//error/label';
		$oLabelLists = $xpath -> query ($sQueryLabel);
		$aMsg = explode (' ', $sMsg);
		foreach ($oLabelLists as $oLabel) {
			$aLabel = explode (' ', $oLabel -> nodeValue);
			$aDiff = array_diff ($aLabel, $aMsg);
			if (empty ($aDiff)) {
				$aTempArr['TRANSLATION'] = $oLabel -> nextSibling -> nextSibling -> nodeValue;
				$aTempArr['SUGGESTION'] = $oLabel -> nextSibling -> nextSibling -> nextSibling -> nextSibling -> nodeValue;
				return $aTempArr;
			}
		}
		return false;
	}

	/**
	* private function checkTypeTrans ()
	* try to find the error type translation
	* @Param (int) cErrno : the PHP constant error type code
	* @Return (string) nodeValue : the translated error type
	*/
	private function checkTypeTrans ($cErrno) {
		$xpath = new DOMXPath($this -> oXMLTYPES);
		$sQueryLevel = '//type/level';
		$oLevelList = $xpath -> query ($sQueryLevel);
		foreach ($oLevelList as $oLevel) {
			if (constant ($oLevel -> nodeValue) === $cErrno) {
				return $oLevel -> nextSibling -> nextSibling -> nodeValue;
			}
		}
		return false;
	}

	/**
	* public function myExceptionHandler ()
	* the exception handler : builds the XML error log
	* @Param (object) e : the Exception object
	*/
	public function myExceptionHandler ($e) {
		if (is_null ($this -> oXMLDOC) || is_null ($this -> oXMLROOT)) {
			$this -> createLog ();
		}
		$sErrStr = $e -> getMessage ();
		$iErrLine = $e -> getLine ();
		$sType = 'Exception '.$e -> getCode ();
		if (is_null ($this -> sAssertion)) {
			$sErrFile = $e -> getFile ();
		} else {
			$sErrFile = $this -> sAssertion;
			$this -> sAssertion = null;
		}
		$aVars['TRACEASSTRING'] = $e -> getTraceAsString ();
		$aTempArr = array ('TRANSLATION' => '', 'SUGGESTION' => '');

		$this -> buildLog ($sType, $sErrStr, $sErrFile, $iErrLine, $aTempArr, $aVars);
	}

	/**
	* public function myErrorHandler ()
	* the error handler : builds the XML error log
	* @Param (int) cErrno : the PHP constant error type code
	* @Param (string) sErrStr : the PHP error message
	* @Param (string) sErrFile : the file in which the error has been detected
	* @Param (int) iErrLine : the line of the error
	* @Param (array) mVars : the context
	* @Return (boolean)
	*/
	public function myErrorHandler ($cErrno, $sErrStr, $sErrFile, $iErrLine, $mVars) {
		if (false === $this -> aEnabled[$cErrno]) {
			return true;
		}
		if (is_null ($this -> oXMLDOC) || is_null ($this -> oXMLROOT)) {
			$this -> createLog ();
		}
		$aTempArr = $this -> checkErrorMessage ($sErrStr);
		$sType = $this -> checkTypeTrans ($cErrno);
		$aVars = array ();
		foreach ($mVars as $sK => $sV) {
			if ((!is_object ($sV) || $sV != $this) && $sK !== 'GLOBALS' && !empty ($sV)) {
				$aVars[$sK] = $sV;
			}
		}
		if (!is_null ($this -> sAssertion)) {
			$sErrFile = $this -> sAssertion;
			$this -> sAssertion = null;
		}
		$this -> buildLog ($sType, $sErrStr, $sErrFile, $iErrLine, $aTempArr, $aVars);
		return true;
	}

	/**
	* private function buildLog ()
	* the error handler : builds the XML error log
	* @Param (string) sType : The type of error/exception
	* @Param (string) sErrStr : the PHP error message
	* @Param (string) sErrFile : the file in which the error has been detected
	* @Param (int) iErrLine : the line of the error
	* @Param (string) sVars : the context
	*/
	private function buildLog ($sType, $sErrStr, $sErrFile, $iErrLine, $aTempArr, $aVars) {
		$iErrLine --;
		if ($iErrLine < 0) {
			$iErrLine = 0;
		}
		$oNewLog = $this -> oXMLDOC -> createElement ('ERROR');
		$dump = $this -> oXMLROOT -> getElementsByTagName('ERROR');
		$iNewId = $dump -> length + 1;
		$oNewLog = $this -> oXMLROOT -> appendChild ($oNewLog);
		$oNewLog -> setAttribute ('xml:id', '_'.$iNewId);
		$aElem[] = $this -> oXMLDOC -> createElement ('DATE', date ('d-m-Y H:i:s'));
		$aElem[] = $this -> oXMLDOC -> createElement ('TYPE', $sType);
		$sErrStr = utf8_encode ($sErrStr);
		$aElem[] = $this -> oXMLDOC -> createElement ('PHP_MESSAGE', $sErrStr);
		$aElem[] = $this -> oXMLDOC -> createElement ('FILE', $sErrFile);
		$aElem[] = $this -> oXMLDOC -> createElement ('LINE', $iErrLine);
		if (function_exists ('memory_get_usage')) {
			$iMemory = @memory_get_usage ();
		} else {
			$iMemory = 'n/a';
		}
		$aElem[] = $this -> oXMLDOC -> createElement ('MEMORY', $iMemory);
		$aElem[] = $this -> oXMLDOC -> createElement ('TRANSLATION', $aTempArr['TRANSLATION']);
		$aElem[] = $this -> oXMLDOC -> createElement ('SUGGESTION', $aTempArr['SUGGESTION']);

		$sContext = utf8_encode (print_r ($aVars, true));
		$sContext = str_replace (array_keys ($this -> aReplace), $this -> aReplace, $sContext);
		$aElem[] = $this -> oXMLDOC -> createElement ('CONTEXT', '<pre>'.$sContext.'</pre>');
		$oSource = $this -> oXMLDOC -> createElement ('SOURCE');
		$aSourceElem = array ();
		foreach ($this -> getLine ($sErrFile, $iErrLine) as $iLine => $sLine) {
			$sLine = utf8_encode ($sLine);
			$sLine = str_replace (array_keys ($this -> aReplace), $this -> aReplace, $sLine);
			if ($iLine === ($iErrLine)) {
				$aSourceElem[] = $this -> oXMLDOC -> createElement ('SOURCE_LINE_ERROR', ' /** ERROR AROUND THIS LINE => */ '.$sLine);
			} else {
				$aSourceElem[] = $this -> oXMLDOC -> createElement ('SOURCE_LINE', $sLine);
			}
		}
		foreach ($aSourceElem as $oSourceElem) {
			$oSource -> appendChild ($oSourceElem);
		}
		foreach ($aElem as $oElem) {
			$oNewLog -> appendChild ($oElem);
		}
		$oNewLog -> appendChild ($oSource);
		$this -> oCurrentNode = $oNewLog;
		if (true === $this -> aOptions['REALTIME']) {
			$this -> printMe ();
		}
	}
	/**
	* private function getLine ()
	* method to get the lines around the detected error
	* @Param (string) sErrFile : the file in which the error has been detected
	* @Param (int) iErrLine : the line of the error
	* @Return (array) aSource : array with each line
	*/
	private function getLine ($sErrFile, $iErrLine) {
		$aSource = array ();
		if (file_exists ($sErrFile)) {
			$aLines = file ($sErrFile);
			for ($i = $iErrLine - $this -> iNbLines; $i<= $iErrLine + $this -> iNbLines; $i ++) {
				if (isset ($aLines[$i])) {
					$aSource[$i] = $aLines[$i];
				}
			}
		}
		return $aSource;
	}

	/**
	* public function loadXML ()
	* loads an external error log
	* @Param (string) sFile : the error log file to be loaded
	* @Return (boolean)
	*/
	public function loadXML ($sFile) {
		if (!file_exists ($this -> sLogPath.'/'.$sFile)) {
			return false;
		}
		if (is_null ($this -> oXMLDOC)) {
			$this -> oXMLDOC = new DOMDocument ('1.0', 'utf-8');
		}
		$this -> oXMLDOC -> load ($this -> sLogPath.'/'.$sFile);
		return true;
	}

	/**
	* public function showAll ()
	* show the whole current xml log
	*/
	public function showAll () {
		$xpath = new DOMXPath($this -> oXMLDOC);
		$sQuery = '//ERROR';
		$oNodeLists = $xpath -> query ($sQuery);
		foreach ($oNodeLists as $oNodeList) {
			$this -> oCurrentNode = $oNodeList;
			$this -> printMe ();
		}
	}

	/**
	* public function showLog ()
	* show the whole current log in a table, with stats (best used after odebugger::loadXML())
	* @Return (string) sHtml : the generated HTML
	*/
	public function showLog () {
		$sBaseHtml = file_get_contents ($this -> sTplPath.'/'.$this -> sTemplateHTMLLOG.'.dat');
		$iStartPos = strpos ($sBaseHtml, '<!-- LINES HERE -->');
		$sHtml = substr ($sBaseHtml, 0, $iStartPos);
		$iEndPos = strpos ($sBaseHtml, '<!-- STATS -->');
		$iLength = strlen ($sBaseHtml);
		$sTempHtml = substr ($sBaseHtml, $iStartPos,   - ($iLength - $iEndPos));
		$sTempHtmlTotal = '';
		$xpath = new DOMXPath($this -> oXMLDOC);
		$sQuery = '//ERROR';
		$oNodeLists = $xpath -> query ($sQuery);
		foreach ($oNodeLists as $oNodeList) {
			$this -> oCurrentNode = $oNodeList;
			$sTempHtmlTotal .= $this -> printMeLog ($sTempHtml);
		}
		$sHtml .= $sTempHtmlTotal;
		$sQuery = '//ERROR/TYPE';
		$oNodeLists = $xpath -> query ($sQuery);
		foreach ($oNodeLists as $oNodeList) {
			$aTypes[] = $oNodeList  -> nodeValue;
		}
		$sHtml .= substr ($sBaseHtml, $iEndPos, ($iLength - 1));
		$aCountType = array_count_values ($aTypes);
		$sCountType = '';
		foreach ($aCountType as $kType => $vType) {
			$sCountType .= $kType.' : '.$vType.'<br />';
		}
		$sVersion = @phpversion ();
		$sHtml = str_replace ($this -> aIndex[100], $sCountType, $sHtml);
		$sHtml = str_replace ($this -> aIndex[101], $sVersion , $sHtml);
		return $sHtml;
	}

	/**
	* private function printMe ()
	* display a caught error
	* @Return (string) sHtml : the generated HTML
	*/
	private function printMe () {
		$sHtml = file_get_contents ($this -> sTplPath.'/'.$this -> sTemplateHTML.'.dat');
		$nodeList = $this -> oCurrentNode -> childNodes;
		$iId = $this -> oCurrentNode -> getAttribute ('id');
		for ($i = 0; $i < $nodeList -> length; $i++) {
			$sName = $nodeList -> item($i) -> nodeName;
			if ($sName === 'SOURCE') {
				$sourceNodeList = $nodeList -> item($i) -> childNodes;
				$sValeur = '';
				for ($j = 0; $j < $sourceNodeList -> length; $j++) {
					$sValeur .= str_replace (array ('<?php', '?>', '<?'), '', $sourceNodeList -> item($j) -> nodeValue);
				}
				$sValeur = str_replace ($this -> aReplace, array_keys ($this -> aReplace), $sValeur);
				$sValeur = highlight_string ('<?php '."\r\n".$sValeur.'?>', true);
			} else {
				$sValeur = $nodeList -> item($i) -> nodeValue;
			}
			$sId = uniqid().'_'.$iId;
			$aReplacement = array ($sName, $sValeur);
			$sHtml = str_replace ($this -> aIndex[$i], $aReplacement, $sHtml);
			$sHtml = str_replace ('{ID}', $sId, $sHtml);
		}
		echo $sHtml;
	}

	/**
	* private function printMeLog ()
	* display a caught error, used by odebugger::showLog()
	* @Return (string) sHtml : the generated HTML
	*/
	private function printMeLog ($sHtml) {
		$nodeList = $this -> oCurrentNode -> childNodes;
		$iId = $this -> oCurrentNode -> getAttribute ('id');
		for ($i = 0; $i < $nodeList -> length; $i++) {
			if ($nodeList -> item($i) -> nodeName === 'SOURCE') {
				$sourceNodeList = $nodeList -> item($i) -> childNodes;
				$sValeur = '';
				for ($j = 0; $j < $sourceNodeList -> length; $j++) {
					$sValeur .= str_replace (array ('<?php', '?>', '<?'), '', $sourceNodeList -> item($j) -> nodeValue);
				}
				$sValeur = str_replace ($this -> aReplace, array_keys ($this -> aReplace), $sValeur);
				$sValeur = highlight_string ('<?php '."\r\n".$sValeur.'?>', true);
			} else {
				$sValeur = $nodeList -> item($i) -> nodeValue;
			}
			$sHtml = str_replace ($this -> aIndex[$i][1], $sValeur, $sHtml);
			$sId = uniqid().'_'.$iId;
			$sHtml = str_replace ('{ID}', $sId, $sHtml);
		}
		return $sHtml;
	}

	/**
	* public function saveToFile ()
	* save the current log to a given file
	* @Param (string) sFile : name of the log file
	* @Return (boolean)
	*/
	public function saveToFile ($sFile = null) {
		if (is_null ($this -> oXMLDOC)) {
			return true;
		}
		if ($sFile === null) {
			$sFile = $this -> sCurId.'_error_log.xml';
		}
		/*
		if (file_exists ($this -> sCurDir.$this -> sLogPath.'/'.$sFile)) {
			$this -> oXMLDOC -> save ($this -> sCurDir.$this -> sLogPath.'/'.$sFile);
			chmod ($this -> sCurDir.$this -> sLogPath.'/'.$sFile, 0775);
		} else {
			$this -> oXMLDOC -> save ($this -> sLogPath.'/'.$sFile);
			chmod ($this -> sLogPath.'/'.$sFile, 0775);
		}
		*/
		if ($this -> sLogPath === 'logs') {
			$this -> oXMLDOC -> save ($this -> sCurDir.$this -> sLogPath.'/'.$sFile);
			chmod ($this -> sCurDir.$this -> sLogPath.'/'.$sFile, 0775);
		} else {
			$this -> oXMLDOC -> save ($this -> sLogPath.'/'.$sFile);
			chmod ($this -> sLogPath.'/'.$sFile, 0775);
		}
		return true;
	}

	/**
	* public function __destruct ()
	* destructor
	* will save the log to a file if the LOG_FILE option is set to true
	*/
	public function __destruct () {
		if (true === $this -> aOptions['LOG_FILE']) {
			$this -> saveToFile ();
		}
	}

	/**
	* public function __set ()
	* allows some properties to be set
	* @Param (string) sProp : name of the property
	* @Param (mixed) mVal : the value to be given to the property
	* @Return (boolean) false if failed, true if succeeded
	*/
	public function __set ($sProp, $mVal) {
		if (false === array_key_exists ($sProp, $this -> aCanBeSet)) {
			return false;
		}
		switch ($sProp) {
			case 'LINES' :
				if (!is_int ($mVal)) {
					return false;
				}
				$this -> iNbLines = $mVal;
				break;
			case 'HTML' :
				if (!file_exists ($this -> sTplPath.'/'.$mVal.'.dat')) {
					return false;
				}
				$this -> sTemplateHTML = $mVal;
				break;
			case 'HTMLLOG' :
				if (!file_exists ($this -> sTplPath.'/'.$mVal.'.dat')) {
					return false;
				}
				$this -> sTemplateHTMLLOG = $mVal;
				break;
			case 'CSS' :
				if (!file_exists ($this -> sCssPath.'/'.$mVal.'.dat')) {
					return false;
				}
				$this -> sTemplateCSS = $mVal;
				readfile ($this -> sCssPath.'/'.$mVal.'.dat');
				break;
			case 'CSSLOG' :
				if (!file_exists ($this -> sCssPath.'/'.$mVal.'.dat')) {
					return false;
				}
				$this -> sTemplateCSSLOG = $mVal;
				readfile ($this -> sCssPath.'/'.$mVal.'.dat');
				break;
			case 'REALTIME' :
				if (!is_bool ($mVal)) {
					return false;
				}
				$this -> aOptions['REALTIME'] = $mVal;
				break;
			case 'LOGFILE' :
				if (!is_bool ($mVal)) {
					return false;
				}
				$this -> aOptions['LOG_FILE'] = $mVal;
				break;
			case 'LOGUNIQUE' :
				if (!is_bool ($mVal)) {
					return false;
				}
				$this -> aOptions['LOGUNIQUE'] = $mVal;
				break;
			case 'ERROR' :
				if (!is_bool ($mVal)) {
					return false;
				}
				$this -> aOptions['ERROR'] = $mVal;
				if (true === $mVal) {
					set_error_handler (array ($this, 'myErrorHandler'));
				} else {
					restore_error_handler ();
				}
				break;
			case 'EXCEPTION' :
				if (!is_bool ($mVal)) {
					return false;
				}
				$this -> aOptions['EXCEPTION'] = $mVal;
				if (true === $mVal) {
					set_exception_handler (array ($this, 'myExceptionHandler'));
				} else {
					restore_exception_handler ();
				}
				break;
			case 'ENABLE' :
					if (!array_key_exists ($mVal, $this -> aEnabled)) {
						return false;
					}
					$this -> aEnabled[$mVal] = true;
				break;
			case 'DISABLE' :
					if (!array_key_exists ($mVal, $this -> aEnabled)) {
						return false;
					}
					$this -> aEnabled[$mVal] = false;
				break;
			default:
				return false;
				break;
		}
		return true;
	}

	/**
	* public function __get ()
	* allows some properties to be get
	* @Param (string) sProp : name of the property
	* @Return (boolean) false if failed, value of the property if succeeded
	*/
	public function __get ($sProp) {
		if (false === array_key_exists ($sProp, $this -> aCanBeSet)) {
			return false;
		}
		$sRealProp = $this -> aCanBeSet[$sProp];
		return $this -> $sRealProp;
	}
}
?>