Rajout du dossier core + MAJ .gitignore

core/vendor/symfony/expression-language/.gitignore

@@ -0,0 +1,3 @@
+vendor/
+composer.lock
+phpunit.xml

core/vendor/symfony/expression-language/CHANGELOG.md

@@ -0,0 +1,12 @@
+CHANGELOG
+=========
+
+2.6.0
+-----
+
+ * Added ExpressionFunction and ExpressionFunctionProviderInterface
+
+2.4.0
+-----
+
+ * added the component

core/vendor/symfony/expression-language/Compiler.php

@@ -0,0 +1,148 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage;
+
+/**
+ * Compiles a node to PHP code.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class Compiler
+{
+    private $source;
+    private $functions;
+
+    public function __construct(array $functions)
+    {
+        $this->functions = $functions;
+    }
+
+    public function getFunction($name)
+    {
+        return $this->functions[$name];
+    }
+
+    /**
+     * Gets the current PHP code after compilation.
+     *
+     * @return string The PHP code
+     */
+    public function getSource()
+    {
+        return $this->source;
+    }
+
+    public function reset()
+    {
+        $this->source = '';
+
+        return $this;
+    }
+
+    /**
+     * Compiles a node.
+     *
+     * @param Node\Node $node The node to compile
+     *
+     * @return Compiler The current compiler instance
+     */
+    public function compile(Node\Node $node)
+    {
+        $node->compile($this);
+
+        return $this;
+    }
+
+    public function subcompile(Node\Node $node)
+    {
+        $current = $this->source;
+        $this->source = '';
+
+        $node->compile($this);
+
+        $source = $this->source;
+        $this->source = $current;
+
+        return $source;
+    }
+
+    /**
+     * Adds a raw string to the compiled code.
+     *
+     * @param string $string The string
+     *
+     * @return Compiler The current compiler instance
+     */
+    public function raw($string)
+    {
+        $this->source .= $string;
+
+        return $this;
+    }
+
+    /**
+     * Adds a quoted string to the compiled code.
+     *
+     * @param string $value The string
+     *
+     * @return Compiler The current compiler instance
+     */
+    public function string($value)
+    {
+        $this->source .= sprintf('"%s"', addcslashes($value, "\0\t\"\$\\"));
+
+        return $this;
+    }
+
+    /**
+     * Returns a PHP representation of a given value.
+     *
+     * @param mixed $value The value to convert
+     *
+     * @return Compiler The current compiler instance
+     */
+    public function repr($value)
+    {
+        if (is_int($value) || is_float($value)) {
+            if (false !== $locale = setlocale(LC_NUMERIC, 0)) {
+                setlocale(LC_NUMERIC, 'C');
+            }
+
+            $this->raw($value);
+
+            if (false !== $locale) {
+                setlocale(LC_NUMERIC, $locale);
+            }
+        } elseif (null === $value) {
+            $this->raw('null');
+        } elseif (is_bool($value)) {
+            $this->raw($value ? 'true' : 'false');
+        } elseif (is_array($value)) {
+            $this->raw('array(');
+            $first = true;
+            foreach ($value as $key => $value) {
+                if (!$first) {
+                    $this->raw(', ');
+                }
+                $first = false;
+                $this->repr($key);
+                $this->raw(' => ');
+                $this->repr($value);
+            }
+            $this->raw(')');
+        } else {
+            $this->string($value);
+        }
+
+        return $this;
+    }
+}

core/vendor/symfony/expression-language/Expression.php

@@ -0,0 +1,42 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage;
+
+/**
+ * Represents an expression.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class Expression
+{
+    protected $expression;
+
+    /**
+     * Constructor.
+     *
+     * @param string $expression An expression
+     */
+    public function __construct($expression)
+    {
+        $this->expression = (string) $expression;
+    }
+
+    /**
+     * Gets the expression.
+     *
+     * @return string The expression
+     */
+    public function __toString()
+    {
+        return $this->expression;
+    }
+}

core/vendor/symfony/expression-language/ExpressionFunction.php

@@ -0,0 +1,65 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage;
+
+/**
+ * Represents a function that can be used in an expression.
+ *
+ * A function is defined by two PHP callables. The callables are used
+ * by the language to compile and/or evaluate the function.
+ *
+ * The "compiler" function is used at compilation time and must return a
+ * PHP representation of the function call (it receives the function
+ * arguments as arguments).
+ *
+ * The "evaluator" function is used for expression evaluation and must return
+ * the value of the function call based on the values defined for the
+ * expression (it receives the values as a first argument and the function
+ * arguments as remaining arguments).
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class ExpressionFunction
+{
+    private $name;
+    private $compiler;
+    private $evaluator;
+
+    /**
+     * Constructor.
+     *
+     * @param string   $name      The function name
+     * @param callable $compiler  A callable able to compile the function
+     * @param callable $evaluator A callable able to evaluate the function
+     */
+    public function __construct($name, $compiler, $evaluator)
+    {
+        $this->name = $name;
+        $this->compiler = $compiler;
+        $this->evaluator = $evaluator;
+    }
+
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    public function getCompiler()
+    {
+        return $this->compiler;
+    }
+
+    public function getEvaluator()
+    {
+        return $this->evaluator;
+    }
+}

core/vendor/symfony/expression-language/ExpressionFunctionProviderInterface.php

@@ -0,0 +1,23 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+interface ExpressionFunctionProviderInterface
+{
+    /**
+     * @return ExpressionFunction[] An array of Function instances
+     */
+    public function getFunctions();
+}

core/vendor/symfony/expression-language/ExpressionLanguage.php

@@ -0,0 +1,167 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage;
+
+use Symfony\Component\ExpressionLanguage\ParserCache\ArrayParserCache;
+use Symfony\Component\ExpressionLanguage\ParserCache\ParserCacheInterface;
+
+/**
+ * Allows to compile and evaluate expressions written in your own DSL.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class ExpressionLanguage
+{
+    /**
+     * @var ParserCacheInterface
+     */
+    private $cache;
+    private $lexer;
+    private $parser;
+    private $compiler;
+
+    protected $functions = array();
+
+    /**
+     * @param ParserCacheInterface                  $cache
+     * @param ExpressionFunctionProviderInterface[] $providers
+     */
+    public function __construct(ParserCacheInterface $cache = null, array $providers = array())
+    {
+        $this->cache = $cache ?: new ArrayParserCache();
+        $this->registerFunctions();
+        foreach ($providers as $provider) {
+            $this->registerProvider($provider);
+        }
+    }
+
+    /**
+     * Compiles an expression source code.
+     *
+     * @param Expression|string $expression The expression to compile
+     * @param array             $names      An array of valid names
+     *
+     * @return string The compiled PHP source code
+     */
+    public function compile($expression, $names = array())
+    {
+        return $this->getCompiler()->compile($this->parse($expression, $names)->getNodes())->getSource();
+    }
+
+    /**
+     * Evaluate an expression.
+     *
+     * @param Expression|string $expression The expression to compile
+     * @param array             $values     An array of values
+     *
+     * @return string The result of the evaluation of the expression
+     */
+    public function evaluate($expression, $values = array())
+    {
+        return $this->parse($expression, array_keys($values))->getNodes()->evaluate($this->functions, $values);
+    }
+
+    /**
+     * Parses an expression.
+     *
+     * @param Expression|string $expression The expression to parse
+     * @param array             $names      An array of valid names
+     *
+     * @return ParsedExpression A ParsedExpression instance
+     */
+    public function parse($expression, $names)
+    {
+        if ($expression instanceof ParsedExpression) {
+            return $expression;
+        }
+
+        asort($names);
+        $cacheKeyItems = array();
+
+        foreach ($names as $nameKey => $name) {
+            $cacheKeyItems[] = is_int($nameKey) ? $name : $nameKey.':'.$name;
+        }
+
+        $key = $expression.'//'.implode('|', $cacheKeyItems);
+
+        if (null === $parsedExpression = $this->cache->fetch($key)) {
+            $nodes = $this->getParser()->parse($this->getLexer()->tokenize((string) $expression), $names);
+            $parsedExpression = new ParsedExpression((string) $expression, $nodes);
+
+            $this->cache->save($key, $parsedExpression);
+        }
+
+        return $parsedExpression;
+    }
+
+    /**
+     * Registers a function.
+     *
+     * @param string   $name      The function name
+     * @param callable $compiler  A callable able to compile the function
+     * @param callable $evaluator A callable able to evaluate the function
+     *
+     * @see ExpressionFunction
+     */
+    public function register($name, $compiler, $evaluator)
+    {
+        $this->functions[$name] = array('compiler' => $compiler, 'evaluator' => $evaluator);
+    }
+
+    public function addFunction(ExpressionFunction $function)
+    {
+        $this->register($function->getName(), $function->getCompiler(), $function->getEvaluator());
+    }
+
+    public function registerProvider(ExpressionFunctionProviderInterface $provider)
+    {
+        foreach ($provider->getFunctions() as $function) {
+            $this->addFunction($function);
+        }
+    }
+
+    protected function registerFunctions()
+    {
+        $this->register('constant', function ($constant) {
+            return sprintf('constant(%s)', $constant);
+        }, function (array $values, $constant) {
+            return constant($constant);
+        });
+    }
+
+    private function getLexer()
+    {
+        if (null === $this->lexer) {
+            $this->lexer = new Lexer();
+        }
+
+        return $this->lexer;
+    }
+
+    private function getParser()
+    {
+        if (null === $this->parser) {
+            $this->parser = new Parser($this->functions);
+        }
+
+        return $this->parser;
+    }
+
+    private function getCompiler()
+    {
+        if (null === $this->compiler) {
+            $this->compiler = new Compiler($this->functions);
+        }
+
+        return $this->compiler->reset();
+    }
+}

core/vendor/symfony/expression-language/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2004-2016 Fabien Potencier
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished
+to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

core/vendor/symfony/expression-language/Lexer.php

