Parser.php

Ir para a documentação deste ficheiro.

<?php
/*
 * 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.
 *
 * This software consists of voluntary contributions made by many individuals
 * and is licensed under the LGPL. For more information, see
 * <http://www.doctrine-project.org>.
 */
 
namespace Doctrine\Common\Annotations;
 
use Closure, Doctrine\Common\ClassLoader;
 
class Parser
{
    private static $strippedTags = array(
        "{@internal", "{@inheritdoc", "{@link"
    );
 
    private $lexer;
 
    protected $isNestedAnnotation = false;
 
    private $defaultAnnotationNamespace = '';
 
    private $namespaceAliases = array();
 
    private $context = '';
 
    private $autoloadAnnotations = false;
 
    private $annotationCreationFunction;
 
    public function __construct(Lexer $lexer = null)
    {
        $this->lexer = $lexer ?: new Lexer;
    }
 
    public function getLexer()
    {
        return $this->lexer;
    }
 
    public function setAutoloadAnnotations($bool)
    {
        $this->autoloadAnnotations = $bool;
    }
 
    public function setAnnotationCreationFunction(Closure $func)
    {
        $this->annotationCreationFunction = $func;
    }
 
    public function getAutoloadAnnotations()
    {
        return $this->autoloadAnnotations;
    }
 
    public function setDefaultAnnotationNamespace($defaultNamespace)
    {
        $this->defaultAnnotationNamespace = $defaultNamespace;
    }
 
    public function setAnnotationNamespaceAlias($namespace, $alias)
    {
        $this->namespaceAliases[$alias] = $namespace;
    }
 
    public function getNamespaceAliases()
    {
        return $this->namespaceAliases;
    }
 
    public function parse($docBlockString, $context='')
    {
        $this->context = $context;
 
        // Strip out some known inline tags.
        $input = str_replace(self::$strippedTags, '', $docBlockString);
 
        // Cut of the beginning of the input until the first '@'.
        $input = substr($input, strpos($input, '@'));
 
        $this->lexer->reset();
        $this->lexer->setInput(trim($input, '* /'));
        $this->lexer->moveNext();
 
        if ($this->lexer->isNextToken(Lexer::T_AT)) {
            return $this->Annotations();
        }
 
        return array();
    }
 
    public function match($token)
    {
        if ( ! ($this->lexer->lookahead['type'] === $token)) {
            $this->syntaxError($this->lexer->getLiteral($token));
        }
        $this->lexer->moveNext();
    }
 
    private function syntaxError($expected, $token = null)
    {
        if ($token === null) {
            $token = $this->lexer->lookahead;
        }
 
        $message =  "Expected {$expected}, got ";
 
        if ($this->lexer->lookahead === null) {
            $message .= 'end of string';
        } else {
            $message .= "'{$token['value']}' at position {$token['position']}";
        }
 
        if (strlen($this->context)) {
            $message .= ' in ' . $this->context;
        }
 
        $message .= '.';
 
        throw AnnotationException::syntaxError($message);
    }
 
    public function Annotations()
    {
        $this->isNestedAnnotation = false;
 
        $annotations = array();
        $annot = $this->Annotation();
 
        if ($annot !== false) {
            $annotations[get_class($annot)] = $annot;
            $this->lexer->skipUntil(Lexer::T_AT);
        }
 
        while ($this->lexer->lookahead !== null && $this->lexer->isNextToken(Lexer::T_AT)) {
            $this->isNestedAnnotation = false;
            $annot = $this->Annotation();
 
            if ($annot !== false) {
                $annotations[get_class($annot)] = $annot;
                $this->lexer->skipUntil(Lexer::T_AT);
            }
        }
 
        return $annotations;
    }
 
    public function Annotation()
    {
        $values = array();
        $nameParts = array();
 
        $this->match(Lexer::T_AT);
        $this->match(Lexer::T_IDENTIFIER);
        $nameParts[] = $this->lexer->token['value'];
 
        while ($this->lexer->isNextToken(Lexer::T_NAMESPACE_SEPARATOR)) {
            $this->match(Lexer::T_NAMESPACE_SEPARATOR);
            $this->match(Lexer::T_IDENTIFIER);
            $nameParts[] = $this->lexer->token['value'];
        }
 
        // Effectively pick the name of the class (append default NS if none, grab from NS alias, etc)
        if (strpos($nameParts[0], ':')) {
            list ($alias, $nameParts[0]) = explode(':', $nameParts[0]);
 
            // If the namespace alias doesnt exist, skip until next annotation
            if ( ! isset($this->namespaceAliases[$alias])) {
                $this->lexer->skipUntil(Lexer::T_AT);
                return false;
            }
 
            $name = $this->namespaceAliases[$alias] . implode('\\', $nameParts);
        } else if (count($nameParts) == 1) {
            $name = $this->defaultAnnotationNamespace . $nameParts[0];
        } else {
            $name = implode('\\', $nameParts);
        }
 
        // Does the annotation class exist?
        if ( ! class_exists($name, $this->autoloadAnnotations)) {
            $this->lexer->skipUntil(Lexer::T_AT);
            return false;
        }
 
        // Next will be nested
        $this->isNestedAnnotation = true;
 
        if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
            $this->match(Lexer::T_OPEN_PARENTHESIS);
 
            if ( ! $this->lexer->isNextToken(Lexer::T_CLOSE_PARENTHESIS)) {
                $values = $this->Values();
            }
 
            $this->match(Lexer::T_CLOSE_PARENTHESIS);
        }
 
