Gecko [ www.utparral.edu.mx ]

Name	Size	Permission
.channels	[ DIR ]	drwxr-xr-x
.registry	[ DIR ]	drwxr-xr-x
Archive	[ DIR ]	drwxr-xr-x
Auth	[ DIR ]	drwxr-xr-x
Benchmark	[ DIR ]	drwxr-xr-x
build	[ DIR ]	drwxr-xr-x
Cache	[ DIR ]	drwxr-xr-x
Console	[ DIR ]	drwxr-xr-x
Contact	[ DIR ]	drwxr-xr-x
Crypt	[ DIR ]	drwxr-xr-x
data	[ DIR ]	drwxr-xr-x
doc	[ DIR ]	drwxr-xr-x
example	[ DIR ]	drwxr-xr-x
extensions	[ DIR ]	drwxr-xr-x
File	[ DIR ]	drwxr-xr-x
fonts	[ DIR ]	drwxr-xr-x
FSM	[ DIR ]	drwxr-xr-x
HTML	[ DIR ]	drwxr-xr-x
HTTP	[ DIR ]	drwxr-xr-x
I18N	[ DIR ]	drwxr-xr-x
Image	[ DIR ]	drwxr-xr-x
Log	[ DIR ]	drwxr-xr-x
Mail	[ DIR ]	drwxr-xr-x
Math	[ DIR ]	drwxr-xr-x
MDB	[ DIR ]	drwxr-xr-x
MDB2	[ DIR ]	drwxr-xr-x
MP3	[ DIR ]	drwxr-xr-x
Net	[ DIR ]	drwxr-xr-x
Numbers	[ DIR ]	drwxr-xr-x
OS	[ DIR ]	drwxr-xr-x
Pager	[ DIR ]	drwxr-xr-x
Payment_Clieop	[ DIR ]	drwxr-xr-x
PEAR	[ DIR ]	drwxr-xr-x
PHP	[ DIR ]	drwxr-xr-x
PHPUnit	[ DIR ]	drwxr-xr-x
Science	[ DIR ]	drwxr-xr-x
Stream	[ DIR ]	drwxr-xr-x
Structures	[ DIR ]	drwxr-xr-x
SymfonyComponents	[ DIR ]	drwxr-xr-x
System	[ DIR ]	drwxr-xr-x
test	[ DIR ]	drwxr-xr-x
Text	[ DIR ]	drwxr-xr-x
Tree	[ DIR ]	drwxr-xr-x
Var_Dump	[ DIR ]	drwxr-xr-x
XML	[ DIR ]	drwxr-xr-x
.depdb	30.49 KB	-rw-r--r--
.depdblock	0 B	-rw-r--r--
.filemap	178.4 KB	-rw-r--r--
.lock	0 B	-rw-r--r--
Auth.php	38.4 KB	-rw-r--r--
Cache.php	10.78 KB	-rw-r--r--
Cezpdf.php	80.11 KB	-rw-r--r--
Contact_Vcard_Build.php	929 B	-rw-r--r--
Contact_Vcard_Parse.php	927 B	-rw-r--r--
Cpdf.php	149.29 KB	-rw-r--r--
fpdf.php	45.98 KB	-rwxrwxrwx
FSM.php	10.72 KB	-rw-r--r--
HTTP.php	17.95 KB	-rw-r--r--
Log.php	26.37 KB	-rw-r--r--
Mail.php	9.65 KB	-rw-r--r--
MDB2.php	149.14 KB	-rw-r--r--
Pager.php	9.05 KB	-rw-r--r--
pearcmd.php	14.49 KB	-rw-r--r--
PEAR.php	35.32 KB	-rw-r--r--
peclcmd.php	1.08 KB	-rw-r--r--
System.php	20.21 KB	-rw-r--r--
Var_Dump.php	20.38 KB	-rw-r--r--

Code Editor : Var_Dump.php

<?php
/* vim: set expandtab tabstop=4 shiftwidth=4: */
// +----------------------------------------------------------------------+
// | PHP version 4                                                        |
// +----------------------------------------------------------------------+
// | Copyright (c) 1997-2006 The PHP Group                                |
// +----------------------------------------------------------------------+
// | This source file is subject to version 3.0 of the PHP license,       |
// | that is bundled with this package in the file LICENSE, and is        |
// | available through the world-wide-web at the following url:           |
// | http://www.php.net/license/3_0.txt.                                  |
// | If you did not receive a copy of the PHP license and are unable to   |
// | obtain it through the world-wide-web, please send a note to          |
// | license@php.net so we can mail you a copy immediately.               |
// +----------------------------------------------------------------------+
// | Authors: Frederic Poeydomenge <fpoeydomenge@free.fr>                 |
// +----------------------------------------------------------------------+

