<?php
/**
* Zend Framework (http://framework.zend.com/)
*
* @link http://github.com/zendframework/zf2 for the canonical source repository
* @copyright Copyright (c) 2005-2014 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
namespace Zend\Code\Scanner;
use Zend\Code\Annotation\AnnotationManager;
use Zend\Code\Exception;
use Zend\Code\NameInformation;
class TokenArrayScanner implements ScannerInterface
{
/**
* @var bool
*/
protected $isScanned = false;
/**
* @var array
*/
protected $tokens = array();
/**
* @var null
*/
protected $docComment = null;
/**
* @var NameInformation
*/
protected $nameInformation = null;
/**
* @var array
*/
protected $infos = array();
/**
* @var AnnotationManager
*/
protected $annotationManager = null;
/**
* @param null|array $tokens
* @param null|AnnotationManager $annotationManager
*/
public function __construct($tokens, AnnotationManager $annotationManager = null)
{
$this->tokens = $tokens;
$this->annotationManager = $annotationManager;
}
/**
* @return AnnotationManager
*/
public function getAnnotationManager()
{
return $this->annotationManager;
}
/**
* Get doc comment
*
* @todo Assignment of $this->docComment should probably be done in scan()
* and then $this->getDocComment() just retrieves it.
*
* @return string
*/
public function getDocComment()
{
foreach ($this->tokens as $token) {
$type = $token[0];
$value = $token[1];
if (($type == T_OPEN_TAG) || ($type == T_WHITESPACE)) {
continue;
} elseif ($type == T_DOC_COMMENT) {
$this->docComment = $value;
return $this->docComment;
} else {
// Only whitespace is allowed before file docblocks
return;
}
}
}
/**
* @return array
*/
public function getNamespaces()
{
$this->scan();
$namespaces = array();
foreach ($this->infos as $info) {
if ($info['type'] == 'namespace') {
$namespaces[] = $info['namespace'];
}
}
return $namespaces;
}
/**
* @param null|string $namespace
* @return array|null
*/
public function getUses($namespace = null)
{
$this->scan();
return $this->getUsesNoScan($namespace);
}
/**
* @return array
*/
public function getIncludes()
{
$this->scan();
// @todo Implement getIncludes() in TokenArrayScanner
}
/**
* @return array
*/
public function getClassNames()
{
$this->scan();
$return = array();
foreach ($this->infos as $info) {
if ($info['type'] != 'class') {
continue;
}
$return[] = $info['name'];
}
return $return;
}
/**
* @return ClassScanner[]
*/
public function getClasses()
{
$this->scan();
$return = array();
foreach ($this->infos as $info) {
if ($info['type'] != 'class') {
continue;
}
$return[] = $this->getClass($info['name']);
}
return $return;
}
/**
* Return the class object from this scanner
*
* @param string|int $name
* @throws Exception\InvalidArgumentException
* @return ClassScanner
*/
public function getClass($name)
{
$this->scan();
if (is_int($name)) {
$info = $this->infos[$name];
if ($info['type'] != 'class') {
throw new Exception\InvalidArgumentException('Index of info offset is not about a class');
}
} elseif (is_string($name)) {
$classFound = false;
foreach ($this->infos as $info) {
if ($info['type'] === 'class' && $info['name'] === $name) {
$classFound = true;
break;
}
}
if (!$classFound) {
return false;
}
}
return new ClassScanner(
array_slice(
$this->tokens,
$info['tokenStart'],
($info['tokenEnd'] - $info['tokenStart'] + 1)
), // zero indexed array
new NameInformation($info['namespace'], $info['uses'])
);
}
/**
* @param string $className
* @return bool|null|NameInformation
*/
public function getClassNameInformation($className)
{
$this->scan();
$classFound = false;
foreach ($this->infos as $info) {
if ($info['type'] === 'class' && $info['name'] === $className) {
$classFound = true;
break;
}
}
if (!$classFound) {
return false;
}
if (!isset($info)) {
return null;
}
return new NameInformation($info['namespace'], $info['uses']);
}
/**
* @return array
*/
public function getFunctionNames()
{
$this->scan();
$functionNames = array();
foreach ($this->infos as $info) {
if ($info['type'] == 'function') {
$functionNames[] = $info['name'];
}
}
return $functionNames;
}
/**
* @return array
*/
public function getFunctions()
{
$this->scan();
$functions = array();
foreach ($this->infos as $info) {
if ($info['type'] == 'function') {
// @todo $functions[] = new FunctionScanner($info['name']);
}
}
return $functions;
}
/**
* Export
*
* @param $tokens
*/
public static function export($tokens)
{
// @todo
}
public function __toString()
{
// @todo
}
/**
* Scan
*
* @todo: $this->docComment should be assigned for valid docblock during
* the scan instead of $this->getDocComment() (starting with
* T_DOC_COMMENT case)
*
* @throws Exception\RuntimeException
*/
protected function scan()
{
if ($this->isScanned) {
return;
}
if (!$this->tokens) {
throw new Exception\RuntimeException('No tokens were provided');
}
/**
* Variables & Setup
*/
$tokens = &$this->tokens; // localize
$infos = &$this->infos; // localize
$tokenIndex = null;
$token = null;
$tokenType = null;
$tokenContent = null;
$tokenLine = null;
$namespace = null;
$docCommentIndex = false;
$infoIndex = 0;
/*
* MACRO creation
*/
$MACRO_TOKEN_ADVANCE = function () use (&$tokens, &$tokenIndex, &$token, &$tokenType, &$tokenContent, &$tokenLine) {
$tokenIndex = ($tokenIndex === null) ? 0 : $tokenIndex + 1;
if (!isset($tokens[$tokenIndex])) {
$token = false;
$tokenContent = false;
$tokenType = false;
$tokenLine = false;
return false;
}
if (is_string($tokens[$tokenIndex]) && $tokens[$tokenIndex] === '"') {
do {
$tokenIndex++;
} while (!(is_string($tokens[$tokenIndex]) && $tokens[$tokenIndex] === '"'));
}
$token = $tokens[$tokenIndex];
if (is_array($token)) {
list($tokenType, $tokenContent, $tokenLine) = $token;
} else {
$tokenType = null;
$tokenContent = $token;
}
return $tokenIndex;
};
$MACRO_TOKEN_LOGICAL_START_INDEX = function () use (&$tokenIndex, &$docCommentIndex) {
return ($docCommentIndex === false) ? $tokenIndex : $docCommentIndex;
};
$MACRO_DOC_COMMENT_START = function () use (&$tokenIndex, &$docCommentIndex) {
$docCommentIndex = $tokenIndex;
return $docCommentIndex;
};
$MACRO_DOC_COMMENT_VALIDATE = function () use (&$tokenType, &$docCommentIndex) {
static $validTrailingTokens = null;
if ($validTrailingTokens === null) {
$validTrailingTokens = array(T_WHITESPACE, T_FINAL, T_ABSTRACT, T_INTERFACE, T_CLASS, T_FUNCTION);
}
if ($docCommentIndex !== false && !in_array($tokenType, $validTrailingTokens)) {
$docCommentIndex = false;
}
return $docCommentIndex;
};
$MACRO_INFO_ADVANCE = function () use (&$infoIndex, &$infos, &$tokenIndex, &$tokenLine) {
$infos[$infoIndex]['tokenEnd'] = $tokenIndex;
$infos[$infoIndex]['lineEnd'] = $tokenLine;
$infoIndex++;
return $infoIndex;
};
/**
* START FINITE STATE MACHINE FOR SCANNING TOKENS
*/
// Initialize token
$MACRO_TOKEN_ADVANCE();
SCANNER_TOP:
if ($token === false) {
goto SCANNER_END;
}
// Validate current doc comment index
$MACRO_DOC_COMMENT_VALIDATE();
switch ($tokenType) {
case T_DOC_COMMENT:
$MACRO_DOC_COMMENT_START();
goto SCANNER_CONTINUE;
case T_NAMESPACE:
$infos[$infoIndex] = array(
'type' => 'namespace',
'tokenStart' => $MACRO_TOKEN_LOGICAL_START_INDEX(),
'tokenEnd' => null,
'lineStart' => $token[2],
'lineEnd' => null,
'namespace' => null,
);
// start processing with next token
if ($MACRO_TOKEN_ADVANCE() === false) {
goto SCANNER_END;
}
SCANNER_NAMESPACE_TOP:
if ($tokenType === null && $tokenContent === ';' || $tokenContent === '{') {
goto SCANNER_NAMESPACE_END;
}
if ($tokenType === T_WHITESPACE) {
goto SCANNER_NAMESPACE_CONTINUE;
}
if ($tokenType === T_NS_SEPARATOR || $tokenType === T_STRING) {
$infos[$infoIndex]['namespace'] .= $tokenContent;
}
SCANNER_NAMESPACE_CONTINUE:
if ($MACRO_TOKEN_ADVANCE() === false) {
goto SCANNER_END;
}
goto SCANNER_NAMESPACE_TOP;
SCANNER_NAMESPACE_END:
$namespace = $infos[$infoIndex]['namespace'];
$MACRO_INFO_ADVANCE();
goto SCANNER_CONTINUE;
case T_USE:
$infos[$infoIndex] = array(
'type' => 'use',
'tokenStart' => $MACRO_TOKEN_LOGICAL_START_INDEX(),
'tokenEnd' => null,
'lineStart' => $tokens[$tokenIndex][2],
'lineEnd' => null,
'namespace' => $namespace,
'statements' => array(0 => array('use' => null,
'as' => null)),
);
$useStatementIndex = 0;
$useAsContext = false;
// start processing with next token
if ($MACRO_TOKEN_ADVANCE() === false) {
goto SCANNER_END;
}
SCANNER_USE_TOP:
if ($tokenType === null) {
if ($tokenContent === ';') {
goto SCANNER_USE_END;
} elseif ($tokenContent === ',') {
$useAsContext = false;
$useStatementIndex++;
$infos[$infoIndex]['statements'][$useStatementIndex] = array('use' => null,
'as' => null);
}
}
// ANALYZE
if ($tokenType !== null) {
if ($tokenType == T_AS) {
$useAsContext = true;
goto SCANNER_USE_CONTINUE;
}
if ($tokenType == T_NS_SEPARATOR || $tokenType == T_STRING) {
if ($useAsContext == false) {
$infos[$infoIndex]['statements'][$useStatementIndex]['use'] .= $tokenContent;
} else {
$infos[$infoIndex]['statements'][$useStatementIndex]['as'] = $tokenContent;
}
}
}
SCANNER_USE_CONTINUE:
if ($MACRO_TOKEN_ADVANCE() === false) {
goto SCANNER_END;
}
goto SCANNER_USE_TOP;
SCANNER_USE_END:
$MACRO_INFO_ADVANCE();
goto SCANNER_CONTINUE;
case T_INCLUDE:
case T_INCLUDE_ONCE:
case T_REQUIRE:
case T_REQUIRE_ONCE:
// Static for performance
static $includeTypes = array(
T_INCLUDE => 'include',
T_INCLUDE_ONCE => 'include_once',
T_REQUIRE => 'require',
T_REQUIRE_ONCE => 'require_once'
);
$infos[$infoIndex] = array(
'type' => 'include',
'tokenStart' => $MACRO_TOKEN_LOGICAL_START_INDEX(),
'tokenEnd' => null,
'lineStart' => $tokens[$tokenIndex][2],
'lineEnd' => null,
'includeType' => $includeTypes[$tokens[$tokenIndex][0]],
'path' => '',
);
// start processing with next token
if ($MACRO_TOKEN_ADVANCE() === false) {
goto SCANNER_END;
}
SCANNER_INCLUDE_TOP:
if ($tokenType === null && $tokenContent === ';') {
goto SCANNER_INCLUDE_END;
}
$infos[$infoIndex]['path'] .= $tokenContent;
SCANNER_INCLUDE_CONTINUE:
if ($MACRO_TOKEN_ADVANCE() === false) {
goto SCANNER_END;
}
goto SCANNER_INCLUDE_TOP;
SCANNER_INCLUDE_END:
$MACRO_INFO_ADVANCE();
goto SCANNER_CONTINUE;
case T_FUNCTION:
case T_FINAL:
case T_ABSTRACT:
case T_CLASS:
case T_INTERFACE:
$infos[$infoIndex] = array(
'type' => ($tokenType === T_FUNCTION) ? 'function' : 'class',
'tokenStart' => $MACRO_TOKEN_LOGICAL_START_INDEX(),
'tokenEnd' => null,
'lineStart' => $tokens[$tokenIndex][2],
'lineEnd' => null,
'namespace' => $namespace,
'uses' => $this->getUsesNoScan($namespace),
'name' => null,
'shortName' => null,
);
$classBraceCount = 0;
// start processing with current token
SCANNER_CLASS_TOP:
// process the name
if ($infos[$infoIndex]['shortName'] == ''
&& (($tokenType === T_CLASS || $tokenType === T_INTERFACE) && $infos[$infoIndex]['type'] === 'class'
|| ($tokenType === T_FUNCTION && $infos[$infoIndex]['type'] === 'function'))
) {
$infos[$infoIndex]['shortName'] = $tokens[$tokenIndex + 2][1];
$infos[$infoIndex]['name'] = (($namespace != null) ? $namespace . '\\' : '') . $infos[$infoIndex]['shortName'];
}
if ($tokenType === null) {
if ($tokenContent == '{') {
$classBraceCount++;
}
if ($tokenContent == '}') {
$classBraceCount--;
if ($classBraceCount === 0) {
goto SCANNER_CLASS_END;
}
}
}
SCANNER_CLASS_CONTINUE:
if ($MACRO_TOKEN_ADVANCE() === false) {
goto SCANNER_END;
}
goto SCANNER_CLASS_TOP;
SCANNER_CLASS_END:
$MACRO_INFO_ADVANCE();
goto SCANNER_CONTINUE;
}
SCANNER_CONTINUE:
if ($MACRO_TOKEN_ADVANCE() === false) {
goto SCANNER_END;
}
goto SCANNER_TOP;
SCANNER_END:
/**
* END FINITE STATE MACHINE FOR SCANNING TOKENS
*/
$this->isScanned = true;
}
/**
* Check for namespace
*
* @param string $namespace
* @return bool
*/
public function hasNamespace($namespace)
{
$this->scan();
foreach ($this->infos as $info) {
if ($info['type'] == 'namespace' && $info['namespace'] == $namespace) {
return true;
}
}
return false;
}
/**
* @param string $namespace
* @return null|array
* @throws Exception\InvalidArgumentException
*/
protected function getUsesNoScan($namespace)
{
$namespaces = array();
foreach ($this->infos as $info) {
if ($info['type'] == 'namespace') {
$namespaces[] = $info['namespace'];
}
}
if ($namespace === null) {
$namespace = array_shift($namespaces);
} elseif (!is_string($namespace)) {
throw new Exception\InvalidArgumentException('Invalid namespace provided');
} elseif (!in_array($namespace, $namespaces)) {
return null;
}
$uses = array();
foreach ($this->infos as $info) {
if ($info['type'] !== 'use') {
continue;
}
foreach ($info['statements'] as $statement) {
if ($info['namespace'] == $namespace) {
$uses[] = $statement;
}
}
}
return $uses;
}
}