PDF rausgenommen

msd2/phpBB3/vendor/symfony/config/ConfigCache.php

@@ -0,0 +1,79 @@
+<?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\Config;
+
+use Symfony\Component\Config\Resource\BCResourceInterfaceChecker;
+use Symfony\Component\Config\Resource\SelfCheckingResourceChecker;
+
+/**
+ * ConfigCache caches arbitrary content in files on disk.
+ *
+ * When in debug mode, those metadata resources that implement
+ * \Symfony\Component\Config\Resource\SelfCheckingResourceInterface will
+ * be used to check cache freshness.
+ *
+ * During a transition period, also instances of
+ * \Symfony\Component\Config\Resource\ResourceInterface will be checked
+ * by means of the isFresh() method. This behaviour is deprecated since 2.8
+ * and will be removed in 3.0.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ * @author Matthias Pigulla <mp@webfactory.de>
+ */
+class ConfigCache extends ResourceCheckerConfigCache
+{
+    private $debug;
+
+    /**
+     * @param string $file  The absolute cache path
+     * @param bool   $debug Whether debugging is enabled or not
+     */
+    public function __construct($file, $debug)
+    {
+        parent::__construct($file, array(
+            new SelfCheckingResourceChecker(),
+            new BCResourceInterfaceChecker(),
+        ));
+        $this->debug = (bool) $debug;
+    }
+
+    /**
+     * Gets the cache file path.
+     *
+     * @return string The cache file path
+     *
+     * @deprecated since 2.7, to be removed in 3.0. Use getPath() instead.
+     */
+    public function __toString()
+    {
+        @trigger_error('ConfigCache::__toString() is deprecated since Symfony 2.7 and will be removed in 3.0. Use the getPath() method instead.', E_USER_DEPRECATED);
+
+        return $this->getPath();
+    }
+
+    /**
+     * Checks if the cache is still fresh.
+     *
+     * This implementation always returns true when debug is off and the
+     * cache file exists.
+     *
+     * @return bool true if the cache is fresh, false otherwise
+     */
+    public function isFresh()
+    {
+        if (!$this->debug && is_file($this->getPath())) {
+            return true;
+        }
+
+        return parent::isFresh();
+    }
+}