/**
 * Wrapper for the var_dump function.
 *
 * " The var_dump function displays structured information about expressions
 * that includes its type and value. Arrays are explored recursively
 * with values indented to show structure. "
 *
 * The Var_Dump class captures the output of the var_dump function,
 * by using output control functions, and then uses external renderer
 * classes for displaying the result in various graphical ways :
 * simple text, HTML/XHTML text, HTML/XHTML table, XML, ...
 *
 * @category  PHP
 * @package   Var_Dump
 * @author    Frederic Poeydomenge <fpoeydomenge@free.fr>
 * @copyright 1997-2006 The PHP Group
 * @license   http://www.php.net/license/3_0.txt PHP License 3.0
 * @version   CVS: $Id: Var_Dump.php 237750 2007-06-15 08:06:25Z fredericpoeydome $
 * @link      http://pear.php.net/package/Var_Dump
 */

/**
 * Include Renderer class
 */

require_once 'Var_Dump/Renderer.php';

/**
 * Constants
 */

define ('VAR_DUMP_START_GROUP',          1);
define ('VAR_DUMP_FINISH_GROUP',         2);
define ('VAR_DUMP_START_ELEMENT_NUM',    3);
define ('VAR_DUMP_START_ELEMENT_STR',    4);
define ('VAR_DUMP_FINISH_ELEMENT',       5);
define ('VAR_DUMP_FINISH_STRING',        6);

define ('VAR_DUMP_PREG_MATCH',           0);
define ('VAR_DUMP_PREG_SPACES',          1);
define ('VAR_DUMP_PREG_KEY_QUOTE',       2);
define ('VAR_DUMP_PREG_KEY',             3);
define ('VAR_DUMP_PREG_STRING_TYPE',     4);
define ('VAR_DUMP_PREG_STRING_LENGTH',   5);
define ('VAR_DUMP_PREG_STRING_VALUE',    6);
define ('VAR_DUMP_PREG_VALUE',           7);
define ('VAR_DUMP_PREG_VALUE_REFERENCE', 8);
define ('VAR_DUMP_PREG_VALUE_TYPE',      9);
define ('VAR_DUMP_PREG_VALUE_COMPL',    10);
define ('VAR_DUMP_PREG_VALUE_RESOURCE', 11);
define ('VAR_DUMP_PREG_ARRAY_END',      12);
define ('VAR_DUMP_PREG_ARRAY_START',    13);
define ('VAR_DUMP_PREG_ARRAY_TYPE',     14);
define ('VAR_DUMP_PREG_ARRAY_COUNT',    15);
define ('VAR_DUMP_PREG_STRING_COMPL',   16);

/**
 * Main class.
 *
 * @category  PHP
 * @package   Var_Dump
 * @author    Frederic Poeydomenge <fpoeydomenge@free.fr>
 * @copyright 1997-2006 The PHP Group
 * @license   http://www.php.net/license/3_0.txt PHP License 3.0
 * @version   CVS: $Id: Var_Dump.php 237750 2007-06-15 08:06:25Z fredericpoeydome $
 * @link      http://pear.php.net/package/Var_Dump
 */

