/common/libraries/plugin/pear/PEAR/Common.php

<?php

/**

 * PEAR_Common, the base class for the PEAR Installer

 *

 * PHP versions 4 and 5

 *

 * LICENSE: This source file is subject to version 3.0 of the PHP license

 * that is available through the world-wide-web at the following URI:

 * 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 web, please

 * send a note to license@php.net so we can mail you a copy immediately.

 *

 * @category   pear

 * @package    PEAR

 * @author     Stig Bakken <ssb@php.net>

 * @author     Tomas V. V. Cox <cox@idecnet.com>

 * @author     Greg Beaver <cellog@php.net>

 * @copyright  1997-2008 The PHP Group

 * @license    http://www.php.net/license/3_0.txt  PHP License 3.0

 * @version    CVS: $Id: Common.php 137 2009-11-09 13:24:37Z vanpouckesven $

 * @link       http://pear.php.net/package/PEAR

 * @since      File available since Release 0.1.0

 * @deprecated File deprecated since Release 1.4.0a1

 */



/**

 * Include error handling

 */

require_once 'PEAR.php';



// {{{ constants and globals





/**

 * PEAR_Common error when an invalid PHP file is passed to PEAR_Common::analyzeSourceCode()

 */

define('PEAR_COMMON_ERROR_INVALIDPHP', 1);

define('_PEAR_COMMON_PACKAGE_NAME_PREG', '[A-Za-z][a-zA-Z0-9_]+');

define('PEAR_COMMON_PACKAGE_NAME_PREG', '/^' . _PEAR_COMMON_PACKAGE_NAME_PREG . '\\z/');



// this should allow: 1, 1.0, 1.0RC1, 1.0dev, 1.0dev123234234234, 1.0a1, 1.0b1, 1.0pl1

define('_PEAR_COMMON_PACKAGE_VERSION_PREG', '\d+(?:\.\d+)*(?:[a-zA-Z]+\d*)?');

define('PEAR_COMMON_PACKAGE_VERSION_PREG', '/^' . _PEAR_COMMON_PACKAGE_VERSION_PREG . '\\z/i');



// XXX far from perfect :-)

define('_PEAR_COMMON_PACKAGE_DOWNLOAD_PREG', '(' . _PEAR_COMMON_PACKAGE_NAME_PREG . ')(-([.0-9a-zA-Z]+))?');

define('PEAR_COMMON_PACKAGE_DOWNLOAD_PREG', '/^' . _PEAR_COMMON_PACKAGE_DOWNLOAD_PREG . '\\z/');



define('_PEAR_CHANNELS_NAME_PREG', '[A-Za-z][a-zA-Z0-9\.]+');

define('PEAR_CHANNELS_NAME_PREG', '/^' . _PEAR_CHANNELS_NAME_PREG . '\\z/');



// this should allow any dns or IP address, plus a path - NO UNDERSCORES ALLOWED

define('_PEAR_CHANNELS_SERVER_PREG', '[a-zA-Z0-9\-]+(?:\.[a-zA-Z0-9\-]+)*(\/[a-zA-Z0-9\-]+)*');

define('PEAR_CHANNELS_SERVER_PREG', '/^' . _PEAR_CHANNELS_SERVER_PREG . '\\z/i');



define('_PEAR_CHANNELS_PACKAGE_PREG', '(' . _PEAR_CHANNELS_SERVER_PREG . ')\/(' . _PEAR_COMMON_PACKAGE_NAME_PREG . ')');

define('PEAR_CHANNELS_PACKAGE_PREG', '/^' . _PEAR_CHANNELS_PACKAGE_PREG . '\\z/i');



define('_PEAR_COMMON_CHANNEL_DOWNLOAD_PREG', '(' . _PEAR_CHANNELS_NAME_PREG . ')::(' . _PEAR_COMMON_PACKAGE_NAME_PREG . ')(-([.0-9a-zA-Z]+))?');

define('PEAR_COMMON_CHANNEL_DOWNLOAD_PREG', '/^' . _PEAR_COMMON_CHANNEL_DOWNLOAD_PREG . '\\z/');



/**

 * List of temporary files and directories registered by

 * PEAR_Common::addTempFile().

 * @var array

 */

$GLOBALS['_PEAR_Common_tempfiles'] = array();



/**

 * Valid maintainer roles

 * @var array

 */

