TemplateService.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Core\TypoScript;

use TYPO3\CMS\Core\Utility\ExtensionManagementUtility;
use TYPO3\CMS\Core\Utility\GeneralUtility;

class TemplateService {

    // Debugging, analysis:
    // If set, the global tt-timeobject is used to log the performance.
    public $tt_track = 1;

    // If set, the template is always rendered. Used from Admin Panel.
    public $forceTemplateParsing = 0;

    // Backend Analysis modules settings:
    // This array is passed on to matchObj by generateConfig(). If it holds elements, they are used for matching instead. See commment at the match-class. Used for backend modules only. Never frontend!
    public $matchAlternative = array();

    // If set, the match-class matches everything! Used for backend modules only. Never frontend!
    public $matchAll = 0;

    public $backend_info = 0;

    // Set from the backend - used to set an absolute path (PATH_site) so that relative resources are properly found with getFileName()
    public $getFileName_backPath = '';

    // Externally set breakpoints (used by Backend Modules)
    public $ext_constants_BRP = 0;

    public $ext_config_BRP = 0;

    public $ext_regLinenumbers = FALSE;

    public $ext_regComments = FALSE;

    // Constants:
    public $tempPath = 'typo3temp/';

    // Set Internally:
    // This MUST be initialized by the init() function
    public $whereClause = '';

    public $debug = 0;

    // This is the only paths (relative!!) that are allowed for resources in TypoScript. Should all be appended with '/'. You can extend these by the global array TYPO3_CONF_VARS. See init() function.
    public $allowedPaths = array();

    // See init(); Set if preview of some kind is enabled.
    public $simulationHiddenOrTime = 0;

    // Set, if the TypoScript template structure is loaded and OK, see ->start()
    public $loaded = 0;

    // Default TypoScript Setup code
    public $setup = array(
        'styles.' => array(
            'insertContent' => 'CONTENT',
            'insertContent.' => array(
                'table' => 'tt_content',
                'select.' => array(
                    'orderBy' => 'sorting',
                    'where' => 'colPos=0',
                    'languageField' => 'sys_language_uid'
                )
            )
        ),
        'config.' => array(
            'extTarget' => '_top',
            'uniqueLinkVars' => 1
        )
    );

    public $flatSetup = array();

    // Default TypoScript Constants code:
    public $const = array(
        '_clear' => '<img src="clear.gif" width="1" height="1" alt="" />',
        '_blackBorderWrap' => '<table border="0" bgcolor="black" cellspacing="0" cellpadding="1"><tr><td> | </td></tr></table>',
        '_tableWrap' => '<table border="0" cellspacing="0" cellpadding="0"> | </table>',
        '_tableWrap_DEBUG' => '<table border="1" cellspacing="0" cellpadding="0"> | </table>',
        '_stdFrameParams' => 'frameborder="no" marginheight="0" marginwidth="0" noresize="noresize"',
        '_stdFramesetParams' => 'border="0" framespacing="0" frameborder="no"'
    );

    // For fetching TypoScript code from template hierarchy before parsing it. Each array contains code field values from template records/files:
    // Setup field
    public $config = array();

    // Constant field
    public $constants = array();

    protected $templateIncludePaths = array();

    // For Template Analyser in backend
    public $hierarchyInfo = array();

    // For Template Analyser in backend (setup content only)
    public $hierarchyInfoToRoot = array();

    // Next-level flag (see runThroughTemplates())
    public $nextLevel = 0;

    // The Page UID of the root page
    public $rootId;

    // The rootline from current page to the root page
    public $rootLine;

    // Rootline all the way to the root. Set but runThroughTemplates
    public $absoluteRootLine;

    // A pointer to the last entry in the rootline where a template was found.
    public $outermostRootlineIndexWithTemplate = 0;

    // Array of arrays with title/uid of templates in hierarchy
    public $rowSum;

    // The current site title field.
    public $sitetitle = '';

    // Tracking all conditions found during parsing of TypoScript. Used for the "all" key in currentPageData
    public $sections;

    // Tracking all matching conditions found
    public $sectionsMatch;

    public $clearList_const = array();

    public $clearList_setup = array();

    public $parserErrors = array();

    public $setup_constants = array();

    // Other:
    // Used by getFileName for caching of references to file resources
    public $fileCache = array();

    // Keys are frame names and values are type-values, which must be used to refer correctly to the content of the frames.
    public $frames = array();

    // Contains mapping of Page id numbers to MP variables.
    public $MPmap = '';

    protected $extensionStaticsProcessed = FALSE;

    protected $processExtensionStatics = FALSE;

    protected $isDefaultTypoScriptAdded = FALSE;

    protected $processIncludesHasBeenRun = FALSE;

    public function getProcessExtensionStatics() {
        return $this->processExtensionStatics;
    }

    public function setProcessExtensionStatics($processExtensionStatics) {
        $this->processExtensionStatics = (bool) $processExtensionStatics;
    }

    public function init() {
        // $this->whereClause is used only to select templates from sys_template.
        // $GLOBALS['SIM_ACCESS_TIME'] is used so that we're able to simulate a later time as a test...
        $this->whereClause = 'AND deleted=0 ';
        if (!$GLOBALS['TSFE']->showHiddenRecords) {
            $this->whereClause .= 'AND hidden=0 ';
        }
        if ($GLOBALS['TSFE']->showHiddenRecords || $GLOBALS['SIM_ACCESS_TIME'] != $GLOBALS['ACCESS_TIME']) {
            // Set the simulation flag, if simulation is detected!
            $this->simulationHiddenOrTime = 1;
        }
        $this->whereClause .= 'AND (starttime<=' . $GLOBALS['SIM_ACCESS_TIME'] . ') AND (endtime=0 OR endtime>' . $GLOBALS['SIM_ACCESS_TIME'] . ')';
        // Sets the paths from where TypoScript resources are allowed to be used:
        $this->allowedPaths = array(
            'media/',
            $GLOBALS['TYPO3_CONF_VARS']['BE']['fileadminDir'],
            // fileadmin/ path
            'uploads/',
            'typo3temp/',
            TYPO3_mainDir . 'ext/',
            TYPO3_mainDir . 'sysext/',
            TYPO3_mainDir . 'contrib/',
            'typo3conf/ext/'
        );
        if ($GLOBALS['TYPO3_CONF_VARS']['FE']['addAllowedPaths']) {
            $pathArr = GeneralUtility::trimExplode(',', $GLOBALS['TYPO3_CONF_VARS']['FE']['addAllowedPaths'], TRUE);
            foreach ($pathArr as $p) {
                // Once checked for path, but as this may run from typo3/mod/web/ts/ dir, that'll not work!! So the paths ar uncritically included here.
                $this->allowedPaths[] = $p;
            }
        }
    }