@@ -0,0 +1,103 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage;
+
+/**
+ * Lexes an expression.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class Lexer
+{
+    /**
+     * Tokenizes an expression.
+     *
+     * @param string $expression The expression to tokenize
+     *
+     * @return TokenStream A token stream instance
+     *
+     * @throws SyntaxError
+     */
+    public function tokenize($expression)
+    {
+        $expression = str_replace(array("\r", "\n", "\t", "\v", "\f"), ' ', $expression);
+        $cursor = 0;
+        $tokens = array();
+        $brackets = array();
+        $end = strlen($expression);
+
+        while ($cursor < $end) {
+            if (' ' == $expression[$cursor]) {
+                ++$cursor;
+
+                continue;
+            }
+
+            if (preg_match('/[0-9]+(?:\.[0-9]+)?/A', $expression, $match, null, $cursor)) {
+                // numbers
+                $number = (float) $match[0];  // floats
+                if (ctype_digit($match[0]) && $number <= PHP_INT_MAX) {
+                    $number = (int) $match[0]; // integers lower than the maximum
+                }
+                $tokens[] = new Token(Token::NUMBER_TYPE, $number, $cursor + 1);
+                $cursor += strlen($match[0]);
+            } elseif (false !== strpos('([{', $expression[$cursor])) {
+                // opening bracket
+                $brackets[] = array($expression[$cursor], $cursor);
+
+                $tokens[] = new Token(Token::PUNCTUATION_TYPE, $expression[$cursor], $cursor + 1);
+                ++$cursor;
+            } elseif (false !== strpos(')]}', $expression[$cursor])) {
+                // closing bracket
+                if (empty($brackets)) {
+                    throw new SyntaxError(sprintf('Unexpected "%s"', $expression[$cursor]), $cursor);
+                }
+
+                list($expect, $cur) = array_pop($brackets);
+                if ($expression[$cursor] != strtr($expect, '([{', ')]}')) {
+                    throw new SyntaxError(sprintf('Unclosed "%s"', $expect), $cur);
+                }
+
+                $tokens[] = new Token(Token::PUNCTUATION_TYPE, $expression[$cursor], $cursor + 1);
+                ++$cursor;
+            } elseif (preg_match('/"([^"\\\\]*(?:\\\\.[^"\\\\]*)*)"|\'([^\'\\\\]*(?:\\\\.[^\'\\\\]*)*)\'/As', $expression, $match, null, $cursor)) {
+                // strings
+                $tokens[] = new Token(Token::STRING_TYPE, stripcslashes(substr($match[0], 1, -1)), $cursor + 1);
+                $cursor += strlen($match[0]);
+            } elseif (preg_match('/not in(?=[\s(])|\!\=\=|not(?=[\s(])|and(?=[\s(])|\=\=\=|\>\=|or(?=[\s(])|\<\=|\*\*|\.\.|in(?=[\s(])|&&|\|\||matches|\=\=|\!\=|\*|~|%|\/|\>|\||\!|\^|&|\+|\<|\-/A', $expression, $match, null, $cursor)) {
+                // operators
+                $tokens[] = new Token(Token::OPERATOR_TYPE, $match[0], $cursor + 1);
+                $cursor += strlen($match[0]);
+            } elseif (false !== strpos('.,?:', $expression[$cursor])) {
+                // punctuation
+                $tokens[] = new Token(Token::PUNCTUATION_TYPE, $expression[$cursor], $cursor + 1);
+                ++$cursor;
+            } elseif (preg_match('/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/A', $expression, $match, null, $cursor)) {
+                // names
+                $tokens[] = new Token(Token::NAME_TYPE, $match[0], $cursor + 1);
+                $cursor += strlen($match[0]);
+            } else {
+                // unlexable
+                throw new SyntaxError(sprintf('Unexpected character "%s"', $expression[$cursor]), $cursor);
+            }
+        }
+
+        $tokens[] = new Token(Token::EOF_TYPE, null, $cursor + 1);
+
+        if (!empty($brackets)) {
+            list($expect, $cur) = array_pop($brackets);
+            throw new SyntaxError(sprintf('Unclosed "%s"', $expect), $cur);
+        }
+
+        return new TokenStream($tokens);
+    }
+}

core/vendor/symfony/expression-language/Node/ArgumentsNode.php

@@ -0,0 +1,27 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class ArgumentsNode extends ArrayNode
+{
+    public function compile(Compiler $compiler)
+    {
+        $this->compileArguments($compiler, false);
+    }
+}

core/vendor/symfony/expression-language/Node/ArrayNode.php

@@ -0,0 +1,90 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class ArrayNode extends Node
+{
+    protected $index;
+
+    public function __construct()
+    {
+        $this->index = -1;
+    }
+
+    public function addElement(Node $value, Node $key = null)
+    {
+        if (null === $key) {
+            $key = new ConstantNode(++$this->index);
+        }
+
+        array_push($this->nodes, $key, $value);
+    }
+
+    /**
+     * Compiles the node to PHP.
+     *
+     * @param Compiler $compiler A Compiler instance
+     */
+    public function compile(Compiler $compiler)
+    {
+        $compiler->raw('array(');
+        $this->compileArguments($compiler);
+        $compiler->raw(')');
+    }
+
+    public function evaluate($functions, $values)
+    {
+        $result = array();
+        foreach ($this->getKeyValuePairs() as $pair) {
+            $result[$pair['key']->evaluate($functions, $values)] = $pair['value']->evaluate($functions, $values);
+        }
+
+        return $result;
+    }
+
+    protected function getKeyValuePairs()
+    {
+        $pairs = array();
+        foreach (array_chunk($this->nodes, 2) as $pair) {
+            $pairs[] = array('key' => $pair[0], 'value' => $pair[1]);
+        }
+
+        return $pairs;
+    }
+
+    protected function compileArguments(Compiler $compiler, $withKeys = true)
+    {
+        $first = true;
+        foreach ($this->getKeyValuePairs() as $pair) {
+            if (!$first) {
+                $compiler->raw(', ');
+            }
+            $first = false;
+
+            if ($withKeys) {
+                $compiler
+                    ->compile($pair['key'])
+                    ->raw(' => ')
+                ;
+            }
+
+            $compiler->compile($pair['value']);
+        }
+    }
+}

core/vendor/symfony/expression-language/Node/BinaryNode.php

@@ -0,0 +1,157 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class BinaryNode extends Node
+{
+    private static $operators = array(
+        '~' => '.',
+        'and' => '&&',
+        'or' => '||',
+    );
+
+    private static $functions = array(
+        '**' => 'pow',
+        '..' => 'range',
+        'in' => 'in_array',
+        'not in' => '!in_array',
+    );
+
+    public function __construct($operator, Node $left, Node $right)
+    {
+        parent::__construct(
+            array('left' => $left, 'right' => $right),
+            array('operator' => $operator)
+        );
+    }
+
+    public function compile(Compiler $compiler)
+    {
+        $operator = $this->attributes['operator'];
+
+        if ('matches' == $operator) {
+            $compiler
+                ->raw('preg_match(')
+                ->compile($this->nodes['right'])
+                ->raw(', ')
+                ->compile($this->nodes['left'])
+                ->raw(')')
+            ;
+
+            return;
+        }
+
+        if (isset(self::$functions[$operator])) {
+            $compiler
+                ->raw(sprintf('%s(', self::$functions[$operator]))
+                ->compile($this->nodes['left'])
+                ->raw(', ')
+                ->compile($this->nodes['right'])
+                ->raw(')')
+            ;
+
+            return;
+        }
+
+        if (isset(self::$operators[$operator])) {
+            $operator = self::$operators[$operator];
+        }
+
+        $compiler
+            ->raw('(')
+            ->compile($this->nodes['left'])
+            ->raw(' ')
+            ->raw($operator)
+            ->raw(' ')
+            ->compile($this->nodes['right'])
+            ->raw(')')
+        ;
+    }
+
+    public function evaluate($functions, $values)
+    {
+        $operator = $this->attributes['operator'];
+        $left = $this->nodes['left']->evaluate($functions, $values);
+
+        if (isset(self::$functions[$operator])) {
+            $right = $this->nodes['right']->evaluate($functions, $values);
+
+            if ('not in' === $operator) {
+                return !in_array($left, $right);
+            }
+            $f = self::$functions[$operator];
+
+            return $f($left, $right);
+        }
+
+        switch ($operator) {
+            case 'or':
+            case '||':
+                return $left || $this->nodes['right']->evaluate($functions, $values);
+            case 'and':
+            case '&&':
+                return $left && $this->nodes['right']->evaluate($functions, $values);
+        }
+
+        $right = $this->nodes['right']->evaluate($functions, $values);
+
+        switch ($operator) {
+            case '|':
+                return $left | $right;
+            case '^':
+                return $left ^ $right;
+            case '&':
+                return $left & $right;
+            case '==':
+                return $left == $right;
+            case '===':
+                return $left === $right;
+            case '!=':
+                return $left != $right;
+            case '!==':
+                return $left !== $right;
+            case '<':
+                return $left < $right;
+            case '>':
+                return $left > $right;
+            case '>=':
+                return $left >= $right;
+            case '<=':
+                return $left <= $right;
+            case 'not in':
+                return !in_array($left, $right);
+            case 'in':
+                return in_array($left, $right);
+            case '+':
+                return $left + $right;
+            case '-':
+                return $left - $right;
+            case '~':
+                return $left.$right;
+            case '*':
+                return $left * $right;
+            case '/':
+                return $left / $right;
+            case '%':
+                return $left % $right;
+            case 'matches':
+                return preg_match($right, $left);
+        }
+    }
+}

core/vendor/symfony/expression-language/Node/ConditionalNode.php

@@ -0,0 +1,51 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class ConditionalNode extends Node
+{
+    public function __construct(Node $expr1, Node $expr2, Node $expr3)
+    {
+        parent::__construct(
+            array('expr1' => $expr1, 'expr2' => $expr2, 'expr3' => $expr3)
+        );
+    }
+
+    public function compile(Compiler $compiler)
+    {
+        $compiler
+            ->raw('((')
+            ->compile($this->nodes['expr1'])
+            ->raw(') ? (')
+            ->compile($this->nodes['expr2'])
+            ->raw(') : (')
+            ->compile($this->nodes['expr3'])
+            ->raw('))')
+        ;
+    }
+
+    public function evaluate($functions, $values)
+    {
+        if ($this->nodes['expr1']->evaluate($functions, $values)) {
+            return $this->nodes['expr2']->evaluate($functions, $values);
+        }
+
+        return $this->nodes['expr3']->evaluate($functions, $values);
+    }
+}

core/vendor/symfony/expression-language/Node/ConstantNode.php

@@ -0,0 +1,40 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class ConstantNode extends Node
+{
+    public function __construct($value)
+    {
+        parent::__construct(
+            array(),
+            array('value' => $value)
+        );
+    }
+
+    public function compile(Compiler $compiler)
+    {
+        $compiler->repr($this->attributes['value']);
+    }
+
+    public function evaluate($functions, $values)
+    {
+        return $this->attributes['value'];
+    }
+}

core/vendor/symfony/expression-language/Node/FunctionNode.php

@@ -0,0 +1,52 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class FunctionNode extends Node
+{
+    public function __construct($name, Node $arguments)
+    {
+        parent::__construct(
+            array('arguments' => $arguments),
+            array('name' => $name)
+        );
+    }
+
+    public function compile(Compiler $compiler)
+    {
+        $arguments = array();
+        foreach ($this->nodes['arguments']->nodes as $node) {
+            $arguments[] = $compiler->subcompile($node);
+        }
+
+        $function = $compiler->getFunction($this->attributes['name']);
+
+        $compiler->raw(call_user_func_array($function['compiler'], $arguments));
+    }
+
+    public function evaluate($functions, $values)
+    {
+        $arguments = array($values);
+        foreach ($this->nodes['arguments']->nodes as $node) {
+            $arguments[] = $node->evaluate($functions, $values);
+        }
+
+        return call_user_func_array($functions[$this->attributes['name']]['evaluator'], $arguments);
+    }
+}