$GLOBALS['_PEAR_Common_maintainer_roles'] = array('lead', 'developer', 'contributor', 'helper');



/**

 * Valid release states

 * @var array

 */

$GLOBALS['_PEAR_Common_release_states'] = array('alpha', 'beta', 'stable', 'snapshot', 'devel');



/**

 * Valid dependency types

 * @var array

 */

$GLOBALS['_PEAR_Common_dependency_types'] = array('pkg', 'ext', 'php', 'prog', 'ldlib', 'rtlib', 'os', 'websrv', 'sapi');



/**

 * Valid dependency relations

 * @var array

 */

$GLOBALS['_PEAR_Common_dependency_relations'] = array('has', 'eq', 'lt', 'le', 'gt', 'ge', 'not', 'ne');



/**

 * Valid file roles

 * @var array

 */

$GLOBALS['_PEAR_Common_file_roles'] = array('php', 'ext', 'test', 'doc', 'data', 'src', 'script');



/**

 * Valid replacement types

 * @var array

 */

$GLOBALS['_PEAR_Common_replacement_types'] = array('php-const', 'pear-config', 'package-info');



/**

 * Valid "provide" types

 * @var array

 */

$GLOBALS['_PEAR_Common_provide_types'] = array('ext', 'prog', 'class', 'function', 'feature', 'api');



/**

 * Valid "provide" types

 * @var array

 */

$GLOBALS['_PEAR_Common_script_phases'] = array('pre-install', 'post-install', 'pre-uninstall', 'post-uninstall', 

        'pre-build', 'post-build', 'pre-configure', 'post-configure', 'pre-setup', 'post-setup');



// }}}





/**

 * Class providing common functionality for PEAR administration classes.

 * @category   pear

 * @package    PEAR

 * @author     Stig Bakken <ssb@php.net>

 * @author     Tomas V. V. Cox <cox@idecnet.com>

 * @author     Greg Beaver <cellog@php.net>

 * @copyright  1997-2008 The PHP Group

 * @license    http://www.php.net/license/3_0.txt  PHP License 3.0

 * @version    Release: 1.7.2

 * @link       http://pear.php.net/package/PEAR

 * @since      Class available since Release 1.4.0a1

 * @deprecated This class will disappear, and its components will be spread

 * into smaller classes, like the AT&T breakup, as of Release 1.4.0a1

 */

class PEAR_Common extends PEAR

{

    // {{{ properties

    



    /** stack of elements, gives some sort of XML context */

    var $element_stack = array();

    

    /** name of currently parsed XML element */

    var $current_element;

    

    /** array of attributes of the currently parsed XML element */

    var $current_attributes = array();

    

    /** assoc with information about a package */

    var $pkginfo = array();

    

    /**

     * User Interface object (PEAR_Frontend_* class).  If null,

     * the log() method uses print.

     * @var object

     */

    var $ui = null;

    

    /**

     * Configuration object (PEAR_Config).

     * @var PEAR_Config

     */

    var $config = null;

    

    var $current_path = null;

    

    /**

     * PEAR_SourceAnalyzer instance

     * @var object

     */

    var $source_analyzer = null;

    /**

     * Flag variable used to mark a valid package file

     * @var boolean

     * @access private

     */

    var $_validPackageFile;



    // }}}

    



    // {{{ constructor

    



    /**

     * PEAR_Common constructor

     *

     * @access public

     */

    function __construct()

    {

        parent :: __construct();

        $this->config = &PEAR_Config :: singleton();

        $this->debug = $this->config->get('verbose');

    }



    // }}}

    // {{{ destructor

    



    /**

     * PEAR_Common destructor

     *

     * @access private

     */

    function _PEAR_Common()

    {

        // doesn't work due to bug #14744

        //$tempfiles = $this->_tempfiles;

        $tempfiles = & $GLOBALS['_PEAR_Common_tempfiles'];

        while ($file = array_shift($tempfiles))

        {

            if (@is_dir($file))

            {

                if (! class_exists('System'))

                {

                    require_once 'System.php';

                }

                System :: rm(array('-rf', $file));

            }

            elseif (file_exists($file))

            {

                unlink($file);

            }

        }

    }



    // }}}

    // {{{ addTempFile()

    



    /**

     * Register a temporary file or directory.  When the destructor is

     * executed, all registered temporary files and directories are

     * removed.

     *

     * @param string  $file  name of file or directory

     *

     * @return void

     *

     * @access public

     */

