Source for file Var_Dump.php

<?php
/* vim: set expandtab tabstop=4 shiftwidth=4: */
// +----------------------------------------------------------------------+
// | PHP version 4                                                        |
// +----------------------------------------------------------------------+
// | Copyright (c) 1997-2004 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 <frederic.poeydomenge@free.fr>         |
// +----------------------------------------------------------------------+
//
// $Id:
 
require_once 'PEAR.php';
require_once 'Var_Dump/Renderer.php';
 
/**
 * 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, (X)HTML text, (X)HTML table, XML, ...
 *
 * @package Var_Dump
 * @category PHP
 * @author Frederic Poeydomenge <frederic.poeydomenge@free.fr>
 */
 
// {{{ 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_ELEMENT_NL', 6);
// }}}
 
class Var_Dump
{
 
    // {{{ properties
 
    /**
     * Run-time configuration options.
     * @var array 
     * @access public
     */
    var $options = array(
        'display_mode' => 'XHTML_Text'
    );
 
    /**
     * Rendering configuration options.
     * See Var_Dump/Renderer/*.php for the complete list of options
     * @var array 
     * @access public
     */
    var $rendererOptions = array();
 
    /**
     * Rendering object.
     * @var object 
     * @access public
     */
    var $renderer = NULL;
 
    // }}}
 
    // {{{ constructor
    /**
     * 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 array $options         Global parameters.
     * @param array $rendererOptions Parameters for the rendering.
     * @access public
     */
    function Var_Dump($options = array(), $rendererOptions = array())
        {
        $this->options = array_merge (
            $this->options,
            $options
        );
        $this->rendererOptions = $rendererOptions;
        $this->renderer = & Var_Dump_Renderer::factory(
            $this->options['display_mode'],
            $this->rendererOptions
        );
    }
    // }}}
    
    // {{{ factory()
    /**
     * 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 array $options         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;
    }
    // }}}
 
    // {{{ toString()
    /**
     * 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 (PEAR::isError($this->renderer)) {
            return '';
        }
 
        $family = array(); // element family
        $depth  = array(); // element depth
        $type   = array(); // element type
        $value  = array(); // element value
        $variation = 0;
 
        ob_start();
        var_dump($expression);
        $variable = ob_get_contents();
        ob_end_clean();
 
        // The numbers between the 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
              (?:                               # start of alternative
                (?:\[("?)(.*?)\\2\]=>)          #   = Key [2-3]
                  |                             #   OR
                (?:                             #   = Value, multiline [4-5]
                  (&?string\([0-9]*\))          #     - type [4]
                  \s+"((?:.*[^"])?$\n           #     - value [5], first line
                  (?:^.*[^"]$\n)*               #     - value [5], multiple middle line
                  ^.*)"                         #     - value [5], last line
                )                               #
                  |                             #   OR
                (                               #   = Value [6-11]
                  (&?)                          #     - reference [7]
                  (bool|string|int|float|       #     - type [8]
                  resource|NULL|\*RECURSION\*)  #
                  (?:\((.*?)\))?                #     - complement [9]
                  (?:\s+(?:                     #     - value [10-11]
                    (?:"(.*?)") |               #       . string [10] OR
                    (?:of\ type\ \((.*?)\))     #       . resource [11]
                  ))?                           #
                )                               #
                  |                             #   OR
                (})                             #   = End of array [12]
                  |                             #   OR
                (?:(&?(?:array|object).*)\ {)   #   = Start of array [13]
              )                                 # end of alternative
            $/Smx',
            $variable,
            $matches,
            PREG_SET_ORDER
        );
 
        $stack = array();
        $keyLen = array();
        $maxLen = 0;
 
        foreach($matches AS $match) {
            $count = count($match);
            if ($count>=4 and $count<=14) {
                $depth[] = strlen($match[1]) >> 1;
                switch ($count) {
                    case 4:
 
                        $len = strlen($match[3]);
                        if ($len > $maxLen) {
                            $maxLen = $len;
                        }
 
                        if (empty($match[2])) {
                            $family[] = VAR_DUMP_START_ELEMENT_NUM;
                        } else {
                            $family[] = VAR_DUMP_START_ELEMENT_STR;
                                              }
                        $type[] = NULL;
                        $value[] = $match[3];
 
                        break;
                    case 6: 
                        $variation += substr_count($match[5], "\n");
                        $family[] = VAR_DUMP_FINISH_ELEMENT_NL;
                        $type[] = $match[4];
                        $value[] = $match[5];
                        break;
                    case 7:
                    case 8:
                    case 9:
                    case 10:
                    case 11:
                    case 12:
                        $family[] = VAR_DUMP_FINISH_ELEMENT;
                        switch ($match[8]) {
                          case 'bool':
                          case 'int':
                          case 'float':
                              $type[] = $match[7] . $match[8];
                              $value[] = $match[9];
                              break;
                          case 'string':
                              $type[] = $match[7] . $match[8] . '(' . $match[9] . ')';
                              $value[] = $match[10];
                              break;
                          case 'resource':
                              $type[] = $match[7] . $match[8] . '(' . $match[11] . ')';
                              $value[] = $match[9];
                              break;
                          default:
                              $type[] = $match[7].$match[8];
                              $value[] = '';
                              break;
                        }
                        break;
                    case 13:
 
                        $oldLen = array_pop($stack);
                        $keyLen[$oldLen[0]] = $maxLen;
                        $maxLen = $oldLen[1];
 
                        $family[] = VAR_DUMP_FINISH_GROUP;
                        $type[] = NULL;
                        $value[] = $match[$count-1];
 
                        break;
                    case 14:
 
                        array_push($stack, array(count($family), $maxLen));
                        $maxLen = 0;
 
                        $family[] = VAR_DUMP_START_GROUP;
                        $type[] = NULL;
                        $value[] = $match[$count-1];
 
                        break;
                }
            }
        }
 
        // Check if there was a parse error
        if (count($matches) + $variation != count(explode("\n", $variable)) - 1) {
            PEAR::raiseError('Var_Dump: parse error, the resulting matches do not match the initial variable.', FALSE, PEAR_ERROR_TRIGGER);
        }
 
        $this->renderer->initialize($family, $depth, $type, $value, $keyLen);
                
        return $this->renderer->toString();
 
    }
    // }}}
 
    // {{{ singleton()
    /**
     * 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());
        }
        return $instance;
    }
    // }}}
 
    // {{{ displayInit()
    /**
     * Initialise the singleton object used by the display() method.
     * @see Var_Dump::singleton(), Var_Dump::display()
     * @param array $options         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);
    }
    // }}}
 
    // {{{ display()
    /**
     * 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.
     * @return string If returned, the string representation of the variable.
     * @access public
     */
    function display($expression, $return=FALSE)
    {
        $display = & Var_Dump::singleton();
        if ($return) {
            return $display->toString($expression);
        } else {
            echo $display->toString($expression);
        }
    }
    // }}}
 
}
 
?>