core/vendor/symfony/expression-language/Node/GetAttrNode.php

@@ -0,0 +1,97 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class GetAttrNode extends Node
+{
+    const PROPERTY_CALL = 1;
+    const METHOD_CALL = 2;
+    const ARRAY_CALL = 3;
+
+    public function __construct(Node $node, Node $attribute, ArrayNode $arguments, $type)
+    {
+        parent::__construct(
+            array('node' => $node, 'attribute' => $attribute, 'arguments' => $arguments),
+            array('type' => $type)
+        );
+    }
+
+    public function compile(Compiler $compiler)
+    {
+        switch ($this->attributes['type']) {
+            case self::PROPERTY_CALL:
+                $compiler
+                    ->compile($this->nodes['node'])
+                    ->raw('->')
+                    ->raw($this->nodes['attribute']->attributes['value'])
+                ;
+                break;
+
+            case self::METHOD_CALL:
+                $compiler
+                    ->compile($this->nodes['node'])
+                    ->raw('->')
+                    ->raw($this->nodes['attribute']->attributes['value'])
+                    ->raw('(')
+                    ->compile($this->nodes['arguments'])
+                    ->raw(')')
+                ;
+                break;
+
+            case self::ARRAY_CALL:
+                $compiler
+                    ->compile($this->nodes['node'])
+                    ->raw('[')
+                    ->compile($this->nodes['attribute'])->raw(']')
+                ;
+                break;
+        }
+    }
+
+    public function evaluate($functions, $values)
+    {
+        switch ($this->attributes['type']) {
+            case self::PROPERTY_CALL:
+                $obj = $this->nodes['node']->evaluate($functions, $values);
+                if (!is_object($obj)) {
+                    throw new \RuntimeException('Unable to get a property on a non-object.');
+                }
+
+                $property = $this->nodes['attribute']->attributes['value'];
+
+                return $obj->$property;
+
+            case self::METHOD_CALL:
+                $obj = $this->nodes['node']->evaluate($functions, $values);
+                if (!is_object($obj)) {
+                    throw new \RuntimeException('Unable to get a property on a non-object.');
+                }
+
+                return call_user_func_array(array($obj, $this->nodes['attribute']->attributes['value']), $this->nodes['arguments']->evaluate($functions, $values));
+
+            case self::ARRAY_CALL:
+                $array = $this->nodes['node']->evaluate($functions, $values);
+                if (!is_array($array) && !$array instanceof \ArrayAccess) {
+                    throw new \RuntimeException('Unable to get an item on a non-array.');
+                }
+
+                return $array[$this->nodes['attribute']->evaluate($functions, $values)];
+        }
+    }
+}

core/vendor/symfony/expression-language/Node/NameNode.php

@@ -0,0 +1,40 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class NameNode extends Node
+{
+    public function __construct($name)
+    {
+        parent::__construct(
+            array(),
+            array('name' => $name)
+        );
+    }
+
+    public function compile(Compiler $compiler)
+    {
+        $compiler->raw('$'.$this->attributes['name']);
+    }
+
+    public function evaluate($functions, $values)
+    {
+        return $values[$this->attributes['name']];
+    }
+}

core/vendor/symfony/expression-language/Node/Node.php

@@ -0,0 +1,78 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * Represents a node in the AST.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class Node
+{
+    public $nodes = array();
+    public $attributes = array();
+
+    /**
+     * Constructor.
+     *
+     * @param array $nodes      An array of nodes
+     * @param array $attributes An array of attributes
+     */
+    public function __construct(array $nodes = array(), array $attributes = array())
+    {
+        $this->nodes = $nodes;
+        $this->attributes = $attributes;
+    }
+
+    public function __toString()
+    {
+        $attributes = array();
+        foreach ($this->attributes as $name => $value) {
+            $attributes[] = sprintf('%s: %s', $name, str_replace("\n", '', var_export($value, true)));
+        }
+
+        $repr = array(str_replace('Symfony\Component\ExpressionLanguage\Node\\', '', get_class($this)).'('.implode(', ', $attributes));
+
+        if (count($this->nodes)) {
+            foreach ($this->nodes as $node) {
+                foreach (explode("\n", (string) $node) as $line) {
+                    $repr[] = '    '.$line;
+                }
+            }
+
+            $repr[] = ')';
+        } else {
+            $repr[0] .= ')';
+        }
+
+        return implode("\n", $repr);
+    }
+
+    public function compile(Compiler $compiler)
+    {
+        foreach ($this->nodes as $node) {
+            $node->compile($compiler);
+        }
+    }
+
+    public function evaluate($functions, $values)
+    {
+        $results = array();
+        foreach ($this->nodes as $node) {
+            $results[] = $node->evaluate($functions, $values);
+        }
+
+        return $results;
+    }
+}

core/vendor/symfony/expression-language/Node/UnaryNode.php

@@ -0,0 +1,61 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class UnaryNode extends Node
+{
+    private static $operators = array(
+        '!' => '!',
+        'not' => '!',
+        '+' => '+',
+        '-' => '-',
+    );
+
+    public function __construct($operator, Node $node)
+    {
+        parent::__construct(
+            array('node' => $node),
+            array('operator' => $operator)
+        );
+    }
+
+    public function compile(Compiler $compiler)
+    {
+        $compiler
+            ->raw('(')
+            ->raw(self::$operators[$this->attributes['operator']])
+            ->compile($this->nodes['node'])
+            ->raw(')')
+        ;
+    }
+
+    public function evaluate($functions, $values)
+    {
+        $value = $this->nodes['node']->evaluate($functions, $values);
+        switch ($this->attributes['operator']) {
+            case 'not':
+            case '!':
+                return !$value;
+            case '-':
+                return -$value;
+        }
+
+        return $value;
+    }
+}

core/vendor/symfony/expression-language/ParsedExpression.php

@@ -0,0 +1,42 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage;
+
+use Symfony\Component\ExpressionLanguage\Node\Node;
+
+/**
+ * Represents an already parsed expression.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class ParsedExpression extends Expression
+{
+    private $nodes;
+
+    /**
+     * Constructor.
+     *
+     * @param string $expression An expression
+     * @param Node   $nodes      A Node representing the expression
+     */
+    public function __construct($expression, Node $nodes)
+    {
+        parent::__construct($expression);
+
+        $this->nodes = $nodes;
+    }
+
+    public function getNodes()
+    {
+        return $this->nodes;
+    }
+}

core/vendor/symfony/expression-language/Parser.php

