typo3/sysext/core/Classes/TypoScript/Parser/TypoScriptParser.php

   1 <?php
   2 namespace TYPO3\CMS\Core\TypoScript\Parser;
   3
   4 /*
   5  * This file is part of the TYPO3 CMS project.
   6  *
   7  * It is free software; you can redistribute it and/or modify it under
   8  * the terms of the GNU General Public License, either version 2
   9  * of the License, or any later version.
  10  *
  11  * For the full copyright and license information, please read the
  12  * LICENSE.txt file that was distributed with this source code.
  13  *
  14  * The TYPO3 project - inspiring people to share!
  15  */
  16
  17 use Psr\Log\LoggerInterface;
  18 use Symfony\Component\Finder\Finder;
  19 use TYPO3\CMS\Backend\Configuration\TypoScript\ConditionMatching\ConditionMatcher as BackendConditionMatcher;
  20 use TYPO3\CMS\Core\Configuration\TypoScript\ConditionMatching\AbstractConditionMatcher;
  21 use TYPO3\CMS\Core\Log\LogManager;
  22 use TYPO3\CMS\Core\TimeTracker\TimeTracker;
  23 use TYPO3\CMS\Core\TypoScript\ExtendedTemplateService;
  24 use TYPO3\CMS\Core\Utility\GeneralUtility;
  25 use TYPO3\CMS\Core\Utility\MathUtility;
  26 use TYPO3\CMS\Core\Utility\PathUtility;
  27 use TYPO3\CMS\Frontend\Configuration\TypoScript\ConditionMatching\ConditionMatcher as FrontendConditionMatcher;
  28
  29 /**
  30  * The TypoScript parser
  31  */
  32 class TypoScriptParser
  33 {
  34     /**
  35      * TypoScript hierarchy being build during parsing.
  36      *
  37      * @var array
  38      */
  39     public $setup = [];
  40
  41     /**
  42      * Raw data, the input string exploded by LF
  43      *
  44      * @var array
  45      */
  46     public $raw;
  47
  48     /**
  49      * Pointer to entry in raw data array
  50      *
  51      * @var int
  52      */
  53     public $rawP;
  54
  55     /**
  56      * Holding the value of the last comment
  57      *
  58      * @var string
  59      */
  60     public $lastComment = '';
  61
  62     /**
  63      * Internally set, used as internal flag to create a multi-line comment (one of those like /* ... * /
  64      *
  65      * @var bool
  66      */
  67     public $commentSet = false;
  68
  69     /**
  70      * Internally set, when multiline value is accumulated
  71      *
  72      * @var bool
  73      */
  74     public $multiLineEnabled = false;
  75
  76     /**
  77      * Internally set, when multiline value is accumulated
  78      *
  79      * @var string
  80      */
  81     public $multiLineObject = '';
  82
  83     /**
  84      * Internally set, when multiline value is accumulated
  85      *
  86      * @var array
  87      */
  88     public $multiLineValue = [];
  89
  90     /**
  91      * Internally set, when in brace. Counter.
  92      *
  93      * @var int
  94      */
  95     public $inBrace = 0;
  96
  97     /**
  98      * For each condition this flag is set, if the condition is TRUE,
  99      * else it's cleared. Then it's used by the [ELSE] condition to determine if the next part should be parsed.
 100      *
 101      * @var bool
 102      */
 103     public $lastConditionTrue = true;
 104
 105     /**
 106      * Tracking all conditions found
 107      *
 108      * @var array
 109      */
 110     public $sections = [];
 111
 112     /**
 113      * Tracking all matching conditions found
 114      *
 115      * @var array
 116      */
 117     public $sectionsMatch = [];
 118
 119     /**
 120      * If set, then syntax highlight mode is on; Call the function syntaxHighlight() to use this function
 121      *
 122      * @var bool
 123      */
 124     public $syntaxHighLight = false;
 125
 126     /**
 127      * Syntax highlight data is accumulated in this array. Used by syntaxHighlight_print() to construct the output.
 128      *
 129      * @var array
 130      */
 131     public $highLightData = [];
 132
 133     /**
 134      * Syntax highlight data keeping track of the curly brace level for each line
 135      *
 136      * @var array
 137      */
 138     public $highLightData_bracelevel = [];
 139
 140     /**
 141      * DO NOT register the comments. This is default for the ordinary sitetemplate!
 142      *
 143      * @var bool
 144      */
 145     public $regComments = false;
 146
 147     /**
 148      * DO NOT register the linenumbers. This is default for the ordinary sitetemplate!
 149      *
 150      * @var bool
 151      */
 152     public $regLinenumbers = false;
 153
 154     /**
 155      * Error accumulation array.
 156      *
 157      * @var array
 158      */
 159     public $errors = [];
 160
 161     /**
 162      * Used for the error messages line number reporting. Set externally.
 163      *
 164      * @var int
 165      */
 166     public $lineNumberOffset = 0;
 167
 168     /**
 169      * Line for break point.
 170      *
 171      * @var int
 172      */
 173     public $breakPointLN = 0;
 174
 175     /**
 176      * @var array
 177      */
 178     public $highLightStyles = [
 179         'prespace' => ['<span class="ts-prespace">', '</span>'],
 180         // Space before any content on a line
 181         'objstr_postspace' => ['<span class="ts-objstr_postspace">', '</span>'],
 182         // Space after the object string on a line
 183         'operator_postspace' => ['<span class="ts-operator_postspace">', '</span>'],
 184         // Space after the operator on a line
 185         'operator' => ['<span class="ts-operator">', '</span>'],
 186         // The operator char
 187         'value' => ['<span class="ts-value">', '</span>'],
 188         // The value of a line
 189         'objstr' => ['<span class="ts-objstr">', '</span>'],
 190         // The object string of a line
 191         'value_copy' => ['<span class="ts-value_copy">', '</span>'],
 192         // The value when the copy syntax (<) is used; that means the object reference
 193         'value_unset' => ['<span class="ts-value_unset">', '</span>'],
 194         // The value when an object is unset. Should not exist.
 195         'ignored' => ['<span class="ts-ignored">', '</span>'],
 196         // The "rest" of a line which will be ignored.
 197         'default' => ['<span class="ts-default">', '</span>'],
 198         // The default style if none other is applied.
 199         'comment' => ['<span class="ts-comment">', '</span>'],
 200         // Comment lines
 201         'condition' => ['<span class="ts-condition">', '</span>'],
 202         // Conditions
 203         'error' => ['<span class="ts-error">', '</span>'],
 204         // Error messages
 205         'linenum' => ['<span class="ts-linenum">', '</span>']
 206     ];
 207
 208     /**
 209      * Additional attributes for the <span> tags for a blockmode line
 210      *
 211      * @var string
 212      */
 213     public $highLightBlockStyles = '';
 214
 215     /**
 216      * The hex-HTML color for the blockmode
 217      *
 218      * @var string
 219      */
 220     public $highLightBlockStyles_basecolor = '#cccccc';
 221
 222     /**
 223      * @var \TYPO3\CMS\Core\TypoScript\ExtendedTemplateService
 224      */
 225     public $parentObject;
 226
 227     /**
 228      * Start parsing the input TypoScript text piece. The result is stored in $this->setup
 229      *
 230      * @param string $string The TypoScript text
 231      * @param object|string $matchObj If is object, then this is used to match conditions found in the TypoScript code. If matchObj not specified, then no conditions will work! (Except [GLOBAL])
 232      */
 233     public function parse($string, $matchObj = '')
 234     {
 235         $this->raw = explode(LF, $string);
 236         $this->rawP = 0;
 237         $pre = '[GLOBAL]';
 238         while ($pre) {
 239             if ($this->breakPointLN && $pre === '[_BREAK]') {
 240                 $this->error('Breakpoint at ' . ($this->lineNumberOffset + $this->rawP - 2) . ': Line content was "' . $this->raw[$this->rawP - 2] . '"', 1);
 241                 break;
 242             }
 243             $preUppercase = strtoupper($pre);
 244             if ($pre[0] === '[' &&
 245                 ($preUppercase === '[GLOBAL]' ||
 246                     $preUppercase === '[END]' ||
 247                     !$this->lastConditionTrue && $preUppercase === '[ELSE]')
 248             ) {
 249                 $pre = trim($this->parseSub($this->setup));
 250                 $this->lastConditionTrue = 1;
 251             } else {
 252                 // We're in a specific section. Therefore we log this section
 253                 $specificSection = $preUppercase !== '[ELSE]';
 254                 if ($specificSection) {
 255                     $this->sections[md5($pre)] = $pre;
 256                 }
 257                 if (is_object($matchObj) && $matchObj->match($pre) || $this->syntaxHighLight) {
 258                     if ($specificSection) {
 259                         $this->sectionsMatch[md5($pre)] = $pre;
 260                     }
 261                     $pre = trim($this->parseSub($this->setup));
 262                     $this->lastConditionTrue = 1;
 263                 } else {
 264                     $pre = $this->nextDivider();
 265                     $this->lastConditionTrue = 0;
 266                 }
 267             }
 268         }
 269         if ($this->inBrace) {
 270             $this->error('Line ' . ($this->lineNumberOffset + $this->rawP - 1) . ': The script is short of ' . $this->inBrace . ' end brace(s)', 1);
 271         }
 272         if ($this->multiLineEnabled) {
 273             $this->error('Line ' . ($this->lineNumberOffset + $this->rawP - 1) . ': A multiline value section is not ended with a parenthesis!', 1);
 274         }
 275         $this->lineNumberOffset += count($this->raw) + 1;
 276     }
 277
 278     /**
 279      * Will search for the next condition. When found it will return the line content (the condition value) and have advanced the internal $this->rawP pointer to point to the next line after the condition.
 280      *
 281      * @return string The condition value
 282      * @see parse()
 283      */
 284     public function nextDivider()
 285     {
 286         while (isset($this->raw[$this->rawP])) {
 287             $line = trim($this->raw[$this->rawP]);
 288             $this->rawP++;
 289             if ($line && $line[0] === '[') {
 290                 return $line;
 291             }
 292         }
 293         return '';
 294     }
 295
 296     /**
 297      * Parsing the $this->raw TypoScript lines from pointer, $this->rawP
 298      *
 299      * @param array $setup Reference to the setup array in which to accumulate the values.
 300      * @return string|NULL Returns the string of the condition found, the exit signal or possible nothing (if it completed parsing with no interruptions)
 301      */
 302     public function parseSub(array &$setup)
 303     {
 304         while (isset($this->raw[$this->rawP])) {
 305             $line = ltrim($this->raw[$this->rawP]);
 306             $lineP = $this->rawP;
 307             $this->rawP++;
 308             if ($this->syntaxHighLight) {
 309                 $this->regHighLight('prespace', $lineP, strlen($line));
 310             }
 311             // Breakpoint?
 312             // By adding 1 we get that line processed
 313             if ($this->breakPointLN && $this->lineNumberOffset + $this->rawP - 1 === $this->breakPointLN + 1) {
 314                 return '[_BREAK]';
 315             }
 316             // Set comment flag?
 317             if (!$this->multiLineEnabled && strpos($line, '/*') === 0) {
 318                 $this->commentSet = 1;
 319             }
 320             // If $this->multiLineEnabled we will go and get the line values here because we know, the first if() will be TRUE.
 321             if (!$this->commentSet && ($line || $this->multiLineEnabled)) {
 322                 // If multiline is enabled. Escape by ')'
 323                 if ($this->multiLineEnabled) {
 324                     // Multiline ends...
 325                     if ($line[0] === ')') {
 326                         if ($this->syntaxHighLight) {
 327                             $this->regHighLight('operator', $lineP, strlen($line) - 1);
 328                         }
 329                         // Disable multiline
 330                         $this->multiLineEnabled = 0;
 331                         $theValue = implode($this->multiLineValue, LF);
 332                         if (strpos($this->multiLineObject, '.') !== false) {
 333                             // Set the value deeper.
 334                             $this->setVal($this->multiLineObject, $setup, [$theValue]);
 335                         } else {
 336                             // Set value regularly
 337                             $setup[$this->multiLineObject] = $theValue;
 338                             if ($this->lastComment && $this->regComments) {
 339                                 $setup[$this->multiLineObject . '..'] .= $this->lastComment;
 340                             }
 341                             if ($this->regLinenumbers) {
 342                                 $setup[$this->multiLineObject . '.ln..'][] = $this->lineNumberOffset + $this->rawP - 1;
 343                             }
 344                         }
 345                     } else {
 346                         if ($this->syntaxHighLight) {
 347                             $this->regHighLight('value', $lineP);
 348                         }
 349                         $this->multiLineValue[] = $this->raw[$this->rawP - 1];
 350                     }
 351                 } elseif ($this->inBrace === 0 && $line[0] === '[') {
 352                     // Beginning of condition (only on level zero compared to brace-levels
 353                     if ($this->syntaxHighLight) {
 354                         $this->regHighLight('condition', $lineP);
 355                     }
 356                     return $line;
 357                 } else {
 358                     // Return if GLOBAL condition is set - no matter what.
 359                     if ($line[0] === '[' && stripos($line, '[GLOBAL]') !== false) {
 360                         if ($this->syntaxHighLight) {
 361                             $this->regHighLight('condition', $lineP);
 362                         }
 363                         $this->error('Line ' . ($this->lineNumberOffset + $this->rawP - 1) . ': On return to [GLOBAL] scope, the script was short of ' . $this->inBrace . ' end brace(s)', 1);
 364                         $this->inBrace = 0;
 365                         return $line;
 366                     }
 367                     if ($line[0] !== '}' && $line[0] !== '#' && $line[0] !== '/') {
 368                         // If not brace-end or comment
 369                         // Find object name string until we meet an operator
 370                         $varL = strcspn($line, TAB . ' {=<>(');
 371                         // check for special ":=" operator
 372                         if ($varL > 0 && substr($line, $varL-1, 2) === ':=') {
 373                             --$varL;
 374                         }
 375                         // also remove tabs after the object string name
 376                         $objStrName = substr($line, 0, $varL);
 377                         if ($this->syntaxHighLight) {
 378                             $this->regHighLight('objstr', $lineP, strlen(substr($line, $varL)));
 379                         }
 380                         if ($objStrName !== '') {
 381                             $r = [];
 382                             if (preg_match('/[^[:alnum:]_\\\\\\.:-]/i', $objStrName, $r)) {
 383                                 $this->error('Line ' . ($this->lineNumberOffset + $this->rawP - 1) . ': Object Name String, "' . htmlspecialchars($objStrName) . '" contains invalid character "' . $r[0] . '". Must be alphanumeric or one of: "_:-\\."');
 384                             } else {
 385                                 $line = ltrim(substr($line, $varL));
 386                                 if ($this->syntaxHighLight) {
 387                                     $this->regHighLight('objstr_postspace', $lineP, strlen($line));
 388                                     if ($line !== '') {
 389                                         $this->regHighLight('operator', $lineP, strlen($line) - 1);
 390                                         $this->regHighLight('operator_postspace', $lineP, strlen(ltrim(substr($line, 1))));
 391                                     }
 392                                 }
 393                                 if ($line === '') {
 394                                     $this->error('Line ' . ($this->lineNumberOffset + $this->rawP - 1) . ': Object Name String, "' . htmlspecialchars($objStrName) . '" was not followed by any operator, =<>({');
 395                                 } else {
 396                                     // Checking for special TSparser properties (to change TS values at parsetime)
 397                                     $match = [];
 398                                     if ($line[0] === ':' && preg_match('/^:=\\s*([[:alpha:]]+)\\s*\\((.*)\\).*/', $line, $match)) {
 399                                         $tsFunc = $match[1];
 400                                         $tsFuncArg = $match[2];
 401                                         list($currentValue) = $this->getVal($objStrName, $setup);
 402                                         $tsFuncArg = str_replace(['\\\\', '\\n', '\\t'], ['\\', LF, TAB], $tsFuncArg);
 403                                         $newValue = $this->executeValueModifier($tsFunc, $tsFuncArg, $currentValue);
 404                                         if (isset($newValue)) {
 405                                             $line = '= ' . $newValue;
 406                                         }
 407                                     }
 408                                     switch ($line[0]) {
 409                                         case '=':
 410                                             if ($this->syntaxHighLight) {
 411                                                 $this->regHighLight('value', $lineP, strlen(ltrim(substr($line, 1))) - strlen(trim(substr($line, 1))));
 412                                             }
 413                                             if (strpos($objStrName, '.') !== false) {
 414                                                 $value = [];
 415                                                 $value[0] = trim(substr($line, 1));
 416                                                 $this->setVal($objStrName, $setup, $value);
 417                                             } else {
 418                                                 $setup[$objStrName] = trim(substr($line, 1));
 419                                                 if ($this->lastComment && $this->regComments) {
 420                                                     // Setting comment..
 421                                                     $setup[$objStrName . '..'] .= $this->lastComment;
 422                                                 }
 423                                                 if ($this->regLinenumbers) {
 424                                                     $setup[$objStrName . '.ln..'][] = $this->lineNumberOffset + $this->rawP - 1;
 425                                                 }
 426                                             }
 427                                             break;
 428                                         case '{':
 429                                             $this->inBrace++;
 430                                             if (strpos($objStrName, '.') !== false) {
 431                                                 $exitSig = $this->rollParseSub($objStrName, $setup);
 432                                                 if ($exitSig) {
 433                                                     return $exitSig;
 434                                                 }
 435                                             } else {
 436                                                 if (!isset($setup[$objStrName . '.'])) {
 437                                                     $setup[$objStrName . '.'] = [];
 438                                                 }
 439                                                 $exitSig = $this->parseSub($setup[$objStrName . '.']);
 440                                                 if ($exitSig) {
 441                                                     return $exitSig;
 442                                                 }
 443                                             }
 444                                             break;
 445                                         case '(':
 446                                             $this->multiLineObject = $objStrName;
 447                                             $this->multiLineEnabled = 1;
 448                                             $this->multiLineValue = [];
 449                                             break;
 450                                         case '<':
 451                                             if ($this->syntaxHighLight) {
 452                                                 $this->regHighLight('value_copy', $lineP, strlen(ltrim(substr($line, 1))) - strlen(trim(substr($line, 1))));
 453                                             }
 454                                             $theVal = trim(substr($line, 1));
 455                                             if ($theVal[0] === '.') {
 456                                                 $res = $this->getVal(substr($theVal, 1), $setup);
 457                                             } else {
 458                                                 $res = $this->getVal($theVal, $this->setup);
 459                                             }
 460                                             // unserialize(serialize(...)) may look stupid but is needed because of some reference issues.
 461                                             // See forge issue #76919 and functional test hasFlakyReferences()
 462                                             $this->setVal($objStrName, $setup, unserialize(serialize($res)), 1);
 463                                             break;
 464                                         case '>':
 465                                             if ($this->syntaxHighLight) {
 466                                                 $this->regHighLight('value_unset', $lineP, strlen(ltrim(substr($line, 1))) - strlen(trim(substr($line, 1))));
 467                                             }
 468                                             $this->setVal($objStrName, $setup, 'UNSET');
 469                                             break;
 470                                         default:
 471                                             $this->error('Line ' . ($this->lineNumberOffset + $this->rawP - 1) . ': Object Name String, "' . htmlspecialchars($objStrName) . '" was not followed by any operator, =<>({');
 472                                     }
 473                                 }
 474                             }
 475                             $this->lastComment = '';
 476                         }
 477                     } elseif ($line[0] === '}') {
 478                         $this->inBrace--;
 479                         $this->lastComment = '';
 480                         if ($this->syntaxHighLight) {
 481                             $this->regHighLight('operator', $lineP, strlen($line) - 1);
 482                         }
 483                         if ($this->inBrace < 0) {
 484                             $this->error('Line ' . ($this->lineNumberOffset + $this->rawP - 1) . ': An end brace is in excess.', 1);
 485                             $this->inBrace = 0;
 486                         } else {
 487                             break;
 488                         }
 489                     } else {
 490                         if ($this->syntaxHighLight) {
 491                             $this->regHighLight('comment', $lineP);
 492                         }
 493                         // Comment. The comments are concatenated in this temporary string:
 494                         if ($this->regComments) {
 495                             $this->lastComment .= rtrim($line) . LF;
 496                         }
 497                     }
 498                     if (strpos($line, '### ERROR') === 0) {
 499                         $this->error(substr($line, 11));
 500                     }
 501                 }
 502             }
 503             // Unset comment
 504             if ($this->commentSet) {
 505                 if ($this->syntaxHighLight) {
 506                     $this->regHighLight('comment', $lineP);
 507                 }
 508                 if (strpos($line, '*/') === 0) {
 509                     $this->commentSet = 0;
 510                 }
 511             }
 512         }
 513         return null;
 514     }
 515
 516     /**
 517      * Executes operator functions, called from TypoScript
 518      * example: page.10.value := appendString(!)
 519      *
 520      * @param string $modifierName TypoScript function called
 521      * @param string $modifierArgument Function arguments; In case of multiple arguments, the method must split on its own
 522      * @param string $currentValue Current TypoScript value
 523      * @return string Modification result
 524      */
 525     protected function executeValueModifier($modifierName, $modifierArgument = null, $currentValue = null)
 526     {
 527         $newValue = null;
 528         switch ($modifierName) {
 529             case 'prependString':
 530                 $newValue = $modifierArgument . $currentValue;
 531                 break;
 532             case 'appendString':
 533                 $newValue = $currentValue . $modifierArgument;
 534                 break;
 535             case 'removeString':
 536                 $newValue = str_replace($modifierArgument, '', $currentValue);
 537                 break;
 538             case 'replaceString':
 539                 list($fromStr, $toStr) = explode('|', $modifierArgument, 2);
 540                 $newValue = str_replace($fromStr, $toStr, $currentValue);
 541                 break;
 542             case 'addToList':
 543                 $newValue = ((string)$currentValue !== '' ? $currentValue . ',' : '') . $modifierArgument;
 544                 break;
 545             case 'removeFromList':
 546                 $existingElements = GeneralUtility::trimExplode(',', $currentValue);
 547                 $removeElements = GeneralUtility::trimExplode(',', $modifierArgument);
 548                 if (!empty($removeElements)) {
 549                     $newValue = implode(',', array_diff($existingElements, $removeElements));
 550                 }
 551                 break;
 552             case 'uniqueList':
 553                 $elements = GeneralUtility::trimExplode(',', $currentValue);
 554                 $newValue = implode(',', array_unique($elements));
 555                 break;
 556             case 'reverseList':
 557                 $elements = GeneralUtility::trimExplode(',', $currentValue);
 558                 $newValue = implode(',', array_reverse($elements));
 559                 break;
 560             case 'sortList':
 561                 $elements = GeneralUtility::trimExplode(',', $currentValue);
 562                 $arguments = GeneralUtility::trimExplode(',', $modifierArgument);
 563                 $arguments = array_map('strtolower', $arguments);
 564                 $sort_flags = SORT_REGULAR;
 565                 if (in_array('numeric', $arguments)) {
 566                     $sort_flags = SORT_NUMERIC;
 567                     // If the sorting modifier "numeric" is given, all values
 568                     // are checked and an exception is thrown if a non-numeric value is given
 569                     // otherwise there is a different behaviour between PHP7 and PHP 5.x
 570                     // See also the warning on http://us.php.net/manual/en/function.sort.php
 571                     foreach ($elements as $element) {
 572                         if (!is_numeric($element)) {
 573                             throw new \InvalidArgumentException('The list "' . $currentValue . '" should be sorted numerically but contains a non-numeric value', 1438191758);
 574                         }
 575                     }
 576                 }
 577                 sort($elements, $sort_flags);
 578                 if (in_array('descending', $arguments)) {
 579                     $elements = array_reverse($elements);
 580                 }
 581                 $newValue = implode(',', $elements);
 582                 break;
 583             default:
 584                 if (isset($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_tsparser.php']['preParseFunc'][$modifierName])) {
 585                     $hookMethod = $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_tsparser.php']['preParseFunc'][$modifierName];
 586                     $params = ['currentValue' => $currentValue, 'functionArgument' => $modifierArgument];
 587                     $fakeThis = false;
 588                     $newValue = GeneralUtility::callUserFunction($hookMethod, $params, $fakeThis);
 589                 } else {
 590                     $this->getLogger()->warning('Missing function definition for ' . $modifierName . ' on TypoScript');
 591                 }
 592         }
 593         return $newValue;
 594     }
 595
 596     /**
 597      * Parsing of TypoScript keys inside a curly brace where the key is composite of at least two keys,
 598      * thus having to recursively call itself to get the value
 599      *
 600      * @param string $string The object sub-path, eg "thisprop.another_prot
 601      * @param array $setup The local setup array from the function calling this function
 602      * @return string Returns the exitSignal
 603      * @see parseSub()
 604      */
 605     public function rollParseSub($string, array &$setup)
 606     {
 607         if ((string)$string === '') {
 608             return '';
 609         }
 610
 611         list($key, $remainingKey) = $this->parseNextKeySegment($string);
 612         $key .= '.';
 613         if (!isset($setup[$key])) {
 614             $setup[$key] = [];
 615         }
 616         $exitSig = $remainingKey === ''
 617             ? $this->parseSub($setup[$key])
 618             : $this->rollParseSub($remainingKey, $setup[$key]);
 619         return $exitSig ?: '';
 620     }
 621
 622     /**
 623      * Get a value/property pair for an object path in TypoScript, eg. "myobject.myvalue.mysubproperty".
 624      * Here: Used by the "copy" operator, <
 625      *
 626      * @param string $string Object path for which to get the value
 627      * @param array $setup Global setup code if $string points to a global object path. But if string is prefixed with "." then its the local setup array.
 628      * @return array An array with keys 0/1 being value/property respectively
 629      */
 630     public function getVal($string, $setup)
 631     {
 632         if ((string)$string === '') {
 633             return [];
 634         }
 635
 636         list($key, $remainingKey) = $this->parseNextKeySegment($string);
 637         $subKey = $key . '.';
 638         if ($remainingKey === '') {
 639             $retArr = [];
 640             if (isset($setup[$key])) {
 641                 $retArr[0] = $setup[$key];
 642             }
 643             if (isset($setup[$subKey])) {
 644                 $retArr[1] = $setup[$subKey];
 645             }
 646             return $retArr;
 647         }
 648         if ($setup[$subKey]) {
 649             return $this->getVal($remainingKey, $setup[$subKey]);
 650         }
 651
 652         return [];
 653     }
 654
 655     /**
 656      * Setting a value/property of an object string in the setup array.
 657      *
 658      * @param string $string The object sub-path, eg "thisprop.another_prot
 659      * @param array $setup The local setup array from the function calling this function.
 660      * @param array|string $value The value/property pair array to set. If only one of them is set, then the other is not touched (unless $wipeOut is set, which it is when copies are made which must include both value and property)
 661      * @param bool $wipeOut If set, then both value and property is wiped out when a copy is made of another value.
 662      */
 663     public function setVal($string, array &$setup, $value, $wipeOut = false)
 664     {
 665         if ((string)$string === '') {
 666             return;
 667         }
 668
 669         list($key, $remainingKey) = $this->parseNextKeySegment($string);
 670         $subKey = $key . '.';
 671         if ($remainingKey === '') {
 672             if ($value === 'UNSET') {
 673                 unset($setup[$key]);
 674                 unset($setup[$subKey]);
 675                 if ($this->regLinenumbers) {
 676                     $setup[$key . '.ln..'][] = ($this->lineNumberOffset + $this->rawP - 1) . '>';
 677                 }
 678             } else {
 679                 $lnRegisDone = 0;
 680                 if ($wipeOut) {
 681                     unset($setup[$key]);
 682                     unset($setup[$subKey]);
 683                     if ($this->regLinenumbers) {
 684                         $setup[$key . '.ln..'][] = ($this->lineNumberOffset + $this->rawP - 1) . '<';
 685                         $lnRegisDone = 1;
 686                     }
 687                 }
 688                 if (isset($value[0])) {
 689                     $setup[$key] = $value[0];
 690                 }
 691                 if (isset($value[1])) {
 692                     $setup[$subKey] = $value[1];
 693                 }
 694                 if ($this->lastComment && $this->regComments) {
 695                     $setup[$key . '..'] .= $this->lastComment;
 696                 }
 697                 if ($this->regLinenumbers && !$lnRegisDone) {
 698                     $setup[$key . '.ln..'][] = $this->lineNumberOffset + $this->rawP - 1;
 699                 }
 700             }
 701         } else {
 702             if (!isset($setup[$subKey])) {
 703                 $setup[$subKey] = [];
 704             }
 705             $this->setVal($remainingKey, $setup[$subKey], $value);
 706         }
 707     }
 708
 709     /**
 710      * Determines the first key segment of a TypoScript key by searching for the first
 711      * unescaped dot in the given key string.
 712      *
 713      * Since the escape characters are only needed to correctly determine the key
 714      * segment any escape characters before the first unescaped dot are
 715      * stripped from the key.
 716      *
 717      * @param string $key The key, possibly consisting of multiple key segments separated by unescaped dots
 718      * @return array Array with key segment and remaining part of $key
 719      */
 720     protected function parseNextKeySegment($key)
 721     {
 722         // if no dot is in the key, nothing to do
 723         $dotPosition = strpos($key, '.');
 724         if ($dotPosition === false) {
 725             return [$key, ''];
 726         }
 727
 728         if (strpos($key, '\\') !== false) {
 729             // backslashes are in the key, so we do further parsing
 730
 731             while ($dotPosition !== false) {
 732                 if ($dotPosition > 0 && $key[$dotPosition - 1] !== '\\' || $dotPosition > 1 && $key[$dotPosition - 2] === '\\') {
 733                     break;
 734                 }
 735                 // escaped dot found, continue
 736                 $dotPosition = strpos($key, '.', $dotPosition + 1);
 737             }
 738
 739             if ($dotPosition === false) {
 740                 // no regular dot found
 741                 $keySegment = $key;
 742                 $remainingKey = '';
 743             } else {
 744                 if ($dotPosition > 1 && $key[$dotPosition - 2] === '\\' && $key[$dotPosition - 1] === '\\') {
 745                     $keySegment = substr($key, 0, $dotPosition - 1);
 746                 } else {
 747                     $keySegment = substr($key, 0, $dotPosition);
 748                 }
 749                 $remainingKey = substr($key, $dotPosition + 1);
 750             }
 751
 752             // fix key segment by removing escape sequences
 753             $keySegment = str_replace('\\.', '.', $keySegment);
 754         } else {
 755             // no backslash in the key, we're fine off
 756             list($keySegment, $remainingKey) = explode('.', $key, 2);
 757         }
 758         return [$keySegment, $remainingKey];
 759     }
 760
 761     /**
 762      * Stacks errors/messages from the TypoScript parser into an internal array, $this->error
 763      * If "TT" is a global object (as it is in the frontend when backend users are logged in) the message will be registered here as well.
 764      *
 765      * @param string $err The error message string
 766      * @param int $num The error severity (in the scale of TimeTracker::setTSlogMessage: Approx: 2=warning, 1=info, 0=nothing, 3=fatal.)
 767      */
 768     public function error($err, $num = 2)
 769     {
 770         $tt = $this->getTimeTracker();
 771         if ($tt !== null) {
 772             $tt->setTSlogMessage($err, $num);
 773         }
 774         $this->errors[] = [$err, $num, $this->rawP - 1, $this->lineNumberOffset];
 775     }
 776
 777     /**
 778      * Checks the input string (un-parsed TypoScript) for include-commands ("<INCLUDE_TYPOSCRIPT: ....")
 779      * Use: \TYPO3\CMS\Core\TypoScript\Parser\TypoScriptParser::checkIncludeLines()
 780      *
 781      * @param string $string Unparsed TypoScript
 782      * @param int $cycle_counter Counter for detecting endless loops
 783      * @param bool $returnFiles When set an array containing the resulting typoscript and all included files will get returned
 784      * @param string $parentFilenameOrPath The parent file (with absolute path) or path for relative includes
 785      * @return string Complete TypoScript with includes added.
 786      * @static
 787      */
 788     public static function checkIncludeLines($string, $cycle_counter = 1, $returnFiles = false, $parentFilenameOrPath = '')
 789     {
 790         $includedFiles = [];
 791         if ($cycle_counter > 100) {
 792             self::getLogger()->warning('It appears like TypoScript code is looping over itself. Check your templates for "<INCLUDE_TYPOSCRIPT: ..." tags');
 793             if ($returnFiles) {
 794                 return [
 795                     'typoscript' => '',
 796                     'files' => $includedFiles
 797                 ];
 798             }
 799             return '
 800 ###
 801 ### ERROR: Recursion!
 802 ###
 803 ';
 804         }
 805
 806         // Checking for @import syntax imported files
 807         $string = self::addImportsFromExternalFiles($string, $cycle_counter, $returnFiles, $includedFiles, $parentFilenameOrPath);
 808
 809         // If no tags found, no need to do slower preg_split
 810         if (strpos($string, '<INCLUDE_TYPOSCRIPT:') !== false) {
 811             $splitRegEx = '/\r?\n\s*<INCLUDE_TYPOSCRIPT:\s*(?i)source\s*=\s*"((?i)file|dir):\s*([^"]*)"(.*)>[\ \t]*/';
 812             $parts = preg_split($splitRegEx, LF . $string . LF, -1, PREG_SPLIT_DELIM_CAPTURE);
 813             // First text part goes through
 814             $newString = $parts[0] . LF;
 815             $partCount = count($parts);
 816             for ($i = 1; $i + 3 < $partCount; $i += 4) {
 817                 // $parts[$i] contains 'FILE' or 'DIR'
 818                 // $parts[$i+1] contains relative file or directory path to be included
 819                 // $parts[$i+2] optional properties of the INCLUDE statement
 820                 // $parts[$i+3] next part of the typoscript string (part in between include-tags)
 821                 $includeType = $parts[$i];
 822                 $filename = $parts[$i + 1];
 823                 $originalFilename = $filename;
 824                 $optionalProperties = $parts[$i + 2];
 825                 $tsContentsTillNextInclude = $parts[$i + 3];
 826
 827                 // Check condition
 828                 $matches = preg_split('#(?i)condition\\s*=\\s*"((?:\\\\\\\\|\\\\"|[^\\"])*)"(\\s*|>)#', $optionalProperties, 2, PREG_SPLIT_DELIM_CAPTURE);
 829                 // If there was a condition
 830                 if (count($matches) > 1) {
 831                     // Unescape the condition
 832                     $condition = trim(stripslashes($matches[1]));
 833                     // If necessary put condition in square brackets
 834                     if ($condition[0] !== '[') {
 835                         $condition = '[' . $condition . ']';
 836                     }
 837
 838                     /** @var AbstractConditionMatcher $conditionMatcher */
 839                     $conditionMatcher = null;
 840                     if (TYPO3_REQUESTTYPE & TYPO3_REQUESTTYPE_FE) {
 841                         $conditionMatcher = GeneralUtility::makeInstance(FrontendConditionMatcher::class);
 842                     } else {
 843                         $conditionMatcher = GeneralUtility::makeInstance(BackendConditionMatcher::class);
 844                     }
 845
 846                     // If it didn't match then proceed to the next include, but prepend next normal (not file) part to output string
 847                     if (!$conditionMatcher->match($condition)) {
 848                         $newString .= $tsContentsTillNextInclude . LF;
 849                         continue;
 850                     }
 851                 }
 852
 853                 // Resolve a possible relative paths if a parent file is given
 854                 if ($parentFilenameOrPath !== '' && $filename[0] === '.') {
 855                     $filename = PathUtility::getAbsolutePathOfRelativeReferencedFileOrPath($parentFilenameOrPath, $filename);
 856                 }
 857
 858                 // There must be a line-break char after - not sure why this check is necessary, kept it for being 100% backwards compatible
 859                 // An empty string is also ok (means that the next line is also a valid include_typoscript tag)
 860                 if (!preg_match('/(^\\s*\\r?\\n|^$)/', $tsContentsTillNextInclude)) {
 861                     $newString .= self::typoscriptIncludeError('Invalid characters after <INCLUDE_TYPOSCRIPT: source="' . $includeType . ':' . $filename . '">-tag (rest of line must be empty).');
 862                 } elseif (strpos('..', $filename) !== false) {
 863                     $newString .= self::typoscriptIncludeError('Invalid filepath "' . $filename . '" (containing "..").');
 864                 } else {
 865                     switch (strtolower($includeType)) {
 866                         case 'file':
 867                             self::includeFile($originalFilename, $cycle_counter, $returnFiles, $newString, $includedFiles, $optionalProperties, $parentFilenameOrPath);
 868                             break;
 869                         case 'dir':
 870                             self::includeDirectory($originalFilename, $cycle_counter, $returnFiles, $newString, $includedFiles, $optionalProperties, $parentFilenameOrPath);
 871                             break;
 872                         default:
 873                             $newString .= self::typoscriptIncludeError('No valid option for INCLUDE_TYPOSCRIPT source property (valid options are FILE or DIR)');
 874                     }
 875                 }
 876                 // Prepend next normal (not file) part to output string
 877                 $newString .= $tsContentsTillNextInclude . LF;
 878
 879                 // load default TypoScript for content rendering templates like
 880                 // fluid_styled_content if those have been included through f.e.
 881                 // <INCLUDE_TYPOSCRIPT: source="FILE:EXT:fluid_styled_content/Configuration/TypoScript/setup.txt">
 882                 if (strpos(strtolower($filename), 'ext:') === 0) {
 883                     $filePointerPathParts = explode('/', substr($filename, 4));
 884
 885                     // remove file part, determine whether to load setup or constants
 886                     list($includeType, ) = explode('.', array_pop($filePointerPathParts));
 887
 888                     if (in_array($includeType, ['setup', 'constants'])) {
 889                         // adapt extension key to required format (no underscores)
 890                         $filePointerPathParts[0] = str_replace('_', '', $filePointerPathParts[0]);
 891
 892                         // load default TypoScript
 893                         $defaultTypoScriptKey = implode('/', $filePointerPathParts) . '/';
 894                         if (in_array($defaultTypoScriptKey, $GLOBALS['TYPO3_CONF_VARS']['FE']['contentRenderingTemplates'], true)) {
 895                             $newString .= $GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_' . $includeType . '.']['defaultContentRendering'];
 896                         }
 897                     }
 898                 }
 899             }
 900             // Add a line break before and after the included code in order to make sure that the parser always has a LF.
 901             $string = LF . trim($newString) . LF;
 902         }
 903         // When all included files should get returned, simply return an compound array containing
 904         // the TypoScript with all "includes" processed and the files which got included
 905         if ($returnFiles) {
 906             return [
 907                 'typoscript' => $string,
 908                 'files' => $includedFiles
 909             ];
 910         }
 911         return $string;
 912     }
 913
 914     /**
 915      * Splits the unparsed TypoScript content into @import statements
 916      *
 917      * @param string $typoScript unparsed TypoScript
 918      * @param int $cycleCounter counter to stop recursion
 919      * @param bool $returnFiles whether to populate the included Files or not
 920      * @param array $includedFiles - by reference - if any included files are added, they are added here
 921      * @param string $parentFilenameOrPath the current imported file to resolve relative paths - handled by reference
 922      * @return string the unparsed TypoScript with included external files
 923      */
 924     protected static function addImportsFromExternalFiles($typoScript, $cycleCounter, $returnFiles, &$includedFiles, &$parentFilenameOrPath)
 925     {
 926         // Check for new syntax "@import 'EXT:bennilove/Configuration/TypoScript/*'"
 927         if (strpos($typoScript, '@import \'') !== false || strpos($typoScript, '@import "') !== false) {
 928             $splitRegEx = '/\r?\n\s*@import\s[\'"]([^\'"]*)[\'"][\ \t]?/';
 929             $parts = preg_split($splitRegEx, LF . $typoScript . LF, -1, PREG_SPLIT_DELIM_CAPTURE);
 930             // First text part goes through
 931             $newString = $parts[0] . LF;
 932             $partCount = count($parts);
 933             for ($i = 1; $i + 2 <= $partCount; $i += 2) {
 934                 $filename = $parts[$i];
 935                 $tsContentsTillNextInclude = $parts[$i + 1];
 936                 // Resolve a possible relative paths if a parent file is given
 937                 if ($parentFilenameOrPath !== '' && $filename[0] === '.') {
 938                     $filename = PathUtility::getAbsolutePathOfRelativeReferencedFileOrPath($parentFilenameOrPath, $filename);
 939                 }
 940                 $newString .= self::importExternalTypoScriptFile($filename, $cycleCounter, $returnFiles, $includedFiles);
 941                 // Prepend next normal (not file) part to output string
 942                 $newString .= $tsContentsTillNextInclude;
 943             }
 944             // Add a line break before and after the included code in order to make sure that the parser always has a LF.
 945             $typoScript = LF . trim($newString) . LF;
 946         }
 947         return $typoScript;
 948     }
 949
 950     /**
 951      * Include file $filename. Contents of the file will be returned, filename is added to &$includedFiles.
 952      * Further include/import statements in the contents are processed recursively.
 953      *
 954      * @param string $filename Full absolute path+filename to the typoscript file to be included
 955      * @param int $cycleCounter Counter for detecting endless loops
 956      * @param bool $returnFiles When set, filenames of included files will be prepended to the array &$includedFiles
 957      * @param array &$includedFiles Array to which the filenames of included files will be prepended (referenced)
 958      * @return string the unparsed TypoScript content from external files
 959      */
 960     protected static function importExternalTypoScriptFile($filename, $cycleCounter, $returnFiles, array &$includedFiles)
 961     {
 962         if (strpos('..', $filename) !== false) {
 963             return self::typoscriptIncludeError('Invalid filepath "' . $filename . '" (containing "..").');
 964         }
 965
 966         $content = '';
 967         $absoluteFileName = GeneralUtility::getFileAbsFileName($filename);
 968         if ((string)$absoluteFileName === '') {
 969             return self::typoscriptIncludeError('Illegal filepath "' . $filename . '".');
 970         }
 971
 972         $finder = new Finder();
 973         $finder
 974             // no recursive mode on purpose
 975             ->depth(0)
 976             // no directories should be fetched
 977             ->files()
 978             ->sortByName();
 979
 980         // Search all files in the folder
 981         if (is_dir($absoluteFileName)) {
 982             $finder->in($absoluteFileName);
 983             // Used for the TypoScript comments
 984             $readableFilePrefix = $filename;
 985         } else {
 986             // Apparently this is not a folder, so the restriction
 987             // is the folder so we restrict into this folder
 988             $finder->in(dirname($absoluteFileName));
 989             if (!is_file($absoluteFileName)
 990                 && strpos(basename($absoluteFileName), '*') === false
 991                 && substr(basename($absoluteFileName), -11) !== '.typoscript') {
 992                 $absoluteFileName .= '*.typoscript';
 993             }
 994             $finder->name(basename($absoluteFileName));
 995             $readableFilePrefix = dirname($filename);
 996         }
 997
 998         foreach ($finder as $fileObject) {
 999             // Clean filename output for comments
1000             $readableFileName = rtrim($readableFilePrefix, '/') . '/' . $fileObject->getFilename();
1001             $content .= '### @import \'' . $readableFileName . '\' begin ###' . LF;
1002             // Check for allowed files
1003             if (!GeneralUtility::verifyFilenameAgainstDenyPattern($fileObject->getFilename())) {
1004                 $content .= self::typoscriptIncludeError('File "' . $readableFileName . '" was not included since it is not allowed due to fileDenyPattern.');
1005             } else {
1006                 $includedFiles[] = $fileObject->getPathname();
1007                 // check for includes in included text
1008                 $included_text = self::checkIncludeLines($fileObject->getContents(), $cycleCounter++, $returnFiles, $absoluteFileName);
1009                 // If the method also has to return all included files, merge currently included
1010                 // files with files included by recursively calling itself
1011                 if ($returnFiles && is_array($included_text)) {
1012                     $includedFiles = array_merge($includedFiles, $included_text['files']);
1013                     $included_text = $included_text['typoscript'];
1014                 }
1015                 $content .= $included_text . LF;
1016             }
1017             $content .= '### @import \'' . $readableFileName . '\' end ###' . LF;
1018
1019             // load default TypoScript for content rendering templates like
1020             // fluid_styled_content if those have been included through e.g.
1021             // @import "fluid_styled_content/Configuration/TypoScript/setup.typoscript"
1022             if (strpos(strtoupper($filename), 'EXT:') === 0) {
1023                 $filePointerPathParts = explode('/', substr($filename, 4));
1024                 // remove file part, determine whether to load setup or constants
1025                 list($includeType) = explode('.', array_pop($filePointerPathParts));
1026
1027                 if (in_array($includeType, ['setup', 'constants'], true)) {
1028                     // adapt extension key to required format (no underscores)
1029                     $filePointerPathParts[0] = str_replace('_', '', $filePointerPathParts[0]);
1030
1031                     // load default TypoScript
1032                     $defaultTypoScriptKey = implode('/', $filePointerPathParts) . '/';
1033                     if (in_array($defaultTypoScriptKey, $GLOBALS['TYPO3_CONF_VARS']['FE']['contentRenderingTemplates'], true)) {
1034                         $content .= $GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_' . $includeType . '.']['defaultContentRendering'];
1035                     }
1036                 }
1037             }
1038         }
1039
1040         if (empty($content)) {
1041             return self::typoscriptIncludeError('No file or folder found for importing TypoScript on "' . $filename . '".');
1042         }
1043         return $content;
1044     }
1045
1046     /**
1047      * Include file $filename. Contents of the file will be prepended to &$newstring, filename to &$includedFiles
1048      * Further include_typoscript tags in the contents are processed recursively
1049      *
1050      * @param string $filename Relative path to the typoscript file to be included
1051      * @param int $cycle_counter Counter for detecting endless loops
1052      * @param bool $returnFiles When set, filenames of included files will be prepended to the array &$includedFiles
1053      * @param string &$newString The output string to which the content of the file will be prepended (referenced
1054      * @param array &$includedFiles Array to which the filenames of included files will be prepended (referenced)
1055      * @param string $optionalProperties
1056      * @param string $parentFilenameOrPath The parent file (with absolute path) or path for relative includes
1057      * @static
1058      */
1059     public static function includeFile($filename, $cycle_counter = 1, $returnFiles = false, &$newString = '', array &$includedFiles = [], $optionalProperties = '', $parentFilenameOrPath = '')
1060     {
1061         // Resolve a possible relative paths if a parent file is given
1062         if ($parentFilenameOrPath !== '' && $filename[0] === '.') {
1063             $absfilename = PathUtility::getAbsolutePathOfRelativeReferencedFileOrPath($parentFilenameOrPath, $filename);
1064         } else {
1065             $absfilename = $filename;
1066         }
1067         $absfilename = GeneralUtility::getFileAbsFileName($absfilename);
1068
1069         $newString .= LF . '### <INCLUDE_TYPOSCRIPT: source="FILE:' . $filename . '"' . $optionalProperties . '> BEGIN:' . LF;
1070         if ((string)$filename !== '') {
1071             // Must exist and must not contain '..' and must be relative
1072             // Check for allowed files
1073             if (!GeneralUtility::verifyFilenameAgainstDenyPattern($absfilename)) {
1074                 $newString .= self::typoscriptIncludeError('File "' . $filename . '" was not included since it is not allowed due to fileDenyPattern.');
1075             } elseif (!@file_exists($absfilename)) {
1076                 $newString .= self::typoscriptIncludeError('File "' . $filename . '" was not found.');
1077             } else {
1078                 $includedFiles[] = $absfilename;
1079                 // check for includes in included text
1080                 $included_text = self::checkIncludeLines(file_get_contents($absfilename), $cycle_counter + 1, $returnFiles, $absfilename);
1081                 // If the method also has to return all included files, merge currently included
1082                 // files with files included by recursively calling itself
1083                 if ($returnFiles && is_array($included_text)) {
1084                     $includedFiles = array_merge($includedFiles, $included_text['files']);
1085                     $included_text = $included_text['typoscript'];
1086                 }
1087                 $newString .= $included_text . LF;
1088             }
1089         }
1090         $newString .= '### <INCLUDE_TYPOSCRIPT: source="FILE:' . $filename . '"' . $optionalProperties . '> END:' . LF . LF;
1091     }
1092
1093     /**
1094      * Include all files with matching Typoscript extensions in directory $dirPath. Contents of the files are
1095      * prepended to &$newstring, filename to &$includedFiles.
1096      * Order of the directory items to be processed: files first, then directories, both in alphabetical order.
1097      * Further include_typoscript tags in the contents of the files are processed recursively.
1098      *
1099      * @param string $dirPath Relative path to the directory to be included
1100      * @param int $cycle_counter Counter for detecting endless loops
1101      * @param bool $returnFiles When set, filenames of included files will be prepended to the array &$includedFiles
1102      * @param string &$newString The output string to which the content of the file will be prepended (referenced)
1103      * @param array &$includedFiles Array to which the filenames of included files will be prepended (referenced)
1104      * @param string $optionalProperties
1105      * @param string $parentFilenameOrPath The parent file (with absolute path) or path for relative includes
1106      * @static
1107      */
1108     protected static function includeDirectory($dirPath, $cycle_counter = 1, $returnFiles = false, &$newString = '', array &$includedFiles = [], $optionalProperties = '', $parentFilenameOrPath = '')
1109     {
1110         // Extract the value of the property extensions="..."
1111         $matches = preg_split('#(?i)extensions\s*=\s*"([^"]*)"(\s*|>)#', $optionalProperties, 2, PREG_SPLIT_DELIM_CAPTURE);
1112         if (count($matches) > 1) {
1113             $includedFileExtensions = $matches[1];
1114         } else {
1115             $includedFileExtensions = '';
1116         }
1117
1118         // Resolve a possible relative paths if a parent file is given
1119         if ($parentFilenameOrPath !== '' && $dirPath[0] === '.') {
1120             $resolvedDirPath = PathUtility::getAbsolutePathOfRelativeReferencedFileOrPath($parentFilenameOrPath, $dirPath);
1121         } else {
1122             $resolvedDirPath = $dirPath;
1123         }
1124         $absDirPath = GeneralUtility::getFileAbsFileName($resolvedDirPath);
1125         if ($absDirPath) {
1126             $absDirPath = rtrim($absDirPath, '/') . '/';
1127             $newString .= LF . '### <INCLUDE_TYPOSCRIPT: source="DIR:' . $dirPath . '"' . $optionalProperties . '> BEGIN:' . LF;
1128             // Get alphabetically sorted file index in array
1129             $fileIndex = GeneralUtility::getAllFilesAndFoldersInPath([], $absDirPath, $includedFileExtensions);
1130             // Prepend file contents to $newString
1131             $prefixLength = strlen(PATH_site);
1132             foreach ($fileIndex as $absFileRef) {
1133                 $relFileRef = substr($absFileRef, $prefixLength);
1134                 self::includeFile($relFileRef, $cycle_counter, $returnFiles, $newString, $includedFiles, '', $absDirPath);
1135             }
1136             $newString .= '### <INCLUDE_TYPOSCRIPT: source="DIR:' . $dirPath . '"' . $optionalProperties . '> END:' . LF . LF;
1137         } else {
1138             $newString .= self::typoscriptIncludeError('The path "' . $resolvedDirPath . '" is invalid.');
1139         }
1140     }
1141
1142     /**
1143      * Process errors in INCLUDE_TYPOSCRIPT tags
1144      * Errors are logged and printed in the concatenated TypoScript result (as can be seen in Template Analyzer)
1145      *
1146      * @param string $error Text of the error message
1147      * @return string The error message encapsulated in comments
1148      * @static
1149      */
1150     protected static function typoscriptIncludeError($error)
1151     {
1152         self::getLogger()->warning($error);
1153         return "\n###\n### ERROR: " . $error . "\n###\n\n";
1154     }
1155
1156     /**
1157      * Parses the string in each value of the input array for include-commands
1158      *
1159      * @param array $array Array with TypoScript in each value
1160      * @return array Same array but where the values has been parsed for include-commands
1161      */
1162     public static function checkIncludeLines_array(array $array)
1163     {
1164         foreach ($array as $k => $v) {
1165             $array[$k] = self::checkIncludeLines($array[$k]);
1166         }
1167         return $array;
1168     }
1169
1170     /**
1171      * Search for commented INCLUDE_TYPOSCRIPT statements
1172      * and save the content between the BEGIN and the END line to the specified file
1173      *
1174      * @param string  $string Template content
1175      * @param int $cycle_counter Counter for detecting endless loops
1176      * @param array   $extractedFileNames
1177      * @param string  $parentFilenameOrPath
1178      *
1179      * @throws \RuntimeException
1180      * @throws \UnexpectedValueException
1181      * @return string Template content with uncommented include statements
1182      */
1183     public static function extractIncludes($string, $cycle_counter = 1, array $extractedFileNames = [], $parentFilenameOrPath = '')
1184     {
1185         if ($cycle_counter > 10) {
1186             self::getLogger()->warning('It appears like TypoScript code is looping over itself. Check your templates for "<INCLUDE_TYPOSCRIPT: ..." tags');
1187             return '
1188 ###
1189 ### ERROR: Recursion!
1190 ###
1191 ';
1192         }
1193         $expectedEndTag = '';
1194         $fileContent = [];
1195         $restContent = [];
1196         $fileName = null;
1197         $inIncludePart = false;
1198         $lines = preg_split("/\r\n|\n|\r/", $string);
1199         $skipNextLineIfEmpty = false;
1200         $openingCommentedIncludeStatement = null;
1201         $optionalProperties = '';
1202         foreach ($lines as $line) {
1203             // \TYPO3\CMS\Core\TypoScript\Parser\TypoScriptParser::checkIncludeLines inserts
1204             // an additional empty line, remove this again
1205             if ($skipNextLineIfEmpty) {
1206                 if (trim($line) === '') {
1207                     continue;
1208                 }
1209                 $skipNextLineIfEmpty = false;
1210             }
1211
1212             // Outside commented include statements
1213             if (!$inIncludePart) {
1214                 // Search for beginning commented include statements
1215                 if (preg_match('/###\\s*<INCLUDE_TYPOSCRIPT:\\s*source\\s*=\\s*"\\s*((?i)file|dir)\\s*:\\s*([^"]*)"(.*)>\\s*BEGIN/i', $line, $matches)) {
1216                     // Found a commented include statement
1217
1218                     // Save this line in case there is no ending tag
1219                     $openingCommentedIncludeStatement = trim($line);
1220                     $openingCommentedIncludeStatement = preg_replace('/\\s*### Warning: .*###\\s*/', '', $openingCommentedIncludeStatement);
1221
1222                     // type of match: FILE or DIR
1223                     $inIncludePart = strtoupper($matches[1]);
1224                     $fileName = $matches[2];
1225                     $optionalProperties = $matches[3];
1226
1227                     $expectedEndTag = '### <INCLUDE_TYPOSCRIPT: source="' . $inIncludePart . ':' . $fileName . '"' . $optionalProperties . '> END';
1228                     // Strip all whitespace characters to make comparison safer
1229                     $expectedEndTag = strtolower(preg_replace('/\s/', '', $expectedEndTag));
1230                 } else {
1231                     // If this is not a beginning commented include statement this line goes into the rest content
1232                     $restContent[] = $line;
1233                 }
1234             } else {
1235                 // Inside commented include statements
1236                 // Search for the matching ending commented include statement
1237                 $strippedLine = preg_replace('/\s/', '', $line);
1238                 if (stripos($strippedLine, $expectedEndTag) !== false) {
1239                     // Found the matching ending include statement
1240                     $fileContentString = implode(PHP_EOL, $fileContent);
1241
1242                     // Write the content to the file
1243
1244                     // Resolve a possible relative paths if a parent file is given
1245                     if ($parentFilenameOrPath !== '' && $fileName[0] === '.') {
1246                         $realFileName = PathUtility::getAbsolutePathOfRelativeReferencedFileOrPath($parentFilenameOrPath, $fileName);
1247                     } else {
1248                         $realFileName = $fileName;
1249                     }
1250                     $realFileName = GeneralUtility::getFileAbsFileName($realFileName);
1251
1252                     if ($inIncludePart === 'FILE') {
1253                         // Some file checks
1254                         if (!GeneralUtility::verifyFilenameAgainstDenyPattern($realFileName)) {
1255                             throw new \UnexpectedValueException(sprintf('File "%s" was not included since it is not allowed due to fileDenyPattern.', $fileName), 1382651858);
1256                         }
1257                         if (empty($realFileName)) {
1258                             throw new \UnexpectedValueException(sprintf('"%s" is not a valid file location.', $fileName), 1294586441);
1259                         }
1260                         if (!is_writable($realFileName)) {
1261                             throw new \RuntimeException(sprintf('"%s" is not writable.', $fileName), 1294586442);
1262                         }
1263                         if (in_array($realFileName, $extractedFileNames)) {
1264                             throw new \RuntimeException(sprintf('Recursive/multiple inclusion of file "%s"', $realFileName), 1294586443);
1265                         }
1266                         $extractedFileNames[] = $realFileName;
1267
1268                         // Recursive call to detected nested commented include statements
1269                         $fileContentString = self::extractIncludes($fileContentString, $cycle_counter + 1, $extractedFileNames, $realFileName);
1270
1271                         // Write the content to the file
1272                         if (!GeneralUtility::writeFile($realFileName, $fileContentString)) {
1273                             throw new \RuntimeException(sprintf('Could not write file "%s"', $realFileName), 1294586444);
1274                         }
1275                         // Insert reference to the file in the rest content
1276                         $restContent[] = '<INCLUDE_TYPOSCRIPT: source="FILE:' . $fileName . '"' . $optionalProperties . '>';
1277                     } else {
1278                         // must be DIR
1279
1280                         // Some file checks
1281                         if (empty($realFileName)) {
1282                             throw new \UnexpectedValueException(sprintf('"%s" is not a valid location.', $fileName), 1366493602);
1283                         }
1284                         if (!is_dir($realFileName)) {
1285                             throw new \RuntimeException(sprintf('"%s" is not a directory.', $fileName), 1366493603);
1286                         }
1287                         if (in_array($realFileName, $extractedFileNames)) {
1288                             throw new \RuntimeException(sprintf('Recursive/multiple inclusion of directory "%s"', $realFileName), 1366493604);
1289                         }
1290                         $extractedFileNames[] = $realFileName;
1291
1292                         // Recursive call to detected nested commented include statements
1293                         self::extractIncludes($fileContentString, $cycle_counter + 1, $extractedFileNames, $realFileName);
1294
1295                         // just drop content between tags since it should usually just contain individual files from that dir
1296
1297                         // Insert reference to the dir in the rest content
1298                         $restContent[] = '<INCLUDE_TYPOSCRIPT: source="DIR:' . $fileName . '"' . $optionalProperties . '>';
1299                     }
1300
1301                     // Reset variables (preparing for the next commented include statement)
1302                     $fileContent = [];
1303                     $fileName = null;
1304                     $inIncludePart = false;
1305                     $openingCommentedIncludeStatement = null;
1306                     // \TYPO3\CMS\Core\TypoScript\Parser\TypoScriptParser::checkIncludeLines inserts
1307                     // an additional empty line, remove this again
1308                     $skipNextLineIfEmpty = true;
1309                 } else {
1310                     // If this is not an ending commented include statement this line goes into the file content
1311                     $fileContent[] = $line;
1312                 }
1313             }
1314         }
1315         // If we're still inside commented include statements copy the lines back to the rest content
1316         if ($inIncludePart) {
1317             $restContent[] = $openingCommentedIncludeStatement . ' ### Warning: Corresponding end line missing! ###';
1318             $restContent = array_merge($restContent, $fileContent);
1319         }
1320         $restContentString = implode(PHP_EOL, $restContent);
1321         return $restContentString;
1322     }
1323
1324     /**
1325      * Processes the string in each value of the input array with extractIncludes
1326      *
1327      * @param array $array Array with TypoScript in each value
1328      * @return array Same array but where the values has been processed with extractIncludes
1329      */
1330     public static function extractIncludes_array(array $array)
1331     {
1332         foreach ($array as $k => $v) {
1333             $array[$k] = self::extractIncludes($array[$k]);
1334         }
1335         return $array;
1336     }
1337
1338     /**********************************
1339      *
1340      * Syntax highlighting
1341      *
1342      *********************************/
1343     /**
1344      * Syntax highlight a TypoScript text
1345      * Will parse the content. Remember, the internal setup array may contain invalid parsed content since conditions are ignored!
1346      *
1347      * @param string $string The TypoScript text
1348      * @param mixed $lineNum If blank, linenumbers are NOT printed. If array then the first key is the linenumber offset to add to the internal counter.
1349      * @param bool $highlightBlockMode If set, then the highlighted output will be formatted in blocks based on the brace levels. prespace will be ignored and empty lines represented with a single no-break-space.
1350      * @return string HTML code for the syntax highlighted string
1351      */
1352     public function doSyntaxHighlight($string, $lineNum = '', $highlightBlockMode = false)
1353     {
1354         $this->syntaxHighLight = 1;
1355         $this->highLightData = [];
1356         $this->errors = [];
1357         // This is done in order to prevent empty <span>..</span> sections around CR content. Should not do anything but help lessen the amount of HTML code.
1358         $string = str_replace(CR, '', $string);
1359         $this->parse($string);
1360         return $this->syntaxHighlight_print($lineNum, $highlightBlockMode);
1361     }
1362
1363     /**
1364      * Registers a part of a TypoScript line for syntax highlighting.
1365      *
1366      * @param string $code Key from the internal array $this->highLightStyles
1367      * @param int $pointer Pointer to the line in $this->raw which this is about
1368      * @param int $strlen The number of chars LEFT on this line before the end is reached.
1369      * @access private
1370      * @see parse()
1371      */
1372     public function regHighLight($code, $pointer, $strlen = -1)
1373     {
1374         if ($strlen === -1) {
1375             $this->highLightData[$pointer] = [[$code, 0]];
1376         } else {
1377             $this->highLightData[$pointer][] = [$code, $strlen];
1378         }
1379         $this->highLightData_bracelevel[$pointer] = $this->inBrace;
1380     }
1381
1382     /**
1383      * Formatting the TypoScript code in $this->raw based on the data collected by $this->regHighLight in $this->highLightData
1384      *
1385      * @param mixed $lineNumDat If blank, linenumbers are NOT printed. If array then the first key is the linenumber offset to add to the internal counter.
1386      * @param bool $highlightBlockMode If set, then the highlighted output will be formatted in blocks based on the brace levels. prespace will be ignored and empty lines represented with a single no-break-space.
1387      * @return string HTML content
1388      * @access private
1389      * @see doSyntaxHighlight()
1390      */
1391     public function syntaxHighlight_print($lineNumDat, $highlightBlockMode)
1392     {
1393         // Registers all error messages in relation to their linenumber
1394         $errA = [];
1395         foreach ($this->errors as $err) {
1396             $errA[$err[2]][] = $err[0];
1397         }
1398         // Generates the syntax highlighted output:
1399         $lines = [];
1400         foreach ($this->raw as $rawP => $value) {
1401             $start = 0;
1402             $strlen = strlen($value);
1403             $lineC = '';
1404             if (is_array($this->highLightData[$rawP])) {
1405                 foreach ($this->highLightData[$rawP] as $set) {
1406                     $len = $strlen - $start - $set[1];
1407                     if ($len > 0) {
1408                         $part = substr($value, $start, $len);
1409                         $start += $len;
1410                         $st = $this->highLightStyles[isset($this->highLightStyles[$set[0]]) ? $set[0] : 'default'];
1411                         if (!$highlightBlockMode || $set[0] !== 'prespace') {
1412                             $lineC .= $st[0] . htmlspecialchars($part) . $st[1];
1413                         }
1414                     } elseif ($len < 0) {
1415                         debug([$len, $value, $rawP]);
1416                     }
1417                 }
1418             } else {
1419                 debug([$value]);
1420             }
1421             if (strlen($value) > $start) {
1422                 $lineC .= $this->highLightStyles['ignored'][0] . htmlspecialchars(substr($value, $start)) . $this->highLightStyles['ignored'][1];
1423             }
1424             if ($errA[$rawP]) {
1425                 $lineC .= $this->highLightStyles['error'][0] . '<strong> - ERROR:</strong> ' . htmlspecialchars(implode(';', $errA[$rawP])) . $this->highLightStyles['error'][1];
1426             }
1427             if ($highlightBlockMode && $this->highLightData_bracelevel[$rawP]) {
1428                 $lineC = str_pad('', $this->highLightData_bracelevel[$rawP] * 2, ' ', STR_PAD_LEFT) . '<span style="' . $this->highLightBlockStyles . ($this->highLightBlockStyles_basecolor ? 'background-color: ' . $this->modifyHTMLColorAll($this->highLightBlockStyles_basecolor, -$this->highLightData_bracelevel[$rawP] * 16) : '') . '">' . ($lineC !== '' ? $lineC : '&nbsp;') . '</span>';
1429             }
1430             if (is_array($lineNumDat)) {
1431                 $lineNum = $rawP + $lineNumDat[0];
1432                 if ($this->parentObject instanceof ExtendedTemplateService) {
1433                     $lineNum = $this->parentObject->ext_lnBreakPointWrap($lineNum, $lineNum);
1434                 }
1435                 $lineC = $this->highLightStyles['linenum'][0] . str_pad($lineNum, 4, ' ', STR_PAD_LEFT) . ':' . $this->highLightStyles['linenum'][1] . ' ' . $lineC;
1436             }
1437             $lines[] = $lineC;
1438         }
1439         return '<pre class="ts-hl">' . implode(LF, $lines) . '</pre>';
1440     }
1441
1442     /**
1443      * @return TimeTracker
1444      */
1445     protected function getTimeTracker()
1446     {
1447         return GeneralUtility::makeInstance(TimeTracker::class);
1448     }
1449
1450     /**
1451      * Modifies a HTML Hex color by adding/subtracting $R,$G and $B integers
1452      *
1453      * @param string $color A hexadecimal color code, #xxxxxx
1454      * @param int $R Offset value 0-255
1455      * @param int $G Offset value 0-255
1456      * @param int $B Offset value 0-255
1457      * @return string A hexadecimal color code, #xxxxxx, modified according to input vars
1458      * @see modifyHTMLColorAll()
1459      */
1460     protected function modifyHTMLColor($color, $R, $G, $B)
1461     {
1462         // This takes a hex-color (# included!) and adds $R, $G and $B to the HTML-color (format: #xxxxxx) and returns the new color
1463         $nR = MathUtility::forceIntegerInRange(hexdec(substr($color, 1, 2)) + $R, 0, 255);
1464         $nG = MathUtility::forceIntegerInRange(hexdec(substr($color, 3, 2)) + $G, 0, 255);
1465         $nB = MathUtility::forceIntegerInRange(hexdec(substr($color, 5, 2)) + $B, 0, 255);
1466         return '#' . substr(('0' . dechex($nR)), -2) . substr(('0' . dechex($nG)), -2) . substr(('0' . dechex($nB)), -2);
1467     }
1468
1469     /**
1470      * Modifies a HTML Hex color by adding/subtracting $all integer from all R/G/B channels
1471      *
1472      * @param string $color A hexadecimal color code, #xxxxxx
1473      * @param int $all Offset value 0-255 for all three channels.
1474      * @return string A hexadecimal color code, #xxxxxx, modified according to input vars
1475      * @see modifyHTMLColor()
1476      */
1477     protected function modifyHTMLColorAll($color, $all)
1478     {
1479         return $this->modifyHTMLColor($color, $all, $all, $all);
1480     }
1481
1482     /**
1483      * Get a logger instance
1484      *
1485      * This class uses logging mostly in static functions, hence we need a static getter for the logger.
1486      * Injection of a logger instance via GeneralUtility::makeInstance is not possible.
1487      *
1488      * @return LoggerInterface
1489      */
1490     protected static function getLogger()
1491     {
1492         return GeneralUtility::makeInstance(LogManager::class)->getLogger(__CLASS__);
1493     }
1494 }