msd2/phpBB3/vendor/symfony/config/ConfigCacheFactory.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\Config;
+
+/**
+ * Basic implementation of ConfigCacheFactoryInterface that
+ * creates an instance of the default ConfigCache.
+ *
+ * This factory and/or cache <em>do not</em> support cache validation
+ * by means of ResourceChecker instances (that is, service-based).
+ *
+ * @author Matthias Pigulla <mp@webfactory.de>
+ */
+class ConfigCacheFactory implements ConfigCacheFactoryInterface
+{
+    private $debug;
+
+    /**
+     * @param bool $debug The debug flag to pass to ConfigCache
+     */
+    public function __construct($debug)
+    {
+        $this->debug = $debug;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function cache($file, $callback)
+    {
+        if (!\is_callable($callback)) {
+            throw new \InvalidArgumentException(sprintf('Invalid type for callback argument. Expected callable, but got "%s".', \gettype($callback)));
+        }
+
+        $cache = new ConfigCache($file, $this->debug);
+        if (!$cache->isFresh()) {
+            \call_user_func($callback, $cache);
+        }
+
+        return $cache;
+    }
+}

msd2/phpBB3/vendor/symfony/config/ConfigCacheFactoryInterface.php

@@ -0,0 +1,32 @@
+<?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\Config;
+
+/**
+ * Interface for a ConfigCache factory. This factory creates
+ * an instance of ConfigCacheInterface and initializes the
+ * cache if necessary.
+ *
+ * @author Matthias Pigulla <mp@webfactory.de>
+ */
+interface ConfigCacheFactoryInterface
+{
+    /**
+     * Creates a cache instance and (re-)initializes it if necessary.
+     *
+     * @param string   $file     The absolute cache file path
+     * @param callable $callable The callable to be executed when the cache needs to be filled (i. e. is not fresh). The cache will be passed as the only parameter to this callback
+     *
+     * @return ConfigCacheInterface $configCache The cache instance
+     */
+    public function cache($file, $callable);
+}

msd2/phpBB3/vendor/symfony/config/ConfigCacheInterface.php

@@ -0,0 +1,49 @@
+<?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\Config;
+
+use Symfony\Component\Config\Resource\ResourceInterface;
+
+/**
+ * Interface for ConfigCache.
+ *
+ * @author Matthias Pigulla <mp@webfactory.de>
+ */
+interface ConfigCacheInterface
+{
+    /**
+     * Gets the cache file path.
+     *
+     * @return string The cache file path
+     */
+    public function getPath();
+
+    /**
+     * Checks if the cache is still fresh.
+     *
+     * This check should take the metadata passed to the write() method into consideration.
+     *
+     * @return bool Whether the cache is still fresh
+     */
+    public function isFresh();
+
+    /**
+     * Writes the given content into the cache file. Metadata will be stored
+     * independently and can be used to check cache freshness at a later time.
+     *
+     * @param string                   $content  The content to write into the cache
+     * @param ResourceInterface[]|null $metadata An array of ResourceInterface instances
+     *
+     * @throws \RuntimeException When the cache file cannot be written
+     */
+    public function write($content, array $metadata = null);
+}

msd2/phpBB3/vendor/symfony/config/Definition/ArrayNode.php

@@ -0,0 +1,378 @@
+<?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\Config\Definition;
+
+use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
+use Symfony\Component\Config\Definition\Exception\InvalidTypeException;
+use Symfony\Component\Config\Definition\Exception\UnsetKeyException;
+
+/**
+ * Represents an Array node in the config tree.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class ArrayNode extends BaseNode implements PrototypeNodeInterface
+{
+    protected $xmlRemappings = array();
+    protected $children = array();
+    protected $allowFalse = false;
+    protected $allowNewKeys = true;
+    protected $addIfNotSet = false;
+    protected $performDeepMerging = true;
+    protected $ignoreExtraKeys = false;
+    protected $removeExtraKeys = true;
+    protected $normalizeKeys = true;
+
+    public function setNormalizeKeys($normalizeKeys)
+    {
+        $this->normalizeKeys = (bool) $normalizeKeys;
+    }
+
+    /**
+     * Normalizes keys between the different configuration formats.
+     *
+     * Namely, you mostly have foo_bar in YAML while you have foo-bar in XML.
+     * After running this method, all keys are normalized to foo_bar.
+     *
+     * If you have a mixed key like foo-bar_moo, it will not be altered.
+     * The key will also not be altered if the target key already exists.
+     *
+     * @param mixed $value
+     *
+     * @return array The value with normalized keys
+     */
+    protected function preNormalize($value)
+    {
+        if (!$this->normalizeKeys || !\is_array($value)) {
+            return $value;
+        }
+
+        $normalized = array();
+
+        foreach ($value as $k => $v) {
+            if (false !== strpos($k, '-') && false === strpos($k, '_') && !array_key_exists($normalizedKey = str_replace('-', '_', $k), $value)) {
+                $normalized[$normalizedKey] = $v;
+            } else {
+                $normalized[$k] = $v;
+            }
+        }
+
+        return $normalized;
+    }
+
+    /**
+     * Retrieves the children of this node.
+     *
+     * @return array The children
+     */
+    public function getChildren()
+    {
+        return $this->children;
+    }
+
+    /**
+     * Sets the xml remappings that should be performed.
+     *
+     * @param array $remappings An array of the form array(array(string, string))
+     */
+    public function setXmlRemappings(array $remappings)
+    {
+        $this->xmlRemappings = $remappings;
+    }
+
+    /**
+     * Gets the xml remappings that should be performed.
+     *
+     * @return array $remappings an array of the form array(array(string, string))
+     */
+    public function getXmlRemappings()
+    {
+        return $this->xmlRemappings;
+    }
+
+    /**
+     * Sets whether to add default values for this array if it has not been
+     * defined in any of the configuration files.
+     *
+     * @param bool $boolean
+     */
+    public function setAddIfNotSet($boolean)
+    {
+        $this->addIfNotSet = (bool) $boolean;
+    }
+
+    /**
+     * Sets whether false is allowed as value indicating that the array should be unset.
+     *
+     * @param bool $allow
+     */
+    public function setAllowFalse($allow)
+    {
+        $this->allowFalse = (bool) $allow;
+    }
+
+    /**
+     * Sets whether new keys can be defined in subsequent configurations.
+     *
+     * @param bool $allow
+     */
+    public function setAllowNewKeys($allow)
+    {
+        $this->allowNewKeys = (bool) $allow;
+    }
+
+    /**
+     * Sets if deep merging should occur.
+     *
+     * @param bool $boolean
+     */
+    public function setPerformDeepMerging($boolean)
+    {
+        $this->performDeepMerging = (bool) $boolean;
+    }
+
+    /**
+     * Whether extra keys should just be ignore without an exception.
+     *
+     * @param bool $boolean To allow extra keys
+     * @param bool $remove  To remove extra keys
+     */
+    public function setIgnoreExtraKeys($boolean, $remove = true)
+    {
+        $this->ignoreExtraKeys = (bool) $boolean;
+        $this->removeExtraKeys = $this->ignoreExtraKeys && $remove;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function setName($name)
+    {
+        $this->name = $name;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function hasDefaultValue()
+    {
+        return $this->addIfNotSet;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getDefaultValue()
+    {
+        if (!$this->hasDefaultValue()) {
+            throw new \RuntimeException(sprintf('The node at path "%s" has no default value.', $this->getPath()));
+        }
+
+        $defaults = array();
+        foreach ($this->children as $name => $child) {
+            if ($child->hasDefaultValue()) {
+                $defaults[$name] = $child->getDefaultValue();
+            }
+        }
+
+        return $defaults;
+    }
+
+    /**
+     * Adds a child node.
+     *
+     * @throws \InvalidArgumentException when the child node has no name
+     * @throws \InvalidArgumentException when the child node's name is not unique
+     */
+    public function addChild(NodeInterface $node)
+    {
+        $name = $node->getName();
+        if (!\strlen($name)) {
+            throw new \InvalidArgumentException('Child nodes must be named.');
+        }
+        if (isset($this->children[$name])) {
+            throw new \InvalidArgumentException(sprintf('A child node named "%s" already exists.', $name));
+        }
+
+        $this->children[$name] = $node;
+    }
+
+    /**
+     * Finalizes the value of this node.
+     *
+     * @param mixed $value
+     *
+     * @return mixed The finalised value
+     *
+     * @throws UnsetKeyException
+     * @throws InvalidConfigurationException if the node doesn't have enough children
+     */
+    protected function finalizeValue($value)
+    {
+        if (false === $value) {
+            throw new UnsetKeyException(sprintf('Unsetting key for path "%s", value: %s', $this->getPath(), json_encode($value)));
+        }
+
+        foreach ($this->children as $name => $child) {
+            if (!array_key_exists($name, $value)) {
+                if ($child->isRequired()) {
+                    $ex = new InvalidConfigurationException(sprintf('The child node "%s" at path "%s" must be configured.', $name, $this->getPath()));
+                    $ex->setPath($this->getPath());
+
+                    throw $ex;
+                }
+
+                if ($child->hasDefaultValue()) {
+                    $value[$name] = $child->getDefaultValue();
+                }
+
+                continue;
+            }
+
+            try {
+                $value[$name] = $child->finalize($value[$name]);
+            } catch (UnsetKeyException $e) {
+                unset($value[$name]);
+            }
+        }
+
+        return $value;
+    }
+
+    /**
+     * Validates the type of the value.
+     *
+     * @param mixed $value
+     *
+     * @throws InvalidTypeException
+     */
+    protected function validateType($value)
+    {
+        if (!\is_array($value) && (!$this->allowFalse || false !== $value)) {
+            $ex = new InvalidTypeException(sprintf('Invalid type for path "%s". Expected array, but got %s', $this->getPath(), \gettype($value)));
+            if ($hint = $this->getInfo()) {
+                $ex->addHint($hint);
+            }
+            $ex->setPath($this->getPath());
+
+            throw $ex;
+        }
+    }
+
+    /**
+     * Normalizes the value.
+     *
+     * @param mixed $value The value to normalize
+     *
+     * @return mixed The normalized value
+     *
+     * @throws InvalidConfigurationException
+     */
+    protected function normalizeValue($value)
+    {
+        if (false === $value) {
+            return $value;
+        }
+
+        $value = $this->remapXml($value);
+
+        $normalized = array();
+        foreach ($value as $name => $val) {
+            if (isset($this->children[$name])) {
+                $normalized[$name] = $this->children[$name]->normalize($val);
+                unset($value[$name]);
+            } elseif (!$this->removeExtraKeys) {
+                $normalized[$name] = $val;
+            }
+        }
+
+        // if extra fields are present, throw exception
+        if (\count($value) && !$this->ignoreExtraKeys) {
+            $ex = new InvalidConfigurationException(sprintf('Unrecognized option%s "%s" under "%s"', 1 === \count($value) ? '' : 's', implode(', ', array_keys($value)), $this->getPath()));
+            $ex->setPath($this->getPath());
+
+            throw $ex;
+        }
+
+        return $normalized;
+    }
+
+    /**
+     * Remaps multiple singular values to a single plural value.
+     *
+     * @param array $value The source values
+     *
+     * @return array The remapped values
+     */
+    protected function remapXml($value)
+    {
+        foreach ($this->xmlRemappings as $transformation) {
+            list($singular, $plural) = $transformation;
+
+            if (!isset($value[$singular])) {
+                continue;
+            }
+
+            $value[$plural] = Processor::normalizeConfig($value, $singular, $plural);
+            unset($value[$singular]);
+        }
+
+        return $value;
+    }
+
+    /**
+     * Merges values together.
+     *
+     * @param mixed $leftSide  The left side to merge
+     * @param mixed $rightSide The right side to merge
+     *
+     * @return mixed The merged values
+     *
+     * @throws InvalidConfigurationException
+     * @throws \RuntimeException
+     */
+    protected function mergeValues($leftSide, $rightSide)
+    {
+        if (false === $rightSide) {
+            // if this is still false after the last config has been merged the
+            // finalization pass will take care of removing this key entirely
+            return false;
+        }
+
+        if (false === $leftSide || !$this->performDeepMerging) {
+            return $rightSide;
+        }
+
+        foreach ($rightSide as $k => $v) {
+            // no conflict
+            if (!array_key_exists($k, $leftSide)) {
+                if (!$this->allowNewKeys) {
+                    $ex = new InvalidConfigurationException(sprintf('You are not allowed to define new elements for path "%s". Please define all elements for this path in one config file. If you are trying to overwrite an element, make sure you redefine it with the same name.', $this->getPath()));
+                    $ex->setPath($this->getPath());
+
+                    throw $ex;
+                }
+
+                $leftSide[$k] = $v;
+                continue;
+            }
+
+            if (!isset($this->children[$k])) {
+                throw new \RuntimeException('merge() expects a normalized config array.');
+            }
+
+            $leftSide[$k] = $this->children[$k]->merge($leftSide[$k], $v);
+        }
+
+        return $leftSide;
+    }
+}

msd2/phpBB3/vendor/symfony/config/Definition/BaseNode.php

@@ -0,0 +1,325 @@
+<?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\Config\Definition;
+
+use Symfony\Component\Config\Definition\Exception\Exception;
+use Symfony\Component\Config\Definition\Exception\ForbiddenOverwriteException;
+use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
+use Symfony\Component\Config\Definition\Exception\InvalidTypeException;
+
+/**
+ * The base node class.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+abstract class BaseNode implements NodeInterface
+{
+    protected $name;
+    protected $parent;
+    protected $normalizationClosures = array();
+    protected $finalValidationClosures = array();
+    protected $allowOverwrite = true;
+    protected $required = false;
+    protected $equivalentValues = array();
+    protected $attributes = array();
+
+    /**
+     * @param string|null        $name   The name of the node
+     * @param NodeInterface|null $parent The parent of this node
+     *
+     * @throws \InvalidArgumentException if the name contains a period
+     */
+    public function __construct($name, NodeInterface $parent = null)
+    {
+        if (false !== strpos($name = (string) $name, '.')) {
+            throw new \InvalidArgumentException('The name must not contain ".".');
+        }
+
+        $this->name = $name;
+        $this->parent = $parent;
+    }
+
+    public function setAttribute($key, $value)
+    {
+        $this->attributes[$key] = $value;
+    }
+
+    public function getAttribute($key, $default = null)
+    {
+        return isset($this->attributes[$key]) ? $this->attributes[$key] : $default;
+    }
+
+    public function hasAttribute($key)
+    {
+        return isset($this->attributes[$key]);
+    }
+
+    public function getAttributes()
+    {
+        return $this->attributes;
+    }
+
+    public function setAttributes(array $attributes)
+    {
+        $this->attributes = $attributes;
+    }
+
+    public function removeAttribute($key)
+    {
+        unset($this->attributes[$key]);
+    }
+
+    /**
+     * Sets an info message.
+     *
+     * @param string $info
+     */
+    public function setInfo($info)
+    {
+        $this->setAttribute('info', $info);
+    }
+
+    /**
+     * Returns info message.
+     *
+     * @return string The info text
+     */
+    public function getInfo()
+    {
+        return $this->getAttribute('info');
+    }
+
+    /**
+     * Sets the example configuration for this node.
+     *
+     * @param string|array $example
+     */
+    public function setExample($example)
+    {
+        $this->setAttribute('example', $example);
+    }
+
+    /**
+     * Retrieves the example configuration for this node.
+     *
+     * @return string|array The example
+     */
+    public function getExample()
+    {
+        return $this->getAttribute('example');
+    }
+
+    /**
+     * Adds an equivalent value.
+     *
+     * @param mixed $originalValue
+     * @param mixed $equivalentValue
+     */
+    public function addEquivalentValue($originalValue, $equivalentValue)
+    {
+        $this->equivalentValues[] = array($originalValue, $equivalentValue);
+    }
+
+    /**
+     * Set this node as required.
+     *
+     * @param bool $boolean Required node
+     */
+    public function setRequired($boolean)
+    {
+        $this->required = (bool) $boolean;
+    }
+
+    /**
+     * Sets if this node can be overridden.
+     *
+     * @param bool $allow
+     */
+    public function setAllowOverwrite($allow)
+    {
+        $this->allowOverwrite = (bool) $allow;
+    }
+
+    /**
+     * Sets the closures used for normalization.
+     *
+     * @param \Closure[] $closures An array of Closures used for normalization
+     */
+    public function setNormalizationClosures(array $closures)
+    {
+        $this->normalizationClosures = $closures;
+    }
+
+    /**
+     * Sets the closures used for final validation.
+     *
+     * @param \Closure[] $closures An array of Closures used for final validation
+     */
+    public function setFinalValidationClosures(array $closures)
+    {
+        $this->finalValidationClosures = $closures;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isRequired()
+    {
+        return $this->required;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getPath()
+    {
+        $path = $this->name;
+
+        if (null !== $this->parent) {
+            $path = $this->parent->getPath().'.'.$path;
+        }
+
+        return $path;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    final public function merge($leftSide, $rightSide)
+    {
+        if (!$this->allowOverwrite) {
+            throw new ForbiddenOverwriteException(sprintf('Configuration path "%s" cannot be overwritten. You have to define all options for this path, and any of its sub-paths in one configuration section.', $this->getPath()));
+        }
+
+        $this->validateType($leftSide);
+        $this->validateType($rightSide);
+
+        return $this->mergeValues($leftSide, $rightSide);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    final public function normalize($value)
+    {
+        $value = $this->preNormalize($value);
+
+        // run custom normalization closures
+        foreach ($this->normalizationClosures as $closure) {
+            $value = $closure($value);
+        }
+
+        // replace value with their equivalent
+        foreach ($this->equivalentValues as $data) {
+            if ($data[0] === $value) {
+                $value = $data[1];
+            }
+        }
+
+        // validate type
+        $this->validateType($value);
+
+        // normalize value
+        return $this->normalizeValue($value);
+    }
+
+    /**
+     * Normalizes the value before any other normalization is applied.
+     *
+     * @param $value
+     *
+     * @return $value The normalized array value
+     */
+    protected function preNormalize($value)
+    {
+        return $value;
+    }
+
+    /**
+     * Returns parent node for this node.
+     *
+     * @return NodeInterface|null
+     */
+    public function getParent()
+    {
+        return $this->parent;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    final public function finalize($value)
+    {
+        $this->validateType($value);
+
+        $value = $this->finalizeValue($value);
+
+        // Perform validation on the final value if a closure has been set.
+        // The closure is also allowed to return another value.
+        foreach ($this->finalValidationClosures as $closure) {
+            try {
+                $value = $closure($value);
+            } catch (Exception $e) {
+                throw $e;
+            } catch (\Exception $e) {
+                throw new InvalidConfigurationException(sprintf('Invalid configuration for path "%s": %s', $this->getPath(), $e->getMessage()), $e->getCode(), $e);
+            }
+        }
+
+        return $value;
+    }
+
+    /**
+     * Validates the type of a Node.
+     *
+     * @param mixed $value The value to validate
+     *
+     * @throws InvalidTypeException when the value is invalid
+     */
+    abstract protected function validateType($value);
+
+    /**
+     * Normalizes the value.
+     *
+     * @param mixed $value The value to normalize
+     *
+     * @return mixed The normalized value
+     */
+    abstract protected function normalizeValue($value);
+
+    /**
+     * Merges two values together.
+     *
+     * @param mixed $leftSide
+     * @param mixed $rightSide
+     *
+     * @return mixed The merged value
+     */
+    abstract protected function mergeValues($leftSide, $rightSide);
+
+    /**
+     * Finalizes a value.
+     *
+     * @param mixed $value The value to finalize
+     *
+     * @return mixed The finalized value
+     */
+    abstract protected function finalizeValue($value);
+}

msd2/phpBB3/vendor/symfony/config/Definition/BooleanNode.php

@@ -0,0 +1,47 @@
+<?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\Config\Definition;
+
+use Symfony\Component\Config\Definition\Exception\InvalidTypeException;
+
+/**
+ * This node represents a Boolean value in the config tree.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class BooleanNode extends ScalarNode
+{
+    /**
+     * {@inheritdoc}
+     */
+    protected function validateType($value)
+    {
+        if (!\is_bool($value)) {
+            $ex = new InvalidTypeException(sprintf('Invalid type for path "%s". Expected boolean, but got %s.', $this->getPath(), \gettype($value)));
+            if ($hint = $this->getInfo()) {
+                $ex->addHint($hint);
+            }
+            $ex->setPath($this->getPath());
+
+            throw $ex;
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function isValueEmpty($value)
+    {
+        // a boolean value cannot be empty
+        return false;
+    }
+}

msd2/phpBB3/vendor/symfony/config/Definition/Builder/ArrayNodeDefinition.php

@@ -0,0 +1,457 @@
+<?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\Config\Definition\Builder;
+
+use Symfony\Component\Config\Definition\ArrayNode;
+use Symfony\Component\Config\Definition\Exception\InvalidDefinitionException;
+use Symfony\Component\Config\Definition\PrototypedArrayNode;
+
+/**
+ * This class provides a fluent interface for defining an array node.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class ArrayNodeDefinition extends NodeDefinition implements ParentNodeDefinitionInterface
+{
+    protected $performDeepMerging = true;
+    protected $ignoreExtraKeys = false;
+    protected $removeExtraKeys = true;
+    protected $children = array();
+    protected $prototype;
+    protected $atLeastOne = false;
+    protected $allowNewKeys = true;
+    protected $key;
+    protected $removeKeyItem;
+    protected $addDefaults = false;
+    protected $addDefaultChildren = false;
+    protected $nodeBuilder;
+    protected $normalizeKeys = true;
+
+    /**
+     * {@inheritdoc}
+     */
+    public function __construct($name, NodeParentInterface $parent = null)
+    {
+        parent::__construct($name, $parent);
+
+        $this->nullEquivalent = array();
+        $this->trueEquivalent = array();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function setBuilder(NodeBuilder $builder)
+    {
+        $this->nodeBuilder = $builder;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function children()
+    {
+        return $this->getNodeBuilder();
+    }
+
+    /**
+     * Sets a prototype for child nodes.
+     *
+     * @param string $type The type of node
+     *
+     * @return NodeDefinition
+     */
+    public function prototype($type)
+    {
+        return $this->prototype = $this->getNodeBuilder()->node(null, $type)->setParent($this);
+    }
+
+    /**
+     * Adds the default value if the node is not set in the configuration.
+     *
+     * This method is applicable to concrete nodes only (not to prototype nodes).
+     * If this function has been called and the node is not set during the finalization
+     * phase, it's default value will be derived from its children default values.
+     *
+     * @return $this
+     */
+    public function addDefaultsIfNotSet()
+    {
+        $this->addDefaults = true;
+
+        return $this;
+    }
+
+    /**
+     * Adds children with a default value when none are defined.
+     *
+     * This method is applicable to prototype nodes only.
+     *
+     * @param int|string|array|null $children The number of children|The child name|The children names to be added
+     *
+     * @return $this
+     */
+    public function addDefaultChildrenIfNoneSet($children = null)
+    {
+        $this->addDefaultChildren = $children;
+
+        return $this;
+    }
+
+    /**
+     * Requires the node to have at least one element.
+     *
+     * This method is applicable to prototype nodes only.
+     *
+     * @return $this
+     */
+    public function requiresAtLeastOneElement()
+    {
+        $this->atLeastOne = true;
+
+        return $this;
+    }
+
+    /**
+     * Disallows adding news keys in a subsequent configuration.
+     *
+     * If used all keys have to be defined in the same configuration file.
+     *
+     * @return $this
+     */
+    public function disallowNewKeysInSubsequentConfigs()
+    {
+        $this->allowNewKeys = false;
+
+        return $this;
+    }
+
+    /**
+     * Sets a normalization rule for XML configurations.
+     *
+     * @param string $singular The key to remap
+     * @param string $plural   The plural of the key for irregular plurals
+     *
+     * @return $this
+     */
+    public function fixXmlConfig($singular, $plural = null)
+    {
+        $this->normalization()->remap($singular, $plural);
+
+        return $this;
+    }
+
+    /**
+     * Sets the attribute which value is to be used as key.
+     *
+     * This is useful when you have an indexed array that should be an
+     * associative array. You can select an item from within the array
+     * to be the key of the particular item. For example, if "id" is the
+     * "key", then:
+     *
+     *     array(
+     *         array('id' => 'my_name', 'foo' => 'bar'),
+     *     );
+     *
+     *   becomes
+     *
+     *     array(
+     *         'my_name' => array('foo' => 'bar'),
+     *     );
+     *
+     * If you'd like "'id' => 'my_name'" to still be present in the resulting
+     * array, then you can set the second argument of this method to false.
+     *
+     * This method is applicable to prototype nodes only.
+     *
+     * @param string $name          The name of the key
+     * @param bool   $removeKeyItem Whether or not the key item should be removed
+     *
+     * @return $this
+     */
+    public function useAttributeAsKey($name, $removeKeyItem = true)
+    {
+        $this->key = $name;
+        $this->removeKeyItem = $removeKeyItem;
+
+        return $this;
+    }
+
+    /**
+     * Sets whether the node can be unset.
+     *
+     * @param bool $allow
+     *
+     * @return $this
+     */
+    public function canBeUnset($allow = true)
+    {
+        $this->merge()->allowUnset($allow);
+
+        return $this;
+    }
+
+    /**
+     * Adds an "enabled" boolean to enable the current section.
+     *
+     * By default, the section is disabled. If any configuration is specified then
+     * the node will be automatically enabled:
+     *
+     * enableableArrayNode: {enabled: true, ...}   # The config is enabled & default values get overridden
+     * enableableArrayNode: ~                      # The config is enabled & use the default values
+     * enableableArrayNode: true                   # The config is enabled & use the default values
+     * enableableArrayNode: {other: value, ...}    # The config is enabled & default values get overridden
+     * enableableArrayNode: {enabled: false, ...}  # The config is disabled
+     * enableableArrayNode: false                  # The config is disabled
+     *
+     * @return $this
+     */
+    public function canBeEnabled()
+    {
+        $this
+            ->addDefaultsIfNotSet()
+            ->treatFalseLike(array('enabled' => false))
+            ->treatTrueLike(array('enabled' => true))
+            ->treatNullLike(array('enabled' => true))
+            ->beforeNormalization()
+                ->ifArray()
+                ->then(function ($v) {
+                    $v['enabled'] = isset($v['enabled']) ? $v['enabled'] : true;
+
+                    return $v;
+                })
+            ->end()
+            ->children()
+                ->booleanNode('enabled')
+                    ->defaultFalse()
+        ;
+
+        return $this;
+    }
+
+    /**
+     * Adds an "enabled" boolean to enable the current section.
+     *
+     * By default, the section is enabled.
+     *
+     * @return $this
+     */
+    public function canBeDisabled()
+    {
+        $this
+            ->addDefaultsIfNotSet()
+            ->treatFalseLike(array('enabled' => false))
+            ->treatTrueLike(array('enabled' => true))
+            ->treatNullLike(array('enabled' => true))
+            ->children()
+                ->booleanNode('enabled')
+                    ->defaultTrue()
+        ;
+
+        return $this;
+    }
+
+    /**
+     * Disables the deep merging of the node.
+     *
+     * @return $this
+     */
+    public function performNoDeepMerging()
+    {
+        $this->performDeepMerging = false;
+
+        return $this;
+    }
+
+    /**
+     * Allows extra config keys to be specified under an array without
+     * throwing an exception.
+     *
+     * Those config values are simply ignored and removed from the
+     * resulting array. This should be used only in special cases where
+     * you want to send an entire configuration array through a special
+     * tree that processes only part of the array.
+     *
+     * @param bool $remove Whether to remove the extra keys
+     *
+     * @return $this
+     */
+    public function ignoreExtraKeys($remove = true)
+    {
+        $this->ignoreExtraKeys = true;
+        $this->removeExtraKeys = $remove;
+
+        return $this;
+    }
+
+    /**
+     * Sets key normalization.
+     *
+     * @param bool $bool Whether to enable key normalization
+     *
+     * @return $this
+     */
+    public function normalizeKeys($bool)
+    {
+        $this->normalizeKeys = (bool) $bool;
+
+        return $this;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function append(NodeDefinition $node)
+    {
+        $this->children[$node->name] = $node->setParent($this);
+
+        return $this;
+    }
+
+    /**
+     * Returns a node builder to be used to add children and prototype.
+     *
+     * @return NodeBuilder The node builder
+     */
+    protected function getNodeBuilder()
+    {
+        if (null === $this->nodeBuilder) {
+            $this->nodeBuilder = new NodeBuilder();
+        }
+
+        return $this->nodeBuilder->setParent($this);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function createNode()
+    {
+        if (null === $this->prototype) {
+            $node = new ArrayNode($this->name, $this->parent);
+
+            $this->validateConcreteNode($node);
+
+            $node->setAddIfNotSet($this->addDefaults);
+
+            foreach ($this->children as $child) {
+                $child->parent = $node;
+                $node->addChild($child->getNode());
+            }
+        } else {
+            $node = new PrototypedArrayNode($this->name, $this->parent);
+
+            $this->validatePrototypeNode($node);
+
+            if (null !== $this->key) {
+                $node->setKeyAttribute($this->key, $this->removeKeyItem);
+            }
+
+            if (true === $this->atLeastOne) {
+                $node->setMinNumberOfElements(1);
+            }
+
+            if ($this->default) {
+                $node->setDefaultValue($this->defaultValue);
+            }
+
+            if (false !== $this->addDefaultChildren) {
+                $node->setAddChildrenIfNoneSet($this->addDefaultChildren);
+                if ($this->prototype instanceof static && null === $this->prototype->prototype) {
+                    $this->prototype->addDefaultsIfNotSet();
+                }
+            }
+
+            $this->prototype->parent = $node;
+            $node->setPrototype($this->prototype->getNode());
+        }
+
+        $node->setAllowNewKeys($this->allowNewKeys);
+        $node->addEquivalentValue(null, $this->nullEquivalent);
+        $node->addEquivalentValue(true, $this->trueEquivalent);
+        $node->addEquivalentValue(false, $this->falseEquivalent);
+        $node->setPerformDeepMerging($this->performDeepMerging);
+        $node->setRequired($this->required);
+        $node->setIgnoreExtraKeys($this->ignoreExtraKeys, $this->removeExtraKeys);
+        $node->setNormalizeKeys($this->normalizeKeys);
+
+        if (null !== $this->normalization) {
+            $node->setNormalizationClosures($this->normalization->before);
+            $node->setXmlRemappings($this->normalization->remappings);
+        }
+
+        if (null !== $this->merge) {
+            $node->setAllowOverwrite($this->merge->allowOverwrite);
+            $node->setAllowFalse($this->merge->allowFalse);
+        }
+
+        if (null !== $this->validation) {
+            $node->setFinalValidationClosures($this->validation->rules);
+        }
+
+        return $node;
+    }
+
+    /**
+     * Validate the configuration of a concrete node.
+     *
+     * @throws InvalidDefinitionException
+     */
+    protected function validateConcreteNode(ArrayNode $node)
+    {
+        $path = $node->getPath();
+
+        if (null !== $this->key) {
+            throw new InvalidDefinitionException(sprintf('->useAttributeAsKey() is not applicable to concrete nodes at path "%s"', $path));
+        }
+
+        if (true === $this->atLeastOne) {
+            throw new InvalidDefinitionException(sprintf('->requiresAtLeastOneElement() is not applicable to concrete nodes at path "%s"', $path));
+        }
+
+        if ($this->default) {
+            throw new InvalidDefinitionException(sprintf('->defaultValue() is not applicable to concrete nodes at path "%s"', $path));
+        }
+
+        if (false !== $this->addDefaultChildren) {
+            throw new InvalidDefinitionException(sprintf('->addDefaultChildrenIfNoneSet() is not applicable to concrete nodes at path "%s"', $path));
+        }
+    }
+
+    /**
+     * Validate the configuration of a prototype node.
+     *
+     * @throws InvalidDefinitionException
+     */
+    protected function validatePrototypeNode(PrototypedArrayNode $node)
+    {
+        $path = $node->getPath();
+
+        if ($this->addDefaults) {
+            throw new InvalidDefinitionException(sprintf('->addDefaultsIfNotSet() is not applicable to prototype nodes at path "%s"', $path));
+        }
+
+        if (false !== $this->addDefaultChildren) {
+            if ($this->default) {
+                throw new InvalidDefinitionException(sprintf('A default value and default children might not be used together at path "%s"', $path));
+            }
+
+            if (null !== $this->key && (null === $this->addDefaultChildren || \is_int($this->addDefaultChildren) && $this->addDefaultChildren > 0)) {
+                throw new InvalidDefinitionException(sprintf('->addDefaultChildrenIfNoneSet() should set default children names as ->useAttributeAsKey() is used at path "%s"', $path));
+            }
+
+            if (null === $this->key && (\is_string($this->addDefaultChildren) || \is_array($this->addDefaultChildren))) {
+                throw new InvalidDefinitionException(sprintf('->addDefaultChildrenIfNoneSet() might not set default children names as ->useAttributeAsKey() is not used at path "%s"', $path));
+            }
+        }
+    }
+}

msd2/phpBB3/vendor/symfony/config/Definition/Builder/BooleanNodeDefinition.php

@@ -0,0 +1,54 @@
+<?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\Config\Definition\Builder;
+
+use Symfony\Component\Config\Definition\BooleanNode;
+
+/**
+ * This class provides a fluent interface for defining a node.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class BooleanNodeDefinition extends ScalarNodeDefinition
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function __construct($name, NodeParentInterface $parent = null)
+    {
+        parent::__construct($name, $parent);
+
+        $this->nullEquivalent = true;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @deprecated Deprecated since version 2.8, to be removed in 3.0.
+     */
+    public function cannotBeEmpty()
+    {
+        @trigger_error('The '.__METHOD__.' method is deprecated since Symfony 2.8 and will be removed in 3.0.', E_USER_DEPRECATED);
+
+        return parent::cannotBeEmpty();
+    }
+
+    /**
+     * Instantiate a Node.
+     *
+     * @return BooleanNode The node
+     */
+    protected function instantiateNode()
+    {
+        return new BooleanNode($this->name, $this->parent);
+    }
+}

msd2/phpBB3/vendor/symfony/config/Definition/Builder/EnumNodeDefinition.php

@@ -0,0 +1,56 @@
+<?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\Config\Definition\Builder;
+
+use Symfony\Component\Config\Definition\EnumNode;
+
+/**
+ * Enum Node Definition.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class EnumNodeDefinition extends ScalarNodeDefinition
+{
+    private $values;
+
+    /**
+     * @return $this
+     */
+    public function values(array $values)
+    {
+        $values = array_unique($values);
+
+        if (empty($values)) {
+            throw new \InvalidArgumentException('->values() must be called with at least one value.');
+        }
+
+        $this->values = $values;
+
+        return $this;
+    }
+
+    /**
+     * Instantiate a Node.
+     *
+     * @return EnumNode The node
+     *
+     * @throws \RuntimeException
+     */
+    protected function instantiateNode()
+    {
+        if (null === $this->values) {
+            throw new \RuntimeException('You must call ->values() on enum nodes.');
+        }
+
+        return new EnumNode($this->name, $this->parent, $this->values);
+    }
+}

msd2/phpBB3/vendor/symfony/config/Definition/Builder/ExprBuilder.php

@@ -0,0 +1,223 @@
+<?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\Config\Definition\Builder;
+
+use Symfony\Component\Config\Definition\Exception\UnsetKeyException;
+
+/**
+ * This class builds an if expression.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ * @author Christophe Coevoet <stof@notk.org>
+ */
+class ExprBuilder
+{
+    protected $node;
+    public $ifPart;
+    public $thenPart;
+
+    public function __construct(NodeDefinition $node)
+    {
+        $this->node = $node;
+    }
+
+    /**
+     * Marks the expression as being always used.
+     *
+     * @return $this
+     */
+    public function always(\Closure $then = null)
+    {
+        $this->ifPart = function ($v) { return true; };
+
+        if (null !== $then) {
+            $this->thenPart = $then;
+        }
+
+        return $this;
+    }
+
+    /**
+     * Sets a closure to use as tests.
+     *
+     * The default one tests if the value is true.
+     *
+     * @return $this
+     */
+    public function ifTrue(\Closure $closure = null)
+    {
+        if (null === $closure) {
+            $closure = function ($v) { return true === $v; };
+        }
+
+        $this->ifPart = $closure;
+
+        return $this;
+    }
+
+    /**
+     * Tests if the value is a string.
+     *
+     * @return $this
+     */
+    public function ifString()
+    {
+        $this->ifPart = function ($v) { return \is_string($v); };
+
+        return $this;
+    }
+
+    /**
+     * Tests if the value is null.
+     *
+     * @return $this
+     */
+    public function ifNull()
+    {
+        $this->ifPart = function ($v) { return null === $v; };
+
+        return $this;
+    }
+
+    /**
+     * Tests if the value is an array.
+     *
+     * @return $this
+     */
+    public function ifArray()
+    {
+        $this->ifPart = function ($v) { return \is_array($v); };
+
+        return $this;
+    }
+
+    /**
+     * Tests if the value is in an array.
+     *
+     * @return $this
+     */
+    public function ifInArray(array $array)
+    {
+        $this->ifPart = function ($v) use ($array) { return \in_array($v, $array, true); };
+
+        return $this;
+    }
+
+    /**
+     * Tests if the value is not in an array.
+     *
+     * @return $this
+     */
+    public function ifNotInArray(array $array)
+    {
+        $this->ifPart = function ($v) use ($array) { return !\in_array($v, $array, true); };
+
+        return $this;
+    }
+
+    /**
+     * Sets the closure to run if the test pass.
+     *
+     * @return $this
+     */
+    public function then(\Closure $closure)
+    {
+        $this->thenPart = $closure;
+
+        return $this;
+    }
+
+    /**
+     * Sets a closure returning an empty array.
+     *
+     * @return $this
+     */
+    public function thenEmptyArray()
+    {
+        $this->thenPart = function ($v) { return array(); };
+
+        return $this;
+    }
+
+    /**
+     * Sets a closure marking the value as invalid at validation time.
+     *
+     * if you want to add the value of the node in your message just use a %s placeholder.
+     *
+     * @param string $message
+     *
+     * @return $this
+     *
+     * @throws \InvalidArgumentException
+     */
+    public function thenInvalid($message)
+    {
+        $this->thenPart = function ($v) use ($message) { throw new \InvalidArgumentException(sprintf($message, json_encode($v))); };
+
+        return $this;
+    }
+
+    /**
+     * Sets a closure unsetting this key of the array at validation time.
+     *
+     * @return $this
+     *
+     * @throws UnsetKeyException
+     */
+    public function thenUnset()
+    {
+        $this->thenPart = function ($v) { throw new UnsetKeyException('Unsetting key'); };
+
+        return $this;
+    }
+
+    /**
+     * Returns the related node.
+     *
+     * @return NodeDefinition|ArrayNodeDefinition|VariableNodeDefinition
+     *
+     * @throws \RuntimeException
+     */
+    public function end()
+    {
+        if (null === $this->ifPart) {
+            throw new \RuntimeException('You must specify an if part.');
+        }
+        if (null === $this->thenPart) {
+            throw new \RuntimeException('You must specify a then part.');
+        }
+
+        return $this->node;
+    }
+
+    /**
+     * Builds the expressions.
+     *
+     * @param ExprBuilder[] $expressions An array of ExprBuilder instances to build
+     *
+     * @return array
+     */
+    public static function buildExpressions(array $expressions)
+    {
+        foreach ($expressions as $k => $expr) {
+            if ($expr instanceof self) {
+                $if = $expr->ifPart;
+                $then = $expr->thenPart;
+                $expressions[$k] = function ($v) use ($if, $then) {
+                    return $if($v) ? $then($v) : $v;
+                };
+            }
+        }
+
+        return $expressions;
+    }
+}

msd2/phpBB3/vendor/symfony/config/Definition/Builder/FloatNodeDefinition.php

@@ -0,0 +1,32 @@
+<?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\Config\Definition\Builder;
+
+use Symfony\Component\Config\Definition\FloatNode;
+
+/**
+ * This class provides a fluent interface for defining a float node.
+ *
+ * @author Jeanmonod David <david.jeanmonod@gmail.com>
+ */
+class FloatNodeDefinition extends NumericNodeDefinition
+{
+    /**
+     * Instantiates a Node.
+     *
+     * @return FloatNode The node
+     */
+    protected function instantiateNode()
+    {
+        return new FloatNode($this->name, $this->parent, $this->min, $this->max);
+    }
+}

msd2/phpBB3/vendor/symfony/config/Definition/Builder/IntegerNodeDefinition.php

@@ -0,0 +1,32 @@
+<?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\Config\Definition\Builder;
+
+use Symfony\Component\Config\Definition\IntegerNode;
+
+/**
+ * This class provides a fluent interface for defining an integer node.
+ *
+ * @author Jeanmonod David <david.jeanmonod@gmail.com>
+ */
+class IntegerNodeDefinition extends NumericNodeDefinition
+{
+    /**
+     * Instantiates a Node.
+     *
+     * @return IntegerNode The node
+     */
+    protected function instantiateNode()
+    {
+        return new IntegerNode($this->name, $this->parent, $this->min, $this->max);
+    }
+}

msd2/phpBB3/vendor/symfony/config/Definition/Builder/MergeBuilder.php

@@ -0,0 +1,67 @@
+<?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\Config\Definition\Builder;
+
+/**
+ * This class builds merge conditions.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class MergeBuilder
+{
+    protected $node;
+    public $allowFalse = false;
+    public $allowOverwrite = true;
+
+    public function __construct(NodeDefinition $node)
+    {
+        $this->node = $node;
+    }
+
+    /**
+     * Sets whether the node can be unset.
+     *
+     * @param bool $allow
+     *
+     * @return $this
+     */
+    public function allowUnset($allow = true)
+    {
+        $this->allowFalse = $allow;
+
+        return $this;
+    }
+
+    /**
+     * Sets whether the node can be overwritten.
+     *
+     * @param bool $deny Whether the overwriting is forbidden or not
+     *
+     * @return $this
+     */
+    public function denyOverwrite($deny = true)
+    {
+        $this->allowOverwrite = !$deny;
+
+        return $this;
+    }
+
+    /**
+     * Returns the related node.
+     *
+     * @return NodeDefinition|ArrayNodeDefinition|VariableNodeDefinition
+     */
+    public function end()
+    {
+        return $this->node;
+    }
+}

msd2/phpBB3/vendor/symfony/config/Definition/Builder/NodeBuilder.php

@@ -0,0 +1,238 @@
+<?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\Config\Definition\Builder;
+
+/**
+ * This class provides a fluent interface for building a node.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class NodeBuilder implements NodeParentInterface
+{
+    protected $parent;
+    protected $nodeMapping;
+
+    public function __construct()
+    {
+        $this->nodeMapping = array(
+            'variable' => __NAMESPACE__.'\\VariableNodeDefinition',
+            'scalar' => __NAMESPACE__.'\\ScalarNodeDefinition',
+            'boolean' => __NAMESPACE__.'\\BooleanNodeDefinition',
+            'integer' => __NAMESPACE__.'\\IntegerNodeDefinition',
+            'float' => __NAMESPACE__.'\\FloatNodeDefinition',
+            'array' => __NAMESPACE__.'\\ArrayNodeDefinition',
+            'enum' => __NAMESPACE__.'\\EnumNodeDefinition',
+        );
+    }
+
+    /**
+     * Set the parent node.
+     *
+     * @return $this
+     */
+    public function setParent(ParentNodeDefinitionInterface $parent = null)
+    {
+        $this->parent = $parent;
+
+        return $this;
+    }
+
+    /**
+     * Creates a child array node.
+     *
+     * @param string $name The name of the node
+     *
+     * @return ArrayNodeDefinition The child node
+     */
+    public function arrayNode($name)
+    {
+        return $this->node($name, 'array');
+    }
+
+    /**
+     * Creates a child scalar node.
+     *
+     * @param string $name The name of the node
+     *
+     * @return ScalarNodeDefinition The child node
+     */
+    public function scalarNode($name)
+    {
+        return $this->node($name, 'scalar');
+    }
+
+    /**
+     * Creates a child Boolean node.
+     *
+     * @param string $name The name of the node
+     *
+     * @return BooleanNodeDefinition The child node
+     */
+    public function booleanNode($name)
+    {
+        return $this->node($name, 'boolean');
+    }
+
+    /**
+     * Creates a child integer node.
+     *
+     * @param string $name The name of the node
+     *
+     * @return IntegerNodeDefinition The child node
+     */
+    public function integerNode($name)
+    {
+        return $this->node($name, 'integer');
+    }
+
+    /**
+     * Creates a child float node.
+     *
+     * @param string $name The name of the node
+     *
+     * @return FloatNodeDefinition The child node
+     */
+    public function floatNode($name)
+    {
+        return $this->node($name, 'float');
+    }
+
+    /**
+     * Creates a child EnumNode.
+     *
+     * @param string $name
+     *
+     * @return EnumNodeDefinition
+     */
+    public function enumNode($name)
+    {
+        return $this->node($name, 'enum');
+    }
+
+    /**
+     * Creates a child variable node.
+     *
+     * @param string $name The name of the node
+     *
+     * @return VariableNodeDefinition The builder of the child node
+     */
+    public function variableNode($name)
+    {
+        return $this->node($name, 'variable');
+    }
+
+    /**
+     * Returns the parent node.
+     *
+     * @return ParentNodeDefinitionInterface|NodeDefinition The parent node
+     */
+    public function end()
+    {
+        return $this->parent;
+    }
+
+    /**
+     * Creates a child node.
+     *
+     * @param string|null $name The name of the node
+     * @param string      $type The type of the node
+     *
+     * @return NodeDefinition The child node
+     *
+     * @throws \RuntimeException When the node type is not registered
+     * @throws \RuntimeException When the node class is not found
+     */
+    public function node($name, $type)
+    {
+        $class = $this->getNodeClass($type);
+
+        $node = new $class($name);
+
+        $this->append($node);
+
+        return $node;
+    }
+
+    /**
+     * Appends a node definition.
+     *
+     * Usage:
+     *
+     *     $node = new ArrayNodeDefinition('name')
+     *         ->children()
+     *             ->scalarNode('foo')->end()
+     *             ->scalarNode('baz')->end()
+     *             ->append($this->getBarNodeDefinition())
+     *         ->end()
+     *     ;
+     *
+     * @return $this
+     */
+    public function append(NodeDefinition $node)
+    {
+        if ($node instanceof ParentNodeDefinitionInterface) {
+            $builder = clone $this;
+            $builder->setParent(null);
+            $node->setBuilder($builder);
+        }
+
+        if (null !== $this->parent) {
+            $this->parent->append($node);
+            // Make this builder the node parent to allow for a fluid interface
+            $node->setParent($this);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Adds or overrides a node Type.
+     *
+     * @param string $type  The name of the type
+     * @param string $class The fully qualified name the node definition class
+     *
+     * @return $this
+     */
+    public function setNodeClass($type, $class)
+    {
+        $this->nodeMapping[strtolower($type)] = $class;
+
+        return $this;
+    }
+
+    /**
+     * Returns the class name of the node definition.
+     *
+     * @param string $type The node type
+     *
+     * @return string The node definition class name
+     *
+     * @throws \RuntimeException When the node type is not registered
+     * @throws \RuntimeException When the node class is not found
+     */
+    protected function getNodeClass($type)
+    {
+        $type = strtolower($type);
+
+        if (!isset($this->nodeMapping[$type])) {
+            throw new \RuntimeException(sprintf('The node type "%s" is not registered.', $type));
+        }
+
+        $class = $this->nodeMapping[$type];
+
+        if (!class_exists($class)) {
+            throw new \RuntimeException(sprintf('The node class "%s" does not exist.', $class));
+        }
+
+        return $class;
+    }
+}

msd2/phpBB3/vendor/symfony/config/Definition/Builder/NodeDefinition.php

@@ -0,0 +1,335 @@
+<?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\Config\Definition\Builder;
+
+use Symfony\Component\Config\Definition\Exception\InvalidDefinitionException;
+use Symfony\Component\Config\Definition\NodeInterface;
+
+/**
+ * This class provides a fluent interface for defining a node.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+abstract class NodeDefinition implements NodeParentInterface
+{
+    protected $name;
+    protected $normalization;
+    protected $validation;
+    protected $defaultValue;
+    protected $default = false;
+    protected $required = false;
+    protected $merge;
+    protected $allowEmptyValue = true;
+    protected $nullEquivalent;
+    protected $trueEquivalent = true;
+    protected $falseEquivalent = false;
+    protected $parent;
+    protected $attributes = array();
+
+    /**
+     * @param string|null              $name   The name of the node
+     * @param NodeParentInterface|null $parent The parent
+     */
+    public function __construct($name, NodeParentInterface $parent = null)
+    {
+        $this->parent = $parent;
+        $this->name = $name;
+    }
+
+    /**
+     * Sets the parent node.
+     *
+     * @return $this
+     */
+    public function setParent(NodeParentInterface $parent)
+    {
+        $this->parent = $parent;
+
+        return $this;
+    }
+
+    /**
+     * Sets info message.
+     *
+     * @param string $info The info text
+     *
+     * @return $this
+     */
+    public function info($info)
+    {
+        return $this->attribute('info', $info);
+    }
+
+    /**
+     * Sets example configuration.
+     *
+     * @param string|array $example
+     *
+     * @return $this
+     */
+    public function example($example)
+    {
+        return $this->attribute('example', $example);
+    }
+
+    /**
+     * Sets an attribute on the node.
+     *
+     * @param string $key
+     * @param mixed  $value
+     *
+     * @return $this
+     */
+    public function attribute($key, $value)
+    {
+        $this->attributes[$key] = $value;
+
+        return $this;
+    }
+
+    /**
+     * Returns the parent node.
+     *
+     * @return NodeParentInterface|NodeBuilder|NodeDefinition|ArrayNodeDefinition|VariableNodeDefinition|null The builder of the parent node
+     */
+    public function end()
+    {
+        return $this->parent;
+    }
+
+    /**
+     * Creates the node.
+     *
+     * @param bool $forceRootNode Whether to force this node as the root node
+     *
+     * @return NodeInterface
+     */
+    public function getNode($forceRootNode = false)
+    {
+        if ($forceRootNode) {
+            $this->parent = null;
+        }
+
+        if (null !== $this->normalization) {
+            $this->normalization->before = ExprBuilder::buildExpressions($this->normalization->before);
+        }
+
+        if (null !== $this->validation) {
+            $this->validation->rules = ExprBuilder::buildExpressions($this->validation->rules);
+        }
+
+        $node = $this->createNode();
+        $node->setAttributes($this->attributes);
+
+        return $node;
+    }
+
+    /**
+     * Sets the default value.
+     *
+     * @param mixed $value The default value
+     *
+     * @return $this
+     */
+    public function defaultValue($value)
+    {
+        $this->default = true;
+        $this->defaultValue = $value;
+
+        return $this;
+    }
+
+    /**
+     * Sets the node as required.
+     *
+     * @return $this
+     */
+    public function isRequired()
+    {
+        $this->required = true;
+
+        return $this;
+    }
+
+    /**
+     * Sets the equivalent value used when the node contains null.
+     *
+     * @param mixed $value
+     *
+     * @return $this
+     */
+    public function treatNullLike($value)
+    {
+        $this->nullEquivalent = $value;
+
+        return $this;
+    }
+
+    /**
+     * Sets the equivalent value used when the node contains true.
+     *
+     * @param mixed $value
+     *
+     * @return $this
+     */
+    public function treatTrueLike($value)
+    {
+        $this->trueEquivalent = $value;
+
+        return $this;
+    }
+
+    /**
+     * Sets the equivalent value used when the node contains false.
+     *
+     * @param mixed $value
+     *
+     * @return $this
+     */
+    public function treatFalseLike($value)
+    {
+        $this->falseEquivalent = $value;
+
+        return $this;
+    }
+
+    /**
+     * Sets null as the default value.
+     *
+     * @return $this
+     */
+    public function defaultNull()
+    {
+        return $this->defaultValue(null);
+    }
+
+    /**
+     * Sets true as the default value.
+     *
+     * @return $this
+     */
+    public function defaultTrue()
+    {
+        return $this->defaultValue(true);
+    }
+
+    /**
+     * Sets false as the default value.
+     *
+     * @return $this
+     */
+    public function defaultFalse()
+    {
+        return $this->defaultValue(false);
+    }
+
+    /**
+     * Sets an expression to run before the normalization.
+     *
+     * @return ExprBuilder
+     */
+    public function beforeNormalization()
+    {
+        return $this->normalization()->before();
+    }
+
+    /**
+     * Denies the node value being empty.
+     *
+     * @return $this
+     */
+    public function cannotBeEmpty()
+    {
+        $this->allowEmptyValue = false;
+
+        return $this;
+    }
+
+    /**
+     * Sets an expression to run for the validation.
+     *
+     * The expression receives the value of the node and must return it. It can
+     * modify it.
+     * An exception should be thrown when the node is not valid.
+     *
+     * @return ExprBuilder
+     */
+    public function validate()
+    {
+        return $this->validation()->rule();
+    }
+
+    /**
+     * Sets whether the node can be overwritten.
+     *
+     * @param bool $deny Whether the overwriting is forbidden or not
+     *
+     * @return $this
+     */
+    public function cannotBeOverwritten($deny = true)
+    {
+        $this->merge()->denyOverwrite($deny);
+
+        return $this;
+    }
+
+    /**
+     * Gets the builder for validation rules.
+     *
+     * @return ValidationBuilder
+     */
+    protected function validation()
+    {
+        if (null === $this->validation) {
+            $this->validation = new ValidationBuilder($this);
+        }
+
+        return $this->validation;
+    }
+
+    /**
+     * Gets the builder for merging rules.
+     *
+     * @return MergeBuilder
+     */
+    protected function merge()
+    {
+        if (null === $this->merge) {
+            $this->merge = new MergeBuilder($this);
+        }
+
+        return $this->merge;
+    }
+
+    /**
+     * Gets the builder for normalization rules.
+     *
+     * @return NormalizationBuilder
+     */
+    protected function normalization()
+    {
+        if (null === $this->normalization) {
+            $this->normalization = new NormalizationBuilder($this);
+        }
+
+        return $this->normalization;
+    }
+
+    /**
+     * Instantiate and configure the node according to this definition.
+     *
+     * @return NodeInterface $node The node instance
+     *
+     * @throws InvalidDefinitionException When the definition is invalid
+     */
+    abstract protected function createNode();
+}

msd2/phpBB3/vendor/symfony/config/Definition/Builder/NodeParentInterface.php

@@ -0,0 +1,21 @@
+<?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\Config\Definition\Builder;
+
+/**
+ * An interface that must be implemented by all node parents.
+ *
+ * @author Victor Berchet <victor@suumit.com>
+ */
+interface NodeParentInterface
+{
+}

msd2/phpBB3/vendor/symfony/config/Definition/Builder/NormalizationBuilder.php

@@ -0,0 +1,60 @@
+<?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\Config\Definition\Builder;
+
+/**
+ * This class builds normalization conditions.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class NormalizationBuilder
+{
+    protected $node;
+    public $before = array();
+    public $remappings = array();
+
+    public function __construct(NodeDefinition $node)
+    {
+        $this->node = $node;
+    }
+
+    /**
+     * Registers a key to remap to its plural form.
+     *
+     * @param string $key    The key to remap
+     * @param string $plural The plural of the key in case of irregular plural
+     *
+     * @return $this
+     */
+    public function remap($key, $plural = null)
+    {
+        $this->remappings[] = array($key, null === $plural ? $key.'s' : $plural);
+
+        return $this;
+    }
+
+    /**
+     * Registers a closure to run before the normalization or an expression builder to build it if null is provided.
+     *
+     * @return ExprBuilder|$this
+     */
+    public function before(\Closure $closure = null)
+    {
+        if (null !== $closure) {
+            $this->before[] = $closure;
+
+            return $this;
+        }
+
+        return $this->before[] = new ExprBuilder($this->node);
+    }
+}

msd2/phpBB3/vendor/symfony/config/Definition/Builder/NumericNodeDefinition.php

@@ -0,0 +1,73 @@
+<?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\Config\Definition\Builder;
+
+/**
+ * Abstract class that contains common code of integer and float node definitions.
+ *
+ * @author David Jeanmonod <david.jeanmonod@gmail.com>
+ */
+abstract class NumericNodeDefinition extends ScalarNodeDefinition
+{
+    protected $min;
+    protected $max;
+
+    /**
+     * Ensures that the value is smaller than the given reference.
+     *
+     * @param mixed $max
+     *
+     * @return $this
+     *
+     * @throws \InvalidArgumentException when the constraint is inconsistent
+     */
+    public function max($max)
+    {
+        if (isset($this->min) && $this->min > $max) {
+            throw new \InvalidArgumentException(sprintf('You cannot define a max(%s) as you already have a min(%s)', $max, $this->min));
+        }
+        $this->max = $max;
+
+        return $this;
+    }
+
+    /**
+     * Ensures that the value is bigger than the given reference.
+     *
+     * @param mixed $min
+     *
+     * @return $this
+     *
+     * @throws \InvalidArgumentException when the constraint is inconsistent
+     */
+    public function min($min)
+    {
+        if (isset($this->max) && $this->max < $min) {
+            throw new \InvalidArgumentException(sprintf('You cannot define a min(%s) as you already have a max(%s)', $min, $this->max));
+        }
+        $this->min = $min;
+
+        return $this;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @deprecated Deprecated since version 2.8, to be removed in 3.0.
+     */
+    public function cannotBeEmpty()
+    {
+        @trigger_error('The '.__METHOD__.' method is deprecated since Symfony 2.8 and will be removed in 3.0.', E_USER_DEPRECATED);
+
+        return parent::cannotBeEmpty();
+    }
+}

msd2/phpBB3/vendor/symfony/config/Definition/Builder/ParentNodeDefinitionInterface.php

@@ -0,0 +1,49 @@
+<?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\Config\Definition\Builder;
+
+/**
+ * An interface that must be implemented by nodes which can have children.
+ *
+ * @author Victor Berchet <victor@suumit.com>
+ */
+interface ParentNodeDefinitionInterface
+{
+    /**
+     * Returns a builder to add children nodes.
+     *
+     * @return NodeBuilder
+     */
+    public function children();
+
+    /**
+     * Appends a node definition.
+     *
+     * Usage:
+     *
+     *     $node = $parentNode
+     *         ->children()
+     *             ->scalarNode('foo')->end()
+     *             ->scalarNode('baz')->end()
+     *             ->append($this->getBarNodeDefinition())
+     *         ->end()
+     *     ;
+     *
+     * @return $this
+     */
+    public function append(NodeDefinition $node);
+
+    /**
+     * Sets a custom children builder.
+     */
+    public function setBuilder(NodeBuilder $builder);
+}

msd2/phpBB3/vendor/symfony/config/Definition/Builder/ScalarNodeDefinition.php

@@ -0,0 +1,32 @@
+<?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\Config\Definition\Builder;
+
+use Symfony\Component\Config\Definition\ScalarNode;
+
+/**
+ * This class provides a fluent interface for defining a node.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class ScalarNodeDefinition extends VariableNodeDefinition
+{
+    /**
+     * Instantiate a Node.
+     *
+     * @return ScalarNode The node
+     */
+    protected function instantiateNode()
+    {
+        return new ScalarNode($this->name, $this->parent);
+    }
+}

msd2/phpBB3/vendor/symfony/config/Definition/Builder/TreeBuilder.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\Config\Definition\Builder;
+
+use Symfony\Component\Config\Definition\NodeInterface;
+
+/**
+ * This is the entry class for building a config tree.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class TreeBuilder implements NodeParentInterface
+{
+    protected $tree;
+    protected $root;
+    protected $builder;
+
+    /**
+     * Creates the root node.
+     *
+     * @param string      $name    The name of the root node
+     * @param string      $type    The type of the root node
+     * @param NodeBuilder $builder A custom node builder instance
+     *
+     * @return ArrayNodeDefinition|NodeDefinition The root node (as an ArrayNodeDefinition when the type is 'array')
+     *
+     * @throws \RuntimeException When the node type is not supported
+     */
+    public function root($name, $type = 'array', NodeBuilder $builder = null)
+    {
+        $builder = $builder ?: new NodeBuilder();
+
+        return $this->root = $builder->node($name, $type)->setParent($this);
+    }
+
+    /**
+     * Builds the tree.
+     *
+     * @return NodeInterface
+     *
+     * @throws \RuntimeException
+     */
+    public function buildTree()
+    {
+        if (null === $this->root) {
+            throw new \RuntimeException('The configuration tree has no root node.');
+        }
+        if (null !== $this->tree) {
+            return $this->tree;
+        }
+
+        return $this->tree = $this->root->getNode(true);
+    }
+}

msd2/phpBB3/vendor/symfony/config/Definition/Builder/ValidationBuilder.php

@@ -0,0 +1,44 @@
+<?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\Config\Definition\Builder;
+
+/**
+ * This class builds validation conditions.
+ *
+ * @author Christophe Coevoet <stof@notk.org>
+ */
+class ValidationBuilder
+{
+    protected $node;
+    public $rules = array();
+
+    public function __construct(NodeDefinition $node)
+    {
+        $this->node = $node;
+    }
+
+    /**
+     * Registers a closure to run as normalization or an expression builder to build it if null is provided.
+     *
+     * @return ExprBuilder|$this
+     */
+    public function rule(\Closure $closure = null)
+    {
+        if (null !== $closure) {
+            $this->rules[] = $closure;
+
+            return $this;
+        }
+
+        return $this->rules[] = new ExprBuilder($this->node);
+    }
+}

msd2/phpBB3/vendor/symfony/config/Definition/Builder/VariableNodeDefinition.php

@@ -0,0 +1,64 @@
+<?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\Config\Definition\Builder;
+
+use Symfony\Component\Config\Definition\VariableNode;
+
+/**
+ * This class provides a fluent interface for defining a node.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class VariableNodeDefinition extends NodeDefinition
+{
+    /**
+     * Instantiate a Node.
+     *
+     * @return VariableNode The node
+     */
+    protected function instantiateNode()
+    {
+        return new VariableNode($this->name, $this->parent);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function createNode()
+    {
+        $node = $this->instantiateNode();
+
+        if (null !== $this->normalization) {
+            $node->setNormalizationClosures($this->normalization->before);
+        }
+
+        if (null !== $this->merge) {
+            $node->setAllowOverwrite($this->merge->allowOverwrite);
+        }
+
+        if (true === $this->default) {
+            $node->setDefaultValue($this->defaultValue);
+        }
+
+        $node->setAllowEmptyValue($this->allowEmptyValue);
+        $node->addEquivalentValue(null, $this->nullEquivalent);
+        $node->addEquivalentValue(true, $this->trueEquivalent);
+        $node->addEquivalentValue(false, $this->falseEquivalent);
+        $node->setRequired($this->required);
+
+        if (null !== $this->validation) {
+            $node->setFinalValidationClosures($this->validation->rules);
+        }
+
+        return $node;
+    }
+}

msd2/phpBB3/vendor/symfony/config/Definition/ConfigurationInterface.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\Config\Definition;
+
+/**
+ * Configuration interface.
+ *
+ * @author Victor Berchet <victor@suumit.com>
+ */
+interface ConfigurationInterface
+{
+    /**
+     * Generates the configuration tree builder.
+     *
+     * @return \Symfony\Component\Config\Definition\Builder\TreeBuilder The tree builder
+     */
+    public function getConfigTreeBuilder();
+}

msd2/phpBB3/vendor/symfony/config/Definition/Dumper/XmlReferenceDumper.php

@@ -0,0 +1,304 @@
+<?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\Config\Definition\Dumper;
+
+use Symfony\Component\Config\Definition\ArrayNode;
+use Symfony\Component\Config\Definition\ConfigurationInterface;
+use Symfony\Component\Config\Definition\EnumNode;
+use Symfony\Component\Config\Definition\NodeInterface;
+use Symfony\Component\Config\Definition\PrototypedArrayNode;
+
+/**
+ * Dumps a XML reference configuration for the given configuration/node instance.
+ *
+ * @author Wouter J <waldio.webdesign@gmail.com>
+ */
+class XmlReferenceDumper
+{
+    private $reference;
+
+    public function dump(ConfigurationInterface $configuration, $namespace = null)
+    {
+        return $this->dumpNode($configuration->getConfigTreeBuilder()->buildTree(), $namespace);
+    }
+
+    public function dumpNode(NodeInterface $node, $namespace = null)
+    {
+        $this->reference = '';
+        $this->writeNode($node, 0, true, $namespace);
+        $ref = $this->reference;
+        $this->reference = null;
+
+        return $ref;
+    }
+
+    /**
+     * @param NodeInterface $node
+     * @param int           $depth
+     * @param bool          $root      If the node is the root node
+     * @param string        $namespace The namespace of the node
+     */
+    private function writeNode(NodeInterface $node, $depth = 0, $root = false, $namespace = null)
+    {
+        $rootName = ($root ? 'config' : $node->getName());
+        $rootNamespace = ($namespace ?: ($root ? 'http://example.org/schema/dic/'.$node->getName() : null));
+
+        // xml remapping
+        if ($node->getParent()) {
+            $remapping = array_filter($node->getParent()->getXmlRemappings(), function ($mapping) use ($rootName) {
+                return $rootName === $mapping[1];
+            });
+
+            if (\count($remapping)) {
+                list($singular) = current($remapping);
+                $rootName = $singular;
+            }
+        }
+        $rootName = str_replace('_', '-', $rootName);
+
+        $rootAttributes = array();
+        $rootAttributeComments = array();
+        $rootChildren = array();
+        $rootComments = array();
+
+        if ($node instanceof ArrayNode) {
+            $children = $node->getChildren();
+
+            // comments about the root node
+            if ($rootInfo = $node->getInfo()) {
+                $rootComments[] = $rootInfo;
+            }
+
+            if ($rootNamespace) {
+                $rootComments[] = 'Namespace: '.$rootNamespace;
+            }
+
+            // render prototyped nodes
+            if ($node instanceof PrototypedArrayNode) {
+                $prototype = $node->getPrototype();
+
+                $info = 'prototype';
+                if (null !== $prototype->getInfo()) {
+                    $info .= ': '.$prototype->getInfo();
+                }
+                array_unshift($rootComments, $info);
+
+                if ($key = $node->getKeyAttribute()) {
+                    $rootAttributes[$key] = str_replace('-', ' ', $rootName).' '.$key;
+                }
+
+                if ($prototype instanceof ArrayNode) {
+                    $children = $prototype->getChildren();
+                } else {
+                    if ($prototype->hasDefaultValue()) {
+                        $prototypeValue = $prototype->getDefaultValue();
+                    } else {
+                        switch (\get_class($prototype)) {
+                            case 'Symfony\Component\Config\Definition\ScalarNode':
+                                $prototypeValue = 'scalar value';
+                                break;
+
+                            case 'Symfony\Component\Config\Definition\FloatNode':
+                            case 'Symfony\Component\Config\Definition\IntegerNode':
+                                $prototypeValue = 'numeric value';
+                                break;
+
+                            case 'Symfony\Component\Config\Definition\BooleanNode':
+                                $prototypeValue = 'true|false';
+                                break;
+
+                            case 'Symfony\Component\Config\Definition\EnumNode':
+                                $prototypeValue = implode('|', array_map('json_encode', $prototype->getValues()));
+                                break;
+
+                            default:
+                                $prototypeValue = 'value';
+                        }
+                    }
+                }
+            }
+
+            // get attributes and elements
+            foreach ($children as $child) {
+                if (!$child instanceof ArrayNode) {
+                    // get attributes
+
+                    // metadata
+                    $name = str_replace('_', '-', $child->getName());
+                    $value = '%%%%not_defined%%%%'; // use a string which isn't used in the normal world
+
+                    // comments
+                    $comments = array();
+                    if ($info = $child->getInfo()) {
+                        $comments[] = $info;
+                    }
+
+                    if ($example = $child->getExample()) {
+                        $comments[] = 'Example: '.$example;
+                    }
+
+                    if ($child->isRequired()) {
+                        $comments[] = 'Required';
+                    }
+
+                    if ($child instanceof EnumNode) {
+                        $comments[] = 'One of '.implode('; ', array_map('json_encode', $child->getValues()));
+                    }
+
+                    if (\count($comments)) {
+                        $rootAttributeComments[$name] = implode(";\n", $comments);
+                    }
+
+                    // default values
+                    if ($child->hasDefaultValue()) {
+                        $value = $child->getDefaultValue();
+                    }
+
+                    // append attribute
+                    $rootAttributes[$name] = $value;
+                } else {
+                    // get elements
+                    $rootChildren[] = $child;
+                }
+            }
+        }
+
+        // render comments
+
+        // root node comment
+        if (\count($rootComments)) {
+            foreach ($rootComments as $comment) {
+                $this->writeLine('<!-- '.$comment.' -->', $depth);
+            }
+        }
+
+        // attribute comments
+        if (\count($rootAttributeComments)) {
+            foreach ($rootAttributeComments as $attrName => $comment) {
+                $commentDepth = $depth + 4 + \strlen($attrName) + 2;
+                $commentLines = explode("\n", $comment);
+                $multiline = (\count($commentLines) > 1);
+                $comment = implode(PHP_EOL.str_repeat(' ', $commentDepth), $commentLines);
+
+                if ($multiline) {
+                    $this->writeLine('<!--', $depth);
+                    $this->writeLine($attrName.': '.$comment, $depth + 4);
+                    $this->writeLine('-->', $depth);
+                } else {
+                    $this->writeLine('<!-- '.$attrName.': '.$comment.' -->', $depth);
+                }
+            }
+        }
+
+        // render start tag + attributes
+        $rootIsVariablePrototype = isset($prototypeValue);
+        $rootIsEmptyTag = (0 === \count($rootChildren) && !$rootIsVariablePrototype);
+        $rootOpenTag = '<'.$rootName;
+        if (1 >= ($attributesCount = \count($rootAttributes))) {
+            if (1 === $attributesCount) {
+                $rootOpenTag .= sprintf(' %s="%s"', current(array_keys($rootAttributes)), $this->writeValue(current($rootAttributes)));
+            }
+
+            $rootOpenTag .= $rootIsEmptyTag ? ' />' : '>';
+
+            if ($rootIsVariablePrototype) {
+                $rootOpenTag .= $prototypeValue.'</'.$rootName.'>';
+            }
+
+            $this->writeLine($rootOpenTag, $depth);
+        } else {
+            $this->writeLine($rootOpenTag, $depth);
+
+            $i = 1;
+
+            foreach ($rootAttributes as $attrName => $attrValue) {
+                $attr = sprintf('%s="%s"', $attrName, $this->writeValue($attrValue));
+
+                $this->writeLine($attr, $depth + 4);
+
+                if ($attributesCount === $i++) {
+                    $this->writeLine($rootIsEmptyTag ? '/>' : '>', $depth);
+
+                    if ($rootIsVariablePrototype) {
+                        $rootOpenTag .= $prototypeValue.'</'.$rootName.'>';
+                    }
+                }
+            }
+        }
+
+        // render children tags
+        foreach ($rootChildren as $child) {
+            $this->writeLine('');
+            $this->writeNode($child, $depth + 4);
+        }
+
+        // render end tag
+        if (!$rootIsEmptyTag && !$rootIsVariablePrototype) {
+            $this->writeLine('');
+
+            $rootEndTag = '</'.$rootName.'>';
+            $this->writeLine($rootEndTag, $depth);
+        }
+    }
+
+    /**
+     * Outputs a single config reference line.
+     *
+     * @param string $text
+     * @param int    $indent
+     */
+    private function writeLine($text, $indent = 0)
+    {
+        $indent = \strlen($text) + $indent;
+        $format = '%'.$indent.'s';
+
+        $this->reference .= sprintf($format, $text).PHP_EOL;
+    }
+
+    /**
+     * Renders the string conversion of the value.
+     *
+     * @param mixed $value
+     *
+     * @return string
+     */
+    private function writeValue($value)
+    {
+        if ('%%%%not_defined%%%%' === $value) {
+            return '';
+        }
+
+        if (\is_string($value) || is_numeric($value)) {
+            return $value;
+        }
+
+        if (false === $value) {
+            return 'false';
+        }
+
+        if (true === $value) {
+            return 'true';
+        }
+
+        if (null === $value) {
+            return 'null';
+        }
+
+        if (empty($value)) {
+            return '';
+        }
+
+        if (\is_array($value)) {
+            return implode(',', $value);
+        }
+    }
+}

msd2/phpBB3/vendor/symfony/config/Definition/Dumper/YamlReferenceDumper.php

@@ -0,0 +1,203 @@
+<?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\Config\Definition\Dumper;
+
+use Symfony\Component\Config\Definition\ArrayNode;
+use Symfony\Component\Config\Definition\ConfigurationInterface;
+use Symfony\Component\Config\Definition\EnumNode;
+use Symfony\Component\Config\Definition\NodeInterface;
+use Symfony\Component\Config\Definition\PrototypedArrayNode;
+use Symfony\Component\Yaml\Inline;
+
+/**
+ * Dumps a Yaml reference configuration for the given configuration/node instance.
+ *
+ * @author Kevin Bond <kevinbond@gmail.com>
+ */
+class YamlReferenceDumper
+{
+    private $reference;
+
+    public function dump(ConfigurationInterface $configuration)
+    {
+        return $this->dumpNode($configuration->getConfigTreeBuilder()->buildTree());
+    }
+
+    public function dumpNode(NodeInterface $node)
+    {
+        $this->reference = '';
+        $this->writeNode($node);
+        $ref = $this->reference;
+        $this->reference = null;
+
+        return $ref;
+    }
+
+    /**
+     * @param NodeInterface $node
+     * @param int           $depth
+     */
+    private function writeNode(NodeInterface $node, $depth = 0)
+    {
+        $comments = array();
+        $default = '';
+        $defaultArray = null;
+        $children = null;
+        $example = $node->getExample();
+
+        // defaults
+        if ($node instanceof ArrayNode) {
+            $children = $node->getChildren();
+
+            if ($node instanceof PrototypedArrayNode) {
+                $prototype = $node->getPrototype();
+
+                if ($prototype instanceof ArrayNode) {
+                    $children = $prototype->getChildren();
+                }
+
+                // check for attribute as key
+                if ($key = $node->getKeyAttribute()) {
+                    $keyNodeClass = 'Symfony\Component\Config\Definition\\'.($prototype instanceof ArrayNode ? 'ArrayNode' : 'ScalarNode');
+                    $keyNode = new $keyNodeClass($key, $node);
+
+                    $info = 'Prototype';
+                    if (null !== $prototype->getInfo()) {
+                        $info .= ': '.$prototype->getInfo();
+                    }
+                    $keyNode->setInfo($info);
+
+                    // add children
+                    foreach ($children as $childNode) {
+                        $keyNode->addChild($childNode);
+                    }
+                    $children = array($key => $keyNode);
+                }
+            }
+
+            if (!$children) {
+                if ($node->hasDefaultValue() && \count($defaultArray = $node->getDefaultValue())) {
+                    $default = '';
+                } elseif (!\is_array($example)) {
+                    $default = '[]';
+                }
+            }
+        } elseif ($node instanceof EnumNode) {
+            $comments[] = 'One of '.implode('; ', array_map('json_encode', $node->getValues()));
+            $default = $node->hasDefaultValue() ? Inline::dump($node->getDefaultValue()) : '~';
+        } else {
+            $default = '~';
+
+            if ($node->hasDefaultValue()) {
+                $default = $node->getDefaultValue();
+
+                if (\is_array($default)) {
+                    if (\count($defaultArray = $node->getDefaultValue())) {
+                        $default = '';
+                    } elseif (!\is_array($example)) {
+                        $default = '[]';
+                    }
+                } else {
+                    $default = Inline::dump($default);
+                }
+            }
+        }
+
+        // required?
+        if ($node->isRequired()) {
+            $comments[] = 'Required';
+        }
+
+        // example
+        if ($example && !\is_array($example)) {
+            $comments[] = 'Example: '.$example;
+        }
+
+        $default = '' != (string) $default ? ' '.$default : '';
+        $comments = \count($comments) ? '# '.implode(', ', $comments) : '';
+
+        $text = rtrim(sprintf('%-21s%s %s', $node->getName().':', $default, $comments), ' ');
+
+        if ($info = $node->getInfo()) {
+            $this->writeLine('');
+            // indenting multi-line info
+            $info = str_replace("\n", sprintf("\n%".($depth * 4).'s# ', ' '), $info);
+            $this->writeLine('# '.$info, $depth * 4);
+        }
+
+        $this->writeLine($text, $depth * 4);
+
+        // output defaults
+        if ($defaultArray) {
+            $this->writeLine('');
+
+            $message = \count($defaultArray) > 1 ? 'Defaults' : 'Default';
+
+            $this->writeLine('# '.$message.':', $depth * 4 + 4);
+
+            $this->writeArray($defaultArray, $depth + 1);
+        }
+
+        if (\is_array($example)) {
+            $this->writeLine('');
+
+            $message = \count($example) > 1 ? 'Examples' : 'Example';
+
+            $this->writeLine('# '.$message.':', $depth * 4 + 4);
+
+            $this->writeArray($example, $depth + 1);
+        }
+
+        if ($children) {
+            foreach ($children as $childNode) {
+                $this->writeNode($childNode, $depth + 1);
+            }
+        }
+    }
+
+    /**
+     * Outputs a single config reference line.
+     *
+     * @param string $text
+     * @param int    $indent
+     */
+    private function writeLine($text, $indent = 0)
+    {
+        $indent = \strlen($text) + $indent;
+        $format = '%'.$indent.'s';
+
+        $this->reference .= sprintf($format, $text)."\n";
+    }
+
+    private function writeArray(array $array, $depth)
+    {
+        $isIndexed = array_values($array) === $array;
+
+        foreach ($array as $key => $value) {
+            if (\is_array($value)) {
+                $val = '';
+            } else {
+                $val = $value;
+            }
+
+            if ($isIndexed) {
+                $this->writeLine('- '.$val, $depth * 4);
+            } else {
+                $this->writeLine(sprintf('%-20s %s', $key.':', $val), $depth * 4);
+            }
+
+            if (\is_array($value)) {
+                $this->writeArray($value, $depth + 1);
+            }
+        }
+    }
+}

msd2/phpBB3/vendor/symfony/config/Definition/EnumNode.php

@@ -0,0 +1,54 @@
+<?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\Config\Definition;
+
+use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
+
+/**
+ * Node which only allows a finite set of values.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class EnumNode extends ScalarNode
+{
+    private $values;
+
+    public function __construct($name, NodeInterface $parent = null, array $values = array())
+    {
+        $values = array_unique($values);
+        if (empty($values)) {
+            throw new \InvalidArgumentException('$values must contain at least one element.');
+        }
+
+        parent::__construct($name, $parent);
+        $this->values = $values;
+    }
+
+    public function getValues()
+    {
+        return $this->values;
+    }
+
+    protected function finalizeValue($value)
+    {
+        $value = parent::finalizeValue($value);
+
+        if (!\in_array($value, $this->values, true)) {
+            $ex = new InvalidConfigurationException(sprintf('The value %s is not allowed for path "%s". Permissible values: %s', json_encode($value), $this->getPath(), implode(', ', array_map('json_encode', $this->values))));
+            $ex->setPath($this->getPath());
+
+            throw $ex;
+        }
+
+        return $value;
+    }
+}

msd2/phpBB3/vendor/symfony/config/Definition/Exception/DuplicateKeyException.php

@@ -0,0 +1,22 @@
+<?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\Config\Definition\Exception;
+
+/**
+ * This exception is thrown whenever the key of an array is not unique. This can
+ * only be the case if the configuration is coming from an XML file.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class DuplicateKeyException extends InvalidConfigurationException
+{
+}

msd2/phpBB3/vendor/symfony/config/Definition/Exception/Exception.php

@@ -0,0 +1,21 @@
+<?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\Config\Definition\Exception;
+
+/**
+ * Base exception for all configuration exceptions.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class Exception extends \RuntimeException
+{
+}

msd2/phpBB3/vendor/symfony/config/Definition/Exception/ForbiddenOverwriteException.php

@@ -0,0 +1,22 @@
+<?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\Config\Definition\Exception;
+
+/**
+ * This exception is thrown when a configuration path is overwritten from a
+ * subsequent configuration file, but the entry node specifically forbids this.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class ForbiddenOverwriteException extends InvalidConfigurationException
+{
+}

msd2/phpBB3/vendor/symfony/config/Definition/Exception/InvalidConfigurationException.php

@@ -0,0 +1,49 @@
+<?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\Config\Definition\Exception;
+
+/**
+ * A very general exception which can be thrown whenever non of the more specific
+ * exceptions is suitable.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class InvalidConfigurationException extends Exception
+{
+    private $path;
+    private $containsHints = false;
+
+    public function setPath($path)
+    {
+        $this->path = $path;
+    }
+
+    public function getPath()
+    {
+        return $this->path;
+    }
+
+    /**
+     * Adds extra information that is suffixed to the original exception message.
+     *
+     * @param string $hint
+     */
+    public function addHint($hint)
+    {
+        if (!$this->containsHints) {
+            $this->message .= "\nHint: ".$hint;
+            $this->containsHints = true;
+        } else {
+            $this->message .= ', '.$hint;
+        }
+    }
+}

msd2/phpBB3/vendor/symfony/config/Definition/Exception/InvalidDefinitionException.php

@@ -0,0 +1,21 @@
+<?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\Config\Definition\Exception;
+
+/**
+ * Thrown when an error is detected in a node Definition.
+ *
+ * @author Victor Berchet <victor.berchet@suumit.com>
+ */
+class InvalidDefinitionException extends Exception
+{
+}

msd2/phpBB3/vendor/symfony/config/Definition/Exception/InvalidTypeException.php

@@ -0,0 +1,21 @@
+<?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\Config\Definition\Exception;
+
+/**
+ * This exception is thrown if an invalid type is encountered.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class InvalidTypeException extends InvalidConfigurationException
+{
+}

msd2/phpBB3/vendor/symfony/config/Definition/Exception/UnsetKeyException.php

@@ -0,0 +1,22 @@
+<?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\Config\Definition\Exception;
+
+/**
+ * This exception is usually not encountered by the end-user, but only used
+ * internally to signal the parent scope to unset a key.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class UnsetKeyException extends Exception
+{
+}

msd2/phpBB3/vendor/symfony/config/Definition/FloatNode.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\Config\Definition;
+
+use Symfony\Component\Config\Definition\Exception\InvalidTypeException;
+
+/**
+ * This node represents a float value in the config tree.
+ *
+ * @author Jeanmonod David <david.jeanmonod@gmail.com>
+ */
+class FloatNode extends NumericNode
+{
+    /**
+     * {@inheritdoc}
+     */
+    protected function validateType($value)
+    {
+        // Integers are also accepted, we just cast them
+        if (\is_int($value)) {
+            $value = (float) $value;
+        }
+
+        if (!\is_float($value)) {
+            $ex = new InvalidTypeException(sprintf('Invalid type for path "%s". Expected float, but got %s.', $this->getPath(), \gettype($value)));
+            if ($hint = $this->getInfo()) {
+                $ex->addHint($hint);
+            }
+            $ex->setPath($this->getPath());
+
+            throw $ex;
+        }
+    }
+}

msd2/phpBB3/vendor/symfony/config/Definition/IntegerNode.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\Config\Definition;
+
+use Symfony\Component\Config\Definition\Exception\InvalidTypeException;
+
+/**
+ * This node represents an integer value in the config tree.
+ *
+ * @author Jeanmonod David <david.jeanmonod@gmail.com>
+ */
+class IntegerNode extends NumericNode
+{
+    /**
+     * {@inheritdoc}
+     */
+    protected function validateType($value)
+    {
+        if (!\is_int($value)) {
+            $ex = new InvalidTypeException(sprintf('Invalid type for path "%s". Expected int, but got %s.', $this->getPath(), \gettype($value)));
+            if ($hint = $this->getInfo()) {
+                $ex->addHint($hint);
+            }
+            $ex->setPath($this->getPath());
+
+            throw $ex;
+        }
+    }
+}

msd2/phpBB3/vendor/symfony/config/Definition/NodeInterface.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\Config\Definition;
+
+use Symfony\Component\Config\Definition\Exception\ForbiddenOverwriteException;
+use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
+use Symfony\Component\Config\Definition\Exception\InvalidTypeException;
+
+/**
+ * Common Interface among all nodes.
+ *
+ * In most cases, it is better to inherit from BaseNode instead of implementing
+ * this interface yourself.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+interface NodeInterface
+{
+    /**
+     * Returns the name of the node.
+     *
+     * @return string The name of the node
+     */
+    public function getName();
+
+    /**
+     * Returns the path of the node.
+     *
+     * @return string The node path
+     */
+    public function getPath();
+
+    /**
+     * Returns true when the node is required.
+     *
+     * @return bool If the node is required
+     */
+    public function isRequired();
+
+    /**
+     * Returns true when the node has a default value.
+     *
+     * @return bool If the node has a default value
+     */
+    public function hasDefaultValue();
+
+    /**
+     * Returns the default value of the node.
+     *
+     * @return mixed The default value
+     *
+     * @throws \RuntimeException if the node has no default value
+     */
+    public function getDefaultValue();
+
+    /**
+     * Normalizes a value.
+     *
+     * @param mixed $value The value to normalize
+     *
+     * @return mixed The normalized value
+     *
+     * @throws InvalidTypeException if the value type is invalid
+     */
+    public function normalize($value);
+
+    /**
+     * Merges two values together.
+     *
+     * @param mixed $leftSide
+     * @param mixed $rightSide
+     *
+     * @return mixed The merged value
+     *
+     * @throws ForbiddenOverwriteException if the configuration path cannot be overwritten
+     * @throws InvalidTypeException        if the value type is invalid
+     */
+    public function merge($leftSide, $rightSide);
+
+    /**
+     * Finalizes a value.
+     *
+     * @param mixed $value The value to finalize
+     *
+     * @return mixed The finalized value
+     *
+     * @throws InvalidTypeException          if the value type is invalid
+     * @throws InvalidConfigurationException if the value is invalid configuration
+     */
+    public function finalize($value);
+}

msd2/phpBB3/vendor/symfony/config/Definition/NumericNode.php

@@ -0,0 +1,64 @@
+<?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\Config\Definition;
+
+use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
+
+/**
+ * This node represents a numeric value in the config tree.
+ *
+ * @author David Jeanmonod <david.jeanmonod@gmail.com>
+ */
+class NumericNode extends ScalarNode
+{
+    protected $min;
+    protected $max;
+
+    public function __construct($name, NodeInterface $parent = null, $min = null, $max = null)
+    {
+        parent::__construct($name, $parent);
+        $this->min = $min;
+        $this->max = $max;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function finalizeValue($value)
+    {
+        $value = parent::finalizeValue($value);
+
+        $errorMsg = null;
+        if (isset($this->min) && $value < $this->min) {
+            $errorMsg = sprintf('The value %s is too small for path "%s". Should be greater than or equal to %s', $value, $this->getPath(), $this->min);
+        }
+        if (isset($this->max) && $value > $this->max) {
+            $errorMsg = sprintf('The value %s is too big for path "%s". Should be less than or equal to %s', $value, $this->getPath(), $this->max);
+        }
+        if (isset($errorMsg)) {
+            $ex = new InvalidConfigurationException($errorMsg);
+            $ex->setPath($this->getPath());
+            throw $ex;
+        }
+
+        return $value;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function isValueEmpty($value)
+    {
+        // a numeric value cannot be empty
+        return false;
+    }
+}

msd2/phpBB3/vendor/symfony/config/Definition/Processor.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\Config\Definition;
+
+/**
+ * This class is the entry point for config normalization/merging/finalization.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class Processor
+{
+    /**
+     * Processes an array of configurations.
+     *
+     * @param NodeInterface $configTree The node tree describing the configuration
+     * @param array         $configs    An array of configuration items to process
+     *
+     * @return array The processed configuration
+     */
+    public function process(NodeInterface $configTree, array $configs)
+    {
+        $currentConfig = array();
+        foreach ($configs as $config) {
+            $config = $configTree->normalize($config);
+            $currentConfig = $configTree->merge($currentConfig, $config);
+        }
+
+        return $configTree->finalize($currentConfig);
+    }
+
+    /**
+     * Processes an array of configurations.
+     *
+     * @param ConfigurationInterface $configuration The configuration class
+     * @param array                  $configs       An array of configuration items to process
+     *
+     * @return array The processed configuration
+     */
+    public function processConfiguration(ConfigurationInterface $configuration, array $configs)
+    {
+        return $this->process($configuration->getConfigTreeBuilder()->buildTree(), $configs);
+    }
+
+    /**
+     * Normalizes a configuration entry.
+     *
+     * This method returns a normalize configuration array for a given key
+     * to remove the differences due to the original format (YAML and XML mainly).
+     *
+     * Here is an example.
+     *
+     * The configuration in XML:
+     *
+     * <twig:extension>twig.extension.foo</twig:extension>
+     * <twig:extension>twig.extension.bar</twig:extension>
+     *
+     * And the same configuration in YAML:
+     *
+     * extensions: ['twig.extension.foo', 'twig.extension.bar']
+     *
+     * @param array  $config A config array
+     * @param string $key    The key to normalize
+     * @param string $plural The plural form of the key if it is irregular
+     *
+     * @return array
+     */
+    public static function normalizeConfig($config, $key, $plural = null)
+    {
+        if (null === $plural) {
+            $plural = $key.'s';
+        }
+
+        if (isset($config[$plural])) {
+            return $config[$plural];
+        }
+
+        if (isset($config[$key])) {
+            if (\is_string($config[$key]) || !\is_int(key($config[$key]))) {
+                // only one
+                return  array($config[$key]);
+            }
+
+            return  $config[$key];
+        }
+
+        return array();
+    }
+}

msd2/phpBB3/vendor/symfony/config/Definition/PrototypeNodeInterface.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\Config\Definition;
+
+/**
+ * This interface must be implemented by nodes which can be used as prototypes.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+interface PrototypeNodeInterface extends NodeInterface
+{
+    /**
+     * Sets the name of the node.
+     *
+     * @param string $name The name of the node
+     */
+    public function setName($name);
+}

msd2/phpBB3/vendor/symfony/config/Definition/PrototypedArrayNode.php

@@ -0,0 +1,377 @@
+<?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\Config\Definition;
+
+use Symfony\Component\Config\Definition\Exception\DuplicateKeyException;
+use Symfony\Component\Config\Definition\Exception\Exception;
+use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
+use Symfony\Component\Config\Definition\Exception\UnsetKeyException;
+
+/**
+ * Represents a prototyped Array node in the config tree.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class PrototypedArrayNode extends ArrayNode
+{
+    protected $prototype;
+    protected $keyAttribute;
+    protected $removeKeyAttribute = false;
+    protected $minNumberOfElements = 0;
+    protected $defaultValue = array();
+    protected $defaultChildren;
+    /**
+     * @var NodeInterface[] An array of the prototypes of the simplified value children
+     */
+    private $valuePrototypes = array();
+
+    /**
+     * Sets the minimum number of elements that a prototype based node must
+     * contain. By default this is zero, meaning no elements.
+     *
+     * @param int $number
+     */
+    public function setMinNumberOfElements($number)
+    {
+        $this->minNumberOfElements = $number;
+    }
+
+    /**
+     * Sets the attribute which value is to be used as key.
+     *
+     * This is useful when you have an indexed array that should be an
+     * associative array. You can select an item from within the array
+     * to be the key of the particular item. For example, if "id" is the
+     * "key", then:
+     *
+     *     array(
+     *         array('id' => 'my_name', 'foo' => 'bar'),
+     *     );
+     *
+     *  becomes
+     *
+     *      array(
+     *          'my_name' => array('foo' => 'bar'),
+     *      );
+     *
+     * If you'd like "'id' => 'my_name'" to still be present in the resulting
+     * array, then you can set the second argument of this method to false.
+     *
+     * @param string $attribute The name of the attribute which value is to be used as a key
+     * @param bool   $remove    Whether or not to remove the key
+     */
+    public function setKeyAttribute($attribute, $remove = true)
+    {
+        $this->keyAttribute = $attribute;
+        $this->removeKeyAttribute = $remove;
+    }
+
+    /**
+     * Retrieves the name of the attribute which value should be used as key.
+     *
+     * @return string The name of the attribute
+     */
+    public function getKeyAttribute()
+    {
+        return $this->keyAttribute;
+    }
+
+    /**
+     * Sets the default value of this node.
+     *
+     * @param string $value
+     *
+     * @throws \InvalidArgumentException if the default value is not an array
+     */
+    public function setDefaultValue($value)
+    {
+        if (!\is_array($value)) {
+            throw new \InvalidArgumentException($this->getPath().': the default value of an array node has to be an array.');
+        }
+
+        $this->defaultValue = $value;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function hasDefaultValue()
+    {
+        return true;
+    }
+
+    /**
+     * Adds default children when none are set.
+     *
+     * @param int|string|array|null $children The number of children|The child name|The children names to be added
+     */
+    public function setAddChildrenIfNoneSet($children = array('defaults'))
+    {
+        if (null === $children) {
+            $this->defaultChildren = array('defaults');
+        } else {
+            $this->defaultChildren = \is_int($children) && $children > 0 ? range(1, $children) : (array) $children;
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * The default value could be either explicited or derived from the prototype
+     * default value.
+     */
+    public function getDefaultValue()
+    {
+        if (null !== $this->defaultChildren) {
+            $default = $this->prototype->hasDefaultValue() ? $this->prototype->getDefaultValue() : array();
+            $defaults = array();
+            foreach (array_values($this->defaultChildren) as $i => $name) {
+                $defaults[null === $this->keyAttribute ? $i : $name] = $default;
+            }
+
+            return $defaults;
+        }
+
+        return $this->defaultValue;
+    }
+
+    /**
+     * Sets the node prototype.
+     */
+    public function setPrototype(PrototypeNodeInterface $node)
+    {
+        $this->prototype = $node;
+    }
+
+    /**
+     * Retrieves the prototype.
+     *
+     * @return PrototypeNodeInterface The prototype
+     */
+    public function getPrototype()
+    {
+        return $this->prototype;
+    }
+
+    /**
+     * Disable adding concrete children for prototyped nodes.
+     *
+     * @throws Exception
+     */
+    public function addChild(NodeInterface $node)
+    {
+        throw new Exception('A prototyped array node can not have concrete children.');
+    }
+
+    /**
+     * Finalizes the value of this node.
+     *
+     * @param mixed $value
+     *
+     * @return mixed The finalized value
+     *
+     * @throws UnsetKeyException
+     * @throws InvalidConfigurationException if the node doesn't have enough children
+     */
+    protected function finalizeValue($value)
+    {
+        if (false === $value) {
+            throw new UnsetKeyException(sprintf('Unsetting key for path "%s", value: %s', $this->getPath(), json_encode($value)));
+        }
+
+        foreach ($value as $k => $v) {
+            $prototype = $this->getPrototypeForChild($k);
+            try {
+                $value[$k] = $prototype->finalize($v);
+            } catch (UnsetKeyException $e) {
+                unset($value[$k]);
+            }
+        }
+
+        if (\count($value) < $this->minNumberOfElements) {
+            $ex = new InvalidConfigurationException(sprintf('The path "%s" should have at least %d element(s) defined.', $this->getPath(), $this->minNumberOfElements));
+            $ex->setPath($this->getPath());
+
+            throw $ex;
+        }
+
+        return $value;
+    }
+
+    /**
+     * Normalizes the value.
+     *
+     * @param mixed $value The value to normalize
+     *
+     * @return mixed The normalized value
+     *
+     * @throws InvalidConfigurationException
+     * @throws DuplicateKeyException
+     */
+    protected function normalizeValue($value)
+    {
+        if (false === $value) {
+            return $value;
+        }
+
+        $value = $this->remapXml($value);
+
+        $isAssoc = array_keys($value) !== range(0, \count($value) - 1);
+        $normalized = array();
+        foreach ($value as $k => $v) {
+            if (null !== $this->keyAttribute && \is_array($v)) {
+                if (!isset($v[$this->keyAttribute]) && \is_int($k) && !$isAssoc) {
+                    $ex = new InvalidConfigurationException(sprintf('The attribute "%s" must be set for path "%s".', $this->keyAttribute, $this->getPath()));
+                    $ex->setPath($this->getPath());
+
+                    throw $ex;
+                } elseif (isset($v[$this->keyAttribute])) {
+                    $k = $v[$this->keyAttribute];
+
+                    // remove the key attribute when required
+                    if ($this->removeKeyAttribute) {
+                        unset($v[$this->keyAttribute]);
+                    }
+
+                    // if only "value" is left
+                    if (array_keys($v) === array('value')) {
+                        $v = $v['value'];
+                        if ($this->prototype instanceof ArrayNode && ($children = $this->prototype->getChildren()) && array_key_exists('value', $children)) {
+                            $valuePrototype = current($this->valuePrototypes) ?: clone $children['value'];
+                            $valuePrototype->parent = $this;
+                            $originalClosures = $this->prototype->normalizationClosures;
+                            if (\is_array($originalClosures)) {
+                                $valuePrototypeClosures = $valuePrototype->normalizationClosures;
+                                $valuePrototype->normalizationClosures = \is_array($valuePrototypeClosures) ? array_merge($originalClosures, $valuePrototypeClosures) : $originalClosures;
+                            }
+                            $this->valuePrototypes[$k] = $valuePrototype;
+                        }
+                    }
+                }
+
+                if (array_key_exists($k, $normalized)) {
+                    $ex = new DuplicateKeyException(sprintf('Duplicate key "%s" for path "%s".', $k, $this->getPath()));
+                    $ex->setPath($this->getPath());
+
+                    throw $ex;
+                }
+            }
+
+            $prototype = $this->getPrototypeForChild($k);
+            if (null !== $this->keyAttribute || $isAssoc) {
+                $normalized[$k] = $prototype->normalize($v);
+            } else {
+                $normalized[] = $prototype->normalize($v);
+            }
+        }
+
+        return $normalized;
+    }
+
+    /**
+     * Merges values together.
+     *
+     * @param mixed $leftSide  The left side to merge
+     * @param mixed $rightSide The right side to merge
+     *
+     * @return mixed The merged values
+     *
+     * @throws InvalidConfigurationException
+     * @throws \RuntimeException
+     */
+    protected function mergeValues($leftSide, $rightSide)
+    {
+        if (false === $rightSide) {
+            // if this is still false after the last config has been merged the
+            // finalization pass will take care of removing this key entirely
+            return false;
+        }
+
+        if (false === $leftSide || !$this->performDeepMerging) {
+            return $rightSide;
+        }
+
+        foreach ($rightSide as $k => $v) {
+            // prototype, and key is irrelevant, so simply append the element
+            if (null === $this->keyAttribute) {
+                $leftSide[] = $v;
+                continue;
+            }
+
+            // no conflict
+            if (!array_key_exists($k, $leftSide)) {
+                if (!$this->allowNewKeys) {
+                    $ex = new InvalidConfigurationException(sprintf('You are not allowed to define new elements for path "%s". Please define all elements for this path in one config file.', $this->getPath()));
+                    $ex->setPath($this->getPath());
+
+                    throw $ex;
+                }
+
+                $leftSide[$k] = $v;
+                continue;
+            }
+
+            $prototype = $this->getPrototypeForChild($k);
+            $leftSide[$k] = $prototype->merge($leftSide[$k], $v);
+        }
+
+        return $leftSide;
+    }
+
+    /**
+     * Returns a prototype for the child node that is associated to $key in the value array.
+     * For general child nodes, this will be $this->prototype.
+     * But if $this->removeKeyAttribute is true and there are only two keys in the child node:
+     * one is same as this->keyAttribute and the other is 'value', then the prototype will be different.
+     *
+     * For example, assume $this->keyAttribute is 'name' and the value array is as follows:
+     *
+     *     array(
+     *         array(
+     *             'name' => 'name001',
+     *             'value' => 'value001'
+     *         )
+     *     )
+     *
+     * Now, the key is 0 and the child node is:
+     *
+     *     array(
+     *        'name' => 'name001',
+     *        'value' => 'value001'
+     *     )
+     *
+     * When normalizing the value array, the 'name' element will removed from the child node
+     * and its value becomes the new key of the child node:
+     *
+     *     array(
+     *         'name001' => array('value' => 'value001')
+     *     )
+     *
+     * Now only 'value' element is left in the child node which can be further simplified into a string:
+     *
+     *     array('name001' => 'value001')
+     *
+     * Now, the key becomes 'name001' and the child node becomes 'value001' and
+     * the prototype of child node 'name001' should be a ScalarNode instead of an ArrayNode instance.
+     *
+     * @param string $key The key of the child node
+     *
+     * @return mixed The prototype instance
+     */
+    private function getPrototypeForChild($key)
+    {
+        $prototype = isset($this->valuePrototypes[$key]) ? $this->valuePrototypes[$key] : $this->prototype;
+        $prototype->setName($key);
+
+        return $prototype;
+    }
+}

msd2/phpBB3/vendor/symfony/config/Definition/ReferenceDumper.php

@@ -0,0 +1,24 @@
+<?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\Config\Definition;
+
+@trigger_error('The '.__NAMESPACE__.'\ReferenceDumper class is deprecated since Symfony 2.4 and will be removed in 3.0. Use the Symfony\Component\Config\Definition\Dumper\YamlReferenceDumper class instead.', E_USER_DEPRECATED);
+
+use Symfony\Component\Config\Definition\Dumper\YamlReferenceDumper;
+
+/**
+ * @deprecated since version 2.4, to be removed in 3.0.
+ *             Use {@link \Symfony\Component\Config\Definition\Dumper\YamlReferenceDumper} instead.
+ */
+class ReferenceDumper extends YamlReferenceDumper
+{
+}

msd2/phpBB3/vendor/symfony/config/Definition/ScalarNode.php

@@ -0,0 +1,53 @@
+<?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\Config\Definition;
+
+use Symfony\Component\Config\Definition\Exception\InvalidTypeException;
+
+/**
+ * This node represents a scalar value in the config tree.
+ *
+ * The following values are considered scalars:
+ *   * booleans
+ *   * strings
+ *   * null
+ *   * integers
+ *   * floats
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class ScalarNode extends VariableNode
+{
+    /**
+     * {@inheritdoc}
+     */
+    protected function validateType($value)
+    {
+        if (!is_scalar($value) && null !== $value) {
+            $ex = new InvalidTypeException(sprintf('Invalid type for path "%s". Expected scalar, but got %s.', $this->getPath(), \gettype($value)));
+            if ($hint = $this->getInfo()) {
+                $ex->addHint($hint);
+            }
+            $ex->setPath($this->getPath());
+
+            throw $ex;
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function isValueEmpty($value)
+    {
+        return null === $value || '' === $value;
+    }
+}

msd2/phpBB3/vendor/symfony/config/Definition/VariableNode.php

@@ -0,0 +1,128 @@
+<?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\Config\Definition;
+
+use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
+
+/**
+ * This node represents a value of variable type in the config tree.
+ *
+ * This node is intended for values of arbitrary type.
+ * Any PHP type is accepted as a value.
+ *
+ * @author Jeremy Mikola <jmikola@gmail.com>
+ */
+class VariableNode extends BaseNode implements PrototypeNodeInterface
+{
+    protected $defaultValueSet = false;
+    protected $defaultValue;
+    protected $allowEmptyValue = true;
+
+    public function setDefaultValue($value)
+    {
+        $this->defaultValueSet = true;
+        $this->defaultValue = $value;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function hasDefaultValue()
+    {
+        return $this->defaultValueSet;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getDefaultValue()
+    {
+        $v = $this->defaultValue;
+
+        return $v instanceof \Closure ? $v() : $v;
+    }
+
+    /**
+     * Sets if this node is allowed to have an empty value.
+     *
+     * @param bool $boolean True if this entity will accept empty values
+     */
+    public function setAllowEmptyValue($boolean)
+    {
+        $this->allowEmptyValue = (bool) $boolean;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function setName($name)
+    {
+        $this->name = $name;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function validateType($value)
+    {
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function finalizeValue($value)
+    {
+        if (!$this->allowEmptyValue && $this->isValueEmpty($value)) {
+            $ex = new InvalidConfigurationException(sprintf('The path "%s" cannot contain an empty value, but got %s.', $this->getPath(), json_encode($value)));
+            if ($hint = $this->getInfo()) {
+                $ex->addHint($hint);
+            }
+            $ex->setPath($this->getPath());
+
+            throw $ex;
+        }
+
+        return $value;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function normalizeValue($value)
+    {
+        return $value;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function mergeValues($leftSide, $rightSide)
+    {
+        return $rightSide;
+    }
+
+    /**
+     * Evaluates if the given value is to be treated as empty.
+     *
+     * By default, PHP's empty() function is used to test for emptiness. This
+     * method may be overridden by subtypes to better match their understanding
+     * of empty data.
+     *
+     * @param mixed $value
+     *
+     * @return bool
+     */
+    protected function isValueEmpty($value)
+    {
+        return empty($value);
+    }
+}

msd2/phpBB3/vendor/symfony/config/Exception/FileLoaderImportCircularReferenceException.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\Config\Exception;
+
+/**
+ * Exception class for when a circular reference is detected when importing resources.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class FileLoaderImportCircularReferenceException extends FileLoaderLoadException
+{
+    public function __construct(array $resources, $code = null, $previous = null)
+    {
+        $message = sprintf('Circular reference detected in "%s" ("%s" > "%s").', $this->varToString($resources[0]), implode('" > "', $resources), $resources[0]);
+
+        \Exception::__construct($message, $code, $previous);
+    }
+}

msd2/phpBB3/vendor/symfony/config/Exception/FileLoaderLoadException.php

@@ -0,0 +1,101 @@
+<?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\Config\Exception;
+
+/**
+ * Exception class for when a resource cannot be loaded or imported.
+ *
+ * @author Ryan Weaver <ryan@thatsquality.com>
+ */
+class FileLoaderLoadException extends \Exception
+{
+    /**
+     * @param string     $resource       The resource that could not be imported
+     * @param string     $sourceResource The original resource importing the new resource
+     * @param int        $code           The error code
+     * @param \Exception $previous       A previous exception
+     */
+    public function __construct($resource, $sourceResource = null, $code = null, $previous = null)
+    {
+        $message = '';
+        if ($previous) {
+            // Include the previous exception, to help the user see what might be the underlying cause
+
+            // Trim the trailing period of the previous message. We only want 1 period remove so no rtrim...
+            if ('.' === substr($previous->getMessage(), -1)) {
+                $trimmedMessage = substr($previous->getMessage(), 0, -1);
+                $message .= sprintf('%s', $trimmedMessage).' in ';
+            } else {
+                $message .= sprintf('%s', $previous->getMessage()).' in ';
+            }
+            $message .= $resource.' ';
+
+            // show tweaked trace to complete the human readable sentence
+            if (null === $sourceResource) {
+                $message .= sprintf('(which is loaded in resource "%s")', $this->varToString($resource));
+            } else {
+                $message .= sprintf('(which is being imported from "%s")', $this->varToString($sourceResource));
+            }
+            $message .= '.';
+
+        // if there's no previous message, present it the default way
+        } elseif (null === $sourceResource) {
+            $message .= sprintf('Cannot load resource "%s".', $this->varToString($resource));
+        } else {
+            $message .= sprintf('Cannot import resource "%s" from "%s".', $this->varToString($resource), $this->varToString($sourceResource));
+        }
+
+        // Is the resource located inside a bundle?
+        if ('@' === $resource[0]) {
+            $parts = explode(\DIRECTORY_SEPARATOR, $resource);
+            $bundle = substr($parts[0], 1);
+            $message .= sprintf(' Make sure the "%s" bundle is correctly registered and loaded in the application kernel class.', $bundle);
+            $message .= sprintf(' If the bundle is registered, make sure the bundle path "%s" is not empty.', $resource);
+        }
+
+        parent::__construct($message, $code, $previous);
+    }
+
+    protected function varToString($var)
+    {
+        if (\is_object($var)) {
+            return sprintf('Object(%s)', \get_class($var));
+        }
+
+        if (\is_array($var)) {
+            $a = array();
+            foreach ($var as $k => $v) {
+                $a[] = sprintf('%s => %s', $k, $this->varToString($v));
+            }
+
+            return sprintf('Array(%s)', implode(', ', $a));
+        }
+
+        if (\is_resource($var)) {
+            return sprintf('Resource(%s)', get_resource_type($var));
+        }
+
+        if (null === $var) {
+            return 'null';
+        }
+
+        if (false === $var) {
+            return 'false';
+        }
+
+        if (true === $var) {
+            return 'true';
+        }
+
+        return (string) $var;
+    }
+}

msd2/phpBB3/vendor/symfony/config/FileLocator.php

@@ -0,0 +1,94 @@
+<?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\Config;
+
+/**
+ * FileLocator uses an array of pre-defined paths to find files.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class FileLocator implements FileLocatorInterface
+{
+    protected $paths;
+
+    /**
+     * @param string|array $paths A path or an array of paths where to look for resources
+     */
+    public function __construct($paths = array())
+    {
+        $this->paths = (array) $paths;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function locate($name, $currentPath = null, $first = true)
+    {
+        if ('' == $name) {
+            throw new \InvalidArgumentException('An empty file name is not valid to be located.');
+        }
+
+        if ($this->isAbsolutePath($name)) {
+            if (!file_exists($name)) {
+                throw new \InvalidArgumentException(sprintf('The file "%s" does not exist.', $name));
+            }
+
+            return $name;
+        }
+
+        $paths = $this->paths;
+
+        if (null !== $currentPath) {
+            array_unshift($paths, $currentPath);
+        }
+
+        $paths = array_unique($paths);
+        $filepaths = array();
+
+        foreach ($paths as $path) {
+            if (@file_exists($file = $path.\DIRECTORY_SEPARATOR.$name)) {
+                if (true === $first) {
+                    return $file;
+                }
+                $filepaths[] = $file;
+            }
+        }
+
+        if (!$filepaths) {
+            throw new \InvalidArgumentException(sprintf('The file "%s" does not exist (in: %s).', $name, implode(', ', $paths)));
+        }
+
+        return $filepaths;
+    }
+
+    /**
+     * Returns whether the file path is an absolute path.
+     *
+     * @param string $file A file path
+     *
+     * @return bool
+     */
+    private function isAbsolutePath($file)
+    {
+        if ('/' === $file[0] || '\\' === $file[0]
+            || (\strlen($file) > 3 && ctype_alpha($file[0])
+                && ':' === $file[1]
+                && ('\\' === $file[2] || '/' === $file[2])
+            )
+            || null !== parse_url($file, PHP_URL_SCHEME)
+        ) {
+            return true;
+        }
+
+        return false;
+    }
+}

msd2/phpBB3/vendor/symfony/config/FileLocatorInterface.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\Config;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+interface FileLocatorInterface
+{
+    /**
+     * Returns a full path for a given file name.
+     *
+     * @param string      $name        The file name to locate
+     * @param string|null $currentPath The current path
+     * @param bool        $first       Whether to return the first occurrence or an array of filenames
+     *
+     * @return string|array The full path to the file or an array of file paths
+     *
+     * @throws \InvalidArgumentException When file is not found
+     */
+    public function locate($name, $currentPath = null, $first = true);
+}

msd2/phpBB3/vendor/symfony/config/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.

msd2/phpBB3/vendor/symfony/config/Loader/DelegatingLoader.php

@@ -0,0 +1,50 @@
+<?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\Config\Loader;
+
+use Symfony\Component\Config\Exception\FileLoaderLoadException;
+
+/**
+ * DelegatingLoader delegates loading to other loaders using a loader resolver.
+ *
+ * This loader acts as an array of LoaderInterface objects - each having
+ * a chance to load a given resource (handled by the resolver)
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class DelegatingLoader extends Loader
+{
+    public function __construct(LoaderResolverInterface $resolver)
+    {
+        $this->resolver = $resolver;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function load($resource, $type = null)
+    {
+        if (false === $loader = $this->resolver->resolve($resource, $type)) {
+            throw new FileLoaderLoadException($resource);
+        }
+
+        return $loader->load($resource, $type);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function supports($resource, $type = null)
+    {
+        return false !== $this->resolver->resolve($resource, $type);
+    }
+}

msd2/phpBB3/vendor/symfony/config/Loader/FileLoader.php

@@ -0,0 +1,126 @@
+<?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\Config\Loader;
+
+use Symfony\Component\Config\Exception\FileLoaderImportCircularReferenceException;
+use Symfony\Component\Config\Exception\FileLoaderLoadException;
+use Symfony\Component\Config\FileLocatorInterface;
+
+/**
+ * FileLoader is the abstract class used by all built-in loaders that are file based.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+abstract class FileLoader extends Loader
+{
+    protected static $loading = array();
+
+    protected $locator;
+
+    private $currentDir;
+
+    public function __construct(FileLocatorInterface $locator)
+    {
+        $this->locator = $locator;
+    }
+
+    /**
+     * Sets the current directory.
+     *
+     * @param string $dir
+     */
+    public function setCurrentDir($dir)
+    {
+        $this->currentDir = $dir;
+    }
+
+    /**
+     * Returns the file locator used by this loader.
+     *
+     * @return FileLocatorInterface
+     */
+    public function getLocator()
+    {
+        return $this->locator;
+    }
+
+    /**
+     * Imports a resource.
+     *
+     * @param mixed       $resource       A Resource
+     * @param string|null $type           The resource type or null if unknown
+     * @param bool        $ignoreErrors   Whether to ignore import errors or not
+     * @param string|null $sourceResource The original resource importing the new resource
+     *
+     * @return mixed
+     *
+     * @throws FileLoaderLoadException
+     * @throws FileLoaderImportCircularReferenceException
+     */
+    public function import($resource, $type = null, $ignoreErrors = false, $sourceResource = null)
+    {
+        try {
+            $loader = $this->resolve($resource, $type);
+
+            if ($loader instanceof self && null !== $this->currentDir) {
+                // we fallback to the current locator to keep BC
+                // as some some loaders do not call the parent __construct()
+                // @deprecated should be removed in 3.0
+                $locator = $loader->getLocator();
+                if (null === $locator) {
+                    @trigger_error('Not calling the parent constructor in '.\get_class($loader).' which extends '.__CLASS__.' is deprecated since Symfony 2.7 and will not be supported anymore in 3.0.', E_USER_DEPRECATED);
+                    $locator = $this->locator;
+                }
+
+                $resource = $locator->locate($resource, $this->currentDir, false);
+            }
+
+            $resources = \is_array($resource) ? $resource : array($resource);
+            for ($i = 0; $i < $resourcesCount = \count($resources); ++$i) {
+                if (isset(self::$loading[$resources[$i]])) {
+                    if ($i == $resourcesCount - 1) {
+                        throw new FileLoaderImportCircularReferenceException(array_keys(self::$loading));
+                    }
+                } else {
+                    $resource = $resources[$i];
+                    break;
+                }
+            }
+            self::$loading[$resource] = true;
+
+            try {
+                $ret = $loader->load($resource, $type);
+            } catch (\Exception $e) {
+                unset(self::$loading[$resource]);
+                throw $e;
+            } catch (\Throwable $e) {
+                unset(self::$loading[$resource]);
+                throw $e;
+            }
+
+            unset(self::$loading[$resource]);
+
+            return $ret;
+        } catch (FileLoaderImportCircularReferenceException $e) {
+            throw $e;
+        } catch (\Exception $e) {
+            if (!$ignoreErrors) {
+                // prevent embedded imports from nesting multiple exceptions
+                if ($e instanceof FileLoaderLoadException) {
+                    throw $e;
+                }
+
+                throw new FileLoaderLoadException($resource, $sourceResource, null, $e);
+            }
+        }
+    }
+}

msd2/phpBB3/vendor/symfony/config/Loader/Loader.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\Config\Loader;
+
+use Symfony\Component\Config\Exception\FileLoaderLoadException;
+
+/**
+ * Loader is the abstract class used by all built-in loaders.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+abstract class Loader implements LoaderInterface
+{
+    protected $resolver;
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getResolver()
+    {
+        return $this->resolver;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function setResolver(LoaderResolverInterface $resolver)
+    {
+        $this->resolver = $resolver;
+    }
+
+    /**
+     * Imports a resource.
+     *
+     * @param mixed       $resource A resource
+     * @param string|null $type     The resource type or null if unknown
+     *
+     * @return mixed
+     */
+    public function import($resource, $type = null)
+    {
+        return $this->resolve($resource, $type)->load($resource, $type);
+    }
+
+    /**
+     * Finds a loader able to load an imported resource.
+     *
+     * @param mixed       $resource A resource
+     * @param string|null $type     The resource type or null if unknown
+     *
+     * @return $this|LoaderInterface
+     *
+     * @throws FileLoaderLoadException If no loader is found
+     */
+    public function resolve($resource, $type = null)
+    {
+        if ($this->supports($resource, $type)) {
+            return $this;
+        }
+
+        $loader = null === $this->resolver ? false : $this->resolver->resolve($resource, $type);
+
+        if (false === $loader) {
+            throw new FileLoaderLoadException($resource);
+        }
+
+        return $loader;
+    }
+}

msd2/phpBB3/vendor/symfony/config/Loader/LoaderInterface.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\Config\Loader;
+
+/**
+ * LoaderInterface is the interface implemented by all loader classes.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+interface LoaderInterface
+{
+    /**
+     * Loads a resource.
+     *
+     * @param mixed       $resource The resource
+     * @param string|null $type     The resource type or null if unknown
+     *
+     * @throws \Exception If something went wrong
+     */
+    public function load($resource, $type = null);
+
+    /**
+     * Returns whether this class supports the given resource.
+     *
+     * @param mixed       $resource A resource
+     * @param string|null $type     The resource type or null if unknown
+     *
+     * @return bool True if this class supports the given resource, false otherwise
+     */
+    public function supports($resource, $type = null);
+
+    /**
+     * Gets the loader resolver.
+     *
+     * @return LoaderResolverInterface A LoaderResolverInterface instance
+     */
+    public function getResolver();
+
+    /**
+     * Sets the loader resolver.
+     */
+    public function setResolver(LoaderResolverInterface $resolver);
+}

msd2/phpBB3/vendor/symfony/config/Loader/LoaderResolver.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\Config\Loader;
+
+/**
+ * LoaderResolver selects a loader for a given resource.
+ *
+ * A resource can be anything (e.g. a full path to a config file or a Closure).
+ * Each loader determines whether it can load a resource and how.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class LoaderResolver implements LoaderResolverInterface
+{
+    /**
+     * @var LoaderInterface[] An array of LoaderInterface objects
+     */
+    private $loaders = array();
+
+    /**
+     * @param LoaderInterface[] $loaders An array of loaders
+     */
+    public function __construct(array $loaders = array())
+    {
+        foreach ($loaders as $loader) {
+            $this->addLoader($loader);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function resolve($resource, $type = null)
+    {
+        foreach ($this->loaders as $loader) {
+            if ($loader->supports($resource, $type)) {
+                return $loader;
+            }
+        }
+
+        return false;
+    }
+
+    public function addLoader(LoaderInterface $loader)
+    {
+        $this->loaders[] = $loader;
+        $loader->setResolver($this);
+    }
+
+    /**
+     * Returns the registered loaders.
+     *
+     * @return LoaderInterface[] An array of LoaderInterface instances
+     */
+    public function getLoaders()
+    {
+        return $this->loaders;
+    }
+}

msd2/phpBB3/vendor/symfony/config/Loader/LoaderResolverInterface.php

@@ -0,0 +1,30 @@
+<?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\Config\Loader;
+
+/**
+ * LoaderResolverInterface selects a loader for a given resource.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+interface LoaderResolverInterface
+{
+    /**
+     * Returns a loader able to load the resource.
+     *
+     * @param mixed       $resource A resource
+     * @param string|null $type     The resource type or null if unknown
+     *
+     * @return LoaderInterface|false The loader or false if none is able to load the resource
+     */
+    public function resolve($resource, $type = null);
+}

msd2/phpBB3/vendor/symfony/config/Resource/BCResourceInterfaceChecker.php

@@ -0,0 +1,36 @@
+<?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\Config\Resource;
+
+/**
+ * Resource checker for the ResourceInterface. Exists for BC.
+ *
+ * @author Matthias Pigulla <mp@webfactory.de>
+ *
+ * @deprecated since 2.8, to be removed in 3.0.
+ */
+class BCResourceInterfaceChecker extends SelfCheckingResourceChecker
+{
+    public function supports(ResourceInterface $metadata)
+    {
+        /* As all resources must be instanceof ResourceInterface,
+           we support them all. */
+        return true;
+    }
+
+    public function isFresh(ResourceInterface $resource, $timestamp)
+    {
+        @trigger_error(sprintf('The class "%s" is performing resource checking through ResourceInterface::isFresh(), which is deprecated since Symfony 2.8 and will be removed in 3.0', \get_class($resource)), E_USER_DEPRECATED);
+
+        return parent::isFresh($resource, $timestamp); // For now, $metadata features the isFresh() method, so off we go (quack quack)
+    }
+}

msd2/phpBB3/vendor/symfony/config/Resource/DirectoryResource.php

@@ -0,0 +1,110 @@
+<?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\Config\Resource;
+
+/**
+ * DirectoryResource represents a resources stored in a subdirectory tree.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class DirectoryResource implements SelfCheckingResourceInterface, \Serializable
+{
+    private $resource;
+    private $pattern;
+
+    /**
+     * @param string      $resource The file path to the resource
+     * @param string|null $pattern  A pattern to restrict monitored files
+     */
+    public function __construct($resource, $pattern = null)
+    {
+        $this->resource = $resource;
+        $this->pattern = $pattern;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function __toString()
+    {
+        return md5(serialize(array($this->resource, $this->pattern)));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getResource()
+    {
+        return $this->resource;
+    }
+
+    /**
+     * Returns the pattern to restrict monitored files.
+     *
+     * @return string|null
+     */
+    public function getPattern()
+    {
+        return $this->pattern;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isFresh($timestamp)
+    {
+        if (!is_dir($this->resource)) {
+            return false;
+        }
+
+        if ($timestamp < filemtime($this->resource)) {
+            return false;
+        }
+
+        foreach (new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($this->resource), \RecursiveIteratorIterator::SELF_FIRST) as $file) {
+            // if regex filtering is enabled only check matching files
+            if ($this->pattern && $file->isFile() && !preg_match($this->pattern, $file->getBasename())) {
+                continue;
+            }
+
+            // always monitor directories for changes, except the .. entries
+            // (otherwise deleted files wouldn't get detected)
+            if ($file->isDir() && '/..' === substr($file, -3)) {
+                continue;
+            }
+
+            // for broken links
+            try {
+                $fileMTime = $file->getMTime();
+            } catch (\RuntimeException $e) {
+                continue;
+            }
+
+            // early return if a file's mtime exceeds the passed timestamp
+            if ($timestamp < $fileMTime) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public function serialize()
+    {
+        return serialize(array($this->resource, $this->pattern));
+    }
+
+    public function unserialize($serialized)
+    {
+        list($this->resource, $this->pattern) = unserialize($serialized);
+    }
+}

msd2/phpBB3/vendor/symfony/config/Resource/FileExistenceResource.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\Config\Resource;
+
+/**
+ * FileExistenceResource represents a resource stored on the filesystem.
+ * Freshness is only evaluated against resource creation or deletion.
+ *
+ * The resource can be a file or a directory.
+ *
+ * @author Charles-Henri Bruyand <charleshenri.bruyand@gmail.com>
+ */
+class FileExistenceResource implements SelfCheckingResourceInterface, \Serializable
+{
+    private $resource;
+
+    private $exists;
+
+    /**
+     * @param string $resource The file path to the resource
+     */
+    public function __construct($resource)
+    {
+        $this->resource = (string) $resource;
+        $this->exists = file_exists($resource);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function __toString()
+    {
+        return $this->resource;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getResource()
+    {
+        return $this->resource;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isFresh($timestamp)
+    {
+        return file_exists($this->resource) === $this->exists;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function serialize()
+    {
+        return serialize(array($this->resource, $this->exists));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function unserialize($serialized)
+    {
+        list($this->resource, $this->exists) = unserialize($serialized);
+    }
+}

msd2/phpBB3/vendor/symfony/config/Resource/FileResource.php

@@ -0,0 +1,73 @@
+<?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\Config\Resource;
+
+/**
+ * FileResource represents a resource stored on the filesystem.
+ *
+ * The resource can be a file or a directory.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class FileResource implements SelfCheckingResourceInterface, \Serializable
+{
+    /**
+     * @var string|false
+     */
+    private $resource;
+
+    /**
+     * @param string $resource The file path to the resource
+     */
+    public function __construct($resource)
+    {
+        $this->resource = realpath($resource) ?: (file_exists($resource) ? $resource : false);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function __toString()
+    {
+        return (string) $this->resource;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getResource()
+    {
+        return $this->resource;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isFresh($timestamp)
+    {
+        if (false === $this->resource || !file_exists($this->resource)) {
+            return false;
+        }
+
+        return filemtime($this->resource) <= $timestamp;
+    }
+
+    public function serialize()
+    {
+        return serialize($this->resource);
+    }
+
+    public function unserialize($serialized)
+    {
+        $this->resource = unserialize($serialized);
+    }
+}

msd2/phpBB3/vendor/symfony/config/Resource/ResourceInterface.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\Config\Resource;
+
+/**
+ * ResourceInterface is the interface that must be implemented by all Resource classes.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+interface ResourceInterface
+{
+    /**
+     * Returns a string representation of the Resource.
+     *
+     * This method is necessary to allow for resource de-duplication, for example by means
+     * of array_unique(). The string returned need not have a particular meaning, but has
+     * to be identical for different ResourceInterface instances referring to the same
+     * resource; and it should be unlikely to collide with that of other, unrelated
+     * resource instances.
+     *
+     * @return string A string representation unique to the underlying Resource
+     */
+    public function __toString();
+
+    /**
+     * Returns true if the resource has not been updated since the given timestamp.
+     *
+     * @param int $timestamp The last time the resource was loaded
+     *
+     * @return bool True if the resource has not been updated, false otherwise
+     *
+     * @deprecated since 2.8, to be removed in 3.0. If your resource can check itself for
+     *             freshness implement the SelfCheckingResourceInterface instead.
+     */
+    public function isFresh($timestamp);
+
+    /**
+     * Returns the tied resource.
+     *
+     * @return mixed The resource
+     *
+     * @deprecated since 2.8, to be removed in 3.0. As there are many different kinds of resource,
+     *             a single getResource() method does not make sense at the interface level. You
+     *             can still call getResource() on implementing classes, probably after performing
+     *             a type check. If you know the concrete type of Resource at hand, the return value
+     *             of this method may make sense to you.
+     */
+    public function getResource();
+}

msd2/phpBB3/vendor/symfony/config/Resource/SelfCheckingResourceChecker.php

@@ -0,0 +1,36 @@
+<?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\Config\Resource;
+
+use Symfony\Component\Config\ResourceCheckerInterface;
+
+/**
+ * Resource checker for instances of SelfCheckingResourceInterface.
+ *
+ * As these resources perform the actual check themselves, we can provide
+ * this class as a standard way of validating them.
+ *
+ * @author Matthias Pigulla <mp@webfactory.de>
+ */
+class SelfCheckingResourceChecker implements ResourceCheckerInterface
+{
+    public function supports(ResourceInterface $metadata)
+    {
+        return $metadata instanceof SelfCheckingResourceInterface;
+    }
+
+    public function isFresh(ResourceInterface $resource, $timestamp)
+    {
+        /* @var SelfCheckingResourceInterface $resource */
+        return $resource->isFresh($timestamp);
+    }
+}

msd2/phpBB3/vendor/symfony/config/Resource/SelfCheckingResourceInterface.php

@@ -0,0 +1,30 @@
+<?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\Config\Resource;
+
+/**
+ * Interface for Resources that can check for freshness autonomously,
+ * without special support from external services.
+ *
+ * @author Matthias Pigulla <mp@webfactory.de>
+ */
+interface SelfCheckingResourceInterface extends ResourceInterface
+{
+    /**
+     * Returns true if the resource has not been updated since the given timestamp.
+     *
+     * @param int $timestamp The last time the resource was loaded
+     *
+     * @return bool True if the resource has not been updated, false otherwise
+     */
+    public function isFresh($timestamp);
+}

msd2/phpBB3/vendor/symfony/config/ResourceCheckerConfigCache.php

@@ -0,0 +1,168 @@
+<?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\Config;
+
+use Symfony\Component\Config\Resource\ResourceInterface;
+use Symfony\Component\Filesystem\Exception\IOException;
+use Symfony\Component\Filesystem\Filesystem;
+
+/**
+ * ResourceCheckerConfigCache uses instances of ResourceCheckerInterface
+ * to check whether cached data is still fresh.
+ *
+ * @author Matthias Pigulla <mp@webfactory.de>
+ */
+class ResourceCheckerConfigCache implements ConfigCacheInterface
+{
+    /**
+     * @var string
+     */
+    private $file;
+
+    /**
+     * @var ResourceCheckerInterface[]
+     */
+    private $resourceCheckers;
+
+    /**
+     * @param string                     $file             The absolute cache path
+     * @param ResourceCheckerInterface[] $resourceCheckers The ResourceCheckers to use for the freshness check
+     */
+    public function __construct($file, array $resourceCheckers = array())
+    {
+        $this->file = $file;
+        $this->resourceCheckers = $resourceCheckers;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getPath()
+    {
+        return $this->file;
+    }
+
+    /**
+     * Checks if the cache is still fresh.
+     *
+     * This implementation will make a decision solely based on the ResourceCheckers
+     * passed in the constructor.
+     *
+     * The first ResourceChecker that supports a given resource is considered authoritative.
+     * Resources with no matching ResourceChecker will silently be ignored and considered fresh.
+     *
+     * @return bool true if the cache is fresh, false otherwise
+     */
+    public function isFresh()
+    {
+        if (!is_file($this->file)) {
+            return false;
+        }
+
+        if (!$this->resourceCheckers) {
+            return true; // shortcut - if we don't have any checkers we don't need to bother with the meta file at all
+        }
+
+        $metadata = $this->getMetaFile();
+        if (!is_file($metadata)) {
+            return false;
+        }
+
+        $e = null;
+        $meta = false;
+        $time = filemtime($this->file);
+        $signalingException = new \UnexpectedValueException();
+        $prevUnserializeHandler = ini_set('unserialize_callback_func', '');
+        $prevErrorHandler = set_error_handler(function ($type, $msg, $file, $line, $context) use (&$prevErrorHandler, $signalingException) {
+            if (E_WARNING === $type && 'Class __PHP_Incomplete_Class has no unserializer' === $msg) {
+                throw $signalingException;
+            }
+
+            return $prevErrorHandler ? $prevErrorHandler($type, $msg, $file, $line, $context) : false;
+        });
+
+        try {
+            $meta = unserialize(file_get_contents($metadata));
+        } catch (\Error $e) {
+        } catch (\Exception $e) {
+        }
+        restore_error_handler();
+        ini_set('unserialize_callback_func', $prevUnserializeHandler);
+        if (null !== $e && $e !== $signalingException) {
+            throw $e;
+        }
+        if (false === $meta) {
+            return false;
+        }
+
+        foreach ($meta as $resource) {
+            /* @var ResourceInterface $resource */
+            foreach ($this->resourceCheckers as $checker) {
+                if (!$checker->supports($resource)) {
+                    continue; // next checker
+                }
+                if ($checker->isFresh($resource, $time)) {
+                    break; // no need to further check this resource
+                }
+
+                return false; // cache is stale
+            }
+            // no suitable checker found, ignore this resource
+        }
+
+        return true;
+    }
+
+    /**
+     * Writes cache.
+     *
+     * @param string              $content  The content to write in the cache
+     * @param ResourceInterface[] $metadata An array of metadata
+     *
+     * @throws \RuntimeException When cache file can't be written
+     */
+    public function write($content, array $metadata = null)
+    {
+        $mode = 0666;
+        $umask = umask();
+        $filesystem = new Filesystem();
+        $filesystem->dumpFile($this->file, $content, null);
+        try {
+            $filesystem->chmod($this->file, $mode, $umask);
+        } catch (IOException $e) {
+            // discard chmod failure (some filesystem may not support it)
+        }
+
+        if (null !== $metadata) {
+            $filesystem->dumpFile($this->getMetaFile(), serialize($metadata), null);
+            try {
+                $filesystem->chmod($this->getMetaFile(), $mode, $umask);
+            } catch (IOException $e) {
+                // discard chmod failure (some filesystem may not support it)
+            }
+        }
+
+        if (\function_exists('opcache_invalidate') && ini_get('opcache.enable')) {
+            @opcache_invalidate($this->file, true);
+        }
+    }
+
+    /**
+     * Gets the meta file path.
+     *
+     * @return string The meta file path
+     */
+    private function getMetaFile()
+    {
+        return $this->file.'.meta';
+    }
+}

msd2/phpBB3/vendor/symfony/config/ResourceCheckerConfigCacheFactory.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\Config;
+
+/**
+ * A ConfigCacheFactory implementation that validates the
+ * cache with an arbitrary set of ResourceCheckers.
+ *
+ * @author Matthias Pigulla <mp@webfactory.de>
+ */
+class ResourceCheckerConfigCacheFactory implements ConfigCacheFactoryInterface
+{
+    /**
+     * @var ResourceCheckerInterface[]
+     */
+    private $resourceCheckers = array();
+
+    /**
+     * @param ResourceCheckerInterface[] $resourceCheckers
+     */
+    public function __construct(array $resourceCheckers = array())
+    {
+        $this->resourceCheckers = $resourceCheckers;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function cache($file, $callback)
+    {
+        if (!\is_callable($callback)) {
+            throw new \InvalidArgumentException(sprintf('Invalid type for callback argument. Expected callable, but got "%s".', \gettype($callback)));
+        }
+
+        $cache = new ResourceCheckerConfigCache($file, $this->resourceCheckers);
+        if (!$cache->isFresh()) {
+            \call_user_func($callback, $cache);
+        }
+
+        return $cache;
+    }
+}

msd2/phpBB3/vendor/symfony/config/ResourceCheckerInterface.php

@@ -0,0 +1,48 @@
+<?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\Config;
+
+use Symfony\Component\Config\Resource\ResourceInterface;
+
+/**
+ * Interface for ResourceCheckers.
+ *
+ * When a ResourceCheckerConfigCache instance is checked for freshness, all its associated
+ * metadata resources are passed to ResourceCheckers. The ResourceCheckers
+ * can then inspect the resources and decide whether the cache can be considered
+ * fresh or not.
+ *
+ * @author Matthias Pigulla <mp@webfactory.de>
+ * @author Benjamin Klotz <bk@webfactory.de>
+ */
+interface ResourceCheckerInterface
+{
+    /**
+     * Queries the ResourceChecker whether it can validate a given
+     * resource or not.
+     *
+     * @param ResourceInterface $metadata The resource to be checked for freshness
+     *
+     * @return bool True if the ResourceChecker can handle this resource type, false if not
+     */
+    public function supports(ResourceInterface $metadata);
+
+    /**
+     * Validates the resource.
+     *
+     * @param ResourceInterface $resource  The resource to be validated
+     * @param int               $timestamp The timestamp at which the cache associated with this resource was created
+     *
+     * @return bool True if the resource has not changed since the given timestamp, false otherwise
+     */
+    public function isFresh(ResourceInterface $resource, $timestamp);
+}

msd2/phpBB3/vendor/symfony/config/Util/XmlUtils.php

@@ -0,0 +1,243 @@
+<?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\Config\Util;
+
+/**
+ * XMLUtils is a bunch of utility methods to XML operations.
+ *
+ * This class contains static methods only and is not meant to be instantiated.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ * @author Martin Hasoň <martin.hason@gmail.com>
+ */
+class XmlUtils
+{
+    /**
+     * This class should not be instantiated.
+     */
+    private function __construct()
+    {
+    }
+
+    /**
+     * Loads an XML file.
+     *
+     * @param string               $file             An XML file path
+     * @param string|callable|null $schemaOrCallable An XSD schema file path, a callable, or null to disable validation
+     *
+     * @return \DOMDocument
+     *
+     * @throws \InvalidArgumentException When loading of XML file returns error
+     * @throws \RuntimeException         When DOM extension is missing
+     */
+    public static function loadFile($file, $schemaOrCallable = null)
+    {
+        if (!\extension_loaded('dom')) {
+            throw new \RuntimeException('Extension DOM is required.');
+        }
+
+        $content = @file_get_contents($file);
+        if ('' === trim($content)) {
+            throw new \InvalidArgumentException(sprintf('File %s does not contain valid XML, it is empty.', $file));
+        }
+
+        $internalErrors = libxml_use_internal_errors(true);
+        $disableEntities = libxml_disable_entity_loader(true);
+        libxml_clear_errors();
+
+        $dom = new \DOMDocument();
+        $dom->validateOnParse = true;
+        if (!$dom->loadXML($content, LIBXML_NONET | (\defined('LIBXML_COMPACT') ? LIBXML_COMPACT : 0))) {
+            libxml_disable_entity_loader($disableEntities);
+
+            throw new \InvalidArgumentException(implode("\n", static::getXmlErrors($internalErrors)));
+        }
+
+        $dom->normalizeDocument();
+
+        libxml_use_internal_errors($internalErrors);
+        libxml_disable_entity_loader($disableEntities);
+
+        foreach ($dom->childNodes as $child) {
+            if (XML_DOCUMENT_TYPE_NODE === $child->nodeType) {
+                throw new \InvalidArgumentException('Document types are not allowed.');
+            }
+        }
+
+        if (null !== $schemaOrCallable) {
+            $internalErrors = libxml_use_internal_errors(true);
+            libxml_clear_errors();
+
+            $e = null;
+            if (\is_callable($schemaOrCallable)) {
+                try {
+                    $valid = \call_user_func($schemaOrCallable, $dom, $internalErrors);
+                } catch (\Exception $e) {
+                    $valid = false;
+                }
+            } elseif (!\is_array($schemaOrCallable) && is_file((string) $schemaOrCallable)) {
+                $schemaSource = file_get_contents((string) $schemaOrCallable);
+                $valid = @$dom->schemaValidateSource($schemaSource);
+            } else {
+                libxml_use_internal_errors($internalErrors);
+
+                throw new \InvalidArgumentException('The schemaOrCallable argument has to be a valid path to XSD file or callable.');
+            }
+
+            if (!$valid) {
+                $messages = static::getXmlErrors($internalErrors);
+                if (empty($messages)) {
+                    $messages = array(sprintf('The XML file "%s" is not valid.', $file));
+                }
+                throw new \InvalidArgumentException(implode("\n", $messages), 0, $e);
+            }
+        }
+
+        libxml_clear_errors();
+        libxml_use_internal_errors($internalErrors);
+
+        return $dom;
+    }
+
+    /**
+     * Converts a \DOMElement object to a PHP array.
+     *
+     * The following rules applies during the conversion:
+     *
+     *  * Each tag is converted to a key value or an array
+     *    if there is more than one "value"
+     *
+     *  * The content of a tag is set under a "value" key (<foo>bar</foo>)
+     *    if the tag also has some nested tags
+     *
+     *  * The attributes are converted to keys (<foo foo="bar"/>)
+     *
+     *  * The nested-tags are converted to keys (<foo><foo>bar</foo></foo>)
+     *
+     * @param \DOMElement $element     A \DOMElement instance
+     * @param bool        $checkPrefix Check prefix in an element or an attribute name
+     *
+     * @return array A PHP array
+     */
+    public static function convertDomElementToArray(\DOMElement $element, $checkPrefix = true)
+    {
+        $prefix = (string) $element->prefix;
+        $empty = true;
+        $config = array();
+        foreach ($element->attributes as $name => $node) {
+            if ($checkPrefix && !\in_array((string) $node->prefix, array('', $prefix), true)) {
+                continue;
+            }
+            $config[$name] = static::phpize($node->value);
+            $empty = false;
+        }
+
+        $nodeValue = false;
+        foreach ($element->childNodes as $node) {
+            if ($node instanceof \DOMText) {
+                if ('' !== trim($node->nodeValue)) {
+                    $nodeValue = trim($node->nodeValue);
+                    $empty = false;
+                }
+            } elseif ($checkPrefix && $prefix != (string) $node->prefix) {
+                continue;
+            } elseif (!$node instanceof \DOMComment) {
+                $value = static::convertDomElementToArray($node, $checkPrefix);
+
+                $key = $node->localName;
+                if (isset($config[$key])) {
+                    if (!\is_array($config[$key]) || !\is_int(key($config[$key]))) {
+                        $config[$key] = array($config[$key]);
+                    }
+                    $config[$key][] = $value;
+                } else {
+                    $config[$key] = $value;
+                }
+
+                $empty = false;
+            }
+        }
+
+        if (false !== $nodeValue) {
+            $value = static::phpize($nodeValue);
+            if (\count($config)) {
+                $config['value'] = $value;
+            } else {
+                $config = $value;
+            }
+        }
+
+        return !$empty ? $config : null;
+    }
+
+    /**
+     * Converts an xml value to a PHP type.
+     *
+     * @param mixed $value
+     *
+     * @return mixed
+     */
+    public static function phpize($value)
+    {
+        $value = (string) $value;
+        $lowercaseValue = strtolower($value);
+
+        switch (true) {
+            case 'null' === $lowercaseValue:
+                return;
+            case ctype_digit($value):
+                $raw = $value;
+                $cast = (int) $value;
+
+                return '0' == $value[0] ? octdec($value) : (((string) $raw === (string) $cast) ? $cast : $raw);
+            case isset($value[1]) && '-' === $value[0] && ctype_digit(substr($value, 1)):
+                $raw = $value;
+                $cast = (int) $value;
+
+                return '0' == $value[1] ? octdec($value) : (((string) $raw === (string) $cast) ? $cast : $raw);
+            case 'true' === $lowercaseValue:
+                return true;
+            case 'false' === $lowercaseValue:
+                return false;
+            case isset($value[1]) && '0b' == $value[0].$value[1]:
+                return bindec($value);
+            case is_numeric($value):
+                return '0x' === $value[0].$value[1] ? hexdec($value) : (float) $value;
+            case preg_match('/^0x[0-9a-f]++$/i', $value):
+                return hexdec($value);
+            case preg_match('/^(-|\+)?[0-9]+(\.[0-9]+)?$/', $value):
+                return (float) $value;
+            default:
+                return $value;
+        }
+    }
+
+    protected static function getXmlErrors($internalErrors)
+    {
+        $errors = array();
+        foreach (libxml_get_errors() as $error) {
+            $errors[] = sprintf('[%s %s] %s (in %s - line %d, column %d)',
+                LIBXML_ERR_WARNING == $error->level ? 'WARNING' : 'ERROR',
+                $error->code,
+                trim($error->message),
+                $error->file ?: 'n/a',
+                $error->line,
+                $error->column
+            );
+        }
+
+        libxml_clear_errors();
+        libxml_use_internal_errors($internalErrors);
+
+        return $errors;
+    }
+}

msd2/phpBB3/vendor/symfony/config/composer.json

@@ -0,0 +1,41 @@
+{
+    "name": "symfony/config",
+    "type": "library",
+    "description": "Symfony Config 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",
+        "symfony/filesystem": "~2.3|~3.0.0",
+        "symfony/polyfill-ctype": "~1.8"
+    },
+    "require-dev": {
+        "symfony/yaml": "~2.7|~3.0.0"
+    },
+    "suggest": {
+        "symfony/yaml": "To use the yaml reference dumper"
+    },
+    "autoload": {
+        "psr-4": { "Symfony\\Component\\Config\\": "" },
+        "exclude-from-classmap": [
+            "/Tests/"
+        ]
+    },
+    "minimum-stability": "dev",
+    "extra": {
+        "branch-alias": {
+            "dev-master": "2.8-dev"
+        }
+    }
+}