    function addTempFile($file)

    {

        if (! class_exists('PEAR_Frontend'))

        {

            require_once 'PEAR/Frontend.php';

        }

        PEAR_Frontend :: addTempFile($file);

    }



    // }}}

    // {{{ mkDirHier()

    



    /**

     * Wrapper to System::mkDir(), creates a directory as well as

     * any necessary parent directories.

     *

     * @param string  $dir  directory name

     *

     * @return bool TRUE on success, or a PEAR error

     *

     * @access public

     */

    function mkDirHier($dir)

    {

        $this->log(2, "+ create dir $dir");

        if (! class_exists('System'))

        {

            require_once 'System.php';

        }

        return System :: mkDir(array('-p', $dir));

    }



    // }}}

    // {{{ log()

    



    /**

     * Logging method.

     *

     * @param int    $level  log level (0 is quiet, higher is noisier)

     * @param string $msg    message to write to the log

     *

     * @return void

     *

     * @access public

     * @static

     */

    function log($level, $msg, $append_crlf = true)

    {

        if ($this->debug >= $level)

        {

            if (! class_exists('PEAR_Frontend'))

            {

                require_once 'PEAR/Frontend.php';

            }

            $ui = &PEAR_Frontend :: singleton();

            if (is_a($ui, 'PEAR_Frontend'))

            {

                $ui->log($msg, $append_crlf);

            }

            else

            {

                print "$msg\n";

            }

        }

    }



    // }}}

    // {{{ mkTempDir()

    



    /**

     * Create and register a temporary directory.

     *

     * @param string $tmpdir (optional) Directory to use as tmpdir.

     * Will use system defaults (for example

     * /tmp or c:\windows\temp) if not specified

     *

     * @return string name of created directory

     *

     * @access public

     */

    function mkTempDir($tmpdir = '')

    {

        if ($tmpdir)

        {

            $topt = array('-t', $tmpdir);

        }

        else

        {

            $topt = array();

        }

        $topt = array_merge($topt, array('-d', 'pear'));

        if (! class_exists('System'))

        {

            require_once 'System.php';

        }

        if (! $tmpdir = System :: mktemp($topt))

        {

            return false;

        }

        $this->addTempFile($tmpdir);

        return $tmpdir;

    }



    // }}}

    // {{{ setFrontendObject()

    



    /**

     * Set object that represents the frontend to be used.

     *

     * @param  object Reference of the frontend object

     * @return void

     * @access public

     */

    function setFrontendObject(&$ui)

    {

        $this->ui = &$ui;

    }



    // }}}

    



    // {{{ infoFromTgzFile()

    



    /**

     * Returns information about a package file.  Expects the name of

     * a gzipped tar file as input.

     *

     * @param string  $file  name of .tgz file

     *

     * @return array  array with package information

     *

     * @access public

     * @deprecated use PEAR_PackageFile->fromTgzFile() instead

     *

     */

    function infoFromTgzFile($file)

    {

        $packagefile = &new PEAR_PackageFile($this->config);

        $pf = &$packagefile->fromTgzFile($file, PEAR_VALIDATE_NORMAL);

        if (PEAR :: isError($pf))

        {

            $errs = $pf->getUserinfo();

            if (is_array($errs))

            {

                foreach ($errs as $error)

                {

                    $e = $this->raiseError($error['message'], $error['code'], null, null, $error);

                }

            }

            return $pf;

        }

        return $this->_postProcessValidPackagexml($pf);

    }



    // }}}

    // {{{ infoFromDescriptionFile()

    



    /**

     * Returns information about a package file.  Expects the name of

     * a package xml file as input.

     *

     * @param string  $descfile  name of package xml file

     *

     * @return array  array with package information

     *

     * @access public

     * @deprecated use PEAR_PackageFile->fromPackageFile() instead

     *

     */

    function infoFromDescriptionFile($descfile)

    {

        $packagefile = &new PEAR_PackageFile($this->config);

        $pf = &$packagefile->fromPackageFile($descfile, PEAR_VALIDATE_NORMAL);

        if (PEAR :: isError($pf))

        {

            $errs = $pf->getUserinfo();

            if (is_array($errs))

            {

                foreach ($errs as $error)

                {

                    $e = $this->raiseError($error['message'], $error['code'], null, null, $error);

                }

            }

            return $pf;

        }

        return $this->_postProcessValidPackagexml($pf);

    }



