1926 lines
68 KiB
PHP
1926 lines
68 KiB
PHP
<?php
|
|
/**
|
|
* Copyright (c) 2008-2009, Davey Shafik <davey@php.net>
|
|
* Laurent Laville <pear@laurent-laville.org>
|
|
*
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of the authors nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
|
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* PHP versions 4 and 5
|
|
*
|
|
* @category PHP
|
|
* @package PHP_CompatInfo
|
|
* @author Davey Shafik <davey@php.net>
|
|
* @author Laurent Laville <pear@laurent-laville.org>
|
|
* @license http://www.opensource.org/licenses/bsd-license.php BSD
|
|
* @version CVS: $Id: Parser.php,v 1.21 2009/01/02 10:18:47 farell Exp $
|
|
* @link http://pear.php.net/package/PHP_CompatInfo
|
|
* @since File available since Release 1.8.0b2
|
|
*/
|
|
|
|
require_once 'Event/Dispatcher.php';
|
|
require_once 'File/Find.php';
|
|
|
|
/**
|
|
* An array of class init versions and extension
|
|
*/
|
|
require_once 'PHP/CompatInfo/class_array.php';
|
|
|
|
/**
|
|
* An array of function init versions and extension
|
|
*/
|
|
require_once 'PHP/CompatInfo/func_array.php';
|
|
|
|
/**
|
|
* An array of constants and their init versions
|
|
*/
|
|
require_once 'PHP/CompatInfo/const_array.php';
|
|
|
|
/**
|
|
* An abstract base class for CompatInfo renderers
|
|
*/
|
|
require_once 'PHP/CompatInfo/Renderer.php';
|
|
|
|
/**
|
|
* Event name of parsing data source start process
|
|
*/
|
|
define('PHP_COMPATINFO_EVENT_AUDITSTARTED', 'auditStarted');
|
|
/**
|
|
* Event name of parsing data source end process
|
|
*/
|
|
define('PHP_COMPATINFO_EVENT_AUDITFINISHED', 'auditFinished');
|
|
/**
|
|
* Event name of parsing a file start process
|
|
*/
|
|
define('PHP_COMPATINFO_EVENT_FILESTARTED', 'fileStarted');
|
|
/**
|
|
* Event name of parsing a file end process
|
|
*/
|
|
define('PHP_COMPATINFO_EVENT_FILEFINISHED', 'fileFinished');
|
|
/**
|
|
* Event name of parsing a file start process
|
|
*/
|
|
define('PHP_COMPATINFO_EVENT_CODESTARTED', 'codeStarted');
|
|
/**
|
|
* Event name of parsing a file end process
|
|
*/
|
|
define('PHP_COMPATINFO_EVENT_CODEFINISHED', 'codeFinished');
|
|
|
|
/**
|
|
* Parser logic
|
|
*
|
|
* This class is the model in the MVC design pattern of API 1.8.0 (since beta 2)
|
|
*
|
|
* @category PHP
|
|
* @package PHP_CompatInfo
|
|
* @author Laurent Laville <pear@laurent-laville.org>
|
|
* @license http://www.opensource.org/licenses/bsd-license.php BSD
|
|
* @version Release: 1.9.0
|
|
* @link http://pear.php.net/package/PHP_CompatInfo
|
|
* @since Class available since Release 1.8.0b2
|
|
*/
|
|
class PHP_CompatInfo_Parser
|
|
{
|
|
/**
|
|
* Instance of concrete renderer used to show parse results
|
|
*
|
|
* @var object
|
|
* @since 1.8.0b2
|
|
* @access protected
|
|
*/
|
|
var $renderer;
|
|
|
|
/**
|
|
* Stores the event dispatcher which handles notifications
|
|
*
|
|
* @var object
|
|
* @since 1.8.0b2
|
|
* @access protected
|
|
*/
|
|
var $dispatcher;
|
|
|
|
/**
|
|
* Count the number of observer registered.
|
|
* The Event_Dispatcher will be add on first observer registration, and
|
|
* will be removed with the last observer.
|
|
*
|
|
* @var integer
|
|
* @since 1.8.0b2
|
|
* @access private
|
|
*/
|
|
var $_observerCount;
|
|
|
|
/**
|
|
* @var string Earliest version of PHP to use
|
|
* @since 0.7.0
|
|
*/
|
|
var $latest_version = '4.0.0';
|
|
|
|
/**
|
|
* @var string Last version of PHP to use
|
|
*/
|
|
var $earliest_version = '';
|
|
|
|
/**
|
|
* @var array Parsing options
|
|
*/
|
|
var $options;
|
|
|
|
/**
|
|
* @var array Data Source
|
|
* @since 1.8.0b2
|
|
*/
|
|
var $dataSource;
|
|
|
|
/**
|
|
* @var array Directory list found when parsing data source
|
|
* @since 1.8.0b2
|
|
* @see getDirlist()
|
|
*/
|
|
var $directories;
|
|
|
|
/**
|
|
* @var array List of files ignored when parsing data source
|
|
* @since 1.8.0b2
|
|
* @see getIgnoredFiles()
|
|
*/
|
|
var $ignored_files = array();
|
|
|
|
/**
|
|
* @var array Result of the latest data source parsing
|
|
* @since 1.9.0b1
|
|
* @see parseData()
|
|
*/
|
|
var $latest_parse = null;
|
|
|
|
/**
|
|
* Class constructor (ZE1) for PHP4
|
|
*
|
|
* @access public
|
|
* @since version 1.8.0b2 (2008-06-03)
|
|
*/
|
|
function PHP_CompatInfo_Parser()
|
|
{
|
|
$this->__construct();
|
|
}
|
|
|
|
/**
|
|
* Class constructor (ZE2) for PHP5+
|
|
*
|
|
* @access public
|
|
* @since version 1.8.0b2 (2008-06-03)
|
|
*/
|
|
function __construct()
|
|
{
|
|
$this->options = array(
|
|
'file_ext' => array('php', 'php4', 'inc', 'phtml'),
|
|
'recurse_dir' => true,
|
|
'debug' => false,
|
|
'is_string' => false,
|
|
'ignore_files' => array(),
|
|
'ignore_dirs' => array()
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Set up driver to be used
|
|
*
|
|
* Set up driver to be used, dependant on specified type.
|
|
*
|
|
* @param string $type Name the type of driver (html, text...)
|
|
* @param array $conf A hash containing any additional configuration
|
|
*
|
|
* @access public
|
|
* @return void
|
|
* @since version 1.8.0b2 (2008-06-03)
|
|
*/
|
|
function setOutputDriver($type, $conf = array())
|
|
{
|
|
$this->renderer =& PHP_CompatInfo_Renderer::factory($this, $type, $conf);
|
|
}
|
|
|
|
/**
|
|
* Registers a new listener
|
|
*
|
|
* Registers a new listener with the given criteria.
|
|
*
|
|
* @param mixed $callback A PHP callback
|
|
* @param string $nName (optional) Expected notification name
|
|
*
|
|
* @access public
|
|
* @return void
|
|
* @since version 1.8.0b2 (2008-06-03)
|
|
*/
|
|
function addListener($callback, $nName = EVENT_DISPATCHER_GLOBAL)
|
|
{
|
|
$this->dispatcher =& Event_Dispatcher::getInstance();
|
|
// $this->dispatcher->setNotificationClass('PHP_CompatInfo_Audit');
|
|
$this->dispatcher->addObserver($callback, $nName);
|
|
$this->_observerCount++;
|
|
}
|
|
|
|
/**
|
|
* Removes a registered listener
|
|
*
|
|
* Removes a registered listener that correspond to the given criteria.
|
|
*
|
|
* @param mixed $callback A PHP callback
|
|
* @param string $nName (optional) Expected notification name
|
|
*
|
|
* @access public
|
|
* @return bool True if listener was removed, false otherwise.
|
|
* @since version 1.8.0b2 (2008-06-03)
|
|
*/
|
|
function removeListener($callback, $nName = EVENT_DISPATCHER_GLOBAL)
|
|
{
|
|
$result = $this->dispatcher->removeObserver($callback, $nName);
|
|
|
|
if ($result) {
|
|
$this->_observerCount--;
|
|
if ($this->_observerCount == 0) {
|
|
unset($this->dispatcher);
|
|
}
|
|
}
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Post a new notification to all listeners registered.
|
|
*
|
|
* This notification occured only if a dispatcher exists. That means if
|
|
* at least one listener was registered.
|
|
*
|
|
* @param string $event Name of the notification handler
|
|
* @param array $info (optional) Additional information about the notification
|
|
*
|
|
* @access public
|
|
* @return void
|
|
* @since version 1.8.0b2 (2008-06-03)
|
|
*/
|
|
function notifyListeners($event, $info = array())
|
|
{
|
|
if (isset($this->dispatcher)) {
|
|
$this->dispatcher->post($this, $event, $info);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load components list
|
|
*
|
|
* Load components list for a PHP version or subset
|
|
*
|
|
* @param string $min PHP minimal version
|
|
* @param string|boolean $max (optional) PHP maximal version
|
|
* @param boolean $include_const (optional) include constants list
|
|
* in final result
|
|
* @param boolean $groupby_vers (optional) give initial php version
|
|
* of function or constant
|
|
*
|
|
* @return array An array of php function/constant names history
|
|
* @access public
|
|
* @static
|
|
* @since version 1.2.0 (2006-08-23)
|
|
*/
|
|
function loadVersion($min, $max = false,
|
|
$include_const = false, $groupby_vers = false)
|
|
{
|
|
$keys = array();
|
|
foreach ($GLOBALS['_PHP_COMPATINFO_FUNCS'] as $func => $arr) {
|
|
if (isset($arr['pecl']) && $arr['pecl'] === true) {
|
|
continue;
|
|
}
|
|
$vmin = $arr['init'];
|
|
if (version_compare($vmin, $min) < 0) {
|
|
continue;
|
|
}
|
|
if ($max) {
|
|
$end = (isset($arr['end'])) ? $arr['end'] : $vmin;
|
|
|
|
if (version_compare($end, $max) < 1) {
|
|
if ($groupby_vers === true) {
|
|
$keys[$vmin][] = $func;
|
|
} else {
|
|
$keys[] = $func;
|
|
}
|
|
}
|
|
} else {
|
|
if ($groupby_vers === true) {
|
|
$keys[$vmin][] = $func;
|
|
} else {
|
|
$keys[] = $func;
|
|
}
|
|
}
|
|
}
|
|
if ($groupby_vers === true) {
|
|
foreach ($keys as $vmin => $func) {
|
|
sort($keys[$vmin]);
|
|
}
|
|
ksort($keys);
|
|
} else {
|
|
sort($keys);
|
|
}
|
|
|
|
if ($include_const === true) {
|
|
$keys = array('functions' => $keys, 'constants' => array());
|
|
foreach ($GLOBALS['_PHP_COMPATINFO_CONST'] as $const => $arr) {
|
|
$vmin = $arr['init'];
|
|
if (version_compare($vmin, $min) < 0) {
|
|
continue;
|
|
}
|
|
if ($max) {
|
|
$end = (isset($arr['end'])) ? $arr['end'] : $vmin;
|
|
|
|
if (version_compare($end, $max) < 1) {
|
|
if ($groupby_vers === true) {
|
|
$keys['constants'][$vmin][] = $arr['name'];
|
|
} else {
|
|
$keys['constants'][] = $arr['name'];
|
|
}
|
|
}
|
|
} else {
|
|
if ($groupby_vers === true) {
|
|
$keys['constants'][$vmin][] = $arr['name'];
|
|
} else {
|
|
$keys['constants'][] = $arr['name'];
|
|
}
|
|
}
|
|
}
|
|
ksort($keys['constants']);
|
|
}
|
|
return $keys;
|
|
}
|
|
|
|
/**
|
|
* Returns list of directory parsed
|
|
*
|
|
* Returns list of directory parsed, depending of restrictive parser options.
|
|
*
|
|
* @param mixed $dir The directory name
|
|
* @param array $options An array of parser options. See parseData() method.
|
|
*
|
|
* @access public
|
|
* @return array list of directories that should be parsed
|
|
* @since version 1.8.0b2 (2008-06-03)
|
|
*/
|
|
function getDirlist($dir, $options)
|
|
{
|
|
if (!isset($this->directories)) {
|
|
$this->getFilelist($dir, $options);
|
|
}
|
|
|
|
return $this->directories;
|
|
}
|
|
|
|
/**
|
|
* Returns list of files parsed
|
|
*
|
|
* Returns list of files parsed, depending of restrictive parser options.
|
|
*
|
|
* @param mixed $dir The directory name where to look files
|
|
* @param array $options An array of parser options. See parseData() method.
|
|
*
|
|
* @access public
|
|
* @return array list of files that should be parsed
|
|
* @since version 1.8.0b2 (2008-06-03)
|
|
*/
|
|
function getFilelist($dir, $options)
|
|
{
|
|
$skipped = array();
|
|
$ignored = array();
|
|
|
|
$options = array_merge($this->options, $options);
|
|
$options['file_ext'] = array_map('strtolower', $options['file_ext']);
|
|
|
|
if ($dir{strlen($dir)-1} == '/' || $dir{strlen($dir)-1} == '\\') {
|
|
$dir = substr($dir, 0, -1);
|
|
}
|
|
|
|
// use system directory separator rather than forward slash by default
|
|
$ff = new File_Find();
|
|
$ff->dirsep = DIRECTORY_SEPARATOR;
|
|
|
|
// get directory list that should be ignored from scope
|
|
$ignore_dirs = array();
|
|
if (count($options['ignore_dirs']) > 0) {
|
|
foreach ($options['ignore_dirs'] as $cond) {
|
|
$cond = str_replace('\\', "\\\\", $cond);
|
|
$dirs = $ff->search('`'.$cond.'`', $dir, 'perl',
|
|
true, 'directories');
|
|
$ignore_dirs = array_merge($ignore_dirs, $dirs);
|
|
}
|
|
}
|
|
|
|
// get file list that should be ignored from scope
|
|
$ignore_files = array();
|
|
if (count($options['ignore_files']) > 0) {
|
|
foreach ($options['ignore_files'] as $cond) {
|
|
$cond = str_replace('\\', "\\\\", $cond);
|
|
$files = $ff->search('`'.$cond.'`', $dir, 'perl',
|
|
true, 'files');
|
|
$ignore_files = array_merge($ignore_files, $files);
|
|
}
|
|
}
|
|
|
|
list($directories, $files) = $ff->maptree($dir);
|
|
|
|
foreach ($files as $file) {
|
|
|
|
$file_info = pathinfo($file);
|
|
if ($options['recurse_dir'] == false
|
|
&& $file_info['dirname'] != $dir) {
|
|
$skipped[] = $file;
|
|
continue;
|
|
}
|
|
if (in_array($file_info['dirname'], $ignore_dirs)) {
|
|
$ignored[] = $file;
|
|
|
|
} elseif (in_array($file, $ignore_files)) {
|
|
$ignored[] = $file;
|
|
|
|
} else {
|
|
if (isset($file_info['extension'])
|
|
&& in_array(strtolower($file_info['extension']),
|
|
$options['file_ext'])) {
|
|
continue;
|
|
}
|
|
$ignored[] = $file;
|
|
}
|
|
}
|
|
|
|
$files = PHP_CompatInfo_Parser::_arrayDiff($files,
|
|
array_merge($ignored, $skipped));
|
|
$this->directories
|
|
= PHP_CompatInfo_Parser::_arrayDiff($directories, $ignore_dirs);
|
|
$this->ignored_files
|
|
= $ignored;
|
|
|
|
return $files;
|
|
}
|
|
|
|
/**
|
|
* Returns list of files ignored
|
|
*
|
|
* Returns list of files ignored while parsing directories
|
|
*
|
|
* @access public
|
|
* @return array or false on error
|
|
* @since version 1.8.0b2 (2008-06-03)
|
|
*/
|
|
function getIgnoredFiles()
|
|
{
|
|
return $this->ignored_files;
|
|
}
|
|
|
|
/**
|
|
* Returns the latest parse data source ignored functions
|
|
*
|
|
* Returns the latest parse data source ignored functions list
|
|
*
|
|
* @param mixed $file (optional) A specific filename or not (false)
|
|
*
|
|
* @access public
|
|
* @return mixed Null on error or if there were no previous data parsing
|
|
* @since version 1.9.0b2 (2008-12-19)
|
|
*/
|
|
function getIgnoredFunctions($file = false)
|
|
{
|
|
if (!is_array($this->latest_parse)) {
|
|
// no code analysis found
|
|
$functions = null;
|
|
} elseif ($file === false) {
|
|
$functions = $this->latest_parse['ignored_functions'];
|
|
} elseif (isset($this->latest_parse[$file])) {
|
|
$functions = $this->latest_parse[$file]['ignored_functions'];
|
|
} else {
|
|
$functions = null;
|
|
}
|
|
|
|
return $functions;
|
|
}
|
|
|
|
/**
|
|
* Returns the latest parse data source ignored extensions
|
|
*
|
|
* Returns the latest parse data source ignored extensions list
|
|
*
|
|
* @param mixed $file (optional) A specific filename or not (false)
|
|
*
|
|
* @access public
|
|
* @return mixed Null on error or if there were no previous data parsing
|
|
* @since version 1.9.0b2 (2008-12-19)
|
|
*/
|
|
function getIgnoredExtensions($file = false)
|
|
{
|
|
if (!is_array($this->latest_parse)) {
|
|
// no code analysis found
|
|
$extensions = null;
|
|
} elseif ($file === false) {
|
|
$extensions = $this->latest_parse['ignored_extensions'];
|
|
} elseif (isset($this->latest_parse[$file])) {
|
|
$extensions = $this->latest_parse[$file]['ignored_extensions'];
|
|
} else {
|
|
$extensions = null;
|
|
}
|
|
|
|
return $extensions;
|
|
}
|
|
|
|
/**
|
|
* Returns the latest parse data source ignored constants
|
|
*
|
|
* Returns the latest parse data source ignored constants list
|
|
*
|
|
* @param mixed $file (optional) A specific filename or not (false)
|
|
*
|
|
* @access public
|
|
* @return mixed Null on error or if there were no previous data parsing
|
|
* @since version 1.9.0b2 (2008-12-19)
|
|
*/
|
|
function getIgnoredConstants($file = false)
|
|
{
|
|
if (!is_array($this->latest_parse)) {
|
|
// no code analysis found
|
|
$constants = null;
|
|
} elseif ($file === false) {
|
|
$constants = $this->latest_parse['ignored_constants'];
|
|
} elseif (isset($this->latest_parse[$file])) {
|
|
$constants = $this->latest_parse[$file]['ignored_constants'];
|
|
} else {
|
|
$constants = null;
|
|
}
|
|
|
|
return $constants;
|
|
}
|
|
|
|
/**
|
|
* Returns the latest parse data source version
|
|
*
|
|
* Returns the latest parse data source version, minimum and/or maximum
|
|
*
|
|
* @param mixed $file (optional) A specific filename or not (false)
|
|
* @param bool $max (optional) Level with or without contextual data
|
|
*
|
|
* @access public
|
|
* @return mixed Null on error or if there were no previous data parsing
|
|
* @since version 1.9.0b1 (2008-11-30)
|
|
*/
|
|
function getVersion($file = false, $max = false)
|
|
{
|
|
$key = ($max === true) ? 'max_version' : 'version';
|
|
|
|
if (!is_array($this->latest_parse)) {
|
|
// no code analysis found
|
|
$version = null;
|
|
} elseif ($file === false) {
|
|
$version = $this->latest_parse[$key];
|
|
} elseif (isset($this->latest_parse[$file])) {
|
|
$version = $this->latest_parse[$file][$key];
|
|
} else {
|
|
$version = null;
|
|
}
|
|
|
|
return $version;
|
|
}
|
|
|
|
/**
|
|
* Returns the latest parse data source classes declared
|
|
*
|
|
* Returns the latest parse data source classes declared (internal or
|
|
* end-user defined)
|
|
*
|
|
* @param mixed $file (optional) A specific filename or not (false)
|
|
*
|
|
* @access public
|
|
* @return mixed Null on error or if there were no previous data parsing
|
|
* @since version 1.9.0b1 (2008-11-30)
|
|
*/
|
|
function getClasses($file = false)
|
|
{
|
|
if (!is_array($this->latest_parse)) {
|
|
// no code analysis found
|
|
$classes = null;
|
|
} elseif ($file === false) {
|
|
$classes = $this->latest_parse['classes'];
|
|
} elseif (isset($this->latest_parse[$file])) {
|
|
$classes = $this->latest_parse[$file]['classes'];
|
|
} else {
|
|
$classes = null;
|
|
}
|
|
|
|
return $classes;
|
|
}
|
|
|
|
/**
|
|
* Returns the latest parse data source functions declared
|
|
*
|
|
* Returns the latest parse data source functions declared (internal or
|
|
* end-user defined)
|
|
*
|
|
* @param mixed $file (optional) A specific filename or not (false)
|
|
*
|
|
* @access public
|
|
* @return mixed Null on error or if there were no previous data parsing
|
|
* @since version 1.9.0b1 (2008-11-30)
|
|
*/
|
|
function getFunctions($file = false)
|
|
{
|
|
if (!is_array($this->latest_parse)) {
|
|
// no code analysis found
|
|
$functions = null;
|
|
} elseif ($file === false) {
|
|
$functions = $this->latest_parse['functions'];
|
|
} elseif (isset($this->latest_parse[$file])) {
|
|
$functions = $this->latest_parse[$file]['functions'];
|
|
} else {
|
|
$functions = null;
|
|
}
|
|
|
|
return $functions;
|
|
}
|
|
|
|
/**
|
|
* Returns the latest parse data source extensions used
|
|
*
|
|
* Returns the latest parse data source extensions used
|
|
*
|
|
* @param mixed $file (optional) A specific filename or not (false)
|
|
*
|
|
* @access public
|
|
* @return mixed Null on error or if there were no previous data parsing
|
|
* @since version 1.9.0b1 (2008-11-30)
|
|
*/
|
|
function getExtensions($file = false)
|
|
{
|
|
if (!is_array($this->latest_parse)) {
|
|
// no code analysis found
|
|
$extensions = null;
|
|
} elseif ($file === false) {
|
|
$extensions = $this->latest_parse['extensions'];
|
|
} elseif (isset($this->latest_parse[$file])) {
|
|
$extensions = $this->latest_parse[$file]['extensions'];
|
|
} else {
|
|
$extensions = null;
|
|
}
|
|
|
|
return $extensions;
|
|
}
|
|
|
|
/**
|
|
* Returns the latest parse data source constants declared
|
|
*
|
|
* Returns the latest parse data source constants declared (internal or
|
|
* end-user defined)
|
|
*
|
|
* @param mixed $file (optional) A specific filename or not (false)
|
|
*
|
|
* @access public
|
|
* @return mixed Null on error or if there were no previous data parsing
|
|
* @since version 1.9.0b1 (2008-11-30)
|
|
*/
|
|
function getConstants($file = false)
|
|
{
|
|
if (!is_array($this->latest_parse)) {
|
|
// no code analysis found
|
|
$constants = null;
|
|
} elseif ($file === false) {
|
|
$constants = $this->latest_parse['constants'];
|
|
} elseif (isset($this->latest_parse[$file])) {
|
|
$constants = $this->latest_parse[$file]['constants'];
|
|
} else {
|
|
$constants = null;
|
|
}
|
|
|
|
return $constants;
|
|
}
|
|
|
|
/**
|
|
* Returns the latest parse data source tokens declared
|
|
*
|
|
* Returns the latest parse data source PHP5+ tokens declared
|
|
*
|
|
* @param mixed $file (optional) A specific filename or not (false)
|
|
*
|
|
* @access public
|
|
* @return mixed Null on error or if there were no previous data parsing
|
|
* @since version 1.9.0b1 (2008-11-30)
|
|
*/
|
|
function getTokens($file = false)
|
|
{
|
|
if (!is_array($this->latest_parse)) {
|
|
// no code analysis found
|
|
} elseif ($file === false) {
|
|
$tokens = $this->latest_parse['tokens'];
|
|
} elseif (isset($this->latest_parse[$file])) {
|
|
$tokens = $this->latest_parse[$file]['tokens'];
|
|
} else {
|
|
$tokens = null;
|
|
}
|
|
|
|
return $tokens;
|
|
}
|
|
|
|
/**
|
|
* Returns the latest parse data source conditions
|
|
*
|
|
* Returns the latest parse data source conditions, with or without
|
|
* contextual data
|
|
*
|
|
* @param mixed $file (optional) A specific filename or not (false)
|
|
* @param bool $levelOnly (optional) Level with or without contextual data
|
|
*
|
|
* @access public
|
|
* @return mixed Null on error or if there were no previous data parsing
|
|
* @since version 1.9.0b1 (2008-11-30)
|
|
*/
|
|
function getConditions($file = false, $levelOnly = false)
|
|
{
|
|
if (!is_array($this->latest_parse)) {
|
|
// no code analysis found
|
|
$conditions = null;
|
|
} elseif ($file === false) {
|
|
$conditions = $this->latest_parse['cond_code'];
|
|
} elseif (isset($this->latest_parse[$file])) {
|
|
$conditions = $this->latest_parse[$file]['cond_code'];
|
|
} else {
|
|
$conditions = null;
|
|
}
|
|
|
|
if (is_array($conditions) && $levelOnly === true) {
|
|
$conditions = $conditions[0];
|
|
}
|
|
return $conditions;
|
|
}
|
|
|
|
/**
|
|
* Parse a data source
|
|
*
|
|
* Parse a data source with auto detect ability. This data source, may be
|
|
* one of these follows: a directory, a file, a string (chunk of code),
|
|
* an array of multiple origin.
|
|
*
|
|
* Each of five parsing functions support common and specifics options.
|
|
*
|
|
* * Common options :
|
|
* - 'debug' Contains a boolean to control whether
|
|
* extra ouput is shown.
|
|
* - 'ignore_functions' Contains an array of functions to ignore
|
|
* when calculating the version needed.
|
|
* - 'ignore_constants' Contains an array of constants to ignore
|
|
* when calculating the version needed.
|
|
* - 'ignore_extensions' Contains an array of php extensions to ignore
|
|
* when calculating the version needed.
|
|
* - 'ignore_versions' Contains an array of php versions to ignore
|
|
* when calculating the version needed.
|
|
* - 'ignore_functions_match' Contains an array of function patterns to ignore
|
|
* when calculating the version needed.
|
|
* - 'ignore_extensions_match' Contains an array of extension patterns to ignore
|
|
* when calculating the version needed.
|
|
* - 'ignore_constants_match' Contains an array of constant patterns to ignore
|
|
* when calculating the version needed.
|
|
*
|
|
* * parseArray, parseDir|parseFolder, specific options :
|
|
* - 'file_ext' Contains an array of file extensions to parse
|
|
* for PHP code. Default: php, php4, inc, phtml
|
|
* - 'ignore_files' Contains an array of files to ignore.
|
|
* File names are case insensitive.
|
|
*
|
|
* * parseArray specific options :
|
|
* - 'is_string' Contains a boolean which says if the array values
|
|
* are strings or file names.
|
|
*
|
|
* * parseDir|parseFolder specific options :
|
|
* - 'recurse_dir' Boolean on whether to recursively find files
|
|
* - 'ignore_dirs' Contains an array of directories to ignore.
|
|
* Directory names are case insensitive.
|
|
*
|
|
* @param mixed $dataSource The data source (may be file, dir, string, or array)
|
|
* @param array $options An array of options. See above.
|
|
*
|
|
* @access public
|
|
* @return array or false on error
|
|
* @since version 1.8.0b2 (2008-06-03)
|
|
*/
|
|
function parseData($dataSource, $options = array())
|
|
{
|
|
$this->options = array_merge($this->options, $options);
|
|
|
|
$dataType = gettype($dataSource);
|
|
$dataCount = 0;
|
|
// - when array source with mixed content incompatible
|
|
// - if all directories are not readable
|
|
// - if data source invalid type: other than file, directory, string
|
|
|
|
if ($dataType == 'string' || $dataType == 'array') {
|
|
if (is_array($dataSource)) {
|
|
//$dataType = 'array';
|
|
} elseif (is_dir($dataSource)) {
|
|
$dataType = 'directory';
|
|
$dataSource = array($dataSource);
|
|
} elseif (is_file($dataSource)) {
|
|
$dataType = 'file';
|
|
$dataSource = array($dataSource);
|
|
} elseif (substr($dataSource, 0, 5) == '<?php') {
|
|
//$dataType = 'string';
|
|
$this->options = array_merge($this->options,
|
|
array('is_string' => true));
|
|
$dataSource = array($dataSource);
|
|
} else {
|
|
//$dataType = 'string';
|
|
// directory or file are misspelled
|
|
}
|
|
if (is_array($dataSource)) {
|
|
$dataSource = $this->_validateDataSource($dataSource,
|
|
$this->options);
|
|
$dataCount = count($dataSource);
|
|
}
|
|
}
|
|
|
|
$this->dataSource = array('dataSource' => $dataSource,
|
|
'dataType' => $dataType,
|
|
'dataCount' => $dataCount);
|
|
|
|
$eventInfo = array_merge($this->dataSource,
|
|
array('parseOptions' => $this->options));
|
|
|
|
// notify all observers that parsing data source begin
|
|
$this->notifyListeners(PHP_COMPATINFO_EVENT_AUDITSTARTED, $eventInfo);
|
|
|
|
if ($dataCount == 0) {
|
|
$parseData = false;
|
|
} else {
|
|
switch ($dataType) {
|
|
case 'array' :
|
|
$parseData = $this->_parseArray($dataSource, $this->options);
|
|
break;
|
|
case 'string' :
|
|
$parseData = $this->_parseString($dataSource, $this->options);
|
|
break;
|
|
case 'file' :
|
|
$parseData = $this->_parseFile($dataSource, $this->options);
|
|
break;
|
|
case 'directory' :
|
|
$parseData = $this->_parseDir($dataSource, $this->options);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// notify all observers that parsing data source is over
|
|
$this->notifyListeners(PHP_COMPATINFO_EVENT_AUDITFINISHED, $parseData);
|
|
|
|
$this->latest_parse = $parseData;
|
|
return $parseData;
|
|
}
|
|
|
|
/**
|
|
* Validate content of data source
|
|
*
|
|
* Validate content of data source list, before parsing each source
|
|
*
|
|
* @param mixed $dataSource The data source (may be file, dir, or string)
|
|
* @param array $options Parser options (see parseData() method for details)
|
|
*
|
|
* @access private
|
|
* @return array empty array on error
|
|
* @since version 1.8.0b3 (2008-06-07)
|
|
*/
|
|
function _validateDataSource($dataSource, $options = array())
|
|
{
|
|
/**
|
|
* Array by default expect to contains list of files and/or directories.
|
|
* If you want a list of chunk of code (strings), 'is_string' option
|
|
* must be set to true.
|
|
*/
|
|
$list = array();
|
|
|
|
foreach ($dataSource as $source) {
|
|
if ($options['is_string'] === true) {
|
|
if (is_string($source)) {
|
|
$list[] = $source;
|
|
} else {
|
|
/**
|
|
* One of items is not a string (chunk of code). All
|
|
* data sources parsing are stopped and considered as invalid.
|
|
*/
|
|
$list = array();
|
|
break;
|
|
}
|
|
} else {
|
|
if (is_dir($source) && is_readable($source)) {
|
|
$files = $this->getFilelist($source, $options);
|
|
$list = array_merge($list, $files);
|
|
} elseif (is_file($source)) {
|
|
$list[] = $source;
|
|
} else {
|
|
/**
|
|
* One of items is not a valid file or directory. All
|
|
* data sources parsing are stopped and considered as invalid.
|
|
*/
|
|
$list = array();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $list;
|
|
}
|
|
|
|
/**
|
|
* Parse an Array of Files
|
|
*
|
|
* You can parse an array of Files or Strings, to parse
|
|
* strings, $options['is_string'] must be set to true
|
|
*
|
|
* @param array $dataSource Array of file &| directory names or code strings
|
|
* @param array $options Parser options (see parseData() method for details)
|
|
*
|
|
* @access private
|
|
* @return array or false on error
|
|
* @since version 0.7.0 (2004-03-09)
|
|
* @see parseData()
|
|
*/
|
|
function _parseArray($dataSource, $options = array())
|
|
{
|
|
// Each data source have been checked before (see _validateDataSource() )
|
|
if (is_file($dataSource[0])) {
|
|
$parseData = $this->_parseDir($dataSource, $options);
|
|
} else {
|
|
$parseData = $this->_parseString($dataSource, $options);
|
|
}
|
|
|
|
return $parseData;
|
|
}
|
|
|
|
/**
|
|
* Parse a string
|
|
*
|
|
* Parse a string for its compatibility info.
|
|
*
|
|
* @param array $strings PHP Code to parse
|
|
* @param array $options Parser options (see parseData() method for details)
|
|
*
|
|
* @access private
|
|
* @return array or false on error
|
|
* @since version 0.7.0 (2004-03-09)
|
|
* @see parseData()
|
|
*/
|
|
function _parseString($strings, $options = array())
|
|
{
|
|
$results = $this->_parseElements($strings, $options);
|
|
return $results;
|
|
}
|
|
|
|
/**
|
|
* Parse a single file
|
|
*
|
|
* Parse a single file for its compatibility info.
|
|
*
|
|
* @param string $file File to parse
|
|
* @param array $options Parser options (see parseData() method for details)
|
|
*
|
|
* @access private
|
|
* @return array or false on error
|
|
* @since version 0.7.0 (2004-03-09)
|
|
* @see parseData()
|
|
*/
|
|
function _parseFile($file, $options = array())
|
|
{
|
|
$results = $this->_parseElements($file, $options);
|
|
return $results;
|
|
}
|
|
|
|
/**
|
|
* Parse a directory
|
|
*
|
|
* Parse a directory recursively for its compatibility info
|
|
*
|
|
* @param array $files Files list of folder to parse
|
|
* @param array $options Parser options (see parseData() method for details)
|
|
*
|
|
* @access private
|
|
* @return array or false on error
|
|
* @since version 0.8.0 (2004-04-22)
|
|
* @see parseData()
|
|
*/
|
|
function _parseDir($files, $options = array())
|
|
{
|
|
$results = $this->_parseElements($files, $options);
|
|
return $results;
|
|
}
|
|
|
|
/**
|
|
* Parse a list of elements
|
|
*
|
|
* Parse a list of directory|file elements, or chunk of code (strings)
|
|
*
|
|
* @param array $elements Array of file &| directory names or code strings
|
|
* @param array $options Parser options (see parseData() method for details)
|
|
*
|
|
* @access private
|
|
* @return array
|
|
* @since version 1.8.0b3 (2008-06-07)
|
|
* @see _parseString(), _parseDir()
|
|
*/
|
|
function _parseElements($elements, $options = array())
|
|
{
|
|
$files_parsed = array();
|
|
$latest_version = $this->latest_version;
|
|
$earliest_version = $this->earliest_version;
|
|
$all_functions = array();
|
|
$classes = array();
|
|
$functions = array();
|
|
$extensions = array();
|
|
$constants = array();
|
|
$tokens = array();
|
|
$ignored_functions = array();
|
|
$ignored_extensions = array();
|
|
$ignored_constants = array();
|
|
$function_exists = array();
|
|
$extension_loaded = array();
|
|
$defined = array();
|
|
$cond_code = 0;
|
|
|
|
foreach ($elements as $p => $element) {
|
|
$index = $p + 1;
|
|
if (is_file($element)) {
|
|
if (in_array($element, $options['ignore_files'])) {
|
|
$this->ignored_files[] = $element;
|
|
continue;
|
|
}
|
|
$eventInfo
|
|
= array('filename' => $element, 'fileindex' => $index);
|
|
$this->notifyListeners(PHP_COMPATINFO_EVENT_FILESTARTED, $eventInfo);
|
|
|
|
$tokens_list = $this->_tokenize($element);
|
|
$kfile = $element;
|
|
$files_parsed[$kfile] = $this->_parseTokens($tokens_list, $options);
|
|
|
|
$this->notifyListeners(PHP_COMPATINFO_EVENT_FILEFINISHED);
|
|
} else {
|
|
$eventInfo
|
|
= array('stringdata' => $element, 'stringindex' => $index);
|
|
$this->notifyListeners(PHP_COMPATINFO_EVENT_CODESTARTED, $eventInfo);
|
|
|
|
$tokens_list = $this->_tokenize($element, true);
|
|
$kfile = 'string_' . $index;
|
|
$files_parsed[$kfile] = $this->_parseTokens($tokens_list, $options);
|
|
|
|
$this->notifyListeners(PHP_COMPATINFO_EVENT_CODEFINISHED);
|
|
}
|
|
}
|
|
|
|
foreach ($files_parsed as $fn => $file) {
|
|
$cmp = version_compare($latest_version, $file['version']);
|
|
if ($cmp === -1) {
|
|
$latest_version = $file['version'];
|
|
}
|
|
if ($file['max_version'] != '') {
|
|
$cmp = version_compare($earliest_version, $file['max_version']);
|
|
if ($earliest_version == '' || $cmp === 1) {
|
|
$earliest_version = $file['max_version'];
|
|
}
|
|
}
|
|
foreach ($file['classes'] as $class) {
|
|
if (!in_array($class, $classes)) {
|
|
$classes[] = $class;
|
|
}
|
|
}
|
|
foreach ($file['functions'] as $func) {
|
|
if (!in_array($func, $functions)) {
|
|
$functions[] = $func;
|
|
}
|
|
}
|
|
foreach ($file['extensions'] as $ext) {
|
|
if (!in_array($ext, $extensions)) {
|
|
$extensions[] = $ext;
|
|
}
|
|
}
|
|
foreach ($file['constants'] as $const) {
|
|
if (!in_array($const, $constants)) {
|
|
$constants[] = $const;
|
|
}
|
|
}
|
|
foreach ($file['tokens'] as $token) {
|
|
if (!in_array($token, $tokens)) {
|
|
$tokens[] = $token;
|
|
}
|
|
}
|
|
foreach ($file['ignored_functions'] as $if) {
|
|
if (!in_array($if, $ignored_functions)) {
|
|
$ignored_functions[] = $if;
|
|
}
|
|
}
|
|
foreach ($file['ignored_extensions'] as $ie) {
|
|
if (!in_array($ie, $ignored_extensions)) {
|
|
$ignored_extensions[] = $ie;
|
|
}
|
|
}
|
|
foreach ($file['ignored_constants'] as $ic) {
|
|
if (!in_array($ic, $ignored_constants)) {
|
|
$ignored_constants[] = $ic;
|
|
}
|
|
}
|
|
foreach ($file['cond_code'][1][0] as $ccf) {
|
|
if (!in_array($ccf, $function_exists)) {
|
|
$function_exists[] = $ccf;
|
|
}
|
|
}
|
|
foreach ($file['cond_code'][1][1] as $cce) {
|
|
if (!in_array($cce, $extension_loaded)) {
|
|
$extension_loaded[] = $cce;
|
|
}
|
|
}
|
|
foreach ($file['cond_code'][1][2] as $ccc) {
|
|
if (!in_array($ccc, $defined)) {
|
|
$defined[] = $ccc;
|
|
}
|
|
}
|
|
if ($options['debug'] === false) {
|
|
unset($files_parsed[$fn]['cond_code'][1]);
|
|
} else {
|
|
unset($file['ignored_functions']);
|
|
unset($file['ignored_extensions']);
|
|
unset($file['ignored_constants']);
|
|
unset($file['max_version']);
|
|
unset($file['version']);
|
|
unset($file['classes']);
|
|
unset($file['functions']);
|
|
unset($file['extensions']);
|
|
unset($file['constants']);
|
|
unset($file['tokens']);
|
|
unset($file['cond_code']);
|
|
|
|
foreach ($file as $version => $file_functions) {
|
|
// extra information available only when debug mode is on
|
|
if (isset($all_functions[$version])) {
|
|
foreach ($file_functions as $func) {
|
|
$k = array_search($func, $all_functions[$version]);
|
|
if ($k === false) {
|
|
$all_functions[$version][] = $func;
|
|
}
|
|
}
|
|
} else {
|
|
$all_functions[$version] = $file_functions;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (count($files_parsed) == 0) {
|
|
return false;
|
|
}
|
|
|
|
if (count($function_exists) > 0) {
|
|
$cond_code += 1;
|
|
}
|
|
if (count($extension_loaded) > 0) {
|
|
$cond_code += 2;
|
|
}
|
|
if (count($defined) > 0) {
|
|
$cond_code += 4;
|
|
}
|
|
if ($options['debug'] === false) {
|
|
$cond_code = array($cond_code);
|
|
} else {
|
|
sort($function_exists);
|
|
sort($extension_loaded);
|
|
sort($defined);
|
|
$cond_code = array($cond_code, array($function_exists,
|
|
$extension_loaded,
|
|
$defined));
|
|
}
|
|
|
|
sort($ignored_functions);
|
|
sort($ignored_extensions);
|
|
sort($ignored_constants);
|
|
sort($classes);
|
|
sort($functions);
|
|
natcasesort($extensions);
|
|
sort($constants);
|
|
sort($tokens);
|
|
$main_info = array('ignored_files' => $this->getIgnoredFiles(),
|
|
'ignored_functions' => $ignored_functions,
|
|
'ignored_extensions' => $ignored_extensions,
|
|
'ignored_constants' => $ignored_constants,
|
|
'max_version' => $earliest_version,
|
|
'version' => $latest_version,
|
|
'classes' => $classes,
|
|
'functions' => $functions,
|
|
'extensions' => array_values($extensions),
|
|
'constants' => $constants,
|
|
'tokens' => $tokens,
|
|
'cond_code' => $cond_code);
|
|
|
|
if (count($files_parsed) == 1) {
|
|
if ($options['debug'] === false) {
|
|
$parseData = $main_info;
|
|
} else {
|
|
$main_info = array('ignored_files' => $this->getIgnoredFiles());
|
|
$parseData = array_merge($main_info,
|
|
$files_parsed[$kfile], $all_functions);
|
|
}
|
|
} else {
|
|
if ($options['debug'] === false) {
|
|
$parseData = array_merge($main_info, $files_parsed);
|
|
} else {
|
|
$parseData = array_merge($main_info, $all_functions, $files_parsed);
|
|
}
|
|
}
|
|
|
|
$this->notifyListeners(PHP_COMPATINFO_EVENT_FILEFINISHED, $parseData);
|
|
return $parseData;
|
|
}
|
|
|
|
/**
|
|
* Token a file or string
|
|
*
|
|
* @param string $input Filename or PHP code
|
|
* @param boolean $is_string Whether or note the input is a string
|
|
* @param boolean $debug add token names for human read
|
|
*
|
|
* @access private
|
|
* @return array
|
|
* @since version 0.7.0 (2004-03-09)
|
|
*/
|
|
function _tokenize($input, $is_string = false, $debug = false)
|
|
{
|
|
if ($is_string === false) {
|
|
$input = file_get_contents($input, true);
|
|
}
|
|
$tokens = token_get_all($input);
|
|
|
|
if ($debug === true) {
|
|
$r = array();
|
|
foreach ($tokens as $token) {
|
|
if (is_array($token)) {
|
|
$token[] = token_name($token[0]);
|
|
} else {
|
|
$token = $token[0];
|
|
}
|
|
$r[] = $token;
|
|
}
|
|
} else {
|
|
$r = $tokens;
|
|
}
|
|
return $r;
|
|
}
|
|
|
|
/**
|
|
* Parse the given Tokens
|
|
*
|
|
* The tokens are those returned by token_get_all() which is nicely
|
|
* wrapped in PHP_CompatInfo::_tokenize
|
|
*
|
|
* @param array $tokens Array of PHP Tokens
|
|
* @param boolean $options Show Extra Output
|
|
*
|
|
* @access private
|
|
* @return array
|
|
* @since version 0.7.0 (2004-03-09)
|
|
*/
|
|
function _parseTokens($tokens, $options)
|
|
{
|
|
static $akeys;
|
|
|
|
$classes = array();
|
|
$functions = array();
|
|
$functions_version = array();
|
|
$latest_version = $this->latest_version;
|
|
$earliest_version = $this->earliest_version;
|
|
$extensions = array();
|
|
$constants = array();
|
|
$constant_names = array();
|
|
$token_names = array();
|
|
$udf = array();
|
|
$ignore_functions = array();
|
|
$ignored_functions = array();
|
|
$ignore_extensions = array();
|
|
$ignored_extensions = array();
|
|
$ignore_constants = array();
|
|
$ignored_constants = array();
|
|
$function_exists = array();
|
|
$extension_loaded = array();
|
|
$defined = array();
|
|
$cond_code = 0;
|
|
|
|
if (isset($options['ignore_constants'])) {
|
|
$options['ignore_constants']
|
|
= array_map('strtoupper', $options['ignore_constants']);
|
|
} else {
|
|
$options['ignore_constants'] = array();
|
|
}
|
|
if (isset($options['ignore_extensions'])) {
|
|
$options['ignore_extensions']
|
|
= array_map('strtolower', $options['ignore_extensions']);
|
|
} else {
|
|
$options['ignore_extensions'] = array();
|
|
}
|
|
if (isset($options['ignore_versions'][0])) {
|
|
$min_ver = $options['ignore_versions'][0];
|
|
} else {
|
|
$min_ver = false;
|
|
}
|
|
if (isset($options['ignore_versions'][1])) {
|
|
$max_ver = $options['ignore_versions'][1];
|
|
} else {
|
|
$max_ver = false;
|
|
}
|
|
|
|
if (isset($options['ignore_functions_match'])) {
|
|
list($ifm_compare, $ifm_patterns) = $options['ignore_functions_match'];
|
|
} else {
|
|
$ifm_compare = false;
|
|
}
|
|
if (isset($options['ignore_extensions_match'])) {
|
|
list($iem_compare, $iem_patterns) = $options['ignore_extensions_match'];
|
|
} else {
|
|
$iem_compare = false;
|
|
}
|
|
if (isset($options['ignore_constants_match'])) {
|
|
list($icm_compare, $icm_patterns) = $options['ignore_constants_match'];
|
|
} else {
|
|
$icm_compare = false;
|
|
}
|
|
|
|
$token_count = sizeof($tokens);
|
|
$i = 0;
|
|
$found_class = false;
|
|
while ($i < $token_count) {
|
|
if ($this->_isToken($tokens[$i], 'T_FUNCTION')) {
|
|
$found_func = false;
|
|
} else {
|
|
$found_func = true;
|
|
}
|
|
while ($found_func == false) {
|
|
$i += 1;
|
|
if ($this->_isToken($tokens[$i], 'T_STRING')) {
|
|
$found_func = true;
|
|
$func = $tokens[$i][1];
|
|
if ($found_class === false
|
|
|| in_array($func, $function_exists)) {
|
|
$udf[] = $func;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Try to detect PHP method chaining implementation
|
|
if ($this->_isToken($tokens[$i], 'T_VARIABLE')
|
|
&& $this->_isToken($tokens[$i+1], 'T_OBJECT_OPERATOR')
|
|
&& $this->_isToken($tokens[$i+2], 'T_STRING')
|
|
&& $this->_isToken($tokens[$i+3], '(')) {
|
|
|
|
$i += 3;
|
|
$php5_method_chaining = false;
|
|
while (((!is_array($tokens[$i]) && $tokens[$i] == ';') === false)
|
|
&& (!$this->_isToken($tokens[$i], 'T_CLOSE_TAG'))
|
|
) {
|
|
$i += 1;
|
|
if ((($this->_isToken($tokens[$i], ')'))
|
|
|| ($this->_isToken($tokens[$i], 'T_WHITESPACE')))
|
|
&& $this->_isToken($tokens[$i+1], 'T_OBJECT_OPERATOR')) {
|
|
|
|
$php5_method_chaining = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Compare "ignore_functions_match" pre-condition
|
|
if (is_string($ifm_compare)) {
|
|
if (strcasecmp('preg_match', $ifm_compare) != 0) {
|
|
// Try to catch function_exists() condition
|
|
if ($this->_isToken($tokens[$i], 'T_STRING')
|
|
&& (strcasecmp($tokens[$i][1], $ifm_compare) == 0)) {
|
|
|
|
while ((!$this->_isToken($tokens[$i],
|
|
'T_CONSTANT_ENCAPSED_STRING'))) {
|
|
$i += 1;
|
|
}
|
|
$func = trim($tokens[$i][1], "'");
|
|
|
|
/**
|
|
* try if function_exists()
|
|
* match one or more pattern condition
|
|
*/
|
|
foreach ($ifm_patterns as $pattern) {
|
|
if (preg_match($pattern, $func) === 1) {
|
|
$ignore_functions[] = $func;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Compare "ignore_extensions_match" pre-condition
|
|
if (is_string($iem_compare)) {
|
|
if (strcasecmp('preg_match', $iem_compare) != 0) {
|
|
// Try to catch extension_loaded() condition
|
|
if ($this->_isToken($tokens[$i], 'T_STRING')
|
|
&& (strcasecmp($tokens[$i][1], $iem_compare) == 0)) {
|
|
|
|
while ((!$this->_isToken($tokens[$i],
|
|
'T_CONSTANT_ENCAPSED_STRING'))) {
|
|
$i += 1;
|
|
}
|
|
$ext = trim($tokens[$i][1], "'");
|
|
|
|
/**
|
|
* try if extension_loaded()
|
|
* match one or more pattern condition
|
|
*/
|
|
foreach ($iem_patterns as $pattern) {
|
|
if (preg_match($pattern, $ext) === 1) {
|
|
$ignore_extensions[] = $ext;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Compare "ignore_constants_match" pre-condition
|
|
if (is_string($icm_compare)) {
|
|
if (strcasecmp('preg_match', $icm_compare) != 0) {
|
|
// Try to catch defined() condition
|
|
if ($this->_isToken($tokens[$i], 'T_STRING')
|
|
&& (strcasecmp($tokens[$i][1], $icm_compare) == 0)) {
|
|
|
|
while ((!$this->_isToken($tokens[$i],
|
|
'T_CONSTANT_ENCAPSED_STRING'))) {
|
|
$i += 1;
|
|
}
|
|
$cst = trim($tokens[$i][1], "'");
|
|
|
|
/**
|
|
* try if defined()
|
|
* match one or more pattern condition
|
|
*/
|
|
foreach ($icm_patterns as $pattern) {
|
|
if (preg_match($pattern, $cst) === 1) {
|
|
$ignore_constants[] = $cst;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// try to detect class instantiation
|
|
if ($this->_isToken($tokens[$i], 'T_STRING')
|
|
&& (isset($tokens[$i-2]))
|
|
&& $this->_isToken($tokens[$i-2], 'T_NEW')) {
|
|
|
|
$is_class = true;
|
|
$classes[] = $tokens[$i][1];
|
|
} else {
|
|
$is_class = false;
|
|
}
|
|
|
|
if ($this->_isToken($tokens[$i], 'T_STRING')
|
|
&& $is_class == false
|
|
&& (isset($tokens[$i+1]))
|
|
&& $this->_isToken($tokens[$i+1], '(')) {
|
|
|
|
$is_function = false;
|
|
|
|
if (isset($tokens[$i-1])
|
|
&& !$this->_isToken($tokens[$i-1], 'T_DOUBLE_COLON')
|
|
&& !$this->_isToken($tokens[$i-1], 'T_OBJECT_OPERATOR')) {
|
|
|
|
if (isset($tokens[$i-2])
|
|
&& $this->_isToken($tokens[$i-2], 'T_FUNCTION')) {
|
|
// its a function declaration
|
|
} else {
|
|
$is_function = true;
|
|
}
|
|
}
|
|
if ($is_function == true || !is_array($tokens[$i-1])) {
|
|
$functions[] = strtolower($tokens[$i][1]);
|
|
}
|
|
}
|
|
|
|
// try to detect condition function_exists()
|
|
if ($this->_isToken($tokens[$i], 'T_STRING')
|
|
&& (strcasecmp($tokens[$i][1], 'function_exists') == 0)) {
|
|
|
|
$j = $i;
|
|
while ((!$this->_isToken($tokens[$j], ')'))) {
|
|
if ($this->_isToken($tokens[$j], 'T_CONSTANT_ENCAPSED_STRING')) {
|
|
$t_string = $tokens[$j][1];
|
|
$t_string = trim($t_string, "'");
|
|
$t_string = trim($t_string, '"');
|
|
$function_exists[] = $t_string;
|
|
}
|
|
$j++;
|
|
}
|
|
}
|
|
// try to detect condition extension_loaded()
|
|
if ($this->_isToken($tokens[$i], 'T_STRING')
|
|
&& (strcasecmp($tokens[$i][1], 'extension_loaded') == 0)) {
|
|
|
|
$j = $i;
|
|
while ((!$this->_isToken($tokens[$j], ')'))) {
|
|
if ($this->_isToken($tokens[$j], 'T_CONSTANT_ENCAPSED_STRING')) {
|
|
$t_string = $tokens[$j][1];
|
|
$t_string = trim($t_string, "'");
|
|
$t_string = trim($t_string, '"');
|
|
$extension_loaded[] = $t_string;
|
|
}
|
|
$j++;
|
|
}
|
|
}
|
|
// try to detect condition defined()
|
|
if ($this->_isToken($tokens[$i], 'T_STRING')
|
|
&& (strcasecmp($tokens[$i][1], 'defined') == 0)) {
|
|
|
|
$j = $i;
|
|
while ((!$this->_isToken($tokens[$j], ')'))) {
|
|
if ($this->_isToken($tokens[$j], 'T_CONSTANT_ENCAPSED_STRING')) {
|
|
$t_string = $tokens[$j][1];
|
|
$t_string = trim($t_string, "'");
|
|
$t_string = trim($t_string, '"');
|
|
$defined[] = $t_string;
|
|
}
|
|
$j++;
|
|
}
|
|
}
|
|
|
|
// try to detect beginning of a class
|
|
if ($this->_isToken($tokens[$i], 'T_CLASS')) {
|
|
$found_class = true;
|
|
}
|
|
|
|
if (is_array($tokens[$i])) {
|
|
if (!isset($akeys)) {
|
|
// build contents one time only (static variable)
|
|
$akeys = array_keys($GLOBALS['_PHP_COMPATINFO_CONST']);
|
|
}
|
|
$const = strtoupper($tokens[$i][1]);
|
|
$found = array_search($const, $akeys);
|
|
if ($found !== false) {
|
|
if ($this->_isToken($tokens[$i], 'T_ENCAPSED_AND_WHITESPACE')) {
|
|
// PHP 5 constant tokens found into a string
|
|
} else {
|
|
// Compare "ignore_constants_match" free condition
|
|
$icm_preg_match = false;
|
|
if (is_string($icm_compare)) {
|
|
if (strcasecmp('preg_match', $icm_compare) == 0) {
|
|
/**
|
|
* try if preg_match()
|
|
* match one or more pattern condition
|
|
*/
|
|
foreach ($icm_patterns as $pattern) {
|
|
if (preg_match($pattern, $const) === 1) {
|
|
$icm_preg_match = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
$init = $GLOBALS['_PHP_COMPATINFO_CONST'][$const]['init'];
|
|
if (!PHP_CompatInfo_Parser::_ignore($init,
|
|
$min_ver, $max_ver)) {
|
|
$constants[] = $const;
|
|
if (in_array($const, $ignore_constants)
|
|
|| in_array($const, $options['ignore_constants'])
|
|
|| $icm_preg_match) {
|
|
$ignored_constants[] = $const;
|
|
} else {
|
|
$latest_version = $init;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
$i += 1;
|
|
}
|
|
|
|
$classes = array_unique($classes);
|
|
$functions = array_unique($functions);
|
|
if (isset($options['ignore_functions'])) {
|
|
$options['ignore_functions']
|
|
= array_map('strtolower', $options['ignore_functions']);
|
|
} else {
|
|
$options['ignore_functions'] = array();
|
|
}
|
|
if (count($ignore_functions) > 0) {
|
|
$ignore_functions = array_map('strtolower', $ignore_functions);
|
|
$options['ignore_functions']
|
|
= array_merge($options['ignore_functions'], $ignore_functions);
|
|
$options['ignore_functions']
|
|
= array_unique($options['ignore_functions']);
|
|
}
|
|
if (count($ignore_extensions) > 0) {
|
|
$options['ignore_extensions']
|
|
= array_merge($options['ignore_extensions'], $ignore_extensions);
|
|
$options['ignore_extensions']
|
|
= array_unique($options['ignore_extensions']);
|
|
}
|
|
|
|
foreach ($classes as $name) {
|
|
if (!isset($GLOBALS['_PHP_COMPATINFO_CLASS'][$name])) {
|
|
continue; // skip this unknown class
|
|
}
|
|
$class = $GLOBALS['_PHP_COMPATINFO_CLASS'][$name];
|
|
if (PHP_CompatInfo_Parser::_ignore($class['init'], $min_ver, $max_ver)) {
|
|
continue; // skip this class version
|
|
}
|
|
|
|
$cmp = version_compare($latest_version, $class['init']);
|
|
if ($cmp === -1) {
|
|
$latest_version = $class['init'];
|
|
}
|
|
if (array_key_exists('end', $class)) {
|
|
$cmp = version_compare($earliest_version, $class['end']);
|
|
if ($earliest_version == '' || $cmp === 1) {
|
|
$earliest_version = $class['end'];
|
|
}
|
|
}
|
|
|
|
if (array_key_exists('ext', $class)) {
|
|
// this class depends of an extension
|
|
$extensions[] = $class['ext'];
|
|
}
|
|
}
|
|
|
|
foreach ($functions as $name) {
|
|
if (!isset($GLOBALS['_PHP_COMPATINFO_FUNCS'][$name])) {
|
|
continue; // skip this unknown function
|
|
}
|
|
$func = $GLOBALS['_PHP_COMPATINFO_FUNCS'][$name];
|
|
|
|
// retrieve if available the extension name
|
|
if ((isset($func['ext']))
|
|
&& ($func['ext'] != 'standard')
|
|
&& ($func['ext'] != 'zend')) {
|
|
$extension = $func['ext'];
|
|
} else {
|
|
$extension = false;
|
|
}
|
|
|
|
// Compare "ignore_functions_match" free condition
|
|
$ifm_preg_match = false;
|
|
if (is_string($ifm_compare)) {
|
|
if (strcasecmp('preg_match', $ifm_compare) == 0) {
|
|
/**
|
|
* try if preg_match()
|
|
* match one or more pattern condition
|
|
*/
|
|
foreach ($ifm_patterns as $pattern) {
|
|
if (preg_match($pattern, $name) === 1) {
|
|
$ifm_preg_match = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((!in_array($name, $udf))
|
|
&& (!in_array($name, $options['ignore_functions']))
|
|
&& ($ifm_preg_match === false)) {
|
|
|
|
if ($extension && !in_array($extension, $extensions)) {
|
|
$extensions[] = $extension;
|
|
}
|
|
|
|
// Compare "ignore_extensions_match" free condition
|
|
$iem_preg_match = false;
|
|
if (is_string($iem_compare)) {
|
|
if (strcasecmp('preg_match', $iem_compare) == 0) {
|
|
/**
|
|
* try if preg_match()
|
|
* match one or more pattern condition
|
|
*/
|
|
foreach ($iem_patterns as $pattern) {
|
|
if (preg_match($pattern, $extension) === 1) {
|
|
$iem_preg_match = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ($extension
|
|
&& (in_array($extension, $options['ignore_extensions'])
|
|
|| $iem_preg_match)) {
|
|
if (!in_array($extension, $ignored_extensions)) {
|
|
// extension is ignored (only once)
|
|
$ignored_extensions[] = $extension;
|
|
}
|
|
// all extension functions are also ignored
|
|
$ignored_functions[] = $name;
|
|
continue; // skip this extension function
|
|
}
|
|
|
|
if (PHP_CompatInfo_Parser::_ignore($func['init'],
|
|
$min_ver, $max_ver)) {
|
|
continue; // skip this function version
|
|
}
|
|
|
|
if ($options['debug'] == true) {
|
|
$functions_version[$func['init']][] = array(
|
|
'function' => $name,
|
|
'extension' => $extension,
|
|
'pecl' => $func['pecl']
|
|
);
|
|
}
|
|
if ($extension === false
|
|
|| (isset($func['pecl']) && $func['pecl'] === false) ) {
|
|
$cmp = version_compare($latest_version, $func['init']);
|
|
if ($cmp === -1) {
|
|
$latest_version = $func['init'];
|
|
}
|
|
if (array_key_exists('end', $func)) {
|
|
$cmp = version_compare($earliest_version, $func['end']);
|
|
if ($earliest_version == '' || $cmp === 1) {
|
|
$earliest_version = $func['end'];
|
|
}
|
|
}
|
|
}
|
|
|
|
} else {
|
|
// function is ignored
|
|
$ignored_functions[] = $name;
|
|
}
|
|
}
|
|
|
|
$ignored_constants = array_unique($ignored_constants);
|
|
$constants = array_unique($constants);
|
|
foreach ($constants as $constant) {
|
|
$const = $GLOBALS['_PHP_COMPATINFO_CONST'][$constant];
|
|
if (PHP_CompatInfo_Parser::_ignore($const['init'], $min_ver, $max_ver)) {
|
|
continue; // skip this constant version
|
|
}
|
|
if (!in_array($constant, $ignored_constants)) {
|
|
$cmp = version_compare($latest_version, $const['init']);
|
|
if ($cmp === -1) {
|
|
$latest_version = $const['init'];
|
|
}
|
|
if (array_key_exists('end', $const)) {
|
|
$cmp = version_compare($earliest_version, $const['end']);
|
|
if ($earliest_version == '' || $cmp === 1) {
|
|
$earliest_version = $const['end'];
|
|
}
|
|
}
|
|
}
|
|
if (!in_array($const['name'], $constant_names)) {
|
|
// split PHP5 tokens and pure PHP constants
|
|
if ($const['name'] == strtolower($const['name'])) {
|
|
$token_names[] = $const['name'];
|
|
} else {
|
|
$constant_names[] = $const['name'];
|
|
}
|
|
}
|
|
}
|
|
|
|
if (isset($php5_method_chaining)
|
|
&& $php5_method_chaining === true
|
|
&& version_compare($latest_version, '5.0.0') < 0) {
|
|
// when PHP Method chaining is detected, only available for PHP 5
|
|
$latest_version = '5.0.0';
|
|
}
|
|
|
|
ksort($functions_version);
|
|
|
|
if (count($function_exists) > 0) {
|
|
$function_exists = array_unique($function_exists);
|
|
$cond_code += 1;
|
|
}
|
|
if (count($extension_loaded) > 0) {
|
|
$extension_loaded = array_unique($extension_loaded);
|
|
$cond_code += 2;
|
|
}
|
|
if (count($defined) > 0) {
|
|
$defined = array_unique($defined);
|
|
$cond_code += 4;
|
|
}
|
|
$cond_code = array($cond_code, array($function_exists,
|
|
$extension_loaded,
|
|
$defined));
|
|
|
|
sort($ignored_functions);
|
|
sort($ignored_extensions);
|
|
sort($ignored_constants);
|
|
sort($classes);
|
|
sort($functions);
|
|
natcasesort($extensions);
|
|
sort($constant_names);
|
|
sort($token_names);
|
|
$main_info = array('ignored_functions' => $ignored_functions,
|
|
'ignored_extensions' => $ignored_extensions,
|
|
'ignored_constants' => $ignored_constants,
|
|
'max_version' => $earliest_version,
|
|
'version' => $latest_version,
|
|
'classes' => $classes,
|
|
'functions' => $functions,
|
|
'extensions' => array_values($extensions),
|
|
'constants' => $constant_names,
|
|
'tokens' => $token_names,
|
|
'cond_code' => $cond_code);
|
|
|
|
$functions_version = array_merge($main_info, $functions_version);
|
|
return $functions_version;
|
|
}
|
|
|
|
/**
|
|
* Checks if function which has $init version should be keep
|
|
* or ignore (version is between $min_ver and $max_ver).
|
|
*
|
|
* @param string $init version of current function
|
|
* @param string $min_ver minimum version of function to ignore
|
|
* @param string $max_ver maximum version of function to ignore
|
|
*
|
|
* @access private
|
|
* @return boolean True to ignore function/constant, false otherwise
|
|
* @since version 1.4.0 (2006-09-27)
|
|
* @static
|
|
*/
|
|
function _ignore($init, $min_ver, $max_ver)
|
|
{
|
|
if ($min_ver) {
|
|
$cmp = version_compare($init, $min_ver);
|
|
if ($max_ver && $cmp >= 0) {
|
|
$cmp = version_compare($init, $max_ver);
|
|
if ($cmp < 1) {
|
|
return true;
|
|
}
|
|
} elseif ($cmp === 0) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Checks if the given token is of this symbolic name
|
|
*
|
|
* @param mixed $token Single PHP token to test
|
|
* @param string $symbolic Symbolic name of the given token
|
|
*
|
|
* @access private
|
|
* @return bool
|
|
* @since version 1.7.0b4 (2008-04-03)
|
|
*/
|
|
function _isToken($token, $symbolic)
|
|
{
|
|
if (is_array($token)) {
|
|
$t = token_name($token[0]);
|
|
} else {
|
|
$t = $token;
|
|
}
|
|
return ($t == $symbolic);
|
|
}
|
|
|
|
/**
|
|
* Computes the difference of arrays
|
|
*
|
|
* Computes the difference of arrays and returns result without original keys
|
|
*
|
|
* @param array $array1 The array to compare from
|
|
* @param array $array2 The array to compare against
|
|
*
|
|
* @access private
|
|
* @static
|
|
* @link http://www.php.net/manual/en/function.array-diff.php#82297
|
|
* @return array
|
|
* @since version 1.8.0b2 (2008-06-03)
|
|
*/
|
|
function _arrayDiff($array1, $array2)
|
|
{
|
|
// This wrapper for array_diff rekeys the array returned
|
|
$valid_array = array_diff($array1, $array2);
|
|
|
|
// reinstantiate $array1 variable
|
|
$array1 = array();
|
|
|
|
// loop through the validated array and move elements to $array1
|
|
// this is necessary because the array_diff function
|
|
// returns arrays that retain their original keys
|
|
foreach ($valid_array as $valid) {
|
|
$array1[] = $valid;
|
|
}
|
|
return $array1;
|
|
}
|
|
}
|
|
?>
|