TemplateParser.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Fluid\Core\Parser;

/*                                                                        *
 * This script is backported from the TYPO3 Flow package "TYPO3.Fluid".   *
 *                                                                        *
 * It is free software; you can redistribute it and/or modify it under    *
 * the terms of the GNU Lesser General Public License, either version 3   *
 *  of the License, or (at your option) any later version.                *
 *                                                                        *
 * The TYPO3 project - inspiring people to share!                         *
 *                                                                        */

class TemplateParser
{
    public static $SCAN_PATTERN_NAMESPACEDECLARATION = '/(?<!\\\\){namespace\\s*(?P<identifier>[a-zA-Z]+[a-zA-Z0-9]*)\\s*=\\s*(?P<phpNamespace>(?:[A-Za-z0-9\.]+|Tx)(?:LEGACY_NAMESPACE_SEPARATOR\\w+|FLUID_NAMESPACE_SEPARATOR\\w+)+)\\s*}/m';
    public static $SCAN_PATTERN_XMLNSDECLARATION = '/\sxmlns:(?P<identifier>.*?)="(?P<xmlNamespace>.*?)"/m';

    const CONTEXT_INSIDE_VIEWHELPER_ARGUMENTS = 1;
    const CONTEXT_OUTSIDE_VIEWHELPER_ARGUMENTS = 2;