    public function getCurrentPageData() {
        return GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Cache\\CacheManager')->getCache('cache_pagesection')->get((int)$GLOBALS['TSFE']->id . '_' . GeneralUtility::md5int($GLOBALS['TSFE']->MP));
    }

    public function matching($cc) {
        if (is_array($cc['all'])) {
            $matchObj = GeneralUtility::makeInstance('TYPO3\\CMS\\Frontend\\Configuration\\TypoScript\\ConditionMatching\\ConditionMatcher');
            $matchObj->setRootline((array) $cc['rootLine']);
            foreach ($cc['all'] as $key => $pre) {
                if ($matchObj->match($pre)) {
                    $sectionsMatch[$key] = $pre;
                }
            }
            $cc['match'] = $sectionsMatch;
        }
        return $cc;
    }

    public function start($theRootLine) {
        if (is_array($theRootLine)) {
            $setupData = '';
            $hash = '';
            // Flag that indicates that the existing data in cache_pagesection
            // could be used (this is the case if $TSFE->all is set, and the
            // rowSum still matches). Based on this we decide if cache_pagesection
            // needs to be updated...
            $isCached = FALSE;
            $this->runThroughTemplates($theRootLine);
            if ($GLOBALS['TSFE']->all) {
                $cc = $GLOBALS['TSFE']->all;
                // The two rowSums must NOT be different from each other - which they will be if start/endtime or hidden has changed!
                if (serialize($this->rowSum) !== serialize($cc['rowSum'])) {
                    unset($cc);
                } else {
                    // If $TSFE->all contains valid data, we don't need to update cache_pagesection (because this data was fetched from there already)
                    if (serialize($this->rootLine) === serialize($cc['rootLine'])) {
                        $isCached = TRUE;
                    }
                    // When the data is serialized below (ROWSUM hash), it must not contain the rootline by concept. So this must be removed (and added again later)...
                    unset($cc['rootLine']);
                }
            }
            // This is about getting the hash string which is used to fetch the cached TypoScript template.
            // If there was some cached currentPageData ($cc) then that's good (it gives us the hash).
            if (is_array($cc)) {
                // If currentPageData was actually there, we match the result (if this wasn't done already in $TSFE->getFromCache()...)
                if (!$cc['match']) {
                    // TODO: check if this can ever be the case - otherwise remove
                    $cc = $this->matching($cc);
                    ksort($cc);
                }
                $hash = md5(serialize($cc));
            } else {
                // If currentPageData was not there, we first find $rowSum (freshly generated). After that we try to see, if it is stored with a list of all conditions. If so we match the result.
                $rowSumHash = md5('ROWSUM:' . serialize($this->rowSum));
                $result = \TYPO3\CMS\Frontend\Page\PageRepository::getHash($rowSumHash);
                if (is_array($result)) {
                    $cc = array();
                    $cc['all'] = $result;
                    $cc['rowSum'] = $this->rowSum;
                    $cc = $this->matching($cc);
                    ksort($cc);
                    $hash = md5(serialize($cc));
                }
            }
            if ($hash) {
                // Get TypoScript setup array
                $setupData = \TYPO3\CMS\Frontend\Page\PageRepository::getHash($hash);
            }
            if (is_array($setupData) && !$this->forceTemplateParsing) {
                // If TypoScript setup structure was cached we unserialize it here:
                $this->setup = $setupData;
                if ($this->tt_track) {
                    $GLOBALS['TT']->setTSLogMessage('Using cached TS template data');
                }
            } else {
                if ($this->tt_track) {
                    $GLOBALS['TT']->setTSLogMessage('Not using any cached TS data');
                }

                // Make configuration
                $this->generateConfig();
                // This stores the template hash thing
                $cc = array();
                // All sections in the template at this point is found
                $cc['all'] = $this->sections;
                // The line of templates is collected
                $cc['rowSum'] = $this->rowSum;
                $cc = $this->matching($cc);
                ksort($cc);
                $hash = md5(serialize($cc));
                // This stores the data.
                \TYPO3\CMS\Frontend\Page\PageRepository::storeHash($hash, $this->setup, 'TS_TEMPLATE');
                if ($this->tt_track) {
                    $GLOBALS['TT']->setTSlogMessage('TS template size, serialized: ' . strlen(serialize($this->setup)) . ' bytes');
                }
                $rowSumHash = md5('ROWSUM:' . serialize($this->rowSum));
                \TYPO3\CMS\Frontend\Page\PageRepository::storeHash($rowSumHash, $cc['all'], 'TMPL_CONDITIONS_ALL');
            }
            // Add rootLine
            $cc['rootLine'] = $this->rootLine;
            ksort($cc);
            // Make global and save
            $GLOBALS['TSFE']->all = $cc;
            // Matching must be executed for every request, so this must never be part of the pagesection cache!
            unset($cc['match']);
            if (!$isCached && !$this->simulationHiddenOrTime && !$GLOBALS['TSFE']->no_cache) {
                // Only save the data if we're not simulating by hidden/starttime/endtime
                $mpvarHash = GeneralUtility::md5int($GLOBALS['TSFE']->MP);
                $pageSectionCache = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Cache\\CacheManager')->getCache('cache_pagesection');
                $pageSectionCache->set((int)$GLOBALS['TSFE']->id . '_' . $mpvarHash, $cc, array(
                    'pageId_' . (int)$GLOBALS['TSFE']->id,
                    'mpvarHash_' . $mpvarHash
                ));
            }
            // If everything OK.
            if ($this->rootId && $this->rootLine && $this->setup) {
                $this->loaded = 1;
            }
        }
    }