@@ -0,0 +1,384 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage;
+
+/**
+ * Parsers a token stream.
+ *
+ * This parser implements a "Precedence climbing" algorithm.
+ *
+ * @see http://www.engr.mun.ca/~theo/Misc/exp_parsing.htm
+ * @see http://en.wikipedia.org/wiki/Operator-precedence_parser
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class Parser
+{
+    const OPERATOR_LEFT = 1;
+    const OPERATOR_RIGHT = 2;
+
+    private $stream;
+    private $unaryOperators;
+    private $binaryOperators;
+    private $functions;
+    private $names;
+
+    public function __construct(array $functions)
+    {
+        $this->functions = $functions;
+
+        $this->unaryOperators = array(
+            'not' => array('precedence' => 50),
+            '!' => array('precedence' => 50),
+            '-' => array('precedence' => 500),
+            '+' => array('precedence' => 500),
+        );
+        $this->binaryOperators = array(
+            'or' => array('precedence' => 10, 'associativity' => self::OPERATOR_LEFT),
+            '||' => array('precedence' => 10, 'associativity' => self::OPERATOR_LEFT),
+            'and' => array('precedence' => 15, 'associativity' => self::OPERATOR_LEFT),
+            '&&' => array('precedence' => 15, 'associativity' => self::OPERATOR_LEFT),
+            '|' => array('precedence' => 16, 'associativity' => self::OPERATOR_LEFT),
+            '^' => array('precedence' => 17, 'associativity' => self::OPERATOR_LEFT),
+            '&' => array('precedence' => 18, 'associativity' => self::OPERATOR_LEFT),
+            '==' => array('precedence' => 20, 'associativity' => self::OPERATOR_LEFT),
+            '===' => array('precedence' => 20, 'associativity' => self::OPERATOR_LEFT),
+            '!=' => array('precedence' => 20, 'associativity' => self::OPERATOR_LEFT),
+            '!==' => array('precedence' => 20, 'associativity' => self::OPERATOR_LEFT),
+            '<' => array('precedence' => 20, 'associativity' => self::OPERATOR_LEFT),
+            '>' => array('precedence' => 20, 'associativity' => self::OPERATOR_LEFT),
+            '>=' => array('precedence' => 20, 'associativity' => self::OPERATOR_LEFT),
+            '<=' => array('precedence' => 20, 'associativity' => self::OPERATOR_LEFT),
+            'not in' => array('precedence' => 20, 'associativity' => self::OPERATOR_LEFT),
+            'in' => array('precedence' => 20, 'associativity' => self::OPERATOR_LEFT),
+            'matches' => array('precedence' => 20, 'associativity' => self::OPERATOR_LEFT),
+            '..' => array('precedence' => 25, 'associativity' => self::OPERATOR_LEFT),
+            '+' => array('precedence' => 30, 'associativity' => self::OPERATOR_LEFT),
+            '-' => array('precedence' => 30, 'associativity' => self::OPERATOR_LEFT),
+            '~' => array('precedence' => 40, 'associativity' => self::OPERATOR_LEFT),
+            '*' => array('precedence' => 60, 'associativity' => self::OPERATOR_LEFT),
+            '/' => array('precedence' => 60, 'associativity' => self::OPERATOR_LEFT),
+            '%' => array('precedence' => 60, 'associativity' => self::OPERATOR_LEFT),
+            '**' => array('precedence' => 200, 'associativity' => self::OPERATOR_RIGHT),
+        );
+    }
+
+    /**
+     * Converts a token stream to a node tree.
+     *
+     * The valid names is an array where the values
+     * are the names that the user can use in an expression.
+     *
+     * If the variable name in the compiled PHP code must be
+     * different, define it as the key.
+     *
+     * For instance, ['this' => 'container'] means that the
+     * variable 'container' can be used in the expression
+     * but the compiled code will use 'this'.
+     *
+     * @param TokenStream $stream A token stream instance
+     * @param array       $names  An array of valid names
+     *
+     * @return Node\Node A node tree
+     *
+     * @throws SyntaxError
+     */
+    public function parse(TokenStream $stream, $names = array())
+    {
+        $this->stream = $stream;
+        $this->names = $names;
+
+        $node = $this->parseExpression();
+        if (!$stream->isEOF()) {
+            throw new SyntaxError(sprintf('Unexpected token "%s" of value "%s"', $stream->current->type, $stream->current->value), $stream->current->cursor);
+        }
+
+        return $node;
+    }
+
+    public function parseExpression($precedence = 0)
+    {
+        $expr = $this->getPrimary();
+        $token = $this->stream->current;
+        while ($token->test(Token::OPERATOR_TYPE) && isset($this->binaryOperators[$token->value]) && $this->binaryOperators[$token->value]['precedence'] >= $precedence) {
+            $op = $this->binaryOperators[$token->value];
+            $this->stream->next();
+
+            $expr1 = $this->parseExpression(self::OPERATOR_LEFT === $op['associativity'] ? $op['precedence'] + 1 : $op['precedence']);
+            $expr = new Node\BinaryNode($token->value, $expr, $expr1);
+
+            $token = $this->stream->current;
+        }
+
+        if (0 === $precedence) {
+            return $this->parseConditionalExpression($expr);
+        }
+
+        return $expr;
+    }
+
+    protected function getPrimary()
+    {
+        $token = $this->stream->current;
+
+        if ($token->test(Token::OPERATOR_TYPE) && isset($this->unaryOperators[$token->value])) {
+            $operator = $this->unaryOperators[$token->value];
+            $this->stream->next();
+            $expr = $this->parseExpression($operator['precedence']);
+
+            return $this->parsePostfixExpression(new Node\UnaryNode($token->value, $expr));
+        }
+
+        if ($token->test(Token::PUNCTUATION_TYPE, '(')) {
+            $this->stream->next();
+            $expr = $this->parseExpression();
+            $this->stream->expect(Token::PUNCTUATION_TYPE, ')', 'An opened parenthesis is not properly closed');
+
+            return $this->parsePostfixExpression($expr);
+        }
+
+        return $this->parsePrimaryExpression();
+    }
+
+    protected function parseConditionalExpression($expr)
+    {
+        while ($this->stream->current->test(Token::PUNCTUATION_TYPE, '?')) {
+            $this->stream->next();
+            if (!$this->stream->current->test(Token::PUNCTUATION_TYPE, ':')) {
+                $expr2 = $this->parseExpression();
+                if ($this->stream->current->test(Token::PUNCTUATION_TYPE, ':')) {
+                    $this->stream->next();
+                    $expr3 = $this->parseExpression();
+                } else {
+                    $expr3 = new Node\ConstantNode(null);
+                }
+            } else {
+                $this->stream->next();
+                $expr2 = $expr;
+                $expr3 = $this->parseExpression();
+            }
+
+            $expr = new Node\ConditionalNode($expr, $expr2, $expr3);
+        }
+
+        return $expr;
+    }
+
+    public function parsePrimaryExpression()
+    {
+        $token = $this->stream->current;
+        switch ($token->type) {
+            case Token::NAME_TYPE:
+                $this->stream->next();
+                switch ($token->value) {
+                    case 'true':
+                    case 'TRUE':
+                        return new Node\ConstantNode(true);
+
+                    case 'false':
+                    case 'FALSE':
+                        return new Node\ConstantNode(false);
+
+                    case 'null':
+                    case 'NULL':
+                        return new Node\ConstantNode(null);
+
+                    default:
+                        if ('(' === $this->stream->current->value) {
+                            if (false === isset($this->functions[$token->value])) {
+                                throw new SyntaxError(sprintf('The function "%s" does not exist', $token->value), $token->cursor);
+                            }
+
+                            $node = new Node\FunctionNode($token->value, $this->parseArguments());
+                        } else {
+                            if (!in_array($token->value, $this->names, true)) {
+                                throw new SyntaxError(sprintf('Variable "%s" is not valid', $token->value), $token->cursor);
+                            }
+
+                            // is the name used in the compiled code different
+                            // from the name used in the expression?
+                            if (is_int($name = array_search($token->value, $this->names))) {
+                                $name = $token->value;
+                            }
+
+                            $node = new Node\NameNode($name);
+                        }
+                }
+                break;
+
+            case Token::NUMBER_TYPE:
+            case Token::STRING_TYPE:
+                $this->stream->next();
+
+                return new Node\ConstantNode($token->value);
+
+            default:
+                if ($token->test(Token::PUNCTUATION_TYPE, '[')) {
+                    $node = $this->parseArrayExpression();
+                } elseif ($token->test(Token::PUNCTUATION_TYPE, '{')) {
+                    $node = $this->parseHashExpression();
+                } else {
+                    throw new SyntaxError(sprintf('Unexpected token "%s" of value "%s"', $token->type, $token->value), $token->cursor);
+                }
+        }
+
+        return $this->parsePostfixExpression($node);
+    }
+
+    public function parseArrayExpression()
+    {
+        $this->stream->expect(Token::PUNCTUATION_TYPE, '[', 'An array element was expected');
+
+        $node = new Node\ArrayNode();
+        $first = true;
+        while (!$this->stream->current->test(Token::PUNCTUATION_TYPE, ']')) {
+            if (!$first) {
+                $this->stream->expect(Token::PUNCTUATION_TYPE, ',', 'An array element must be followed by a comma');
+
+                // trailing ,?
+                if ($this->stream->current->test(Token::PUNCTUATION_TYPE, ']')) {
+                    break;
+                }
+            }
+            $first = false;
+
+            $node->addElement($this->parseExpression());
+        }
+        $this->stream->expect(Token::PUNCTUATION_TYPE, ']', 'An opened array is not properly closed');
+
+        return $node;
+    }
+
+    public function parseHashExpression()
+    {
+        $this->stream->expect(Token::PUNCTUATION_TYPE, '{', 'A hash element was expected');
+
+        $node = new Node\ArrayNode();
+        $first = true;
+        while (!$this->stream->current->test(Token::PUNCTUATION_TYPE, '}')) {
+            if (!$first) {
+                $this->stream->expect(Token::PUNCTUATION_TYPE, ',', 'A hash value must be followed by a comma');
+
+                // trailing ,?
+                if ($this->stream->current->test(Token::PUNCTUATION_TYPE, '}')) {
+                    break;
+                }
+            }
+            $first = false;
+
+            // a hash key can be:
+            //
+            //  * a number -- 12
+            //  * a string -- 'a'
+            //  * a name, which is equivalent to a string -- a
+            //  * an expression, which must be enclosed in parentheses -- (1 + 2)
+            if ($this->stream->current->test(Token::STRING_TYPE) || $this->stream->current->test(Token::NAME_TYPE) || $this->stream->current->test(Token::NUMBER_TYPE)) {
+                $key = new Node\ConstantNode($this->stream->current->value);
+                $this->stream->next();
+            } elseif ($this->stream->current->test(Token::PUNCTUATION_TYPE, '(')) {
+                $key = $this->parseExpression();
+            } else {
+                $current = $this->stream->current;
+
+                throw new SyntaxError(sprintf('A hash key must be a quoted string, a number, a name, or an expression enclosed in parentheses (unexpected token "%s" of value "%s"', $current->type, $current->value), $current->cursor);
+            }
+
+            $this->stream->expect(Token::PUNCTUATION_TYPE, ':', 'A hash key must be followed by a colon (:)');
+            $value = $this->parseExpression();
+
+            $node->addElement($value, $key);
+        }
+        $this->stream->expect(Token::PUNCTUATION_TYPE, '}', 'An opened hash is not properly closed');
+
+        return $node;
+    }
+
+    public function parsePostfixExpression($node)
+    {
+        $token = $this->stream->current;
+        while ($token->type == Token::PUNCTUATION_TYPE) {
+            if ('.' === $token->value) {
+                $this->stream->next();
+                $token = $this->stream->current;
+                $this->stream->next();
+
+                if (
+                    $token->type !== Token::NAME_TYPE
+                    &&
+                    // Operators like "not" and "matches" are valid method or property names,
+                    //
+                    // In other words, besides NAME_TYPE, OPERATOR_TYPE could also be parsed as a property or method.
+                    // This is because operators are processed by the lexer prior to names. So "not" in "foo.not()" or "matches" in "foo.matches" will be recognized as an operator first.
+                    // But in fact, "not" and "matches" in such expressions shall be parsed as method or property names.
+                    //
+                    // And this ONLY works if the operator consists of valid characters for a property or method name.
+                    //
+                    // Other types, such as STRING_TYPE and NUMBER_TYPE, can't be parsed as property nor method names.
+                    //
+                    // As a result, if $token is NOT an operator OR $token->value is NOT a valid property or method name, an exception shall be thrown.
+                    ($token->type !== Token::OPERATOR_TYPE || !preg_match('/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/A', $token->value))
+                ) {
+                    throw new SyntaxError('Expected name', $token->cursor);
+                }
+
+                $arg = new Node\ConstantNode($token->value);
+
+                $arguments = new Node\ArgumentsNode();
+                if ($this->stream->current->test(Token::PUNCTUATION_TYPE, '(')) {
+                    $type = Node\GetAttrNode::METHOD_CALL;
+                    foreach ($this->parseArguments()->nodes as $n) {
+                        $arguments->addElement($n);
+                    }
+                } else {
+                    $type = Node\GetAttrNode::PROPERTY_CALL;
+                }
+
+                $node = new Node\GetAttrNode($node, $arg, $arguments, $type);
+            } elseif ('[' === $token->value) {
+                if ($node instanceof Node\GetAttrNode && Node\GetAttrNode::METHOD_CALL === $node->attributes['type'] && PHP_VERSION_ID < 50400) {
+                    throw new SyntaxError('Array calls on a method call is only supported on PHP 5.4+', $token->cursor);
+                }
+
+                $this->stream->next();
+                $arg = $this->parseExpression();
+                $this->stream->expect(Token::PUNCTUATION_TYPE, ']');
+
+                $node = new Node\GetAttrNode($node, $arg, new Node\ArgumentsNode(), Node\GetAttrNode::ARRAY_CALL);
+            } else {
+                break;
+            }
+
+            $token = $this->stream->current;
+        }
+
+        return $node;
+    }
+
+    /**
+     * Parses arguments.
+     */
+    public function parseArguments()
+    {
+        $args = array();
+        $this->stream->expect(Token::PUNCTUATION_TYPE, '(', 'A list of arguments must begin with an opening parenthesis');
+        while (!$this->stream->current->test(Token::PUNCTUATION_TYPE, ')')) {
+            if (!empty($args)) {
+                $this->stream->expect(Token::PUNCTUATION_TYPE, ',', 'Arguments must be separated by a comma');
+            }
+
+            $args[] = $this->parseExpression();
+        }
+        $this->stream->expect(Token::PUNCTUATION_TYPE, ')', 'A list of arguments must be closed by a parenthesis');
+
+        return new Node\Node($args);
+    }
+}

core/vendor/symfony/expression-language/ParserCache/ArrayParserCache.php