    // }}}

    // {{{ infoFromString()

    



    /**

     * Returns information about a package file.  Expects the contents

     * of a package xml file as input.

     *

     * @param string  $data  contents of package.xml file

     *

     * @return array   array with package information

     *

     * @access public

     * @deprecated use PEAR_PackageFile->fromXmlstring() instead

     *

     */

    function infoFromString($data)

    {

        $packagefile = &new PEAR_PackageFile($this->config);

        $pf = &$packagefile->fromXmlString($data, PEAR_VALIDATE_NORMAL, false);

        if (PEAR :: isError($pf))

        {

            $errs = $pf->getUserinfo();

            if (is_array($errs))

            {

                foreach ($errs as $error)

                {

                    $e = $this->raiseError($error['message'], $error['code'], null, null, $error);

                }

            }

            return $pf;

        }

        return $this->_postProcessValidPackagexml($pf);

    }



    // }}}

    



    /**

     * @param PEAR_PackageFile_v1|PEAR_PackageFile_v2

     * @return array

     */

    function _postProcessValidPackagexml(&$pf)

    {

        if (is_a($pf, 'PEAR_PackageFile_v2'))

        {

            // sort of make this into a package.xml 1.0-style array

            // changelog is not converted to old format.

            $arr = $pf->toArray(true);

            $arr = array_merge($arr, $arr['old']);

            unset($arr['old']);

            unset($arr['xsdversion']);

            unset($arr['contents']);

            unset($arr['compatible']);

            unset($arr['channel']);

            unset($arr['uri']);

            unset($arr['dependencies']);

            unset($arr['phprelease']);

            unset($arr['extsrcrelease']);

            unset($arr['zendextsrcrelease']);

            unset($arr['extbinrelease']);

            unset($arr['zendextbinrelease']);

            unset($arr['bundle']);

            unset($arr['lead']);

            unset($arr['developer']);

            unset($arr['helper']);

            unset($arr['contributor']);

            $arr['filelist'] = $pf->getFilelist();

            $this->pkginfo = $arr;

            return $arr;

        }

        else

        {

            $this->pkginfo = $pf->toArray();

            return $this->pkginfo;

        }

    }



    // {{{ infoFromAny()

    



    /**

     * Returns package information from different sources

     *

     * This method is able to extract information about a package

     * from a .tgz archive or from a XML package definition file.

     *

     * @access public

     * @param  string Filename of the source ('package.xml', '<package>.tgz')

     * @return string

     * @deprecated use PEAR_PackageFile->fromAnyFile() instead

     */

    function infoFromAny($info)

    {

        if (is_string($info) && file_exists($info))

        {

            $packagefile = &new PEAR_PackageFile($this->config);

            $pf = &$packagefile->fromAnyFile($info, PEAR_VALIDATE_NORMAL);

            if (PEAR :: isError($pf))

            {

                $errs = $pf->getUserinfo();

                if (is_array($errs))

                {

                    foreach ($errs as $error)

                    {

                        $e = $this->raiseError($error['message'], $error['code'], null, null, $error);

                    }

                }

                return $pf;

            }

            return $this->_postProcessValidPackagexml($pf);

        }

        return $info;

    }



    // }}}

    // {{{ xmlFromInfo()

    



    /**

     * Return an XML document based on the package info (as returned

     * by the PEAR_Common::infoFrom* methods).

     *

     * @param array  $pkginfo  package info

     *

     * @return string XML data

     *

     * @access public

     * @deprecated use a PEAR_PackageFile_v* object's generator instead

     */

    function xmlFromInfo($pkginfo)

    {

        $config = &PEAR_Config :: singleton();

        $packagefile = &new PEAR_PackageFile($config);

        $pf = &$packagefile->fromArray($pkginfo);

        $gen = &$pf->getDefaultGenerator();

        return $gen->toXml(PEAR_VALIDATE_PACKAGING);

    }



    // }}}

    // {{{ validatePackageInfo()

    



    /**

     * Validate XML package definition file.

     *

     * @param  string $info Filename of the package archive or of the

     * package definition file

     * @param  array $errors Array that will contain the errors

     * @param  array $warnings Array that will contain the warnings

     * @param  string $dir_prefix (optional) directory where source files

     * may be found, or empty if they are not available

     * @access public

     * @return boolean

     * @deprecated use the validation of PEAR_PackageFile objects

     */

