 |
PHK Manager |  |
|
| Size: | 12958 |
| Storage flags: |
<?php
//=============================================================================
//
// Copyright Francois Laupretre <automap@tekwire.net>
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
//=============================================================================
/**
* @copyright Francois Laupretre <automap@tekwire.net>
* @license http://www.apache.org/licenses/LICENSE-2.0 Apache License, V 2.0
* @category Automap
* @package Automap
*///==========================================================================
namespace Automap\Build {
//=============================================================================
//-- For PHP version < 5.3.0
// <Automap>:ignore constant T_NAMESPACE
if (!defined('T_NAMESPACE')) define('T_NAMESPACE',-2);
// <Automap>:ignore constant T_NS_SEPARATOR
if (!defined('T_NS_SEPARATOR')) define('T_NS_SEPARATOR',-3);
// <Automap>:ignore constant T_CONST
if (!defined('T_CONST')) define('T_CONST',-4);
// <Automap>:ignore constant T_TRAIT
if (!defined('T_TRAIT')) define('T_TRAIT',-5);
//===========================================================================
/**
* The Automap parser
*
* This class analyzes PHP scripts, packages, or extensions to extract the
* symbols they define
*
* API status: Public
* Included in the PHK PHP runtime: No
* Implemented in the extension: No
*///==========================================================================
if (!class_exists('Automap\Build\Parser',false))
{
class Parser implements ParserInterface
{
//-- Parser states :
const ST_OUT=1; // Upper level
const ST_FUNCTION_FOUND=\Automap\Mgr::T_FUNCTION; // Found 'function'. Looking for name
const ST_SKIPPING_BLOCK_NOSTRING=3; // In block, outside of string
const ST_SKIPPING_BLOCK_STRING=4; // In block, in string
const ST_CLASS_FOUND=\Automap\Mgr::T_CLASS; // Found 'class'. Looking for name
const ST_DEFINE_FOUND=6; // Found 'define'. Looking for '('
const ST_DEFINE_2=7; // Found '('. Looking for constant name
const ST_SKIPPING_TO_EOL=8; // Got constant. Looking for EOL (';')
const ST_NAMESPACE_FOUND=9; // Found 'namespace'. Looking for <whitespace>
const ST_NAMESPACE_2=10; // Found 'namespace' and <whitespace>. Looking for name
const ST_CONST_FOUND=11; // Found 'const'. Looking for name
const AUTOMAP_COMMENT=',// *<Automap>:(\S+)(.*)$,';
//---------
/** @var array(array('type' => <symbol type>,'name' => <case-sensitive symbol name>)) */
private $symbols;
/** @var array(symbol keys) A list of symbols to exclude */
private $exclude_list;
//---------------------------------------------------------------------------
/**
* Constructor
*/
public function __construct()
{
$this->symbols=array();
$this->exclude_list=array();
}
//---------------------------------
private function cleanup()
{
// Filter out excluded symbols
if (count($this->exclude_list))
{
foreach(array_keys($this->symbols) as $n)
{
$s=$this->symbols[$n];
$key=\Automap\Map::key($s['type'],$s['name']);
if (array_search($key,$this->exclude_list)!==false)
unset($this->symbols[$n]);
}
}
$a=$this->symbols;
$this->symbols=array();
$this->exclude_list=array();
return $a;
}
//---------------------------------
/**
* Mark a symbol as excluded
*
* @param string $type one of the \Automap\Mgr::T_xx constants
* @param string $name The symbol name
* @return null
*/
private function exclude($type,$name)
{
$this->exclude_list[]=\Automap\Map::key($type,$name);
}
//---------------------------------
/**
* Add a symbol into the table
*
* Filter out the symbol from the exclude list
*
* @param string $type one of the \Automap\Mgr::T_xx constants
* @param string $name The symbol name
* @return null
*/
private function addSymbol($type,$name)
{
$this->symbols[]=array('type' => $type, 'name' => $name);
}
//---------------------------------
/**
* Extracts symbols from an extension
*
* @param string $file Extension name
* @return null
* @throw \Exception if extension cannot be loaded
*/
public function parseExtension($file)
{
$extension_list=get_loaded_extensions();
@dl($file);
$a=array_diff(get_loaded_extensions(),$extension_list);
if (($ext_name=array_pop($a))===NULL)
throw new \Exception($file.': Cannot load extension');
$this->addSymbol(\Automap\Mgr::T_EXTENSION,$ext_name);
$ext=new \ReflectionExtension($ext_name);
foreach($ext->getFunctions() as $func)
$this->addSymbol(\Automap\Mgr::T_FUNCTION,$func->getName());
foreach(array_keys($ext->getConstants()) as $constant)
$this->addSymbol(\Automap\Mgr::T_CONSTANT,$constant);
foreach($ext->getClasses() as $class)
$this->addSymbol(\Automap\Mgr::T_CLASS,$class->getName());
if (method_exists($ext,'getInterfaces')) // Compatibility
{
foreach($ext->getInterfaces() as $interface)
$this->addSymbol(\Automap\Mgr::T_CLASS,$interface->getName());
}
if (method_exists($ext,'getTraits')) // Compatibility
{
foreach($ext->getTraits() as $trait)
$this->addSymbol(\Automap\Mgr::T_CLASS,$trait->getName());
}
return $this->cleanup();
}
//---------------------------------
/**
* Combine a namespace with a symbol
*
* The leading and trailing backslashes are first suppressed from the namespace.
* Then, if the namespace is not empty it is prepended to the symbol using a
* backslash.
*
* @param string $ns Namespace (can be empty)
* @param string $symbol Symbol name (cannot be empty)
* @return string Fully qualified name without leading backslash
*/
private static function combineNSSymbol($ns,$symbol)
{
$ns=trim($ns,'\\');
return $ns.(($ns==='') ? '' : '\\').$symbol;
}
//---------------------------------
/**
* Register explicit declarations
*
* Format:
* <double-slash> <Automap>:declare <type> <value>
* <double-slash> <Automap>:ignore <type> <value>
* <double-slash> <Automap>:ignore-file
* <double-slash> <Automap>:skip-blocks
*
* @return bool false if indexing is disabled on this file
*/
private function parseAutomapDirectives($buf,&$skip_blocks)
{
$a=null;
if (preg_match_all('{^//\s+\<Automap\>:(\S+)(.*)$}m',$buf,$a,PREG_SET_ORDER)!=0)
{
foreach($a as $match)
{
switch ($cmd=$match[1])
{
case 'ignore-file':
return false;
case 'skip-blocks':
$skip_blocks=true;
break;
case 'declare':
case 'ignore':
$type_string=strtolower(strtok($match[2],' '));
$name=strtok(' ');
if ($type_string===false || $name===false)
throw new \Exception($cmd.': Directive needs 2 args');
$type=\Automap\Mgr::stringToType($type_string);
if ($cmd=='declare')
$this->addSymbol($type,$name);
else
$this->exclude($type,$name);
break;
default:
throw new \Exception($cmd.': Invalid Automap directive');
}
}
}
return true;
}
//---------------------------------
/**
* Extracts symbols from a PHP script file
*
* @param string $path FIle to parse
* @return array of symbols
* @throws \Exception on parse error
*/
public function parseScriptFile($path)
{
try
{
// Don't run PECL accelerated read for virtual files
$buf=((function_exists('\Automap\Ext\file_get_contents')
&& (strpos($path,'://')===false)) ?
\Automap\Ext\file_get_contents($path)
: file_get_contents($path));
$ret=$this->parseScript($buf);
return $ret;
}
catch (\Exception $e)
{ throw new \Exception("$path: ".$e->getMessage()); }
}
//---------------------------------
/**
* Extracts symbols from a PHP script contained in a string
*
* @param string $buf The script to parse
* @return array of symbols
* @throws \Exception on parse error
*/
public function parseScript($buf)
{
$buf=str_replace("\r",'',$buf);
$skip_blocks=false;
if (!$this->parseAutomapDirectives($buf,$skip_blocks)) return array();
if (function_exists('\Automap\Ext\parseTokens'))
{ // If PECL function is available
$a=\Automap\Ext\parseTokens($buf,$skip_blocks);
//var_dump($a);//TRACE
foreach($a as $k) $this->addSymbol($k{0},substr($k,1));
}
else
{
$this->parseTokens($buf,$skip_blocks);
}
return $this->cleanup();
}
//---------------------------------
/**
* Extract symbols from script tokens
*/
private function parseTokens($buf,$skip_blocks)
{
$block_level=0;
$state=self::ST_OUT;
$name='';
$ns='';
// Note: Using php_strip_whitespace() before token_get_all does not improve
// performance.
foreach(token_get_all($buf) as $token)
{
if (is_string($token))
{
$tvalue=$token;
$tnum=-1;
$tname='String';
}
else
{
list($tnum,$tvalue)=$token;
$tname=token_name($tnum);
}
if (($tnum==T_COMMENT)||($tnum==T_DOC_COMMENT)) continue;
if (($tnum==T_WHITESPACE)&&($state!=self::ST_NAMESPACE_FOUND)) continue;
//echo "$tname <$tvalue>\n";//TRACE
switch($state)
{
case self::ST_OUT:
switch($tnum)
{
case T_FUNCTION:
$state=self::ST_FUNCTION_FOUND;
break;
case T_CLASS:
case T_INTERFACE:
case T_TRAIT:
$state=self::ST_CLASS_FOUND;
break;
case T_NAMESPACE:
$state=self::ST_NAMESPACE_FOUND;
$name='';
break;
case T_CONST:
$state=self::ST_CONST_FOUND;
break;
case T_STRING:
if ($tvalue=='define') $state=self::ST_DEFINE_FOUND;
$name='';
break;
// If this flag is set, we skip anything enclosed
// between {} chars, ignoring any conditional block.
case -1:
if ($tvalue=='{' && $skip_blocks)
{
$state=self::ST_SKIPPING_BLOCK_NOSTRING;
$block_level=1;
}
break;
}
break;
case self::ST_NAMESPACE_FOUND:
$state=($tnum==T_WHITESPACE) ? self::ST_NAMESPACE_2 : self::ST_OUT;
break;
case self::ST_NAMESPACE_2:
switch($tnum)
{
case T_STRING:
$name .=$tvalue;
break;
case T_NS_SEPARATOR:
$name .= '\\';
break;
default:
$ns=$name;
$state=self::ST_OUT;
}
break;
case self::ST_FUNCTION_FOUND:
if (($tnum==-1)&&($tvalue=='('))
{ // Closure : Ignore (no function name to get here)
$state=self::ST_OUT;
break;
}
//-- Function returning ref: keep looking for name
if ($tnum==-1 && $tvalue=='&') break;
// No break here !
case self::ST_CLASS_FOUND:
if ($tnum==T_STRING)
{
$this->addSymbol($state,self::combineNSSymbol($ns,$tvalue));
}
else throw new \Exception('Unrecognized token for class/function definition'
."(type=$tnum ($tname);value='$tvalue'). String expected");
$state=self::ST_SKIPPING_BLOCK_NOSTRING;
$block_level=0;
break;
case self::ST_CONST_FOUND:
if ($tnum==T_STRING)
{
$this->addSymbol(\Automap\Mgr::T_CONSTANT,self::combineNSSymbol($ns,$tvalue));
}
else throw new \Exception('Unrecognized token for constant definition'
."(type=$tnum ($tname);value='$tvalue'). String expected");
$state=self::ST_OUT;
break;
case self::ST_SKIPPING_BLOCK_STRING:
if ($tnum==-1 && $tvalue=='"')
$state=self::ST_SKIPPING_BLOCK_NOSTRING;
break;
case self::ST_SKIPPING_BLOCK_NOSTRING:
if ($tnum==-1 || $tnum==T_CURLY_OPEN)
{
switch($tvalue)
{
case '"':
$state=self::ST_SKIPPING_BLOCK_STRING;
break;
case '{':
$block_level++;
//TRACE echo "block_level=$block_level\n";
break;
case '}':
$block_level--;
if ($block_level==0) $state=self::ST_OUT;
//TRACE echo "block_level=$block_level\n";
break;
}
}
break;
case self::ST_DEFINE_FOUND:
if ($tnum==-1 && $tvalue=='(') $state=self::ST_DEFINE_2;
else throw new \Exception('Unrecognized token for constant definition'
."(type=$tnum ($tname);value='$tvalue'). Expected '('");
break;
case self::ST_DEFINE_2:
// Remember: T_STRING is incorrect in 'define' as constant name.
// Current namespace is ignored in 'define' statement.
if ($tnum==T_CONSTANT_ENCAPSED_STRING)
{
$schar=$tvalue{0};
if ($schar=="'" || $schar=='"') $tvalue=trim($tvalue,$schar);
$this->addSymbol(\Automap\Mgr::T_CONSTANT,$tvalue);
}
else throw new \Exception('Unrecognized token for constant definition'
."(type=$tnum ($tname);value='$tvalue'). Expected quoted string constant");
$state=self::ST_SKIPPING_TO_EOL;
break;
case self::ST_SKIPPING_TO_EOL:
if ($tnum==-1 && $tvalue==';') $state=self::ST_OUT;
break;
}
}
}
//---
} // End of class
//===========================================================================
} // End of class_exists
//===========================================================================
} // End of namespace
//===========================================================================
?>