    /*******************************************************************
     *
     * Fetching TypoScript code text for the Template Hierarchy
     *
     *******************************************************************/
    public function runThroughTemplates($theRootLine, $start_template_uid = 0) {
        $this->constants = array();
        $this->config = array();
        $this->rowSum = array();
        $this->hierarchyInfoToRoot = array();
        $this->absoluteRootLine = $theRootLine;
        $this->isDefaultTyposcriptAdded = FALSE;

        reset($this->absoluteRootLine);
        $c = count($this->absoluteRootLine);
        for ($a = 0; $a < $c; $a++) {
            // If some template loaded before has set a template-id for the next level, then load this template first!
            if ($this->nextLevel) {
                $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('*', 'sys_template', 'uid=' . (int)$this->nextLevel . ' ' . $this->whereClause);
                $this->nextLevel = 0;
                if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) {
                    $this->versionOL($row);
                    if (is_array($row)) {
                        $this->processTemplate($row, 'sys_' . $row['uid'], $this->absoluteRootLine[$a]['uid'], 'sys_' . $row['uid']);
                        $this->outermostRootlineIndexWithTemplate = $a;
                    }
                }
                $GLOBALS['TYPO3_DB']->sql_free_result($res);
            }
            $addC = '';
            // If first loop AND there is set an alternative template uid, use that
            if ($a == $c - 1 && $start_template_uid) {
                $addC = ' AND uid=' . (int)$start_template_uid;
            }
            $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('*', 'sys_template', 'pid=' . (int)$this->absoluteRootLine[$a]['uid'] . $addC . ' ' . $this->whereClause, '', 'sorting', 1);
            if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) {
                $this->versionOL($row);
                if (is_array($row)) {
                    $this->processTemplate($row, 'sys_' . $row['uid'], $this->absoluteRootLine[$a]['uid'], 'sys_' . $row['uid']);
                    $this->outermostRootlineIndexWithTemplate = $a;
                }
            }
            $GLOBALS['TYPO3_DB']->sql_free_result($res);
            $this->rootLine[] = $this->absoluteRootLine[$a];
        }

        // Process extension static files if not done yet, but explicitly requested
        if (!$this->extensionStaticsProcessed && $this->processExtensionStatics) {
            $this->addExtensionStatics('sys_0', 'sys_0', 0, array());
        }

        // Add the global default TypoScript from the TYPO3_CONF_VARS
        $this->addDefaultTypoScript();

        $this->processIncludes();
    }

    public function processTemplate($row, $idList, $pid, $templateID = '', $templateParent = '', $includePath = '') {
        // Adding basic template record information to rowSum array
        $this->rowSum[] = array($row['uid'], $row['title'], $row['tstamp']);
        // Processing "Clear"-flags
        if ($row['clear']) {
            $clConst = $row['clear'] & 1;
            $clConf = $row['clear'] & 2;
            if ($clConst) {
                // Keep amount of items to stay in sync with $this->templateIncludePaths so processIncludes() does not break
                foreach ($this->constants as &$constantConfiguration) {
                    $constantConfiguration = '';
                }
                unset($constantConfiguration);
                $this->clearList_const = array();
            }
            if ($clConf) {
                // Keep amount of items to stay in sync with $this->templateIncludePaths so processIncludes() does not break
                foreach ($this->config as &$configConfiguration) {
                    $configConfiguration = '';
                }
                unset($configConfiguration);
                $this->hierarchyInfoToRoot = array();
                $this->clearList_setup = array();
            }
        }
        // Include static records (static_template) or files (from extensions) (#1/2)
        // NORMAL inclusion, The EXACT same code is found below the basedOn inclusion!!!
        if (!$row['includeStaticAfterBasedOn']) {
            $this->includeStaticTypoScriptSources($idList, $templateID, $pid, $row);
        }
        // Include "Based On" sys_templates:
        // 'basedOn' is a list of templates to include
        if (trim($row['basedOn'])) {
            // Manually you can put this value in the field and then the based_on ID will be taken from the $_GET var defined by '=....'.
            // Example: If $row['basedOn'] is 'EXTERNAL_BASED_ON_TEMPLATE_ID=based_on_uid', then the global var, based_on_uid - given by the URL like '&based_on_uid=999' - is included instead!
            // This feature allows us a hack to test/demonstrate various included templates on the same set of content bearing pages. Used by the "freesite" extension.
            $basedOn_hackFeature = explode('=', $row['basedOn']);
            if ($basedOn_hackFeature[0] == 'EXTERNAL_BASED_ON_TEMPLATE_ID' && $basedOn_hackFeature[1]) {
                $id = (int)GeneralUtility::_GET($basedOn_hackFeature[1]);
                // If $id is not allready included ...
                if ($id && !GeneralUtility::inList($idList, ('sys_' . $id))) {
                    $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('*', 'sys_template', 'uid=' . $id . ' ' . $this->whereClause);
                    // there was a template, then we fetch that
                    if ($subrow = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) {
                        $this->versionOL($subrow);
                        if (is_array($subrow)) {
                            $this->processTemplate($subrow, $idList . ',sys_' . $id, $pid, 'sys_' . $id, $templateID);
                        }
                    }
                    $GLOBALS['TYPO3_DB']->sql_free_result($res);
                }
            } else {
                // Normal Operation, which is to include the "based-on" sys_templates,
                // if they are not already included, and maintaining the sorting of the templates
                $basedOnIds = GeneralUtility::intExplode(',', $row['basedOn'], TRUE);
                // skip template if it's already included
                foreach ($basedOnIds as $key => $basedOnId) {
                    if (GeneralUtility::inList($idList, 'sys_' . $basedOnId)) {
                        unset($basedOnIds[$key]);
                    }
                }
                if (!empty($basedOnIds)) {
                    $subTemplates = $GLOBALS['TYPO3_DB']->exec_SELECTgetRows('*', 'sys_template', 'uid IN (' . implode(',', $basedOnIds) . ') ' . $this->whereClause, '', '', '', 'uid');
                    // Traversing list again to ensure the sorting of the templates
                    foreach ($basedOnIds as $id) {
                        if (is_array($subTemplates[$id])) {
                            $this->versionOL($subTemplates[$id]);
                            $this->processTemplate($subTemplates[$id], $idList . ',sys_' . $id, $pid, 'sys_' . $id, $templateID);
                        }
                    }
                }
            }
        }
        // Include static records (static_template) or files (from extensions) (#2/2)
        if ($row['includeStaticAfterBasedOn']) {
            $this->includeStaticTypoScriptSources($idList, $templateID, $pid, $row);
        }
        // Creating hierarchy information; Used by backend analysis tools
        $this->hierarchyInfo[] = ($this->hierarchyInfoToRoot[] = array(
            'root' => trim($row['root']),
            'next' => $row['nextLevel'],
            'clConst' => $clConst,
            'clConf' => $clConf,
            'templateID' => $templateID,
            'templateParent' => $templateParent,
            'title' => $row['title'],
            'uid' => $row['uid'],
            'pid' => $row['pid'],
            'configLines' => substr_count($row['config'], LF) + 1
        ));
        // Adding the content of the fields constants (Constants) and config (Setup)
        $this->constants[] = $row['constants'];
        $this->config[] = $row['config'];
        $this->templateIncludePaths[] = $includePath;
        // For backend analysis (Template Analyser) provide the order of added constants/config template IDs
        $this->clearList_const[] = $templateID;
        $this->clearList_setup[] = $templateID;
        if (trim($row['sitetitle'])) {
            $this->sitetitle = $row['sitetitle'];
        }
        // If the template record is a Rootlevel record, set the flag and clear the template rootLine (so it starts over from this point)
        if (trim($row['root'])) {
            $this->rootId = $pid;
            $this->rootLine = array();
        }
        // If a template is set to be active on the next level set this internal value to point to this UID. (See runThroughTemplates())
        if ($row['nextLevel']) {
            $this->nextLevel = $row['nextLevel'];
        } else {
            $this->nextLevel = 0;
        }
    }

    public function updateRootlineData($fullRootLine) {
        if (!is_array($this->rootLine) || count($this->rootLine) === 0) {
            return;
        }

        $fullRootLineByUid = array();
        foreach ($fullRootLine as $rootLineData) {
            $fullRootLineByUid[$rootLineData['uid']] = $rootLineData;
        }

        foreach ($this->rootLine as $level => $dataArray) {
            $currentUid = $dataArray['uid'];

            if (!array_key_exists($currentUid, $fullRootLineByUid)) {
                throw new \RuntimeException(sprintf('The full rootLine does not contain data for the page with the uid %d that is contained in the template rootline.', $currentUid), 1370419654);
            }

            $this->rootLine[$level] = $fullRootLineByUid[$currentUid];
        }
    }

    public function includeStaticTypoScriptSources($idList, $templateID, $pid, $row) {
        // Static Template Records (static_template): include_static is a list of static templates to include
        // Call function for link rendering:
        if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_tstemplate.php']['includeStaticTypoScriptSources'])) {
            $_params = array(
                'idList' => &$idList,
                'templateId' => &$templateID,
                'pid' => &$pid,
                'row' => &$row
            );
            foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_tstemplate.php']['includeStaticTypoScriptSources'] as $_funcRef) {
                GeneralUtility::callUserFunction($_funcRef, $_params, $this);
            }
        }
        // If "Include before all static templates if root-flag is set" is set:
        if ($row['static_file_mode'] == 3 && substr($templateID, 0, 4) == 'sys_' && $row['root']) {
            $this->addExtensionStatics($idList, $templateID, $pid, $row);
        }
        // Static Template Files (Text files from extensions): include_static_file is a list of static files to include (from extensions)
        if (trim($row['include_static_file'])) {
            $include_static_fileArr = GeneralUtility::trimExplode(',', $row['include_static_file'], TRUE);
            // Traversing list
            foreach ($include_static_fileArr as $ISF_file) {
                if (substr($ISF_file, 0, 4) == 'EXT:') {
                    list($ISF_extKey, $ISF_localPath) = explode('/', substr($ISF_file, 4), 2);
                    if ((string)$ISF_extKey !== '' && \TYPO3\CMS\Core\Utility\ExtensionManagementUtility::isLoaded($ISF_extKey) && (string)$ISF_localPath !== '') {
                        $ISF_localPath = rtrim($ISF_localPath, '/') . '/';
                        $ISF_filePath = \TYPO3\CMS\Core\Utility\ExtensionManagementUtility::extPath($ISF_extKey) . $ISF_localPath;
                        if (@is_dir($ISF_filePath)) {
                            $mExtKey = str_replace('_', '', $ISF_extKey . '/' . $ISF_localPath);
                            $subrow = array(
                                'constants' => @file_exists(($ISF_filePath . 'constants.txt')) ? GeneralUtility::getUrl($ISF_filePath . 'constants.txt') : '',
                                'config' => @file_exists(($ISF_filePath . 'setup.txt')) ? GeneralUtility::getUrl($ISF_filePath . 'setup.txt') : '',
                                'include_static' => @file_exists(($ISF_filePath . 'include_static.txt')) ? implode(',', array_unique(GeneralUtility::intExplode(',', GeneralUtility::getUrl($ISF_filePath . 'include_static.txt')))) : '',
                                'include_static_file' => @file_exists(($ISF_filePath . 'include_static_file.txt')) ? implode(',', array_unique(explode(',', GeneralUtility::getUrl($ISF_filePath . 'include_static_file.txt')))) : '',
                                'title' => $ISF_file,
                                'uid' => $mExtKey
                            );
                            $subrow = $this->prependStaticExtra($subrow);
                            $this->processTemplate($subrow, $idList . ',ext_' . $mExtKey, $pid, 'ext_' . $mExtKey, $templateID, $ISF_filePath);
                        }
                    }
                }
            }
        }
        // If "Default (include before if root flag is set)" is set OR
        // "Always include before this template record" AND root-flag are set
        if ($row['static_file_mode'] == 1 || $row['static_file_mode'] == 0 && substr($templateID, 0, 4) == 'sys_' && $row['root']) {
            $this->addExtensionStatics($idList, $templateID, $pid, $row);
        }
        // Include Static Template Records after all other TypoScript has been included.
        if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_tstemplate.php']['includeStaticTypoScriptSourcesAtEnd'])) {
            $_params = array(
                'idList' => &$idList,
                'templateId' => &$templateID,
                'pid' => &$pid,
                'row' => &$row
            );
            foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_tstemplate.php']['includeStaticTypoScriptSourcesAtEnd'] as $_funcRef) {
                GeneralUtility::callUserFunction($_funcRef, $_params, $this);
            }
        }
    }

    public function addExtensionStatics($idList, $templateID, $pid, $row) {
        $this->extensionStaticsProcessed = TRUE;

        // @TODO: Change to use new API
        foreach ($GLOBALS['TYPO3_LOADED_EXT'] as $extKey => $files) {
            if ((is_array($files) || $files instanceof \ArrayAccess) && ($files['ext_typoscript_constants.txt'] || $files['ext_typoscript_setup.txt'])) {
                $mExtKey = str_replace('_', '', $extKey);
                $subrow = array(
                    'constants' => $files['ext_typoscript_constants.txt'] ? GeneralUtility::getUrl($files['ext_typoscript_constants.txt']) : '',
                    'config' => $files['ext_typoscript_setup.txt'] ? GeneralUtility::getUrl($files['ext_typoscript_setup.txt']) : '',
                    'title' => $extKey,
                    'uid' => $mExtKey
                );
                $subrow = $this->prependStaticExtra($subrow);
                $extPath = ExtensionManagementUtility::extPath($extKey);
                $this->processTemplate($subrow, $idList . ',ext_' . $mExtKey, $pid, 'ext_' . $mExtKey, $templateID, $extPath);
            }
        }
    }

    public function prependStaticExtra($subrow) {
        // the identifier can be "43" if coming from "static template" extension or a path like "cssstyledcontent/static/"
        $identifier = $subrow['uid'];
        $subrow['config'] .= $GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_setup.'][$identifier];
        $subrow['constants'] .= $GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_constants.'][$identifier];
        // if this is a template of type "default content rendering", also see if other extensions have added their TypoScript that should be included after the content definitions
        if (in_array($identifier, $GLOBALS['TYPO3_CONF_VARS']['FE']['contentRenderingTemplates'], TRUE)) {
            $subrow['config'] .= $GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_setup.']['defaultContentRendering'];
            $subrow['constants'] .= $GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_constants.']['defaultContentRendering'];
        }
        return $subrow;
    }

    public function versionOL(&$row) {
        // Distinguish frontend and backend call:
        // To do the fronted call a full frontend is required, just checking for
        // TYPO3_MODE === 'FE' is not enough. This could otherwise lead to fatals in
        // eId scripts that run in frontend scope, but do not have a full blown frontend.
        if (is_object($GLOBALS['TSFE']) === TRUE && property_exists($GLOBALS['TSFE'], 'sys_page') === TRUE && method_exists($GLOBALS['TSFE']->sys_page, 'versionOL') === TRUE) {
            // Frontend
            $GLOBALS['TSFE']->sys_page->versionOL('sys_template', $row);
        } else {
            // Backend
            \TYPO3\CMS\Backend\Utility\BackendUtility::workspaceOL('sys_template', $row);
        }
    }

    /*******************************************************************
     *
     * Parsing TypoScript code text from Template Records into PHP array
     *
     *******************************************************************/
    public function generateConfig() {
        // Add default TS for all code types
        $this->addDefaultTypoScript();

        // Parse the TypoScript code text for include-instructions!
        $this->processIncludes();
        // These vars are also set lateron...
        $this->setup['sitetitle'] = $this->sitetitle;
        // ****************************
        // Parse TypoScript Constants
        // ****************************
        // Initialize parser and match-condition classes:
        $constants = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\TypoScript\\Parser\\TypoScriptParser');
        $constants->breakPointLN = (int)$this->ext_constants_BRP;
        $constants->setup = $this->const;
        $constants->setup = $this->mergeConstantsFromPageTSconfig($constants->setup);
        $matchObj = GeneralUtility::makeInstance('TYPO3\\CMS\\Frontend\\Configuration\\TypoScript\\ConditionMatching\\ConditionMatcher');
        $matchObj->setSimulateMatchConditions($this->matchAlternative);
        $matchObj->setSimulateMatchResult((bool) $this->matchAll);
        // Traverse constants text fields and parse them
        foreach ($this->constants as $str) {
            $constants->parse($str, $matchObj);
        }
        // Read out parse errors if any
        $this->parserErrors['constants'] = $constants->errors;
        // Then flatten the structure from a multi-dim array to a single dim array with all constants listed as key/value pairs (ready for substitution)
        $this->flatSetup = array();
        $this->flattenSetup($constants->setup, '', '');
        // ***********************************************
        // Parse TypoScript Setup (here called "config")
        // ***********************************************
        // Initialize parser and match-condition classes:
        $config = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\TypoScript\\Parser\\TypoScriptParser');
        $config->breakPointLN = (int)$this->ext_config_BRP;
        $config->regLinenumbers = $this->ext_regLinenumbers;
        $config->regComments = $this->ext_regComments;
        $config->setup = $this->setup;
        // Transfer information about conditions found in "Constants" and which of them returned TRUE.
        $config->sections = $constants->sections;
        $config->sectionsMatch = $constants->sectionsMatch;
        // Traverse setup text fields and concatenate them into one, single string separated by a [GLOBAL] condition
        $all = '';
        foreach ($this->config as $str) {
            $all .= '
[GLOBAL]
' . $str;
        }
        // Substitute constants in the Setup code:
        if ($this->tt_track) {
            $GLOBALS['TT']->push('Substitute Constants (' . count($this->flatSetup) . ')');
        }
        $all = $this->substituteConstants($all);
        if ($this->tt_track) {
            $GLOBALS['TT']->pull();
        }
        // Searching for possible unsubstituted constants left (only for information)
        if (strstr($all, '{$')) {
            $theConstList = array();
            $findConst = explode('{$', $all);
            array_shift($findConst);
            foreach ($findConst as $constVal) {
                $constLen = \TYPO3\CMS\Core\Utility\MathUtility::forceIntegerInRange(strcspn($constVal, '}'), 0, 50);
                $theConstList[] = '{$' . substr($constVal, 0, ($constLen + 1));
            }
            if ($this->tt_track) {
                $GLOBALS['TT']->setTSlogMessage(implode(', ', $theConstList) . ': Constants may remain un-substituted!!', 2);
            }
        }
        // Logging the textual size of the TypoScript Setup field text with all constants substituted:
        if ($this->tt_track) {
            $GLOBALS['TT']->setTSlogMessage('TypoScript template size as textfile: ' . strlen($all) . ' bytes');
        }
        // Finally parse the Setup field TypoScript code (where constants are now substituted)
        $config->parse($all, $matchObj);
        // Read out parse errors if any
        $this->parserErrors['config'] = $config->errors;
        // Transfer the TypoScript array from the parser object to the internal $this->setup array:
        $this->setup = $config->setup;
        if ($this->backend_info) {
            // Used for backend purposes only
            $this->setup_constants = $constants->setup;
        }
        // ****************************************************************
        // Final processing of the $this->setup TypoScript Template array
        // Basically: This is unsetting/setting of certain reserved keys.
        // ****************************************************************
        // These vars are allready set after 'processTemplate', but because $config->setup overrides them (in the line above!), we set them again. They are not changed compared to the value they had in the top of the page!
        unset($this->setup['sitetitle']);
        unset($this->setup['sitetitle.']);
        $this->setup['sitetitle'] = $this->sitetitle;
        // Unsetting some vars...
        unset($this->setup['types.']);
        unset($this->setup['types']);
        if (is_array($this->setup)) {
            foreach ($this->setup as $key => $value) {
                if ($value == 'PAGE') {
                    // Set the typeNum of the current page object:
                    if (isset($this->setup[$key . '.']['typeNum'])) {
                        $typeNum = $this->setup[$key . '.']['typeNum'];
                        $this->setup['types.'][$typeNum] = $key;
                    } elseif (!isset($this->setup['types.'][0]) || !$this->setup['types.'][0]) {
                        $this->setup['types.'][0] = $key;
                    }
                }
            }
        }
        unset($this->setup['styles.']);
        unset($this->setup['temp.']);
        unset($constants);
        // Storing the conditions found/matched information:
        $this->sections = $config->sections;
        $this->sectionsMatch = $config->sectionsMatch;
    }

    public function processIncludes() {
        if ($this->processIncludesHasBeenRun) {
            return;
        }

        $paths = $this->templateIncludePaths;
        $files = array();
        foreach ($this->constants as &$value) {
            $includeData = \TYPO3\CMS\Core\TypoScript\Parser\TypoScriptParser::checkIncludeLines($value, 1, TRUE, array_shift($paths));
            $files = array_merge($files, $includeData['files']);
            $value = $includeData['typoscript'];
        }
        unset($value);
        $paths = $this->templateIncludePaths;
        foreach ($this->config as &$value) {
            $includeData = \TYPO3\CMS\Core\TypoScript\Parser\TypoScriptParser::checkIncludeLines($value, 1, TRUE, array_shift($paths));
            $files = array_merge($files, $includeData['files']);
            $value = $includeData['typoscript'];
        }
        unset($value);

        if (!empty($files)) {
            $files = array_unique($files);
            foreach ($files as $file) {
                $this->rowSum[] = array($file, filemtime($file));
            }
        }

        $this->processIncludesHasBeenRun = TRUE;
    }

    public function mergeConstantsFromPageTSconfig($constArray) {
        $TSdataArray = array();
        // Setting default configuration:
        $TSdataArray[] = $GLOBALS['TYPO3_CONF_VARS']['BE']['defaultPageTSconfig'];
        for ($a = 0; $a <= $this->outermostRootlineIndexWithTemplate; $a++) {
            $TSdataArray[] = $this->absoluteRootLine[$a]['TSconfig'];
        }
        // Parsing the user TS (or getting from cache)
        $TSdataArray = \TYPO3\CMS\Core\TypoScript\Parser\TypoScriptParser::checkIncludeLines_array($TSdataArray);
        $userTS = implode(LF . '[GLOBAL]' . LF, $TSdataArray);
        $parseObj = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\TypoScript\\Parser\\TypoScriptParser');
        $parseObj->parse($userTS);
        if (is_array($parseObj->setup['TSFE.']['constants.'])) {
            \TYPO3\CMS\Core\Utility\ArrayUtility::mergeRecursiveWithOverrule($constArray, $parseObj->setup['TSFE.']['constants.']);
        }
        return $constArray;
    }

    public function flattenSetup($setupArray, $prefix, $resourceFlag) {
        if (is_array($setupArray)) {
            foreach ($setupArray as $key => $val) {
                if ($prefix || substr($key, 0, 16) != 'TSConstantEditor') {
                    // We don't want 'TSConstantEditor' in the flattend setup on the first level (190201)
                    if (is_array($val)) {
                        $this->flattenSetup($val, $prefix . $key, $key == 'file.');
                    } elseif ($resourceFlag) {
                        $this->flatSetup[$prefix . $key] = $this->getFileName($val);
                    } else {
                        $this->flatSetup[$prefix . $key] = $val;
                    }
                }
            }
        }
    }

    public function substituteConstants($all) {
        if ($this->tt_track) {
            $GLOBALS['TT']->setTSlogMessage('Constants to substitute: ' . count($this->flatSetup));
        }
        $noChange = FALSE;
        // Recursive substitution of constants (up to 10 nested levels)
        for ($i = 0; $i < 10 && !$noChange; $i++) {
            $old_all = $all;
            $all = preg_replace_callback('/\\{\\$(.[^}]*)\\}/', array($this, 'substituteConstantsCallBack'), $all);
            if ($old_all == $all) {
                $noChange = TRUE;
            }
        }
        return $all;
    }

    public function substituteConstantsCallBack($matches) {
        // Replace {$CONST} if found in $this->flatSetup, else leave unchanged
        return isset($this->flatSetup[$matches[1]]) && !is_array($this->flatSetup[$matches[1]]) ? $this->flatSetup[$matches[1]] : $matches[0];
    }

    /*******************************************************************
     *
     * Various API functions, used from elsewhere in the frontend classes
     *
     *******************************************************************/
    public function splitConfArray($conf, $splitCount) {
        // Initialize variables:
        $splitCount = (int)$splitCount;
        $conf2 = array();
        if ($splitCount && is_array($conf)) {
            // Initialize output to carry at least the keys:
            for ($aKey = 0; $aKey < $splitCount; $aKey++) {
                $conf2[$aKey] = array();
            }
            // Recursive processing of array keys:
            foreach ($conf as $cKey => $val) {
                if (is_array($val)) {
                    $tempConf = $this->splitConfArray($val, $splitCount);
                    foreach ($tempConf as $aKey => $val) {
                        $conf2[$aKey][$cKey] = $val;
                    }
                } else {
                    // Splitting of all values on this level of the TypoScript object tree:
                    if ($cKey === 'noTrimWrap' || (!strstr($val, '|*|') && !strstr($val, '||'))) {
                        for ($aKey = 0; $aKey < $splitCount; $aKey++) {
                            $conf2[$aKey][$cKey] = $val;
                        }
                    } else {
                        $main = explode('|*|', $val);
                        $mainCount = count($main);
                        $lastC = 0;
                        $middleC = 0;
                        $firstC = 0;
                        if ($main[0]) {
                            $first = explode('||', $main[0]);
                            $firstC = count($first);
                        }
                        if ($main[1]) {
                            $middle = explode('||', $main[1]);
                            $middleC = count($middle);
                        }
                        if ($main[2]) {
                            $last = explode('||', $main[2]);
                            $lastC = count($last);
                            $value = $last[0];
                        }
                        for ($aKey = 0; $aKey < $splitCount; $aKey++) {
                            if ($firstC && isset($first[$aKey])) {
                                $value = $first[$aKey];
                            } elseif ($middleC) {
                                $value = $middle[($aKey - $firstC) % $middleC];
                            }
                            if ($lastC && $lastC >= $splitCount - $aKey) {
                                $value = $last[$lastC - ($splitCount - $aKey)];
                            }
                            $conf2[$aKey][$cKey] = trim($value);
                        }
                    }
                }
            }
        }
        return $conf2;
    }

    public function getFileName($fileFromSetup) {
        $file = trim($fileFromSetup);
        if (!$file) {
            return;
        } elseif (strstr($file, '../')) {
            if ($this->tt_track) {
                $GLOBALS['TT']->setTSlogMessage('File path "' . $file . '" contained illegal string "../"!', 3);
            }
            return;
        }
        // Cache
        $hash = md5($file);
        if (isset($this->fileCache[$hash])) {
            return $this->fileCache[$hash];
        }
        if (substr($file, 0, 4) === 'EXT:') {
            $newFile = '';
            list($extKey, $script) = explode('/', substr($file, 4), 2);
            if ($extKey && \TYPO3\CMS\Core\Utility\ExtensionManagementUtility::isLoaded($extKey)) {
                $extPath = \TYPO3\CMS\Core\Utility\ExtensionManagementUtility::extPath($extKey);
                $newFile = \TYPO3\CMS\Core\Utility\PathUtility::stripPathSitePrefix($extPath) . $script;
            }
            if (!@file_exists((PATH_site . $newFile))) {
                if ($this->tt_track) {
                    $GLOBALS['TT']->setTSlogMessage('Extension media file "' . $newFile . '" was not found!', 3);
                }
                return;
            } else {
                $file = $newFile;
            }
        }
        // if this is an URL, it can be returned directly
        $urlScheme = parse_url($file, PHP_URL_SCHEME);
        if ($urlScheme === 'https' || $urlScheme === 'http' || is_file(PATH_site . $file)) {
            return $file;
        }
        // Find
        if (strpos($file, '/') !== FALSE) {
            // If the file is in the media/ folder but it doesn't exist,
            // it is assumed that it's in the tslib folder
            if (GeneralUtility::isFirstPartOfStr($file, 'media/') && !file_exists(($this->getFileName_backPath . $file))) {
                $file = \TYPO3\CMS\Core\Utility\ExtensionManagementUtility::siteRelPath('cms') . 'tslib/' . $file;
            }
            if (file_exists($this->getFileName_backPath . $file)) {
                $outFile = $file;
                $fileInfo = GeneralUtility::split_fileref($outFile);
                $OK = 0;
                foreach ($this->allowedPaths as $val) {
                    if (substr($fileInfo['path'], 0, strlen($val)) == $val) {
                        $OK = 1;
                        break;
                    }
                }
                if ($OK) {
                    $this->fileCache[$hash] = $outFile;
                    return $outFile;
                } elseif ($this->tt_track) {
                    $GLOBALS['TT']->setTSlogMessage('"' . $file . '" was not located in the allowed paths: (' . implode(',', $this->allowedPaths) . ')', 3);
                }
            } elseif ($this->tt_track) {
                $GLOBALS['TT']->setTSlogMessage('"' . $this->getFileName_backPath . $file . '" is not a file (non-uploads/.. resource, did not exist).', 3);
            }
        }
    }

    public function printTitle($pageTitle, $noTitle = FALSE, $showTitleFirst = FALSE) {
        $siteTitle = trim($this->setup['sitetitle']);
        $pageTitle = $noTitle ? '' : $pageTitle;
        $pageTitleSeparator = '';
        if ($showTitleFirst) {
            $temp = $siteTitle;
            $siteTitle = $pageTitle;
            $pageTitle = $temp;
        }
        if ($pageTitle != '' && $siteTitle != '') {
            $pageTitleSeparator = ': ';
            if (isset($this->setup['config.']['pageTitleSeparator']) && $this->setup['config.']['pageTitleSeparator']) {
                $pageTitleSeparator = $this->setup['config.']['pageTitleSeparator'];

                if (is_object($GLOBALS['TSFE']->cObj) && isset($this->setup['config.']['pageTitleSeparator.']) && is_array($this->setup['config.']['pageTitleSeparator.'])) {
                    $pageTitleSeparator = $GLOBALS['TSFE']->cObj->stdWrap($pageTitleSeparator, $this->setup['config.']['pageTitleSeparator.']);
                } else {
                    $pageTitleSeparator .= ' ';
                }
            }
        }
        return $siteTitle . $pageTitleSeparator . $pageTitle;
    }

    public function fileContent($fName) {
        $incFile = $this->getFileName($fName);
        if ($incFile) {
            return @file_get_contents($incFile);
        }
    }

    public function wrap($content, $wrap) {
        if ($wrap) {
            $wrapArr = explode('|', $wrap);
            return trim($wrapArr[0]) . $content . trim($wrapArr[1]);
        } else {
            return $content;
        }
    }

    public function removeQueryString($url) {
        if (substr($url, -1) == '?') {
            return substr($url, 0, -1);
        } else {
            return $url;
        }
    }

    static public function sortedKeyList($setupArr, $acceptOnlyProperties = FALSE) {
        $keyArr = array();
        $setupArrKeys = array_keys($setupArr);
        foreach ($setupArrKeys as $key) {
            if ($acceptOnlyProperties || \TYPO3\CMS\Core\Utility\MathUtility::canBeInterpretedAsInteger($key)) {
                $keyArr[] = (int)$key;
            }
        }
        $keyArr = array_unique($keyArr);
        sort($keyArr);
        return $keyArr;
    }

    public function getRootlineLevel($list) {
        $idx = 0;
        foreach ($this->rootLine as $page) {
            if (GeneralUtility::inList($list, $page['uid'])) {
                return $idx;
            }
            $idx++;
        }
        return FALSE;
    }

    /*******************************************************************
     *
     * Functions for creating links
     *
     *******************************************************************/
    public function linkData($page, $oTarget, $no_cache, $script, $overrideArray = NULL, $addParams = '', $typeOverride = '', $targetDomain = '') {
        $LD = array();
        // Overriding some fields in the page record and still preserves the values by adding them as parameters. Little strange function.
        if (is_array($overrideArray)) {
            foreach ($overrideArray as $theKey => $theNewVal) {
                $addParams .= '&real_' . $theKey . '=' . rawurlencode($page[$theKey]);
                $page[$theKey] = $theNewVal;
            }
        }
        // Adding Mount Points, "&MP=", parameter for the current page if any is set:
        if (!strstr($addParams, '&MP=')) {
            // Looking for hardcoded defaults:
            if (trim($GLOBALS['TSFE']->MP_defaults[$page['uid']])) {
                $addParams .= '&MP=' . rawurlencode(trim($GLOBALS['TSFE']->MP_defaults[$page['uid']]));
            } elseif ($GLOBALS['TSFE']->config['config']['MP_mapRootPoints']) {
                // Else look in automatically created map:
                $m = $this->getFromMPmap($page['uid']);
                if ($m) {
                    $addParams .= '&MP=' . rawurlencode($m);
                }
            }
        }
        // Setting ID/alias:
        if (!$script) {
            $script = $GLOBALS['TSFE']->config['mainScript'];
        }
        if ($page['alias']) {
            $LD['url'] = $script . '?id=' . rawurlencode($page['alias']);
        } else {
            $LD['url'] = $script . '?id=' . $page['uid'];
        }
        // Setting target
        $LD['target'] = trim($page['target']) ?: $oTarget;
        // typeNum
        $typeNum = $this->setup[$LD['target'] . '.']['typeNum'];
        if (!\TYPO3\CMS\Core\Utility\MathUtility::canBeInterpretedAsInteger($typeOverride) && (int)$GLOBALS['TSFE']->config['config']['forceTypeValue']) {
            $typeOverride = (int)$GLOBALS['TSFE']->config['config']['forceTypeValue'];
        }
        if ((string)$typeOverride !== '') {
            $typeNum = $typeOverride;
        }
        // Override...
        if ($typeNum) {
            $LD['type'] = '&type=' . (int)$typeNum;
        } else {
            $LD['type'] = '';
        }
        // Preserving the type number.
        $LD['orig_type'] = $LD['type'];
        // noCache
        $LD['no_cache'] = trim($page['no_cache']) || $no_cache ? '&no_cache=1' : '';
        // linkVars
        if ($GLOBALS['TSFE']->config['config']['uniqueLinkVars']) {
            if ($addParams) {
                $LD['linkVars'] = GeneralUtility::implodeArrayForUrl('', GeneralUtility::explodeUrl2Array($GLOBALS['TSFE']->linkVars . $addParams), '', FALSE, TRUE);
            } else {
                $LD['linkVars'] = $GLOBALS['TSFE']->linkVars;
            }
        } else {
            $LD['linkVars'] = $GLOBALS['TSFE']->linkVars . $addParams;
        }
        // Add absRefPrefix if exists.
        $LD['url'] = $GLOBALS['TSFE']->absRefPrefix . $LD['url'];
        // If the special key 'sectionIndex_uid' (added 'manually' in tslib/menu.php to the page-record) is set, then the link jumps directly to a section on the page.
        $LD['sectionIndex'] = $page['sectionIndex_uid'] ? '#c' . $page['sectionIndex_uid'] : '';
        // Compile the normal total url
        $LD['totalURL'] = $this->removeQueryString(($LD['url'] . $LD['type'] . $LD['no_cache'] . $LD['linkVars'] . $GLOBALS['TSFE']->getMethodUrlIdToken)) . $LD['sectionIndex'];
        // Call post processing function for link rendering:
        if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_tstemplate.php']['linkData-PostProc'])) {
            $_params = array(
                'LD' => &$LD,
                'args' => array('page' => $page, 'oTarget' => $oTarget, 'no_cache' => $no_cache, 'script' => $script, 'overrideArray' => $overrideArray, 'addParams' => $addParams, 'typeOverride' => $typeOverride, 'targetDomain' => $targetDomain),
                'typeNum' => $typeNum
            );
            foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_tstemplate.php']['linkData-PostProc'] as $_funcRef) {
                GeneralUtility::callUserFunction($_funcRef, $_params, $this);
            }
        }
        // Return the LD-array
        return $LD;
    }

    public function getFromMPmap($pageId = 0) {
        // Create map if not found already:
        if (!is_array($this->MPmap)) {
            $this->MPmap = array();
            $rootPoints = GeneralUtility::trimExplode(',', strtolower($GLOBALS['TSFE']->config['config']['MP_mapRootPoints']), TRUE);
            // Traverse rootpoints:
            foreach ($rootPoints as $p) {
                if ($p == 'root') {
                    $p = $this->rootLine[0]['uid'];
                    $initMParray = array();
                    if ($this->rootLine[0]['_MOUNT_OL'] && $this->rootLine[0]['_MP_PARAM']) {
                        $initMParray[] = $this->rootLine[0]['_MP_PARAM'];
                    }
                }
                $this->initMPmap_create($p, $initMParray);
            }
        }
        // Finding MP var for Page ID:
        if ($pageId) {
            if (is_array($this->MPmap[$pageId]) && count($this->MPmap[$pageId])) {
                return implode(',', $this->MPmap[$pageId]);
            }
        }
    }

    public function initMPmap_create($id, $MP_array = array(), $level = 0) {
        $id = (int)$id;
        if ($id <= 0) {
            return;
        }
        // First level, check id
        if (!$level) {
            // Find mount point if any:
            $mount_info = $GLOBALS['TSFE']->sys_page->getMountPointInfo($id);
            // Overlay mode:
            if (is_array($mount_info) && $mount_info['overlay']) {
                $MP_array[] = $mount_info['MPvar'];
                $id = $mount_info['mount_pid'];
            }
            // Set mapping information for this level:
            $this->MPmap[$id] = $MP_array;
            // Normal mode:
            if (is_array($mount_info) && !$mount_info['overlay']) {
                $MP_array[] = $mount_info['MPvar'];
                $id = $mount_info['mount_pid'];
            }
        }
        if ($id && $level < 20) {
            $nextLevelAcc = array();
            // Select and traverse current level pages:
            $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('uid,pid,doktype,mount_pid,mount_pid_ol', 'pages', 'pid=' . (int)$id . ' AND deleted=0 AND doktype<>' . \TYPO3\CMS\Frontend\Page\PageRepository::DOKTYPE_RECYCLER . ' AND doktype<>' . \TYPO3\CMS\Frontend\Page\PageRepository::DOKTYPE_BE_USER_SECTION);
            while ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) {
                // Find mount point if any:
                $next_id = $row['uid'];
                $next_MP_array = $MP_array;
                $mount_info = $GLOBALS['TSFE']->sys_page->getMountPointInfo($next_id, $row);
                // Overlay mode:
                if (is_array($mount_info) && $mount_info['overlay']) {
                    $next_MP_array[] = $mount_info['MPvar'];
                    $next_id = $mount_info['mount_pid'];
                }
                if (!isset($this->MPmap[$next_id])) {
                    // Set mapping information for this level:
                    $this->MPmap[$next_id] = $next_MP_array;
                    // Normal mode:
                    if (is_array($mount_info) && !$mount_info['overlay']) {
                        $next_MP_array[] = $mount_info['MPvar'];
                        $next_id = $mount_info['mount_pid'];
                    }
                    // Register recursive call
                    // (have to do it this way since ALL of the current level should be registered BEFORE the sublevel at any time)
                    $nextLevelAcc[] = array($next_id, $next_MP_array);
                }
            }
            $GLOBALS['TYPO3_DB']->sql_free_result($res);
            // Call recursively, if any:
            foreach ($nextLevelAcc as $pSet) {
                $this->initMPmap_create($pSet[0], $pSet[1], $level + 1);
            }
        }
    }

    protected function addDefaultTypoScript() {
        // Add default TS for all code types, if not done already
        if (!$this->isDefaultTypoScriptAdded) {
            // adding default setup and constants
            // defaultTypoScript_setup is *very* unlikely to be empty
            // the count of elements in ->constants, ->config and ->templateIncludePaths have to be in sync
            array_unshift($this->constants, (string)$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_constants']);
            array_unshift($this->config, (string)$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_setup']);
            array_unshift($this->templateIncludePaths, '');
            // prepare a proper entry to hierachyInfo (used by TemplateAnalyzer in BE)
            $rootTemplateId = $this->hierarchyInfo[count($this->hierarchyInfo)-1]['templateID'];
            $defaultTemplateInfo = array(
                'root' => '',
                'next' => '',
                'clConst' => '',
                'clConf' => '',
                'templateID' => '_defaultTypoScript_',
                'templateParent' => $rootTemplateId,
                'title' => 'SYS:TYPO3_CONF_VARS:FE:defaultTypoScript',
                'uid' => '_defaultTypoScript_',
                'pid' => '',
                'configLines' => substr_count((string)$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_setup'], LF) + 1
            );
            // push info to information arrays used in BE by TemplateTools (Analyzer)
            array_unshift($this->clearList_const, $defaultTemplateInfo['uid']);
            array_unshift($this->clearList_setup, $defaultTemplateInfo['uid']);
            array_unshift($this->hierarchyInfo, $defaultTemplateInfo);
            $this->isDefaultTypoScriptAdded = TRUE;
        }
    }

}