    function validatePackageInfo($info, &$errors, &$warnings, $dir_prefix = '')

    {

        $config = &PEAR_Config :: singleton();

        $packagefile = &new PEAR_PackageFile($config);

        PEAR :: staticPushErrorHandling(PEAR_ERROR_RETURN);

        if (strpos($info, '<?xml') !== false)

        {

            $pf = &$packagefile->fromXmlString($info, PEAR_VALIDATE_NORMAL, '');

        }

        else

        {

            $pf = &$packagefile->fromAnyFile($info, PEAR_VALIDATE_NORMAL);

        }

        PEAR :: staticPopErrorHandling();

        if (PEAR :: isError($pf))

        {

            $errs = $pf->getUserinfo();

            if (is_array($errs))

            {

                foreach ($errs as $error)

                {

                    if ($error['level'] == 'error')

                    {

                        $errors[] = $error['message'];

                    }

                    else

                    {

                        $warnings[] = $error['message'];

                    }

                }

            }

            return false;

        }

        return true;

    }



    // }}}

    // {{{ buildProvidesArray()

    



    /**

     * Build a "provides" array from data returned by

     * analyzeSourceCode().  The format of the built array is like

     * this:

     *

     * array(

     * 'class;MyClass' => 'array('type' => 'class', 'name' => 'MyClass'),

     * ...

     * )

     *

     *

     * @param array $srcinfo array with information about a source file

     * as returned by the analyzeSourceCode() method.

     *

     * @return void

     *

     * @access public

     *

     */

    function buildProvidesArray($srcinfo)

    {

        $file = basename($srcinfo['source_file']);

        $pn = '';

        if (isset($this->_packageName))

        {

            $pn = $this->_packageName;

        }

        $pnl = strlen($pn);

        foreach ($srcinfo['declared_classes'] as $class)

        {

            $key = "class;$class";

            if (isset($this->pkginfo['provides'][$key]))

            {

                continue;

            }

            $this->pkginfo['provides'][$key] = array('file' => $file, 'type' => 'class', 'name' => $class);

            if (isset($srcinfo['inheritance'][$class]))

            {

                $this->pkginfo['provides'][$key]['extends'] = $srcinfo['inheritance'][$class];

            }

        }

        foreach ($srcinfo['declared_methods'] as $class => $methods)

        {

            foreach ($methods as $method)

            {

                $function = "$class::$method";

                $key = "function;$function";

                if ($method{0} == '_' || ! strcasecmp($method, $class) || isset($this->pkginfo['provides'][$key]))

                {

                    continue;

                }

                $this->pkginfo['provides'][$key] = array('file' => $file, 'type' => 'function', 'name' => $function);

            }

        }

        

        foreach ($srcinfo['declared_functions'] as $function)

        {

            $key = "function;$function";

            if ($function{0} == '_' || isset($this->pkginfo['provides'][$key]))

            {

                continue;

            }

            if (! strstr($function, '::') && strncasecmp($function, $pn, $pnl))

            {

                $warnings[] = "in1 " . $file . ": function \"$function\" not prefixed with package name \"$pn\"";

            }

            $this->pkginfo['provides'][$key] = array('file' => $file, 'type' => 'function', 'name' => $function);

        }

    }



    // }}}

    // {{{ analyzeSourceCode()

    



    /**

     * Analyze the source code of the given PHP file

     *

     * @param  string Filename of the PHP file

     * @return mixed

     * @access public

     */

    function analyzeSourceCode($file)