@@ -0,0 +1,41 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\ParserCache;
+
+use Symfony\Component\ExpressionLanguage\ParsedExpression;
+
+/**
+ * @author Adrien Brault <adrien.brault@gmail.com>
+ */
+class ArrayParserCache implements ParserCacheInterface
+{
+    /**
+     * @var array
+     */
+    private $cache = array();
+
+    /**
+     * {@inheritdoc}
+     */
+    public function fetch($key)
+    {
+        return isset($this->cache[$key]) ? $this->cache[$key] : null;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function save($key, ParsedExpression $expression)
+    {
+        $this->cache[$key] = $expression;
+    }
+}

core/vendor/symfony/expression-language/ParserCache/ParserCacheInterface.php

@@ -0,0 +1,37 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\ParserCache;
+
+use Symfony\Component\ExpressionLanguage\ParsedExpression;
+
+/**
+ * @author Adrien Brault <adrien.brault@gmail.com>
+ */
+interface ParserCacheInterface
+{
+    /**
+     * Saves an expression in the cache.
+     *
+     * @param string           $key        The cache key
+     * @param ParsedExpression $expression A ParsedExpression instance to store in the cache
+     */
+    public function save($key, ParsedExpression $expression);
+
+    /**
+     * Fetches an expression from the cache.
+     *
+     * @param string $key The cache key
+     *
+     * @return ParsedExpression|null
+     */
+    public function fetch($key);
+}

core/vendor/symfony/expression-language/README.md

@@ -0,0 +1,43 @@
+ExpressionLanguage Component
+============================
+
+The ExpressionLanguage component provides an engine that can compile and
+evaluate expressions:
+
+    use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
+
+    $language = new ExpressionLanguage();
+
+    echo $language->evaluate('1 + foo', array('foo' => 2));
+    // would output 3
+
+    echo $language->compile('1 + foo', array('foo'));
+    // would output (1 + $foo)
+
+By default, the engine implements simple math and logic functions, method
+calls, property accesses, and array accesses.
+
+You can extend your DSL with functions:
+
+    $compiler = function ($arg) {
+        return sprintf('strtoupper(%s)', $arg);
+    };
+    $evaluator = function (array $variables, $value) {
+        return strtoupper($value);
+    };
+    $language->register('upper', $compiler, $evaluator);
+
+    echo $language->evaluate('"foo" ~ upper(foo)', array('foo' => 'bar'));
+    // would output fooBAR
+
+    echo $language->compile('"foo" ~ upper(foo)');
+    // would output ("foo" . strtoupper($foo))
+
+Resources
+---------
+
+You can run the unit tests with the following command:
+
+    $ cd path/to/Symfony/Component/ExpressionLanguage/
+    $ composer.phar install --dev
+    $ phpunit

core/vendor/symfony/expression-language/Resources/bin/generate_operator_regex.php

@@ -0,0 +1,23 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+$operators = array('not', '!', 'or', '||', '&&', 'and', '|', '^', '&', '==', '===', '!=', '!==', '<', '>', '>=', '<=', 'not in', 'in', '..', '+', '-', '~', '*', '/', '%', 'matches', '**');
+$operators = array_combine($operators, array_map('strlen', $operators));
+arsort($operators);
+
+$regex = array();
+foreach ($operators as $operator => $length) {
+    // an operator that ends with a character must be followed by
+    // a whitespace or a parenthesis
+    $regex[] = preg_quote($operator, '/').(ctype_alpha($operator[$length - 1]) ? '(?=[\s(])' : '');
+}
+
+echo '/'.implode('|', $regex).'/A';

core/vendor/symfony/expression-language/SerializedParsedExpression.php

@@ -0,0 +1,39 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage;
+
+/**
+ * Represents an already parsed expression.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class SerializedParsedExpression extends ParsedExpression
+{
+    private $nodes;
+
+    /**
+     * Constructor.
+     *
+     * @param string $expression An expression
+     * @param string $nodes      The serialized nodes for the expression
+     */
+    public function __construct($expression, $nodes)
+    {
+        $this->expression = (string) $expression;
+        $this->nodes = $nodes;
+    }
+
+    public function getNodes()
+    {
+        return unserialize($this->nodes);
+    }
+}

core/vendor/symfony/expression-language/SyntaxError.php

@@ -0,0 +1,20 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage;
+
+class SyntaxError extends \LogicException
+{
+    public function __construct($message, $cursor = 0)
+    {
+        parent::__construct(sprintf('%s around position %d.', $message, $cursor));
+    }
+}

core/vendor/symfony/expression-language/Tests/ExpressionLanguageTest.php

@@ -0,0 +1,141 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Tests;
+
+use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
+use Symfony\Component\ExpressionLanguage\Tests\Fixtures\TestProvider;
+
+class ExpressionLanguageTest extends \PHPUnit_Framework_TestCase
+{
+    public function testCachedParse()
+    {
+        $cacheMock = $this->getMock('Symfony\Component\ExpressionLanguage\ParserCache\ParserCacheInterface');
+        $savedParsedExpression = null;
+        $expressionLanguage = new ExpressionLanguage($cacheMock);
+
+        $cacheMock
+            ->expects($this->exactly(2))
+            ->method('fetch')
+            ->with('1 + 1//')
+            ->will($this->returnCallback(function () use (&$savedParsedExpression) {
+                return $savedParsedExpression;
+            }))
+        ;
+        $cacheMock
+            ->expects($this->exactly(1))
+            ->method('save')
+            ->with('1 + 1//', $this->isInstanceOf('Symfony\Component\ExpressionLanguage\ParsedExpression'))
+            ->will($this->returnCallback(function ($key, $expression) use (&$savedParsedExpression) {
+                $savedParsedExpression = $expression;
+            }))
+        ;
+
+        $parsedExpression = $expressionLanguage->parse('1 + 1', array());
+        $this->assertSame($savedParsedExpression, $parsedExpression);
+
+        $parsedExpression = $expressionLanguage->parse('1 + 1', array());
+        $this->assertSame($savedParsedExpression, $parsedExpression);
+    }
+
+    public function testConstantFunction()
+    {
+        $expressionLanguage = new ExpressionLanguage();
+        $this->assertEquals(PHP_VERSION, $expressionLanguage->evaluate('constant("PHP_VERSION")'));
+
+        $expressionLanguage = new ExpressionLanguage();
+        $this->assertEquals('constant("PHP_VERSION")', $expressionLanguage->compile('constant("PHP_VERSION")'));
+    }
+
+    public function testProviders()
+    {
+        $expressionLanguage = new ExpressionLanguage(null, array(new TestProvider()));
+        $this->assertEquals('foo', $expressionLanguage->evaluate('identity("foo")'));
+        $this->assertEquals('"foo"', $expressionLanguage->compile('identity("foo")'));
+    }
+
+    /**
+     * @dataProvider shortCircuitProviderEvaluate
+     */
+    public function testShortCircuitOperatorsEvaluate($expression, array $values, $expected)
+    {
+        $expressionLanguage = new ExpressionLanguage();
+        $this->assertEquals($expected, $expressionLanguage->evaluate($expression, $values));
+    }
+
+    /**
+     * @dataProvider shortCircuitProviderCompile
+     */
+    public function testShortCircuitOperatorsCompile($expression, array $names, $expected)
+    {
+        $result = null;
+        $expressionLanguage = new ExpressionLanguage();
+        eval(sprintf('$result = %s;', $expressionLanguage->compile($expression, $names)));
+        $this->assertSame($expected, $result);
+    }
+
+    public function shortCircuitProviderEvaluate()
+    {
+        $object = $this->getMockBuilder('stdClass')->setMethods(array('foo'))->getMock();
+        $object->expects($this->never())->method('foo');
+
+        return array(
+            array('false and object.foo()', array('object' => $object), false),
+            array('false && object.foo()', array('object' => $object), false),
+            array('true || object.foo()', array('object' => $object), true),
+            array('true or object.foo()', array('object' => $object), true),
+        );
+    }
+
+    public function shortCircuitProviderCompile()
+    {
+        return array(
+            array('false and foo', array('foo' => 'foo'), false),
+            array('false && foo', array('foo' => 'foo'), false),
+            array('true || foo', array('foo' => 'foo'), true),
+            array('true or foo', array('foo' => 'foo'), true),
+        );
+    }
+
+    public function testCachingForOverriddenVariableNames()
+    {
+        $expressionLanguage = new ExpressionLanguage();
+        $expression = 'a + b';
+        $expressionLanguage->evaluate($expression, array('a' => 1, 'b' => 1));
+        $result = $expressionLanguage->compile($expression, array('a', 'B' => 'b'));
+        $this->assertSame('($a + $B)', $result);
+    }
+
+    public function testCachingWithDifferentNamesOrder()
+    {
+        $cacheMock = $this->getMock('Symfony\Component\ExpressionLanguage\ParserCache\ParserCacheInterface');
+        $expressionLanguage = new ExpressionLanguage($cacheMock);
+        $savedParsedExpressions = array();
+        $cacheMock
+            ->expects($this->exactly(2))
+            ->method('fetch')
+            ->will($this->returnCallback(function ($key) use (&$savedParsedExpressions) {
+                return isset($savedParsedExpressions[$key]) ? $savedParsedExpressions[$key] : null;
+            }))
+        ;
+        $cacheMock
+            ->expects($this->exactly(1))
+            ->method('save')
+            ->will($this->returnCallback(function ($key, $expression) use (&$savedParsedExpressions) {
+                $savedParsedExpressions[$key] = $expression;
+            }))
+        ;
+
+        $expression = 'a + b';
+        $expressionLanguage->compile($expression, array('a', 'B' => 'b'));
+        $expressionLanguage->compile($expression, array('B' => 'b', 'a'));
+    }
+}

core/vendor/symfony/expression-language/Tests/ExpressionTest.php

@@ -0,0 +1,27 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Tests;
+
+use Symfony\Component\ExpressionLanguage\Expression;
+
+class ExpressionTest extends \PHPUnit_Framework_TestCase
+{
+    public function testSerialization()
+    {
+        $expression = new Expression('kernel.boot()');
+
+        $serializedExpression = serialize($expression);
+        $unserializedExpression = unserialize($serializedExpression);
+
+        $this->assertEquals($expression, $unserializedExpression);
+    }
+}

core/vendor/symfony/expression-language/Tests/Fixtures/TestProvider.php

@@ -0,0 +1,29 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Tests\Fixtures;
+
+use Symfony\Component\ExpressionLanguage\ExpressionFunction;
+use Symfony\Component\ExpressionLanguage\ExpressionFunctionProviderInterface;
+
+class TestProvider implements ExpressionFunctionProviderInterface
+{
+    public function getFunctions()
+    {
+        return array(
+            new ExpressionFunction('identity', function ($input) {
+                return $input;
+            }, function (array $values, $input) {
+                return $input;
+            }),
+        );
+    }
+}

core/vendor/symfony/expression-language/Tests/LexerTest.php

