DEBUG_ verfügbar.
*
* @package MySQLDumper
* @author D4rk4ng3l
* @version 0.3
* @copyright 2010 Stefan 'D4rk4ng3l' Krenz
*/
/**
* Debug class by Stefan Krenz
*
* @package MySQLDumper
*
*/
class Debug
{
/**
* Debug-Ausgabe als einfacher Text.
*/
const OUTPUT_PLAIN = 0x000001;
/**
* Debug-Ausgabe als HTML-Quelltext.
*/
const OUTPUT_HTML = 0x000002;
/**
* Debug-Ausgabe als HTML-Kommentar.
*/
const OUTPUT_HTML_COMMENT = 0x000003;
/**
* Debug-Ausgabe in einer Datei als einfacher Text.
* {@link Debug::setOutputFilename()}
*/
const OUTPUT_FILE = 0x000004;
/**
* Debug-Ausgabe als Javascript Kommentar.
*/
const OUTPUT_JAVASCRIPT = 0x000005;
/**
* Alias für {@link Debug::OUTPUT_JAVASCRIPT}
*/
const OUTPUT_JS = 0x000005;
/**
* Backtrace-Ausgabe deaktivieren.
*/
const BACKTRACE_NONE = 0x000100;
/**
* Einfache Backtrace-Ausgabe. Gibt nur die Debug::out()
* aufrufende Funktion aus.
*/
const BACKTRACE_SIMPLE = 0x000200;
/**
* Komplexe Backtrace-Ausgabe. Gibt alle aufrufenden Funktionen aus.
*/
const BACKTRACE_COMPLETE = 0x000300;
/**
* HTML-Quelltext im HTML-Format ausgeben.
*/
const HTMLMODE_HTML = 0x010000;
/**
* HTML-Quelltext im XHTML-Format ausgeben.
*/
const HTMLMODE_XHTML = 0x020000;
/**
* Speichert den Modus für die Debug-Ausgabe.
*
* Siehe auch:
* {@link Debug::OUTPUT_PLAIN}
* {@link Debug::OUTPUT_HTML}
* {@link Debug::OUTPUT_HTML_COMMENT}
* {@link Debug::OUTPUT_FILE}
*
* @var int Ausgabemodus
* @static
*/
private static $_outputMode = self::OUTPUT_HTML;
/**
* Speichert den Modus für die Backtrace-Ausgabe.
*
* Siehe auch:
* {@link Debug::BACKTRACE_NONE}
* {@link Debug::BACKTRACE_SIMPLE}
* {@link Debug::BACKTRACE_COMPLETE}
*
* @var int Backtracemodus
* @static
*/
private static $_backtraceMode = self::BACKTRACE_SIMPLE;
/**
* Speichert den Modus für die HTML-Ausgabe.
*
* Siehe auch: {@link Debug::HTMLMODE_HTML, Debug::HTMLMODE_XHTML}
*
* @var int HTML-Quelltext-Modus
* @static
*/
private static $_htmlMode = self::HTMLMODE_HTML;
/**
* Speichert Informationen über die registrierten Callback-Funktionen.
*
* Nähere Informationen zum callback Typ:
* siehe PHP-Manual
*
* @var array Benutzerdefinierte Callback-Funktionen
* @static
*/
private static $_callbacks = array(
self::OUTPUT_PLAIN => array(__CLASS__, 'defaultCallback'),
self::OUTPUT_HTML => array(__CLASS__, 'defaultCallback'),
self::OUTPUT_HTML_COMMENT => array(__CLASS__, 'defaultCallback'),
self::OUTPUT_FILE => array(__CLASS__, 'defaultCallback'),
self::OUTPUT_JAVASCRIPT => array(__CLASS__, 'defaultCallback'),
);
/**
* Speichert den Inhalt der zuletzt ausgegebenen Variablen.
*
* @var mixed Letzte ausgegebene Variable.
* @static
*/
private static $_lastVariable = null;
/**
* Speichert den Backtrace der letzten Debug-Ausgabe.
*
* @var array Backtrace der letzten Debug-Ausgabe
* @static
*/
private static $_lastBacktrace = null;
/**
* Speichert den HTML-Quellcode für den Zeilenumbruch,
* basierend auf dem aktuellen HTML-Ausgabe-Modus.
*
* @var string Zeilenumbruch für HTML-Ausgabe
*/
private static $_htmlLineBreak = "
\n";
/**
* Speichert den Dateinamen für die Dateiausgabe.
*
* Siehe auch: {@link Debug::OUTPUT_FILE}
*
* @var string Dateiname für die Debug-Ausgabe
*/
private static $_outputFilename = 'debug.txt';
/**
* Deaktivierter Konstruktor. Klasse ist nur statisch zu benutzen.
*/
private function __construct()
{
}
/**
* Deaktiviertes klonen.
*/
private function __clone()
{
}
/**
* Gibt eine typbasierte Ausgabe zurück.
*
* Ist $arg ein Array, so wird 'Array' zurückgeben.
* Ist $arg ein Objekt, so wird der Name der Klasse zurückgeben.
* Ist $arg ein Boolean, so wird 'TRUE' bzw. 'FALSE' zurückgeben.
* Ist $arg ein String, so wird er in Anführungsstriche gesetzt.
* Ist $arg null, so wird 'NULL' zurückgeben.
* Ist der Typ der Variablen $arg unbekannt,
* so wird die Variable selbst zurückgegeben.
*
* @param mixed $arg Funktionparameter
*
* @return mixed
*/
private static function getArg($arg)
{
if (is_array($arg)) {
$result = 'Array';
} elseif (is_object($arg)) {
$result = get_class($arg);
} elseif (is_bool($arg)) {
$result = $arg ? 'TRUE' : 'FALSE';
} elseif (is_string($arg)) {
$result = '"' . $arg . '"';
} elseif (is_null($arg)) {
$result = 'NULL';
} else {
$result = $arg;
}
return $result;
}
private static function _getBacktrace($backtrace, $outputBacktraceType)
{
$outputBacktrace = '';
switch ($outputBacktraceType) {
case self::BACKTRACE_NONE:
break;
case self::BACKTRACE_SIMPLE:
$outputBacktrace = 'Debugoutput called from '
. $backtrace[0]['file'] . '['
. $backtrace[0]['line'] . ']';
break;
case self::BACKTRACE_COMPLETE:
foreach ($backtrace as $traceNum => $trace) {
$args = (count($trace['args']) > 0) ?
self::getArg($trace['args'][0]) : '';
for ($i = 1; $i < count($trace['args']); $i++) {
$args .= ', ' . self::getArg($trace['args'][$i]);
}
$outputBacktrace .= '#' . $traceNum . ': ' . $trace['file']
. '[' . $trace['line'] . '] ' . $trace['class']
. $trace['type'] . $trace['function'] . '('
. $args . ")\n";
}
break;
default:
$outputBacktrace = 'Debugoutput called from '
. $backtrace[0]['file'] . '[' . $backtrace[0]['line'] . ']';
break;
}
return $outputBacktrace;
}
private static function _doOutput(
$outputFormatType,
$outputBacktrace,
$dumpedVar,
$outputHtmlModeType
)
{
switch ($outputFormatType) {
case self::OUTPUT_PLAIN:
echo $outputBacktrace;
echo $dumpedVar;
break;
case self::OUTPUT_HTML:
echo '' .
nl2br(
$outputBacktrace,
($outputHtmlModeType == self::HTMLMODE_XHTML)
) . '' . self::$_htmlLineBreak;
echo '
'; echo htmlspecialchars($dumpedVar); echo ''; break; case self::OUTPUT_HTML_COMMENT: echo ''. "\n"; break; case self::OUTPUT_FILE: $output = $outputBacktrace . "\n"; $output .= $dumpedVar . "\n\n"; $filePointer = fopen(self::$_outputFilename, "a+"); fwrite($filePointer, $output); fclose($filePointer); break; case self::OUTPUT_JAVASCRIPT: echo "/*\n"; echo $outputBacktrace . "\n\n"; echo $dumpedVar; echo "\n*/\n"; } } /** * Standard Callback-Funktion * * Siehe auch: {@link Debug::$_callbacks} * * @param mixed $var Variable, die ausgegeben werden soll. * @param array $backtrace Backtrace des Aufrufs von Debug::out() * @param int $outputFormat Ausgabe-Format * * @return void */ public static function defaultCallback($var, $backtrace, $outputFormat) { $outputFormatType = ($outputFormat | 0xFFFFFF00) ^ 0xFFFFFF00; $outputBacktraceType = ($outputFormat | 0xFFFF00FF) ^ 0xFFFF00FF; $outputHtmlModeType = ($outputFormat | 0xFF00FFFF) ^ 0xFF00FFFF; if ($outputFormatType == 0) { $outputFormatType = self::$_outputMode; } if ($outputBacktraceType == 0) { $outputBacktraceType = self::$_backtraceMode; } if ($outputHtmlModeType == 0) { $outputHtmlModeType = self::$_htmlMode; } self::$_htmlLineBreak = nl2br( "\n", ($outputHtmlModeType == self::HTMLMODE_XHTML) ); ob_start(); var_dump($var); $dumpedVar = ob_get_contents(); ob_end_clean(); $outputBacktrace = self::_getBacktrace( $backtrace, $outputBacktraceType ); self::_doOutput( $outputFormatType, $outputBacktrace, $dumpedVar, $outputHtmlModeType ); } /** * Erzeugt eine Ausgabe, die beim Auffinden * von Fehlern (debugging) unterstützt. * * @param mixed $var Variable, die ausgegeben werden soll. * @param int $outputFormat Format für die Ausgabe. * * @return void */ public static function out($var, $outputFormat = null) { if ($outputFormat === null) { $outputFormat = self::$_outputMode | self::$_backtraceMode | self::$_htmlMode; } $outputFormatType = ($outputFormat | 0xFFFFFF00) ^ 0xFFFFFF00; if ($outputFormatType == 0) { $outputFormatType = self::$_outputMode; $outputFormat = self::$_outputMode | $outputFormat; } $backtrace = debug_backtrace(); if (isset(self::$_callbacks[$outputFormatType])) { call_user_func_array( self::$_callbacks[$outputFormatType], array($var, $backtrace, $outputFormat) ); } else { $message = 'Für das angegebene Ausgabeformat wurde keine ' . 'Callback-Funktion definiert. Format: 0x' . sprintf('%8.8X', $outputFormatType); throw new Exception($message); } self::$_lastBacktrace = $backtrace; self::$_lastVariable = $var; } /** * Gibt den Backtrace des letzten Aufrufs von Debug::out() zurück. * * @return array */ public static function getLastBacktrace() { return self::$_lastBacktrace; } /** * Gibt den Inhalt der zuletzt ausgegebenen Variablen zurück. * * @return mixed */ public static function getLastVariable() { return self::$_lastVariable; } /** * Fügt eine Callback-Funktion zum Stack hinzu, * diese wird beim Aufruf von Debug::out() * automatisch aufgerufen. Diese Funktion muss gleichzeitig den Inhalt * des Debug::out() Aufrufs ausgeben. * * Für nähere Informationen über mögliche * Callback-Funktionen {@link Debug::$_callbacks} * * Die Callback-Funktion muss dem folgenden Format entsprechen: * method null callback($var, $backtrace, $outputFormat) * {@link Debug::defaultCallback()} * * Benutze für das Ausgabeformat ($outputFormat) * einen Integer zwischen 0x10 und 0xFF. * * Alternativ kann für $outputFormat auch ein Array übergeben werden. * Es gilt dann die Konvention: * Index 0: Ausgabeformat (entspricht $outputFormat mit einem Integer) * Index 1: Callback-Information (entspricht $callbackFunction) * * Ausgabeformate sollten global mit dem Präfix * 'DEBUG_OUTPUT_' registriert werden. * Zusätzliche Ausgabeinformationen können in den * Bytes 3 und 4 (0xFFFF0000) übergeben werden. * * @param mixed $outputFormat Ausgabeformat * @param mixed $callbackFunction Informationen über die Callback-Funktion * * @return bool */ public static function registerCallbackFunction( $outputFormat, $callbackFunction = null ) { if (is_array($outputFormat)) { self::$_callbacks[$outputFormat[0]] = $outputFormat[1]; return is_callable($outputFormat[1]); } else { self::$_callbacks[$outputFormat] = $callbackFunction; return is_callable($callbackFunction); } } /** * Entfernt eine Callback-Funktion vom Stack. * * @param int $outputFormat Ausgabeformat */ public static function unregisterCallbackFunction($outputFormat) { unset(self::$_callbacks[$outputFormat]); } /** * Setzt den Modus für die Ausgabe. * {@link Debug::$_outputMode} * * @param int $outputMode Ausgabemodus */ public static function setDefaultOutputMode($outputMode) { self::$_outputMode = $outputMode; } /** * Setzt den Modus für den Backtrace. * {@link Debug::$_backtraceMode} * * @param int $backtraceMode Backtrace-Modus */ public static function setDefaultBacktraceMode($backtraceMode) { self::$_backtraceMode = $backtraceMode; } /** * Setzt den Modus für die HTML-Ausgabe * {@link Debug::$_htmlMode} * * @param int $htmlMode HTML-Modus */ public static function setDefaultHtmlMode($htmlMode) { self::$_htmlMode = $htmlMode; } /** * Setzt den Dateinamen für die Dateiausgabe. * {@link Debug::$_outputFilename} * * @param string $outputFilename Dateiname */ public static function setOutputFilename($outputFilename = 'debug.txt') { self::$_outputFilename = $outputFilename; } } $debugReflection = new ReflectionClass('Debug'); $constants = $debugReflection->getConstants(); foreach ($constants as $constantName => $constantValue) { define('DEBUG_' . $constantName, $constantValue); }