    {

        if (! function_exists("token_get_all"))

        {

            return false;

        }

        if (! defined('T_DOC_COMMENT'))

        {

            define('T_DOC_COMMENT', T_COMMENT);

        }

        if (! defined('T_INTERFACE'))

        {

            define('T_INTERFACE', - 1);

        }

        if (! defined('T_IMPLEMENTS'))

        {

            define('T_IMPLEMENTS', - 1);

        }

        if (! $fp = @fopen($file, "r"))

        {

            return false;

        }

        fclose($fp);

        $contents = file_get_contents($file);

        $tokens = token_get_all($contents);

        /*

        for ($i = 0; $i < sizeof($tokens); $i++) {

            @list($token, $data) = $tokens[$i];

            if (is_string($token)) {

                var_dump($token);

            } else {

                print token_name($token) . ' ';

                var_dump(rtrim($data));

            }

        }

*/

        $look_for = 0;

        $paren_level = 0;

        $bracket_level = 0;

        $brace_level = 0;

        $lastphpdoc = '';

        $current_class = '';

        $current_interface = '';

        $current_class_level = - 1;

        $current_function = '';

        $current_function_level = - 1;

        $declared_classes = array();

        $declared_interfaces = array();

        $declared_functions = array();

        $declared_methods = array();

        $used_classes = array();

        $used_functions = array();

        $extends = array();

        $implements = array();

        $nodeps = array();

        $inquote = false;

        $interface = false;

        for($i = 0; $i < sizeof($tokens); $i ++)

        {

            if (is_array($tokens[$i]))

            {

                list($token, $data) = $tokens[$i];

            }

            else

            {

                $token = $tokens[$i];

                $data = '';

            }

            if ($inquote)

            {

                if ($token != '"')

                {

                    continue;

                }

                else

                {

                    $inquote = false;

                    continue;

                }

            }

            switch ($token)

            {

                case T_WHITESPACE :

                    continue;

                case ';' :

                    if ($interface)

                    {

                        $current_function = '';

                        $current_function_level = - 1;

                    }

                    break;

                case '"' :

                    $inquote = true;

                    break;

                case T_CURLY_OPEN :

                case T_DOLLAR_OPEN_CURLY_BRACES :

                case '{' :

                    $brace_level ++;

                    continue 2;

                case '}' :

                    $brace_level --;

                    if ($current_class_level == $brace_level)

                    {

                        $current_class = '';

                        $current_class_level = - 1;

                    }

                    if ($current_function_level == $brace_level)

                    {

                        $current_function = '';

                        $current_function_level = - 1;

                    }

                    continue 2;

                case '[' :

                    $bracket_level ++;

                    continue 2;

                case ']' :

                    $bracket_level --;

                    continue 2;

                case '(' :

                    $paren_level ++;

                    continue 2;

                case ')' :

                    $paren_level --;

                    continue 2;

                case T_INTERFACE :

                    $interface = true;

                case T_CLASS :

                    if (($current_class_level != - 1) || ($current_function_level != - 1))

                    {

                        PEAR :: raiseError("Parser error: invalid PHP found in file \"$file\"", PEAR_COMMON_ERROR_INVALIDPHP);

                        return false;

                    }

                case T_FUNCTION :

                case T_NEW :

                case T_EXTENDS :

                case T_IMPLEMENTS :

                    $look_for = $token;

                    continue 2;

                case T_STRING :

                    if (version_compare(zend_version(), '2.0', '<'))

                    {

                        if (in_array(strtolower($data), array('public', 'private', 'protected', 'abstract', 

                                'interface', 'implements', 'throw')))

                        {

                            PEAR :: raiseError('Error: PHP5 token encountered in ' . $file . 'packaging should be done in PHP 5');

                            return false;

                        }

                    }

                    if ($look_for == T_CLASS)

                    {

                        $current_class = $data;

                        $current_class_level = $brace_level;

                        $declared_classes[] = $current_class;

                    }

                    elseif ($look_for == T_INTERFACE)

                    {

                        $current_interface = $data;

                        $current_class_level = $brace_level;

                        $declared_interfaces[] = $current_interface;

                    }

                    elseif ($look_for == T_IMPLEMENTS)

                    {

                        $implements[$current_class] = $data;

                    }

                    elseif ($look_for == T_EXTENDS)

                    {

                        $extends[$current_class] = $data;

                    }

                    elseif ($look_for == T_FUNCTION)

                    {

                        if ($current_class)

                        {

                            $current_function = "$current_class::$data";

                            $declared_methods[$current_class][] = $data;

                        }

                        elseif ($current_interface)

                        {

                            $current_function = "$current_interface::$data";

                            $declared_methods[$current_interface][] = $data;

                        }

                        else

                        {

                            $current_function = $data;

                            $declared_functions[] = $current_function;

                        }

                        $current_function_level = $brace_level;

                        $m = array();

                    }

                    elseif ($look_for == T_NEW)

                    {

                        $used_classes[$data] = true;

                    }

                    $look_for = 0;

                    continue 2;

                case T_VARIABLE :

                    $look_for = 0;

                    continue 2;

                case T_DOC_COMMENT :

                case T_COMMENT :

                    if (preg_match('!^/\*\*\s!', $data))

                    {

                        $lastphpdoc = $data;

                        if (preg_match_all('/@nodep\s+(\S+)/', $lastphpdoc, $m))

                        {

                            $nodeps = array_merge($nodeps, $m[1]);

                        }

                    }

                    continue 2;

                case T_DOUBLE_COLON :

                    if (! ($tokens[$i - 1][0] == T_WHITESPACE || $tokens[$i - 1][0] == T_STRING))

                    {

                        PEAR :: raiseError("Parser error: invalid PHP found in file \"$file\"", PEAR_COMMON_ERROR_INVALIDPHP);

                        return false;

                    }

                    $class = $tokens[$i - 1][1];

                    if (strtolower($class) != 'parent')

                    {

                        $used_classes[$class] = true;

                    }

                    continue 2;

            }

        }

        return array("source_file" => $file, "declared_classes" => $declared_classes, 

                "declared_interfaces" => $declared_interfaces, "declared_methods" => $declared_methods, 

                "declared_functions" => $declared_functions, 

                "used_classes" => array_diff(array_keys($used_classes), $nodeps), "inheritance" => $extends, 

                "implements" => $implements);

    }