@@ -0,0 +1,91 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Tests;
+
+use Symfony\Component\ExpressionLanguage\Lexer;
+use Symfony\Component\ExpressionLanguage\Token;
+use Symfony\Component\ExpressionLanguage\TokenStream;
+
+class LexerTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @dataProvider getTokenizeData
+     */
+    public function testTokenize($tokens, $expression)
+    {
+        $tokens[] = new Token('end of expression', null, strlen($expression) + 1);
+        $lexer = new Lexer();
+        $this->assertEquals(new TokenStream($tokens), $lexer->tokenize($expression));
+    }
+
+    public function getTokenizeData()
+    {
+        return array(
+            array(
+                array(new Token('name', 'a', 3)),
+                '  a  ',
+            ),
+            array(
+                array(new Token('name', 'a', 1)),
+                'a',
+            ),
+            array(
+                array(new Token('string', 'foo', 1)),
+                '"foo"',
+            ),
+            array(
+                array(new Token('number', '3', 1)),
+                '3',
+            ),
+            array(
+                array(new Token('operator', '+', 1)),
+                '+',
+            ),
+            array(
+                array(new Token('punctuation', '.', 1)),
+                '.',
+            ),
+            array(
+                array(
+                    new Token('punctuation', '(', 1),
+                    new Token('number', '3', 2),
+                    new Token('operator', '+', 4),
+                    new Token('number', '5', 6),
+                    new Token('punctuation', ')', 7),
+                    new Token('operator', '~', 9),
+                    new Token('name', 'foo', 11),
+                    new Token('punctuation', '(', 14),
+                    new Token('string', 'bar', 15),
+                    new Token('punctuation', ')', 20),
+                    new Token('punctuation', '.', 21),
+                    new Token('name', 'baz', 22),
+                    new Token('punctuation', '[', 25),
+                    new Token('number', '4', 26),
+                    new Token('punctuation', ']', 27),
+                ),
+                '(3 + 5) ~ foo("bar").baz[4]',
+            ),
+            array(
+                array(new Token('operator', '..', 1)),
+                '..',
+            ),
+            array(
+                array(new Token('string', '#foo', 1)),
+                "'#foo'",
+            ),
+            array(
+                array(new Token('string', '#foo', 1)),
+                '"#foo"',
+            ),
+        );
+    }
+}

core/vendor/symfony/expression-language/Tests/Node/AbstractNodeTest.php

@@ -0,0 +1,39 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Tests\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+abstract class AbstractNodeTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @dataProvider getEvaluateData
+     */
+    public function testEvaluate($expected, $node, $variables = array(), $functions = array())
+    {
+        $this->assertSame($expected, $node->evaluate($functions, $variables));
+    }
+
+    abstract public function getEvaluateData();
+
+    /**
+     * @dataProvider getCompileData
+     */
+    public function testCompile($expected, $node, $functions = array())
+    {
+        $compiler = new Compiler($functions);
+        $node->compile($compiler);
+        $this->assertSame($expected, $compiler->getSource());
+    }
+
+    abstract public function getCompileData();
+}

core/vendor/symfony/expression-language/Tests/Node/ArgumentsNodeTest.php

@@ -0,0 +1,29 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Tests\Node;
+
+use Symfony\Component\ExpressionLanguage\Node\ArgumentsNode;
+
+class ArgumentsNodeTest extends ArrayNodeTest
+{
+    public function getCompileData()
+    {
+        return array(
+            array('"a", "b"', $this->getArrayNode()),
+        );
+    }
+
+    protected function createArrayNode()
+    {
+        return new ArgumentsNode();
+    }
+}

core/vendor/symfony/expression-language/Tests/Node/ArrayNodeTest.php

@@ -0,0 +1,58 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Tests\Node;
+
+use Symfony\Component\ExpressionLanguage\Node\ArrayNode;
+use Symfony\Component\ExpressionLanguage\Node\ConstantNode;
+
+class ArrayNodeTest extends AbstractNodeTest
+{
+    public function testSerialization()
+    {
+        $node = $this->createArrayNode();
+        $node->addElement(new ConstantNode('foo'));
+
+        $serializedNode = serialize($node);
+        $unserializedNode = unserialize($serializedNode);
+
+        $this->assertEquals($node, $unserializedNode);
+        $this->assertNotEquals($this->createArrayNode(), $unserializedNode);
+    }
+
+    public function getEvaluateData()
+    {
+        return array(
+            array(array('b' => 'a', 'b'), $this->getArrayNode()),
+        );
+    }
+
+    public function getCompileData()
+    {
+        return array(
+            array('array("b" => "a", 0 => "b")', $this->getArrayNode()),
+        );
+    }
+
+    protected function getArrayNode()
+    {
+        $array = $this->createArrayNode();
+        $array->addElement(new ConstantNode('a'), new ConstantNode('b'));
+        $array->addElement(new ConstantNode('b'));
+
+        return $array;
+    }
+
+    protected function createArrayNode()
+    {
+        return new ArrayNode();
+    }
+}

core/vendor/symfony/expression-language/Tests/Node/BinaryNodeTest.php

@@ -0,0 +1,117 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Tests\Node;
+
+use Symfony\Component\ExpressionLanguage\Node\BinaryNode;
+use Symfony\Component\ExpressionLanguage\Node\ArrayNode;
+use Symfony\Component\ExpressionLanguage\Node\ConstantNode;
+
+class BinaryNodeTest extends AbstractNodeTest
+{
+    public function getEvaluateData()
+    {
+        $array = new ArrayNode();
+        $array->addElement(new ConstantNode('a'));
+        $array->addElement(new ConstantNode('b'));
+
+        return array(
+            array(true, new BinaryNode('or', new ConstantNode(true), new ConstantNode(false))),
+            array(true, new BinaryNode('||', new ConstantNode(true), new ConstantNode(false))),
+            array(false, new BinaryNode('and', new ConstantNode(true), new ConstantNode(false))),
+            array(false, new BinaryNode('&&', new ConstantNode(true), new ConstantNode(false))),
+
+            array(0, new BinaryNode('&', new ConstantNode(2), new ConstantNode(4))),
+            array(6, new BinaryNode('|', new ConstantNode(2), new ConstantNode(4))),
+            array(6, new BinaryNode('^', new ConstantNode(2), new ConstantNode(4))),
+
+            array(true, new BinaryNode('<', new ConstantNode(1), new ConstantNode(2))),
+            array(true, new BinaryNode('<=', new ConstantNode(1), new ConstantNode(2))),
+            array(true, new BinaryNode('<=', new ConstantNode(1), new ConstantNode(1))),
+
+            array(false, new BinaryNode('>', new ConstantNode(1), new ConstantNode(2))),
+            array(false, new BinaryNode('>=', new ConstantNode(1), new ConstantNode(2))),
+            array(true, new BinaryNode('>=', new ConstantNode(1), new ConstantNode(1))),
+
+            array(true, new BinaryNode('===', new ConstantNode(true), new ConstantNode(true))),
+            array(false, new BinaryNode('!==', new ConstantNode(true), new ConstantNode(true))),
+
+            array(false, new BinaryNode('==', new ConstantNode(2), new ConstantNode(1))),
+            array(true, new BinaryNode('!=', new ConstantNode(2), new ConstantNode(1))),
+
+            array(-1, new BinaryNode('-', new ConstantNode(1), new ConstantNode(2))),
+            array(3, new BinaryNode('+', new ConstantNode(1), new ConstantNode(2))),
+            array(4, new BinaryNode('*', new ConstantNode(2), new ConstantNode(2))),
+            array(1, new BinaryNode('/', new ConstantNode(2), new ConstantNode(2))),
+            array(1, new BinaryNode('%', new ConstantNode(5), new ConstantNode(2))),
+            array(25, new BinaryNode('**', new ConstantNode(5), new ConstantNode(2))),
+            array('ab', new BinaryNode('~', new ConstantNode('a'), new ConstantNode('b'))),
+
+            array(true, new BinaryNode('in', new ConstantNode('a'), $array)),
+            array(false, new BinaryNode('in', new ConstantNode('c'), $array)),
+            array(true, new BinaryNode('not in', new ConstantNode('c'), $array)),
+            array(false, new BinaryNode('not in', new ConstantNode('a'), $array)),
+
+            array(array(1, 2, 3), new BinaryNode('..', new ConstantNode(1), new ConstantNode(3))),
+
+            array(1, new BinaryNode('matches', new ConstantNode('abc'), new ConstantNode('/^[a-z]+$/'))),
+        );
+    }
+
+    public function getCompileData()
+    {
+        $array = new ArrayNode();
+        $array->addElement(new ConstantNode('a'));
+        $array->addElement(new ConstantNode('b'));
+
+        return array(
+            array('(true || false)', new BinaryNode('or', new ConstantNode(true), new ConstantNode(false))),
+            array('(true || false)', new BinaryNode('||', new ConstantNode(true), new ConstantNode(false))),
+            array('(true && false)', new BinaryNode('and', new ConstantNode(true), new ConstantNode(false))),
+            array('(true && false)', new BinaryNode('&&', new ConstantNode(true), new ConstantNode(false))),
+
+            array('(2 & 4)', new BinaryNode('&', new ConstantNode(2), new ConstantNode(4))),
+            array('(2 | 4)', new BinaryNode('|', new ConstantNode(2), new ConstantNode(4))),
+            array('(2 ^ 4)', new BinaryNode('^', new ConstantNode(2), new ConstantNode(4))),
+
+            array('(1 < 2)', new BinaryNode('<', new ConstantNode(1), new ConstantNode(2))),
+            array('(1 <= 2)', new BinaryNode('<=', new ConstantNode(1), new ConstantNode(2))),
+            array('(1 <= 1)', new BinaryNode('<=', new ConstantNode(1), new ConstantNode(1))),
+
+            array('(1 > 2)', new BinaryNode('>', new ConstantNode(1), new ConstantNode(2))),
+            array('(1 >= 2)', new BinaryNode('>=', new ConstantNode(1), new ConstantNode(2))),
+            array('(1 >= 1)', new BinaryNode('>=', new ConstantNode(1), new ConstantNode(1))),
+
+            array('(true === true)', new BinaryNode('===', new ConstantNode(true), new ConstantNode(true))),
+            array('(true !== true)', new BinaryNode('!==', new ConstantNode(true), new ConstantNode(true))),
+
+            array('(2 == 1)', new BinaryNode('==', new ConstantNode(2), new ConstantNode(1))),
+            array('(2 != 1)', new BinaryNode('!=', new ConstantNode(2), new ConstantNode(1))),
+
+            array('(1 - 2)', new BinaryNode('-', new ConstantNode(1), new ConstantNode(2))),
+            array('(1 + 2)', new BinaryNode('+', new ConstantNode(1), new ConstantNode(2))),
+            array('(2 * 2)', new BinaryNode('*', new ConstantNode(2), new ConstantNode(2))),
+            array('(2 / 2)', new BinaryNode('/', new ConstantNode(2), new ConstantNode(2))),
+            array('(5 % 2)', new BinaryNode('%', new ConstantNode(5), new ConstantNode(2))),
+            array('pow(5, 2)', new BinaryNode('**', new ConstantNode(5), new ConstantNode(2))),
+            array('("a" . "b")', new BinaryNode('~', new ConstantNode('a'), new ConstantNode('b'))),
+
+            array('in_array("a", array(0 => "a", 1 => "b"))', new BinaryNode('in', new ConstantNode('a'), $array)),
+            array('in_array("c", array(0 => "a", 1 => "b"))', new BinaryNode('in', new ConstantNode('c'), $array)),
+            array('!in_array("c", array(0 => "a", 1 => "b"))', new BinaryNode('not in', new ConstantNode('c'), $array)),
+            array('!in_array("a", array(0 => "a", 1 => "b"))', new BinaryNode('not in', new ConstantNode('a'), $array)),
+
+            array('range(1, 3)', new BinaryNode('..', new ConstantNode(1), new ConstantNode(3))),
+
+            array('preg_match("/^[a-z]+/i\$/", "abc")', new BinaryNode('matches', new ConstantNode('abc'), new ConstantNode('/^[a-z]+/i$/'))),
+        );
+    }
+}

