init web ems all

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

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

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

@@ -0,0 +1,146 @@
+<?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.
+     *
+     * @return $this
+     */
+    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 $this
+     */
+    public function raw($string)
+    {
+        $this->source .= $string;
+
+        return $this;
+    }
+
+    /**
+     * Adds a quoted string to the compiled code.
+     *
+     * @param string $value The string
+     *
+     * @return $this
+     */
+    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 $this
+     */
+    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;
+    }
+}

phpMyAdmin/vendor/symfony/expression-language/Expression.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;
+
+/**
+ * Represents an expression.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class Expression
+{
+    protected $expression;
+
+    /**
+     * @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;
+    }
+}

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

@@ -0,0 +1,63 @@
+<?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;
+
+    /**
+     * @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;
+    }
+}

phpMyAdmin/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();
+}

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

@@ -0,0 +1,170 @@
+<?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
+{
+    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 mixed 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
+     *
+     * @throws \LogicException when registering a function after calling evaluate(), compile() or parse()
+     *
+     * @see ExpressionFunction
+     */
+    public function register($name, $compiler, $evaluator)
+    {
+        if (null !== $this->parser) {
+            throw new \LogicException('Registering functions after calling evaluate(), compile() or parse() is not supported.');
+        }
+
+        $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();
+    }
+}

phpMyAdmin/vendor/symfony/expression-language/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2004-2018 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.

phpMyAdmin/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, 0, $cursor)) {
+                // numbers
+                $number = (float) $match[0];  // floats
+                if (preg_match('/^[0-9]+$/', $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, $expression);
+                }
+
+                list($expect, $cur) = array_pop($brackets);
+                if ($expression[$cursor] != strtr($expect, '([{', ')]}')) {
+                    throw new SyntaxError(sprintf('Unclosed "%s"', $expect), $cur, $expression);
+                }
+
+                $tokens[] = new Token(Token::PUNCTUATION_TYPE, $expression[$cursor], $cursor + 1);
+                ++$cursor;
+            } elseif (preg_match('/"([^"\\\\]*(?:\\\\.[^"\\\\]*)*)"|\'([^\'\\\\]*(?:\\\\.[^\'\\\\]*)*)\'/As', $expression, $match, 0, $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, 0, $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, 0, $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, $expression);
+            }
+        }
+
+        $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, $expression);
+        }
+
+        return new TokenStream($tokens, $expression);
+    }
+}

phpMyAdmin/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);
+    }
+}

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

@@ -0,0 +1,88 @@
+<?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.
+     */
+    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']);
+        }
+    }
+}

phpMyAdmin/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);
+        }
+    }
+}

phpMyAdmin/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);
+    }
+}

phpMyAdmin/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'];
+    }
+}

phpMyAdmin/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);
+    }
+}

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

@@ -0,0 +1,100 @@
+<?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.');
+                }
+                if (!\is_callable($toCall = array($obj, $this->nodes['attribute']->attributes['value']))) {
+                    throw new \RuntimeException(sprintf('Unable to call method "%s" of object "%s".', $this->nodes['attribute']->attributes['value'], \get_class($obj)));
+                }
+
+                return \call_user_func_array($toCall, $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)];
+        }
+    }
+}

phpMyAdmin/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']];
+    }
+}

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

@@ -0,0 +1,76 @@
+<?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();
+
+    /**
+     * @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;
+    }
+}

phpMyAdmin/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;
+    }
+}

phpMyAdmin/vendor/symfony/expression-language/ParsedExpression.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;
+
+use Symfony\Component\ExpressionLanguage\Node\Node;
+
+/**
+ * Represents an already parsed expression.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class ParsedExpression extends Expression
+{
+    private $nodes;
+
+    /**
+     * @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;
+    }
+}

phpMyAdmin/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, $stream->getExpression());
+        }
+
+        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, $this->stream->getExpression());
+                            }
+
+                            $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, $this->stream->getExpression());
+                            }
+
+                            // 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, $this->stream->getExpression());
+                }
+        }
+
+        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->getExpression());
+            }
+
+            $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::PUNCTUATION_TYPE == $token->type) {
+            if ('.' === $token->value) {
+                $this->stream->next();
+                $token = $this->stream->current;
+                $this->stream->next();
+
+                if (
+                    Token::NAME_TYPE !== $token->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::OPERATOR_TYPE !== $token->type || !preg_match('/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/A', $token->value))
+                ) {
+                    throw new SyntaxError('Expected name', $token->cursor, $this->stream->getExpression());
+                }
+
+                $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->getExpression());
+                }
+
+                $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);
+    }
+}

phpMyAdmin/vendor/symfony/expression-language/ParserCache/ArrayParserCache.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\ParserCache;
+
+use Symfony\Component\ExpressionLanguage\ParsedExpression;
+
+/**
+ * @author Adrien Brault <adrien.brault@gmail.com>
+ */
+class ArrayParserCache implements ParserCacheInterface
+{
+    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;
+    }
+}