    public static $SPLIT_PATTERN_TEMPLATE_DYNAMICTAGS = '/
        (
            (?: <\\/?                                      # Start dynamic tags
                    (?:(?:NAMESPACE):[a-zA-Z0-9\\.]+)     # A tag consists of the namespace prefix and word characters
                    (?:                                   # Begin tag arguments
                        \\s*[a-zA-Z0-9:-]+                  # Argument Keys
                        =                                 # =
                        (?>                               # either... If we have found an argument, we will not back-track (That does the Atomic Bracket)
                            "(?:\\\\"|[^"])*"              # a double-quoted string
                            |\'(?:\\\\\'|[^\'])*\'        # or a single quoted string
                        )\\s*                              #
                    )*                                    # Tag arguments can be replaced many times.
                \\s*
                \\/?>                                      # Closing tag
            )
            |(?:                                          # Start match CDATA section
                <!\\[CDATA\\[.*?\\]\\]>
            )
        )/xs';

    public static $SCAN_PATTERN_TEMPLATE_VIEWHELPERTAG = '/
        ^<                                                # A Tag begins with <
        (?P<NamespaceIdentifier>NAMESPACE):               # Then comes the Namespace prefix followed by a :
        (?P<MethodIdentifier>                             # Now comes the Name of the ViewHelper
            [a-zA-Z0-9\\.]+
        )
        (?P<Attributes>                                   # Begin Tag Attributes
            (?:                                           # A tag might have multiple attributes
                \\s*
                [a-zA-Z0-9:-]+                             # The attribute name
                =                                         # =
                (?>                                       # either... # If we have found an argument, we will not back-track (That does the Atomic Bracket)
                    "(?:\\\\"|[^"])*"                      # a double-quoted string
                    |\'(?:\\\\\'|[^\'])*\'                # or a single quoted string
                )                                         #
                \\s*
            )*                                            # A tag might have multiple attributes
        )                                                 # End Tag Attributes
        \\s*
        (?P<Selfclosing>\\/?)                              # A tag might be selfclosing
        >$/x';

    public static $SCAN_PATTERN_TEMPLATE_CLOSINGVIEWHELPERTAG = '/^<\\/(?P<NamespaceIdentifier>NAMESPACE):(?P<MethodIdentifier>[a-zA-Z0-9\\.]+)\\s*>$/';

    public static $SCAN_PATTERN_NAMESPACE_FLUID_HTML_TAG = '/<html\\s++[^>]*data-namespace-typo3-fluid="true"[^>]*>/m';

    public static $SCAN_PATTERN_REMOVE_VIEWHELPERS_XMLNSDECLARATIONS = '/(?:\\s*+xmlns:(?:%1$s)="[^"]*"\\s*+)++/m';

    public static $SPLIT_PATTERN_TAGARGUMENTS = '/
        (?:                                              #
            \\s*                                          #
            (?P<Argument>                                # The attribute name
                [a-zA-Z0-9:-]+                            #
            )                                            #
            =                                            # =
            (?>                                          # If we have found an argument, we will not back-track (That does the Atomic Bracket)
                (?P<ValueQuoted>                         # either...
                    (?:"(?:\\\\"|[^"])*")                 # a double-quoted string
                    |(?:\'(?:\\\\\'|[^\'])*\')           # or a single quoted string
                )
            )\\s*
        )
        /xs';

    public static $SCAN_PATTERN_CDATA = '/^<!\\[CDATA\\[(.*?)\\]\\]>$/s';

    public static $SPLIT_PATTERN_SHORTHANDSYNTAX = '/
        (
            {                                # Start of shorthand syntax
                (?:                          # Shorthand syntax is either composed of...
                    [a-zA-Z0-9\\->_:,.()]     # Various characters
                    |"(?:\\\\"|[^"])*"        # Double-quoted strings
                    |\'(?:\\\\\'|[^\'])*\'   # Single-quoted strings
                    |(?R)                    # Other shorthand syntaxes inside, albeit not in a quoted string
                    |\\s+                     # Spaces
                )+
            }                                # End of shorthand syntax
        )/x';

    public static $SCAN_PATTERN_SHORTHANDSYNTAX_OBJECTACCESSORS = '/
        ^{                                                      # Start of shorthand syntax
                                                            # A shorthand syntax is either...
            (?P<Object>[a-zA-Z0-9\\-_.]*)                                     # ... an object accessor
            \\s*(?P<Delimiter>(?:->)?)\\s*

            (?P<ViewHelper>                                 # ... a ViewHelper
                [a-zA-Z0-9]+                                # Namespace prefix of ViewHelper (as in $SCAN_PATTERN_TEMPLATE_VIEWHELPERTAG)
                :
                [a-zA-Z0-9\\.]+                             # Method Identifier (as in $SCAN_PATTERN_TEMPLATE_VIEWHELPERTAG)
                \\(                                          # Opening parameter brackets of ViewHelper
                    (?P<ViewHelperArguments>                # Start submatch for ViewHelper arguments. This is taken from $SCAN_PATTERN_SHORTHANDSYNTAX_ARRAYS
                        (?:
                            \\s*[a-zA-Z0-9\\-_]+                  # The keys of the array
                            \\s*:\\s*                             # Key|Value delimiter :
                            (?:                                 # Possible value options:
                                "(?:\\\\"|[^"])*"                # Double qouoted string
                                |\'(?:\\\\\'|[^\'])*\'          # Single quoted string
                                |[a-zA-Z0-9\\-_.]+               # variable identifiers
                                |{(?P>ViewHelperArguments)}     # Another sub-array
                            )                                   # END possible value options
                            \\s*,?                               # There might be a , to separate different parts of the array
                        )*                                  # The above cycle is repeated for all array elements
                    )                                       # End ViewHelper Arguments submatch
                \\)                                          # Closing parameter brackets of ViewHelper
            )?
            (?P<AdditionalViewHelpers>                      # There can be more than one ViewHelper chained, by adding more -> and the ViewHelper (recursively)
                (?:
                    \\s*->\\s*
                    (?P>ViewHelper)
                )*
            )
        }$/x';

    public static $SPLIT_PATTERN_SHORTHANDSYNTAX_VIEWHELPER = '/

        (?P<NamespaceIdentifier>[a-zA-Z0-9]+)       # Namespace prefix of ViewHelper (as in $SCAN_PATTERN_TEMPLATE_VIEWHELPERTAG)
        :
        (?P<MethodIdentifier>[a-zA-Z0-9\\.]+)
        \\(                                          # Opening parameter brackets of ViewHelper
            (?P<ViewHelperArguments>                # Start submatch for ViewHelper arguments. This is taken from $SCAN_PATTERN_SHORTHANDSYNTAX_ARRAYS
                (?:
                    \\s*[a-zA-Z0-9\\-_]+                  # The keys of the array
                    \\s*:\\s*                             # Key|Value delimiter :
                    (?:                                 # Possible value options:
                        "(?:\\\\"|[^"])*"                # Double qouoted string
                        |\'(?:\\\\\'|[^\'])*\'          # Single quoted string
                        |[a-zA-Z0-9\\-_.]+               # variable identifiers
                        |{(?P>ViewHelperArguments)}     # Another sub-array
                    )                                   # END possible value options
                    \\s*,?                               # There might be a , to separate different parts of the array
                )*                                  # The above cycle is repeated for all array elements
            )                                       # End ViewHelper Arguments submatch
        \\)                                          # Closing parameter brackets of ViewHelper
        /x';

    public static $SCAN_PATTERN_SHORTHANDSYNTAX_ARRAYS = '/^
        (?P<Recursion>                                  # Start the recursive part of the regular expression - describing the array syntax
            {                                           # Each array needs to start with {
                (?P<Array>                              # Start submatch
                    (?:
                        \\s*[a-zA-Z0-9\\-_]+              # The keys of the array
                        \\s*:\\s*                         # Key|Value delimiter :
                        (?:                             # Possible value options:
                            "(?:\\\\"|[^"])*"            # Double qouoted string
                            |\'(?:\\\\\'|[^\'])*\'      # Single quoted string
                            |[a-zA-Z0-9\\-_.]+           # variable identifiers
                            |(?P>Recursion)             # Another sub-array
                        )                               # END possible value options
                        \\s*,?                           # There might be a , to separate different parts of the array
                    )*                                  # The above cycle is repeated for all array elements
                )                                       # End array submatch
            }                                           # Each array ends with }
        )$/x';

    public static $SPLIT_PATTERN_SHORTHANDSYNTAX_ARRAY_PARTS = '/
        (?P<ArrayPart>                                             # Start submatch
            (?P<Key>[a-zA-Z0-9\\-_]+)                               # The keys of the array
            \\s*:\\s*                                                   # Key|Value delimiter :
            (?:                                                       # Possible value options:
                (?P<QuotedString>                                     # Quoted string
                    (?:"(?:\\\\"|[^"])*")
                    |(?:\'(?:\\\\\'|[^\'])*\')
                )
                |(?P<VariableIdentifier>[a-zA-Z][a-zA-Z0-9\\-_.]*)    # variable identifiers have to start with a letter
                |(?P<Number>[0-9.]+)                                  # Number
                |{\\s*(?P<Subarray>(?:(?P>ArrayPart)\\s*,?\\s*)+)\\s*}              # Another sub-array
            )                                                         # END possible value options
        )                                                          # End array part submatch
    /x';

    public static $SCAN_PATTERN_DEFAULT_XML_NAMESPACE = '/^http\:\/\/typo3\.org\/ns\/(?P<PhpNamespace>.+)$/s';

    protected $namespaces = [
        'f' => 'TYPO3\\CMS\\Fluid\\ViewHelpers'
    ];

    protected $objectManager;

    protected $configuration;

    protected $settings;

    protected $viewHelperNameToImplementationClassNameRuntimeCache = [];

    public function __construct()
    {
        self::$SCAN_PATTERN_NAMESPACEDECLARATION = str_replace(
            [
                'LEGACY_NAMESPACE_SEPARATOR',
                'FLUID_NAMESPACE_SEPARATOR'
            ],
            [
                preg_quote(\TYPO3\CMS\Fluid\Fluid::LEGACY_NAMESPACE_SEPARATOR),
                preg_quote(\TYPO3\CMS\Fluid\Fluid::NAMESPACE_SEPARATOR)
            ],
            self::$SCAN_PATTERN_NAMESPACEDECLARATION
        );
    }

    public function injectSettings(array $settings)
    {
        $this->settings = $settings;
    }

    public function setConfiguration(\TYPO3\CMS\Fluid\Core\Parser\Configuration $configuration = null)
    {
        $this->configuration = $configuration;
    }

    public function parse($templateString)
    {
        if (!is_string($templateString)) {
            throw new \TYPO3\CMS\Fluid\Core\Parser\Exception('Parse requires a template string as argument, ' . gettype($templateString) . ' given.', 1224237899);
        }
        $this->reset();

        $templateString = $this->extractNamespaceDefinitions($templateString);
        $splitTemplate = $this->splitTemplateAtDynamicTags($templateString);

        $parsingState = $this->buildObjectTree($splitTemplate, self::CONTEXT_OUTSIDE_VIEWHELPER_ARGUMENTS);

        $variableContainer = $parsingState->getVariableContainer();
        if ($variableContainer !== null && $variableContainer->exists('layoutName')) {
            $parsingState->setLayoutNameNode($variableContainer->get('layoutName'));
        }

        return $parsingState;
    }

    public function getNamespaces()
    {
        return $this->namespaces;
    }

    protected function reset()
    {
        $this->namespaces = [
            'f' => 'TYPO3\\CMS\\Fluid\\ViewHelpers'
        ];
    }

    protected function extractNamespaceDefinitions($templateString)
    {
        $matches = [];
        $foundIdentifiers = [];
        preg_match_all(self::$SCAN_PATTERN_XMLNSDECLARATION, $templateString, $matches, PREG_SET_ORDER);
        foreach ($matches as $match) {
            // skip reserved "f" namespace identifier
            if ($match['identifier'] === 'f') {
                $foundIdentifiers[] = 'f';
                continue;
            }
            if (array_key_exists($match['identifier'], $this->namespaces)) {
                throw new \TYPO3\CMS\Fluid\Core\Parser\Exception(sprintf('Namespace identifier "%s" is already registered. Do not re-declare namespaces!', $match['identifier']), 1331135889);
            }
            if (isset($this->settings['namespaces'][$match['xmlNamespace']])) {
                $phpNamespace = $this->settings['namespaces'][$match['xmlNamespace']];
            } else {
                $matchedPhpNamespace = [];
                if (preg_match(self::$SCAN_PATTERN_DEFAULT_XML_NAMESPACE, $match['xmlNamespace'], $matchedPhpNamespace) === 0) {
                    continue;
                }
                $phpNamespace = str_replace('/', '\\', $matchedPhpNamespace['PhpNamespace']);
            }
            $foundIdentifiers[] = $match['identifier'];
            $this->namespaces[$match['identifier']] = $phpNamespace;
        }

        $templateString = $this->removeXmlnsViewHelperNamespaceDeclarations($templateString, $foundIdentifiers);

        $matches = [];
        preg_match_all(self::$SCAN_PATTERN_NAMESPACEDECLARATION, $templateString, $matches, PREG_SET_ORDER);
        foreach ($matches as $match) {
            if (array_key_exists($match['identifier'], $this->namespaces)) {
                throw new \TYPO3\CMS\Fluid\Core\Parser\Exception(sprintf('Namespace identifier "%s" is already registered. Do not re-declare namespaces!', $match['identifier']), 1224241246);
            }
            $this->namespaces[$match['identifier']] = $match['phpNamespace'];
        }
        if ($matches !== []) {
            $templateString = preg_replace(self::$SCAN_PATTERN_NAMESPACEDECLARATION, '', $templateString);
        }

        return $templateString;
    }

    protected function removeXmlnsViewHelperNamespaceDeclarations($templateString, array $foundIdentifiers)
    {
        $foundHtmlTags = 0;
        $templateString = preg_replace(self::$SCAN_PATTERN_NAMESPACE_FLUID_HTML_TAG, '', $templateString, 1, $foundHtmlTags);
        if ($foundHtmlTags > 0) {
            $templateString = str_replace('</html>', '', $templateString);
        }

        if (!empty($foundIdentifiers)) {
            $foundIdentifiers = array_map(function ($foundIdentifier) {
                return preg_quote($foundIdentifier, '/');
            }, $foundIdentifiers);
            $foundIdentifiers = implode('|', $foundIdentifiers);

            // replaces the pattern with space because the pattern includes trailing spaces and consecutive xmlns ViewHelper defintions
            $templateString = preg_replace(
                sprintf(self::$SCAN_PATTERN_REMOVE_VIEWHELPERS_XMLNSDECLARATIONS, $foundIdentifiers),
                ' ',
                $templateString
            );
        }

        return $templateString;
    }

    protected function splitTemplateAtDynamicTags($templateString)
    {
        $regularExpression = $this->prepareTemplateRegularExpression(self::$SPLIT_PATTERN_TEMPLATE_DYNAMICTAGS);
        return preg_split($regularExpression, $templateString, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY);
    }

    protected function buildObjectTree($splitTemplate, $context)
    {
        $regularExpression_openingViewHelperTag = $this->prepareTemplateRegularExpression(self::$SCAN_PATTERN_TEMPLATE_VIEWHELPERTAG);
        $regularExpression_closingViewHelperTag = $this->prepareTemplateRegularExpression(self::$SCAN_PATTERN_TEMPLATE_CLOSINGVIEWHELPERTAG);

        $state = $this->objectManager->get(\TYPO3\CMS\Fluid\Core\Parser\ParsingState::class);
        $rootNode = $this->objectManager->get(\TYPO3\CMS\Fluid\Core\Parser\SyntaxTree\RootNode::class);
        $state->setRootNode($rootNode);
        $state->pushNodeToStack($rootNode);

        foreach ($splitTemplate as $templateElement) {
            $matchedVariables = [];
            if (preg_match(self::$SCAN_PATTERN_CDATA, $templateElement, $matchedVariables) > 0) {
                $this->textHandler($state, $matchedVariables[1]);
            } elseif (preg_match($regularExpression_openingViewHelperTag, $templateElement, $matchedVariables) > 0) {
                $this->openingViewHelperTagHandler($state, $matchedVariables['NamespaceIdentifier'], $matchedVariables['MethodIdentifier'], $matchedVariables['Attributes'], ($matchedVariables['Selfclosing'] !== ''));
            } elseif (preg_match($regularExpression_closingViewHelperTag, $templateElement, $matchedVariables) > 0) {
                $this->closingViewHelperTagHandler($state, $matchedVariables['NamespaceIdentifier'], $matchedVariables['MethodIdentifier']);
            } else {
                $this->textAndShorthandSyntaxHandler($state, $templateElement, $context);
            }
        }

        if ($state->countNodeStack() !== 1) {
            throw new \TYPO3\CMS\Fluid\Core\Parser\Exception('Not all tags were closed!', 1238169398);
        }
        return $state;
    }

    protected function openingViewHelperTagHandler(\TYPO3\CMS\Fluid\Core\Parser\ParsingState $state, $namespaceIdentifier, $methodIdentifier, $arguments, $selfclosing)
    {
        $argumentsObjectTree = $this->parseArguments($arguments);
        $this->initializeViewHelperAndAddItToStack($state, $namespaceIdentifier, $methodIdentifier, $argumentsObjectTree);

        if ($selfclosing) {
            $node = $state->popNodeFromStack();
            $this->callInterceptor($node, \TYPO3\CMS\Fluid\Core\Parser\InterceptorInterface::INTERCEPT_CLOSING_VIEWHELPER, $state);
        }
    }

    protected function initializeViewHelperAndAddItToStack(\TYPO3\CMS\Fluid\Core\Parser\ParsingState $state, $namespaceIdentifier, $methodIdentifier, $argumentsObjectTree)
    {
        if (!array_key_exists($namespaceIdentifier, $this->namespaces)) {
            throw new \TYPO3\CMS\Fluid\Core\Parser\Exception('Namespace could not be resolved. This exception should never be thrown!', 1224254792);
        }
        $viewHelper = $this->objectManager->get($this->resolveViewHelperName($namespaceIdentifier, $methodIdentifier));
        $this->viewHelperNameToImplementationClassNameRuntimeCache[$namespaceIdentifier][$methodIdentifier] = get_class($viewHelper);

        // The following three checks are only done *in an uncached template*, and not needed anymore in the cached version
        $expectedViewHelperArguments = $viewHelper->prepareArguments();
        $this->abortIfUnregisteredArgumentsExist($expectedViewHelperArguments, $argumentsObjectTree);
        $this->abortIfRequiredArgumentsAreMissing($expectedViewHelperArguments, $argumentsObjectTree);
        $this->rewriteBooleanNodesInArgumentsObjectTree($expectedViewHelperArguments, $argumentsObjectTree);

        $currentViewHelperNode = $this->objectManager->get(\TYPO3\CMS\Fluid\Core\Parser\SyntaxTree\ViewHelperNode::class, $viewHelper, $argumentsObjectTree);

        $state->getNodeFromStack()->addChildNode($currentViewHelperNode);

        if ($viewHelper instanceof \TYPO3\CMS\Fluid\Core\ViewHelper\Facets\ChildNodeAccessInterface && !($viewHelper instanceof \TYPO3\CMS\Fluid\Core\ViewHelper\Facets\CompilableInterface)) {
            $state->setCompilable(false);
        }

        // PostParse Facet
        if ($viewHelper instanceof \TYPO3\CMS\Fluid\Core\ViewHelper\Facets\PostParseInterface) {
            $viewHelper::postParseEvent($currentViewHelperNode, $argumentsObjectTree, $state->getVariableContainer());
        }

        $this->callInterceptor($currentViewHelperNode, \TYPO3\CMS\Fluid\Core\Parser\InterceptorInterface::INTERCEPT_OPENING_VIEWHELPER, $state);

        $state->pushNodeToStack($currentViewHelperNode);
    }

    protected function abortIfUnregisteredArgumentsExist($expectedArguments, $actualArguments)
    {
        $expectedArgumentNames = [];
        foreach ($expectedArguments as $expectedArgument) {
            $expectedArgumentNames[] = $expectedArgument->getName();
        }

        foreach ($actualArguments as $argumentName => $_) {
            if (!in_array($argumentName, $expectedArgumentNames)) {
                throw new \TYPO3\CMS\Fluid\Core\Parser\Exception('Argument "' . $argumentName . '" was not registered.', 1237823695);
            }
        }
    }

    protected function abortIfRequiredArgumentsAreMissing($expectedArguments, $actualArguments)
    {
        $actualArgumentNames = array_keys($actualArguments);
        foreach ($expectedArguments as $expectedArgument) {
            if ($expectedArgument->isRequired() && !in_array($expectedArgument->getName(), $actualArgumentNames)) {
                throw new \TYPO3\CMS\Fluid\Core\Parser\Exception('Required argument "' . $expectedArgument->getName() . '" was not supplied.', 1237823699);
            }
        }
    }

    protected function rewriteBooleanNodesInArgumentsObjectTree($argumentDefinitions, &$argumentsObjectTree)
    {
        foreach ($argumentDefinitions as $argumentName => $argumentDefinition) {
            if ($argumentDefinition->getType() === 'boolean' && isset($argumentsObjectTree[$argumentName])) {
                $argumentsObjectTree[$argumentName] = new \TYPO3\CMS\Fluid\Core\Parser\SyntaxTree\BooleanNode($argumentsObjectTree[$argumentName]);
            }
        }
    }

    protected function resolveViewHelperName($namespaceIdentifier, $methodIdentifier)
    {
        if (isset($this->viewHelperNameToImplementationClassNameRuntimeCache[$namespaceIdentifier][$methodIdentifier])) {
            $name = $this->viewHelperNameToImplementationClassNameRuntimeCache[$namespaceIdentifier][$methodIdentifier];
        } else {
            $explodedViewHelperName = explode('.', $methodIdentifier);
            $namespaceSeparator = strpos($this->namespaces[$namespaceIdentifier], \TYPO3\CMS\Fluid\Fluid::NAMESPACE_SEPARATOR) !== false ? \TYPO3\CMS\Fluid\Fluid::NAMESPACE_SEPARATOR : \TYPO3\CMS\Fluid\Fluid::LEGACY_NAMESPACE_SEPARATOR;
            if (count($explodedViewHelperName) > 1) {
                $className = implode($namespaceSeparator, array_map('ucfirst', $explodedViewHelperName));
            } else {
                $className = ucfirst($explodedViewHelperName[0]);
            }
            $className .= 'ViewHelper';
            $name = $this->namespaces[$namespaceIdentifier] . $namespaceSeparator . $className;
            $name = \TYPO3\CMS\Core\Core\ClassLoadingInformation::getClassNameForAlias($name);
            // The name isn't cached in viewHelperNameToImplementationClassNameRuntimeCache here because the
            // class could be overloaded by extbase object manager. Thus the cache is filled in
            // initializeViewHelperAndAddItToStack after getting the real object from the object manager.
        }
        return $name;
    }

    protected function closingViewHelperTagHandler(\TYPO3\CMS\Fluid\Core\Parser\ParsingState $state, $namespaceIdentifier, $methodIdentifier)
    {
        if (!array_key_exists($namespaceIdentifier, $this->namespaces)) {
            throw new \TYPO3\CMS\Fluid\Core\Parser\Exception('Namespace could not be resolved. This exception should never be thrown!', 1224256186);
        }
        $lastStackElement = $state->popNodeFromStack();
        if (!($lastStackElement instanceof \TYPO3\CMS\Fluid\Core\Parser\SyntaxTree\ViewHelperNode)) {
            throw new \TYPO3\CMS\Fluid\Core\Parser\Exception('You closed a templating tag which you never opened!', 1224485838);
        }
        if ($lastStackElement->getViewHelperClassName() != $this->resolveViewHelperName($namespaceIdentifier, $methodIdentifier)) {
            throw new \TYPO3\CMS\Fluid\Core\Parser\Exception('Templating tags not properly nested. Expected: ' . $lastStackElement->getViewHelperClassName() . '; Actual: ' . $this->resolveViewHelperName($namespaceIdentifier, $methodIdentifier), 1224485398);
        }
        $this->callInterceptor($lastStackElement, \TYPO3\CMS\Fluid\Core\Parser\InterceptorInterface::INTERCEPT_CLOSING_VIEWHELPER, $state);
    }

    protected function objectAccessorHandler(\TYPO3\CMS\Fluid\Core\Parser\ParsingState $state, $objectAccessorString, $delimiter, $viewHelperString, $additionalViewHelpersString)
    {
        $viewHelperString .= $additionalViewHelpersString;
        $numberOfViewHelpers = 0;

        // The following post-processing handles a case when there is only a ViewHelper, and no Object Accessor.
        // Resolves bug #5107.
        if ($delimiter === '' && $viewHelperString !== '') {
            $viewHelperString = $objectAccessorString . $viewHelperString;
            $objectAccessorString = '';
        }

        // ViewHelpers
        $matches = [];
        if ($viewHelperString !== '' && preg_match_all(self::$SPLIT_PATTERN_SHORTHANDSYNTAX_VIEWHELPER, $viewHelperString, $matches, PREG_SET_ORDER) > 0) {
            // The last ViewHelper has to be added first for correct chaining.
            foreach (array_reverse($matches) as $singleMatch) {
                if ($singleMatch['ViewHelperArguments'] !== '') {
                    $arguments = $this->postProcessArgumentsForObjectAccessor(
                        $this->recursiveArrayHandler($singleMatch['ViewHelperArguments'])
                    );
                } else {
                    $arguments = [];
                }
                $this->initializeViewHelperAndAddItToStack($state, $singleMatch['NamespaceIdentifier'], $singleMatch['MethodIdentifier'], $arguments);
                $numberOfViewHelpers++;
            }
        }

        // Object Accessor
        if ($objectAccessorString !== '') {
            $node = $this->objectManager->get(\TYPO3\CMS\Fluid\Core\Parser\SyntaxTree\ObjectAccessorNode::class, $objectAccessorString);
            $this->callInterceptor($node, \TYPO3\CMS\Fluid\Core\Parser\InterceptorInterface::INTERCEPT_OBJECTACCESSOR, $state);

            $state->getNodeFromStack()->addChildNode($node);
        }

        // Close ViewHelper Tags if needed.
        for ($i=0; $i<$numberOfViewHelpers; $i++) {
            $node = $state->popNodeFromStack();
            $this->callInterceptor($node, \TYPO3\CMS\Fluid\Core\Parser\InterceptorInterface::INTERCEPT_CLOSING_VIEWHELPER, $state);
        }
    }

    protected function callInterceptor(\TYPO3\CMS\Fluid\Core\Parser\SyntaxTree\NodeInterface &$node, $interceptionPoint, \TYPO3\CMS\Fluid\Core\Parser\ParsingState $state)
    {
        if ($this->configuration !== null) {
            // $this->configuration is UNSET inside the arguments of a ViewHelper.
            // That's why the interceptors are only called if the object accessor is not inside a ViewHelper Argument
            // This could be a problem if We have a ViewHelper as an argument to another ViewHelper, and an ObjectAccessor nested inside there.
            // @todo Clean up this.
            $interceptors = $this->configuration->getInterceptors($interceptionPoint);
            if (count($interceptors) > 0) {
                foreach ($interceptors as $interceptor) {
                    $node = $interceptor->process($node, $interceptionPoint, $state);
                }
            }
        }
    }

    protected function postProcessArgumentsForObjectAccessor(array $arguments)
    {
        foreach ($arguments as $argumentName => $argumentValue) {
            if (!($argumentValue instanceof \TYPO3\CMS\Fluid\Core\Parser\SyntaxTree\AbstractNode)) {
                $arguments[$argumentName] = $this->objectManager->get(\TYPO3\CMS\Fluid\Core\Parser\SyntaxTree\TextNode::class, (string)$argumentValue);
            }
        }
        return $arguments;
    }

    protected function parseArguments($argumentsString)
    {
        $argumentsObjectTree = [];
        $matches = [];
        if (preg_match_all(self::$SPLIT_PATTERN_TAGARGUMENTS, $argumentsString, $matches, PREG_SET_ORDER) > 0) {
            $configurationBackup = $this->configuration;
            $this->configuration = null;
            foreach ($matches as $singleMatch) {
                $argument = $singleMatch['Argument'];
                $value = $this->unquoteString($singleMatch['ValueQuoted']);
                $argumentsObjectTree[$argument] = $this->buildArgumentObjectTree($value);
            }
            $this->configuration = $configurationBackup;
        }
        return $argumentsObjectTree;
    }

    protected function buildArgumentObjectTree($argumentString)
    {
        if (strpos($argumentString, '{') === false && strpos($argumentString, '<') === false) {
            return $this->objectManager->get(\TYPO3\CMS\Fluid\Core\Parser\SyntaxTree\TextNode::class, $argumentString);
        }
        $splitArgument = $this->splitTemplateAtDynamicTags($argumentString);
        $rootNode = $this->buildObjectTree($splitArgument, self::CONTEXT_INSIDE_VIEWHELPER_ARGUMENTS)->getRootNode();
        return $rootNode;
    }

    protected function unquoteString($quotedValue)
    {
        switch ($quotedValue[0]) {
            case '"':
                $value = str_replace('\\"', '"', preg_replace('/(^"|"$)/', '', $quotedValue));
            break;
            case "'":
                $value = str_replace("\\'", "'", preg_replace('/(^\'|\'$)/', '', $quotedValue));
            break;
            default:
                $value = $quotedValue;
        }
        return str_replace('\\\\', '\\', $value);
    }

    protected function prepareTemplateRegularExpression($regularExpression)
    {
        return str_replace('NAMESPACE', implode('|', array_keys($this->namespaces)), $regularExpression);
    }

    protected function textAndShorthandSyntaxHandler(\TYPO3\CMS\Fluid\Core\Parser\ParsingState $state, $text, $context)
    {
        $sections = preg_split($this->prepareTemplateRegularExpression(self::$SPLIT_PATTERN_SHORTHANDSYNTAX), $text, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY);

        foreach ($sections as $section) {
            $matchedVariables = [];
            if (preg_match(self::$SCAN_PATTERN_SHORTHANDSYNTAX_OBJECTACCESSORS, $section, $matchedVariables) > 0) {
                $this->objectAccessorHandler($state, $matchedVariables['Object'], $matchedVariables['Delimiter'], isset($matchedVariables['ViewHelper']) ? $matchedVariables['ViewHelper'] : '', isset($matchedVariables['AdditionalViewHelpers']) ? $matchedVariables['AdditionalViewHelpers'] : '');
            } elseif ($context === self::CONTEXT_INSIDE_VIEWHELPER_ARGUMENTS && preg_match(self::$SCAN_PATTERN_SHORTHANDSYNTAX_ARRAYS, $section, $matchedVariables) > 0) {
                // We only match arrays if we are INSIDE viewhelper arguments
                $this->arrayHandler($state, $matchedVariables['Array']);
            } else {
                $this->textHandler($state, $section);
            }
        }
    }

    protected function arrayHandler(\TYPO3\CMS\Fluid\Core\Parser\ParsingState $state, $arrayText)
    {
        $state->getNodeFromStack()->addChildNode(
            $this->objectManager->get(\TYPO3\CMS\Fluid\Core\Parser\SyntaxTree\ArrayNode::class, $this->recursiveArrayHandler($arrayText))
        );
    }

    protected function recursiveArrayHandler($arrayText)
    {
        $matches = [];
        if (preg_match_all(self::$SPLIT_PATTERN_SHORTHANDSYNTAX_ARRAY_PARTS, $arrayText, $matches, PREG_SET_ORDER) > 0) {
            $arrayToBuild = [];
            foreach ($matches as $singleMatch) {
                $arrayKey = $singleMatch['Key'];
                if (!empty($singleMatch['VariableIdentifier'])) {
                    $arrayToBuild[$arrayKey] = $this->objectManager->get(\TYPO3\CMS\Fluid\Core\Parser\SyntaxTree\ObjectAccessorNode::class, $singleMatch['VariableIdentifier']);
                } elseif (array_key_exists('Number', $singleMatch) && (!empty($singleMatch['Number']) || $singleMatch['Number'] === '0')) {
                    $arrayToBuild[$arrayKey] = floatval($singleMatch['Number']);
                } elseif ((array_key_exists('QuotedString', $singleMatch) && !empty($singleMatch['QuotedString']))) {
                    $argumentString = $this->unquoteString($singleMatch['QuotedString']);
                    $arrayToBuild[$arrayKey] = $this->buildArgumentObjectTree($argumentString);
                } elseif (array_key_exists('Subarray', $singleMatch) && !empty($singleMatch['Subarray'])) {
                    $arrayToBuild[$arrayKey] = $this->objectManager->get(\TYPO3\CMS\Fluid\Core\Parser\SyntaxTree\ArrayNode::class, $this->recursiveArrayHandler($singleMatch['Subarray']));
                } else {
                    throw new \TYPO3\CMS\Fluid\Core\Parser\Exception('This exception should never be thrown, as the array value has to be of some type (Value given: "' . var_export($singleMatch, true) . '"). Please post your template to the bugtracker at forge.typo3.org.', 1225136013);
                }
            }
            return $arrayToBuild;
        } else {
            throw new \TYPO3\CMS\Fluid\Core\Parser\Exception('This exception should never be thrown, there is most likely some error in the regular expressions. Please post your template to the bugtracker at forge.typo3.org.', 1225136014);
        }
    }

    protected function textHandler(\TYPO3\CMS\Fluid\Core\Parser\ParsingState $state, $text)
    {
        $node = $this->objectManager->get(\TYPO3\CMS\Fluid\Core\Parser\SyntaxTree\TextNode::class, $text);
        $this->callInterceptor($node, \TYPO3\CMS\Fluid\Core\Parser\InterceptorInterface::INTERCEPT_TEXT, $state);

        $state->getNodeFromStack()->addChildNode($node);
    }
}