core/vendor/symfony/expression-language/Tests/Node/ConditionalNodeTest.php

@@ -0,0 +1,34 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Tests\Node;
+
+use Symfony\Component\ExpressionLanguage\Node\ConditionalNode;
+use Symfony\Component\ExpressionLanguage\Node\ConstantNode;
+
+class ConditionalNodeTest extends AbstractNodeTest
+{
+    public function getEvaluateData()
+    {
+        return array(
+            array(1, new ConditionalNode(new ConstantNode(true), new ConstantNode(1), new ConstantNode(2))),
+            array(2, new ConditionalNode(new ConstantNode(false), new ConstantNode(1), new ConstantNode(2))),
+        );
+    }
+
+    public function getCompileData()
+    {
+        return array(
+            array('((true) ? (1) : (2))', new ConditionalNode(new ConstantNode(true), new ConstantNode(1), new ConstantNode(2))),
+            array('((false) ? (1) : (2))', new ConditionalNode(new ConstantNode(false), new ConstantNode(1), new ConstantNode(2))),
+        );
+    }
+}

core/vendor/symfony/expression-language/Tests/Node/ConstantNodeTest.php

@@ -0,0 +1,43 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Tests\Node;
+
+use Symfony\Component\ExpressionLanguage\Node\ConstantNode;
+
+class ConstantNodeTest extends AbstractNodeTest
+{
+    public function getEvaluateData()
+    {
+        return array(
+            array(false, new ConstantNode(false)),
+            array(true, new ConstantNode(true)),
+            array(null, new ConstantNode(null)),
+            array(3, new ConstantNode(3)),
+            array(3.3, new ConstantNode(3.3)),
+            array('foo', new ConstantNode('foo')),
+            array(array(1, 'b' => 'a'), new ConstantNode(array(1, 'b' => 'a'))),
+        );
+    }
+
+    public function getCompileData()
+    {
+        return array(
+            array('false', new ConstantNode(false)),
+            array('true', new ConstantNode(true)),
+            array('null', new ConstantNode(null)),
+            array('3', new ConstantNode(3)),
+            array('3.3', new ConstantNode(3.3)),
+            array('"foo"', new ConstantNode('foo')),
+            array('array(0 => 1, "b" => "a")', new ConstantNode(array(1, 'b' => 'a'))),
+        );
+    }
+}

core/vendor/symfony/expression-language/Tests/Node/FunctionNodeTest.php

@@ -0,0 +1,45 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Tests\Node;
+
+use Symfony\Component\ExpressionLanguage\Node\FunctionNode;
+use Symfony\Component\ExpressionLanguage\Node\ConstantNode;
+use Symfony\Component\ExpressionLanguage\Node\Node;
+
+class FunctionNodeTest extends AbstractNodeTest
+{
+    public function getEvaluateData()
+    {
+        return array(
+            array('bar', new FunctionNode('foo', new Node(array(new ConstantNode('bar')))), array(), array('foo' => $this->getCallables())),
+        );
+    }
+
+    public function getCompileData()
+    {
+        return array(
+            array('foo("bar")', new FunctionNode('foo', new Node(array(new ConstantNode('bar')))), array('foo' => $this->getCallables())),
+        );
+    }
+
+    protected function getCallables()
+    {
+        return array(
+            'compiler' => function ($arg) {
+                return sprintf('foo(%s)', $arg);
+            },
+            'evaluator' => function ($variables, $arg) {
+                return $arg;
+            },
+        );
+    }
+}

core/vendor/symfony/expression-language/Tests/Node/GetAttrNodeTest.php

@@ -0,0 +1,65 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Tests\Node;
+
+use Symfony\Component\ExpressionLanguage\Node\ArrayNode;
+use Symfony\Component\ExpressionLanguage\Node\NameNode;
+use Symfony\Component\ExpressionLanguage\Node\GetAttrNode;
+use Symfony\Component\ExpressionLanguage\Node\ConstantNode;
+
+class GetAttrNodeTest extends AbstractNodeTest
+{
+    public function getEvaluateData()
+    {
+        return array(
+            array('b', new GetAttrNode(new NameNode('foo'), new ConstantNode(0), $this->getArrayNode(), GetAttrNode::ARRAY_CALL), array('foo' => array('b' => 'a', 'b'))),
+            array('a', new GetAttrNode(new NameNode('foo'), new ConstantNode('b'), $this->getArrayNode(), GetAttrNode::ARRAY_CALL), array('foo' => array('b' => 'a', 'b'))),
+
+            array('bar', new GetAttrNode(new NameNode('foo'), new ConstantNode('foo'), $this->getArrayNode(), GetAttrNode::PROPERTY_CALL), array('foo' => new Obj())),
+
+            array('baz', new GetAttrNode(new NameNode('foo'), new ConstantNode('foo'), $this->getArrayNode(), GetAttrNode::METHOD_CALL), array('foo' => new Obj())),
+            array('a', new GetAttrNode(new NameNode('foo'), new NameNode('index'), $this->getArrayNode(), GetAttrNode::ARRAY_CALL), array('foo' => array('b' => 'a', 'b'), 'index' => 'b')),
+        );
+    }
+
+    public function getCompileData()
+    {
+        return array(
+            array('$foo[0]', new GetAttrNode(new NameNode('foo'), new ConstantNode(0), $this->getArrayNode(), GetAttrNode::ARRAY_CALL)),
+            array('$foo["b"]', new GetAttrNode(new NameNode('foo'), new ConstantNode('b'), $this->getArrayNode(), GetAttrNode::ARRAY_CALL)),
+
+            array('$foo->foo', new GetAttrNode(new NameNode('foo'), new ConstantNode('foo'), $this->getArrayNode(), GetAttrNode::PROPERTY_CALL), array('foo' => new Obj())),
+
+            array('$foo->foo(array("b" => "a", 0 => "b"))', new GetAttrNode(new NameNode('foo'), new ConstantNode('foo'), $this->getArrayNode(), GetAttrNode::METHOD_CALL), array('foo' => new Obj())),
+            array('$foo[$index]', new GetAttrNode(new NameNode('foo'), new NameNode('index'), $this->getArrayNode(), GetAttrNode::ARRAY_CALL)),
+        );
+    }
+
+    protected function getArrayNode()
+    {
+        $array = new ArrayNode();
+        $array->addElement(new ConstantNode('a'), new ConstantNode('b'));
+        $array->addElement(new ConstantNode('b'));
+
+        return $array;
+    }
+}
+
+class Obj
+{
+    public $foo = 'bar';
+
+    public function foo()
+    {
+        return 'baz';
+    }
+}

core/vendor/symfony/expression-language/Tests/Node/NameNodeTest.php

@@ -0,0 +1,31 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Tests\Node;
+
+use Symfony\Component\ExpressionLanguage\Node\NameNode;
+
+class NameNodeTest extends AbstractNodeTest
+{
+    public function getEvaluateData()
+    {
+        return array(
+            array('bar', new NameNode('foo'), array('foo' => 'bar')),
+        );
+    }
+
+    public function getCompileData()
+    {
+        return array(
+            array('$foo', new NameNode('foo')),
+        );
+    }
+}

core/vendor/symfony/expression-language/Tests/Node/NodeTest.php

@@ -0,0 +1,40 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Tests\Node;
+
+use Symfony\Component\ExpressionLanguage\Node\Node;
+use Symfony\Component\ExpressionLanguage\Node\ConstantNode;
+
+class NodeTest extends \PHPUnit_Framework_TestCase
+{
+    public function testToString()
+    {
+        $node = new Node(array(new ConstantNode('foo')));
+
+        $this->assertEquals(<<<EOF
+Node(
+    ConstantNode(value: 'foo')
+)
+EOF
+        , (string) $node);
+    }
+
+    public function testSerialization()
+    {
+        $node = new Node(array('foo' => 'bar'), array('bar' => 'foo'));
+
+        $serializedNode = serialize($node);
+        $unserializedNode = unserialize($serializedNode);
+
+        $this->assertEquals($node, $unserializedNode);
+    }
+}

core/vendor/symfony/expression-language/Tests/Node/UnaryNodeTest.php

@@ -0,0 +1,38 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Tests\Node;
+
+use Symfony\Component\ExpressionLanguage\Node\UnaryNode;
+use Symfony\Component\ExpressionLanguage\Node\ConstantNode;
+
+class UnaryNodeTest extends AbstractNodeTest
+{
+    public function getEvaluateData()
+    {
+        return array(
+            array(-1, new UnaryNode('-', new ConstantNode(1))),
+            array(3, new UnaryNode('+', new ConstantNode(3))),
+            array(false, new UnaryNode('!', new ConstantNode(true))),
+            array(false, new UnaryNode('not', new ConstantNode(true))),
+        );
+    }
+
+    public function getCompileData()
+    {
+        return array(
+            array('(-1)', new UnaryNode('-', new ConstantNode(1))),
+            array('(+3)', new UnaryNode('+', new ConstantNode(3))),
+            array('(!true)', new UnaryNode('!', new ConstantNode(true))),
+            array('(!true)', new UnaryNode('not', new ConstantNode(true))),
+        );
+    }
+}

core/vendor/symfony/expression-language/Tests/ParsedExpressionTest.php

@@ -0,0 +1,28 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Tests;
+
+use Symfony\Component\ExpressionLanguage\Node\ConstantNode;
+use Symfony\Component\ExpressionLanguage\ParsedExpression;
+
+class ParsedExpressionTest extends \PHPUnit_Framework_TestCase
+{
+    public function testSerialization()
+    {
+        $expression = new ParsedExpression('25', new ConstantNode('25'));
+
+        $serializedExpression = serialize($expression);
+        $unserializedExpression = unserialize($serializedExpression);
+
+        $this->assertEquals($expression, $unserializedExpression);
+    }
+}

core/vendor/symfony/expression-language/Tests/ParserTest.php