phpMyAdmin/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);
+}

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

@@ -0,0 +1,15 @@
+ExpressionLanguage Component
+============================
+
+The ExpressionLanguage component provides an engine that can compile and
+evaluate expressions. An expression is a one-liner that returns a value
+(mostly, but not limited to, Booleans).
+
+Resources
+---------
+
+  * [Documentation](https://symfony.com/doc/current/components/expression_language/introduction.html)
+  * [Contributing](https://symfony.com/doc/current/contributing/index.html)
+  * [Report issues](https://github.com/symfony/symfony/issues) and
+    [send Pull Requests](https://github.com/symfony/symfony/pulls)
+    in the [main Symfony repository](https://github.com/symfony/symfony)

phpMyAdmin/vendor/symfony/expression-language/SerializedParsedExpression.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;
+
+/**
+ * Represents an already parsed expression.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class SerializedParsedExpression extends ParsedExpression
+{
+    private $nodes;
+
+    /**
+     * @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);
+    }
+}

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

@@ -0,0 +1,26 @@
+<?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, $expression = '')
+    {
+        $message = sprintf('%s around position %d', $message, $cursor);
+        if ($expression) {
+            $message = sprintf('%s for expression `%s`', $message, $expression);
+        }
+        $message .= '.';
+
+        parent::__construct($message);
+    }
+}

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

@@ -0,0 +1,66 @@
+<?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';
+
+    /**
+     * @param string                $type   The type of the token (self::*_TYPE)
+     * @param string|int|float|null $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);
+    }
+}

phpMyAdmin/vendor/symfony/expression-language/TokenStream.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;
+
+/**
+ * Represents a token stream.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class TokenStream
+{
+    public $current;
+
+    private $tokens;
+    private $position = 0;
+    private $expression;
+
+    /**
+     * @param array  $tokens     An array of tokens
+     * @param string $expression
+     */
+    public function __construct(array $tokens, $expression = '')
+    {
+        $this->tokens = $tokens;
+        $this->current = $tokens[0];
+        $this->expression = $expression;
+    }
+
+    /**
+     * 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()
+    {
+        ++$this->position;
+
+        if (!isset($this->tokens[$this->position])) {
+            throw new SyntaxError('Unexpected end of expression', $this->current->cursor, $this->expression);
+        }
+
+        $this->current = $this->tokens[$this->position];
+    }
+
+    /**
+     * Tests a token.
+     *
+     * @param array|int   $type    The type to test
+     * @param string|null $value   The token value
+     * @param string|null $message The syntax error message
+     */
+    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->expression);
+        }
+        $this->next();
+    }
+
+    /**
+     * Checks if end of stream was reached.
+     *
+     * @return bool
+     */
+    public function isEOF()
+    {
+        return Token::EOF_TYPE === $this->current->type;
+    }
+
+    /**
+     * @internal
+     *
+     * @return string
+     */
+    public function getExpression()
+    {
+        return $this->expression;
+    }
+}

phpMyAdmin/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"
+        }
+    }
+}

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

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:noNamespaceSchemaLocation="http://schema.phpunit.de/5.2/phpunit.xsd"
+         backupGlobals="false"
+         colors="true"
+         bootstrap="vendor/autoload.php"
+         failOnRisky="true"
+         failOnWarning="true"
+>
+    <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>