DiscuzX /source/class/vizto/vizto_debug.php

Language PHP Lines 384
MD5 Hash e78e7b30543dfeaecd251680aaeeb28e
Repository https://github.com/jinbo51/DiscuzX.git View Raw File
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
<?php defined('IN_DISCUZ') || die('Access Denied');
/**
 * Created by IntelliJ IDEA.
 * User: Administrator
 * Date: 13-5-6
 * Time: 上午7:39
 * To change this template use File | Settings | File Templates.
 */



class vizto_debug {

	/**
	 * Returns an HTML string of debugging information about any number of
	 * variables, each wrapped in a "pre" tag:
	 *
	 *     // Displays the type and value of each variable
	 *     echo Debug::vars($foo, $bar, $baz);
	 *
	 * @param   mixed $var,...    variable to debug
	 *
	 * @return  string
	 */
	public static function vars() {
		if(func_num_args() === 0)
			return;

		// Get all passed variables
		$variables = func_get_args();

		$output = array();
		foreach($variables as $var) {
			$output[] = vizto_debug::_dump($var, 1024);
		}

		return '<pre class="debug">'.implode("\n", $output).'</pre>';
	}

	/**
	 * Returns an HTML string of information about a single variable.
	 *
	 * Borrows heavily on concepts from the Debug class of [Nette](http://nettephp.com/).
	 *
	 * @param   mixed   $value              variable to dump
	 * @param   integer $length             maximum length of strings
	 * @param   integer $level_recursion    recursion limit
	 *
	 * @return  string
	 */
	public static function dump($value, $length = 128, $level_recursion = 10) {
		return vizto_debug::_dump($value, $length, $level_recursion);
	}

