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); }