@@ -0,0 +1,197 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Tests;
+
+use Symfony\Component\ExpressionLanguage\Parser;
+use Symfony\Component\ExpressionLanguage\Lexer;
+use Symfony\Component\ExpressionLanguage\Node;
+
+class ParserTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @expectedException        \Symfony\Component\ExpressionLanguage\SyntaxError
+     * @expectedExceptionMessage Variable "foo" is not valid around position 1.
+     */
+    public function testParseWithInvalidName()
+    {
+        $lexer = new Lexer();
+        $parser = new Parser(array());
+        $parser->parse($lexer->tokenize('foo'));
+    }
+
+    /**
+     * @expectedException        \Symfony\Component\ExpressionLanguage\SyntaxError
+     * @expectedExceptionMessage Variable "foo" is not valid around position 1.
+     */
+    public function testParseWithZeroInNames()
+    {
+        $lexer = new Lexer();
+        $parser = new Parser(array());
+        $parser->parse($lexer->tokenize('foo'), array(0));
+    }
+
+    /**
+     * @dataProvider getParseData
+     */
+    public function testParse($node, $expression, $names = array())
+    {
+        $lexer = new Lexer();
+        $parser = new Parser(array());
+        $this->assertEquals($node, $parser->parse($lexer->tokenize($expression), $names));
+    }
+
+    public function getParseData()
+    {
+        $arguments = new Node\ArgumentsNode();
+        $arguments->addElement(new Node\ConstantNode('arg1'));
+        $arguments->addElement(new Node\ConstantNode(2));
+        $arguments->addElement(new Node\ConstantNode(true));
+
+        return array(
+            array(
+                new Node\NameNode('a'),
+                'a',
+                array('a'),
+            ),
+            array(
+                new Node\ConstantNode('a'),
+                '"a"',
+            ),
+            array(
+                new Node\ConstantNode(3),
+                '3',
+            ),
+            array(
+                new Node\ConstantNode(false),
+                'false',
+            ),
+            array(
+                new Node\ConstantNode(true),
+                'true',
+            ),
+            array(
+                new Node\ConstantNode(null),
+                'null',
+            ),
+            array(
+                new Node\UnaryNode('-', new Node\ConstantNode(3)),
+                '-3',
+            ),
+            array(
+                new Node\BinaryNode('-', new Node\ConstantNode(3), new Node\ConstantNode(3)),
+                '3 - 3',
+            ),
+            array(
+                new Node\BinaryNode('*',
+                    new Node\BinaryNode('-', new Node\ConstantNode(3), new Node\ConstantNode(3)),
+                    new Node\ConstantNode(2)
+                ),
+                '(3 - 3) * 2',
+            ),
+            array(
+                new Node\GetAttrNode(new Node\NameNode('foo'), new Node\ConstantNode('bar'), new Node\ArgumentsNode(), Node\GetAttrNode::PROPERTY_CALL),
+                'foo.bar',
+                array('foo'),
+            ),
+            array(
+                new Node\GetAttrNode(new Node\NameNode('foo'), new Node\ConstantNode('bar'), new Node\ArgumentsNode(), Node\GetAttrNode::METHOD_CALL),
+                'foo.bar()',
+                array('foo'),
+            ),
+            array(
+                new Node\GetAttrNode(new Node\NameNode('foo'), new Node\ConstantNode('not'), new Node\ArgumentsNode(), Node\GetAttrNode::METHOD_CALL),
+                'foo.not()',
+                array('foo'),
+            ),
+            array(
+                new Node\GetAttrNode(
+                    new Node\NameNode('foo'),
+                    new Node\ConstantNode('bar'),
+                    $arguments,
+                    Node\GetAttrNode::METHOD_CALL
+                ),
+                'foo.bar("arg1", 2, true)',
+                array('foo'),
+            ),
+            array(
+                new Node\GetAttrNode(new Node\NameNode('foo'), new Node\ConstantNode(3), new Node\ArgumentsNode(), Node\GetAttrNode::ARRAY_CALL),
+                'foo[3]',
+                array('foo'),
+            ),
+            array(
+                new Node\ConditionalNode(new Node\ConstantNode(true), new Node\ConstantNode(true), new Node\ConstantNode(false)),
+                'true ? true : false',
+            ),
+            array(
+                new Node\BinaryNode('matches', new Node\ConstantNode('foo'), new Node\ConstantNode('/foo/')),
+                '"foo" matches "/foo/"',
+            ),
+
+            // chained calls
+            array(
+                $this->createGetAttrNode(
+                    $this->createGetAttrNode(
+                        $this->createGetAttrNode(
+                            $this->createGetAttrNode(new Node\NameNode('foo'), 'bar', Node\GetAttrNode::METHOD_CALL),
+                            'foo', Node\GetAttrNode::METHOD_CALL),
+                        'baz', Node\GetAttrNode::PROPERTY_CALL),
+                    '3', Node\GetAttrNode::ARRAY_CALL),
+                'foo.bar().foo().baz[3]',
+                array('foo'),
+            ),
+
+            array(
+                new Node\NameNode('foo'),
+                'bar',
+                array('foo' => 'bar'),
+            ),
+        );
+    }
+
+    private function createGetAttrNode($node, $item, $type)
+    {
+        return new Node\GetAttrNode($node, new Node\ConstantNode($item), new Node\ArgumentsNode(), $type);
+    }
+
+    /**
+     * @dataProvider getInvalidPostfixData
+     * @expectedException \Symfony\Component\ExpressionLanguage\SyntaxError
+     */
+    public function testParseWithInvalidPostfixData($expr, $names = array())
+    {
+        $lexer = new Lexer();
+        $parser = new Parser(array());
+        $parser->parse($lexer->tokenize($expr), $names);
+    }
+
+    public function getInvalidPostfixData()
+    {
+        return array(
+            array(
+                'foo."#"',
+                array('foo'),
+            ),
+            array(
+                'foo."bar"',
+                array('foo'),
+            ),
+            array(
+                'foo.**',
+                array('foo'),
+            ),
+            array(
+                'foo.123',
+                array('foo'),
+            ),
+        );
+    }
+}

core/vendor/symfony/expression-language/Token.php

@@ -0,0 +1,68 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage;
+
+/**
+ * Represents a Token.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class Token
+{
+    public $value;
+    public $type;
+    public $cursor;
+
+    const EOF_TYPE = 'end of expression';
+    const NAME_TYPE = 'name';
+    const NUMBER_TYPE = 'number';
+    const STRING_TYPE = 'string';
+    const OPERATOR_TYPE = 'operator';
+    const PUNCTUATION_TYPE = 'punctuation';
+
+    /**
+     * Constructor.
+     *
+     * @param int    $type   The type of the token
+     * @param string $value  The token value
+     * @param int    $cursor The cursor position in the source
+     */
+    public function __construct($type, $value, $cursor)
+    {
+        $this->type = $type;
+        $this->value = $value;
+        $this->cursor = $cursor;
+    }
+
+    /**
+     * Returns a string representation of the token.
+     *
+     * @return string A string representation of the token
+     */
+    public function __toString()
+    {
+        return sprintf('%3d %-11s %s', $this->cursor, strtoupper($this->type), $this->value);
+    }
+
+    /**
+     * Tests the current token for a type and/or a value.
+     *
+     * @param array|int   $type  The type to test
+     * @param string|null $value The token value
+     *
+     * @return bool
+     */
+    public function test($type, $value = null)
+    {
+        return $this->type === $type && (null === $value || $this->value == $value);
+    }
+}

core/vendor/symfony/expression-language/TokenStream.php

@@ -0,0 +1,82 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage;
+
+/**
+ * Represents a token stream.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class TokenStream
+{
+    public $current;
+
+    private $tokens;
+    private $position = 0;
+
+    /**
+     * Constructor.
+     *
+     * @param array $tokens An array of tokens
+     */
+    public function __construct(array $tokens)
+    {
+        $this->tokens = $tokens;
+        $this->current = $tokens[0];
+    }
+
+    /**
+     * Returns a string representation of the token stream.
+     *
+     * @return string
+     */
+    public function __toString()
+    {
+        return implode("\n", $this->tokens);
+    }
+
+    /**
+     * Sets the pointer to the next token and returns the old one.
+     */
+    public function next()
+    {
+        if (!isset($this->tokens[$this->position])) {
+            throw new SyntaxError('Unexpected end of expression', $this->current->cursor);
+        }
+
+        ++$this->position;
+
+        $this->current = $this->tokens[$this->position];
+    }
+
+    /**
+     * Tests a token.
+     */
+    public function expect($type, $value = null, $message = null)
+    {
+        $token = $this->current;
+        if (!$token->test($type, $value)) {
+            throw new SyntaxError(sprintf('%sUnexpected token "%s" of value "%s" ("%s" expected%s)', $message ? $message.'. ' : '', $token->type, $token->value, $type, $value ? sprintf(' with value "%s"', $value) : ''), $token->cursor);
+        }
+        $this->next();
+    }
+
+    /**
+     * Checks if end of stream was reached.
+     *
+     * @return bool
+     */
+    public function isEOF()
+    {
+        return $this->current->type === Token::EOF_TYPE;
+    }
+}

core/vendor/symfony/expression-language/composer.json

@@ -0,0 +1,33 @@
+{
+    "name": "symfony/expression-language",
+    "type": "library",
+    "description": "Symfony ExpressionLanguage Component",
+    "keywords": [],
+    "homepage": "https://symfony.com",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Fabien Potencier",
+            "email": "fabien@symfony.com"
+        },
+        {
+            "name": "Symfony Community",
+            "homepage": "https://symfony.com/contributors"
+        }
+    ],
+    "require": {
+        "php": ">=5.3.9"
+    },
+    "autoload": {
+        "psr-4": { "Symfony\\Component\\ExpressionLanguage\\": "" },
+        "exclude-from-classmap": [
+            "/Tests/"
+        ]
+    },
+    "minimum-stability": "dev",
+    "extra": {
+        "branch-alias": {
+            "dev-master": "2.8-dev"
+        }
+    }
+}

core/vendor/symfony/expression-language/phpunit.xml.dist

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<phpunit backupGlobals="false"
+         backupStaticAttributes="false"
+         colors="true"
+         convertErrorsToExceptions="true"
+         convertNoticesToExceptions="true"
+         convertWarningsToExceptions="true"
+         processIsolation="false"
+         stopOnFailure="false"
+         syntaxCheck="false"
+         bootstrap="vendor/autoload.php"
+>
+    <php>
+        <ini name="error_reporting" value="-1" />
+    </php>
+
+    <testsuites>
+        <testsuite name="Symfony ExpressionLanguage Component Test Suite">
+            <directory>./Tests/</directory>
+        </testsuite>
+    </testsuites>
+
+    <filter>
+        <whitelist>
+            <directory>./</directory>
+            <exclude>
+                <directory>./Tests</directory>
+                <directory>./vendor</directory>
+            </exclude>
+        </whitelist>
+    </filter>
+</phpunit>