955 lines
28 KiB
PHP
955 lines
28 KiB
PHP
<?php
|
|
|
|
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
|
|
|
|
/**
|
|
* PHP_Debug : A simple and fast way to debug your PHP code
|
|
*
|
|
* The basic purpose of PHP_Debug is to provide assistance in debugging PHP
|
|
* code, by 'debug' i don't mean 'step by step debug' but program trace,
|
|
* variables display, process time, included files, queries executed, watch
|
|
* variables... These informations are gathered through the script execution and
|
|
* therefore are displayed at the end of the script (in a nice floating div or a
|
|
* html table) so that it can be read and used at any moment. (especially
|
|
* usefull during the development phase of a project or in production with a
|
|
* secure key/ip)
|
|
*
|
|
* PHP version 5 only
|
|
*
|
|
* Copyright (c) 2007 - Vernet Loïc
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*
|
|
* @category PHP
|
|
* @package PHP_Debug
|
|
* @author Vernet Loïc <qrf_coil[at]yahoo.fr>
|
|
* @copyright 1997-2007 The PHP Group
|
|
* @license http://www.opensource.org/licenses/mit-license.php MIT
|
|
* @link http://pear.php.net/package/PHP_Debug
|
|
* @link http://phpdebug.sourceforge.net
|
|
* @link http://www.php-debug.com
|
|
* @see Text_Highlighter
|
|
* @see Var_Dump, SQL_Parser
|
|
* @since 1.0.0RC1
|
|
* @version CVS: $Id: Debug.php,v 1.6 2009/01/12 21:13:00 c0il Exp $
|
|
*/
|
|
|
|
/**
|
|
* Factory class for renderer of Debug class
|
|
*
|
|
* @see Debug/Renderer/*.php
|
|
*/
|
|
require_once 'PHP/DebugLine.php';
|
|
require_once 'PHP/Debug/Renderer.php';
|
|
|
|
/**
|
|
* External constants
|
|
*
|
|
* @filesource
|
|
* @package PHP_Debug
|
|
*/
|
|
if (!defined('CR')) {
|
|
define('CR', "\n");
|
|
}
|
|
|
|
class PHP_Debug
|
|
{
|
|
|
|
/**
|
|
* Possible version of class Debug
|
|
*/
|
|
const VERSION_STANDALONE = 0;
|
|
const VERSION_PEAR = 1;
|
|
const VERSION_DEFAULT = self::VERSION_STANDALONE;
|
|
const VERSION = self::VERSION_STANDALONE;
|
|
const RELEASE = 'V2.1.5';
|
|
const PEAR_RELEASE = 'V1.0.3';
|
|
|
|
/**
|
|
* These are constant for dump() and DumpObj() functions.
|
|
*
|
|
* - DUMP_DISP : Tell the function to display the debug info.
|
|
* - DUMP_STR : Tell the fonction to return the debug info as a string
|
|
* - DUMP_VARNAME : Default name of Array - DBG_ARR_OBJNAME : Default name
|
|
* of Object
|
|
*/
|
|
const DUMP_DISP = 1;
|
|
const DUMP_STR = 2;
|
|
const DUMP_VARNAME = 'Variable';
|
|
|
|
/**
|
|
* These are constant for addDebug functions, they set the behaviour where
|
|
* the function should add the debug information in first or in last
|
|
* position
|
|
*/
|
|
const POSITIONLAST = 0;
|
|
const POSITIONFIRST = 1;
|
|
|
|
/**
|
|
* These are constants to define Super array environment variables
|
|
*/
|
|
const GLOBAL_GET = 0;
|
|
const GLOBAL_POST = 1;
|
|
const GLOBAL_FILES = 2;
|
|
const GLOBAL_COOKIE = 3;
|
|
const GLOBAL_REQUEST = 4;
|
|
const GLOBAL_SESSION = 5;
|
|
const GLOBAL_GLOBALS = 6;
|
|
|
|
/**
|
|
* Default configuration options
|
|
*
|
|
* @since V2.0.0 - 16 apr 2006
|
|
* @see setOptions()
|
|
* @var array
|
|
*/
|
|
protected $defaultOptions = array(
|
|
'render_mode' => 'Div', // Renderer mode
|
|
'render_type' => 'HTML', // Renderer type
|
|
'restrict_access' => false, // Restrict or not the access
|
|
'allowed_ip' => array('127.0.0.1'), // Authorized IP to view the debug when restrict_access is true
|
|
'allow_url_access' => false, // Allow to access the debug with a special parameter in the url
|
|
'url_key' => 'debug', // Key for url instant access
|
|
'url_pass' => 'true', // Password for url instant access
|
|
'enable_watch' => false, // Enable the watch function
|
|
'replace_errorhandler' => true, // Replace or no the PHP errorhandler
|
|
'lang' => 'EN', // Language
|
|
);
|
|
|
|
/**
|
|
* Default static options for static functions
|
|
*
|
|
* @since V2.0.0 - 16 apr 2006
|
|
* @see dump()
|
|
* @var array
|
|
*/
|
|
protected static $staticOptions = array(
|
|
'dump_method' => 'print_r', // print_r or var_dump
|
|
'pear_var_dump_method' => 'Var_Dump::display' // Var_Dump display funtion (not used for now)
|
|
);
|
|
|
|
/**
|
|
* Functions from this class that must be excluded in order to have the
|
|
* correct backtrace information
|
|
*
|
|
* @see PHP_DebugLine::setTraceback()
|
|
* @since V2.0.0 - 13 apr 2006
|
|
* @var array
|
|
*/
|
|
public static $excludedBackTraceFunctions = array(
|
|
'add',
|
|
'dump',
|
|
'error',
|
|
'query',
|
|
'addDebug',
|
|
'setAction',
|
|
'addDebugFirst',
|
|
'watchesCallback',
|
|
'errorHandlerCallback'
|
|
);
|
|
|
|
/**
|
|
* Correspondance between super array constant and variable name
|
|
* Used by renderers
|
|
*
|
|
* @since V2.0.0 - 18 apr 2006
|
|
* @var array
|
|
*/
|
|
public static $globalEnvConstantsCorresp = array(
|
|
self::GLOBAL_GET => '_GET',
|
|
self::GLOBAL_POST => '_POST',
|
|
self::GLOBAL_FILES => '_FILES',
|
|
self::GLOBAL_COOKIE => '_COOKIE',
|
|
self::GLOBAL_REQUEST=> '_REQUEST',
|
|
self::GLOBAL_SESSION=> '_SESSION',
|
|
self::GLOBAL_GLOBALS=> 'GLOBALS'
|
|
);
|
|
|
|
/**
|
|
* Default configuration options
|
|
*
|
|
* @since V2.0.0 - 13 apr 2006
|
|
* @see setOptions()
|
|
* @var array
|
|
*/
|
|
protected $options = array();
|
|
|
|
/**
|
|
* This is the array where the debug lines are collected.
|
|
*
|
|
* @since V2.0.0 - 11 apr 2006
|
|
* @see DebugLine
|
|
* @var array
|
|
*/
|
|
protected $debugLineBuffer = array();
|
|
|
|
/**
|
|
* This is the array containing all the required/included files of the
|
|
* script
|
|
*
|
|
* @since V2.0.0 - 17 apr 2006
|
|
* @see render(), PHP_DebugLine::TYPE_TEMPLATES
|
|
* @var array
|
|
*/
|
|
protected $requiredFiles = array();
|
|
|
|
/**
|
|
* This is the array containing all the watched variables
|
|
*
|
|
* @since V2.0.0 - 16 apr 2006
|
|
* @see watch()
|
|
* @var array
|
|
*/
|
|
protected $watches = array();
|
|
|
|
/**
|
|
* Execution start time
|
|
*
|
|
* @since V2.0.0 - 11 apr 2006
|
|
* @see __construct()
|
|
* @var float
|
|
*/
|
|
protected $startTime;
|
|
|
|
/**
|
|
* Exection end time
|
|
*
|
|
* @since V2.0.0 - 11 apr 2006
|
|
* @see render()
|
|
* @var float
|
|
*/
|
|
protected $endTime;
|
|
|
|
/**
|
|
* Number of queries executed during script
|
|
*
|
|
* @since V2.0.0 - 19 apr 2006
|
|
* @var integer
|
|
*/
|
|
protected $queryCount = 0;
|
|
|
|
/**
|
|
* PHP_Debug class constructor
|
|
*
|
|
* Here we set :
|
|
* - the execution start time
|
|
* - the options
|
|
* - the error and watch call back functions
|
|
*
|
|
* @param array $options Array containing options to affect to Debug
|
|
* object and his childs
|
|
*
|
|
* @since V2.0.0 - 11 apr 2006
|
|
*/
|
|
function __construct($options = array())
|
|
{
|
|
$this->startTime = PHP_Debug::getMicroTimeNow();
|
|
$this->options = array_merge($this->defaultOptions, $options);
|
|
$this->setWatchCallback();
|
|
$this->setErrorHandler();
|
|
}
|
|
|
|
/**
|
|
* Add a debug information
|
|
*
|
|
* @param string $info The main debug information
|
|
* (may be empty for some debug line types)
|
|
* @param integer $type Type of the DebugLine
|
|
*
|
|
* @see Debug constants
|
|
* @since V1.0.0 - 07 Apr 2006
|
|
*/
|
|
public function addDebug($info, $type = PHP_DebugLine::TYPE_STD,
|
|
$position = self::POSITIONLAST)
|
|
{
|
|
// Add info
|
|
$debugLine = new PHP_DebugLine($info, $type);
|
|
if ($position == self::POSITIONLAST) {
|
|
$this->debugLineBuffer[] = $debugLine;
|
|
} else {
|
|
array_unshift($this->debugLineBuffer, $debugLine);
|
|
}
|
|
|
|
// Additional process for some types
|
|
switch ($type) {
|
|
case PHP_DebugLine::TYPE_QUERY:
|
|
$this->queryCount++;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// Return debugline
|
|
return $debugLine;
|
|
}
|
|
|
|
/**
|
|
* Add a debug info before all the existing other debug lines
|
|
* It is an alias for addDebug($info, self::POSITIONLAST)
|
|
*
|
|
* @see addDebug
|
|
* @since V1.0.0 - 13 Apr 2006
|
|
*/
|
|
public function addDebugFirst($info, $type = PHP_DebugLine::TYPE_STD)
|
|
{
|
|
return $this->addDebug($info, $type, self::POSITIONFIRST);
|
|
}
|
|
|
|
/**
|
|
* This is an alias for the addDebug function
|
|
*
|
|
* @see addDebug()
|
|
* @since V2.0.0 - 20 apr 2006
|
|
*/
|
|
public function add($info, $type = PHP_DebugLine::TYPE_STD)
|
|
{
|
|
return $this->addDebug($info, $type);
|
|
}
|
|
|
|
/**
|
|
* This is an alias for the addDebug function when wanting to add a query
|
|
* debug information
|
|
*
|
|
* @see addDebug(), PHP_DebugLine::TYPE_QUERY
|
|
* @since V2.0.0 - 21 Apr 2006
|
|
*/
|
|
public function query($qry)
|
|
{
|
|
return $this->addDebug($qry, PHP_DebugLine::TYPE_QUERY);
|
|
}
|
|
|
|
/**
|
|
* This is an alias for the addDebug function when wanting to add a
|
|
* database related debug info
|
|
*
|
|
* @see addDebug(), PHP_DebugLine::TYPE_QUERYREL
|
|
* @since V2.1.0 - 3 apr 2007
|
|
*/
|
|
public function queryRel($info)
|
|
{
|
|
return $this->addDebug($info, PHP_DebugLine::TYPE_QUERYREL);
|
|
}
|
|
|
|
/**
|
|
* This is an alias for the addDebug function when wanting to add an
|
|
* application error
|
|
*
|
|
* @see addDebug(), PHP_DebugLine::TYPE_APPERROR
|
|
* @since V2.0.0 - 21 Apr 2006
|
|
*/
|
|
public function error($info)
|
|
{
|
|
return $this->addDebug($info, PHP_DebugLine::TYPE_APPERROR);
|
|
}
|
|
|
|
/**
|
|
* This is an alias for adding the monitoring of processtime
|
|
*
|
|
* @see addDebug(), PHP_DebugLine::TYPE_PROCESSPERF
|
|
* @since V2.1.0 - 21 Apr 2006
|
|
*/
|
|
public function addProcessPerf()
|
|
{
|
|
return $this->addDebug('', PHP_DebugLine::TYPE_PROCESSPERF);
|
|
}
|
|
|
|
/**
|
|
* This a method to dump the content of any variable and add the result in
|
|
* the debug information
|
|
*
|
|
* @param mixed $var Variable to dump
|
|
* @param string $varname Name of the variable
|
|
*
|
|
* @since V2.0.0 - 25 Apr 2006
|
|
*/
|
|
public function dump($obj, $varName = '')
|
|
{
|
|
$info[] = $varName;
|
|
$info[] = $obj;
|
|
return $this->addDebug($info, PHP_DebugLine::TYPE_DUMP);
|
|
}
|
|
|
|
/**
|
|
* Set the main action of PHP script
|
|
*
|
|
* @param string $action Name of the main action of the file
|
|
*
|
|
* @since V2.0.0 - 25 Apr 2006
|
|
* @see PHP_DebugLine::TYPE_CURRENTFILE
|
|
*/
|
|
public function setAction($action)
|
|
{
|
|
$this->add($action, PHP_DebugLine::TYPE_PAGEACTION);
|
|
}
|
|
|
|
/**
|
|
* Add an application setting
|
|
*
|
|
* @param string $action Name of the main action of the file
|
|
*
|
|
* @since V2.1.0 - 02 Apr 2007
|
|
* @see PHP_DebugLine::TYPE_ENV
|
|
*/
|
|
public function addSetting($value, $name)
|
|
{
|
|
$this->add($name. ': '. $value, PHP_DebugLine::TYPE_ENV);
|
|
}
|
|
|
|
/**
|
|
* Add a group of settings
|
|
*
|
|
* @param string $action Name of the main action of the file
|
|
*
|
|
* @since V2.1.0 - 2 Apr 2007
|
|
* @see PHP_DebugLine::TYPE_ENV
|
|
*/
|
|
public function addSettings($values, $name)
|
|
{
|
|
$this->add($name. ': '.
|
|
PHP_Debug::dumpVar(
|
|
$values,
|
|
$name,
|
|
false,
|
|
PHP_Debug::DUMP_STR
|
|
),
|
|
PHP_DebugLine::TYPE_ENV
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Set the callback fucntion to process the watches, enabled depending of
|
|
* the options flag 'enable_watch'
|
|
*
|
|
* @since V2.0.0 - 16 apr 2006
|
|
* @see options, watches, watchesCallback()
|
|
*/
|
|
protected function setWatchCallback()
|
|
{
|
|
if ($this->options['enable_watch'] == true) {
|
|
if (count($this->watches) === 0) {
|
|
$watchMethod = array($this, 'watchesCallback');
|
|
register_tick_function($watchMethod);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set the callback function to process replace the php error handler,
|
|
* enabled depending of the options flag 'replace_errorhandler'
|
|
*
|
|
* @since V2.0.0 - 16 apr 2006
|
|
* @see options, errorHandlerCallback()
|
|
*/
|
|
protected function setErrorHandler()
|
|
{
|
|
if ($this->options['replace_errorhandler'] == true) {
|
|
|
|
$errorhandler = array(
|
|
$this,
|
|
'errorHandlerCallback'
|
|
);
|
|
set_error_handler($errorhandler);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Callback function for php error handling
|
|
*
|
|
* Warning : the only PHP error codes that are processed by this user
|
|
* handler are : E_WARNING, E_NOTICE, E_USER_ERROR
|
|
* For the other error codes the standart php handler will be used
|
|
*
|
|
* @since V2.0.0 - 17 apr 2006
|
|
* @see options, setErrorHandler()
|
|
*/
|
|
public function errorHandlerCallback()
|
|
{
|
|
$details = func_get_args();
|
|
$popNumber = 3;
|
|
|
|
// We already have line & file with setBackTrace function
|
|
for ($index = 0; $index < $popNumber; $index++) {
|
|
array_pop($details);
|
|
}
|
|
|
|
if ($details[0] != E_STRICT)
|
|
$this->addDebug($details, PHP_DebugLine::TYPE_PHPERROR);
|
|
}
|
|
|
|
/**
|
|
* Add a variable to the watchlist. Watched variables must be in a declare
|
|
* (ticks=n) block so that every n ticks the watched variables are checked
|
|
* for changes. If any changes were made, the new value of the variable is
|
|
* recorded
|
|
*
|
|
* @param string $variableName Variable to watch
|
|
* @since V2.0.0 - 17 apr 2006
|
|
* @see watchesCallback()
|
|
*/
|
|
public function watch($variableName)
|
|
{
|
|
if ($this->options['enable_watch'] == true) {
|
|
if (isset($GLOBALS[$variableName])) {
|
|
$this->watches[$variableName] = $GLOBALS[$variableName];
|
|
} else {
|
|
$this->watches[$variableName] = null;
|
|
}
|
|
} else {
|
|
throw new Exception('The Watch function is disabled please set the option \'enable_watch\' to \'true\' to be able to use this feature, it\'s stable with a Unix server');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Watch callback function, process watches and add changes to the debug
|
|
* information
|
|
*
|
|
* @since V2.0.0 - 17 apr 2006
|
|
* @see watch()
|
|
*/
|
|
public function watchesCallback()
|
|
{
|
|
// Check if there are variables to watch
|
|
if (count($this->watches)) {
|
|
foreach ($this->watches as $variableName => $variableValue) {
|
|
if ($GLOBALS[$variableName] !== $this->watches[$variableName]) {
|
|
|
|
$info = array(
|
|
$variableName,
|
|
$this->watches[$variableName],
|
|
$GLOBALS[$variableName]
|
|
);
|
|
|
|
$this->watches[$variableName] = $GLOBALS[$variableName];
|
|
$this->addDebug($info, PHP_DebugLine::TYPE_WATCH);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get global process time
|
|
*
|
|
* @return float Execution process time of the script
|
|
*
|
|
* @see getElapsedTime()
|
|
* @since V2.0.0 - 21 Apr 2006
|
|
*/
|
|
public function getProcessTime()
|
|
{
|
|
return $this->getElapsedTime($this->startTime, $this->endTime);
|
|
}
|
|
|
|
/**
|
|
* Get database related process time
|
|
*
|
|
* @return float Execection process time of the script for all
|
|
* database specific tasks
|
|
*
|
|
* @see PHP_DebugLine::TYPE_QUERY, PHP_DebugLine::TYPE_QUERYREL
|
|
* @since V2.0.0 - 21 Apr 2006
|
|
*/
|
|
public function getQueryTime()
|
|
{
|
|
$queryTime = 0;
|
|
|
|
foreach($this->debugLineBuffer as $lkey => $lvalue) {
|
|
$properties = $lvalue->getProperties();
|
|
if ($properties['type'] == PHP_DebugLine::TYPE_QUERY
|
|
|| $properties['type'] == PHP_DebugLine::TYPE_QUERYREL) {
|
|
if (!empty($properties['endTime'])) {
|
|
$queryTime = $queryTime +
|
|
$this->getElapsedTime(
|
|
$properties['startTime'],
|
|
$properties['endTime']);
|
|
}
|
|
}
|
|
}
|
|
return $queryTime;
|
|
}
|
|
|
|
/**
|
|
* PHP_Debug default output function, first we finish the processes and
|
|
* then a render object is created and its render method is invoked
|
|
*
|
|
* The renderer used is set with the options, all the possible renderer
|
|
* are in the directory Debug/Renderer/*.php
|
|
* (not the files ending by '_Config.php')
|
|
*
|
|
* @since V2.0.0 - 13 apr 2006
|
|
* @see Debug_Renderer
|
|
*/
|
|
public function render()
|
|
{
|
|
// Finish process
|
|
$this->endTime = PHP_Debug::getMicroTimeNow();
|
|
|
|
// Render output if we are allowed to
|
|
if ($this->isAllowed()) {
|
|
|
|
// Create render object and invoke its render function
|
|
$renderer = PHP_Debug_Renderer::factory($this, $this->options);
|
|
|
|
// Get required files here to have event all Debug classes
|
|
$this->requiredFiles = get_required_files();
|
|
|
|
// Call rendering
|
|
return $renderer->render();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Alias for the render function
|
|
*
|
|
* @since V2.0.0 - 17 apr 2006
|
|
* @see render()
|
|
*/
|
|
public function display()
|
|
{
|
|
echo $this->render();
|
|
}
|
|
|
|
/**
|
|
* Return the output without displaying it
|
|
*
|
|
* @since V2.0.1 - 17 apr 2006
|
|
* @see render()
|
|
*/
|
|
public function getOutput()
|
|
{
|
|
return $this->render();
|
|
}
|
|
|
|
/**
|
|
* Restrict access to a list of IP
|
|
*
|
|
* @param array $ip Array with IP to allow access
|
|
* @since V2.0.0 - 11 Apr 2006
|
|
* @see $options, isAllowed()
|
|
*/
|
|
function restrictAccess($ip)
|
|
{
|
|
$this->options['allowed_ip'] = $ip;
|
|
}
|
|
|
|
/**
|
|
* Test if the client is allowed to access the debug information
|
|
* There are several possibilities :
|
|
* - 'restrict_access' flag is set to false
|
|
* - 'restrict_access' flag is set to true and client IP is the
|
|
* allowed ip in the options 'allowed_ip'
|
|
* - Access by url is allowed with flag 'allow_url_access' then
|
|
* the client must enter the good key and password in the url
|
|
*
|
|
* @since V2.0.0 - 20 apr 2006
|
|
* @see $options, restrictAcess()
|
|
*/
|
|
protected function isAllowed()
|
|
{
|
|
if ($this->options['restrict_access'] == true) {
|
|
|
|
// Check if client IP is among the allowed ones
|
|
if (in_array(
|
|
$_SERVER['REMOTE_ADDR'],
|
|
$this->options['allowed_ip']
|
|
)) {
|
|
return true;
|
|
}
|
|
// Check if instant access is allowed and test key and password
|
|
elseif ($this->options['allow_url_access'] == true) {
|
|
|
|
$key = $this->options['url_key'];
|
|
|
|
if (!empty($_GET[$key])) {
|
|
if ($_GET[$key] == $this->options['url_pass']) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
// Access is not restricted
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return microtime from a timestamp
|
|
*
|
|
* @param $time Timestamp to retrieve micro time
|
|
* @return numeric Microtime of timestamp param
|
|
*
|
|
* @since V1.1.0 - 14 Nov 2003
|
|
* @see $DebugMode
|
|
*/
|
|
public static function getMicroTime($time)
|
|
{
|
|
list($usec, $sec) = explode(' ', $time);
|
|
return (float)$usec + (float)$sec;
|
|
}
|
|
|
|
/**
|
|
* Alias for getMicroTime(microtime()
|
|
*
|
|
* @see getMicroTime()
|
|
* @since V2.0.0 - 19 apr 2006
|
|
*/
|
|
public static function getMicroTimeNow()
|
|
{
|
|
return PHP_Debug::getMicroTime(microtime());
|
|
}
|
|
|
|
/**
|
|
* Get elapsed time between 2 timestamp
|
|
*
|
|
* @param float $timeStart Start time
|
|
* @param float $timeEnd End time
|
|
* @return float Numeric difference between the two times
|
|
* ref in format 00.0000 sec
|
|
*
|
|
* @see getMicroTime()
|
|
* @since V1.0.0 - 20 Oct 2003
|
|
*/
|
|
public static function getElapsedTime($timeStart, $timeEnd)
|
|
{
|
|
return round($timeEnd - $timeStart, 4);
|
|
}
|
|
|
|
/**
|
|
* Returns Uri prefix, including protocol, hostname and server port.
|
|
*
|
|
* @return string Uniform resource identifier prefix
|
|
*/
|
|
public static function getUriPrefix()
|
|
{
|
|
$pathArray = $_SERVER;
|
|
|
|
if (PHP_Debug::isSecure()) {
|
|
$standardPort = '443';
|
|
$proto = 'https';
|
|
} else {
|
|
$standardPort = '80';
|
|
$proto = 'http';
|
|
}
|
|
|
|
$port = $pathArray['SERVER_PORT'] == $standardPort || !$pathArray['SERVER_PORT'] ? '' : ':'.$pathArray['SERVER_PORT'];
|
|
return $proto.'://'. $pathArray['SERVER_NAME']. $port;
|
|
}
|
|
|
|
/**
|
|
* Test if url is secured
|
|
*
|
|
* @since V2.1.1 - 23 avr. 2007
|
|
*/
|
|
public static function isSecure()
|
|
{
|
|
return $_SERVER['SERVER_PORT'] != 80;
|
|
}
|
|
|
|
/**
|
|
* Returns current host name.
|
|
*
|
|
* @since V2.1.1 - 23 avr. 2007
|
|
*/
|
|
public static function getHost()
|
|
{
|
|
$pathArray = $_SERVER;
|
|
return isset($pathArray['HTTP_X_FORWARDED_HOST']) ? $pathArray['HTTP_X_FORWARDED_HOST'] : (isset($pathArray['HTTP_HOST']) ? $pathArray['HTTP_HOST'] : '');
|
|
}
|
|
|
|
/**
|
|
* Returns current script name.
|
|
*
|
|
* @return string
|
|
* @since V2.1.1 - 23 avr. 2007
|
|
*/
|
|
public static function getScriptName()
|
|
{
|
|
$pathArray = $_SERVER;
|
|
return isset($pathArray['SCRIPT_NAME']) ? $pathArray['SCRIPT_NAME'] : (isset($pathArray['ORIG_SCRIPT_NAME']) ? $pathArray['ORIG_SCRIPT_NAME'] : '');
|
|
}
|
|
|
|
/**
|
|
* Return the query string
|
|
*
|
|
* @author Vernet Loic
|
|
* @since 2.1.1 - 23 avr. 2007
|
|
*/
|
|
public static function getQueryString()
|
|
{
|
|
return $_SERVER['QUERY_STRING'] ? '?'. $_SERVER['QUERY_STRING'] : '';
|
|
}
|
|
|
|
/**
|
|
* Return the full url
|
|
*
|
|
* @author Vernet Loi
|
|
* @since 2.1.1 - 23 avr. 2007
|
|
*/
|
|
public static function getUrl()
|
|
{
|
|
return self::getUriPrefix(). self::getScriptName(). self::getQueryString();
|
|
}
|
|
|
|
/**
|
|
* Set the endtime for a DebugLine in order to monitor the performance
|
|
* of a part of script
|
|
*
|
|
* @see PHP_DebugLine::endTime
|
|
* @since V2.0.0 - 19 apr 2006
|
|
*/
|
|
public function stopTimer()
|
|
{
|
|
$this->debugLineBuffer[count($this->debugLineBuffer)-1]->setEndTime();
|
|
}
|
|
|
|
/**
|
|
* Display the content of any kind of variable
|
|
*
|
|
* - Mode PHP_DEBUG_DUMP_ARR_DISP display the array
|
|
* - Mode PHP_DEBUG_DUMP_ARR_STR return the infos as a string
|
|
*
|
|
* @param mixed $var Variable to dump
|
|
* @param string $varname Name of the variable
|
|
* @param integer $mode Mode of function
|
|
* @param boolean $stopExec Stop the process after display of debug
|
|
* @return mixed Nothing or string depending on the mode
|
|
*
|
|
* @since V2.0.0 - 25 Apr 2006
|
|
*/
|
|
public static function dumpVar(
|
|
$var,
|
|
$varName = self::DUMP_VARNAME,
|
|
$stopExec = false,
|
|
$mode = self::DUMP_DISP) {
|
|
$dumpMethod = self::$staticOptions['dump_method'];
|
|
ob_start();
|
|
$dumpMethod($var);
|
|
|
|
$dbgBuffer = htmlentities(ob_get_contents());
|
|
ob_end_clean();
|
|
|
|
switch ($mode) {
|
|
default:
|
|
case self::DUMP_DISP:
|
|
|
|
if (empty($varName)) {
|
|
if (is_array($var)) {
|
|
$varName = 'Array';
|
|
} elseif (is_object($var)) {
|
|
$varName = get_class($var);
|
|
} else {
|
|
$varName = 'Variable';
|
|
}
|
|
}
|
|
|
|
$dbgBuffer = '<pre><b>dump of \''. $varName. '\'</b> :'.
|
|
CR. $dbgBuffer. '</pre>';
|
|
echo $dbgBuffer;
|
|
break;
|
|
|
|
case PHP_Debug::DUMP_STR:
|
|
return($dbgBuffer);
|
|
}
|
|
|
|
// Check process stop
|
|
if ($stopExec) {
|
|
$backtrace = debug_backtrace();
|
|
$dieMsg = '<pre><b>Process stopped by PHP_Debug</b>'. CR;
|
|
$dieMsg .= $backtrace[0]['file'] ? '» file : <b>'.
|
|
$backtrace[0]['file'] .'</b>'. CR : '';
|
|
$dieMsg .= $backtrace[0]['line'] ? '» line : <b>'.
|
|
$backtrace[0]['line'] .'</b>'. CR : '';
|
|
$dieMsg .= $backtrace[1]['class'] ? '» class : <b>'.
|
|
$backtrace[1]['class'] .'</b>'. CR : '';
|
|
$dieMsg .= $backtrace[1]['function'] ? '» function : <b>'.
|
|
$backtrace[1]['function'] .'</b>'. CR : '';
|
|
$dieMsg .= '</pre>';
|
|
die($dieMsg);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get one option
|
|
*
|
|
* @param string $optionsIdx Name of the option to get
|
|
* @since V2.0.0 - 13 apr 2006
|
|
*/
|
|
public function getOption($optionIdx)
|
|
{
|
|
return $this->options[$optionIdx];
|
|
}
|
|
|
|
/**
|
|
* Getter of requiredFiles property
|
|
*
|
|
* @return array Array with the included/required files
|
|
* @since V2.0.0 - 13 apr 2006
|
|
* @see requiredFiles
|
|
*/
|
|
public function getRequiredFiles()
|
|
{
|
|
return $this->requiredFiles;
|
|
}
|
|
|
|
/**
|
|
* Getter of debugString property
|
|
*
|
|
* @since V2.0.0 - 13 apr 2006
|
|
* @see debugLineBuffer
|
|
*/
|
|
public function getDebugBuffer()
|
|
{
|
|
return $this->debugLineBuffer;
|
|
}
|
|
|
|
/**
|
|
* Getter of queryCount property
|
|
*
|
|
* @since V2.0.0 - 21 Apr 2006
|
|
* @see queryCount
|
|
*/
|
|
public function getQueryCount()
|
|
{
|
|
return $this->queryCount;
|
|
}
|
|
|
|
/**
|
|
* Debug default output function, simply uses the static dump fonction
|
|
* of this class
|
|
*
|
|
* @since V2.0.0 - 11 apr 2006
|
|
* @see dump
|
|
*/
|
|
public function __toString()
|
|
{
|
|
return '<pre>'. PHP_Debug::dumpVar(
|
|
$this,
|
|
__CLASS__. ' class instance',
|
|
false,
|
|
PHP_Debug::DUMP_STR
|
|
). '</pre>';
|
|
}
|
|
} |