	/**
	 * Helper for Debug::dump(), handles recursion in arrays and objects.
	 *
	 * @param   mixed   $var    variable to dump
	 * @param   integer $length maximum length of strings
	 * @param   integer $limit  recursion limit
	 * @param   integer $level  current recursion level (internal usage only!)
	 *
	 * @return  string
	 */
	protected static function _dump(& $var, $length = 128, $limit = 10, $level = 0) {
		global $_G;
		if($var === NULL) {
			return '<small>NULL</small>';
		} elseif(is_bool($var)) {
			return '<small>bool</small> '.($var ? 'TRUE' : 'FALSE');
		} elseif(is_float($var)) {
			return '<small>float</small> '.$var;
		} elseif(is_resource($var)) {
			if(($type = get_resource_type($var)) === 'stream' AND $meta = stream_get_meta_data($var)) {
				$meta = stream_get_meta_data($var);

				if(isset($meta['uri'])) {
					$file = $meta['uri'];

					if(function_exists('stream_is_local')) {
						// Only exists on PHP >= 5.2.4
						if(stream_is_local($file)) {
							$file = Debug::path($file);
						}
					}

					return '<small>resource</small><span>('.$type.')</span> '.htmlspecialchars($file, ENT_NOQUOTES, Kohana::$charset);
				}
			} else {
				return '<small>resource</small><span>('.$type.')</span>';
			}
		} elseif(is_string($var)) {
			// Clean invalid multibyte characters. iconv is only invoked
			// if there are non ASCII characters in the string, so this
			// isn't too much of a hit.
			$var = UTF8::clean($var, Kohana::$charset);

			if(UTF8::strlen($var) > $length) {
				// Encode the truncated string
				$str = htmlspecialchars(UTF8::substr($var, 0, $length), ENT_NOQUOTES, $_G['charset']).'&nbsp;&hellip;';
			} else {
				// Encode the string
				$str = htmlspecialchars($var, ENT_NOQUOTES, $_G['charset']);
			}

			return '<small>string</small><span>('.strlen($var).')</span> "'.$str.'"';
		} elseif(is_array($var)) {
			$output = array();

			// Indentation for this variable
			$space = str_repeat($s = '    ', $level);

			static $marker;

			if($marker === NULL) {
				// Make a unique marker
				$marker = uniqid("\x00");
			}

			if(empty($var)) {
				// Do nothing
			} elseif(isset($var[$marker])) {
				$output[] = "(\n$space$s*RECURSION*\n$space)";
			} elseif($level < $limit) {
				$output[] = "<span>(";

				$var[$marker] = TRUE;
				foreach($var as $key => & $val) {
					if($key === $marker) continue;
					if(!is_int($key)) {
						$key = '"'.htmlspecialchars($key, ENT_NOQUOTES, Kohana::$charset).'"';
					}

					$output[] = "$space$s$key => ".vizto_debug::_dump($val, $length, $limit, $level + 1);
				}
				unset($var[$marker]);

				$output[] = "$space)</span>";
			} else {
				// Depth too great
				$output[] = "(\n$space$s...\n$space)";
			}

			return '<small>array</small><span>('.count($var).')</span> '.implode("\n", $output);
		} elseif(is_object($var)) {
			// Copy the object as an array
			$array = (array)$var;

			$output = array();

			// Indentation for this variable
			$space = str_repeat($s = '    ', $level);

			$hash = spl_object_hash($var);

			// Objects that are being dumped
			static $objects = array();

			if(empty($var)) {
				// Do nothing
			} elseif(isset($objects[$hash])) {
				$output[] = "{\n$space$s*RECURSION*\n$space}";
			} elseif($level < $limit) {
				$output[] = "<code>{";

				$objects[$hash] = TRUE;
				foreach($array as $key => & $val) {
					if($key[0] === "\x00") {
						// Determine if the access is protected or protected
						$access = '<small>'.(($key[1] === '*') ? 'protected' : 'private').'</small>';

						// Remove the access level from the variable name
						$key = substr($key, strrpos($key, "\x00") + 1);
					} else {
						$access = '<small>public</small>';
					}

					$output[] = "$space$s$access $key => ".vizto_debug::_dump($val, $length, $limit, $level + 1);
				}
				unset($objects[$hash]);

				$output[] = "$space}</code>";
			} else {
				// Depth too great
				$output[] = "{\n$space$s...\n$space}";
			}

			return '<small>object</small> <span>'.get_class($var).'('.count($array).')</span> '.implode("\n", $output);
		} else {
			return '<small>'.gettype($var).'</small> '.htmlspecialchars(print_r($var, TRUE), ENT_NOQUOTES, $_G['charset']);
		}
	}

	/**
	 * Removes application, system, modpath, or docroot from a filename,
	 * replacing them with the plain text equivalents. Useful for debugging
	 * when you want to display a shorter path.
	 *
	 *     // Displays SYSPATH/classes/kohana.php
	 *     echo Debug::path(Kohana::find_file('classes', 'kohana'));
	 *
	 * @param   string $file   path to debug
	 *
	 * @return  string
	 */
	public static function path($file) {
		if(strpos($file, APPPATH) === 0) {
			$file = 'APPPATH'.DIRECTORY_SEPARATOR.substr($file, strlen(APPPATH));
		} elseif(strpos($file, SYSPATH) === 0) {
			$file = 'SYSPATH'.DIRECTORY_SEPARATOR.substr($file, strlen(SYSPATH));
		} elseif(strpos($file, MODPATH) === 0) {
			$file = 'MODPATH'.DIRECTORY_SEPARATOR.substr($file, strlen(MODPATH));
		} elseif(strpos($file, DOCROOT) === 0) {
			$file = 'DOCROOT'.DIRECTORY_SEPARATOR.substr($file, strlen(DOCROOT));
		}

		return $file;
	}