    // }}}

    // {{{  betterStates()

    



    /**

     * Return an array containing all of the states that are more stable than

     * or equal to the passed in state

     *

     * @param string Release state

     * @param boolean Determines whether to include $state in the list

     * @return false|array False if $state is not a valid release state

     */

    function betterStates($state, $include = false)

    {

        static $states = array('snapshot', 'devel', 'alpha', 'beta', 'stable');

        $i = array_search($state, $states);

        if ($i === false)

        {

            return false;

        }

        if ($include)

        {

            $i --;

        }

        return array_slice($states, $i + 1);

    }



    // }}}

    // {{{ detectDependencies()

    



    function detectDependencies($any, $status_callback = null)

    {

        if (! function_exists("token_get_all"))

        {

            return false;

        }

        if (PEAR :: isError($info = $this->infoFromAny($any)))

        {

            return $this->raiseError($info);

        }

        if (! is_array($info))

        {

            return false;

        }

        $deps = array();

        $used_c = $decl_c = $decl_f = $decl_m = array();

        foreach ($info['filelist'] as $file => $fa)

        {

            $tmp = $this->analyzeSourceCode($file);

            $used_c = @array_merge($used_c, $tmp['used_classes']);

            $decl_c = @array_merge($decl_c, $tmp['declared_classes']);

            $decl_f = @array_merge($decl_f, $tmp['declared_functions']);

            $decl_m = @array_merge($decl_m, $tmp['declared_methods']);

            $inheri = @array_merge($inheri, $tmp['inheritance']);

        }

        $used_c = array_unique($used_c);

        $decl_c = array_unique($decl_c);

        $undecl_c = array_diff($used_c, $decl_c);

        return array('used_classes' => $used_c, 'declared_classes' => $decl_c, 'declared_methods' => $decl_m, 

                'declared_functions' => $decl_f, 'undeclared_classes' => $undecl_c, 'inheritance' => $inheri);

    }



    // }}}

    // {{{ getUserRoles()

    



    /**

     * Get the valid roles for a PEAR package maintainer

     *

     * @return array

     * @static

     */

    function getUserRoles()

    {

        return $GLOBALS['_PEAR_Common_maintainer_roles'];

    }



    // }}}

    // {{{ getReleaseStates()

    



    /**

     * Get the valid package release states of packages

     *

     * @return array

     * @static

     */

    function getReleaseStates()

    {

        return $GLOBALS['_PEAR_Common_release_states'];

    }



    // }}}

    // {{{ getDependencyTypes()

    



    /**

     * Get the implemented dependency types (php, ext, pkg etc.)

     *

     * @return array

     * @static

     */

    function getDependencyTypes()

    {

        return $GLOBALS['_PEAR_Common_dependency_types'];

    }



    // }}}

    // {{{ getDependencyRelations()

    



    /**

     * Get the implemented dependency relations (has, lt, ge etc.)

     *

     * @return array

     * @static

     */

    function getDependencyRelations()

    {

        return $GLOBALS['_PEAR_Common_dependency_relations'];

    }



    // }}}

    // {{{ getFileRoles()

    



    /**

     * Get the implemented file roles

     *

     * @return array

     * @static

     */