class Var_Dump
{

/**
     * Default configuration options.
     *
     * @var array
     * @access public
     */
    var $defaultOptions = array(
        'display_mode' => 'XHTML_Text', // Display mode.
        'ignore_list'  => NULL          // List of ignored class names.
    );

/**
     * Run-time configuration options.
     *
     * @var array
     * @access public
     */
    var $options = array();

/**
     * Rendering object.
     *
     * @var object
     * @access public
     */
    var $renderer = NULL;

/**
     * Rendering configuration options.
     *
     * See Var_Dump/Renderer/*.php for the complete list of options
     *
     * @var array
     * @access public
     */
    var $rendererOptions = array();

/**
     * Class constructor.
     *
     * The factory approach must be used in relationship with the
     * toString() method.
     * See Var_Dump/Renderer/*.php for the complete list of options
     *
     * @see Var_Dump::toString()
     * @param mixed $options String (display mode) or array (Global parameters).
     * @param array $rendererOptions Parameters for the rendering.
     * @access public
     */
    function Var_Dump($options = array(), $rendererOptions = array())
    {

if (! is_null($options)) {
            if (is_string($options)) {
                $options = array(
                    'display_mode' => $options
                );
            }
            $this->options = array_merge (
                $this->defaultOptions,
                $options
            );
        }

if (! is_null($rendererOptions) and is_array($rendererOptions)) {
            $this->rendererOptions = $rendererOptions;
            $this->renderer = & Var_Dump_Renderer::factory(
                $this->options['display_mode'],
                $this->rendererOptions
            );
        }

}

/**
     * Attempt to return a concrete Var_Dump instance.
     *
     * The factory approach must be used in relationship with the
     * toString() method.
     * See Var_Dump/Renderer/*.php for the complete list of options
     *
     * @see Var_Dump::toString()
     * @param mixed $options String (display mode) or array (Global parameters).
     * @param array $rendererOptions Parameters for the rendering.
     * @access public
     */
    function & factory($options = array(), $rendererOptions = array())
    {
        $obj = new Var_Dump($options, $rendererOptions);
        return $obj;
    }

/**
     * Uses a renderer object to return the string representation of a variable.
     *
     * @param mixed $expression The variable to parse.
     * @return string The string representation of the variable.
     * @access public
     */
    function toString($expression)
    {

if (is_null($this->renderer)) {
            return '';
        }

$family = array(); // element family
        $depth  = array(); // element depth
        $type   = array(); // element type
        $value  = array(); // element value

// When xdebug is loaded, disable the custom fancy var_dump() function,
        // that is not compatible with the regexp parsing below, by forcing
        // the "html_errors" configuration option to "off"

if (extension_loaded('xdebug')) {
            ini_set('html_errors', '0');
        }

// Captures the output of the var_dump function,
        // by using output control functions.

ob_start();
        var_dump($expression);
        $variable = ob_get_contents();
        ob_end_clean();

// When xdebug is loaded, restore the value of the
        // "html_errors" configuration option

if (extension_loaded('xdebug')) {
            ini_restore('html_errors');
        }

// Regexp that parses the output of the var_dump function.
        // The numbers between square brackets [] are the reference
        // of the captured subpattern, and correspond to the entries
        // in the resulting $matches array.

preg_match_all(
            '!^
              (\s*)                                 # 2 spaces for each depth level
              (?:                                   #
                (?:\[("?)(.*?)\\2\]=>)              # Key [2-3]
                  |                                 #   or
                (?:(&?string$(\d+)$)\s+"(.*))     # String [4-6]
                  |                                 #   or
                (                                   # Value [7-11]
                  (&?)                              #   - reference [8]
                  (bool|int|float|resource|         #   - type [9]
                  NULL|\*RECURSION\*|UNKNOWN:0)     #
                  (?:$(.*?)$)?                    #   - complement [10]
                  (?:\sof\stype\s$(.*?)$)?        #   - resource [11]
                )                                   #
                  |                                 #   or
                (})                                 # End of array/object [12]
                  |                                 #   or
                (?:(&?(array|object)$(.+)$.*)\ {) # Start of array/object [13-15]
                  |                                 #   or
                (.*)                                # String (additional lines) [16]
              )                                     #
            $!Smx',
            $variable,
            $matches,
            PREG_SET_ORDER
        );

// Used to keep the maxLen of the keys for each nested variable.

$stackLen = array();
        $keyLen = array();
        $maxLen = 0;

// Used when matching a string, to count the remaining
        // number of chars before the end of the string.

$countdown = 0;

// Loop through the matches of the previously defined regexp.

reset($matches);
        while (list($key, $match) = each($matches)) {

$count = count($match) - 1;

// Find which alternative has been matched in the regexp,
            // by looking at the number of elements in the $match array.

switch ($count) {

// Key
                //=====
                // - Compute the maxLen of the keys at the actual depth

case VAR_DUMP_PREG_KEY:
                    $len = strlen($match[VAR_DUMP_PREG_KEY]);
                    if ($len > $maxLen) {
                        $maxLen = $len;
                    }
                    if (empty($match[VAR_DUMP_PREG_KEY_QUOTE])) {
                        $family[] = VAR_DUMP_START_ELEMENT_NUM;
                    } else {
                        $family[] = VAR_DUMP_START_ELEMENT_STR;
                    }
                    $depth[] = strlen($match[VAR_DUMP_PREG_SPACES]) >> 1;
                    $type[]  = NULL;
                    $value[] = $match[VAR_DUMP_PREG_KEY];
                    break;

// String
                //========
                // - Set the countdown (remaining number of chars before eol) =
                //   len of the string - matched len + 1 (final ")

case VAR_DUMP_PREG_STRING_TYPE:
                case VAR_DUMP_PREG_STRING_LENGTH:
                case VAR_DUMP_PREG_STRING_VALUE:
                    $countdown =
                        $match[VAR_DUMP_PREG_STRING_LENGTH]
                        - strlen($match[VAR_DUMP_PREG_STRING_VALUE])
                        + 1;
                    $family[] = VAR_DUMP_FINISH_STRING;
                    $depth[] = strlen($match[VAR_DUMP_PREG_SPACES]) >> 1;
                    $type[] = $match[VAR_DUMP_PREG_STRING_TYPE];
                    if ($countdown == 0) {
                        $value[] = substr($match[VAR_DUMP_PREG_STRING_VALUE], 0, -1);
                    } else {
                        $value[] = $match[VAR_DUMP_PREG_STRING_VALUE];
                    }
                    break;

// String (additional lines)
                //===========================
                // - Compute new countdown value
                // - Pop value off the end of the array, and concatenate new value
                // - Last additional line : remove trailing "
                // - Push new value onto the end of array

case VAR_DUMP_PREG_STRING_COMPL:
                    if ($countdown > 0) {
                        $countdown -= strlen($match[VAR_DUMP_PREG_MATCH]) + 1;
                        $new_value =
                            array_pop($value) . "\n" .
                            $match[VAR_DUMP_PREG_STRING_COMPL];
                        if ($countdown == 0) {
                            $new_value = substr($new_value, 0, -1);
                        }
                        array_push($value, $new_value);
                    }
                    break;

// Value
                //=======

case VAR_DUMP_PREG_VALUE:
                case VAR_DUMP_PREG_VALUE_REFERENCE:
                case VAR_DUMP_PREG_VALUE_TYPE:
                case VAR_DUMP_PREG_VALUE_COMPL:
                case VAR_DUMP_PREG_VALUE_RESOURCE:
                    $family[] = VAR_DUMP_FINISH_ELEMENT;
                    $depth[] = strlen($match[VAR_DUMP_PREG_SPACES]) >> 1;
                    switch ($match[VAR_DUMP_PREG_VALUE_TYPE]) {
                        case 'bool':
                        case 'int':
                        case 'float':
                            $type[] =
                                $match[VAR_DUMP_PREG_VALUE_REFERENCE] .
                                $match[VAR_DUMP_PREG_VALUE_TYPE];
                            $value[] = $match[VAR_DUMP_PREG_VALUE_COMPL];
                            break;
                        case 'resource':
                            $type[] =
                                $match[VAR_DUMP_PREG_VALUE_REFERENCE] .
                                $match[VAR_DUMP_PREG_VALUE_TYPE] .
                                '(' . $match[VAR_DUMP_PREG_VALUE_RESOURCE] . ')';
                            $value[] = $match[VAR_DUMP_PREG_VALUE_COMPL];
                            break;
                        default:
                            $type[] =
                                $match[VAR_DUMP_PREG_VALUE_REFERENCE] .
                                $match[VAR_DUMP_PREG_VALUE_TYPE];
                            $value[] = NULL;
                            break;
                    }
                    break;

// String (additional line containing a single "}")
                //==================================================
                // - see "case VAR_DUMP_PREG_STRING_COMPL" just above
                //
                // OR End of array/object
                //========================
                // - Pop the maxLen of the keys off the end of the stack
                // - If the last element on the stack is an array(0) or object(0),
                //   replace it by a standard element

case VAR_DUMP_PREG_ARRAY_END:

if ($countdown > 0) {
                        // String
                        $countdown -= strlen($match[VAR_DUMP_PREG_MATCH]) + 1;
                        $new_value = array_pop($value) . "\n" . '}';
                        if ($countdown == 0) {
                            $new_value = substr($new_value, 0, -1);
                        }
                        array_push($value, $new_value);
                    } else {
                        // End of array/object
                        $oldLen = array_pop($stackLen);
                        $keyLen[$oldLen[0]] = $maxLen;
                        $maxLen = $oldLen[1];
                        if (
                            ($family[count($family) - 1] == VAR_DUMP_START_GROUP)
                                and
                            ($type[count($type) - 1] === 0)
                        ) {
                            $family[count($family) - 1] = VAR_DUMP_FINISH_ELEMENT;
                            $type[count($type) - 1] = $value[count($value) - 1];
                            $value[count($value) - 1] = NULL;
                        } else {
                            $family[] = VAR_DUMP_FINISH_GROUP;
                            $depth[] = strlen($match[VAR_DUMP_PREG_SPACES]) >> 1;
                            $type[] = NULL;
                            $value[] = $match[VAR_DUMP_PREG_ARRAY_END];
                        }
                    }
                    break;

// Start of array/object
                //=======================
                // - If object is in the "ignore_list", jump at the end of it
                // - Else process it normally :
                //   - Push the maxLen of the keys onto the end of the stack
                //   - Initialize new maxLen to 0

case VAR_DUMP_PREG_ARRAY_START:
                case VAR_DUMP_PREG_ARRAY_TYPE:
                case VAR_DUMP_PREG_ARRAY_COUNT:
                    
                    $parse = TRUE;

// If object is in the "ignore_list", jump at the end of it.

if ($match[VAR_DUMP_PREG_ARRAY_TYPE] == 'object') {
                        $infos = $match[VAR_DUMP_PREG_ARRAY_COUNT];
                        $class_name = substr($infos, 0, strpos($infos, ')'));
                        if (
                            ! is_null($this->options['ignore_list'])
                                and
                            in_array($class_name, $this->options['ignore_list'])
                        ) {
                            $family[] = VAR_DUMP_FINISH_STRING;
                            $depth[] = strlen($match[VAR_DUMP_PREG_SPACES]) >> 1;
                            $type[] = 'object(' . $class_name . ')';
                            $value[] = 'Not parsed.';
                            while ($parse) {
                                list($dummy, $each) = each($matches);
                                if (
                                    $match[VAR_DUMP_PREG_SPACES] == $each[VAR_DUMP_PREG_SPACES]
                                        and
                                    (count($each) - 1) == VAR_DUMP_PREG_ARRAY_END
                                ) {
                                    $parse = FALSE;
                                }
                            };
                        }
                    }

// If not, process it normally.

if ($parse) {

array_push($stackLen, array(count($family), $maxLen));
                        $maxLen = 0;
                        $family[] = VAR_DUMP_START_GROUP;
                        $depth[] = strlen($match[VAR_DUMP_PREG_SPACES]) >> 1;
                        $type[] = (int) $match[VAR_DUMP_PREG_ARRAY_COUNT];
                        $value[] = $match[VAR_DUMP_PREG_ARRAY_START];

}

break;

}

$this->renderer->initialize($family, $depth, $type, $value, $keyLen);

return $this->renderer->toString();

}

/**
     * Attempt to return a concrete singleton Var_Dump instance.
     *
     * The singleton approach must be used in relationship with the
     * displayInit() and display() methods.
     * See Var_Dump/Renderer/*.php for the complete list of options
     *
     * @see Var_Dump::display(), Var_Dump::displayInit()
     * @return object Var_Dump instance
     * @access public
     */
    function & singleton()
    {
        static $instance;
        if (! isset($instance)) {
            $instance = new Var_Dump(array(), array(), array());
        }
        return $instance;
    }

/**
     * Initialise the singleton object used by the display() method.
     *
     * @see Var_Dump::singleton(), Var_Dump::display()
     * @param mixed $options String (display mode) or array (Global parameters).
     * @param array $rendererOptions Parameters for the rendering.
     * @access public
     */
    function displayInit($options = array(), $rendererOptions = array())
    {
        $displayInit = & Var_Dump::singleton();
        $displayInit->Var_Dump($options, $rendererOptions);
    }

/**
     * Outputs or returns a string representation of a variable.
     *
     * @see Var_Dump::singleton(), Var_Dump::displayInit()
     * @param mixed $expression The variable to parse.
     * @param bool $return Whether the variable should be echoed or returned.
     * @param mixed $options String (display mode) or array (Global parameters).
     * @param array $rendererOptions Parameters for the rendering.
     * @return string If returned, the string representation of the variable.
     * @access public
     */
    function display($expression, $return = FALSE, $options = NULL, $rendererOptions = NULL)
    {
        $display = & Var_Dump::singleton();
        if (! is_null($options) or ! is_null($rendererOptions)) {
            if (is_null($rendererOptions)) {
                $rendererOptions = array();
            }
            $display->Var_Dump($options, $rendererOptions);
        }
        if ($return === TRUE) {
            return $display->toString($expression);
        } else {
            echo $display->toString($expression);
        }
    }

}

${this.title}

Code Editor : Var_Dump.php