	/**
	 * Returns an HTML string, highlighting a specific line of a file, with some
	 * number of lines padded above and below.
	 *
	 *     // Highlights the current line of the current file
	 *     echo Debug::source(__FILE__, __LINE__);
	 *
	 * @param   string  $file           file to open
	 * @param   integer $line_number    line number to highlight
	 * @param   integer $padding        number of padding lines
	 *
	 * @return  string   source of file
	 * @return  FALSE    file is unreadable
	 */
	public static function source($file, $line_number, $padding = 5) {
		global $_G;
		if(!$file OR !is_readable($file)) {
			// Continuing will cause errors
			return FALSE;
		}

		// Open the file and set the line position
		$file = fopen($file, 'r');
		$line = 0;

		// Set the reading range
		$range = array('start' => $line_number - $padding, 'end' => $line_number + $padding);

		// Set the zero-padding amount for line numbers
		$format = '% '.strlen($range['end']).'d';

		$source = '';
		while(($row = fgets($file)) !== FALSE) {
			// Increment the line number
			if(++$line > $range['end'])
				break;

			if($line >= $range['start']) {
				// Make the row safe for output
				$row = htmlspecialchars($row, ENT_NOQUOTES, $_G['charset']);

				// Trim whitespace and sanitize the row
				$row = '<span class="number">'.sprintf($format, $line).'</span> '.$row;

				if($line === $line_number) {
					// Apply highlighting to this row
					$row = '<span class="line highlight">'.$row.'</span>';
				} else {
					$row = '<span class="line">'.$row.'</span>';
				}

				// Add to the captured source
				$source .= $row;
			}
		}

		// Close the file
		fclose($file);

		return '<pre class="source"><code>'.$source.'</code></pre>';
	}

	/**
	 * Returns an array of HTML strings that represent each step in the backtrace.
	 *
	 *     // Displays the entire current backtrace
	 *     echo implode('<br/>', Debug::trace());
	 *
	 * @param   array $trace
	 *
	 * @return  string
	 */
	public static function trace(array $trace = NULL) {
		if($trace === NULL) {
			// Start a new trace
			$trace = debug_backtrace();
		}

		// Non-standard function calls
		$statements = array('include', 'include_once', 'require', 'require_once');

		$output = array();
		foreach($trace as $step) {
			if(!isset($step['function'])) {
				// Invalid trace step
				continue;
			}

			if(isset($step['file']) AND isset($step['line'])) {
				// Include the source of this step
				$source = vizto_debug::source($step['file'], $step['line']);
			}

			if(isset($step['file'])) {
				$file = $step['file'];

				if(isset($step['line'])) {
					$line = $step['line'];
				}
			}

			// function()
			$function = $step['function'];

			if(in_array($step['function'], $statements)) {
				if(empty($step['args'])) {
					// No arguments
					$args = array();
				} else {
					// Sanitize the file path
					$args = array($step['args'][0]);
				}
			} elseif(isset($step['args'])) {
				if(!function_exists($step['function']) OR strpos($step['function'], '{closure}') !== FALSE) {
					// Introspection on closures or language constructs in a stack trace is impossible
					$params = NULL;
				} else {
					if(isset($step['class'])) {
						if(method_exists($step['class'], $step['function'])) {
							$reflection = new ReflectionMethod($step['class'], $step['function']);
						} else {
							$reflection = new ReflectionMethod($step['class'], '__call');
						}
					} else {
						$reflection = new ReflectionFunction($step['function']);
					}

					// Get the function parameters
					$params = $reflection->getParameters();
				}

				$args = array();

				foreach($step['args'] as $i => $arg) {
					if(isset($params[$i])) {
						// Assign the argument by the parameter name
						$args[$params[$i]->name] = $arg;
					} else {
						// Assign the argument by number
						$args[$i] = $arg;
					}
				}
			}

			if(isset($step['class'])) {
				// Class->method() or Class::method()
				$function = $step['class'].$step['type'].$step['function'];
			}

			$output[] = array(
				'function' => $function,
				'args'     => isset($args) ? $args : NULL,
				'file'     => isset($file) ? $file : NULL,
				'line'     => isset($line) ? $line : NULL,
				'source'   => isset($source) ? $source : NULL,
			);

			unset($function, $args, $file, $line, $source);
		}

		return $output;
	}

}
Back to Top