    function getFileRoles()

    {

        return $GLOBALS['_PEAR_Common_file_roles'];

    }



    // }}}

    // {{{ getReplacementTypes()

    



    /**

     * Get the implemented file replacement types in

     *

     * @return array

     * @static

     */

    function getReplacementTypes()

    {

        return $GLOBALS['_PEAR_Common_replacement_types'];

    }



    // }}}

    // {{{ getProvideTypes()

    



    /**

     * Get the implemented file replacement types in

     *

     * @return array

     * @static

     */

    function getProvideTypes()

    {

        return $GLOBALS['_PEAR_Common_provide_types'];

    }



    // }}}

    // {{{ getScriptPhases()

    



    /**

     * Get the implemented file replacement types in

     *

     * @return array

     * @static

     */

    function getScriptPhases()

    {

        return $GLOBALS['_PEAR_Common_script_phases'];

    }



    // }}}

    // {{{ validPackageName()

    



    /**

     * Test whether a string contains a valid package name.

     *

     * @param string $name the package name to test

     *

     * @return bool

     *

     * @access public

     */

    function validPackageName($name)

    {

        return (bool) preg_match(PEAR_COMMON_PACKAGE_NAME_PREG, $name);

    }



    // }}}

    // {{{ validPackageVersion()

    



    /**

     * Test whether a string contains a valid package version.

     *

     * @param string $ver the package version to test

     *

     * @return bool

     *

     * @access public

     */

    function validPackageVersion($ver)

    {

        return (bool) preg_match(PEAR_COMMON_PACKAGE_VERSION_PREG, $ver);

    }



    // }}}

    



    // {{{ downloadHttp()

    



    /**

     * Download a file through HTTP.  Considers suggested file name in

     * Content-disposition: header and can run a callback function for

     * different events.  The callback will be called with two

     * parameters: the callback type, and parameters.  The implemented

     * callback types are:

     *

     * 'setup'       called at the very beginning, parameter is a UI object

     * that should be used for all output

     * 'message'     the parameter is a string with an informational message

     * 'saveas'      may be used to save with a different file name, the

     * parameter is the filename that is about to be used.

     * If a 'saveas' callback returns a non-empty string,

     * that file name will be used as the filename instead.

     * Note that $save_dir will not be affected by this, only

     * the basename of the file.

     * 'start'       download is starting, parameter is number of bytes

     * that are expected, or -1 if unknown

     * 'bytesread'   parameter is the number of bytes read so far

     * 'done'        download is complete, parameter is the total number

     * of bytes read

     * 'connfailed'  if the TCP connection fails, this callback is called

     * with array(host,port,errno,errmsg)

     * 'writefailed' if writing to disk fails, this callback is called

     * with array(destfile,errmsg)

     *

     * If an HTTP proxy has been configured (http_proxy PEAR_Config

     * setting), the proxy will be used.

     *

     * @param string  $url       the URL to download

     * @param object  $ui        PEAR_Frontend_* instance

     * @param object  $config    PEAR_Config instance

     * @param string  $save_dir  (optional) directory to save file in

     * @param mixed   $callback  (optional) function/method to call for status

     * updates

     *

     * @return string  Returns the full path of the downloaded file or a PEAR

     * error on failure.  If the error is caused by

     * socket-related errors, the error object will

     * have the fsockopen error code available through

     * getCode().

     *

     * @access public

     * @deprecated in favor of PEAR_Downloader::downloadHttp()

     */

    function downloadHttp($url, &$ui, $save_dir = '.', $callback = null)

    {

        if (! class_exists('PEAR_Downloader'))

        {

            require_once 'PEAR/Downloader.php';

        }

        return PEAR_Downloader :: downloadHttp($url, $ui, $save_dir, $callback);

    }



    // }}}

    



    /**

     * @param string $path relative or absolute include path

     * @return boolean

     * @static

     */

    function isIncludeable($path)

    {

        if (file_exists($path) && is_readable($path))

        {

            return true;

        }

        $ipath = explode(PATH_SEPARATOR, ini_get('include_path'));

        foreach ($ipath as $include)

        {

            $test = realpath($include . DIRECTORY_SEPARATOR . $path);

            if (file_exists($test) && is_readable($test))

            {

                return true;

            }

        }

        return false;

    }

}

require_once 'PEAR/Config.php';

require_once 'PEAR/PackageFile.php';

?>