        if ($this->annotationCreationFunction !== null) {
            $func = $this->annotationCreationFunction;
            $annot = $func($name, $values);
        }
 
        return isset($annot) ? $annot : $this->newAnnotation($name, $values);
    }
 
    public function Values()
    {
        $values = array();
 
        // Handle the case of a single array as value, i.e. @Foo({....})
        if ($this->lexer->isNextToken(Lexer::T_OPEN_CURLY_BRACES)) {
            $values['value'] = $this->Value();
            return $values;
        }
 
        $values[] = $this->Value();
 
        while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
            $this->match(Lexer::T_COMMA);
            $value = $this->Value();
 
            if ( ! is_array($value)) {
                $this->syntaxError('Value', $value);
            }
 
            $values[] = $value;
        }
 
        foreach ($values as $k => $value) {
            if (is_array($value) && is_string(key($value))) {
                $key = key($value);
                $values[$key] = $value[$key];
            } else {
                $values['value'] = $value;
            }
 
            unset($values[$k]);
        }
 
        return $values;
    }
 
    public function Value()
    {
        $peek = $this->lexer->glimpse();
 
        if ($peek['value'] === '=') {
            return $this->FieldAssignment();
        }
 
        return $this->PlainValue();
    }
 
    public function PlainValue()
    {
        if ($this->lexer->isNextToken(Lexer::T_OPEN_CURLY_BRACES)) {
            return $this->Arrayx();
        }
 
        if ($this->lexer->isNextToken(Lexer::T_AT)) {
            return $this->Annotation();
        }
 
        switch ($this->lexer->lookahead['type']) {
            case Lexer::T_STRING:
                $this->match(Lexer::T_STRING);
                return $this->lexer->token['value'];
 
            case Lexer::T_INTEGER:
                $this->match(Lexer::T_INTEGER);
                return $this->lexer->token['value'];
 
            case Lexer::T_FLOAT:
                $this->match(Lexer::T_FLOAT);
                return $this->lexer->token['value'];
 
            case Lexer::T_TRUE:
                $this->match(Lexer::T_TRUE);
                return true;
 
            case Lexer::T_FALSE:
                $this->match(Lexer::T_FALSE);
                return false;
 
            default:
                $this->syntaxError('PlainValue');
        }
    }
 
    public function FieldAssignment()
    {
        $this->match(Lexer::T_IDENTIFIER);
        $fieldName = $this->lexer->token['value'];
        $this->match(Lexer::T_EQUALS);
 
        return array($fieldName => $this->PlainValue());
    }
 
    public function Arrayx()
    {
        $array = $values = array();
 
        $this->match(Lexer::T_OPEN_CURLY_BRACES);
        $values[] = $this->ArrayEntry();
 
        while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
            $this->match(Lexer::T_COMMA);
            $values[] = $this->ArrayEntry();
        }
 
        $this->match(Lexer::T_CLOSE_CURLY_BRACES);
 
        foreach ($values as $value) {
            list ($key, $val) = $value;
 
            if ($key !== null) {
                $array[$key] = $val;
            } else {
                $array[] = $val;
            }
        }
 
        return $array;
    }
 
    public function ArrayEntry()
    {
        $peek = $this->lexer->glimpse();
 
        if ($peek['value'] == '=') {
            $this->match(
                $this->lexer->isNextToken(Lexer::T_INTEGER) ? Lexer::T_INTEGER : Lexer::T_STRING
            );
 
            $key = $this->lexer->token['value'];
            $this->match(Lexer::T_EQUALS);
 
            return array($key, $this->PlainValue());
        }
 
        return array(null, $this->Value());
    }
 
    protected function newAnnotation($name, array $values)
    {
        return new $name($values);
    }
}